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/module.h>
27 #include <linux/errno.h>
29 #include <linux/poll.h>
30 #include <linux/kthread.h>
31 #include <linux/idr.h>
32 #include <linux/mutex.h>
38 #include "transport.h"
42 #define SCHED_TIMEOUT 10
43 #define MAXPOLLWADDR 2
46 Rworksched
= 1, /* read work scheduled or running */
47 Rpending
= 2, /* can read */
48 Wworksched
= 4, /* write work scheduled or running */
49 Wpending
= 8, /* can write */
58 struct v9fs_mux_poll_task
;
63 struct v9fs_fcall
*tcall
;
64 struct v9fs_fcall
*rcall
;
66 v9fs_mux_req_callback cb
;
69 struct list_head req_list
;
72 struct v9fs_mux_data
{
74 struct list_head mux_list
;
75 struct v9fs_mux_poll_task
*poll_task
;
77 unsigned char *extended
;
78 struct v9fs_transport
*trans
;
79 struct v9fs_idpool tagpool
;
81 wait_queue_head_t equeue
;
82 struct list_head req_list
;
83 struct list_head unsent_req_list
;
84 struct v9fs_fcall
*rcall
;
90 wait_queue_t poll_wait
[MAXPOLLWADDR
];
91 wait_queue_head_t
*poll_waddr
[MAXPOLLWADDR
];
93 struct work_struct rq
;
94 struct work_struct wq
;
98 struct v9fs_mux_poll_task
{
99 struct task_struct
*task
;
100 struct list_head mux_list
;
104 struct v9fs_mux_rpc
{
105 struct v9fs_mux_data
*m
;
107 struct v9fs_fcall
*tcall
;
108 struct v9fs_fcall
*rcall
;
109 wait_queue_head_t wqueue
;
112 static int v9fs_poll_proc(void *);
113 static void v9fs_read_work(struct work_struct
*work
);
114 static void v9fs_write_work(struct work_struct
*work
);
115 static void v9fs_pollwait(struct file
*filp
, wait_queue_head_t
* wait_address
,
117 static u16
v9fs_mux_get_tag(struct v9fs_mux_data
*);
118 static void v9fs_mux_put_tag(struct v9fs_mux_data
*, u16
);
120 static DEFINE_MUTEX(v9fs_mux_task_lock
);
121 static struct workqueue_struct
*v9fs_mux_wq
;
123 static int v9fs_mux_num
;
124 static int v9fs_mux_poll_task_num
;
125 static struct v9fs_mux_poll_task v9fs_mux_poll_tasks
[100];
127 int v9fs_mux_global_init(void)
131 for (i
= 0; i
< ARRAY_SIZE(v9fs_mux_poll_tasks
); i
++)
132 v9fs_mux_poll_tasks
[i
].task
= NULL
;
134 v9fs_mux_wq
= create_workqueue("v9fs");
136 printk(KERN_WARNING
"v9fs: mux: creating workqueue failed\n");
143 void v9fs_mux_global_exit(void)
145 destroy_workqueue(v9fs_mux_wq
);
149 * v9fs_mux_calc_poll_procs - calculates the number of polling procs
150 * based on the number of mounted v9fs filesystems.
152 * The current implementation returns sqrt of the number of mounts.
154 static int v9fs_mux_calc_poll_procs(int muxnum
)
158 if (v9fs_mux_poll_task_num
)
159 n
= muxnum
/ v9fs_mux_poll_task_num
+
160 (muxnum
% v9fs_mux_poll_task_num
? 1 : 0);
164 if (n
> ARRAY_SIZE(v9fs_mux_poll_tasks
))
165 n
= ARRAY_SIZE(v9fs_mux_poll_tasks
);
170 static int v9fs_mux_poll_start(struct v9fs_mux_data
*m
)
173 struct v9fs_mux_poll_task
*vpt
, *vptlast
;
174 struct task_struct
*pproc
;
176 dprintk(DEBUG_MUX
, "mux %p muxnum %d procnum %d\n", m
, v9fs_mux_num
,
177 v9fs_mux_poll_task_num
);
178 mutex_lock(&v9fs_mux_task_lock
);
180 n
= v9fs_mux_calc_poll_procs(v9fs_mux_num
+ 1);
181 if (n
> v9fs_mux_poll_task_num
) {
182 for (i
= 0; i
< ARRAY_SIZE(v9fs_mux_poll_tasks
); i
++) {
183 if (v9fs_mux_poll_tasks
[i
].task
== NULL
) {
184 vpt
= &v9fs_mux_poll_tasks
[i
];
185 dprintk(DEBUG_MUX
, "create proc %p\n", vpt
);
186 pproc
= kthread_create(v9fs_poll_proc
, vpt
,
189 if (!IS_ERR(pproc
)) {
191 INIT_LIST_HEAD(&vpt
->mux_list
);
193 v9fs_mux_poll_task_num
++;
194 wake_up_process(vpt
->task
);
200 if (i
>= ARRAY_SIZE(v9fs_mux_poll_tasks
))
201 dprintk(DEBUG_ERROR
, "warning: no free poll slots\n");
204 n
= (v9fs_mux_num
+ 1) / v9fs_mux_poll_task_num
+
205 ((v9fs_mux_num
+ 1) % v9fs_mux_poll_task_num
? 1 : 0);
208 for (i
= 0; i
< ARRAY_SIZE(v9fs_mux_poll_tasks
); i
++) {
209 vpt
= &v9fs_mux_poll_tasks
[i
];
210 if (vpt
->task
!= NULL
) {
212 if (vpt
->muxnum
< n
) {
213 dprintk(DEBUG_MUX
, "put in proc %d\n", i
);
214 list_add(&m
->mux_list
, &vpt
->mux_list
);
217 memset(&m
->poll_waddr
, 0, sizeof(m
->poll_waddr
));
218 init_poll_funcptr(&m
->pt
, v9fs_pollwait
);
224 if (i
>= ARRAY_SIZE(v9fs_mux_poll_tasks
)) {
228 dprintk(DEBUG_MUX
, "put in proc %d\n", i
);
229 list_add(&m
->mux_list
, &vptlast
->mux_list
);
231 m
->poll_task
= vptlast
;
232 memset(&m
->poll_waddr
, 0, sizeof(m
->poll_waddr
));
233 init_poll_funcptr(&m
->pt
, v9fs_pollwait
);
237 mutex_unlock(&v9fs_mux_task_lock
);
242 static void v9fs_mux_poll_stop(struct v9fs_mux_data
*m
)
245 struct v9fs_mux_poll_task
*vpt
;
247 mutex_lock(&v9fs_mux_task_lock
);
249 list_del(&m
->mux_list
);
250 for(i
= 0; i
< ARRAY_SIZE(m
->poll_waddr
); i
++) {
251 if (m
->poll_waddr
[i
] != NULL
) {
252 remove_wait_queue(m
->poll_waddr
[i
], &m
->poll_wait
[i
]);
253 m
->poll_waddr
[i
] = NULL
;
258 dprintk(DEBUG_MUX
, "destroy proc %p\n", vpt
);
259 send_sig(SIGKILL
, vpt
->task
, 1);
261 v9fs_mux_poll_task_num
--;
264 mutex_unlock(&v9fs_mux_task_lock
);
268 * v9fs_mux_init - allocate and initialize the per-session mux data
269 * Creates the polling task if this is the first session.
271 * @trans - transport structure
272 * @msize - maximum message size
273 * @extended - pointer to the extended flag
275 struct v9fs_mux_data
*v9fs_mux_init(struct v9fs_transport
*trans
, int msize
,
276 unsigned char *extended
)
279 struct v9fs_mux_data
*m
, *mtmp
;
281 dprintk(DEBUG_MUX
, "transport %p msize %d\n", trans
, msize
);
282 m
= kmalloc(sizeof(struct v9fs_mux_data
), GFP_KERNEL
);
284 return ERR_PTR(-ENOMEM
);
286 spin_lock_init(&m
->lock
);
287 INIT_LIST_HEAD(&m
->mux_list
);
289 m
->extended
= extended
;
291 idr_init(&m
->tagpool
.pool
);
292 init_MUTEX(&m
->tagpool
.lock
);
294 init_waitqueue_head(&m
->equeue
);
295 INIT_LIST_HEAD(&m
->req_list
);
296 INIT_LIST_HEAD(&m
->unsent_req_list
);
300 m
->wpos
= m
->wsize
= 0;
302 INIT_WORK(&m
->rq
, v9fs_read_work
);
303 INIT_WORK(&m
->wq
, v9fs_write_work
);
305 memset(&m
->poll_waddr
, 0, sizeof(m
->poll_waddr
));
307 n
= v9fs_mux_poll_start(m
);
311 n
= trans
->poll(trans
, &m
->pt
);
313 dprintk(DEBUG_MUX
, "mux %p can read\n", m
);
314 set_bit(Rpending
, &m
->wsched
);
318 dprintk(DEBUG_MUX
, "mux %p can write\n", m
);
319 set_bit(Wpending
, &m
->wsched
);
322 for(i
= 0; i
< ARRAY_SIZE(m
->poll_waddr
); i
++) {
323 if (IS_ERR(m
->poll_waddr
[i
])) {
324 v9fs_mux_poll_stop(m
);
325 mtmp
= (void *)m
->poll_waddr
; /* the error code */
336 * v9fs_mux_destroy - cancels all pending requests and frees mux resources
338 void v9fs_mux_destroy(struct v9fs_mux_data
*m
)
340 dprintk(DEBUG_MUX
, "mux %p prev %p next %p\n", m
,
341 m
->mux_list
.prev
, m
->mux_list
.next
);
342 v9fs_mux_cancel(m
, -ECONNRESET
);
344 if (!list_empty(&m
->req_list
)) {
345 /* wait until all processes waiting on this session exit */
346 dprintk(DEBUG_MUX
, "mux %p waiting for empty request queue\n",
348 wait_event_timeout(m
->equeue
, (list_empty(&m
->req_list
)), 5000);
349 dprintk(DEBUG_MUX
, "mux %p request queue empty: %d\n", m
,
350 list_empty(&m
->req_list
));
353 v9fs_mux_poll_stop(m
);
360 * v9fs_pollwait - called by files poll operation to add v9fs-poll task
361 * to files wait queue
364 v9fs_pollwait(struct file
*filp
, wait_queue_head_t
* wait_address
,
368 struct v9fs_mux_data
*m
;
370 m
= container_of(p
, struct v9fs_mux_data
, pt
);
371 for(i
= 0; i
< ARRAY_SIZE(m
->poll_waddr
); i
++)
372 if (m
->poll_waddr
[i
] == NULL
)
375 if (i
>= ARRAY_SIZE(m
->poll_waddr
)) {
376 dprintk(DEBUG_ERROR
, "not enough wait_address slots\n");
380 m
->poll_waddr
[i
] = wait_address
;
383 dprintk(DEBUG_ERROR
, "no wait_address\n");
384 m
->poll_waddr
[i
] = ERR_PTR(-EIO
);
388 init_waitqueue_entry(&m
->poll_wait
[i
], m
->poll_task
->task
);
389 add_wait_queue(wait_address
, &m
->poll_wait
[i
]);
393 * v9fs_poll_mux - polls a mux and schedules read or write works if necessary
395 static void v9fs_poll_mux(struct v9fs_mux_data
*m
)
402 n
= m
->trans
->poll(m
->trans
, NULL
);
403 if (n
< 0 || n
& (POLLERR
| POLLHUP
| POLLNVAL
)) {
404 dprintk(DEBUG_MUX
, "error mux %p err %d\n", m
, n
);
407 v9fs_mux_cancel(m
, n
);
411 set_bit(Rpending
, &m
->wsched
);
412 dprintk(DEBUG_MUX
, "mux %p can read\n", m
);
413 if (!test_and_set_bit(Rworksched
, &m
->wsched
)) {
414 dprintk(DEBUG_MUX
, "schedule read work mux %p\n", m
);
415 queue_work(v9fs_mux_wq
, &m
->rq
);
420 set_bit(Wpending
, &m
->wsched
);
421 dprintk(DEBUG_MUX
, "mux %p can write\n", m
);
422 if ((m
->wsize
|| !list_empty(&m
->unsent_req_list
))
423 && !test_and_set_bit(Wworksched
, &m
->wsched
)) {
424 dprintk(DEBUG_MUX
, "schedule write work mux %p\n", m
);
425 queue_work(v9fs_mux_wq
, &m
->wq
);
431 * v9fs_poll_proc - polls all v9fs transports for new events and queues
432 * the appropriate work to the work queue
434 static int v9fs_poll_proc(void *a
)
436 struct v9fs_mux_data
*m
, *mtmp
;
437 struct v9fs_mux_poll_task
*vpt
;
440 dprintk(DEBUG_MUX
, "start %p %p\n", current
, vpt
);
441 allow_signal(SIGKILL
);
442 while (!kthread_should_stop()) {
443 set_current_state(TASK_INTERRUPTIBLE
);
444 if (signal_pending(current
))
447 list_for_each_entry_safe(m
, mtmp
, &vpt
->mux_list
, mux_list
) {
451 dprintk(DEBUG_MUX
, "sleeping...\n");
452 schedule_timeout(SCHED_TIMEOUT
* HZ
);
455 __set_current_state(TASK_RUNNING
);
456 dprintk(DEBUG_MUX
, "finish\n");
461 * v9fs_write_work - called when a transport can send some data
463 static void v9fs_write_work(struct work_struct
*work
)
466 struct v9fs_mux_data
*m
;
467 struct v9fs_req
*req
;
469 m
= container_of(work
, struct v9fs_mux_data
, wq
);
472 clear_bit(Wworksched
, &m
->wsched
);
477 if (list_empty(&m
->unsent_req_list
)) {
478 clear_bit(Wworksched
, &m
->wsched
);
484 req
= list_entry(m
->unsent_req_list
.next
, struct v9fs_req
,
486 list_move_tail(&req
->req_list
, &m
->req_list
);
487 if (req
->err
== ERREQFLUSH
)
490 m
->wbuf
= req
->tcall
->sdata
;
491 m
->wsize
= req
->tcall
->size
;
493 dump_data(m
->wbuf
, m
->wsize
);
494 spin_unlock(&m
->lock
);
497 dprintk(DEBUG_MUX
, "mux %p pos %d size %d\n", m
, m
->wpos
, m
->wsize
);
498 clear_bit(Wpending
, &m
->wsched
);
499 err
= m
->trans
->write(m
->trans
, m
->wbuf
+ m
->wpos
, m
->wsize
- m
->wpos
);
500 dprintk(DEBUG_MUX
, "mux %p sent %d bytes\n", m
, err
);
501 if (err
== -EAGAIN
) {
502 clear_bit(Wworksched
, &m
->wsched
);
510 if (m
->wpos
== m
->wsize
)
511 m
->wpos
= m
->wsize
= 0;
513 if (m
->wsize
== 0 && !list_empty(&m
->unsent_req_list
)) {
514 if (test_and_clear_bit(Wpending
, &m
->wsched
))
517 n
= m
->trans
->poll(m
->trans
, NULL
);
520 dprintk(DEBUG_MUX
, "schedule write work mux %p\n", m
);
521 queue_work(v9fs_mux_wq
, &m
->wq
);
523 clear_bit(Wworksched
, &m
->wsched
);
525 clear_bit(Wworksched
, &m
->wsched
);
530 v9fs_mux_cancel(m
, err
);
531 clear_bit(Wworksched
, &m
->wsched
);
534 static void process_request(struct v9fs_mux_data
*m
, struct v9fs_req
*req
)
537 struct v9fs_str
*ename
;
539 if (!req
->err
&& req
->rcall
->id
== RERROR
) {
540 ecode
= req
->rcall
->params
.rerror
.errno
;
541 ename
= &req
->rcall
->params
.rerror
.error
;
543 dprintk(DEBUG_MUX
, "Rerror %.*s\n", ename
->len
, ename
->str
);
549 req
->err
= v9fs_errstr2errno(ename
->str
, ename
->len
);
551 if (!req
->err
) { /* string match failed */
552 PRINT_FCALL_ERROR("unknown error", req
->rcall
);
556 req
->err
= -ESERVERFAULT
;
558 } else if (req
->tcall
&& req
->rcall
->id
!= req
->tcall
->id
+ 1) {
559 dprintk(DEBUG_ERROR
, "fcall mismatch: expected %d, got %d\n",
560 req
->tcall
->id
+ 1, req
->rcall
->id
);
567 * v9fs_read_work - called when there is some data to be read from a transport
569 static void v9fs_read_work(struct work_struct
*work
)
572 struct v9fs_mux_data
*m
;
573 struct v9fs_req
*req
, *rptr
, *rreq
;
574 struct v9fs_fcall
*rcall
;
577 m
= container_of(work
, struct v9fs_mux_data
, rq
);
583 dprintk(DEBUG_MUX
, "start mux %p pos %d\n", m
, m
->rpos
);
587 kmalloc(sizeof(struct v9fs_fcall
) + m
->msize
, GFP_KERNEL
);
593 m
->rbuf
= (char *)m
->rcall
+ sizeof(struct v9fs_fcall
);
597 clear_bit(Rpending
, &m
->wsched
);
598 err
= m
->trans
->read(m
->trans
, m
->rbuf
+ m
->rpos
, m
->msize
- m
->rpos
);
599 dprintk(DEBUG_MUX
, "mux %p got %d bytes\n", m
, err
);
600 if (err
== -EAGAIN
) {
601 clear_bit(Rworksched
, &m
->wsched
);
609 while (m
->rpos
> 4) {
610 n
= le32_to_cpu(*(__le32
*) m
->rbuf
);
613 "requested packet size too big: %d\n", n
);
621 dump_data(m
->rbuf
, n
);
623 v9fs_deserialize_fcall(m
->rbuf
, n
, m
->rcall
, *m
->extended
);
628 if ((v9fs_debug_level
&DEBUG_FCALL
) == DEBUG_FCALL
) {
631 v9fs_printfcall(buf
, sizeof(buf
), m
->rcall
,
633 printk(KERN_NOTICE
">>> %p %s\n", m
, buf
);
639 m
->rcall
= kmalloc(sizeof(struct v9fs_fcall
) + m
->msize
,
646 m
->rbuf
= (char *)m
->rcall
+ sizeof(struct v9fs_fcall
);
647 memmove(m
->rbuf
, rbuf
+ n
, m
->rpos
- n
);
655 dprintk(DEBUG_MUX
, "mux %p fcall id %d tag %d\n", m
, rcall
->id
,
660 list_for_each_entry_safe(rreq
, rptr
, &m
->req_list
, req_list
) {
661 if (rreq
->tag
== rcall
->tag
) {
663 if (req
->flush
!= Flushing
)
664 list_del(&req
->req_list
);
668 spin_unlock(&m
->lock
);
672 process_request(m
, req
);
674 if (req
->flush
!= Flushing
) {
676 (*req
->cb
) (req
, req
->cba
);
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 successfully. 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
);
749 if ((v9fs_debug_level
&DEBUG_FCALL
) == DEBUG_FCALL
) {
752 v9fs_printfcall(buf
, sizeof(buf
), tc
, *m
->extended
);
753 printk(KERN_NOTICE
"<<< %p %s\n", m
, buf
);
756 spin_lock_init(&req
->lock
);
766 list_add_tail(&req
->req_list
, &m
->unsent_req_list
);
767 spin_unlock(&m
->lock
);
769 if (test_and_clear_bit(Wpending
, &m
->wsched
))
772 n
= m
->trans
->poll(m
->trans
, NULL
);
774 if (n
& POLLOUT
&& !test_and_set_bit(Wworksched
, &m
->wsched
))
775 queue_work(v9fs_mux_wq
, &m
->wq
);
780 static void v9fs_mux_free_request(struct v9fs_mux_data
*m
, struct v9fs_req
*req
)
782 v9fs_mux_put_tag(m
, req
->tag
);
786 static void v9fs_mux_flush_cb(struct v9fs_req
*freq
, void *a
)
788 v9fs_mux_req_callback cb
;
790 struct v9fs_mux_data
*m
;
791 struct v9fs_req
*req
, *rreq
, *rptr
;
794 dprintk(DEBUG_MUX
, "mux %p tc %p rc %p err %d oldtag %d\n", m
,
795 freq
->tcall
, freq
->rcall
, freq
->err
,
796 freq
->tcall
->params
.tflush
.oldtag
);
800 tag
= freq
->tcall
->params
.tflush
.oldtag
;
802 list_for_each_entry_safe(rreq
, rptr
, &m
->req_list
, req_list
) {
803 if (rreq
->tag
== tag
) {
805 list_del(&req
->req_list
);
809 spin_unlock(&m
->lock
);
812 spin_lock(&req
->lock
);
813 req
->flush
= Flushed
;
814 spin_unlock(&req
->lock
);
817 (*req
->cb
) (req
, req
->cba
);
826 v9fs_mux_free_request(m
, freq
);
830 v9fs_mux_flush_request(struct v9fs_mux_data
*m
, struct v9fs_req
*req
)
832 struct v9fs_fcall
*fc
;
833 struct v9fs_req
*rreq
, *rptr
;
835 dprintk(DEBUG_MUX
, "mux %p req %p tag %d\n", m
, req
, req
->tag
);
837 /* if a response was received for a request, do nothing */
838 spin_lock(&req
->lock
);
839 if (req
->rcall
|| req
->err
) {
840 spin_unlock(&req
->lock
);
841 dprintk(DEBUG_MUX
, "mux %p req %p response already received\n", m
, req
);
845 req
->flush
= Flushing
;
846 spin_unlock(&req
->lock
);
849 /* if the request is not sent yet, just remove it from the list */
850 list_for_each_entry_safe(rreq
, rptr
, &m
->unsent_req_list
, req_list
) {
851 if (rreq
->tag
== req
->tag
) {
852 dprintk(DEBUG_MUX
, "mux %p req %p request is not sent yet\n", m
, req
);
853 list_del(&rreq
->req_list
);
854 req
->flush
= Flushed
;
855 spin_unlock(&m
->lock
);
857 (*req
->cb
) (req
, req
->cba
);
861 spin_unlock(&m
->lock
);
863 clear_thread_flag(TIF_SIGPENDING
);
864 fc
= v9fs_create_tflush(req
->tag
);
865 v9fs_send_request(m
, fc
, v9fs_mux_flush_cb
, m
);
870 v9fs_mux_rpc_cb(struct v9fs_req
*req
, void *a
)
872 struct v9fs_mux_rpc
*r
;
874 dprintk(DEBUG_MUX
, "req %p r %p\n", req
, a
);
876 r
->rcall
= req
->rcall
;
879 if (req
->flush
!=None
&& !req
->err
)
880 r
->err
= -ERESTARTSYS
;
886 * v9fs_mux_rpc - sends 9P request and waits until a response is available.
887 * The function can be interrupted.
889 * @tc: request to be sent
890 * @rc: pointer where a pointer to the response is stored
893 v9fs_mux_rpc(struct v9fs_mux_data
*m
, struct v9fs_fcall
*tc
,
894 struct v9fs_fcall
**rc
)
898 struct v9fs_req
*req
;
899 struct v9fs_mux_rpc r
;
905 init_waitqueue_head(&r
.wqueue
);
911 if (signal_pending(current
)) {
913 clear_thread_flag(TIF_SIGPENDING
);
916 req
= v9fs_send_request(m
, tc
, v9fs_mux_rpc_cb
, &r
);
919 dprintk(DEBUG_MUX
, "error %d\n", err
);
923 err
= wait_event_interruptible(r
.wqueue
, r
.rcall
!= NULL
|| r
.err
< 0);
927 if (err
== -ERESTARTSYS
&& m
->trans
->status
== Connected
&& m
->err
== 0) {
928 if (v9fs_mux_flush_request(m
, req
)) {
929 /* wait until we get response of the flush message */
931 clear_thread_flag(TIF_SIGPENDING
);
932 err
= wait_event_interruptible(r
.wqueue
,
934 } while (!r
.rcall
&& !r
.err
&& err
==-ERESTARTSYS
&&
935 m
->trans
->status
==Connected
&& !m
->err
);
943 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
945 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
953 v9fs_mux_free_request(m
, req
);
962 * v9fs_mux_rpcnb - sends 9P request without waiting for response.
964 * @tc: request to be sent
965 * @cb: callback function to be called when response arrives
966 * @cba: value to pass to the callback function
968 int v9fs_mux_rpcnb(struct v9fs_mux_data
*m
, struct v9fs_fcall
*tc
,
969 v9fs_mux_req_callback cb
, void *a
)
972 struct v9fs_req
*req
;
974 req
= v9fs_send_request(m
, tc
, cb
, a
);
977 dprintk(DEBUG_MUX
, "error %d\n", err
);
981 dprintk(DEBUG_MUX
, "mux %p tc %p tag %d\n", m
, tc
, req
->tag
);
987 * v9fs_mux_cancel - cancel all pending requests with error
991 void v9fs_mux_cancel(struct v9fs_mux_data
*m
, int err
)
993 struct v9fs_req
*req
, *rtmp
;
994 LIST_HEAD(cancel_list
);
996 dprintk(DEBUG_ERROR
, "mux %p err %d\n", m
, err
);
999 list_for_each_entry_safe(req
, rtmp
, &m
->req_list
, req_list
) {
1000 list_move(&req
->req_list
, &cancel_list
);
1002 list_for_each_entry_safe(req
, rtmp
, &m
->unsent_req_list
, req_list
) {
1003 list_move(&req
->req_list
, &cancel_list
);
1005 spin_unlock(&m
->lock
);
1007 list_for_each_entry_safe(req
, rtmp
, &cancel_list
, req_list
) {
1008 list_del(&req
->req_list
);
1013 (*req
->cb
) (req
, req
->cba
);
1018 wake_up(&m
->equeue
);
1021 static u16
v9fs_mux_get_tag(struct v9fs_mux_data
*m
)
1025 tag
= v9fs_get_idpool(&m
->tagpool
);
1032 static void v9fs_mux_put_tag(struct v9fs_mux_data
*m
, u16 tag
)
1034 if (tag
!= V9FS_NOTAG
&& v9fs_check_idpool(tag
, &m
->tagpool
))
1035 v9fs_put_idpool(tag
, &m
->tagpool
);