+/*
+ * Copyright (C) 2009-2012 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+/** \file buffer_tree.c Buffer tree and buffer pool implementations. */
#include <regex.h>
-#include <stdbool.h>
#include "para.h"
#include "list.h"
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 {
*
* \param bnd Specifies how to create the new node.
*
+ * \return A pointer to the newly allocated node.
+ *
* This function always succeeds (or calls exit()). The returned pointer must
* be freed using btr_free_node() after the node has been removed from the
* buffer tree via btr_remove_node().
{
if (btrb->pool)
btr_pool_deallocate(btrb->pool, btrb->size);
- else
+ else if (!btrb->dont_free)
free(btrb->buf);
}
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;
+
+ assert(size != 0);
+ 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.
*
*/
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)
}
/**
- * Obtain the next buffer of the input queue of a buffer tree node.
+ * Obtain the next buffer of the input queue, omitting data.
*
* \param btrn The node whose input queue is to be queried.
- * \param bufp Result pointer.
+ * \param omit Number of bytes to be omitted.
+ * \param bufp Result pointer. It is OK to pass \p NULL here.
*
- * \return The number of bytes that can be read from buf. Zero if the input
- * buffer queue is empty. In this case the value of \a bufp is undefined.
+ * 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
+ * used instead of btr_next_buffer() to get a reference to the buffer obtained
+ * by skipping the given number of bytes. Skipped input bytes are not consumed.
+ *
+ * With a zero \a omit argument, this function is equivalent to \ref
+ * btr_next_buffer().
+ *
+ * \return Number of bytes in \a bufp. If there are less than or equal to \a
+ * omit many bytes available in the input queue of the buffer tree node pointed
+ * to by \a btrn, the function returns zero and the value of \a bufp is
+ * undefined.
*/
-size_t btr_next_buffer(struct btr_node *btrn, char **bufp)
+size_t btr_next_buffer_omit(struct btr_node *btrn, size_t omit, char **bufp)
{
struct btr_buffer_reference *br;
+ size_t wrap_count, sz, rv = 0;
char *buf, *result = NULL;
- size_t sz, rv = 0;
- FOR_EACH_BUFFER_REF(br, btrn) {
+ br = get_first_input_br(btrn);
+ if (!br)
+ return 0;
+ wrap_count = br->wrap_count;
+ if (wrap_count > 0) { /* we have a wrap buffer */
sz = btr_get_buffer_by_reference(br, &buf);
- if (!result) {
- result = buf;
- rv = sz;
- if (!br->btrb->pool)
- break;
- continue;
+ if (sz > omit) { /* and it's big enough */
+ result = buf + omit;
+ rv = sz - omit;
+ /*
+ * Wrap buffers are allocated by malloc(), so the next
+ * buffer ref will not align nicely, so we return the
+ * tail of the wrap buffer.
+ */
+ goto out;
}
- if (!br->btrb->pool)
- break;
- if (result + rv != buf)
- break;
- rv += sz;
+ /*
+ * The next wrap_count bytes exist twice, in the wrap buffer
+ * and as a buffer reference in the buffer tree pool.
+ */
+ omit += wrap_count;
+ }
+ /*
+ * For buffer tree pools, the buffers in the list align, i.e. the next
+ * buffer in the list starts directly at the end of its predecessor. In
+ * this case we merge adjacent buffers and return one larger buffer
+ * instead.
+ */
+ FOR_EACH_BUFFER_REF(br, btrn) {
+ sz = btr_get_buffer_by_reference(br, &buf);
+ if (result) {
+ if (result + rv != buf)
+ goto out;
+ rv += sz;
+ } else if (sz > omit) {
+ result = buf + omit;
+ rv = sz - omit;
+ } else
+ omit -= sz;
}
+ if (!result)
+ return 0;
+out:
if (bufp)
*bufp = result;
return rv;
}
+/**
+ * Obtain the next buffer of the input queue of a buffer tree node.
+ *
+ * \param btrn The node whose input queue is to be queried.
+ * \param bufp Result pointer.
+ *
+ * \return The number of bytes that can be read from buf.
+ *
+ * The call of this function is is equivalent to calling \ref
+ * btr_next_buffer_omit() with an \a omit value of zero.
+ */
+size_t btr_next_buffer(struct btr_node *btrn, char **bufp)
+{
+ return btr_next_buffer_omit(btrn, 0, bufp);
+}
+
/**
* Deallocate the given number of bytes from the input queue.
*
*
* This function must be used to get rid of existing buffer references in the
* node's input queue. If no references to a buffer remain, the underlying
- * buffers are either freed (in the non-buffer tree case) or the read head of
+ * buffers are either freed (in the non-buffer pool case) or the read head of
* the buffer pool is being advanced.
*
* Note that \a numbytes may be smaller than the buffer size. In this case the
numbytes -= br->btrb->size - br->consumed;
btr_drop_buffer_reference(br);
}
- assert(true);
+ assert(false);
}
/*
* We have a wrap buffer, consume from it. If in total, i.e. including
return btr_consume(btrn, sz);
}
-static void flush_input_queue(struct btr_node *btrn)
-{
- struct btr_buffer_reference *br, *tmp;
- FOR_EACH_BUFFER_REF_SAFE(br, tmp, btrn)
- btr_drop_buffer_reference(br);
-}
-
/**
- * Free all resources allocated by btr_new_node().
+ * Clear the input queue of a buffer tree node.
*
- * Like free(3), it is OK to call this with a \p NULL pointer argument.
+ * \param btrn The node whose input queue should be cleared.
*/
-void btr_free_node(struct btr_node *btrn)
+void btr_drain(struct btr_node *btrn)
{
- if (!btrn)
- return;
- free(btrn->name);
- free(btrn);
+ struct btr_buffer_reference *br, *tmp;
+
+ FOR_EACH_BUFFER_REF_SAFE(br, tmp, btrn)
+ btr_drop_buffer_reference(br);
}
/**
* 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;
- flush_input_queue(btrn);
+ 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;
}
/**
*
* \param btrn The node whose output queue size should be computed.
*
- * This function iterates over all children of the given node and returns the
- * size of the largest input queue.
+ * \return This function iterates over all children of the given node and
+ * returns the size of the largest input queue.
*/
size_t btr_get_output_queue_size(struct btr_node *btrn)
{
return max_size;
}
-int btr_exec(struct btr_node *btrn, const char *command, char **value_result)
-{
- if (!btrn)
- return -ERRNO_TO_PARA_ERROR(EINVAL);
- if (!btrn->execute)
- return -ERRNO_TO_PARA_ERROR(ENOTSUP);
- return btrn->execute(btrn, command, value_result);
-}
-
/**
- * 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;
}
/**
* Obtain the context of a buffer node tree.
*
- * The returned pointer equals the context pointer used at creation time of the
- * node.
+ * \param btrn The node whose output queue size should be computed.
+ *
+ * \return A pointer to the \a context address specified at node creation time.
*
* \sa btr_new_node(), struct \ref btr_node_description.
*/
struct btr_buffer_reference *br, *wbr = NULL;
int num_refs; /* including wrap buffer */
char *buf, *buf1 = NULL, *buf2 = NULL;
- size_t sz, sz1 = 0, sz2 = 0, wsz;
+ size_t sz, sz1 = 0, sz2 = 0, wb_consumed = 0;
br = get_first_input_br(btrn);
if (!br || br_available_bytes(br) >= dest_size)
wbr = br;
if (sz >= dest_size)
return;
+ wb_consumed = br->consumed;
continue;
}
if (!buf1) {
assert(buf2 + sz2 == buf);
sz2 += sz;
next:
- if (sz1 + sz2 >= dest_size)
+ if (sz1 + sz2 >= dest_size + wb_consumed)
break;
}
if (!buf2) /* nothing to do */
* We already have a wrap buffer, but it is too small. It might be
* partially used.
*/
- wsz = br_available_bytes(wbr);
if (wbr->wrap_count == sz1 && wbr->btrb->size >= sz1 + sz2) /* nothing we can do about it */
return;
sz = sz1 + sz2 - wbr->btrb->size; /* amount of new data */
}
/** 640K ought to be enough for everybody ;) */
-#define BTRN_MAX_PENDING (640 * 1024)
+#define BTRN_MAX_PENDING (96 * 1024)
/**
* Return the current state of a buffer tree node.
{
*tv = btrn->start;
}
+
+struct btr_node *btr_parent(struct btr_node *btrn)
+{
+ return btrn->parent;
+}
projects / paraslash.git / blobdiff