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