trans_fd.c 26 KB

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