Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/include/linux/sunrpc/sched.h |
| 3 | * |
| 4 | * Scheduling primitives for kernel Sun RPC. |
| 5 | * |
| 6 | * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> |
| 7 | */ |
| 8 | |
| 9 | #ifndef _LINUX_SUNRPC_SCHED_H_ |
| 10 | #define _LINUX_SUNRPC_SCHED_H_ |
| 11 | |
| 12 | #include <linux/timer.h> |
| 13 | #include <linux/sunrpc/types.h> |
| 14 | #include <linux/spinlock.h> |
| 15 | #include <linux/wait.h> |
| 16 | #include <linux/workqueue.h> |
| 17 | #include <linux/sunrpc/xdr.h> |
| 18 | |
| 19 | /* |
| 20 | * This is the actual RPC procedure call info. |
| 21 | */ |
| 22 | struct rpc_procinfo; |
| 23 | struct rpc_message { |
| 24 | struct rpc_procinfo * rpc_proc; /* Procedure information */ |
| 25 | void * rpc_argp; /* Arguments */ |
| 26 | void * rpc_resp; /* Result */ |
| 27 | struct rpc_cred * rpc_cred; /* Credentials */ |
| 28 | }; |
| 29 | |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 30 | struct rpc_call_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | struct rpc_wait_queue; |
| 32 | struct rpc_wait { |
| 33 | struct list_head list; /* wait queue links */ |
| 34 | struct list_head links; /* Links to related tasks */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | struct rpc_wait_queue * rpc_waitq; /* RPC wait queue we're on */ |
| 36 | }; |
| 37 | |
| 38 | /* |
| 39 | * This is the RPC task struct |
| 40 | */ |
| 41 | struct rpc_task { |
| 42 | #ifdef RPC_DEBUG |
| 43 | unsigned long tk_magic; /* 0xf00baa */ |
| 44 | #endif |
Trond Myklebust | 44c2887 | 2006-01-03 09:55:06 +0100 | [diff] [blame] | 45 | atomic_t tk_count; /* Reference count */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | struct list_head tk_task; /* global list of tasks */ |
| 47 | struct rpc_clnt * tk_client; /* RPC client */ |
| 48 | struct rpc_rqst * tk_rqstp; /* RPC request */ |
| 49 | int tk_status; /* result of last operation */ |
| 50 | |
| 51 | /* |
| 52 | * RPC call state |
| 53 | */ |
| 54 | struct rpc_message tk_msg; /* RPC call info */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | __u8 tk_garb_retry; |
| 56 | __u8 tk_cred_retry; |
| 57 | |
| 58 | unsigned long tk_cookie; /* Cookie for batching tasks */ |
| 59 | |
| 60 | /* |
| 61 | * timeout_fn to be executed by timer bottom half |
| 62 | * callback to be executed after waking up |
| 63 | * action next procedure for async tasks |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 64 | * tk_ops caller callbacks |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | */ |
| 66 | void (*tk_timeout_fn)(struct rpc_task *); |
| 67 | void (*tk_callback)(struct rpc_task *); |
| 68 | void (*tk_action)(struct rpc_task *); |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 69 | const struct rpc_call_ops *tk_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | void * tk_calldata; |
| 71 | |
| 72 | /* |
| 73 | * tk_timer is used for async processing by the RPC scheduling |
| 74 | * primitives. You should not access this directly unless |
| 75 | * you have a pathological interest in kernel oopses. |
| 76 | */ |
| 77 | struct timer_list tk_timer; /* kernel timer */ |
| 78 | unsigned long tk_timeout; /* timeout for rpc_sleep() */ |
| 79 | unsigned short tk_flags; /* misc flags */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | unsigned char tk_priority : 2;/* Task priority */ |
| 81 | unsigned long tk_runstate; /* Task run status */ |
| 82 | struct workqueue_struct *tk_workqueue; /* Normally rpciod, but could |
| 83 | * be any workqueue |
| 84 | */ |
| 85 | union { |
| 86 | struct work_struct tk_work; /* Async task work queue */ |
| 87 | struct rpc_wait tk_wait; /* RPC wait */ |
| 88 | } u; |
| 89 | #ifdef RPC_DEBUG |
| 90 | unsigned short tk_pid; /* debugging aid */ |
| 91 | #endif |
| 92 | }; |
| 93 | #define tk_auth tk_client->cl_auth |
| 94 | #define tk_xprt tk_client->cl_xprt |
| 95 | |
| 96 | /* support walking a list of tasks on a wait queue */ |
| 97 | #define task_for_each(task, pos, head) \ |
| 98 | list_for_each(pos, head) \ |
| 99 | if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1) |
| 100 | |
| 101 | #define task_for_first(task, head) \ |
| 102 | if (!list_empty(head) && \ |
| 103 | ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1)) |
| 104 | |
| 105 | /* .. and walking list of all tasks */ |
| 106 | #define alltask_for_each(task, pos, head) \ |
| 107 | list_for_each(pos, head) \ |
| 108 | if ((task=list_entry(pos, struct rpc_task, tk_task)),1) |
| 109 | |
| 110 | typedef void (*rpc_action)(struct rpc_task *); |
| 111 | |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 112 | struct rpc_call_ops { |
Trond Myklebust | 4ce70ad | 2006-01-03 09:55:05 +0100 | [diff] [blame] | 113 | void (*rpc_call_prepare)(struct rpc_task *, void *); |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 114 | void (*rpc_call_done)(struct rpc_task *, void *); |
| 115 | void (*rpc_release)(void *); |
| 116 | }; |
| 117 | |
| 118 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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_CHILD 0x0008 /* is child of other task */ |
| 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_KILLED 0x0100 /* task was killed */ |
| 129 | #define RPC_TASK_SOFT 0x0200 /* Use soft timeouts */ |
| 130 | #define RPC_TASK_NOINTR 0x0400 /* uninterruptible task */ |
| 131 | |
| 132 | #define RPC_IS_ASYNC(t) ((t)->tk_flags & RPC_TASK_ASYNC) |
| 133 | #define RPC_IS_CHILD(t) ((t)->tk_flags & RPC_TASK_CHILD) |
| 134 | #define RPC_IS_SWAPPER(t) ((t)->tk_flags & RPC_TASK_SWAPPER) |
| 135 | #define RPC_DO_ROOTOVERRIDE(t) ((t)->tk_flags & RPC_TASK_ROOTCREDS) |
| 136 | #define RPC_ASSASSINATED(t) ((t)->tk_flags & RPC_TASK_KILLED) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | #define RPC_DO_CALLBACK(t) ((t)->tk_callback != NULL) |
| 138 | #define RPC_IS_SOFT(t) ((t)->tk_flags & RPC_TASK_SOFT) |
| 139 | #define RPC_TASK_UNINTERRUPTIBLE(t) ((t)->tk_flags & RPC_TASK_NOINTR) |
| 140 | |
| 141 | #define RPC_TASK_RUNNING 0 |
| 142 | #define RPC_TASK_QUEUED 1 |
| 143 | #define RPC_TASK_WAKEUP 2 |
| 144 | #define RPC_TASK_HAS_TIMER 3 |
Trond Myklebust | 44c2887 | 2006-01-03 09:55:06 +0100 | [diff] [blame] | 145 | #define RPC_TASK_ACTIVE 4 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | |
| 147 | #define RPC_IS_RUNNING(t) (test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)) |
| 148 | #define rpc_set_running(t) (set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)) |
| 149 | #define rpc_test_and_set_running(t) \ |
| 150 | (test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)) |
| 151 | #define rpc_clear_running(t) \ |
| 152 | do { \ |
| 153 | smp_mb__before_clear_bit(); \ |
| 154 | clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \ |
| 155 | smp_mb__after_clear_bit(); \ |
| 156 | } while (0) |
| 157 | |
| 158 | #define RPC_IS_QUEUED(t) (test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)) |
| 159 | #define rpc_set_queued(t) (set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)) |
| 160 | #define rpc_clear_queued(t) \ |
| 161 | do { \ |
| 162 | smp_mb__before_clear_bit(); \ |
| 163 | clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \ |
| 164 | smp_mb__after_clear_bit(); \ |
| 165 | } while (0) |
| 166 | |
| 167 | #define rpc_start_wakeup(t) \ |
| 168 | (test_and_set_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate) == 0) |
| 169 | #define rpc_finish_wakeup(t) \ |
| 170 | do { \ |
| 171 | smp_mb__before_clear_bit(); \ |
| 172 | clear_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate); \ |
| 173 | smp_mb__after_clear_bit(); \ |
| 174 | } while (0) |
| 175 | |
Trond Myklebust | 44c2887 | 2006-01-03 09:55:06 +0100 | [diff] [blame] | 176 | #define RPC_IS_ACTIVATED(t) (test_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate)) |
| 177 | #define rpc_set_active(t) (set_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate)) |
| 178 | #define rpc_clear_active(t) \ |
| 179 | do { \ |
| 180 | smp_mb__before_clear_bit(); \ |
| 181 | clear_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate); \ |
| 182 | smp_mb__after_clear_bit(); \ |
| 183 | } while(0) |
| 184 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | /* |
| 186 | * Task priorities. |
| 187 | * Note: if you change these, you must also change |
| 188 | * the task initialization definitions below. |
| 189 | */ |
| 190 | #define RPC_PRIORITY_LOW 0 |
| 191 | #define RPC_PRIORITY_NORMAL 1 |
| 192 | #define RPC_PRIORITY_HIGH 2 |
| 193 | #define RPC_NR_PRIORITY (RPC_PRIORITY_HIGH+1) |
| 194 | |
| 195 | /* |
| 196 | * RPC synchronization objects |
| 197 | */ |
| 198 | struct rpc_wait_queue { |
| 199 | spinlock_t lock; |
| 200 | struct list_head tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */ |
| 201 | unsigned long cookie; /* cookie of last task serviced */ |
| 202 | unsigned char maxpriority; /* maximum priority (0 if queue is not a priority queue) */ |
| 203 | unsigned char priority; /* current priority */ |
| 204 | unsigned char count; /* # task groups remaining serviced so far */ |
| 205 | unsigned char nr; /* # tasks remaining for cookie */ |
Chuck Lever | e19b63d | 2006-03-20 13:44:15 -0500 | [diff] [blame^] | 206 | unsigned short qlen; /* total # tasks waiting in queue */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | #ifdef RPC_DEBUG |
| 208 | const char * name; |
| 209 | #endif |
| 210 | }; |
| 211 | |
| 212 | /* |
| 213 | * This is the # requests to send consecutively |
| 214 | * from a single cookie. The aim is to improve |
| 215 | * performance of NFS operations such as read/write. |
| 216 | */ |
| 217 | #define RPC_BATCH_COUNT 16 |
| 218 | |
| 219 | #ifndef RPC_DEBUG |
| 220 | # define RPC_WAITQ_INIT(var,qname) { \ |
| 221 | .lock = SPIN_LOCK_UNLOCKED, \ |
| 222 | .tasks = { \ |
| 223 | [0] = LIST_HEAD_INIT(var.tasks[0]), \ |
| 224 | [1] = LIST_HEAD_INIT(var.tasks[1]), \ |
| 225 | [2] = LIST_HEAD_INIT(var.tasks[2]), \ |
| 226 | }, \ |
| 227 | } |
| 228 | #else |
| 229 | # define RPC_WAITQ_INIT(var,qname) { \ |
| 230 | .lock = SPIN_LOCK_UNLOCKED, \ |
| 231 | .tasks = { \ |
| 232 | [0] = LIST_HEAD_INIT(var.tasks[0]), \ |
| 233 | [1] = LIST_HEAD_INIT(var.tasks[1]), \ |
| 234 | [2] = LIST_HEAD_INIT(var.tasks[2]), \ |
| 235 | }, \ |
| 236 | .name = qname, \ |
| 237 | } |
| 238 | #endif |
| 239 | # define RPC_WAITQ(var,qname) struct rpc_wait_queue var = RPC_WAITQ_INIT(var,qname) |
| 240 | |
| 241 | #define RPC_IS_PRIORITY(q) ((q)->maxpriority > 0) |
| 242 | |
| 243 | /* |
| 244 | * Function prototypes |
| 245 | */ |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 246 | struct rpc_task *rpc_new_task(struct rpc_clnt *, int flags, |
| 247 | const struct rpc_call_ops *ops, void *data); |
Trond Myklebust | 44c2887 | 2006-01-03 09:55:06 +0100 | [diff] [blame] | 248 | struct rpc_task *rpc_run_task(struct rpc_clnt *clnt, int flags, |
| 249 | const struct rpc_call_ops *ops, void *data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | struct rpc_task *rpc_new_child(struct rpc_clnt *, struct rpc_task *parent); |
Trond Myklebust | 963d8fe | 2006-01-03 09:55:04 +0100 | [diff] [blame] | 251 | void rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt, |
| 252 | int flags, const struct rpc_call_ops *ops, |
| 253 | void *data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | void rpc_release_task(struct rpc_task *); |
Trond Myklebust | abbcf28 | 2006-01-03 09:55:03 +0100 | [diff] [blame] | 255 | void rpc_exit_task(struct rpc_task *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | void rpc_killall_tasks(struct rpc_clnt *); |
| 257 | int rpc_execute(struct rpc_task *); |
| 258 | void rpc_run_child(struct rpc_task *parent, struct rpc_task *child, |
| 259 | rpc_action action); |
| 260 | void rpc_init_priority_wait_queue(struct rpc_wait_queue *, const char *); |
| 261 | void rpc_init_wait_queue(struct rpc_wait_queue *, const char *); |
| 262 | void rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *, |
| 263 | rpc_action action, rpc_action timer); |
| 264 | void rpc_wake_up_task(struct rpc_task *); |
| 265 | void rpc_wake_up(struct rpc_wait_queue *); |
| 266 | struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *); |
| 267 | void rpc_wake_up_status(struct rpc_wait_queue *, int); |
| 268 | void rpc_delay(struct rpc_task *, unsigned long); |
| 269 | void * rpc_malloc(struct rpc_task *, size_t); |
Chuck Lever | 0210714 | 2006-01-03 09:55:49 +0100 | [diff] [blame] | 270 | void rpc_free(struct rpc_task *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | int rpciod_up(void); |
| 272 | void rpciod_down(void); |
| 273 | void rpciod_wake_up(void); |
Trond Myklebust | 44c2887 | 2006-01-03 09:55:06 +0100 | [diff] [blame] | 274 | int __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | #ifdef RPC_DEBUG |
| 276 | void rpc_show_tasks(void); |
| 277 | #endif |
| 278 | int rpc_init_mempool(void); |
| 279 | void rpc_destroy_mempool(void); |
Trond Myklebust | 24c5d9d | 2006-03-20 13:44:08 -0500 | [diff] [blame] | 280 | extern struct workqueue_struct *rpciod_workqueue; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | |
| 282 | static inline void rpc_exit(struct rpc_task *task, int status) |
| 283 | { |
| 284 | task->tk_status = status; |
Trond Myklebust | abbcf28 | 2006-01-03 09:55:03 +0100 | [diff] [blame] | 285 | task->tk_action = rpc_exit_task; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | } |
| 287 | |
Trond Myklebust | 44c2887 | 2006-01-03 09:55:06 +0100 | [diff] [blame] | 288 | static inline int rpc_wait_for_completion_task(struct rpc_task *task) |
| 289 | { |
| 290 | return __rpc_wait_for_completion_task(task, NULL); |
| 291 | } |
| 292 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 293 | #ifdef RPC_DEBUG |
| 294 | static inline const char * rpc_qname(struct rpc_wait_queue *q) |
| 295 | { |
| 296 | return ((q && q->name) ? q->name : "unknown"); |
| 297 | } |
| 298 | #endif |
| 299 | |
| 300 | #endif /* _LINUX_SUNRPC_SCHED_H_ */ |