client.c 53 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * net/9p/clnt.c
  4. *
  5. * 9P Client
  6. *
  7. * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
  8. * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
  9. */
  10. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11. #include <linux/module.h>
  12. #include <linux/errno.h>
  13. #include <linux/fs.h>
  14. #include <linux/poll.h>
  15. #include <linux/idr.h>
  16. #include <linux/mutex.h>
  17. #include <linux/slab.h>
  18. #include <linux/sched/signal.h>
  19. #include <linux/uaccess.h>
  20. #include <linux/uio.h>
  21. #include <net/9p/9p.h>
  22. #include <linux/parser.h>
  23. #include <linux/seq_file.h>
  24. #include <net/9p/client.h>
  25. #include <net/9p/transport.h>
  26. #include "protocol.h"
  27. #define CREATE_TRACE_POINTS
  28. #include <trace/events/9p.h>
  29. /*
  30. * Client Option Parsing (code inspired by NFS code)
  31. * - a little lazy - parse all client options
  32. */
  33. enum {
  34. Opt_msize,
  35. Opt_trans,
  36. Opt_legacy,
  37. Opt_version,
  38. Opt_err,
  39. };
  40. static const match_table_t tokens = {
  41. {Opt_msize, "msize=%u"},
  42. {Opt_legacy, "noextend"},
  43. {Opt_trans, "trans=%s"},
  44. {Opt_version, "version=%s"},
  45. {Opt_err, NULL},
  46. };
  47. inline int p9_is_proto_dotl(struct p9_client *clnt)
  48. {
  49. return clnt->proto_version == p9_proto_2000L;
  50. }
  51. EXPORT_SYMBOL(p9_is_proto_dotl);
  52. inline int p9_is_proto_dotu(struct p9_client *clnt)
  53. {
  54. return clnt->proto_version == p9_proto_2000u;
  55. }
  56. EXPORT_SYMBOL(p9_is_proto_dotu);
  57. int p9_show_client_options(struct seq_file *m, struct p9_client *clnt)
  58. {
  59. if (clnt->msize != 8192)
  60. seq_printf(m, ",msize=%u", clnt->msize);
  61. seq_printf(m, ",trans=%s", clnt->trans_mod->name);
  62. switch (clnt->proto_version) {
  63. case p9_proto_legacy:
  64. seq_puts(m, ",noextend");
  65. break;
  66. case p9_proto_2000u:
  67. seq_puts(m, ",version=9p2000.u");
  68. break;
  69. case p9_proto_2000L:
  70. /* Default */
  71. break;
  72. }
  73. if (clnt->trans_mod->show_options)
  74. return clnt->trans_mod->show_options(m, clnt);
  75. return 0;
  76. }
  77. EXPORT_SYMBOL(p9_show_client_options);
  78. /*
  79. * Some error codes are taken directly from the server replies,
  80. * make sure they are valid.
  81. */
  82. static int safe_errno(int err)
  83. {
  84. if ((err > 0) || (err < -MAX_ERRNO)) {
  85. p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err);
  86. return -EPROTO;
  87. }
  88. return err;
  89. }
  90. /* Interpret mount option for protocol version */
  91. static int get_protocol_version(char *s)
  92. {
  93. int version = -EINVAL;
  94. if (!strcmp(s, "9p2000")) {
  95. version = p9_proto_legacy;
  96. p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n");
  97. } else if (!strcmp(s, "9p2000.u")) {
  98. version = p9_proto_2000u;
  99. p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
  100. } else if (!strcmp(s, "9p2000.L")) {
  101. version = p9_proto_2000L;
  102. p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
  103. } else
  104. pr_info("Unknown protocol version %s\n", s);
  105. return version;
  106. }
  107. /**
  108. * parse_options - parse mount options into client structure
  109. * @opts: options string passed from mount
  110. * @clnt: existing v9fs client information
  111. *
  112. * Return 0 upon success, -ERRNO upon failure
  113. */
  114. static int parse_opts(char *opts, struct p9_client *clnt)
  115. {
  116. char *options, *tmp_options;
  117. char *p;
  118. substring_t args[MAX_OPT_ARGS];
  119. int option;
  120. char *s;
  121. int ret = 0;
  122. clnt->proto_version = p9_proto_2000L;
  123. clnt->msize = 8192;
  124. if (!opts)
  125. return 0;
  126. tmp_options = kstrdup(opts, GFP_KERNEL);
  127. if (!tmp_options) {
  128. p9_debug(P9_DEBUG_ERROR,
  129. "failed to allocate copy of option string\n");
  130. return -ENOMEM;
  131. }
  132. options = tmp_options;
  133. while ((p = strsep(&options, ",")) != NULL) {
  134. int token, r;
  135. if (!*p)
  136. continue;
  137. token = match_token(p, tokens, args);
  138. switch (token) {
  139. case Opt_msize:
  140. r = match_int(&args[0], &option);
  141. if (r < 0) {
  142. p9_debug(P9_DEBUG_ERROR,
  143. "integer field, but no integer?\n");
  144. ret = r;
  145. continue;
  146. }
  147. if (option < 4096) {
  148. p9_debug(P9_DEBUG_ERROR,
  149. "msize should be at least 4k\n");
  150. ret = -EINVAL;
  151. continue;
  152. }
  153. clnt->msize = option;
  154. break;
  155. case Opt_trans:
  156. s = match_strdup(&args[0]);
  157. if (!s) {
  158. ret = -ENOMEM;
  159. p9_debug(P9_DEBUG_ERROR,
  160. "problem allocating copy of trans arg\n");
  161. goto free_and_return;
  162. }
  163. v9fs_put_trans(clnt->trans_mod);
  164. clnt->trans_mod = v9fs_get_trans_by_name(s);
  165. if (clnt->trans_mod == NULL) {
  166. pr_info("Could not find request transport: %s\n",
  167. s);
  168. ret = -EINVAL;
  169. }
  170. kfree(s);
  171. break;
  172. case Opt_legacy:
  173. clnt->proto_version = p9_proto_legacy;
  174. break;
  175. case Opt_version:
  176. s = match_strdup(&args[0]);
  177. if (!s) {
  178. ret = -ENOMEM;
  179. p9_debug(P9_DEBUG_ERROR,
  180. "problem allocating copy of version arg\n");
  181. goto free_and_return;
  182. }
  183. r = get_protocol_version(s);
  184. if (r < 0)
  185. ret = r;
  186. else
  187. clnt->proto_version = r;
  188. kfree(s);
  189. break;
  190. default:
  191. continue;
  192. }
  193. }
  194. free_and_return:
  195. if (ret)
  196. v9fs_put_trans(clnt->trans_mod);
  197. kfree(tmp_options);
  198. return ret;
  199. }
  200. static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc,
  201. int alloc_msize)
  202. {
  203. if (likely(c->fcall_cache) && alloc_msize == c->msize) {
  204. fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS);
  205. fc->cache = c->fcall_cache;
  206. } else {
  207. fc->sdata = kmalloc(alloc_msize, GFP_NOFS);
  208. fc->cache = NULL;
  209. }
  210. if (!fc->sdata)
  211. return -ENOMEM;
  212. fc->capacity = alloc_msize;
  213. return 0;
  214. }
  215. void p9_fcall_fini(struct p9_fcall *fc)
  216. {
  217. /* sdata can be NULL for interrupted requests in trans_rdma,
  218. * and kmem_cache_free does not do NULL-check for us
  219. */
  220. if (unlikely(!fc->sdata))
  221. return;
  222. if (fc->cache)
  223. kmem_cache_free(fc->cache, fc->sdata);
  224. else
  225. kfree(fc->sdata);
  226. }
  227. EXPORT_SYMBOL(p9_fcall_fini);
  228. static struct kmem_cache *p9_req_cache;
  229. /**
  230. * p9_req_alloc - Allocate a new request.
  231. * @c: Client session.
  232. * @type: Transaction type.
  233. * @max_size: Maximum packet size for this request.
  234. *
  235. * Context: Process context.
  236. * Return: Pointer to new request.
  237. */
  238. static struct p9_req_t *
  239. p9_tag_alloc(struct p9_client *c, int8_t type, unsigned int max_size)
  240. {
  241. struct p9_req_t *req = kmem_cache_alloc(p9_req_cache, GFP_NOFS);
  242. int alloc_msize = min(c->msize, max_size);
  243. int tag;
  244. if (!req)
  245. return ERR_PTR(-ENOMEM);
  246. if (p9_fcall_init(c, &req->tc, alloc_msize))
  247. goto free_req;
  248. if (p9_fcall_init(c, &req->rc, alloc_msize))
  249. goto free;
  250. p9pdu_reset(&req->tc);
  251. p9pdu_reset(&req->rc);
  252. req->t_err = 0;
  253. req->status = REQ_STATUS_ALLOC;
  254. init_waitqueue_head(&req->wq);
  255. INIT_LIST_HEAD(&req->req_list);
  256. idr_preload(GFP_NOFS);
  257. spin_lock_irq(&c->lock);
  258. if (type == P9_TVERSION)
  259. tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1,
  260. GFP_NOWAIT);
  261. else
  262. tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT);
  263. req->tc.tag = tag;
  264. spin_unlock_irq(&c->lock);
  265. idr_preload_end();
  266. if (tag < 0)
  267. goto free;
  268. /* Init ref to two because in the general case there is one ref
  269. * that is put asynchronously by a writer thread, one ref
  270. * temporarily given by p9_tag_lookup and put by p9_client_cb
  271. * in the recv thread, and one ref put by p9_tag_remove in the
  272. * main thread. The only exception is virtio that does not use
  273. * p9_tag_lookup but does not have a writer thread either
  274. * (the write happens synchronously in the request/zc_request
  275. * callback), so p9_client_cb eats the second ref there
  276. * as the pointer is duplicated directly by virtqueue_add_sgs()
  277. */
  278. refcount_set(&req->refcount.refcount, 2);
  279. return req;
  280. free:
  281. p9_fcall_fini(&req->tc);
  282. p9_fcall_fini(&req->rc);
  283. free_req:
  284. kmem_cache_free(p9_req_cache, req);
  285. return ERR_PTR(-ENOMEM);
  286. }
  287. /**
  288. * p9_tag_lookup - Look up a request by tag.
  289. * @c: Client session.
  290. * @tag: Transaction ID.
  291. *
  292. * Context: Any context.
  293. * Return: A request, or %NULL if there is no request with that tag.
  294. */
  295. struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
  296. {
  297. struct p9_req_t *req;
  298. rcu_read_lock();
  299. again:
  300. req = idr_find(&c->reqs, tag);
  301. if (req) {
  302. /* We have to be careful with the req found under rcu_read_lock
  303. * Thanks to SLAB_TYPESAFE_BY_RCU we can safely try to get the
  304. * ref again without corrupting other data, then check again
  305. * that the tag matches once we have the ref
  306. */
  307. if (!p9_req_try_get(req))
  308. goto again;
  309. if (req->tc.tag != tag) {
  310. p9_req_put(req);
  311. goto again;
  312. }
  313. }
  314. rcu_read_unlock();
  315. return req;
  316. }
  317. EXPORT_SYMBOL(p9_tag_lookup);
  318. /**
  319. * p9_tag_remove - Remove a tag.
  320. * @c: Client session.
  321. * @r: Request of reference.
  322. *
  323. * Context: Any context.
  324. */
  325. static int p9_tag_remove(struct p9_client *c, struct p9_req_t *r)
  326. {
  327. unsigned long flags;
  328. u16 tag = r->tc.tag;
  329. p9_debug(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
  330. spin_lock_irqsave(&c->lock, flags);
  331. idr_remove(&c->reqs, tag);
  332. spin_unlock_irqrestore(&c->lock, flags);
  333. return p9_req_put(r);
  334. }
  335. static void p9_req_free(struct kref *ref)
  336. {
  337. struct p9_req_t *r = container_of(ref, struct p9_req_t, refcount);
  338. p9_fcall_fini(&r->tc);
  339. p9_fcall_fini(&r->rc);
  340. kmem_cache_free(p9_req_cache, r);
  341. }
  342. int p9_req_put(struct p9_req_t *r)
  343. {
  344. return kref_put(&r->refcount, p9_req_free);
  345. }
  346. EXPORT_SYMBOL(p9_req_put);
  347. /**
  348. * p9_tag_cleanup - cleans up tags structure and reclaims resources
  349. * @c: v9fs client struct
  350. *
  351. * This frees resources associated with the tags structure
  352. *
  353. */
  354. static void p9_tag_cleanup(struct p9_client *c)
  355. {
  356. struct p9_req_t *req;
  357. int id;
  358. rcu_read_lock();
  359. idr_for_each_entry(&c->reqs, req, id) {
  360. pr_info("Tag %d still in use\n", id);
  361. if (p9_tag_remove(c, req) == 0)
  362. pr_warn("Packet with tag %d has still references",
  363. req->tc.tag);
  364. }
  365. rcu_read_unlock();
  366. }
  367. /**
  368. * p9_client_cb - call back from transport to client
  369. * c: client state
  370. * req: request received
  371. *
  372. */
  373. void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status)
  374. {
  375. p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag);
  376. /*
  377. * This barrier is needed to make sure any change made to req before
  378. * the status change is visible to another thread
  379. */
  380. smp_wmb();
  381. req->status = status;
  382. wake_up(&req->wq);
  383. p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag);
  384. p9_req_put(req);
  385. }
  386. EXPORT_SYMBOL(p9_client_cb);
  387. /**
  388. * p9_parse_header - parse header arguments out of a packet
  389. * @pdu: packet to parse
  390. * @size: size of packet
  391. * @type: type of request
  392. * @tag: tag of packet
  393. * @rewind: set if we need to rewind offset afterwards
  394. */
  395. int
  396. p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
  397. int rewind)
  398. {
  399. int8_t r_type;
  400. int16_t r_tag;
  401. int32_t r_size;
  402. int offset = pdu->offset;
  403. int err;
  404. pdu->offset = 0;
  405. err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
  406. if (err)
  407. goto rewind_and_exit;
  408. if (type)
  409. *type = r_type;
  410. if (tag)
  411. *tag = r_tag;
  412. if (size)
  413. *size = r_size;
  414. if (pdu->size != r_size || r_size < 7) {
  415. err = -EINVAL;
  416. goto rewind_and_exit;
  417. }
  418. pdu->id = r_type;
  419. pdu->tag = r_tag;
  420. p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n",
  421. pdu->size, pdu->id, pdu->tag);
  422. rewind_and_exit:
  423. if (rewind)
  424. pdu->offset = offset;
  425. return err;
  426. }
  427. EXPORT_SYMBOL(p9_parse_header);
  428. /**
  429. * p9_check_errors - check 9p packet for error return and process it
  430. * @c: current client instance
  431. * @req: request to parse and check for error conditions
  432. *
  433. * returns error code if one is discovered, otherwise returns 0
  434. *
  435. * this will have to be more complicated if we have multiple
  436. * error packet types
  437. */
  438. static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
  439. {
  440. int8_t type;
  441. int err;
  442. int ecode;
  443. err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
  444. if (req->rc.size >= c->msize) {
  445. p9_debug(P9_DEBUG_ERROR,
  446. "requested packet size too big: %d\n",
  447. req->rc.size);
  448. return -EIO;
  449. }
  450. /*
  451. * dump the response from server
  452. * This should be after check errors which poplulate pdu_fcall.
  453. */
  454. trace_9p_protocol_dump(c, &req->rc);
  455. if (err) {
  456. p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
  457. return err;
  458. }
  459. if (type != P9_RERROR && type != P9_RLERROR)
  460. return 0;
  461. if (!p9_is_proto_dotl(c)) {
  462. char *ename;
  463. err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
  464. &ename, &ecode);
  465. if (err)
  466. goto out_err;
  467. if (p9_is_proto_dotu(c) && ecode < 512)
  468. err = -ecode;
  469. if (!err) {
  470. err = p9_errstr2errno(ename, strlen(ename));
  471. p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
  472. -ecode, ename);
  473. }
  474. kfree(ename);
  475. } else {
  476. err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode);
  477. if (err)
  478. goto out_err;
  479. err = -ecode;
  480. p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
  481. }
  482. return err;
  483. out_err:
  484. p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
  485. return err;
  486. }
  487. /**
  488. * p9_check_zc_errors - check 9p packet for error return and process it
  489. * @c: current client instance
  490. * @req: request to parse and check for error conditions
  491. * @in_hdrlen: Size of response protocol buffer.
  492. *
  493. * returns error code if one is discovered, otherwise returns 0
  494. *
  495. * this will have to be more complicated if we have multiple
  496. * error packet types
  497. */
  498. static int p9_check_zc_errors(struct p9_client *c, struct p9_req_t *req,
  499. struct iov_iter *uidata, int in_hdrlen)
  500. {
  501. int err;
  502. int ecode;
  503. int8_t type;
  504. char *ename = NULL;
  505. err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
  506. /*
  507. * dump the response from server
  508. * This should be after parse_header which poplulate pdu_fcall.
  509. */
  510. trace_9p_protocol_dump(c, &req->rc);
  511. if (err) {
  512. p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
  513. return err;
  514. }
  515. if (type != P9_RERROR && type != P9_RLERROR)
  516. return 0;
  517. if (!p9_is_proto_dotl(c)) {
  518. /* Error is reported in string format */
  519. int len;
  520. /* 7 = header size for RERROR; */
  521. int inline_len = in_hdrlen - 7;
  522. len = req->rc.size - req->rc.offset;
  523. if (len > (P9_ZC_HDR_SZ - 7)) {
  524. err = -EFAULT;
  525. goto out_err;
  526. }
  527. ename = &req->rc.sdata[req->rc.offset];
  528. if (len > inline_len) {
  529. /* We have error in external buffer */
  530. if (!copy_from_iter_full(ename + inline_len,
  531. len - inline_len, uidata)) {
  532. err = -EFAULT;
  533. goto out_err;
  534. }
  535. }
  536. ename = NULL;
  537. err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
  538. &ename, &ecode);
  539. if (err)
  540. goto out_err;
  541. if (p9_is_proto_dotu(c) && ecode < 512)
  542. err = -ecode;
  543. if (!err) {
  544. err = p9_errstr2errno(ename, strlen(ename));
  545. p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
  546. -ecode, ename);
  547. }
  548. kfree(ename);
  549. } else {
  550. err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode);
  551. err = -ecode;
  552. p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
  553. }
  554. return err;
  555. out_err:
  556. p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
  557. return err;
  558. }
  559. static struct p9_req_t *
  560. p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
  561. /**
  562. * p9_client_flush - flush (cancel) a request
  563. * @c: client state
  564. * @oldreq: request to cancel
  565. *
  566. * This sents a flush for a particular request and links
  567. * the flush request to the original request. The current
  568. * code only supports a single flush request although the protocol
  569. * allows for multiple flush requests to be sent for a single request.
  570. *
  571. */
  572. static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
  573. {
  574. struct p9_req_t *req;
  575. int16_t oldtag;
  576. int err;
  577. err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1);
  578. if (err)
  579. return err;
  580. p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
  581. req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
  582. if (IS_ERR(req))
  583. return PTR_ERR(req);
  584. /*
  585. * if we haven't received a response for oldreq,
  586. * remove it from the list
  587. */
  588. if (oldreq->status == REQ_STATUS_SENT) {
  589. if (c->trans_mod->cancelled)
  590. c->trans_mod->cancelled(c, oldreq);
  591. }
  592. p9_tag_remove(c, req);
  593. return 0;
  594. }
  595. static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
  596. int8_t type, int req_size,
  597. const char *fmt, va_list ap)
  598. {
  599. int err;
  600. struct p9_req_t *req;
  601. p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type);
  602. /* we allow for any status other than disconnected */
  603. if (c->status == Disconnected)
  604. return ERR_PTR(-EIO);
  605. /* if status is begin_disconnected we allow only clunk request */
  606. if ((c->status == BeginDisconnect) && (type != P9_TCLUNK))
  607. return ERR_PTR(-EIO);
  608. req = p9_tag_alloc(c, type, req_size);
  609. if (IS_ERR(req))
  610. return req;
  611. /* marshall the data */
  612. p9pdu_prepare(&req->tc, req->tc.tag, type);
  613. err = p9pdu_vwritef(&req->tc, c->proto_version, fmt, ap);
  614. if (err)
  615. goto reterr;
  616. p9pdu_finalize(c, &req->tc);
  617. trace_9p_client_req(c, type, req->tc.tag);
  618. return req;
  619. reterr:
  620. p9_tag_remove(c, req);
  621. /* We have to put also the 2nd reference as it won't be used */
  622. p9_req_put(req);
  623. return ERR_PTR(err);
  624. }
  625. /**
  626. * p9_client_rpc - issue a request and wait for a response
  627. * @c: client session
  628. * @type: type of request
  629. * @fmt: protocol format string (see protocol.c)
  630. *
  631. * Returns request structure (which client must free using p9_tag_remove)
  632. */
  633. static struct p9_req_t *
  634. p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
  635. {
  636. va_list ap;
  637. int sigpending, err;
  638. unsigned long flags;
  639. struct p9_req_t *req;
  640. va_start(ap, fmt);
  641. req = p9_client_prepare_req(c, type, c->msize, fmt, ap);
  642. va_end(ap);
  643. if (IS_ERR(req))
  644. return req;
  645. if (signal_pending(current)) {
  646. sigpending = 1;
  647. clear_thread_flag(TIF_SIGPENDING);
  648. } else
  649. sigpending = 0;
  650. err = c->trans_mod->request(c, req);
  651. if (err < 0) {
  652. /* write won't happen */
  653. p9_req_put(req);
  654. if (err != -ERESTARTSYS && err != -EFAULT)
  655. c->status = Disconnected;
  656. goto recalc_sigpending;
  657. }
  658. again:
  659. /* Wait for the response */
  660. err = wait_event_killable(req->wq, req->status >= REQ_STATUS_RCVD);
  661. /*
  662. * Make sure our req is coherent with regard to updates in other
  663. * threads - echoes to wmb() in the callback
  664. */
  665. smp_rmb();
  666. if ((err == -ERESTARTSYS) && (c->status == Connected)
  667. && (type == P9_TFLUSH)) {
  668. sigpending = 1;
  669. clear_thread_flag(TIF_SIGPENDING);
  670. goto again;
  671. }
  672. if (req->status == REQ_STATUS_ERROR) {
  673. p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
  674. err = req->t_err;
  675. }
  676. if ((err == -ERESTARTSYS) && (c->status == Connected)) {
  677. p9_debug(P9_DEBUG_MUX, "flushing\n");
  678. sigpending = 1;
  679. clear_thread_flag(TIF_SIGPENDING);
  680. if (c->trans_mod->cancel(c, req))
  681. p9_client_flush(c, req);
  682. /* if we received the response anyway, don't signal error */
  683. if (req->status == REQ_STATUS_RCVD)
  684. err = 0;
  685. }
  686. recalc_sigpending:
  687. if (sigpending) {
  688. spin_lock_irqsave(&current->sighand->siglock, flags);
  689. recalc_sigpending();
  690. spin_unlock_irqrestore(&current->sighand->siglock, flags);
  691. }
  692. if (err < 0)
  693. goto reterr;
  694. err = p9_check_errors(c, req);
  695. trace_9p_client_res(c, type, req->rc.tag, err);
  696. if (!err)
  697. return req;
  698. reterr:
  699. p9_tag_remove(c, req);
  700. return ERR_PTR(safe_errno(err));
  701. }
  702. /**
  703. * p9_client_zc_rpc - issue a request and wait for a response
  704. * @c: client session
  705. * @type: type of request
  706. * @uidata: destination for zero copy read
  707. * @uodata: source for zero copy write
  708. * @inlen: read buffer size
  709. * @olen: write buffer size
  710. * @in_hdrlen: reader header size, This is the size of response protocol data
  711. * @fmt: protocol format string (see protocol.c)
  712. *
  713. * Returns request structure (which client must free using p9_tag_remove)
  714. */
  715. static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
  716. struct iov_iter *uidata,
  717. struct iov_iter *uodata,
  718. int inlen, int olen, int in_hdrlen,
  719. const char *fmt, ...)
  720. {
  721. va_list ap;
  722. int sigpending, err;
  723. unsigned long flags;
  724. struct p9_req_t *req;
  725. va_start(ap, fmt);
  726. /*
  727. * We allocate a inline protocol data of only 4k bytes.
  728. * The actual content is passed in zero-copy fashion.
  729. */
  730. req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, fmt, ap);
  731. va_end(ap);
  732. if (IS_ERR(req))
  733. return req;
  734. if (signal_pending(current)) {
  735. sigpending = 1;
  736. clear_thread_flag(TIF_SIGPENDING);
  737. } else
  738. sigpending = 0;
  739. err = c->trans_mod->zc_request(c, req, uidata, uodata,
  740. inlen, olen, in_hdrlen);
  741. if (err < 0) {
  742. if (err == -EIO)
  743. c->status = Disconnected;
  744. if (err != -ERESTARTSYS)
  745. goto recalc_sigpending;
  746. }
  747. if (req->status == REQ_STATUS_ERROR) {
  748. p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
  749. err = req->t_err;
  750. }
  751. if ((err == -ERESTARTSYS) && (c->status == Connected)) {
  752. p9_debug(P9_DEBUG_MUX, "flushing\n");
  753. sigpending = 1;
  754. clear_thread_flag(TIF_SIGPENDING);
  755. if (c->trans_mod->cancel(c, req))
  756. p9_client_flush(c, req);
  757. /* if we received the response anyway, don't signal error */
  758. if (req->status == REQ_STATUS_RCVD)
  759. err = 0;
  760. }
  761. recalc_sigpending:
  762. if (sigpending) {
  763. spin_lock_irqsave(&current->sighand->siglock, flags);
  764. recalc_sigpending();
  765. spin_unlock_irqrestore(&current->sighand->siglock, flags);
  766. }
  767. if (err < 0)
  768. goto reterr;
  769. err = p9_check_zc_errors(c, req, uidata, in_hdrlen);
  770. trace_9p_client_res(c, type, req->rc.tag, err);
  771. if (!err)
  772. return req;
  773. reterr:
  774. p9_tag_remove(c, req);
  775. return ERR_PTR(safe_errno(err));
  776. }
  777. static struct p9_fid *p9_fid_create(struct p9_client *clnt)
  778. {
  779. int ret;
  780. struct p9_fid *fid;
  781. p9_debug(P9_DEBUG_FID, "clnt %p\n", clnt);
  782. fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
  783. if (!fid)
  784. return NULL;
  785. memset(&fid->qid, 0, sizeof(struct p9_qid));
  786. fid->mode = -1;
  787. fid->uid = current_fsuid();
  788. fid->clnt = clnt;
  789. fid->rdir = NULL;
  790. fid->fid = 0;
  791. idr_preload(GFP_KERNEL);
  792. spin_lock_irq(&clnt->lock);
  793. ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1,
  794. GFP_NOWAIT);
  795. spin_unlock_irq(&clnt->lock);
  796. idr_preload_end();
  797. if (!ret)
  798. return fid;
  799. kfree(fid);
  800. return NULL;
  801. }
  802. static void p9_fid_destroy(struct p9_fid *fid)
  803. {
  804. struct p9_client *clnt;
  805. unsigned long flags;
  806. p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid);
  807. clnt = fid->clnt;
  808. spin_lock_irqsave(&clnt->lock, flags);
  809. idr_remove(&clnt->fids, fid->fid);
  810. spin_unlock_irqrestore(&clnt->lock, flags);
  811. kfree(fid->rdir);
  812. kfree(fid);
  813. }
  814. static int p9_client_version(struct p9_client *c)
  815. {
  816. int err = 0;
  817. struct p9_req_t *req;
  818. char *version = NULL;
  819. int msize;
  820. p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
  821. c->msize, c->proto_version);
  822. switch (c->proto_version) {
  823. case p9_proto_2000L:
  824. req = p9_client_rpc(c, P9_TVERSION, "ds",
  825. c->msize, "9P2000.L");
  826. break;
  827. case p9_proto_2000u:
  828. req = p9_client_rpc(c, P9_TVERSION, "ds",
  829. c->msize, "9P2000.u");
  830. break;
  831. case p9_proto_legacy:
  832. req = p9_client_rpc(c, P9_TVERSION, "ds",
  833. c->msize, "9P2000");
  834. break;
  835. default:
  836. return -EINVAL;
  837. }
  838. if (IS_ERR(req))
  839. return PTR_ERR(req);
  840. err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version);
  841. if (err) {
  842. p9_debug(P9_DEBUG_9P, "version error %d\n", err);
  843. trace_9p_protocol_dump(c, &req->rc);
  844. goto error;
  845. }
  846. p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
  847. if (!strncmp(version, "9P2000.L", 8))
  848. c->proto_version = p9_proto_2000L;
  849. else if (!strncmp(version, "9P2000.u", 8))
  850. c->proto_version = p9_proto_2000u;
  851. else if (!strncmp(version, "9P2000", 6))
  852. c->proto_version = p9_proto_legacy;
  853. else {
  854. p9_debug(P9_DEBUG_ERROR,
  855. "server returned an unknown version: %s\n", version);
  856. err = -EREMOTEIO;
  857. goto error;
  858. }
  859. if (msize < 4096) {
  860. p9_debug(P9_DEBUG_ERROR,
  861. "server returned a msize < 4096: %d\n", msize);
  862. err = -EREMOTEIO;
  863. goto error;
  864. }
  865. if (msize < c->msize)
  866. c->msize = msize;
  867. error:
  868. kfree(version);
  869. p9_tag_remove(c, req);
  870. return err;
  871. }
  872. struct p9_client *p9_client_create(const char *dev_name, char *options)
  873. {
  874. int err;
  875. struct p9_client *clnt;
  876. char *client_id;
  877. err = 0;
  878. clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
  879. if (!clnt)
  880. return ERR_PTR(-ENOMEM);
  881. clnt->trans_mod = NULL;
  882. clnt->trans = NULL;
  883. clnt->fcall_cache = NULL;
  884. client_id = utsname()->nodename;
  885. memcpy(clnt->name, client_id, strlen(client_id) + 1);
  886. spin_lock_init(&clnt->lock);
  887. idr_init(&clnt->fids);
  888. idr_init(&clnt->reqs);
  889. err = parse_opts(options, clnt);
  890. if (err < 0)
  891. goto free_client;
  892. if (!clnt->trans_mod)
  893. clnt->trans_mod = v9fs_get_default_trans();
  894. if (clnt->trans_mod == NULL) {
  895. err = -EPROTONOSUPPORT;
  896. p9_debug(P9_DEBUG_ERROR,
  897. "No transport defined or default transport\n");
  898. goto free_client;
  899. }
  900. p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
  901. clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
  902. err = clnt->trans_mod->create(clnt, dev_name, options);
  903. if (err)
  904. goto put_trans;
  905. if (clnt->msize > clnt->trans_mod->maxsize)
  906. clnt->msize = clnt->trans_mod->maxsize;
  907. if (clnt->msize < 4096) {
  908. p9_debug(P9_DEBUG_ERROR,
  909. "Please specify a msize of at least 4k\n");
  910. err = -EINVAL;
  911. goto close_trans;
  912. }
  913. err = p9_client_version(clnt);
  914. if (err)
  915. goto close_trans;
  916. /* P9_HDRSZ + 4 is the smallest packet header we can have that is
  917. * followed by data accessed from userspace by read
  918. */
  919. clnt->fcall_cache =
  920. kmem_cache_create_usercopy("9p-fcall-cache", clnt->msize,
  921. 0, 0, P9_HDRSZ + 4,
  922. clnt->msize - (P9_HDRSZ + 4),
  923. NULL);
  924. return clnt;
  925. close_trans:
  926. clnt->trans_mod->close(clnt);
  927. put_trans:
  928. v9fs_put_trans(clnt->trans_mod);
  929. free_client:
  930. kfree(clnt);
  931. return ERR_PTR(err);
  932. }
  933. EXPORT_SYMBOL(p9_client_create);
  934. void p9_client_destroy(struct p9_client *clnt)
  935. {
  936. struct p9_fid *fid;
  937. int id;
  938. p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt);
  939. if (clnt->trans_mod)
  940. clnt->trans_mod->close(clnt);
  941. v9fs_put_trans(clnt->trans_mod);
  942. idr_for_each_entry(&clnt->fids, fid, id) {
  943. pr_info("Found fid %d not clunked\n", fid->fid);
  944. p9_fid_destroy(fid);
  945. }
  946. p9_tag_cleanup(clnt);
  947. kmem_cache_destroy(clnt->fcall_cache);
  948. kfree(clnt);
  949. }
  950. EXPORT_SYMBOL(p9_client_destroy);
  951. void p9_client_disconnect(struct p9_client *clnt)
  952. {
  953. p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
  954. clnt->status = Disconnected;
  955. }
  956. EXPORT_SYMBOL(p9_client_disconnect);
  957. void p9_client_begin_disconnect(struct p9_client *clnt)
  958. {
  959. p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
  960. clnt->status = BeginDisconnect;
  961. }
  962. EXPORT_SYMBOL(p9_client_begin_disconnect);
  963. struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
  964. const char *uname, kuid_t n_uname, const char *aname)
  965. {
  966. int err = 0;
  967. struct p9_req_t *req;
  968. struct p9_fid *fid;
  969. struct p9_qid qid;
  970. p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
  971. afid ? afid->fid : -1, uname, aname);
  972. fid = p9_fid_create(clnt);
  973. if (!fid) {
  974. err = -ENOMEM;
  975. goto error;
  976. }
  977. fid->uid = n_uname;
  978. req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
  979. afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
  980. if (IS_ERR(req)) {
  981. err = PTR_ERR(req);
  982. goto error;
  983. }
  984. err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", &qid);
  985. if (err) {
  986. trace_9p_protocol_dump(clnt, &req->rc);
  987. p9_tag_remove(clnt, req);
  988. goto error;
  989. }
  990. p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
  991. qid.type, (unsigned long long)qid.path, qid.version);
  992. memmove(&fid->qid, &qid, sizeof(struct p9_qid));
  993. p9_tag_remove(clnt, req);
  994. return fid;
  995. error:
  996. if (fid)
  997. p9_fid_destroy(fid);
  998. return ERR_PTR(err);
  999. }
  1000. EXPORT_SYMBOL(p9_client_attach);
  1001. struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
  1002. const unsigned char * const *wnames, int clone)
  1003. {
  1004. int err;
  1005. struct p9_client *clnt;
  1006. struct p9_fid *fid;
  1007. struct p9_qid *wqids;
  1008. struct p9_req_t *req;
  1009. uint16_t nwqids, count;
  1010. err = 0;
  1011. wqids = NULL;
  1012. clnt = oldfid->clnt;
  1013. if (clone) {
  1014. fid = p9_fid_create(clnt);
  1015. if (!fid) {
  1016. err = -ENOMEM;
  1017. goto error;
  1018. }
  1019. fid->uid = oldfid->uid;
  1020. } else
  1021. fid = oldfid;
  1022. p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
  1023. oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
  1024. req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
  1025. nwname, wnames);
  1026. if (IS_ERR(req)) {
  1027. err = PTR_ERR(req);
  1028. goto error;
  1029. }
  1030. err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids);
  1031. if (err) {
  1032. trace_9p_protocol_dump(clnt, &req->rc);
  1033. p9_tag_remove(clnt, req);
  1034. goto clunk_fid;
  1035. }
  1036. p9_tag_remove(clnt, req);
  1037. p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
  1038. if (nwqids != nwname) {
  1039. err = -ENOENT;
  1040. goto clunk_fid;
  1041. }
  1042. for (count = 0; count < nwqids; count++)
  1043. p9_debug(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n",
  1044. count, wqids[count].type,
  1045. (unsigned long long)wqids[count].path,
  1046. wqids[count].version);
  1047. if (nwname)
  1048. memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
  1049. else
  1050. fid->qid = oldfid->qid;
  1051. kfree(wqids);
  1052. return fid;
  1053. clunk_fid:
  1054. kfree(wqids);
  1055. p9_client_clunk(fid);
  1056. fid = NULL;
  1057. error:
  1058. if (fid && (fid != oldfid))
  1059. p9_fid_destroy(fid);
  1060. return ERR_PTR(err);
  1061. }
  1062. EXPORT_SYMBOL(p9_client_walk);
  1063. int p9_client_open(struct p9_fid *fid, int mode)
  1064. {
  1065. int err;
  1066. struct p9_client *clnt;
  1067. struct p9_req_t *req;
  1068. struct p9_qid qid;
  1069. int iounit;
  1070. clnt = fid->clnt;
  1071. p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
  1072. p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
  1073. err = 0;
  1074. if (fid->mode != -1)
  1075. return -EINVAL;
  1076. if (p9_is_proto_dotl(clnt))
  1077. req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
  1078. else
  1079. req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
  1080. if (IS_ERR(req)) {
  1081. err = PTR_ERR(req);
  1082. goto error;
  1083. }
  1084. err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
  1085. if (err) {
  1086. trace_9p_protocol_dump(clnt, &req->rc);
  1087. goto free_and_error;
  1088. }
  1089. p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
  1090. p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN", qid.type,
  1091. (unsigned long long)qid.path, qid.version, iounit);
  1092. fid->mode = mode;
  1093. fid->iounit = iounit;
  1094. free_and_error:
  1095. p9_tag_remove(clnt, req);
  1096. error:
  1097. return err;
  1098. }
  1099. EXPORT_SYMBOL(p9_client_open);
  1100. int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags, u32 mode,
  1101. kgid_t gid, struct p9_qid *qid)
  1102. {
  1103. int err = 0;
  1104. struct p9_client *clnt;
  1105. struct p9_req_t *req;
  1106. int iounit;
  1107. p9_debug(P9_DEBUG_9P,
  1108. ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
  1109. ofid->fid, name, flags, mode,
  1110. from_kgid(&init_user_ns, gid));
  1111. clnt = ofid->clnt;
  1112. if (ofid->mode != -1)
  1113. return -EINVAL;
  1114. req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
  1115. mode, gid);
  1116. if (IS_ERR(req)) {
  1117. err = PTR_ERR(req);
  1118. goto error;
  1119. }
  1120. err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit);
  1121. if (err) {
  1122. trace_9p_protocol_dump(clnt, &req->rc);
  1123. goto free_and_error;
  1124. }
  1125. p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
  1126. qid->type,
  1127. (unsigned long long)qid->path,
  1128. qid->version, iounit);
  1129. ofid->mode = mode;
  1130. ofid->iounit = iounit;
  1131. free_and_error:
  1132. p9_tag_remove(clnt, req);
  1133. error:
  1134. return err;
  1135. }
  1136. EXPORT_SYMBOL(p9_client_create_dotl);
  1137. int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode,
  1138. char *extension)
  1139. {
  1140. int err;
  1141. struct p9_client *clnt;
  1142. struct p9_req_t *req;
  1143. struct p9_qid qid;
  1144. int iounit;
  1145. p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
  1146. fid->fid, name, perm, mode);
  1147. err = 0;
  1148. clnt = fid->clnt;
  1149. if (fid->mode != -1)
  1150. return -EINVAL;
  1151. req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
  1152. mode, extension);
  1153. if (IS_ERR(req)) {
  1154. err = PTR_ERR(req);
  1155. goto error;
  1156. }
  1157. err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
  1158. if (err) {
  1159. trace_9p_protocol_dump(clnt, &req->rc);
  1160. goto free_and_error;
  1161. }
  1162. p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
  1163. qid.type,
  1164. (unsigned long long)qid.path,
  1165. qid.version, iounit);
  1166. fid->mode = mode;
  1167. fid->iounit = iounit;
  1168. free_and_error:
  1169. p9_tag_remove(clnt, req);
  1170. error:
  1171. return err;
  1172. }
  1173. EXPORT_SYMBOL(p9_client_fcreate);
  1174. int p9_client_symlink(struct p9_fid *dfid, const char *name,
  1175. const char *symtgt, kgid_t gid, struct p9_qid *qid)
  1176. {
  1177. int err = 0;
  1178. struct p9_client *clnt;
  1179. struct p9_req_t *req;
  1180. p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
  1181. dfid->fid, name, symtgt);
  1182. clnt = dfid->clnt;
  1183. req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
  1184. gid);
  1185. if (IS_ERR(req)) {
  1186. err = PTR_ERR(req);
  1187. goto error;
  1188. }
  1189. err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
  1190. if (err) {
  1191. trace_9p_protocol_dump(clnt, &req->rc);
  1192. goto free_and_error;
  1193. }
  1194. p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
  1195. qid->type, (unsigned long long)qid->path, qid->version);
  1196. free_and_error:
  1197. p9_tag_remove(clnt, req);
  1198. error:
  1199. return err;
  1200. }
  1201. EXPORT_SYMBOL(p9_client_symlink);
  1202. int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, const char *newname)
  1203. {
  1204. struct p9_client *clnt;
  1205. struct p9_req_t *req;
  1206. p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
  1207. dfid->fid, oldfid->fid, newname);
  1208. clnt = dfid->clnt;
  1209. req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
  1210. newname);
  1211. if (IS_ERR(req))
  1212. return PTR_ERR(req);
  1213. p9_debug(P9_DEBUG_9P, "<<< RLINK\n");
  1214. p9_tag_remove(clnt, req);
  1215. return 0;
  1216. }
  1217. EXPORT_SYMBOL(p9_client_link);
  1218. int p9_client_fsync(struct p9_fid *fid, int datasync)
  1219. {
  1220. int err;
  1221. struct p9_client *clnt;
  1222. struct p9_req_t *req;
  1223. p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d\n",
  1224. fid->fid, datasync);
  1225. err = 0;
  1226. clnt = fid->clnt;
  1227. req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
  1228. if (IS_ERR(req)) {
  1229. err = PTR_ERR(req);
  1230. goto error;
  1231. }
  1232. p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);
  1233. p9_tag_remove(clnt, req);
  1234. error:
  1235. return err;
  1236. }
  1237. EXPORT_SYMBOL(p9_client_fsync);
  1238. int p9_client_clunk(struct p9_fid *fid)
  1239. {
  1240. int err;
  1241. struct p9_client *clnt;
  1242. struct p9_req_t *req;
  1243. int retries = 0;
  1244. if (!fid) {
  1245. pr_warn("%s (%d): Trying to clunk with NULL fid\n",
  1246. __func__, task_pid_nr(current));
  1247. dump_stack();
  1248. return 0;
  1249. }
  1250. again:
  1251. p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n", fid->fid,
  1252. retries);
  1253. err = 0;
  1254. clnt = fid->clnt;
  1255. req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
  1256. if (IS_ERR(req)) {
  1257. err = PTR_ERR(req);
  1258. goto error;
  1259. }
  1260. p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
  1261. p9_tag_remove(clnt, req);
  1262. error:
  1263. /*
  1264. * Fid is not valid even after a failed clunk
  1265. * If interrupted, retry once then give up and
  1266. * leak fid until umount.
  1267. */
  1268. if (err == -ERESTARTSYS) {
  1269. if (retries++ == 0)
  1270. goto again;
  1271. } else
  1272. p9_fid_destroy(fid);
  1273. return err;
  1274. }
  1275. EXPORT_SYMBOL(p9_client_clunk);
  1276. int p9_client_remove(struct p9_fid *fid)
  1277. {
  1278. int err;
  1279. struct p9_client *clnt;
  1280. struct p9_req_t *req;
  1281. p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
  1282. err = 0;
  1283. clnt = fid->clnt;
  1284. req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
  1285. if (IS_ERR(req)) {
  1286. err = PTR_ERR(req);
  1287. goto error;
  1288. }
  1289. p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
  1290. p9_tag_remove(clnt, req);
  1291. error:
  1292. if (err == -ERESTARTSYS)
  1293. p9_client_clunk(fid);
  1294. else
  1295. p9_fid_destroy(fid);
  1296. return err;
  1297. }
  1298. EXPORT_SYMBOL(p9_client_remove);
  1299. int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
  1300. {
  1301. int err = 0;
  1302. struct p9_req_t *req;
  1303. struct p9_client *clnt;
  1304. p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
  1305. dfid->fid, name, flags);
  1306. clnt = dfid->clnt;
  1307. req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
  1308. if (IS_ERR(req)) {
  1309. err = PTR_ERR(req);
  1310. goto error;
  1311. }
  1312. p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
  1313. p9_tag_remove(clnt, req);
  1314. error:
  1315. return err;
  1316. }
  1317. EXPORT_SYMBOL(p9_client_unlinkat);
  1318. int
  1319. p9_client_read(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err)
  1320. {
  1321. int total = 0;
  1322. *err = 0;
  1323. while (iov_iter_count(to)) {
  1324. int count;
  1325. count = p9_client_read_once(fid, offset, to, err);
  1326. if (!count || *err)
  1327. break;
  1328. offset += count;
  1329. total += count;
  1330. }
  1331. return total;
  1332. }
  1333. EXPORT_SYMBOL(p9_client_read);
  1334. int
  1335. p9_client_read_once(struct p9_fid *fid, u64 offset, struct iov_iter *to,
  1336. int *err)
  1337. {
  1338. struct p9_client *clnt = fid->clnt;
  1339. struct p9_req_t *req;
  1340. int count = iov_iter_count(to);
  1341. int rsize, non_zc = 0;
  1342. char *dataptr;
  1343. *err = 0;
  1344. p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n",
  1345. fid->fid, (unsigned long long) offset, (int)iov_iter_count(to));
  1346. rsize = fid->iounit;
  1347. if (!rsize || rsize > clnt->msize - P9_IOHDRSZ)
  1348. rsize = clnt->msize - P9_IOHDRSZ;
  1349. if (count < rsize)
  1350. rsize = count;
  1351. /* Don't bother zerocopy for small IO (< 1024) */
  1352. if (clnt->trans_mod->zc_request && rsize > 1024) {
  1353. /* response header len is 11
  1354. * PDU Header(7) + IO Size (4)
  1355. */
  1356. req = p9_client_zc_rpc(clnt, P9_TREAD, to, NULL, rsize,
  1357. 0, 11, "dqd", fid->fid,
  1358. offset, rsize);
  1359. } else {
  1360. non_zc = 1;
  1361. req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
  1362. rsize);
  1363. }
  1364. if (IS_ERR(req)) {
  1365. *err = PTR_ERR(req);
  1366. return 0;
  1367. }
  1368. *err = p9pdu_readf(&req->rc, clnt->proto_version,
  1369. "D", &count, &dataptr);
  1370. if (*err) {
  1371. trace_9p_protocol_dump(clnt, &req->rc);
  1372. p9_tag_remove(clnt, req);
  1373. return 0;
  1374. }
  1375. if (rsize < count) {
  1376. pr_err("bogus RREAD count (%d > %d)\n", count, rsize);
  1377. count = rsize;
  1378. }
  1379. p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
  1380. if (non_zc) {
  1381. int n = copy_to_iter(dataptr, count, to);
  1382. if (n != count) {
  1383. *err = -EFAULT;
  1384. p9_tag_remove(clnt, req);
  1385. return n;
  1386. }
  1387. } else {
  1388. iov_iter_advance(to, count);
  1389. }
  1390. p9_tag_remove(clnt, req);
  1391. return count;
  1392. }
  1393. EXPORT_SYMBOL(p9_client_read_once);
  1394. int
  1395. p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err)
  1396. {
  1397. struct p9_client *clnt = fid->clnt;
  1398. struct p9_req_t *req;
  1399. int total = 0;
  1400. *err = 0;
  1401. p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %zd\n",
  1402. fid->fid, (unsigned long long) offset,
  1403. iov_iter_count(from));
  1404. while (iov_iter_count(from)) {
  1405. int count = iov_iter_count(from);
  1406. int rsize = fid->iounit;
  1407. if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
  1408. rsize = clnt->msize - P9_IOHDRSZ;
  1409. if (count < rsize)
  1410. rsize = count;
  1411. /* Don't bother zerocopy for small IO (< 1024) */
  1412. if (clnt->trans_mod->zc_request && rsize > 1024) {
  1413. req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, from, 0,
  1414. rsize, P9_ZC_HDR_SZ, "dqd",
  1415. fid->fid, offset, rsize);
  1416. } else {
  1417. req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
  1418. offset, rsize, from);
  1419. }
  1420. if (IS_ERR(req)) {
  1421. *err = PTR_ERR(req);
  1422. break;
  1423. }
  1424. *err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &count);
  1425. if (*err) {
  1426. trace_9p_protocol_dump(clnt, &req->rc);
  1427. p9_tag_remove(clnt, req);
  1428. break;
  1429. }
  1430. if (rsize < count) {
  1431. pr_err("bogus RWRITE count (%d > %d)\n", count, rsize);
  1432. count = rsize;
  1433. }
  1434. p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
  1435. p9_tag_remove(clnt, req);
  1436. iov_iter_advance(from, count);
  1437. total += count;
  1438. offset += count;
  1439. }
  1440. return total;
  1441. }
  1442. EXPORT_SYMBOL(p9_client_write);
  1443. struct p9_wstat *p9_client_stat(struct p9_fid *fid)
  1444. {
  1445. int err;
  1446. struct p9_client *clnt;
  1447. struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
  1448. struct p9_req_t *req;
  1449. u16 ignored;
  1450. p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
  1451. if (!ret)
  1452. return ERR_PTR(-ENOMEM);
  1453. err = 0;
  1454. clnt = fid->clnt;
  1455. req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
  1456. if (IS_ERR(req)) {
  1457. err = PTR_ERR(req);
  1458. goto error;
  1459. }
  1460. err = p9pdu_readf(&req->rc, clnt->proto_version, "wS", &ignored, ret);
  1461. if (err) {
  1462. trace_9p_protocol_dump(clnt, &req->rc);
  1463. p9_tag_remove(clnt, req);
  1464. goto error;
  1465. }
  1466. p9_debug(P9_DEBUG_9P,
  1467. "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
  1468. "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
  1469. "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
  1470. "<<< uid=%d gid=%d n_muid=%d\n",
  1471. ret->size, ret->type, ret->dev, ret->qid.type,
  1472. (unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
  1473. ret->atime, ret->mtime, (unsigned long long)ret->length,
  1474. ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
  1475. from_kuid(&init_user_ns, ret->n_uid),
  1476. from_kgid(&init_user_ns, ret->n_gid),
  1477. from_kuid(&init_user_ns, ret->n_muid));
  1478. p9_tag_remove(clnt, req);
  1479. return ret;
  1480. error:
  1481. kfree(ret);
  1482. return ERR_PTR(err);
  1483. }
  1484. EXPORT_SYMBOL(p9_client_stat);
  1485. struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
  1486. u64 request_mask)
  1487. {
  1488. int err;
  1489. struct p9_client *clnt;
  1490. struct p9_stat_dotl *ret = kmalloc(sizeof(struct p9_stat_dotl),
  1491. GFP_KERNEL);
  1492. struct p9_req_t *req;
  1493. p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
  1494. fid->fid, request_mask);
  1495. if (!ret)
  1496. return ERR_PTR(-ENOMEM);
  1497. err = 0;
  1498. clnt = fid->clnt;
  1499. req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
  1500. if (IS_ERR(req)) {
  1501. err = PTR_ERR(req);
  1502. goto error;
  1503. }
  1504. err = p9pdu_readf(&req->rc, clnt->proto_version, "A", ret);
  1505. if (err) {
  1506. trace_9p_protocol_dump(clnt, &req->rc);
  1507. p9_tag_remove(clnt, req);
  1508. goto error;
  1509. }
  1510. p9_debug(P9_DEBUG_9P,
  1511. "<<< RGETATTR st_result_mask=%lld\n"
  1512. "<<< qid=%x.%llx.%x\n"
  1513. "<<< st_mode=%8.8x st_nlink=%llu\n"
  1514. "<<< st_uid=%d st_gid=%d\n"
  1515. "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
  1516. "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
  1517. "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
  1518. "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
  1519. "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
  1520. "<<< st_gen=%lld st_data_version=%lld\n",
  1521. ret->st_result_mask, ret->qid.type, ret->qid.path,
  1522. ret->qid.version, ret->st_mode, ret->st_nlink,
  1523. from_kuid(&init_user_ns, ret->st_uid),
  1524. from_kgid(&init_user_ns, ret->st_gid),
  1525. ret->st_rdev, ret->st_size, ret->st_blksize,
  1526. ret->st_blocks, ret->st_atime_sec, ret->st_atime_nsec,
  1527. ret->st_mtime_sec, ret->st_mtime_nsec, ret->st_ctime_sec,
  1528. ret->st_ctime_nsec, ret->st_btime_sec, ret->st_btime_nsec,
  1529. ret->st_gen, ret->st_data_version);
  1530. p9_tag_remove(clnt, req);
  1531. return ret;
  1532. error:
  1533. kfree(ret);
  1534. return ERR_PTR(err);
  1535. }
  1536. EXPORT_SYMBOL(p9_client_getattr_dotl);
  1537. static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
  1538. {
  1539. int ret;
  1540. /* NOTE: size shouldn't include its own length */
  1541. /* size[2] type[2] dev[4] qid[13] */
  1542. /* mode[4] atime[4] mtime[4] length[8]*/
  1543. /* name[s] uid[s] gid[s] muid[s] */
  1544. ret = 2+4+13+4+4+4+8+2+2+2+2;
  1545. if (wst->name)
  1546. ret += strlen(wst->name);
  1547. if (wst->uid)
  1548. ret += strlen(wst->uid);
  1549. if (wst->gid)
  1550. ret += strlen(wst->gid);
  1551. if (wst->muid)
  1552. ret += strlen(wst->muid);
  1553. if ((proto_version == p9_proto_2000u) ||
  1554. (proto_version == p9_proto_2000L)) {
  1555. ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
  1556. if (wst->extension)
  1557. ret += strlen(wst->extension);
  1558. }
  1559. return ret;
  1560. }
  1561. int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
  1562. {
  1563. int err;
  1564. struct p9_req_t *req;
  1565. struct p9_client *clnt;
  1566. err = 0;
  1567. clnt = fid->clnt;
  1568. wst->size = p9_client_statsize(wst, clnt->proto_version);
  1569. p9_debug(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
  1570. p9_debug(P9_DEBUG_9P,
  1571. " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
  1572. " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
  1573. " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
  1574. " uid=%d gid=%d n_muid=%d\n",
  1575. wst->size, wst->type, wst->dev, wst->qid.type,
  1576. (unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
  1577. wst->atime, wst->mtime, (unsigned long long)wst->length,
  1578. wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
  1579. from_kuid(&init_user_ns, wst->n_uid),
  1580. from_kgid(&init_user_ns, wst->n_gid),
  1581. from_kuid(&init_user_ns, wst->n_muid));
  1582. req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size+2, wst);
  1583. if (IS_ERR(req)) {
  1584. err = PTR_ERR(req);
  1585. goto error;
  1586. }
  1587. p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
  1588. p9_tag_remove(clnt, req);
  1589. error:
  1590. return err;
  1591. }
  1592. EXPORT_SYMBOL(p9_client_wstat);
  1593. int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
  1594. {
  1595. int err;
  1596. struct p9_req_t *req;
  1597. struct p9_client *clnt;
  1598. err = 0;
  1599. clnt = fid->clnt;
  1600. p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
  1601. p9_debug(P9_DEBUG_9P,
  1602. " valid=%x mode=%x uid=%d gid=%d size=%lld\n"
  1603. " atime_sec=%lld atime_nsec=%lld\n"
  1604. " mtime_sec=%lld mtime_nsec=%lld\n",
  1605. p9attr->valid, p9attr->mode,
  1606. from_kuid(&init_user_ns, p9attr->uid),
  1607. from_kgid(&init_user_ns, p9attr->gid),
  1608. p9attr->size, p9attr->atime_sec, p9attr->atime_nsec,
  1609. p9attr->mtime_sec, p9attr->mtime_nsec);
  1610. req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
  1611. if (IS_ERR(req)) {
  1612. err = PTR_ERR(req);
  1613. goto error;
  1614. }
  1615. p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
  1616. p9_tag_remove(clnt, req);
  1617. error:
  1618. return err;
  1619. }
  1620. EXPORT_SYMBOL(p9_client_setattr);
  1621. int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
  1622. {
  1623. int err;
  1624. struct p9_req_t *req;
  1625. struct p9_client *clnt;
  1626. err = 0;
  1627. clnt = fid->clnt;
  1628. p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
  1629. req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
  1630. if (IS_ERR(req)) {
  1631. err = PTR_ERR(req);
  1632. goto error;
  1633. }
  1634. err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
  1635. &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
  1636. &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
  1637. if (err) {
  1638. trace_9p_protocol_dump(clnt, &req->rc);
  1639. p9_tag_remove(clnt, req);
  1640. goto error;
  1641. }
  1642. p9_debug(P9_DEBUG_9P, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
  1643. "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
  1644. "fsid %llu namelen %ld\n",
  1645. fid->fid, (long unsigned int)sb->type, (long int)sb->bsize,
  1646. sb->blocks, sb->bfree, sb->bavail, sb->files, sb->ffree,
  1647. sb->fsid, (long int)sb->namelen);
  1648. p9_tag_remove(clnt, req);
  1649. error:
  1650. return err;
  1651. }
  1652. EXPORT_SYMBOL(p9_client_statfs);
  1653. int p9_client_rename(struct p9_fid *fid,
  1654. struct p9_fid *newdirfid, const char *name)
  1655. {
  1656. int err;
  1657. struct p9_req_t *req;
  1658. struct p9_client *clnt;
  1659. err = 0;
  1660. clnt = fid->clnt;
  1661. p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
  1662. fid->fid, newdirfid->fid, name);
  1663. req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
  1664. newdirfid->fid, name);
  1665. if (IS_ERR(req)) {
  1666. err = PTR_ERR(req);
  1667. goto error;
  1668. }
  1669. p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
  1670. p9_tag_remove(clnt, req);
  1671. error:
  1672. return err;
  1673. }
  1674. EXPORT_SYMBOL(p9_client_rename);
  1675. int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
  1676. struct p9_fid *newdirfid, const char *new_name)
  1677. {
  1678. int err;
  1679. struct p9_req_t *req;
  1680. struct p9_client *clnt;
  1681. err = 0;
  1682. clnt = olddirfid->clnt;
  1683. p9_debug(P9_DEBUG_9P, ">>> TRENAMEAT olddirfid %d old name %s"
  1684. " newdirfid %d new name %s\n", olddirfid->fid, old_name,
  1685. newdirfid->fid, new_name);
  1686. req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
  1687. old_name, newdirfid->fid, new_name);
  1688. if (IS_ERR(req)) {
  1689. err = PTR_ERR(req);
  1690. goto error;
  1691. }
  1692. p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
  1693. newdirfid->fid, new_name);
  1694. p9_tag_remove(clnt, req);
  1695. error:
  1696. return err;
  1697. }
  1698. EXPORT_SYMBOL(p9_client_renameat);
  1699. /*
  1700. * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
  1701. */
  1702. struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
  1703. const char *attr_name, u64 *attr_size)
  1704. {
  1705. int err;
  1706. struct p9_req_t *req;
  1707. struct p9_client *clnt;
  1708. struct p9_fid *attr_fid;
  1709. err = 0;
  1710. clnt = file_fid->clnt;
  1711. attr_fid = p9_fid_create(clnt);
  1712. if (!attr_fid) {
  1713. err = -ENOMEM;
  1714. goto error;
  1715. }
  1716. p9_debug(P9_DEBUG_9P,
  1717. ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
  1718. file_fid->fid, attr_fid->fid, attr_name);
  1719. req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
  1720. file_fid->fid, attr_fid->fid, attr_name);
  1721. if (IS_ERR(req)) {
  1722. err = PTR_ERR(req);
  1723. goto error;
  1724. }
  1725. err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size);
  1726. if (err) {
  1727. trace_9p_protocol_dump(clnt, &req->rc);
  1728. p9_tag_remove(clnt, req);
  1729. goto clunk_fid;
  1730. }
  1731. p9_tag_remove(clnt, req);
  1732. p9_debug(P9_DEBUG_9P, "<<< RXATTRWALK fid %d size %llu\n",
  1733. attr_fid->fid, *attr_size);
  1734. return attr_fid;
  1735. clunk_fid:
  1736. p9_client_clunk(attr_fid);
  1737. attr_fid = NULL;
  1738. error:
  1739. if (attr_fid && (attr_fid != file_fid))
  1740. p9_fid_destroy(attr_fid);
  1741. return ERR_PTR(err);
  1742. }
  1743. EXPORT_SYMBOL_GPL(p9_client_xattrwalk);
  1744. int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
  1745. u64 attr_size, int flags)
  1746. {
  1747. int err;
  1748. struct p9_req_t *req;
  1749. struct p9_client *clnt;
  1750. p9_debug(P9_DEBUG_9P,
  1751. ">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
  1752. fid->fid, name, (long long)attr_size, flags);
  1753. err = 0;
  1754. clnt = fid->clnt;
  1755. req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
  1756. fid->fid, name, attr_size, flags);
  1757. if (IS_ERR(req)) {
  1758. err = PTR_ERR(req);
  1759. goto error;
  1760. }
  1761. p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
  1762. p9_tag_remove(clnt, req);
  1763. error:
  1764. return err;
  1765. }
  1766. EXPORT_SYMBOL_GPL(p9_client_xattrcreate);
  1767. int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
  1768. {
  1769. int err, rsize, non_zc = 0;
  1770. struct p9_client *clnt;
  1771. struct p9_req_t *req;
  1772. char *dataptr;
  1773. struct kvec kv = {.iov_base = data, .iov_len = count};
  1774. struct iov_iter to;
  1775. iov_iter_kvec(&to, READ, &kv, 1, count);
  1776. p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
  1777. fid->fid, (unsigned long long) offset, count);
  1778. err = 0;
  1779. clnt = fid->clnt;
  1780. rsize = fid->iounit;
  1781. if (!rsize || rsize > clnt->msize-P9_READDIRHDRSZ)
  1782. rsize = clnt->msize - P9_READDIRHDRSZ;
  1783. if (count < rsize)
  1784. rsize = count;
  1785. /* Don't bother zerocopy for small IO (< 1024) */
  1786. if (clnt->trans_mod->zc_request && rsize > 1024) {
  1787. /*
  1788. * response header len is 11
  1789. * PDU Header(7) + IO Size (4)
  1790. */
  1791. req = p9_client_zc_rpc(clnt, P9_TREADDIR, &to, NULL, rsize, 0,
  1792. 11, "dqd", fid->fid, offset, rsize);
  1793. } else {
  1794. non_zc = 1;
  1795. req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
  1796. offset, rsize);
  1797. }
  1798. if (IS_ERR(req)) {
  1799. err = PTR_ERR(req);
  1800. goto error;
  1801. }
  1802. err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr);
  1803. if (err) {
  1804. trace_9p_protocol_dump(clnt, &req->rc);
  1805. goto free_and_error;
  1806. }
  1807. if (rsize < count) {
  1808. pr_err("bogus RREADDIR count (%d > %d)\n", count, rsize);
  1809. count = rsize;
  1810. }
  1811. p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
  1812. if (non_zc)
  1813. memmove(data, dataptr, count);
  1814. p9_tag_remove(clnt, req);
  1815. return count;
  1816. free_and_error:
  1817. p9_tag_remove(clnt, req);
  1818. error:
  1819. return err;
  1820. }
  1821. EXPORT_SYMBOL(p9_client_readdir);
  1822. int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode,
  1823. dev_t rdev, kgid_t gid, struct p9_qid *qid)
  1824. {
  1825. int err;
  1826. struct p9_client *clnt;
  1827. struct p9_req_t *req;
  1828. err = 0;
  1829. clnt = fid->clnt;
  1830. p9_debug(P9_DEBUG_9P, ">>> TMKNOD fid %d name %s mode %d major %d "
  1831. "minor %d\n", fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
  1832. req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
  1833. MAJOR(rdev), MINOR(rdev), gid);
  1834. if (IS_ERR(req))
  1835. return PTR_ERR(req);
  1836. err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
  1837. if (err) {
  1838. trace_9p_protocol_dump(clnt, &req->rc);
  1839. goto error;
  1840. }
  1841. p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
  1842. (unsigned long long)qid->path, qid->version);
  1843. error:
  1844. p9_tag_remove(clnt, req);
  1845. return err;
  1846. }
  1847. EXPORT_SYMBOL(p9_client_mknod_dotl);
  1848. int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode,
  1849. kgid_t gid, struct p9_qid *qid)
  1850. {
  1851. int err;
  1852. struct p9_client *clnt;
  1853. struct p9_req_t *req;
  1854. err = 0;
  1855. clnt = fid->clnt;
  1856. p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
  1857. fid->fid, name, mode, from_kgid(&init_user_ns, gid));
  1858. req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg", fid->fid, name, mode,
  1859. gid);
  1860. if (IS_ERR(req))
  1861. return PTR_ERR(req);
  1862. err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
  1863. if (err) {
  1864. trace_9p_protocol_dump(clnt, &req->rc);
  1865. goto error;
  1866. }
  1867. p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
  1868. (unsigned long long)qid->path, qid->version);
  1869. error:
  1870. p9_tag_remove(clnt, req);
  1871. return err;
  1872. }
  1873. EXPORT_SYMBOL(p9_client_mkdir_dotl);
  1874. int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
  1875. {
  1876. int err;
  1877. struct p9_client *clnt;
  1878. struct p9_req_t *req;
  1879. err = 0;
  1880. clnt = fid->clnt;
  1881. p9_debug(P9_DEBUG_9P, ">>> TLOCK fid %d type %i flags %d "
  1882. "start %lld length %lld proc_id %d client_id %s\n",
  1883. fid->fid, flock->type, flock->flags, flock->start,
  1884. flock->length, flock->proc_id, flock->client_id);
  1885. req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
  1886. flock->flags, flock->start, flock->length,
  1887. flock->proc_id, flock->client_id);
  1888. if (IS_ERR(req))
  1889. return PTR_ERR(req);
  1890. err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status);
  1891. if (err) {
  1892. trace_9p_protocol_dump(clnt, &req->rc);
  1893. goto error;
  1894. }
  1895. p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
  1896. error:
  1897. p9_tag_remove(clnt, req);
  1898. return err;
  1899. }
  1900. EXPORT_SYMBOL(p9_client_lock_dotl);
  1901. int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
  1902. {
  1903. int err;
  1904. struct p9_client *clnt;
  1905. struct p9_req_t *req;
  1906. err = 0;
  1907. clnt = fid->clnt;
  1908. p9_debug(P9_DEBUG_9P, ">>> TGETLOCK fid %d, type %i start %lld "
  1909. "length %lld proc_id %d client_id %s\n", fid->fid, glock->type,
  1910. glock->start, glock->length, glock->proc_id, glock->client_id);
  1911. req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid, glock->type,
  1912. glock->start, glock->length, glock->proc_id, glock->client_id);
  1913. if (IS_ERR(req))
  1914. return PTR_ERR(req);
  1915. err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type,
  1916. &glock->start, &glock->length, &glock->proc_id,
  1917. &glock->client_id);
  1918. if (err) {
  1919. trace_9p_protocol_dump(clnt, &req->rc);
  1920. goto error;
  1921. }
  1922. p9_debug(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "
  1923. "proc_id %d client_id %s\n", glock->type, glock->start,
  1924. glock->length, glock->proc_id, glock->client_id);
  1925. error:
  1926. p9_tag_remove(clnt, req);
  1927. return err;
  1928. }
  1929. EXPORT_SYMBOL(p9_client_getlock_dotl);
  1930. int p9_client_readlink(struct p9_fid *fid, char **target)
  1931. {
  1932. int err;
  1933. struct p9_client *clnt;
  1934. struct p9_req_t *req;
  1935. err = 0;
  1936. clnt = fid->clnt;
  1937. p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);
  1938. req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
  1939. if (IS_ERR(req))
  1940. return PTR_ERR(req);
  1941. err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target);
  1942. if (err) {
  1943. trace_9p_protocol_dump(clnt, &req->rc);
  1944. goto error;
  1945. }
  1946. p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
  1947. error:
  1948. p9_tag_remove(clnt, req);
  1949. return err;
  1950. }
  1951. EXPORT_SYMBOL(p9_client_readlink);
  1952. int __init p9_client_init(void)
  1953. {
  1954. p9_req_cache = KMEM_CACHE(p9_req_t, SLAB_TYPESAFE_BY_RCU);
  1955. return p9_req_cache ? 0 : -ENOMEM;
  1956. }
  1957. void __exit p9_client_exit(void)
  1958. {
  1959. kmem_cache_destroy(p9_req_cache);
  1960. }