+/*
+ * 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"
return btr_pool_available(btrp);
}
+/**
+ * Get references to buffers pointing to free space of the buffer pool area.
+ *
+ * \param btrp The buffer pool.
+ * \param iov The scatter array.
+ *
+ * \return Zero if the buffer pool is full, one if the free space of the buffer
+ * pool area is available as a single contiguous buffer, two if the free space
+ * consists of two buffers. If this function returns the value n, then n
+ * elements of \a iov are initialized.
+ */
+int btr_pool_get_buffers(struct btr_pool *btrp, struct iovec iov[2])
+{
+ size_t sz, unused;
+ char *buf;
+
+ sz = btr_pool_get_buffer(btrp, &buf);
+ if (sz == 0)
+ return 0;
+ iov[0].iov_len = sz;
+ iov[0].iov_base = buf;
+ unused = btr_pool_unused(btrp);
+ if (sz == unused)
+ return 1;
+ iov[1].iov_len = unused - sz;
+ iov[1].iov_base = btrp->area_start;
+ return 2;
+}
+
/**
* Mark a part of the buffer pool area as allocated.
*
*
* \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().
}
/**
- * 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 omit Number of bytes to be omitted.
* \param bufp Result pointer.
*
- * \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)
+/**
+ * Clear the input queue of a buffer tree node.
+ *
+ * \param btrn The node whose input queue should be cleared.
+ */
+void btr_drain(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().
*
+ * \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)
PARA_NOTICE_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);
}
assert(list_empty(&btrn->children));
}
-/*
- * Return the size of the largest input queue.
+/**
+ * Return number of queued output bytes of a buffer tree node.
*
- * Iterates over all children of the given node.
+ * \param btrn The node whose output queue size should be computed.
+ *
+ * \return This function iterates over all children of the given node and
+ * returns the size of the largest input queue.
*/
-static size_t btr_bytes_pending(struct btr_node *btrn)
+size_t btr_get_output_queue_size(struct btr_node *btrn)
{
size_t max_size = 0;
struct btr_node *ch;
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.
*
/**
* 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.
if (type != BTR_NT_LEAF) {
if (btr_no_children(btrn))
return -E_BTR_NO_CHILD;
- if (btr_bytes_pending(btrn) > BTRN_MAX_PENDING)
+ if (btr_get_output_queue_size(btrn) > BTRN_MAX_PENDING)
return 0;
}
if (type != BTR_NT_ROOT) {
projects / paraslash.git / blobdiff