/*
- * Copyright (C) 2009-2011 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2009-2013 Andre Noll <maan@systemlinux.org>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
int refcount;
/* NULL means no buffer pool but a malloced buffer. */
struct btr_pool *pool;
+ /* Only relevant if pool is NULL. */
+ bool dont_free;
};
struct btr_buffer_reference {
bnd->child->parent = btrn;
goto out;
}
- PARA_EMERG_LOG("inserting internal nodes not yet supported.\n");
- exit(EXIT_FAILURE);
- assert(bnd->child->parent == bnd->parent);
+ list_add_tail(&btrn->node, &bnd->parent->children);
+ list_move(&bnd->child->node, &btrn->children);
+ bnd->child->parent = btrn;
+ PARA_INFO_LOG("added %s as internal node\n", bnd->name);
out:
return btrn;
}
{
if (btrb->pool)
btr_pool_deallocate(btrb->pool, btrb->size);
- else
+ else if (!btrb->dont_free)
free(btrb->buf);
}
{
struct btr_buffer *btrb;
- assert(size != 0);
+ if (size == 0)
+ return;
if (list_empty(&btrn->children)) {
free(buf);
return;
add_btrb_to_children(btrb, btrn, 0);
}
+/**
+ * Insert a buffer into the buffer tree, non-freeing variant.
+ *
+ * \param buf See \ref btr_add_output().
+ * \param size See \ref btr_add_output().
+ * \param btrn See \ref btr_add_output().
+ *
+ * This is similar to btr_add_output() but additionally sets the \p dont_free
+ * flag on \a buf. If the refcount for the buffer drops to zero, \a buf will
+ * not be deallocated if this flag is set.
+ *
+ * The \p dont_free bit also prevents the children of \a btrn from modifying
+ * the buffer contents inplace. Specifically, \ref btr_inplace_ok() returns
+ * false if there is any buffer in the input queue with the \p dont_free bit
+ * set.
+ */
+void btr_add_output_dont_free(const char *buf, size_t size, struct btr_node *btrn)
+{
+ struct btr_buffer *btrb;
+
+ if (size == 0)
+ return;
+ if (list_empty(&btrn->children))
+ return;
+ btrb = new_btrb((char *)buf, size);
+ btrb->dont_free = true;
+ add_btrb_to_children(btrb, btrn, 0);
+}
+
/**
* Feed data to child nodes of a buffer tree node.
*
char *buf;
size_t avail;
- assert(size != 0);
+ if (size == 0)
+ return;
if (list_empty(&btrn->children))
return;
avail = btr_pool_get_buffer(btrp, &buf);
*/
bool btr_inplace_ok(struct btr_node *btrn)
{
- if (!btrn->parent)
- return true;
- return list_is_singular(&btrn->parent->children);
+ struct btr_buffer_reference *br;
+ FOR_EACH_BUFFER_REF(br, btrn) {
+ struct btr_buffer *btrb = br->btrb;
+ if (btrb->refcount > 1)
+ return false;
+ if (btrb->dont_free == true)
+ return false;
+ }
+ return true;
}
static inline size_t br_available_bytes(struct btr_buffer_reference *br)
*
* \param btrn The node whose input queue is to be queried.
* \param omit Number of bytes to be omitted.
- * \param bufp Result pointer.
+ * \param bufp Result pointer. It is OK to pass \p NULL here.
*
* If a buffer tree node needs more input data but can not consume the data it
* already has (because it might be needed again later) this function can be
btr_drop_buffer_reference(br);
}
-/**
- * Free all resources allocated by btr_new_node().
- *
- * \param btrn Pointer to a btr node obtained by \ref btr_new_node().
- *
- * Like free(3), it is OK to call this with a \p NULL pointer argument.
- */
-void btr_free_node(struct btr_node *btrn)
-{
- if (!btrn)
- return;
- free(btrn->name);
- free(btrn);
-}
-
/**
* Remove a node from a buffer tree.
*
- * \param btrn The node to remove.
+ * \param btrnp Determines the node to remove.
*
- * This makes all child nodes of \a btrn orphans and removes \a btrn from the
- * list of children of its parent. Moreover, the input queue of \a btrn is
- * flushed if it is not empty.
+ * This orphans all children of the node given by \a btrnp and removes this
+ * node from the child list of its parent. Moreover, the input queue is flushed
+ * and the node pointer given by \a btrp is set to \p NULL.
*
* \sa \ref btr_splice_out_node.
*/
-void btr_remove_node(struct btr_node *btrn)
+void btr_remove_node(struct btr_node **btrnp)
{
struct btr_node *ch;
+ struct btr_node *btrn;
- if (!btrn)
+ if (!btrnp)
return;
- PARA_NOTICE_LOG("removing btr node %s from buffer tree\n", btrn->name);
+ btrn = *btrnp;
+ if (!btrn)
+ goto out;
+ PARA_INFO_LOG("removing btr node %s from buffer tree\n", btrn->name);
FOR_EACH_CHILD(ch, btrn)
ch->parent = NULL;
btr_drain(btrn);
if (btrn->parent)
list_del(&btrn->node);
+ free(btrn->name);
+ free(btrn);
+out:
+ *btrnp = NULL;
}
/**
list_move(&ch->node, &btrn->parent->children);
}
assert(list_empty(&btrn->children));
+ btrn->parent = NULL;
}
/**
}
/**
- * Execute a inter-node command on a parent node.
+ * Execute an inter-node command on the given node or on a parent node.
*
* \param btrn The node to start looking.
* \param command The command to execute.
* \param value_result Additional arguments and result value.
*
- * This function traverses the buffer tree upwards and looks for parent nodes
- * of \a btrn that understands \a command. On the first such node the command
- * is executed, and the result is stored in \a value_result.
+ * This function traverses the buffer tree from \a btrn upwards and looks for
+ * the first node that understands \a command. On this node \a command is
+ * executed, and the result is stored in \a value_result.
*
* \return \p -ENOTSUP if no parent node of \a btrn understands \a command.
* Otherwise the return value of the command handler is returned.
+ *
+ * \sa \ref receiver::execute, filter::execute, writer::execute.
*/
int btr_exec_up(struct btr_node *btrn, const char *command, char **value_result)
{
int ret;
for (; btrn; btrn = btrn->parent) {
- struct btr_node *parent = btrn->parent;
- if (!parent)
- return -ERRNO_TO_PARA_ERROR(ENOTSUP);
- if (!parent->execute)
+ if (!btrn->execute)
continue;
- PARA_INFO_LOG("parent: %s, cmd: %s\n", parent->name, command);
- ret = parent->execute(parent, command, value_result);
+ PARA_INFO_LOG("executing %s on %s\n", command, btrn->name);
+ ret = btrn->execute(btrn, command, value_result);
if (ret == -ERRNO_TO_PARA_ERROR(ENOTSUP))
continue;
if (ret < 0)
return ret;
if (value_result && *value_result)
- PARA_NOTICE_LOG("%s(%s): %s\n", command, parent->name,
+ PARA_INFO_LOG("%s(%s): %s\n", command, btrn->name,
*value_result);
return 1;
}
{
*tv = btrn->start;
}
+
+struct btr_node *btr_parent(struct btr_node *btrn)
+{
+ return btrn->parent;
+}
projects / paraslash.git / blobdiff