Lines Matching +full:wait +full:- +full:queue
1 // SPDX-License-Identifier: GPL-2.0-only
54 * rpciod-related stuff
63 unsigned long timeout = READ_ONCE(task->tk_timeout); in rpc_task_timeout()
68 return timeout - now; in rpc_task_timeout()
76 * queue->lock and bh_disabled in order to avoid races within
80 __rpc_disable_timer(struct rpc_wait_queue *queue, struct rpc_task *task) in __rpc_disable_timer() argument
82 if (list_empty(&task->u.tk_wait.timer_list)) in __rpc_disable_timer()
84 task->tk_timeout = 0; in __rpc_disable_timer()
85 list_del(&task->u.tk_wait.timer_list); in __rpc_disable_timer()
86 if (list_empty(&queue->timer_list.list)) in __rpc_disable_timer()
87 cancel_delayed_work(&queue->timer_list.dwork); in __rpc_disable_timer()
91 rpc_set_queue_timer(struct rpc_wait_queue *queue, unsigned long expires) in rpc_set_queue_timer() argument
94 queue->timer_list.expires = expires; in rpc_set_queue_timer()
98 expires -= now; in rpc_set_queue_timer()
99 mod_delayed_work(rpciod_workqueue, &queue->timer_list.dwork, expires); in rpc_set_queue_timer()
106 __rpc_add_timer(struct rpc_wait_queue *queue, struct rpc_task *task, in __rpc_add_timer() argument
109 task->tk_timeout = timeout; in __rpc_add_timer()
110 if (list_empty(&queue->timer_list.list) || time_before(timeout, queue->timer_list.expires)) in __rpc_add_timer()
111 rpc_set_queue_timer(queue, timeout); in __rpc_add_timer()
112 list_add(&task->u.tk_wait.timer_list, &queue->timer_list.list); in __rpc_add_timer()
115 static void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int priority) in rpc_set_waitqueue_priority() argument
117 if (queue->priority != priority) { in rpc_set_waitqueue_priority()
118 queue->priority = priority; in rpc_set_waitqueue_priority()
119 queue->nr = 1U << priority; in rpc_set_waitqueue_priority()
123 static void rpc_reset_waitqueue_priority(struct rpc_wait_queue *queue) in rpc_reset_waitqueue_priority() argument
125 rpc_set_waitqueue_priority(queue, queue->maxpriority); in rpc_reset_waitqueue_priority()
129 * Add a request to a queue list
137 if (t->tk_owner == task->tk_owner) { in __rpc_list_enqueue_task()
138 list_add_tail(&task->u.tk_wait.links, in __rpc_list_enqueue_task()
139 &t->u.tk_wait.links); in __rpc_list_enqueue_task()
140 /* Cache the queue head in task->u.tk_wait.list */ in __rpc_list_enqueue_task()
141 task->u.tk_wait.list.next = q; in __rpc_list_enqueue_task()
142 task->u.tk_wait.list.prev = NULL; in __rpc_list_enqueue_task()
146 INIT_LIST_HEAD(&task->u.tk_wait.links); in __rpc_list_enqueue_task()
147 list_add_tail(&task->u.tk_wait.list, q); in __rpc_list_enqueue_task()
151 * Remove request from a queue list
159 if (task->u.tk_wait.list.prev == NULL) { in __rpc_list_dequeue_task()
160 list_del(&task->u.tk_wait.links); in __rpc_list_dequeue_task()
163 if (!list_empty(&task->u.tk_wait.links)) { in __rpc_list_dequeue_task()
164 t = list_first_entry(&task->u.tk_wait.links, in __rpc_list_dequeue_task()
167 /* Assume __rpc_list_enqueue_task() cached the queue head */ in __rpc_list_dequeue_task()
168 q = t->u.tk_wait.list.next; in __rpc_list_dequeue_task()
169 list_add_tail(&t->u.tk_wait.list, q); in __rpc_list_dequeue_task()
170 list_del(&task->u.tk_wait.links); in __rpc_list_dequeue_task()
172 list_del(&task->u.tk_wait.list); in __rpc_list_dequeue_task()
176 * Add new request to a priority queue.
178 static void __rpc_add_wait_queue_priority(struct rpc_wait_queue *queue, in __rpc_add_wait_queue_priority() argument
182 if (unlikely(queue_priority > queue->maxpriority)) in __rpc_add_wait_queue_priority()
183 queue_priority = queue->maxpriority; in __rpc_add_wait_queue_priority()
184 __rpc_list_enqueue_task(&queue->tasks[queue_priority], task); in __rpc_add_wait_queue_priority()
188 * Add new request to wait queue.
190 static void __rpc_add_wait_queue(struct rpc_wait_queue *queue, in __rpc_add_wait_queue() argument
194 INIT_LIST_HEAD(&task->u.tk_wait.timer_list); in __rpc_add_wait_queue()
195 if (RPC_IS_PRIORITY(queue)) in __rpc_add_wait_queue()
196 __rpc_add_wait_queue_priority(queue, task, queue_priority); in __rpc_add_wait_queue()
198 list_add_tail(&task->u.tk_wait.list, &queue->tasks[0]); in __rpc_add_wait_queue()
199 task->tk_waitqueue = queue; in __rpc_add_wait_queue()
200 queue->qlen++; in __rpc_add_wait_queue()
207 * Remove request from a priority queue.
215 * Remove request from queue.
218 static void __rpc_remove_wait_queue(struct rpc_wait_queue *queue, struct rpc_task *task) in __rpc_remove_wait_queue() argument
220 __rpc_disable_timer(queue, task); in __rpc_remove_wait_queue()
221 if (RPC_IS_PRIORITY(queue)) in __rpc_remove_wait_queue()
224 list_del(&task->u.tk_wait.list); in __rpc_remove_wait_queue()
225 queue->qlen--; in __rpc_remove_wait_queue()
228 static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname, unsigne… in __rpc_init_priority_wait_queue() argument
232 spin_lock_init(&queue->lock); in __rpc_init_priority_wait_queue()
233 for (i = 0; i < ARRAY_SIZE(queue->tasks); i++) in __rpc_init_priority_wait_queue()
234 INIT_LIST_HEAD(&queue->tasks[i]); in __rpc_init_priority_wait_queue()
235 queue->maxpriority = nr_queues - 1; in __rpc_init_priority_wait_queue()
236 rpc_reset_waitqueue_priority(queue); in __rpc_init_priority_wait_queue()
237 queue->qlen = 0; in __rpc_init_priority_wait_queue()
238 queue->timer_list.expires = 0; in __rpc_init_priority_wait_queue()
239 INIT_DELAYED_WORK(&queue->timer_list.dwork, __rpc_queue_timer_fn); in __rpc_init_priority_wait_queue()
240 INIT_LIST_HEAD(&queue->timer_list.list); in __rpc_init_priority_wait_queue()
241 rpc_assign_waitqueue_name(queue, qname); in __rpc_init_priority_wait_queue()
244 void rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname) in rpc_init_priority_wait_queue() argument
246 __rpc_init_priority_wait_queue(queue, qname, RPC_NR_PRIORITY); in rpc_init_priority_wait_queue()
250 void rpc_init_wait_queue(struct rpc_wait_queue *queue, const char *qname) in rpc_init_wait_queue() argument
252 __rpc_init_priority_wait_queue(queue, qname, 1); in rpc_init_wait_queue()
256 void rpc_destroy_wait_queue(struct rpc_wait_queue *queue) in rpc_destroy_wait_queue() argument
258 cancel_delayed_work_sync(&queue->timer_list.dwork); in rpc_destroy_wait_queue()
266 return -ERESTARTSYS; in rpc_wait_bit_killable()
275 task->tk_pid = atomic_inc_return(&rpc_pid); in rpc_task_set_debuginfo()
286 set_bit(RPC_TASK_ACTIVE, &task->tk_runstate); in rpc_set_active()
296 void *m = &task->tk_runstate; in rpc_complete_task()
304 spin_lock_irqsave(&wq->lock, flags); in rpc_complete_task()
305 clear_bit(RPC_TASK_ACTIVE, &task->tk_runstate); in rpc_complete_task()
306 ret = atomic_dec_and_test(&task->tk_count); in rpc_complete_task()
309 spin_unlock_irqrestore(&wq->lock, flags); in rpc_complete_task()
314 * Allow callers to wait for completion of an RPC call
317 * to enforce taking of the wq->lock and hence avoid races with
324 return out_of_line_wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE, in __rpc_wait_for_completion_task()
333 * rpc_wait_queue, this must be called with the queue spinlock held to protect
334 * the wait queue operation.
349 INIT_WORK(&task->u.tk_work, rpc_async_schedule); in rpc_make_runnable()
350 queue_work(wq, &task->u.tk_work); in rpc_make_runnable()
352 wake_up_bit(&task->tk_runstate, RPC_TASK_QUEUED); in rpc_make_runnable()
356 * Prepare for sleeping on a wait queue.
358 * NB: An RPC task will only receive interrupt-driven events as long
359 * as it's on a wait queue.
389 task->tk_status = -ETIMEDOUT; in __rpc_sleep_on_priority_timeout()
394 if (action && !WARN_ON_ONCE(task->tk_callback != NULL)) in rpc_set_tk_callback()
395 task->tk_callback = action; in rpc_set_tk_callback()
402 task->tk_status = -EIO; in rpc_sleep_check_activated()
418 * Protect the queue operations. in rpc_sleep_on_timeout()
420 spin_lock(&q->lock); in rpc_sleep_on_timeout()
421 __rpc_sleep_on_priority_timeout(q, task, timeout, task->tk_priority); in rpc_sleep_on_timeout()
422 spin_unlock(&q->lock); in rpc_sleep_on_timeout()
434 WARN_ON_ONCE(task->tk_timeout != 0); in rpc_sleep_on()
436 * Protect the queue operations. in rpc_sleep_on()
438 spin_lock(&q->lock); in rpc_sleep_on()
439 __rpc_sleep_on_priority(q, task, task->tk_priority); in rpc_sleep_on()
440 spin_unlock(&q->lock); in rpc_sleep_on()
450 priority -= RPC_PRIORITY_LOW; in rpc_sleep_on_priority_timeout()
452 * Protect the queue operations. in rpc_sleep_on_priority_timeout()
454 spin_lock(&q->lock); in rpc_sleep_on_priority_timeout()
456 spin_unlock(&q->lock); in rpc_sleep_on_priority_timeout()
466 WARN_ON_ONCE(task->tk_timeout != 0); in rpc_sleep_on_priority()
467 priority -= RPC_PRIORITY_LOW; in rpc_sleep_on_priority()
469 * Protect the queue operations. in rpc_sleep_on_priority()
471 spin_lock(&q->lock); in rpc_sleep_on_priority()
473 spin_unlock(&q->lock); in rpc_sleep_on_priority()
478 * __rpc_do_wake_up_task_on_wq - wake up a single rpc_task
480 * @queue: wait queue
483 * Caller must hold queue->lock, and have cleared the task queued flag.
486 struct rpc_wait_queue *queue, in __rpc_do_wake_up_task_on_wq() argument
495 trace_rpc_task_wakeup(task, queue); in __rpc_do_wake_up_task_on_wq()
497 __rpc_remove_wait_queue(queue, task); in __rpc_do_wake_up_task_on_wq()
503 * Wake up a queued task while the queue lock is being held
507 struct rpc_wait_queue *queue, struct rpc_task *task, in rpc_wake_up_task_on_wq_queue_action_locked() argument
512 if (task->tk_waitqueue == queue) { in rpc_wake_up_task_on_wq_queue_action_locked()
514 __rpc_do_wake_up_task_on_wq(wq, queue, task); in rpc_wake_up_task_on_wq_queue_action_locked()
523 * Wake up a queued task while the queue lock is being held
525 static void rpc_wake_up_task_queue_locked(struct rpc_wait_queue *queue, in rpc_wake_up_task_queue_locked() argument
528 rpc_wake_up_task_on_wq_queue_action_locked(rpciod_workqueue, queue, in rpc_wake_up_task_queue_locked()
533 * Wake up a task on a specific queue
535 void rpc_wake_up_queued_task(struct rpc_wait_queue *queue, struct rpc_task *task) in rpc_wake_up_queued_task() argument
539 spin_lock(&queue->lock); in rpc_wake_up_queued_task()
540 rpc_wake_up_task_queue_locked(queue, task); in rpc_wake_up_queued_task()
541 spin_unlock(&queue->lock); in rpc_wake_up_queued_task()
547 task->tk_status = *(int *)status; in rpc_task_action_set_status()
552 rpc_wake_up_task_queue_set_status_locked(struct rpc_wait_queue *queue, in rpc_wake_up_task_queue_set_status_locked() argument
555 rpc_wake_up_task_on_wq_queue_action_locked(rpciod_workqueue, queue, in rpc_wake_up_task_queue_set_status_locked()
560 * rpc_wake_up_queued_task_set_status - wake up a task and set task->tk_status
561 * @queue: pointer to rpc_wait_queue
565 * If @task is queued on @queue, then it is woken up, and @task->tk_status is
569 rpc_wake_up_queued_task_set_status(struct rpc_wait_queue *queue, in rpc_wake_up_queued_task_set_status() argument
574 spin_lock(&queue->lock); in rpc_wake_up_queued_task_set_status()
575 rpc_wake_up_task_queue_set_status_locked(queue, task, status); in rpc_wake_up_queued_task_set_status()
576 spin_unlock(&queue->lock); in rpc_wake_up_queued_task_set_status()
580 * Wake up the next task on a priority queue.
582 static struct rpc_task *__rpc_find_next_queued_priority(struct rpc_wait_queue *queue) in __rpc_find_next_queued_priority() argument
588 * Service the privileged queue. in __rpc_find_next_queued_priority()
590 q = &queue->tasks[RPC_NR_PRIORITY - 1]; in __rpc_find_next_queued_priority()
591 if (queue->maxpriority > RPC_PRIORITY_PRIVILEGED && !list_empty(q)) { in __rpc_find_next_queued_priority()
599 q = &queue->tasks[queue->priority]; in __rpc_find_next_queued_priority()
600 if (!list_empty(q) && queue->nr) { in __rpc_find_next_queued_priority()
601 queue->nr--; in __rpc_find_next_queued_priority()
607 * Service the next queue. in __rpc_find_next_queued_priority()
610 if (q == &queue->tasks[0]) in __rpc_find_next_queued_priority()
611 q = &queue->tasks[queue->maxpriority]; in __rpc_find_next_queued_priority()
613 q = q - 1; in __rpc_find_next_queued_priority()
618 } while (q != &queue->tasks[queue->priority]); in __rpc_find_next_queued_priority()
620 rpc_reset_waitqueue_priority(queue); in __rpc_find_next_queued_priority()
624 rpc_set_waitqueue_priority(queue, (unsigned int)(q - &queue->tasks[0])); in __rpc_find_next_queued_priority()
629 static struct rpc_task *__rpc_find_next_queued(struct rpc_wait_queue *queue) in __rpc_find_next_queued() argument
631 if (RPC_IS_PRIORITY(queue)) in __rpc_find_next_queued()
632 return __rpc_find_next_queued_priority(queue); in __rpc_find_next_queued()
633 if (!list_empty(&queue->tasks[0])) in __rpc_find_next_queued()
634 return list_first_entry(&queue->tasks[0], struct rpc_task, u.tk_wait.list); in __rpc_find_next_queued()
639 * Wake up the first task on the wait queue.
642 struct rpc_wait_queue *queue, in rpc_wake_up_first_on_wq() argument
647 spin_lock(&queue->lock); in rpc_wake_up_first_on_wq()
648 task = __rpc_find_next_queued(queue); in rpc_wake_up_first_on_wq()
650 task = rpc_wake_up_task_on_wq_queue_action_locked(wq, queue, in rpc_wake_up_first_on_wq()
652 spin_unlock(&queue->lock); in rpc_wake_up_first_on_wq()
658 * Wake up the first task on the wait queue.
660 struct rpc_task *rpc_wake_up_first(struct rpc_wait_queue *queue, in rpc_wake_up_first() argument
663 return rpc_wake_up_first_on_wq(rpciod_workqueue, queue, func, data); in rpc_wake_up_first()
673 * Wake up the next task on the wait queue.
675 struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *queue) in rpc_wake_up_next() argument
677 return rpc_wake_up_first(queue, rpc_wake_up_next_func, NULL); in rpc_wake_up_next()
682 * rpc_wake_up_locked - wake up all rpc_tasks
683 * @queue: rpc_wait_queue on which the tasks are sleeping
686 static void rpc_wake_up_locked(struct rpc_wait_queue *queue) in rpc_wake_up_locked() argument
691 task = __rpc_find_next_queued(queue); in rpc_wake_up_locked()
694 rpc_wake_up_task_queue_locked(queue, task); in rpc_wake_up_locked()
699 * rpc_wake_up - wake up all rpc_tasks
700 * @queue: rpc_wait_queue on which the tasks are sleeping
702 * Grabs queue->lock
704 void rpc_wake_up(struct rpc_wait_queue *queue) in rpc_wake_up() argument
706 spin_lock(&queue->lock); in rpc_wake_up()
707 rpc_wake_up_locked(queue); in rpc_wake_up()
708 spin_unlock(&queue->lock); in rpc_wake_up()
713 * rpc_wake_up_status_locked - wake up all rpc_tasks and set their status value.
714 * @queue: rpc_wait_queue on which the tasks are sleeping
717 static void rpc_wake_up_status_locked(struct rpc_wait_queue *queue, int status) in rpc_wake_up_status_locked() argument
722 task = __rpc_find_next_queued(queue); in rpc_wake_up_status_locked()
725 rpc_wake_up_task_queue_set_status_locked(queue, task, status); in rpc_wake_up_status_locked()
730 * rpc_wake_up_status - wake up all rpc_tasks and set their status value.
731 * @queue: rpc_wait_queue on which the tasks are sleeping
734 * Grabs queue->lock
736 void rpc_wake_up_status(struct rpc_wait_queue *queue, int status) in rpc_wake_up_status() argument
738 spin_lock(&queue->lock); in rpc_wake_up_status()
739 rpc_wake_up_status_locked(queue, status); in rpc_wake_up_status()
740 spin_unlock(&queue->lock); in rpc_wake_up_status()
746 struct rpc_wait_queue *queue = container_of(work, in __rpc_queue_timer_fn() local
752 spin_lock(&queue->lock); in __rpc_queue_timer_fn()
754 list_for_each_entry_safe(task, n, &queue->timer_list.list, u.tk_wait.timer_list) { in __rpc_queue_timer_fn()
755 timeo = task->tk_timeout; in __rpc_queue_timer_fn()
757 trace_rpc_task_timeout(task, task->tk_action); in __rpc_queue_timer_fn()
758 task->tk_status = -ETIMEDOUT; in __rpc_queue_timer_fn()
759 rpc_wake_up_task_queue_locked(queue, task); in __rpc_queue_timer_fn()
765 if (!list_empty(&queue->timer_list.list)) in __rpc_queue_timer_fn()
766 rpc_set_queue_timer(queue, expires); in __rpc_queue_timer_fn()
767 spin_unlock(&queue->lock); in __rpc_queue_timer_fn()
772 if (task->tk_status == -ETIMEDOUT) in __rpc_atrun()
773 task->tk_status = 0; in __rpc_atrun()
786 * Helper to call task->tk_ops->rpc_call_prepare
790 task->tk_ops->rpc_call_prepare(task, task->tk_calldata); in rpc_prepare_task()
797 task->tk_garb_retry = 2; in rpc_init_task_statistics()
798 task->tk_cred_retry = 2; in rpc_init_task_statistics()
801 task->tk_start = ktime_get(); in rpc_init_task_statistics()
807 task->tk_timeouts = 0; in rpc_reset_task_statistics()
808 task->tk_flags &= ~(RPC_CALL_MAJORSEEN|RPC_TASK_SENT); in rpc_reset_task_statistics()
813 * Helper that calls task->tk_ops->rpc_call_done if it exists
817 trace_rpc_task_end(task, task->tk_action); in rpc_exit_task()
818 task->tk_action = NULL; in rpc_exit_task()
819 if (task->tk_ops->rpc_count_stats) in rpc_exit_task()
820 task->tk_ops->rpc_count_stats(task, task->tk_calldata); in rpc_exit_task()
821 else if (task->tk_client) in rpc_exit_task()
822 rpc_count_iostats(task, task->tk_client->cl_metrics); in rpc_exit_task()
823 if (task->tk_ops->rpc_call_done != NULL) { in rpc_exit_task()
824 task->tk_ops->rpc_call_done(task, task->tk_calldata); in rpc_exit_task()
825 if (task->tk_action != NULL) { in rpc_exit_task()
835 struct rpc_wait_queue *queue; in rpc_signal_task() local
840 trace_rpc_task_signalled(task, task->tk_action); in rpc_signal_task()
841 set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate); in rpc_signal_task()
843 queue = READ_ONCE(task->tk_waitqueue); in rpc_signal_task()
844 if (queue) in rpc_signal_task()
845 rpc_wake_up_queued_task_set_status(queue, task, -ERESTARTSYS); in rpc_signal_task()
850 task->tk_status = status; in rpc_exit()
851 task->tk_action = rpc_exit_task; in rpc_exit()
852 rpc_wake_up_queued_task(task->tk_waitqueue, task); in rpc_exit()
858 if (ops->rpc_release != NULL) in rpc_release_calldata()
859 ops->rpc_release(calldata); in rpc_release_calldata()
867 struct rpc_wait_queue *queue; in __rpc_execute() local
885 do_action = task->tk_action; in __rpc_execute()
886 if (task->tk_callback) { in __rpc_execute()
887 do_action = task->tk_callback; in __rpc_execute()
888 task->tk_callback = NULL; in __rpc_execute()
905 task->tk_rpc_status = -ERESTARTSYS; in __rpc_execute()
906 rpc_exit(task, -ERESTARTSYS); in __rpc_execute()
910 * The queue->lock protects against races with in __rpc_execute()
918 queue = task->tk_waitqueue; in __rpc_execute()
919 spin_lock(&queue->lock); in __rpc_execute()
921 spin_unlock(&queue->lock); in __rpc_execute()
925 spin_unlock(&queue->lock); in __rpc_execute()
930 trace_rpc_task_sync_sleep(task, task->tk_action); in __rpc_execute()
931 status = out_of_line_wait_on_bit(&task->tk_runstate, in __rpc_execute()
937 * -ERESTARTSYS. In order to catch any callbacks that in __rpc_execute()
938 * clean up after sleeping on some queue, we don't in __rpc_execute()
941 trace_rpc_task_signalled(task, task->tk_action); in __rpc_execute()
942 set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate); in __rpc_execute()
943 task->tk_rpc_status = -ERESTARTSYS; in __rpc_execute()
944 rpc_exit(task, -ERESTARTSYS); in __rpc_execute()
946 trace_rpc_task_sync_wake(task, task->tk_action); in __rpc_execute()
954 * User-visible entry point to the scheduler.
984 * rpc_malloc - allocate RPC buffer resources
992 * returning -ENOMEM and suppressing warning if the request cannot
1002 struct rpc_rqst *rqst = task->tk_rqstp; in rpc_malloc()
1003 size_t size = rqst->rq_callsize + rqst->rq_rcvsize; in rpc_malloc()
1019 return -ENOMEM; in rpc_malloc()
1021 buf->len = size; in rpc_malloc()
1022 rqst->rq_buffer = buf->data; in rpc_malloc()
1023 rqst->rq_rbuffer = (char *)rqst->rq_buffer + rqst->rq_callsize; in rpc_malloc()
1029 * rpc_free - free RPC buffer resources allocated via rpc_malloc
1035 void *buffer = task->tk_rqstp->rq_buffer; in rpc_free()
1040 size = buf->len; in rpc_free()
1055 atomic_set(&task->tk_count, 1); in rpc_init_task()
1056 task->tk_flags = task_setup_data->flags; in rpc_init_task()
1057 task->tk_ops = task_setup_data->callback_ops; in rpc_init_task()
1058 task->tk_calldata = task_setup_data->callback_data; in rpc_init_task()
1059 INIT_LIST_HEAD(&task->tk_task); in rpc_init_task()
1061 task->tk_priority = task_setup_data->priority - RPC_PRIORITY_LOW; in rpc_init_task()
1062 task->tk_owner = current->tgid; in rpc_init_task()
1065 task->tk_workqueue = task_setup_data->workqueue; in rpc_init_task()
1067 task->tk_xprt = rpc_task_get_xprt(task_setup_data->rpc_client, in rpc_init_task()
1068 xprt_get(task_setup_data->rpc_xprt)); in rpc_init_task()
1070 task->tk_op_cred = get_rpccred(task_setup_data->rpc_op_cred); in rpc_init_task()
1072 if (task->tk_ops->rpc_call_prepare != NULL) in rpc_init_task()
1073 task->tk_action = rpc_prepare_task; in rpc_init_task()
1089 struct rpc_task *task = setup_data->task; in rpc_new_task()
1098 task->tk_flags |= flags; in rpc_new_task()
1103 * rpc_free_task - release rpc task and perform cleanups
1110 * on the same address and won't execute them concurrently - ie. it
1111 * makes a work item which is queued again while being executed wait
1123 unsigned short tk_flags = task->tk_flags; in rpc_free_task()
1125 put_rpccred(task->tk_op_cred); in rpc_free_task()
1126 rpc_release_calldata(task->tk_ops, task->tk_calldata); in rpc_free_task()
1143 if (task->tk_msg.rpc_cred) { in rpc_release_resources_task()
1144 if (!(task->tk_flags & RPC_TASK_CRED_NOREF)) in rpc_release_resources_task()
1145 put_cred(task->tk_msg.rpc_cred); in rpc_release_resources_task()
1146 task->tk_msg.rpc_cred = NULL; in rpc_release_resources_task()
1155 INIT_WORK(&task->u.tk_work, rpc_async_release); in rpc_final_put_task()
1156 queue_work(q, &task->u.tk_work); in rpc_final_put_task()
1163 if (atomic_dec_and_test(&task->tk_count)) { in rpc_do_put_task()
1177 rpc_do_put_task(task, task->tk_workqueue); in rpc_put_task_async()
1188 * Note: at this point we have been removed from rpc_clnt->cl_tasks, in rpc_release_task()
1189 * so it should be safe to use task->tk_count as a test for whether in rpc_release_task()
1192 if (atomic_read(&task->tk_count) != 1 + !RPC_IS_ASYNC(task)) { in rpc_release_task()
1197 if (!atomic_dec_and_test(&task->tk_count)) in rpc_release_task()
1200 rpc_final_put_task(task, task->tk_workqueue); in rpc_release_task()
1205 return try_module_get(THIS_MODULE) ? 0 : -EINVAL; in rpciod_up()
1221 * Create the rpciod thread and wait for it to start. in rpciod_start()
1301 return -ENOMEM; in rpc_init_mempool()