6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2
11 * as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to:
20 * Free Software Foundation
21 * 51 Franklin Street, Fifth Floor
22 * Boston, MA 02111-1301 USA
26 #include <linux/config.h>
27 #include <linux/module.h>
28 #include <linux/errno.h>
30 #include <linux/poll.h>
31 #include <linux/kthread.h>
32 #include <linux/idr.h>
33 #include <linux/mutex.h>
39 #include "transport.h"
43 #define SCHED_TIMEOUT 10
44 #define MAXPOLLWADDR 2
47 Rworksched
= 1, /* read work scheduled or running */
48 Rpending
= 2, /* can read */
49 Wworksched
= 4, /* write work scheduled or running */
50 Wpending
= 8, /* can write */
53 struct v9fs_mux_poll_task
;
57 struct v9fs_fcall
*tcall
;
58 struct v9fs_fcall
*rcall
;
60 v9fs_mux_req_callback cb
;
62 struct list_head req_list
;
65 struct v9fs_mux_data
{
67 struct list_head mux_list
;
68 struct v9fs_mux_poll_task
*poll_task
;
70 unsigned char *extended
;
71 struct v9fs_transport
*trans
;
72 struct v9fs_idpool tagpool
;
74 wait_queue_head_t equeue
;
75 struct list_head req_list
;
76 struct list_head unsent_req_list
;
77 struct v9fs_fcall
*rcall
;
83 wait_queue_t poll_wait
[MAXPOLLWADDR
];
84 wait_queue_head_t
*poll_waddr
[MAXPOLLWADDR
];
86 struct work_struct rq
;
87 struct work_struct wq
;
91 struct v9fs_mux_poll_task
{
92 struct task_struct
*task
;
93 struct list_head mux_list
;
98 struct v9fs_mux_data
*m
;
101 struct v9fs_fcall
*rcall
;
102 wait_queue_head_t wqueue
;
105 static int v9fs_poll_proc(void *);
106 static void v9fs_read_work(void *);
107 static void v9fs_write_work(void *);
108 static void v9fs_pollwait(struct file
*filp
, wait_queue_head_t
* wait_address
,
110 static u16
v9fs_mux_get_tag(struct v9fs_mux_data
*);
111 static void v9fs_mux_put_tag(struct v9fs_mux_data
*, u16
);
113 static DEFINE_MUTEX(v9fs_mux_task_lock
);
114 static struct workqueue_struct
*v9fs_mux_wq
;
116 static int v9fs_mux_num
;
117 static int v9fs_mux_poll_task_num
;
118 static struct v9fs_mux_poll_task v9fs_mux_poll_tasks
[100];
120 int v9fs_mux_global_init(void)
124 for (i
= 0; i
< ARRAY_SIZE(v9fs_mux_poll_tasks
); i
++)
125 v9fs_mux_poll_tasks
[i
].task
= NULL
;
127 v9fs_mux_wq
= create_workqueue("v9fs");
134 void v9fs_mux_global_exit(void)
136 destroy_workqueue(v9fs_mux_wq
);
140 * v9fs_mux_calc_poll_procs - calculates the number of polling procs
141 * based on the number of mounted v9fs filesystems.
143 * The current implementation returns sqrt of the number of mounts.
145 static int v9fs_mux_calc_poll_procs(int muxnum
)
149 if (v9fs_mux_poll_task_num
)
150 n
= muxnum
/ v9fs_mux_poll_task_num
+
151 (muxnum
% v9fs_mux_poll_task_num
? 1 : 0);
155 if (n
> ARRAY_SIZE(v9fs_mux_poll_tasks
))
156 n
= ARRAY_SIZE(v9fs_mux_poll_tasks
);
161 static int v9fs_mux_poll_start(struct v9fs_mux_data
*m
)
164 struct v9fs_mux_poll_task
*vpt
, *vptlast
;
165 struct task_struct
*pproc
;
167 dprintk(DEBUG_MUX
, "mux %p muxnum %d procnum %d\n", m
, v9fs_mux_num
,
168 v9fs_mux_poll_task_num
);
169 mutex_lock(&v9fs_mux_task_lock
);
171 n
= v9fs_mux_calc_poll_procs(v9fs_mux_num
+ 1);
172 if (n
> v9fs_mux_poll_task_num
) {
173 for (i
= 0; i
< ARRAY_SIZE(v9fs_mux_poll_tasks
); i
++) {
174 if (v9fs_mux_poll_tasks
[i
].task
== NULL
) {
175 vpt
= &v9fs_mux_poll_tasks
[i
];
176 dprintk(DEBUG_MUX
, "create proc %p\n", vpt
);
177 pproc
= kthread_create(v9fs_poll_proc
, vpt
,
180 if (!IS_ERR(pproc
)) {
182 INIT_LIST_HEAD(&vpt
->mux_list
);
184 v9fs_mux_poll_task_num
++;
185 wake_up_process(vpt
->task
);
191 if (i
>= ARRAY_SIZE(v9fs_mux_poll_tasks
))
192 dprintk(DEBUG_ERROR
, "warning: no free poll slots\n");
195 n
= (v9fs_mux_num
+ 1) / v9fs_mux_poll_task_num
+
196 ((v9fs_mux_num
+ 1) % v9fs_mux_poll_task_num
? 1 : 0);
199 for (i
= 0; i
< ARRAY_SIZE(v9fs_mux_poll_tasks
); i
++) {
200 vpt
= &v9fs_mux_poll_tasks
[i
];
201 if (vpt
->task
!= NULL
) {
203 if (vpt
->muxnum
< n
) {
204 dprintk(DEBUG_MUX
, "put in proc %d\n", i
);
205 list_add(&m
->mux_list
, &vpt
->mux_list
);
208 memset(&m
->poll_waddr
, 0, sizeof(m
->poll_waddr
));
209 init_poll_funcptr(&m
->pt
, v9fs_pollwait
);
215 if (i
>= ARRAY_SIZE(v9fs_mux_poll_tasks
)) {
219 dprintk(DEBUG_MUX
, "put in proc %d\n", i
);
220 list_add(&m
->mux_list
, &vptlast
->mux_list
);
222 m
->poll_task
= vptlast
;
223 memset(&m
->poll_waddr
, 0, sizeof(m
->poll_waddr
));
224 init_poll_funcptr(&m
->pt
, v9fs_pollwait
);
228 mutex_unlock(&v9fs_mux_task_lock
);
233 static void v9fs_mux_poll_stop(struct v9fs_mux_data
*m
)
236 struct v9fs_mux_poll_task
*vpt
;
238 mutex_lock(&v9fs_mux_task_lock
);
240 list_del(&m
->mux_list
);
241 for(i
= 0; i
< ARRAY_SIZE(m
->poll_waddr
); i
++) {
242 if (m
->poll_waddr
[i
] != NULL
) {
243 remove_wait_queue(m
->poll_waddr
[i
], &m
->poll_wait
[i
]);
244 m
->poll_waddr
[i
] = NULL
;
249 dprintk(DEBUG_MUX
, "destroy proc %p\n", vpt
);
250 send_sig(SIGKILL
, vpt
->task
, 1);
252 v9fs_mux_poll_task_num
--;
255 mutex_unlock(&v9fs_mux_task_lock
);
259 * v9fs_mux_init - allocate and initialize the per-session mux data
260 * Creates the polling task if this is the first session.
262 * @trans - transport structure
263 * @msize - maximum message size
264 * @extended - pointer to the extended flag
266 struct v9fs_mux_data
*v9fs_mux_init(struct v9fs_transport
*trans
, int msize
,
267 unsigned char *extended
)
270 struct v9fs_mux_data
*m
, *mtmp
;
272 dprintk(DEBUG_MUX
, "transport %p msize %d\n", trans
, msize
);
273 m
= kmalloc(sizeof(struct v9fs_mux_data
), GFP_KERNEL
);
275 return ERR_PTR(-ENOMEM
);
277 spin_lock_init(&m
->lock
);
278 INIT_LIST_HEAD(&m
->mux_list
);
280 m
->extended
= extended
;
282 idr_init(&m
->tagpool
.pool
);
283 init_MUTEX(&m
->tagpool
.lock
);
285 init_waitqueue_head(&m
->equeue
);
286 INIT_LIST_HEAD(&m
->req_list
);
287 INIT_LIST_HEAD(&m
->unsent_req_list
);
291 m
->wpos
= m
->wsize
= 0;
293 INIT_WORK(&m
->rq
, v9fs_read_work
, m
);
294 INIT_WORK(&m
->wq
, v9fs_write_work
, m
);
296 memset(&m
->poll_waddr
, 0, sizeof(m
->poll_waddr
));
298 n
= v9fs_mux_poll_start(m
);
302 n
= trans
->poll(trans
, &m
->pt
);
304 dprintk(DEBUG_MUX
, "mux %p can read\n", m
);
305 set_bit(Rpending
, &m
->wsched
);
309 dprintk(DEBUG_MUX
, "mux %p can write\n", m
);
310 set_bit(Wpending
, &m
->wsched
);
313 for(i
= 0; i
< ARRAY_SIZE(m
->poll_waddr
); i
++) {
314 if (IS_ERR(m
->poll_waddr
[i
])) {
315 v9fs_mux_poll_stop(m
);
316 mtmp
= (void *)m
->poll_waddr
; /* the error code */
327 * v9fs_mux_destroy - cancels all pending requests and frees mux resources
329 void v9fs_mux_destroy(struct v9fs_mux_data
*m
)
331 dprintk(DEBUG_MUX
, "mux %p prev %p next %p\n", m
,
332 m
->mux_list
.prev
, m
->mux_list
.next
);
333 v9fs_mux_cancel(m
, -ECONNRESET
);
335 if (!list_empty(&m
->req_list
)) {
336 /* wait until all processes waiting on this session exit */
337 dprintk(DEBUG_MUX
, "mux %p waiting for empty request queue\n",
339 wait_event_timeout(m
->equeue
, (list_empty(&m
->req_list
)), 5000);
340 dprintk(DEBUG_MUX
, "mux %p request queue empty: %d\n", m
,
341 list_empty(&m
->req_list
));
344 v9fs_mux_poll_stop(m
);
351 * v9fs_pollwait - called by files poll operation to add v9fs-poll task
352 * to files wait queue
355 v9fs_pollwait(struct file
*filp
, wait_queue_head_t
* wait_address
,
359 struct v9fs_mux_data
*m
;
361 m
= container_of(p
, struct v9fs_mux_data
, pt
);
362 for(i
= 0; i
< ARRAY_SIZE(m
->poll_waddr
); i
++)
363 if (m
->poll_waddr
[i
] == NULL
)
366 if (i
>= ARRAY_SIZE(m
->poll_waddr
)) {
367 dprintk(DEBUG_ERROR
, "not enough wait_address slots\n");
371 m
->poll_waddr
[i
] = wait_address
;
374 dprintk(DEBUG_ERROR
, "no wait_address\n");
375 m
->poll_waddr
[i
] = ERR_PTR(-EIO
);
379 init_waitqueue_entry(&m
->poll_wait
[i
], m
->poll_task
->task
);
380 add_wait_queue(wait_address
, &m
->poll_wait
[i
]);
384 * v9fs_poll_mux - polls a mux and schedules read or write works if necessary
386 static void v9fs_poll_mux(struct v9fs_mux_data
*m
)
393 n
= m
->trans
->poll(m
->trans
, NULL
);
394 if (n
< 0 || n
& (POLLERR
| POLLHUP
| POLLNVAL
)) {
395 dprintk(DEBUG_MUX
, "error mux %p err %d\n", m
, n
);
398 v9fs_mux_cancel(m
, n
);
402 set_bit(Rpending
, &m
->wsched
);
403 dprintk(DEBUG_MUX
, "mux %p can read\n", m
);
404 if (!test_and_set_bit(Rworksched
, &m
->wsched
)) {
405 dprintk(DEBUG_MUX
, "schedule read work mux %p\n", m
);
406 queue_work(v9fs_mux_wq
, &m
->rq
);
411 set_bit(Wpending
, &m
->wsched
);
412 dprintk(DEBUG_MUX
, "mux %p can write\n", m
);
413 if ((m
->wsize
|| !list_empty(&m
->unsent_req_list
))
414 && !test_and_set_bit(Wworksched
, &m
->wsched
)) {
415 dprintk(DEBUG_MUX
, "schedule write work mux %p\n", m
);
416 queue_work(v9fs_mux_wq
, &m
->wq
);
422 * v9fs_poll_proc - polls all v9fs transports for new events and queues
423 * the appropriate work to the work queue
425 static int v9fs_poll_proc(void *a
)
427 struct v9fs_mux_data
*m
, *mtmp
;
428 struct v9fs_mux_poll_task
*vpt
;
431 dprintk(DEBUG_MUX
, "start %p %p\n", current
, vpt
);
432 allow_signal(SIGKILL
);
433 while (!kthread_should_stop()) {
434 set_current_state(TASK_INTERRUPTIBLE
);
435 if (signal_pending(current
))
438 list_for_each_entry_safe(m
, mtmp
, &vpt
->mux_list
, mux_list
) {
442 dprintk(DEBUG_MUX
, "sleeping...\n");
443 schedule_timeout(SCHED_TIMEOUT
* HZ
);
446 __set_current_state(TASK_RUNNING
);
447 dprintk(DEBUG_MUX
, "finish\n");
452 * v9fs_write_work - called when a transport can send some data
454 static void v9fs_write_work(void *a
)
457 struct v9fs_mux_data
*m
;
458 struct v9fs_req
*req
;
463 clear_bit(Wworksched
, &m
->wsched
);
468 if (list_empty(&m
->unsent_req_list
)) {
469 clear_bit(Wworksched
, &m
->wsched
);
475 req
= list_entry(m
->unsent_req_list
.next
, struct v9fs_req
,
477 list_move_tail(&req
->req_list
, &m
->req_list
);
478 if (req
->err
== ERREQFLUSH
)
481 m
->wbuf
= req
->tcall
->sdata
;
482 m
->wsize
= req
->tcall
->size
;
484 dump_data(m
->wbuf
, m
->wsize
);
485 spin_unlock(&m
->lock
);
488 dprintk(DEBUG_MUX
, "mux %p pos %d size %d\n", m
, m
->wpos
, m
->wsize
);
489 clear_bit(Wpending
, &m
->wsched
);
490 err
= m
->trans
->write(m
->trans
, m
->wbuf
+ m
->wpos
, m
->wsize
- m
->wpos
);
491 dprintk(DEBUG_MUX
, "mux %p sent %d bytes\n", m
, err
);
492 if (err
== -EAGAIN
) {
493 clear_bit(Wworksched
, &m
->wsched
);
501 if (m
->wpos
== m
->wsize
)
502 m
->wpos
= m
->wsize
= 0;
504 if (m
->wsize
== 0 && !list_empty(&m
->unsent_req_list
)) {
505 if (test_and_clear_bit(Wpending
, &m
->wsched
))
508 n
= m
->trans
->poll(m
->trans
, NULL
);
511 dprintk(DEBUG_MUX
, "schedule write work mux %p\n", m
);
512 queue_work(v9fs_mux_wq
, &m
->wq
);
514 clear_bit(Wworksched
, &m
->wsched
);
516 clear_bit(Wworksched
, &m
->wsched
);
521 v9fs_mux_cancel(m
, err
);
522 clear_bit(Wworksched
, &m
->wsched
);
525 static void process_request(struct v9fs_mux_data
*m
, struct v9fs_req
*req
)
528 struct v9fs_str
*ename
;
531 if (!req
->err
&& req
->rcall
->id
== RERROR
) {
532 ecode
= req
->rcall
->params
.rerror
.errno
;
533 ename
= &req
->rcall
->params
.rerror
.error
;
535 dprintk(DEBUG_MUX
, "Rerror %.*s\n", ename
->len
, ename
->str
);
541 req
->err
= v9fs_errstr2errno(ename
->str
, ename
->len
);
543 if (!req
->err
) { /* string match failed */
544 PRINT_FCALL_ERROR("unknown error", req
->rcall
);
548 req
->err
= -ESERVERFAULT
;
550 } else if (req
->tcall
&& req
->rcall
->id
!= req
->tcall
->id
+ 1) {
551 dprintk(DEBUG_ERROR
, "fcall mismatch: expected %d, got %d\n",
552 req
->tcall
->id
+ 1, req
->rcall
->id
);
557 if (req
->err
== ERREQFLUSH
)
561 dprintk(DEBUG_MUX
, "calling callback tcall %p rcall %p\n",
562 req
->tcall
, req
->rcall
);
564 (*req
->cb
) (req
->cba
, req
->tcall
, req
->rcall
, req
->err
);
569 v9fs_mux_put_tag(m
, tag
);
576 * v9fs_read_work - called when there is some data to be read from a transport
578 static void v9fs_read_work(void *a
)
581 struct v9fs_mux_data
*m
;
582 struct v9fs_req
*req
, *rptr
, *rreq
;
583 struct v9fs_fcall
*rcall
;
592 dprintk(DEBUG_MUX
, "start mux %p pos %d\n", m
, m
->rpos
);
596 kmalloc(sizeof(struct v9fs_fcall
) + m
->msize
, GFP_KERNEL
);
602 m
->rbuf
= (char *)m
->rcall
+ sizeof(struct v9fs_fcall
);
606 clear_bit(Rpending
, &m
->wsched
);
607 err
= m
->trans
->read(m
->trans
, m
->rbuf
+ m
->rpos
, m
->msize
- m
->rpos
);
608 dprintk(DEBUG_MUX
, "mux %p got %d bytes\n", m
, err
);
609 if (err
== -EAGAIN
) {
610 clear_bit(Rworksched
, &m
->wsched
);
618 while (m
->rpos
> 4) {
619 n
= le32_to_cpu(*(__le32
*) m
->rbuf
);
622 "requested packet size too big: %d\n", n
);
630 dump_data(m
->rbuf
, n
);
632 v9fs_deserialize_fcall(m
->rbuf
, n
, m
->rcall
, *m
->extended
);
637 if ((v9fs_debug_level
&DEBUG_FCALL
) == DEBUG_FCALL
) {
640 v9fs_printfcall(buf
, sizeof(buf
), m
->rcall
,
642 printk(KERN_NOTICE
">>> %p %s\n", m
, buf
);
648 m
->rcall
= kmalloc(sizeof(struct v9fs_fcall
) + m
->msize
,
655 m
->rbuf
= (char *)m
->rcall
+ sizeof(struct v9fs_fcall
);
656 memmove(m
->rbuf
, rbuf
+ n
, m
->rpos
- n
);
664 dprintk(DEBUG_MUX
, "mux %p fcall id %d tag %d\n", m
, rcall
->id
,
669 list_for_each_entry_safe(rreq
, rptr
, &m
->req_list
, req_list
) {
670 if (rreq
->tag
== rcall
->tag
) {
673 list_del(&req
->req_list
);
674 spin_unlock(&m
->lock
);
675 process_request(m
, req
);
682 spin_unlock(&m
->lock
);
683 if (err
>= 0 && rcall
->id
!= RFLUSH
)
685 "unexpected response mux %p id %d tag %d\n",
686 m
, rcall
->id
, rcall
->tag
);
691 if (!list_empty(&m
->req_list
)) {
692 if (test_and_clear_bit(Rpending
, &m
->wsched
))
695 n
= m
->trans
->poll(m
->trans
, NULL
);
698 dprintk(DEBUG_MUX
, "schedule read work mux %p\n", m
);
699 queue_work(v9fs_mux_wq
, &m
->rq
);
701 clear_bit(Rworksched
, &m
->wsched
);
703 clear_bit(Rworksched
, &m
->wsched
);
708 v9fs_mux_cancel(m
, err
);
709 clear_bit(Rworksched
, &m
->wsched
);
713 * v9fs_send_request - send 9P request
714 * The function can sleep until the request is scheduled for sending.
715 * The function can be interrupted. Return from the function is not
716 * a guarantee that the request is sent succesfully. Can return errors
717 * that can be retrieved by PTR_ERR macros.
720 * @tc: request to be sent
721 * @cb: callback function to call when response is received
722 * @cba: parameter to pass to the callback function
724 static struct v9fs_req
*v9fs_send_request(struct v9fs_mux_data
*m
,
725 struct v9fs_fcall
*tc
,
726 v9fs_mux_req_callback cb
, void *cba
)
729 struct v9fs_req
*req
;
731 dprintk(DEBUG_MUX
, "mux %p task %p tcall %p id %d\n", m
, current
,
734 return ERR_PTR(m
->err
);
736 req
= kmalloc(sizeof(struct v9fs_req
), GFP_KERNEL
);
738 return ERR_PTR(-ENOMEM
);
740 if (tc
->id
== TVERSION
)
743 n
= v9fs_mux_get_tag(m
);
746 return ERR_PTR(-ENOMEM
);
750 if ((v9fs_debug_level
&DEBUG_FCALL
) == DEBUG_FCALL
) {
753 v9fs_printfcall(buf
, sizeof(buf
), tc
, *m
->extended
);
754 printk(KERN_NOTICE
"<<< %p %s\n", m
, buf
);
765 list_add_tail(&req
->req_list
, &m
->unsent_req_list
);
766 spin_unlock(&m
->lock
);
768 if (test_and_clear_bit(Wpending
, &m
->wsched
))
771 n
= m
->trans
->poll(m
->trans
, NULL
);
773 if (n
& POLLOUT
&& !test_and_set_bit(Wworksched
, &m
->wsched
))
774 queue_work(v9fs_mux_wq
, &m
->wq
);
779 static void v9fs_mux_flush_cb(void *a
, struct v9fs_fcall
*tc
,
780 struct v9fs_fcall
*rc
, int err
)
782 v9fs_mux_req_callback cb
;
784 struct v9fs_mux_data
*m
;
785 struct v9fs_req
*req
, *rptr
;
788 dprintk(DEBUG_MUX
, "mux %p tc %p rc %p err %d oldtag %d\n", m
, tc
,
789 rc
, err
, tc
->params
.tflush
.oldtag
);
793 tag
= tc
->params
.tflush
.oldtag
;
794 list_for_each_entry_safe(req
, rptr
, &m
->req_list
, req_list
) {
795 if (req
->tag
== tag
) {
796 list_del(&req
->req_list
);
800 spin_unlock(&m
->lock
);
801 (*cb
) (req
->cba
, req
->tcall
, req
->rcall
,
811 spin_unlock(&m
->lock
);
813 v9fs_mux_put_tag(m
, tag
);
819 v9fs_mux_flush_request(struct v9fs_mux_data
*m
, struct v9fs_req
*req
)
821 struct v9fs_fcall
*fc
;
823 dprintk(DEBUG_MUX
, "mux %p req %p tag %d\n", m
, req
, req
->tag
);
825 fc
= v9fs_create_tflush(req
->tag
);
826 v9fs_send_request(m
, fc
, v9fs_mux_flush_cb
, m
);
830 v9fs_mux_rpc_cb(void *a
, struct v9fs_fcall
*tc
, struct v9fs_fcall
*rc
, int err
)
832 struct v9fs_mux_rpc
*r
;
834 if (err
== ERREQFLUSH
) {
836 dprintk(DEBUG_MUX
, "err req flush\n");
841 dprintk(DEBUG_MUX
, "mux %p req %p tc %p rc %p err %d\n", r
->m
, r
->req
,
849 * v9fs_mux_rpc - sends 9P request and waits until a response is available.
850 * The function can be interrupted.
852 * @tc: request to be sent
853 * @rc: pointer where a pointer to the response is stored
856 v9fs_mux_rpc(struct v9fs_mux_data
*m
, struct v9fs_fcall
*tc
,
857 struct v9fs_fcall
**rc
)
861 struct v9fs_req
*req
;
862 struct v9fs_mux_rpc r
;
867 init_waitqueue_head(&r
.wqueue
);
872 req
= v9fs_send_request(m
, tc
, v9fs_mux_rpc_cb
, &r
);
875 dprintk(DEBUG_MUX
, "error %d\n", err
);
880 dprintk(DEBUG_MUX
, "mux %p tc %p tag %d rpc %p req %p\n", m
, tc
,
882 err
= wait_event_interruptible(r
.wqueue
, r
.rcall
!= NULL
|| r
.err
< 0);
886 if (err
== -ERESTARTSYS
&& m
->trans
->status
== Connected
&& m
->err
== 0) {
889 req
->err
= ERREQFLUSH
;
890 spin_unlock(&m
->lock
);
892 clear_thread_flag(TIF_SIGPENDING
);
893 v9fs_mux_flush_request(m
, req
);
894 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
896 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
901 dprintk(DEBUG_MUX
, "got response id %d tag %d\n",
902 r
.rcall
->id
, r
.rcall
->tag
);
910 dprintk(DEBUG_MUX
, "got error %d\n", err
);
920 * v9fs_mux_rpcnb - sends 9P request without waiting for response.
922 * @tc: request to be sent
923 * @cb: callback function to be called when response arrives
924 * @cba: value to pass to the callback function
926 int v9fs_mux_rpcnb(struct v9fs_mux_data
*m
, struct v9fs_fcall
*tc
,
927 v9fs_mux_req_callback cb
, void *a
)
930 struct v9fs_req
*req
;
932 req
= v9fs_send_request(m
, tc
, cb
, a
);
935 dprintk(DEBUG_MUX
, "error %d\n", err
);
939 dprintk(DEBUG_MUX
, "mux %p tc %p tag %d\n", m
, tc
, req
->tag
);
945 * v9fs_mux_cancel - cancel all pending requests with error
949 void v9fs_mux_cancel(struct v9fs_mux_data
*m
, int err
)
951 struct v9fs_req
*req
, *rtmp
;
952 LIST_HEAD(cancel_list
);
954 dprintk(DEBUG_MUX
, "mux %p err %d\n", m
, err
);
957 list_for_each_entry_safe(req
, rtmp
, &m
->req_list
, req_list
) {
958 list_move(&req
->req_list
, &cancel_list
);
960 spin_unlock(&m
->lock
);
962 list_for_each_entry_safe(req
, rtmp
, &cancel_list
, req_list
) {
963 list_del(&req
->req_list
);
968 (*req
->cb
) (req
->cba
, req
->tcall
, req
->rcall
, req
->err
);
978 static u16
v9fs_mux_get_tag(struct v9fs_mux_data
*m
)
982 tag
= v9fs_get_idpool(&m
->tagpool
);
989 static void v9fs_mux_put_tag(struct v9fs_mux_data
*m
, u16 tag
)
991 if (tag
!= V9FS_NOTAG
&& v9fs_check_idpool(tag
, &m
->tagpool
))
992 v9fs_put_idpool(tag
, &m
->tagpool
);