[PATCH] v9fs: Support to force umount
[linux-2.6.git] / fs / 9p / mux.c
1 /*
2  * linux/fs/9p/mux.c
3  *
4  * Protocol Multiplexer
5  *
6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7  *  Copyright (C) 2004 by Latchesar Ionkov <lucho@ionkov.net>
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>
31 #include <linux/kthread.h>
32 #include <linux/idr.h>
33
34 #include "debug.h"
35 #include "v9fs.h"
36 #include "9p.h"
37 #include "transport.h"
38 #include "conv.h"
39 #include "mux.h"
40
41 /**
42  * dprintcond - print condition of session info
43  * @v9ses: session info structure
44  * @req: RPC request structure
45  *
46  */
47
48 static inline int
49 dprintcond(struct v9fs_session_info *v9ses, struct v9fs_rpcreq *req)
50 {
51         dprintk(DEBUG_MUX, "condition: %d, %p\n", v9ses->transport->status,
52                 req->rcall);
53         return 0;
54 }
55
56 /**
57  * xread - force read of a certain number of bytes
58  * @v9ses: session info structure
59  * @ptr: pointer to buffer
60  * @sz: number of bytes to read
61  *
62  * Chuck Cranor CS-533 project1
63  */
64
65 static int xread(struct v9fs_session_info *v9ses, void *ptr, unsigned long sz)
66 {
67         int rd = 0;
68         int ret = 0;
69         while (rd < sz) {
70                 ret = v9ses->transport->read(v9ses->transport, ptr, sz - rd);
71                 if (ret <= 0) {
72                         dprintk(DEBUG_ERROR, "xread errno %d\n", ret);
73                         return ret;
74                 }
75                 rd += ret;
76                 ptr += ret;
77         }
78         return (rd);
79 }
80
81 /**
82  * read_message - read a full 9P2000 fcall packet
83  * @v9ses: session info structure
84  * @rcall: fcall structure to read into
85  * @rcalllen: size of fcall buffer
86  *
87  */
88
89 static int
90 read_message(struct v9fs_session_info *v9ses,
91              struct v9fs_fcall *rcall, int rcalllen)
92 {
93         unsigned char buf[4];
94         void *data;
95         int size = 0;
96         int res = 0;
97
98         res = xread(v9ses, buf, sizeof(buf));
99         if (res < 0) {
100                 dprintk(DEBUG_ERROR,
101                         "Reading of count field failed returned: %d\n", res);
102                 return res;
103         }
104
105         if (res < 4) {
106                 dprintk(DEBUG_ERROR,
107                         "Reading of count field failed returned: %d\n", res);
108                 return -EIO;
109         }
110
111         size = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
112         dprintk(DEBUG_MUX, "got a packet count: %d\n", size);
113
114         /* adjust for the four bytes of size */
115         size -= 4;
116
117         if (size > v9ses->maxdata) {
118                 dprintk(DEBUG_ERROR, "packet too big: %d\n", size);
119                 return -E2BIG;
120         }
121
122         data = kmalloc(size, GFP_KERNEL);
123         if (!data) {
124                 eprintk(KERN_WARNING, "out of memory\n");
125                 return -ENOMEM;
126         }
127
128         res = xread(v9ses, data, size);
129         if (res < size) {
130                 dprintk(DEBUG_ERROR, "Reading of fcall failed returned: %d\n",
131                         res);
132                 kfree(data);
133                 return res;
134         }
135
136         /* we now have an in-memory string that is the reply.
137          * deserialize it. There is very little to go wrong at this point
138          * save for v9fs_alloc errors.
139          */
140         res = v9fs_deserialize_fcall(v9ses, size, data, v9ses->maxdata,
141                                      rcall, rcalllen);
142
143         kfree(data);
144
145         if (res < 0)
146                 return res;
147
148         return 0;
149 }
150
151 /**
152  * v9fs_recv - receive an RPC response for a particular tag
153  * @v9ses: session info structure
154  * @req: RPC request structure
155  *
156  */
157
158 static int v9fs_recv(struct v9fs_session_info *v9ses, struct v9fs_rpcreq *req)
159 {
160         int ret = 0;
161
162         dprintk(DEBUG_MUX, "waiting for response: %d\n", req->tcall->tag);
163         ret = wait_event_interruptible(v9ses->read_wait,
164                        ((v9ses->transport->status != Connected) ||
165                         (req->rcall != 0) || dprintcond(v9ses, req)));
166
167         dprintk(DEBUG_MUX, "got it: rcall %p\n", req->rcall);
168         if (v9ses->transport->status == Disconnected)
169                 return -ECONNRESET;
170
171         if (ret == 0) {
172                 spin_lock(&v9ses->muxlock);
173                 list_del(&req->next);
174                 spin_unlock(&v9ses->muxlock);
175         }
176
177         return ret;
178 }
179
180 /**
181  * v9fs_send - send a 9P request
182  * @v9ses: session info structure
183  * @req: RPC request to send
184  *
185  */
186
187 static int v9fs_send(struct v9fs_session_info *v9ses, struct v9fs_rpcreq *req)
188 {
189         int ret = -1;
190         void *data = NULL;
191         struct v9fs_fcall *tcall = req->tcall;
192
193         data = kmalloc(v9ses->maxdata + V9FS_IOHDRSZ, GFP_KERNEL);
194         if (!data)
195                 return -ENOMEM;
196
197         tcall->size = 0;        /* enforce size recalculation */
198         ret =
199             v9fs_serialize_fcall(v9ses, tcall, data,
200                                  v9ses->maxdata + V9FS_IOHDRSZ);
201         if (ret < 0)
202                 goto free_data;
203
204         spin_lock(&v9ses->muxlock);
205         list_add(&req->next, &v9ses->mux_fcalls);
206         spin_unlock(&v9ses->muxlock);
207
208         dprintk(DEBUG_MUX, "sending message: tag %d size %d\n", tcall->tag,
209                 tcall->size);
210         ret = v9ses->transport->write(v9ses->transport, data, tcall->size);
211
212         if (ret != tcall->size) {
213                 spin_lock(&v9ses->muxlock);
214                 list_del(&req->next);
215                 kfree(req->rcall);
216
217                 spin_unlock(&v9ses->muxlock);
218                 if (ret >= 0)
219                         ret = -EREMOTEIO;
220         } else
221                 ret = 0;
222
223       free_data:
224         kfree(data);
225         return ret;
226 }
227
228 /**
229  * v9fs_mux_rpc - send a request, receive a response
230  * @v9ses: session info structure
231  * @tcall: fcall to send
232  * @rcall: buffer to place response into
233  *
234  */
235
236 long
237 v9fs_mux_rpc(struct v9fs_session_info *v9ses, struct v9fs_fcall *tcall,
238              struct v9fs_fcall **rcall)
239 {
240         int tid = -1;
241         struct v9fs_fcall *fcall = NULL;
242         struct v9fs_rpcreq req;
243         int ret = -1;
244
245         if (!v9ses)
246                 return -EINVAL;
247
248         if (rcall)
249                 *rcall = NULL;
250
251         if (tcall->id != TVERSION) {
252                 tid = v9fs_get_idpool(&v9ses->tidpool);
253                 if (tid < 0)
254                         return -ENOMEM;
255         }
256
257         tcall->tag = tid;
258
259         req.tcall = tcall;
260         req.rcall = NULL;
261
262         ret = v9fs_send(v9ses, &req);
263
264         if (ret < 0) {
265                 if (tcall->id != TVERSION)
266                         v9fs_put_idpool(tid, &v9ses->tidpool);
267                 dprintk(DEBUG_MUX, "error %d\n", ret);
268                 return ret;
269         }
270
271         ret = v9fs_recv(v9ses, &req);
272
273         fcall = req.rcall;
274
275         dprintk(DEBUG_MUX, "received: tag=%x, ret=%d\n", tcall->tag, ret);
276         if (ret == -ERESTARTSYS) {
277                 if (v9ses->transport->status != Disconnected
278                     && tcall->id != TFLUSH) {
279                         unsigned long flags;
280
281                         dprintk(DEBUG_MUX, "flushing the tag: %d\n",
282                                 tcall->tag);
283                         clear_thread_flag(TIF_SIGPENDING);
284                         v9fs_t_flush(v9ses, tcall->tag);
285                         spin_lock_irqsave(&current->sighand->siglock, flags);
286                         recalc_sigpending();
287                         spin_unlock_irqrestore(&current->sighand->siglock,
288                                                flags);
289                         dprintk(DEBUG_MUX, "flushing done\n");
290                 }
291
292                 goto release_req;
293         } else if (ret < 0)
294                 goto release_req;
295
296         if (!fcall)
297                 ret = -EIO;
298         else {
299                 if (fcall->id == RERROR) {
300                         ret = v9fs_errstr2errno(fcall->params.rerror.error);
301                         if (ret == 0) { /* string match failed */
302                                 if (fcall->params.rerror.errno)
303                                         ret = -(fcall->params.rerror.errno);
304                                 else
305                                         ret = -ESERVERFAULT;
306                         }
307                 } else if (fcall->id != tcall->id + 1) {
308                         dprintk(DEBUG_ERROR,
309                                 "fcall mismatch: expected %d, got %d\n",
310                                 tcall->id + 1, fcall->id);
311                         ret = -EIO;
312                 }
313         }
314
315       release_req:
316         if (tcall->id != TVERSION)
317                 v9fs_put_idpool(tid, &v9ses->tidpool);
318         if (rcall)
319                 *rcall = fcall;
320         else
321                 kfree(fcall);
322
323         return ret;
324 }
325
326 /**
327  * v9fs_mux_cancel_requests - cancels all pending requests
328  *
329  * @v9ses: session info structure
330  * @err: error code to return to the requests
331  */
332 void v9fs_mux_cancel_requests(struct v9fs_session_info *v9ses, int err)
333 {
334         struct v9fs_rpcreq *rptr;
335         struct v9fs_rpcreq *rreq;
336
337         dprintk(DEBUG_MUX, " %d\n", err);
338         spin_lock(&v9ses->muxlock);
339         list_for_each_entry_safe(rreq, rptr, &v9ses->mux_fcalls, next) {
340                 rreq->err = err;
341         }
342         spin_unlock(&v9ses->muxlock);
343         wake_up_all(&v9ses->read_wait);
344 }
345
346 /**
347  * v9fs_recvproc - kproc to handle demultiplexing responses
348  * @data: session info structure
349  *
350  */
351
352 static int v9fs_recvproc(void *data)
353 {
354         struct v9fs_session_info *v9ses = (struct v9fs_session_info *)data;
355         struct v9fs_fcall *rcall = NULL;
356         struct v9fs_rpcreq *rptr;
357         struct v9fs_rpcreq *req;
358         struct v9fs_rpcreq *rreq;
359         int err = 0;
360
361         allow_signal(SIGKILL);
362         set_current_state(TASK_INTERRUPTIBLE);
363         complete(&v9ses->proccmpl);
364         while (!kthread_should_stop() && err >= 0) {
365                 req = rptr = rreq = NULL;
366
367                 rcall = kmalloc(v9ses->maxdata + V9FS_IOHDRSZ, GFP_KERNEL);
368                 if (!rcall) {
369                         eprintk(KERN_ERR, "no memory for buffers\n");
370                         break;
371                 }
372
373                 err = read_message(v9ses, rcall, v9ses->maxdata + V9FS_IOHDRSZ);
374                 if (err < 0) {
375                         kfree(rcall);
376                         break;
377                 }
378                 spin_lock(&v9ses->muxlock);
379                 list_for_each_entry_safe(rreq, rptr, &v9ses->mux_fcalls, next) {
380                         if (rreq->tcall->tag == rcall->tag) {
381                                 req = rreq;
382                                 req->rcall = rcall;
383                                 break;
384                         }
385                 }
386
387                 if (req && (req->tcall->id == TFLUSH)) {
388                         struct v9fs_rpcreq *treq = NULL;
389                         list_for_each_entry_safe(treq, rptr, &v9ses->mux_fcalls, next) {
390                                 if (treq->tcall->tag ==
391                                     req->tcall->params.tflush.oldtag) {
392                                         list_del(&rptr->next);
393                                         kfree(treq->rcall);
394                                         break;
395                                 }
396                         }
397                 }
398
399                 spin_unlock(&v9ses->muxlock);
400
401                 if (!req) {
402                         dprintk(DEBUG_ERROR,
403                                 "unexpected response: id %d tag %d\n",
404                                 rcall->id, rcall->tag);
405
406                         kfree(rcall);
407                 }
408
409                 wake_up_all(&v9ses->read_wait);
410                 set_current_state(TASK_INTERRUPTIBLE);
411         }
412
413         /* Inform all pending processes about the failure */
414         wake_up_all(&v9ses->read_wait);
415
416         if (signal_pending(current))
417                 complete(&v9ses->proccmpl);
418
419         dprintk(DEBUG_MUX, "recvproc: end\n");
420         v9ses->recvproc = NULL;
421
422         return err >= 0;
423 }
424
425 /**
426  * v9fs_mux_init - initialize multiplexer (spawn kproc)
427  * @v9ses: session info structure
428  * @dev_name: mount device information (to create unique kproc)
429  *
430  */
431
432 int v9fs_mux_init(struct v9fs_session_info *v9ses, const char *dev_name)
433 {
434         char procname[60];
435
436         strncpy(procname, dev_name, sizeof(procname));
437         procname[sizeof(procname) - 1] = 0;
438
439         init_waitqueue_head(&v9ses->read_wait);
440         init_completion(&v9ses->fcread);
441         init_completion(&v9ses->proccmpl);
442         spin_lock_init(&v9ses->muxlock);
443         INIT_LIST_HEAD(&v9ses->mux_fcalls);
444         v9ses->recvproc = NULL;
445         v9ses->curfcall = NULL;
446
447         v9ses->recvproc = kthread_create(v9fs_recvproc, v9ses,
448                                          "v9fs_recvproc %s", procname);
449
450         if (IS_ERR(v9ses->recvproc)) {
451                 eprintk(KERN_ERR, "cannot create receiving thread\n");
452                 v9fs_session_close(v9ses);
453                 return -ECONNABORTED;
454         }
455
456         wake_up_process(v9ses->recvproc);
457         wait_for_completion(&v9ses->proccmpl);
458
459         return 0;
460 }