6 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2
11 * as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to:
20 * Free Software Foundation
21 * 51 Franklin Street, Fifth Floor
22 * Boston, MA 02111-1301 USA
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28 #include <linux/module.h>
29 #include <linux/errno.h>
31 #include <linux/poll.h>
32 #include <linux/idr.h>
33 #include <linux/mutex.h>
34 #include <linux/slab.h>
35 #include <linux/sched/signal.h>
36 #include <linux/uaccess.h>
37 #include <linux/uio.h>
38 #include <net/9p/9p.h>
39 #include <linux/parser.h>
40 #include <linux/seq_file.h>
41 #include <net/9p/client.h>
42 #include <net/9p/transport.h>
45 #define CREATE_TRACE_POINTS
46 #include <trace/events/9p.h>
49 * Client Option Parsing (code inspired by NFS code)
50 * - a little lazy - parse all client options
61 static const match_table_t tokens
= {
62 {Opt_msize
, "msize=%u"},
63 {Opt_legacy
, "noextend"},
64 {Opt_trans
, "trans=%s"},
65 {Opt_version
, "version=%s"},
69 inline int p9_is_proto_dotl(struct p9_client
*clnt
)
71 return clnt
->proto_version
== p9_proto_2000L
;
73 EXPORT_SYMBOL(p9_is_proto_dotl
);
75 inline int p9_is_proto_dotu(struct p9_client
*clnt
)
77 return clnt
->proto_version
== p9_proto_2000u
;
79 EXPORT_SYMBOL(p9_is_proto_dotu
);
81 int p9_show_client_options(struct seq_file
*m
, struct p9_client
*clnt
)
83 if (clnt
->msize
!= 8192)
84 seq_printf(m
, ",msize=%u", clnt
->msize
);
85 seq_printf(m
, ",trans=%s", clnt
->trans_mod
->name
);
87 switch (clnt
->proto_version
) {
89 seq_puts(m
, ",noextend");
92 seq_puts(m
, ",version=9p2000.u");
99 if (clnt
->trans_mod
->show_options
)
100 return clnt
->trans_mod
->show_options(m
, clnt
);
103 EXPORT_SYMBOL(p9_show_client_options
);
106 * Some error codes are taken directly from the server replies,
107 * make sure they are valid.
109 static int safe_errno(int err
)
111 if ((err
> 0) || (err
< -MAX_ERRNO
)) {
112 p9_debug(P9_DEBUG_ERROR
, "Invalid error code %d\n", err
);
119 /* Interpret mount option for protocol version */
120 static int get_protocol_version(char *s
)
122 int version
= -EINVAL
;
124 if (!strcmp(s
, "9p2000")) {
125 version
= p9_proto_legacy
;
126 p9_debug(P9_DEBUG_9P
, "Protocol version: Legacy\n");
127 } else if (!strcmp(s
, "9p2000.u")) {
128 version
= p9_proto_2000u
;
129 p9_debug(P9_DEBUG_9P
, "Protocol version: 9P2000.u\n");
130 } else if (!strcmp(s
, "9p2000.L")) {
131 version
= p9_proto_2000L
;
132 p9_debug(P9_DEBUG_9P
, "Protocol version: 9P2000.L\n");
134 pr_info("Unknown protocol version %s\n", s
);
140 * parse_options - parse mount options into client structure
141 * @opts: options string passed from mount
142 * @clnt: existing v9fs client information
144 * Return 0 upon success, -ERRNO upon failure
147 static int parse_opts(char *opts
, struct p9_client
*clnt
)
149 char *options
, *tmp_options
;
151 substring_t args
[MAX_OPT_ARGS
];
156 clnt
->proto_version
= p9_proto_2000L
;
162 tmp_options
= kstrdup(opts
, GFP_KERNEL
);
164 p9_debug(P9_DEBUG_ERROR
,
165 "failed to allocate copy of option string\n");
168 options
= tmp_options
;
170 while ((p
= strsep(&options
, ",")) != NULL
) {
174 token
= match_token(p
, tokens
, args
);
177 r
= match_int(&args
[0], &option
);
179 p9_debug(P9_DEBUG_ERROR
,
180 "integer field, but no integer?\n");
185 p9_debug(P9_DEBUG_ERROR
,
186 "msize should be at least 4k\n");
190 clnt
->msize
= option
;
193 s
= match_strdup(&args
[0]);
196 p9_debug(P9_DEBUG_ERROR
,
197 "problem allocating copy of trans arg\n");
198 goto free_and_return
;
200 clnt
->trans_mod
= v9fs_get_trans_by_name(s
);
201 if (clnt
->trans_mod
== NULL
) {
202 pr_info("Could not find request transport: %s\n",
206 goto free_and_return
;
211 clnt
->proto_version
= p9_proto_legacy
;
214 s
= match_strdup(&args
[0]);
217 p9_debug(P9_DEBUG_ERROR
,
218 "problem allocating copy of version arg\n");
219 goto free_and_return
;
221 ret
= get_protocol_version(s
);
222 if (ret
== -EINVAL
) {
224 goto free_and_return
;
227 clnt
->proto_version
= ret
;
239 static struct p9_fcall
*p9_fcall_alloc(int alloc_msize
)
242 fc
= kmalloc(sizeof(struct p9_fcall
) + alloc_msize
, GFP_NOFS
);
245 fc
->capacity
= alloc_msize
;
246 fc
->sdata
= (char *) fc
+ sizeof(struct p9_fcall
);
251 * p9_tag_alloc - lookup/allocate a request by tag
252 * @c: client session to lookup tag within
253 * @tag: numeric id for transaction
255 * this is a simple array lookup, but will grow the
256 * request_slots as necessary to accommodate transaction
257 * ids which did not previously have a slot.
259 * this code relies on the client spinlock to manage locks, its
260 * possible we should switch to something else, but I'd rather
261 * stick with something low-overhead for the common case.
265 static struct p9_req_t
*
266 p9_tag_alloc(struct p9_client
*c
, u16 tag
, unsigned int max_size
)
270 struct p9_req_t
*req
;
271 int alloc_msize
= min(c
->msize
, max_size
);
273 /* This looks up the original request by tag so we know which
274 * buffer to read the data into */
277 if (tag
>= c
->max_tag
) {
278 spin_lock_irqsave(&c
->lock
, flags
);
279 /* check again since original check was outside of lock */
280 while (tag
>= c
->max_tag
) {
281 row
= (tag
/ P9_ROW_MAXTAG
);
282 c
->reqs
[row
] = kcalloc(P9_ROW_MAXTAG
,
283 sizeof(struct p9_req_t
), GFP_ATOMIC
);
286 pr_err("Couldn't grow tag array\n");
287 spin_unlock_irqrestore(&c
->lock
, flags
);
288 return ERR_PTR(-ENOMEM
);
290 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
291 c
->reqs
[row
][col
].status
= REQ_STATUS_IDLE
;
292 c
->reqs
[row
][col
].tc
= NULL
;
294 c
->max_tag
+= P9_ROW_MAXTAG
;
296 spin_unlock_irqrestore(&c
->lock
, flags
);
298 row
= tag
/ P9_ROW_MAXTAG
;
299 col
= tag
% P9_ROW_MAXTAG
;
301 req
= &c
->reqs
[row
][col
];
303 req
->wq
= kmalloc(sizeof(wait_queue_head_t
), GFP_NOFS
);
306 init_waitqueue_head(req
->wq
);
310 req
->tc
= p9_fcall_alloc(alloc_msize
);
312 req
->rc
= p9_fcall_alloc(alloc_msize
);
313 if (!req
->tc
|| !req
->rc
)
316 p9pdu_reset(req
->tc
);
317 p9pdu_reset(req
->rc
);
319 req
->tc
->tag
= tag
-1;
320 req
->status
= REQ_STATUS_ALLOC
;
325 pr_err("Couldn't grow tag array\n");
329 req
->tc
= req
->rc
= NULL
;
331 return ERR_PTR(-ENOMEM
);
335 * p9_tag_lookup - lookup a request by tag
336 * @c: client session to lookup tag within
337 * @tag: numeric id for transaction
341 struct p9_req_t
*p9_tag_lookup(struct p9_client
*c
, u16 tag
)
345 /* This looks up the original request by tag so we know which
346 * buffer to read the data into */
349 if(tag
>= c
->max_tag
)
352 row
= tag
/ P9_ROW_MAXTAG
;
353 col
= tag
% P9_ROW_MAXTAG
;
355 return &c
->reqs
[row
][col
];
357 EXPORT_SYMBOL(p9_tag_lookup
);
360 * p9_tag_init - setup tags structure and contents
361 * @c: v9fs client struct
363 * This initializes the tags structure for each client instance.
367 static int p9_tag_init(struct p9_client
*c
)
371 c
->tagpool
= p9_idpool_create();
372 if (IS_ERR(c
->tagpool
)) {
373 err
= PTR_ERR(c
->tagpool
);
376 err
= p9_idpool_get(c
->tagpool
); /* reserve tag 0 */
378 p9_idpool_destroy(c
->tagpool
);
387 * p9_tag_cleanup - cleans up tags structure and reclaims resources
388 * @c: v9fs client struct
390 * This frees resources associated with the tags structure
393 static void p9_tag_cleanup(struct p9_client
*c
)
397 /* check to insure all requests are idle */
398 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
399 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
400 if (c
->reqs
[row
][col
].status
!= REQ_STATUS_IDLE
) {
401 p9_debug(P9_DEBUG_MUX
,
402 "Attempting to cleanup non-free tag %d,%d\n",
404 /* TODO: delay execution of cleanup */
411 p9_idpool_put(0, c
->tagpool
); /* free reserved tag 0 */
412 p9_idpool_destroy(c
->tagpool
);
415 /* free requests associated with tags */
416 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
417 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
418 kfree(c
->reqs
[row
][col
].wq
);
419 kfree(c
->reqs
[row
][col
].tc
);
420 kfree(c
->reqs
[row
][col
].rc
);
428 * p9_free_req - free a request and clean-up as necessary
430 * r: request to release
434 static void p9_free_req(struct p9_client
*c
, struct p9_req_t
*r
)
436 int tag
= r
->tc
->tag
;
437 p9_debug(P9_DEBUG_MUX
, "clnt %p req %p tag: %d\n", c
, r
, tag
);
439 r
->status
= REQ_STATUS_IDLE
;
440 if (tag
!= P9_NOTAG
&& p9_idpool_check(tag
, c
->tagpool
))
441 p9_idpool_put(tag
, c
->tagpool
);
445 * p9_client_cb - call back from transport to client
447 * req: request received
450 void p9_client_cb(struct p9_client
*c
, struct p9_req_t
*req
, int status
)
452 p9_debug(P9_DEBUG_MUX
, " tag %d\n", req
->tc
->tag
);
455 * This barrier is needed to make sure any change made to req before
456 * the other thread wakes up will indeed be seen by the waiting side.
459 req
->status
= status
;
462 p9_debug(P9_DEBUG_MUX
, "wakeup: %d\n", req
->tc
->tag
);
464 EXPORT_SYMBOL(p9_client_cb
);
467 * p9_parse_header - parse header arguments out of a packet
468 * @pdu: packet to parse
469 * @size: size of packet
470 * @type: type of request
471 * @tag: tag of packet
472 * @rewind: set if we need to rewind offset afterwards
476 p9_parse_header(struct p9_fcall
*pdu
, int32_t *size
, int8_t *type
, int16_t *tag
,
482 int offset
= pdu
->offset
;
489 err
= p9pdu_readf(pdu
, 0, "dbw", &r_size
, &r_type
, &r_tag
);
491 goto rewind_and_exit
;
497 p9_debug(P9_DEBUG_9P
, "<<< size=%d type: %d tag: %d\n",
498 pdu
->size
, pdu
->id
, pdu
->tag
);
510 pdu
->offset
= offset
;
513 EXPORT_SYMBOL(p9_parse_header
);
516 * p9_check_errors - check 9p packet for error return and process it
517 * @c: current client instance
518 * @req: request to parse and check for error conditions
520 * returns error code if one is discovered, otherwise returns 0
522 * this will have to be more complicated if we have multiple
526 static int p9_check_errors(struct p9_client
*c
, struct p9_req_t
*req
)
532 err
= p9_parse_header(req
->rc
, NULL
, &type
, NULL
, 0);
534 * dump the response from server
535 * This should be after check errors which poplulate pdu_fcall.
537 trace_9p_protocol_dump(c
, req
->rc
);
539 p9_debug(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
542 if (type
!= P9_RERROR
&& type
!= P9_RLERROR
)
545 if (!p9_is_proto_dotl(c
)) {
547 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "s?d",
552 if (p9_is_proto_dotu(c
) && ecode
< 512)
556 err
= p9_errstr2errno(ename
, strlen(ename
));
558 p9_debug(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n",
563 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "d", &ecode
);
566 p9_debug(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
572 p9_debug(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
578 * p9_check_zc_errors - check 9p packet for error return and process it
579 * @c: current client instance
580 * @req: request to parse and check for error conditions
581 * @in_hdrlen: Size of response protocol buffer.
583 * returns error code if one is discovered, otherwise returns 0
585 * this will have to be more complicated if we have multiple
589 static int p9_check_zc_errors(struct p9_client
*c
, struct p9_req_t
*req
,
590 struct iov_iter
*uidata
, int in_hdrlen
)
597 err
= p9_parse_header(req
->rc
, NULL
, &type
, NULL
, 0);
599 * dump the response from server
600 * This should be after parse_header which poplulate pdu_fcall.
602 trace_9p_protocol_dump(c
, req
->rc
);
604 p9_debug(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
608 if (type
!= P9_RERROR
&& type
!= P9_RLERROR
)
611 if (!p9_is_proto_dotl(c
)) {
612 /* Error is reported in string format */
614 /* 7 = header size for RERROR; */
615 int inline_len
= in_hdrlen
- 7;
617 len
= req
->rc
->size
- req
->rc
->offset
;
618 if (len
> (P9_ZC_HDR_SZ
- 7)) {
623 ename
= &req
->rc
->sdata
[req
->rc
->offset
];
624 if (len
> inline_len
) {
625 /* We have error in external buffer */
626 if (!copy_from_iter_full(ename
+ inline_len
,
627 len
- inline_len
, uidata
)) {
633 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "s?d",
638 if (p9_is_proto_dotu(c
) && ecode
< 512)
642 err
= p9_errstr2errno(ename
, strlen(ename
));
644 p9_debug(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n",
649 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "d", &ecode
);
652 p9_debug(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
657 p9_debug(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
661 static struct p9_req_t
*
662 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...);
665 * p9_client_flush - flush (cancel) a request
667 * @oldreq: request to cancel
669 * This sents a flush for a particular request and links
670 * the flush request to the original request. The current
671 * code only supports a single flush request although the protocol
672 * allows for multiple flush requests to be sent for a single request.
676 static int p9_client_flush(struct p9_client
*c
, struct p9_req_t
*oldreq
)
678 struct p9_req_t
*req
;
682 err
= p9_parse_header(oldreq
->tc
, NULL
, NULL
, &oldtag
, 1);
686 p9_debug(P9_DEBUG_9P
, ">>> TFLUSH tag %d\n", oldtag
);
688 req
= p9_client_rpc(c
, P9_TFLUSH
, "w", oldtag
);
693 * if we haven't received a response for oldreq,
694 * remove it from the list
696 if (oldreq
->status
== REQ_STATUS_SENT
)
697 if (c
->trans_mod
->cancelled
)
698 c
->trans_mod
->cancelled(c
, oldreq
);
704 static struct p9_req_t
*p9_client_prepare_req(struct p9_client
*c
,
705 int8_t type
, int req_size
,
706 const char *fmt
, va_list ap
)
709 struct p9_req_t
*req
;
711 p9_debug(P9_DEBUG_MUX
, "client %p op %d\n", c
, type
);
713 /* we allow for any status other than disconnected */
714 if (c
->status
== Disconnected
)
715 return ERR_PTR(-EIO
);
717 /* if status is begin_disconnected we allow only clunk request */
718 if ((c
->status
== BeginDisconnect
) && (type
!= P9_TCLUNK
))
719 return ERR_PTR(-EIO
);
722 if (type
!= P9_TVERSION
) {
723 tag
= p9_idpool_get(c
->tagpool
);
725 return ERR_PTR(-ENOMEM
);
728 req
= p9_tag_alloc(c
, tag
, req_size
);
732 /* marshall the data */
733 p9pdu_prepare(req
->tc
, tag
, type
);
734 err
= p9pdu_vwritef(req
->tc
, c
->proto_version
, fmt
, ap
);
737 p9pdu_finalize(c
, req
->tc
);
738 trace_9p_client_req(c
, type
, tag
);
746 * p9_client_rpc - issue a request and wait for a response
748 * @type: type of request
749 * @fmt: protocol format string (see protocol.c)
751 * Returns request structure (which client must free using p9_free_req)
754 static struct p9_req_t
*
755 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...)
760 struct p9_req_t
*req
;
763 req
= p9_client_prepare_req(c
, type
, c
->msize
, fmt
, ap
);
768 if (signal_pending(current
)) {
770 clear_thread_flag(TIF_SIGPENDING
);
774 err
= c
->trans_mod
->request(c
, req
);
776 if (err
!= -ERESTARTSYS
&& err
!= -EFAULT
)
777 c
->status
= Disconnected
;
781 /* Wait for the response */
782 err
= wait_event_killable(*req
->wq
, req
->status
>= REQ_STATUS_RCVD
);
785 * Make sure our req is coherent with regard to updates in other
786 * threads - echoes to wmb() in the callback
790 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)
791 && (type
== P9_TFLUSH
)) {
793 clear_thread_flag(TIF_SIGPENDING
);
797 if (req
->status
== REQ_STATUS_ERROR
) {
798 p9_debug(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
801 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
802 p9_debug(P9_DEBUG_MUX
, "flushing\n");
804 clear_thread_flag(TIF_SIGPENDING
);
806 if (c
->trans_mod
->cancel(c
, req
))
807 p9_client_flush(c
, req
);
809 /* if we received the response anyway, don't signal error */
810 if (req
->status
== REQ_STATUS_RCVD
)
814 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
816 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
821 err
= p9_check_errors(c
, req
);
822 trace_9p_client_res(c
, type
, req
->rc
->tag
, err
);
827 return ERR_PTR(safe_errno(err
));
831 * p9_client_zc_rpc - issue a request and wait for a response
833 * @type: type of request
834 * @uidata: destination for zero copy read
835 * @uodata: source for zero copy write
836 * @inlen: read buffer size
837 * @olen: write buffer size
838 * @hdrlen: reader header size, This is the size of response protocol data
839 * @fmt: protocol format string (see protocol.c)
841 * Returns request structure (which client must free using p9_free_req)
843 static struct p9_req_t
*p9_client_zc_rpc(struct p9_client
*c
, int8_t type
,
844 struct iov_iter
*uidata
,
845 struct iov_iter
*uodata
,
846 int inlen
, int olen
, int in_hdrlen
,
847 const char *fmt
, ...)
852 struct p9_req_t
*req
;
856 * We allocate a inline protocol data of only 4k bytes.
857 * The actual content is passed in zero-copy fashion.
859 req
= p9_client_prepare_req(c
, type
, P9_ZC_HDR_SZ
, fmt
, ap
);
864 if (signal_pending(current
)) {
866 clear_thread_flag(TIF_SIGPENDING
);
870 err
= c
->trans_mod
->zc_request(c
, req
, uidata
, uodata
,
871 inlen
, olen
, in_hdrlen
);
874 c
->status
= Disconnected
;
875 if (err
!= -ERESTARTSYS
)
878 if (req
->status
== REQ_STATUS_ERROR
) {
879 p9_debug(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
882 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
883 p9_debug(P9_DEBUG_MUX
, "flushing\n");
885 clear_thread_flag(TIF_SIGPENDING
);
887 if (c
->trans_mod
->cancel(c
, req
))
888 p9_client_flush(c
, req
);
890 /* if we received the response anyway, don't signal error */
891 if (req
->status
== REQ_STATUS_RCVD
)
895 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
897 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
902 err
= p9_check_zc_errors(c
, req
, uidata
, in_hdrlen
);
903 trace_9p_client_res(c
, type
, req
->rc
->tag
, err
);
908 return ERR_PTR(safe_errno(err
));
911 static struct p9_fid
*p9_fid_create(struct p9_client
*clnt
)
917 p9_debug(P9_DEBUG_FID
, "clnt %p\n", clnt
);
918 fid
= kmalloc(sizeof(struct p9_fid
), GFP_KERNEL
);
920 return ERR_PTR(-ENOMEM
);
922 ret
= p9_idpool_get(clnt
->fidpool
);
929 memset(&fid
->qid
, 0, sizeof(struct p9_qid
));
931 fid
->uid
= current_fsuid();
934 spin_lock_irqsave(&clnt
->lock
, flags
);
935 list_add(&fid
->flist
, &clnt
->fidlist
);
936 spin_unlock_irqrestore(&clnt
->lock
, flags
);
945 static void p9_fid_destroy(struct p9_fid
*fid
)
947 struct p9_client
*clnt
;
950 p9_debug(P9_DEBUG_FID
, "fid %d\n", fid
->fid
);
952 p9_idpool_put(fid
->fid
, clnt
->fidpool
);
953 spin_lock_irqsave(&clnt
->lock
, flags
);
954 list_del(&fid
->flist
);
955 spin_unlock_irqrestore(&clnt
->lock
, flags
);
960 static int p9_client_version(struct p9_client
*c
)
963 struct p9_req_t
*req
;
964 char *version
= NULL
;
967 p9_debug(P9_DEBUG_9P
, ">>> TVERSION msize %d protocol %d\n",
968 c
->msize
, c
->proto_version
);
970 switch (c
->proto_version
) {
972 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
973 c
->msize
, "9P2000.L");
976 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
977 c
->msize
, "9P2000.u");
979 case p9_proto_legacy
:
980 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
990 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "ds", &msize
, &version
);
992 p9_debug(P9_DEBUG_9P
, "version error %d\n", err
);
993 trace_9p_protocol_dump(c
, req
->rc
);
997 p9_debug(P9_DEBUG_9P
, "<<< RVERSION msize %d %s\n", msize
, version
);
998 if (!strncmp(version
, "9P2000.L", 8))
999 c
->proto_version
= p9_proto_2000L
;
1000 else if (!strncmp(version
, "9P2000.u", 8))
1001 c
->proto_version
= p9_proto_2000u
;
1002 else if (!strncmp(version
, "9P2000", 6))
1003 c
->proto_version
= p9_proto_legacy
;
1005 p9_debug(P9_DEBUG_ERROR
,
1006 "server returned an unknown version: %s\n", version
);
1012 p9_debug(P9_DEBUG_ERROR
,
1013 "server returned a msize < 4096: %d\n", msize
);
1017 if (msize
< c
->msize
)
1022 p9_free_req(c
, req
);
1027 struct p9_client
*p9_client_create(const char *dev_name
, char *options
)
1030 struct p9_client
*clnt
;
1034 clnt
= kmalloc(sizeof(struct p9_client
), GFP_KERNEL
);
1036 return ERR_PTR(-ENOMEM
);
1038 clnt
->trans_mod
= NULL
;
1041 client_id
= utsname()->nodename
;
1042 memcpy(clnt
->name
, client_id
, strlen(client_id
) + 1);
1044 spin_lock_init(&clnt
->lock
);
1045 INIT_LIST_HEAD(&clnt
->fidlist
);
1047 err
= p9_tag_init(clnt
);
1051 err
= parse_opts(options
, clnt
);
1053 goto destroy_tagpool
;
1055 if (!clnt
->trans_mod
)
1056 clnt
->trans_mod
= v9fs_get_default_trans();
1058 if (clnt
->trans_mod
== NULL
) {
1059 err
= -EPROTONOSUPPORT
;
1060 p9_debug(P9_DEBUG_ERROR
,
1061 "No transport defined or default transport\n");
1062 goto destroy_tagpool
;
1065 clnt
->fidpool
= p9_idpool_create();
1066 if (IS_ERR(clnt
->fidpool
)) {
1067 err
= PTR_ERR(clnt
->fidpool
);
1071 p9_debug(P9_DEBUG_MUX
, "clnt %p trans %p msize %d protocol %d\n",
1072 clnt
, clnt
->trans_mod
, clnt
->msize
, clnt
->proto_version
);
1074 err
= clnt
->trans_mod
->create(clnt
, dev_name
, options
);
1076 goto destroy_fidpool
;
1078 if (clnt
->msize
> clnt
->trans_mod
->maxsize
)
1079 clnt
->msize
= clnt
->trans_mod
->maxsize
;
1081 if (clnt
->msize
< 4096) {
1082 p9_debug(P9_DEBUG_ERROR
,
1083 "Please specify a msize of at least 4k\n");
1088 err
= p9_client_version(clnt
);
1095 clnt
->trans_mod
->close(clnt
);
1097 p9_idpool_destroy(clnt
->fidpool
);
1099 v9fs_put_trans(clnt
->trans_mod
);
1101 p9_idpool_destroy(clnt
->tagpool
);
1104 return ERR_PTR(err
);
1106 EXPORT_SYMBOL(p9_client_create
);
1108 void p9_client_destroy(struct p9_client
*clnt
)
1110 struct p9_fid
*fid
, *fidptr
;
1112 p9_debug(P9_DEBUG_MUX
, "clnt %p\n", clnt
);
1114 if (clnt
->trans_mod
)
1115 clnt
->trans_mod
->close(clnt
);
1117 v9fs_put_trans(clnt
->trans_mod
);
1119 list_for_each_entry_safe(fid
, fidptr
, &clnt
->fidlist
, flist
) {
1120 pr_info("Found fid %d not clunked\n", fid
->fid
);
1121 p9_fid_destroy(fid
);
1125 p9_idpool_destroy(clnt
->fidpool
);
1127 p9_tag_cleanup(clnt
);
1131 EXPORT_SYMBOL(p9_client_destroy
);
1133 void p9_client_disconnect(struct p9_client
*clnt
)
1135 p9_debug(P9_DEBUG_9P
, "clnt %p\n", clnt
);
1136 clnt
->status
= Disconnected
;
1138 EXPORT_SYMBOL(p9_client_disconnect
);
1140 void p9_client_begin_disconnect(struct p9_client
*clnt
)
1142 p9_debug(P9_DEBUG_9P
, "clnt %p\n", clnt
);
1143 clnt
->status
= BeginDisconnect
;
1145 EXPORT_SYMBOL(p9_client_begin_disconnect
);
1147 struct p9_fid
*p9_client_attach(struct p9_client
*clnt
, struct p9_fid
*afid
,
1148 const char *uname
, kuid_t n_uname
, const char *aname
)
1151 struct p9_req_t
*req
;
1156 p9_debug(P9_DEBUG_9P
, ">>> TATTACH afid %d uname %s aname %s\n",
1157 afid
? afid
->fid
: -1, uname
, aname
);
1158 fid
= p9_fid_create(clnt
);
1166 req
= p9_client_rpc(clnt
, P9_TATTACH
, "ddss?u", fid
->fid
,
1167 afid
? afid
->fid
: P9_NOFID
, uname
, aname
, n_uname
);
1173 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", &qid
);
1175 trace_9p_protocol_dump(clnt
, req
->rc
);
1176 p9_free_req(clnt
, req
);
1180 p9_debug(P9_DEBUG_9P
, "<<< RATTACH qid %x.%llx.%x\n",
1181 qid
.type
, (unsigned long long)qid
.path
, qid
.version
);
1183 memmove(&fid
->qid
, &qid
, sizeof(struct p9_qid
));
1185 p9_free_req(clnt
, req
);
1190 p9_fid_destroy(fid
);
1191 return ERR_PTR(err
);
1193 EXPORT_SYMBOL(p9_client_attach
);
1195 struct p9_fid
*p9_client_walk(struct p9_fid
*oldfid
, uint16_t nwname
,
1196 const unsigned char * const *wnames
, int clone
)
1199 struct p9_client
*clnt
;
1201 struct p9_qid
*wqids
;
1202 struct p9_req_t
*req
;
1203 uint16_t nwqids
, count
;
1207 clnt
= oldfid
->clnt
;
1209 fid
= p9_fid_create(clnt
);
1216 fid
->uid
= oldfid
->uid
;
1221 p9_debug(P9_DEBUG_9P
, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
1222 oldfid
->fid
, fid
->fid
, nwname
, wnames
? wnames
[0] : NULL
);
1224 req
= p9_client_rpc(clnt
, P9_TWALK
, "ddT", oldfid
->fid
, fid
->fid
,
1231 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "R", &nwqids
, &wqids
);
1233 trace_9p_protocol_dump(clnt
, req
->rc
);
1234 p9_free_req(clnt
, req
);
1237 p9_free_req(clnt
, req
);
1239 p9_debug(P9_DEBUG_9P
, "<<< RWALK nwqid %d:\n", nwqids
);
1241 if (nwqids
!= nwname
) {
1246 for (count
= 0; count
< nwqids
; count
++)
1247 p9_debug(P9_DEBUG_9P
, "<<< [%d] %x.%llx.%x\n",
1248 count
, wqids
[count
].type
,
1249 (unsigned long long)wqids
[count
].path
,
1250 wqids
[count
].version
);
1253 memmove(&fid
->qid
, &wqids
[nwqids
- 1], sizeof(struct p9_qid
));
1255 fid
->qid
= oldfid
->qid
;
1262 p9_client_clunk(fid
);
1266 if (fid
&& (fid
!= oldfid
))
1267 p9_fid_destroy(fid
);
1269 return ERR_PTR(err
);
1271 EXPORT_SYMBOL(p9_client_walk
);
1273 int p9_client_open(struct p9_fid
*fid
, int mode
)
1276 struct p9_client
*clnt
;
1277 struct p9_req_t
*req
;
1282 p9_debug(P9_DEBUG_9P
, ">>> %s fid %d mode %d\n",
1283 p9_is_proto_dotl(clnt
) ? "TLOPEN" : "TOPEN", fid
->fid
, mode
);
1286 if (fid
->mode
!= -1)
1289 if (p9_is_proto_dotl(clnt
))
1290 req
= p9_client_rpc(clnt
, P9_TLOPEN
, "dd", fid
->fid
, mode
);
1292 req
= p9_client_rpc(clnt
, P9_TOPEN
, "db", fid
->fid
, mode
);
1298 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1300 trace_9p_protocol_dump(clnt
, req
->rc
);
1301 goto free_and_error
;
1304 p9_debug(P9_DEBUG_9P
, "<<< %s qid %x.%llx.%x iounit %x\n",
1305 p9_is_proto_dotl(clnt
) ? "RLOPEN" : "ROPEN", qid
.type
,
1306 (unsigned long long)qid
.path
, qid
.version
, iounit
);
1309 fid
->iounit
= iounit
;
1312 p9_free_req(clnt
, req
);
1316 EXPORT_SYMBOL(p9_client_open
);
1318 int p9_client_create_dotl(struct p9_fid
*ofid
, const char *name
, u32 flags
, u32 mode
,
1319 kgid_t gid
, struct p9_qid
*qid
)
1322 struct p9_client
*clnt
;
1323 struct p9_req_t
*req
;
1326 p9_debug(P9_DEBUG_9P
,
1327 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1328 ofid
->fid
, name
, flags
, mode
,
1329 from_kgid(&init_user_ns
, gid
));
1332 if (ofid
->mode
!= -1)
1335 req
= p9_client_rpc(clnt
, P9_TLCREATE
, "dsddg", ofid
->fid
, name
, flags
,
1342 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", qid
, &iounit
);
1344 trace_9p_protocol_dump(clnt
, req
->rc
);
1345 goto free_and_error
;
1348 p9_debug(P9_DEBUG_9P
, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1350 (unsigned long long)qid
->path
,
1351 qid
->version
, iounit
);
1354 ofid
->iounit
= iounit
;
1357 p9_free_req(clnt
, req
);
1361 EXPORT_SYMBOL(p9_client_create_dotl
);
1363 int p9_client_fcreate(struct p9_fid
*fid
, const char *name
, u32 perm
, int mode
,
1367 struct p9_client
*clnt
;
1368 struct p9_req_t
*req
;
1372 p9_debug(P9_DEBUG_9P
, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1373 fid
->fid
, name
, perm
, mode
);
1377 if (fid
->mode
!= -1)
1380 req
= p9_client_rpc(clnt
, P9_TCREATE
, "dsdb?s", fid
->fid
, name
, perm
,
1387 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1389 trace_9p_protocol_dump(clnt
, req
->rc
);
1390 goto free_and_error
;
1393 p9_debug(P9_DEBUG_9P
, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1395 (unsigned long long)qid
.path
,
1396 qid
.version
, iounit
);
1399 fid
->iounit
= iounit
;
1402 p9_free_req(clnt
, req
);
1406 EXPORT_SYMBOL(p9_client_fcreate
);
1408 int p9_client_symlink(struct p9_fid
*dfid
, const char *name
,
1409 const char *symtgt
, kgid_t gid
, struct p9_qid
*qid
)
1412 struct p9_client
*clnt
;
1413 struct p9_req_t
*req
;
1415 p9_debug(P9_DEBUG_9P
, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
1416 dfid
->fid
, name
, symtgt
);
1419 req
= p9_client_rpc(clnt
, P9_TSYMLINK
, "dssg", dfid
->fid
, name
, symtgt
,
1426 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
1428 trace_9p_protocol_dump(clnt
, req
->rc
);
1429 goto free_and_error
;
1432 p9_debug(P9_DEBUG_9P
, "<<< RSYMLINK qid %x.%llx.%x\n",
1433 qid
->type
, (unsigned long long)qid
->path
, qid
->version
);
1436 p9_free_req(clnt
, req
);
1440 EXPORT_SYMBOL(p9_client_symlink
);
1442 int p9_client_link(struct p9_fid
*dfid
, struct p9_fid
*oldfid
, const char *newname
)
1444 struct p9_client
*clnt
;
1445 struct p9_req_t
*req
;
1447 p9_debug(P9_DEBUG_9P
, ">>> TLINK dfid %d oldfid %d newname %s\n",
1448 dfid
->fid
, oldfid
->fid
, newname
);
1450 req
= p9_client_rpc(clnt
, P9_TLINK
, "dds", dfid
->fid
, oldfid
->fid
,
1453 return PTR_ERR(req
);
1455 p9_debug(P9_DEBUG_9P
, "<<< RLINK\n");
1456 p9_free_req(clnt
, req
);
1459 EXPORT_SYMBOL(p9_client_link
);
1461 int p9_client_fsync(struct p9_fid
*fid
, int datasync
)
1464 struct p9_client
*clnt
;
1465 struct p9_req_t
*req
;
1467 p9_debug(P9_DEBUG_9P
, ">>> TFSYNC fid %d datasync:%d\n",
1468 fid
->fid
, datasync
);
1472 req
= p9_client_rpc(clnt
, P9_TFSYNC
, "dd", fid
->fid
, datasync
);
1478 p9_debug(P9_DEBUG_9P
, "<<< RFSYNC fid %d\n", fid
->fid
);
1480 p9_free_req(clnt
, req
);
1485 EXPORT_SYMBOL(p9_client_fsync
);
1487 int p9_client_clunk(struct p9_fid
*fid
)
1490 struct p9_client
*clnt
;
1491 struct p9_req_t
*req
;
1495 pr_warn("%s (%d): Trying to clunk with NULL fid\n",
1496 __func__
, task_pid_nr(current
));
1502 p9_debug(P9_DEBUG_9P
, ">>> TCLUNK fid %d (try %d)\n", fid
->fid
,
1507 req
= p9_client_rpc(clnt
, P9_TCLUNK
, "d", fid
->fid
);
1513 p9_debug(P9_DEBUG_9P
, "<<< RCLUNK fid %d\n", fid
->fid
);
1515 p9_free_req(clnt
, req
);
1518 * Fid is not valid even after a failed clunk
1519 * If interrupted, retry once then give up and
1520 * leak fid until umount.
1522 if (err
== -ERESTARTSYS
) {
1526 p9_fid_destroy(fid
);
1529 EXPORT_SYMBOL(p9_client_clunk
);
1531 int p9_client_remove(struct p9_fid
*fid
)
1534 struct p9_client
*clnt
;
1535 struct p9_req_t
*req
;
1537 p9_debug(P9_DEBUG_9P
, ">>> TREMOVE fid %d\n", fid
->fid
);
1541 req
= p9_client_rpc(clnt
, P9_TREMOVE
, "d", fid
->fid
);
1547 p9_debug(P9_DEBUG_9P
, "<<< RREMOVE fid %d\n", fid
->fid
);
1549 p9_free_req(clnt
, req
);
1551 if (err
== -ERESTARTSYS
)
1552 p9_client_clunk(fid
);
1554 p9_fid_destroy(fid
);
1557 EXPORT_SYMBOL(p9_client_remove
);
1559 int p9_client_unlinkat(struct p9_fid
*dfid
, const char *name
, int flags
)
1562 struct p9_req_t
*req
;
1563 struct p9_client
*clnt
;
1565 p9_debug(P9_DEBUG_9P
, ">>> TUNLINKAT fid %d %s %d\n",
1566 dfid
->fid
, name
, flags
);
1569 req
= p9_client_rpc(clnt
, P9_TUNLINKAT
, "dsd", dfid
->fid
, name
, flags
);
1574 p9_debug(P9_DEBUG_9P
, "<<< RUNLINKAT fid %d %s\n", dfid
->fid
, name
);
1576 p9_free_req(clnt
, req
);
1580 EXPORT_SYMBOL(p9_client_unlinkat
);
1583 p9_client_read(struct p9_fid
*fid
, u64 offset
, struct iov_iter
*to
, int *err
)
1585 struct p9_client
*clnt
= fid
->clnt
;
1586 struct p9_req_t
*req
;
1590 p9_debug(P9_DEBUG_9P
, ">>> TREAD fid %d offset %llu %d\n",
1591 fid
->fid
, (unsigned long long) offset
, (int)iov_iter_count(to
));
1593 while (iov_iter_count(to
)) {
1594 int count
= iov_iter_count(to
);
1595 int rsize
, non_zc
= 0;
1598 rsize
= fid
->iounit
;
1599 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1600 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1605 /* Don't bother zerocopy for small IO (< 1024) */
1606 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
1608 * response header len is 11
1609 * PDU Header(7) + IO Size (4)
1611 req
= p9_client_zc_rpc(clnt
, P9_TREAD
, to
, NULL
, rsize
,
1612 0, 11, "dqd", fid
->fid
,
1616 req
= p9_client_rpc(clnt
, P9_TREAD
, "dqd", fid
->fid
, offset
,
1620 *err
= PTR_ERR(req
);
1624 *err
= p9pdu_readf(req
->rc
, clnt
->proto_version
,
1625 "D", &count
, &dataptr
);
1627 trace_9p_protocol_dump(clnt
, req
->rc
);
1628 p9_free_req(clnt
, req
);
1631 if (rsize
< count
) {
1632 pr_err("bogus RREAD count (%d > %d)\n", count
, rsize
);
1636 p9_debug(P9_DEBUG_9P
, "<<< RREAD count %d\n", count
);
1638 p9_free_req(clnt
, req
);
1643 int n
= copy_to_iter(dataptr
, count
, to
);
1648 p9_free_req(clnt
, req
);
1652 iov_iter_advance(to
, count
);
1656 p9_free_req(clnt
, req
);
1660 EXPORT_SYMBOL(p9_client_read
);
1663 p9_client_write(struct p9_fid
*fid
, u64 offset
, struct iov_iter
*from
, int *err
)
1665 struct p9_client
*clnt
= fid
->clnt
;
1666 struct p9_req_t
*req
;
1670 p9_debug(P9_DEBUG_9P
, ">>> TWRITE fid %d offset %llu count %zd\n",
1671 fid
->fid
, (unsigned long long) offset
,
1672 iov_iter_count(from
));
1674 while (iov_iter_count(from
)) {
1675 int count
= iov_iter_count(from
);
1676 int rsize
= fid
->iounit
;
1677 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1678 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1683 /* Don't bother zerocopy for small IO (< 1024) */
1684 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
1685 req
= p9_client_zc_rpc(clnt
, P9_TWRITE
, NULL
, from
, 0,
1686 rsize
, P9_ZC_HDR_SZ
, "dqd",
1687 fid
->fid
, offset
, rsize
);
1689 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqV", fid
->fid
,
1690 offset
, rsize
, from
);
1693 *err
= PTR_ERR(req
);
1697 *err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "d", &count
);
1699 trace_9p_protocol_dump(clnt
, req
->rc
);
1700 p9_free_req(clnt
, req
);
1703 if (rsize
< count
) {
1704 pr_err("bogus RWRITE count (%d > %d)\n", count
, rsize
);
1708 p9_debug(P9_DEBUG_9P
, "<<< RWRITE count %d\n", count
);
1710 p9_free_req(clnt
, req
);
1711 iov_iter_advance(from
, count
);
1717 EXPORT_SYMBOL(p9_client_write
);
1719 struct p9_wstat
*p9_client_stat(struct p9_fid
*fid
)
1722 struct p9_client
*clnt
;
1723 struct p9_wstat
*ret
= kmalloc(sizeof(struct p9_wstat
), GFP_KERNEL
);
1724 struct p9_req_t
*req
;
1727 p9_debug(P9_DEBUG_9P
, ">>> TSTAT fid %d\n", fid
->fid
);
1730 return ERR_PTR(-ENOMEM
);
1735 req
= p9_client_rpc(clnt
, P9_TSTAT
, "d", fid
->fid
);
1741 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "wS", &ignored
, ret
);
1743 trace_9p_protocol_dump(clnt
, req
->rc
);
1744 p9_free_req(clnt
, req
);
1748 p9_debug(P9_DEBUG_9P
,
1749 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1750 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1751 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1752 "<<< uid=%d gid=%d n_muid=%d\n",
1753 ret
->size
, ret
->type
, ret
->dev
, ret
->qid
.type
,
1754 (unsigned long long)ret
->qid
.path
, ret
->qid
.version
, ret
->mode
,
1755 ret
->atime
, ret
->mtime
, (unsigned long long)ret
->length
,
1756 ret
->name
, ret
->uid
, ret
->gid
, ret
->muid
, ret
->extension
,
1757 from_kuid(&init_user_ns
, ret
->n_uid
),
1758 from_kgid(&init_user_ns
, ret
->n_gid
),
1759 from_kuid(&init_user_ns
, ret
->n_muid
));
1761 p9_free_req(clnt
, req
);
1766 return ERR_PTR(err
);
1768 EXPORT_SYMBOL(p9_client_stat
);
1770 struct p9_stat_dotl
*p9_client_getattr_dotl(struct p9_fid
*fid
,
1774 struct p9_client
*clnt
;
1775 struct p9_stat_dotl
*ret
= kmalloc(sizeof(struct p9_stat_dotl
),
1777 struct p9_req_t
*req
;
1779 p9_debug(P9_DEBUG_9P
, ">>> TGETATTR fid %d, request_mask %lld\n",
1780 fid
->fid
, request_mask
);
1783 return ERR_PTR(-ENOMEM
);
1788 req
= p9_client_rpc(clnt
, P9_TGETATTR
, "dq", fid
->fid
, request_mask
);
1794 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "A", ret
);
1796 trace_9p_protocol_dump(clnt
, req
->rc
);
1797 p9_free_req(clnt
, req
);
1801 p9_debug(P9_DEBUG_9P
,
1802 "<<< RGETATTR st_result_mask=%lld\n"
1803 "<<< qid=%x.%llx.%x\n"
1804 "<<< st_mode=%8.8x st_nlink=%llu\n"
1805 "<<< st_uid=%d st_gid=%d\n"
1806 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1807 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1808 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1809 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1810 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1811 "<<< st_gen=%lld st_data_version=%lld",
1812 ret
->st_result_mask
, ret
->qid
.type
, ret
->qid
.path
,
1813 ret
->qid
.version
, ret
->st_mode
, ret
->st_nlink
,
1814 from_kuid(&init_user_ns
, ret
->st_uid
),
1815 from_kgid(&init_user_ns
, ret
->st_gid
),
1816 ret
->st_rdev
, ret
->st_size
, ret
->st_blksize
,
1817 ret
->st_blocks
, ret
->st_atime_sec
, ret
->st_atime_nsec
,
1818 ret
->st_mtime_sec
, ret
->st_mtime_nsec
, ret
->st_ctime_sec
,
1819 ret
->st_ctime_nsec
, ret
->st_btime_sec
, ret
->st_btime_nsec
,
1820 ret
->st_gen
, ret
->st_data_version
);
1822 p9_free_req(clnt
, req
);
1827 return ERR_PTR(err
);
1829 EXPORT_SYMBOL(p9_client_getattr_dotl
);
1831 static int p9_client_statsize(struct p9_wstat
*wst
, int proto_version
)
1835 /* NOTE: size shouldn't include its own length */
1836 /* size[2] type[2] dev[4] qid[13] */
1837 /* mode[4] atime[4] mtime[4] length[8]*/
1838 /* name[s] uid[s] gid[s] muid[s] */
1839 ret
= 2+4+13+4+4+4+8+2+2+2+2;
1842 ret
+= strlen(wst
->name
);
1844 ret
+= strlen(wst
->uid
);
1846 ret
+= strlen(wst
->gid
);
1848 ret
+= strlen(wst
->muid
);
1850 if ((proto_version
== p9_proto_2000u
) ||
1851 (proto_version
== p9_proto_2000L
)) {
1852 ret
+= 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1854 ret
+= strlen(wst
->extension
);
1860 int p9_client_wstat(struct p9_fid
*fid
, struct p9_wstat
*wst
)
1863 struct p9_req_t
*req
;
1864 struct p9_client
*clnt
;
1868 wst
->size
= p9_client_statsize(wst
, clnt
->proto_version
);
1869 p9_debug(P9_DEBUG_9P
, ">>> TWSTAT fid %d\n", fid
->fid
);
1870 p9_debug(P9_DEBUG_9P
,
1871 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1872 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1873 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1874 " uid=%d gid=%d n_muid=%d\n",
1875 wst
->size
, wst
->type
, wst
->dev
, wst
->qid
.type
,
1876 (unsigned long long)wst
->qid
.path
, wst
->qid
.version
, wst
->mode
,
1877 wst
->atime
, wst
->mtime
, (unsigned long long)wst
->length
,
1878 wst
->name
, wst
->uid
, wst
->gid
, wst
->muid
, wst
->extension
,
1879 from_kuid(&init_user_ns
, wst
->n_uid
),
1880 from_kgid(&init_user_ns
, wst
->n_gid
),
1881 from_kuid(&init_user_ns
, wst
->n_muid
));
1883 req
= p9_client_rpc(clnt
, P9_TWSTAT
, "dwS", fid
->fid
, wst
->size
+2, wst
);
1889 p9_debug(P9_DEBUG_9P
, "<<< RWSTAT fid %d\n", fid
->fid
);
1891 p9_free_req(clnt
, req
);
1895 EXPORT_SYMBOL(p9_client_wstat
);
1897 int p9_client_setattr(struct p9_fid
*fid
, struct p9_iattr_dotl
*p9attr
)
1900 struct p9_req_t
*req
;
1901 struct p9_client
*clnt
;
1905 p9_debug(P9_DEBUG_9P
, ">>> TSETATTR fid %d\n", fid
->fid
);
1906 p9_debug(P9_DEBUG_9P
,
1907 " valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1908 " atime_sec=%lld atime_nsec=%lld\n"
1909 " mtime_sec=%lld mtime_nsec=%lld\n",
1910 p9attr
->valid
, p9attr
->mode
,
1911 from_kuid(&init_user_ns
, p9attr
->uid
),
1912 from_kgid(&init_user_ns
, p9attr
->gid
),
1913 p9attr
->size
, p9attr
->atime_sec
, p9attr
->atime_nsec
,
1914 p9attr
->mtime_sec
, p9attr
->mtime_nsec
);
1916 req
= p9_client_rpc(clnt
, P9_TSETATTR
, "dI", fid
->fid
, p9attr
);
1922 p9_debug(P9_DEBUG_9P
, "<<< RSETATTR fid %d\n", fid
->fid
);
1923 p9_free_req(clnt
, req
);
1927 EXPORT_SYMBOL(p9_client_setattr
);
1929 int p9_client_statfs(struct p9_fid
*fid
, struct p9_rstatfs
*sb
)
1932 struct p9_req_t
*req
;
1933 struct p9_client
*clnt
;
1938 p9_debug(P9_DEBUG_9P
, ">>> TSTATFS fid %d\n", fid
->fid
);
1940 req
= p9_client_rpc(clnt
, P9_TSTATFS
, "d", fid
->fid
);
1946 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "ddqqqqqqd", &sb
->type
,
1947 &sb
->bsize
, &sb
->blocks
, &sb
->bfree
, &sb
->bavail
,
1948 &sb
->files
, &sb
->ffree
, &sb
->fsid
, &sb
->namelen
);
1950 trace_9p_protocol_dump(clnt
, req
->rc
);
1951 p9_free_req(clnt
, req
);
1955 p9_debug(P9_DEBUG_9P
, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1956 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1957 "fsid %llu namelen %ld\n",
1958 fid
->fid
, (long unsigned int)sb
->type
, (long int)sb
->bsize
,
1959 sb
->blocks
, sb
->bfree
, sb
->bavail
, sb
->files
, sb
->ffree
,
1960 sb
->fsid
, (long int)sb
->namelen
);
1962 p9_free_req(clnt
, req
);
1966 EXPORT_SYMBOL(p9_client_statfs
);
1968 int p9_client_rename(struct p9_fid
*fid
,
1969 struct p9_fid
*newdirfid
, const char *name
)
1972 struct p9_req_t
*req
;
1973 struct p9_client
*clnt
;
1978 p9_debug(P9_DEBUG_9P
, ">>> TRENAME fid %d newdirfid %d name %s\n",
1979 fid
->fid
, newdirfid
->fid
, name
);
1981 req
= p9_client_rpc(clnt
, P9_TRENAME
, "dds", fid
->fid
,
1982 newdirfid
->fid
, name
);
1988 p9_debug(P9_DEBUG_9P
, "<<< RRENAME fid %d\n", fid
->fid
);
1990 p9_free_req(clnt
, req
);
1994 EXPORT_SYMBOL(p9_client_rename
);
1996 int p9_client_renameat(struct p9_fid
*olddirfid
, const char *old_name
,
1997 struct p9_fid
*newdirfid
, const char *new_name
)
2000 struct p9_req_t
*req
;
2001 struct p9_client
*clnt
;
2004 clnt
= olddirfid
->clnt
;
2006 p9_debug(P9_DEBUG_9P
, ">>> TRENAMEAT olddirfid %d old name %s"
2007 " newdirfid %d new name %s\n", olddirfid
->fid
, old_name
,
2008 newdirfid
->fid
, new_name
);
2010 req
= p9_client_rpc(clnt
, P9_TRENAMEAT
, "dsds", olddirfid
->fid
,
2011 old_name
, newdirfid
->fid
, new_name
);
2017 p9_debug(P9_DEBUG_9P
, "<<< RRENAMEAT newdirfid %d new name %s\n",
2018 newdirfid
->fid
, new_name
);
2020 p9_free_req(clnt
, req
);
2024 EXPORT_SYMBOL(p9_client_renameat
);
2027 * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
2029 struct p9_fid
*p9_client_xattrwalk(struct p9_fid
*file_fid
,
2030 const char *attr_name
, u64
*attr_size
)
2033 struct p9_req_t
*req
;
2034 struct p9_client
*clnt
;
2035 struct p9_fid
*attr_fid
;
2038 clnt
= file_fid
->clnt
;
2039 attr_fid
= p9_fid_create(clnt
);
2040 if (IS_ERR(attr_fid
)) {
2041 err
= PTR_ERR(attr_fid
);
2045 p9_debug(P9_DEBUG_9P
,
2046 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
2047 file_fid
->fid
, attr_fid
->fid
, attr_name
);
2049 req
= p9_client_rpc(clnt
, P9_TXATTRWALK
, "dds",
2050 file_fid
->fid
, attr_fid
->fid
, attr_name
);
2055 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "q", attr_size
);
2057 trace_9p_protocol_dump(clnt
, req
->rc
);
2058 p9_free_req(clnt
, req
);
2061 p9_free_req(clnt
, req
);
2062 p9_debug(P9_DEBUG_9P
, "<<< RXATTRWALK fid %d size %llu\n",
2063 attr_fid
->fid
, *attr_size
);
2066 p9_client_clunk(attr_fid
);
2069 if (attr_fid
&& (attr_fid
!= file_fid
))
2070 p9_fid_destroy(attr_fid
);
2072 return ERR_PTR(err
);
2074 EXPORT_SYMBOL_GPL(p9_client_xattrwalk
);
2076 int p9_client_xattrcreate(struct p9_fid
*fid
, const char *name
,
2077 u64 attr_size
, int flags
)
2080 struct p9_req_t
*req
;
2081 struct p9_client
*clnt
;
2083 p9_debug(P9_DEBUG_9P
,
2084 ">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
2085 fid
->fid
, name
, (long long)attr_size
, flags
);
2088 req
= p9_client_rpc(clnt
, P9_TXATTRCREATE
, "dsqd",
2089 fid
->fid
, name
, attr_size
, flags
);
2094 p9_debug(P9_DEBUG_9P
, "<<< RXATTRCREATE fid %d\n", fid
->fid
);
2095 p9_free_req(clnt
, req
);
2099 EXPORT_SYMBOL_GPL(p9_client_xattrcreate
);
2101 int p9_client_readdir(struct p9_fid
*fid
, char *data
, u32 count
, u64 offset
)
2103 int err
, rsize
, non_zc
= 0;
2104 struct p9_client
*clnt
;
2105 struct p9_req_t
*req
;
2107 struct kvec kv
= {.iov_base
= data
, .iov_len
= count
};
2110 iov_iter_kvec(&to
, READ
| ITER_KVEC
, &kv
, 1, count
);
2112 p9_debug(P9_DEBUG_9P
, ">>> TREADDIR fid %d offset %llu count %d\n",
2113 fid
->fid
, (unsigned long long) offset
, count
);
2118 rsize
= fid
->iounit
;
2119 if (!rsize
|| rsize
> clnt
->msize
-P9_READDIRHDRSZ
)
2120 rsize
= clnt
->msize
- P9_READDIRHDRSZ
;
2125 /* Don't bother zerocopy for small IO (< 1024) */
2126 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
2128 * response header len is 11
2129 * PDU Header(7) + IO Size (4)
2131 req
= p9_client_zc_rpc(clnt
, P9_TREADDIR
, &to
, NULL
, rsize
, 0,
2132 11, "dqd", fid
->fid
, offset
, rsize
);
2135 req
= p9_client_rpc(clnt
, P9_TREADDIR
, "dqd", fid
->fid
,
2143 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "D", &count
, &dataptr
);
2145 trace_9p_protocol_dump(clnt
, req
->rc
);
2146 goto free_and_error
;
2148 if (rsize
< count
) {
2149 pr_err("bogus RREADDIR count (%d > %d)\n", count
, rsize
);
2153 p9_debug(P9_DEBUG_9P
, "<<< RREADDIR count %d\n", count
);
2156 memmove(data
, dataptr
, count
);
2158 p9_free_req(clnt
, req
);
2162 p9_free_req(clnt
, req
);
2166 EXPORT_SYMBOL(p9_client_readdir
);
2168 int p9_client_mknod_dotl(struct p9_fid
*fid
, const char *name
, int mode
,
2169 dev_t rdev
, kgid_t gid
, struct p9_qid
*qid
)
2172 struct p9_client
*clnt
;
2173 struct p9_req_t
*req
;
2177 p9_debug(P9_DEBUG_9P
, ">>> TMKNOD fid %d name %s mode %d major %d "
2178 "minor %d\n", fid
->fid
, name
, mode
, MAJOR(rdev
), MINOR(rdev
));
2179 req
= p9_client_rpc(clnt
, P9_TMKNOD
, "dsdddg", fid
->fid
, name
, mode
,
2180 MAJOR(rdev
), MINOR(rdev
), gid
);
2182 return PTR_ERR(req
);
2184 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
2186 trace_9p_protocol_dump(clnt
, req
->rc
);
2189 p9_debug(P9_DEBUG_9P
, "<<< RMKNOD qid %x.%llx.%x\n", qid
->type
,
2190 (unsigned long long)qid
->path
, qid
->version
);
2193 p9_free_req(clnt
, req
);
2197 EXPORT_SYMBOL(p9_client_mknod_dotl
);
2199 int p9_client_mkdir_dotl(struct p9_fid
*fid
, const char *name
, int mode
,
2200 kgid_t gid
, struct p9_qid
*qid
)
2203 struct p9_client
*clnt
;
2204 struct p9_req_t
*req
;
2208 p9_debug(P9_DEBUG_9P
, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
2209 fid
->fid
, name
, mode
, from_kgid(&init_user_ns
, gid
));
2210 req
= p9_client_rpc(clnt
, P9_TMKDIR
, "dsdg", fid
->fid
, name
, mode
,
2213 return PTR_ERR(req
);
2215 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
2217 trace_9p_protocol_dump(clnt
, req
->rc
);
2220 p9_debug(P9_DEBUG_9P
, "<<< RMKDIR qid %x.%llx.%x\n", qid
->type
,
2221 (unsigned long long)qid
->path
, qid
->version
);
2224 p9_free_req(clnt
, req
);
2228 EXPORT_SYMBOL(p9_client_mkdir_dotl
);
2230 int p9_client_lock_dotl(struct p9_fid
*fid
, struct p9_flock
*flock
, u8
*status
)
2233 struct p9_client
*clnt
;
2234 struct p9_req_t
*req
;
2238 p9_debug(P9_DEBUG_9P
, ">>> TLOCK fid %d type %i flags %d "
2239 "start %lld length %lld proc_id %d client_id %s\n",
2240 fid
->fid
, flock
->type
, flock
->flags
, flock
->start
,
2241 flock
->length
, flock
->proc_id
, flock
->client_id
);
2243 req
= p9_client_rpc(clnt
, P9_TLOCK
, "dbdqqds", fid
->fid
, flock
->type
,
2244 flock
->flags
, flock
->start
, flock
->length
,
2245 flock
->proc_id
, flock
->client_id
);
2248 return PTR_ERR(req
);
2250 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "b", status
);
2252 trace_9p_protocol_dump(clnt
, req
->rc
);
2255 p9_debug(P9_DEBUG_9P
, "<<< RLOCK status %i\n", *status
);
2257 p9_free_req(clnt
, req
);
2261 EXPORT_SYMBOL(p9_client_lock_dotl
);
2263 int p9_client_getlock_dotl(struct p9_fid
*fid
, struct p9_getlock
*glock
)
2266 struct p9_client
*clnt
;
2267 struct p9_req_t
*req
;
2271 p9_debug(P9_DEBUG_9P
, ">>> TGETLOCK fid %d, type %i start %lld "
2272 "length %lld proc_id %d client_id %s\n", fid
->fid
, glock
->type
,
2273 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
2275 req
= p9_client_rpc(clnt
, P9_TGETLOCK
, "dbqqds", fid
->fid
, glock
->type
,
2276 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
2279 return PTR_ERR(req
);
2281 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "bqqds", &glock
->type
,
2282 &glock
->start
, &glock
->length
, &glock
->proc_id
,
2285 trace_9p_protocol_dump(clnt
, req
->rc
);
2288 p9_debug(P9_DEBUG_9P
, "<<< RGETLOCK type %i start %lld length %lld "
2289 "proc_id %d client_id %s\n", glock
->type
, glock
->start
,
2290 glock
->length
, glock
->proc_id
, glock
->client_id
);
2292 p9_free_req(clnt
, req
);
2295 EXPORT_SYMBOL(p9_client_getlock_dotl
);
2297 int p9_client_readlink(struct p9_fid
*fid
, char **target
)
2300 struct p9_client
*clnt
;
2301 struct p9_req_t
*req
;
2305 p9_debug(P9_DEBUG_9P
, ">>> TREADLINK fid %d\n", fid
->fid
);
2307 req
= p9_client_rpc(clnt
, P9_TREADLINK
, "d", fid
->fid
);
2309 return PTR_ERR(req
);
2311 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "s", target
);
2313 trace_9p_protocol_dump(clnt
, req
->rc
);
2316 p9_debug(P9_DEBUG_9P
, "<<< RREADLINK target %s\n", *target
);
2318 p9_free_req(clnt
, req
);
2321 EXPORT_SYMBOL(p9_client_readlink
);