X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=write_common.c;h=ac92bc1a1740d1eeefa50551d03744a6018fce41;hp=7fb8d12337b6fdc28a1af741e5a0cd6a74f21ea4;hb=9f487d2aaaa3462d9e4ecd76f22a75c9ae847e92;hpb=4b6458e9fc11eb741200dfebd8dc96a333956e4b diff --git a/write_common.c b/write_common.c index 7fb8d123..ac92bc1a 100644 --- a/write_common.c +++ b/write_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006 Andre Noll + * Copyright (C) 2006-2007 Andre Noll * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -25,10 +25,28 @@ #include "write.h" #include "error.h" +/** the array containing the names of all supported writers */ const char *writer_names[] ={WRITER_NAMES}; + +/** the array of supported writers */ struct writer writers[NUM_SUPPORTED_WRITERS] = {WRITER_ARRAY}; -static void wng_post_select(__a_unused struct sched *s, struct task *t) +static void wng_pre_select(__a_unused struct sched *s, struct task *t) +{ + struct writer_node_group *g = t->private_data; + int i; + + FOR_EACH_WRITER_NODE(i, g) { + struct writer_node *wn = &g->writer_nodes[i]; + t->ret = wn->writer->pre_select(s, wn); + if (t->ret < 0) { + g->eof = 1; + return; + } + } +} + +static void wng_post_select(struct sched *s, struct task *t) { struct writer_node_group *g = t->private_data; int i; @@ -36,82 +54,129 @@ static void wng_post_select(__a_unused struct sched *s, struct task *t) FOR_EACH_WRITER_NODE(i, g) { struct writer_node *wn = &g->writer_nodes[i]; - t->ret = wn->task.ret; - if (t->ret < 0) + t->ret = wn->writer->post_select(s, wn); + if (t->ret < 0) { + g->eof = 1; return; + } if (!i) - min_written = t->ret; + min_written = wn->written; else - min_written = PARA_MIN(min_written, t->ret); + min_written = PARA_MIN(min_written, wn->written); + } +// PARA_INFO_LOG("loaded: %zd, min_written: %zd bytes\n", *g->loaded, min_written); + if (min_written) { + *g->loaded -= min_written; + FOR_EACH_WRITER_NODE(i, g) + g->writer_nodes[i].written -= min_written; } - *g->loaded -= min_written; - if (!*g->loaded && *g->input_eof) + if (!*g->loaded && *g->input_eof) { + g->eof = 1; t->ret = -E_WNG_EOF; - else - t->ret = 1; - if (*g->loaded && min_written) + return; + } + t->ret = 1; + if (*g->loaded && min_written) { +// PARA_INFO_LOG("moving %zd bytes\n", *g->loaded); memmove(g->buf, g->buf + min_written, *g->loaded); + } } +/** + * call the open function of each writer in the group + * + * \param g the writer node group + * + * \return If at least one open function returned an error, all successful + * writer notes get closed and this error value is returned. Upon success, a + * task associated with \a g is registered to the scheduler and the function + * returnes a positive value. + * */ int wng_open(struct writer_node_group *g) { int i, ret = 1; + PARA_NOTICE_LOG("opening wng %p with %d writer(s)\n", g, g->num_writers); + register_task(&g->task); FOR_EACH_WRITER_NODE(i, g) { struct writer_node *wn = &g->writer_nodes[i]; + wn->wng = g; ret = wn->writer->open(wn); if (ret < 0) - goto out; + goto err_out; wn->chunk_bytes = ret; g->max_chunk_bytes = PARA_MAX(g->max_chunk_bytes, ret); - wn->wng = g; - PARA_DEBUG_LOG("pre_select: %p\n", &wn->writer->pre_select); - PARA_DEBUG_LOG("post_select: %p\n", &wn->writer->post_select); - wn->task.pre_select = wn->writer->pre_select; - wn->task.post_select = wn->writer->post_select; - wn->task.private_data = wn; - register_task(&wn->task); } sprintf(g->task.status, "%s", "writer node group"); g->eof = 0; - register_task(&g->task); -out: + return 1; +err_out: + unregister_task(&g->task); + while (i > 0) { + struct writer_node *wn = &g->writer_nodes[--i]; + wn->writer->close(wn); + } + g->num_writers = 0; + g->eof = 1; return ret; } -void wng_destroy(struct writer_node_group *g) + +/** + * unregister a writer node group task + * + * \param g the group whose task is to be closed + */ +void wng_unregister(struct writer_node_group *g) { - if (!g) - return; - free(g->written); - free(g->writer_nodes); - free(g); + unregister_task(&g->task); + g->eof = 1; } +/** + * call the close function of each writer in the given group + * + * \param g the writer node group to close + * + * This function also frees all resources of the given group. + */ void wng_close(struct writer_node_group *g) { int i; + if (!g) + return; + PARA_NOTICE_LOG("closing wng with %d writer(s)\n", g->num_writers); FOR_EACH_WRITER_NODE(i, g) { struct writer_node *wn = &g->writer_nodes[i]; - unregister_task(&wn->task); wn->writer->close(wn); } + free(g->writer_nodes); + free(g); } +/** + * allocate and initialize a new writer_node_group struct + * + * \param num_writers the number of writer nodes for the new group + * + * \return Pointer to the new writer node group + */ struct writer_node_group *wng_new(unsigned num_writers) { struct writer_node_group *g = para_calloc(sizeof(struct writer_node_group)); g->num_writers = num_writers; g->writer_nodes = para_calloc(num_writers * sizeof(struct writer_node)); - g->written = para_calloc(num_writers * sizeof(size_t)); g->task.private_data = g; g->task.post_select = wng_post_select; - g->task.flags = POST_ADD_TAIL; + g->task.pre_select = wng_pre_select; return g; } +/** + * call the init function of each supported paraslash writer + */ void init_supported_writers(void) { int i; @@ -119,8 +184,22 @@ void init_supported_writers(void) FOR_EACH_WRITER(i) writers[i].init(&writers[i]); } - -void *check_writer_arg(char *wa, int *writer_num) +/** + * check if given string is a valid command line for any writer + * + * \param \wa string of the form writer_name:options + * \param writer_num contains the number of the writer upon success + * + * This function checks whether \a wa starts with the name of a supported + * paraslash writer, optinally followed by a colon and any options for that + * writer. If a valid writer name was found and further are present, the + * remaining part of \a wa is passed to that writer's config parser. + * + * \return On success, a pointer to the gengetopt args info struct is returned + * and \a writer_num contains the number of the writer. Otherwise this function + * returns \p NULL. + */ +void *check_writer_arg(const char *wa, int *writer_num) { int i; @@ -146,6 +225,14 @@ void *check_writer_arg(char *wa, int *writer_num) return NULL; } +/** + * setup a writer node group with only one writer, the default writer + * + * The writer which is set up depends on the OS. It defaults to alsa for Linux, + * osx_write for OS X, file writer if neither of these is supported. + * + * \return pointer to the allocated writer node group + */ struct writer_node_group *setup_default_wng(void) { struct writer_node_group *wng = wng_new(1); @@ -156,8 +243,6 @@ struct writer_node_group *setup_default_wng(void) else default_writer = 1; wng->writer_nodes[0].writer = &writers[default_writer]; - sprintf(wng->writer_nodes[0].task.status, "%s", - writer_names[default_writer]); PARA_INFO_LOG("using default writer: %s %p\n", writer_names[default_writer], writers[default_writer].parse_config); wng->writer_nodes[0].conf = writers[default_writer].parse_config("");