Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/net/sunrpc/sched.c
4 : : *
5 : : * Scheduling for synchronous and asynchronous RPC requests.
6 : : *
7 : : * Copyright (C) 1996 Olaf Kirch, <okir@monad.swb.de>
8 : : *
9 : : * TCP NFS related read + write fixes
10 : : * (C) 1999 Dave Airlie, University of Limerick, Ireland <airlied@linux.ie>
11 : : */
12 : :
13 : : #include <linux/module.h>
14 : :
15 : : #include <linux/sched.h>
16 : : #include <linux/interrupt.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/mempool.h>
19 : : #include <linux/smp.h>
20 : : #include <linux/spinlock.h>
21 : : #include <linux/mutex.h>
22 : : #include <linux/freezer.h>
23 : : #include <linux/sched/mm.h>
24 : :
25 : : #include <linux/sunrpc/clnt.h>
26 : : #include <linux/sunrpc/metrics.h>
27 : :
28 : : #include "sunrpc.h"
29 : :
30 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
31 : : #define RPCDBG_FACILITY RPCDBG_SCHED
32 : : #endif
33 : :
34 : : #define CREATE_TRACE_POINTS
35 : : #include <trace/events/sunrpc.h>
36 : :
37 : : /*
38 : : * RPC slabs and memory pools
39 : : */
40 : : #define RPC_BUFFER_MAXSIZE (2048)
41 : : #define RPC_BUFFER_POOLSIZE (8)
42 : : #define RPC_TASK_POOLSIZE (8)
43 : : static struct kmem_cache *rpc_task_slabp __read_mostly;
44 : : static struct kmem_cache *rpc_buffer_slabp __read_mostly;
45 : : static mempool_t *rpc_task_mempool __read_mostly;
46 : : static mempool_t *rpc_buffer_mempool __read_mostly;
47 : :
48 : : static void rpc_async_schedule(struct work_struct *);
49 : : static void rpc_release_task(struct rpc_task *task);
50 : : static void __rpc_queue_timer_fn(struct work_struct *);
51 : :
52 : : /*
53 : : * RPC tasks sit here while waiting for conditions to improve.
54 : : */
55 : : static struct rpc_wait_queue delay_queue;
56 : :
57 : : /*
58 : : * rpciod-related stuff
59 : : */
60 : : struct workqueue_struct *rpciod_workqueue __read_mostly;
61 : : struct workqueue_struct *xprtiod_workqueue __read_mostly;
62 : : EXPORT_SYMBOL_GPL(xprtiod_workqueue);
63 : :
64 : : unsigned long
65 : 0 : rpc_task_timeout(const struct rpc_task *task)
66 : : {
67 [ # # # # : 0 : unsigned long timeout = READ_ONCE(task->tk_timeout);
# # ]
68 : :
69 [ # # # # : 0 : if (timeout != 0) {
# # ]
70 : 0 : unsigned long now = jiffies;
71 [ # # # # : 0 : if (time_before(now, timeout))
# # ]
72 : 0 : return timeout - now;
73 : : }
74 : : return 0;
75 : : }
76 : : EXPORT_SYMBOL_GPL(rpc_task_timeout);
77 : :
78 : : /*
79 : : * Disable the timer for a given RPC task. Should be called with
80 : : * queue->lock and bh_disabled in order to avoid races within
81 : : * rpc_run_timer().
82 : : */
83 : : static void
84 : 0 : __rpc_disable_timer(struct rpc_wait_queue *queue, struct rpc_task *task)
85 : : {
86 [ # # ]: 0 : if (list_empty(&task->u.tk_wait.timer_list))
87 : : return;
88 : 0 : dprintk("RPC: %5u disabling timer\n", task->tk_pid);
89 : 0 : task->tk_timeout = 0;
90 [ # # ]: 0 : list_del(&task->u.tk_wait.timer_list);
91 [ # # ]: 0 : if (list_empty(&queue->timer_list.list))
92 : 0 : cancel_delayed_work(&queue->timer_list.dwork);
93 : : }
94 : :
95 : : static void
96 : 0 : rpc_set_queue_timer(struct rpc_wait_queue *queue, unsigned long expires)
97 : : {
98 : 0 : unsigned long now = jiffies;
99 : 0 : queue->timer_list.expires = expires;
100 [ # # ]: 0 : if (time_before_eq(expires, now))
101 : : expires = 0;
102 : : else
103 : 0 : expires -= now;
104 : 0 : mod_delayed_work(rpciod_workqueue, &queue->timer_list.dwork, expires);
105 : 0 : }
106 : :
107 : : /*
108 : : * Set up a timer for the current task.
109 : : */
110 : : static void
111 : 0 : __rpc_add_timer(struct rpc_wait_queue *queue, struct rpc_task *task,
112 : : unsigned long timeout)
113 : : {
114 : 0 : dprintk("RPC: %5u setting alarm for %u ms\n",
115 : : task->tk_pid, jiffies_to_msecs(timeout - jiffies));
116 : :
117 : 0 : task->tk_timeout = timeout;
118 [ # # # # ]: 0 : if (list_empty(&queue->timer_list.list) || time_before(timeout, queue->timer_list.expires))
119 : 0 : rpc_set_queue_timer(queue, timeout);
120 : 0 : list_add(&task->u.tk_wait.timer_list, &queue->timer_list.list);
121 : 0 : }
122 : :
123 : 42 : static void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int priority)
124 : : {
125 : 42 : if (queue->priority != priority) {
126 : 0 : queue->priority = priority;
127 : 0 : queue->nr = 1U << priority;
128 : : }
129 : : }
130 : :
131 : 42 : static void rpc_reset_waitqueue_priority(struct rpc_wait_queue *queue)
132 : : {
133 : 42 : rpc_set_waitqueue_priority(queue, queue->maxpriority);
134 : : }
135 : :
136 : : /*
137 : : * Add a request to a queue list
138 : : */
139 : : static void
140 : 0 : __rpc_list_enqueue_task(struct list_head *q, struct rpc_task *task)
141 : : {
142 : 0 : struct rpc_task *t;
143 : :
144 [ # # ]: 0 : list_for_each_entry(t, q, u.tk_wait.list) {
145 [ # # ]: 0 : if (t->tk_owner == task->tk_owner) {
146 : 0 : list_add_tail(&task->u.tk_wait.links,
147 : : &t->u.tk_wait.links);
148 : : /* Cache the queue head in task->u.tk_wait.list */
149 : 0 : task->u.tk_wait.list.next = q;
150 : 0 : task->u.tk_wait.list.prev = NULL;
151 : 0 : return;
152 : : }
153 : : }
154 : 0 : INIT_LIST_HEAD(&task->u.tk_wait.links);
155 : 0 : list_add_tail(&task->u.tk_wait.list, q);
156 : : }
157 : :
158 : : /*
159 : : * Remove request from a queue list
160 : : */
161 : : static void
162 : 0 : __rpc_list_dequeue_task(struct rpc_task *task)
163 : : {
164 : 0 : struct list_head *q;
165 : 0 : struct rpc_task *t;
166 : :
167 [ # # ]: 0 : if (task->u.tk_wait.list.prev == NULL) {
168 : 0 : list_del(&task->u.tk_wait.links);
169 : 0 : return;
170 : : }
171 [ # # ]: 0 : if (!list_empty(&task->u.tk_wait.links)) {
172 : 0 : t = list_first_entry(&task->u.tk_wait.links,
173 : : struct rpc_task,
174 : : u.tk_wait.links);
175 : : /* Assume __rpc_list_enqueue_task() cached the queue head */
176 : 0 : q = t->u.tk_wait.list.next;
177 : 0 : list_add_tail(&t->u.tk_wait.list, q);
178 : 0 : list_del(&task->u.tk_wait.links);
179 : : }
180 : 0 : list_del(&task->u.tk_wait.list);
181 : : }
182 : :
183 : : /*
184 : : * Add new request to a priority queue.
185 : : */
186 : 0 : static void __rpc_add_wait_queue_priority(struct rpc_wait_queue *queue,
187 : : struct rpc_task *task,
188 : : unsigned char queue_priority)
189 : : {
190 : 0 : if (unlikely(queue_priority > queue->maxpriority))
191 : 0 : queue_priority = queue->maxpriority;
192 : 0 : __rpc_list_enqueue_task(&queue->tasks[queue_priority], task);
193 : 0 : }
194 : :
195 : : /*
196 : : * Add new request to wait queue.
197 : : *
198 : : * Swapper tasks always get inserted at the head of the queue.
199 : : * This should avoid many nasty memory deadlocks and hopefully
200 : : * improve overall performance.
201 : : * Everyone else gets appended to the queue to ensure proper FIFO behavior.
202 : : */
203 : 0 : static void __rpc_add_wait_queue(struct rpc_wait_queue *queue,
204 : : struct rpc_task *task,
205 : : unsigned char queue_priority)
206 : : {
207 : 0 : WARN_ON_ONCE(RPC_IS_QUEUED(task));
208 [ # # ]: 0 : if (RPC_IS_QUEUED(task))
209 : : return;
210 : :
211 [ # # ]: 0 : INIT_LIST_HEAD(&task->u.tk_wait.timer_list);
212 [ # # ]: 0 : if (RPC_IS_PRIORITY(queue))
213 [ # # ]: 0 : __rpc_add_wait_queue_priority(queue, task, queue_priority);
214 [ # # ]: 0 : else if (RPC_IS_SWAPPER(task))
215 : 0 : list_add(&task->u.tk_wait.list, &queue->tasks[0]);
216 : : else
217 : 0 : list_add_tail(&task->u.tk_wait.list, &queue->tasks[0]);
218 : 0 : task->tk_waitqueue = queue;
219 : 0 : queue->qlen++;
220 : : /* barrier matches the read in rpc_wake_up_task_queue_locked() */
221 : 0 : smp_wmb();
222 : 0 : rpc_set_queued(task);
223 : :
224 : 0 : dprintk("RPC: %5u added to queue %p \"%s\"\n",
225 : : task->tk_pid, queue, rpc_qname(queue));
226 : : }
227 : :
228 : : /*
229 : : * Remove request from a priority queue.
230 : : */
231 : 0 : static void __rpc_remove_wait_queue_priority(struct rpc_task *task)
232 : : {
233 : 0 : __rpc_list_dequeue_task(task);
234 : 0 : }
235 : :
236 : : /*
237 : : * Remove request from queue.
238 : : * Note: must be called with spin lock held.
239 : : */
240 : 0 : static void __rpc_remove_wait_queue(struct rpc_wait_queue *queue, struct rpc_task *task)
241 : : {
242 : 0 : __rpc_disable_timer(queue, task);
243 [ # # ]: 0 : if (RPC_IS_PRIORITY(queue))
244 : 0 : __rpc_remove_wait_queue_priority(task);
245 : : else
246 : 0 : list_del(&task->u.tk_wait.list);
247 : 0 : queue->qlen--;
248 : 0 : dprintk("RPC: %5u removed from queue %p \"%s\"\n",
249 : : task->tk_pid, queue, rpc_qname(queue));
250 : 0 : }
251 : :
252 : 42 : static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname, unsigned char nr_queues)
253 : : {
254 : 42 : int i;
255 : :
256 : 42 : spin_lock_init(&queue->lock);
257 [ + + ]: 210 : for (i = 0; i < ARRAY_SIZE(queue->tasks); i++)
258 : 168 : INIT_LIST_HEAD(&queue->tasks[i]);
259 : 42 : queue->maxpriority = nr_queues - 1;
260 [ - + ]: 42 : rpc_reset_waitqueue_priority(queue);
261 : 42 : queue->qlen = 0;
262 : 42 : queue->timer_list.expires = 0;
263 : 42 : INIT_DELAYED_WORK(&queue->timer_list.dwork, __rpc_queue_timer_fn);
264 : 42 : INIT_LIST_HEAD(&queue->timer_list.list);
265 : 42 : rpc_assign_waitqueue_name(queue, qname);
266 : 42 : }
267 : :
268 : 0 : void rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname)
269 : : {
270 : 0 : __rpc_init_priority_wait_queue(queue, qname, RPC_NR_PRIORITY);
271 : 0 : }
272 : : EXPORT_SYMBOL_GPL(rpc_init_priority_wait_queue);
273 : :
274 : 42 : void rpc_init_wait_queue(struct rpc_wait_queue *queue, const char *qname)
275 : : {
276 : 21 : __rpc_init_priority_wait_queue(queue, qname, 1);
277 : 21 : }
278 : : EXPORT_SYMBOL_GPL(rpc_init_wait_queue);
279 : :
280 : 0 : void rpc_destroy_wait_queue(struct rpc_wait_queue *queue)
281 : : {
282 : 0 : cancel_delayed_work_sync(&queue->timer_list.dwork);
283 : 0 : }
284 : : EXPORT_SYMBOL_GPL(rpc_destroy_wait_queue);
285 : :
286 : 0 : static int rpc_wait_bit_killable(struct wait_bit_key *key, int mode)
287 : : {
288 : 0 : freezable_schedule_unsafe();
289 [ # # ]: 0 : if (signal_pending_state(mode, current))
290 : 0 : return -ERESTARTSYS;
291 : : return 0;
292 : : }
293 : :
294 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
295 : 0 : static void rpc_task_set_debuginfo(struct rpc_task *task)
296 : : {
297 : 0 : static atomic_t rpc_pid;
298 : :
299 : 0 : task->tk_pid = atomic_inc_return(&rpc_pid);
300 : : }
301 : : #else
302 : : static inline void rpc_task_set_debuginfo(struct rpc_task *task)
303 : : {
304 : : }
305 : : #endif
306 : :
307 : 0 : static void rpc_set_active(struct rpc_task *task)
308 : : {
309 : 0 : rpc_task_set_debuginfo(task);
310 : 0 : set_bit(RPC_TASK_ACTIVE, &task->tk_runstate);
311 : 0 : trace_rpc_task_begin(task, NULL);
312 : 0 : }
313 : :
314 : : /*
315 : : * Mark an RPC call as having completed by clearing the 'active' bit
316 : : * and then waking up all tasks that were sleeping.
317 : : */
318 : 0 : static int rpc_complete_task(struct rpc_task *task)
319 : : {
320 : 0 : void *m = &task->tk_runstate;
321 : 0 : wait_queue_head_t *wq = bit_waitqueue(m, RPC_TASK_ACTIVE);
322 : 0 : struct wait_bit_key k = __WAIT_BIT_KEY_INITIALIZER(m, RPC_TASK_ACTIVE);
323 : 0 : unsigned long flags;
324 : 0 : int ret;
325 : :
326 : 0 : trace_rpc_task_complete(task, NULL);
327 : :
328 : 0 : spin_lock_irqsave(&wq->lock, flags);
329 : 0 : clear_bit(RPC_TASK_ACTIVE, &task->tk_runstate);
330 : 0 : ret = atomic_dec_and_test(&task->tk_count);
331 [ # # ]: 0 : if (waitqueue_active(wq))
332 : 0 : __wake_up_locked_key(wq, TASK_NORMAL, &k);
333 : 0 : spin_unlock_irqrestore(&wq->lock, flags);
334 : 0 : return ret;
335 : : }
336 : :
337 : : /*
338 : : * Allow callers to wait for completion of an RPC call
339 : : *
340 : : * Note the use of out_of_line_wait_on_bit() rather than wait_on_bit()
341 : : * to enforce taking of the wq->lock and hence avoid races with
342 : : * rpc_complete_task().
343 : : */
344 : 0 : int __rpc_wait_for_completion_task(struct rpc_task *task, wait_bit_action_f *action)
345 : : {
346 [ # # ]: 0 : if (action == NULL)
347 : 0 : action = rpc_wait_bit_killable;
348 : 0 : return out_of_line_wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE,
349 : : action, TASK_KILLABLE);
350 : : }
351 : : EXPORT_SYMBOL_GPL(__rpc_wait_for_completion_task);
352 : :
353 : : /*
354 : : * Make an RPC task runnable.
355 : : *
356 : : * Note: If the task is ASYNC, and is being made runnable after sitting on an
357 : : * rpc_wait_queue, this must be called with the queue spinlock held to protect
358 : : * the wait queue operation.
359 : : * Note the ordering of rpc_test_and_set_running() and rpc_clear_queued(),
360 : : * which is needed to ensure that __rpc_execute() doesn't loop (due to the
361 : : * lockless RPC_IS_QUEUED() test) before we've had a chance to test
362 : : * the RPC_TASK_RUNNING flag.
363 : : */
364 : 0 : static void rpc_make_runnable(struct workqueue_struct *wq,
365 : : struct rpc_task *task)
366 : : {
367 : 0 : bool need_wakeup = !rpc_test_and_set_running(task);
368 : :
369 : 0 : rpc_clear_queued(task);
370 [ # # ]: 0 : if (!need_wakeup)
371 : : return;
372 [ # # ]: 0 : if (RPC_IS_ASYNC(task)) {
373 : 0 : INIT_WORK(&task->u.tk_work, rpc_async_schedule);
374 : 0 : queue_work(wq, &task->u.tk_work);
375 : : } else
376 : 0 : wake_up_bit(&task->tk_runstate, RPC_TASK_QUEUED);
377 : : }
378 : :
379 : : /*
380 : : * Prepare for sleeping on a wait queue.
381 : : * By always appending tasks to the list we ensure FIFO behavior.
382 : : * NB: An RPC task will only receive interrupt-driven events as long
383 : : * as it's on a wait queue.
384 : : */
385 : 0 : static void __rpc_sleep_on_priority(struct rpc_wait_queue *q,
386 : : struct rpc_task *task,
387 : : unsigned char queue_priority)
388 : : {
389 : 0 : dprintk("RPC: %5u sleep_on(queue \"%s\" time %lu)\n",
390 : : task->tk_pid, rpc_qname(q), jiffies);
391 : :
392 : 0 : trace_rpc_task_sleep(task, q);
393 : :
394 : 0 : __rpc_add_wait_queue(q, task, queue_priority);
395 : :
396 : : }
397 : :
398 : 0 : static void __rpc_sleep_on_priority_timeout(struct rpc_wait_queue *q,
399 : : struct rpc_task *task, unsigned long timeout,
400 : : unsigned char queue_priority)
401 : : {
402 [ # # ]: 0 : if (time_is_after_jiffies(timeout)) {
403 : 0 : __rpc_sleep_on_priority(q, task, queue_priority);
404 : 0 : __rpc_add_timer(q, task, timeout);
405 : : } else
406 : 0 : task->tk_status = -ETIMEDOUT;
407 : 0 : }
408 : :
409 : 0 : static void rpc_set_tk_callback(struct rpc_task *task, rpc_action action)
410 : : {
411 [ # # # # : 0 : if (action && !WARN_ON_ONCE(task->tk_callback != NULL))
# # # # ]
412 : 0 : task->tk_callback = action;
413 : : }
414 : :
415 : 0 : static bool rpc_sleep_check_activated(struct rpc_task *task)
416 : : {
417 : : /* We shouldn't ever put an inactive task to sleep */
418 [ # # # # ]: 0 : if (WARN_ON_ONCE(!RPC_IS_ACTIVATED(task))) {
419 : 0 : task->tk_status = -EIO;
420 : 0 : rpc_put_task_async(task);
421 : 0 : return false;
422 : : }
423 : : return true;
424 : : }
425 : :
426 : 0 : void rpc_sleep_on_timeout(struct rpc_wait_queue *q, struct rpc_task *task,
427 : : rpc_action action, unsigned long timeout)
428 : : {
429 [ # # ]: 0 : if (!rpc_sleep_check_activated(task))
430 : : return;
431 : :
432 [ # # ]: 0 : rpc_set_tk_callback(task, action);
433 : :
434 : : /*
435 : : * Protect the queue operations.
436 : : */
437 : 0 : spin_lock(&q->lock);
438 : 0 : __rpc_sleep_on_priority_timeout(q, task, timeout, task->tk_priority);
439 : 0 : spin_unlock(&q->lock);
440 : : }
441 : : EXPORT_SYMBOL_GPL(rpc_sleep_on_timeout);
442 : :
443 : 0 : void rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task,
444 : : rpc_action action)
445 : : {
446 [ # # ]: 0 : if (!rpc_sleep_check_activated(task))
447 : : return;
448 : :
449 [ # # ]: 0 : rpc_set_tk_callback(task, action);
450 : :
451 [ # # ]: 0 : WARN_ON_ONCE(task->tk_timeout != 0);
452 : : /*
453 : : * Protect the queue operations.
454 : : */
455 : 0 : spin_lock(&q->lock);
456 : 0 : __rpc_sleep_on_priority(q, task, task->tk_priority);
457 : 0 : spin_unlock(&q->lock);
458 : : }
459 : : EXPORT_SYMBOL_GPL(rpc_sleep_on);
460 : :
461 : 0 : void rpc_sleep_on_priority_timeout(struct rpc_wait_queue *q,
462 : : struct rpc_task *task, unsigned long timeout, int priority)
463 : : {
464 [ # # ]: 0 : if (!rpc_sleep_check_activated(task))
465 : : return;
466 : :
467 : 0 : priority -= RPC_PRIORITY_LOW;
468 : : /*
469 : : * Protect the queue operations.
470 : : */
471 : 0 : spin_lock(&q->lock);
472 : 0 : __rpc_sleep_on_priority_timeout(q, task, timeout, priority);
473 : 0 : spin_unlock(&q->lock);
474 : : }
475 : : EXPORT_SYMBOL_GPL(rpc_sleep_on_priority_timeout);
476 : :
477 : 0 : void rpc_sleep_on_priority(struct rpc_wait_queue *q, struct rpc_task *task,
478 : : int priority)
479 : : {
480 [ # # ]: 0 : if (!rpc_sleep_check_activated(task))
481 : : return;
482 : :
483 [ # # ]: 0 : WARN_ON_ONCE(task->tk_timeout != 0);
484 : 0 : priority -= RPC_PRIORITY_LOW;
485 : : /*
486 : : * Protect the queue operations.
487 : : */
488 : 0 : spin_lock(&q->lock);
489 : 0 : __rpc_sleep_on_priority(q, task, priority);
490 : 0 : spin_unlock(&q->lock);
491 : : }
492 : : EXPORT_SYMBOL_GPL(rpc_sleep_on_priority);
493 : :
494 : : /**
495 : : * __rpc_do_wake_up_task_on_wq - wake up a single rpc_task
496 : : * @wq: workqueue on which to run task
497 : : * @queue: wait queue
498 : : * @task: task to be woken up
499 : : *
500 : : * Caller must hold queue->lock, and have cleared the task queued flag.
501 : : */
502 : 0 : static void __rpc_do_wake_up_task_on_wq(struct workqueue_struct *wq,
503 : : struct rpc_wait_queue *queue,
504 : : struct rpc_task *task)
505 : : {
506 : 0 : dprintk("RPC: %5u __rpc_wake_up_task (now %lu)\n",
507 : : task->tk_pid, jiffies);
508 : :
509 : : /* Has the task been executed yet? If not, we cannot wake it up! */
510 [ # # ]: 0 : if (!RPC_IS_ACTIVATED(task)) {
511 : 0 : printk(KERN_ERR "RPC: Inactive task (%p) being woken up!\n", task);
512 : 0 : return;
513 : : }
514 : :
515 : 0 : trace_rpc_task_wakeup(task, queue);
516 : :
517 : 0 : __rpc_remove_wait_queue(queue, task);
518 : :
519 : 0 : rpc_make_runnable(wq, task);
520 : :
521 : 0 : dprintk("RPC: __rpc_wake_up_task done\n");
522 : : }
523 : :
524 : : /*
525 : : * Wake up a queued task while the queue lock is being held
526 : : */
527 : : static struct rpc_task *
528 : 0 : rpc_wake_up_task_on_wq_queue_action_locked(struct workqueue_struct *wq,
529 : : struct rpc_wait_queue *queue, struct rpc_task *task,
530 : : bool (*action)(struct rpc_task *, void *), void *data)
531 : : {
532 [ # # ]: 0 : if (RPC_IS_QUEUED(task)) {
533 : 0 : smp_rmb();
534 [ # # ]: 0 : if (task->tk_waitqueue == queue) {
535 [ # # # # ]: 0 : if (action == NULL || action(task, data)) {
536 : 0 : __rpc_do_wake_up_task_on_wq(wq, queue, task);
537 : 0 : return task;
538 : : }
539 : : }
540 : : }
541 : : return NULL;
542 : : }
543 : :
544 : : /*
545 : : * Wake up a queued task while the queue lock is being held
546 : : */
547 : 0 : static void rpc_wake_up_task_queue_locked(struct rpc_wait_queue *queue,
548 : : struct rpc_task *task)
549 : : {
550 : 0 : rpc_wake_up_task_on_wq_queue_action_locked(rpciod_workqueue, queue,
551 : : task, NULL, NULL);
552 : 0 : }
553 : :
554 : : /*
555 : : * Wake up a task on a specific queue
556 : : */
557 : 0 : void rpc_wake_up_queued_task(struct rpc_wait_queue *queue, struct rpc_task *task)
558 : : {
559 [ # # ]: 0 : if (!RPC_IS_QUEUED(task))
560 : : return;
561 : 0 : spin_lock(&queue->lock);
562 : 0 : rpc_wake_up_task_queue_locked(queue, task);
563 : 0 : spin_unlock(&queue->lock);
564 : : }
565 : : EXPORT_SYMBOL_GPL(rpc_wake_up_queued_task);
566 : :
567 : 0 : static bool rpc_task_action_set_status(struct rpc_task *task, void *status)
568 : : {
569 : 0 : task->tk_status = *(int *)status;
570 : 0 : return true;
571 : : }
572 : :
573 : : static void
574 : 0 : rpc_wake_up_task_queue_set_status_locked(struct rpc_wait_queue *queue,
575 : : struct rpc_task *task, int status)
576 : : {
577 : 0 : rpc_wake_up_task_on_wq_queue_action_locked(rpciod_workqueue, queue,
578 : : task, rpc_task_action_set_status, &status);
579 : : }
580 : :
581 : : /**
582 : : * rpc_wake_up_queued_task_set_status - wake up a task and set task->tk_status
583 : : * @queue: pointer to rpc_wait_queue
584 : : * @task: pointer to rpc_task
585 : : * @status: integer error value
586 : : *
587 : : * If @task is queued on @queue, then it is woken up, and @task->tk_status is
588 : : * set to the value of @status.
589 : : */
590 : : void
591 : 0 : rpc_wake_up_queued_task_set_status(struct rpc_wait_queue *queue,
592 : : struct rpc_task *task, int status)
593 : : {
594 [ # # ]: 0 : if (!RPC_IS_QUEUED(task))
595 : : return;
596 : 0 : spin_lock(&queue->lock);
597 : 0 : rpc_wake_up_task_queue_set_status_locked(queue, task, status);
598 : 0 : spin_unlock(&queue->lock);
599 : : }
600 : :
601 : : /*
602 : : * Wake up the next task on a priority queue.
603 : : */
604 : 0 : static struct rpc_task *__rpc_find_next_queued_priority(struct rpc_wait_queue *queue)
605 : : {
606 : 0 : struct list_head *q;
607 : 0 : struct rpc_task *task;
608 : :
609 : : /*
610 : : * Service a batch of tasks from a single owner.
611 : : */
612 : 0 : q = &queue->tasks[queue->priority];
613 [ # # # # ]: 0 : if (!list_empty(q) && --queue->nr) {
614 : 0 : task = list_first_entry(q, struct rpc_task, u.tk_wait.list);
615 : 0 : goto out;
616 : : }
617 : :
618 : : /*
619 : : * Service the next queue.
620 : : */
621 : 0 : do {
622 [ # # ]: 0 : if (q == &queue->tasks[0])
623 : 0 : q = &queue->tasks[queue->maxpriority];
624 : : else
625 : 0 : q = q - 1;
626 [ # # ]: 0 : if (!list_empty(q)) {
627 : 0 : task = list_first_entry(q, struct rpc_task, u.tk_wait.list);
628 : 0 : goto new_queue;
629 : : }
630 [ # # ]: 0 : } while (q != &queue->tasks[queue->priority]);
631 : :
632 [ # # ]: 0 : rpc_reset_waitqueue_priority(queue);
633 : : return NULL;
634 : :
635 : : new_queue:
636 [ # # ]: 0 : rpc_set_waitqueue_priority(queue, (unsigned int)(q - &queue->tasks[0]));
637 : : out:
638 : : return task;
639 : : }
640 : :
641 : 0 : static struct rpc_task *__rpc_find_next_queued(struct rpc_wait_queue *queue)
642 : : {
643 : 0 : if (RPC_IS_PRIORITY(queue))
644 : 0 : return __rpc_find_next_queued_priority(queue);
645 [ # # ]: 0 : if (!list_empty(&queue->tasks[0]))
646 : 0 : return list_first_entry(&queue->tasks[0], struct rpc_task, u.tk_wait.list);
647 : : return NULL;
648 : : }
649 : :
650 : : /*
651 : : * Wake up the first task on the wait queue.
652 : : */
653 : 0 : struct rpc_task *rpc_wake_up_first_on_wq(struct workqueue_struct *wq,
654 : : struct rpc_wait_queue *queue,
655 : : bool (*func)(struct rpc_task *, void *), void *data)
656 : : {
657 : 0 : struct rpc_task *task = NULL;
658 : :
659 : 0 : dprintk("RPC: wake_up_first(%p \"%s\")\n",
660 : : queue, rpc_qname(queue));
661 : 0 : spin_lock(&queue->lock);
662 [ # # ]: 0 : task = __rpc_find_next_queued(queue);
663 [ # # ]: 0 : if (task != NULL)
664 : 0 : task = rpc_wake_up_task_on_wq_queue_action_locked(wq, queue,
665 : : task, func, data);
666 : 0 : spin_unlock(&queue->lock);
667 : :
668 : 0 : return task;
669 : : }
670 : :
671 : : /*
672 : : * Wake up the first task on the wait queue.
673 : : */
674 : 0 : struct rpc_task *rpc_wake_up_first(struct rpc_wait_queue *queue,
675 : : bool (*func)(struct rpc_task *, void *), void *data)
676 : : {
677 : 0 : return rpc_wake_up_first_on_wq(rpciod_workqueue, queue, func, data);
678 : : }
679 : : EXPORT_SYMBOL_GPL(rpc_wake_up_first);
680 : :
681 : 0 : static bool rpc_wake_up_next_func(struct rpc_task *task, void *data)
682 : : {
683 : 0 : return true;
684 : : }
685 : :
686 : : /*
687 : : * Wake up the next task on the wait queue.
688 : : */
689 : 0 : struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *queue)
690 : : {
691 : 0 : return rpc_wake_up_first(queue, rpc_wake_up_next_func, NULL);
692 : : }
693 : : EXPORT_SYMBOL_GPL(rpc_wake_up_next);
694 : :
695 : : /**
696 : : * rpc_wake_up - wake up all rpc_tasks
697 : : * @queue: rpc_wait_queue on which the tasks are sleeping
698 : : *
699 : : * Grabs queue->lock
700 : : */
701 : 0 : void rpc_wake_up(struct rpc_wait_queue *queue)
702 : : {
703 : 0 : struct list_head *head;
704 : :
705 : 0 : spin_lock(&queue->lock);
706 : 0 : head = &queue->tasks[queue->maxpriority];
707 : 0 : for (;;) {
708 [ # # ]: 0 : while (!list_empty(head)) {
709 : 0 : struct rpc_task *task;
710 : 0 : task = list_first_entry(head,
711 : : struct rpc_task,
712 : : u.tk_wait.list);
713 : 0 : rpc_wake_up_task_queue_locked(queue, task);
714 : : }
715 [ # # ]: 0 : if (head == &queue->tasks[0])
716 : : break;
717 : 0 : head--;
718 : : }
719 : 0 : spin_unlock(&queue->lock);
720 : 0 : }
721 : : EXPORT_SYMBOL_GPL(rpc_wake_up);
722 : :
723 : : /**
724 : : * rpc_wake_up_status - wake up all rpc_tasks and set their status value.
725 : : * @queue: rpc_wait_queue on which the tasks are sleeping
726 : : * @status: status value to set
727 : : *
728 : : * Grabs queue->lock
729 : : */
730 : 0 : void rpc_wake_up_status(struct rpc_wait_queue *queue, int status)
731 : : {
732 : 0 : struct list_head *head;
733 : :
734 : 0 : spin_lock(&queue->lock);
735 : 0 : head = &queue->tasks[queue->maxpriority];
736 : 0 : for (;;) {
737 [ # # ]: 0 : while (!list_empty(head)) {
738 : 0 : struct rpc_task *task;
739 : 0 : task = list_first_entry(head,
740 : : struct rpc_task,
741 : : u.tk_wait.list);
742 : 0 : task->tk_status = status;
743 : 0 : rpc_wake_up_task_queue_locked(queue, task);
744 : : }
745 [ # # ]: 0 : if (head == &queue->tasks[0])
746 : : break;
747 : 0 : head--;
748 : : }
749 : 0 : spin_unlock(&queue->lock);
750 : 0 : }
751 : : EXPORT_SYMBOL_GPL(rpc_wake_up_status);
752 : :
753 : 0 : static void __rpc_queue_timer_fn(struct work_struct *work)
754 : : {
755 : 0 : struct rpc_wait_queue *queue = container_of(work,
756 : : struct rpc_wait_queue,
757 : : timer_list.dwork.work);
758 : 0 : struct rpc_task *task, *n;
759 : 0 : unsigned long expires, now, timeo;
760 : :
761 : 0 : spin_lock(&queue->lock);
762 : 0 : expires = now = jiffies;
763 [ # # ]: 0 : list_for_each_entry_safe(task, n, &queue->timer_list.list, u.tk_wait.timer_list) {
764 : 0 : timeo = task->tk_timeout;
765 [ # # ]: 0 : if (time_after_eq(now, timeo)) {
766 : 0 : dprintk("RPC: %5u timeout\n", task->tk_pid);
767 : 0 : task->tk_status = -ETIMEDOUT;
768 : 0 : rpc_wake_up_task_queue_locked(queue, task);
769 : 0 : continue;
770 : : }
771 [ # # # # ]: 0 : if (expires == now || time_after(expires, timeo))
772 : : expires = timeo;
773 : : }
774 [ # # ]: 0 : if (!list_empty(&queue->timer_list.list))
775 : 0 : rpc_set_queue_timer(queue, expires);
776 : 0 : spin_unlock(&queue->lock);
777 : 0 : }
778 : :
779 : 0 : static void __rpc_atrun(struct rpc_task *task)
780 : : {
781 [ # # ]: 0 : if (task->tk_status == -ETIMEDOUT)
782 : 0 : task->tk_status = 0;
783 : 0 : }
784 : :
785 : : /*
786 : : * Run a task at a later time
787 : : */
788 : 0 : void rpc_delay(struct rpc_task *task, unsigned long delay)
789 : : {
790 : 0 : rpc_sleep_on_timeout(&delay_queue, task, __rpc_atrun, jiffies + delay);
791 : 0 : }
792 : : EXPORT_SYMBOL_GPL(rpc_delay);
793 : :
794 : : /*
795 : : * Helper to call task->tk_ops->rpc_call_prepare
796 : : */
797 : 0 : void rpc_prepare_task(struct rpc_task *task)
798 : : {
799 : 0 : task->tk_ops->rpc_call_prepare(task, task->tk_calldata);
800 : 0 : }
801 : :
802 : : static void
803 : 0 : rpc_init_task_statistics(struct rpc_task *task)
804 : : {
805 : : /* Initialize retry counters */
806 : 0 : task->tk_garb_retry = 2;
807 : 0 : task->tk_cred_retry = 2;
808 : 0 : task->tk_rebind_retry = 2;
809 : :
810 : : /* starting timestamp */
811 : 0 : task->tk_start = ktime_get();
812 : : }
813 : :
814 : : static void
815 : 0 : rpc_reset_task_statistics(struct rpc_task *task)
816 : : {
817 : 0 : task->tk_timeouts = 0;
818 : 0 : task->tk_flags &= ~(RPC_CALL_MAJORSEEN|RPC_TASK_SENT);
819 : 0 : rpc_init_task_statistics(task);
820 : 0 : }
821 : :
822 : : /*
823 : : * Helper that calls task->tk_ops->rpc_call_done if it exists
824 : : */
825 : 0 : void rpc_exit_task(struct rpc_task *task)
826 : : {
827 : 0 : trace_rpc_task_end(task, task->tk_action);
828 : 0 : task->tk_action = NULL;
829 [ # # ]: 0 : if (task->tk_ops->rpc_count_stats)
830 : 0 : task->tk_ops->rpc_count_stats(task, task->tk_calldata);
831 [ # # ]: 0 : else if (task->tk_client)
832 : 0 : rpc_count_iostats(task, task->tk_client->cl_metrics);
833 [ # # ]: 0 : if (task->tk_ops->rpc_call_done != NULL) {
834 : 0 : task->tk_ops->rpc_call_done(task, task->tk_calldata);
835 [ # # ]: 0 : if (task->tk_action != NULL) {
836 : : /* Always release the RPC slot and buffer memory */
837 : 0 : xprt_release(task);
838 : 0 : rpc_reset_task_statistics(task);
839 : : }
840 : : }
841 : 0 : }
842 : :
843 : 0 : void rpc_signal_task(struct rpc_task *task)
844 : : {
845 : 0 : struct rpc_wait_queue *queue;
846 : :
847 [ # # ]: 0 : if (!RPC_IS_ACTIVATED(task))
848 : : return;
849 : :
850 : 0 : trace_rpc_task_signalled(task, task->tk_action);
851 : 0 : set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate);
852 : 0 : smp_mb__after_atomic();
853 [ # # ]: 0 : queue = READ_ONCE(task->tk_waitqueue);
854 [ # # ]: 0 : if (queue)
855 : 0 : rpc_wake_up_queued_task_set_status(queue, task, -ERESTARTSYS);
856 : : }
857 : :
858 : 0 : void rpc_exit(struct rpc_task *task, int status)
859 : : {
860 : 0 : task->tk_status = status;
861 : 0 : task->tk_action = rpc_exit_task;
862 : 0 : rpc_wake_up_queued_task(task->tk_waitqueue, task);
863 : 0 : }
864 : : EXPORT_SYMBOL_GPL(rpc_exit);
865 : :
866 : 0 : void rpc_release_calldata(const struct rpc_call_ops *ops, void *calldata)
867 : : {
868 [ # # ]: 0 : if (ops->rpc_release != NULL)
869 : 0 : ops->rpc_release(calldata);
870 : 0 : }
871 : :
872 : : /*
873 : : * This is the RPC `scheduler' (or rather, the finite state machine).
874 : : */
875 : 0 : static void __rpc_execute(struct rpc_task *task)
876 : : {
877 : 0 : struct rpc_wait_queue *queue;
878 : 0 : int task_is_async = RPC_IS_ASYNC(task);
879 : 0 : int status = 0;
880 : :
881 : 0 : dprintk("RPC: %5u __rpc_execute flags=0x%x\n",
882 : : task->tk_pid, task->tk_flags);
883 : :
884 [ # # ]: 0 : WARN_ON_ONCE(RPC_IS_QUEUED(task));
885 [ # # ]: 0 : if (RPC_IS_QUEUED(task))
886 : : return;
887 : :
888 : 0 : for (;;) {
889 : 0 : void (*do_action)(struct rpc_task *);
890 : :
891 : : /*
892 : : * Perform the next FSM step or a pending callback.
893 : : *
894 : : * tk_action may be NULL if the task has been killed.
895 : : * In particular, note that rpc_killall_tasks may
896 : : * do this at any time, so beware when dereferencing.
897 : : */
898 : 0 : do_action = task->tk_action;
899 [ # # ]: 0 : if (task->tk_callback) {
900 : 0 : do_action = task->tk_callback;
901 : 0 : task->tk_callback = NULL;
902 : : }
903 [ # # ]: 0 : if (!do_action)
904 : : break;
905 : 0 : trace_rpc_task_run_action(task, do_action);
906 : 0 : do_action(task);
907 : :
908 : : /*
909 : : * Lockless check for whether task is sleeping or not.
910 : : */
911 [ # # ]: 0 : if (!RPC_IS_QUEUED(task))
912 : 0 : continue;
913 : :
914 : : /*
915 : : * Signalled tasks should exit rather than sleep.
916 : : */
917 [ # # ]: 0 : if (RPC_SIGNALLED(task)) {
918 : 0 : task->tk_rpc_status = -ERESTARTSYS;
919 : 0 : rpc_exit(task, -ERESTARTSYS);
920 : : }
921 : :
922 : : /*
923 : : * The queue->lock protects against races with
924 : : * rpc_make_runnable().
925 : : *
926 : : * Note that once we clear RPC_TASK_RUNNING on an asynchronous
927 : : * rpc_task, rpc_make_runnable() can assign it to a
928 : : * different workqueue. We therefore cannot assume that the
929 : : * rpc_task pointer may still be dereferenced.
930 : : */
931 : 0 : queue = task->tk_waitqueue;
932 : 0 : spin_lock(&queue->lock);
933 [ # # ]: 0 : if (!RPC_IS_QUEUED(task)) {
934 : 0 : spin_unlock(&queue->lock);
935 : 0 : continue;
936 : : }
937 : 0 : rpc_clear_running(task);
938 : 0 : spin_unlock(&queue->lock);
939 [ # # ]: 0 : if (task_is_async)
940 : : return;
941 : :
942 : : /* sync task: sleep here */
943 : 0 : dprintk("RPC: %5u sync task going to sleep\n", task->tk_pid);
944 : 0 : status = out_of_line_wait_on_bit(&task->tk_runstate,
945 : : RPC_TASK_QUEUED, rpc_wait_bit_killable,
946 : : TASK_KILLABLE);
947 [ # # ]: 0 : if (status < 0) {
948 : : /*
949 : : * When a sync task receives a signal, it exits with
950 : : * -ERESTARTSYS. In order to catch any callbacks that
951 : : * clean up after sleeping on some queue, we don't
952 : : * break the loop here, but go around once more.
953 : : */
954 : 0 : trace_rpc_task_signalled(task, task->tk_action);
955 : 0 : set_bit(RPC_TASK_SIGNALLED, &task->tk_runstate);
956 : 0 : task->tk_rpc_status = -ERESTARTSYS;
957 : 0 : rpc_exit(task, -ERESTARTSYS);
958 : : }
959 : : dprintk("RPC: %5u sync task resuming\n", task->tk_pid);
960 : : }
961 : :
962 : 0 : dprintk("RPC: %5u return %d, status %d\n", task->tk_pid, status,
963 : : task->tk_status);
964 : : /* Release all resources associated with the task */
965 : 0 : rpc_release_task(task);
966 : : }
967 : :
968 : : /*
969 : : * User-visible entry point to the scheduler.
970 : : *
971 : : * This may be called recursively if e.g. an async NFS task updates
972 : : * the attributes and finds that dirty pages must be flushed.
973 : : * NOTE: Upon exit of this function the task is guaranteed to be
974 : : * released. In particular note that tk_release() will have
975 : : * been called, so your task memory may have been freed.
976 : : */
977 : 0 : void rpc_execute(struct rpc_task *task)
978 : : {
979 : 0 : bool is_async = RPC_IS_ASYNC(task);
980 : :
981 : 0 : rpc_set_active(task);
982 : 0 : rpc_make_runnable(rpciod_workqueue, task);
983 [ # # ]: 0 : if (!is_async)
984 : 0 : __rpc_execute(task);
985 : 0 : }
986 : :
987 : 0 : static void rpc_async_schedule(struct work_struct *work)
988 : : {
989 : 0 : unsigned int pflags = memalloc_nofs_save();
990 : :
991 : 0 : __rpc_execute(container_of(work, struct rpc_task, u.tk_work));
992 : 0 : memalloc_nofs_restore(pflags);
993 : 0 : }
994 : :
995 : : /**
996 : : * rpc_malloc - allocate RPC buffer resources
997 : : * @task: RPC task
998 : : *
999 : : * A single memory region is allocated, which is split between the
1000 : : * RPC call and RPC reply that this task is being used for. When
1001 : : * this RPC is retired, the memory is released by calling rpc_free.
1002 : : *
1003 : : * To prevent rpciod from hanging, this allocator never sleeps,
1004 : : * returning -ENOMEM and suppressing warning if the request cannot
1005 : : * be serviced immediately. The caller can arrange to sleep in a
1006 : : * way that is safe for rpciod.
1007 : : *
1008 : : * Most requests are 'small' (under 2KiB) and can be serviced from a
1009 : : * mempool, ensuring that NFS reads and writes can always proceed,
1010 : : * and that there is good locality of reference for these buffers.
1011 : : */
1012 : 0 : int rpc_malloc(struct rpc_task *task)
1013 : : {
1014 : 0 : struct rpc_rqst *rqst = task->tk_rqstp;
1015 : 0 : size_t size = rqst->rq_callsize + rqst->rq_rcvsize;
1016 : 0 : struct rpc_buffer *buf;
1017 : 0 : gfp_t gfp = GFP_NOFS;
1018 : :
1019 [ # # ]: 0 : if (RPC_IS_SWAPPER(task))
1020 : 0 : gfp = __GFP_MEMALLOC | GFP_NOWAIT | __GFP_NOWARN;
1021 : :
1022 : 0 : size += sizeof(struct rpc_buffer);
1023 [ # # ]: 0 : if (size <= RPC_BUFFER_MAXSIZE)
1024 : 0 : buf = mempool_alloc(rpc_buffer_mempool, gfp);
1025 : : else
1026 [ # # ]: 0 : buf = kmalloc(size, gfp);
1027 : :
1028 [ # # ]: 0 : if (!buf)
1029 : : return -ENOMEM;
1030 : :
1031 : 0 : buf->len = size;
1032 : 0 : dprintk("RPC: %5u allocated buffer of size %zu at %p\n",
1033 : : task->tk_pid, size, buf);
1034 : 0 : rqst->rq_buffer = buf->data;
1035 : 0 : rqst->rq_rbuffer = (char *)rqst->rq_buffer + rqst->rq_callsize;
1036 : 0 : return 0;
1037 : : }
1038 : : EXPORT_SYMBOL_GPL(rpc_malloc);
1039 : :
1040 : : /**
1041 : : * rpc_free - free RPC buffer resources allocated via rpc_malloc
1042 : : * @task: RPC task
1043 : : *
1044 : : */
1045 : 0 : void rpc_free(struct rpc_task *task)
1046 : : {
1047 : 0 : void *buffer = task->tk_rqstp->rq_buffer;
1048 : 0 : size_t size;
1049 : 0 : struct rpc_buffer *buf;
1050 : :
1051 : 0 : buf = container_of(buffer, struct rpc_buffer, data);
1052 : 0 : size = buf->len;
1053 : :
1054 : 0 : dprintk("RPC: freeing buffer of size %zu at %p\n",
1055 : : size, buf);
1056 : :
1057 [ # # ]: 0 : if (size <= RPC_BUFFER_MAXSIZE)
1058 : 0 : mempool_free(buf, rpc_buffer_mempool);
1059 : : else
1060 : 0 : kfree(buf);
1061 : 0 : }
1062 : : EXPORT_SYMBOL_GPL(rpc_free);
1063 : :
1064 : : /*
1065 : : * Creation and deletion of RPC task structures
1066 : : */
1067 : 0 : static void rpc_init_task(struct rpc_task *task, const struct rpc_task_setup *task_setup_data)
1068 : : {
1069 : 0 : memset(task, 0, sizeof(*task));
1070 : 0 : atomic_set(&task->tk_count, 1);
1071 : 0 : task->tk_flags = task_setup_data->flags;
1072 : 0 : task->tk_ops = task_setup_data->callback_ops;
1073 : 0 : task->tk_calldata = task_setup_data->callback_data;
1074 : 0 : INIT_LIST_HEAD(&task->tk_task);
1075 : :
1076 : 0 : task->tk_priority = task_setup_data->priority - RPC_PRIORITY_LOW;
1077 : 0 : task->tk_owner = current->tgid;
1078 : :
1079 : : /* Initialize workqueue for async tasks */
1080 : 0 : task->tk_workqueue = task_setup_data->workqueue;
1081 : :
1082 : 0 : task->tk_xprt = rpc_task_get_xprt(task_setup_data->rpc_client,
1083 : : xprt_get(task_setup_data->rpc_xprt));
1084 : :
1085 [ # # ]: 0 : task->tk_op_cred = get_rpccred(task_setup_data->rpc_op_cred);
1086 : :
1087 [ # # ]: 0 : if (task->tk_ops->rpc_call_prepare != NULL)
1088 : 0 : task->tk_action = rpc_prepare_task;
1089 : :
1090 : 0 : rpc_init_task_statistics(task);
1091 : :
1092 : 0 : dprintk("RPC: new task initialized, procpid %u\n",
1093 : : task_pid_nr(current));
1094 : 0 : }
1095 : :
1096 : : static struct rpc_task *
1097 : 0 : rpc_alloc_task(void)
1098 : : {
1099 : 0 : return (struct rpc_task *)mempool_alloc(rpc_task_mempool, GFP_NOFS);
1100 : : }
1101 : :
1102 : : /*
1103 : : * Create a new task for the specified client.
1104 : : */
1105 : 0 : struct rpc_task *rpc_new_task(const struct rpc_task_setup *setup_data)
1106 : : {
1107 : 0 : struct rpc_task *task = setup_data->task;
1108 : 0 : unsigned short flags = 0;
1109 : :
1110 [ # # ]: 0 : if (task == NULL) {
1111 : 0 : task = rpc_alloc_task();
1112 : 0 : flags = RPC_TASK_DYNAMIC;
1113 : : }
1114 : :
1115 : 0 : rpc_init_task(task, setup_data);
1116 : 0 : task->tk_flags |= flags;
1117 : 0 : dprintk("RPC: allocated task %p\n", task);
1118 : 0 : return task;
1119 : : }
1120 : :
1121 : : /*
1122 : : * rpc_free_task - release rpc task and perform cleanups
1123 : : *
1124 : : * Note that we free up the rpc_task _after_ rpc_release_calldata()
1125 : : * in order to work around a workqueue dependency issue.
1126 : : *
1127 : : * Tejun Heo states:
1128 : : * "Workqueue currently considers two work items to be the same if they're
1129 : : * on the same address and won't execute them concurrently - ie. it
1130 : : * makes a work item which is queued again while being executed wait
1131 : : * for the previous execution to complete.
1132 : : *
1133 : : * If a work function frees the work item, and then waits for an event
1134 : : * which should be performed by another work item and *that* work item
1135 : : * recycles the freed work item, it can create a false dependency loop.
1136 : : * There really is no reliable way to detect this short of verifying
1137 : : * every memory free."
1138 : : *
1139 : : */
1140 : 0 : static void rpc_free_task(struct rpc_task *task)
1141 : : {
1142 : 0 : unsigned short tk_flags = task->tk_flags;
1143 : :
1144 : 0 : put_rpccred(task->tk_op_cred);
1145 [ # # ]: 0 : rpc_release_calldata(task->tk_ops, task->tk_calldata);
1146 : :
1147 [ # # ]: 0 : if (tk_flags & RPC_TASK_DYNAMIC) {
1148 : 0 : dprintk("RPC: %5u freeing task\n", task->tk_pid);
1149 : 0 : mempool_free(task, rpc_task_mempool);
1150 : : }
1151 : 0 : }
1152 : :
1153 : 0 : static void rpc_async_release(struct work_struct *work)
1154 : : {
1155 : 0 : unsigned int pflags = memalloc_nofs_save();
1156 : :
1157 : 0 : rpc_free_task(container_of(work, struct rpc_task, u.tk_work));
1158 : 0 : memalloc_nofs_restore(pflags);
1159 : 0 : }
1160 : :
1161 : 0 : static void rpc_release_resources_task(struct rpc_task *task)
1162 : : {
1163 : 0 : xprt_release(task);
1164 [ # # ]: 0 : if (task->tk_msg.rpc_cred) {
1165 : 0 : put_cred(task->tk_msg.rpc_cred);
1166 : 0 : task->tk_msg.rpc_cred = NULL;
1167 : : }
1168 : 0 : rpc_task_release_client(task);
1169 : 0 : }
1170 : :
1171 : 0 : static void rpc_final_put_task(struct rpc_task *task,
1172 : : struct workqueue_struct *q)
1173 : : {
1174 [ # # ]: 0 : if (q != NULL) {
1175 : 0 : INIT_WORK(&task->u.tk_work, rpc_async_release);
1176 : 0 : queue_work(q, &task->u.tk_work);
1177 : : } else
1178 : 0 : rpc_free_task(task);
1179 : 0 : }
1180 : :
1181 : 0 : static void rpc_do_put_task(struct rpc_task *task, struct workqueue_struct *q)
1182 : : {
1183 [ # # ]: 0 : if (atomic_dec_and_test(&task->tk_count)) {
1184 : 0 : rpc_release_resources_task(task);
1185 : 0 : rpc_final_put_task(task, q);
1186 : : }
1187 : 0 : }
1188 : :
1189 : 0 : void rpc_put_task(struct rpc_task *task)
1190 : : {
1191 : 0 : rpc_do_put_task(task, NULL);
1192 : 0 : }
1193 : : EXPORT_SYMBOL_GPL(rpc_put_task);
1194 : :
1195 : 0 : void rpc_put_task_async(struct rpc_task *task)
1196 : : {
1197 : 0 : rpc_do_put_task(task, task->tk_workqueue);
1198 : 0 : }
1199 : : EXPORT_SYMBOL_GPL(rpc_put_task_async);
1200 : :
1201 : 0 : static void rpc_release_task(struct rpc_task *task)
1202 : : {
1203 : 0 : dprintk("RPC: %5u release task\n", task->tk_pid);
1204 : :
1205 [ # # ]: 0 : WARN_ON_ONCE(RPC_IS_QUEUED(task));
1206 : :
1207 : 0 : rpc_release_resources_task(task);
1208 : :
1209 : : /*
1210 : : * Note: at this point we have been removed from rpc_clnt->cl_tasks,
1211 : : * so it should be safe to use task->tk_count as a test for whether
1212 : : * or not any other processes still hold references to our rpc_task.
1213 : : */
1214 [ # # ]: 0 : if (atomic_read(&task->tk_count) != 1 + !RPC_IS_ASYNC(task)) {
1215 : : /* Wake up anyone who may be waiting for task completion */
1216 [ # # ]: 0 : if (!rpc_complete_task(task))
1217 : : return;
1218 : : } else {
1219 [ # # ]: 0 : if (!atomic_dec_and_test(&task->tk_count))
1220 : : return;
1221 : : }
1222 : 0 : rpc_final_put_task(task, task->tk_workqueue);
1223 : : }
1224 : :
1225 : 0 : int rpciod_up(void)
1226 : : {
1227 [ # # ]: 0 : return try_module_get(THIS_MODULE) ? 0 : -EINVAL;
1228 : : }
1229 : :
1230 : 0 : void rpciod_down(void)
1231 : : {
1232 : 0 : module_put(THIS_MODULE);
1233 : 0 : }
1234 : :
1235 : : /*
1236 : : * Start up the rpciod workqueue.
1237 : : */
1238 : 21 : static int rpciod_start(void)
1239 : : {
1240 : 21 : struct workqueue_struct *wq;
1241 : :
1242 : : /*
1243 : : * Create the rpciod thread and wait for it to start.
1244 : : */
1245 : 21 : dprintk("RPC: creating workqueue rpciod\n");
1246 : 21 : wq = alloc_workqueue("rpciod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);
1247 [ - + ]: 21 : if (!wq)
1248 : 0 : goto out_failed;
1249 : 21 : rpciod_workqueue = wq;
1250 : : /* Note: highpri because network receive is latency sensitive */
1251 : 21 : wq = alloc_workqueue("xprtiod", WQ_UNBOUND|WQ_MEM_RECLAIM|WQ_HIGHPRI, 0);
1252 [ - + ]: 21 : if (!wq)
1253 : 0 : goto free_rpciod;
1254 : 21 : xprtiod_workqueue = wq;
1255 : 21 : return 1;
1256 : : free_rpciod:
1257 : 0 : wq = rpciod_workqueue;
1258 : 0 : rpciod_workqueue = NULL;
1259 : 0 : destroy_workqueue(wq);
1260 : : out_failed:
1261 : : return 0;
1262 : : }
1263 : :
1264 : 0 : static void rpciod_stop(void)
1265 : : {
1266 : 0 : struct workqueue_struct *wq = NULL;
1267 : :
1268 [ # # ]: 0 : if (rpciod_workqueue == NULL)
1269 : : return;
1270 : 0 : dprintk("RPC: destroying workqueue rpciod\n");
1271 : :
1272 : 0 : wq = rpciod_workqueue;
1273 : 0 : rpciod_workqueue = NULL;
1274 : 0 : destroy_workqueue(wq);
1275 : 0 : wq = xprtiod_workqueue;
1276 : 0 : xprtiod_workqueue = NULL;
1277 : 0 : destroy_workqueue(wq);
1278 : : }
1279 : :
1280 : : void
1281 : 0 : rpc_destroy_mempool(void)
1282 : : {
1283 : 0 : rpciod_stop();
1284 : 0 : mempool_destroy(rpc_buffer_mempool);
1285 : 0 : mempool_destroy(rpc_task_mempool);
1286 : 0 : kmem_cache_destroy(rpc_task_slabp);
1287 : 0 : kmem_cache_destroy(rpc_buffer_slabp);
1288 : 0 : rpc_destroy_wait_queue(&delay_queue);
1289 : 0 : }
1290 : :
1291 : : int
1292 : 21 : rpc_init_mempool(void)
1293 : : {
1294 : : /*
1295 : : * The following is not strictly a mempool initialisation,
1296 : : * but there is no harm in doing it here
1297 : : */
1298 : 21 : rpc_init_wait_queue(&delay_queue, "delayq");
1299 [ - + ]: 21 : if (!rpciod_start())
1300 : 0 : goto err_nomem;
1301 : :
1302 : 21 : rpc_task_slabp = kmem_cache_create("rpc_tasks",
1303 : : sizeof(struct rpc_task),
1304 : : 0, SLAB_HWCACHE_ALIGN,
1305 : : NULL);
1306 [ - + ]: 21 : if (!rpc_task_slabp)
1307 : 0 : goto err_nomem;
1308 : 21 : rpc_buffer_slabp = kmem_cache_create("rpc_buffers",
1309 : : RPC_BUFFER_MAXSIZE,
1310 : : 0, SLAB_HWCACHE_ALIGN,
1311 : : NULL);
1312 [ - + ]: 21 : if (!rpc_buffer_slabp)
1313 : 0 : goto err_nomem;
1314 : 21 : rpc_task_mempool = mempool_create_slab_pool(RPC_TASK_POOLSIZE,
1315 : : rpc_task_slabp);
1316 [ - + ]: 21 : if (!rpc_task_mempool)
1317 : 0 : goto err_nomem;
1318 : 21 : rpc_buffer_mempool = mempool_create_slab_pool(RPC_BUFFER_POOLSIZE,
1319 : : rpc_buffer_slabp);
1320 [ - + ]: 21 : if (!rpc_buffer_mempool)
1321 : 0 : goto err_nomem;
1322 : : return 0;
1323 : 0 : err_nomem:
1324 : 0 : rpc_destroy_mempool();
1325 : 0 : return -ENOMEM;
1326 : : }
|
