1 // SPDX-License-Identifier: GPL-2.0-only
7 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
8 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/module.h>
14 #include <linux/errno.h>
16 #include <linux/poll.h>
17 #include <linux/idr.h>
18 #include <linux/mutex.h>
19 #include <linux/slab.h>
20 #include <linux/sched/signal.h>
21 #include <linux/uaccess.h>
22 #include <linux/uio.h>
23 #include <net/9p/9p.h>
24 #include <linux/parser.h>
25 #include <linux/seq_file.h>
26 #include <net/9p/client.h>
27 #include <net/9p/transport.h>
30 #define CREATE_TRACE_POINTS
31 #include <trace/events/9p.h>
34 * Client Option Parsing (code inspired by NFS code)
35 * - a little lazy - parse all client options
46 static const match_table_t tokens
= {
47 {Opt_msize
, "msize=%u"},
48 {Opt_legacy
, "noextend"},
49 {Opt_trans
, "trans=%s"},
50 {Opt_version
, "version=%s"},
54 inline int p9_is_proto_dotl(struct p9_client
*clnt
)
56 return clnt
->proto_version
== p9_proto_2000L
;
58 EXPORT_SYMBOL(p9_is_proto_dotl
);
60 inline int p9_is_proto_dotu(struct p9_client
*clnt
)
62 return clnt
->proto_version
== p9_proto_2000u
;
64 EXPORT_SYMBOL(p9_is_proto_dotu
);
66 int p9_show_client_options(struct seq_file
*m
, struct p9_client
*clnt
)
68 if (clnt
->msize
!= 8192)
69 seq_printf(m
, ",msize=%u", clnt
->msize
);
70 seq_printf(m
, ",trans=%s", clnt
->trans_mod
->name
);
72 switch (clnt
->proto_version
) {
74 seq_puts(m
, ",noextend");
77 seq_puts(m
, ",version=9p2000.u");
84 if (clnt
->trans_mod
->show_options
)
85 return clnt
->trans_mod
->show_options(m
, clnt
);
88 EXPORT_SYMBOL(p9_show_client_options
);
91 * Some error codes are taken directly from the server replies,
92 * make sure they are valid.
94 static int safe_errno(int err
)
96 if ((err
> 0) || (err
< -MAX_ERRNO
)) {
97 p9_debug(P9_DEBUG_ERROR
, "Invalid error code %d\n", err
);
104 /* Interpret mount option for protocol version */
105 static int get_protocol_version(char *s
)
107 int version
= -EINVAL
;
109 if (!strcmp(s
, "9p2000")) {
110 version
= p9_proto_legacy
;
111 p9_debug(P9_DEBUG_9P
, "Protocol version: Legacy\n");
112 } else if (!strcmp(s
, "9p2000.u")) {
113 version
= p9_proto_2000u
;
114 p9_debug(P9_DEBUG_9P
, "Protocol version: 9P2000.u\n");
115 } else if (!strcmp(s
, "9p2000.L")) {
116 version
= p9_proto_2000L
;
117 p9_debug(P9_DEBUG_9P
, "Protocol version: 9P2000.L\n");
119 pr_info("Unknown protocol version %s\n", s
);
125 * parse_options - parse mount options into client structure
126 * @opts: options string passed from mount
127 * @clnt: existing v9fs client information
129 * Return 0 upon success, -ERRNO upon failure
132 static int parse_opts(char *opts
, struct p9_client
*clnt
)
134 char *options
, *tmp_options
;
136 substring_t args
[MAX_OPT_ARGS
];
141 clnt
->proto_version
= p9_proto_2000L
;
147 tmp_options
= kstrdup(opts
, GFP_KERNEL
);
149 p9_debug(P9_DEBUG_ERROR
,
150 "failed to allocate copy of option string\n");
153 options
= tmp_options
;
155 while ((p
= strsep(&options
, ",")) != NULL
) {
159 token
= match_token(p
, tokens
, args
);
162 r
= match_int(&args
[0], &option
);
164 p9_debug(P9_DEBUG_ERROR
,
165 "integer field, but no integer?\n");
170 p9_debug(P9_DEBUG_ERROR
,
171 "msize should be at least 4k\n");
175 clnt
->msize
= option
;
178 s
= match_strdup(&args
[0]);
181 p9_debug(P9_DEBUG_ERROR
,
182 "problem allocating copy of trans arg\n");
183 goto free_and_return
;
186 v9fs_put_trans(clnt
->trans_mod
);
187 clnt
->trans_mod
= v9fs_get_trans_by_name(s
);
188 if (clnt
->trans_mod
== NULL
) {
189 pr_info("Could not find request transport: %s\n",
196 clnt
->proto_version
= p9_proto_legacy
;
199 s
= match_strdup(&args
[0]);
202 p9_debug(P9_DEBUG_ERROR
,
203 "problem allocating copy of version arg\n");
204 goto free_and_return
;
206 r
= get_protocol_version(s
);
210 clnt
->proto_version
= r
;
220 v9fs_put_trans(clnt
->trans_mod
);
225 static int p9_fcall_init(struct p9_client
*c
, struct p9_fcall
*fc
,
228 if (likely(c
->fcall_cache
) && alloc_msize
== c
->msize
) {
229 fc
->sdata
= kmem_cache_alloc(c
->fcall_cache
, GFP_NOFS
);
230 fc
->cache
= c
->fcall_cache
;
232 fc
->sdata
= kmalloc(alloc_msize
, GFP_NOFS
);
237 fc
->capacity
= alloc_msize
;
241 void p9_fcall_fini(struct p9_fcall
*fc
)
243 /* sdata can be NULL for interrupted requests in trans_rdma,
244 * and kmem_cache_free does not do NULL-check for us
246 if (unlikely(!fc
->sdata
))
250 kmem_cache_free(fc
->cache
, fc
->sdata
);
254 EXPORT_SYMBOL(p9_fcall_fini
);
256 static struct kmem_cache
*p9_req_cache
;
259 * p9_req_alloc - Allocate a new request.
260 * @c: Client session.
261 * @type: Transaction type.
262 * @max_size: Maximum packet size for this request.
264 * Context: Process context.
265 * Return: Pointer to new request.
267 static struct p9_req_t
*
268 p9_tag_alloc(struct p9_client
*c
, int8_t type
, unsigned int max_size
)
270 struct p9_req_t
*req
= kmem_cache_alloc(p9_req_cache
, GFP_NOFS
);
271 int alloc_msize
= min(c
->msize
, max_size
);
275 return ERR_PTR(-ENOMEM
);
277 if (p9_fcall_init(c
, &req
->tc
, alloc_msize
))
279 if (p9_fcall_init(c
, &req
->rc
, alloc_msize
))
282 p9pdu_reset(&req
->tc
);
283 p9pdu_reset(&req
->rc
);
284 req
->status
= REQ_STATUS_ALLOC
;
285 init_waitqueue_head(&req
->wq
);
286 INIT_LIST_HEAD(&req
->req_list
);
288 idr_preload(GFP_NOFS
);
289 spin_lock_irq(&c
->lock
);
290 if (type
== P9_TVERSION
)
291 tag
= idr_alloc(&c
->reqs
, req
, P9_NOTAG
, P9_NOTAG
+ 1,
294 tag
= idr_alloc(&c
->reqs
, req
, 0, P9_NOTAG
, GFP_NOWAIT
);
296 spin_unlock_irq(&c
->lock
);
301 /* Init ref to two because in the general case there is one ref
302 * that is put asynchronously by a writer thread, one ref
303 * temporarily given by p9_tag_lookup and put by p9_client_cb
304 * in the recv thread, and one ref put by p9_tag_remove in the
305 * main thread. The only exception is virtio that does not use
306 * p9_tag_lookup but does not have a writer thread either
307 * (the write happens synchronously in the request/zc_request
308 * callback), so p9_client_cb eats the second ref there
309 * as the pointer is duplicated directly by virtqueue_add_sgs()
311 refcount_set(&req
->refcount
.refcount
, 2);
316 p9_fcall_fini(&req
->tc
);
317 p9_fcall_fini(&req
->rc
);
319 kmem_cache_free(p9_req_cache
, req
);
320 return ERR_PTR(-ENOMEM
);
324 * p9_tag_lookup - Look up a request by tag.
325 * @c: Client session.
326 * @tag: Transaction ID.
328 * Context: Any context.
329 * Return: A request, or %NULL if there is no request with that tag.
331 struct p9_req_t
*p9_tag_lookup(struct p9_client
*c
, u16 tag
)
333 struct p9_req_t
*req
;
337 req
= idr_find(&c
->reqs
, tag
);
339 /* We have to be careful with the req found under rcu_read_lock
340 * Thanks to SLAB_TYPESAFE_BY_RCU we can safely try to get the
341 * ref again without corrupting other data, then check again
342 * that the tag matches once we have the ref
344 if (!p9_req_try_get(req
))
346 if (req
->tc
.tag
!= tag
) {
355 EXPORT_SYMBOL(p9_tag_lookup
);
358 * p9_tag_remove - Remove a tag.
359 * @c: Client session.
360 * @r: Request of reference.
362 * Context: Any context.
364 static int p9_tag_remove(struct p9_client
*c
, struct p9_req_t
*r
)
369 p9_debug(P9_DEBUG_MUX
, "clnt %p req %p tag: %d\n", c
, r
, tag
);
370 spin_lock_irqsave(&c
->lock
, flags
);
371 idr_remove(&c
->reqs
, tag
);
372 spin_unlock_irqrestore(&c
->lock
, flags
);
373 return p9_req_put(r
);
376 static void p9_req_free(struct kref
*ref
)
378 struct p9_req_t
*r
= container_of(ref
, struct p9_req_t
, refcount
);
379 p9_fcall_fini(&r
->tc
);
380 p9_fcall_fini(&r
->rc
);
381 kmem_cache_free(p9_req_cache
, r
);
384 int p9_req_put(struct p9_req_t
*r
)
386 return kref_put(&r
->refcount
, p9_req_free
);
388 EXPORT_SYMBOL(p9_req_put
);
391 * p9_tag_cleanup - cleans up tags structure and reclaims resources
392 * @c: v9fs client struct
394 * This frees resources associated with the tags structure
397 static void p9_tag_cleanup(struct p9_client
*c
)
399 struct p9_req_t
*req
;
403 idr_for_each_entry(&c
->reqs
, req
, id
) {
404 pr_info("Tag %d still in use\n", id
);
405 if (p9_tag_remove(c
, req
) == 0)
406 pr_warn("Packet with tag %d has still references",
413 * p9_client_cb - call back from transport to client
415 * req: request received
418 void p9_client_cb(struct p9_client
*c
, struct p9_req_t
*req
, int status
)
420 p9_debug(P9_DEBUG_MUX
, " tag %d\n", req
->tc
.tag
);
423 * This barrier is needed to make sure any change made to req before
424 * the status change is visible to another thread
427 req
->status
= status
;
430 p9_debug(P9_DEBUG_MUX
, "wakeup: %d\n", req
->tc
.tag
);
433 EXPORT_SYMBOL(p9_client_cb
);
436 * p9_parse_header - parse header arguments out of a packet
437 * @pdu: packet to parse
438 * @size: size of packet
439 * @type: type of request
440 * @tag: tag of packet
441 * @rewind: set if we need to rewind offset afterwards
445 p9_parse_header(struct p9_fcall
*pdu
, int32_t *size
, int8_t *type
, int16_t *tag
,
451 int offset
= pdu
->offset
;
456 err
= p9pdu_readf(pdu
, 0, "dbw", &r_size
, &r_type
, &r_tag
);
458 goto rewind_and_exit
;
467 if (pdu
->size
!= r_size
|| r_size
< 7) {
469 goto rewind_and_exit
;
475 p9_debug(P9_DEBUG_9P
, "<<< size=%d type: %d tag: %d\n",
476 pdu
->size
, pdu
->id
, pdu
->tag
);
480 pdu
->offset
= offset
;
483 EXPORT_SYMBOL(p9_parse_header
);
486 * p9_check_errors - check 9p packet for error return and process it
487 * @c: current client instance
488 * @req: request to parse and check for error conditions
490 * returns error code if one is discovered, otherwise returns 0
492 * this will have to be more complicated if we have multiple
496 static int p9_check_errors(struct p9_client
*c
, struct p9_req_t
*req
)
502 err
= p9_parse_header(&req
->rc
, NULL
, &type
, NULL
, 0);
503 if (req
->rc
.size
>= c
->msize
) {
504 p9_debug(P9_DEBUG_ERROR
,
505 "requested packet size too big: %d\n",
510 * dump the response from server
511 * This should be after check errors which poplulate pdu_fcall.
513 trace_9p_protocol_dump(c
, &req
->rc
);
515 p9_debug(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
518 if (type
!= P9_RERROR
&& type
!= P9_RLERROR
)
521 if (!p9_is_proto_dotl(c
)) {
523 err
= p9pdu_readf(&req
->rc
, c
->proto_version
, "s?d",
528 if (p9_is_proto_dotu(c
) && ecode
< 512)
532 err
= p9_errstr2errno(ename
, strlen(ename
));
534 p9_debug(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n",
539 err
= p9pdu_readf(&req
->rc
, c
->proto_version
, "d", &ecode
);
542 p9_debug(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
548 p9_debug(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
554 * p9_check_zc_errors - check 9p packet for error return and process it
555 * @c: current client instance
556 * @req: request to parse and check for error conditions
557 * @in_hdrlen: Size of response protocol buffer.
559 * returns error code if one is discovered, otherwise returns 0
561 * this will have to be more complicated if we have multiple
565 static int p9_check_zc_errors(struct p9_client
*c
, struct p9_req_t
*req
,
566 struct iov_iter
*uidata
, int in_hdrlen
)
573 err
= p9_parse_header(&req
->rc
, NULL
, &type
, NULL
, 0);
575 * dump the response from server
576 * This should be after parse_header which poplulate pdu_fcall.
578 trace_9p_protocol_dump(c
, &req
->rc
);
580 p9_debug(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
584 if (type
!= P9_RERROR
&& type
!= P9_RLERROR
)
587 if (!p9_is_proto_dotl(c
)) {
588 /* Error is reported in string format */
590 /* 7 = header size for RERROR; */
591 int inline_len
= in_hdrlen
- 7;
593 len
= req
->rc
.size
- req
->rc
.offset
;
594 if (len
> (P9_ZC_HDR_SZ
- 7)) {
599 ename
= &req
->rc
.sdata
[req
->rc
.offset
];
600 if (len
> inline_len
) {
601 /* We have error in external buffer */
602 if (!copy_from_iter_full(ename
+ inline_len
,
603 len
- inline_len
, uidata
)) {
609 err
= p9pdu_readf(&req
->rc
, c
->proto_version
, "s?d",
614 if (p9_is_proto_dotu(c
) && ecode
< 512)
618 err
= p9_errstr2errno(ename
, strlen(ename
));
620 p9_debug(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n",
625 err
= p9pdu_readf(&req
->rc
, c
->proto_version
, "d", &ecode
);
628 p9_debug(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
633 p9_debug(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
637 static struct p9_req_t
*
638 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...);
641 * p9_client_flush - flush (cancel) a request
643 * @oldreq: request to cancel
645 * This sents a flush for a particular request and links
646 * the flush request to the original request. The current
647 * code only supports a single flush request although the protocol
648 * allows for multiple flush requests to be sent for a single request.
652 static int p9_client_flush(struct p9_client
*c
, struct p9_req_t
*oldreq
)
654 struct p9_req_t
*req
;
658 err
= p9_parse_header(&oldreq
->tc
, NULL
, NULL
, &oldtag
, 1);
662 p9_debug(P9_DEBUG_9P
, ">>> TFLUSH tag %d\n", oldtag
);
664 req
= p9_client_rpc(c
, P9_TFLUSH
, "w", oldtag
);
669 * if we haven't received a response for oldreq,
670 * remove it from the list
672 if (oldreq
->status
== REQ_STATUS_SENT
) {
673 if (c
->trans_mod
->cancelled
)
674 c
->trans_mod
->cancelled(c
, oldreq
);
677 p9_tag_remove(c
, req
);
681 static struct p9_req_t
*p9_client_prepare_req(struct p9_client
*c
,
682 int8_t type
, int req_size
,
683 const char *fmt
, va_list ap
)
686 struct p9_req_t
*req
;
688 p9_debug(P9_DEBUG_MUX
, "client %p op %d\n", c
, type
);
690 /* we allow for any status other than disconnected */
691 if (c
->status
== Disconnected
)
692 return ERR_PTR(-EIO
);
694 /* if status is begin_disconnected we allow only clunk request */
695 if ((c
->status
== BeginDisconnect
) && (type
!= P9_TCLUNK
))
696 return ERR_PTR(-EIO
);
698 req
= p9_tag_alloc(c
, type
, req_size
);
702 /* marshall the data */
703 p9pdu_prepare(&req
->tc
, req
->tc
.tag
, type
);
704 err
= p9pdu_vwritef(&req
->tc
, c
->proto_version
, fmt
, ap
);
707 p9pdu_finalize(c
, &req
->tc
);
708 trace_9p_client_req(c
, type
, req
->tc
.tag
);
711 p9_tag_remove(c
, req
);
712 /* We have to put also the 2nd reference as it won't be used */
718 * p9_client_rpc - issue a request and wait for a response
720 * @type: type of request
721 * @fmt: protocol format string (see protocol.c)
723 * Returns request structure (which client must free using p9_tag_remove)
726 static struct p9_req_t
*
727 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...)
732 struct p9_req_t
*req
;
735 req
= p9_client_prepare_req(c
, type
, c
->msize
, fmt
, ap
);
740 if (signal_pending(current
)) {
742 clear_thread_flag(TIF_SIGPENDING
);
746 err
= c
->trans_mod
->request(c
, req
);
748 /* write won't happen */
750 if (err
!= -ERESTARTSYS
&& err
!= -EFAULT
)
751 c
->status
= Disconnected
;
752 goto recalc_sigpending
;
755 /* Wait for the response */
756 err
= wait_event_killable(req
->wq
, req
->status
>= REQ_STATUS_RCVD
);
759 * Make sure our req is coherent with regard to updates in other
760 * threads - echoes to wmb() in the callback
764 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)
765 && (type
== P9_TFLUSH
)) {
767 clear_thread_flag(TIF_SIGPENDING
);
771 if (req
->status
== REQ_STATUS_ERROR
) {
772 p9_debug(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
775 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
776 p9_debug(P9_DEBUG_MUX
, "flushing\n");
778 clear_thread_flag(TIF_SIGPENDING
);
780 if (c
->trans_mod
->cancel(c
, req
))
781 p9_client_flush(c
, req
);
783 /* if we received the response anyway, don't signal error */
784 if (req
->status
== REQ_STATUS_RCVD
)
789 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
791 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
796 err
= p9_check_errors(c
, req
);
797 trace_9p_client_res(c
, type
, req
->rc
.tag
, err
);
801 p9_tag_remove(c
, req
);
802 return ERR_PTR(safe_errno(err
));
806 * p9_client_zc_rpc - issue a request and wait for a response
808 * @type: type of request
809 * @uidata: destination for zero copy read
810 * @uodata: source for zero copy write
811 * @inlen: read buffer size
812 * @olen: write buffer size
813 * @hdrlen: reader header size, This is the size of response protocol data
814 * @fmt: protocol format string (see protocol.c)
816 * Returns request structure (which client must free using p9_tag_remove)
818 static struct p9_req_t
*p9_client_zc_rpc(struct p9_client
*c
, int8_t type
,
819 struct iov_iter
*uidata
,
820 struct iov_iter
*uodata
,
821 int inlen
, int olen
, int in_hdrlen
,
822 const char *fmt
, ...)
827 struct p9_req_t
*req
;
831 * We allocate a inline protocol data of only 4k bytes.
832 * The actual content is passed in zero-copy fashion.
834 req
= p9_client_prepare_req(c
, type
, P9_ZC_HDR_SZ
, fmt
, ap
);
839 if (signal_pending(current
)) {
841 clear_thread_flag(TIF_SIGPENDING
);
845 err
= c
->trans_mod
->zc_request(c
, req
, uidata
, uodata
,
846 inlen
, olen
, in_hdrlen
);
849 c
->status
= Disconnected
;
850 if (err
!= -ERESTARTSYS
)
851 goto recalc_sigpending
;
853 if (req
->status
== REQ_STATUS_ERROR
) {
854 p9_debug(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
857 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
858 p9_debug(P9_DEBUG_MUX
, "flushing\n");
860 clear_thread_flag(TIF_SIGPENDING
);
862 if (c
->trans_mod
->cancel(c
, req
))
863 p9_client_flush(c
, req
);
865 /* if we received the response anyway, don't signal error */
866 if (req
->status
== REQ_STATUS_RCVD
)
871 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
873 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
878 err
= p9_check_zc_errors(c
, req
, uidata
, in_hdrlen
);
879 trace_9p_client_res(c
, type
, req
->rc
.tag
, err
);
883 p9_tag_remove(c
, req
);
884 return ERR_PTR(safe_errno(err
));
887 static struct p9_fid
*p9_fid_create(struct p9_client
*clnt
)
892 p9_debug(P9_DEBUG_FID
, "clnt %p\n", clnt
);
893 fid
= kmalloc(sizeof(struct p9_fid
), GFP_KERNEL
);
897 memset(&fid
->qid
, 0, sizeof(struct p9_qid
));
899 fid
->uid
= current_fsuid();
904 idr_preload(GFP_KERNEL
);
905 spin_lock_irq(&clnt
->lock
);
906 ret
= idr_alloc_u32(&clnt
->fids
, fid
, &fid
->fid
, P9_NOFID
- 1,
908 spin_unlock_irq(&clnt
->lock
);
918 static void p9_fid_destroy(struct p9_fid
*fid
)
920 struct p9_client
*clnt
;
923 p9_debug(P9_DEBUG_FID
, "fid %d\n", fid
->fid
);
925 spin_lock_irqsave(&clnt
->lock
, flags
);
926 idr_remove(&clnt
->fids
, fid
->fid
);
927 spin_unlock_irqrestore(&clnt
->lock
, flags
);
932 static int p9_client_version(struct p9_client
*c
)
935 struct p9_req_t
*req
;
936 char *version
= NULL
;
939 p9_debug(P9_DEBUG_9P
, ">>> TVERSION msize %d protocol %d\n",
940 c
->msize
, c
->proto_version
);
942 switch (c
->proto_version
) {
944 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
945 c
->msize
, "9P2000.L");
948 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
949 c
->msize
, "9P2000.u");
951 case p9_proto_legacy
:
952 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
962 err
= p9pdu_readf(&req
->rc
, c
->proto_version
, "ds", &msize
, &version
);
964 p9_debug(P9_DEBUG_9P
, "version error %d\n", err
);
965 trace_9p_protocol_dump(c
, &req
->rc
);
969 p9_debug(P9_DEBUG_9P
, "<<< RVERSION msize %d %s\n", msize
, version
);
970 if (!strncmp(version
, "9P2000.L", 8))
971 c
->proto_version
= p9_proto_2000L
;
972 else if (!strncmp(version
, "9P2000.u", 8))
973 c
->proto_version
= p9_proto_2000u
;
974 else if (!strncmp(version
, "9P2000", 6))
975 c
->proto_version
= p9_proto_legacy
;
977 p9_debug(P9_DEBUG_ERROR
,
978 "server returned an unknown version: %s\n", version
);
984 p9_debug(P9_DEBUG_ERROR
,
985 "server returned a msize < 4096: %d\n", msize
);
989 if (msize
< c
->msize
)
994 p9_tag_remove(c
, req
);
999 struct p9_client
*p9_client_create(const char *dev_name
, char *options
)
1002 struct p9_client
*clnt
;
1006 clnt
= kmalloc(sizeof(struct p9_client
), GFP_KERNEL
);
1008 return ERR_PTR(-ENOMEM
);
1010 clnt
->trans_mod
= NULL
;
1012 clnt
->fcall_cache
= NULL
;
1014 client_id
= utsname()->nodename
;
1015 memcpy(clnt
->name
, client_id
, strlen(client_id
) + 1);
1017 spin_lock_init(&clnt
->lock
);
1018 idr_init(&clnt
->fids
);
1019 idr_init(&clnt
->reqs
);
1021 err
= parse_opts(options
, clnt
);
1025 if (!clnt
->trans_mod
)
1026 clnt
->trans_mod
= v9fs_get_default_trans();
1028 if (clnt
->trans_mod
== NULL
) {
1029 err
= -EPROTONOSUPPORT
;
1030 p9_debug(P9_DEBUG_ERROR
,
1031 "No transport defined or default transport\n");
1035 p9_debug(P9_DEBUG_MUX
, "clnt %p trans %p msize %d protocol %d\n",
1036 clnt
, clnt
->trans_mod
, clnt
->msize
, clnt
->proto_version
);
1038 err
= clnt
->trans_mod
->create(clnt
, dev_name
, options
);
1042 if (clnt
->msize
> clnt
->trans_mod
->maxsize
)
1043 clnt
->msize
= clnt
->trans_mod
->maxsize
;
1045 if (clnt
->msize
< 4096) {
1046 p9_debug(P9_DEBUG_ERROR
,
1047 "Please specify a msize of at least 4k\n");
1052 err
= p9_client_version(clnt
);
1056 /* P9_HDRSZ + 4 is the smallest packet header we can have that is
1057 * followed by data accessed from userspace by read
1060 kmem_cache_create_usercopy("9p-fcall-cache", clnt
->msize
,
1062 clnt
->msize
- (P9_HDRSZ
+ 4),
1068 clnt
->trans_mod
->close(clnt
);
1070 v9fs_put_trans(clnt
->trans_mod
);
1073 return ERR_PTR(err
);
1075 EXPORT_SYMBOL(p9_client_create
);
1077 void p9_client_destroy(struct p9_client
*clnt
)
1082 p9_debug(P9_DEBUG_MUX
, "clnt %p\n", clnt
);
1084 if (clnt
->trans_mod
)
1085 clnt
->trans_mod
->close(clnt
);
1087 v9fs_put_trans(clnt
->trans_mod
);
1089 idr_for_each_entry(&clnt
->fids
, fid
, id
) {
1090 pr_info("Found fid %d not clunked\n", fid
->fid
);
1091 p9_fid_destroy(fid
);
1094 p9_tag_cleanup(clnt
);
1096 kmem_cache_destroy(clnt
->fcall_cache
);
1099 EXPORT_SYMBOL(p9_client_destroy
);
1101 void p9_client_disconnect(struct p9_client
*clnt
)
1103 p9_debug(P9_DEBUG_9P
, "clnt %p\n", clnt
);
1104 clnt
->status
= Disconnected
;
1106 EXPORT_SYMBOL(p9_client_disconnect
);
1108 void p9_client_begin_disconnect(struct p9_client
*clnt
)
1110 p9_debug(P9_DEBUG_9P
, "clnt %p\n", clnt
);
1111 clnt
->status
= BeginDisconnect
;
1113 EXPORT_SYMBOL(p9_client_begin_disconnect
);
1115 struct p9_fid
*p9_client_attach(struct p9_client
*clnt
, struct p9_fid
*afid
,
1116 const char *uname
, kuid_t n_uname
, const char *aname
)
1119 struct p9_req_t
*req
;
1124 p9_debug(P9_DEBUG_9P
, ">>> TATTACH afid %d uname %s aname %s\n",
1125 afid
? afid
->fid
: -1, uname
, aname
);
1126 fid
= p9_fid_create(clnt
);
1133 req
= p9_client_rpc(clnt
, P9_TATTACH
, "ddss?u", fid
->fid
,
1134 afid
? afid
->fid
: P9_NOFID
, uname
, aname
, n_uname
);
1140 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Q", &qid
);
1142 trace_9p_protocol_dump(clnt
, &req
->rc
);
1143 p9_tag_remove(clnt
, req
);
1147 p9_debug(P9_DEBUG_9P
, "<<< RATTACH qid %x.%llx.%x\n",
1148 qid
.type
, (unsigned long long)qid
.path
, qid
.version
);
1150 memmove(&fid
->qid
, &qid
, sizeof(struct p9_qid
));
1152 p9_tag_remove(clnt
, req
);
1157 p9_fid_destroy(fid
);
1158 return ERR_PTR(err
);
1160 EXPORT_SYMBOL(p9_client_attach
);
1162 struct p9_fid
*p9_client_walk(struct p9_fid
*oldfid
, uint16_t nwname
,
1163 const unsigned char * const *wnames
, int clone
)
1166 struct p9_client
*clnt
;
1168 struct p9_qid
*wqids
;
1169 struct p9_req_t
*req
;
1170 uint16_t nwqids
, count
;
1174 clnt
= oldfid
->clnt
;
1176 fid
= p9_fid_create(clnt
);
1182 fid
->uid
= oldfid
->uid
;
1187 p9_debug(P9_DEBUG_9P
, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
1188 oldfid
->fid
, fid
->fid
, nwname
, wnames
? wnames
[0] : NULL
);
1190 req
= p9_client_rpc(clnt
, P9_TWALK
, "ddT", oldfid
->fid
, fid
->fid
,
1197 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "R", &nwqids
, &wqids
);
1199 trace_9p_protocol_dump(clnt
, &req
->rc
);
1200 p9_tag_remove(clnt
, req
);
1203 p9_tag_remove(clnt
, req
);
1205 p9_debug(P9_DEBUG_9P
, "<<< RWALK nwqid %d:\n", nwqids
);
1207 if (nwqids
!= nwname
) {
1212 for (count
= 0; count
< nwqids
; count
++)
1213 p9_debug(P9_DEBUG_9P
, "<<< [%d] %x.%llx.%x\n",
1214 count
, wqids
[count
].type
,
1215 (unsigned long long)wqids
[count
].path
,
1216 wqids
[count
].version
);
1219 memmove(&fid
->qid
, &wqids
[nwqids
- 1], sizeof(struct p9_qid
));
1221 fid
->qid
= oldfid
->qid
;
1228 p9_client_clunk(fid
);
1232 if (fid
&& (fid
!= oldfid
))
1233 p9_fid_destroy(fid
);
1235 return ERR_PTR(err
);
1237 EXPORT_SYMBOL(p9_client_walk
);
1239 int p9_client_open(struct p9_fid
*fid
, int mode
)
1242 struct p9_client
*clnt
;
1243 struct p9_req_t
*req
;
1248 p9_debug(P9_DEBUG_9P
, ">>> %s fid %d mode %d\n",
1249 p9_is_proto_dotl(clnt
) ? "TLOPEN" : "TOPEN", fid
->fid
, mode
);
1252 if (fid
->mode
!= -1)
1255 if (p9_is_proto_dotl(clnt
))
1256 req
= p9_client_rpc(clnt
, P9_TLOPEN
, "dd", fid
->fid
, mode
);
1258 req
= p9_client_rpc(clnt
, P9_TOPEN
, "db", fid
->fid
, mode
);
1264 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1266 trace_9p_protocol_dump(clnt
, &req
->rc
);
1267 goto free_and_error
;
1270 p9_debug(P9_DEBUG_9P
, "<<< %s qid %x.%llx.%x iounit %x\n",
1271 p9_is_proto_dotl(clnt
) ? "RLOPEN" : "ROPEN", qid
.type
,
1272 (unsigned long long)qid
.path
, qid
.version
, iounit
);
1275 fid
->iounit
= iounit
;
1278 p9_tag_remove(clnt
, req
);
1282 EXPORT_SYMBOL(p9_client_open
);
1284 int p9_client_create_dotl(struct p9_fid
*ofid
, const char *name
, u32 flags
, u32 mode
,
1285 kgid_t gid
, struct p9_qid
*qid
)
1288 struct p9_client
*clnt
;
1289 struct p9_req_t
*req
;
1292 p9_debug(P9_DEBUG_9P
,
1293 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1294 ofid
->fid
, name
, flags
, mode
,
1295 from_kgid(&init_user_ns
, gid
));
1298 if (ofid
->mode
!= -1)
1301 req
= p9_client_rpc(clnt
, P9_TLCREATE
, "dsddg", ofid
->fid
, name
, flags
,
1308 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Qd", qid
, &iounit
);
1310 trace_9p_protocol_dump(clnt
, &req
->rc
);
1311 goto free_and_error
;
1314 p9_debug(P9_DEBUG_9P
, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1316 (unsigned long long)qid
->path
,
1317 qid
->version
, iounit
);
1320 ofid
->iounit
= iounit
;
1323 p9_tag_remove(clnt
, req
);
1327 EXPORT_SYMBOL(p9_client_create_dotl
);
1329 int p9_client_fcreate(struct p9_fid
*fid
, const char *name
, u32 perm
, int mode
,
1333 struct p9_client
*clnt
;
1334 struct p9_req_t
*req
;
1338 p9_debug(P9_DEBUG_9P
, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1339 fid
->fid
, name
, perm
, mode
);
1343 if (fid
->mode
!= -1)
1346 req
= p9_client_rpc(clnt
, P9_TCREATE
, "dsdb?s", fid
->fid
, name
, perm
,
1353 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1355 trace_9p_protocol_dump(clnt
, &req
->rc
);
1356 goto free_and_error
;
1359 p9_debug(P9_DEBUG_9P
, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1361 (unsigned long long)qid
.path
,
1362 qid
.version
, iounit
);
1365 fid
->iounit
= iounit
;
1368 p9_tag_remove(clnt
, req
);
1372 EXPORT_SYMBOL(p9_client_fcreate
);
1374 int p9_client_symlink(struct p9_fid
*dfid
, const char *name
,
1375 const char *symtgt
, kgid_t gid
, struct p9_qid
*qid
)
1378 struct p9_client
*clnt
;
1379 struct p9_req_t
*req
;
1381 p9_debug(P9_DEBUG_9P
, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
1382 dfid
->fid
, name
, symtgt
);
1385 req
= p9_client_rpc(clnt
, P9_TSYMLINK
, "dssg", dfid
->fid
, name
, symtgt
,
1392 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Q", qid
);
1394 trace_9p_protocol_dump(clnt
, &req
->rc
);
1395 goto free_and_error
;
1398 p9_debug(P9_DEBUG_9P
, "<<< RSYMLINK qid %x.%llx.%x\n",
1399 qid
->type
, (unsigned long long)qid
->path
, qid
->version
);
1402 p9_tag_remove(clnt
, req
);
1406 EXPORT_SYMBOL(p9_client_symlink
);
1408 int p9_client_link(struct p9_fid
*dfid
, struct p9_fid
*oldfid
, const char *newname
)
1410 struct p9_client
*clnt
;
1411 struct p9_req_t
*req
;
1413 p9_debug(P9_DEBUG_9P
, ">>> TLINK dfid %d oldfid %d newname %s\n",
1414 dfid
->fid
, oldfid
->fid
, newname
);
1416 req
= p9_client_rpc(clnt
, P9_TLINK
, "dds", dfid
->fid
, oldfid
->fid
,
1419 return PTR_ERR(req
);
1421 p9_debug(P9_DEBUG_9P
, "<<< RLINK\n");
1422 p9_tag_remove(clnt
, req
);
1425 EXPORT_SYMBOL(p9_client_link
);
1427 int p9_client_fsync(struct p9_fid
*fid
, int datasync
)
1430 struct p9_client
*clnt
;
1431 struct p9_req_t
*req
;
1433 p9_debug(P9_DEBUG_9P
, ">>> TFSYNC fid %d datasync:%d\n",
1434 fid
->fid
, datasync
);
1438 req
= p9_client_rpc(clnt
, P9_TFSYNC
, "dd", fid
->fid
, datasync
);
1444 p9_debug(P9_DEBUG_9P
, "<<< RFSYNC fid %d\n", fid
->fid
);
1446 p9_tag_remove(clnt
, req
);
1451 EXPORT_SYMBOL(p9_client_fsync
);
1453 int p9_client_clunk(struct p9_fid
*fid
)
1456 struct p9_client
*clnt
;
1457 struct p9_req_t
*req
;
1461 pr_warn("%s (%d): Trying to clunk with NULL fid\n",
1462 __func__
, task_pid_nr(current
));
1468 p9_debug(P9_DEBUG_9P
, ">>> TCLUNK fid %d (try %d)\n", fid
->fid
,
1473 req
= p9_client_rpc(clnt
, P9_TCLUNK
, "d", fid
->fid
);
1479 p9_debug(P9_DEBUG_9P
, "<<< RCLUNK fid %d\n", fid
->fid
);
1481 p9_tag_remove(clnt
, req
);
1484 * Fid is not valid even after a failed clunk
1485 * If interrupted, retry once then give up and
1486 * leak fid until umount.
1488 if (err
== -ERESTARTSYS
) {
1492 p9_fid_destroy(fid
);
1495 EXPORT_SYMBOL(p9_client_clunk
);
1497 int p9_client_remove(struct p9_fid
*fid
)
1500 struct p9_client
*clnt
;
1501 struct p9_req_t
*req
;
1503 p9_debug(P9_DEBUG_9P
, ">>> TREMOVE fid %d\n", fid
->fid
);
1507 req
= p9_client_rpc(clnt
, P9_TREMOVE
, "d", fid
->fid
);
1513 p9_debug(P9_DEBUG_9P
, "<<< RREMOVE fid %d\n", fid
->fid
);
1515 p9_tag_remove(clnt
, req
);
1517 if (err
== -ERESTARTSYS
)
1518 p9_client_clunk(fid
);
1520 p9_fid_destroy(fid
);
1523 EXPORT_SYMBOL(p9_client_remove
);
1525 int p9_client_unlinkat(struct p9_fid
*dfid
, const char *name
, int flags
)
1528 struct p9_req_t
*req
;
1529 struct p9_client
*clnt
;
1531 p9_debug(P9_DEBUG_9P
, ">>> TUNLINKAT fid %d %s %d\n",
1532 dfid
->fid
, name
, flags
);
1535 req
= p9_client_rpc(clnt
, P9_TUNLINKAT
, "dsd", dfid
->fid
, name
, flags
);
1540 p9_debug(P9_DEBUG_9P
, "<<< RUNLINKAT fid %d %s\n", dfid
->fid
, name
);
1542 p9_tag_remove(clnt
, req
);
1546 EXPORT_SYMBOL(p9_client_unlinkat
);
1549 p9_client_read(struct p9_fid
*fid
, u64 offset
, struct iov_iter
*to
, int *err
)
1551 struct p9_client
*clnt
= fid
->clnt
;
1552 struct p9_req_t
*req
;
1556 p9_debug(P9_DEBUG_9P
, ">>> TREAD fid %d offset %llu %d\n",
1557 fid
->fid
, (unsigned long long) offset
, (int)iov_iter_count(to
));
1559 while (iov_iter_count(to
)) {
1560 int count
= iov_iter_count(to
);
1561 int rsize
, non_zc
= 0;
1564 rsize
= fid
->iounit
;
1565 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1566 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1571 /* Don't bother zerocopy for small IO (< 1024) */
1572 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
1574 * response header len is 11
1575 * PDU Header(7) + IO Size (4)
1577 req
= p9_client_zc_rpc(clnt
, P9_TREAD
, to
, NULL
, rsize
,
1578 0, 11, "dqd", fid
->fid
,
1582 req
= p9_client_rpc(clnt
, P9_TREAD
, "dqd", fid
->fid
, offset
,
1586 *err
= PTR_ERR(req
);
1590 *err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
,
1591 "D", &count
, &dataptr
);
1593 trace_9p_protocol_dump(clnt
, &req
->rc
);
1594 p9_tag_remove(clnt
, req
);
1597 if (rsize
< count
) {
1598 pr_err("bogus RREAD count (%d > %d)\n", count
, rsize
);
1602 p9_debug(P9_DEBUG_9P
, "<<< RREAD count %d\n", count
);
1604 p9_tag_remove(clnt
, req
);
1609 int n
= copy_to_iter(dataptr
, count
, to
);
1614 p9_tag_remove(clnt
, req
);
1618 iov_iter_advance(to
, count
);
1622 p9_tag_remove(clnt
, req
);
1626 EXPORT_SYMBOL(p9_client_read
);
1629 p9_client_write(struct p9_fid
*fid
, u64 offset
, struct iov_iter
*from
, int *err
)
1631 struct p9_client
*clnt
= fid
->clnt
;
1632 struct p9_req_t
*req
;
1636 p9_debug(P9_DEBUG_9P
, ">>> TWRITE fid %d offset %llu count %zd\n",
1637 fid
->fid
, (unsigned long long) offset
,
1638 iov_iter_count(from
));
1640 while (iov_iter_count(from
)) {
1641 int count
= iov_iter_count(from
);
1642 int rsize
= fid
->iounit
;
1643 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1644 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1649 /* Don't bother zerocopy for small IO (< 1024) */
1650 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
1651 req
= p9_client_zc_rpc(clnt
, P9_TWRITE
, NULL
, from
, 0,
1652 rsize
, P9_ZC_HDR_SZ
, "dqd",
1653 fid
->fid
, offset
, rsize
);
1655 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqV", fid
->fid
,
1656 offset
, rsize
, from
);
1659 *err
= PTR_ERR(req
);
1663 *err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "d", &count
);
1665 trace_9p_protocol_dump(clnt
, &req
->rc
);
1666 p9_tag_remove(clnt
, req
);
1669 if (rsize
< count
) {
1670 pr_err("bogus RWRITE count (%d > %d)\n", count
, rsize
);
1674 p9_debug(P9_DEBUG_9P
, "<<< RWRITE count %d\n", count
);
1676 p9_tag_remove(clnt
, req
);
1677 iov_iter_advance(from
, count
);
1683 EXPORT_SYMBOL(p9_client_write
);
1685 struct p9_wstat
*p9_client_stat(struct p9_fid
*fid
)
1688 struct p9_client
*clnt
;
1689 struct p9_wstat
*ret
= kmalloc(sizeof(struct p9_wstat
), GFP_KERNEL
);
1690 struct p9_req_t
*req
;
1693 p9_debug(P9_DEBUG_9P
, ">>> TSTAT fid %d\n", fid
->fid
);
1696 return ERR_PTR(-ENOMEM
);
1701 req
= p9_client_rpc(clnt
, P9_TSTAT
, "d", fid
->fid
);
1707 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "wS", &ignored
, ret
);
1709 trace_9p_protocol_dump(clnt
, &req
->rc
);
1710 p9_tag_remove(clnt
, req
);
1714 p9_debug(P9_DEBUG_9P
,
1715 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1716 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1717 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1718 "<<< uid=%d gid=%d n_muid=%d\n",
1719 ret
->size
, ret
->type
, ret
->dev
, ret
->qid
.type
,
1720 (unsigned long long)ret
->qid
.path
, ret
->qid
.version
, ret
->mode
,
1721 ret
->atime
, ret
->mtime
, (unsigned long long)ret
->length
,
1722 ret
->name
, ret
->uid
, ret
->gid
, ret
->muid
, ret
->extension
,
1723 from_kuid(&init_user_ns
, ret
->n_uid
),
1724 from_kgid(&init_user_ns
, ret
->n_gid
),
1725 from_kuid(&init_user_ns
, ret
->n_muid
));
1727 p9_tag_remove(clnt
, req
);
1732 return ERR_PTR(err
);
1734 EXPORT_SYMBOL(p9_client_stat
);
1736 struct p9_stat_dotl
*p9_client_getattr_dotl(struct p9_fid
*fid
,
1740 struct p9_client
*clnt
;
1741 struct p9_stat_dotl
*ret
= kmalloc(sizeof(struct p9_stat_dotl
),
1743 struct p9_req_t
*req
;
1745 p9_debug(P9_DEBUG_9P
, ">>> TGETATTR fid %d, request_mask %lld\n",
1746 fid
->fid
, request_mask
);
1749 return ERR_PTR(-ENOMEM
);
1754 req
= p9_client_rpc(clnt
, P9_TGETATTR
, "dq", fid
->fid
, request_mask
);
1760 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "A", ret
);
1762 trace_9p_protocol_dump(clnt
, &req
->rc
);
1763 p9_tag_remove(clnt
, req
);
1767 p9_debug(P9_DEBUG_9P
,
1768 "<<< RGETATTR st_result_mask=%lld\n"
1769 "<<< qid=%x.%llx.%x\n"
1770 "<<< st_mode=%8.8x st_nlink=%llu\n"
1771 "<<< st_uid=%d st_gid=%d\n"
1772 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1773 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1774 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1775 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1776 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1777 "<<< st_gen=%lld st_data_version=%lld\n",
1778 ret
->st_result_mask
, ret
->qid
.type
, ret
->qid
.path
,
1779 ret
->qid
.version
, ret
->st_mode
, ret
->st_nlink
,
1780 from_kuid(&init_user_ns
, ret
->st_uid
),
1781 from_kgid(&init_user_ns
, ret
->st_gid
),
1782 ret
->st_rdev
, ret
->st_size
, ret
->st_blksize
,
1783 ret
->st_blocks
, ret
->st_atime_sec
, ret
->st_atime_nsec
,
1784 ret
->st_mtime_sec
, ret
->st_mtime_nsec
, ret
->st_ctime_sec
,
1785 ret
->st_ctime_nsec
, ret
->st_btime_sec
, ret
->st_btime_nsec
,
1786 ret
->st_gen
, ret
->st_data_version
);
1788 p9_tag_remove(clnt
, req
);
1793 return ERR_PTR(err
);
1795 EXPORT_SYMBOL(p9_client_getattr_dotl
);
1797 static int p9_client_statsize(struct p9_wstat
*wst
, int proto_version
)
1801 /* NOTE: size shouldn't include its own length */
1802 /* size[2] type[2] dev[4] qid[13] */
1803 /* mode[4] atime[4] mtime[4] length[8]*/
1804 /* name[s] uid[s] gid[s] muid[s] */
1805 ret
= 2+4+13+4+4+4+8+2+2+2+2;
1808 ret
+= strlen(wst
->name
);
1810 ret
+= strlen(wst
->uid
);
1812 ret
+= strlen(wst
->gid
);
1814 ret
+= strlen(wst
->muid
);
1816 if ((proto_version
== p9_proto_2000u
) ||
1817 (proto_version
== p9_proto_2000L
)) {
1818 ret
+= 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1820 ret
+= strlen(wst
->extension
);
1826 int p9_client_wstat(struct p9_fid
*fid
, struct p9_wstat
*wst
)
1829 struct p9_req_t
*req
;
1830 struct p9_client
*clnt
;
1834 wst
->size
= p9_client_statsize(wst
, clnt
->proto_version
);
1835 p9_debug(P9_DEBUG_9P
, ">>> TWSTAT fid %d\n", fid
->fid
);
1836 p9_debug(P9_DEBUG_9P
,
1837 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1838 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1839 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1840 " uid=%d gid=%d n_muid=%d\n",
1841 wst
->size
, wst
->type
, wst
->dev
, wst
->qid
.type
,
1842 (unsigned long long)wst
->qid
.path
, wst
->qid
.version
, wst
->mode
,
1843 wst
->atime
, wst
->mtime
, (unsigned long long)wst
->length
,
1844 wst
->name
, wst
->uid
, wst
->gid
, wst
->muid
, wst
->extension
,
1845 from_kuid(&init_user_ns
, wst
->n_uid
),
1846 from_kgid(&init_user_ns
, wst
->n_gid
),
1847 from_kuid(&init_user_ns
, wst
->n_muid
));
1849 req
= p9_client_rpc(clnt
, P9_TWSTAT
, "dwS", fid
->fid
, wst
->size
+2, wst
);
1855 p9_debug(P9_DEBUG_9P
, "<<< RWSTAT fid %d\n", fid
->fid
);
1857 p9_tag_remove(clnt
, req
);
1861 EXPORT_SYMBOL(p9_client_wstat
);
1863 int p9_client_setattr(struct p9_fid
*fid
, struct p9_iattr_dotl
*p9attr
)
1866 struct p9_req_t
*req
;
1867 struct p9_client
*clnt
;
1871 p9_debug(P9_DEBUG_9P
, ">>> TSETATTR fid %d\n", fid
->fid
);
1872 p9_debug(P9_DEBUG_9P
,
1873 " valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1874 " atime_sec=%lld atime_nsec=%lld\n"
1875 " mtime_sec=%lld mtime_nsec=%lld\n",
1876 p9attr
->valid
, p9attr
->mode
,
1877 from_kuid(&init_user_ns
, p9attr
->uid
),
1878 from_kgid(&init_user_ns
, p9attr
->gid
),
1879 p9attr
->size
, p9attr
->atime_sec
, p9attr
->atime_nsec
,
1880 p9attr
->mtime_sec
, p9attr
->mtime_nsec
);
1882 req
= p9_client_rpc(clnt
, P9_TSETATTR
, "dI", fid
->fid
, p9attr
);
1888 p9_debug(P9_DEBUG_9P
, "<<< RSETATTR fid %d\n", fid
->fid
);
1889 p9_tag_remove(clnt
, req
);
1893 EXPORT_SYMBOL(p9_client_setattr
);
1895 int p9_client_statfs(struct p9_fid
*fid
, struct p9_rstatfs
*sb
)
1898 struct p9_req_t
*req
;
1899 struct p9_client
*clnt
;
1904 p9_debug(P9_DEBUG_9P
, ">>> TSTATFS fid %d\n", fid
->fid
);
1906 req
= p9_client_rpc(clnt
, P9_TSTATFS
, "d", fid
->fid
);
1912 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "ddqqqqqqd", &sb
->type
,
1913 &sb
->bsize
, &sb
->blocks
, &sb
->bfree
, &sb
->bavail
,
1914 &sb
->files
, &sb
->ffree
, &sb
->fsid
, &sb
->namelen
);
1916 trace_9p_protocol_dump(clnt
, &req
->rc
);
1917 p9_tag_remove(clnt
, req
);
1921 p9_debug(P9_DEBUG_9P
, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1922 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1923 "fsid %llu namelen %ld\n",
1924 fid
->fid
, (long unsigned int)sb
->type
, (long int)sb
->bsize
,
1925 sb
->blocks
, sb
->bfree
, sb
->bavail
, sb
->files
, sb
->ffree
,
1926 sb
->fsid
, (long int)sb
->namelen
);
1928 p9_tag_remove(clnt
, req
);
1932 EXPORT_SYMBOL(p9_client_statfs
);
1934 int p9_client_rename(struct p9_fid
*fid
,
1935 struct p9_fid
*newdirfid
, const char *name
)
1938 struct p9_req_t
*req
;
1939 struct p9_client
*clnt
;
1944 p9_debug(P9_DEBUG_9P
, ">>> TRENAME fid %d newdirfid %d name %s\n",
1945 fid
->fid
, newdirfid
->fid
, name
);
1947 req
= p9_client_rpc(clnt
, P9_TRENAME
, "dds", fid
->fid
,
1948 newdirfid
->fid
, name
);
1954 p9_debug(P9_DEBUG_9P
, "<<< RRENAME fid %d\n", fid
->fid
);
1956 p9_tag_remove(clnt
, req
);
1960 EXPORT_SYMBOL(p9_client_rename
);
1962 int p9_client_renameat(struct p9_fid
*olddirfid
, const char *old_name
,
1963 struct p9_fid
*newdirfid
, const char *new_name
)
1966 struct p9_req_t
*req
;
1967 struct p9_client
*clnt
;
1970 clnt
= olddirfid
->clnt
;
1972 p9_debug(P9_DEBUG_9P
, ">>> TRENAMEAT olddirfid %d old name %s"
1973 " newdirfid %d new name %s\n", olddirfid
->fid
, old_name
,
1974 newdirfid
->fid
, new_name
);
1976 req
= p9_client_rpc(clnt
, P9_TRENAMEAT
, "dsds", olddirfid
->fid
,
1977 old_name
, newdirfid
->fid
, new_name
);
1983 p9_debug(P9_DEBUG_9P
, "<<< RRENAMEAT newdirfid %d new name %s\n",
1984 newdirfid
->fid
, new_name
);
1986 p9_tag_remove(clnt
, req
);
1990 EXPORT_SYMBOL(p9_client_renameat
);
1993 * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
1995 struct p9_fid
*p9_client_xattrwalk(struct p9_fid
*file_fid
,
1996 const char *attr_name
, u64
*attr_size
)
1999 struct p9_req_t
*req
;
2000 struct p9_client
*clnt
;
2001 struct p9_fid
*attr_fid
;
2004 clnt
= file_fid
->clnt
;
2005 attr_fid
= p9_fid_create(clnt
);
2010 p9_debug(P9_DEBUG_9P
,
2011 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
2012 file_fid
->fid
, attr_fid
->fid
, attr_name
);
2014 req
= p9_client_rpc(clnt
, P9_TXATTRWALK
, "dds",
2015 file_fid
->fid
, attr_fid
->fid
, attr_name
);
2020 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "q", attr_size
);
2022 trace_9p_protocol_dump(clnt
, &req
->rc
);
2023 p9_tag_remove(clnt
, req
);
2026 p9_tag_remove(clnt
, req
);
2027 p9_debug(P9_DEBUG_9P
, "<<< RXATTRWALK fid %d size %llu\n",
2028 attr_fid
->fid
, *attr_size
);
2031 p9_client_clunk(attr_fid
);
2034 if (attr_fid
&& (attr_fid
!= file_fid
))
2035 p9_fid_destroy(attr_fid
);
2037 return ERR_PTR(err
);
2039 EXPORT_SYMBOL_GPL(p9_client_xattrwalk
);
2041 int p9_client_xattrcreate(struct p9_fid
*fid
, const char *name
,
2042 u64 attr_size
, int flags
)
2045 struct p9_req_t
*req
;
2046 struct p9_client
*clnt
;
2048 p9_debug(P9_DEBUG_9P
,
2049 ">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
2050 fid
->fid
, name
, (long long)attr_size
, flags
);
2053 req
= p9_client_rpc(clnt
, P9_TXATTRCREATE
, "dsqd",
2054 fid
->fid
, name
, attr_size
, flags
);
2059 p9_debug(P9_DEBUG_9P
, "<<< RXATTRCREATE fid %d\n", fid
->fid
);
2060 p9_tag_remove(clnt
, req
);
2064 EXPORT_SYMBOL_GPL(p9_client_xattrcreate
);
2066 int p9_client_readdir(struct p9_fid
*fid
, char *data
, u32 count
, u64 offset
)
2068 int err
, rsize
, non_zc
= 0;
2069 struct p9_client
*clnt
;
2070 struct p9_req_t
*req
;
2072 struct kvec kv
= {.iov_base
= data
, .iov_len
= count
};
2075 iov_iter_kvec(&to
, READ
, &kv
, 1, count
);
2077 p9_debug(P9_DEBUG_9P
, ">>> TREADDIR fid %d offset %llu count %d\n",
2078 fid
->fid
, (unsigned long long) offset
, count
);
2083 rsize
= fid
->iounit
;
2084 if (!rsize
|| rsize
> clnt
->msize
-P9_READDIRHDRSZ
)
2085 rsize
= clnt
->msize
- P9_READDIRHDRSZ
;
2090 /* Don't bother zerocopy for small IO (< 1024) */
2091 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
2093 * response header len is 11
2094 * PDU Header(7) + IO Size (4)
2096 req
= p9_client_zc_rpc(clnt
, P9_TREADDIR
, &to
, NULL
, rsize
, 0,
2097 11, "dqd", fid
->fid
, offset
, rsize
);
2100 req
= p9_client_rpc(clnt
, P9_TREADDIR
, "dqd", fid
->fid
,
2108 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "D", &count
, &dataptr
);
2110 trace_9p_protocol_dump(clnt
, &req
->rc
);
2111 goto free_and_error
;
2113 if (rsize
< count
) {
2114 pr_err("bogus RREADDIR count (%d > %d)\n", count
, rsize
);
2118 p9_debug(P9_DEBUG_9P
, "<<< RREADDIR count %d\n", count
);
2121 memmove(data
, dataptr
, count
);
2123 p9_tag_remove(clnt
, req
);
2127 p9_tag_remove(clnt
, req
);
2131 EXPORT_SYMBOL(p9_client_readdir
);
2133 int p9_client_mknod_dotl(struct p9_fid
*fid
, const char *name
, int mode
,
2134 dev_t rdev
, kgid_t gid
, struct p9_qid
*qid
)
2137 struct p9_client
*clnt
;
2138 struct p9_req_t
*req
;
2142 p9_debug(P9_DEBUG_9P
, ">>> TMKNOD fid %d name %s mode %d major %d "
2143 "minor %d\n", fid
->fid
, name
, mode
, MAJOR(rdev
), MINOR(rdev
));
2144 req
= p9_client_rpc(clnt
, P9_TMKNOD
, "dsdddg", fid
->fid
, name
, mode
,
2145 MAJOR(rdev
), MINOR(rdev
), gid
);
2147 return PTR_ERR(req
);
2149 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Q", qid
);
2151 trace_9p_protocol_dump(clnt
, &req
->rc
);
2154 p9_debug(P9_DEBUG_9P
, "<<< RMKNOD qid %x.%llx.%x\n", qid
->type
,
2155 (unsigned long long)qid
->path
, qid
->version
);
2158 p9_tag_remove(clnt
, req
);
2162 EXPORT_SYMBOL(p9_client_mknod_dotl
);
2164 int p9_client_mkdir_dotl(struct p9_fid
*fid
, const char *name
, int mode
,
2165 kgid_t gid
, struct p9_qid
*qid
)
2168 struct p9_client
*clnt
;
2169 struct p9_req_t
*req
;
2173 p9_debug(P9_DEBUG_9P
, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
2174 fid
->fid
, name
, mode
, from_kgid(&init_user_ns
, gid
));
2175 req
= p9_client_rpc(clnt
, P9_TMKDIR
, "dsdg", fid
->fid
, name
, mode
,
2178 return PTR_ERR(req
);
2180 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "Q", qid
);
2182 trace_9p_protocol_dump(clnt
, &req
->rc
);
2185 p9_debug(P9_DEBUG_9P
, "<<< RMKDIR qid %x.%llx.%x\n", qid
->type
,
2186 (unsigned long long)qid
->path
, qid
->version
);
2189 p9_tag_remove(clnt
, req
);
2193 EXPORT_SYMBOL(p9_client_mkdir_dotl
);
2195 int p9_client_lock_dotl(struct p9_fid
*fid
, struct p9_flock
*flock
, u8
*status
)
2198 struct p9_client
*clnt
;
2199 struct p9_req_t
*req
;
2203 p9_debug(P9_DEBUG_9P
, ">>> TLOCK fid %d type %i flags %d "
2204 "start %lld length %lld proc_id %d client_id %s\n",
2205 fid
->fid
, flock
->type
, flock
->flags
, flock
->start
,
2206 flock
->length
, flock
->proc_id
, flock
->client_id
);
2208 req
= p9_client_rpc(clnt
, P9_TLOCK
, "dbdqqds", fid
->fid
, flock
->type
,
2209 flock
->flags
, flock
->start
, flock
->length
,
2210 flock
->proc_id
, flock
->client_id
);
2213 return PTR_ERR(req
);
2215 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "b", status
);
2217 trace_9p_protocol_dump(clnt
, &req
->rc
);
2220 p9_debug(P9_DEBUG_9P
, "<<< RLOCK status %i\n", *status
);
2222 p9_tag_remove(clnt
, req
);
2226 EXPORT_SYMBOL(p9_client_lock_dotl
);
2228 int p9_client_getlock_dotl(struct p9_fid
*fid
, struct p9_getlock
*glock
)
2231 struct p9_client
*clnt
;
2232 struct p9_req_t
*req
;
2236 p9_debug(P9_DEBUG_9P
, ">>> TGETLOCK fid %d, type %i start %lld "
2237 "length %lld proc_id %d client_id %s\n", fid
->fid
, glock
->type
,
2238 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
2240 req
= p9_client_rpc(clnt
, P9_TGETLOCK
, "dbqqds", fid
->fid
, glock
->type
,
2241 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
2244 return PTR_ERR(req
);
2246 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "bqqds", &glock
->type
,
2247 &glock
->start
, &glock
->length
, &glock
->proc_id
,
2250 trace_9p_protocol_dump(clnt
, &req
->rc
);
2253 p9_debug(P9_DEBUG_9P
, "<<< RGETLOCK type %i start %lld length %lld "
2254 "proc_id %d client_id %s\n", glock
->type
, glock
->start
,
2255 glock
->length
, glock
->proc_id
, glock
->client_id
);
2257 p9_tag_remove(clnt
, req
);
2260 EXPORT_SYMBOL(p9_client_getlock_dotl
);
2262 int p9_client_readlink(struct p9_fid
*fid
, char **target
)
2265 struct p9_client
*clnt
;
2266 struct p9_req_t
*req
;
2270 p9_debug(P9_DEBUG_9P
, ">>> TREADLINK fid %d\n", fid
->fid
);
2272 req
= p9_client_rpc(clnt
, P9_TREADLINK
, "d", fid
->fid
);
2274 return PTR_ERR(req
);
2276 err
= p9pdu_readf(&req
->rc
, clnt
->proto_version
, "s", target
);
2278 trace_9p_protocol_dump(clnt
, &req
->rc
);
2281 p9_debug(P9_DEBUG_9P
, "<<< RREADLINK target %s\n", *target
);
2283 p9_tag_remove(clnt
, req
);
2286 EXPORT_SYMBOL(p9_client_readlink
);
2288 int __init
p9_client_init(void)
2290 p9_req_cache
= KMEM_CACHE(p9_req_t
, SLAB_TYPESAFE_BY_RCU
);
2291 return p9_req_cache
? 0 : -ENOMEM
;
2294 void __exit
p9_client_exit(void)
2296 kmem_cache_destroy(p9_req_cache
);