protocol.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * net/9p/protocol.c
  4. *
  5. * 9P Protocol Support Code
  6. *
  7. * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
  8. *
  9. * Base on code from Anthony Liguori <aliguori@us.ibm.com>
  10. * Copyright (C) 2008 by IBM, Corp.
  11. */
  12. #include <linux/module.h>
  13. #include <linux/errno.h>
  14. #include <linux/kernel.h>
  15. #include <linux/uaccess.h>
  16. #include <linux/slab.h>
  17. #include <linux/sched.h>
  18. #include <linux/stddef.h>
  19. #include <linux/types.h>
  20. #include <linux/uio.h>
  21. #include <net/9p/9p.h>
  22. #include <net/9p/client.h>
  23. #include "protocol.h"
  24. #include <trace/events/9p.h>
  25. static int
  26. p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
  27. void p9stat_free(struct p9_wstat *stbuf)
  28. {
  29. kfree(stbuf->name);
  30. stbuf->name = NULL;
  31. kfree(stbuf->uid);
  32. stbuf->uid = NULL;
  33. kfree(stbuf->gid);
  34. stbuf->gid = NULL;
  35. kfree(stbuf->muid);
  36. stbuf->muid = NULL;
  37. kfree(stbuf->extension);
  38. stbuf->extension = NULL;
  39. }
  40. EXPORT_SYMBOL(p9stat_free);
  41. size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
  42. {
  43. size_t len = min(pdu->size - pdu->offset, size);
  44. memcpy(data, &pdu->sdata[pdu->offset], len);
  45. pdu->offset += len;
  46. return size - len;
  47. }
  48. static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
  49. {
  50. size_t len = min(pdu->capacity - pdu->size, size);
  51. memcpy(&pdu->sdata[pdu->size], data, len);
  52. pdu->size += len;
  53. return size - len;
  54. }
  55. static size_t
  56. pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size)
  57. {
  58. size_t len = min(pdu->capacity - pdu->size, size);
  59. struct iov_iter i = *from;
  60. if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, &i))
  61. len = 0;
  62. pdu->size += len;
  63. return size - len;
  64. }
  65. /*
  66. b - int8_t
  67. w - int16_t
  68. d - int32_t
  69. q - int64_t
  70. s - string
  71. u - numeric uid
  72. g - numeric gid
  73. S - stat
  74. Q - qid
  75. D - data blob (int32_t size followed by void *, results are not freed)
  76. T - array of strings (int16_t count, followed by strings)
  77. R - array of qids (int16_t count, followed by qids)
  78. A - stat for 9p2000.L (p9_stat_dotl)
  79. ? - if optional = 1, continue parsing
  80. */
  81. static int
  82. p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
  83. va_list ap)
  84. {
  85. const char *ptr;
  86. int errcode = 0;
  87. for (ptr = fmt; *ptr; ptr++) {
  88. switch (*ptr) {
  89. case 'b':{
  90. int8_t *val = va_arg(ap, int8_t *);
  91. if (pdu_read(pdu, val, sizeof(*val))) {
  92. errcode = -EFAULT;
  93. break;
  94. }
  95. }
  96. break;
  97. case 'w':{
  98. int16_t *val = va_arg(ap, int16_t *);
  99. __le16 le_val;
  100. if (pdu_read(pdu, &le_val, sizeof(le_val))) {
  101. errcode = -EFAULT;
  102. break;
  103. }
  104. *val = le16_to_cpu(le_val);
  105. }
  106. break;
  107. case 'd':{
  108. int32_t *val = va_arg(ap, int32_t *);
  109. __le32 le_val;
  110. if (pdu_read(pdu, &le_val, sizeof(le_val))) {
  111. errcode = -EFAULT;
  112. break;
  113. }
  114. *val = le32_to_cpu(le_val);
  115. }
  116. break;
  117. case 'q':{
  118. int64_t *val = va_arg(ap, int64_t *);
  119. __le64 le_val;
  120. if (pdu_read(pdu, &le_val, sizeof(le_val))) {
  121. errcode = -EFAULT;
  122. break;
  123. }
  124. *val = le64_to_cpu(le_val);
  125. }
  126. break;
  127. case 's':{
  128. char **sptr = va_arg(ap, char **);
  129. uint16_t len;
  130. errcode = p9pdu_readf(pdu, proto_version,
  131. "w", &len);
  132. if (errcode)
  133. break;
  134. *sptr = kmalloc(len + 1, GFP_NOFS);
  135. if (*sptr == NULL) {
  136. errcode = -ENOMEM;
  137. break;
  138. }
  139. if (pdu_read(pdu, *sptr, len)) {
  140. errcode = -EFAULT;
  141. kfree(*sptr);
  142. *sptr = NULL;
  143. } else
  144. (*sptr)[len] = 0;
  145. }
  146. break;
  147. case 'u': {
  148. kuid_t *uid = va_arg(ap, kuid_t *);
  149. __le32 le_val;
  150. if (pdu_read(pdu, &le_val, sizeof(le_val))) {
  151. errcode = -EFAULT;
  152. break;
  153. }
  154. *uid = make_kuid(&init_user_ns,
  155. le32_to_cpu(le_val));
  156. } break;
  157. case 'g': {
  158. kgid_t *gid = va_arg(ap, kgid_t *);
  159. __le32 le_val;
  160. if (pdu_read(pdu, &le_val, sizeof(le_val))) {
  161. errcode = -EFAULT;
  162. break;
  163. }
  164. *gid = make_kgid(&init_user_ns,
  165. le32_to_cpu(le_val));
  166. } break;
  167. case 'Q':{
  168. struct p9_qid *qid =
  169. va_arg(ap, struct p9_qid *);
  170. errcode = p9pdu_readf(pdu, proto_version, "bdq",
  171. &qid->type, &qid->version,
  172. &qid->path);
  173. }
  174. break;
  175. case 'S':{
  176. struct p9_wstat *stbuf =
  177. va_arg(ap, struct p9_wstat *);
  178. memset(stbuf, 0, sizeof(struct p9_wstat));
  179. stbuf->n_uid = stbuf->n_muid = INVALID_UID;
  180. stbuf->n_gid = INVALID_GID;
  181. errcode =
  182. p9pdu_readf(pdu, proto_version,
  183. "wwdQdddqssss?sugu",
  184. &stbuf->size, &stbuf->type,
  185. &stbuf->dev, &stbuf->qid,
  186. &stbuf->mode, &stbuf->atime,
  187. &stbuf->mtime, &stbuf->length,
  188. &stbuf->name, &stbuf->uid,
  189. &stbuf->gid, &stbuf->muid,
  190. &stbuf->extension,
  191. &stbuf->n_uid, &stbuf->n_gid,
  192. &stbuf->n_muid);
  193. if (errcode)
  194. p9stat_free(stbuf);
  195. }
  196. break;
  197. case 'D':{
  198. uint32_t *count = va_arg(ap, uint32_t *);
  199. void **data = va_arg(ap, void **);
  200. errcode =
  201. p9pdu_readf(pdu, proto_version, "d", count);
  202. if (!errcode) {
  203. *count =
  204. min_t(uint32_t, *count,
  205. pdu->size - pdu->offset);
  206. *data = &pdu->sdata[pdu->offset];
  207. }
  208. }
  209. break;
  210. case 'T':{
  211. uint16_t *nwname = va_arg(ap, uint16_t *);
  212. char ***wnames = va_arg(ap, char ***);
  213. errcode = p9pdu_readf(pdu, proto_version,
  214. "w", nwname);
  215. if (!errcode) {
  216. *wnames =
  217. kmalloc_array(*nwname,
  218. sizeof(char *),
  219. GFP_NOFS);
  220. if (!*wnames)
  221. errcode = -ENOMEM;
  222. }
  223. if (!errcode) {
  224. int i;
  225. for (i = 0; i < *nwname; i++) {
  226. errcode =
  227. p9pdu_readf(pdu,
  228. proto_version,
  229. "s",
  230. &(*wnames)[i]);
  231. if (errcode)
  232. break;
  233. }
  234. }
  235. if (errcode) {
  236. if (*wnames) {
  237. int i;
  238. for (i = 0; i < *nwname; i++)
  239. kfree((*wnames)[i]);
  240. }
  241. kfree(*wnames);
  242. *wnames = NULL;
  243. }
  244. }
  245. break;
  246. case 'R':{
  247. uint16_t *nwqid = va_arg(ap, uint16_t *);
  248. struct p9_qid **wqids =
  249. va_arg(ap, struct p9_qid **);
  250. *wqids = NULL;
  251. errcode =
  252. p9pdu_readf(pdu, proto_version, "w", nwqid);
  253. if (!errcode) {
  254. *wqids =
  255. kmalloc_array(*nwqid,
  256. sizeof(struct p9_qid),
  257. GFP_NOFS);
  258. if (*wqids == NULL)
  259. errcode = -ENOMEM;
  260. }
  261. if (!errcode) {
  262. int i;
  263. for (i = 0; i < *nwqid; i++) {
  264. errcode =
  265. p9pdu_readf(pdu,
  266. proto_version,
  267. "Q",
  268. &(*wqids)[i]);
  269. if (errcode)
  270. break;
  271. }
  272. }
  273. if (errcode) {
  274. kfree(*wqids);
  275. *wqids = NULL;
  276. }
  277. }
  278. break;
  279. case 'A': {
  280. struct p9_stat_dotl *stbuf =
  281. va_arg(ap, struct p9_stat_dotl *);
  282. memset(stbuf, 0, sizeof(struct p9_stat_dotl));
  283. errcode =
  284. p9pdu_readf(pdu, proto_version,
  285. "qQdugqqqqqqqqqqqqqqq",
  286. &stbuf->st_result_mask,
  287. &stbuf->qid,
  288. &stbuf->st_mode,
  289. &stbuf->st_uid, &stbuf->st_gid,
  290. &stbuf->st_nlink,
  291. &stbuf->st_rdev, &stbuf->st_size,
  292. &stbuf->st_blksize, &stbuf->st_blocks,
  293. &stbuf->st_atime_sec,
  294. &stbuf->st_atime_nsec,
  295. &stbuf->st_mtime_sec,
  296. &stbuf->st_mtime_nsec,
  297. &stbuf->st_ctime_sec,
  298. &stbuf->st_ctime_nsec,
  299. &stbuf->st_btime_sec,
  300. &stbuf->st_btime_nsec,
  301. &stbuf->st_gen,
  302. &stbuf->st_data_version);
  303. }
  304. break;
  305. case '?':
  306. if ((proto_version != p9_proto_2000u) &&
  307. (proto_version != p9_proto_2000L))
  308. return 0;
  309. break;
  310. default:
  311. BUG();
  312. break;
  313. }
  314. if (errcode)
  315. break;
  316. }
  317. return errcode;
  318. }
  319. int
  320. p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
  321. va_list ap)
  322. {
  323. const char *ptr;
  324. int errcode = 0;
  325. for (ptr = fmt; *ptr; ptr++) {
  326. switch (*ptr) {
  327. case 'b':{
  328. int8_t val = va_arg(ap, int);
  329. if (pdu_write(pdu, &val, sizeof(val)))
  330. errcode = -EFAULT;
  331. }
  332. break;
  333. case 'w':{
  334. __le16 val = cpu_to_le16(va_arg(ap, int));
  335. if (pdu_write(pdu, &val, sizeof(val)))
  336. errcode = -EFAULT;
  337. }
  338. break;
  339. case 'd':{
  340. __le32 val = cpu_to_le32(va_arg(ap, int32_t));
  341. if (pdu_write(pdu, &val, sizeof(val)))
  342. errcode = -EFAULT;
  343. }
  344. break;
  345. case 'q':{
  346. __le64 val = cpu_to_le64(va_arg(ap, int64_t));
  347. if (pdu_write(pdu, &val, sizeof(val)))
  348. errcode = -EFAULT;
  349. }
  350. break;
  351. case 's':{
  352. const char *sptr = va_arg(ap, const char *);
  353. uint16_t len = 0;
  354. if (sptr)
  355. len = min_t(size_t, strlen(sptr),
  356. USHRT_MAX);
  357. errcode = p9pdu_writef(pdu, proto_version,
  358. "w", len);
  359. if (!errcode && pdu_write(pdu, sptr, len))
  360. errcode = -EFAULT;
  361. }
  362. break;
  363. case 'u': {
  364. kuid_t uid = va_arg(ap, kuid_t);
  365. __le32 val = cpu_to_le32(
  366. from_kuid(&init_user_ns, uid));
  367. if (pdu_write(pdu, &val, sizeof(val)))
  368. errcode = -EFAULT;
  369. } break;
  370. case 'g': {
  371. kgid_t gid = va_arg(ap, kgid_t);
  372. __le32 val = cpu_to_le32(
  373. from_kgid(&init_user_ns, gid));
  374. if (pdu_write(pdu, &val, sizeof(val)))
  375. errcode = -EFAULT;
  376. } break;
  377. case 'Q':{
  378. const struct p9_qid *qid =
  379. va_arg(ap, const struct p9_qid *);
  380. errcode =
  381. p9pdu_writef(pdu, proto_version, "bdq",
  382. qid->type, qid->version,
  383. qid->path);
  384. } break;
  385. case 'S':{
  386. const struct p9_wstat *stbuf =
  387. va_arg(ap, const struct p9_wstat *);
  388. errcode =
  389. p9pdu_writef(pdu, proto_version,
  390. "wwdQdddqssss?sugu",
  391. stbuf->size, stbuf->type,
  392. stbuf->dev, &stbuf->qid,
  393. stbuf->mode, stbuf->atime,
  394. stbuf->mtime, stbuf->length,
  395. stbuf->name, stbuf->uid,
  396. stbuf->gid, stbuf->muid,
  397. stbuf->extension, stbuf->n_uid,
  398. stbuf->n_gid, stbuf->n_muid);
  399. } break;
  400. case 'V':{
  401. uint32_t count = va_arg(ap, uint32_t);
  402. struct iov_iter *from =
  403. va_arg(ap, struct iov_iter *);
  404. errcode = p9pdu_writef(pdu, proto_version, "d",
  405. count);
  406. if (!errcode && pdu_write_u(pdu, from, count))
  407. errcode = -EFAULT;
  408. }
  409. break;
  410. case 'T':{
  411. uint16_t nwname = va_arg(ap, int);
  412. const char **wnames = va_arg(ap, const char **);
  413. errcode = p9pdu_writef(pdu, proto_version, "w",
  414. nwname);
  415. if (!errcode) {
  416. int i;
  417. for (i = 0; i < nwname; i++) {
  418. errcode =
  419. p9pdu_writef(pdu,
  420. proto_version,
  421. "s",
  422. wnames[i]);
  423. if (errcode)
  424. break;
  425. }
  426. }
  427. }
  428. break;
  429. case 'R':{
  430. uint16_t nwqid = va_arg(ap, int);
  431. struct p9_qid *wqids =
  432. va_arg(ap, struct p9_qid *);
  433. errcode = p9pdu_writef(pdu, proto_version, "w",
  434. nwqid);
  435. if (!errcode) {
  436. int i;
  437. for (i = 0; i < nwqid; i++) {
  438. errcode =
  439. p9pdu_writef(pdu,
  440. proto_version,
  441. "Q",
  442. &wqids[i]);
  443. if (errcode)
  444. break;
  445. }
  446. }
  447. }
  448. break;
  449. case 'I':{
  450. struct p9_iattr_dotl *p9attr = va_arg(ap,
  451. struct p9_iattr_dotl *);
  452. errcode = p9pdu_writef(pdu, proto_version,
  453. "ddugqqqqq",
  454. p9attr->valid,
  455. p9attr->mode,
  456. p9attr->uid,
  457. p9attr->gid,
  458. p9attr->size,
  459. p9attr->atime_sec,
  460. p9attr->atime_nsec,
  461. p9attr->mtime_sec,
  462. p9attr->mtime_nsec);
  463. }
  464. break;
  465. case '?':
  466. if ((proto_version != p9_proto_2000u) &&
  467. (proto_version != p9_proto_2000L))
  468. return 0;
  469. break;
  470. default:
  471. BUG();
  472. break;
  473. }
  474. if (errcode)
  475. break;
  476. }
  477. return errcode;
  478. }
  479. int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
  480. {
  481. va_list ap;
  482. int ret;
  483. va_start(ap, fmt);
  484. ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
  485. va_end(ap);
  486. return ret;
  487. }
  488. static int
  489. p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
  490. {
  491. va_list ap;
  492. int ret;
  493. va_start(ap, fmt);
  494. ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
  495. va_end(ap);
  496. return ret;
  497. }
  498. int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
  499. {
  500. struct p9_fcall fake_pdu;
  501. int ret;
  502. fake_pdu.size = len;
  503. fake_pdu.capacity = len;
  504. fake_pdu.sdata = buf;
  505. fake_pdu.offset = 0;
  506. ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
  507. if (ret) {
  508. p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
  509. trace_9p_protocol_dump(clnt, &fake_pdu);
  510. return ret;
  511. }
  512. return fake_pdu.offset;
  513. }
  514. EXPORT_SYMBOL(p9stat_read);
  515. int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
  516. {
  517. pdu->id = type;
  518. return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
  519. }
  520. int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
  521. {
  522. int size = pdu->size;
  523. int err;
  524. pdu->size = 0;
  525. err = p9pdu_writef(pdu, 0, "d", size);
  526. pdu->size = size;
  527. trace_9p_protocol_dump(clnt, pdu);
  528. p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
  529. pdu->size, pdu->id, pdu->tag);
  530. return err;
  531. }
  532. void p9pdu_reset(struct p9_fcall *pdu)
  533. {
  534. pdu->offset = 0;
  535. pdu->size = 0;
  536. }
  537. int p9dirent_read(struct p9_client *clnt, char *buf, int len,
  538. struct p9_dirent *dirent)
  539. {
  540. struct p9_fcall fake_pdu;
  541. int ret;
  542. char *nameptr;
  543. fake_pdu.size = len;
  544. fake_pdu.capacity = len;
  545. fake_pdu.sdata = buf;
  546. fake_pdu.offset = 0;
  547. ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
  548. &dirent->d_off, &dirent->d_type, &nameptr);
  549. if (ret) {
  550. p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
  551. trace_9p_protocol_dump(clnt, &fake_pdu);
  552. return ret;
  553. }
  554. ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
  555. if (ret < 0) {
  556. p9_debug(P9_DEBUG_ERROR,
  557. "On the wire dirent name too long: %s\n",
  558. nameptr);
  559. kfree(nameptr);
  560. return ret;
  561. }
  562. kfree(nameptr);
  563. return fake_pdu.offset;
  564. }
  565. EXPORT_SYMBOL(p9dirent_read);