client.c 53 KB

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