Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
trans_fd.c
Go to the documentation of this file.
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 <[email protected]>
7  * Copyright (C) 2004-2005 by Latchesar Ionkov <[email protected]>
8  * Copyright (C) 2004-2008 by Eric Van Hensbergen <[email protected]>
9  * Copyright (C) 1997-2002 by Ron Minnich <[email protected]>
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 
62 struct p9_fd_opts {
63  int rfd;
64  int wfd;
66 };
67 
76 struct p9_trans_fd {
77  struct file *rd;
78  struct file *wr;
79  struct p9_conn *conn;
80 };
81 
82 /*
83  * Option Parsing (code inspired by NFS code)
84  * - a little lazy - parse all fd-transport options
85  */
86 
87 enum {
88  /* Options that take integer arguments */
90 };
91 
92 static const match_table_t tokens = {
93  {Opt_port, "port=%u"},
94  {Opt_rfdno, "rfdno=%u"},
95  {Opt_wfdno, "wfdno=%u"},
96  {Opt_err, NULL},
97 };
98 
99 enum {
100  Rworksched = 1, /* read work scheduled or running */
101  Rpending = 2, /* can read */
102  Wworksched = 4, /* write work scheduled or running */
103  Wpending = 8, /* can write */
104 };
105 
106 struct p9_poll_wait {
107  struct p9_conn *conn;
110 };
111 
136 struct p9_conn {
138  struct p9_client *client;
139  int err;
142  struct p9_req_t *req;
143  char tmp_buf[7];
144  int rsize;
145  int rpos;
146  char *rbuf;
147  int wpos;
148  int wsize;
149  char *wbuf;
153  struct work_struct rq;
154  struct work_struct wq;
155  unsigned long wsched;
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 void p9_mux_poll_stop(struct p9_conn *m)
165 {
166  unsigned long flags;
167  int i;
168 
169  for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
170  struct p9_poll_wait *pwait = &m->poll_wait[i];
171 
172  if (pwait->wait_addr) {
173  remove_wait_queue(pwait->wait_addr, &pwait->wait);
174  pwait->wait_addr = NULL;
175  }
176  }
177 
178  spin_lock_irqsave(&p9_poll_lock, flags);
179  list_del_init(&m->poll_pending_link);
180  spin_unlock_irqrestore(&p9_poll_lock, flags);
181 }
182 
190 static void p9_conn_cancel(struct p9_conn *m, int err)
191 {
192  struct p9_req_t *req, *rtmp;
193  unsigned long flags;
194  LIST_HEAD(cancel_list);
195 
196  p9_debug(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
197 
198  spin_lock_irqsave(&m->client->lock, flags);
199 
200  if (m->err) {
201  spin_unlock_irqrestore(&m->client->lock, flags);
202  return;
203  }
204 
205  m->err = err;
206 
207  list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
208  req->status = REQ_STATUS_ERROR;
209  if (!req->t_err)
210  req->t_err = err;
211  list_move(&req->req_list, &cancel_list);
212  }
214  req->status = REQ_STATUS_ERROR;
215  if (!req->t_err)
216  req->t_err = err;
217  list_move(&req->req_list, &cancel_list);
218  }
219  spin_unlock_irqrestore(&m->client->lock, flags);
220 
221  list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
222  p9_debug(P9_DEBUG_ERROR, "call back req %p\n", req);
223  list_del(&req->req_list);
224  p9_client_cb(m->client, req);
225  }
226 }
227 
228 static int
229 p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt)
230 {
231  int ret, n;
232  struct p9_trans_fd *ts = NULL;
233 
234  if (client && client->status == Connected)
235  ts = client->trans;
236 
237  if (!ts)
238  return -EREMOTEIO;
239 
240  if (!ts->rd->f_op || !ts->rd->f_op->poll)
241  return -EIO;
242 
243  if (!ts->wr->f_op || !ts->wr->f_op->poll)
244  return -EIO;
245 
246  ret = ts->rd->f_op->poll(ts->rd, pt);
247  if (ret < 0)
248  return ret;
249 
250  if (ts->rd != ts->wr) {
251  n = ts->wr->f_op->poll(ts->wr, pt);
252  if (n < 0)
253  return n;
254  ret = (ret & ~POLLOUT) | (n & ~POLLIN);
255  }
256 
257  return ret;
258 }
259 
268 static int p9_fd_read(struct p9_client *client, void *v, int len)
269 {
270  int ret;
271  struct p9_trans_fd *ts = NULL;
272 
273  if (client && client->status != Disconnected)
274  ts = client->trans;
275 
276  if (!ts)
277  return -EREMOTEIO;
278 
279  if (!(ts->rd->f_flags & O_NONBLOCK))
280  p9_debug(P9_DEBUG_ERROR, "blocking read ...\n");
281 
282  ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
283  if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
284  client->status = Disconnected;
285  return ret;
286 }
287 
294 static void p9_read_work(struct work_struct *work)
295 {
296  int n, err;
297  struct p9_conn *m;
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 %d\n", m, m->rpos);
305 
306  if (!m->rbuf) {
307  m->rbuf = m->tmp_buf;
308  m->rpos = 0;
309  m->rsize = 7; /* start by reading header */
310  }
311 
312  clear_bit(Rpending, &m->wsched);
313  p9_debug(P9_DEBUG_TRANS, "read mux %p pos %d size: %d = %d\n",
314  m, m->rpos, m->rsize, m->rsize-m->rpos);
315  err = p9_fd_read(m->client, m->rbuf + m->rpos,
316  m->rsize - m->rpos);
317  p9_debug(P9_DEBUG_TRANS, "mux %p got %d bytes\n", m, err);
318  if (err == -EAGAIN) {
319  goto end_clear;
320  }
321 
322  if (err <= 0)
323  goto error;
324 
325  m->rpos += err;
326 
327  if ((!m->req) && (m->rpos == m->rsize)) { /* header read in */
328  u16 tag;
329  p9_debug(P9_DEBUG_TRANS, "got new header\n");
330 
331  n = le32_to_cpu(*(__le32 *) m->rbuf); /* read packet size */
332  if (n >= m->client->msize) {
334  "requested packet size too big: %d\n", n);
335  err = -EIO;
336  goto error;
337  }
338 
339  tag = le16_to_cpu(*(__le16 *) (m->rbuf+5)); /* read tag */
341  "mux %p pkt: size: %d bytes tag: %d\n", m, n, tag);
342 
343  m->req = p9_tag_lookup(m->client, tag);
344  if (!m->req || (m->req->status != REQ_STATUS_SENT &&
345  m->req->status != REQ_STATUS_FLSH)) {
346  p9_debug(P9_DEBUG_ERROR, "Unexpected packet tag %d\n",
347  tag);
348  err = -EIO;
349  goto error;
350  }
351 
352  if (m->req->rc == NULL) {
353  m->req->rc = kmalloc(sizeof(struct p9_fcall) +
354  m->client->msize, GFP_NOFS);
355  if (!m->req->rc) {
356  m->req = NULL;
357  err = -ENOMEM;
358  goto error;
359  }
360  }
361  m->rbuf = (char *)m->req->rc + sizeof(struct p9_fcall);
362  memcpy(m->rbuf, m->tmp_buf, m->rsize);
363  m->rsize = n;
364  }
365 
366  /* not an else because some packets (like clunk) have no payload */
367  if ((m->req) && (m->rpos == m->rsize)) { /* packet is read in */
368  p9_debug(P9_DEBUG_TRANS, "got new packet\n");
369  spin_lock(&m->client->lock);
370  if (m->req->status != REQ_STATUS_ERROR)
371  m->req->status = REQ_STATUS_RCVD;
372  list_del(&m->req->req_list);
373  spin_unlock(&m->client->lock);
374  p9_client_cb(m->client, m->req);
375  m->rbuf = NULL;
376  m->rpos = 0;
377  m->rsize = 0;
378  m->req = NULL;
379  }
380 
381 end_clear:
383 
384  if (!list_empty(&m->req_list)) {
386  n = POLLIN;
387  else
388  n = p9_fd_poll(m->client, NULL);
389 
390  if ((n & POLLIN) && !test_and_set_bit(Rworksched, &m->wsched)) {
391  p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
392  schedule_work(&m->rq);
393  }
394  }
395 
396  return;
397 error:
398  p9_conn_cancel(m, err);
400 }
401 
410 static int p9_fd_write(struct p9_client *client, void *v, int len)
411 {
412  int ret;
413  mm_segment_t oldfs;
414  struct p9_trans_fd *ts = NULL;
415 
416  if (client && client->status != Disconnected)
417  ts = client->trans;
418 
419  if (!ts)
420  return -EREMOTEIO;
421 
422  if (!(ts->wr->f_flags & O_NONBLOCK))
423  p9_debug(P9_DEBUG_ERROR, "blocking write ...\n");
424 
425  oldfs = get_fs();
426  set_fs(get_ds());
427  /* The cast to a user pointer is valid due to the set_fs() */
428  ret = vfs_write(ts->wr, (__force void __user *)v, len, &ts->wr->f_pos);
429  set_fs(oldfs);
430 
431  if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
432  client->status = Disconnected;
433  return ret;
434 }
435 
442 static void p9_write_work(struct work_struct *work)
443 {
444  int n, err;
445  struct p9_conn *m;
446  struct p9_req_t *req;
447 
448  m = container_of(work, struct p9_conn, wq);
449 
450  if (m->err < 0) {
452  return;
453  }
454 
455  if (!m->wsize) {
456  spin_lock(&m->client->lock);
457  if (list_empty(&m->unsent_req_list)) {
459  spin_unlock(&m->client->lock);
460  return;
461  }
462 
463  req = list_entry(m->unsent_req_list.next, struct p9_req_t,
464  req_list);
465  req->status = REQ_STATUS_SENT;
466  p9_debug(P9_DEBUG_TRANS, "move req %p\n", req);
467  list_move_tail(&req->req_list, &m->req_list);
468 
469  m->wbuf = req->tc->sdata;
470  m->wsize = req->tc->size;
471  m->wpos = 0;
472  spin_unlock(&m->client->lock);
473  }
474 
475  p9_debug(P9_DEBUG_TRANS, "mux %p pos %d size %d\n",
476  m, m->wpos, m->wsize);
477  clear_bit(Wpending, &m->wsched);
478  err = p9_fd_write(m->client, m->wbuf + m->wpos, m->wsize - m->wpos);
479  p9_debug(P9_DEBUG_TRANS, "mux %p sent %d bytes\n", m, err);
480  if (err == -EAGAIN)
481  goto end_clear;
482 
483 
484  if (err < 0)
485  goto error;
486  else if (err == 0) {
487  err = -EREMOTEIO;
488  goto error;
489  }
490 
491  m->wpos += err;
492  if (m->wpos == m->wsize)
493  m->wpos = m->wsize = 0;
494 
495 end_clear:
497 
498  if (m->wsize || !list_empty(&m->unsent_req_list)) {
500  n = POLLOUT;
501  else
502  n = p9_fd_poll(m->client, NULL);
503 
504  if ((n & POLLOUT) &&
506  p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
507  schedule_work(&m->wq);
508  }
509  }
510 
511  return;
512 
513 error:
514  p9_conn_cancel(m, err);
516 }
517 
518 static int p9_pollwake(wait_queue_t *wait, unsigned int mode, int sync, void *key)
519 {
520  struct p9_poll_wait *pwait =
521  container_of(wait, struct p9_poll_wait, wait);
522  struct p9_conn *m = pwait->conn;
523  unsigned long flags;
524 
525  spin_lock_irqsave(&p9_poll_lock, flags);
526  if (list_empty(&m->poll_pending_link))
527  list_add_tail(&m->poll_pending_link, &p9_poll_pending_list);
528  spin_unlock_irqrestore(&p9_poll_lock, flags);
529 
530  schedule_work(&p9_poll_work);
531  return 1;
532 }
533 
543 static void
544 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
545 {
546  struct p9_conn *m = container_of(p, struct p9_conn, pt);
547  struct p9_poll_wait *pwait = NULL;
548  int i;
549 
550  for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
551  if (m->poll_wait[i].wait_addr == NULL) {
552  pwait = &m->poll_wait[i];
553  break;
554  }
555  }
556 
557  if (!pwait) {
558  p9_debug(P9_DEBUG_ERROR, "not enough wait_address slots\n");
559  return;
560  }
561 
562  pwait->conn = m;
563  pwait->wait_addr = wait_address;
564  init_waitqueue_func_entry(&pwait->wait, p9_pollwake);
565  add_wait_queue(wait_address, &pwait->wait);
566 }
567 
575 static struct p9_conn *p9_conn_create(struct p9_client *client)
576 {
577  int n;
578  struct p9_conn *m;
579 
580  p9_debug(P9_DEBUG_TRANS, "client %p msize %d\n", client, client->msize);
581  m = kzalloc(sizeof(struct p9_conn), GFP_KERNEL);
582  if (!m)
583  return ERR_PTR(-ENOMEM);
584 
585  INIT_LIST_HEAD(&m->mux_list);
586  m->client = client;
587 
588  INIT_LIST_HEAD(&m->req_list);
589  INIT_LIST_HEAD(&m->unsent_req_list);
590  INIT_WORK(&m->rq, p9_read_work);
591  INIT_WORK(&m->wq, p9_write_work);
592  INIT_LIST_HEAD(&m->poll_pending_link);
593  init_poll_funcptr(&m->pt, p9_pollwait);
594 
595  n = p9_fd_poll(client, &m->pt);
596  if (n & POLLIN) {
597  p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
598  set_bit(Rpending, &m->wsched);
599  }
600 
601  if (n & POLLOUT) {
602  p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
603  set_bit(Wpending, &m->wsched);
604  }
605 
606  return m;
607 }
608 
615 static void p9_poll_mux(struct p9_conn *m)
616 {
617  int n;
618 
619  if (m->err < 0)
620  return;
621 
622  n = p9_fd_poll(m->client, NULL);
623  if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
624  p9_debug(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
625  if (n >= 0)
626  n = -ECONNRESET;
627  p9_conn_cancel(m, n);
628  }
629 
630  if (n & POLLIN) {
631  set_bit(Rpending, &m->wsched);
632  p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
633  if (!test_and_set_bit(Rworksched, &m->wsched)) {
634  p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
635  schedule_work(&m->rq);
636  }
637  }
638 
639  if (n & POLLOUT) {
640  set_bit(Wpending, &m->wsched);
641  p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
642  if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
644  p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
645  schedule_work(&m->wq);
646  }
647  }
648 }
649 
661 static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
662 {
663  int n;
664  struct p9_trans_fd *ts = client->trans;
665  struct p9_conn *m = ts->conn;
666 
667  p9_debug(P9_DEBUG_TRANS, "mux %p task %p tcall %p id %d\n",
668  m, current, req->tc, req->tc->id);
669  if (m->err < 0)
670  return m->err;
671 
672  spin_lock(&client->lock);
673  req->status = REQ_STATUS_UNSENT;
675  spin_unlock(&client->lock);
676 
678  n = POLLOUT;
679  else
680  n = p9_fd_poll(m->client, NULL);
681 
682  if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
683  schedule_work(&m->wq);
684 
685  return 0;
686 }
687 
688 static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
689 {
690  int ret = 1;
691 
692  p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
693 
694  spin_lock(&client->lock);
695 
696  if (req->status == REQ_STATUS_UNSENT) {
697  list_del(&req->req_list);
698  req->status = REQ_STATUS_FLSHD;
699  ret = 0;
700  } else if (req->status == REQ_STATUS_SENT)
701  req->status = REQ_STATUS_FLSH;
702 
703  spin_unlock(&client->lock);
704 
705  return ret;
706 }
707 
716 static int parse_opts(char *params, struct p9_fd_opts *opts)
717 {
718  char *p;
720  int option;
721  char *options, *tmp_options;
722 
723  opts->port = P9_PORT;
724  opts->rfd = ~0;
725  opts->wfd = ~0;
726 
727  if (!params)
728  return 0;
729 
730  tmp_options = kstrdup(params, GFP_KERNEL);
731  if (!tmp_options) {
733  "failed to allocate copy of option string\n");
734  return -ENOMEM;
735  }
736  options = tmp_options;
737 
738  while ((p = strsep(&options, ",")) != NULL) {
739  int token;
740  int r;
741  if (!*p)
742  continue;
743  token = match_token(p, tokens, args);
744  if (token != Opt_err) {
745  r = match_int(&args[0], &option);
746  if (r < 0) {
748  "integer field, but no integer?\n");
749  continue;
750  }
751  }
752  switch (token) {
753  case Opt_port:
754  opts->port = option;
755  break;
756  case Opt_rfdno:
757  opts->rfd = option;
758  break;
759  case Opt_wfdno:
760  opts->wfd = option;
761  break;
762  default:
763  continue;
764  }
765  }
766 
767  kfree(tmp_options);
768  return 0;
769 }
770 
771 static int p9_fd_open(struct p9_client *client, int rfd, int wfd)
772 {
773  struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
774  GFP_KERNEL);
775  if (!ts)
776  return -ENOMEM;
777 
778  ts->rd = fget(rfd);
779  ts->wr = fget(wfd);
780  if (!ts->rd || !ts->wr) {
781  if (ts->rd)
782  fput(ts->rd);
783  if (ts->wr)
784  fput(ts->wr);
785  kfree(ts);
786  return -EIO;
787  }
788 
789  client->trans = ts;
790  client->status = Connected;
791 
792  return 0;
793 }
794 
795 static int p9_socket_open(struct p9_client *client, struct socket *csocket)
796 {
797  struct p9_trans_fd *p;
798  struct file *file;
799  int ret;
800 
801  p = kmalloc(sizeof(struct p9_trans_fd), GFP_KERNEL);
802  if (!p)
803  return -ENOMEM;
804 
805  csocket->sk->sk_allocation = GFP_NOIO;
806  file = sock_alloc_file(csocket, 0, NULL);
807  if (IS_ERR(file)) {
808  pr_err("%s (%d): failed to map fd\n",
809  __func__, task_pid_nr(current));
810  sock_release(csocket);
811  kfree(p);
812  return PTR_ERR(file);
813  }
814 
815  get_file(file);
816  p->wr = p->rd = file;
817  client->trans = p;
818  client->status = Connected;
819 
820  p->rd->f_flags |= O_NONBLOCK;
821 
822  p->conn = p9_conn_create(client);
823  if (IS_ERR(p->conn)) {
824  ret = PTR_ERR(p->conn);
825  p->conn = NULL;
826  kfree(p);
827  sockfd_put(csocket);
828  sockfd_put(csocket);
829  return ret;
830  }
831  return 0;
832 }
833 
840 static void p9_conn_destroy(struct p9_conn *m)
841 {
842  p9_debug(P9_DEBUG_TRANS, "mux %p prev %p next %p\n",
843  m, m->mux_list.prev, m->mux_list.next);
844 
845  p9_mux_poll_stop(m);
846  cancel_work_sync(&m->rq);
847  cancel_work_sync(&m->wq);
848 
849  p9_conn_cancel(m, -ECONNRESET);
850 
851  m->client = NULL;
852  kfree(m);
853 }
854 
861 static void p9_fd_close(struct p9_client *client)
862 {
863  struct p9_trans_fd *ts;
864 
865  if (!client)
866  return;
867 
868  ts = client->trans;
869  if (!ts)
870  return;
871 
872  client->status = Disconnected;
873 
874  p9_conn_destroy(ts->conn);
875 
876  if (ts->rd)
877  fput(ts->rd);
878  if (ts->wr)
879  fput(ts->wr);
880 
881  kfree(ts);
882 }
883 
884 /*
885  * stolen from NFS - maybe should be made a generic function?
886  */
887 static inline int valid_ipaddr4(const char *buf)
888 {
889  int rc, count, in[4];
890 
891  rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
892  if (rc != 4)
893  return -EINVAL;
894  for (count = 0; count < 4; count++) {
895  if (in[count] > 255)
896  return -EINVAL;
897  }
898  return 0;
899 }
900 
901 static int
902 p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args)
903 {
904  int err;
905  struct socket *csocket;
906  struct sockaddr_in sin_server;
907  struct p9_fd_opts opts;
908 
909  err = parse_opts(args, &opts);
910  if (err < 0)
911  return err;
912 
913  if (valid_ipaddr4(addr) < 0)
914  return -EINVAL;
915 
916  csocket = NULL;
917 
918  sin_server.sin_family = AF_INET;
919  sin_server.sin_addr.s_addr = in_aton(addr);
920  sin_server.sin_port = htons(opts.port);
921  err = __sock_create(read_pnet(&current->nsproxy->net_ns), PF_INET,
922  SOCK_STREAM, IPPROTO_TCP, &csocket, 1);
923  if (err) {
924  pr_err("%s (%d): problem creating socket\n",
925  __func__, task_pid_nr(current));
926  return err;
927  }
928 
929  err = csocket->ops->connect(csocket,
930  (struct sockaddr *)&sin_server,
931  sizeof(struct sockaddr_in), 0);
932  if (err < 0) {
933  pr_err("%s (%d): problem connecting socket to %s\n",
934  __func__, task_pid_nr(current), addr);
935  sock_release(csocket);
936  return err;
937  }
938 
939  return p9_socket_open(client, csocket);
940 }
941 
942 static int
943 p9_fd_create_unix(struct p9_client *client, const char *addr, char *args)
944 {
945  int err;
946  struct socket *csocket;
947  struct sockaddr_un sun_server;
948 
949  csocket = NULL;
950 
951  if (strlen(addr) >= UNIX_PATH_MAX) {
952  pr_err("%s (%d): address too long: %s\n",
953  __func__, task_pid_nr(current), addr);
954  return -ENAMETOOLONG;
955  }
956 
957  sun_server.sun_family = PF_UNIX;
958  strcpy(sun_server.sun_path, addr);
959  err = __sock_create(read_pnet(&current->nsproxy->net_ns), PF_UNIX,
960  SOCK_STREAM, 0, &csocket, 1);
961  if (err < 0) {
962  pr_err("%s (%d): problem creating socket\n",
963  __func__, task_pid_nr(current));
964 
965  return err;
966  }
967  err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
968  sizeof(struct sockaddr_un) - 1, 0);
969  if (err < 0) {
970  pr_err("%s (%d): problem connecting socket: %s: %d\n",
971  __func__, task_pid_nr(current), addr, err);
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(struct p9_client *client, const char *addr, char *args)
981 {
982  int err;
983  struct p9_fd_opts opts;
984  struct p9_trans_fd *p;
985 
986  parse_opts(args, &opts);
987 
988  if (opts.rfd == ~0 || opts.wfd == ~0) {
989  pr_err("Insufficient options for proto=fd\n");
990  return -ENOPROTOOPT;
991  }
992 
993  err = p9_fd_open(client, opts.rfd, opts.wfd);
994  if (err < 0)
995  return err;
996 
997  p = (struct p9_trans_fd *) client->trans;
998  p->conn = p9_conn_create(client);
999  if (IS_ERR(p->conn)) {
1000  err = PTR_ERR(p->conn);
1001  p->conn = NULL;
1002  fput(p->rd);
1003  fput(p->wr);
1004  return err;
1005  }
1006 
1007  return 0;
1008 }
1009 
1010 static struct p9_trans_module p9_tcp_trans = {
1011  .name = "tcp",
1012  .maxsize = MAX_SOCK_BUF,
1013  .def = 1,
1014  .create = p9_fd_create_tcp,
1015  .close = p9_fd_close,
1016  .request = p9_fd_request,
1017  .cancel = p9_fd_cancel,
1018  .owner = THIS_MODULE,
1019 };
1020 
1021 static struct p9_trans_module p9_unix_trans = {
1022  .name = "unix",
1023  .maxsize = MAX_SOCK_BUF,
1024  .def = 0,
1025  .create = p9_fd_create_unix,
1026  .close = p9_fd_close,
1027  .request = p9_fd_request,
1028  .cancel = p9_fd_cancel,
1029  .owner = THIS_MODULE,
1030 };
1031 
1032 static struct p9_trans_module p9_fd_trans = {
1033  .name = "fd",
1034  .maxsize = MAX_SOCK_BUF,
1035  .def = 0,
1036  .create = p9_fd_create,
1037  .close = p9_fd_close,
1038  .request = p9_fd_request,
1039  .cancel = p9_fd_cancel,
1040  .owner = THIS_MODULE,
1041 };
1042 
1052 static void p9_poll_workfn(struct work_struct *work)
1053 {
1054  unsigned long flags;
1055 
1056  p9_debug(P9_DEBUG_TRANS, "start %p\n", current);
1057 
1058  spin_lock_irqsave(&p9_poll_lock, flags);
1059  while (!list_empty(&p9_poll_pending_list)) {
1060  struct p9_conn *conn = list_first_entry(&p9_poll_pending_list,
1061  struct p9_conn,
1063  list_del_init(&conn->poll_pending_link);
1064  spin_unlock_irqrestore(&p9_poll_lock, flags);
1065 
1066  p9_poll_mux(conn);
1067 
1068  spin_lock_irqsave(&p9_poll_lock, flags);
1069  }
1070  spin_unlock_irqrestore(&p9_poll_lock, flags);
1071 
1072  p9_debug(P9_DEBUG_TRANS, "finish\n");
1073 }
1074 
1076 {
1077  v9fs_register_trans(&p9_tcp_trans);
1078  v9fs_register_trans(&p9_unix_trans);
1079  v9fs_register_trans(&p9_fd_trans);
1080 
1081  return 0;
1082 }
1083 
1085 {
1086  flush_work(&p9_poll_work);
1087  v9fs_unregister_trans(&p9_tcp_trans);
1088  v9fs_unregister_trans(&p9_unix_trans);
1089  v9fs_unregister_trans(&p9_fd_trans);
1090 }