trans_fd.c

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