Commit | Line | Data |
---|---|---|
426cc91a EVH |
1 | /* |
2 | * linux/fs/9p/mux.c | |
3 | * | |
4 | * Protocol Multiplexer | |
5 | * | |
6 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> | |
3cf6429a | 7 | * Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net> |
426cc91a EVH |
8 | * |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to: | |
21 | * Free Software Foundation | |
22 | * 51 Franklin Street, Fifth Floor | |
23 | * Boston, MA 02111-1301 USA | |
24 | * | |
25 | */ | |
26 | ||
27 | #include <linux/config.h> | |
28 | #include <linux/module.h> | |
29 | #include <linux/errno.h> | |
30 | #include <linux/fs.h> | |
3cf6429a | 31 | #include <linux/poll.h> |
426cc91a EVH |
32 | #include <linux/kthread.h> |
33 | #include <linux/idr.h> | |
4f7a07b8 | 34 | #include <linux/mutex.h> |
426cc91a EVH |
35 | |
36 | #include "debug.h" | |
37 | #include "v9fs.h" | |
38 | #include "9p.h" | |
426cc91a | 39 | #include "conv.h" |
531b1094 | 40 | #include "transport.h" |
426cc91a EVH |
41 | #include "mux.h" |
42 | ||
3cf6429a LI |
43 | #define ERREQFLUSH 1 |
44 | #define SCHED_TIMEOUT 10 | |
45 | #define MAXPOLLWADDR 2 | |
46 | ||
47 | enum { | |
48 | Rworksched = 1, /* read work scheduled or running */ | |
49 | Rpending = 2, /* can read */ | |
50 | Wworksched = 4, /* write work scheduled or running */ | |
51 | Wpending = 8, /* can write */ | |
52 | }; | |
53 | ||
54 | struct v9fs_mux_poll_task; | |
55 | ||
56 | struct v9fs_req { | |
57 | int tag; | |
58 | struct v9fs_fcall *tcall; | |
59 | struct v9fs_fcall *rcall; | |
60 | int err; | |
61 | v9fs_mux_req_callback cb; | |
62 | void *cba; | |
63 | struct list_head req_list; | |
64 | }; | |
65 | ||
66 | struct v9fs_mux_data { | |
67 | spinlock_t lock; | |
68 | struct list_head mux_list; | |
69 | struct v9fs_mux_poll_task *poll_task; | |
70 | int msize; | |
71 | unsigned char *extended; | |
72 | struct v9fs_transport *trans; | |
4a26c242 | 73 | struct v9fs_idpool tagpool; |
3cf6429a LI |
74 | int err; |
75 | wait_queue_head_t equeue; | |
76 | struct list_head req_list; | |
77 | struct list_head unsent_req_list; | |
531b1094 | 78 | struct v9fs_fcall *rcall; |
3cf6429a LI |
79 | int rpos; |
80 | char *rbuf; | |
81 | int wpos; | |
82 | int wsize; | |
83 | char *wbuf; | |
84 | wait_queue_t poll_wait[MAXPOLLWADDR]; | |
85 | wait_queue_head_t *poll_waddr[MAXPOLLWADDR]; | |
86 | poll_table pt; | |
87 | struct work_struct rq; | |
88 | struct work_struct wq; | |
89 | unsigned long wsched; | |
90 | }; | |
91 | ||
92 | struct v9fs_mux_poll_task { | |
93 | struct task_struct *task; | |
94 | struct list_head mux_list; | |
95 | int muxnum; | |
96 | }; | |
97 | ||
98 | struct v9fs_mux_rpc { | |
99 | struct v9fs_mux_data *m; | |
100 | struct v9fs_req *req; | |
101 | int err; | |
102 | struct v9fs_fcall *rcall; | |
103 | wait_queue_head_t wqueue; | |
104 | }; | |
105 | ||
106 | static int v9fs_poll_proc(void *); | |
107 | static void v9fs_read_work(void *); | |
108 | static void v9fs_write_work(void *); | |
109 | static void v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address, | |
110 | poll_table * p); | |
531b1094 LI |
111 | static u16 v9fs_mux_get_tag(struct v9fs_mux_data *); |
112 | static void v9fs_mux_put_tag(struct v9fs_mux_data *, u16); | |
3cf6429a | 113 | |
4f7a07b8 | 114 | static DEFINE_MUTEX(v9fs_mux_task_lock); |
3cf6429a LI |
115 | static struct workqueue_struct *v9fs_mux_wq; |
116 | ||
117 | static int v9fs_mux_num; | |
118 | static int v9fs_mux_poll_task_num; | |
119 | static struct v9fs_mux_poll_task v9fs_mux_poll_tasks[100]; | |
120 | ||
1dac06b2 | 121 | int v9fs_mux_global_init(void) |
3cf6429a LI |
122 | { |
123 | int i; | |
124 | ||
125 | for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) | |
126 | v9fs_mux_poll_tasks[i].task = NULL; | |
127 | ||
128 | v9fs_mux_wq = create_workqueue("v9fs"); | |
1dac06b2 LI |
129 | if (!v9fs_mux_wq) |
130 | return -ENOMEM; | |
131 | ||
132 | return 0; | |
3cf6429a | 133 | } |
426cc91a | 134 | |
3cf6429a | 135 | void v9fs_mux_global_exit(void) |
426cc91a | 136 | { |
3cf6429a | 137 | destroy_workqueue(v9fs_mux_wq); |
426cc91a EVH |
138 | } |
139 | ||
140 | /** | |
3cf6429a LI |
141 | * v9fs_mux_calc_poll_procs - calculates the number of polling procs |
142 | * based on the number of mounted v9fs filesystems. | |
426cc91a | 143 | * |
3cf6429a | 144 | * The current implementation returns sqrt of the number of mounts. |
426cc91a | 145 | */ |
29c6e486 | 146 | static int v9fs_mux_calc_poll_procs(int muxnum) |
3cf6429a LI |
147 | { |
148 | int n; | |
149 | ||
150 | if (v9fs_mux_poll_task_num) | |
151 | n = muxnum / v9fs_mux_poll_task_num + | |
152 | (muxnum % v9fs_mux_poll_task_num ? 1 : 0); | |
153 | else | |
154 | n = 1; | |
155 | ||
156 | if (n > ARRAY_SIZE(v9fs_mux_poll_tasks)) | |
157 | n = ARRAY_SIZE(v9fs_mux_poll_tasks); | |
426cc91a | 158 | |
3cf6429a LI |
159 | return n; |
160 | } | |
161 | ||
1dac06b2 | 162 | static int v9fs_mux_poll_start(struct v9fs_mux_data *m) |
426cc91a | 163 | { |
3cf6429a LI |
164 | int i, n; |
165 | struct v9fs_mux_poll_task *vpt, *vptlast; | |
1dac06b2 | 166 | struct task_struct *pproc; |
3cf6429a LI |
167 | |
168 | dprintk(DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, v9fs_mux_num, | |
169 | v9fs_mux_poll_task_num); | |
4f7a07b8 | 170 | mutex_lock(&v9fs_mux_task_lock); |
3cf6429a LI |
171 | |
172 | n = v9fs_mux_calc_poll_procs(v9fs_mux_num + 1); | |
173 | if (n > v9fs_mux_poll_task_num) { | |
174 | for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) { | |
175 | if (v9fs_mux_poll_tasks[i].task == NULL) { | |
176 | vpt = &v9fs_mux_poll_tasks[i]; | |
177 | dprintk(DEBUG_MUX, "create proc %p\n", vpt); | |
1dac06b2 | 178 | pproc = kthread_create(v9fs_poll_proc, vpt, |
531b1094 | 179 | "v9fs-poll"); |
1dac06b2 LI |
180 | |
181 | if (!IS_ERR(pproc)) { | |
182 | vpt->task = pproc; | |
183 | INIT_LIST_HEAD(&vpt->mux_list); | |
184 | vpt->muxnum = 0; | |
185 | v9fs_mux_poll_task_num++; | |
186 | wake_up_process(vpt->task); | |
187 | } | |
3cf6429a LI |
188 | break; |
189 | } | |
426cc91a | 190 | } |
426cc91a | 191 | |
3cf6429a LI |
192 | if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks)) |
193 | dprintk(DEBUG_ERROR, "warning: no free poll slots\n"); | |
194 | } | |
426cc91a | 195 | |
3cf6429a LI |
196 | n = (v9fs_mux_num + 1) / v9fs_mux_poll_task_num + |
197 | ((v9fs_mux_num + 1) % v9fs_mux_poll_task_num ? 1 : 0); | |
198 | ||
199 | vptlast = NULL; | |
200 | for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) { | |
201 | vpt = &v9fs_mux_poll_tasks[i]; | |
202 | if (vpt->task != NULL) { | |
203 | vptlast = vpt; | |
204 | if (vpt->muxnum < n) { | |
205 | dprintk(DEBUG_MUX, "put in proc %d\n", i); | |
206 | list_add(&m->mux_list, &vpt->mux_list); | |
207 | vpt->muxnum++; | |
208 | m->poll_task = vpt; | |
209 | memset(&m->poll_waddr, 0, sizeof(m->poll_waddr)); | |
210 | init_poll_funcptr(&m->pt, v9fs_pollwait); | |
211 | break; | |
212 | } | |
213 | } | |
426cc91a EVH |
214 | } |
215 | ||
3cf6429a | 216 | if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks)) { |
1dac06b2 LI |
217 | if (vptlast == NULL) |
218 | return -ENOMEM; | |
219 | ||
3cf6429a LI |
220 | dprintk(DEBUG_MUX, "put in proc %d\n", i); |
221 | list_add(&m->mux_list, &vptlast->mux_list); | |
222 | vptlast->muxnum++; | |
1dac06b2 | 223 | m->poll_task = vptlast; |
3cf6429a LI |
224 | memset(&m->poll_waddr, 0, sizeof(m->poll_waddr)); |
225 | init_poll_funcptr(&m->pt, v9fs_pollwait); | |
426cc91a EVH |
226 | } |
227 | ||
3cf6429a | 228 | v9fs_mux_num++; |
4f7a07b8 | 229 | mutex_unlock(&v9fs_mux_task_lock); |
1dac06b2 LI |
230 | |
231 | return 0; | |
3cf6429a | 232 | } |
426cc91a | 233 | |
3cf6429a LI |
234 | static void v9fs_mux_poll_stop(struct v9fs_mux_data *m) |
235 | { | |
236 | int i; | |
237 | struct v9fs_mux_poll_task *vpt; | |
238 | ||
4f7a07b8 | 239 | mutex_lock(&v9fs_mux_task_lock); |
3cf6429a LI |
240 | vpt = m->poll_task; |
241 | list_del(&m->mux_list); | |
242 | for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) { | |
243 | if (m->poll_waddr[i] != NULL) { | |
244 | remove_wait_queue(m->poll_waddr[i], &m->poll_wait[i]); | |
245 | m->poll_waddr[i] = NULL; | |
246 | } | |
247 | } | |
248 | vpt->muxnum--; | |
249 | if (!vpt->muxnum) { | |
250 | dprintk(DEBUG_MUX, "destroy proc %p\n", vpt); | |
251 | send_sig(SIGKILL, vpt->task, 1); | |
252 | vpt->task = NULL; | |
253 | v9fs_mux_poll_task_num--; | |
254 | } | |
255 | v9fs_mux_num--; | |
4f7a07b8 | 256 | mutex_unlock(&v9fs_mux_task_lock); |
3cf6429a | 257 | } |
426cc91a | 258 | |
3cf6429a LI |
259 | /** |
260 | * v9fs_mux_init - allocate and initialize the per-session mux data | |
261 | * Creates the polling task if this is the first session. | |
262 | * | |
263 | * @trans - transport structure | |
264 | * @msize - maximum message size | |
265 | * @extended - pointer to the extended flag | |
266 | */ | |
267 | struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize, | |
268 | unsigned char *extended) | |
269 | { | |
270 | int i, n; | |
271 | struct v9fs_mux_data *m, *mtmp; | |
272 | ||
273 | dprintk(DEBUG_MUX, "transport %p msize %d\n", trans, msize); | |
531b1094 | 274 | m = kmalloc(sizeof(struct v9fs_mux_data), GFP_KERNEL); |
3cf6429a LI |
275 | if (!m) |
276 | return ERR_PTR(-ENOMEM); | |
277 | ||
278 | spin_lock_init(&m->lock); | |
279 | INIT_LIST_HEAD(&m->mux_list); | |
280 | m->msize = msize; | |
281 | m->extended = extended; | |
282 | m->trans = trans; | |
4a26c242 RC |
283 | idr_init(&m->tagpool.pool); |
284 | init_MUTEX(&m->tagpool.lock); | |
3cf6429a LI |
285 | m->err = 0; |
286 | init_waitqueue_head(&m->equeue); | |
287 | INIT_LIST_HEAD(&m->req_list); | |
288 | INIT_LIST_HEAD(&m->unsent_req_list); | |
531b1094 | 289 | m->rcall = NULL; |
3cf6429a | 290 | m->rpos = 0; |
531b1094 | 291 | m->rbuf = NULL; |
3cf6429a | 292 | m->wpos = m->wsize = 0; |
531b1094 | 293 | m->wbuf = NULL; |
3cf6429a LI |
294 | INIT_WORK(&m->rq, v9fs_read_work, m); |
295 | INIT_WORK(&m->wq, v9fs_write_work, m); | |
296 | m->wsched = 0; | |
297 | memset(&m->poll_waddr, 0, sizeof(m->poll_waddr)); | |
1dac06b2 LI |
298 | m->poll_task = NULL; |
299 | n = v9fs_mux_poll_start(m); | |
300 | if (n) | |
301 | return ERR_PTR(n); | |
3cf6429a LI |
302 | |
303 | n = trans->poll(trans, &m->pt); | |
304 | if (n & POLLIN) { | |
305 | dprintk(DEBUG_MUX, "mux %p can read\n", m); | |
306 | set_bit(Rpending, &m->wsched); | |
426cc91a EVH |
307 | } |
308 | ||
3cf6429a LI |
309 | if (n & POLLOUT) { |
310 | dprintk(DEBUG_MUX, "mux %p can write\n", m); | |
311 | set_bit(Wpending, &m->wsched); | |
426cc91a EVH |
312 | } |
313 | ||
3cf6429a LI |
314 | for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) { |
315 | if (IS_ERR(m->poll_waddr[i])) { | |
316 | v9fs_mux_poll_stop(m); | |
317 | mtmp = (void *)m->poll_waddr; /* the error code */ | |
318 | kfree(m); | |
319 | m = mtmp; | |
320 | break; | |
321 | } | |
426cc91a EVH |
322 | } |
323 | ||
3cf6429a LI |
324 | return m; |
325 | } | |
426cc91a | 326 | |
3cf6429a LI |
327 | /** |
328 | * v9fs_mux_destroy - cancels all pending requests and frees mux resources | |
329 | */ | |
330 | void v9fs_mux_destroy(struct v9fs_mux_data *m) | |
331 | { | |
332 | dprintk(DEBUG_MUX, "mux %p prev %p next %p\n", m, | |
333 | m->mux_list.prev, m->mux_list.next); | |
334 | v9fs_mux_cancel(m, -ECONNRESET); | |
335 | ||
336 | if (!list_empty(&m->req_list)) { | |
337 | /* wait until all processes waiting on this session exit */ | |
338 | dprintk(DEBUG_MUX, "mux %p waiting for empty request queue\n", | |
339 | m); | |
340 | wait_event_timeout(m->equeue, (list_empty(&m->req_list)), 5000); | |
341 | dprintk(DEBUG_MUX, "mux %p request queue empty: %d\n", m, | |
342 | list_empty(&m->req_list)); | |
343 | } | |
426cc91a | 344 | |
3cf6429a LI |
345 | v9fs_mux_poll_stop(m); |
346 | m->trans = NULL; | |
426cc91a | 347 | |
3cf6429a | 348 | kfree(m); |
426cc91a EVH |
349 | } |
350 | ||
351 | /** | |
3cf6429a LI |
352 | * v9fs_pollwait - called by files poll operation to add v9fs-poll task |
353 | * to files wait queue | |
426cc91a | 354 | */ |
3cf6429a LI |
355 | static void |
356 | v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address, | |
357 | poll_table * p) | |
426cc91a | 358 | { |
3cf6429a LI |
359 | int i; |
360 | struct v9fs_mux_data *m; | |
426cc91a | 361 | |
3cf6429a LI |
362 | m = container_of(p, struct v9fs_mux_data, pt); |
363 | for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) | |
364 | if (m->poll_waddr[i] == NULL) | |
365 | break; | |
cb2e87a6 | 366 | |
3cf6429a LI |
367 | if (i >= ARRAY_SIZE(m->poll_waddr)) { |
368 | dprintk(DEBUG_ERROR, "not enough wait_address slots\n"); | |
369 | return; | |
370 | } | |
cb2e87a6 | 371 | |
3cf6429a | 372 | m->poll_waddr[i] = wait_address; |
cb2e87a6 | 373 | |
3cf6429a LI |
374 | if (!wait_address) { |
375 | dprintk(DEBUG_ERROR, "no wait_address\n"); | |
376 | m->poll_waddr[i] = ERR_PTR(-EIO); | |
377 | return; | |
378 | } | |
426cc91a | 379 | |
3cf6429a LI |
380 | init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task); |
381 | add_wait_queue(wait_address, &m->poll_wait[i]); | |
426cc91a EVH |
382 | } |
383 | ||
384 | /** | |
3cf6429a | 385 | * v9fs_poll_mux - polls a mux and schedules read or write works if necessary |
426cc91a | 386 | */ |
29c6e486 | 387 | static void v9fs_poll_mux(struct v9fs_mux_data *m) |
426cc91a | 388 | { |
3cf6429a | 389 | int n; |
426cc91a | 390 | |
3cf6429a LI |
391 | if (m->err < 0) |
392 | return; | |
393 | ||
394 | n = m->trans->poll(m->trans, NULL); | |
395 | if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) { | |
396 | dprintk(DEBUG_MUX, "error mux %p err %d\n", m, n); | |
397 | if (n >= 0) | |
398 | n = -ECONNRESET; | |
399 | v9fs_mux_cancel(m, n); | |
400 | } | |
401 | ||
402 | if (n & POLLIN) { | |
403 | set_bit(Rpending, &m->wsched); | |
404 | dprintk(DEBUG_MUX, "mux %p can read\n", m); | |
405 | if (!test_and_set_bit(Rworksched, &m->wsched)) { | |
406 | dprintk(DEBUG_MUX, "schedule read work mux %p\n", m); | |
407 | queue_work(v9fs_mux_wq, &m->rq); | |
408 | } | |
409 | } | |
426cc91a | 410 | |
3cf6429a LI |
411 | if (n & POLLOUT) { |
412 | set_bit(Wpending, &m->wsched); | |
413 | dprintk(DEBUG_MUX, "mux %p can write\n", m); | |
414 | if ((m->wsize || !list_empty(&m->unsent_req_list)) | |
415 | && !test_and_set_bit(Wworksched, &m->wsched)) { | |
416 | dprintk(DEBUG_MUX, "schedule write work mux %p\n", m); | |
417 | queue_work(v9fs_mux_wq, &m->wq); | |
418 | } | |
419 | } | |
426cc91a EVH |
420 | } |
421 | ||
422 | /** | |
3cf6429a LI |
423 | * v9fs_poll_proc - polls all v9fs transports for new events and queues |
424 | * the appropriate work to the work queue | |
426cc91a | 425 | */ |
3cf6429a | 426 | static int v9fs_poll_proc(void *a) |
426cc91a | 427 | { |
3cf6429a LI |
428 | struct v9fs_mux_data *m, *mtmp; |
429 | struct v9fs_mux_poll_task *vpt; | |
426cc91a | 430 | |
3cf6429a LI |
431 | vpt = a; |
432 | dprintk(DEBUG_MUX, "start %p %p\n", current, vpt); | |
433 | allow_signal(SIGKILL); | |
434 | while (!kthread_should_stop()) { | |
435 | set_current_state(TASK_INTERRUPTIBLE); | |
436 | if (signal_pending(current)) | |
437 | break; | |
426cc91a | 438 | |
3cf6429a LI |
439 | list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) { |
440 | v9fs_poll_mux(m); | |
441 | } | |
442 | ||
443 | dprintk(DEBUG_MUX, "sleeping...\n"); | |
444 | schedule_timeout(SCHED_TIMEOUT * HZ); | |
445 | } | |
cb2e87a6 | 446 | |
3cf6429a LI |
447 | __set_current_state(TASK_RUNNING); |
448 | dprintk(DEBUG_MUX, "finish\n"); | |
449 | return 0; | |
450 | } | |
426cc91a | 451 | |
3cf6429a LI |
452 | /** |
453 | * v9fs_write_work - called when a transport can send some data | |
454 | */ | |
455 | static void v9fs_write_work(void *a) | |
456 | { | |
457 | int n, err; | |
458 | struct v9fs_mux_data *m; | |
531b1094 | 459 | struct v9fs_req *req; |
426cc91a | 460 | |
3cf6429a | 461 | m = a; |
426cc91a | 462 | |
3cf6429a LI |
463 | if (m->err < 0) { |
464 | clear_bit(Wworksched, &m->wsched); | |
465 | return; | |
426cc91a EVH |
466 | } |
467 | ||
3cf6429a LI |
468 | if (!m->wsize) { |
469 | if (list_empty(&m->unsent_req_list)) { | |
470 | clear_bit(Wworksched, &m->wsched); | |
471 | return; | |
426cc91a EVH |
472 | } |
473 | ||
3cf6429a | 474 | spin_lock(&m->lock); |
034b91a3 LI |
475 | again: |
476 | req = list_entry(m->unsent_req_list.next, struct v9fs_req, | |
531b1094 LI |
477 | req_list); |
478 | list_move_tail(&req->req_list, &m->req_list); | |
034b91a3 LI |
479 | if (req->err == ERREQFLUSH) |
480 | goto again; | |
481 | ||
531b1094 LI |
482 | m->wbuf = req->tcall->sdata; |
483 | m->wsize = req->tcall->size; | |
3cf6429a | 484 | m->wpos = 0; |
531b1094 | 485 | dump_data(m->wbuf, m->wsize); |
3cf6429a | 486 | spin_unlock(&m->lock); |
426cc91a EVH |
487 | } |
488 | ||
3cf6429a LI |
489 | dprintk(DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos, m->wsize); |
490 | clear_bit(Wpending, &m->wsched); | |
491 | err = m->trans->write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos); | |
492 | dprintk(DEBUG_MUX, "mux %p sent %d bytes\n", m, err); | |
493 | if (err == -EAGAIN) { | |
494 | clear_bit(Wworksched, &m->wsched); | |
495 | return; | |
496 | } | |
497 | ||
498 | if (err <= 0) | |
499 | goto error; | |
500 | ||
501 | m->wpos += err; | |
502 | if (m->wpos == m->wsize) | |
503 | m->wpos = m->wsize = 0; | |
504 | ||
505 | if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) { | |
506 | if (test_and_clear_bit(Wpending, &m->wsched)) | |
507 | n = POLLOUT; | |
508 | else | |
509 | n = m->trans->poll(m->trans, NULL); | |
510 | ||
511 | if (n & POLLOUT) { | |
512 | dprintk(DEBUG_MUX, "schedule write work mux %p\n", m); | |
513 | queue_work(v9fs_mux_wq, &m->wq); | |
514 | } else | |
515 | clear_bit(Wworksched, &m->wsched); | |
516 | } else | |
517 | clear_bit(Wworksched, &m->wsched); | |
426cc91a | 518 | |
3cf6429a LI |
519 | return; |
520 | ||
521 | error: | |
522 | v9fs_mux_cancel(m, err); | |
523 | clear_bit(Wworksched, &m->wsched); | |
426cc91a EVH |
524 | } |
525 | ||
3cf6429a | 526 | static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req) |
322b329a | 527 | { |
3cf6429a | 528 | int ecode, tag; |
531b1094 | 529 | struct v9fs_str *ename; |
3cf6429a LI |
530 | |
531 | tag = req->tag; | |
034b91a3 | 532 | if (!req->err && req->rcall->id == RERROR) { |
3cf6429a | 533 | ecode = req->rcall->params.rerror.errno; |
531b1094 | 534 | ename = &req->rcall->params.rerror.error; |
322b329a | 535 | |
531b1094 | 536 | dprintk(DEBUG_MUX, "Rerror %.*s\n", ename->len, ename->str); |
3cf6429a LI |
537 | |
538 | if (*m->extended) | |
539 | req->err = -ecode; | |
540 | ||
541 | if (!req->err) { | |
531b1094 | 542 | req->err = v9fs_errstr2errno(ename->str, ename->len); |
3cf6429a LI |
543 | |
544 | if (!req->err) { /* string match failed */ | |
531b1094 | 545 | PRINT_FCALL_ERROR("unknown error", req->rcall); |
3cf6429a LI |
546 | } |
547 | ||
548 | if (!req->err) | |
549 | req->err = -ESERVERFAULT; | |
550 | } | |
551 | } else if (req->tcall && req->rcall->id != req->tcall->id + 1) { | |
552 | dprintk(DEBUG_ERROR, "fcall mismatch: expected %d, got %d\n", | |
553 | req->tcall->id + 1, req->rcall->id); | |
554 | if (!req->err) | |
555 | req->err = -EIO; | |
322b329a | 556 | } |
3cf6429a | 557 | |
034b91a3 LI |
558 | if (req->err == ERREQFLUSH) |
559 | return; | |
560 | ||
561 | if (req->cb) { | |
3cf6429a LI |
562 | dprintk(DEBUG_MUX, "calling callback tcall %p rcall %p\n", |
563 | req->tcall, req->rcall); | |
564 | ||
565 | (*req->cb) (req->cba, req->tcall, req->rcall, req->err); | |
566 | req->cb = NULL; | |
567 | } else | |
568 | kfree(req->rcall); | |
569 | ||
531b1094 | 570 | v9fs_mux_put_tag(m, tag); |
3cf6429a LI |
571 | |
572 | wake_up(&m->equeue); | |
573 | kfree(req); | |
322b329a EVH |
574 | } |
575 | ||
426cc91a | 576 | /** |
3cf6429a | 577 | * v9fs_read_work - called when there is some data to be read from a transport |
426cc91a | 578 | */ |
3cf6429a | 579 | static void v9fs_read_work(void *a) |
426cc91a | 580 | { |
531b1094 | 581 | int n, err; |
3cf6429a LI |
582 | struct v9fs_mux_data *m; |
583 | struct v9fs_req *req, *rptr, *rreq; | |
584 | struct v9fs_fcall *rcall; | |
531b1094 | 585 | char *rbuf; |
3cf6429a LI |
586 | |
587 | m = a; | |
588 | ||
589 | if (m->err < 0) | |
590 | return; | |
591 | ||
592 | rcall = NULL; | |
593 | dprintk(DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos); | |
531b1094 LI |
594 | |
595 | if (!m->rcall) { | |
596 | m->rcall = | |
597 | kmalloc(sizeof(struct v9fs_fcall) + m->msize, GFP_KERNEL); | |
598 | if (!m->rcall) { | |
599 | err = -ENOMEM; | |
600 | goto error; | |
601 | } | |
602 | ||
603 | m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall); | |
604 | m->rpos = 0; | |
605 | } | |
606 | ||
3cf6429a LI |
607 | clear_bit(Rpending, &m->wsched); |
608 | err = m->trans->read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos); | |
609 | dprintk(DEBUG_MUX, "mux %p got %d bytes\n", m, err); | |
610 | if (err == -EAGAIN) { | |
611 | clear_bit(Rworksched, &m->wsched); | |
612 | return; | |
613 | } | |
426cc91a | 614 | |
3cf6429a LI |
615 | if (err <= 0) |
616 | goto error; | |
426cc91a | 617 | |
3cf6429a LI |
618 | m->rpos += err; |
619 | while (m->rpos > 4) { | |
620 | n = le32_to_cpu(*(__le32 *) m->rbuf); | |
621 | if (n >= m->msize) { | |
622 | dprintk(DEBUG_ERROR, | |
623 | "requested packet size too big: %d\n", n); | |
624 | err = -EIO; | |
625 | goto error; | |
626 | } | |
627 | ||
628 | if (m->rpos < n) | |
426cc91a | 629 | break; |
3cf6429a | 630 | |
3cf6429a | 631 | dump_data(m->rbuf, n); |
531b1094 LI |
632 | err = |
633 | v9fs_deserialize_fcall(m->rbuf, n, m->rcall, *m->extended); | |
cb2e87a6 | 634 | if (err < 0) { |
3cf6429a | 635 | goto error; |
426cc91a EVH |
636 | } |
637 | ||
531b1094 LI |
638 | rcall = m->rcall; |
639 | rbuf = m->rbuf; | |
640 | if (m->rpos > n) { | |
641 | m->rcall = kmalloc(sizeof(struct v9fs_fcall) + m->msize, | |
642 | GFP_KERNEL); | |
643 | if (!m->rcall) { | |
644 | err = -ENOMEM; | |
645 | goto error; | |
646 | } | |
647 | ||
648 | m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall); | |
649 | memmove(m->rbuf, rbuf + n, m->rpos - n); | |
650 | m->rpos -= n; | |
651 | } else { | |
652 | m->rcall = NULL; | |
653 | m->rbuf = NULL; | |
654 | m->rpos = 0; | |
655 | } | |
656 | ||
3cf6429a LI |
657 | dprintk(DEBUG_MUX, "mux %p fcall id %d tag %d\n", m, rcall->id, |
658 | rcall->tag); | |
659 | ||
660 | req = NULL; | |
661 | spin_lock(&m->lock); | |
662 | list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) { | |
663 | if (rreq->tag == rcall->tag) { | |
664 | req = rreq; | |
665 | req->rcall = rcall; | |
666 | list_del(&req->req_list); | |
667 | spin_unlock(&m->lock); | |
668 | process_request(m, req); | |
669 | break; | |
426cc91a | 670 | } |
531b1094 | 671 | |
426cc91a EVH |
672 | } |
673 | ||
426cc91a | 674 | if (!req) { |
3cf6429a LI |
675 | spin_unlock(&m->lock); |
676 | if (err >= 0 && rcall->id != RFLUSH) | |
cb2e87a6 | 677 | dprintk(DEBUG_ERROR, |
3cf6429a LI |
678 | "unexpected response mux %p id %d tag %d\n", |
679 | m, rcall->id, rcall->tag); | |
426cc91a EVH |
680 | kfree(rcall); |
681 | } | |
426cc91a EVH |
682 | } |
683 | ||
3cf6429a LI |
684 | if (!list_empty(&m->req_list)) { |
685 | if (test_and_clear_bit(Rpending, &m->wsched)) | |
686 | n = POLLIN; | |
687 | else | |
688 | n = m->trans->poll(m->trans, NULL); | |
689 | ||
690 | if (n & POLLIN) { | |
691 | dprintk(DEBUG_MUX, "schedule read work mux %p\n", m); | |
692 | queue_work(v9fs_mux_wq, &m->rq); | |
693 | } else | |
694 | clear_bit(Rworksched, &m->wsched); | |
695 | } else | |
696 | clear_bit(Rworksched, &m->wsched); | |
426cc91a | 697 | |
3cf6429a | 698 | return; |
426cc91a | 699 | |
3cf6429a LI |
700 | error: |
701 | v9fs_mux_cancel(m, err); | |
702 | clear_bit(Rworksched, &m->wsched); | |
426cc91a EVH |
703 | } |
704 | ||
705 | /** | |
3cf6429a LI |
706 | * v9fs_send_request - send 9P request |
707 | * The function can sleep until the request is scheduled for sending. | |
708 | * The function can be interrupted. Return from the function is not | |
709 | * a guarantee that the request is sent succesfully. Can return errors | |
710 | * that can be retrieved by PTR_ERR macros. | |
426cc91a | 711 | * |
3cf6429a LI |
712 | * @m: mux data |
713 | * @tc: request to be sent | |
714 | * @cb: callback function to call when response is received | |
715 | * @cba: parameter to pass to the callback function | |
426cc91a | 716 | */ |
3cf6429a LI |
717 | static struct v9fs_req *v9fs_send_request(struct v9fs_mux_data *m, |
718 | struct v9fs_fcall *tc, | |
719 | v9fs_mux_req_callback cb, void *cba) | |
720 | { | |
721 | int n; | |
722 | struct v9fs_req *req; | |
723 | ||
724 | dprintk(DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current, | |
725 | tc, tc->id); | |
726 | if (m->err < 0) | |
727 | return ERR_PTR(m->err); | |
728 | ||
729 | req = kmalloc(sizeof(struct v9fs_req), GFP_KERNEL); | |
730 | if (!req) | |
731 | return ERR_PTR(-ENOMEM); | |
426cc91a | 732 | |
3cf6429a LI |
733 | if (tc->id == TVERSION) |
734 | n = V9FS_NOTAG; | |
735 | else | |
531b1094 | 736 | n = v9fs_mux_get_tag(m); |
3cf6429a LI |
737 | |
738 | if (n < 0) | |
739 | return ERR_PTR(-ENOMEM); | |
740 | ||
531b1094 LI |
741 | v9fs_set_tag(tc, n); |
742 | ||
3cf6429a LI |
743 | req->tag = n; |
744 | req->tcall = tc; | |
745 | req->rcall = NULL; | |
746 | req->err = 0; | |
747 | req->cb = cb; | |
748 | req->cba = cba; | |
749 | ||
750 | spin_lock(&m->lock); | |
751 | list_add_tail(&req->req_list, &m->unsent_req_list); | |
752 | spin_unlock(&m->lock); | |
753 | ||
754 | if (test_and_clear_bit(Wpending, &m->wsched)) | |
755 | n = POLLOUT; | |
756 | else | |
757 | n = m->trans->poll(m->trans, NULL); | |
758 | ||
759 | if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched)) | |
760 | queue_work(v9fs_mux_wq, &m->wq); | |
761 | ||
762 | return req; | |
763 | } | |
764 | ||
29c6e486 AB |
765 | static void v9fs_mux_flush_cb(void *a, struct v9fs_fcall *tc, |
766 | struct v9fs_fcall *rc, int err) | |
426cc91a | 767 | { |
3cf6429a LI |
768 | v9fs_mux_req_callback cb; |
769 | int tag; | |
770 | struct v9fs_mux_data *m; | |
771 | struct v9fs_req *req, *rptr; | |
772 | ||
773 | m = a; | |
774 | dprintk(DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m, tc, | |
775 | rc, err, tc->params.tflush.oldtag); | |
776 | ||
777 | spin_lock(&m->lock); | |
778 | cb = NULL; | |
779 | tag = tc->params.tflush.oldtag; | |
780 | list_for_each_entry_safe(req, rptr, &m->req_list, req_list) { | |
781 | if (req->tag == tag) { | |
782 | list_del(&req->req_list); | |
783 | if (req->cb) { | |
784 | cb = req->cb; | |
785 | req->cb = NULL; | |
786 | spin_unlock(&m->lock); | |
787 | (*cb) (req->cba, req->tcall, req->rcall, | |
788 | req->err); | |
789 | } | |
790 | kfree(req); | |
791 | wake_up(&m->equeue); | |
792 | break; | |
793 | } | |
794 | } | |
795 | ||
796 | if (!cb) | |
797 | spin_unlock(&m->lock); | |
798 | ||
531b1094 | 799 | v9fs_mux_put_tag(m, tag); |
3cf6429a LI |
800 | kfree(tc); |
801 | kfree(rc); | |
802 | } | |
803 | ||
804 | static void | |
805 | v9fs_mux_flush_request(struct v9fs_mux_data *m, struct v9fs_req *req) | |
806 | { | |
807 | struct v9fs_fcall *fc; | |
808 | ||
809 | dprintk(DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag); | |
810 | ||
531b1094 | 811 | fc = v9fs_create_tflush(req->tag); |
3cf6429a LI |
812 | v9fs_send_request(m, fc, v9fs_mux_flush_cb, m); |
813 | } | |
814 | ||
815 | static void | |
816 | v9fs_mux_rpc_cb(void *a, struct v9fs_fcall *tc, struct v9fs_fcall *rc, int err) | |
817 | { | |
818 | struct v9fs_mux_rpc *r; | |
819 | ||
820 | if (err == ERREQFLUSH) { | |
034b91a3 | 821 | kfree(rc); |
3cf6429a LI |
822 | dprintk(DEBUG_MUX, "err req flush\n"); |
823 | return; | |
824 | } | |
825 | ||
826 | r = a; | |
827 | dprintk(DEBUG_MUX, "mux %p req %p tc %p rc %p err %d\n", r->m, r->req, | |
828 | tc, rc, err); | |
829 | r->rcall = rc; | |
830 | r->err = err; | |
831 | wake_up(&r->wqueue); | |
832 | } | |
833 | ||
834 | /** | |
835 | * v9fs_mux_rpc - sends 9P request and waits until a response is available. | |
836 | * The function can be interrupted. | |
837 | * @m: mux data | |
838 | * @tc: request to be sent | |
839 | * @rc: pointer where a pointer to the response is stored | |
840 | */ | |
841 | int | |
842 | v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc, | |
843 | struct v9fs_fcall **rc) | |
844 | { | |
845 | int err; | |
846 | unsigned long flags; | |
847 | struct v9fs_req *req; | |
848 | struct v9fs_mux_rpc r; | |
849 | ||
850 | r.err = 0; | |
851 | r.rcall = NULL; | |
852 | r.m = m; | |
853 | init_waitqueue_head(&r.wqueue); | |
854 | ||
855 | if (rc) | |
856 | *rc = NULL; | |
857 | ||
858 | req = v9fs_send_request(m, tc, v9fs_mux_rpc_cb, &r); | |
859 | if (IS_ERR(req)) { | |
860 | err = PTR_ERR(req); | |
861 | dprintk(DEBUG_MUX, "error %d\n", err); | |
862 | return PTR_ERR(req); | |
863 | } | |
864 | ||
865 | r.req = req; | |
866 | dprintk(DEBUG_MUX, "mux %p tc %p tag %d rpc %p req %p\n", m, tc, | |
867 | req->tag, &r, req); | |
868 | err = wait_event_interruptible(r.wqueue, r.rcall != NULL || r.err < 0); | |
869 | if (r.err < 0) | |
870 | err = r.err; | |
871 | ||
872 | if (err == -ERESTARTSYS && m->trans->status == Connected && m->err == 0) { | |
873 | spin_lock(&m->lock); | |
874 | req->tcall = NULL; | |
875 | req->err = ERREQFLUSH; | |
876 | spin_unlock(&m->lock); | |
877 | ||
878 | clear_thread_flag(TIF_SIGPENDING); | |
879 | v9fs_mux_flush_request(m, req); | |
880 | spin_lock_irqsave(¤t->sighand->siglock, flags); | |
881 | recalc_sigpending(); | |
882 | spin_unlock_irqrestore(¤t->sighand->siglock, flags); | |
426cc91a EVH |
883 | } |
884 | ||
3cf6429a LI |
885 | if (!err) { |
886 | if (r.rcall) | |
887 | dprintk(DEBUG_MUX, "got response id %d tag %d\n", | |
888 | r.rcall->id, r.rcall->tag); | |
889 | ||
890 | if (rc) | |
891 | *rc = r.rcall; | |
892 | else | |
893 | kfree(r.rcall); | |
894 | } else { | |
895 | kfree(r.rcall); | |
896 | dprintk(DEBUG_MUX, "got error %d\n", err); | |
897 | if (err > 0) | |
898 | err = -EIO; | |
899 | } | |
900 | ||
901 | return err; | |
902 | } | |
903 | ||
29c6e486 | 904 | #if 0 |
3cf6429a LI |
905 | /** |
906 | * v9fs_mux_rpcnb - sends 9P request without waiting for response. | |
907 | * @m: mux data | |
908 | * @tc: request to be sent | |
909 | * @cb: callback function to be called when response arrives | |
910 | * @cba: value to pass to the callback function | |
911 | */ | |
912 | int v9fs_mux_rpcnb(struct v9fs_mux_data *m, struct v9fs_fcall *tc, | |
913 | v9fs_mux_req_callback cb, void *a) | |
914 | { | |
915 | int err; | |
916 | struct v9fs_req *req; | |
917 | ||
918 | req = v9fs_send_request(m, tc, cb, a); | |
919 | if (IS_ERR(req)) { | |
920 | err = PTR_ERR(req); | |
921 | dprintk(DEBUG_MUX, "error %d\n", err); | |
922 | return PTR_ERR(req); | |
923 | } | |
426cc91a | 924 | |
3cf6429a | 925 | dprintk(DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag); |
426cc91a EVH |
926 | return 0; |
927 | } | |
29c6e486 | 928 | #endif /* 0 */ |
3cf6429a LI |
929 | |
930 | /** | |
931 | * v9fs_mux_cancel - cancel all pending requests with error | |
932 | * @m: mux data | |
933 | * @err: error code | |
934 | */ | |
935 | void v9fs_mux_cancel(struct v9fs_mux_data *m, int err) | |
936 | { | |
937 | struct v9fs_req *req, *rtmp; | |
938 | LIST_HEAD(cancel_list); | |
939 | ||
940 | dprintk(DEBUG_MUX, "mux %p err %d\n", m, err); | |
941 | m->err = err; | |
942 | spin_lock(&m->lock); | |
943 | list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) { | |
944 | list_move(&req->req_list, &cancel_list); | |
945 | } | |
946 | spin_unlock(&m->lock); | |
947 | ||
948 | list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) { | |
949 | list_del(&req->req_list); | |
950 | if (!req->err) | |
951 | req->err = err; | |
952 | ||
953 | if (req->cb) | |
954 | (*req->cb) (req->cba, req->tcall, req->rcall, req->err); | |
955 | else | |
956 | kfree(req->rcall); | |
957 | ||
958 | kfree(req); | |
959 | } | |
960 | ||
961 | wake_up(&m->equeue); | |
962 | } | |
531b1094 LI |
963 | |
964 | static u16 v9fs_mux_get_tag(struct v9fs_mux_data *m) | |
965 | { | |
966 | int tag; | |
967 | ||
4a26c242 | 968 | tag = v9fs_get_idpool(&m->tagpool); |
531b1094 LI |
969 | if (tag < 0) |
970 | return V9FS_NOTAG; | |
971 | else | |
972 | return (u16) tag; | |
973 | } | |
974 | ||
975 | static void v9fs_mux_put_tag(struct v9fs_mux_data *m, u16 tag) | |
976 | { | |
4a26c242 RC |
977 | if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tagpool)) |
978 | v9fs_put_idpool(tag, &m->tagpool); | |
531b1094 | 979 | } |