/*
* flow control, wait for queue to get below the limit
*/
static void
qflow(Queue *q)
{
for(;;){
if(q->noblock || qnotfull(q))
break;
ilock(q);
q->state |= Qflow;
iunlock(q);
eqlock(&q->wlock);
if(waserror()){
qunlock(&q->wlock);
nexterror();
}
sleep(&q->wr, qnotfull, q);
qunlock(&q->wlock);
poperror();
}
}
/* Adds block (which can be a list of blocks) to the queue, subject to
* qio_flags. Returns the length written on success or -1 on non-throwable
* error. Adjust qio_flags to control the value-added features!. */
static ssize_t __qbwrite(struct queue *q, struct block *b, int qio_flags)
{
ssize_t ret;
bool dowakeup = FALSE;
bool was_empty;
if (q->bypass) {
ret = blocklen(b);
(*q->bypass) (q->arg, b);
return ret;
}
spin_lock_irqsave(&q->lock);
was_empty = q->len == 0;
if (q->state & Qclosed) {
spin_unlock_irqsave(&q->lock);
freeblist(b);
if (!(qio_flags & QIO_CAN_ERR_SLEEP))
return -1;
if (q->err[0])
error(EFAIL, q->err);
else
error(EFAIL, "connection closed");
}
if ((qio_flags & QIO_LIMIT) && (q->len >= q->limit)) {
/* drop overflow takes priority over regular non-blocking */
if ((qio_flags & QIO_DROP_OVERFLOW) || (q->state & Qdropoverflow)) {
spin_unlock_irqsave(&q->lock);
freeb(b);
return -1;
}
/* People shouldn't set NON_BLOCK without CAN_ERR, but we can be nice
* and catch it. */
if ((qio_flags & QIO_CAN_ERR_SLEEP) && (qio_flags & QIO_NON_BLOCK)) {
spin_unlock_irqsave(&q->lock);
freeb(b);
error(EAGAIN, "queue full");
}
}
ret = enqueue_blist(q, b);
QDEBUG checkb(b, "__qbwrite");
/* make sure other end gets awakened */
if (q->state & Qstarve) {
q->state &= ~Qstarve;
dowakeup = TRUE;
}
spin_unlock_irqsave(&q->lock);
/* TODO: not sure if the usage of a kick is mutually exclusive with a
* wakeup, meaning that actual users either want a kick or have qreaders. */
if (q->kick && (dowakeup || (q->state & Qkick)))
q->kick(q->arg);
if (dowakeup)
rendez_wakeup(&q->rr);
if (was_empty)
qwake_cb(q, FDTAP_FILT_READABLE);
/*
* flow control, wait for queue to get below the limit
* before allowing the process to continue and queue
* more. We do this here so that postnote can only
* interrupt us after the data has been queued. This
* means that things like 9p flushes and ssl messages
* will not be disrupted by software interrupts.
*
* Note - this is moderately dangerous since a process
* that keeps getting interrupted and rewriting will
* queue infinite crud.
*/
if ((qio_flags & QIO_CAN_ERR_SLEEP) &&
!(q->state & Qdropoverflow) && !(qio_flags & QIO_NON_BLOCK)) {
/* This is a racy peek at the q status. If we accidentally block, we
* set Qflow, so someone should wake us. If we accidentally don't
* block, we just returned to the user and let them slip a block past
* flow control. */
while (!qnotfull(q)) {
spin_lock_irqsave(&q->lock);
q->state |= Qflow;
spin_unlock_irqsave(&q->lock);
rendez_sleep(&q->wr, qnotfull, q);
}
}
return ret;
}
/*
* add a block to a queue obeying flow control
*/
long
qbwrite(Queue *q, Block *b)
{
int n, dowakeup;
Proc *p;
n = BLEN(b);
if(q->bypass){
(*q->bypass)(q->arg, b);
return n;
}
dowakeup = 0;
qlock(&q->wlock);
if(waserror()){
if(b != nil)
freeb(b);
qunlock(&q->wlock);
nexterror();
}
ilock(q);
/* give up if the queue is closed */
if(q->state & Qclosed){
iunlock(q);
error(q->err);
}
/* if nonblocking, don't queue over the limit */
if(q->len >= q->limit){
if(q->noblock){
iunlock(q);
freeb(b);
noblockcnt += n;
qunlock(&q->wlock);
poperror();
return n;
}
}
/* queue the block */
if(q->bfirst)
q->blast->next = b;
else
q->bfirst = b;
q->blast = b;
b->next = 0;
q->len += BALLOC(b);
q->dlen += n;
QDEBUG checkb(b, "qbwrite");
b = nil;
/* make sure other end gets awakened */
if(q->state & Qstarve){
q->state &= ~Qstarve;
dowakeup = 1;
}
iunlock(q);
/* get output going again */
if(q->kick && (dowakeup || (q->state&Qkick)))
q->kick(q->arg);
/* wakeup anyone consuming at the other end */
if(dowakeup){
p = wakeup(&q->rr);
/* if we just wokeup a higher priority process, let it run */
if(p != nil && p->priority > up->priority)
sched();
}
/*
* flow control, wait for queue to get below the limit
* before allowing the process to continue and queue
* more. We do this here so that postnote can only
* interrupt us after the data has been queued. This
* means that things like 9p flushes and ssl messages
* will not be disrupted by software interrupts.
*
* Note - this is moderately dangerous since a process
* that keeps getting interrupted and rewriting will
* queue infinite crud.
*/
for(;;){
if(q->noblock || qnotfull(q))
break;
ilock(q);
q->state |= Qflow;
iunlock(q);
sleep(&q->wr, qnotfull, q);
}
USED(b);
qunlock(&q->wlock);
poperror();
return n;
}
/*
* add a block to a queue obeying flow control
*/
long qbwrite(struct queue *q, struct block *b)
{
ERRSTACK(1);
int n, dowakeup;
volatile bool should_free_b = TRUE;
n = BLEN(b);
if (q->bypass) {
(*q->bypass) (q->arg, b);
return n;
}
dowakeup = 0;
qlock(&q->wlock);
if (waserror()) {
if (b != NULL && should_free_b)
freeb(b);
qunlock(&q->wlock);
nexterror();
}
spin_lock_irqsave(&q->lock);
/* give up if the queue is closed */
if (q->state & Qclosed) {
spin_unlock_irqsave(&q->lock);
error(EFAIL, q->err);
}
/* if nonblocking, don't queue over the limit */
if (q->len >= q->limit) {
/* drop overflow takes priority over regular non-blocking */
if (q->state & Qdropoverflow) {
spin_unlock_irqsave(&q->lock);
freeb(b);
dropcnt += n;
qunlock(&q->wlock);
poperror();
return n;
}
if (q->state & Qnonblock) {
spin_unlock_irqsave(&q->lock);
freeb(b);
error(EAGAIN, "queue full");
}
}
/* queue the block */
should_free_b = FALSE;
if (q->bfirst)
q->blast->next = b;
else
q->bfirst = b;
q->blast = b;
b->next = 0;
q->len += BALLOC(b);
q->dlen += n;
QDEBUG checkb(b, "qbwrite");
b = NULL;
/* make sure other end gets awakened */
if (q->state & Qstarve) {
q->state &= ~Qstarve;
dowakeup = 1;
}
spin_unlock_irqsave(&q->lock);
/* get output going again */
if (q->kick && (dowakeup || (q->state & Qkick)))
q->kick(q->arg);
/* wakeup anyone consuming at the other end */
if (dowakeup) {
rendez_wakeup(&q->rr);
qwake_cb(q, FDTAP_FILT_READABLE);
}
/*
* flow control, wait for queue to get below the limit
* before allowing the process to continue and queue
* more. We do this here so that postnote can only
* interrupt us after the data has been queued. This
* means that things like 9p flushes and ssl messages
* will not be disrupted by software interrupts.
*
* Note - this is moderately dangerous since a process
* that keeps getting interrupted and rewriting will
* queue infinite crud.
*/
for (;;) {
if ((q->state & (Qdropoverflow | Qnonblock)) || qnotfull(q))
break;
spin_lock_irqsave(&q->lock);
q->state |= Qflow;
spin_unlock_irqsave(&q->lock);
rendez_sleep(&q->wr, qnotfull, q);
}
qunlock(&q->wlock);
poperror();
return n;
}
/*
* add a block to a queue obeying flow control
*/
long
qbwrite(Queue *q, Block *b)
{
int n, dowakeup;
volatile struct {Block *b;} cb;
dowakeup = 0;
n = BLEN(b);
if(q->bypass){
(*q->bypass)(q->arg, b);
return n;
}
cb.b = b;
qlock(&q->wlock);
if(waserror()){
if(cb.b != nil)
freeb(cb.b);
qunlock(&q->wlock);
nexterror();
}
lock(&q->l);
/* give up if the queue is closed */
if(q->state & Qclosed){
unlock(&q->l);
error(q->err);
}
/* if nonblocking, don't queue over the limit */
if(q->len >= q->limit){
if(q->noblock){
unlock(&q->l);
freeb(b);
poperror();
qunlock(&q->wlock);
return n;
}
}
/* queue the block */
if(q->bfirst)
q->blast->next = b;
else
q->bfirst = b;
q->blast = b;
b->next = 0;
q->len += BALLOC(b);
q->dlen += n;
QDEBUG checkb(b, "qbwrite");
cb.b = nil;
if(q->state & Qstarve){
q->state &= ~Qstarve;
dowakeup = 1;
}
unlock(&q->l);
/* get output going again */
if(q->kick && (dowakeup || (q->state&Qkick)))
q->kick(q->arg);
if(dowakeup)
Wakeup(&q->rr);
/*
* flow control, wait for queue to get below the limit
* before allowing the process to continue and queue
* more. We do this here so that postnote can only
* interrupt us after the data has been queued. This
* means that things like 9p flushes and ssl messages
* will not be disrupted by software interrupts.
*
* Note - this is moderately dangerous since a process
* that keeps getting interrupted and rewriting will
* queue infinite crud.
*/
for(;;){
if(q->noblock || qnotfull(q))
break;
lock(&q->l);
q->state |= Qflow;
unlock(&q->l);
Sleep(&q->wr, qnotfull, q);
}
qunlock(&q->wlock);
poperror();
return n;
}
