~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/9p/trans_fd.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/fs/9p/trans_fd.c
  3  *
  4  * Fd transport layer.  Includes deprecated socket layer.
  5  *
  6  *  Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
  7  *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
  8  *  Copyright (C) 2004-2008 by Eric Van Hensbergen <ericvh@gmail.com>
  9  *  Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
 10  *
 11  *  This program is free software; you can redistribute it and/or modify
 12  *  it under the terms of the GNU General Public License version 2
 13  *  as published by the Free Software Foundation.
 14  *
 15  *  This program is distributed in the hope that it will be useful,
 16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 18  *  GNU General Public License for more details.
 19  *
 20  *  You should have received a copy of the GNU General Public License
 21  *  along with this program; if not, write to:
 22  *  Free Software Foundation
 23  *  51 Franklin Street, Fifth Floor
 24  *  Boston, MA  02111-1301  USA
 25  *
 26  */
 27 
 28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 29 
 30 #include <linux/in.h>
 31 #include <linux/module.h>
 32 #include <linux/net.h>
 33 #include <linux/ipv6.h>
 34 #include <linux/kthread.h>
 35 #include <linux/errno.h>
 36 #include <linux/kernel.h>
 37 #include <linux/un.h>
 38 #include <linux/uaccess.h>
 39 #include <linux/inet.h>
 40 #include <linux/idr.h>
 41 #include <linux/file.h>
 42 #include <linux/parser.h>
 43 #include <linux/slab.h>
 44 #include <net/9p/9p.h>
 45 #include <net/9p/client.h>
 46 #include <net/9p/transport.h>
 47 
 48 #include <linux/syscalls.h> /* killme */
 49 
 50 #define P9_PORT 564
 51 #define MAX_SOCK_BUF (64*1024)
 52 #define MAXPOLLWADDR    2
 53 
 54 /**
 55  * struct p9_fd_opts - per-transport options
 56  * @rfd: file descriptor for reading (trans=fd)
 57  * @wfd: file descriptor for writing (trans=fd)
 58  * @port: port to connect to (trans=tcp)
 59  *
 60  */
 61 
 62 struct p9_fd_opts {
 63         int rfd;
 64         int wfd;
 65         u16 port;
 66         int privport;
 67 };
 68 
 69 /*
 70   * Option Parsing (code inspired by NFS code)
 71   *  - a little lazy - parse all fd-transport options
 72   */
 73 
 74 enum {
 75         /* Options that take integer arguments */
 76         Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
 77         /* Options that take no arguments */
 78         Opt_privport,
 79 };
 80 
 81 static const match_table_t tokens = {
 82         {Opt_port, "port=%u"},
 83         {Opt_rfdno, "rfdno=%u"},
 84         {Opt_wfdno, "wfdno=%u"},
 85         {Opt_privport, "privport"},
 86         {Opt_err, NULL},
 87 };
 88 
 89 enum {
 90         Rworksched = 1,         /* read work scheduled or running */
 91         Rpending = 2,           /* can read */
 92         Wworksched = 4,         /* write work scheduled or running */
 93         Wpending = 8,           /* can write */
 94 };
 95 
 96 struct p9_poll_wait {
 97         struct p9_conn *conn;
 98         wait_queue_t wait;
 99         wait_queue_head_t *wait_addr;
100 };
101 
102 /**
103  * struct p9_conn - fd mux connection state information
104  * @mux_list: list link for mux to manage multiple connections (?)
105  * @client: reference to client instance for this connection
106  * @err: error state
107  * @req_list: accounting for requests which have been sent
108  * @unsent_req_list: accounting for requests that haven't been sent
109  * @req: current request being processed (if any)
110  * @tmp_buf: temporary buffer to read in header
111  * @rc: temporary fcall for reading current frame
112  * @wpos: write position for current frame
113  * @wsize: amount of data to write for current frame
114  * @wbuf: current write buffer
115  * @poll_pending_link: pending links to be polled per conn
116  * @poll_wait: array of wait_q's for various worker threads
117  * @pt: poll state
118  * @rq: current read work
119  * @wq: current write work
120  * @wsched: ????
121  *
122  */
123 
124 struct p9_conn {
125         struct list_head mux_list;
126         struct p9_client *client;
127         int err;
128         struct list_head req_list;
129         struct list_head unsent_req_list;
130         struct p9_req_t *req;
131         char tmp_buf[7];
132         struct p9_fcall rc;
133         int wpos;
134         int wsize;
135         char *wbuf;
136         struct list_head poll_pending_link;
137         struct p9_poll_wait poll_wait[MAXPOLLWADDR];
138         poll_table pt;
139         struct work_struct rq;
140         struct work_struct wq;
141         unsigned long wsched;
142 };
143 
144 /**
145  * struct p9_trans_fd - transport state
146  * @rd: reference to file to read from
147  * @wr: reference of file to write to
148  * @conn: connection state reference
149  *
150  */
151 
152 struct p9_trans_fd {
153         struct file *rd;
154         struct file *wr;
155         struct p9_conn conn;
156 };
157 
158 static void p9_poll_workfn(struct work_struct *work);
159 
160 static DEFINE_SPINLOCK(p9_poll_lock);
161 static LIST_HEAD(p9_poll_pending_list);
162 static DECLARE_WORK(p9_poll_work, p9_poll_workfn);
163 
164 static unsigned int p9_ipport_resv_min = P9_DEF_MIN_RESVPORT;
165 static unsigned int p9_ipport_resv_max = P9_DEF_MAX_RESVPORT;
166 
167 static void p9_mux_poll_stop(struct p9_conn *m)
168 {
169         unsigned long flags;
170         int i;
171 
172         for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
173                 struct p9_poll_wait *pwait = &m->poll_wait[i];
174 
175                 if (pwait->wait_addr) {
176                         remove_wait_queue(pwait->wait_addr, &pwait->wait);
177                         pwait->wait_addr = NULL;
178                 }
179         }
180 
181         spin_lock_irqsave(&p9_poll_lock, flags);
182         list_del_init(&m->poll_pending_link);
183         spin_unlock_irqrestore(&p9_poll_lock, flags);
184 }
185 
186 /**
187  * p9_conn_cancel - cancel all pending requests with error
188  * @m: mux data
189  * @err: error code
190  *
191  */
192 
193 static void p9_conn_cancel(struct p9_conn *m, int err)
194 {
195         struct p9_req_t *req, *rtmp;
196         unsigned long flags;
197         LIST_HEAD(cancel_list);
198 
199         p9_debug(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
200 
201         spin_lock_irqsave(&m->client->lock, flags);
202 
203         if (m->err) {
204                 spin_unlock_irqrestore(&m->client->lock, flags);
205                 return;
206         }
207 
208         m->err = err;
209 
210         list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
211                 list_move(&req->req_list, &cancel_list);
212         }
213         list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
214                 list_move(&req->req_list, &cancel_list);
215         }
216         spin_unlock_irqrestore(&m->client->lock, flags);
217 
218         list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
219                 p9_debug(P9_DEBUG_ERROR, "call back req %p\n", req);
220                 list_del(&req->req_list);
221                 if (!req->t_err)
222                         req->t_err = err;
223                 p9_client_cb(m->client, req, REQ_STATUS_ERROR);
224         }
225 }
226 
227 static int
228 p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt)
229 {
230         int ret, n;
231         struct p9_trans_fd *ts = NULL;
232 
233         if (client && client->status == Connected)
234                 ts = client->trans;
235 
236         if (!ts)
237                 return -EREMOTEIO;
238 
239         if (!ts->rd->f_op->poll)
240                 return -EIO;
241 
242         if (!ts->wr->f_op->poll)
243                 return -EIO;
244 
245         ret = ts->rd->f_op->poll(ts->rd, pt);
246         if (ret < 0)
247                 return ret;
248 
249         if (ts->rd != ts->wr) {
250                 n = ts->wr->f_op->poll(ts->wr, pt);
251                 if (n < 0)
252                         return n;
253                 ret = (ret & ~POLLOUT) | (n & ~POLLIN);
254         }
255 
256         return ret;
257 }
258 
259 /**
260  * p9_fd_read- read from a fd
261  * @client: client instance
262  * @v: buffer to receive data into
263  * @len: size of receive buffer
264  *
265  */
266 
267 static int p9_fd_read(struct p9_client *client, void *v, int len)
268 {
269         int ret;
270         struct p9_trans_fd *ts = NULL;
271 
272         if (client && client->status != Disconnected)
273                 ts = client->trans;
274 
275         if (!ts)
276                 return -EREMOTEIO;
277 
278         if (!(ts->rd->f_flags & O_NONBLOCK))
279                 p9_debug(P9_DEBUG_ERROR, "blocking read ...\n");
280 
281         ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
282         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
283                 client->status = Disconnected;
284         return ret;
285 }
286 
287 /**
288  * p9_read_work - called when there is some data to be read from a transport
289  * @work: container of work to be done
290  *
291  */
292 
293 static void p9_read_work(struct work_struct *work)
294 {
295         int n, err;
296         struct p9_conn *m;
297         int status = REQ_STATUS_ERROR;
298 
299         m = container_of(work, struct p9_conn, rq);
300 
301         if (m->err < 0)
302                 return;
303 
304         p9_debug(P9_DEBUG_TRANS, "start mux %p pos %zd\n", m, m->rc.offset);
305 
306         if (!m->rc.sdata) {
307                 m->rc.sdata = m->tmp_buf;
308                 m->rc.offset = 0;
309                 m->rc.capacity = 7; /* start by reading header */
310         }
311 
312         clear_bit(Rpending, &m->wsched);
313         p9_debug(P9_DEBUG_TRANS, "read mux %p pos %zd size: %zd = %zd\n",
314                  m, m->rc.offset, m->rc.capacity,
315                  m->rc.capacity - m->rc.offset);
316         err = p9_fd_read(m->client, m->rc.sdata + m->rc.offset,
317                          m->rc.capacity - m->rc.offset);
318         p9_debug(P9_DEBUG_TRANS, "mux %p got %d bytes\n", m, err);
319         if (err == -EAGAIN)
320                 goto end_clear;
321 
322         if (err <= 0)
323                 goto error;
324 
325         m->rc.offset += err;
326 
327         /* header read in */
328         if ((!m->req) && (m->rc.offset == m->rc.capacity)) {
329                 p9_debug(P9_DEBUG_TRANS, "got new header\n");
330 
331                 err = p9_parse_header(&m->rc, NULL, NULL, NULL, 0);
332                 if (err) {
333                         p9_debug(P9_DEBUG_ERROR,
334                                  "error parsing header: %d\n", err);
335                         goto error;
336                 }
337 
338                 if (m->rc.size >= m->client->msize) {
339                         p9_debug(P9_DEBUG_ERROR,
340                                  "requested packet size too big: %d\n",
341                                  m->rc.size);
342                         err = -EIO;
343                         goto error;
344                 }
345 
346                 p9_debug(P9_DEBUG_TRANS,
347                          "mux %p pkt: size: %d bytes tag: %d\n",
348                          m, m->rc.size, m->rc.tag);
349 
350                 m->req = p9_tag_lookup(m->client, m->rc.tag);
351                 if (!m->req || (m->req->status != REQ_STATUS_SENT)) {
352                         p9_debug(P9_DEBUG_ERROR, "Unexpected packet tag %d\n",
353                                  m->rc.tag);
354                         err = -EIO;
355                         goto error;
356                 }
357 
358                 if (m->req->rc == NULL) {
359                         p9_debug(P9_DEBUG_ERROR,
360                                  "No recv fcall for tag %d (req %p), disconnecting!\n",
361                                  m->rc.tag, m->req);
362                         m->req = NULL;
363                         err = -EIO;
364                         goto error;
365                 }
366                 m->rc.sdata = (char *)m->req->rc + sizeof(struct p9_fcall);
367                 memcpy(m->rc.sdata, m->tmp_buf, m->rc.capacity);
368                 m->rc.capacity = m->rc.size;
369         }
370 
371         /* packet is read in
372          * not an else because some packets (like clunk) have no payload
373          */
374         if ((m->req) && (m->rc.offset == m->rc.capacity)) {
375                 p9_debug(P9_DEBUG_TRANS, "got new packet\n");
376                 spin_lock(&m->client->lock);
377                 if (m->req->status != REQ_STATUS_ERROR)
378                         status = REQ_STATUS_RCVD;
379                 list_del(&m->req->req_list);
380                 spin_unlock(&m->client->lock);
381                 p9_client_cb(m->client, m->req, status);
382                 m->rc.sdata = NULL;
383                 m->rc.offset = 0;
384                 m->rc.capacity = 0;
385                 m->req = NULL;
386         }
387 
388 end_clear:
389         clear_bit(Rworksched, &m->wsched);
390 
391         if (!list_empty(&m->req_list)) {
392                 if (test_and_clear_bit(Rpending, &m->wsched))
393                         n = POLLIN;
394                 else
395                         n = p9_fd_poll(m->client, NULL);
396 
397                 if ((n & POLLIN) && !test_and_set_bit(Rworksched, &m->wsched)) {
398                         p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
399                         schedule_work(&m->rq);
400                 }
401         }
402 
403         return;
404 error:
405         p9_conn_cancel(m, err);
406         clear_bit(Rworksched, &m->wsched);
407 }
408 
409 /**
410  * p9_fd_write - write to a socket
411  * @client: client instance
412  * @v: buffer to send data from
413  * @len: size of send buffer
414  *
415  */
416 
417 static int p9_fd_write(struct p9_client *client, void *v, int len)
418 {
419         int ret;
420         mm_segment_t oldfs;
421         struct p9_trans_fd *ts = NULL;
422 
423         if (client && client->status != Disconnected)
424                 ts = client->trans;
425 
426         if (!ts)
427                 return -EREMOTEIO;
428 
429         if (!(ts->wr->f_flags & O_NONBLOCK))
430                 p9_debug(P9_DEBUG_ERROR, "blocking write ...\n");
431 
432         oldfs = get_fs();
433         set_fs(get_ds());
434         /* The cast to a user pointer is valid due to the set_fs() */
435         ret = vfs_write(ts->wr, (__force void __user *)v, len, &ts->wr->f_pos);
436         set_fs(oldfs);
437 
438         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
439                 client->status = Disconnected;
440         return ret;
441 }
442 
443 /**
444  * p9_write_work - called when a transport can send some data
445  * @work: container for work to be done
446  *
447  */
448 
449 static void p9_write_work(struct work_struct *work)
450 {
451         int n, err;
452         struct p9_conn *m;
453         struct p9_req_t *req;
454 
455         m = container_of(work, struct p9_conn, wq);
456 
457         if (m->err < 0) {
458                 clear_bit(Wworksched, &m->wsched);
459                 return;
460         }
461 
462         if (!m->wsize) {
463                 spin_lock(&m->client->lock);
464                 if (list_empty(&m->unsent_req_list)) {
465                         clear_bit(Wworksched, &m->wsched);
466                         spin_unlock(&m->client->lock);
467                         return;
468                 }
469 
470                 req = list_entry(m->unsent_req_list.next, struct p9_req_t,
471                                req_list);
472                 req->status = REQ_STATUS_SENT;
473                 p9_debug(P9_DEBUG_TRANS, "move req %p\n", req);
474                 list_move_tail(&req->req_list, &m->req_list);
475 
476                 m->wbuf = req->tc->sdata;
477                 m->wsize = req->tc->size;
478                 m->wpos = 0;
479                 spin_unlock(&m->client->lock);
480         }
481 
482         p9_debug(P9_DEBUG_TRANS, "mux %p pos %d size %d\n",
483                  m, m->wpos, m->wsize);
484         clear_bit(Wpending, &m->wsched);
485         err = p9_fd_write(m->client, m->wbuf + m->wpos, m->wsize - m->wpos);
486         p9_debug(P9_DEBUG_TRANS, "mux %p sent %d bytes\n", m, err);
487         if (err == -EAGAIN)
488                 goto end_clear;
489 
490 
491         if (err < 0)
492                 goto error;
493         else if (err == 0) {
494                 err = -EREMOTEIO;
495                 goto error;
496         }
497 
498         m->wpos += err;
499         if (m->wpos == m->wsize)
500                 m->wpos = m->wsize = 0;
501 
502 end_clear:
503         clear_bit(Wworksched, &m->wsched);
504 
505         if (m->wsize || !list_empty(&m->unsent_req_list)) {
506                 if (test_and_clear_bit(Wpending, &m->wsched))
507                         n = POLLOUT;
508                 else
509                         n = p9_fd_poll(m->client, NULL);
510 
511                 if ((n & POLLOUT) &&
512                    !test_and_set_bit(Wworksched, &m->wsched)) {
513                         p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
514                         schedule_work(&m->wq);
515                 }
516         }
517 
518         return;
519 
520 error:
521         p9_conn_cancel(m, err);
522         clear_bit(Wworksched, &m->wsched);
523 }
524 
525 static int p9_pollwake(wait_queue_t *wait, unsigned int mode, int sync, void *key)
526 {
527         struct p9_poll_wait *pwait =
528                 container_of(wait, struct p9_poll_wait, wait);
529         struct p9_conn *m = pwait->conn;
530         unsigned long flags;
531 
532         spin_lock_irqsave(&p9_poll_lock, flags);
533         if (list_empty(&m->poll_pending_link))
534                 list_add_tail(&m->poll_pending_link, &p9_poll_pending_list);
535         spin_unlock_irqrestore(&p9_poll_lock, flags);
536 
537         schedule_work(&p9_poll_work);
538         return 1;
539 }
540 
541 /**
542  * p9_pollwait - add poll task to the wait queue
543  * @filp: file pointer being polled
544  * @wait_address: wait_q to block on
545  * @p: poll state
546  *
547  * called by files poll operation to add v9fs-poll task to files wait queue
548  */
549 
550 static void
551 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
552 {
553         struct p9_conn *m = container_of(p, struct p9_conn, pt);
554         struct p9_poll_wait *pwait = NULL;
555         int i;
556 
557         for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
558                 if (m->poll_wait[i].wait_addr == NULL) {
559                         pwait = &m->poll_wait[i];
560                         break;
561                 }
562         }
563 
564         if (!pwait) {
565                 p9_debug(P9_DEBUG_ERROR, "not enough wait_address slots\n");
566                 return;
567         }
568 
569         pwait->conn = m;
570         pwait->wait_addr = wait_address;
571         init_waitqueue_func_entry(&pwait->wait, p9_pollwake);
572         add_wait_queue(wait_address, &pwait->wait);
573 }
574 
575 /**
576  * p9_conn_create - initialize the per-session mux data
577  * @client: client instance
578  *
579  * Note: Creates the polling task if this is the first session.
580  */
581 
582 static void p9_conn_create(struct p9_client *client)
583 {
584         int n;
585         struct p9_trans_fd *ts = client->trans;
586         struct p9_conn *m = &ts->conn;
587 
588         p9_debug(P9_DEBUG_TRANS, "client %p msize %d\n", client, client->msize);
589 
590         INIT_LIST_HEAD(&m->mux_list);
591         m->client = client;
592 
593         INIT_LIST_HEAD(&m->req_list);
594         INIT_LIST_HEAD(&m->unsent_req_list);
595         INIT_WORK(&m->rq, p9_read_work);
596         INIT_WORK(&m->wq, p9_write_work);
597         INIT_LIST_HEAD(&m->poll_pending_link);
598         init_poll_funcptr(&m->pt, p9_pollwait);
599 
600         n = p9_fd_poll(client, &m->pt);
601         if (n & POLLIN) {
602                 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
603                 set_bit(Rpending, &m->wsched);
604         }
605 
606         if (n & POLLOUT) {
607                 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
608                 set_bit(Wpending, &m->wsched);
609         }
610 }
611 
612 /**
613  * p9_poll_mux - polls a mux and schedules read or write works if necessary
614  * @m: connection to poll
615  *
616  */
617 
618 static void p9_poll_mux(struct p9_conn *m)
619 {
620         int n;
621 
622         if (m->err < 0)
623                 return;
624 
625         n = p9_fd_poll(m->client, NULL);
626         if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
627                 p9_debug(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
628                 if (n >= 0)
629                         n = -ECONNRESET;
630                 p9_conn_cancel(m, n);
631         }
632 
633         if (n & POLLIN) {
634                 set_bit(Rpending, &m->wsched);
635                 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
636                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
637                         p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
638                         schedule_work(&m->rq);
639                 }
640         }
641 
642         if (n & POLLOUT) {
643                 set_bit(Wpending, &m->wsched);
644                 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
645                 if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
646                     !test_and_set_bit(Wworksched, &m->wsched)) {
647                         p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
648                         schedule_work(&m->wq);
649                 }
650         }
651 }
652 
653 /**
654  * p9_fd_request - send 9P request
655  * The function can sleep until the request is scheduled for sending.
656  * The function can be interrupted. Return from the function is not
657  * a guarantee that the request is sent successfully.
658  *
659  * @client: client instance
660  * @req: request to be sent
661  *
662  */
663 
664 static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
665 {
666         int n;
667         struct p9_trans_fd *ts = client->trans;
668         struct p9_conn *m = &ts->conn;
669 
670         p9_debug(P9_DEBUG_TRANS, "mux %p task %p tcall %p id %d\n",
671                  m, current, req->tc, req->tc->id);
672         if (m->err < 0)
673                 return m->err;
674 
675         spin_lock(&client->lock);
676         req->status = REQ_STATUS_UNSENT;
677         list_add_tail(&req->req_list, &m->unsent_req_list);
678         spin_unlock(&client->lock);
679 
680         if (test_and_clear_bit(Wpending, &m->wsched))
681                 n = POLLOUT;
682         else
683                 n = p9_fd_poll(m->client, NULL);
684 
685         if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
686                 schedule_work(&m->wq);
687 
688         return 0;
689 }
690 
691 static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
692 {
693         int ret = 1;
694 
695         p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
696 
697         spin_lock(&client->lock);
698 
699         if (req->status == REQ_STATUS_UNSENT) {
700                 list_del(&req->req_list);
701                 req->status = REQ_STATUS_FLSHD;
702                 ret = 0;
703         }
704         spin_unlock(&client->lock);
705 
706         return ret;
707 }
708 
709 static int p9_fd_cancelled(struct p9_client *client, struct p9_req_t *req)
710 {
711         p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
712 
713         /* we haven't received a response for oldreq,
714          * remove it from the list.
715          */
716         spin_lock(&client->lock);
717         list_del(&req->req_list);
718         spin_unlock(&client->lock);
719 
720         return 0;
721 }
722 
723 /**
724  * parse_opts - parse mount options into p9_fd_opts structure
725  * @params: options string passed from mount
726  * @opts: fd transport-specific structure to parse options into
727  *
728  * Returns 0 upon success, -ERRNO upon failure
729  */
730 
731 static int parse_opts(char *params, struct p9_fd_opts *opts)
732 {
733         char *p;
734         substring_t args[MAX_OPT_ARGS];
735         int option;
736         char *options, *tmp_options;
737 
738         opts->port = P9_PORT;
739         opts->rfd = ~0;
740         opts->wfd = ~0;
741         opts->privport = 0;
742 
743         if (!params)
744                 return 0;
745 
746         tmp_options = kstrdup(params, GFP_KERNEL);
747         if (!tmp_options) {
748                 p9_debug(P9_DEBUG_ERROR,
749                          "failed to allocate copy of option string\n");
750                 return -ENOMEM;
751         }
752         options = tmp_options;
753 
754         while ((p = strsep(&options, ",")) != NULL) {
755                 int token;
756                 int r;
757                 if (!*p)
758                         continue;
759                 token = match_token(p, tokens, args);
760                 if ((token != Opt_err) && (token != Opt_privport)) {
761                         r = match_int(&args[0], &option);
762                         if (r < 0) {
763                                 p9_debug(P9_DEBUG_ERROR,
764                                          "integer field, but no integer?\n");
765                                 continue;
766                         }
767                 }
768                 switch (token) {
769                 case Opt_port:
770                         opts->port = option;
771                         break;
772                 case Opt_rfdno:
773                         opts->rfd = option;
774                         break;
775                 case Opt_wfdno:
776                         opts->wfd = option;
777                         break;
778                 case Opt_privport:
779                         opts->privport = 1;
780                         break;
781                 default:
782                         continue;
783                 }
784         }
785 
786         kfree(tmp_options);
787         return 0;
788 }
789 
790 static int p9_fd_open(struct p9_client *client, int rfd, int wfd)
791 {
792         struct p9_trans_fd *ts = kzalloc(sizeof(struct p9_trans_fd),
793                                            GFP_KERNEL);
794         if (!ts)
795                 return -ENOMEM;
796 
797         ts->rd = fget(rfd);
798         ts->wr = fget(wfd);
799         if (!ts->rd || !ts->wr) {
800                 if (ts->rd)
801                         fput(ts->rd);
802                 if (ts->wr)
803                         fput(ts->wr);
804                 kfree(ts);
805                 return -EIO;
806         }
807 
808         client->trans = ts;
809         client->status = Connected;
810 
811         return 0;
812 }
813 
814 static int p9_socket_open(struct p9_client *client, struct socket *csocket)
815 {
816         struct p9_trans_fd *p;
817         struct file *file;
818 
819         p = kzalloc(sizeof(struct p9_trans_fd), GFP_KERNEL);
820         if (!p)
821                 return -ENOMEM;
822 
823         csocket->sk->sk_allocation = GFP_NOIO;
824         file = sock_alloc_file(csocket, 0, NULL);
825         if (IS_ERR(file)) {
826                 pr_err("%s (%d): failed to map fd\n",
827                        __func__, task_pid_nr(current));
828                 sock_release(csocket);
829                 kfree(p);
830                 return PTR_ERR(file);
831         }
832 
833         get_file(file);
834         p->wr = p->rd = file;
835         client->trans = p;
836         client->status = Connected;
837 
838         p->rd->f_flags |= O_NONBLOCK;
839 
840         p9_conn_create(client);
841         return 0;
842 }
843 
844 /**
845  * p9_mux_destroy - cancels all pending requests of mux
846  * @m: mux to destroy
847  *
848  */
849 
850 static void p9_conn_destroy(struct p9_conn *m)
851 {
852         p9_debug(P9_DEBUG_TRANS, "mux %p prev %p next %p\n",
853                  m, m->mux_list.prev, m->mux_list.next);
854 
855         p9_mux_poll_stop(m);
856         cancel_work_sync(&m->rq);
857         cancel_work_sync(&m->wq);
858 
859         p9_conn_cancel(m, -ECONNRESET);
860 
861         m->client = NULL;
862 }
863 
864 /**
865  * p9_fd_close - shutdown file descriptor transport
866  * @client: client instance
867  *
868  */
869 
870 static void p9_fd_close(struct p9_client *client)
871 {
872         struct p9_trans_fd *ts;
873 
874         if (!client)
875                 return;
876 
877         ts = client->trans;
878         if (!ts)
879                 return;
880 
881         client->status = Disconnected;
882 
883         p9_conn_destroy(&ts->conn);
884 
885         if (ts->rd)
886                 fput(ts->rd);
887         if (ts->wr)
888                 fput(ts->wr);
889 
890         kfree(ts);
891 }
892 
893 /*
894  * stolen from NFS - maybe should be made a generic function?
895  */
896 static inline int valid_ipaddr4(const char *buf)
897 {
898         int rc, count, in[4];
899 
900         rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
901         if (rc != 4)
902                 return -EINVAL;
903         for (count = 0; count < 4; count++) {
904                 if (in[count] > 255)
905                         return -EINVAL;
906         }
907         return 0;
908 }
909 
910 static int p9_bind_privport(struct socket *sock)
911 {
912         struct sockaddr_in cl;
913         int port, err = -EINVAL;
914 
915         memset(&cl, 0, sizeof(cl));
916         cl.sin_family = AF_INET;
917         cl.sin_addr.s_addr = INADDR_ANY;
918         for (port = p9_ipport_resv_max; port >= p9_ipport_resv_min; port--) {
919                 cl.sin_port = htons((ushort)port);
920                 err = kernel_bind(sock, (struct sockaddr *)&cl, sizeof(cl));
921                 if (err != -EADDRINUSE)
922                         break;
923         }
924         return err;
925 }
926 
927 
928 static int
929 p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args)
930 {
931         int err;
932         struct socket *csocket;
933         struct sockaddr_in sin_server;
934         struct p9_fd_opts opts;
935 
936         err = parse_opts(args, &opts);
937         if (err < 0)
938                 return err;
939 
940         if (valid_ipaddr4(addr) < 0)
941                 return -EINVAL;
942 
943         csocket = NULL;
944 
945         sin_server.sin_family = AF_INET;
946         sin_server.sin_addr.s_addr = in_aton(addr);
947         sin_server.sin_port = htons(opts.port);
948         err = __sock_create(current->nsproxy->net_ns, PF_INET,
949                             SOCK_STREAM, IPPROTO_TCP, &csocket, 1);
950         if (err) {
951                 pr_err("%s (%d): problem creating socket\n",
952                        __func__, task_pid_nr(current));
953                 return err;
954         }
955 
956         if (opts.privport) {
957                 err = p9_bind_privport(csocket);
958                 if (err < 0) {
959                         pr_err("%s (%d): problem binding to privport\n",
960                                __func__, task_pid_nr(current));
961                         sock_release(csocket);
962                         return err;
963                 }
964         }
965 
966         err = csocket->ops->connect(csocket,
967                                     (struct sockaddr *)&sin_server,
968                                     sizeof(struct sockaddr_in), 0);
969         if (err < 0) {
970                 pr_err("%s (%d): problem connecting socket to %s\n",
971                        __func__, task_pid_nr(current), addr);
972                 sock_release(csocket);
973                 return err;
974         }
975 
976         return p9_socket_open(client, csocket);
977 }
978 
979 static int
980 p9_fd_create_unix(struct p9_client *client, const char *addr, char *args)
981 {
982         int err;
983         struct socket *csocket;
984         struct sockaddr_un sun_server;
985 
986         csocket = NULL;
987 
988         if (strlen(addr) >= UNIX_PATH_MAX) {
989                 pr_err("%s (%d): address too long: %s\n",
990                        __func__, task_pid_nr(current), addr);
991                 return -ENAMETOOLONG;
992         }
993 
994         sun_server.sun_family = PF_UNIX;
995         strcpy(sun_server.sun_path, addr);
996         err = __sock_create(current->nsproxy->net_ns, PF_UNIX,
997                             SOCK_STREAM, 0, &csocket, 1);
998         if (err < 0) {
999                 pr_err("%s (%d): problem creating socket\n",
1000                        __func__, task_pid_nr(current));
1001 
1002                 return err;
1003         }
1004         err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1005                         sizeof(struct sockaddr_un) - 1, 0);
1006         if (err < 0) {
1007                 pr_err("%s (%d): problem connecting socket: %s: %d\n",
1008                        __func__, task_pid_nr(current), addr, err);
1009                 sock_release(csocket);
1010                 return err;
1011         }
1012 
1013         return p9_socket_open(client, csocket);
1014 }
1015 
1016 static int
1017 p9_fd_create(struct p9_client *client, const char *addr, char *args)
1018 {
1019         int err;
1020         struct p9_fd_opts opts;
1021 
1022         parse_opts(args, &opts);
1023 
1024         if (opts.rfd == ~0 || opts.wfd == ~0) {
1025                 pr_err("Insufficient options for proto=fd\n");
1026                 return -ENOPROTOOPT;
1027         }
1028 
1029         err = p9_fd_open(client, opts.rfd, opts.wfd);
1030         if (err < 0)
1031                 return err;
1032 
1033         p9_conn_create(client);
1034 
1035         return 0;
1036 }
1037 
1038 static struct p9_trans_module p9_tcp_trans = {
1039         .name = "tcp",
1040         .maxsize = MAX_SOCK_BUF,
1041         .def = 0,
1042         .create = p9_fd_create_tcp,
1043         .close = p9_fd_close,
1044         .request = p9_fd_request,
1045         .cancel = p9_fd_cancel,
1046         .cancelled = p9_fd_cancelled,
1047         .owner = THIS_MODULE,
1048 };
1049 
1050 static struct p9_trans_module p9_unix_trans = {
1051         .name = "unix",
1052         .maxsize = MAX_SOCK_BUF,
1053         .def = 0,
1054         .create = p9_fd_create_unix,
1055         .close = p9_fd_close,
1056         .request = p9_fd_request,
1057         .cancel = p9_fd_cancel,
1058         .cancelled = p9_fd_cancelled,
1059         .owner = THIS_MODULE,
1060 };
1061 
1062 static struct p9_trans_module p9_fd_trans = {
1063         .name = "fd",
1064         .maxsize = MAX_SOCK_BUF,
1065         .def = 0,
1066         .create = p9_fd_create,
1067         .close = p9_fd_close,
1068         .request = p9_fd_request,
1069         .cancel = p9_fd_cancel,
1070         .cancelled = p9_fd_cancelled,
1071         .owner = THIS_MODULE,
1072 };
1073 
1074 /**
1075  * p9_poll_proc - poll worker thread
1076  * @a: thread state and arguments
1077  *
1078  * polls all v9fs transports for new events and queues the appropriate
1079  * work to the work queue
1080  *
1081  */
1082 
1083 static void p9_poll_workfn(struct work_struct *work)
1084 {
1085         unsigned long flags;
1086 
1087         p9_debug(P9_DEBUG_TRANS, "start %p\n", current);
1088 
1089         spin_lock_irqsave(&p9_poll_lock, flags);
1090         while (!list_empty(&p9_poll_pending_list)) {
1091                 struct p9_conn *conn = list_first_entry(&p9_poll_pending_list,
1092                                                         struct p9_conn,
1093                                                         poll_pending_link);
1094                 list_del_init(&conn->poll_pending_link);
1095                 spin_unlock_irqrestore(&p9_poll_lock, flags);
1096 
1097                 p9_poll_mux(conn);
1098 
1099                 spin_lock_irqsave(&p9_poll_lock, flags);
1100         }
1101         spin_unlock_irqrestore(&p9_poll_lock, flags);
1102 
1103         p9_debug(P9_DEBUG_TRANS, "finish\n");
1104 }
1105 
1106 int p9_trans_fd_init(void)
1107 {
1108         v9fs_register_trans(&p9_tcp_trans);
1109         v9fs_register_trans(&p9_unix_trans);
1110         v9fs_register_trans(&p9_fd_trans);
1111 
1112         return 0;
1113 }
1114 
1115 void p9_trans_fd_exit(void)
1116 {
1117         flush_work(&p9_poll_work);
1118         v9fs_unregister_trans(&p9_tcp_trans);
1119         v9fs_unregister_trans(&p9_unix_trans);
1120         v9fs_unregister_trans(&p9_fd_trans);
1121 }
1122 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp