blob: 7bc2208b6cc4c445286c20e01d9911ac9e75b9b2 [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 Hensbergena80d9232007-10-17 14:31:07 -050069/*
70 * Option Parsing (code inspired by NFS code)
71 * - a little lazy - parse all fd-transport options
72 */
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050073
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050074enum {
75 /* Options that take integer arguments */
Latchesar Ionkov55762692007-11-06 08:02:53 -060076 Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
Jim Garlick2f28c8b2013-05-29 12:15:07 -070077 /* Options that take no arguments */
78 Opt_privport,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050079};
80
Steven Whitehousea447c092008-10-13 10:46:57 +010081static const match_table_t tokens = {
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050082 {Opt_port, "port=%u"},
83 {Opt_rfdno, "rfdno=%u"},
84 {Opt_wfdno, "wfdno=%u"},
Jim Garlick2f28c8b2013-05-29 12:15:07 -070085 {Opt_privport, "privport"},
Latchesar Ionkov55762692007-11-06 08:02:53 -060086 {Opt_err, NULL},
Eric Van Hensbergena80d9232007-10-17 14:31:07 -050087};
88
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -060089enum {
90 Rworksched = 1, /* read work scheduled or running */
91 Rpending = 2, /* can read */
92 Wworksched = 4, /* write work scheduled or running */
93 Wpending = 8, /* can write */
94};
95
Tejun Heo992b3f12008-10-13 18:45:25 -050096struct p9_poll_wait {
97 struct p9_conn *conn;
98 wait_queue_t wait;
99 wait_queue_head_t *wait_addr;
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600100};
101
102/**
103 * struct p9_conn - fd mux connection state information
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600104 * @mux_list: list link for mux to manage multiple connections (?)
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500105 * @client: reference to client instance for this connection
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600106 * @err: error state
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600107 * @req_list: accounting for requests which have been sent
108 * @unsent_req_list: accounting for requests that haven't been sent
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500109 * @req: current request being processed (if any)
110 * @tmp_buf: temporary buffer to read in header
Dominique Martinet947867a2015-09-03 11:28:20 +0200111 * @rc: temporary fcall for reading current frame
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600112 * @wpos: write position for current frame
113 * @wsize: amount of data to write for current frame
114 * @wbuf: current write buffer
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600115 * @poll_pending_link: pending links to be polled per conn
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600116 * @poll_wait: array of wait_q's for various worker threads
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600117 * @pt: poll state
118 * @rq: current read work
119 * @wq: current write work
120 * @wsched: ????
121 *
122 */
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600123
124struct p9_conn {
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600125 struct list_head mux_list;
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500126 struct p9_client *client;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600127 int err;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600128 struct list_head req_list;
129 struct list_head unsent_req_list;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500130 struct p9_req_t *req;
131 char tmp_buf[7];
Dominique Martinet947867a2015-09-03 11:28:20 +0200132 struct p9_fcall rc;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600133 int wpos;
134 int wsize;
135 char *wbuf;
Tejun Heo992b3f12008-10-13 18:45:25 -0500136 struct list_head poll_pending_link;
137 struct p9_poll_wait poll_wait[MAXPOLLWADDR];
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600138 poll_table pt;
139 struct work_struct rq;
140 struct work_struct wq;
141 unsigned long wsched;
142};
143
Simon Derr263c5822014-03-11 10:13:09 +0100144/**
145 * struct p9_trans_fd - transport state
146 * @rd: reference to file to read from
147 * @wr: reference of file to write to
148 * @conn: connection state reference
149 *
150 */
151
152struct p9_trans_fd {
153 struct file *rd;
154 struct file *wr;
155 struct p9_conn conn;
156};
157
Tejun Heoaa70c582011-02-01 11:42:43 +0100158static void p9_poll_workfn(struct work_struct *work);
159
Tejun Heo992b3f12008-10-13 18:45:25 -0500160static DEFINE_SPINLOCK(p9_poll_lock);
161static LIST_HEAD(p9_poll_pending_list);
Tejun Heoaa70c582011-02-01 11:42:43 +0100162static DECLARE_WORK(p9_poll_work, p9_poll_workfn);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600163
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700164static unsigned int p9_ipport_resv_min = P9_DEF_MIN_RESVPORT;
165static unsigned int p9_ipport_resv_max = P9_DEF_MAX_RESVPORT;
166
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600167static void p9_mux_poll_stop(struct p9_conn *m)
168{
Tejun Heo992b3f12008-10-13 18:45:25 -0500169 unsigned long flags;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600170 int i;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600171
Tejun Heo992b3f12008-10-13 18:45:25 -0500172 for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
173 struct p9_poll_wait *pwait = &m->poll_wait[i];
174
175 if (pwait->wait_addr) {
176 remove_wait_queue(pwait->wait_addr, &pwait->wait);
177 pwait->wait_addr = NULL;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600178 }
179 }
Tejun Heo992b3f12008-10-13 18:45:25 -0500180
181 spin_lock_irqsave(&p9_poll_lock, flags);
182 list_del_init(&m->poll_pending_link);
183 spin_unlock_irqrestore(&p9_poll_lock, flags);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600184}
185
186/**
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500187 * p9_conn_cancel - cancel all pending requests with error
188 * @m: mux data
189 * @err: error code
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600190 *
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600191 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600192
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500193static void p9_conn_cancel(struct p9_conn *m, int err)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600194{
Eric Van Hensbergen673d62cd2008-10-13 18:45:22 -0500195 struct p9_req_t *req, *rtmp;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500196 unsigned long flags;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500197 LIST_HEAD(cancel_list);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600198
Joe Perches5d385152011-11-28 10:40:46 -0800199 p9_debug(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500200
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500201 spin_lock_irqsave(&m->client->lock, flags);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500202
203 if (m->err) {
204 spin_unlock_irqrestore(&m->client->lock, flags);
205 return;
206 }
207
208 m->err = err;
209
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500210 list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
211 list_move(&req->req_list, &cancel_list);
Tejun Heo992b3f12008-10-13 18:45:25 -0500212 }
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500213 list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
214 list_move(&req->req_list, &cancel_list);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600215 }
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500216 spin_unlock_irqrestore(&m->client->lock, flags);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600217
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500218 list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
Joe Perches5d385152011-11-28 10:40:46 -0800219 p9_debug(P9_DEBUG_ERROR, "call back req %p\n", req);
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500220 list_del(&req->req_list);
Dominique Martinet2b6e72e2014-01-17 18:31:00 +0100221 if (!req->t_err)
222 req->t_err = err;
223 p9_client_cb(m->client, req, REQ_STATUS_ERROR);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600224 }
225}
226
Julia Lawall29af9302010-09-05 09:00:21 +0000227static int
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500228p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt)
229{
230 int ret, n;
231 struct p9_trans_fd *ts = NULL;
232
233 if (client && client->status == Connected)
234 ts = client->trans;
235
236 if (!ts)
237 return -EREMOTEIO;
238
Al Viro72c2d532013-09-22 16:27:52 -0400239 if (!ts->rd->f_op->poll)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500240 return -EIO;
241
Al Viro72c2d532013-09-22 16:27:52 -0400242 if (!ts->wr->f_op->poll)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500243 return -EIO;
244
245 ret = ts->rd->f_op->poll(ts->rd, pt);
246 if (ret < 0)
247 return ret;
248
249 if (ts->rd != ts->wr) {
250 n = ts->wr->f_op->poll(ts->wr, pt);
251 if (n < 0)
252 return n;
253 ret = (ret & ~POLLOUT) | (n & ~POLLIN);
254 }
255
256 return ret;
257}
258
259/**
260 * p9_fd_read- read from a fd
261 * @client: client instance
262 * @v: buffer to receive data into
263 * @len: size of receive buffer
264 *
265 */
266
267static int p9_fd_read(struct p9_client *client, void *v, int len)
268{
269 int ret;
270 struct p9_trans_fd *ts = NULL;
271
272 if (client && client->status != Disconnected)
273 ts = client->trans;
274
275 if (!ts)
276 return -EREMOTEIO;
277
278 if (!(ts->rd->f_flags & O_NONBLOCK))
Joe Perches5d385152011-11-28 10:40:46 -0800279 p9_debug(P9_DEBUG_ERROR, "blocking read ...\n");
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500280
281 ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
282 if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
283 client->status = Disconnected;
284 return ret;
285}
286
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600287/**
288 * p9_read_work - called when there is some data to be read from a transport
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600289 * @work: container of work to be done
290 *
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600291 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600292
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600293static void p9_read_work(struct work_struct *work)
294{
295 int n, err;
296 struct p9_conn *m;
Dominique Martinet2b6e72e2014-01-17 18:31:00 +0100297 int status = REQ_STATUS_ERROR;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600298
299 m = container_of(work, struct p9_conn, rq);
300
301 if (m->err < 0)
302 return;
303
Dominique Martinet947867a2015-09-03 11:28:20 +0200304 p9_debug(P9_DEBUG_TRANS, "start mux %p pos %zd\n", m, m->rc.offset);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600305
Dominique Martinet947867a2015-09-03 11:28:20 +0200306 if (!m->rc.sdata) {
307 m->rc.sdata = m->tmp_buf;
308 m->rc.offset = 0;
309 m->rc.capacity = 7; /* start by reading header */
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600310 }
311
312 clear_bit(Rpending, &m->wsched);
Dominique Martinet947867a2015-09-03 11:28:20 +0200313 p9_debug(P9_DEBUG_TRANS, "read mux %p pos %zd size: %zd = %zd\n",
314 m, m->rc.offset, m->rc.capacity,
315 m->rc.capacity - m->rc.offset);
316 err = p9_fd_read(m->client, m->rc.sdata + m->rc.offset,
317 m->rc.capacity - m->rc.offset);
Joe Perches5d385152011-11-28 10:40:46 -0800318 p9_debug(P9_DEBUG_TRANS, "mux %p got %d bytes\n", m, err);
Dominique Martinet947867a2015-09-03 11:28:20 +0200319 if (err == -EAGAIN)
Simon Derr04621942012-09-17 15:16:28 +0200320 goto end_clear;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600321
322 if (err <= 0)
323 goto error;
324
Dominique Martinet947867a2015-09-03 11:28:20 +0200325 m->rc.offset += err;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500326
Dominique Martinet947867a2015-09-03 11:28:20 +0200327 /* header read in */
328 if ((!m->req) && (m->rc.offset == m->rc.capacity)) {
Joe Perches5d385152011-11-28 10:40:46 -0800329 p9_debug(P9_DEBUG_TRANS, "got new header\n");
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500330
Dominique Martinet947867a2015-09-03 11:28:20 +0200331 err = p9_parse_header(&m->rc, NULL, NULL, NULL, 0);
332 if (err) {
Joe Perches5d385152011-11-28 10:40:46 -0800333 p9_debug(P9_DEBUG_ERROR,
Dominique Martinet947867a2015-09-03 11:28:20 +0200334 "error parsing header: %d\n", err);
335 goto error;
336 }
337
338 if (m->rc.size >= m->client->msize) {
339 p9_debug(P9_DEBUG_ERROR,
340 "requested packet size too big: %d\n",
341 m->rc.size);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600342 err = -EIO;
343 goto error;
344 }
345
Joe Perches5d385152011-11-28 10:40:46 -0800346 p9_debug(P9_DEBUG_TRANS,
Dominique Martinet947867a2015-09-03 11:28:20 +0200347 "mux %p pkt: size: %d bytes tag: %d\n",
348 m, m->rc.size, m->rc.tag);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600349
Dominique Martinet947867a2015-09-03 11:28:20 +0200350 m->req = p9_tag_lookup(m->client, m->rc.tag);
Simon Derr0bfd6842014-03-10 16:38:52 +0100351 if (!m->req || (m->req->status != REQ_STATUS_SENT)) {
Joe Perches5d385152011-11-28 10:40:46 -0800352 p9_debug(P9_DEBUG_ERROR, "Unexpected packet tag %d\n",
Dominique Martinet947867a2015-09-03 11:28:20 +0200353 m->rc.tag);
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500354 err = -EIO;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600355 goto error;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500356 }
357
358 if (m->req->rc == NULL) {
Dominique Martinet30536002015-09-07 17:06:54 +0200359 p9_debug(P9_DEBUG_ERROR,
360 "No recv fcall for tag %d (req %p), disconnecting!\n",
361 m->rc.tag, m->req);
362 m->req = NULL;
363 err = -EIO;
364 goto error;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500365 }
Dominique Martinet947867a2015-09-03 11:28:20 +0200366 m->rc.sdata = (char *)m->req->rc + sizeof(struct p9_fcall);
367 memcpy(m->rc.sdata, m->tmp_buf, m->rc.capacity);
368 m->rc.capacity = m->rc.size;
Eric Van Hensbergen1b0a7632008-10-13 18:45:22 -0500369 }
370
Dominique Martinet947867a2015-09-03 11:28:20 +0200371 /* packet is read in
372 * not an else because some packets (like clunk) have no payload
373 */
374 if ((m->req) && (m->rc.offset == m->rc.capacity)) {
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)
Dominique Martinet2b6e72e2014-01-17 18:31:00 +0100378 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);
Dominique Martinet2b6e72e2014-01-17 18:31:00 +0100381 p9_client_cb(m->client, m->req, status);
Dominique Martinet947867a2015-09-03 11:28:20 +0200382 m->rc.sdata = NULL;
383 m->rc.offset = 0;
384 m->rc.capacity = 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/**
Simon Derr263c5822014-03-11 10:13:09 +0100576 * p9_conn_create - initialize the per-session mux data
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500577 * @client: client instance
578 *
579 * Note: Creates the polling task if this is the first session.
580 */
581
Simon Derr263c5822014-03-11 10:13:09 +0100582static void p9_conn_create(struct p9_client *client)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500583{
Tejun Heo95820a32008-10-13 18:45:20 -0500584 int n;
Simon Derr263c5822014-03-11 10:13:09 +0100585 struct p9_trans_fd *ts = client->trans;
586 struct p9_conn *m = &ts->conn;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500587
Joe Perches5d385152011-11-28 10:40:46 -0800588 p9_debug(P9_DEBUG_TRANS, "client %p msize %d\n", client, client->msize);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500589
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500590 INIT_LIST_HEAD(&m->mux_list);
591 m->client = client;
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500592
593 INIT_LIST_HEAD(&m->req_list);
594 INIT_LIST_HEAD(&m->unsent_req_list);
595 INIT_WORK(&m->rq, p9_read_work);
596 INIT_WORK(&m->wq, p9_write_work);
597 INIT_LIST_HEAD(&m->poll_pending_link);
598 init_poll_funcptr(&m->pt, p9_pollwait);
599
600 n = p9_fd_poll(client, &m->pt);
601 if (n & POLLIN) {
Joe Perches5d385152011-11-28 10:40:46 -0800602 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500603 set_bit(Rpending, &m->wsched);
604 }
605
606 if (n & POLLOUT) {
Joe Perches5d385152011-11-28 10:40:46 -0800607 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500608 set_bit(Wpending, &m->wsched);
609 }
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500610}
611
612/**
613 * p9_poll_mux - polls a mux and schedules read or write works if necessary
614 * @m: connection to poll
615 *
616 */
617
618static void p9_poll_mux(struct p9_conn *m)
619{
620 int n;
621
622 if (m->err < 0)
623 return;
624
625 n = p9_fd_poll(m->client, NULL);
626 if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
Joe Perches5d385152011-11-28 10:40:46 -0800627 p9_debug(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500628 if (n >= 0)
629 n = -ECONNRESET;
630 p9_conn_cancel(m, n);
631 }
632
633 if (n & POLLIN) {
634 set_bit(Rpending, &m->wsched);
Joe Perches5d385152011-11-28 10:40:46 -0800635 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500636 if (!test_and_set_bit(Rworksched, &m->wsched)) {
Joe Perches5d385152011-11-28 10:40:46 -0800637 p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
Tejun Heo61edeee2011-02-01 11:42:43 +0100638 schedule_work(&m->rq);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500639 }
640 }
641
642 if (n & POLLOUT) {
643 set_bit(Wpending, &m->wsched);
Joe Perches5d385152011-11-28 10:40:46 -0800644 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
Joe Perchesf64f9e72009-11-29 16:55:45 -0800645 if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
646 !test_and_set_bit(Wworksched, &m->wsched)) {
Joe Perches5d385152011-11-28 10:40:46 -0800647 p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
Tejun Heo61edeee2011-02-01 11:42:43 +0100648 schedule_work(&m->wq);
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500649 }
650 }
651}
652
653/**
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500654 * p9_fd_request - send 9P request
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600655 * The function can sleep until the request is scheduled for sending.
656 * The function can be interrupted. Return from the function is not
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500657 * a guarantee that the request is sent successfully.
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600658 *
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500659 * @client: client instance
660 * @req: request to be sent
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600661 *
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600662 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600663
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500664static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600665{
666 int n;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500667 struct p9_trans_fd *ts = client->trans;
Simon Derr263c5822014-03-11 10:13:09 +0100668 struct p9_conn *m = &ts->conn;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600669
Joe Perches5d385152011-11-28 10:40:46 -0800670 p9_debug(P9_DEBUG_TRANS, "mux %p task %p tcall %p id %d\n",
671 m, current, req->tc, req->tc->id);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600672 if (m->err < 0)
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500673 return m->err;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600674
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500675 spin_lock(&client->lock);
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500676 req->status = REQ_STATUS_UNSENT;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600677 list_add_tail(&req->req_list, &m->unsent_req_list);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500678 spin_unlock(&client->lock);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600679
680 if (test_and_clear_bit(Wpending, &m->wsched))
681 n = POLLOUT;
682 else
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500683 n = p9_fd_poll(m->client, NULL);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600684
685 if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
Tejun Heo61edeee2011-02-01 11:42:43 +0100686 schedule_work(&m->wq);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600687
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500688 return 0;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600689}
690
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500691static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600692{
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500693 int ret = 1;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600694
Joe Perches5d385152011-11-28 10:40:46 -0800695 p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600696
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500697 spin_lock(&client->lock);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500698
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500699 if (req->status == REQ_STATUS_UNSENT) {
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500700 list_del(&req->req_list);
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500701 req->status = REQ_STATUS_FLSHD;
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500702 ret = 0;
Simon Derr0bfd6842014-03-10 16:38:52 +0100703 }
Eric Van Hensbergen7eb923b2008-10-17 12:45:40 -0500704 spin_unlock(&client->lock);
705
706 return ret;
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600707}
708
Simon Derrafd8d652014-03-10 16:38:49 +0100709static int p9_fd_cancelled(struct p9_client *client, struct p9_req_t *req)
710{
711 p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
712
713 /* we haven't received a response for oldreq,
714 * remove it from the list.
715 */
716 spin_lock(&client->lock);
717 list_del(&req->req_list);
718 spin_unlock(&client->lock);
719
720 return 0;
721}
722
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600723/**
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600724 * parse_opts - parse mount options into p9_fd_opts structure
725 * @params: options string passed from mount
726 * @opts: fd transport-specific structure to parse options into
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500727 *
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600728 * Returns 0 upon success, -ERRNO upon failure
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500729 */
730
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600731static int parse_opts(char *params, struct p9_fd_opts *opts)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500732{
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500733 char *p;
734 substring_t args[MAX_OPT_ARGS];
735 int option;
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600736 char *options, *tmp_options;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500737
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500738 opts->port = P9_PORT;
739 opts->rfd = ~0;
740 opts->wfd = ~0;
Dominique Martinetb99baa42015-01-09 13:05:56 +0100741 opts->privport = 0;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500742
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600743 if (!params)
744 return 0;
745
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600746 tmp_options = kstrdup(params, GFP_KERNEL);
747 if (!tmp_options) {
Joe Perches5d385152011-11-28 10:40:46 -0800748 p9_debug(P9_DEBUG_ERROR,
749 "failed to allocate copy of option string\n");
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600750 return -ENOMEM;
751 }
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600752 options = tmp_options;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500753
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500754 while ((p = strsep(&options, ",")) != NULL) {
755 int token;
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600756 int r;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500757 if (!*p)
758 continue;
759 token = match_token(p, tokens, args);
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700760 if ((token != Opt_err) && (token != Opt_privport)) {
Abhishek Kulkarni15da4b12009-07-01 08:50:54 +0000761 r = match_int(&args[0], &option);
762 if (r < 0) {
Joe Perches5d385152011-11-28 10:40:46 -0800763 p9_debug(P9_DEBUG_ERROR,
764 "integer field, but no integer?\n");
Abhishek Kulkarni15da4b12009-07-01 08:50:54 +0000765 continue;
766 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500767 }
768 switch (token) {
769 case Opt_port:
770 opts->port = option;
771 break;
772 case Opt_rfdno:
773 opts->rfd = option;
774 break;
775 case Opt_wfdno:
776 opts->wfd = option;
777 break;
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700778 case Opt_privport:
779 opts->privport = 1;
780 break;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500781 default:
782 continue;
783 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500784 }
Eric Van Hensbergend8c8a9e2010-02-08 16:23:23 -0600785
786 kfree(tmp_options);
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600787 return 0;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500788}
789
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500790static int p9_fd_open(struct p9_client *client, int rfd, int wfd)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500791{
Simon Derr263c5822014-03-11 10:13:09 +0100792 struct p9_trans_fd *ts = kzalloc(sizeof(struct p9_trans_fd),
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500793 GFP_KERNEL);
794 if (!ts)
795 return -ENOMEM;
796
797 ts->rd = fget(rfd);
798 ts->wr = fget(wfd);
799 if (!ts->rd || !ts->wr) {
800 if (ts->rd)
801 fput(ts->rd);
802 if (ts->wr)
803 fput(ts->wr);
804 kfree(ts);
805 return -EIO;
806 }
807
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500808 client->trans = ts;
809 client->status = Connected;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500810
811 return 0;
812}
813
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500814static int p9_socket_open(struct p9_client *client, struct socket *csocket)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500815{
Al Viro6b186622009-08-06 02:02:43 +0400816 struct p9_trans_fd *p;
Al Viro56b31d12012-08-18 00:25:51 -0400817 struct file *file;
Al Viro6b186622009-08-06 02:02:43 +0400818
Simon Derr263c5822014-03-11 10:13:09 +0100819 p = kzalloc(sizeof(struct p9_trans_fd), GFP_KERNEL);
Al Viro6b186622009-08-06 02:02:43 +0400820 if (!p)
821 return -ENOMEM;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500822
823 csocket->sk->sk_allocation = GFP_NOIO;
Linus Torvaldsaab174f2012-10-02 20:25:04 -0700824 file = sock_alloc_file(csocket, 0, NULL);
Al Viro56b31d12012-08-18 00:25:51 -0400825 if (IS_ERR(file)) {
Joe Perches5d385152011-11-28 10:40:46 -0800826 pr_err("%s (%d): failed to map fd\n",
827 __func__, task_pid_nr(current));
Al Viro6b186622009-08-06 02:02:43 +0400828 sock_release(csocket);
829 kfree(p);
Al Viro56b31d12012-08-18 00:25:51 -0400830 return PTR_ERR(file);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500831 }
832
Al Viro56b31d12012-08-18 00:25:51 -0400833 get_file(file);
834 p->wr = p->rd = file;
Al Viro6b186622009-08-06 02:02:43 +0400835 client->trans = p;
836 client->status = Connected;
837
Al Viro6b186622009-08-06 02:02:43 +0400838 p->rd->f_flags |= O_NONBLOCK;
839
Simon Derr263c5822014-03-11 10:13:09 +0100840 p9_conn_create(client);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500841 return 0;
842}
843
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500844/**
Simon Derr263c5822014-03-11 10:13:09 +0100845 * p9_mux_destroy - cancels all pending requests of mux
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -0500846 * @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;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500862}
863
864/**
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500865 * p9_fd_close - shutdown file descriptor transport
866 * @client: client instance
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500867 *
868 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600869
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500870static void p9_fd_close(struct p9_client *client)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500871{
872 struct p9_trans_fd *ts;
873
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500874 if (!client)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500875 return;
876
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500877 ts = client->trans;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500878 if (!ts)
879 return;
880
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500881 client->status = Disconnected;
882
Simon Derr263c5822014-03-11 10:13:09 +0100883 p9_conn_destroy(&ts->conn);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -0600884
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500885 if (ts->rd)
886 fput(ts->rd);
887 if (ts->wr)
888 fput(ts->wr);
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500889
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500890 kfree(ts);
891}
892
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -0500893/*
894 * stolen from NFS - maybe should be made a generic function?
895 */
896static inline int valid_ipaddr4(const char *buf)
897{
898 int rc, count, in[4];
899
900 rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
901 if (rc != 4)
902 return -EINVAL;
903 for (count = 0; count < 4; count++) {
904 if (in[count] > 255)
905 return -EINVAL;
906 }
907 return 0;
908}
909
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700910static int p9_bind_privport(struct socket *sock)
911{
912 struct sockaddr_in cl;
913 int port, err = -EINVAL;
914
915 memset(&cl, 0, sizeof(cl));
916 cl.sin_family = AF_INET;
917 cl.sin_addr.s_addr = INADDR_ANY;
918 for (port = p9_ipport_resv_max; port >= p9_ipport_resv_min; port--) {
919 cl.sin_port = htons((ushort)port);
920 err = kernel_bind(sock, (struct sockaddr *)&cl, sizeof(cl));
921 if (err != -EADDRINUSE)
922 break;
923 }
924 return err;
925}
926
927
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500928static int
929p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500930{
931 int err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500932 struct socket *csocket;
933 struct sockaddr_in sin_server;
934 struct p9_fd_opts opts;
935
Eric Van Hensbergenbb8ffdf2008-03-07 10:53:53 -0600936 err = parse_opts(args, &opts);
937 if (err < 0)
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500938 return err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500939
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -0500940 if (valid_ipaddr4(addr) < 0)
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500941 return -EINVAL;
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -0500942
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500943 csocket = NULL;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500944
945 sin_server.sin_family = AF_INET;
946 sin_server.sin_addr.s_addr = in_aton(addr);
947 sin_server.sin_port = htons(opts.port);
Eric W. Biederman0c5c9fb2015-03-11 23:06:44 -0500948 err = __sock_create(current->nsproxy->net_ns, PF_INET,
Rob Landleye75762f2011-05-23 21:46:56 -0500949 SOCK_STREAM, IPPROTO_TCP, &csocket, 1);
Al Viro6b186622009-08-06 02:02:43 +0400950 if (err) {
Joe Perches5d385152011-11-28 10:40:46 -0800951 pr_err("%s (%d): problem creating socket\n",
952 __func__, task_pid_nr(current));
Al Viro6b186622009-08-06 02:02:43 +0400953 return err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500954 }
955
Jim Garlick2f28c8b2013-05-29 12:15:07 -0700956 if (opts.privport) {
957 err = p9_bind_privport(csocket);
958 if (err < 0) {
959 pr_err("%s (%d): problem binding to privport\n",
960 __func__, task_pid_nr(current));
961 sock_release(csocket);
962 return err;
963 }
964 }
965
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500966 err = csocket->ops->connect(csocket,
967 (struct sockaddr *)&sin_server,
968 sizeof(struct sockaddr_in), 0);
969 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -0800970 pr_err("%s (%d): problem connecting socket to %s\n",
971 __func__, task_pid_nr(current), addr);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500972 sock_release(csocket);
Al Viro6b186622009-08-06 02:02:43 +0400973 return err;
974 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500975
Al Viro6b186622009-08-06 02:02:43 +0400976 return p9_socket_open(client, csocket);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500977}
978
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500979static int
980p9_fd_create_unix(struct p9_client *client, const char *addr, char *args)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500981{
982 int err;
983 struct socket *csocket;
984 struct sockaddr_un sun_server;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500985
986 csocket = NULL;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500987
Dan Carpentercff6b8a2010-07-10 11:51:54 +0200988 if (strlen(addr) >= UNIX_PATH_MAX) {
Joe Perches5d385152011-11-28 10:40:46 -0800989 pr_err("%s (%d): address too long: %s\n",
990 __func__, task_pid_nr(current), addr);
Al Viro6b186622009-08-06 02:02:43 +0400991 return -ENAMETOOLONG;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -0500992 }
993
994 sun_server.sun_family = PF_UNIX;
995 strcpy(sun_server.sun_path, addr);
Eric W. Biederman0c5c9fb2015-03-11 23:06:44 -0500996 err = __sock_create(current->nsproxy->net_ns, PF_UNIX,
Rob Landleye75762f2011-05-23 21:46:56 -0500997 SOCK_STREAM, 0, &csocket, 1);
Al Viro6b186622009-08-06 02:02:43 +0400998 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -0800999 pr_err("%s (%d): problem creating socket\n",
1000 __func__, task_pid_nr(current));
1001
Al Viro6b186622009-08-06 02:02:43 +04001002 return err;
1003 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001004 err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1005 sizeof(struct sockaddr_un) - 1, 0);
1006 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -08001007 pr_err("%s (%d): problem connecting socket: %s: %d\n",
1008 __func__, task_pid_nr(current), addr, err);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001009 sock_release(csocket);
Al Viro6b186622009-08-06 02:02:43 +04001010 return err;
1011 }
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001012
Al Viro6b186622009-08-06 02:02:43 +04001013 return p9_socket_open(client, csocket);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001014}
1015
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001016static int
1017p9_fd_create(struct p9_client *client, const char *addr, char *args)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001018{
1019 int err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001020 struct p9_fd_opts opts;
1021
1022 parse_opts(args, &opts);
1023
1024 if (opts.rfd == ~0 || opts.wfd == ~0) {
Joe Perches5d385152011-11-28 10:40:46 -08001025 pr_err("Insufficient options for proto=fd\n");
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001026 return -ENOPROTOOPT;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001027 }
1028
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001029 err = p9_fd_open(client, opts.rfd, opts.wfd);
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001030 if (err < 0)
Al Viro6b186622009-08-06 02:02:43 +04001031 return err;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001032
Simon Derr263c5822014-03-11 10:13:09 +01001033 p9_conn_create(client);
Eric Van Hensbergen8a0dc952008-02-06 19:25:03 -06001034
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001035 return 0;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001036}
1037
1038static struct p9_trans_module p9_tcp_trans = {
1039 .name = "tcp",
1040 .maxsize = MAX_SOCK_BUF,
Eric Van Hensbergenf94741f2013-11-12 10:20:03 -06001041 .def = 0,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001042 .create = p9_fd_create_tcp,
1043 .close = p9_fd_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -05001044 .request = p9_fd_request,
1045 .cancel = p9_fd_cancel,
Simon Derrafd8d652014-03-10 16:38:49 +01001046 .cancelled = p9_fd_cancelled,
Tejun Heo72029fe2008-09-24 16:22:23 -05001047 .owner = THIS_MODULE,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001048};
1049
1050static struct p9_trans_module p9_unix_trans = {
1051 .name = "unix",
1052 .maxsize = MAX_SOCK_BUF,
1053 .def = 0,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001054 .create = p9_fd_create_unix,
1055 .close = p9_fd_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -05001056 .request = p9_fd_request,
1057 .cancel = p9_fd_cancel,
Simon Derrafd8d652014-03-10 16:38:49 +01001058 .cancelled = p9_fd_cancelled,
Tejun Heo72029fe2008-09-24 16:22:23 -05001059 .owner = THIS_MODULE,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001060};
1061
1062static struct p9_trans_module p9_fd_trans = {
1063 .name = "fd",
1064 .maxsize = MAX_SOCK_BUF,
1065 .def = 0,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -05001066 .create = p9_fd_create,
1067 .close = p9_fd_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -05001068 .request = p9_fd_request,
1069 .cancel = p9_fd_cancel,
Simon Derrafd8d652014-03-10 16:38:49 +01001070 .cancelled = p9_fd_cancelled,
Tejun Heo72029fe2008-09-24 16:22:23 -05001071 .owner = THIS_MODULE,
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001072};
1073
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001074/**
1075 * p9_poll_proc - poll worker thread
1076 * @a: thread state and arguments
1077 *
1078 * polls all v9fs transports for new events and queues the appropriate
1079 * work to the work queue
1080 *
1081 */
1082
Tejun Heoaa70c582011-02-01 11:42:43 +01001083static void p9_poll_workfn(struct work_struct *work)
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001084{
1085 unsigned long flags;
1086
Joe Perches5d385152011-11-28 10:40:46 -08001087 p9_debug(P9_DEBUG_TRANS, "start %p\n", current);
Tejun Heoaa70c582011-02-01 11:42:43 +01001088
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001089 spin_lock_irqsave(&p9_poll_lock, flags);
1090 while (!list_empty(&p9_poll_pending_list)) {
1091 struct p9_conn *conn = list_first_entry(&p9_poll_pending_list,
1092 struct p9_conn,
1093 poll_pending_link);
1094 list_del_init(&conn->poll_pending_link);
1095 spin_unlock_irqrestore(&p9_poll_lock, flags);
1096
1097 p9_poll_mux(conn);
1098
1099 spin_lock_irqsave(&p9_poll_lock, flags);
1100 }
1101 spin_unlock_irqrestore(&p9_poll_lock, flags);
1102
Joe Perches5d385152011-11-28 10:40:46 -08001103 p9_debug(P9_DEBUG_TRANS, "finish\n");
Eric Van Hensbergen5503ac52008-10-13 18:45:24 -05001104}
1105
Eric Van Hensbergen887b3ec2008-05-08 20:26:37 -05001106int p9_trans_fd_init(void)
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001107{
1108 v9fs_register_trans(&p9_tcp_trans);
1109 v9fs_register_trans(&p9_unix_trans);
1110 v9fs_register_trans(&p9_fd_trans);
1111
Andrew Morton3387b802008-03-28 14:15:57 -07001112 return 0;
Eric Van Hensbergena80d9232007-10-17 14:31:07 -05001113}
Tejun Heo72029fe2008-09-24 16:22:23 -05001114
1115void p9_trans_fd_exit(void)
1116{
Tejun Heo43829732012-08-20 14:51:24 -07001117 flush_work(&p9_poll_work);
Tejun Heo72029fe2008-09-24 16:22:23 -05001118 v9fs_unregister_trans(&p9_tcp_trans);
1119 v9fs_unregister_trans(&p9_unix_trans);
1120 v9fs_unregister_trans(&p9_fd_trans);
1121}