qio: add a few block helpers
[akaros.git] / kern / src / ns / qio.c
index e7e5d01..16caad3 100644 (file)
@@ -100,7 +100,6 @@ enum {
 
 unsigned int qiomaxatomic = Maxatomic;
 
-static size_t copy_to_block_body(struct block *to, void *from, size_t copy_amt);
 static ssize_t __qbwrite(struct queue *q, struct block *b, int flags);
 static struct block *__qbread(struct queue *q, size_t len, int qio_flags,
                               int mem_flags);
@@ -245,13 +244,13 @@ struct block *copyblock(struct block *bp, int mem_flags)
        newb = block_alloc(BLEN(bp), mem_flags);
        if (!newb)
                return 0;
-       amt = copy_to_block_body(newb, bp->rp, BHLEN(bp));
+       amt = block_copy_to_body(newb, bp->rp, BHLEN(bp));
        assert(amt == BHLEN(bp));
        for (int i = 0; i < bp->nr_extra_bufs; i++) {
                ebd = &bp->extra_data[i];
                if (!ebd->base || !ebd->len)
                        continue;
-               amt = copy_to_block_body(newb, (void*)ebd->base + ebd->off,
+               amt = block_copy_to_body(newb, (void*)ebd->base + ebd->off,
                                         ebd->len);
                assert(amt == ebd->len);
        }
@@ -275,6 +274,22 @@ struct block *linearizeblock(struct block *b)
        return newb;
 }
 
+/* Helper for bookkeeping: we removed amt bytes from block b's ebd, which may
+ * have emptied it. */
+static void block_consume_ebd_bytes(struct block *b, struct extra_bdata *ebd,
+                                   size_t amt)
+{
+       ebd->len -= amt;
+       ebd->off += amt;
+       b->extra_len -= amt;
+       if (!ebd->len) {
+               /* we don't actually have to decref here.  it's also
+                * done in freeb().  this is the earliest we can free. */
+               kfree((void*)ebd->base);
+               ebd->base = ebd->off = 0;
+       }
+}
+
 /* Make sure the first block has at least n bytes in its main body.  Pulls up
  * data from the *list* of blocks.  Returns 0 if there is not enough data in the
  * block list. */
@@ -606,15 +621,6 @@ static struct block *pop_first_block(struct queue *q)
        return b;
 }
 
-/* Helper: copies up to copy_amt from a buf to a block's main body (b->wp) */
-static size_t copy_to_block_body(struct block *to, void *from, size_t copy_amt)
-{
-       copy_amt = MIN(to->lim - to->wp, copy_amt);
-       memcpy(to->wp, from, copy_amt);
-       to->wp += copy_amt;
-       return copy_amt;
-}
-
 /* Accounting helper.  Block b in q lost amt extra_data */
 static void block_and_q_lost_extra(struct block *b, struct queue *q, size_t amt)
 {
@@ -658,7 +664,7 @@ static size_t copy_from_first_block(struct queue *q, struct block *to,
        /* Try to extract from the main body */
        copy_amt = MIN(BHLEN(from), len);
        if (copy_amt) {
-               copy_amt = copy_to_block_body(to, from->rp, copy_amt);
+               copy_amt = block_copy_to_body(to, from->rp, copy_amt);
                from->rp += copy_amt;
                /* We only change dlen, (data len), not q->len, since the q
                 * still has the same block memory allocation (no kfrees
@@ -681,7 +687,7 @@ static size_t copy_from_first_block(struct queue *q, struct block *to,
                                 * main body. */
                                if (copy_amt)
                                        return copy_amt;
-                               copy_amt = copy_to_block_body(to,
+                               copy_amt = block_copy_to_body(to,
                                                              (void*)ebd->base +
                                                              ebd->off,
                                                              ebd->len);
@@ -696,7 +702,7 @@ static size_t copy_from_first_block(struct queue *q, struct block *to,
                         * need to split to get anything from it. */
                        if (copy_amt)
                                return copy_amt;
-                       copy_amt = copy_to_block_body(to, (void*)ebd->base +
+                       copy_amt = block_copy_to_body(to, (void*)ebd->base +
                                                      ebd->off, len);
                        ebd->off += copy_amt;
                        ebd->len -= copy_amt;
@@ -1131,64 +1137,9 @@ struct block *qclone(struct queue *q, int header_len, int len, uint32_t offset)
        return newb;
 }
 
-/*
- *  copy from offset in the queue
- */
-struct block *qcopy_old(struct queue *q, int len, uint32_t offset)
-{
-       int sofar;
-       int n;
-       struct block *b, *nb;
-       uint8_t *p;
-
-       nb = block_alloc(len, MEM_WAIT);
-
-       spin_lock_irqsave(&q->lock);
-
-       /* go to offset */
-       b = q->bfirst;
-       for (sofar = 0;; sofar += n) {
-               if (b == NULL) {
-                       spin_unlock_irqsave(&q->lock);
-                       return nb;
-               }
-               n = BLEN(b);
-               if (sofar + n > offset) {
-                       p = b->rp + offset - sofar;
-                       n -= offset - sofar;
-                       break;
-               }
-               QDEBUG checkb(b, "qcopy");
-               b = b->next;
-       }
-
-       /* copy bytes from there */
-       for (sofar = 0; sofar < len;) {
-               if (n > len - sofar)
-                       n = len - sofar;
-               PANIC_EXTRA(b);
-               memmove(nb->wp, p, n);
-               qcopycnt += n;
-               sofar += n;
-               nb->wp += n;
-               b = b->next;
-               if (b == NULL)
-                       break;
-               n = BLEN(b);
-               p = b->rp;
-       }
-       spin_unlock_irqsave(&q->lock);
-
-       return nb;
-}
-
 struct block *qcopy(struct queue *q, int len, uint32_t offset)
 {
-#ifdef CONFIG_BLOCK_EXTRAS
        return qclone(q, 0, len, offset);
-#else
-       return qcopy_old(q, len, offset);
-#endif
 }
 
 static void qinit_common(struct queue *q)
@@ -1329,16 +1280,7 @@ static size_t read_from_block(struct block *b, uint8_t *to, size_t amt)
                memcpy(to, (void*)(ebd->base + ebd->off), copy_amt);
                /* we're actually consuming the entries, just like how we
                 * advance rp up above, and might only consume part of one. */
-               ebd->len -= copy_amt;
-               ebd->off += copy_amt;
-               b->extra_len -= copy_amt;
-               if (!ebd->len) {
-                       /* we don't actually have to decref here.  it's also
-                        * done in freeb().  this is the earliest we can free.
-                        */
-                       kfree((void*)ebd->base);
-                       ebd->base = ebd->off = 0;
-               }
+               block_consume_ebd_bytes(b, ebd, copy_amt);
                to += copy_amt;
                amt -= copy_amt;
                retval += copy_amt;
@@ -1637,7 +1579,7 @@ static struct block *build_block(void *from, size_t len, int mem_flags)
        /* If len is small, we don't need to bother with the extra_data.  But
         * until the whole stack can handle extd blocks, we'll use them
         * unconditionally.  */
-#ifdef CONFIG_BLOCK_EXTRAS
+
        /* allocb builds in 128 bytes of header space to all blocks, but this is
         * only available via padblock (to the left).  we also need some space
         * for pullupblock for some basic headers (like icmp) that get written
@@ -1660,13 +1602,6 @@ static struct block *build_block(void *from, size_t len, int mem_flags)
        b->extra_data[0].off = 0;
        b->extra_data[0].len = len;
        b->extra_len += len;
-#else
-       b = block_alloc(len, mem_flags);
-       if (!b)
-               return 0;
-       memmove(b->wp, from, len);
-       b->wp += len;
-#endif
        return b;
 }