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.h>
36 #include <linux/uaccess.h>
37 #include <net/9p/9p.h>
38 #include <linux/parser.h>
39 #include <net/9p/client.h>
40 #include <net/9p/transport.h>
43 #define CREATE_TRACE_POINTS
44 #include <trace/events/9p.h>
47 * Client Option Parsing (code inspired by NFS code)
48 * - a little lazy - parse all client options
59 static const match_table_t tokens
= {
60 {Opt_msize
, "msize=%u"},
61 {Opt_legacy
, "noextend"},
62 {Opt_trans
, "trans=%s"},
63 {Opt_version
, "version=%s"},
67 inline int p9_is_proto_dotl(struct p9_client
*clnt
)
69 return clnt
->proto_version
== p9_proto_2000L
;
71 EXPORT_SYMBOL(p9_is_proto_dotl
);
73 inline int p9_is_proto_dotu(struct p9_client
*clnt
)
75 return clnt
->proto_version
== p9_proto_2000u
;
77 EXPORT_SYMBOL(p9_is_proto_dotu
);
80 * Some error codes are taken directly from the server replies,
81 * make sure they are valid.
83 static int safe_errno(int err
)
85 if ((err
> 0) || (err
< -MAX_ERRNO
)) {
86 p9_debug(P9_DEBUG_ERROR
, "Invalid error code %d\n", err
);
93 /* Interpret mount option for protocol version */
94 static int get_protocol_version(char *s
)
96 int version
= -EINVAL
;
98 if (!strcmp(s
, "9p2000")) {
99 version
= p9_proto_legacy
;
100 p9_debug(P9_DEBUG_9P
, "Protocol version: Legacy\n");
101 } else if (!strcmp(s
, "9p2000.u")) {
102 version
= p9_proto_2000u
;
103 p9_debug(P9_DEBUG_9P
, "Protocol version: 9P2000.u\n");
104 } else if (!strcmp(s
, "9p2000.L")) {
105 version
= p9_proto_2000L
;
106 p9_debug(P9_DEBUG_9P
, "Protocol version: 9P2000.L\n");
108 pr_info("Unknown protocol version %s\n", s
);
114 * parse_options - parse mount options into client structure
115 * @opts: options string passed from mount
116 * @clnt: existing v9fs client information
118 * Return 0 upon success, -ERRNO upon failure
121 static int parse_opts(char *opts
, struct p9_client
*clnt
)
123 char *options
, *tmp_options
;
125 substring_t args
[MAX_OPT_ARGS
];
130 clnt
->proto_version
= p9_proto_2000u
;
136 tmp_options
= kstrdup(opts
, GFP_KERNEL
);
138 p9_debug(P9_DEBUG_ERROR
,
139 "failed to allocate copy of option string\n");
142 options
= tmp_options
;
144 while ((p
= strsep(&options
, ",")) != NULL
) {
148 token
= match_token(p
, tokens
, args
);
151 r
= match_int(&args
[0], &option
);
153 p9_debug(P9_DEBUG_ERROR
,
154 "integer field, but no integer?\n");
158 clnt
->msize
= option
;
161 s
= match_strdup(&args
[0]);
164 p9_debug(P9_DEBUG_ERROR
,
165 "problem allocating copy of trans arg\n");
166 goto free_and_return
;
168 clnt
->trans_mod
= v9fs_get_trans_by_name(s
);
169 if (clnt
->trans_mod
== NULL
) {
170 pr_info("Could not find request transport: %s\n",
174 goto free_and_return
;
179 clnt
->proto_version
= p9_proto_legacy
;
182 s
= match_strdup(&args
[0]);
185 p9_debug(P9_DEBUG_ERROR
,
186 "problem allocating copy of version arg\n");
187 goto free_and_return
;
189 ret
= get_protocol_version(s
);
190 if (ret
== -EINVAL
) {
192 goto free_and_return
;
195 clnt
->proto_version
= ret
;
208 * p9_tag_alloc - lookup/allocate a request by tag
209 * @c: client session to lookup tag within
210 * @tag: numeric id for transaction
212 * this is a simple array lookup, but will grow the
213 * request_slots as necessary to accommodate transaction
214 * ids which did not previously have a slot.
216 * this code relies on the client spinlock to manage locks, its
217 * possible we should switch to something else, but I'd rather
218 * stick with something low-overhead for the common case.
222 static struct p9_req_t
*
223 p9_tag_alloc(struct p9_client
*c
, u16 tag
, unsigned int max_size
)
227 struct p9_req_t
*req
;
228 int alloc_msize
= min(c
->msize
, max_size
);
230 /* This looks up the original request by tag so we know which
231 * buffer to read the data into */
234 if (tag
>= c
->max_tag
) {
235 spin_lock_irqsave(&c
->lock
, flags
);
236 /* check again since original check was outside of lock */
237 while (tag
>= c
->max_tag
) {
238 row
= (tag
/ P9_ROW_MAXTAG
);
239 c
->reqs
[row
] = kcalloc(P9_ROW_MAXTAG
,
240 sizeof(struct p9_req_t
), GFP_ATOMIC
);
243 pr_err("Couldn't grow tag array\n");
244 spin_unlock_irqrestore(&c
->lock
, flags
);
245 return ERR_PTR(-ENOMEM
);
247 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
248 c
->reqs
[row
][col
].status
= REQ_STATUS_IDLE
;
249 c
->reqs
[row
][col
].tc
= NULL
;
251 c
->max_tag
+= P9_ROW_MAXTAG
;
253 spin_unlock_irqrestore(&c
->lock
, flags
);
255 row
= tag
/ P9_ROW_MAXTAG
;
256 col
= tag
% P9_ROW_MAXTAG
;
258 req
= &c
->reqs
[row
][col
];
260 req
->wq
= kmalloc(sizeof(wait_queue_head_t
), GFP_NOFS
);
262 pr_err("Couldn't grow tag array\n");
263 return ERR_PTR(-ENOMEM
);
265 init_waitqueue_head(req
->wq
);
266 req
->tc
= kmalloc(sizeof(struct p9_fcall
) + alloc_msize
,
268 req
->rc
= kmalloc(sizeof(struct p9_fcall
) + alloc_msize
,
270 if ((!req
->tc
) || (!req
->rc
)) {
271 pr_err("Couldn't grow tag array\n");
275 req
->tc
= req
->rc
= NULL
;
277 return ERR_PTR(-ENOMEM
);
279 req
->tc
->capacity
= alloc_msize
;
280 req
->rc
->capacity
= alloc_msize
;
281 req
->tc
->sdata
= (char *) req
->tc
+ sizeof(struct p9_fcall
);
282 req
->rc
->sdata
= (char *) req
->rc
+ sizeof(struct p9_fcall
);
285 p9pdu_reset(req
->tc
);
286 p9pdu_reset(req
->rc
);
288 req
->tc
->tag
= tag
-1;
289 req
->status
= REQ_STATUS_ALLOC
;
291 return &c
->reqs
[row
][col
];
295 * p9_tag_lookup - lookup a request by tag
296 * @c: client session to lookup tag within
297 * @tag: numeric id for transaction
301 struct p9_req_t
*p9_tag_lookup(struct p9_client
*c
, u16 tag
)
305 /* This looks up the original request by tag so we know which
306 * buffer to read the data into */
309 if(tag
>= c
->max_tag
)
312 row
= tag
/ P9_ROW_MAXTAG
;
313 col
= tag
% P9_ROW_MAXTAG
;
315 return &c
->reqs
[row
][col
];
317 EXPORT_SYMBOL(p9_tag_lookup
);
320 * p9_tag_init - setup tags structure and contents
321 * @c: v9fs client struct
323 * This initializes the tags structure for each client instance.
327 static int p9_tag_init(struct p9_client
*c
)
331 c
->tagpool
= p9_idpool_create();
332 if (IS_ERR(c
->tagpool
)) {
333 err
= PTR_ERR(c
->tagpool
);
336 err
= p9_idpool_get(c
->tagpool
); /* reserve tag 0 */
338 p9_idpool_destroy(c
->tagpool
);
347 * p9_tag_cleanup - cleans up tags structure and reclaims resources
348 * @c: v9fs client struct
350 * This frees resources associated with the tags structure
353 static void p9_tag_cleanup(struct p9_client
*c
)
357 /* check to insure all requests are idle */
358 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
359 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
360 if (c
->reqs
[row
][col
].status
!= REQ_STATUS_IDLE
) {
361 p9_debug(P9_DEBUG_MUX
,
362 "Attempting to cleanup non-free tag %d,%d\n",
364 /* TODO: delay execution of cleanup */
371 p9_idpool_put(0, c
->tagpool
); /* free reserved tag 0 */
372 p9_idpool_destroy(c
->tagpool
);
375 /* free requests associated with tags */
376 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
377 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
378 kfree(c
->reqs
[row
][col
].wq
);
379 kfree(c
->reqs
[row
][col
].tc
);
380 kfree(c
->reqs
[row
][col
].rc
);
388 * p9_free_req - free a request and clean-up as necessary
390 * r: request to release
394 static void p9_free_req(struct p9_client
*c
, struct p9_req_t
*r
)
396 int tag
= r
->tc
->tag
;
397 p9_debug(P9_DEBUG_MUX
, "clnt %p req %p tag: %d\n", c
, r
, tag
);
399 r
->status
= REQ_STATUS_IDLE
;
400 if (tag
!= P9_NOTAG
&& p9_idpool_check(tag
, c
->tagpool
))
401 p9_idpool_put(tag
, c
->tagpool
);
405 * p9_client_cb - call back from transport to client
407 * req: request received
410 void p9_client_cb(struct p9_client
*c
, struct p9_req_t
*req
)
412 p9_debug(P9_DEBUG_MUX
, " tag %d\n", req
->tc
->tag
);
414 p9_debug(P9_DEBUG_MUX
, "wakeup: %d\n", req
->tc
->tag
);
416 EXPORT_SYMBOL(p9_client_cb
);
419 * p9_parse_header - parse header arguments out of a packet
420 * @pdu: packet to parse
421 * @size: size of packet
422 * @type: type of request
423 * @tag: tag of packet
424 * @rewind: set if we need to rewind offset afterwards
428 p9_parse_header(struct p9_fcall
*pdu
, int32_t *size
, int8_t *type
, int16_t *tag
,
434 int offset
= pdu
->offset
;
441 err
= p9pdu_readf(pdu
, 0, "dbw", &r_size
, &r_type
, &r_tag
);
443 goto rewind_and_exit
;
449 p9_debug(P9_DEBUG_9P
, "<<< size=%d type: %d tag: %d\n",
450 pdu
->size
, pdu
->id
, pdu
->tag
);
462 pdu
->offset
= offset
;
465 EXPORT_SYMBOL(p9_parse_header
);
468 * p9_check_errors - check 9p packet for error return and process it
469 * @c: current client instance
470 * @req: request to parse and check for error conditions
472 * returns error code if one is discovered, otherwise returns 0
474 * this will have to be more complicated if we have multiple
478 static int p9_check_errors(struct p9_client
*c
, struct p9_req_t
*req
)
484 err
= p9_parse_header(req
->rc
, NULL
, &type
, NULL
, 0);
486 * dump the response from server
487 * This should be after check errors which poplulate pdu_fcall.
489 trace_9p_protocol_dump(c
, req
->rc
);
491 p9_debug(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
494 if (type
!= P9_RERROR
&& type
!= P9_RLERROR
)
497 if (!p9_is_proto_dotl(c
)) {
499 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "s?d",
504 if (p9_is_proto_dotu(c
))
507 if (!err
|| !IS_ERR_VALUE(err
)) {
508 err
= p9_errstr2errno(ename
, strlen(ename
));
510 p9_debug(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n",
515 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "d", &ecode
);
518 p9_debug(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
524 p9_debug(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
530 * p9_check_zc_errors - check 9p packet for error return and process it
531 * @c: current client instance
532 * @req: request to parse and check for error conditions
533 * @in_hdrlen: Size of response protocol buffer.
535 * returns error code if one is discovered, otherwise returns 0
537 * this will have to be more complicated if we have multiple
541 static int p9_check_zc_errors(struct p9_client
*c
, struct p9_req_t
*req
,
542 char *uidata
, int in_hdrlen
, int kern_buf
)
549 err
= p9_parse_header(req
->rc
, NULL
, &type
, NULL
, 0);
551 * dump the response from server
552 * This should be after parse_header which poplulate pdu_fcall.
554 trace_9p_protocol_dump(c
, req
->rc
);
556 p9_debug(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
560 if (type
!= P9_RERROR
&& type
!= P9_RLERROR
)
563 if (!p9_is_proto_dotl(c
)) {
564 /* Error is reported in string format */
566 /* 7 = header size for RERROR, 2 is the size of string len; */
567 int inline_len
= in_hdrlen
- (7 + 2);
569 /* Read the size of error string */
570 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "w", &len
);
574 ename
= kmalloc(len
+ 1, GFP_NOFS
);
579 if (len
<= inline_len
) {
580 /* We have error in protocol buffer itself */
581 if (pdu_read(req
->rc
, ename
, len
)) {
588 * Part of the data is in user space buffer.
590 if (pdu_read(req
->rc
, ename
, inline_len
)) {
596 memcpy(ename
+ inline_len
, uidata
,
599 err
= copy_from_user(ename
+ inline_len
,
600 uidata
, len
- inline_len
);
608 if (p9_is_proto_dotu(c
)) {
609 /* For dotu we also have error code */
610 err
= p9pdu_readf(req
->rc
,
611 c
->proto_version
, "d", &ecode
);
616 if (!err
|| !IS_ERR_VALUE(err
)) {
617 err
= p9_errstr2errno(ename
, strlen(ename
));
619 p9_debug(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n",
624 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "d", &ecode
);
627 p9_debug(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
634 p9_debug(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
638 static struct p9_req_t
*
639 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...);
642 * p9_client_flush - flush (cancel) a request
644 * @oldreq: request to cancel
646 * This sents a flush for a particular request and links
647 * the flush request to the original request. The current
648 * code only supports a single flush request although the protocol
649 * allows for multiple flush requests to be sent for a single request.
653 static int p9_client_flush(struct p9_client
*c
, struct p9_req_t
*oldreq
)
655 struct p9_req_t
*req
;
659 err
= p9_parse_header(oldreq
->tc
, NULL
, NULL
, &oldtag
, 1);
663 p9_debug(P9_DEBUG_9P
, ">>> TFLUSH tag %d\n", oldtag
);
665 req
= p9_client_rpc(c
, P9_TFLUSH
, "w", oldtag
);
670 /* if we haven't received a response for oldreq,
671 remove it from the list. */
673 if (oldreq
->status
== REQ_STATUS_FLSH
)
674 list_del(&oldreq
->req_list
);
675 spin_unlock(&c
->lock
);
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
);
699 if (type
!= P9_TVERSION
) {
700 tag
= p9_idpool_get(c
->tagpool
);
702 return ERR_PTR(-ENOMEM
);
705 req
= p9_tag_alloc(c
, tag
, req_size
);
709 /* marshall the data */
710 p9pdu_prepare(req
->tc
, tag
, type
);
711 err
= p9pdu_vwritef(req
->tc
, c
->proto_version
, fmt
, ap
);
714 p9pdu_finalize(c
, req
->tc
);
715 trace_9p_client_req(c
, type
, tag
);
723 * p9_client_rpc - issue a request and wait for a response
725 * @type: type of request
726 * @fmt: protocol format string (see protocol.c)
728 * Returns request structure (which client must free using p9_free_req)
731 static struct p9_req_t
*
732 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...)
737 struct p9_req_t
*req
;
740 req
= p9_client_prepare_req(c
, type
, c
->msize
, fmt
, ap
);
745 if (signal_pending(current
)) {
747 clear_thread_flag(TIF_SIGPENDING
);
751 err
= c
->trans_mod
->request(c
, req
);
753 if (err
!= -ERESTARTSYS
&& err
!= -EFAULT
)
754 c
->status
= Disconnected
;
758 /* Wait for the response */
759 err
= wait_event_interruptible(*req
->wq
,
760 req
->status
>= REQ_STATUS_RCVD
);
762 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)
763 && (type
== P9_TFLUSH
)) {
765 clear_thread_flag(TIF_SIGPENDING
);
769 if (req
->status
== REQ_STATUS_ERROR
) {
770 p9_debug(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
773 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
774 p9_debug(P9_DEBUG_MUX
, "flushing\n");
776 clear_thread_flag(TIF_SIGPENDING
);
778 if (c
->trans_mod
->cancel(c
, req
))
779 p9_client_flush(c
, req
);
781 /* if we received the response anyway, don't signal error */
782 if (req
->status
== REQ_STATUS_RCVD
)
786 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
788 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
793 err
= p9_check_errors(c
, req
);
794 trace_9p_client_res(c
, type
, req
->rc
->tag
, err
);
799 return ERR_PTR(safe_errno(err
));
803 * p9_client_zc_rpc - issue a request and wait for a response
805 * @type: type of request
806 * @uidata: user bffer that should be ued for zero copy read
807 * @uodata: user buffer that shoud be user for zero copy write
808 * @inlen: read buffer size
809 * @olen: write buffer size
810 * @hdrlen: reader header size, This is the size of response protocol data
811 * @fmt: protocol format string (see protocol.c)
813 * Returns request structure (which client must free using p9_free_req)
815 static struct p9_req_t
*p9_client_zc_rpc(struct p9_client
*c
, int8_t type
,
816 char *uidata
, char *uodata
,
817 int inlen
, int olen
, int in_hdrlen
,
818 int kern_buf
, const char *fmt
, ...)
823 struct p9_req_t
*req
;
827 * We allocate a inline protocol data of only 4k bytes.
828 * The actual content is passed in zero-copy fashion.
830 req
= p9_client_prepare_req(c
, type
, P9_ZC_HDR_SZ
, fmt
, ap
);
835 if (signal_pending(current
)) {
837 clear_thread_flag(TIF_SIGPENDING
);
841 /* If we are called with KERNEL_DS force kern_buf */
842 if (segment_eq(get_fs(), KERNEL_DS
))
845 err
= c
->trans_mod
->zc_request(c
, req
, uidata
, uodata
,
846 inlen
, olen
, in_hdrlen
, kern_buf
);
849 c
->status
= Disconnected
;
852 if (req
->status
== REQ_STATUS_ERROR
) {
853 p9_debug(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
856 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
857 p9_debug(P9_DEBUG_MUX
, "flushing\n");
859 clear_thread_flag(TIF_SIGPENDING
);
861 if (c
->trans_mod
->cancel(c
, req
))
862 p9_client_flush(c
, req
);
864 /* if we received the response anyway, don't signal error */
865 if (req
->status
== REQ_STATUS_RCVD
)
869 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
871 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
876 err
= p9_check_zc_errors(c
, req
, uidata
, in_hdrlen
, kern_buf
);
877 trace_9p_client_res(c
, type
, req
->rc
->tag
, err
);
882 return ERR_PTR(safe_errno(err
));
885 static struct p9_fid
*p9_fid_create(struct p9_client
*clnt
)
891 p9_debug(P9_DEBUG_FID
, "clnt %p\n", clnt
);
892 fid
= kmalloc(sizeof(struct p9_fid
), GFP_KERNEL
);
894 return ERR_PTR(-ENOMEM
);
896 ret
= p9_idpool_get(clnt
->fidpool
);
903 memset(&fid
->qid
, 0, sizeof(struct p9_qid
));
905 fid
->uid
= current_fsuid();
908 spin_lock_irqsave(&clnt
->lock
, flags
);
909 list_add(&fid
->flist
, &clnt
->fidlist
);
910 spin_unlock_irqrestore(&clnt
->lock
, flags
);
919 static void p9_fid_destroy(struct p9_fid
*fid
)
921 struct p9_client
*clnt
;
924 p9_debug(P9_DEBUG_FID
, "fid %d\n", fid
->fid
);
926 p9_idpool_put(fid
->fid
, clnt
->fidpool
);
927 spin_lock_irqsave(&clnt
->lock
, flags
);
928 list_del(&fid
->flist
);
929 spin_unlock_irqrestore(&clnt
->lock
, flags
);
934 static int p9_client_version(struct p9_client
*c
)
937 struct p9_req_t
*req
;
941 p9_debug(P9_DEBUG_9P
, ">>> TVERSION msize %d protocol %d\n",
942 c
->msize
, c
->proto_version
);
944 switch (c
->proto_version
) {
946 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
947 c
->msize
, "9P2000.L");
950 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
951 c
->msize
, "9P2000.u");
953 case p9_proto_legacy
:
954 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
965 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "ds", &msize
, &version
);
967 p9_debug(P9_DEBUG_9P
, "version error %d\n", err
);
968 trace_9p_protocol_dump(c
, req
->rc
);
972 p9_debug(P9_DEBUG_9P
, "<<< RVERSION msize %d %s\n", msize
, version
);
973 if (!strncmp(version
, "9P2000.L", 8))
974 c
->proto_version
= p9_proto_2000L
;
975 else if (!strncmp(version
, "9P2000.u", 8))
976 c
->proto_version
= p9_proto_2000u
;
977 else if (!strncmp(version
, "9P2000", 6))
978 c
->proto_version
= p9_proto_legacy
;
984 if (msize
< c
->msize
)
994 struct p9_client
*p9_client_create(const char *dev_name
, char *options
)
997 struct p9_client
*clnt
;
1000 clnt
= kmalloc(sizeof(struct p9_client
), GFP_KERNEL
);
1002 return ERR_PTR(-ENOMEM
);
1004 clnt
->trans_mod
= NULL
;
1006 spin_lock_init(&clnt
->lock
);
1007 INIT_LIST_HEAD(&clnt
->fidlist
);
1009 err
= p9_tag_init(clnt
);
1013 err
= parse_opts(options
, clnt
);
1015 goto destroy_tagpool
;
1017 if (!clnt
->trans_mod
)
1018 clnt
->trans_mod
= v9fs_get_default_trans();
1020 if (clnt
->trans_mod
== NULL
) {
1021 err
= -EPROTONOSUPPORT
;
1022 p9_debug(P9_DEBUG_ERROR
,
1023 "No transport defined or default transport\n");
1024 goto destroy_tagpool
;
1027 clnt
->fidpool
= p9_idpool_create();
1028 if (IS_ERR(clnt
->fidpool
)) {
1029 err
= PTR_ERR(clnt
->fidpool
);
1033 p9_debug(P9_DEBUG_MUX
, "clnt %p trans %p msize %d protocol %d\n",
1034 clnt
, clnt
->trans_mod
, clnt
->msize
, clnt
->proto_version
);
1036 err
= clnt
->trans_mod
->create(clnt
, dev_name
, options
);
1038 goto destroy_fidpool
;
1040 if (clnt
->msize
> clnt
->trans_mod
->maxsize
)
1041 clnt
->msize
= clnt
->trans_mod
->maxsize
;
1043 err
= p9_client_version(clnt
);
1050 clnt
->trans_mod
->close(clnt
);
1052 p9_idpool_destroy(clnt
->fidpool
);
1054 v9fs_put_trans(clnt
->trans_mod
);
1056 p9_idpool_destroy(clnt
->tagpool
);
1059 return ERR_PTR(err
);
1061 EXPORT_SYMBOL(p9_client_create
);
1063 void p9_client_destroy(struct p9_client
*clnt
)
1065 struct p9_fid
*fid
, *fidptr
;
1067 p9_debug(P9_DEBUG_MUX
, "clnt %p\n", clnt
);
1069 if (clnt
->trans_mod
)
1070 clnt
->trans_mod
->close(clnt
);
1072 v9fs_put_trans(clnt
->trans_mod
);
1074 list_for_each_entry_safe(fid
, fidptr
, &clnt
->fidlist
, flist
) {
1075 pr_info("Found fid %d not clunked\n", fid
->fid
);
1076 p9_fid_destroy(fid
);
1080 p9_idpool_destroy(clnt
->fidpool
);
1082 p9_tag_cleanup(clnt
);
1086 EXPORT_SYMBOL(p9_client_destroy
);
1088 void p9_client_disconnect(struct p9_client
*clnt
)
1090 p9_debug(P9_DEBUG_9P
, "clnt %p\n", clnt
);
1091 clnt
->status
= Disconnected
;
1093 EXPORT_SYMBOL(p9_client_disconnect
);
1095 void p9_client_begin_disconnect(struct p9_client
*clnt
)
1097 p9_debug(P9_DEBUG_9P
, "clnt %p\n", clnt
);
1098 clnt
->status
= BeginDisconnect
;
1100 EXPORT_SYMBOL(p9_client_begin_disconnect
);
1102 struct p9_fid
*p9_client_attach(struct p9_client
*clnt
, struct p9_fid
*afid
,
1103 char *uname
, u32 n_uname
, char *aname
)
1106 struct p9_req_t
*req
;
1111 p9_debug(P9_DEBUG_9P
, ">>> TATTACH afid %d uname %s aname %s\n",
1112 afid
? afid
->fid
: -1, uname
, aname
);
1113 fid
= p9_fid_create(clnt
);
1120 req
= p9_client_rpc(clnt
, P9_TATTACH
, "ddss?d", fid
->fid
,
1121 afid
? afid
->fid
: P9_NOFID
, uname
, aname
, n_uname
);
1127 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", &qid
);
1129 trace_9p_protocol_dump(clnt
, req
->rc
);
1130 p9_free_req(clnt
, req
);
1134 p9_debug(P9_DEBUG_9P
, "<<< RATTACH qid %x.%llx.%x\n",
1135 qid
.type
, (unsigned long long)qid
.path
, qid
.version
);
1137 memmove(&fid
->qid
, &qid
, sizeof(struct p9_qid
));
1139 p9_free_req(clnt
, req
);
1144 p9_fid_destroy(fid
);
1145 return ERR_PTR(err
);
1147 EXPORT_SYMBOL(p9_client_attach
);
1149 struct p9_fid
*p9_client_walk(struct p9_fid
*oldfid
, uint16_t nwname
,
1150 char **wnames
, int clone
)
1153 struct p9_client
*clnt
;
1155 struct p9_qid
*wqids
;
1156 struct p9_req_t
*req
;
1157 uint16_t nwqids
, count
;
1161 clnt
= oldfid
->clnt
;
1163 fid
= p9_fid_create(clnt
);
1170 fid
->uid
= oldfid
->uid
;
1175 p9_debug(P9_DEBUG_9P
, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
1176 oldfid
->fid
, fid
->fid
, nwname
, wnames
? wnames
[0] : NULL
);
1178 req
= p9_client_rpc(clnt
, P9_TWALK
, "ddT", oldfid
->fid
, fid
->fid
,
1185 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "R", &nwqids
, &wqids
);
1187 trace_9p_protocol_dump(clnt
, req
->rc
);
1188 p9_free_req(clnt
, req
);
1191 p9_free_req(clnt
, req
);
1193 p9_debug(P9_DEBUG_9P
, "<<< RWALK nwqid %d:\n", nwqids
);
1195 if (nwqids
!= nwname
) {
1200 for (count
= 0; count
< nwqids
; count
++)
1201 p9_debug(P9_DEBUG_9P
, "<<< [%d] %x.%llx.%x\n",
1202 count
, wqids
[count
].type
,
1203 (unsigned long long)wqids
[count
].path
,
1204 wqids
[count
].version
);
1207 memmove(&fid
->qid
, &wqids
[nwqids
- 1], sizeof(struct p9_qid
));
1209 fid
->qid
= oldfid
->qid
;
1216 p9_client_clunk(fid
);
1220 if (fid
&& (fid
!= oldfid
))
1221 p9_fid_destroy(fid
);
1223 return ERR_PTR(err
);
1225 EXPORT_SYMBOL(p9_client_walk
);
1227 int p9_client_open(struct p9_fid
*fid
, int mode
)
1230 struct p9_client
*clnt
;
1231 struct p9_req_t
*req
;
1236 p9_debug(P9_DEBUG_9P
, ">>> %s fid %d mode %d\n",
1237 p9_is_proto_dotl(clnt
) ? "TLOPEN" : "TOPEN", fid
->fid
, mode
);
1240 if (fid
->mode
!= -1)
1243 if (p9_is_proto_dotl(clnt
))
1244 req
= p9_client_rpc(clnt
, P9_TLOPEN
, "dd", fid
->fid
, mode
);
1246 req
= p9_client_rpc(clnt
, P9_TOPEN
, "db", fid
->fid
, mode
);
1252 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1254 trace_9p_protocol_dump(clnt
, req
->rc
);
1255 goto free_and_error
;
1258 p9_debug(P9_DEBUG_9P
, "<<< %s qid %x.%llx.%x iounit %x\n",
1259 p9_is_proto_dotl(clnt
) ? "RLOPEN" : "ROPEN", qid
.type
,
1260 (unsigned long long)qid
.path
, qid
.version
, iounit
);
1263 fid
->iounit
= iounit
;
1266 p9_free_req(clnt
, req
);
1270 EXPORT_SYMBOL(p9_client_open
);
1272 int p9_client_create_dotl(struct p9_fid
*ofid
, char *name
, u32 flags
, u32 mode
,
1273 gid_t gid
, struct p9_qid
*qid
)
1276 struct p9_client
*clnt
;
1277 struct p9_req_t
*req
;
1280 p9_debug(P9_DEBUG_9P
,
1281 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1282 ofid
->fid
, name
, flags
, mode
, gid
);
1285 if (ofid
->mode
!= -1)
1288 req
= p9_client_rpc(clnt
, P9_TLCREATE
, "dsddd", ofid
->fid
, name
, flags
,
1295 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", qid
, &iounit
);
1297 trace_9p_protocol_dump(clnt
, req
->rc
);
1298 goto free_and_error
;
1301 p9_debug(P9_DEBUG_9P
, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1303 (unsigned long long)qid
->path
,
1304 qid
->version
, iounit
);
1307 ofid
->iounit
= iounit
;
1310 p9_free_req(clnt
, req
);
1314 EXPORT_SYMBOL(p9_client_create_dotl
);
1316 int p9_client_fcreate(struct p9_fid
*fid
, char *name
, u32 perm
, int mode
,
1320 struct p9_client
*clnt
;
1321 struct p9_req_t
*req
;
1325 p9_debug(P9_DEBUG_9P
, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1326 fid
->fid
, name
, perm
, mode
);
1330 if (fid
->mode
!= -1)
1333 req
= p9_client_rpc(clnt
, P9_TCREATE
, "dsdb?s", fid
->fid
, name
, perm
,
1340 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1342 trace_9p_protocol_dump(clnt
, req
->rc
);
1343 goto free_and_error
;
1346 p9_debug(P9_DEBUG_9P
, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1348 (unsigned long long)qid
.path
,
1349 qid
.version
, iounit
);
1352 fid
->iounit
= iounit
;
1355 p9_free_req(clnt
, req
);
1359 EXPORT_SYMBOL(p9_client_fcreate
);
1361 int p9_client_symlink(struct p9_fid
*dfid
, char *name
, char *symtgt
, gid_t gid
,
1365 struct p9_client
*clnt
;
1366 struct p9_req_t
*req
;
1368 p9_debug(P9_DEBUG_9P
, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
1369 dfid
->fid
, name
, symtgt
);
1372 req
= p9_client_rpc(clnt
, P9_TSYMLINK
, "dssd", dfid
->fid
, name
, symtgt
,
1379 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
1381 trace_9p_protocol_dump(clnt
, req
->rc
);
1382 goto free_and_error
;
1385 p9_debug(P9_DEBUG_9P
, "<<< RSYMLINK qid %x.%llx.%x\n",
1386 qid
->type
, (unsigned long long)qid
->path
, qid
->version
);
1389 p9_free_req(clnt
, req
);
1393 EXPORT_SYMBOL(p9_client_symlink
);
1395 int p9_client_link(struct p9_fid
*dfid
, struct p9_fid
*oldfid
, char *newname
)
1397 struct p9_client
*clnt
;
1398 struct p9_req_t
*req
;
1400 p9_debug(P9_DEBUG_9P
, ">>> TLINK dfid %d oldfid %d newname %s\n",
1401 dfid
->fid
, oldfid
->fid
, newname
);
1403 req
= p9_client_rpc(clnt
, P9_TLINK
, "dds", dfid
->fid
, oldfid
->fid
,
1406 return PTR_ERR(req
);
1408 p9_debug(P9_DEBUG_9P
, "<<< RLINK\n");
1409 p9_free_req(clnt
, req
);
1412 EXPORT_SYMBOL(p9_client_link
);
1414 int p9_client_fsync(struct p9_fid
*fid
, int datasync
)
1417 struct p9_client
*clnt
;
1418 struct p9_req_t
*req
;
1420 p9_debug(P9_DEBUG_9P
, ">>> TFSYNC fid %d datasync:%d\n",
1421 fid
->fid
, datasync
);
1425 req
= p9_client_rpc(clnt
, P9_TFSYNC
, "dd", fid
->fid
, datasync
);
1431 p9_debug(P9_DEBUG_9P
, "<<< RFSYNC fid %d\n", fid
->fid
);
1433 p9_free_req(clnt
, req
);
1438 EXPORT_SYMBOL(p9_client_fsync
);
1440 int p9_client_clunk(struct p9_fid
*fid
)
1443 struct p9_client
*clnt
;
1444 struct p9_req_t
*req
;
1448 pr_warn("%s (%d): Trying to clunk with NULL fid\n",
1449 __func__
, task_pid_nr(current
));
1455 p9_debug(P9_DEBUG_9P
, ">>> TCLUNK fid %d (try %d)\n", fid
->fid
,
1460 req
= p9_client_rpc(clnt
, P9_TCLUNK
, "d", fid
->fid
);
1466 p9_debug(P9_DEBUG_9P
, "<<< RCLUNK fid %d\n", fid
->fid
);
1468 p9_free_req(clnt
, req
);
1471 * Fid is not valid even after a failed clunk
1472 * If interrupted, retry once then give up and
1473 * leak fid until umount.
1475 if (err
== -ERESTARTSYS
) {
1479 p9_fid_destroy(fid
);
1482 EXPORT_SYMBOL(p9_client_clunk
);
1484 int p9_client_remove(struct p9_fid
*fid
)
1487 struct p9_client
*clnt
;
1488 struct p9_req_t
*req
;
1490 p9_debug(P9_DEBUG_9P
, ">>> TREMOVE fid %d\n", fid
->fid
);
1494 req
= p9_client_rpc(clnt
, P9_TREMOVE
, "d", fid
->fid
);
1500 p9_debug(P9_DEBUG_9P
, "<<< RREMOVE fid %d\n", fid
->fid
);
1502 p9_free_req(clnt
, req
);
1504 if (err
== -ERESTARTSYS
)
1505 p9_client_clunk(fid
);
1507 p9_fid_destroy(fid
);
1510 EXPORT_SYMBOL(p9_client_remove
);
1512 int p9_client_unlinkat(struct p9_fid
*dfid
, const char *name
, int flags
)
1515 struct p9_req_t
*req
;
1516 struct p9_client
*clnt
;
1518 p9_debug(P9_DEBUG_9P
, ">>> TUNLINKAT fid %d %s %d\n",
1519 dfid
->fid
, name
, flags
);
1522 req
= p9_client_rpc(clnt
, P9_TUNLINKAT
, "dsd", dfid
->fid
, name
, flags
);
1527 p9_debug(P9_DEBUG_9P
, "<<< RUNLINKAT fid %d %s\n", dfid
->fid
, name
);
1529 p9_free_req(clnt
, req
);
1533 EXPORT_SYMBOL(p9_client_unlinkat
);
1536 p9_client_read(struct p9_fid
*fid
, char *data
, char __user
*udata
, u64 offset
,
1541 struct p9_req_t
*req
;
1542 struct p9_client
*clnt
;
1543 int err
, rsize
, non_zc
= 0;
1546 p9_debug(P9_DEBUG_9P
, ">>> TREAD fid %d offset %llu %d\n",
1547 fid
->fid
, (unsigned long long) offset
, count
);
1551 rsize
= fid
->iounit
;
1552 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1553 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1558 /* Don't bother zerocopy for small IO (< 1024) */
1559 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
1565 indata
= (__force
char *)udata
;
1567 * response header len is 11
1568 * PDU Header(7) + IO Size (4)
1570 req
= p9_client_zc_rpc(clnt
, P9_TREAD
, indata
, NULL
, rsize
, 0,
1571 11, kernel_buf
, "dqd", fid
->fid
,
1575 req
= p9_client_rpc(clnt
, P9_TREAD
, "dqd", fid
->fid
, offset
,
1583 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "D", &count
, &dataptr
);
1585 trace_9p_protocol_dump(clnt
, req
->rc
);
1586 goto free_and_error
;
1589 p9_debug(P9_DEBUG_9P
, "<<< RREAD count %d\n", count
);
1593 memmove(data
, dataptr
, count
);
1595 err
= copy_to_user(udata
, dataptr
, count
);
1598 goto free_and_error
;
1602 p9_free_req(clnt
, req
);
1606 p9_free_req(clnt
, req
);
1610 EXPORT_SYMBOL(p9_client_read
);
1613 p9_client_write(struct p9_fid
*fid
, char *data
, const char __user
*udata
,
1614 u64 offset
, u32 count
)
1618 struct p9_client
*clnt
;
1619 struct p9_req_t
*req
;
1621 p9_debug(P9_DEBUG_9P
, ">>> TWRITE fid %d offset %llu count %d\n",
1622 fid
->fid
, (unsigned long long) offset
, count
);
1626 rsize
= fid
->iounit
;
1627 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1628 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1633 /* Don't bother zerocopy for small IO (< 1024) */
1634 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
1640 odata
= (char *)udata
;
1641 req
= p9_client_zc_rpc(clnt
, P9_TWRITE
, NULL
, odata
, 0, rsize
,
1642 P9_ZC_HDR_SZ
, kernel_buf
, "dqd",
1643 fid
->fid
, offset
, rsize
);
1646 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqD", fid
->fid
,
1647 offset
, rsize
, data
);
1649 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqU", fid
->fid
,
1650 offset
, rsize
, udata
);
1657 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "d", &count
);
1659 trace_9p_protocol_dump(clnt
, req
->rc
);
1660 goto free_and_error
;
1663 p9_debug(P9_DEBUG_9P
, "<<< RWRITE count %d\n", count
);
1665 p9_free_req(clnt
, req
);
1669 p9_free_req(clnt
, req
);
1673 EXPORT_SYMBOL(p9_client_write
);
1675 struct p9_wstat
*p9_client_stat(struct p9_fid
*fid
)
1678 struct p9_client
*clnt
;
1679 struct p9_wstat
*ret
= kmalloc(sizeof(struct p9_wstat
), GFP_KERNEL
);
1680 struct p9_req_t
*req
;
1683 p9_debug(P9_DEBUG_9P
, ">>> TSTAT fid %d\n", fid
->fid
);
1686 return ERR_PTR(-ENOMEM
);
1691 req
= p9_client_rpc(clnt
, P9_TSTAT
, "d", fid
->fid
);
1697 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "wS", &ignored
, ret
);
1699 trace_9p_protocol_dump(clnt
, req
->rc
);
1700 p9_free_req(clnt
, req
);
1704 p9_debug(P9_DEBUG_9P
,
1705 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1706 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1707 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1708 "<<< uid=%d gid=%d n_muid=%d\n",
1709 ret
->size
, ret
->type
, ret
->dev
, ret
->qid
.type
,
1710 (unsigned long long)ret
->qid
.path
, ret
->qid
.version
, ret
->mode
,
1711 ret
->atime
, ret
->mtime
, (unsigned long long)ret
->length
,
1712 ret
->name
, ret
->uid
, ret
->gid
, ret
->muid
, ret
->extension
,
1713 ret
->n_uid
, ret
->n_gid
, ret
->n_muid
);
1715 p9_free_req(clnt
, req
);
1720 return ERR_PTR(err
);
1722 EXPORT_SYMBOL(p9_client_stat
);
1724 struct p9_stat_dotl
*p9_client_getattr_dotl(struct p9_fid
*fid
,
1728 struct p9_client
*clnt
;
1729 struct p9_stat_dotl
*ret
= kmalloc(sizeof(struct p9_stat_dotl
),
1731 struct p9_req_t
*req
;
1733 p9_debug(P9_DEBUG_9P
, ">>> TGETATTR fid %d, request_mask %lld\n",
1734 fid
->fid
, request_mask
);
1737 return ERR_PTR(-ENOMEM
);
1742 req
= p9_client_rpc(clnt
, P9_TGETATTR
, "dq", fid
->fid
, request_mask
);
1748 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "A", ret
);
1750 trace_9p_protocol_dump(clnt
, req
->rc
);
1751 p9_free_req(clnt
, req
);
1755 p9_debug(P9_DEBUG_9P
,
1756 "<<< RGETATTR st_result_mask=%lld\n"
1757 "<<< qid=%x.%llx.%x\n"
1758 "<<< st_mode=%8.8x st_nlink=%llu\n"
1759 "<<< st_uid=%d st_gid=%d\n"
1760 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1761 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1762 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1763 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1764 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1765 "<<< st_gen=%lld st_data_version=%lld",
1766 ret
->st_result_mask
, ret
->qid
.type
, ret
->qid
.path
,
1767 ret
->qid
.version
, ret
->st_mode
, ret
->st_nlink
, ret
->st_uid
,
1768 ret
->st_gid
, ret
->st_rdev
, ret
->st_size
, ret
->st_blksize
,
1769 ret
->st_blocks
, ret
->st_atime_sec
, ret
->st_atime_nsec
,
1770 ret
->st_mtime_sec
, ret
->st_mtime_nsec
, ret
->st_ctime_sec
,
1771 ret
->st_ctime_nsec
, ret
->st_btime_sec
, ret
->st_btime_nsec
,
1772 ret
->st_gen
, ret
->st_data_version
);
1774 p9_free_req(clnt
, req
);
1779 return ERR_PTR(err
);
1781 EXPORT_SYMBOL(p9_client_getattr_dotl
);
1783 static int p9_client_statsize(struct p9_wstat
*wst
, int proto_version
)
1787 /* NOTE: size shouldn't include its own length */
1788 /* size[2] type[2] dev[4] qid[13] */
1789 /* mode[4] atime[4] mtime[4] length[8]*/
1790 /* name[s] uid[s] gid[s] muid[s] */
1791 ret
= 2+4+13+4+4+4+8+2+2+2+2;
1794 ret
+= strlen(wst
->name
);
1796 ret
+= strlen(wst
->uid
);
1798 ret
+= strlen(wst
->gid
);
1800 ret
+= strlen(wst
->muid
);
1802 if ((proto_version
== p9_proto_2000u
) ||
1803 (proto_version
== p9_proto_2000L
)) {
1804 ret
+= 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1806 ret
+= strlen(wst
->extension
);
1812 int p9_client_wstat(struct p9_fid
*fid
, struct p9_wstat
*wst
)
1815 struct p9_req_t
*req
;
1816 struct p9_client
*clnt
;
1820 wst
->size
= p9_client_statsize(wst
, clnt
->proto_version
);
1821 p9_debug(P9_DEBUG_9P
, ">>> TWSTAT fid %d\n", fid
->fid
);
1822 p9_debug(P9_DEBUG_9P
,
1823 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1824 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1825 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1826 " uid=%d gid=%d n_muid=%d\n",
1827 wst
->size
, wst
->type
, wst
->dev
, wst
->qid
.type
,
1828 (unsigned long long)wst
->qid
.path
, wst
->qid
.version
, wst
->mode
,
1829 wst
->atime
, wst
->mtime
, (unsigned long long)wst
->length
,
1830 wst
->name
, wst
->uid
, wst
->gid
, wst
->muid
, wst
->extension
,
1831 wst
->n_uid
, wst
->n_gid
, wst
->n_muid
);
1833 req
= p9_client_rpc(clnt
, P9_TWSTAT
, "dwS", fid
->fid
, wst
->size
+2, wst
);
1839 p9_debug(P9_DEBUG_9P
, "<<< RWSTAT fid %d\n", fid
->fid
);
1841 p9_free_req(clnt
, req
);
1845 EXPORT_SYMBOL(p9_client_wstat
);
1847 int p9_client_setattr(struct p9_fid
*fid
, struct p9_iattr_dotl
*p9attr
)
1850 struct p9_req_t
*req
;
1851 struct p9_client
*clnt
;
1855 p9_debug(P9_DEBUG_9P
, ">>> TSETATTR fid %d\n", fid
->fid
);
1856 p9_debug(P9_DEBUG_9P
,
1857 " valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1858 " atime_sec=%lld atime_nsec=%lld\n"
1859 " mtime_sec=%lld mtime_nsec=%lld\n",
1860 p9attr
->valid
, p9attr
->mode
, p9attr
->uid
, p9attr
->gid
,
1861 p9attr
->size
, p9attr
->atime_sec
, p9attr
->atime_nsec
,
1862 p9attr
->mtime_sec
, p9attr
->mtime_nsec
);
1864 req
= p9_client_rpc(clnt
, P9_TSETATTR
, "dI", fid
->fid
, p9attr
);
1870 p9_debug(P9_DEBUG_9P
, "<<< RSETATTR fid %d\n", fid
->fid
);
1871 p9_free_req(clnt
, req
);
1875 EXPORT_SYMBOL(p9_client_setattr
);
1877 int p9_client_statfs(struct p9_fid
*fid
, struct p9_rstatfs
*sb
)
1880 struct p9_req_t
*req
;
1881 struct p9_client
*clnt
;
1886 p9_debug(P9_DEBUG_9P
, ">>> TSTATFS fid %d\n", fid
->fid
);
1888 req
= p9_client_rpc(clnt
, P9_TSTATFS
, "d", fid
->fid
);
1894 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "ddqqqqqqd", &sb
->type
,
1895 &sb
->bsize
, &sb
->blocks
, &sb
->bfree
, &sb
->bavail
,
1896 &sb
->files
, &sb
->ffree
, &sb
->fsid
, &sb
->namelen
);
1898 trace_9p_protocol_dump(clnt
, req
->rc
);
1899 p9_free_req(clnt
, req
);
1903 p9_debug(P9_DEBUG_9P
, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1904 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1905 "fsid %llu namelen %ld\n",
1906 fid
->fid
, (long unsigned int)sb
->type
, (long int)sb
->bsize
,
1907 sb
->blocks
, sb
->bfree
, sb
->bavail
, sb
->files
, sb
->ffree
,
1908 sb
->fsid
, (long int)sb
->namelen
);
1910 p9_free_req(clnt
, req
);
1914 EXPORT_SYMBOL(p9_client_statfs
);
1916 int p9_client_rename(struct p9_fid
*fid
,
1917 struct p9_fid
*newdirfid
, const char *name
)
1920 struct p9_req_t
*req
;
1921 struct p9_client
*clnt
;
1926 p9_debug(P9_DEBUG_9P
, ">>> TRENAME fid %d newdirfid %d name %s\n",
1927 fid
->fid
, newdirfid
->fid
, name
);
1929 req
= p9_client_rpc(clnt
, P9_TRENAME
, "dds", fid
->fid
,
1930 newdirfid
->fid
, name
);
1936 p9_debug(P9_DEBUG_9P
, "<<< RRENAME fid %d\n", fid
->fid
);
1938 p9_free_req(clnt
, req
);
1942 EXPORT_SYMBOL(p9_client_rename
);
1944 int p9_client_renameat(struct p9_fid
*olddirfid
, const char *old_name
,
1945 struct p9_fid
*newdirfid
, const char *new_name
)
1948 struct p9_req_t
*req
;
1949 struct p9_client
*clnt
;
1952 clnt
= olddirfid
->clnt
;
1954 p9_debug(P9_DEBUG_9P
, ">>> TRENAMEAT olddirfid %d old name %s"
1955 " newdirfid %d new name %s\n", olddirfid
->fid
, old_name
,
1956 newdirfid
->fid
, new_name
);
1958 req
= p9_client_rpc(clnt
, P9_TRENAMEAT
, "dsds", olddirfid
->fid
,
1959 old_name
, newdirfid
->fid
, new_name
);
1965 p9_debug(P9_DEBUG_9P
, "<<< RRENAMEAT newdirfid %d new name %s\n",
1966 newdirfid
->fid
, new_name
);
1968 p9_free_req(clnt
, req
);
1972 EXPORT_SYMBOL(p9_client_renameat
);
1975 * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
1977 struct p9_fid
*p9_client_xattrwalk(struct p9_fid
*file_fid
,
1978 const char *attr_name
, u64
*attr_size
)
1981 struct p9_req_t
*req
;
1982 struct p9_client
*clnt
;
1983 struct p9_fid
*attr_fid
;
1986 clnt
= file_fid
->clnt
;
1987 attr_fid
= p9_fid_create(clnt
);
1988 if (IS_ERR(attr_fid
)) {
1989 err
= PTR_ERR(attr_fid
);
1993 p9_debug(P9_DEBUG_9P
,
1994 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
1995 file_fid
->fid
, attr_fid
->fid
, attr_name
);
1997 req
= p9_client_rpc(clnt
, P9_TXATTRWALK
, "dds",
1998 file_fid
->fid
, attr_fid
->fid
, attr_name
);
2003 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "q", attr_size
);
2005 trace_9p_protocol_dump(clnt
, req
->rc
);
2006 p9_free_req(clnt
, req
);
2009 p9_free_req(clnt
, req
);
2010 p9_debug(P9_DEBUG_9P
, "<<< RXATTRWALK fid %d size %llu\n",
2011 attr_fid
->fid
, *attr_size
);
2014 p9_client_clunk(attr_fid
);
2017 if (attr_fid
&& (attr_fid
!= file_fid
))
2018 p9_fid_destroy(attr_fid
);
2020 return ERR_PTR(err
);
2022 EXPORT_SYMBOL_GPL(p9_client_xattrwalk
);
2024 int p9_client_xattrcreate(struct p9_fid
*fid
, const char *name
,
2025 u64 attr_size
, int flags
)
2028 struct p9_req_t
*req
;
2029 struct p9_client
*clnt
;
2031 p9_debug(P9_DEBUG_9P
,
2032 ">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
2033 fid
->fid
, name
, (long long)attr_size
, flags
);
2036 req
= p9_client_rpc(clnt
, P9_TXATTRCREATE
, "dsqd",
2037 fid
->fid
, name
, attr_size
, flags
);
2042 p9_debug(P9_DEBUG_9P
, "<<< RXATTRCREATE fid %d\n", fid
->fid
);
2043 p9_free_req(clnt
, req
);
2047 EXPORT_SYMBOL_GPL(p9_client_xattrcreate
);
2049 int p9_client_readdir(struct p9_fid
*fid
, char *data
, u32 count
, u64 offset
)
2051 int err
, rsize
, non_zc
= 0;
2052 struct p9_client
*clnt
;
2053 struct p9_req_t
*req
;
2056 p9_debug(P9_DEBUG_9P
, ">>> TREADDIR fid %d offset %llu count %d\n",
2057 fid
->fid
, (unsigned long long) offset
, count
);
2062 rsize
= fid
->iounit
;
2063 if (!rsize
|| rsize
> clnt
->msize
-P9_READDIRHDRSZ
)
2064 rsize
= clnt
->msize
- P9_READDIRHDRSZ
;
2069 /* Don't bother zerocopy for small IO (< 1024) */
2070 if (clnt
->trans_mod
->zc_request
&& rsize
> 1024) {
2072 * response header len is 11
2073 * PDU Header(7) + IO Size (4)
2075 req
= p9_client_zc_rpc(clnt
, P9_TREADDIR
, data
, NULL
, rsize
, 0,
2076 11, 1, "dqd", fid
->fid
, offset
, rsize
);
2079 req
= p9_client_rpc(clnt
, P9_TREADDIR
, "dqd", fid
->fid
,
2087 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "D", &count
, &dataptr
);
2089 trace_9p_protocol_dump(clnt
, req
->rc
);
2090 goto free_and_error
;
2093 p9_debug(P9_DEBUG_9P
, "<<< RREADDIR count %d\n", count
);
2096 memmove(data
, dataptr
, count
);
2098 p9_free_req(clnt
, req
);
2102 p9_free_req(clnt
, req
);
2106 EXPORT_SYMBOL(p9_client_readdir
);
2108 int p9_client_mknod_dotl(struct p9_fid
*fid
, char *name
, int mode
,
2109 dev_t rdev
, gid_t gid
, struct p9_qid
*qid
)
2112 struct p9_client
*clnt
;
2113 struct p9_req_t
*req
;
2117 p9_debug(P9_DEBUG_9P
, ">>> TMKNOD fid %d name %s mode %d major %d "
2118 "minor %d\n", fid
->fid
, name
, mode
, MAJOR(rdev
), MINOR(rdev
));
2119 req
= p9_client_rpc(clnt
, P9_TMKNOD
, "dsdddd", fid
->fid
, name
, mode
,
2120 MAJOR(rdev
), MINOR(rdev
), gid
);
2122 return PTR_ERR(req
);
2124 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
2126 trace_9p_protocol_dump(clnt
, req
->rc
);
2129 p9_debug(P9_DEBUG_9P
, "<<< RMKNOD qid %x.%llx.%x\n", qid
->type
,
2130 (unsigned long long)qid
->path
, qid
->version
);
2133 p9_free_req(clnt
, req
);
2137 EXPORT_SYMBOL(p9_client_mknod_dotl
);
2139 int p9_client_mkdir_dotl(struct p9_fid
*fid
, char *name
, int mode
,
2140 gid_t gid
, struct p9_qid
*qid
)
2143 struct p9_client
*clnt
;
2144 struct p9_req_t
*req
;
2148 p9_debug(P9_DEBUG_9P
, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
2149 fid
->fid
, name
, mode
, gid
);
2150 req
= p9_client_rpc(clnt
, P9_TMKDIR
, "dsdd", fid
->fid
, name
, mode
,
2153 return PTR_ERR(req
);
2155 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
2157 trace_9p_protocol_dump(clnt
, req
->rc
);
2160 p9_debug(P9_DEBUG_9P
, "<<< RMKDIR qid %x.%llx.%x\n", qid
->type
,
2161 (unsigned long long)qid
->path
, qid
->version
);
2164 p9_free_req(clnt
, req
);
2168 EXPORT_SYMBOL(p9_client_mkdir_dotl
);
2170 int p9_client_lock_dotl(struct p9_fid
*fid
, struct p9_flock
*flock
, u8
*status
)
2173 struct p9_client
*clnt
;
2174 struct p9_req_t
*req
;
2178 p9_debug(P9_DEBUG_9P
, ">>> TLOCK fid %d type %i flags %d "
2179 "start %lld length %lld proc_id %d client_id %s\n",
2180 fid
->fid
, flock
->type
, flock
->flags
, flock
->start
,
2181 flock
->length
, flock
->proc_id
, flock
->client_id
);
2183 req
= p9_client_rpc(clnt
, P9_TLOCK
, "dbdqqds", fid
->fid
, flock
->type
,
2184 flock
->flags
, flock
->start
, flock
->length
,
2185 flock
->proc_id
, flock
->client_id
);
2188 return PTR_ERR(req
);
2190 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "b", status
);
2192 trace_9p_protocol_dump(clnt
, req
->rc
);
2195 p9_debug(P9_DEBUG_9P
, "<<< RLOCK status %i\n", *status
);
2197 p9_free_req(clnt
, req
);
2201 EXPORT_SYMBOL(p9_client_lock_dotl
);
2203 int p9_client_getlock_dotl(struct p9_fid
*fid
, struct p9_getlock
*glock
)
2206 struct p9_client
*clnt
;
2207 struct p9_req_t
*req
;
2211 p9_debug(P9_DEBUG_9P
, ">>> TGETLOCK fid %d, type %i start %lld "
2212 "length %lld proc_id %d client_id %s\n", fid
->fid
, glock
->type
,
2213 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
2215 req
= p9_client_rpc(clnt
, P9_TGETLOCK
, "dbqqds", fid
->fid
, glock
->type
,
2216 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
2219 return PTR_ERR(req
);
2221 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "bqqds", &glock
->type
,
2222 &glock
->start
, &glock
->length
, &glock
->proc_id
,
2225 trace_9p_protocol_dump(clnt
, req
->rc
);
2228 p9_debug(P9_DEBUG_9P
, "<<< RGETLOCK type %i start %lld length %lld "
2229 "proc_id %d client_id %s\n", glock
->type
, glock
->start
,
2230 glock
->length
, glock
->proc_id
, glock
->client_id
);
2232 p9_free_req(clnt
, req
);
2235 EXPORT_SYMBOL(p9_client_getlock_dotl
);
2237 int p9_client_readlink(struct p9_fid
*fid
, char **target
)
2240 struct p9_client
*clnt
;
2241 struct p9_req_t
*req
;
2245 p9_debug(P9_DEBUG_9P
, ">>> TREADLINK fid %d\n", fid
->fid
);
2247 req
= p9_client_rpc(clnt
, P9_TREADLINK
, "d", fid
->fid
);
2249 return PTR_ERR(req
);
2251 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "s", target
);
2253 trace_9p_protocol_dump(clnt
, req
->rc
);
2256 p9_debug(P9_DEBUG_9P
, "<<< RREADLINK target %s\n", *target
);
2258 p9_free_req(clnt
, req
);
2261 EXPORT_SYMBOL(p9_client_readlink
);