Change iNULLim to inilim in qio.c
[akaros.git] / kern / src / ns / qio.c
index c4b21c7..23e535c 100644 (file)
@@ -38,7 +38,7 @@ struct queue {
        int len;                                        /* bytes allocated to queue */
        int dlen;                                       /* data bytes in queue */
        int limit;                                      /* max bytes in queue */
-       int iNULLim;                            /* initial limit */
+       int inilim;                             /* initial limit */
        int state;
        int noblock;                            /* true if writes return immediately when q full */
        int eof;                                        /* number of eofs read by user */
@@ -686,6 +686,8 @@ int qproduce(struct queue *q, void *vp, int len)
 
        /* save in buffer */
        /* use Qcoalesce here to save storage */
+       // TODO: Consider removing the Qcoalesce flag and force a coalescing
+       // strategy by default.
        b = q->blast;
        if ((q->state & Qcoalesce) == 0 || q->bfirst == NULL
                || b->lim - b->wp < len) {
@@ -795,7 +797,7 @@ struct queue *qopen(int limit, int msg, void (*kick) (void *), void *arg)
                return 0;
        qinit_common(q);
 
-       q->limit = q->iNULLim = limit;
+       q->limit = q->inilim = limit;
        q->kick = kick;
        q->arg = arg;
        q->state = msg;
@@ -831,10 +833,10 @@ static int notempty(void *a)
        return (q->state & Qclosed) || q->bfirst != 0;
 }
 
-/*
- *  wait for the queue to be non-empty or closed.
- *  called with q ilocked.
- */
+/* wait for the queue to be non-empty or closed.
+ *
+ * called with q ilocked.  rendez may error out, back through the caller, with
+ * the irqsave lock unlocked.  */
 static int qwait(struct queue *q)
 {
        /* wait for data */
@@ -852,6 +854,7 @@ static int qwait(struct queue *q)
 
                q->state |= Qstarve;    /* flag requesting producer to wake me */
                spin_unlock_irqsave(&q->lock);
+               /* may throw an error() */
                rendez_sleep(&q->rr, notempty, q);
                spin_lock_irqsave(&q->lock);
        }
@@ -1077,6 +1080,8 @@ again:
        }
 
        /* if we get here, there's at least one block in the queue */
+       // TODO: Consider removing the Qcoalesce flag and force a coalescing
+       // strategy by default.
        if (q->state & Qcoalesce) {
                /* when coalescing, 0 length blocks just go away */
                b = q->bfirst;
@@ -1147,6 +1152,7 @@ long qbwrite(struct queue *q, struct block *b)
 {
        ERRSTACK(1);
        int n, dowakeup;
+       volatile bool should_free_b = TRUE;
 
        n = BLEN(b);
 
@@ -1158,7 +1164,7 @@ long qbwrite(struct queue *q, struct block *b)
        dowakeup = 0;
        qlock(&q->wlock);
        if (waserror()) {
-               if (b != NULL)
+               if (b != NULL && should_free_b)
                        freeb(b);
                qunlock(&q->wlock);
                nexterror();
@@ -1185,6 +1191,7 @@ long qbwrite(struct queue *q, struct block *b)
        }
 
        /* queue the block */
+       should_free_b = FALSE;
        if (q->bfirst)
                q->blast->next = b;
        else
@@ -1406,7 +1413,7 @@ void qreopen(struct queue *q)
        q->state &= ~Qclosed;
        q->state |= Qstarve;
        q->eof = 0;
-       q->limit = q->iNULLim;
+       q->limit = q->inilim;
        spin_unlock_irqsave(&q->lock);
 }