net/9p/trans_fd.c

   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 #include <linux/in.h>
  29 #include <linux/module.h>
  30 #include <linux/net.h>
  31 #include <linux/ipv6.h>
  32 #include <linux/kthread.h>
  33 #include <linux/errno.h>
  34 #include <linux/kernel.h>
  35 #include <linux/un.h>
  36 #include <linux/uaccess.h>
  37 #include <linux/inet.h>
  38 #include <linux/idr.h>
  39 #include <linux/file.h>
  40 #include <linux/parser.h>
  41 #include <net/9p/9p.h>
  42 #include <net/9p/transport.h>
  43
  44 #define P9_PORT 564
  45 #define MAX_SOCK_BUF (64*1024)
  46 #define ERREQFLUSH      1
  47 #define SCHED_TIMEOUT   10
  48 #define MAXPOLLWADDR    2
  49
  50 /**
  51  * struct p9_fd_opts - per-transport options
  52  * @rfd: file descriptor for reading (trans=fd)
  53  * @wfd: file descriptor for writing (trans=fd)
  54  * @port: port to connect to (trans=tcp)
  55  *
  56  */
  57
  58 struct p9_fd_opts {
  59         int rfd;
  60         int wfd;
  61         u16 port;
  62 };
  63
  64
  65 /**
  66  * struct p9_trans_fd - transport state
  67  * @rd: reference to file to read from
  68  * @wr: reference of file to write to
  69  * @conn: connection state reference
  70  *
  71  */
  72
  73 struct p9_trans_fd {
  74         struct file *rd;
  75         struct file *wr;
  76         struct p9_conn *conn;
  77 };
  78
  79 /*
  80   * Option Parsing (code inspired by NFS code)
  81   *  - a little lazy - parse all fd-transport options
  82   */
  83
  84 enum {
  85         /* Options that take integer arguments */
  86         Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
  87 };
  88
  89 static match_table_t tokens = {
  90         {Opt_port, "port=%u"},
  91         {Opt_rfdno, "rfdno=%u"},
  92         {Opt_wfdno, "wfdno=%u"},
  93         {Opt_err, NULL},
  94 };
  95
  96 enum {
  97         Rworksched = 1,         /* read work scheduled or running */
  98         Rpending = 2,           /* can read */
  99         Wworksched = 4,         /* write work scheduled or running */
 100         Wpending = 8,           /* can write */
 101 };
 102
 103 enum {
 104         None,
 105         Flushing,
 106         Flushed,
 107 };
 108
 109 struct p9_req;
 110 typedef void (*p9_conn_req_callback)(struct p9_req *req, void *a);
 111
 112 /**
 113  * struct p9_req - fd mux encoding of an rpc transaction
 114  * @lock: protects req_list
 115  * @tag: numeric tag for rpc transaction
 116  * @tcall: request &p9_fcall structure
 117  * @rcall: response &p9_fcall structure
 118  * @err: error state
 119  * @cb: callback for when response is received
 120  * @cba: argument to pass to callback
 121  * @flush: flag to indicate RPC has been flushed
 122  * @req_list: list link for higher level objects to chain requests
 123  *
 124  */
 125
 126 struct p9_req {
 127         spinlock_t lock;
 128         int tag;
 129         struct p9_fcall *tcall;
 130         struct p9_fcall *rcall;
 131         int err;
 132         p9_conn_req_callback cb;
 133         void *cba;
 134         int flush;
 135         struct list_head req_list;
 136 };
 137
 138 struct p9_mux_poll_task {
 139         struct task_struct *task;
 140         struct list_head mux_list;
 141         int muxnum;
 142 };
 143
 144 /**
 145  * struct p9_conn - fd mux connection state information
 146  * @lock: protects mux_list (?)
 147  * @mux_list: list link for mux to manage multiple connections (?)
 148  * @poll_task: task polling on this connection
 149  * @msize: maximum size for connection (dup)
 150  * @extended: 9p2000.u flag (dup)
 151  * @trans: reference to transport instance for this connection
 152  * @tagpool: id accounting for transactions
 153  * @err: error state
 154  * @req_list: accounting for requests which have been sent
 155  * @unsent_req_list: accounting for requests that haven't been sent
 156  * @rcall: current response &p9_fcall structure
 157  * @rpos: read position in current frame
 158  * @rbuf: current read buffer
 159  * @wpos: write position for current frame
 160  * @wsize: amount of data to write for current frame
 161  * @wbuf: current write buffer
 162  * @poll_wait: array of wait_q's for various worker threads
 163  * @poll_waddr: ????
 164  * @pt: poll state
 165  * @rq: current read work
 166  * @wq: current write work
 167  * @wsched: ????
 168  *
 169  */
 170
 171 struct p9_conn {
 172         spinlock_t lock; /* protect lock structure */
 173         struct list_head mux_list;
 174         struct p9_mux_poll_task *poll_task;
 175         int msize;
 176         unsigned char extended;
 177         struct p9_trans *trans;
 178         struct p9_idpool *tagpool;
 179         int err;
 180         struct list_head req_list;
 181         struct list_head unsent_req_list;
 182         struct p9_fcall *rcall;
 183         int rpos;
 184         char *rbuf;
 185         int wpos;
 186         int wsize;
 187         char *wbuf;
 188         wait_queue_t poll_wait[MAXPOLLWADDR];
 189         wait_queue_head_t *poll_waddr[MAXPOLLWADDR];
 190         poll_table pt;
 191         struct work_struct rq;
 192         struct work_struct wq;
 193         unsigned long wsched;
 194 };
 195
 196 /**
 197  * struct p9_mux_rpc - fd mux rpc accounting structure
 198  * @m: connection this request was issued on
 199  * @err: error state
 200  * @tcall: request &p9_fcall
 201  * @rcall: response &p9_fcall
 202  * @wqueue: wait queue that client is blocked on for this rpc
 203  *
 204  * Bug: isn't this information duplicated elsewhere like &p9_req
 205  */
 206
 207 struct p9_mux_rpc {
 208         struct p9_conn *m;
 209         int err;
 210         struct p9_fcall *tcall;
 211         struct p9_fcall *rcall;
 212         wait_queue_head_t wqueue;
 213 };
 214
 215 static int p9_poll_proc(void *);
 216 static void p9_read_work(struct work_struct *work);
 217 static void p9_write_work(struct work_struct *work);
 218 static void p9_pollwait(struct file *filp, wait_queue_head_t *wait_address,
 219                                                                 poll_table *p);
 220 static int p9_fd_write(struct p9_trans *trans, void *v, int len);
 221 static int p9_fd_read(struct p9_trans *trans, void *v, int len);
 222
 223 static DEFINE_MUTEX(p9_mux_task_lock);
 224 static struct workqueue_struct *p9_mux_wq;
 225
 226 static int p9_mux_num;
 227 static int p9_mux_poll_task_num;
 228 static struct p9_mux_poll_task p9_mux_poll_tasks[100];
 229
 230 static void p9_conn_destroy(struct p9_conn *);
 231 static unsigned int p9_fd_poll(struct p9_trans *trans,
 232                                                 struct poll_table_struct *pt);
 233
 234 #ifdef P9_NONBLOCK
 235 static int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
 236         p9_conn_req_callback cb, void *a);
 237 #endif /* P9_NONBLOCK */
 238
 239 static void p9_conn_cancel(struct p9_conn *m, int err);
 240
 241 static int p9_mux_global_init(void)
 242 {
 243         int i;
 244
 245         for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++)
 246                 p9_mux_poll_tasks[i].task = NULL;
 247
 248         p9_mux_wq = create_workqueue("v9fs");
 249         if (!p9_mux_wq) {
 250                 printk(KERN_WARNING "v9fs: mux: creating workqueue failed\n");
 251                 return -ENOMEM;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static u16 p9_mux_get_tag(struct p9_conn *m)
 258 {
 259         int tag;
 260
 261         tag = p9_idpool_get(m->tagpool);
 262         if (tag < 0)
 263                 return P9_NOTAG;
 264         else
 265                 return (u16) tag;
 266 }
 267
 268 static void p9_mux_put_tag(struct p9_conn *m, u16 tag)
 269 {
 270         if (tag != P9_NOTAG && p9_idpool_check(tag, m->tagpool))
 271                 p9_idpool_put(tag, m->tagpool);
 272 }
 273
 274 /**
 275  * p9_mux_calc_poll_procs - calculates the number of polling procs
 276  * @muxnum: number of mounts
 277  *
 278  * Calculation is based on the number of mounted v9fs filesystems.
 279  * The current implementation returns sqrt of the number of mounts.
 280  */
 281
 282 static int p9_mux_calc_poll_procs(int muxnum)
 283 {
 284         int n;
 285
 286         if (p9_mux_poll_task_num)
 287                 n = muxnum / p9_mux_poll_task_num +
 288                     (muxnum % p9_mux_poll_task_num ? 1 : 0);
 289         else
 290                 n = 1;
 291
 292         if (n > ARRAY_SIZE(p9_mux_poll_tasks))
 293                 n = ARRAY_SIZE(p9_mux_poll_tasks);
 294
 295         return n;
 296 }
 297
 298 static int p9_mux_poll_start(struct p9_conn *m)
 299 {
 300         int i, n;
 301         struct p9_mux_poll_task *vpt, *vptlast;
 302         struct task_struct *pproc;
 303
 304         P9_DPRINTK(P9_DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, p9_mux_num,
 305                 p9_mux_poll_task_num);
 306         mutex_lock(&p9_mux_task_lock);
 307
 308         n = p9_mux_calc_poll_procs(p9_mux_num + 1);
 309         if (n > p9_mux_poll_task_num) {
 310                 for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++) {
 311                         if (p9_mux_poll_tasks[i].task == NULL) {
 312                                 vpt = &p9_mux_poll_tasks[i];
 313                                 P9_DPRINTK(P9_DEBUG_MUX, "create proc %p\n",
 314                                                                         vpt);
 315                                 pproc = kthread_create(p9_poll_proc, vpt,
 316                                                                 "v9fs-poll");
 317
 318                                 if (!IS_ERR(pproc)) {
 319                                         vpt->task = pproc;
 320                                         INIT_LIST_HEAD(&vpt->mux_list);
 321                                         vpt->muxnum = 0;
 322                                         p9_mux_poll_task_num++;
 323                                         wake_up_process(vpt->task);
 324                                 }
 325                                 break;
 326                         }
 327                 }
 328
 329                 if (i >= ARRAY_SIZE(p9_mux_poll_tasks))
 330                         P9_DPRINTK(P9_DEBUG_ERROR,
 331                                         "warning: no free poll slots\n");
 332         }
 333
 334         n = (p9_mux_num + 1) / p9_mux_poll_task_num +
 335             ((p9_mux_num + 1) % p9_mux_poll_task_num ? 1 : 0);
 336
 337         vptlast = NULL;
 338         for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++) {
 339                 vpt = &p9_mux_poll_tasks[i];
 340                 if (vpt->task != NULL) {
 341                         vptlast = vpt;
 342                         if (vpt->muxnum < n) {
 343                                 P9_DPRINTK(P9_DEBUG_MUX, "put in proc %d\n", i);
 344                                 list_add(&m->mux_list, &vpt->mux_list);
 345                                 vpt->muxnum++;
 346                                 m->poll_task = vpt;
 347                                 memset(&m->poll_waddr, 0,
 348                                                         sizeof(m->poll_waddr));
 349                                 init_poll_funcptr(&m->pt, p9_pollwait);
 350                                 break;
 351                         }
 352                 }
 353         }
 354
 355         if (i >= ARRAY_SIZE(p9_mux_poll_tasks)) {
 356                 if (vptlast == NULL) {
 357                         mutex_unlock(&p9_mux_task_lock);
 358                         return -ENOMEM;
 359                 }
 360
 361                 P9_DPRINTK(P9_DEBUG_MUX, "put in proc %d\n", i);
 362                 list_add(&m->mux_list, &vptlast->mux_list);
 363                 vptlast->muxnum++;
 364                 m->poll_task = vptlast;
 365                 memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
 366                 init_poll_funcptr(&m->pt, p9_pollwait);
 367         }
 368
 369         p9_mux_num++;
 370         mutex_unlock(&p9_mux_task_lock);
 371
 372         return 0;
 373 }
 374
 375 static void p9_mux_poll_stop(struct p9_conn *m)
 376 {
 377         int i;
 378         struct p9_mux_poll_task *vpt;
 379
 380         mutex_lock(&p9_mux_task_lock);
 381         vpt = m->poll_task;
 382         list_del(&m->mux_list);
 383         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
 384                 if (m->poll_waddr[i] != NULL) {
 385                         remove_wait_queue(m->poll_waddr[i], &m->poll_wait[i]);
 386                         m->poll_waddr[i] = NULL;
 387                 }
 388         }
 389         vpt->muxnum--;
 390         if (!vpt->muxnum) {
 391                 P9_DPRINTK(P9_DEBUG_MUX, "destroy proc %p\n", vpt);
 392                 kthread_stop(vpt->task);
 393                 vpt->task = NULL;
 394                 p9_mux_poll_task_num--;
 395         }
 396         p9_mux_num--;
 397         mutex_unlock(&p9_mux_task_lock);
 398 }
 399
 400 /**
 401  * p9_conn_create - allocate and initialize the per-session mux data
 402  * @trans: transport structure
 403  *
 404  * Note: Creates the polling task if this is the first session.
 405  */
 406
 407 static struct p9_conn *p9_conn_create(struct p9_trans *trans)
 408 {
 409         int i, n;
 410         struct p9_conn *m;
 411
 412         P9_DPRINTK(P9_DEBUG_MUX, "transport %p msize %d\n", trans,
 413                                                                 trans->msize);
 414         m = kzalloc(sizeof(struct p9_conn), GFP_KERNEL);
 415         if (!m)
 416                 return ERR_PTR(-ENOMEM);
 417
 418         spin_lock_init(&m->lock);
 419         INIT_LIST_HEAD(&m->mux_list);
 420         m->msize = trans->msize;
 421         m->extended = trans->extended;
 422         m->trans = trans;
 423         m->tagpool = p9_idpool_create();
 424         if (IS_ERR(m->tagpool)) {
 425                 kfree(m);
 426                 return ERR_PTR(-ENOMEM);
 427         }
 428
 429         INIT_LIST_HEAD(&m->req_list);
 430         INIT_LIST_HEAD(&m->unsent_req_list);
 431         INIT_WORK(&m->rq, p9_read_work);
 432         INIT_WORK(&m->wq, p9_write_work);
 433         n = p9_mux_poll_start(m);
 434         if (n) {
 435                 kfree(m);
 436                 return ERR_PTR(n);
 437         }
 438
 439         n = p9_fd_poll(trans, &m->pt);
 440         if (n & POLLIN) {
 441                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
 442                 set_bit(Rpending, &m->wsched);
 443         }
 444
 445         if (n & POLLOUT) {
 446                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
 447                 set_bit(Wpending, &m->wsched);
 448         }
 449
 450         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
 451                 if (IS_ERR(m->poll_waddr[i])) {
 452                         p9_mux_poll_stop(m);
 453                         kfree(m);
 454                         return (void *)m->poll_waddr;   /* the error code */
 455                 }
 456         }
 457
 458         return m;
 459 }
 460
 461 /**
 462  * p9_mux_destroy - cancels all pending requests and frees mux resources
 463  * @m: mux to destroy
 464  *
 465  */
 466
 467 static void p9_conn_destroy(struct p9_conn *m)
 468 {
 469         P9_DPRINTK(P9_DEBUG_MUX, "mux %p prev %p next %p\n", m,
 470                 m->mux_list.prev, m->mux_list.next);
 471
 472         p9_mux_poll_stop(m);
 473         cancel_work_sync(&m->rq);
 474         cancel_work_sync(&m->wq);
 475
 476         p9_conn_cancel(m, -ECONNRESET);
 477
 478         m->trans = NULL;
 479         p9_idpool_destroy(m->tagpool);
 480         kfree(m);
 481 }
 482
 483 /**
 484  * p9_pollwait - add poll task to the wait queue
 485  * @filp: file pointer being polled
 486  * @wait_address: wait_q to block on
 487  * @p: poll state
 488  *
 489  * called by files poll operation to add v9fs-poll task to files wait queue
 490  */
 491
 492 static void
 493 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
 494 {
 495         int i;
 496         struct p9_conn *m;
 497
 498         m = container_of(p, struct p9_conn, pt);
 499         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)
 500                 if (m->poll_waddr[i] == NULL)
 501                         break;
 502
 503         if (i >= ARRAY_SIZE(m->poll_waddr)) {
 504                 P9_DPRINTK(P9_DEBUG_ERROR, "not enough wait_address slots\n");
 505                 return;
 506         }
 507
 508         m->poll_waddr[i] = wait_address;
 509
 510         if (!wait_address) {
 511                 P9_DPRINTK(P9_DEBUG_ERROR, "no wait_address\n");
 512                 m->poll_waddr[i] = ERR_PTR(-EIO);
 513                 return;
 514         }
 515
 516         init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);
 517         add_wait_queue(wait_address, &m->poll_wait[i]);
 518 }
 519
 520 /**
 521  * p9_poll_mux - polls a mux and schedules read or write works if necessary
 522  * @m: connection to poll
 523  *
 524  */
 525
 526 static void p9_poll_mux(struct p9_conn *m)
 527 {
 528         int n;
 529
 530         if (m->err < 0)
 531                 return;
 532
 533         n = p9_fd_poll(m->trans, NULL);
 534         if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
 535                 P9_DPRINTK(P9_DEBUG_MUX, "error mux %p err %d\n", m, n);
 536                 if (n >= 0)
 537                         n = -ECONNRESET;
 538                 p9_conn_cancel(m, n);
 539         }
 540
 541         if (n & POLLIN) {
 542                 set_bit(Rpending, &m->wsched);
 543                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
 544                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
 545                         P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
 546                         queue_work(p9_mux_wq, &m->rq);
 547                 }
 548         }
 549
 550         if (n & POLLOUT) {
 551                 set_bit(Wpending, &m->wsched);
 552                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
 553                 if ((m->wsize || !list_empty(&m->unsent_req_list))
 554                     && !test_and_set_bit(Wworksched, &m->wsched)) {
 555                         P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
 556                         queue_work(p9_mux_wq, &m->wq);
 557                 }
 558         }
 559 }
 560
 561 /**
 562  * p9_poll_proc - poll worker thread
 563  * @a: thread state and arguments
 564  *
 565  * polls all v9fs transports for new events and queues the appropriate
 566  * work to the work queue
 567  *
 568  */
 569
 570 static int p9_poll_proc(void *a)
 571 {
 572         struct p9_conn *m, *mtmp;
 573         struct p9_mux_poll_task *vpt;
 574
 575         vpt = a;
 576         P9_DPRINTK(P9_DEBUG_MUX, "start %p %p\n", current, vpt);
 577         while (!kthread_should_stop()) {
 578                 set_current_state(TASK_INTERRUPTIBLE);
 579
 580                 list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {
 581                         p9_poll_mux(m);
 582                 }
 583
 584                 P9_DPRINTK(P9_DEBUG_MUX, "sleeping...\n");
 585                 schedule_timeout(SCHED_TIMEOUT * HZ);
 586         }
 587
 588         __set_current_state(TASK_RUNNING);
 589         P9_DPRINTK(P9_DEBUG_MUX, "finish\n");
 590         return 0;
 591 }
 592
 593 /**
 594  * p9_write_work - called when a transport can send some data
 595  * @work: container for work to be done
 596  *
 597  */
 598
 599 static void p9_write_work(struct work_struct *work)
 600 {
 601         int n, err;
 602         struct p9_conn *m;
 603         struct p9_req *req;
 604
 605         m = container_of(work, struct p9_conn, wq);
 606
 607         if (m->err < 0) {
 608                 clear_bit(Wworksched, &m->wsched);
 609                 return;
 610         }
 611
 612         if (!m->wsize) {
 613                 if (list_empty(&m->unsent_req_list)) {
 614                         clear_bit(Wworksched, &m->wsched);
 615                         return;
 616                 }
 617
 618                 spin_lock(&m->lock);
 619 again:
 620                 req = list_entry(m->unsent_req_list.next, struct p9_req,
 621                                req_list);
 622                 list_move_tail(&req->req_list, &m->req_list);
 623                 if (req->err == ERREQFLUSH)
 624                         goto again;
 625
 626                 m->wbuf = req->tcall->sdata;
 627                 m->wsize = req->tcall->size;
 628                 m->wpos = 0;
 629                 spin_unlock(&m->lock);
 630         }
 631
 632         P9_DPRINTK(P9_DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos,
 633                                                                 m->wsize);
 634         clear_bit(Wpending, &m->wsched);
 635         err = p9_fd_write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);
 636         P9_DPRINTK(P9_DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
 637         if (err == -EAGAIN) {
 638                 clear_bit(Wworksched, &m->wsched);
 639                 return;
 640         }
 641
 642         if (err < 0)
 643                 goto error;
 644         else if (err == 0) {
 645                 err = -EREMOTEIO;
 646                 goto error;
 647         }
 648
 649         m->wpos += err;
 650         if (m->wpos == m->wsize)
 651                 m->wpos = m->wsize = 0;
 652
 653         if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {
 654                 if (test_and_clear_bit(Wpending, &m->wsched))
 655                         n = POLLOUT;
 656                 else
 657                         n = p9_fd_poll(m->trans, NULL);
 658
 659                 if (n & POLLOUT) {
 660                         P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
 661                         queue_work(p9_mux_wq, &m->wq);
 662                 } else
 663                         clear_bit(Wworksched, &m->wsched);
 664         } else
 665                 clear_bit(Wworksched, &m->wsched);
 666
 667         return;
 668
 669 error:
 670         p9_conn_cancel(m, err);
 671         clear_bit(Wworksched, &m->wsched);
 672 }
 673
 674 static void process_request(struct p9_conn *m, struct p9_req *req)
 675 {
 676         int ecode;
 677         struct p9_str *ename;
 678
 679         if (!req->err && req->rcall->id == P9_RERROR) {
 680                 ecode = req->rcall->params.rerror.errno;
 681                 ename = &req->rcall->params.rerror.error;
 682
 683                 P9_DPRINTK(P9_DEBUG_MUX, "Rerror %.*s\n", ename->len,
 684                                                                 ename->str);
 685
 686                 if (m->extended)
 687                         req->err = -ecode;
 688
 689                 if (!req->err) {
 690                         req->err = p9_errstr2errno(ename->str, ename->len);
 691
 692                         /* string match failed */
 693                         if (!req->err) {
 694                                 PRINT_FCALL_ERROR("unknown error", req->rcall);
 695                                 req->err = -ESERVERFAULT;
 696                         }
 697                 }
 698         } else if (req->tcall && req->rcall->id != req->tcall->id + 1) {
 699                 P9_DPRINTK(P9_DEBUG_ERROR,
 700                                 "fcall mismatch: expected %d, got %d\n",
 701                                 req->tcall->id + 1, req->rcall->id);
 702                 if (!req->err)
 703                         req->err = -EIO;
 704         }
 705 }
 706
 707 /**
 708  * p9_read_work - called when there is some data to be read from a transport
 709  * @work: container of work to be done
 710  *
 711  */
 712
 713 static void p9_read_work(struct work_struct *work)
 714 {
 715         int n, err;
 716         struct p9_conn *m;
 717         struct p9_req *req, *rptr, *rreq;
 718         struct p9_fcall *rcall;
 719         char *rbuf;
 720
 721         m = container_of(work, struct p9_conn, rq);
 722
 723         if (m->err < 0)
 724                 return;
 725
 726         rcall = NULL;
 727         P9_DPRINTK(P9_DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
 728
 729         if (!m->rcall) {
 730                 m->rcall =
 731                     kmalloc(sizeof(struct p9_fcall) + m->msize, GFP_KERNEL);
 732                 if (!m->rcall) {
 733                         err = -ENOMEM;
 734                         goto error;
 735                 }
 736
 737                 m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
 738                 m->rpos = 0;
 739         }
 740
 741         clear_bit(Rpending, &m->wsched);
 742         err = p9_fd_read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
 743         P9_DPRINTK(P9_DEBUG_MUX, "mux %p got %d bytes\n", m, err);
 744         if (err == -EAGAIN) {
 745                 clear_bit(Rworksched, &m->wsched);
 746                 return;
 747         }
 748
 749         if (err <= 0)
 750                 goto error;
 751
 752         m->rpos += err;
 753         while (m->rpos > 4) {
 754                 n = le32_to_cpu(*(__le32 *) m->rbuf);
 755                 if (n >= m->msize) {
 756                         P9_DPRINTK(P9_DEBUG_ERROR,
 757                                 "requested packet size too big: %d\n", n);
 758                         err = -EIO;
 759                         goto error;
 760                 }
 761
 762                 if (m->rpos < n)
 763                         break;
 764
 765                 err =
 766                     p9_deserialize_fcall(m->rbuf, n, m->rcall, m->extended);
 767                 if (err < 0)
 768                         goto error;
 769
 770 #ifdef CONFIG_NET_9P_DEBUG
 771                 if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
 772                         char buf[150];
 773
 774                         p9_printfcall(buf, sizeof(buf), m->rcall,
 775                                 m->extended);
 776                         printk(KERN_NOTICE ">>> %p %s\n", m, buf);
 777                 }
 778 #endif
 779
 780                 rcall = m->rcall;
 781                 rbuf = m->rbuf;
 782                 if (m->rpos > n) {
 783                         m->rcall = kmalloc(sizeof(struct p9_fcall) + m->msize,
 784                                            GFP_KERNEL);
 785                         if (!m->rcall) {
 786                                 err = -ENOMEM;
 787                                 goto error;
 788                         }
 789
 790                         m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
 791                         memmove(m->rbuf, rbuf + n, m->rpos - n);
 792                         m->rpos -= n;
 793                 } else {
 794                         m->rcall = NULL;
 795                         m->rbuf = NULL;
 796                         m->rpos = 0;
 797                 }
 798
 799                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p fcall id %d tag %d\n", m,
 800                                                         rcall->id, rcall->tag);
 801
 802                 req = NULL;
 803                 spin_lock(&m->lock);
 804                 list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
 805                         if (rreq->tag == rcall->tag) {
 806                                 req = rreq;
 807                                 if (req->flush != Flushing)
 808                                         list_del(&req->req_list);
 809                                 break;
 810                         }
 811                 }
 812                 spin_unlock(&m->lock);
 813
 814                 if (req) {
 815                         req->rcall = rcall;
 816                         process_request(m, req);
 817
 818                         if (req->flush != Flushing) {
 819                                 if (req->cb)
 820                                         (*req->cb) (req, req->cba);
 821                                 else
 822                                         kfree(req->rcall);
 823                         }
 824                 } else {
 825                         if (err >= 0 && rcall->id != P9_RFLUSH)
 826                                 P9_DPRINTK(P9_DEBUG_ERROR,
 827                                   "unexpected response mux %p id %d tag %d\n",
 828                                   m, rcall->id, rcall->tag);
 829                         kfree(rcall);
 830                 }
 831         }
 832
 833         if (!list_empty(&m->req_list)) {
 834                 if (test_and_clear_bit(Rpending, &m->wsched))
 835                         n = POLLIN;
 836                 else
 837                         n = p9_fd_poll(m->trans, NULL);
 838
 839                 if (n & POLLIN) {
 840                         P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
 841                         queue_work(p9_mux_wq, &m->rq);
 842                 } else
 843                         clear_bit(Rworksched, &m->wsched);
 844         } else
 845                 clear_bit(Rworksched, &m->wsched);
 846
 847         return;
 848
 849 error:
 850         p9_conn_cancel(m, err);
 851         clear_bit(Rworksched, &m->wsched);
 852 }
 853
 854 /**
 855  * p9_send_request - send 9P request
 856  * The function can sleep until the request is scheduled for sending.
 857  * The function can be interrupted. Return from the function is not
 858  * a guarantee that the request is sent successfully. Can return errors
 859  * that can be retrieved by PTR_ERR macros.
 860  *
 861  * @m: mux data
 862  * @tc: request to be sent
 863  * @cb: callback function to call when response is received
 864  * @cba: parameter to pass to the callback function
 865  *
 866  */
 867
 868 static struct p9_req *p9_send_request(struct p9_conn *m,
 869                                           struct p9_fcall *tc,
 870                                           p9_conn_req_callback cb, void *cba)
 871 {
 872         int n;
 873         struct p9_req *req;
 874
 875         P9_DPRINTK(P9_DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
 876                 tc, tc->id);
 877         if (m->err < 0)
 878                 return ERR_PTR(m->err);
 879
 880         req = kmalloc(sizeof(struct p9_req), GFP_KERNEL);
 881         if (!req)
 882                 return ERR_PTR(-ENOMEM);
 883
 884         if (tc->id == P9_TVERSION)
 885                 n = P9_NOTAG;
 886         else
 887                 n = p9_mux_get_tag(m);
 888
 889         if (n < 0)
 890                 return ERR_PTR(-ENOMEM);
 891
 892         p9_set_tag(tc, n);
 893
 894 #ifdef CONFIG_NET_9P_DEBUG
 895         if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
 896                 char buf[150];
 897
 898                 p9_printfcall(buf, sizeof(buf), tc, m->extended);
 899                 printk(KERN_NOTICE "<<< %p %s\n", m, buf);
 900         }
 901 #endif
 902
 903         spin_lock_init(&req->lock);
 904         req->tag = n;
 905         req->tcall = tc;
 906         req->rcall = NULL;
 907         req->err = 0;
 908         req->cb = cb;
 909         req->cba = cba;
 910         req->flush = None;
 911
 912         spin_lock(&m->lock);
 913         list_add_tail(&req->req_list, &m->unsent_req_list);
 914         spin_unlock(&m->lock);
 915
 916         if (test_and_clear_bit(Wpending, &m->wsched))
 917                 n = POLLOUT;
 918         else
 919                 n = p9_fd_poll(m->trans, NULL);
 920
 921         if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
 922                 queue_work(p9_mux_wq, &m->wq);
 923
 924         return req;
 925 }
 926
 927 static void p9_mux_free_request(struct p9_conn *m, struct p9_req *req)
 928 {
 929         p9_mux_put_tag(m, req->tag);
 930         kfree(req);
 931 }
 932
 933 static void p9_mux_flush_cb(struct p9_req *freq, void *a)
 934 {
 935         int tag;
 936         struct p9_conn *m;
 937         struct p9_req *req, *rreq, *rptr;
 938
 939         m = a;
 940         P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m,
 941                 freq->tcall, freq->rcall, freq->err,
 942                 freq->tcall->params.tflush.oldtag);
 943
 944         spin_lock(&m->lock);
 945         tag = freq->tcall->params.tflush.oldtag;
 946         req = NULL;
 947         list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
 948                 if (rreq->tag == tag) {
 949                         req = rreq;
 950                         list_del(&req->req_list);
 951                         break;
 952                 }
 953         }
 954         spin_unlock(&m->lock);
 955
 956         if (req) {
 957                 spin_lock(&req->lock);
 958                 req->flush = Flushed;
 959                 spin_unlock(&req->lock);
 960
 961                 if (req->cb)
 962                         (*req->cb) (req, req->cba);
 963                 else
 964                         kfree(req->rcall);
 965         }
 966
 967         kfree(freq->tcall);
 968         kfree(freq->rcall);
 969         p9_mux_free_request(m, freq);
 970 }
 971
 972 static int
 973 p9_mux_flush_request(struct p9_conn *m, struct p9_req *req)
 974 {
 975         struct p9_fcall *fc;
 976         struct p9_req *rreq, *rptr;
 977
 978         P9_DPRINTK(P9_DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
 979
 980         /* if a response was received for a request, do nothing */
 981         spin_lock(&req->lock);
 982         if (req->rcall || req->err) {
 983                 spin_unlock(&req->lock);
 984                 P9_DPRINTK(P9_DEBUG_MUX,
 985                         "mux %p req %p response already received\n", m, req);
 986                 return 0;
 987         }
 988
 989         req->flush = Flushing;
 990         spin_unlock(&req->lock);
 991
 992         spin_lock(&m->lock);
 993         /* if the request is not sent yet, just remove it from the list */
 994         list_for_each_entry_safe(rreq, rptr, &m->unsent_req_list, req_list) {
 995                 if (rreq->tag == req->tag) {
 996                         P9_DPRINTK(P9_DEBUG_MUX,
 997                            "mux %p req %p request is not sent yet\n", m, req);
 998                         list_del(&rreq->req_list);
 999                         req->flush = Flushed;
1000                         spin_unlock(&m->lock);
1001                         if (req->cb)
1002                                 (*req->cb) (req, req->cba);
1003                         return 0;
1004                 }
1005         }
1006         spin_unlock(&m->lock);
1007
1008         clear_thread_flag(TIF_SIGPENDING);
1009         fc = p9_create_tflush(req->tag);
1010         p9_send_request(m, fc, p9_mux_flush_cb, m);
1011         return 1;
1012 }
1013
1014 static void
1015 p9_conn_rpc_cb(struct p9_req *req, void *a)
1016 {
1017         struct p9_mux_rpc *r;
1018
1019         P9_DPRINTK(P9_DEBUG_MUX, "req %p r %p\n", req, a);
1020         r = a;
1021         r->rcall = req->rcall;
1022         r->err = req->err;
1023
1024         if (req->flush != None && !req->err)
1025                 r->err = -ERESTARTSYS;
1026
1027         wake_up(&r->wqueue);
1028 }
1029
1030 /**
1031  * p9_fd_rpc- sends 9P request and waits until a response is available.
1032  *      The function can be interrupted.
1033  * @t: transport data
1034  * @tc: request to be sent
1035  * @rc: pointer where a pointer to the response is stored
1036  *
1037  */
1038
1039 int
1040 p9_fd_rpc(struct p9_trans *t, struct p9_fcall *tc, struct p9_fcall **rc)
1041 {
1042         struct p9_trans_fd *p = t->priv;
1043         struct p9_conn *m = p->conn;
1044         int err, sigpending;
1045         unsigned long flags;
1046         struct p9_req *req;
1047         struct p9_mux_rpc r;
1048
1049         r.err = 0;
1050         r.tcall = tc;
1051         r.rcall = NULL;
1052         r.m = m;
1053         init_waitqueue_head(&r.wqueue);
1054
1055         if (rc)
1056                 *rc = NULL;
1057
1058         sigpending = 0;
1059         if (signal_pending(current)) {
1060                 sigpending = 1;
1061                 clear_thread_flag(TIF_SIGPENDING);
1062         }
1063
1064         req = p9_send_request(m, tc, p9_conn_rpc_cb, &r);
1065         if (IS_ERR(req)) {
1066                 err = PTR_ERR(req);
1067                 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1068                 return err;
1069         }
1070
1071         err = wait_event_interruptible(r.wqueue, r.rcall != NULL || r.err < 0);
1072         if (r.err < 0)
1073                 err = r.err;
1074
1075         if (err == -ERESTARTSYS && m->trans->status == Connected
1076                                                         && m->err == 0) {
1077                 if (p9_mux_flush_request(m, req)) {
1078                         /* wait until we get response of the flush message */
1079                         do {
1080                                 clear_thread_flag(TIF_SIGPENDING);
1081                                 err = wait_event_interruptible(r.wqueue,
1082                                         r.rcall || r.err);
1083                         } while (!r.rcall && !r.err && err == -ERESTARTSYS &&
1084                                 m->trans->status == Connected && !m->err);
1085
1086                         err = -ERESTARTSYS;
1087                 }
1088                 sigpending = 1;
1089         }
1090
1091         if (sigpending) {
1092                 spin_lock_irqsave(&current->sighand->siglock, flags);
1093                 recalc_sigpending();
1094                 spin_unlock_irqrestore(&current->sighand->siglock, flags);
1095         }
1096
1097         if (rc)
1098                 *rc = r.rcall;
1099         else
1100                 kfree(r.rcall);
1101
1102         p9_mux_free_request(m, req);
1103         if (err > 0)
1104                 err = -EIO;
1105
1106         return err;
1107 }
1108
1109 #ifdef P9_NONBLOCK
1110 /**
1111  * p9_conn_rpcnb - sends 9P request without waiting for response.
1112  * @m: mux data
1113  * @tc: request to be sent
1114  * @cb: callback function to be called when response arrives
1115  * @a: value to pass to the callback function
1116  *
1117  */
1118
1119 int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
1120                    p9_conn_req_callback cb, void *a)
1121 {
1122         int err;
1123         struct p9_req *req;
1124
1125         req = p9_send_request(m, tc, cb, a);
1126         if (IS_ERR(req)) {
1127                 err = PTR_ERR(req);
1128                 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1129                 return PTR_ERR(req);
1130         }
1131
1132         P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
1133         return 0;
1134 }
1135 #endif /* P9_NONBLOCK */
1136
1137 /**
1138  * p9_conn_cancel - cancel all pending requests with error
1139  * @m: mux data
1140  * @err: error code
1141  *
1142  */
1143
1144 void p9_conn_cancel(struct p9_conn *m, int err)
1145 {
1146         struct p9_req *req, *rtmp;
1147         LIST_HEAD(cancel_list);
1148
1149         P9_DPRINTK(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
1150         m->err = err;
1151         spin_lock(&m->lock);
1152         list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
1153                 list_move(&req->req_list, &cancel_list);
1154         }
1155         list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
1156                 list_move(&req->req_list, &cancel_list);
1157         }
1158         spin_unlock(&m->lock);
1159
1160         list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
1161                 list_del(&req->req_list);
1162                 if (!req->err)
1163                         req->err = err;
1164
1165                 if (req->cb)
1166                         (*req->cb) (req, req->cba);
1167                 else
1168                         kfree(req->rcall);
1169         }
1170 }
1171
1172 /**
1173  * parse_options - parse mount options into session structure
1174  * @options: options string passed from mount
1175  * @opts: transport-specific structure to parse options into
1176  *
1177  * Returns 0 upon success, -ERRNO upon failure
1178  */
1179
1180 static int parse_opts(char *params, struct p9_fd_opts *opts)
1181 {
1182         char *p;
1183         substring_t args[MAX_OPT_ARGS];
1184         int option;
1185         char *options;
1186         int ret;
1187
1188         opts->port = P9_PORT;
1189         opts->rfd = ~0;
1190         opts->wfd = ~0;
1191
1192         if (!params)
1193                 return 0;
1194
1195         options = kstrdup(params, GFP_KERNEL);
1196         if (!options) {
1197                 P9_DPRINTK(P9_DEBUG_ERROR,
1198                                 "failed to allocate copy of option string\n");
1199                 return -ENOMEM;
1200         }
1201
1202         while ((p = strsep(&options, ",")) != NULL) {
1203                 int token;
1204                 int r;
1205                 if (!*p)
1206                         continue;
1207                 token = match_token(p, tokens, args);
1208                 r = match_int(&args[0], &option);
1209                 if (r < 0) {
1210                         P9_DPRINTK(P9_DEBUG_ERROR,
1211                          "integer field, but no integer?\n");
1212                         ret = r;
1213                         continue;
1214                 }
1215                 switch (token) {
1216                 case Opt_port:
1217                         opts->port = option;
1218                         break;
1219                 case Opt_rfdno:
1220                         opts->rfd = option;
1221                         break;
1222                 case Opt_wfdno:
1223                         opts->wfd = option;
1224                         break;
1225                 default:
1226                         continue;
1227                 }
1228         }
1229         kfree(options);
1230         return 0;
1231 }
1232
1233 static int p9_fd_open(struct p9_trans *trans, int rfd, int wfd)
1234 {
1235         struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
1236                                            GFP_KERNEL);
1237         if (!ts)
1238                 return -ENOMEM;
1239
1240         ts->rd = fget(rfd);
1241         ts->wr = fget(wfd);
1242         if (!ts->rd || !ts->wr) {
1243                 if (ts->rd)
1244                         fput(ts->rd);
1245                 if (ts->wr)
1246                         fput(ts->wr);
1247                 kfree(ts);
1248                 return -EIO;
1249         }
1250
1251         trans->priv = ts;
1252         trans->status = Connected;
1253
1254         return 0;
1255 }
1256
1257 static int p9_socket_open(struct p9_trans *trans, struct socket *csocket)
1258 {
1259         int fd, ret;
1260
1261         csocket->sk->sk_allocation = GFP_NOIO;
1262         fd = sock_map_fd(csocket, 0);
1263         if (fd < 0) {
1264                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
1265                 return fd;
1266         }
1267
1268         ret = p9_fd_open(trans, fd, fd);
1269         if (ret < 0) {
1270                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd\n");
1271                 sockfd_put(csocket);
1272                 return ret;
1273         }
1274
1275         ((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;
1276
1277         return 0;
1278 }
1279
1280 /**
1281  * p9_fd_read- read from a fd
1282  * @trans: transport instance state
1283  * @v: buffer to receive data into
1284  * @len: size of receive buffer
1285  *
1286  */
1287
1288 static int p9_fd_read(struct p9_trans *trans, void *v, int len)
1289 {
1290         int ret;
1291         struct p9_trans_fd *ts = NULL;
1292
1293         if (trans && trans->status != Disconnected)
1294                 ts = trans->priv;
1295
1296         if (!ts)
1297                 return -EREMOTEIO;
1298
1299         if (!(ts->rd->f_flags & O_NONBLOCK))
1300                 P9_DPRINTK(P9_DEBUG_ERROR, "blocking read ...\n");
1301
1302         ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
1303         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1304                 trans->status = Disconnected;
1305         return ret;
1306 }
1307
1308 /**
1309  * p9_fd_write - write to a socket
1310  * @trans: transport instance state
1311  * @v: buffer to send data from
1312  * @len: size of send buffer
1313  *
1314  */
1315
1316 static int p9_fd_write(struct p9_trans *trans, void *v, int len)
1317 {
1318         int ret;
1319         mm_segment_t oldfs;
1320         struct p9_trans_fd *ts = NULL;
1321
1322         if (trans && trans->status != Disconnected)
1323                 ts = trans->priv;
1324
1325         if (!ts)
1326                 return -EREMOTEIO;
1327
1328         if (!(ts->wr->f_flags & O_NONBLOCK))
1329                 P9_DPRINTK(P9_DEBUG_ERROR, "blocking write ...\n");
1330
1331         oldfs = get_fs();
1332         set_fs(get_ds());
1333         /* The cast to a user pointer is valid due to the set_fs() */
1334         ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
1335         set_fs(oldfs);
1336
1337         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1338                 trans->status = Disconnected;
1339         return ret;
1340 }
1341
1342 static unsigned int
1343 p9_fd_poll(struct p9_trans *trans, struct poll_table_struct *pt)
1344 {
1345         int ret, n;
1346         struct p9_trans_fd *ts = NULL;
1347
1348         if (trans && trans->status == Connected)
1349                 ts = trans->priv;
1350
1351         if (!ts)
1352                 return -EREMOTEIO;
1353
1354         if (!ts->rd->f_op || !ts->rd->f_op->poll)
1355                 return -EIO;
1356
1357         if (!ts->wr->f_op || !ts->wr->f_op->poll)
1358                 return -EIO;
1359
1360         ret = ts->rd->f_op->poll(ts->rd, pt);
1361         if (ret < 0)
1362                 return ret;
1363
1364         if (ts->rd != ts->wr) {
1365                 n = ts->wr->f_op->poll(ts->wr, pt);
1366                 if (n < 0)
1367                         return n;
1368                 ret = (ret & ~POLLOUT) | (n & ~POLLIN);
1369         }
1370
1371         return ret;
1372 }
1373
1374 /**
1375  * p9_fd_close - shutdown socket
1376  * @trans: private socket structure
1377  *
1378  */
1379
1380 static void p9_fd_close(struct p9_trans *trans)
1381 {
1382         struct p9_trans_fd *ts;
1383
1384         if (!trans)
1385                 return;
1386
1387         ts = xchg(&trans->priv, NULL);
1388
1389         if (!ts)
1390                 return;
1391
1392         p9_conn_destroy(ts->conn);
1393
1394         trans->status = Disconnected;
1395         if (ts->rd)
1396                 fput(ts->rd);
1397         if (ts->wr)
1398                 fput(ts->wr);
1399         kfree(ts);
1400 }
1401
1402 /*
1403  * stolen from NFS - maybe should be made a generic function?
1404  */
1405 static inline int valid_ipaddr4(const char *buf)
1406 {
1407         int rc, count, in[4];
1408
1409         rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
1410         if (rc != 4)
1411                 return -EINVAL;
1412         for (count = 0; count < 4; count++) {
1413                 if (in[count] > 255)
1414                         return -EINVAL;
1415         }
1416         return 0;
1417 }
1418
1419 static struct p9_trans *
1420 p9_trans_create_tcp(const char *addr, char *args, int msize, unsigned char dotu)
1421 {
1422         int err;
1423         struct p9_trans *trans;
1424         struct socket *csocket;
1425         struct sockaddr_in sin_server;
1426         struct p9_fd_opts opts;
1427         struct p9_trans_fd *p;
1428
1429         err = parse_opts(args, &opts);
1430         if (err < 0)
1431                 return ERR_PTR(err);
1432
1433         if (valid_ipaddr4(addr) < 0)
1434                 return ERR_PTR(-EINVAL);
1435
1436         csocket = NULL;
1437         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1438         if (!trans)
1439                 return ERR_PTR(-ENOMEM);
1440         trans->msize = msize;
1441         trans->extended = dotu;
1442         trans->rpc = p9_fd_rpc;
1443         trans->close = p9_fd_close;
1444
1445         sin_server.sin_family = AF_INET;
1446         sin_server.sin_addr.s_addr = in_aton(addr);
1447         sin_server.sin_port = htons(opts.port);
1448         sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
1449
1450         if (!csocket) {
1451                 P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
1452                 err = -EIO;
1453                 goto error;
1454         }
1455
1456         err = csocket->ops->connect(csocket,
1457                                     (struct sockaddr *)&sin_server,
1458                                     sizeof(struct sockaddr_in), 0);
1459         if (err < 0) {
1460                 P9_EPRINTK(KERN_ERR,
1461                         "p9_trans_tcp: problem connecting socket to %s\n",
1462                         addr);
1463                 goto error;
1464         }
1465
1466         err = p9_socket_open(trans, csocket);
1467         if (err < 0)
1468                 goto error;
1469
1470         p = (struct p9_trans_fd *) trans->priv;
1471         p->conn = p9_conn_create(trans);
1472         if (IS_ERR(p->conn)) {
1473                 err = PTR_ERR(p->conn);
1474                 p->conn = NULL;
1475                 goto error;
1476         }
1477
1478         return trans;
1479
1480 error:
1481         if (csocket)
1482                 sock_release(csocket);
1483
1484         kfree(trans);
1485         return ERR_PTR(err);
1486 }
1487
1488 static struct p9_trans *
1489 p9_trans_create_unix(const char *addr, char *args, int msize,
1490                                                         unsigned char dotu)
1491 {
1492         int err;
1493         struct socket *csocket;
1494         struct sockaddr_un sun_server;
1495         struct p9_trans *trans;
1496         struct p9_trans_fd *p;
1497
1498         csocket = NULL;
1499         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1500         if (!trans)
1501                 return ERR_PTR(-ENOMEM);
1502
1503         trans->rpc = p9_fd_rpc;
1504         trans->close = p9_fd_close;
1505
1506         if (strlen(addr) > UNIX_PATH_MAX) {
1507                 P9_EPRINTK(KERN_ERR, "p9_trans_unix: address too long: %s\n",
1508                         addr);
1509                 err = -ENAMETOOLONG;
1510                 goto error;
1511         }
1512
1513         sun_server.sun_family = PF_UNIX;
1514         strcpy(sun_server.sun_path, addr);
1515         sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
1516         err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1517                         sizeof(struct sockaddr_un) - 1, 0);
1518         if (err < 0) {
1519                 P9_EPRINTK(KERN_ERR,
1520                         "p9_trans_unix: problem connecting socket: %s: %d\n",
1521                         addr, err);
1522                 goto error;
1523         }
1524
1525         err = p9_socket_open(trans, csocket);
1526         if (err < 0)
1527                 goto error;
1528
1529         trans->msize = msize;
1530         trans->extended = dotu;
1531         p = (struct p9_trans_fd *) trans->priv;
1532         p->conn = p9_conn_create(trans);
1533         if (IS_ERR(p->conn)) {
1534                 err = PTR_ERR(p->conn);
1535                 p->conn = NULL;
1536                 goto error;
1537         }
1538
1539         return trans;
1540
1541 error:
1542         if (csocket)
1543                 sock_release(csocket);
1544
1545         kfree(trans);
1546         return ERR_PTR(err);
1547 }
1548
1549 static struct p9_trans *
1550 p9_trans_create_fd(const char *name, char *args, int msize,
1551                                                         unsigned char extended)
1552 {
1553         int err;
1554         struct p9_trans *trans;
1555         struct p9_fd_opts opts;
1556         struct p9_trans_fd *p;
1557
1558         parse_opts(args, &opts);
1559
1560         if (opts.rfd == ~0 || opts.wfd == ~0) {
1561                 printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
1562                 return ERR_PTR(-ENOPROTOOPT);
1563         }
1564
1565         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1566         if (!trans)
1567                 return ERR_PTR(-ENOMEM);
1568
1569         trans->rpc = p9_fd_rpc;
1570         trans->close = p9_fd_close;
1571
1572         err = p9_fd_open(trans, opts.rfd, opts.wfd);
1573         if (err < 0)
1574                 goto error;
1575
1576         trans->msize = msize;
1577         trans->extended = extended;
1578         p = (struct p9_trans_fd *) trans->priv;
1579         p->conn = p9_conn_create(trans);
1580         if (IS_ERR(p->conn)) {
1581                 err = PTR_ERR(p->conn);
1582                 p->conn = NULL;
1583                 goto error;
1584         }
1585
1586         return trans;
1587
1588 error:
1589         kfree(trans);
1590         return ERR_PTR(err);
1591 }
1592
1593 static struct p9_trans_module p9_tcp_trans = {
1594         .name = "tcp",
1595         .maxsize = MAX_SOCK_BUF,
1596         .def = 1,
1597         .create = p9_trans_create_tcp,
1598         .owner = THIS_MODULE,
1599 };
1600
1601 static struct p9_trans_module p9_unix_trans = {
1602         .name = "unix",
1603         .maxsize = MAX_SOCK_BUF,
1604         .def = 0,
1605         .create = p9_trans_create_unix,
1606         .owner = THIS_MODULE,
1607 };
1608
1609 static struct p9_trans_module p9_fd_trans = {
1610         .name = "fd",
1611         .maxsize = MAX_SOCK_BUF,
1612         .def = 0,
1613         .create = p9_trans_create_fd,
1614         .owner = THIS_MODULE,
1615 };
1616
1617 int p9_trans_fd_init(void)
1618 {
1619         int ret = p9_mux_global_init();
1620         if (ret) {
1621                 printk(KERN_WARNING "9p: starting mux failed\n");
1622                 return ret;
1623         }
1624
1625         v9fs_register_trans(&p9_tcp_trans);
1626         v9fs_register_trans(&p9_unix_trans);
1627         v9fs_register_trans(&p9_fd_trans);
1628
1629         return 0;
1630 }
1631
1632 void p9_trans_fd_exit(void)
1633 {
1634         v9fs_unregister_trans(&p9_tcp_trans);
1635         v9fs_unregister_trans(&p9_unix_trans);
1636         v9fs_unregister_trans(&p9_fd_trans);
1637 }