Lines Matching defs:queue
61 * queue->lock and bh_disabled in order to avoid races within
65 __rpc_disable_timer(struct rpc_wait_queue *queue, struct rpc_task *task)
72 if (list_empty(&queue->timer_list.list))
73 del_timer(&queue->timer_list.timer);
77 rpc_set_queue_timer(struct rpc_wait_queue *queue, unsigned long expires)
79 queue->timer_list.expires = expires;
80 mod_timer(&queue->timer_list.timer, expires);
87 __rpc_add_timer(struct rpc_wait_queue *queue, struct rpc_task *task)
96 if (list_empty(&queue->timer_list.list) || time_before(task->u.tk_wait.expires, queue->timer_list.expires))
97 rpc_set_queue_timer(queue, task->u.tk_wait.expires);
98 list_add(&task->u.tk_wait.timer_list, &queue->timer_list.list);
101 static void rpc_rotate_queue_owner(struct rpc_wait_queue *queue)
103 struct list_head *q = &queue->tasks[queue->priority];
108 if (task->tk_owner == queue->owner)
113 static void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int priority)
115 if (queue->priority != priority) {
117 rpc_rotate_queue_owner(queue);
118 queue->priority = priority;
122 static void rpc_set_waitqueue_owner(struct rpc_wait_queue *queue, pid_t pid)
124 queue->owner = pid;
125 queue->nr = RPC_BATCH_COUNT;
128 static void rpc_reset_waitqueue_priority(struct rpc_wait_queue *queue)
130 rpc_set_waitqueue_priority(queue, queue->maxpriority);
131 rpc_set_waitqueue_owner(queue, 0);
135 * Add new request to a priority queue.
137 static void __rpc_add_wait_queue_priority(struct rpc_wait_queue *queue,
145 if (unlikely(queue_priority > queue->maxpriority))
146 queue_priority = queue->maxpriority;
147 if (queue_priority > queue->priority)
148 rpc_set_waitqueue_priority(queue, queue_priority);
149 q = &queue->tasks[queue_priority];
160 * Add new request to wait queue.
162 * Swapper tasks always get inserted at the head of the queue.
165 * Everyone else gets appended to the queue to ensure proper FIFO behavior.
167 static void __rpc_add_wait_queue(struct rpc_wait_queue *queue,
175 if (RPC_IS_PRIORITY(queue))
176 __rpc_add_wait_queue_priority(queue, task, queue_priority);
178 list_add(&task->u.tk_wait.list, &queue->tasks[0]);
180 list_add_tail(&task->u.tk_wait.list, &queue->tasks[0]);
181 task->tk_waitqueue = queue;
182 queue->qlen++;
187 dprintk("RPC: %5u added to queue %p \"%s\"\n",
188 task->tk_pid, queue, rpc_qname(queue));
192 * Remove request from a priority queue.
206 * Remove request from queue.
209 static void __rpc_remove_wait_queue(struct rpc_wait_queue *queue, struct rpc_task *task)
211 __rpc_disable_timer(queue, task);
212 if (RPC_IS_PRIORITY(queue))
215 queue->qlen--;
216 dprintk("RPC: %5u removed from queue %p \"%s\"\n",
217 task->tk_pid, queue, rpc_qname(queue));
220 static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname, unsigned char nr_queues)
224 spin_lock_init(&queue->lock);
225 for (i = 0; i < ARRAY_SIZE(queue->tasks); i++)
226 INIT_LIST_HEAD(&queue->tasks[i]);
227 queue->maxpriority = nr_queues - 1;
228 rpc_reset_waitqueue_priority(queue);
229 queue->qlen = 0;
230 setup_timer(&queue->timer_list.timer, __rpc_queue_timer_fn, (unsigned long)queue);
231 INIT_LIST_HEAD(&queue->timer_list.list);
232 rpc_assign_waitqueue_name(queue, qname);
235 void rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname)
237 __rpc_init_priority_wait_queue(queue, qname, RPC_NR_PRIORITY);
241 void rpc_init_wait_queue(struct rpc_wait_queue *queue, const char *qname)
243 __rpc_init_priority_wait_queue(queue, qname, 1);
247 void rpc_destroy_wait_queue(struct rpc_wait_queue *queue)
249 del_timer_sync(&queue->timer_list.timer);
325 * rpc_wait_queue, this must be called with the queue spinlock held to protect
326 * the wait queue operation.
347 * Prepare for sleeping on a wait queue.
350 * as it's on a wait queue.
357 dprintk("RPC: %5u sleep_on(queue \"%s\" time %lu)\n",
381 * Protect the queue operations.
401 * Protect the queue operations.
411 * @queue: wait queue
414 * Caller must hold queue->lock, and have cleared the task queued flag.
416 static void __rpc_do_wake_up_task(struct rpc_wait_queue *queue, struct rpc_task *task)
427 trace_rpc_task_wakeup(task->tk_client, task, queue);
429 __rpc_remove_wait_queue(queue, task);
437 * Wake up a queued task while the queue lock is being held
439 static void rpc_wake_up_task_queue_locked(struct rpc_wait_queue *queue, struct rpc_task *task)
443 if (task->tk_waitqueue == queue)
444 __rpc_do_wake_up_task(queue, task);
449 * Wake up a task on a specific queue
451 void rpc_wake_up_queued_task(struct rpc_wait_queue *queue, struct rpc_task *task)
453 spin_lock_bh(&queue->lock);
454 rpc_wake_up_task_queue_locked(queue, task);
455 spin_unlock_bh(&queue->lock);
460 * Wake up the next task on a priority queue.
462 static struct rpc_task *__rpc_find_next_queued_priority(struct rpc_wait_queue *queue)
470 q = &queue->tasks[queue->priority];
473 if (queue->owner == task->tk_owner) {
474 if (--queue->nr)
485 * Service the next queue.
488 if (q == &queue->tasks[0])
489 q = &queue->tasks[queue->maxpriority];
496 } while (q != &queue->tasks[queue->priority]);
498 rpc_reset_waitqueue_priority(queue);
502 rpc_set_waitqueue_priority(queue, (unsigned int)(q - &queue->tasks[0]));
504 rpc_set_waitqueue_owner(queue, task->tk_owner);
509 static struct rpc_task *__rpc_find_next_queued(struct rpc_wait_queue *queue)
511 if (RPC_IS_PRIORITY(queue))
512 return __rpc_find_next_queued_priority(queue);
513 if (!list_empty(&queue->tasks[0]))
514 return list_first_entry(&queue->tasks[0], struct rpc_task, u.tk_wait.list);
519 * Wake up the first task on the wait queue.
521 struct rpc_task *rpc_wake_up_first(struct rpc_wait_queue *queue,
527 queue, rpc_qname(queue));
528 spin_lock_bh(&queue->lock);
529 task = __rpc_find_next_queued(queue);
532 rpc_wake_up_task_queue_locked(queue, task);
536 spin_unlock_bh(&queue->lock);
548 * Wake up the next task on the wait queue.
550 struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *queue)
552 return rpc_wake_up_first(queue, rpc_wake_up_next_func, NULL);
558 * @queue: rpc_wait_queue on which the tasks are sleeping
560 * Grabs queue->lock
562 void rpc_wake_up(struct rpc_wait_queue *queue)
566 spin_lock_bh(&queue->lock);
567 head = &queue->tasks[queue->maxpriority];
574 rpc_wake_up_task_queue_locked(queue, task);
576 if (head == &queue->tasks[0])
580 spin_unlock_bh(&queue->lock);
586 * @queue: rpc_wait_queue on which the tasks are sleeping
589 * Grabs queue->lock
591 void rpc_wake_up_status(struct rpc_wait_queue *queue, int status)
595 spin_lock_bh(&queue->lock);
596 head = &queue->tasks[queue->maxpriority];
604 rpc_wake_up_task_queue_locked(queue, task);
606 if (head == &queue->tasks[0])
610 spin_unlock_bh(&queue->lock);
616 struct rpc_wait_queue *queue = (struct rpc_wait_queue *)ptr;
620 spin_lock(&queue->lock);
622 list_for_each_entry_safe(task, n, &queue->timer_list.list, u.tk_wait.timer_list) {
627 rpc_wake_up_task_queue_locked(queue, task);
633 if (!list_empty(&queue->timer_list.list))
634 rpc_set_queue_timer(queue, expires);
635 spin_unlock(&queue->lock);
720 struct rpc_wait_queue *queue;
759 * The queue->lock protects against races with
767 queue = task->tk_waitqueue;
768 spin_lock_bh(&queue->lock);
770 spin_unlock_bh(&queue->lock);
774 spin_unlock_bh(&queue->lock);
787 * clean up after sleeping on some queue, we don't