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()
609 task = list_first_entry(q, struct rpc_task, u.tk_wait.list); in __rpc_find_next_queued_priority()
622 task = list_first_entry(q, struct rpc_task, u.tk_wait.list); in __rpc_find_next_queued_priority()
633 return task; in __rpc_find_next_queued_priority()
646 * Wake up the first task on the wait queue.
652 struct rpc_task *task = NULL; in rpc_wake_up_first_on_wq() local
655 task = __rpc_find_next_queued(queue); in rpc_wake_up_first_on_wq()
656 if (task != NULL) in rpc_wake_up_first_on_wq()
657 task = rpc_wake_up_task_on_wq_queue_action_locked(wq, queue, in rpc_wake_up_first_on_wq()
658 task, func, data); in rpc_wake_up_first_on_wq()
661 return task; in rpc_wake_up_first_on_wq()
665 * Wake up the first task on the wait queue.
674 static bool rpc_wake_up_next_func(struct rpc_task *task, void *data) in rpc_wake_up_next_func() argument
680 * Wake up the next task on the wait queue.
695 struct rpc_task *task; in rpc_wake_up_locked() local
698 task = __rpc_find_next_queued(queue); in rpc_wake_up_locked()
699 if (task == NULL) in rpc_wake_up_locked()
701 rpc_wake_up_task_queue_locked(queue, task); in rpc_wake_up_locked()
726 struct rpc_task *task; in rpc_wake_up_status_locked() local
729 task = __rpc_find_next_queued(queue); in rpc_wake_up_status_locked()
730 if (task == NULL) in rpc_wake_up_status_locked()
732 rpc_wake_up_task_queue_set_status_locked(queue, task, status); in rpc_wake_up_status_locked()
756 struct rpc_task *task, *n; in __rpc_queue_timer_fn() local
761 list_for_each_entry_safe(task, n, &queue->timer_list.list, u.tk_wait.timer_list) { in __rpc_queue_timer_fn()
762 timeo = task->tk_timeout; in __rpc_queue_timer_fn()
764 trace_rpc_task_timeout(task, task->tk_action); in __rpc_queue_timer_fn()
765 task->tk_status = -ETIMEDOUT; in __rpc_queue_timer_fn()
766 rpc_wake_up_task_queue_locked(queue, task); in __rpc_queue_timer_fn()
777 static void __rpc_atrun(struct rpc_task *task) in __rpc_atrun() argument
779 if (task->tk_status == -ETIMEDOUT) in __rpc_atrun()
780 task->tk_status = 0; in __rpc_atrun()
784 * Run a task at a later time
786 void rpc_delay(struct rpc_task *task, unsigned long delay) in rpc_delay() argument
788 rpc_sleep_on_timeout(&delay_queue, task, __rpc_atrun, jiffies + delay); in rpc_delay()
793 * Helper to call task->tk_ops->rpc_call_prepare
795 void rpc_prepare_task(struct rpc_task *task) in rpc_prepare_task() argument
797 task->tk_ops->rpc_call_prepare(task, task->tk_calldata); in rpc_prepare_task()
801 rpc_init_task_statistics(struct rpc_task *task) in rpc_init_task_statistics() argument
804 task->tk_garb_retry = 2; in rpc_init_task_statistics()
805 task->tk_cred_retry = 2; in rpc_init_task_statistics()
806 task->tk_rebind_retry = 2; in rpc_init_task_statistics()
809 task->tk_start = ktime_get(); in rpc_init_task_statistics()
813 rpc_reset_task_statistics(struct rpc_task *task) in rpc_reset_task_statistics() argument
815 task->tk_timeouts = 0; in rpc_reset_task_statistics()
816 task->tk_flags &= ~(RPC_CALL_MAJORSEEN|RPC_TASK_SENT); in rpc_reset_task_statistics()
817 rpc_init_task_statistics(task); in rpc_reset_task_statistics()
821 * Helper that calls task->tk_ops->rpc_call_done if it exists
823 void rpc_exit_task(struct rpc_task *task) in rpc_exit_task() argument
825 trace_rpc_task_end(task, task->tk_action); in rpc_exit_task()
826 task->tk_action = NULL; in rpc_exit_task()
827 if (task->tk_ops->rpc_count_stats) in rpc_exit_task()
828 task->tk_ops->rpc_count_stats(task, task->tk_calldata); in rpc_exit_task()
829 else if (task->tk_client) in rpc_exit_task()
830 rpc_count_iostats(task, task->tk_client->cl_metrics); in rpc_exit_task()
831 if (task->tk_ops->rpc_call_done != NULL) { in rpc_exit_task()
832 task->tk_ops->rpc_call_done(task, task->tk_calldata); in rpc_exit_task()
833 if (task->tk_action != NULL) { in rpc_exit_task()
835 xprt_release(task); in rpc_exit_task()
836 rpc_reset_task_statistics(task); in rpc_exit_task()
841 void rpc_signal_task(struct rpc_task *task) in rpc_signal_task() argument
845 if (!RPC_IS_ACTIVATED(task)) in rpc_signal_task()
848 trace_rpc_task_signalled(task, task->tk_action); in rpc_signal_task()
849 set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate); in rpc_signal_task()
851 queue = READ_ONCE(task->tk_waitqueue); in rpc_signal_task()
853 rpc_wake_up_queued_task_set_status(queue, task, -ERESTARTSYS); in rpc_signal_task()
856 void rpc_exit(struct rpc_task *task, int status) in rpc_exit() argument
858 task->tk_status = status; in rpc_exit()
859 task->tk_action = rpc_exit_task; in rpc_exit()
860 rpc_wake_up_queued_task(task->tk_waitqueue, task); in rpc_exit()
873 static void __rpc_execute(struct rpc_task *task) in __rpc_execute() argument
876 int task_is_async = RPC_IS_ASYNC(task); in __rpc_execute()
879 WARN_ON_ONCE(RPC_IS_QUEUED(task)); in __rpc_execute()
880 if (RPC_IS_QUEUED(task)) in __rpc_execute()
889 * tk_action may be NULL if the task has been killed. in __rpc_execute()
893 do_action = task->tk_action; in __rpc_execute()
894 if (task->tk_callback) { in __rpc_execute()
895 do_action = task->tk_callback; in __rpc_execute()
896 task->tk_callback = NULL; in __rpc_execute()
900 trace_rpc_task_run_action(task, do_action); in __rpc_execute()
901 do_action(task); in __rpc_execute()
904 * Lockless check for whether task is sleeping or not. in __rpc_execute()
906 if (!RPC_IS_QUEUED(task)) in __rpc_execute()
912 if (RPC_SIGNALLED(task)) { in __rpc_execute()
913 task->tk_rpc_status = -ERESTARTSYS; in __rpc_execute()
914 rpc_exit(task, -ERESTARTSYS); in __rpc_execute()
926 queue = task->tk_waitqueue; in __rpc_execute()
928 if (!RPC_IS_QUEUED(task)) { in __rpc_execute()
932 rpc_clear_running(task); in __rpc_execute()
937 /* sync task: sleep here */ in __rpc_execute()
938 trace_rpc_task_sync_sleep(task, task->tk_action); in __rpc_execute()
939 status = out_of_line_wait_on_bit(&task->tk_runstate, in __rpc_execute()
944 * When a sync task receives a signal, it exits with in __rpc_execute()
949 trace_rpc_task_signalled(task, task->tk_action); in __rpc_execute()
950 set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate); in __rpc_execute()
951 task->tk_rpc_status = -ERESTARTSYS; in __rpc_execute()
952 rpc_exit(task, -ERESTARTSYS); in __rpc_execute()
954 trace_rpc_task_sync_wake(task, task->tk_action); in __rpc_execute()
957 /* Release all resources associated with the task */ in __rpc_execute()
958 rpc_release_task(task); in __rpc_execute()
964 * This may be called recursively if e.g. an async NFS task updates
966 * NOTE: Upon exit of this function the task is guaranteed to be
968 * been called, so your task memory may have been freed.
970 void rpc_execute(struct rpc_task *task) in rpc_execute() argument
972 bool is_async = RPC_IS_ASYNC(task); in rpc_execute()
974 rpc_set_active(task); in rpc_execute()
975 rpc_make_runnable(rpciod_workqueue, task); in rpc_execute()
978 __rpc_execute(task); in rpc_execute()
993 * @task: RPC task
996 * RPC call and RPC reply that this task is being used for. When
1008 int rpc_malloc(struct rpc_task *task) in rpc_malloc() argument
1010 struct rpc_rqst *rqst = task->tk_rqstp; in rpc_malloc()
1015 if (RPC_IS_SWAPPER(task)) in rpc_malloc()
1036 * @task: RPC task
1039 void rpc_free(struct rpc_task *task) in rpc_free() argument
1041 void *buffer = task->tk_rqstp->rq_buffer; in rpc_free()
1056 * Creation and deletion of RPC task structures
1058 static void rpc_init_task(struct rpc_task *task, const struct rpc_task_setup *task_setup_data) in rpc_init_task() argument
1060 memset(task, 0, sizeof(*task)); in rpc_init_task()
1061 atomic_set(&task->tk_count, 1); in rpc_init_task()
1062 task->tk_flags = task_setup_data->flags; in rpc_init_task()
1063 task->tk_ops = task_setup_data->callback_ops; in rpc_init_task()
1064 task->tk_calldata = task_setup_data->callback_data; in rpc_init_task()
1065 INIT_LIST_HEAD(&task->tk_task); in rpc_init_task()
1067 task->tk_priority = task_setup_data->priority - RPC_PRIORITY_LOW; in rpc_init_task()
1068 task->tk_owner = current->tgid; in rpc_init_task()
1071 task->tk_workqueue = task_setup_data->workqueue; in rpc_init_task()
1073 task->tk_xprt = rpc_task_get_xprt(task_setup_data->rpc_client, in rpc_init_task()
1076 task->tk_op_cred = get_rpccred(task_setup_data->rpc_op_cred); in rpc_init_task()
1078 if (task->tk_ops->rpc_call_prepare != NULL) in rpc_init_task()
1079 task->tk_action = rpc_prepare_task; in rpc_init_task()
1081 rpc_init_task_statistics(task); in rpc_init_task()
1091 * Create a new task for the specified client.
1095 struct rpc_task *task = setup_data->task; in rpc_new_task() local
1098 if (task == NULL) { in rpc_new_task()
1099 task = rpc_alloc_task(); in rpc_new_task()
1103 rpc_init_task(task, setup_data); in rpc_new_task()
1104 task->tk_flags |= flags; in rpc_new_task()
1105 return task; in rpc_new_task()
1109 * rpc_free_task - release rpc task and perform cleanups
1127 static void rpc_free_task(struct rpc_task *task) in rpc_free_task() argument
1129 unsigned short tk_flags = task->tk_flags; in rpc_free_task()
1131 put_rpccred(task->tk_op_cred); in rpc_free_task()
1132 rpc_release_calldata(task->tk_ops, task->tk_calldata); in rpc_free_task()
1135 mempool_free(task, rpc_task_mempool); in rpc_free_task()
1146 static void rpc_release_resources_task(struct rpc_task *task) in rpc_release_resources_task() argument
1148 xprt_release(task); in rpc_release_resources_task()
1149 if (task->tk_msg.rpc_cred) { in rpc_release_resources_task()
1150 if (!(task->tk_flags & RPC_TASK_CRED_NOREF)) in rpc_release_resources_task()
1151 put_cred(task->tk_msg.rpc_cred); in rpc_release_resources_task()
1152 task->tk_msg.rpc_cred = NULL; in rpc_release_resources_task()
1154 rpc_task_release_client(task); in rpc_release_resources_task()
1157 static void rpc_final_put_task(struct rpc_task *task, in rpc_final_put_task() argument
1161 INIT_WORK(&task->u.tk_work, rpc_async_release); in rpc_final_put_task()
1162 queue_work(q, &task->u.tk_work); in rpc_final_put_task()
1164 rpc_free_task(task); in rpc_final_put_task()
1167 static void rpc_do_put_task(struct rpc_task *task, struct workqueue_struct *q) in rpc_do_put_task() argument
1169 if (atomic_dec_and_test(&task->tk_count)) { in rpc_do_put_task()
1170 rpc_release_resources_task(task); in rpc_do_put_task()
1171 rpc_final_put_task(task, q); in rpc_do_put_task()
1175 void rpc_put_task(struct rpc_task *task) in rpc_put_task() argument
1177 rpc_do_put_task(task, NULL); in rpc_put_task()
1181 void rpc_put_task_async(struct rpc_task *task) in rpc_put_task_async() argument
1183 rpc_do_put_task(task, task->tk_workqueue); in rpc_put_task_async()
1187 static void rpc_release_task(struct rpc_task *task) in rpc_release_task() argument
1189 WARN_ON_ONCE(RPC_IS_QUEUED(task)); in rpc_release_task()
1191 rpc_release_resources_task(task); in rpc_release_task()
1195 * so it should be safe to use task->tk_count as a test for whether in rpc_release_task()
1198 if (atomic_read(&task->tk_count) != 1 + !RPC_IS_ASYNC(task)) { in rpc_release_task()
1199 /* Wake up anyone who may be waiting for task completion */ in rpc_release_task()
1200 if (!rpc_complete_task(task)) in rpc_release_task()
1203 if (!atomic_dec_and_test(&task->tk_count)) in rpc_release_task()
1206 rpc_final_put_task(task, task->tk_workqueue); in rpc_release_task()