X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=afs.c;h=ccda7cdaaa4e211b696d4e898f08c7c2520ab3ef;hp=bc42026e460ac7ba5f38f992ae17e1f18a3c5ce9;hb=745667ae4887ebe0e25a4b9085556ac6ed56b246;hpb=63b57e3e60923cea4e3e1808e3133789db2dc83a diff --git a/afs.c b/afs.c index bc42026e..ccda7cda 100644 --- a/afs.c +++ b/afs.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007-2008 Andre Noll + * Copyright (C) 2007-2009 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -54,13 +54,13 @@ enum afs_table_num { }; static struct afs_table afs_tables[NUM_AFS_TABLES] = { - [TBLNUM_AUDIO_FILES] = {.init = aft_init}, - [TBLNUM_ATTRIBUTES] = {.init = attribute_init}, - [TBLNUM_SCORES] = {.init = score_init}, - [TBLNUM_MOODS] = {.init = moods_init}, - [TBLNUM_LYRICS] = {.init = lyrics_init}, - [TBLNUM_IMAGES] = {.init = images_init}, - [TBLNUM_PLAYLIST] = {.init = playlists_init}, + [TBLNUM_AUDIO_FILES] = {.init = aft_init, .name = "audio_files"}, + [TBLNUM_ATTRIBUTES] = {.init = attribute_init, .name = "attributes"}, + [TBLNUM_SCORES] = {.init = score_init, .name = "scores"}, + [TBLNUM_MOODS] = {.init = moods_init, .name = "moods"}, + [TBLNUM_LYRICS] = {.init = lyrics_init, .name = "lyrics"}, + [TBLNUM_IMAGES] = {.init = images_init, .name = "images"}, + [TBLNUM_PLAYLIST] = {.init = playlists_init, .name = "playlists"}, }; struct command_task { @@ -75,6 +75,7 @@ struct command_task { struct task task; }; +extern int mmd_mutex; extern struct misc_meta_data *mmd; static int server_socket; @@ -140,6 +141,36 @@ struct callback_result { size_t result_size; }; +static int dispatch_result(int result_shmid, callback_result_handler *handler, + void *private_result_data) +{ + struct osl_object result; + void *result_shm; + int ret2, ret = shm_attach(result_shmid, ATTACH_RO, &result_shm); + struct callback_result *cr = result_shm; + + if (ret < 0) { + PARA_ERROR_LOG("attach failed: %s\n", para_strerror(-ret)); + return ret; + } + result.size = cr->result_size; + result.data = result_shm + sizeof(*cr); + if (result.size) { + assert(handler); + ret = handler(&result, private_result_data); + if (ret < 0) + PARA_NOTICE_LOG("result handler error: %s\n", + para_strerror(-ret)); + } + ret2 = shm_detach(result_shm); + if (ret2 < 0) { + PARA_ERROR_LOG("detach failed: %s\n", para_strerror(-ret2)); + if (ret >= 0) + ret = ret2; + } + return ret; +} + /** * Ask the afs process to call a given function. * @@ -160,8 +191,7 @@ struct callback_result { * shmid are passed to that function as an osl object. The private_result_data * pointer is passed as the second argument to \a result_handler. * - * \return Negative, on errors, the return value of the callback function - * otherwise. + * \return Standard. * * \sa send_option_arg_callback_request(), send_standard_callback_request(). */ @@ -170,10 +200,11 @@ int send_callback_request(callback_function *f, struct osl_object *query, void *private_result_data) { struct callback_query *cq; - int num_results = 0, ret, fd = -1, query_shmid, result_shmid; - void *query_shm, *result_shm; + int ret, fd = -1, query_shmid, result_shmid; + void *query_shm; char buf[sizeof(afs_socket_cookie) + sizeof(int)]; size_t query_shm_size = sizeof(*cq); + int dispatch_error = 0; if (query) query_shm_size += query->size; @@ -204,45 +235,37 @@ int send_callback_request(callback_function *f, struct osl_object *query, ret = send_bin_buffer(fd, buf, sizeof(buf)); if (ret < 0) goto out; + /* + * Read all shmids from afs. + * + * Even if the dispatcher returns an error we _must_ continue to read + * shmids from fd so that we can destroy all shared memory areas that + * have been created for us by the afs process. + */ for (;;) { ret = recv_bin_buffer(fd, buf, sizeof(int)); if (ret <= 0) goto out; - if (ret != sizeof(int)) { - ret = -E_AFS_SHORT_READ; - goto out; - } + assert(ret == sizeof(int)); ret = *(int *) buf; - if (ret <= 0) - goto out; + assert(ret > 0); result_shmid = ret; - ret = shm_attach(result_shmid, ATTACH_RO, &result_shm); - if (ret >= 0) { - struct callback_result *cr = result_shm; - struct osl_object result; - num_results++; - result.size = cr->result_size; - result.data = result_shm + sizeof(*cr); - if (result.size) { - assert(result_handler); - ret = result_handler(&result, private_result_data); - if (shm_detach(result_shm) < 0) - PARA_ERROR_LOG("can not detach result\n"); - } - } else - PARA_ERROR_LOG("attach result failed: %d\n", ret); - if (shm_destroy(result_shmid) < 0) - PARA_ERROR_LOG("destroy result failed\n"); + if (!dispatch_error) { + ret = dispatch_result(result_shmid, result_handler, + private_result_data); + if (ret < 0) + dispatch_error = 1; + } + ret = shm_destroy(result_shmid); if (ret < 0) - break; + PARA_CRIT_LOG("destroy result failed: %s\n", + para_strerror(-ret)); } out: if (shm_destroy(query_shmid) < 0) - PARA_ERROR_LOG("%s\n", "shm destroy error"); + PARA_CRIT_LOG("shm destroy error\n"); if (fd >= 0) close(fd); - if (ret >= 0) - ret = num_results; // PARA_DEBUG_LOG("callback_ret: %d\n", ret); return ret; } @@ -571,15 +594,15 @@ static int activate_mood_or_playlist(char *arg, int *num_admissible) free(current_mop); if (arg) { current_mop = para_strdup(arg); - mmd_lock(); + mutex_lock(mmd_mutex); strncpy(mmd->afs_mode_string, arg, sizeof(mmd->afs_mode_string)); mmd->afs_mode_string[sizeof(mmd->afs_mode_string) - 1] = '\0'; - mmd_unlock(); + mutex_unlock(mmd_mutex); } else { - mmd_lock(); + mutex_lock(mmd_mutex); strcpy(mmd->afs_mode_string, "dummy"); - mmd_unlock(); + mutex_unlock(mmd_mutex); current_mop = NULL; } } @@ -753,7 +776,7 @@ static void signal_pre_select(struct sched *s, struct task *t) para_fd_set(st->fd, &s->rfds, &s->max_fileno); } -static void signal_post_select(struct sched *s, struct task *t) +static void afs_signal_post_select(struct sched *s, struct task *t) { struct signal_task *st = container_of(t, struct signal_task, task); if (getppid() == 1) { @@ -765,6 +788,7 @@ static void signal_post_select(struct sched *s, struct task *t) st->signum = para_next_signal(); if (st->signum == SIGHUP) { close_afs_tables(); + parse_config_or_die(1); t->error = open_afs_tables(); if (t->error < 0) return; @@ -781,14 +805,7 @@ static void register_signal_task(void) { struct signal_task *st = &signal_task_struct; - if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { - PARA_EMERG_LOG("failed to ignore SIGPIPE\n"); - exit(EXIT_FAILURE); - } - if (signal(SIGUSR1, SIG_IGN) == SIG_ERR) { - PARA_EMERG_LOG("failed to ignore SIGUSR1\n"); - exit(EXIT_FAILURE); - } + para_sigaction(SIGPIPE, SIG_IGN); st->fd = para_signal_init(); PARA_INFO_LOG("signal pipe: fd %d\n", st->fd); para_install_sighandler(SIGINT); @@ -796,7 +813,7 @@ static void register_signal_task(void) para_install_sighandler(SIGHUP); st->task.pre_select = signal_pre_select; - st->task.post_select = signal_post_select; + st->task.post_select = afs_signal_post_select; sprintf(st->task.status, "signal task"); register_task(&st->task); } @@ -891,7 +908,7 @@ static int call_callback(int fd, int query_shmid) query.data = (char *)query_shm + sizeof(*cq); query.size = cq->query_size; cq->handler(fd, &query); - return 1; + return shm_detach(query_shm); } static int execute_server_command(void) @@ -1022,7 +1039,7 @@ static void register_command_task(uint32_t cookie) */ __noreturn void afs_init(uint32_t cookie, int socket_fd) { - struct sched s; + static struct sched s; int i, ret; register_signal_task(); @@ -1055,7 +1072,7 @@ static void create_tables_callback(int fd, const struct osl_object *query) { uint32_t table_mask = *(uint32_t *)query->data; int i, ret; - char *buf; + struct para_buffer pb = {.buf = NULL}; close_afs_tables(); for (i = 0; i < NUM_AFS_TABLES; i++) { @@ -1068,15 +1085,15 @@ static void create_tables_callback(int fd, const struct osl_object *query) ret = t->create(database_dir); if (ret < 0) goto out; + para_printf(&pb, "successfully created %s table\n", t->name); } ret = open_afs_tables(); out: - if (ret >= 0) - buf = make_message("successfully created afs table(s)\n"); - else - buf = make_message("%s\n", para_strerror(-ret)); - pass_buffer_as_shm(buf, strlen(buf), &fd); - free(buf); + if (ret < 0) + para_printf(&pb, "%s\n", para_strerror(-ret)); + if (pb.buf) + pass_buffer_as_shm(pb.buf, pb.offset, &fd); + free(pb.buf); } int com_init(int fd, int argc, char * const * const argv) @@ -1104,7 +1121,7 @@ int com_init(int fd, int argc, char * const * const argv) return -E_BAD_TABLE_NAME; } } - ret = send_callback_request(create_tables_callback, &query, NULL, NULL); + ret = send_callback_request(create_tables_callback, &query, &send_result, &fd); if (ret < 0) return send_va_buffer(fd, "%s\n", para_strerror(-ret)); return ret; @@ -1173,6 +1190,16 @@ int com_check(int fd, int argc, char * const * const argv) return 1; } +/** + * The afs event dispatcher. + * + * \param event Type of the event. + * \param pb May be \p NULL. + * \param data Type depends on \a event. + * + * This function calls the table handlers of all tables and passes \a pb and \a + * data verbatim. It's up to the handlers to interpret the \a data pointer. + */ void afs_event(enum afs_events event, struct para_buffer *pb, void *data) { @@ -1184,7 +1211,8 @@ void afs_event(enum afs_events event, struct para_buffer *pb, continue; ret = t->event_handler(event, pb, data); if (ret < 0) - PARA_CRIT_LOG("%s\n", para_strerror(-ret)); + PARA_CRIT_LOG("table %s, event %d: %s\n", t->name, + event, para_strerror(-ret)); } }