trans_fd.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363
  1. /*
  2. * linux/fs/9p/trans_fd.c
  3. *
  4. * Fd transport layer. Includes deprecated socket layer.
  5. *
  6. * Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
  7. * Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
  8. * Copyright (C) 2004-2005 by Eric Van Hensbergen <ericvh@gmail.com>
  9. * Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
  10. *
  11. * This program is free software; you can redistribute it and/or modify
  12. * it under the terms of the GNU General Public License version 2
  13. * as published by the Free Software Foundation.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to:
  22. * Free Software Foundation
  23. * 51 Franklin Street, Fifth Floor
  24. * Boston, MA 02111-1301 USA
  25. *
  26. */
  27. #include <linux/in.h>
  28. #include <linux/module.h>
  29. #include <linux/net.h>
  30. #include <linux/ipv6.h>
  31. #include <linux/errno.h>
  32. #include <linux/kernel.h>
  33. #include <linux/un.h>
  34. #include <linux/uaccess.h>
  35. #include <linux/inet.h>
  36. #include <linux/idr.h>
  37. #include <linux/file.h>
  38. #include <net/9p/9p.h>
  39. #include <net/9p/transport.h>
  40. #define P9_PORT 564
  41. struct p9_trans_fd {
  42. struct file *rd;
  43. struct file *wr;
  44. };
  45. static int p9_socket_open(struct p9_transport *trans, struct socket *csocket);
  46. static int p9_fd_open(struct p9_transport *trans, int rfd, int wfd);
  47. static int p9_fd_read(struct p9_transport *trans, void *v, int len);
  48. static int p9_fd_write(struct p9_transport *trans, void *v, int len);
  49. static unsigned int p9_fd_poll(struct p9_transport *trans,
  50. struct poll_table_struct *pt);
  51. static void p9_fd_close(struct p9_transport *trans);
  52. struct p9_transport *p9_trans_create_tcp(const char *addr, int port)
  53. {
  54. int err;
  55. struct p9_transport *trans;
  56. struct socket *csocket;
  57. struct sockaddr_in sin_server;
  58. csocket = NULL;
  59. trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
  60. if (!trans)
  61. return ERR_PTR(-ENOMEM);
  62. trans->write = p9_fd_write;
  63. trans->read = p9_fd_read;
  64. trans->close = p9_fd_close;
  65. trans->poll = p9_fd_poll;
  66. sin_server.sin_family = AF_INET;
  67. sin_server.sin_addr.s_addr = in_aton(addr);
  68. sin_server.sin_port = htons(port);
  69. sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
  70. if (!csocket) {
  71. P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
  72. err = -EIO;
  73. goto error;
  74. }
  75. err = csocket->ops->connect(csocket,
  76. (struct sockaddr *)&sin_server,
  77. sizeof(struct sockaddr_in), 0);
  78. if (err < 0) {
  79. P9_EPRINTK(KERN_ERR,
  80. "p9_trans_tcp: problem connecting socket to %s\n",
  81. addr);
  82. goto error;
  83. }
  84. err = p9_socket_open(trans, csocket);
  85. if (err < 0)
  86. goto error;
  87. return trans;
  88. error:
  89. if (csocket)
  90. sock_release(csocket);
  91. kfree(trans);
  92. return ERR_PTR(err);
  93. }
  94. EXPORT_SYMBOL(p9_trans_create_tcp);
  95. struct p9_transport *p9_trans_create_unix(const char *addr)
  96. {
  97. int err;
  98. struct socket *csocket;
  99. struct sockaddr_un sun_server;
  100. struct p9_transport *trans;
  101. csocket = NULL;
  102. trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
  103. if (!trans)
  104. return ERR_PTR(-ENOMEM);
  105. trans->write = p9_fd_write;
  106. trans->read = p9_fd_read;
  107. trans->close = p9_fd_close;
  108. trans->poll = p9_fd_poll;
  109. if (strlen(addr) > UNIX_PATH_MAX) {
  110. P9_EPRINTK(KERN_ERR, "p9_trans_unix: address too long: %s\n",
  111. addr);
  112. err = -ENAMETOOLONG;
  113. goto error;
  114. }
  115. sun_server.sun_family = PF_UNIX;
  116. strcpy(sun_server.sun_path, addr);
  117. sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
  118. err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
  119. sizeof(struct sockaddr_un) - 1, 0);
  120. if (err < 0) {
  121. P9_EPRINTK(KERN_ERR,
  122. "p9_trans_unix: problem connecting socket: %s: %d\n",
  123. addr, err);
  124. goto error;
  125. }
  126. err = p9_socket_open(trans, csocket);
  127. if (err < 0)
  128. goto error;
  129. return trans;
  130. error:
  131. if (csocket)
  132. sock_release(csocket);
  133. kfree(trans);
  134. return ERR_PTR(err);
  135. }
  136. EXPORT_SYMBOL(p9_trans_create_unix);
  137. struct p9_transport *p9_trans_create_fd(int rfd, int wfd)
  138. {
  139. int err;
  140. struct p9_transport *trans;
  141. if (rfd == ~0 || wfd == ~0) {
  142. printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
  143. return ERR_PTR(-ENOPROTOOPT);
  144. }
  145. trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
  146. if (!trans)
  147. return ERR_PTR(-ENOMEM);
  148. trans->write = p9_fd_write;
  149. trans->read = p9_fd_read;
  150. trans->close = p9_fd_close;
  151. trans->poll = p9_fd_poll;
  152. err = p9_fd_open(trans, rfd, wfd);
  153. if (err < 0)
  154. goto error;
  155. return trans;
  156. error:
  157. kfree(trans);
  158. return ERR_PTR(err);
  159. }
  160. EXPORT_SYMBOL(p9_trans_create_fd);
  161. static int p9_socket_open(struct p9_transport *trans, struct socket *csocket)
  162. {
  163. int fd, ret;
  164. csocket->sk->sk_allocation = GFP_NOIO;
  165. fd = sock_map_fd(csocket);
  166. if (fd < 0) {
  167. P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
  168. return fd;
  169. }
  170. ret = p9_fd_open(trans, fd, fd);
  171. if (ret < 0) {
  172. P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd\n");
  173. sockfd_put(csocket);
  174. return ret;
  175. }
  176. ((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;
  177. return 0;
  178. }
  179. static int p9_fd_open(struct p9_transport *trans, int rfd, int wfd)
  180. {
  181. struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
  182. GFP_KERNEL);
  183. if (!ts)
  184. return -ENOMEM;
  185. ts->rd = fget(rfd);
  186. ts->wr = fget(wfd);
  187. if (!ts->rd || !ts->wr) {
  188. if (ts->rd)
  189. fput(ts->rd);
  190. if (ts->wr)
  191. fput(ts->wr);
  192. kfree(ts);
  193. return -EIO;
  194. }
  195. trans->priv = ts;
  196. trans->status = Connected;
  197. return 0;
  198. }
  199. /**
  200. * p9_fd_read- read from a fd
  201. * @v9ses: session information
  202. * @v: buffer to receive data into
  203. * @len: size of receive buffer
  204. *
  205. */
  206. static int p9_fd_read(struct p9_transport *trans, void *v, int len)
  207. {
  208. int ret;
  209. struct p9_trans_fd *ts = NULL;
  210. if (trans && trans->status != Disconnected)
  211. ts = trans->priv;
  212. if (!ts)
  213. return -EREMOTEIO;
  214. if (!(ts->rd->f_flags & O_NONBLOCK))
  215. P9_DPRINTK(P9_DEBUG_ERROR, "blocking read ...\n");
  216. ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
  217. if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
  218. trans->status = Disconnected;
  219. return ret;
  220. }
  221. /**
  222. * p9_fd_write - write to a socket
  223. * @v9ses: session information
  224. * @v: buffer to send data from
  225. * @len: size of send buffer
  226. *
  227. */
  228. static int p9_fd_write(struct p9_transport *trans, void *v, int len)
  229. {
  230. int ret;
  231. mm_segment_t oldfs;
  232. struct p9_trans_fd *ts = NULL;
  233. if (trans && trans->status != Disconnected)
  234. ts = trans->priv;
  235. if (!ts)
  236. return -EREMOTEIO;
  237. if (!(ts->wr->f_flags & O_NONBLOCK))
  238. P9_DPRINTK(P9_DEBUG_ERROR, "blocking write ...\n");
  239. oldfs = get_fs();
  240. set_fs(get_ds());
  241. /* The cast to a user pointer is valid due to the set_fs() */
  242. ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
  243. set_fs(oldfs);
  244. if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
  245. trans->status = Disconnected;
  246. return ret;
  247. }
  248. static unsigned int
  249. p9_fd_poll(struct p9_transport *trans, struct poll_table_struct *pt)
  250. {
  251. int ret, n;
  252. struct p9_trans_fd *ts = NULL;
  253. mm_segment_t oldfs;
  254. if (trans && trans->status == Connected)
  255. ts = trans->priv;
  256. if (!ts)
  257. return -EREMOTEIO;
  258. if (!ts->rd->f_op || !ts->rd->f_op->poll)
  259. return -EIO;
  260. if (!ts->wr->f_op || !ts->wr->f_op->poll)
  261. return -EIO;
  262. oldfs = get_fs();
  263. set_fs(get_ds());
  264. ret = ts->rd->f_op->poll(ts->rd, pt);
  265. if (ret < 0)
  266. goto end;
  267. if (ts->rd != ts->wr) {
  268. n = ts->wr->f_op->poll(ts->wr, pt);
  269. if (n < 0) {
  270. ret = n;
  271. goto end;
  272. }
  273. ret = (ret & ~POLLOUT) | (n & ~POLLIN);
  274. }
  275. end:
  276. set_fs(oldfs);
  277. return ret;
  278. }
  279. /**
  280. * p9_sock_close - shutdown socket
  281. * @trans: private socket structure
  282. *
  283. */
  284. static void p9_fd_close(struct p9_transport *trans)
  285. {
  286. struct p9_trans_fd *ts;
  287. if (!trans)
  288. return;
  289. ts = xchg(&trans->priv, NULL);
  290. if (!ts)
  291. return;
  292. trans->status = Disconnected;
  293. if (ts->rd)
  294. fput(ts->rd);
  295. if (ts->wr)
  296. fput(ts->wr);
  297. kfree(ts);
  298. }