Lines Matching full:task
45 static void rpc_release_task(struct rpc_task *task);
61 rpc_task_timeout(const struct rpc_task *task) in rpc_task_timeout() argument
63 unsigned long timeout = READ_ONCE(task->tk_timeout); in rpc_task_timeout()
75 * Disable the timer for a given RPC task. Should be called with
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()
103 * Set up a timer for the current task.
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()
112 list_add(&task->u.tk_wait.timer_list, &queue->timer_list.list); in __rpc_add_timer()
132 __rpc_list_enqueue_task(struct list_head *q, struct rpc_task *task) in __rpc_list_enqueue_task() argument
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()
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()
154 __rpc_list_dequeue_task(struct rpc_task *task) in __rpc_list_dequeue_task() argument
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()
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()
179 struct rpc_task *task, in __rpc_add_wait_queue_priority() argument
184 __rpc_list_enqueue_task(&queue->tasks[queue_priority], task); in __rpc_add_wait_queue_priority()
196 struct rpc_task *task, in __rpc_add_wait_queue() argument
199 INIT_LIST_HEAD(&task->u.tk_wait.timer_list); in __rpc_add_wait_queue()
201 __rpc_add_wait_queue_priority(queue, task, queue_priority); in __rpc_add_wait_queue()
202 else if (RPC_IS_SWAPPER(task)) in __rpc_add_wait_queue()
203 list_add(&task->u.tk_wait.list, &queue->tasks[0]); in __rpc_add_wait_queue()
205 list_add_tail(&task->u.tk_wait.list, &queue->tasks[0]); in __rpc_add_wait_queue()
206 task->tk_waitqueue = queue; in __rpc_add_wait_queue()
210 rpc_set_queued(task); in __rpc_add_wait_queue()
216 static void __rpc_remove_wait_queue_priority(struct rpc_task *task) in __rpc_remove_wait_queue_priority() argument
218 __rpc_list_dequeue_task(task); in __rpc_remove_wait_queue_priority()
225 static void __rpc_remove_wait_queue(struct rpc_wait_queue *queue, struct rpc_task *task) in __rpc_remove_wait_queue() argument
227 __rpc_disable_timer(queue, task); in __rpc_remove_wait_queue()
229 __rpc_remove_wait_queue_priority(task); in __rpc_remove_wait_queue()
231 list_del(&task->u.tk_wait.list); in __rpc_remove_wait_queue()
278 static void rpc_task_set_debuginfo(struct rpc_task *task) in rpc_task_set_debuginfo() argument
282 task->tk_pid = atomic_inc_return(&rpc_pid); in rpc_task_set_debuginfo()
285 static inline void rpc_task_set_debuginfo(struct rpc_task *task) in rpc_task_set_debuginfo() argument
290 static void rpc_set_active(struct rpc_task *task) in rpc_set_active() argument
292 rpc_task_set_debuginfo(task); in rpc_set_active()
293 set_bit(RPC_TASK_ACTIVE, &task->tk_runstate); in rpc_set_active()
294 trace_rpc_task_begin(task, NULL); in rpc_set_active()
301 static int rpc_complete_task(struct rpc_task *task) in rpc_complete_task() argument
303 void *m = &task->tk_runstate; in rpc_complete_task()
309 trace_rpc_task_complete(task, NULL); in rpc_complete_task()
312 clear_bit(RPC_TASK_ACTIVE, &task->tk_runstate); in rpc_complete_task()
313 ret = atomic_dec_and_test(&task->tk_count); in rpc_complete_task()
327 int __rpc_wait_for_completion_task(struct rpc_task *task, wait_bit_action_f *action) in __rpc_wait_for_completion_task() argument
331 return out_of_line_wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE, in __rpc_wait_for_completion_task()
337 * Make an RPC task runnable.
339 * Note: If the task is ASYNC, and is being made runnable after sitting on an
348 struct rpc_task *task) in rpc_make_runnable() argument
350 bool need_wakeup = !rpc_test_and_set_running(task); in rpc_make_runnable()
352 rpc_clear_queued(task); in rpc_make_runnable()
355 if (RPC_IS_ASYNC(task)) { in rpc_make_runnable()
356 INIT_WORK(&task->u.tk_work, rpc_async_schedule); in rpc_make_runnable()
357 queue_work(wq, &task->u.tk_work); in rpc_make_runnable()
359 wake_up_bit(&task->tk_runstate, RPC_TASK_QUEUED); in rpc_make_runnable()
365 * NB: An RPC task will only receive interrupt-driven events as long
369 struct rpc_task *task, in __rpc_do_sleep_on_priority() argument
372 trace_rpc_task_sleep(task, q); in __rpc_do_sleep_on_priority()
374 __rpc_add_wait_queue(q, task, queue_priority); in __rpc_do_sleep_on_priority()
378 struct rpc_task *task, in __rpc_sleep_on_priority() argument
381 if (WARN_ON_ONCE(RPC_IS_QUEUED(task))) in __rpc_sleep_on_priority()
383 __rpc_do_sleep_on_priority(q, task, queue_priority); in __rpc_sleep_on_priority()
387 struct rpc_task *task, unsigned long timeout, in __rpc_sleep_on_priority_timeout() argument
390 if (WARN_ON_ONCE(RPC_IS_QUEUED(task))) in __rpc_sleep_on_priority_timeout()
393 __rpc_do_sleep_on_priority(q, task, queue_priority); in __rpc_sleep_on_priority_timeout()
394 __rpc_add_timer(q, task, timeout); in __rpc_sleep_on_priority_timeout()
396 task->tk_status = -ETIMEDOUT; in __rpc_sleep_on_priority_timeout()
399 static void rpc_set_tk_callback(struct rpc_task *task, rpc_action action) in rpc_set_tk_callback() argument
401 if (action && !WARN_ON_ONCE(task->tk_callback != NULL)) in rpc_set_tk_callback()
402 task->tk_callback = action; in rpc_set_tk_callback()
405 static bool rpc_sleep_check_activated(struct rpc_task *task) in rpc_sleep_check_activated() argument
407 /* We shouldn't ever put an inactive task to sleep */ in rpc_sleep_check_activated()
408 if (WARN_ON_ONCE(!RPC_IS_ACTIVATED(task))) { in rpc_sleep_check_activated()
409 task->tk_status = -EIO; in rpc_sleep_check_activated()
410 rpc_put_task_async(task); in rpc_sleep_check_activated()
416 void rpc_sleep_on_timeout(struct rpc_wait_queue *q, struct rpc_task *task, in rpc_sleep_on_timeout() argument
419 if (!rpc_sleep_check_activated(task)) in rpc_sleep_on_timeout()
422 rpc_set_tk_callback(task, action); in rpc_sleep_on_timeout()
428 __rpc_sleep_on_priority_timeout(q, task, timeout, task->tk_priority); in rpc_sleep_on_timeout()
433 void rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task, in rpc_sleep_on() argument
436 if (!rpc_sleep_check_activated(task)) in rpc_sleep_on()
439 rpc_set_tk_callback(task, action); in rpc_sleep_on()
441 WARN_ON_ONCE(task->tk_timeout != 0); in rpc_sleep_on()
446 __rpc_sleep_on_priority(q, task, task->tk_priority); in rpc_sleep_on()
452 struct rpc_task *task, unsigned long timeout, int priority) in rpc_sleep_on_priority_timeout() argument
454 if (!rpc_sleep_check_activated(task)) in rpc_sleep_on_priority_timeout()
462 __rpc_sleep_on_priority_timeout(q, task, timeout, priority); in rpc_sleep_on_priority_timeout()
467 void rpc_sleep_on_priority(struct rpc_wait_queue *q, struct rpc_task *task, in rpc_sleep_on_priority() argument
470 if (!rpc_sleep_check_activated(task)) in rpc_sleep_on_priority()
473 WARN_ON_ONCE(task->tk_timeout != 0); in rpc_sleep_on_priority()
479 __rpc_sleep_on_priority(q, task, priority); in rpc_sleep_on_priority()
486 * @wq: workqueue on which to run task
488 * @task: task to be woken up
490 * Caller must hold queue->lock, and have cleared the task queued flag.
494 struct rpc_task *task) in __rpc_do_wake_up_task_on_wq() argument
496 /* Has the task been executed yet? If not, we cannot wake it up! */ in __rpc_do_wake_up_task_on_wq()
497 if (!RPC_IS_ACTIVATED(task)) { in __rpc_do_wake_up_task_on_wq()
498 printk(KERN_ERR "RPC: Inactive task (%p) being woken up!\n", task); in __rpc_do_wake_up_task_on_wq()
502 trace_rpc_task_wakeup(task, queue); in __rpc_do_wake_up_task_on_wq()
504 __rpc_remove_wait_queue(queue, task); in __rpc_do_wake_up_task_on_wq()
506 rpc_make_runnable(wq, task); in __rpc_do_wake_up_task_on_wq()
510 * Wake up a queued task while the queue lock is being held
514 struct rpc_wait_queue *queue, struct rpc_task *task, in rpc_wake_up_task_on_wq_queue_action_locked() argument
517 if (RPC_IS_QUEUED(task)) { in rpc_wake_up_task_on_wq_queue_action_locked()
519 if (task->tk_waitqueue == queue) { in rpc_wake_up_task_on_wq_queue_action_locked()
520 if (action == NULL || action(task, data)) { in rpc_wake_up_task_on_wq_queue_action_locked()
521 __rpc_do_wake_up_task_on_wq(wq, queue, task); in rpc_wake_up_task_on_wq_queue_action_locked()
522 return task; in rpc_wake_up_task_on_wq_queue_action_locked()
530 * Wake up a queued task while the queue lock is being held
533 struct rpc_task *task) in rpc_wake_up_task_queue_locked() argument
536 task, NULL, NULL); in rpc_wake_up_task_queue_locked()
540 * Wake up a task on a specific queue
542 void rpc_wake_up_queued_task(struct rpc_wait_queue *queue, struct rpc_task *task) in rpc_wake_up_queued_task() argument
544 if (!RPC_IS_QUEUED(task)) in rpc_wake_up_queued_task()
547 rpc_wake_up_task_queue_locked(queue, task); in rpc_wake_up_queued_task()
552 static bool rpc_task_action_set_status(struct rpc_task *task, void *status) in rpc_task_action_set_status() argument
554 task->tk_status = *(int *)status; in rpc_task_action_set_status()
560 struct rpc_task *task, int status) in rpc_wake_up_task_queue_set_status_locked() argument
563 task, rpc_task_action_set_status, &status); in rpc_wake_up_task_queue_set_status_locked()
567 * rpc_wake_up_queued_task_set_status - wake up a task and set task->tk_status
569 * @task: pointer to rpc_task
572 * If @task is queued on @queue, then it is woken up, and @task->tk_status is
577 struct rpc_task *task, int status) in rpc_wake_up_queued_task_set_status() argument
579 if (!RPC_IS_QUEUED(task)) in rpc_wake_up_queued_task_set_status()
582 rpc_wake_up_task_queue_set_status_locked(queue, task, status); in rpc_wake_up_queued_task_set_status()
587 * Wake up the next task on a priority queue.
592 struct rpc_task *task; in __rpc_find_next_queued_priority() local
599 task = list_first_entry(q, struct rpc_task, u.tk_wait.list); in __rpc_find_next_queued_priority()
612 task = list_first_entry(q, struct rpc_task, u.tk_wait.list); in __rpc_find_next_queued_priority()
623 return task; in __rpc_find_next_queued_priority()
636 * Wake up the first task on the wait queue.
642 struct rpc_task *task = NULL; in rpc_wake_up_first_on_wq() local
645 task = __rpc_find_next_queued(queue); in rpc_wake_up_first_on_wq()
646 if (task != NULL) in rpc_wake_up_first_on_wq()
647 task = rpc_wake_up_task_on_wq_queue_action_locked(wq, queue, in rpc_wake_up_first_on_wq()
648 task, func, data); in rpc_wake_up_first_on_wq()
651 return task; in rpc_wake_up_first_on_wq()
655 * Wake up the first task on the wait queue.
664 static bool rpc_wake_up_next_func(struct rpc_task *task, void *data) in rpc_wake_up_next_func() argument
670 * Wake up the next task on the wait queue.
692 struct rpc_task *task; in rpc_wake_up() local
693 task = list_first_entry(head, in rpc_wake_up()
696 rpc_wake_up_task_queue_locked(queue, task); in rpc_wake_up()
721 struct rpc_task *task; in rpc_wake_up_status() local
722 task = list_first_entry(head, in rpc_wake_up_status()
725 task->tk_status = status; in rpc_wake_up_status()
726 rpc_wake_up_task_queue_locked(queue, task); in rpc_wake_up_status()
741 struct rpc_task *task, *n; in __rpc_queue_timer_fn() local
746 list_for_each_entry_safe(task, n, &queue->timer_list.list, u.tk_wait.timer_list) { in __rpc_queue_timer_fn()
747 timeo = task->tk_timeout; in __rpc_queue_timer_fn()
749 trace_rpc_task_timeout(task, task->tk_action); in __rpc_queue_timer_fn()
750 task->tk_status = -ETIMEDOUT; in __rpc_queue_timer_fn()
751 rpc_wake_up_task_queue_locked(queue, task); in __rpc_queue_timer_fn()
762 static void __rpc_atrun(struct rpc_task *task) in __rpc_atrun() argument
764 if (task->tk_status == -ETIMEDOUT) in __rpc_atrun()
765 task->tk_status = 0; in __rpc_atrun()
769 * Run a task at a later time
771 void rpc_delay(struct rpc_task *task, unsigned long delay) in rpc_delay() argument
773 rpc_sleep_on_timeout(&delay_queue, task, __rpc_atrun, jiffies + delay); in rpc_delay()
778 * Helper to call task->tk_ops->rpc_call_prepare
780 void rpc_prepare_task(struct rpc_task *task) in rpc_prepare_task() argument
782 task->tk_ops->rpc_call_prepare(task, task->tk_calldata); in rpc_prepare_task()
786 rpc_init_task_statistics(struct rpc_task *task) in rpc_init_task_statistics() argument
789 task->tk_garb_retry = 2; in rpc_init_task_statistics()
790 task->tk_cred_retry = 2; in rpc_init_task_statistics()
791 task->tk_rebind_retry = 2; in rpc_init_task_statistics()
794 task->tk_start = ktime_get(); in rpc_init_task_statistics()
798 rpc_reset_task_statistics(struct rpc_task *task) in rpc_reset_task_statistics() argument
800 task->tk_timeouts = 0; in rpc_reset_task_statistics()
801 task->tk_flags &= ~(RPC_CALL_MAJORSEEN|RPC_TASK_SENT); in rpc_reset_task_statistics()
802 rpc_init_task_statistics(task); in rpc_reset_task_statistics()
806 * Helper that calls task->tk_ops->rpc_call_done if it exists
808 void rpc_exit_task(struct rpc_task *task) in rpc_exit_task() argument
810 trace_rpc_task_end(task, task->tk_action); in rpc_exit_task()
811 task->tk_action = NULL; in rpc_exit_task()
812 if (task->tk_ops->rpc_count_stats) in rpc_exit_task()
813 task->tk_ops->rpc_count_stats(task, task->tk_calldata); in rpc_exit_task()
814 else if (task->tk_client) in rpc_exit_task()
815 rpc_count_iostats(task, task->tk_client->cl_metrics); in rpc_exit_task()
816 if (task->tk_ops->rpc_call_done != NULL) { in rpc_exit_task()
817 task->tk_ops->rpc_call_done(task, task->tk_calldata); in rpc_exit_task()
818 if (task->tk_action != NULL) { in rpc_exit_task()
820 xprt_release(task); in rpc_exit_task()
821 rpc_reset_task_statistics(task); in rpc_exit_task()
826 void rpc_signal_task(struct rpc_task *task) in rpc_signal_task() argument
830 if (!RPC_IS_ACTIVATED(task)) in rpc_signal_task()
833 trace_rpc_task_signalled(task, task->tk_action); in rpc_signal_task()
834 set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate); in rpc_signal_task()
836 queue = READ_ONCE(task->tk_waitqueue); in rpc_signal_task()
838 rpc_wake_up_queued_task_set_status(queue, task, -ERESTARTSYS); in rpc_signal_task()
841 void rpc_exit(struct rpc_task *task, int status) in rpc_exit() argument
843 task->tk_status = status; in rpc_exit()
844 task->tk_action = rpc_exit_task; in rpc_exit()
845 rpc_wake_up_queued_task(task->tk_waitqueue, task); in rpc_exit()
858 static void __rpc_execute(struct rpc_task *task) in __rpc_execute() argument
861 int task_is_async = RPC_IS_ASYNC(task); in __rpc_execute()
864 WARN_ON_ONCE(RPC_IS_QUEUED(task)); in __rpc_execute()
865 if (RPC_IS_QUEUED(task)) in __rpc_execute()
874 * tk_action may be NULL if the task has been killed. in __rpc_execute()
878 do_action = task->tk_action; in __rpc_execute()
879 if (task->tk_callback) { in __rpc_execute()
880 do_action = task->tk_callback; in __rpc_execute()
881 task->tk_callback = NULL; in __rpc_execute()
885 trace_rpc_task_run_action(task, do_action); in __rpc_execute()
886 do_action(task); in __rpc_execute()
889 * Lockless check for whether task is sleeping or not. in __rpc_execute()
891 if (!RPC_IS_QUEUED(task)) in __rpc_execute()
897 if (RPC_SIGNALLED(task)) { in __rpc_execute()
898 task->tk_rpc_status = -ERESTARTSYS; in __rpc_execute()
899 rpc_exit(task, -ERESTARTSYS); in __rpc_execute()
911 queue = task->tk_waitqueue; in __rpc_execute()
913 if (!RPC_IS_QUEUED(task)) { in __rpc_execute()
917 rpc_clear_running(task); in __rpc_execute()
922 /* sync task: sleep here */ in __rpc_execute()
923 trace_rpc_task_sync_sleep(task, task->tk_action); in __rpc_execute()
924 status = out_of_line_wait_on_bit(&task->tk_runstate, in __rpc_execute()
929 * When a sync task receives a signal, it exits with in __rpc_execute()
934 trace_rpc_task_signalled(task, task->tk_action); in __rpc_execute()
935 set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate); in __rpc_execute()
936 task->tk_rpc_status = -ERESTARTSYS; in __rpc_execute()
937 rpc_exit(task, -ERESTARTSYS); in __rpc_execute()
939 trace_rpc_task_sync_wake(task, task->tk_action); in __rpc_execute()
942 /* Release all resources associated with the task */ in __rpc_execute()
943 rpc_release_task(task); in __rpc_execute()
949 * This may be called recursively if e.g. an async NFS task updates
951 * NOTE: Upon exit of this function the task is guaranteed to be
953 * been called, so your task memory may have been freed.
955 void rpc_execute(struct rpc_task *task) in rpc_execute() argument
957 bool is_async = RPC_IS_ASYNC(task); in rpc_execute()
959 rpc_set_active(task); in rpc_execute()
960 rpc_make_runnable(rpciod_workqueue, task); in rpc_execute()
962 __rpc_execute(task); in rpc_execute()
975 * @task: RPC task
978 * RPC call and RPC reply that this task is being used for. When
990 int rpc_malloc(struct rpc_task *task) in rpc_malloc() argument
992 struct rpc_rqst *rqst = task->tk_rqstp; in rpc_malloc()
997 if (RPC_IS_SWAPPER(task)) in rpc_malloc()
1018 * @task: RPC task
1021 void rpc_free(struct rpc_task *task) in rpc_free() argument
1023 void *buffer = task->tk_rqstp->rq_buffer; in rpc_free()
1038 * Creation and deletion of RPC task structures
1040 static void rpc_init_task(struct rpc_task *task, const struct rpc_task_setup *task_setup_data) in rpc_init_task() argument
1042 memset(task, 0, sizeof(*task)); in rpc_init_task()
1043 atomic_set(&task->tk_count, 1); in rpc_init_task()
1044 task->tk_flags = task_setup_data->flags; in rpc_init_task()
1045 task->tk_ops = task_setup_data->callback_ops; in rpc_init_task()
1046 task->tk_calldata = task_setup_data->callback_data; in rpc_init_task()
1047 INIT_LIST_HEAD(&task->tk_task); in rpc_init_task()
1049 task->tk_priority = task_setup_data->priority - RPC_PRIORITY_LOW; in rpc_init_task()
1050 task->tk_owner = current->tgid; in rpc_init_task()
1053 task->tk_workqueue = task_setup_data->workqueue; in rpc_init_task()
1055 task->tk_xprt = rpc_task_get_xprt(task_setup_data->rpc_client, in rpc_init_task()
1058 task->tk_op_cred = get_rpccred(task_setup_data->rpc_op_cred); in rpc_init_task()
1060 if (task->tk_ops->rpc_call_prepare != NULL) in rpc_init_task()
1061 task->tk_action = rpc_prepare_task; in rpc_init_task()
1063 rpc_init_task_statistics(task); in rpc_init_task()
1073 * Create a new task for the specified client.
1077 struct rpc_task *task = setup_data->task; in rpc_new_task() local
1080 if (task == NULL) { in rpc_new_task()
1081 task = rpc_alloc_task(); in rpc_new_task()
1085 rpc_init_task(task, setup_data); in rpc_new_task()
1086 task->tk_flags |= flags; in rpc_new_task()
1087 return task; in rpc_new_task()
1091 * rpc_free_task - release rpc task and perform cleanups
1109 static void rpc_free_task(struct rpc_task *task) in rpc_free_task() argument
1111 unsigned short tk_flags = task->tk_flags; in rpc_free_task()
1113 put_rpccred(task->tk_op_cred); in rpc_free_task()
1114 rpc_release_calldata(task->tk_ops, task->tk_calldata); in rpc_free_task()
1117 mempool_free(task, rpc_task_mempool); in rpc_free_task()
1128 static void rpc_release_resources_task(struct rpc_task *task) in rpc_release_resources_task() argument
1130 xprt_release(task); in rpc_release_resources_task()
1131 if (task->tk_msg.rpc_cred) { in rpc_release_resources_task()
1132 if (!(task->tk_flags & RPC_TASK_CRED_NOREF)) in rpc_release_resources_task()
1133 put_cred(task->tk_msg.rpc_cred); in rpc_release_resources_task()
1134 task->tk_msg.rpc_cred = NULL; in rpc_release_resources_task()
1136 rpc_task_release_client(task); in rpc_release_resources_task()
1139 static void rpc_final_put_task(struct rpc_task *task, in rpc_final_put_task() argument
1143 INIT_WORK(&task->u.tk_work, rpc_async_release); in rpc_final_put_task()
1144 queue_work(q, &task->u.tk_work); in rpc_final_put_task()
1146 rpc_free_task(task); in rpc_final_put_task()
1149 static void rpc_do_put_task(struct rpc_task *task, struct workqueue_struct *q) in rpc_do_put_task() argument
1151 if (atomic_dec_and_test(&task->tk_count)) { in rpc_do_put_task()
1152 rpc_release_resources_task(task); in rpc_do_put_task()
1153 rpc_final_put_task(task, q); in rpc_do_put_task()
1157 void rpc_put_task(struct rpc_task *task) in rpc_put_task() argument
1159 rpc_do_put_task(task, NULL); in rpc_put_task()
1163 void rpc_put_task_async(struct rpc_task *task) in rpc_put_task_async() argument
1165 rpc_do_put_task(task, task->tk_workqueue); in rpc_put_task_async()
1169 static void rpc_release_task(struct rpc_task *task) in rpc_release_task() argument
1171 WARN_ON_ONCE(RPC_IS_QUEUED(task)); in rpc_release_task()
1173 rpc_release_resources_task(task); in rpc_release_task()
1177 * so it should be safe to use task->tk_count as a test for whether in rpc_release_task()
1180 if (atomic_read(&task->tk_count) != 1 + !RPC_IS_ASYNC(task)) { in rpc_release_task()
1181 /* Wake up anyone who may be waiting for task completion */ in rpc_release_task()
1182 if (!rpc_complete_task(task)) in rpc_release_task()
1185 if (!atomic_dec_and_test(&task->tk_count)) in rpc_release_task()
1188 rpc_final_put_task(task, task->tk_workqueue); in rpc_release_task()