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, *mtmp;
 411
 412         P9_DPRINTK(P9_DEBUG_MUX, "transport %p msize %d\n", trans,
 413                                                                 trans->msize);
 414         m = kmalloc(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                 mtmp = ERR_PTR(-ENOMEM);
 426                 kfree(m);
 427                 return mtmp;
 428         }
 429
 430         m->err = 0;
 431         INIT_LIST_HEAD(&m->req_list);
 432         INIT_LIST_HEAD(&m->unsent_req_list);
 433         m->rcall = NULL;
 434         m->rpos = 0;
 435         m->rbuf = NULL;
 436         m->wpos = m->wsize = 0;
 437         m->wbuf = NULL;
 438         INIT_WORK(&m->rq, p9_read_work);
 439         INIT_WORK(&m->wq, p9_write_work);
 440         m->wsched = 0;
 441         memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
 442         m->poll_task = NULL;
 443         n = p9_mux_poll_start(m);
 444         if (n) {
 445                 kfree(m);
 446                 return ERR_PTR(n);
 447         }
 448
 449         n = p9_fd_poll(trans, &m->pt);
 450         if (n & POLLIN) {
 451                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
 452                 set_bit(Rpending, &m->wsched);
 453         }
 454
 455         if (n & POLLOUT) {
 456                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
 457                 set_bit(Wpending, &m->wsched);
 458         }
 459
 460         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
 461                 if (IS_ERR(m->poll_waddr[i])) {
 462                         p9_mux_poll_stop(m);
 463                         mtmp = (void *)m->poll_waddr;   /* the error code */
 464                         kfree(m);
 465                         m = mtmp;
 466                         break;
 467                 }
 468         }
 469
 470         return m;
 471 }
 472
 473 /**
 474  * p9_mux_destroy - cancels all pending requests and frees mux resources
 475  * @m: mux to destroy
 476  *
 477  */
 478
 479 static void p9_conn_destroy(struct p9_conn *m)
 480 {
 481         P9_DPRINTK(P9_DEBUG_MUX, "mux %p prev %p next %p\n", m,
 482                 m->mux_list.prev, m->mux_list.next);
 483
 484         p9_mux_poll_stop(m);
 485         cancel_work_sync(&m->rq);
 486         cancel_work_sync(&m->wq);
 487
 488         p9_conn_cancel(m, -ECONNRESET);
 489
 490         m->trans = NULL;
 491         p9_idpool_destroy(m->tagpool);
 492         kfree(m);
 493 }
 494
 495 /**
 496  * p9_pollwait - add poll task to the wait queue
 497  * @filp: file pointer being polled
 498  * @wait_address: wait_q to block on
 499  * @p: poll state
 500  *
 501  * called by files poll operation to add v9fs-poll task to files wait queue
 502  */
 503
 504 static void
 505 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
 506 {
 507         int i;
 508         struct p9_conn *m;
 509
 510         m = container_of(p, struct p9_conn, pt);
 511         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)
 512                 if (m->poll_waddr[i] == NULL)
 513                         break;
 514
 515         if (i >= ARRAY_SIZE(m->poll_waddr)) {
 516                 P9_DPRINTK(P9_DEBUG_ERROR, "not enough wait_address slots\n");
 517                 return;
 518         }
 519
 520         m->poll_waddr[i] = wait_address;
 521
 522         if (!wait_address) {
 523                 P9_DPRINTK(P9_DEBUG_ERROR, "no wait_address\n");
 524                 m->poll_waddr[i] = ERR_PTR(-EIO);
 525                 return;
 526         }
 527
 528         init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);
 529         add_wait_queue(wait_address, &m->poll_wait[i]);
 530 }
 531
 532 /**
 533  * p9_poll_mux - polls a mux and schedules read or write works if necessary
 534  * @m: connection to poll
 535  *
 536  */
 537
 538 static void p9_poll_mux(struct p9_conn *m)
 539 {
 540         int n;
 541
 542         if (m->err < 0)
 543                 return;
 544
 545         n = p9_fd_poll(m->trans, NULL);
 546         if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
 547                 P9_DPRINTK(P9_DEBUG_MUX, "error mux %p err %d\n", m, n);
 548                 if (n >= 0)
 549                         n = -ECONNRESET;
 550                 p9_conn_cancel(m, n);
 551         }
 552
 553         if (n & POLLIN) {
 554                 set_bit(Rpending, &m->wsched);
 555                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
 556                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
 557                         P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
 558                         queue_work(p9_mux_wq, &m->rq);
 559                 }
 560         }
 561
 562         if (n & POLLOUT) {
 563                 set_bit(Wpending, &m->wsched);
 564                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
 565                 if ((m->wsize || !list_empty(&m->unsent_req_list))
 566                     && !test_and_set_bit(Wworksched, &m->wsched)) {
 567                         P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
 568                         queue_work(p9_mux_wq, &m->wq);
 569                 }
 570         }
 571 }
 572
 573 /**
 574  * p9_poll_proc - poll worker thread
 575  * @a: thread state and arguments
 576  *
 577  * polls all v9fs transports for new events and queues the appropriate
 578  * work to the work queue
 579  *
 580  */
 581
 582 static int p9_poll_proc(void *a)
 583 {
 584         struct p9_conn *m, *mtmp;
 585         struct p9_mux_poll_task *vpt;
 586
 587         vpt = a;
 588         P9_DPRINTK(P9_DEBUG_MUX, "start %p %p\n", current, vpt);
 589         while (!kthread_should_stop()) {
 590                 set_current_state(TASK_INTERRUPTIBLE);
 591
 592                 list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {
 593                         p9_poll_mux(m);
 594                 }
 595
 596                 P9_DPRINTK(P9_DEBUG_MUX, "sleeping...\n");
 597                 schedule_timeout(SCHED_TIMEOUT * HZ);
 598         }
 599
 600         __set_current_state(TASK_RUNNING);
 601         P9_DPRINTK(P9_DEBUG_MUX, "finish\n");
 602         return 0;
 603 }
 604
 605 /**
 606  * p9_write_work - called when a transport can send some data
 607  * @work: container for work to be done
 608  *
 609  */
 610
 611 static void p9_write_work(struct work_struct *work)
 612 {
 613         int n, err;
 614         struct p9_conn *m;
 615         struct p9_req *req;
 616
 617         m = container_of(work, struct p9_conn, wq);
 618
 619         if (m->err < 0) {
 620                 clear_bit(Wworksched, &m->wsched);
 621                 return;
 622         }
 623
 624         if (!m->wsize) {
 625                 if (list_empty(&m->unsent_req_list)) {
 626                         clear_bit(Wworksched, &m->wsched);
 627                         return;
 628                 }
 629
 630                 spin_lock(&m->lock);
 631 again:
 632                 req = list_entry(m->unsent_req_list.next, struct p9_req,
 633                                req_list);
 634                 list_move_tail(&req->req_list, &m->req_list);
 635                 if (req->err == ERREQFLUSH)
 636                         goto again;
 637
 638                 m->wbuf = req->tcall->sdata;
 639                 m->wsize = req->tcall->size;
 640                 m->wpos = 0;
 641                 spin_unlock(&m->lock);
 642         }
 643
 644         P9_DPRINTK(P9_DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos,
 645                                                                 m->wsize);
 646         clear_bit(Wpending, &m->wsched);
 647         err = p9_fd_write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);
 648         P9_DPRINTK(P9_DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
 649         if (err == -EAGAIN) {
 650                 clear_bit(Wworksched, &m->wsched);
 651                 return;
 652         }
 653
 654         if (err < 0)
 655                 goto error;
 656         else if (err == 0) {
 657                 err = -EREMOTEIO;
 658                 goto error;
 659         }
 660
 661         m->wpos += err;
 662         if (m->wpos == m->wsize)
 663                 m->wpos = m->wsize = 0;
 664
 665         if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {
 666                 if (test_and_clear_bit(Wpending, &m->wsched))
 667                         n = POLLOUT;
 668                 else
 669                         n = p9_fd_poll(m->trans, NULL);
 670
 671                 if (n & POLLOUT) {
 672                         P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
 673                         queue_work(p9_mux_wq, &m->wq);
 674                 } else
 675                         clear_bit(Wworksched, &m->wsched);
 676         } else
 677                 clear_bit(Wworksched, &m->wsched);
 678
 679         return;
 680
 681 error:
 682         p9_conn_cancel(m, err);
 683         clear_bit(Wworksched, &m->wsched);
 684 }
 685
 686 static void process_request(struct p9_conn *m, struct p9_req *req)
 687 {
 688         int ecode;
 689         struct p9_str *ename;
 690
 691         if (!req->err && req->rcall->id == P9_RERROR) {
 692                 ecode = req->rcall->params.rerror.errno;
 693                 ename = &req->rcall->params.rerror.error;
 694
 695                 P9_DPRINTK(P9_DEBUG_MUX, "Rerror %.*s\n", ename->len,
 696                                                                 ename->str);
 697
 698                 if (m->extended)
 699                         req->err = -ecode;
 700
 701                 if (!req->err) {
 702                         req->err = p9_errstr2errno(ename->str, ename->len);
 703
 704                         /* string match failed */
 705                         if (!req->err) {
 706                                 PRINT_FCALL_ERROR("unknown error", req->rcall);
 707                                 req->err = -ESERVERFAULT;
 708                         }
 709                 }
 710         } else if (req->tcall && req->rcall->id != req->tcall->id + 1) {
 711                 P9_DPRINTK(P9_DEBUG_ERROR,
 712                                 "fcall mismatch: expected %d, got %d\n",
 713                                 req->tcall->id + 1, req->rcall->id);
 714                 if (!req->err)
 715                         req->err = -EIO;
 716         }
 717 }
 718
 719 /**
 720  * p9_read_work - called when there is some data to be read from a transport
 721  * @work: container of work to be done
 722  *
 723  */
 724
 725 static void p9_read_work(struct work_struct *work)
 726 {
 727         int n, err;
 728         struct p9_conn *m;
 729         struct p9_req *req, *rptr, *rreq;
 730         struct p9_fcall *rcall;
 731         char *rbuf;
 732
 733         m = container_of(work, struct p9_conn, rq);
 734
 735         if (m->err < 0)
 736                 return;
 737
 738         rcall = NULL;
 739         P9_DPRINTK(P9_DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
 740
 741         if (!m->rcall) {
 742                 m->rcall =
 743                     kmalloc(sizeof(struct p9_fcall) + m->msize, GFP_KERNEL);
 744                 if (!m->rcall) {
 745                         err = -ENOMEM;
 746                         goto error;
 747                 }
 748
 749                 m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
 750                 m->rpos = 0;
 751         }
 752
 753         clear_bit(Rpending, &m->wsched);
 754         err = p9_fd_read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
 755         P9_DPRINTK(P9_DEBUG_MUX, "mux %p got %d bytes\n", m, err);
 756         if (err == -EAGAIN) {
 757                 clear_bit(Rworksched, &m->wsched);
 758                 return;
 759         }
 760
 761         if (err <= 0)
 762                 goto error;
 763
 764         m->rpos += err;
 765         while (m->rpos > 4) {
 766                 n = le32_to_cpu(*(__le32 *) m->rbuf);
 767                 if (n >= m->msize) {
 768                         P9_DPRINTK(P9_DEBUG_ERROR,
 769                                 "requested packet size too big: %d\n", n);
 770                         err = -EIO;
 771                         goto error;
 772                 }
 773
 774                 if (m->rpos < n)
 775                         break;
 776
 777                 err =
 778                     p9_deserialize_fcall(m->rbuf, n, m->rcall, m->extended);
 779                 if (err < 0)
 780                         goto error;
 781
 782 #ifdef CONFIG_NET_9P_DEBUG
 783                 if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
 784                         char buf[150];
 785
 786                         p9_printfcall(buf, sizeof(buf), m->rcall,
 787                                 m->extended);
 788                         printk(KERN_NOTICE ">>> %p %s\n", m, buf);
 789                 }
 790 #endif
 791
 792                 rcall = m->rcall;
 793                 rbuf = m->rbuf;
 794                 if (m->rpos > n) {
 795                         m->rcall = kmalloc(sizeof(struct p9_fcall) + m->msize,
 796                                            GFP_KERNEL);
 797                         if (!m->rcall) {
 798                                 err = -ENOMEM;
 799                                 goto error;
 800                         }
 801
 802                         m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
 803                         memmove(m->rbuf, rbuf + n, m->rpos - n);
 804                         m->rpos -= n;
 805                 } else {
 806                         m->rcall = NULL;
 807                         m->rbuf = NULL;
 808                         m->rpos = 0;
 809                 }
 810
 811                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p fcall id %d tag %d\n", m,
 812                                                         rcall->id, rcall->tag);
 813
 814                 req = NULL;
 815                 spin_lock(&m->lock);
 816                 list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
 817                         if (rreq->tag == rcall->tag) {
 818                                 req = rreq;
 819                                 if (req->flush != Flushing)
 820                                         list_del(&req->req_list);
 821                                 break;
 822                         }
 823                 }
 824                 spin_unlock(&m->lock);
 825
 826                 if (req) {
 827                         req->rcall = rcall;
 828                         process_request(m, req);
 829
 830                         if (req->flush != Flushing) {
 831                                 if (req->cb)
 832                                         (*req->cb) (req, req->cba);
 833                                 else
 834                                         kfree(req->rcall);
 835                         }
 836                 } else {
 837                         if (err >= 0 && rcall->id != P9_RFLUSH)
 838                                 P9_DPRINTK(P9_DEBUG_ERROR,
 839                                   "unexpected response mux %p id %d tag %d\n",
 840                                   m, rcall->id, rcall->tag);
 841                         kfree(rcall);
 842                 }
 843         }
 844
 845         if (!list_empty(&m->req_list)) {
 846                 if (test_and_clear_bit(Rpending, &m->wsched))
 847                         n = POLLIN;
 848                 else
 849                         n = p9_fd_poll(m->trans, NULL);
 850
 851                 if (n & POLLIN) {
 852                         P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
 853                         queue_work(p9_mux_wq, &m->rq);
 854                 } else
 855                         clear_bit(Rworksched, &m->wsched);
 856         } else
 857                 clear_bit(Rworksched, &m->wsched);
 858
 859         return;
 860
 861 error:
 862         p9_conn_cancel(m, err);
 863         clear_bit(Rworksched, &m->wsched);
 864 }
 865
 866 /**
 867  * p9_send_request - send 9P request
 868  * The function can sleep until the request is scheduled for sending.
 869  * The function can be interrupted. Return from the function is not
 870  * a guarantee that the request is sent successfully. Can return errors
 871  * that can be retrieved by PTR_ERR macros.
 872  *
 873  * @m: mux data
 874  * @tc: request to be sent
 875  * @cb: callback function to call when response is received
 876  * @cba: parameter to pass to the callback function
 877  *
 878  */
 879
 880 static struct p9_req *p9_send_request(struct p9_conn *m,
 881                                           struct p9_fcall *tc,
 882                                           p9_conn_req_callback cb, void *cba)
 883 {
 884         int n;
 885         struct p9_req *req;
 886
 887         P9_DPRINTK(P9_DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
 888                 tc, tc->id);
 889         if (m->err < 0)
 890                 return ERR_PTR(m->err);
 891
 892         req = kmalloc(sizeof(struct p9_req), GFP_KERNEL);
 893         if (!req)
 894                 return ERR_PTR(-ENOMEM);
 895
 896         if (tc->id == P9_TVERSION)
 897                 n = P9_NOTAG;
 898         else
 899                 n = p9_mux_get_tag(m);
 900
 901         if (n < 0)
 902                 return ERR_PTR(-ENOMEM);
 903
 904         p9_set_tag(tc, n);
 905
 906 #ifdef CONFIG_NET_9P_DEBUG
 907         if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
 908                 char buf[150];
 909
 910                 p9_printfcall(buf, sizeof(buf), tc, m->extended);
 911                 printk(KERN_NOTICE "<<< %p %s\n", m, buf);
 912         }
 913 #endif
 914
 915         spin_lock_init(&req->lock);
 916         req->tag = n;
 917         req->tcall = tc;
 918         req->rcall = NULL;
 919         req->err = 0;
 920         req->cb = cb;
 921         req->cba = cba;
 922         req->flush = None;
 923
 924         spin_lock(&m->lock);
 925         list_add_tail(&req->req_list, &m->unsent_req_list);
 926         spin_unlock(&m->lock);
 927
 928         if (test_and_clear_bit(Wpending, &m->wsched))
 929                 n = POLLOUT;
 930         else
 931                 n = p9_fd_poll(m->trans, NULL);
 932
 933         if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
 934                 queue_work(p9_mux_wq, &m->wq);
 935
 936         return req;
 937 }
 938
 939 static void p9_mux_free_request(struct p9_conn *m, struct p9_req *req)
 940 {
 941         p9_mux_put_tag(m, req->tag);
 942         kfree(req);
 943 }
 944
 945 static void p9_mux_flush_cb(struct p9_req *freq, void *a)
 946 {
 947         int tag;
 948         struct p9_conn *m;
 949         struct p9_req *req, *rreq, *rptr;
 950
 951         m = a;
 952         P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m,
 953                 freq->tcall, freq->rcall, freq->err,
 954                 freq->tcall->params.tflush.oldtag);
 955
 956         spin_lock(&m->lock);
 957         tag = freq->tcall->params.tflush.oldtag;
 958         req = NULL;
 959         list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
 960                 if (rreq->tag == tag) {
 961                         req = rreq;
 962                         list_del(&req->req_list);
 963                         break;
 964                 }
 965         }
 966         spin_unlock(&m->lock);
 967
 968         if (req) {
 969                 spin_lock(&req->lock);
 970                 req->flush = Flushed;
 971                 spin_unlock(&req->lock);
 972
 973                 if (req->cb)
 974                         (*req->cb) (req, req->cba);
 975                 else
 976                         kfree(req->rcall);
 977         }
 978
 979         kfree(freq->tcall);
 980         kfree(freq->rcall);
 981         p9_mux_free_request(m, freq);
 982 }
 983
 984 static int
 985 p9_mux_flush_request(struct p9_conn *m, struct p9_req *req)
 986 {
 987         struct p9_fcall *fc;
 988         struct p9_req *rreq, *rptr;
 989
 990         P9_DPRINTK(P9_DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
 991
 992         /* if a response was received for a request, do nothing */
 993         spin_lock(&req->lock);
 994         if (req->rcall || req->err) {
 995                 spin_unlock(&req->lock);
 996                 P9_DPRINTK(P9_DEBUG_MUX,
 997                         "mux %p req %p response already received\n", m, req);
 998                 return 0;
 999         }
1000
1001         req->flush = Flushing;
1002         spin_unlock(&req->lock);
1003
1004         spin_lock(&m->lock);
1005         /* if the request is not sent yet, just remove it from the list */
1006         list_for_each_entry_safe(rreq, rptr, &m->unsent_req_list, req_list) {
1007                 if (rreq->tag == req->tag) {
1008                         P9_DPRINTK(P9_DEBUG_MUX,
1009                            "mux %p req %p request is not sent yet\n", m, req);
1010                         list_del(&rreq->req_list);
1011                         req->flush = Flushed;
1012                         spin_unlock(&m->lock);
1013                         if (req->cb)
1014                                 (*req->cb) (req, req->cba);
1015                         return 0;
1016                 }
1017         }
1018         spin_unlock(&m->lock);
1019
1020         clear_thread_flag(TIF_SIGPENDING);
1021         fc = p9_create_tflush(req->tag);
1022         p9_send_request(m, fc, p9_mux_flush_cb, m);
1023         return 1;
1024 }
1025
1026 static void
1027 p9_conn_rpc_cb(struct p9_req *req, void *a)
1028 {
1029         struct p9_mux_rpc *r;
1030
1031         P9_DPRINTK(P9_DEBUG_MUX, "req %p r %p\n", req, a);
1032         r = a;
1033         r->rcall = req->rcall;
1034         r->err = req->err;
1035
1036         if (req->flush != None && !req->err)
1037                 r->err = -ERESTARTSYS;
1038
1039         wake_up(&r->wqueue);
1040 }
1041
1042 /**
1043  * p9_fd_rpc- sends 9P request and waits until a response is available.
1044  *      The function can be interrupted.
1045  * @t: transport data
1046  * @tc: request to be sent
1047  * @rc: pointer where a pointer to the response is stored
1048  *
1049  */
1050
1051 int
1052 p9_fd_rpc(struct p9_trans *t, struct p9_fcall *tc, struct p9_fcall **rc)
1053 {
1054         struct p9_trans_fd *p = t->priv;
1055         struct p9_conn *m = p->conn;
1056         int err, sigpending;
1057         unsigned long flags;
1058         struct p9_req *req;
1059         struct p9_mux_rpc r;
1060
1061         r.err = 0;
1062         r.tcall = tc;
1063         r.rcall = NULL;
1064         r.m = m;
1065         init_waitqueue_head(&r.wqueue);
1066
1067         if (rc)
1068                 *rc = NULL;
1069
1070         sigpending = 0;
1071         if (signal_pending(current)) {
1072                 sigpending = 1;
1073                 clear_thread_flag(TIF_SIGPENDING);
1074         }
1075
1076         req = p9_send_request(m, tc, p9_conn_rpc_cb, &r);
1077         if (IS_ERR(req)) {
1078                 err = PTR_ERR(req);
1079                 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1080                 return err;
1081         }
1082
1083         err = wait_event_interruptible(r.wqueue, r.rcall != NULL || r.err < 0);
1084         if (r.err < 0)
1085                 err = r.err;
1086
1087         if (err == -ERESTARTSYS && m->trans->status == Connected
1088                                                         && m->err == 0) {
1089                 if (p9_mux_flush_request(m, req)) {
1090                         /* wait until we get response of the flush message */
1091                         do {
1092                                 clear_thread_flag(TIF_SIGPENDING);
1093                                 err = wait_event_interruptible(r.wqueue,
1094                                         r.rcall || r.err);
1095                         } while (!r.rcall && !r.err && err == -ERESTARTSYS &&
1096                                 m->trans->status == Connected && !m->err);
1097
1098                         err = -ERESTARTSYS;
1099                 }
1100                 sigpending = 1;
1101         }
1102
1103         if (sigpending) {
1104                 spin_lock_irqsave(&current->sighand->siglock, flags);
1105                 recalc_sigpending();
1106                 spin_unlock_irqrestore(&current->sighand->siglock, flags);
1107         }
1108
1109         if (rc)
1110                 *rc = r.rcall;
1111         else
1112                 kfree(r.rcall);
1113
1114         p9_mux_free_request(m, req);
1115         if (err > 0)
1116                 err = -EIO;
1117
1118         return err;
1119 }
1120
1121 #ifdef P9_NONBLOCK
1122 /**
1123  * p9_conn_rpcnb - sends 9P request without waiting for response.
1124  * @m: mux data
1125  * @tc: request to be sent
1126  * @cb: callback function to be called when response arrives
1127  * @a: value to pass to the callback function
1128  *
1129  */
1130
1131 int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
1132                    p9_conn_req_callback cb, void *a)
1133 {
1134         int err;
1135         struct p9_req *req;
1136
1137         req = p9_send_request(m, tc, cb, a);
1138         if (IS_ERR(req)) {
1139                 err = PTR_ERR(req);
1140                 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1141                 return PTR_ERR(req);
1142         }
1143
1144         P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
1145         return 0;
1146 }
1147 #endif /* P9_NONBLOCK */
1148
1149 /**
1150  * p9_conn_cancel - cancel all pending requests with error
1151  * @m: mux data
1152  * @err: error code
1153  *
1154  */
1155
1156 void p9_conn_cancel(struct p9_conn *m, int err)
1157 {
1158         struct p9_req *req, *rtmp;
1159         LIST_HEAD(cancel_list);
1160
1161         P9_DPRINTK(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
1162         m->err = err;
1163         spin_lock(&m->lock);
1164         list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
1165                 list_move(&req->req_list, &cancel_list);
1166         }
1167         list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
1168                 list_move(&req->req_list, &cancel_list);
1169         }
1170         spin_unlock(&m->lock);
1171
1172         list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
1173                 list_del(&req->req_list);
1174                 if (!req->err)
1175                         req->err = err;
1176
1177                 if (req->cb)
1178                         (*req->cb) (req, req->cba);
1179                 else
1180                         kfree(req->rcall);
1181         }
1182 }
1183
1184 /**
1185  * parse_options - parse mount options into session structure
1186  * @options: options string passed from mount
1187  * @opts: transport-specific structure to parse options into
1188  *
1189  * Returns 0 upon success, -ERRNO upon failure
1190  */
1191
1192 static int parse_opts(char *params, struct p9_fd_opts *opts)
1193 {
1194         char *p;
1195         substring_t args[MAX_OPT_ARGS];
1196         int option;
1197         char *options;
1198         int ret;
1199
1200         opts->port = P9_PORT;
1201         opts->rfd = ~0;
1202         opts->wfd = ~0;
1203
1204         if (!params)
1205                 return 0;
1206
1207         options = kstrdup(params, GFP_KERNEL);
1208         if (!options) {
1209                 P9_DPRINTK(P9_DEBUG_ERROR,
1210                                 "failed to allocate copy of option string\n");
1211                 return -ENOMEM;
1212         }
1213
1214         while ((p = strsep(&options, ",")) != NULL) {
1215                 int token;
1216                 int r;
1217                 if (!*p)
1218                         continue;
1219                 token = match_token(p, tokens, args);
1220                 r = match_int(&args[0], &option);
1221                 if (r < 0) {
1222                         P9_DPRINTK(P9_DEBUG_ERROR,
1223                          "integer field, but no integer?\n");
1224                         ret = r;
1225                         continue;
1226                 }
1227                 switch (token) {
1228                 case Opt_port:
1229                         opts->port = option;
1230                         break;
1231                 case Opt_rfdno:
1232                         opts->rfd = option;
1233                         break;
1234                 case Opt_wfdno:
1235                         opts->wfd = option;
1236                         break;
1237                 default:
1238                         continue;
1239                 }
1240         }
1241         kfree(options);
1242         return 0;
1243 }
1244
1245 static int p9_fd_open(struct p9_trans *trans, int rfd, int wfd)
1246 {
1247         struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
1248                                            GFP_KERNEL);
1249         if (!ts)
1250                 return -ENOMEM;
1251
1252         ts->rd = fget(rfd);
1253         ts->wr = fget(wfd);
1254         if (!ts->rd || !ts->wr) {
1255                 if (ts->rd)
1256                         fput(ts->rd);
1257                 if (ts->wr)
1258                         fput(ts->wr);
1259                 kfree(ts);
1260                 return -EIO;
1261         }
1262
1263         trans->priv = ts;
1264         trans->status = Connected;
1265
1266         return 0;
1267 }
1268
1269 static int p9_socket_open(struct p9_trans *trans, struct socket *csocket)
1270 {
1271         int fd, ret;
1272
1273         csocket->sk->sk_allocation = GFP_NOIO;
1274         fd = sock_map_fd(csocket, 0);
1275         if (fd < 0) {
1276                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
1277                 return fd;
1278         }
1279
1280         ret = p9_fd_open(trans, fd, fd);
1281         if (ret < 0) {
1282                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd\n");
1283                 sockfd_put(csocket);
1284                 return ret;
1285         }
1286
1287         ((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;
1288
1289         return 0;
1290 }
1291
1292 /**
1293  * p9_fd_read- read from a fd
1294  * @trans: transport instance state
1295  * @v: buffer to receive data into
1296  * @len: size of receive buffer
1297  *
1298  */
1299
1300 static int p9_fd_read(struct p9_trans *trans, void *v, int len)
1301 {
1302         int ret;
1303         struct p9_trans_fd *ts = NULL;
1304
1305         if (trans && trans->status != Disconnected)
1306                 ts = trans->priv;
1307
1308         if (!ts)
1309                 return -EREMOTEIO;
1310
1311         if (!(ts->rd->f_flags & O_NONBLOCK))
1312                 P9_DPRINTK(P9_DEBUG_ERROR, "blocking read ...\n");
1313
1314         ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
1315         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1316                 trans->status = Disconnected;
1317         return ret;
1318 }
1319
1320 /**
1321  * p9_fd_write - write to a socket
1322  * @trans: transport instance state
1323  * @v: buffer to send data from
1324  * @len: size of send buffer
1325  *
1326  */
1327
1328 static int p9_fd_write(struct p9_trans *trans, void *v, int len)
1329 {
1330         int ret;
1331         mm_segment_t oldfs;
1332         struct p9_trans_fd *ts = NULL;
1333
1334         if (trans && trans->status != Disconnected)
1335                 ts = trans->priv;
1336
1337         if (!ts)
1338                 return -EREMOTEIO;
1339
1340         if (!(ts->wr->f_flags & O_NONBLOCK))
1341                 P9_DPRINTK(P9_DEBUG_ERROR, "blocking write ...\n");
1342
1343         oldfs = get_fs();
1344         set_fs(get_ds());
1345         /* The cast to a user pointer is valid due to the set_fs() */
1346         ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
1347         set_fs(oldfs);
1348
1349         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1350                 trans->status = Disconnected;
1351         return ret;
1352 }
1353
1354 static unsigned int
1355 p9_fd_poll(struct p9_trans *trans, struct poll_table_struct *pt)
1356 {
1357         int ret, n;
1358         struct p9_trans_fd *ts = NULL;
1359         mm_segment_t oldfs;
1360
1361         if (trans && trans->status == Connected)
1362                 ts = trans->priv;
1363
1364         if (!ts)
1365                 return -EREMOTEIO;
1366
1367         if (!ts->rd->f_op || !ts->rd->f_op->poll)
1368                 return -EIO;
1369
1370         if (!ts->wr->f_op || !ts->wr->f_op->poll)
1371                 return -EIO;
1372
1373         oldfs = get_fs();
1374         set_fs(get_ds());
1375
1376         ret = ts->rd->f_op->poll(ts->rd, pt);
1377         if (ret < 0)
1378                 goto end;
1379
1380         if (ts->rd != ts->wr) {
1381                 n = ts->wr->f_op->poll(ts->wr, pt);
1382                 if (n < 0) {
1383                         ret = n;
1384                         goto end;
1385                 }
1386                 ret = (ret & ~POLLOUT) | (n & ~POLLIN);
1387         }
1388
1389 end:
1390         set_fs(oldfs);
1391         return ret;
1392 }
1393
1394 /**
1395  * p9_fd_close - shutdown socket
1396  * @trans: private socket structure
1397  *
1398  */
1399
1400 static void p9_fd_close(struct p9_trans *trans)
1401 {
1402         struct p9_trans_fd *ts;
1403
1404         if (!trans)
1405                 return;
1406
1407         ts = xchg(&trans->priv, NULL);
1408
1409         if (!ts)
1410                 return;
1411
1412         p9_conn_destroy(ts->conn);
1413
1414         trans->status = Disconnected;
1415         if (ts->rd)
1416                 fput(ts->rd);
1417         if (ts->wr)
1418                 fput(ts->wr);
1419         kfree(ts);
1420 }
1421
1422 /*
1423  * stolen from NFS - maybe should be made a generic function?
1424  */
1425 static inline int valid_ipaddr4(const char *buf)
1426 {
1427         int rc, count, in[4];
1428
1429         rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
1430         if (rc != 4)
1431                 return -EINVAL;
1432         for (count = 0; count < 4; count++) {
1433                 if (in[count] > 255)
1434                         return -EINVAL;
1435         }
1436         return 0;
1437 }
1438
1439 static struct p9_trans *
1440 p9_trans_create_tcp(const char *addr, char *args, int msize, unsigned char dotu)
1441 {
1442         int err;
1443         struct p9_trans *trans;
1444         struct socket *csocket;
1445         struct sockaddr_in sin_server;
1446         struct p9_fd_opts opts;
1447         struct p9_trans_fd *p;
1448
1449         err = parse_opts(args, &opts);
1450         if (err < 0)
1451                 return ERR_PTR(err);
1452
1453         if (valid_ipaddr4(addr) < 0)
1454                 return ERR_PTR(-EINVAL);
1455
1456         csocket = NULL;
1457         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1458         if (!trans)
1459                 return ERR_PTR(-ENOMEM);
1460         trans->msize = msize;
1461         trans->extended = dotu;
1462         trans->rpc = p9_fd_rpc;
1463         trans->close = p9_fd_close;
1464
1465         sin_server.sin_family = AF_INET;
1466         sin_server.sin_addr.s_addr = in_aton(addr);
1467         sin_server.sin_port = htons(opts.port);
1468         sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
1469
1470         if (!csocket) {
1471                 P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
1472                 err = -EIO;
1473                 goto error;
1474         }
1475
1476         err = csocket->ops->connect(csocket,
1477                                     (struct sockaddr *)&sin_server,
1478                                     sizeof(struct sockaddr_in), 0);
1479         if (err < 0) {
1480                 P9_EPRINTK(KERN_ERR,
1481                         "p9_trans_tcp: problem connecting socket to %s\n",
1482                         addr);
1483                 goto error;
1484         }
1485
1486         err = p9_socket_open(trans, csocket);
1487         if (err < 0)
1488                 goto error;
1489
1490         p = (struct p9_trans_fd *) trans->priv;
1491         p->conn = p9_conn_create(trans);
1492         if (IS_ERR(p->conn)) {
1493                 err = PTR_ERR(p->conn);
1494                 p->conn = NULL;
1495                 goto error;
1496         }
1497
1498         return trans;
1499
1500 error:
1501         if (csocket)
1502                 sock_release(csocket);
1503
1504         kfree(trans);
1505         return ERR_PTR(err);
1506 }
1507
1508 static struct p9_trans *
1509 p9_trans_create_unix(const char *addr, char *args, int msize,
1510                                                         unsigned char dotu)
1511 {
1512         int err;
1513         struct socket *csocket;
1514         struct sockaddr_un sun_server;
1515         struct p9_trans *trans;
1516         struct p9_trans_fd *p;
1517
1518         csocket = NULL;
1519         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1520         if (!trans)
1521                 return ERR_PTR(-ENOMEM);
1522
1523         trans->rpc = p9_fd_rpc;
1524         trans->close = p9_fd_close;
1525
1526         if (strlen(addr) > UNIX_PATH_MAX) {
1527                 P9_EPRINTK(KERN_ERR, "p9_trans_unix: address too long: %s\n",
1528                         addr);
1529                 err = -ENAMETOOLONG;
1530                 goto error;
1531         }
1532
1533         sun_server.sun_family = PF_UNIX;
1534         strcpy(sun_server.sun_path, addr);
1535         sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
1536         err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1537                         sizeof(struct sockaddr_un) - 1, 0);
1538         if (err < 0) {
1539                 P9_EPRINTK(KERN_ERR,
1540                         "p9_trans_unix: problem connecting socket: %s: %d\n",
1541                         addr, err);
1542                 goto error;
1543         }
1544
1545         err = p9_socket_open(trans, csocket);
1546         if (err < 0)
1547                 goto error;
1548
1549         trans->msize = msize;
1550         trans->extended = dotu;
1551         p = (struct p9_trans_fd *) trans->priv;
1552         p->conn = p9_conn_create(trans);
1553         if (IS_ERR(p->conn)) {
1554                 err = PTR_ERR(p->conn);
1555                 p->conn = NULL;
1556                 goto error;
1557         }
1558
1559         return trans;
1560
1561 error:
1562         if (csocket)
1563                 sock_release(csocket);
1564
1565         kfree(trans);
1566         return ERR_PTR(err);
1567 }
1568
1569 static struct p9_trans *
1570 p9_trans_create_fd(const char *name, char *args, int msize,
1571                                                         unsigned char extended)
1572 {
1573         int err;
1574         struct p9_trans *trans;
1575         struct p9_fd_opts opts;
1576         struct p9_trans_fd *p;
1577
1578         parse_opts(args, &opts);
1579
1580         if (opts.rfd == ~0 || opts.wfd == ~0) {
1581                 printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
1582                 return ERR_PTR(-ENOPROTOOPT);
1583         }
1584
1585         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1586         if (!trans)
1587                 return ERR_PTR(-ENOMEM);
1588
1589         trans->rpc = p9_fd_rpc;
1590         trans->close = p9_fd_close;
1591
1592         err = p9_fd_open(trans, opts.rfd, opts.wfd);
1593         if (err < 0)
1594                 goto error;
1595
1596         trans->msize = msize;
1597         trans->extended = extended;
1598         p = (struct p9_trans_fd *) trans->priv;
1599         p->conn = p9_conn_create(trans);
1600         if (IS_ERR(p->conn)) {
1601                 err = PTR_ERR(p->conn);
1602                 p->conn = NULL;
1603                 goto error;
1604         }
1605
1606         return trans;
1607
1608 error:
1609         kfree(trans);
1610         return ERR_PTR(err);
1611 }
1612
1613 static struct p9_trans_module p9_tcp_trans = {
1614         .name = "tcp",
1615         .maxsize = MAX_SOCK_BUF,
1616         .def = 1,
1617         .create = p9_trans_create_tcp,
1618         .owner = THIS_MODULE,
1619 };
1620
1621 static struct p9_trans_module p9_unix_trans = {
1622         .name = "unix",
1623         .maxsize = MAX_SOCK_BUF,
1624         .def = 0,
1625         .create = p9_trans_create_unix,
1626         .owner = THIS_MODULE,
1627 };
1628
1629 static struct p9_trans_module p9_fd_trans = {
1630         .name = "fd",
1631         .maxsize = MAX_SOCK_BUF,
1632         .def = 0,
1633         .create = p9_trans_create_fd,
1634         .owner = THIS_MODULE,
1635 };
1636
1637 int p9_trans_fd_init(void)
1638 {
1639         int ret = p9_mux_global_init();
1640         if (ret) {
1641                 printk(KERN_WARNING "9p: starting mux failed\n");
1642                 return ret;
1643         }
1644
1645         v9fs_register_trans(&p9_tcp_trans);
1646         v9fs_register_trans(&p9_unix_trans);
1647         v9fs_register_trans(&p9_fd_trans);
1648
1649         return 0;
1650 }
1651
1652 void p9_trans_fd_exit(void)
1653 {
1654         v9fs_unregister_trans(&p9_tcp_trans);
1655         v9fs_unregister_trans(&p9_unix_trans);
1656         v9fs_unregister_trans(&p9_fd_trans);
1657 }