blob: 9321a77630675dacbca66949e7e2e0f75d25deed [file] [log] [blame]
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001/*
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>
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -06008 * Copyright (C) 2004-2008 by Eric Van Hensbergen <ericvh@gmail.com>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05009 * 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
Joe Perches5d385152011-11-28 10:40:46 -080028#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050030#include <linux/in.h>
31#include <linux/module.h>
32#include <linux/net.h>
33#include <linux/ipv6.h>
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -060034#include <linux/kthread.h>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050035#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>
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050042#include <linux/parser.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050044#include <net/9p/9p.h>
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -050045#include <net/9p/client.h>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050046#include <net/9p/transport.h>
47
Al Viro6b186622009-08-06 02:02:43 +040048#include <linux/syscalls.h> /* killme */
49
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050050#define P9_PORT 564
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050051#define MAX_SOCK_BUF (64*1024)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -060052#define MAXPOLLWADDR 2
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050053
Eric Van Hensbergenee443992008-03-05 07:08:09 -060054/**
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
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050062struct p9_fd_opts {
63 int rfd;
64 int wfd;
65 u16 port;
Jim Garlick2f28c8b2013-05-29 12:15:07 -070066 int privport;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050067};
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050068
Eric Van Hensbergenee443992008-03-05 07:08:09 -060069/**
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
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050077struct p9_trans_fd {
78 struct file *rd;
79 struct file *wr;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -060080 struct p9_conn *conn;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050081};
82
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050083/*
84 * Option Parsing (code inspired by NFS code)
85 * - a little lazy - parse all fd-transport options
86 */
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050087
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050088enum {
89 /* Options that take integer arguments */
Latchesar Ionkov55762692007-11-06 08:02:53 -060090 Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
Jim Garlick2f28c8b2013-05-29 12:15:07 -070091 /* Options that take no arguments */
92 Opt_privport,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050093};
94
Steven Whitehousea447c092008-10-13 10:46:57 +010095static const match_table_t tokens = {
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050096 {Opt_port, "port=%u"},
97 {Opt_rfdno, "rfdno=%u"},
98 {Opt_wfdno, "wfdno=%u"},
Jim Garlick2f28c8b2013-05-29 12:15:07 -070099 {Opt_privport, "privport"},
Latchesar Ionkov55762692007-11-06 08:02:53 -0600100 {Opt_err, NULL},
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500101};
102
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600103enum {
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
Tejun Heo992b3f12008-10-13 18:45:25 -0500110struct p9_poll_wait {
111 struct p9_conn *conn;
112 wait_queue_t wait;
113 wait_queue_head_t *wait_addr;
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600114};
115
116/**
117 * struct p9_conn - fd mux connection state information
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600118 * @mux_list: list link for mux to manage multiple connections (?)
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500119 * @client: reference to client instance for this connection
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600120 * @err: error state
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600121 * @req_list: accounting for requests which have been sent
122 * @unsent_req_list: accounting for requests that haven't been sent
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500123 * @req: current request being processed (if any)
124 * @tmp_buf: temporary buffer to read in header
125 * @rsize: amount to read for current frame
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600126 * @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
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600131 * @poll_pending_link: pending links to be polled per conn
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600132 * @poll_wait: array of wait_q's for various worker threads
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600133 * @pt: poll state
134 * @rq: current read work
135 * @wq: current write work
136 * @wsched: ????
137 *
138 */
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600139
140struct p9_conn {
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600141 struct list_head mux_list;
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500142 struct p9_client *client;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600143 int err;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600144 struct list_head req_list;
145 struct list_head unsent_req_list;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500146 struct p9_req_t *req;
147 char tmp_buf[7];
148 int rsize;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600149 int rpos;
150 char *rbuf;
151 int wpos;
152 int wsize;
153 char *wbuf;
Tejun Heo992b3f12008-10-13 18:45:25 -0500154 struct list_head poll_pending_link;
155 struct p9_poll_wait poll_wait[MAXPOLLWADDR];
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600156 poll_table pt;
157 struct work_struct rq;
158 struct work_struct wq;
159 unsigned long wsched;
160};
161
Tejun Heoaa70c582011-02-01 11:42:43 +0100162static void p9_poll_workfn(struct work_struct *work);
163
Tejun Heo992b3f12008-10-13 18:45:25 -0500164static DEFINE_SPINLOCK(p9_poll_lock);
165static LIST_HEAD(p9_poll_pending_list);
Tejun Heoaa70c582011-02-01 11:42:43 +0100166static DECLARE_WORK(p9_poll_work, p9_poll_workfn);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600167
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700168static unsigned int p9_ipport_resv_min = P9_DEF_MIN_RESVPORT;
169static unsigned int p9_ipport_resv_max = P9_DEF_MAX_RESVPORT;
170
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600171static void p9_mux_poll_stop(struct p9_conn *m)
172{
Tejun Heo992b3f12008-10-13 18:45:25 -0500173 unsigned long flags;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600174 int i;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600175
Tejun Heo992b3f12008-10-13 18:45:25 -0500176 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;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600182 }
183 }
Tejun Heo992b3f12008-10-13 18:45:25 -0500184
185 spin_lock_irqsave(&p9_poll_lock, flags);
186 list_del_init(&m->poll_pending_link);
187 spin_unlock_irqrestore(&p9_poll_lock, flags);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600188}
189
190/**
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500191 * p9_conn_cancel - cancel all pending requests with error
192 * @m: mux data
193 * @err: error code
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600194 *
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600195 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600196
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500197static void p9_conn_cancel(struct p9_conn *m, int err)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600198{
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500199 struct p9_req_t *req, *rtmp;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500200 unsigned long flags;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500201 LIST_HEAD(cancel_list);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600202
Joe Perches5d385152011-11-28 10:40:46 -0800203 p9_debug(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500204
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500205 spin_lock_irqsave(&m->client->lock, flags);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500206
207 if (m->err) {
208 spin_unlock_irqrestore(&m->client->lock, flags);
209 return;
210 }
211
212 m->err = err;
213
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500214 list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500215 req->status = REQ_STATUS_ERROR;
216 if (!req->t_err)
217 req->t_err = err;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500218 list_move(&req->req_list, &cancel_list);
Tejun Heo992b3f12008-10-13 18:45:25 -0500219 }
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500220 list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500221 req->status = REQ_STATUS_ERROR;
222 if (!req->t_err)
223 req->t_err = err;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500224 list_move(&req->req_list, &cancel_list);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600225 }
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500226 spin_unlock_irqrestore(&m->client->lock, flags);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600227
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500228 list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
Joe Perches5d385152011-11-28 10:40:46 -0800229 p9_debug(P9_DEBUG_ERROR, "call back req %p\n", req);
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500230 list_del(&req->req_list);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500231 p9_client_cb(m->client, req);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600232 }
233}
234
Julia Lawall29af9302010-09-05 09:00:21 +0000235static int
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500236p9_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
Al Viro72c2d532013-09-22 16:27:52 -0400247 if (!ts->rd->f_op->poll)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500248 return -EIO;
249
Al Viro72c2d532013-09-22 16:27:52 -0400250 if (!ts->wr->f_op->poll)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500251 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
275static 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))
Joe Perches5d385152011-11-28 10:40:46 -0800287 p9_debug(P9_DEBUG_ERROR, "blocking read ...\n");
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500288
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
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600295/**
296 * p9_read_work - called when there is some data to be read from a transport
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600297 * @work: container of work to be done
298 *
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600299 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600300
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600301static void p9_read_work(struct work_struct *work)
302{
303 int n, err;
304 struct p9_conn *m;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600305
306 m = container_of(work, struct p9_conn, rq);
307
308 if (m->err < 0)
309 return;
310
Joe Perches5d385152011-11-28 10:40:46 -0800311 p9_debug(P9_DEBUG_TRANS, "start mux %p pos %d\n", m, m->rpos);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600312
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500313 if (!m->rbuf) {
314 m->rbuf = m->tmp_buf;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600315 m->rpos = 0;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500316 m->rsize = 7; /* start by reading header */
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600317 }
318
319 clear_bit(Rpending, &m->wsched);
Joe Perches5d385152011-11-28 10:40:46 -0800320 p9_debug(P9_DEBUG_TRANS, "read mux %p pos %d size: %d = %d\n",
321 m, m->rpos, m->rsize, m->rsize-m->rpos);
Eric Van Hensbergenbead27f2008-10-13 18:45:24 -0500322 err = p9_fd_read(m->client, m->rbuf + m->rpos,
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500323 m->rsize - m->rpos);
Joe Perches5d385152011-11-28 10:40:46 -0800324 p9_debug(P9_DEBUG_TRANS, "mux %p got %d bytes\n", m, err);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600325 if (err == -EAGAIN) {
Simon Derr04621942012-09-17 15:16:28 +0200326 goto end_clear;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600327 }
328
329 if (err <= 0)
330 goto error;
331
332 m->rpos += err;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500333
334 if ((!m->req) && (m->rpos == m->rsize)) { /* header read in */
335 u16 tag;
Joe Perches5d385152011-11-28 10:40:46 -0800336 p9_debug(P9_DEBUG_TRANS, "got new header\n");
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500337
338 n = le32_to_cpu(*(__le32 *) m->rbuf); /* read packet size */
Eric Van Hensbergenbead27f2008-10-13 18:45:24 -0500339 if (n >= m->client->msize) {
Joe Perches5d385152011-11-28 10:40:46 -0800340 p9_debug(P9_DEBUG_ERROR,
341 "requested packet size too big: %d\n", n);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600342 err = -EIO;
343 goto error;
344 }
345
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500346 tag = le16_to_cpu(*(__le16 *) (m->rbuf+5)); /* read tag */
Joe Perches5d385152011-11-28 10:40:46 -0800347 p9_debug(P9_DEBUG_TRANS,
348 "mux %p pkt: size: %d bytes tag: %d\n", m, n, tag);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600349
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500350 m->req = p9_tag_lookup(m->client, tag);
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500351 if (!m->req || (m->req->status != REQ_STATUS_SENT &&
352 m->req->status != REQ_STATUS_FLSH)) {
Joe Perches5d385152011-11-28 10:40:46 -0800353 p9_debug(P9_DEBUG_ERROR, "Unexpected packet tag %d\n",
354 tag);
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500355 err = -EIO;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600356 goto error;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500357 }
358
359 if (m->req->rc == NULL) {
360 m->req->rc = kmalloc(sizeof(struct p9_fcall) +
Aneesh Kumar K.Veeff66e2011-03-08 16:39:47 +0530361 m->client->msize, GFP_NOFS);
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500362 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 */
Joe Perches5d385152011-11-28 10:40:46 -0800375 p9_debug(P9_DEBUG_TRANS, "got new packet\n");
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500376 spin_lock(&m->client->lock);
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500377 if (m->req->status != REQ_STATUS_ERROR)
378 m->req->status = REQ_STATUS_RCVD;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500379 list_del(&m->req->req_list);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500380 spin_unlock(&m->client->lock);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500381 p9_client_cb(m->client, m->req);
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500382 m->rbuf = NULL;
383 m->rpos = 0;
384 m->rsize = 0;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500385 m->req = NULL;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600386 }
387
Simon Derr04621942012-09-17 15:16:28 +0200388end_clear:
389 clear_bit(Rworksched, &m->wsched);
390
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600391 if (!list_empty(&m->req_list)) {
392 if (test_and_clear_bit(Rpending, &m->wsched))
393 n = POLLIN;
394 else
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500395 n = p9_fd_poll(m->client, NULL);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600396
Simon Derr04621942012-09-17 15:16:28 +0200397 if ((n & POLLIN) && !test_and_set_bit(Rworksched, &m->wsched)) {
Joe Perches5d385152011-11-28 10:40:46 -0800398 p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
Tejun Heo61edeee2011-02-01 11:42:43 +0100399 schedule_work(&m->rq);
Simon Derr04621942012-09-17 15:16:28 +0200400 }
401 }
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600402
403 return;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600404error:
405 p9_conn_cancel(m, err);
406 clear_bit(Rworksched, &m->wsched);
407}
408
409/**
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500410 * 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
417static 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))
Joe Perches5d385152011-11-28 10:40:46 -0800430 p9_debug(P9_DEBUG_ERROR, "blocking write ...\n");
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500431
432 oldfs = get_fs();
433 set_fs(get_ds());
434 /* The cast to a user pointer is valid due to the set_fs() */
Hannes Edere3db6cb2009-02-25 10:31:37 +0000435 ret = vfs_write(ts->wr, (__force void __user *)v, len, &ts->wr->f_pos);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500436 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
449static void p9_write_work(struct work_struct *work)
450{
451 int n, err;
452 struct p9_conn *m;
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500453 struct p9_req_t *req;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500454
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) {
Simon Derr759f4292012-09-17 15:16:31 +0200463 spin_lock(&m->client->lock);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500464 if (list_empty(&m->unsent_req_list)) {
465 clear_bit(Wworksched, &m->wsched);
Simon Derr759f4292012-09-17 15:16:31 +0200466 spin_unlock(&m->client->lock);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500467 return;
468 }
469
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500470 req = list_entry(m->unsent_req_list.next, struct p9_req_t,
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500471 req_list);
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500472 req->status = REQ_STATUS_SENT;
Joe Perches5d385152011-11-28 10:40:46 -0800473 p9_debug(P9_DEBUG_TRANS, "move req %p\n", req);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500474 list_move_tail(&req->req_list, &m->req_list);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500475
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500476 m->wbuf = req->tc->sdata;
477 m->wsize = req->tc->size;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500478 m->wpos = 0;
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500479 spin_unlock(&m->client->lock);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500480 }
481
Joe Perches5d385152011-11-28 10:40:46 -0800482 p9_debug(P9_DEBUG_TRANS, "mux %p pos %d size %d\n",
483 m, m->wpos, m->wsize);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500484 clear_bit(Wpending, &m->wsched);
485 err = p9_fd_write(m->client, m->wbuf + m->wpos, m->wsize - m->wpos);
Joe Perches5d385152011-11-28 10:40:46 -0800486 p9_debug(P9_DEBUG_TRANS, "mux %p sent %d bytes\n", m, err);
Simon Derr584a8c12012-09-17 15:16:30 +0200487 if (err == -EAGAIN)
488 goto end_clear;
489
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500490
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
Simon Derr584a8c12012-09-17 15:16:30 +0200502end_clear:
503 clear_bit(Wworksched, &m->wsched);
504
Simon Derr1957b3a2012-09-17 15:16:29 +0200505 if (m->wsize || !list_empty(&m->unsent_req_list)) {
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500506 if (test_and_clear_bit(Wpending, &m->wsched))
507 n = POLLOUT;
508 else
509 n = p9_fd_poll(m->client, NULL);
510
Simon Derr584a8c12012-09-17 15:16:30 +0200511 if ((n & POLLOUT) &&
512 !test_and_set_bit(Wworksched, &m->wsched)) {
Joe Perches5d385152011-11-28 10:40:46 -0800513 p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
Tejun Heo61edeee2011-02-01 11:42:43 +0100514 schedule_work(&m->wq);
Simon Derr584a8c12012-09-17 15:16:30 +0200515 }
516 }
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500517
518 return;
519
520error:
521 p9_conn_cancel(m, err);
522 clear_bit(Wworksched, &m->wsched);
523}
524
Eric Dumazet95c96172012-04-15 05:58:06 +0000525static int p9_pollwake(wait_queue_t *wait, unsigned int mode, int sync, void *key)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500526{
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;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500531
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
Tejun Heoaa70c582011-02-01 11:42:43 +0100537 schedule_work(&p9_poll_work);
538 return 1;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500539}
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
550static void
551p9_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) {
Joe Perches5d385152011-11-28 10:40:46 -0800565 p9_debug(P9_DEBUG_ERROR, "not enough wait_address slots\n");
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500566 return;
567 }
568
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500569 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
582static struct p9_conn *p9_conn_create(struct p9_client *client)
583{
Tejun Heo95820a32008-10-13 18:45:20 -0500584 int n;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500585 struct p9_conn *m;
586
Joe Perches5d385152011-11-28 10:40:46 -0800587 p9_debug(P9_DEBUG_TRANS, "client %p msize %d\n", client, client->msize);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500588 m = kzalloc(sizeof(struct p9_conn), GFP_KERNEL);
589 if (!m)
590 return ERR_PTR(-ENOMEM);
591
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500592 INIT_LIST_HEAD(&m->mux_list);
593 m->client = client;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500594
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) {
Joe Perches5d385152011-11-28 10:40:46 -0800604 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500605 set_bit(Rpending, &m->wsched);
606 }
607
608 if (n & POLLOUT) {
Joe Perches5d385152011-11-28 10:40:46 -0800609 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500610 set_bit(Wpending, &m->wsched);
611 }
612
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500613 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
622static 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)) {
Joe Perches5d385152011-11-28 10:40:46 -0800631 p9_debug(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500632 if (n >= 0)
633 n = -ECONNRESET;
634 p9_conn_cancel(m, n);
635 }
636
637 if (n & POLLIN) {
638 set_bit(Rpending, &m->wsched);
Joe Perches5d385152011-11-28 10:40:46 -0800639 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500640 if (!test_and_set_bit(Rworksched, &m->wsched)) {
Joe Perches5d385152011-11-28 10:40:46 -0800641 p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
Tejun Heo61edeee2011-02-01 11:42:43 +0100642 schedule_work(&m->rq);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500643 }
644 }
645
646 if (n & POLLOUT) {
647 set_bit(Wpending, &m->wsched);
Joe Perches5d385152011-11-28 10:40:46 -0800648 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
Joe Perchesf64f9e72009-11-29 16:55:45 -0800649 if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
650 !test_and_set_bit(Wworksched, &m->wsched)) {
Joe Perches5d385152011-11-28 10:40:46 -0800651 p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
Tejun Heo61edeee2011-02-01 11:42:43 +0100652 schedule_work(&m->wq);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500653 }
654 }
655}
656
657/**
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500658 * p9_fd_request - send 9P request
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600659 * The function can sleep until the request is scheduled for sending.
660 * The function can be interrupted. Return from the function is not
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500661 * a guarantee that the request is sent successfully.
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600662 *
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500663 * @client: client instance
664 * @req: request to be sent
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600665 *
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600666 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600667
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500668static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600669{
670 int n;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500671 struct p9_trans_fd *ts = client->trans;
672 struct p9_conn *m = ts->conn;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600673
Joe Perches5d385152011-11-28 10:40:46 -0800674 p9_debug(P9_DEBUG_TRANS, "mux %p task %p tcall %p id %d\n",
675 m, current, req->tc, req->tc->id);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600676 if (m->err < 0)
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500677 return m->err;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600678
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500679 spin_lock(&client->lock);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500680 req->status = REQ_STATUS_UNSENT;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600681 list_add_tail(&req->req_list, &m->unsent_req_list);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500682 spin_unlock(&client->lock);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600683
684 if (test_and_clear_bit(Wpending, &m->wsched))
685 n = POLLOUT;
686 else
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500687 n = p9_fd_poll(m->client, NULL);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600688
689 if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
Tejun Heo61edeee2011-02-01 11:42:43 +0100690 schedule_work(&m->wq);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600691
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500692 return 0;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600693}
694
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500695static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600696{
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500697 int ret = 1;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600698
Joe Perches5d385152011-11-28 10:40:46 -0800699 p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600700
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500701 spin_lock(&client->lock);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500702
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500703 if (req->status == REQ_STATUS_UNSENT) {
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500704 list_del(&req->req_list);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500705 req->status = REQ_STATUS_FLSHD;
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500706 ret = 0;
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500707 } else if (req->status == REQ_STATUS_SENT)
708 req->status = REQ_STATUS_FLSH;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600709
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500710 spin_unlock(&client->lock);
711
712 return ret;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600713}
714
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600715/**
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600716 * 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
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500719 *
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600720 * Returns 0 upon success, -ERRNO upon failure
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500721 */
722
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600723static int parse_opts(char *params, struct p9_fd_opts *opts)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500724{
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500725 char *p;
726 substring_t args[MAX_OPT_ARGS];
727 int option;
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600728 char *options, *tmp_options;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500729
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500730 opts->port = P9_PORT;
731 opts->rfd = ~0;
732 opts->wfd = ~0;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500733
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600734 if (!params)
735 return 0;
736
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600737 tmp_options = kstrdup(params, GFP_KERNEL);
738 if (!tmp_options) {
Joe Perches5d385152011-11-28 10:40:46 -0800739 p9_debug(P9_DEBUG_ERROR,
740 "failed to allocate copy of option string\n");
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600741 return -ENOMEM;
742 }
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600743 options = tmp_options;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500744
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500745 while ((p = strsep(&options, ",")) != NULL) {
746 int token;
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600747 int r;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500748 if (!*p)
749 continue;
750 token = match_token(p, tokens, args);
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700751 if ((token != Opt_err) && (token != Opt_privport)) {
Abhishek Kulkarni15da4b12009-07-01 08:50:54 +0000752 r = match_int(&args[0], &option);
753 if (r < 0) {
Joe Perches5d385152011-11-28 10:40:46 -0800754 p9_debug(P9_DEBUG_ERROR,
755 "integer field, but no integer?\n");
Abhishek Kulkarni15da4b12009-07-01 08:50:54 +0000756 continue;
757 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500758 }
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;
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700769 case Opt_privport:
770 opts->privport = 1;
771 break;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500772 default:
773 continue;
774 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500775 }
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600776
777 kfree(tmp_options);
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600778 return 0;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500779}
780
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500781static int p9_fd_open(struct p9_client *client, int rfd, int wfd)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500782{
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
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500799 client->trans = ts;
800 client->status = Connected;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500801
802 return 0;
803}
804
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500805static int p9_socket_open(struct p9_client *client, struct socket *csocket)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500806{
Al Viro6b186622009-08-06 02:02:43 +0400807 struct p9_trans_fd *p;
Al Viro56b31d12012-08-18 00:25:51 -0400808 struct file *file;
809 int ret;
Al Viro6b186622009-08-06 02:02:43 +0400810
811 p = kmalloc(sizeof(struct p9_trans_fd), GFP_KERNEL);
812 if (!p)
813 return -ENOMEM;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500814
815 csocket->sk->sk_allocation = GFP_NOIO;
Linus Torvaldsaab174f2012-10-02 20:25:04 -0700816 file = sock_alloc_file(csocket, 0, NULL);
Al Viro56b31d12012-08-18 00:25:51 -0400817 if (IS_ERR(file)) {
Joe Perches5d385152011-11-28 10:40:46 -0800818 pr_err("%s (%d): failed to map fd\n",
819 __func__, task_pid_nr(current));
Al Viro6b186622009-08-06 02:02:43 +0400820 sock_release(csocket);
821 kfree(p);
Al Viro56b31d12012-08-18 00:25:51 -0400822 return PTR_ERR(file);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500823 }
824
Al Viro56b31d12012-08-18 00:25:51 -0400825 get_file(file);
826 p->wr = p->rd = file;
Al Viro6b186622009-08-06 02:02:43 +0400827 client->trans = p;
828 client->status = Connected;
829
Al Viro6b186622009-08-06 02:02:43 +0400830 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);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500838 sockfd_put(csocket);
839 return ret;
840 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500841 return 0;
842}
843
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500844/**
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500845 * p9_mux_destroy - cancels all pending requests and frees mux resources
846 * @m: mux to destroy
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500847 *
848 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600849
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500850static void p9_conn_destroy(struct p9_conn *m)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500851{
Joe Perches5d385152011-11-28 10:40:46 -0800852 p9_debug(P9_DEBUG_TRANS, "mux %p prev %p next %p\n",
853 m, m->mux_list.prev, m->mux_list.next);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500854
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500855 p9_mux_poll_stop(m);
856 cancel_work_sync(&m->rq);
857 cancel_work_sync(&m->wq);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500858
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500859 p9_conn_cancel(m, -ECONNRESET);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500860
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500861 m->client = NULL;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500862 kfree(m);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500863}
864
865/**
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500866 * p9_fd_close - shutdown file descriptor transport
867 * @client: client instance
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500868 *
869 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600870
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500871static void p9_fd_close(struct p9_client *client)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500872{
873 struct p9_trans_fd *ts;
874
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500875 if (!client)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500876 return;
877
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500878 ts = client->trans;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500879 if (!ts)
880 return;
881
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500882 client->status = Disconnected;
883
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600884 p9_conn_destroy(ts->conn);
885
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500886 if (ts->rd)
887 fput(ts->rd);
888 if (ts->wr)
889 fput(ts->wr);
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500890
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500891 kfree(ts);
892}
893
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -0500894/*
895 * stolen from NFS - maybe should be made a generic function?
896 */
897static 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
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700911static 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
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500929static int
930p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500931{
932 int err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500933 struct socket *csocket;
934 struct sockaddr_in sin_server;
935 struct p9_fd_opts opts;
936
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600937 err = parse_opts(args, &opts);
938 if (err < 0)
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500939 return err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500940
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -0500941 if (valid_ipaddr4(addr) < 0)
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500942 return -EINVAL;
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -0500943
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500944 csocket = NULL;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500945
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);
Rob Landleye75762f2011-05-23 21:46:56 -0500949 err = __sock_create(read_pnet(&current->nsproxy->net_ns), PF_INET,
950 SOCK_STREAM, IPPROTO_TCP, &csocket, 1);
Al Viro6b186622009-08-06 02:02:43 +0400951 if (err) {
Joe Perches5d385152011-11-28 10:40:46 -0800952 pr_err("%s (%d): problem creating socket\n",
953 __func__, task_pid_nr(current));
Al Viro6b186622009-08-06 02:02:43 +0400954 return err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500955 }
956
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700957 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
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500967 err = csocket->ops->connect(csocket,
968 (struct sockaddr *)&sin_server,
969 sizeof(struct sockaddr_in), 0);
970 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -0800971 pr_err("%s (%d): problem connecting socket to %s\n",
972 __func__, task_pid_nr(current), addr);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500973 sock_release(csocket);
Al Viro6b186622009-08-06 02:02:43 +0400974 return err;
975 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500976
Al Viro6b186622009-08-06 02:02:43 +0400977 return p9_socket_open(client, csocket);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500978}
979
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500980static int
981p9_fd_create_unix(struct p9_client *client, const char *addr, char *args)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500982{
983 int err;
984 struct socket *csocket;
985 struct sockaddr_un sun_server;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500986
987 csocket = NULL;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500988
Dan Carpentercff6b8a2010-07-10 11:51:54 +0200989 if (strlen(addr) >= UNIX_PATH_MAX) {
Joe Perches5d385152011-11-28 10:40:46 -0800990 pr_err("%s (%d): address too long: %s\n",
991 __func__, task_pid_nr(current), addr);
Al Viro6b186622009-08-06 02:02:43 +0400992 return -ENAMETOOLONG;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500993 }
994
995 sun_server.sun_family = PF_UNIX;
996 strcpy(sun_server.sun_path, addr);
Rob Landleye75762f2011-05-23 21:46:56 -0500997 err = __sock_create(read_pnet(&current->nsproxy->net_ns), PF_UNIX,
998 SOCK_STREAM, 0, &csocket, 1);
Al Viro6b186622009-08-06 02:02:43 +0400999 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -08001000 pr_err("%s (%d): problem creating socket\n",
1001 __func__, task_pid_nr(current));
1002
Al Viro6b186622009-08-06 02:02:43 +04001003 return err;
1004 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001005 err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1006 sizeof(struct sockaddr_un) - 1, 0);
1007 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -08001008 pr_err("%s (%d): problem connecting socket: %s: %d\n",
1009 __func__, task_pid_nr(current), addr, err);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001010 sock_release(csocket);
Al Viro6b186622009-08-06 02:02:43 +04001011 return err;
1012 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001013
Al Viro6b186622009-08-06 02:02:43 +04001014 return p9_socket_open(client, csocket);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001015}
1016
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001017static int
1018p9_fd_create(struct p9_client *client, const char *addr, char *args)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001019{
1020 int err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001021 struct p9_fd_opts opts;
Al Viro6b186622009-08-06 02:02:43 +04001022 struct p9_trans_fd *p;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001023
1024 parse_opts(args, &opts);
1025
1026 if (opts.rfd == ~0 || opts.wfd == ~0) {
Joe Perches5d385152011-11-28 10:40:46 -08001027 pr_err("Insufficient options for proto=fd\n");
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001028 return -ENOPROTOOPT;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001029 }
1030
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001031 err = p9_fd_open(client, opts.rfd, opts.wfd);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001032 if (err < 0)
Al Viro6b186622009-08-06 02:02:43 +04001033 return err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001034
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001035 p = (struct p9_trans_fd *) client->trans;
1036 p->conn = p9_conn_create(client);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -06001037 if (IS_ERR(p->conn)) {
1038 err = PTR_ERR(p->conn);
1039 p->conn = NULL;
Al Viro6b186622009-08-06 02:02:43 +04001040 fput(p->rd);
1041 fput(p->wr);
1042 return err;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -06001043 }
1044
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001045 return 0;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001046}
1047
1048static struct p9_trans_module p9_tcp_trans = {
1049 .name = "tcp",
1050 .maxsize = MAX_SOCK_BUF,
1051 .def = 1,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001052 .create = p9_fd_create_tcp,
1053 .close = p9_fd_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -05001054 .request = p9_fd_request,
1055 .cancel = p9_fd_cancel,
Tejun Heo72029fe2008-09-24 16:22:23 -05001056 .owner = THIS_MODULE,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001057};
1058
1059static struct p9_trans_module p9_unix_trans = {
1060 .name = "unix",
1061 .maxsize = MAX_SOCK_BUF,
1062 .def = 0,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001063 .create = p9_fd_create_unix,
1064 .close = p9_fd_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -05001065 .request = p9_fd_request,
1066 .cancel = p9_fd_cancel,
Tejun Heo72029fe2008-09-24 16:22:23 -05001067 .owner = THIS_MODULE,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001068};
1069
1070static struct p9_trans_module p9_fd_trans = {
1071 .name = "fd",
1072 .maxsize = MAX_SOCK_BUF,
1073 .def = 0,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001074 .create = p9_fd_create,
1075 .close = p9_fd_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -05001076 .request = p9_fd_request,
1077 .cancel = p9_fd_cancel,
Tejun Heo72029fe2008-09-24 16:22:23 -05001078 .owner = THIS_MODULE,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001079};
1080
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001081/**
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
Tejun Heoaa70c582011-02-01 11:42:43 +01001090static void p9_poll_workfn(struct work_struct *work)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001091{
1092 unsigned long flags;
1093
Joe Perches5d385152011-11-28 10:40:46 -08001094 p9_debug(P9_DEBUG_TRANS, "start %p\n", current);
Tejun Heoaa70c582011-02-01 11:42:43 +01001095
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001096 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
Joe Perches5d385152011-11-28 10:40:46 -08001110 p9_debug(P9_DEBUG_TRANS, "finish\n");
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001111}
1112
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -05001113int p9_trans_fd_init(void)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001114{
1115 v9fs_register_trans(&p9_tcp_trans);
1116 v9fs_register_trans(&p9_unix_trans);
1117 v9fs_register_trans(&p9_fd_trans);
1118
Andrew Morton3387b802008-03-28 14:15:57 -07001119 return 0;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001120}
Tejun Heo72029fe2008-09-24 16:22:23 -05001121
1122void p9_trans_fd_exit(void)
1123{
Tejun Heo43829732012-08-20 14:51:24 -07001124 flush_work(&p9_poll_work);
Tejun Heo72029fe2008-09-24 16:22:23 -05001125 v9fs_unregister_trans(&p9_tcp_trans);
1126 v9fs_unregister_trans(&p9_unix_trans);
1127 v9fs_unregister_trans(&p9_fd_trans);
1128}