1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
6 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/module.h>
12 #include <linux/errno.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>
28 #define CREATE_TRACE_POINTS
29 #include <trace/events/9p.h>
31 #define DEFAULT_MSIZE (128 * 1024)
33 /* Client Option Parsing (code inspired by NFS code)
34 * - a little lazy - parse all client options
45 static const match_table_t tokens = {
46 {Opt_msize, "msize=%u"},
47 {Opt_legacy, "noextend"},
48 {Opt_trans, "trans=%s"},
49 {Opt_version, "version=%s"},
53 inline int p9_is_proto_dotl(struct p9_client *clnt)
55 return clnt->proto_version == p9_proto_2000L;
57 EXPORT_SYMBOL(p9_is_proto_dotl);
59 inline int p9_is_proto_dotu(struct p9_client *clnt)
61 return clnt->proto_version == p9_proto_2000u;
63 EXPORT_SYMBOL(p9_is_proto_dotu);
65 int p9_show_client_options(struct seq_file *m, struct p9_client *clnt)
67 if (clnt->msize != DEFAULT_MSIZE)
68 seq_printf(m, ",msize=%u", clnt->msize);
69 seq_printf(m, ",trans=%s", clnt->trans_mod->name);
71 switch (clnt->proto_version) {
73 seq_puts(m, ",noextend");
76 seq_puts(m, ",version=9p2000.u");
83 if (clnt->trans_mod->show_options)
84 return clnt->trans_mod->show_options(m, clnt);
87 EXPORT_SYMBOL(p9_show_client_options);
89 /* Some error codes are taken directly from the server replies,
90 * make sure they are valid.
92 static int safe_errno(int err)
94 if (err > 0 || err < -MAX_ERRNO) {
95 p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err);
101 /* Interpret mount option for protocol version */
102 static int get_protocol_version(char *s)
104 int version = -EINVAL;
106 if (!strcmp(s, "9p2000")) {
107 version = p9_proto_legacy;
108 p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n");
109 } else if (!strcmp(s, "9p2000.u")) {
110 version = p9_proto_2000u;
111 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
112 } else if (!strcmp(s, "9p2000.L")) {
113 version = p9_proto_2000L;
114 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
116 pr_info("Unknown protocol version %s\n", s);
123 * parse_opts - parse mount options into client structure
124 * @opts: options string passed from mount
125 * @clnt: existing v9fs client information
127 * Return 0 upon success, -ERRNO upon failure
130 static int parse_opts(char *opts, struct p9_client *clnt)
132 char *options, *tmp_options;
134 substring_t args[MAX_OPT_ARGS];
139 clnt->proto_version = p9_proto_2000L;
140 clnt->msize = DEFAULT_MSIZE;
145 tmp_options = kstrdup(opts, GFP_KERNEL);
148 options = tmp_options;
150 while ((p = strsep(&options, ",")) != NULL) {
155 token = match_token(p, tokens, args);
158 r = match_int(&args[0], &option);
160 p9_debug(P9_DEBUG_ERROR,
161 "integer field, but no integer?\n");
166 p9_debug(P9_DEBUG_ERROR,
167 "msize should be at least 4k\n");
171 clnt->msize = option;
174 s = match_strdup(&args[0]);
177 p9_debug(P9_DEBUG_ERROR,
178 "problem allocating copy of trans arg\n");
179 goto free_and_return;
182 v9fs_put_trans(clnt->trans_mod);
183 clnt->trans_mod = v9fs_get_trans_by_name(s);
184 if (!clnt->trans_mod) {
185 pr_info("Could not find request transport: %s\n",
192 clnt->proto_version = p9_proto_legacy;
195 s = match_strdup(&args[0]);
198 p9_debug(P9_DEBUG_ERROR,
199 "problem allocating copy of version arg\n");
200 goto free_and_return;
202 r = get_protocol_version(s);
206 clnt->proto_version = r;
216 v9fs_put_trans(clnt->trans_mod);
221 static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc,
224 if (likely(c->fcall_cache) && alloc_msize == c->msize) {
225 fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS);
226 fc->cache = c->fcall_cache;
228 fc->sdata = kmalloc(alloc_msize, GFP_NOFS);
233 fc->capacity = alloc_msize;
237 void p9_fcall_fini(struct p9_fcall *fc)
239 /* sdata can be NULL for interrupted requests in trans_rdma,
240 * and kmem_cache_free does not do NULL-check for us
242 if (unlikely(!fc->sdata))
246 kmem_cache_free(fc->cache, fc->sdata);
250 EXPORT_SYMBOL(p9_fcall_fini);
252 static struct kmem_cache *p9_req_cache;
255 * p9_tag_alloc - Allocate a new request.
256 * @c: Client session.
257 * @type: Transaction type.
258 * @t_size: Buffer size for holding this request
259 * (automatic calculation by format template if 0).
260 * @r_size: Buffer size for holding server's reply on this request
261 * (automatic calculation by format template if 0).
262 * @fmt: Format template for assembling 9p request message
263 * (see p9pdu_vwritef).
264 * @ap: Variable arguments to be fed to passed format template
265 * (see p9pdu_vwritef).
267 * Context: Process context.
268 * Return: Pointer to new request.
270 static struct p9_req_t *
271 p9_tag_alloc(struct p9_client *c, int8_t type, uint t_size, uint r_size,
272 const char *fmt, va_list ap)
274 struct p9_req_t *req = kmem_cache_alloc(p9_req_cache, GFP_NOFS);
281 alloc_tsize = min_t(size_t, c->msize,
282 t_size ?: p9_msg_buf_size(c, type, fmt, apc));
285 alloc_rsize = min_t(size_t, c->msize,
286 r_size ?: p9_msg_buf_size(c, type + 1, fmt, ap));
289 return ERR_PTR(-ENOMEM);
291 if (p9_fcall_init(c, &req->tc, alloc_tsize))
293 if (p9_fcall_init(c, &req->rc, alloc_rsize))
296 p9pdu_reset(&req->tc);
297 p9pdu_reset(&req->rc);
299 req->status = REQ_STATUS_ALLOC;
300 /* refcount needs to be set to 0 before inserting into the idr
301 * so p9_tag_lookup does not accept a request that is not fully
302 * initialized. refcount_set to 2 below will mark request ready.
304 refcount_set(&req->refcount, 0);
305 init_waitqueue_head(&req->wq);
306 INIT_LIST_HEAD(&req->req_list);
308 idr_preload(GFP_NOFS);
309 spin_lock_irq(&c->lock);
310 if (type == P9_TVERSION)
311 tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1,
314 tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT);
316 spin_unlock_irq(&c->lock);
321 /* Init ref to two because in the general case there is one ref
322 * that is put asynchronously by a writer thread, one ref
323 * temporarily given by p9_tag_lookup and put by p9_client_cb
324 * in the recv thread, and one ref put by p9_req_put in the
325 * main thread. The only exception is virtio that does not use
326 * p9_tag_lookup but does not have a writer thread either
327 * (the write happens synchronously in the request/zc_request
328 * callback), so p9_client_cb eats the second ref there
329 * as the pointer is duplicated directly by virtqueue_add_sgs()
331 refcount_set(&req->refcount, 2);
336 p9_fcall_fini(&req->tc);
337 p9_fcall_fini(&req->rc);
339 kmem_cache_free(p9_req_cache, req);
340 return ERR_PTR(-ENOMEM);
344 * p9_tag_lookup - Look up a request by tag.
345 * @c: Client session.
346 * @tag: Transaction ID.
348 * Context: Any context.
349 * Return: A request, or %NULL if there is no request with that tag.
351 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
353 struct p9_req_t *req;
357 req = idr_find(&c->reqs, tag);
359 /* We have to be careful with the req found under rcu_read_lock
360 * Thanks to SLAB_TYPESAFE_BY_RCU we can safely try to get the
361 * ref again without corrupting other data, then check again
362 * that the tag matches once we have the ref
364 if (!p9_req_try_get(req))
366 if (req->tc.tag != tag) {
375 EXPORT_SYMBOL(p9_tag_lookup);
378 * p9_tag_remove - Remove a tag.
379 * @c: Client session.
380 * @r: Request of reference.
382 * Context: Any context.
384 static void p9_tag_remove(struct p9_client *c, struct p9_req_t *r)
389 p9_debug(P9_DEBUG_MUX, "freeing clnt %p req %p tag: %d\n", c, r, tag);
390 spin_lock_irqsave(&c->lock, flags);
391 idr_remove(&c->reqs, tag);
392 spin_unlock_irqrestore(&c->lock, flags);
395 int p9_req_put(struct p9_client *c, struct p9_req_t *r)
397 if (refcount_dec_and_test(&r->refcount)) {
400 p9_fcall_fini(&r->tc);
401 p9_fcall_fini(&r->rc);
402 kmem_cache_free(p9_req_cache, r);
407 EXPORT_SYMBOL(p9_req_put);
410 * p9_tag_cleanup - cleans up tags structure and reclaims resources
411 * @c: v9fs client struct
413 * This frees resources associated with the tags structure
416 static void p9_tag_cleanup(struct p9_client *c)
418 struct p9_req_t *req;
422 idr_for_each_entry(&c->reqs, req, id) {
423 pr_info("Tag %d still in use\n", id);
424 if (p9_req_put(c, req) == 0)
425 pr_warn("Packet with tag %d has still references",
432 * p9_client_cb - call back from transport to client
434 * @req: request received
435 * @status: request status, one of REQ_STATUS_*
438 void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status)
440 p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag);
442 /* This barrier is needed to make sure any change made to req before
443 * the status change is visible to another thread
446 WRITE_ONCE(req->status, status);
449 p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag);
452 EXPORT_SYMBOL(p9_client_cb);
455 * p9_parse_header - parse header arguments out of a packet
456 * @pdu: packet to parse
457 * @size: size of packet
458 * @type: type of request
459 * @tag: tag of packet
460 * @rewind: set if we need to rewind offset afterwards
464 p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type,
465 int16_t *tag, int rewind)
470 int offset = pdu->offset;
475 err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
477 goto rewind_and_exit;
486 if (pdu->size != r_size || r_size < 7) {
488 goto rewind_and_exit;
494 p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n",
495 pdu->size, pdu->id, pdu->tag);
499 pdu->offset = offset;
502 EXPORT_SYMBOL(p9_parse_header);
505 * p9_check_errors - check 9p packet for error return and process it
506 * @c: current client instance
507 * @req: request to parse and check for error conditions
509 * returns error code if one is discovered, otherwise returns 0
511 * this will have to be more complicated if we have multiple
515 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
521 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
522 if (req->rc.size >= c->msize) {
523 p9_debug(P9_DEBUG_ERROR,
524 "requested packet size too big: %d\n",
528 /* dump the response from server
529 * This should be after check errors which poplulate pdu_fcall.
531 trace_9p_protocol_dump(c, &req->rc);
533 p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
536 if (type != P9_RERROR && type != P9_RLERROR)
539 if (!p9_is_proto_dotl(c)) {
542 err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
549 if (p9_is_proto_dotu(c) && ecode < 512)
553 err = p9_errstr2errno(ename, strlen(ename));
555 p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
560 err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode);
565 p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
571 p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
576 static struct p9_req_t *
577 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
580 * p9_client_flush - flush (cancel) a request
582 * @oldreq: request to cancel
584 * This sents a flush for a particular request and links
585 * the flush request to the original request. The current
586 * code only supports a single flush request although the protocol
587 * allows for multiple flush requests to be sent for a single request.
591 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
593 struct p9_req_t *req;
597 err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1);
601 p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
603 req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
607 /* if we haven't received a response for oldreq,
608 * remove it from the list
610 if (READ_ONCE(oldreq->status) == REQ_STATUS_SENT) {
611 if (c->trans_mod->cancelled)
612 c->trans_mod->cancelled(c, oldreq);
619 static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
620 int8_t type, uint t_size, uint r_size,
621 const char *fmt, va_list ap)
624 struct p9_req_t *req;
627 p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type);
629 /* we allow for any status other than disconnected */
630 if (c->status == Disconnected)
631 return ERR_PTR(-EIO);
633 /* if status is begin_disconnected we allow only clunk request */
634 if (c->status == BeginDisconnect && type != P9_TCLUNK)
635 return ERR_PTR(-EIO);
638 req = p9_tag_alloc(c, type, t_size, r_size, fmt, apc);
643 /* marshall the data */
644 p9pdu_prepare(&req->tc, req->tc.tag, type);
645 err = p9pdu_vwritef(&req->tc, c->proto_version, fmt, ap);
648 p9pdu_finalize(c, &req->tc);
649 trace_9p_client_req(c, type, req->tc.tag);
653 /* We have to put also the 2nd reference as it won't be used */
659 * p9_client_rpc - issue a request and wait for a response
661 * @type: type of request
662 * @fmt: protocol format string (see protocol.c)
664 * Returns request structure (which client must free using p9_req_put)
667 static struct p9_req_t *
668 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
673 struct p9_req_t *req;
674 /* Passing zero for tsize/rsize to p9_client_prepare_req() tells it to
675 * auto determine an appropriate (small) request/response size
676 * according to actual message data being sent. Currently RDMA
677 * transport is excluded from this response message size optimization,
678 * as it would not cope with it, due to its pooled response buffers
679 * (using an optimized request size for RDMA as well though).
681 const uint tsize = 0;
682 const uint rsize = c->trans_mod->pooled_rbuffers ? c->msize : 0;
685 req = p9_client_prepare_req(c, type, tsize, rsize, fmt, ap);
690 if (signal_pending(current)) {
692 clear_thread_flag(TIF_SIGPENDING);
697 err = c->trans_mod->request(c, req);
699 /* write won't happen */
701 if (err != -ERESTARTSYS && err != -EFAULT)
702 c->status = Disconnected;
703 goto recalc_sigpending;
706 /* Wait for the response */
707 err = wait_event_killable(req->wq,
708 READ_ONCE(req->status) >= REQ_STATUS_RCVD);
710 /* Make sure our req is coherent with regard to updates in other
711 * threads - echoes to wmb() in the callback
715 if (err == -ERESTARTSYS && c->status == Connected &&
718 clear_thread_flag(TIF_SIGPENDING);
722 if (READ_ONCE(req->status) == REQ_STATUS_ERROR) {
723 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
726 if (err == -ERESTARTSYS && c->status == Connected) {
727 p9_debug(P9_DEBUG_MUX, "flushing\n");
729 clear_thread_flag(TIF_SIGPENDING);
731 if (c->trans_mod->cancel(c, req))
732 p9_client_flush(c, req);
734 /* if we received the response anyway, don't signal error */
735 if (READ_ONCE(req->status) == REQ_STATUS_RCVD)
740 spin_lock_irqsave(¤t->sighand->siglock, flags);
742 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
747 err = p9_check_errors(c, req);
748 trace_9p_client_res(c, type, req->rc.tag, err);
753 return ERR_PTR(safe_errno(err));
757 * p9_client_zc_rpc - issue a request and wait for a response
759 * @type: type of request
760 * @uidata: destination for zero copy read
761 * @uodata: source for zero copy write
762 * @inlen: read buffer size
763 * @olen: write buffer size
764 * @in_hdrlen: reader header size, This is the size of response protocol data
765 * @fmt: protocol format string (see protocol.c)
767 * Returns request structure (which client must free using p9_req_put)
769 static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
770 struct iov_iter *uidata,
771 struct iov_iter *uodata,
772 int inlen, int olen, int in_hdrlen,
773 const char *fmt, ...)
778 struct p9_req_t *req;
781 /* We allocate a inline protocol data of only 4k bytes.
782 * The actual content is passed in zero-copy fashion.
784 req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, P9_ZC_HDR_SZ, fmt, ap);
789 if (signal_pending(current)) {
791 clear_thread_flag(TIF_SIGPENDING);
796 err = c->trans_mod->zc_request(c, req, uidata, uodata,
797 inlen, olen, in_hdrlen);
800 c->status = Disconnected;
801 if (err != -ERESTARTSYS)
802 goto recalc_sigpending;
804 if (READ_ONCE(req->status) == REQ_STATUS_ERROR) {
805 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
808 if (err == -ERESTARTSYS && c->status == Connected) {
809 p9_debug(P9_DEBUG_MUX, "flushing\n");
811 clear_thread_flag(TIF_SIGPENDING);
813 if (c->trans_mod->cancel(c, req))
814 p9_client_flush(c, req);
816 /* if we received the response anyway, don't signal error */
817 if (READ_ONCE(req->status) == REQ_STATUS_RCVD)
822 spin_lock_irqsave(¤t->sighand->siglock, flags);
824 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
829 err = p9_check_errors(c, req);
830 trace_9p_client_res(c, type, req->rc.tag, err);
835 return ERR_PTR(safe_errno(err));
838 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
843 p9_debug(P9_DEBUG_FID, "clnt %p\n", clnt);
844 fid = kzalloc(sizeof(*fid), GFP_KERNEL);
849 fid->uid = current_fsuid();
851 refcount_set(&fid->count, 1);
853 idr_preload(GFP_KERNEL);
854 spin_lock_irq(&clnt->lock);
855 ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1,
857 spin_unlock_irq(&clnt->lock);
860 trace_9p_fid_ref(fid, P9_FID_REF_CREATE);
868 static void p9_fid_destroy(struct p9_fid *fid)
870 struct p9_client *clnt;
873 p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid);
874 trace_9p_fid_ref(fid, P9_FID_REF_DESTROY);
876 spin_lock_irqsave(&clnt->lock, flags);
877 idr_remove(&clnt->fids, fid->fid);
878 spin_unlock_irqrestore(&clnt->lock, flags);
883 /* We also need to export tracepoint symbols for tracepoint_enabled() */
884 EXPORT_TRACEPOINT_SYMBOL(9p_fid_ref);
886 void do_trace_9p_fid_get(struct p9_fid *fid)
888 trace_9p_fid_ref(fid, P9_FID_REF_GET);
890 EXPORT_SYMBOL(do_trace_9p_fid_get);
892 void do_trace_9p_fid_put(struct p9_fid *fid)
894 trace_9p_fid_ref(fid, P9_FID_REF_PUT);
896 EXPORT_SYMBOL(do_trace_9p_fid_put);
898 static int p9_client_version(struct p9_client *c)
901 struct p9_req_t *req;
902 char *version = NULL;
905 p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
906 c->msize, c->proto_version);
908 switch (c->proto_version) {
910 req = p9_client_rpc(c, P9_TVERSION, "ds",
911 c->msize, "9P2000.L");
914 req = p9_client_rpc(c, P9_TVERSION, "ds",
915 c->msize, "9P2000.u");
917 case p9_proto_legacy:
918 req = p9_client_rpc(c, P9_TVERSION, "ds",
928 err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version);
930 p9_debug(P9_DEBUG_9P, "version error %d\n", err);
931 trace_9p_protocol_dump(c, &req->rc);
935 p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
936 if (!strncmp(version, "9P2000.L", 8)) {
937 c->proto_version = p9_proto_2000L;
938 } else if (!strncmp(version, "9P2000.u", 8)) {
939 c->proto_version = p9_proto_2000u;
940 } else if (!strncmp(version, "9P2000", 6)) {
941 c->proto_version = p9_proto_legacy;
943 p9_debug(P9_DEBUG_ERROR,
944 "server returned an unknown version: %s\n", version);
950 p9_debug(P9_DEBUG_ERROR,
951 "server returned a msize < 4096: %d\n", msize);
955 if (msize < c->msize)
965 struct p9_client *p9_client_create(const char *dev_name, char *options)
968 struct p9_client *clnt;
972 clnt = kmalloc(sizeof(*clnt), GFP_KERNEL);
974 return ERR_PTR(-ENOMEM);
976 clnt->trans_mod = NULL;
978 clnt->fcall_cache = NULL;
980 client_id = utsname()->nodename;
981 memcpy(clnt->name, client_id, strlen(client_id) + 1);
983 spin_lock_init(&clnt->lock);
984 idr_init(&clnt->fids);
985 idr_init(&clnt->reqs);
987 err = parse_opts(options, clnt);
991 if (!clnt->trans_mod)
992 clnt->trans_mod = v9fs_get_default_trans();
994 if (!clnt->trans_mod) {
995 err = -EPROTONOSUPPORT;
996 p9_debug(P9_DEBUG_ERROR,
997 "No transport defined or default transport\n");
1001 p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
1002 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
1004 err = clnt->trans_mod->create(clnt, dev_name, options);
1008 if (clnt->msize > clnt->trans_mod->maxsize) {
1009 clnt->msize = clnt->trans_mod->maxsize;
1010 pr_info("Limiting 'msize' to %d as this is the maximum "
1011 "supported by transport %s\n",
1012 clnt->msize, clnt->trans_mod->name
1016 if (clnt->msize < 4096) {
1017 p9_debug(P9_DEBUG_ERROR,
1018 "Please specify a msize of at least 4k\n");
1023 err = p9_client_version(clnt);
1027 /* P9_HDRSZ + 4 is the smallest packet header we can have that is
1028 * followed by data accessed from userspace by read
1031 kmem_cache_create_usercopy("9p-fcall-cache", clnt->msize,
1033 clnt->msize - (P9_HDRSZ + 4),
1039 clnt->trans_mod->close(clnt);
1041 v9fs_put_trans(clnt->trans_mod);
1044 return ERR_PTR(err);
1046 EXPORT_SYMBOL(p9_client_create);
1048 void p9_client_destroy(struct p9_client *clnt)
1053 p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt);
1055 if (clnt->trans_mod)
1056 clnt->trans_mod->close(clnt);
1058 v9fs_put_trans(clnt->trans_mod);
1060 idr_for_each_entry(&clnt->fids, fid, id) {
1061 pr_info("Found fid %d not clunked\n", fid->fid);
1062 p9_fid_destroy(fid);
1065 p9_tag_cleanup(clnt);
1067 kmem_cache_destroy(clnt->fcall_cache);
1070 EXPORT_SYMBOL(p9_client_destroy);
1072 void p9_client_disconnect(struct p9_client *clnt)
1074 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
1075 clnt->status = Disconnected;
1077 EXPORT_SYMBOL(p9_client_disconnect);
1079 void p9_client_begin_disconnect(struct p9_client *clnt)
1081 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
1082 clnt->status = BeginDisconnect;
1084 EXPORT_SYMBOL(p9_client_begin_disconnect);
1086 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
1087 const char *uname, kuid_t n_uname,
1091 struct p9_req_t *req;
1095 p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
1096 afid ? afid->fid : -1, uname, aname);
1097 fid = p9_fid_create(clnt);
1104 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
1105 afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
1111 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", &qid);
1113 trace_9p_protocol_dump(clnt, &req->rc);
1114 p9_req_put(clnt, req);
1118 p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
1119 qid.type, qid.path, qid.version);
1121 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1123 p9_req_put(clnt, req);
1128 p9_fid_destroy(fid);
1129 return ERR_PTR(err);
1131 EXPORT_SYMBOL(p9_client_attach);
1133 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
1134 const unsigned char * const *wnames, int clone)
1137 struct p9_client *clnt;
1139 struct p9_qid *wqids;
1140 struct p9_req_t *req;
1145 clnt = oldfid->clnt;
1147 fid = p9_fid_create(clnt);
1153 fid->uid = oldfid->uid;
1158 p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
1159 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
1160 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
1167 err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids);
1169 trace_9p_protocol_dump(clnt, &req->rc);
1170 p9_req_put(clnt, req);
1173 p9_req_put(clnt, req);
1175 p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
1177 if (nwqids != nwname) {
1182 for (count = 0; count < nwqids; count++)
1183 p9_debug(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n",
1184 count, wqids[count].type,
1186 wqids[count].version);
1189 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
1191 memmove(&fid->qid, &oldfid->qid, sizeof(struct p9_qid));
1202 if (fid && fid != oldfid)
1203 p9_fid_destroy(fid);
1205 return ERR_PTR(err);
1207 EXPORT_SYMBOL(p9_client_walk);
1209 int p9_client_open(struct p9_fid *fid, int mode)
1212 struct p9_client *clnt;
1213 struct p9_req_t *req;
1218 p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
1219 p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
1222 if (fid->mode != -1)
1225 if (p9_is_proto_dotl(clnt))
1226 req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
1228 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
1234 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1236 trace_9p_protocol_dump(clnt, &req->rc);
1237 goto free_and_error;
1240 p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
1241 p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN", qid.type,
1242 qid.path, qid.version, iounit);
1244 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1246 fid->iounit = iounit;
1249 p9_req_put(clnt, req);
1253 EXPORT_SYMBOL(p9_client_open);
1255 int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags,
1256 u32 mode, kgid_t gid, struct p9_qid *qid)
1259 struct p9_client *clnt;
1260 struct p9_req_t *req;
1263 p9_debug(P9_DEBUG_9P,
1264 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1265 ofid->fid, name, flags, mode,
1266 from_kgid(&init_user_ns, gid));
1269 if (ofid->mode != -1)
1272 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
1279 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit);
1281 trace_9p_protocol_dump(clnt, &req->rc);
1282 goto free_and_error;
1285 p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1286 qid->type, qid->path, qid->version, iounit);
1288 memmove(&ofid->qid, qid, sizeof(struct p9_qid));
1290 ofid->iounit = iounit;
1293 p9_req_put(clnt, req);
1297 EXPORT_SYMBOL(p9_client_create_dotl);
1299 int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode,
1303 struct p9_client *clnt;
1304 struct p9_req_t *req;
1308 p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1309 fid->fid, name, perm, mode);
1313 if (fid->mode != -1)
1316 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1323 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1325 trace_9p_protocol_dump(clnt, &req->rc);
1326 goto free_and_error;
1329 p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1330 qid.type, qid.path, qid.version, iounit);
1332 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1334 fid->iounit = iounit;
1337 p9_req_put(clnt, req);
1341 EXPORT_SYMBOL(p9_client_fcreate);
1343 int p9_client_symlink(struct p9_fid *dfid, const char *name,
1344 const char *symtgt, kgid_t gid, struct p9_qid *qid)
1347 struct p9_client *clnt;
1348 struct p9_req_t *req;
1350 p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
1351 dfid->fid, name, symtgt);
1354 req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
1361 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
1363 trace_9p_protocol_dump(clnt, &req->rc);
1364 goto free_and_error;
1367 p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
1368 qid->type, qid->path, qid->version);
1371 p9_req_put(clnt, req);
1375 EXPORT_SYMBOL(p9_client_symlink);
1377 int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, const char *newname)
1379 struct p9_client *clnt;
1380 struct p9_req_t *req;
1382 p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
1383 dfid->fid, oldfid->fid, newname);
1385 req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
1388 return PTR_ERR(req);
1390 p9_debug(P9_DEBUG_9P, "<<< RLINK\n");
1391 p9_req_put(clnt, req);
1394 EXPORT_SYMBOL(p9_client_link);
1396 int p9_client_fsync(struct p9_fid *fid, int datasync)
1399 struct p9_client *clnt;
1400 struct p9_req_t *req;
1402 p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d\n",
1403 fid->fid, datasync);
1407 req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
1413 p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);
1415 p9_req_put(clnt, req);
1420 EXPORT_SYMBOL(p9_client_fsync);
1422 int p9_client_clunk(struct p9_fid *fid)
1425 struct p9_client *clnt;
1426 struct p9_req_t *req;
1430 p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n",
1435 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1441 p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1443 p9_req_put(clnt, req);
1445 /* Fid is not valid even after a failed clunk
1446 * If interrupted, retry once then give up and
1447 * leak fid until umount.
1449 if (err == -ERESTARTSYS) {
1453 p9_fid_destroy(fid);
1457 EXPORT_SYMBOL(p9_client_clunk);
1459 int p9_client_remove(struct p9_fid *fid)
1462 struct p9_client *clnt;
1463 struct p9_req_t *req;
1465 p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1469 req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1475 p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1477 p9_req_put(clnt, req);
1479 if (err == -ERESTARTSYS)
1482 p9_fid_destroy(fid);
1485 EXPORT_SYMBOL(p9_client_remove);
1487 int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
1490 struct p9_req_t *req;
1491 struct p9_client *clnt;
1493 p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
1494 dfid->fid, name, flags);
1497 req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
1502 p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
1504 p9_req_put(clnt, req);
1508 EXPORT_SYMBOL(p9_client_unlinkat);
1511 p9_client_read(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err)
1516 while (iov_iter_count(to)) {
1519 count = p9_client_read_once(fid, offset, to, err);
1527 EXPORT_SYMBOL(p9_client_read);
1530 p9_client_read_once(struct p9_fid *fid, u64 offset, struct iov_iter *to,
1533 struct p9_client *clnt = fid->clnt;
1534 struct p9_req_t *req;
1535 int count = iov_iter_count(to);
1536 int rsize, received, non_zc = 0;
1540 p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %zu\n",
1541 fid->fid, offset, iov_iter_count(to));
1543 rsize = fid->iounit;
1544 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ)
1545 rsize = clnt->msize - P9_IOHDRSZ;
1550 /* Don't bother zerocopy for small IO (< 1024) */
1551 if (clnt->trans_mod->zc_request && rsize > 1024) {
1552 /* response header len is 11
1553 * PDU Header(7) + IO Size (4)
1555 req = p9_client_zc_rpc(clnt, P9_TREAD, to, NULL, rsize,
1556 0, 11, "dqd", fid->fid,
1560 req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
1564 *err = PTR_ERR(req);
1566 iov_iter_revert(to, count - iov_iter_count(to));
1570 *err = p9pdu_readf(&req->rc, clnt->proto_version,
1571 "D", &received, &dataptr);
1574 iov_iter_revert(to, count - iov_iter_count(to));
1575 trace_9p_protocol_dump(clnt, &req->rc);
1576 p9_req_put(clnt, req);
1579 if (rsize < received) {
1580 pr_err("bogus RREAD count (%d > %d)\n", received, rsize);
1584 p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", received);
1587 int n = copy_to_iter(dataptr, received, to);
1589 if (n != received) {
1591 p9_req_put(clnt, req);
1595 iov_iter_revert(to, count - received - iov_iter_count(to));
1597 p9_req_put(clnt, req);
1600 EXPORT_SYMBOL(p9_client_read_once);
1603 p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err)
1605 struct p9_client *clnt = fid->clnt;
1606 struct p9_req_t *req;
1610 while (iov_iter_count(from)) {
1611 int count = iov_iter_count(from);
1612 int rsize = fid->iounit;
1615 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ)
1616 rsize = clnt->msize - P9_IOHDRSZ;
1621 p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %d (/%d)\n",
1622 fid->fid, offset, rsize, count);
1624 /* Don't bother zerocopy for small IO (< 1024) */
1625 if (clnt->trans_mod->zc_request && rsize > 1024) {
1626 req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, from, 0,
1627 rsize, P9_ZC_HDR_SZ, "dqd",
1628 fid->fid, offset, rsize);
1630 req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
1631 offset, rsize, from);
1634 iov_iter_revert(from, count - iov_iter_count(from));
1635 *err = PTR_ERR(req);
1639 *err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &written);
1641 iov_iter_revert(from, count - iov_iter_count(from));
1642 trace_9p_protocol_dump(clnt, &req->rc);
1643 p9_req_put(clnt, req);
1646 if (rsize < written) {
1647 pr_err("bogus RWRITE count (%d > %d)\n", written, rsize);
1651 p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", written);
1653 p9_req_put(clnt, req);
1654 iov_iter_revert(from, count - written - iov_iter_count(from));
1660 EXPORT_SYMBOL(p9_client_write);
1662 struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1665 struct p9_client *clnt;
1666 struct p9_wstat *ret;
1667 struct p9_req_t *req;
1670 p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1672 ret = kmalloc(sizeof(*ret), GFP_KERNEL);
1674 return ERR_PTR(-ENOMEM);
1679 req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1685 err = p9pdu_readf(&req->rc, clnt->proto_version, "wS", &ignored, ret);
1687 trace_9p_protocol_dump(clnt, &req->rc);
1688 p9_req_put(clnt, req);
1692 p9_debug(P9_DEBUG_9P,
1693 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1694 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1695 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1696 "<<< uid=%d gid=%d n_muid=%d\n",
1697 ret->size, ret->type, ret->dev, ret->qid.type, ret->qid.path,
1698 ret->qid.version, ret->mode,
1699 ret->atime, ret->mtime, ret->length,
1700 ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
1701 from_kuid(&init_user_ns, ret->n_uid),
1702 from_kgid(&init_user_ns, ret->n_gid),
1703 from_kuid(&init_user_ns, ret->n_muid));
1705 p9_req_put(clnt, req);
1710 return ERR_PTR(err);
1712 EXPORT_SYMBOL(p9_client_stat);
1714 struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
1718 struct p9_client *clnt;
1719 struct p9_stat_dotl *ret;
1720 struct p9_req_t *req;
1722 p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
1723 fid->fid, request_mask);
1725 ret = kmalloc(sizeof(*ret), GFP_KERNEL);
1727 return ERR_PTR(-ENOMEM);
1732 req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
1738 err = p9pdu_readf(&req->rc, clnt->proto_version, "A", ret);
1740 trace_9p_protocol_dump(clnt, &req->rc);
1741 p9_req_put(clnt, req);
1745 p9_debug(P9_DEBUG_9P, "<<< RGETATTR st_result_mask=%lld\n"
1746 "<<< qid=%x.%llx.%x\n"
1747 "<<< st_mode=%8.8x st_nlink=%llu\n"
1748 "<<< st_uid=%d st_gid=%d\n"
1749 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1750 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1751 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1752 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1753 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1754 "<<< st_gen=%lld st_data_version=%lld\n",
1755 ret->st_result_mask,
1756 ret->qid.type, ret->qid.path, ret->qid.version,
1757 ret->st_mode, ret->st_nlink,
1758 from_kuid(&init_user_ns, ret->st_uid),
1759 from_kgid(&init_user_ns, ret->st_gid),
1760 ret->st_rdev, ret->st_size, ret->st_blksize, ret->st_blocks,
1761 ret->st_atime_sec, ret->st_atime_nsec,
1762 ret->st_mtime_sec, ret->st_mtime_nsec,
1763 ret->st_ctime_sec, ret->st_ctime_nsec,
1764 ret->st_btime_sec, ret->st_btime_nsec,
1765 ret->st_gen, ret->st_data_version);
1767 p9_req_put(clnt, req);
1772 return ERR_PTR(err);
1774 EXPORT_SYMBOL(p9_client_getattr_dotl);
1776 static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
1780 /* NOTE: size shouldn't include its own length */
1781 /* size[2] type[2] dev[4] qid[13] */
1782 /* mode[4] atime[4] mtime[4] length[8]*/
1783 /* name[s] uid[s] gid[s] muid[s] */
1784 ret = 2 + 4 + 13 + 4 + 4 + 4 + 8 + 2 + 2 + 2 + 2;
1787 ret += strlen(wst->name);
1789 ret += strlen(wst->uid);
1791 ret += strlen(wst->gid);
1793 ret += strlen(wst->muid);
1795 if (proto_version == p9_proto_2000u ||
1796 proto_version == p9_proto_2000L) {
1797 /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1798 ret += 2 + 4 + 4 + 4;
1800 ret += strlen(wst->extension);
1806 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
1809 struct p9_req_t *req;
1810 struct p9_client *clnt;
1814 wst->size = p9_client_statsize(wst, clnt->proto_version);
1815 p9_debug(P9_DEBUG_9P, ">>> TWSTAT fid %d\n",
1817 p9_debug(P9_DEBUG_9P,
1818 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1819 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1820 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1821 " uid=%d gid=%d n_muid=%d\n",
1822 wst->size, wst->type, wst->dev, wst->qid.type,
1823 wst->qid.path, wst->qid.version,
1824 wst->mode, wst->atime, wst->mtime, wst->length,
1825 wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
1826 from_kuid(&init_user_ns, wst->n_uid),
1827 from_kgid(&init_user_ns, wst->n_gid),
1828 from_kuid(&init_user_ns, wst->n_muid));
1830 req = p9_client_rpc(clnt, P9_TWSTAT, "dwS",
1831 fid->fid, wst->size + 2, wst);
1837 p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1839 p9_req_put(clnt, req);
1843 EXPORT_SYMBOL(p9_client_wstat);
1845 int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
1848 struct p9_req_t *req;
1849 struct p9_client *clnt;
1853 p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
1854 p9_debug(P9_DEBUG_9P, " valid=%x mode=%x uid=%d gid=%d size=%lld\n",
1855 p9attr->valid, p9attr->mode,
1856 from_kuid(&init_user_ns, p9attr->uid),
1857 from_kgid(&init_user_ns, p9attr->gid),
1859 p9_debug(P9_DEBUG_9P, " atime_sec=%lld atime_nsec=%lld\n",
1860 p9attr->atime_sec, p9attr->atime_nsec);
1861 p9_debug(P9_DEBUG_9P, " mtime_sec=%lld mtime_nsec=%lld\n",
1862 p9attr->mtime_sec, p9attr->mtime_nsec);
1864 req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
1870 p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
1871 p9_req_put(clnt, req);
1875 EXPORT_SYMBOL(p9_client_setattr);
1877 int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
1880 struct p9_req_t *req;
1881 struct p9_client *clnt;
1886 p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
1888 req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
1894 err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
1895 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
1896 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
1898 trace_9p_protocol_dump(clnt, &req->rc);
1899 p9_req_put(clnt, req);
1903 p9_debug(P9_DEBUG_9P,
1904 "<<< RSTATFS fid %d type 0x%x bsize %u blocks %llu bfree %llu bavail %llu files %llu ffree %llu fsid %llu namelen %u\n",
1905 fid->fid, sb->type, sb->bsize, sb->blocks, sb->bfree,
1906 sb->bavail, sb->files, sb->ffree, sb->fsid, sb->namelen);
1908 p9_req_put(clnt, req);
1912 EXPORT_SYMBOL(p9_client_statfs);
1914 int p9_client_rename(struct p9_fid *fid,
1915 struct p9_fid *newdirfid, const char *name)
1918 struct p9_req_t *req;
1919 struct p9_client *clnt;
1924 p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
1925 fid->fid, newdirfid->fid, name);
1927 req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
1928 newdirfid->fid, name);
1934 p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
1936 p9_req_put(clnt, req);
1940 EXPORT_SYMBOL(p9_client_rename);
1942 int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
1943 struct p9_fid *newdirfid, const char *new_name)
1946 struct p9_req_t *req;
1947 struct p9_client *clnt;
1950 clnt = olddirfid->clnt;
1952 p9_debug(P9_DEBUG_9P,
1953 ">>> TRENAMEAT olddirfid %d old name %s newdirfid %d new name %s\n",
1954 olddirfid->fid, old_name, newdirfid->fid, new_name);
1956 req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
1957 old_name, newdirfid->fid, new_name);
1963 p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
1964 newdirfid->fid, new_name);
1966 p9_req_put(clnt, req);
1970 EXPORT_SYMBOL(p9_client_renameat);
1972 /* An xattrwalk without @attr_name gives the fid for the lisxattr namespace
1974 struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
1975 const char *attr_name, u64 *attr_size)
1978 struct p9_req_t *req;
1979 struct p9_client *clnt;
1980 struct p9_fid *attr_fid;
1983 clnt = file_fid->clnt;
1984 attr_fid = p9_fid_create(clnt);
1989 p9_debug(P9_DEBUG_9P,
1990 ">>> TXATTRWALK file_fid %d, attr_fid %d name '%s'\n",
1991 file_fid->fid, attr_fid->fid, attr_name);
1993 req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
1994 file_fid->fid, attr_fid->fid, attr_name);
1999 err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size);
2001 trace_9p_protocol_dump(clnt, &req->rc);
2002 p9_req_put(clnt, req);
2005 p9_req_put(clnt, req);
2006 p9_debug(P9_DEBUG_9P, "<<< RXATTRWALK fid %d size %llu\n",
2007 attr_fid->fid, *attr_size);
2010 p9_fid_put(attr_fid);
2013 if (attr_fid && attr_fid != file_fid)
2014 p9_fid_destroy(attr_fid);
2016 return ERR_PTR(err);
2018 EXPORT_SYMBOL_GPL(p9_client_xattrwalk);
2020 int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
2021 u64 attr_size, int flags)
2024 struct p9_req_t *req;
2025 struct p9_client *clnt;
2027 p9_debug(P9_DEBUG_9P,
2028 ">>> TXATTRCREATE fid %d name %s size %llu flag %d\n",
2029 fid->fid, name, attr_size, flags);
2032 req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
2033 fid->fid, name, attr_size, flags);
2038 p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
2039 p9_req_put(clnt, req);
2043 EXPORT_SYMBOL_GPL(p9_client_xattrcreate);
2045 int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
2047 int err, rsize, non_zc = 0;
2048 struct p9_client *clnt;
2049 struct p9_req_t *req;
2051 struct kvec kv = {.iov_base = data, .iov_len = count};
2054 iov_iter_kvec(&to, ITER_DEST, &kv, 1, count);
2056 p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
2057 fid->fid, offset, count);
2062 rsize = fid->iounit;
2063 if (!rsize || rsize > clnt->msize - P9_READDIRHDRSZ)
2064 rsize = clnt->msize - P9_READDIRHDRSZ;
2069 /* Don't bother zerocopy for small IO (< 1024) */
2070 if (clnt->trans_mod->zc_request && rsize > 1024) {
2071 /* response header len is 11
2072 * PDU Header(7) + IO Size (4)
2074 req = p9_client_zc_rpc(clnt, P9_TREADDIR, &to, NULL, rsize, 0,
2075 11, "dqd", fid->fid, offset, rsize);
2078 req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
2086 err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr);
2088 trace_9p_protocol_dump(clnt, &req->rc);
2089 goto free_and_error;
2091 if (rsize < count) {
2092 pr_err("bogus RREADDIR count (%d > %d)\n", count, rsize);
2096 p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
2099 memmove(data, dataptr, count);
2101 p9_req_put(clnt, req);
2105 p9_req_put(clnt, req);
2109 EXPORT_SYMBOL(p9_client_readdir);
2111 int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode,
2112 dev_t rdev, kgid_t gid, struct p9_qid *qid)
2115 struct p9_client *clnt;
2116 struct p9_req_t *req;
2120 p9_debug(P9_DEBUG_9P,
2121 ">>> TMKNOD fid %d name %s mode %d major %d minor %d\n",
2122 fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
2123 req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
2124 MAJOR(rdev), MINOR(rdev), gid);
2126 return PTR_ERR(req);
2128 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
2130 trace_9p_protocol_dump(clnt, &req->rc);
2133 p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n",
2134 qid->type, qid->path, qid->version);
2137 p9_req_put(clnt, req);
2140 EXPORT_SYMBOL(p9_client_mknod_dotl);
2142 int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode,
2143 kgid_t gid, struct p9_qid *qid)
2146 struct p9_client *clnt;
2147 struct p9_req_t *req;
2151 p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
2152 fid->fid, name, mode, from_kgid(&init_user_ns, gid));
2153 req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg",
2154 fid->fid, name, mode, gid);
2156 return PTR_ERR(req);
2158 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
2160 trace_9p_protocol_dump(clnt, &req->rc);
2163 p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
2164 qid->path, qid->version);
2167 p9_req_put(clnt, req);
2170 EXPORT_SYMBOL(p9_client_mkdir_dotl);
2172 int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
2175 struct p9_client *clnt;
2176 struct p9_req_t *req;
2180 p9_debug(P9_DEBUG_9P,
2181 ">>> TLOCK fid %d type %i flags %d start %lld length %lld proc_id %d client_id %s\n",
2182 fid->fid, flock->type, flock->flags, flock->start,
2183 flock->length, flock->proc_id, flock->client_id);
2185 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
2186 flock->flags, flock->start, flock->length,
2187 flock->proc_id, flock->client_id);
2190 return PTR_ERR(req);
2192 err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status);
2194 trace_9p_protocol_dump(clnt, &req->rc);
2197 p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
2199 p9_req_put(clnt, req);
2202 EXPORT_SYMBOL(p9_client_lock_dotl);
2204 int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
2207 struct p9_client *clnt;
2208 struct p9_req_t *req;
2212 p9_debug(P9_DEBUG_9P,
2213 ">>> TGETLOCK fid %d, type %i start %lld length %lld proc_id %d client_id %s\n",
2214 fid->fid, glock->type, glock->start, glock->length,
2215 glock->proc_id, glock->client_id);
2217 req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid,
2218 glock->type, glock->start, glock->length,
2219 glock->proc_id, glock->client_id);
2222 return PTR_ERR(req);
2224 err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type,
2225 &glock->start, &glock->length, &glock->proc_id,
2228 trace_9p_protocol_dump(clnt, &req->rc);
2231 p9_debug(P9_DEBUG_9P,
2232 "<<< RGETLOCK type %i start %lld length %lld proc_id %d client_id %s\n",
2233 glock->type, glock->start, glock->length,
2234 glock->proc_id, glock->client_id);
2236 p9_req_put(clnt, req);
2239 EXPORT_SYMBOL(p9_client_getlock_dotl);
2241 int p9_client_readlink(struct p9_fid *fid, char **target)
2244 struct p9_client *clnt;
2245 struct p9_req_t *req;
2249 p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);
2251 req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
2253 return PTR_ERR(req);
2255 err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target);
2257 trace_9p_protocol_dump(clnt, &req->rc);
2260 p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
2262 p9_req_put(clnt, req);
2265 EXPORT_SYMBOL(p9_client_readlink);
2267 int __init p9_client_init(void)
2269 p9_req_cache = KMEM_CACHE(p9_req_t, SLAB_TYPESAFE_BY_RCU);
2270 return p9_req_cache ? 0 : -ENOMEM;
2273 void __exit p9_client_exit(void)
2275 kmem_cache_destroy(p9_req_cache);