Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : /*
3 : : * linux/include/linux/sunrpc/sched.h
4 : : *
5 : : * Scheduling primitives for kernel Sun RPC.
6 : : *
7 : : * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
8 : : */
9 : :
10 : : #ifndef _LINUX_SUNRPC_SCHED_H_
11 : : #define _LINUX_SUNRPC_SCHED_H_
12 : :
13 : : #include <linux/timer.h>
14 : : #include <linux/ktime.h>
15 : : #include <linux/sunrpc/types.h>
16 : : #include <linux/spinlock.h>
17 : : #include <linux/wait_bit.h>
18 : : #include <linux/workqueue.h>
19 : : #include <linux/sunrpc/xdr.h>
20 : :
21 : : /*
22 : : * This is the actual RPC procedure call info.
23 : : */
24 : : struct rpc_procinfo;
25 : : struct rpc_message {
26 : : const struct rpc_procinfo *rpc_proc; /* Procedure information */
27 : : void * rpc_argp; /* Arguments */
28 : : void * rpc_resp; /* Result */
29 : : const struct cred * rpc_cred; /* Credentials */
30 : : };
31 : :
32 : : struct rpc_call_ops;
33 : : struct rpc_wait_queue;
34 : : struct rpc_wait {
35 : : struct list_head list; /* wait queue links */
36 : : struct list_head links; /* Links to related tasks */
37 : : struct list_head timer_list; /* Timer list */
38 : : };
39 : :
40 : : /*
41 : : * This is the RPC task struct
42 : : */
43 : : struct rpc_task {
44 : : atomic_t tk_count; /* Reference count */
45 : : int tk_status; /* result of last operation */
46 : : struct list_head tk_task; /* global list of tasks */
47 : :
48 : : /*
49 : : * callback to be executed after waking up
50 : : * action next procedure for async tasks
51 : : */
52 : : void (*tk_callback)(struct rpc_task *);
53 : : void (*tk_action)(struct rpc_task *);
54 : :
55 : : unsigned long tk_timeout; /* timeout for rpc_sleep() */
56 : : unsigned long tk_runstate; /* Task run status */
57 : :
58 : : struct rpc_wait_queue *tk_waitqueue; /* RPC wait queue we're on */
59 : : union {
60 : : struct work_struct tk_work; /* Async task work queue */
61 : : struct rpc_wait tk_wait; /* RPC wait */
62 : : } u;
63 : :
64 : : int tk_rpc_status; /* Result of last RPC operation */
65 : :
66 : : /*
67 : : * RPC call state
68 : : */
69 : : struct rpc_message tk_msg; /* RPC call info */
70 : : void * tk_calldata; /* Caller private data */
71 : : const struct rpc_call_ops *tk_ops; /* Caller callbacks */
72 : :
73 : : struct rpc_clnt * tk_client; /* RPC client */
74 : : struct rpc_xprt * tk_xprt; /* Transport */
75 : : struct rpc_cred * tk_op_cred; /* cred being operated on */
76 : :
77 : : struct rpc_rqst * tk_rqstp; /* RPC request */
78 : :
79 : : struct workqueue_struct *tk_workqueue; /* Normally rpciod, but could
80 : : * be any workqueue
81 : : */
82 : : ktime_t tk_start; /* RPC task init timestamp */
83 : :
84 : : pid_t tk_owner; /* Process id for batching tasks */
85 : : unsigned short tk_flags; /* misc flags */
86 : : unsigned short tk_timeouts; /* maj timeouts */
87 : :
88 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
89 : : unsigned short tk_pid; /* debugging aid */
90 : : #endif
91 : : unsigned char tk_priority : 2,/* Task priority */
92 : : tk_garb_retry : 2,
93 : : tk_cred_retry : 2,
94 : : tk_rebind_retry : 2;
95 : : };
96 : :
97 : : typedef void (*rpc_action)(struct rpc_task *);
98 : :
99 : : struct rpc_call_ops {
100 : : void (*rpc_call_prepare)(struct rpc_task *, void *);
101 : : void (*rpc_call_done)(struct rpc_task *, void *);
102 : : void (*rpc_count_stats)(struct rpc_task *, void *);
103 : : void (*rpc_release)(void *);
104 : : };
105 : :
106 : : struct rpc_task_setup {
107 : : struct rpc_task *task;
108 : : struct rpc_clnt *rpc_client;
109 : : struct rpc_xprt *rpc_xprt;
110 : : struct rpc_cred *rpc_op_cred; /* credential being operated on */
111 : : const struct rpc_message *rpc_message;
112 : : const struct rpc_call_ops *callback_ops;
113 : : void *callback_data;
114 : : struct workqueue_struct *workqueue;
115 : : unsigned short flags;
116 : : signed char priority;
117 : : };
118 : :
119 : : /*
120 : : * RPC task flags
121 : : */
122 : : #define RPC_TASK_ASYNC 0x0001 /* is an async task */
123 : : #define RPC_TASK_SWAPPER 0x0002 /* is swapping in/out */
124 : : #define RPC_TASK_NULLCREDS 0x0010 /* Use AUTH_NULL credential */
125 : : #define RPC_CALL_MAJORSEEN 0x0020 /* major timeout seen */
126 : : #define RPC_TASK_ROOTCREDS 0x0040 /* force root creds */
127 : : #define RPC_TASK_DYNAMIC 0x0080 /* task was kmalloc'ed */
128 : : #define RPC_TASK_NO_ROUND_ROBIN 0x0100 /* send requests on "main" xprt */
129 : : #define RPC_TASK_SOFT 0x0200 /* Use soft timeouts */
130 : : #define RPC_TASK_SOFTCONN 0x0400 /* Fail if can't connect */
131 : : #define RPC_TASK_SENT 0x0800 /* message was sent */
132 : : #define RPC_TASK_TIMEOUT 0x1000 /* fail with ETIMEDOUT on timeout */
133 : : #define RPC_TASK_NOCONNECT 0x2000 /* return ENOTCONN if not connected */
134 : : #define RPC_TASK_NO_RETRANS_TIMEOUT 0x4000 /* wait forever for a reply */
135 : :
136 : : #define RPC_IS_ASYNC(t) ((t)->tk_flags & RPC_TASK_ASYNC)
137 : : #define RPC_IS_SWAPPER(t) ((t)->tk_flags & RPC_TASK_SWAPPER)
138 : : #define RPC_IS_SOFT(t) ((t)->tk_flags & (RPC_TASK_SOFT|RPC_TASK_TIMEOUT))
139 : : #define RPC_IS_SOFTCONN(t) ((t)->tk_flags & RPC_TASK_SOFTCONN)
140 : : #define RPC_WAS_SENT(t) ((t)->tk_flags & RPC_TASK_SENT)
141 : :
142 : : #define RPC_TASK_RUNNING 0
143 : : #define RPC_TASK_QUEUED 1
144 : : #define RPC_TASK_ACTIVE 2
145 : : #define RPC_TASK_NEED_XMIT 3
146 : : #define RPC_TASK_NEED_RECV 4
147 : : #define RPC_TASK_MSG_PIN_WAIT 5
148 : : #define RPC_TASK_SIGNALLED 6
149 : :
150 : : #define RPC_IS_RUNNING(t) test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
151 : : #define rpc_set_running(t) set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
152 : : #define rpc_test_and_set_running(t) \
153 : : test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
154 : : #define rpc_clear_running(t) \
155 : : do { \
156 : : smp_mb__before_atomic(); \
157 : : clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \
158 : : smp_mb__after_atomic(); \
159 : : } while (0)
160 : :
161 : : #define RPC_IS_QUEUED(t) test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)
162 : : #define rpc_set_queued(t) set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)
163 : : #define rpc_clear_queued(t) \
164 : : do { \
165 : : smp_mb__before_atomic(); \
166 : : clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \
167 : : smp_mb__after_atomic(); \
168 : : } while (0)
169 : :
170 : : #define RPC_IS_ACTIVATED(t) test_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate)
171 : :
172 : : #define RPC_SIGNALLED(t) test_bit(RPC_TASK_SIGNALLED, &(t)->tk_runstate)
173 : :
174 : : /*
175 : : * Task priorities.
176 : : * Note: if you change these, you must also change
177 : : * the task initialization definitions below.
178 : : */
179 : : #define RPC_PRIORITY_LOW (-1)
180 : : #define RPC_PRIORITY_NORMAL (0)
181 : : #define RPC_PRIORITY_HIGH (1)
182 : : #define RPC_PRIORITY_PRIVILEGED (2)
183 : : #define RPC_NR_PRIORITY (1 + RPC_PRIORITY_PRIVILEGED - RPC_PRIORITY_LOW)
184 : :
185 : : struct rpc_timer {
186 : : struct list_head list;
187 : : unsigned long expires;
188 : : struct delayed_work dwork;
189 : : };
190 : :
191 : : /*
192 : : * RPC synchronization objects
193 : : */
194 : : struct rpc_wait_queue {
195 : : spinlock_t lock;
196 : : struct list_head tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */
197 : : unsigned char maxpriority; /* maximum priority (0 if queue is not a priority queue) */
198 : : unsigned char priority; /* current priority */
199 : : unsigned char nr; /* # tasks remaining for cookie */
200 : : unsigned short qlen; /* total # tasks waiting in queue */
201 : : struct rpc_timer timer_list;
202 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
203 : : const char * name;
204 : : #endif
205 : : };
206 : :
207 : : /*
208 : : * This is the # requests to send consecutively
209 : : * from a single cookie. The aim is to improve
210 : : * performance of NFS operations such as read/write.
211 : : */
212 : : #define RPC_IS_PRIORITY(q) ((q)->maxpriority > 0)
213 : :
214 : : /*
215 : : * Function prototypes
216 : : */
217 : : struct rpc_task *rpc_new_task(const struct rpc_task_setup *);
218 : : struct rpc_task *rpc_run_task(const struct rpc_task_setup *);
219 : : struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req);
220 : : void rpc_put_task(struct rpc_task *);
221 : : void rpc_put_task_async(struct rpc_task *);
222 : : void rpc_signal_task(struct rpc_task *);
223 : : void rpc_exit_task(struct rpc_task *);
224 : : void rpc_exit(struct rpc_task *, int);
225 : : void rpc_release_calldata(const struct rpc_call_ops *, void *);
226 : : void rpc_killall_tasks(struct rpc_clnt *);
227 : : void rpc_execute(struct rpc_task *);
228 : : void rpc_init_priority_wait_queue(struct rpc_wait_queue *, const char *);
229 : : void rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
230 : : void rpc_destroy_wait_queue(struct rpc_wait_queue *);
231 : : unsigned long rpc_task_timeout(const struct rpc_task *task);
232 : : void rpc_sleep_on_timeout(struct rpc_wait_queue *queue,
233 : : struct rpc_task *task,
234 : : rpc_action action,
235 : : unsigned long timeout);
236 : : void rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
237 : : rpc_action action);
238 : : void rpc_sleep_on_priority_timeout(struct rpc_wait_queue *queue,
239 : : struct rpc_task *task,
240 : : unsigned long timeout,
241 : : int priority);
242 : : void rpc_sleep_on_priority(struct rpc_wait_queue *,
243 : : struct rpc_task *,
244 : : int priority);
245 : : void rpc_wake_up_queued_task(struct rpc_wait_queue *,
246 : : struct rpc_task *);
247 : : void rpc_wake_up_queued_task_set_status(struct rpc_wait_queue *,
248 : : struct rpc_task *,
249 : : int);
250 : : void rpc_wake_up(struct rpc_wait_queue *);
251 : : struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
252 : : struct rpc_task *rpc_wake_up_first_on_wq(struct workqueue_struct *wq,
253 : : struct rpc_wait_queue *,
254 : : bool (*)(struct rpc_task *, void *),
255 : : void *);
256 : : struct rpc_task *rpc_wake_up_first(struct rpc_wait_queue *,
257 : : bool (*)(struct rpc_task *, void *),
258 : : void *);
259 : : void rpc_wake_up_status(struct rpc_wait_queue *, int);
260 : : void rpc_delay(struct rpc_task *, unsigned long);
261 : : int rpc_malloc(struct rpc_task *);
262 : : void rpc_free(struct rpc_task *);
263 : : int rpciod_up(void);
264 : : void rpciod_down(void);
265 : : int __rpc_wait_for_completion_task(struct rpc_task *task, wait_bit_action_f *);
266 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
267 : : struct net;
268 : : void rpc_show_tasks(struct net *);
269 : : #endif
270 : : int rpc_init_mempool(void);
271 : : void rpc_destroy_mempool(void);
272 : : extern struct workqueue_struct *rpciod_workqueue;
273 : : extern struct workqueue_struct *xprtiod_workqueue;
274 : : void rpc_prepare_task(struct rpc_task *task);
275 : :
276 : : static inline int rpc_wait_for_completion_task(struct rpc_task *task)
277 : : {
278 : 0 : return __rpc_wait_for_completion_task(task, NULL);
279 : : }
280 : :
281 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
282 : : static inline const char * rpc_qname(const struct rpc_wait_queue *q)
283 : : {
284 [ # # # # : 0 : return ((q && q->name) ? q->name : "unknown");
# # # # #
# # # # #
# # # # #
# # # #
# ]
285 : : }
286 : :
287 : : static inline void rpc_assign_waitqueue_name(struct rpc_wait_queue *q,
288 : : const char *name)
289 : : {
290 : 808 : q->name = name;
291 : : }
292 : : #else
293 : : static inline void rpc_assign_waitqueue_name(struct rpc_wait_queue *q,
294 : : const char *name)
295 : : {
296 : : }
297 : : #endif
298 : :
299 : : #if IS_ENABLED(CONFIG_SUNRPC_SWAP)
300 : : int rpc_clnt_swap_activate(struct rpc_clnt *clnt);
301 : : void rpc_clnt_swap_deactivate(struct rpc_clnt *clnt);
302 : : #else
303 : : static inline int
304 : : rpc_clnt_swap_activate(struct rpc_clnt *clnt)
305 : : {
306 : : return -EINVAL;
307 : : }
308 : :
309 : : static inline void
310 : : rpc_clnt_swap_deactivate(struct rpc_clnt *clnt)
311 : : {
312 : : }
313 : : #endif /* CONFIG_SUNRPC_SWAP */
314 : :
315 : : #endif /* _LINUX_SUNRPC_SCHED_H_ */
|
