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 #include <linux/module.h>
27 #include <linux/errno.h>
29 #include <linux/poll.h>
30 #include <linux/idr.h>
31 #include <linux/mutex.h>
32 #include <linux/slab.h>
33 #include <linux/sched.h>
34 #include <linux/uaccess.h>
35 #include <net/9p/9p.h>
36 #include <linux/parser.h>
37 #include <net/9p/client.h>
38 #include <net/9p/transport.h>
42 * Client Option Parsing (code inspired by NFS code)
43 * - a little lazy - parse all client options
54 static const match_table_t tokens
= {
55 {Opt_msize
, "msize=%u"},
56 {Opt_legacy
, "noextend"},
57 {Opt_trans
, "trans=%s"},
58 {Opt_version
, "version=%s"},
62 inline int p9_is_proto_dotl(struct p9_client
*clnt
)
64 return clnt
->proto_version
== p9_proto_2000L
;
66 EXPORT_SYMBOL(p9_is_proto_dotl
);
68 inline int p9_is_proto_dotu(struct p9_client
*clnt
)
70 return clnt
->proto_version
== p9_proto_2000u
;
72 EXPORT_SYMBOL(p9_is_proto_dotu
);
74 /* Interpret mount option for protocol version */
75 static int get_protocol_version(const substring_t
*name
)
77 int version
= -EINVAL
;
79 if (!strncmp("9p2000", name
->from
, name
->to
-name
->from
)) {
80 version
= p9_proto_legacy
;
81 P9_DPRINTK(P9_DEBUG_9P
, "Protocol version: Legacy\n");
82 } else if (!strncmp("9p2000.u", name
->from
, name
->to
-name
->from
)) {
83 version
= p9_proto_2000u
;
84 P9_DPRINTK(P9_DEBUG_9P
, "Protocol version: 9P2000.u\n");
85 } else if (!strncmp("9p2000.L", name
->from
, name
->to
-name
->from
)) {
86 version
= p9_proto_2000L
;
87 P9_DPRINTK(P9_DEBUG_9P
, "Protocol version: 9P2000.L\n");
89 P9_DPRINTK(P9_DEBUG_ERROR
, "Unknown protocol version %s. ",
95 static struct p9_req_t
*
96 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...);
99 * parse_options - parse mount options into client structure
100 * @opts: options string passed from mount
101 * @clnt: existing v9fs client information
103 * Return 0 upon success, -ERRNO upon failure
106 static int parse_opts(char *opts
, struct p9_client
*clnt
)
108 char *options
, *tmp_options
;
110 substring_t args
[MAX_OPT_ARGS
];
114 clnt
->proto_version
= p9_proto_2000u
;
120 tmp_options
= kstrdup(opts
, GFP_KERNEL
);
122 P9_DPRINTK(P9_DEBUG_ERROR
,
123 "failed to allocate copy of option string\n");
126 options
= tmp_options
;
128 while ((p
= strsep(&options
, ",")) != NULL
) {
132 token
= match_token(p
, tokens
, args
);
133 if (token
< Opt_trans
) {
134 int r
= match_int(&args
[0], &option
);
136 P9_DPRINTK(P9_DEBUG_ERROR
,
137 "integer field, but no integer?\n");
144 clnt
->msize
= option
;
147 clnt
->trans_mod
= v9fs_get_trans_by_name(&args
[0]);
148 if(clnt
->trans_mod
== NULL
) {
149 P9_DPRINTK(P9_DEBUG_ERROR
,
150 "Could not find request transport: %s\n",
153 goto free_and_return
;
157 clnt
->proto_version
= p9_proto_legacy
;
160 ret
= get_protocol_version(&args
[0]);
162 goto free_and_return
;
163 clnt
->proto_version
= ret
;
176 * p9_tag_alloc - lookup/allocate a request by tag
177 * @c: client session to lookup tag within
178 * @tag: numeric id for transaction
180 * this is a simple array lookup, but will grow the
181 * request_slots as necessary to accomodate transaction
182 * ids which did not previously have a slot.
184 * this code relies on the client spinlock to manage locks, its
185 * possible we should switch to something else, but I'd rather
186 * stick with something low-overhead for the common case.
190 static struct p9_req_t
*p9_tag_alloc(struct p9_client
*c
, u16 tag
)
194 struct p9_req_t
*req
;
196 /* This looks up the original request by tag so we know which
197 * buffer to read the data into */
200 if (tag
>= c
->max_tag
) {
201 spin_lock_irqsave(&c
->lock
, flags
);
202 /* check again since original check was outside of lock */
203 while (tag
>= c
->max_tag
) {
204 row
= (tag
/ P9_ROW_MAXTAG
);
205 c
->reqs
[row
] = kcalloc(P9_ROW_MAXTAG
,
206 sizeof(struct p9_req_t
), GFP_ATOMIC
);
209 printk(KERN_ERR
"Couldn't grow tag array\n");
210 spin_unlock_irqrestore(&c
->lock
, flags
);
211 return ERR_PTR(-ENOMEM
);
213 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
214 c
->reqs
[row
][col
].status
= REQ_STATUS_IDLE
;
215 c
->reqs
[row
][col
].tc
= NULL
;
217 c
->max_tag
+= P9_ROW_MAXTAG
;
219 spin_unlock_irqrestore(&c
->lock
, flags
);
221 row
= tag
/ P9_ROW_MAXTAG
;
222 col
= tag
% P9_ROW_MAXTAG
;
224 req
= &c
->reqs
[row
][col
];
226 req
->wq
= kmalloc(sizeof(wait_queue_head_t
), GFP_KERNEL
);
228 printk(KERN_ERR
"Couldn't grow tag array\n");
229 return ERR_PTR(-ENOMEM
);
231 init_waitqueue_head(req
->wq
);
232 req
->tc
= kmalloc(sizeof(struct p9_fcall
)+c
->msize
,
234 req
->rc
= kmalloc(sizeof(struct p9_fcall
)+c
->msize
,
236 if ((!req
->tc
) || (!req
->rc
)) {
237 printk(KERN_ERR
"Couldn't grow tag array\n");
241 req
->tc
= req
->rc
= NULL
;
243 return ERR_PTR(-ENOMEM
);
245 req
->tc
->sdata
= (char *) req
->tc
+ sizeof(struct p9_fcall
);
246 req
->tc
->capacity
= c
->msize
;
247 req
->rc
->sdata
= (char *) req
->rc
+ sizeof(struct p9_fcall
);
248 req
->rc
->capacity
= c
->msize
;
251 p9pdu_reset(req
->tc
);
252 p9pdu_reset(req
->rc
);
254 req
->tc
->tag
= tag
-1;
255 req
->status
= REQ_STATUS_ALLOC
;
257 return &c
->reqs
[row
][col
];
261 * p9_tag_lookup - lookup a request by tag
262 * @c: client session to lookup tag within
263 * @tag: numeric id for transaction
267 struct p9_req_t
*p9_tag_lookup(struct p9_client
*c
, u16 tag
)
271 /* This looks up the original request by tag so we know which
272 * buffer to read the data into */
275 BUG_ON(tag
>= c
->max_tag
);
277 row
= tag
/ P9_ROW_MAXTAG
;
278 col
= tag
% P9_ROW_MAXTAG
;
280 return &c
->reqs
[row
][col
];
282 EXPORT_SYMBOL(p9_tag_lookup
);
285 * p9_tag_init - setup tags structure and contents
286 * @c: v9fs client struct
288 * This initializes the tags structure for each client instance.
292 static int p9_tag_init(struct p9_client
*c
)
296 c
->tagpool
= p9_idpool_create();
297 if (IS_ERR(c
->tagpool
)) {
298 err
= PTR_ERR(c
->tagpool
);
303 p9_idpool_get(c
->tagpool
); /* reserve tag 0 */
311 * p9_tag_cleanup - cleans up tags structure and reclaims resources
312 * @c: v9fs client struct
314 * This frees resources associated with the tags structure
317 static void p9_tag_cleanup(struct p9_client
*c
)
321 /* check to insure all requests are idle */
322 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
323 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
324 if (c
->reqs
[row
][col
].status
!= REQ_STATUS_IDLE
) {
325 P9_DPRINTK(P9_DEBUG_MUX
,
326 "Attempting to cleanup non-free tag %d,%d\n",
328 /* TODO: delay execution of cleanup */
335 p9_idpool_put(0, c
->tagpool
); /* free reserved tag 0 */
336 p9_idpool_destroy(c
->tagpool
);
339 /* free requests associated with tags */
340 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
341 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
342 kfree(c
->reqs
[row
][col
].wq
);
343 kfree(c
->reqs
[row
][col
].tc
);
344 kfree(c
->reqs
[row
][col
].rc
);
352 * p9_free_req - free a request and clean-up as necessary
354 * r: request to release
358 static void p9_free_req(struct p9_client
*c
, struct p9_req_t
*r
)
360 int tag
= r
->tc
->tag
;
361 P9_DPRINTK(P9_DEBUG_MUX
, "clnt %p req %p tag: %d\n", c
, r
, tag
);
363 r
->status
= REQ_STATUS_IDLE
;
364 if (tag
!= P9_NOTAG
&& p9_idpool_check(tag
, c
->tagpool
))
365 p9_idpool_put(tag
, c
->tagpool
);
369 * p9_client_cb - call back from transport to client
371 * req: request received
374 void p9_client_cb(struct p9_client
*c
, struct p9_req_t
*req
)
376 P9_DPRINTK(P9_DEBUG_MUX
, " tag %d\n", req
->tc
->tag
);
378 P9_DPRINTK(P9_DEBUG_MUX
, "wakeup: %d\n", req
->tc
->tag
);
380 EXPORT_SYMBOL(p9_client_cb
);
383 * p9_parse_header - parse header arguments out of a packet
384 * @pdu: packet to parse
385 * @size: size of packet
386 * @type: type of request
387 * @tag: tag of packet
388 * @rewind: set if we need to rewind offset afterwards
392 p9_parse_header(struct p9_fcall
*pdu
, int32_t *size
, int8_t *type
, int16_t *tag
,
398 int offset
= pdu
->offset
;
405 err
= p9pdu_readf(pdu
, 0, "dbw", &r_size
, &r_type
, &r_tag
);
407 goto rewind_and_exit
;
413 P9_DPRINTK(P9_DEBUG_9P
, "<<< size=%d type: %d tag: %d\n", pdu
->size
,
426 pdu
->offset
= offset
;
429 EXPORT_SYMBOL(p9_parse_header
);
432 * p9_check_errors - check 9p packet for error return and process it
433 * @c: current client instance
434 * @req: request to parse and check for error conditions
436 * returns error code if one is discovered, otherwise returns 0
438 * this will have to be more complicated if we have multiple
442 static int p9_check_errors(struct p9_client
*c
, struct p9_req_t
*req
)
447 err
= p9_parse_header(req
->rc
, NULL
, &type
, NULL
, 0);
449 P9_DPRINTK(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
453 if (type
== P9_RERROR
|| type
== P9_RLERROR
) {
456 if (!p9_is_proto_dotl(c
)) {
459 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "s?d",
464 if (p9_is_proto_dotu(c
))
467 if (!err
|| !IS_ERR_VALUE(err
)) {
468 err
= p9_errstr2errno(ename
, strlen(ename
));
470 P9_DPRINTK(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n", -ecode
, ename
);
475 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "d", &ecode
);
478 P9_DPRINTK(P9_DEBUG_9P
, "<<< RLERROR (%d)\n", -ecode
);
487 P9_DPRINTK(P9_DEBUG_ERROR
, "couldn't parse error%d\n", err
);
493 * p9_client_flush - flush (cancel) a request
495 * @oldreq: request to cancel
497 * This sents a flush for a particular requests and links
498 * the flush request to the original request. The current
499 * code only supports a single flush request although the protocol
500 * allows for multiple flush requests to be sent for a single request.
504 static int p9_client_flush(struct p9_client
*c
, struct p9_req_t
*oldreq
)
506 struct p9_req_t
*req
;
510 err
= p9_parse_header(oldreq
->tc
, NULL
, NULL
, &oldtag
, 1);
514 P9_DPRINTK(P9_DEBUG_9P
, ">>> TFLUSH tag %d\n", oldtag
);
516 req
= p9_client_rpc(c
, P9_TFLUSH
, "w", oldtag
);
521 /* if we haven't received a response for oldreq,
522 remove it from the list. */
524 if (oldreq
->status
== REQ_STATUS_FLSH
)
525 list_del(&oldreq
->req_list
);
526 spin_unlock(&c
->lock
);
533 * p9_client_rpc - issue a request and wait for a response
535 * @type: type of request
536 * @fmt: protocol format string (see protocol.c)
538 * Returns request structure (which client must free using p9_free_req)
541 static struct p9_req_t
*
542 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...)
546 struct p9_req_t
*req
;
550 P9_DPRINTK(P9_DEBUG_MUX
, "client %p op %d\n", c
, type
);
552 /* we allow for any status other than disconnected */
553 if (c
->status
== Disconnected
)
554 return ERR_PTR(-EIO
);
556 /* if status is begin_disconnected we allow only clunk request */
557 if ((c
->status
== BeginDisconnect
) && (type
!= P9_TCLUNK
))
558 return ERR_PTR(-EIO
);
560 if (signal_pending(current
)) {
562 clear_thread_flag(TIF_SIGPENDING
);
567 if (type
!= P9_TVERSION
) {
568 tag
= p9_idpool_get(c
->tagpool
);
570 return ERR_PTR(-ENOMEM
);
573 req
= p9_tag_alloc(c
, tag
);
577 /* marshall the data */
578 p9pdu_prepare(req
->tc
, tag
, type
);
580 err
= p9pdu_vwritef(req
->tc
, c
->proto_version
, fmt
, ap
);
582 p9pdu_finalize(req
->tc
);
584 err
= c
->trans_mod
->request(c
, req
);
586 c
->status
= Disconnected
;
590 P9_DPRINTK(P9_DEBUG_MUX
, "wait %p tag: %d\n", req
->wq
, tag
);
591 err
= wait_event_interruptible(*req
->wq
,
592 req
->status
>= REQ_STATUS_RCVD
);
593 P9_DPRINTK(P9_DEBUG_MUX
, "wait %p tag: %d returned %d\n",
596 if (req
->status
== REQ_STATUS_ERROR
) {
597 P9_DPRINTK(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
601 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
602 P9_DPRINTK(P9_DEBUG_MUX
, "flushing\n");
604 clear_thread_flag(TIF_SIGPENDING
);
606 if (c
->trans_mod
->cancel(c
, req
))
607 p9_client_flush(c
, req
);
609 /* if we received the response anyway, don't signal error */
610 if (req
->status
== REQ_STATUS_RCVD
)
615 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
617 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
623 err
= p9_check_errors(c
, req
);
625 P9_DPRINTK(P9_DEBUG_MUX
, "exit: client %p op %d\n", c
, type
);
630 P9_DPRINTK(P9_DEBUG_MUX
, "exit: client %p op %d error: %d\n", c
, type
,
636 static struct p9_fid
*p9_fid_create(struct p9_client
*clnt
)
642 P9_DPRINTK(P9_DEBUG_FID
, "clnt %p\n", clnt
);
643 fid
= kmalloc(sizeof(struct p9_fid
), GFP_KERNEL
);
645 return ERR_PTR(-ENOMEM
);
647 ret
= p9_idpool_get(clnt
->fidpool
);
654 memset(&fid
->qid
, 0, sizeof(struct p9_qid
));
656 fid
->uid
= current_fsuid();
659 spin_lock_irqsave(&clnt
->lock
, flags
);
660 list_add(&fid
->flist
, &clnt
->fidlist
);
661 spin_unlock_irqrestore(&clnt
->lock
, flags
);
670 static void p9_fid_destroy(struct p9_fid
*fid
)
672 struct p9_client
*clnt
;
675 P9_DPRINTK(P9_DEBUG_FID
, "fid %d\n", fid
->fid
);
677 p9_idpool_put(fid
->fid
, clnt
->fidpool
);
678 spin_lock_irqsave(&clnt
->lock
, flags
);
679 list_del(&fid
->flist
);
680 spin_unlock_irqrestore(&clnt
->lock
, flags
);
685 static int p9_client_version(struct p9_client
*c
)
688 struct p9_req_t
*req
;
692 P9_DPRINTK(P9_DEBUG_9P
, ">>> TVERSION msize %d protocol %d\n",
693 c
->msize
, c
->proto_version
);
695 switch (c
->proto_version
) {
697 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
698 c
->msize
, "9P2000.L");
701 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
702 c
->msize
, "9P2000.u");
704 case p9_proto_legacy
:
705 req
= p9_client_rpc(c
, P9_TVERSION
, "ds",
716 err
= p9pdu_readf(req
->rc
, c
->proto_version
, "ds", &msize
, &version
);
718 P9_DPRINTK(P9_DEBUG_9P
, "version error %d\n", err
);
719 p9pdu_dump(1, req
->rc
);
723 P9_DPRINTK(P9_DEBUG_9P
, "<<< RVERSION msize %d %s\n", msize
, version
);
724 if (!strncmp(version
, "9P2000.L", 8))
725 c
->proto_version
= p9_proto_2000L
;
726 else if (!strncmp(version
, "9P2000.u", 8))
727 c
->proto_version
= p9_proto_2000u
;
728 else if (!strncmp(version
, "9P2000", 6))
729 c
->proto_version
= p9_proto_legacy
;
735 if (msize
< c
->msize
)
745 struct p9_client
*p9_client_create(const char *dev_name
, char *options
)
748 struct p9_client
*clnt
;
751 clnt
= kmalloc(sizeof(struct p9_client
), GFP_KERNEL
);
753 return ERR_PTR(-ENOMEM
);
755 clnt
->trans_mod
= NULL
;
757 spin_lock_init(&clnt
->lock
);
758 INIT_LIST_HEAD(&clnt
->fidlist
);
762 err
= parse_opts(options
, clnt
);
766 if (!clnt
->trans_mod
)
767 clnt
->trans_mod
= v9fs_get_default_trans();
769 if (clnt
->trans_mod
== NULL
) {
770 err
= -EPROTONOSUPPORT
;
771 P9_DPRINTK(P9_DEBUG_ERROR
,
772 "No transport defined or default transport\n");
776 clnt
->fidpool
= p9_idpool_create();
777 if (IS_ERR(clnt
->fidpool
)) {
778 err
= PTR_ERR(clnt
->fidpool
);
779 clnt
->fidpool
= NULL
;
783 P9_DPRINTK(P9_DEBUG_MUX
, "clnt %p trans %p msize %d protocol %d\n",
784 clnt
, clnt
->trans_mod
, clnt
->msize
, clnt
->proto_version
);
786 err
= clnt
->trans_mod
->create(clnt
, dev_name
, options
);
788 goto destroy_fidpool
;
790 if ((clnt
->msize
+P9_IOHDRSZ
) > clnt
->trans_mod
->maxsize
)
791 clnt
->msize
= clnt
->trans_mod
->maxsize
-P9_IOHDRSZ
;
793 err
= p9_client_version(clnt
);
800 clnt
->trans_mod
->close(clnt
);
802 p9_idpool_destroy(clnt
->fidpool
);
804 v9fs_put_trans(clnt
->trans_mod
);
809 EXPORT_SYMBOL(p9_client_create
);
811 void p9_client_destroy(struct p9_client
*clnt
)
813 struct p9_fid
*fid
, *fidptr
;
815 P9_DPRINTK(P9_DEBUG_MUX
, "clnt %p\n", clnt
);
818 clnt
->trans_mod
->close(clnt
);
820 v9fs_put_trans(clnt
->trans_mod
);
822 list_for_each_entry_safe(fid
, fidptr
, &clnt
->fidlist
, flist
) {
823 printk(KERN_INFO
"Found fid %d not clunked\n", fid
->fid
);
828 p9_idpool_destroy(clnt
->fidpool
);
830 p9_tag_cleanup(clnt
);
834 EXPORT_SYMBOL(p9_client_destroy
);
836 void p9_client_disconnect(struct p9_client
*clnt
)
838 P9_DPRINTK(P9_DEBUG_9P
, "clnt %p\n", clnt
);
839 clnt
->status
= Disconnected
;
841 EXPORT_SYMBOL(p9_client_disconnect
);
843 void p9_client_begin_disconnect(struct p9_client
*clnt
)
845 P9_DPRINTK(P9_DEBUG_9P
, "clnt %p\n", clnt
);
846 clnt
->status
= BeginDisconnect
;
848 EXPORT_SYMBOL(p9_client_begin_disconnect
);
850 struct p9_fid
*p9_client_attach(struct p9_client
*clnt
, struct p9_fid
*afid
,
851 char *uname
, u32 n_uname
, char *aname
)
854 struct p9_req_t
*req
;
858 P9_DPRINTK(P9_DEBUG_9P
, ">>> TATTACH afid %d uname %s aname %s\n",
859 afid
? afid
->fid
: -1, uname
, aname
);
862 fid
= p9_fid_create(clnt
);
869 req
= p9_client_rpc(clnt
, P9_TATTACH
, "ddss?d", fid
->fid
,
870 afid
? afid
->fid
: P9_NOFID
, uname
, aname
, n_uname
);
876 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", &qid
);
878 p9pdu_dump(1, req
->rc
);
879 p9_free_req(clnt
, req
);
883 P9_DPRINTK(P9_DEBUG_9P
, "<<< RATTACH qid %x.%llx.%x\n",
885 (unsigned long long)qid
.path
,
888 memmove(&fid
->qid
, &qid
, sizeof(struct p9_qid
));
890 p9_free_req(clnt
, req
);
898 EXPORT_SYMBOL(p9_client_attach
);
900 struct p9_fid
*p9_client_walk(struct p9_fid
*oldfid
, int nwname
, char **wnames
,
904 struct p9_client
*clnt
;
906 struct p9_qid
*wqids
;
907 struct p9_req_t
*req
;
908 int16_t nwqids
, count
;
914 fid
= p9_fid_create(clnt
);
921 fid
->uid
= oldfid
->uid
;
926 P9_DPRINTK(P9_DEBUG_9P
, ">>> TWALK fids %d,%d nwname %d wname[0] %s\n",
927 oldfid
->fid
, fid
->fid
, nwname
, wnames
? wnames
[0] : NULL
);
929 req
= p9_client_rpc(clnt
, P9_TWALK
, "ddT", oldfid
->fid
, fid
->fid
,
936 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "R", &nwqids
, &wqids
);
938 p9pdu_dump(1, req
->rc
);
939 p9_free_req(clnt
, req
);
942 p9_free_req(clnt
, req
);
944 P9_DPRINTK(P9_DEBUG_9P
, "<<< RWALK nwqid %d:\n", nwqids
);
946 if (nwqids
!= nwname
) {
951 for (count
= 0; count
< nwqids
; count
++)
952 P9_DPRINTK(P9_DEBUG_9P
, "<<< [%d] %x.%llx.%x\n",
953 count
, wqids
[count
].type
,
954 (unsigned long long)wqids
[count
].path
,
955 wqids
[count
].version
);
958 memmove(&fid
->qid
, &wqids
[nwqids
- 1], sizeof(struct p9_qid
));
960 fid
->qid
= oldfid
->qid
;
967 p9_client_clunk(fid
);
971 if (fid
&& (fid
!= oldfid
))
976 EXPORT_SYMBOL(p9_client_walk
);
978 int p9_client_open(struct p9_fid
*fid
, int mode
)
981 struct p9_client
*clnt
;
982 struct p9_req_t
*req
;
987 P9_DPRINTK(P9_DEBUG_9P
, ">>> %s fid %d mode %d\n",
988 p9_is_proto_dotl(clnt
) ? "TLOPEN" : "TOPEN", fid
->fid
, mode
);
994 if (p9_is_proto_dotl(clnt
))
995 req
= p9_client_rpc(clnt
, P9_TLOPEN
, "dd", fid
->fid
, mode
);
997 req
= p9_client_rpc(clnt
, P9_TOPEN
, "db", fid
->fid
, mode
);
1003 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1005 p9pdu_dump(1, req
->rc
);
1006 goto free_and_error
;
1009 P9_DPRINTK(P9_DEBUG_9P
, "<<< %s qid %x.%llx.%x iounit %x\n",
1010 p9_is_proto_dotl(clnt
) ? "RLOPEN" : "ROPEN", qid
.type
,
1011 (unsigned long long)qid
.path
, qid
.version
, iounit
);
1014 fid
->iounit
= iounit
;
1017 p9_free_req(clnt
, req
);
1021 EXPORT_SYMBOL(p9_client_open
);
1023 int p9_client_create_dotl(struct p9_fid
*ofid
, char *name
, u32 flags
, u32 mode
,
1024 gid_t gid
, struct p9_qid
*qid
)
1027 struct p9_client
*clnt
;
1028 struct p9_req_t
*req
;
1031 P9_DPRINTK(P9_DEBUG_9P
,
1032 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1033 ofid
->fid
, name
, flags
, mode
, gid
);
1036 if (ofid
->mode
!= -1)
1039 req
= p9_client_rpc(clnt
, P9_TLCREATE
, "dsddd", ofid
->fid
, name
, flags
,
1046 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", qid
, &iounit
);
1048 p9pdu_dump(1, req
->rc
);
1049 goto free_and_error
;
1052 P9_DPRINTK(P9_DEBUG_9P
, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1054 (unsigned long long)qid
->path
,
1055 qid
->version
, iounit
);
1058 ofid
->iounit
= iounit
;
1061 p9_free_req(clnt
, req
);
1065 EXPORT_SYMBOL(p9_client_create_dotl
);
1067 int p9_client_fcreate(struct p9_fid
*fid
, char *name
, u32 perm
, int mode
,
1071 struct p9_client
*clnt
;
1072 struct p9_req_t
*req
;
1076 P9_DPRINTK(P9_DEBUG_9P
, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1077 fid
->fid
, name
, perm
, mode
);
1081 if (fid
->mode
!= -1)
1084 req
= p9_client_rpc(clnt
, P9_TCREATE
, "dsdb?s", fid
->fid
, name
, perm
,
1091 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Qd", &qid
, &iounit
);
1093 p9pdu_dump(1, req
->rc
);
1094 goto free_and_error
;
1097 P9_DPRINTK(P9_DEBUG_9P
, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1099 (unsigned long long)qid
.path
,
1100 qid
.version
, iounit
);
1103 fid
->iounit
= iounit
;
1106 p9_free_req(clnt
, req
);
1110 EXPORT_SYMBOL(p9_client_fcreate
);
1112 int p9_client_symlink(struct p9_fid
*dfid
, char *name
, char *symtgt
, gid_t gid
,
1116 struct p9_client
*clnt
;
1117 struct p9_req_t
*req
;
1119 P9_DPRINTK(P9_DEBUG_9P
, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
1120 dfid
->fid
, name
, symtgt
);
1123 req
= p9_client_rpc(clnt
, P9_TSYMLINK
, "dssd", dfid
->fid
, name
, symtgt
,
1130 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
1132 p9pdu_dump(1, req
->rc
);
1133 goto free_and_error
;
1136 P9_DPRINTK(P9_DEBUG_9P
, "<<< RSYMLINK qid %x.%llx.%x\n",
1137 qid
->type
, (unsigned long long)qid
->path
, qid
->version
);
1140 p9_free_req(clnt
, req
);
1144 EXPORT_SYMBOL(p9_client_symlink
);
1146 int p9_client_link(struct p9_fid
*dfid
, struct p9_fid
*oldfid
, char *newname
)
1148 struct p9_client
*clnt
;
1149 struct p9_req_t
*req
;
1151 P9_DPRINTK(P9_DEBUG_9P
, ">>> TLINK dfid %d oldfid %d newname %s\n",
1152 dfid
->fid
, oldfid
->fid
, newname
);
1154 req
= p9_client_rpc(clnt
, P9_TLINK
, "dds", dfid
->fid
, oldfid
->fid
,
1157 return PTR_ERR(req
);
1159 P9_DPRINTK(P9_DEBUG_9P
, "<<< RLINK\n");
1160 p9_free_req(clnt
, req
);
1163 EXPORT_SYMBOL(p9_client_link
);
1165 int p9_client_fsync(struct p9_fid
*fid
)
1168 struct p9_client
*clnt
;
1169 struct p9_req_t
*req
;
1171 P9_DPRINTK(P9_DEBUG_9P
, ">>> TFSYNC fid %d\n", fid
->fid
);
1175 req
= p9_client_rpc(clnt
, P9_TFSYNC
, "d", fid
->fid
);
1181 P9_DPRINTK(P9_DEBUG_9P
, "<<< RFSYNC fid %d\n", fid
->fid
);
1183 p9_free_req(clnt
, req
);
1188 EXPORT_SYMBOL(p9_client_fsync
);
1190 int p9_client_clunk(struct p9_fid
*fid
)
1193 struct p9_client
*clnt
;
1194 struct p9_req_t
*req
;
1197 P9_EPRINTK(KERN_WARNING
, "Trying to clunk with NULL fid\n");
1202 P9_DPRINTK(P9_DEBUG_9P
, ">>> TCLUNK fid %d\n", fid
->fid
);
1206 req
= p9_client_rpc(clnt
, P9_TCLUNK
, "d", fid
->fid
);
1212 P9_DPRINTK(P9_DEBUG_9P
, "<<< RCLUNK fid %d\n", fid
->fid
);
1214 p9_free_req(clnt
, req
);
1215 p9_fid_destroy(fid
);
1220 EXPORT_SYMBOL(p9_client_clunk
);
1222 int p9_client_remove(struct p9_fid
*fid
)
1225 struct p9_client
*clnt
;
1226 struct p9_req_t
*req
;
1228 P9_DPRINTK(P9_DEBUG_9P
, ">>> TREMOVE fid %d\n", fid
->fid
);
1232 req
= p9_client_rpc(clnt
, P9_TREMOVE
, "d", fid
->fid
);
1238 P9_DPRINTK(P9_DEBUG_9P
, "<<< RREMOVE fid %d\n", fid
->fid
);
1240 p9_free_req(clnt
, req
);
1242 p9_fid_destroy(fid
);
1245 EXPORT_SYMBOL(p9_client_remove
);
1248 p9_client_read(struct p9_fid
*fid
, char *data
, char __user
*udata
, u64 offset
,
1251 int err
, rsize
, total
;
1252 struct p9_client
*clnt
;
1253 struct p9_req_t
*req
;
1256 P9_DPRINTK(P9_DEBUG_9P
, ">>> TREAD fid %d offset %llu %d\n", fid
->fid
,
1257 (long long unsigned) offset
, count
);
1262 rsize
= fid
->iounit
;
1263 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1264 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1269 req
= p9_client_rpc(clnt
, P9_TREAD
, "dqd", fid
->fid
, offset
, rsize
);
1275 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "D", &count
, &dataptr
);
1277 p9pdu_dump(1, req
->rc
);
1278 goto free_and_error
;
1281 P9_DPRINTK(P9_DEBUG_9P
, "<<< RREAD count %d\n", count
);
1284 memmove(data
, dataptr
, count
);
1288 err
= copy_to_user(udata
, dataptr
, count
);
1291 goto free_and_error
;
1295 p9_free_req(clnt
, req
);
1299 p9_free_req(clnt
, req
);
1303 EXPORT_SYMBOL(p9_client_read
);
1306 p9_client_write(struct p9_fid
*fid
, char *data
, const char __user
*udata
,
1307 u64 offset
, u32 count
)
1309 int err
, rsize
, total
;
1310 struct p9_client
*clnt
;
1311 struct p9_req_t
*req
;
1313 P9_DPRINTK(P9_DEBUG_9P
, ">>> TWRITE fid %d offset %llu count %d\n",
1314 fid
->fid
, (long long unsigned) offset
, count
);
1319 rsize
= fid
->iounit
;
1320 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1321 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1326 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqD", fid
->fid
, offset
,
1329 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqU", fid
->fid
, offset
,
1336 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "d", &count
);
1338 p9pdu_dump(1, req
->rc
);
1339 goto free_and_error
;
1342 P9_DPRINTK(P9_DEBUG_9P
, "<<< RWRITE count %d\n", count
);
1344 p9_free_req(clnt
, req
);
1348 p9_free_req(clnt
, req
);
1352 EXPORT_SYMBOL(p9_client_write
);
1354 struct p9_wstat
*p9_client_stat(struct p9_fid
*fid
)
1357 struct p9_client
*clnt
;
1358 struct p9_wstat
*ret
= kmalloc(sizeof(struct p9_wstat
), GFP_KERNEL
);
1359 struct p9_req_t
*req
;
1362 P9_DPRINTK(P9_DEBUG_9P
, ">>> TSTAT fid %d\n", fid
->fid
);
1365 return ERR_PTR(-ENOMEM
);
1370 req
= p9_client_rpc(clnt
, P9_TSTAT
, "d", fid
->fid
);
1376 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "wS", &ignored
, ret
);
1378 p9pdu_dump(1, req
->rc
);
1379 p9_free_req(clnt
, req
);
1383 P9_DPRINTK(P9_DEBUG_9P
,
1384 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1385 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1386 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1387 "<<< uid=%d gid=%d n_muid=%d\n",
1388 ret
->size
, ret
->type
, ret
->dev
, ret
->qid
.type
,
1389 (unsigned long long)ret
->qid
.path
, ret
->qid
.version
, ret
->mode
,
1390 ret
->atime
, ret
->mtime
, (unsigned long long)ret
->length
,
1391 ret
->name
, ret
->uid
, ret
->gid
, ret
->muid
, ret
->extension
,
1392 ret
->n_uid
, ret
->n_gid
, ret
->n_muid
);
1394 p9_free_req(clnt
, req
);
1399 return ERR_PTR(err
);
1401 EXPORT_SYMBOL(p9_client_stat
);
1403 struct p9_stat_dotl
*p9_client_getattr_dotl(struct p9_fid
*fid
,
1407 struct p9_client
*clnt
;
1408 struct p9_stat_dotl
*ret
= kmalloc(sizeof(struct p9_stat_dotl
),
1410 struct p9_req_t
*req
;
1412 P9_DPRINTK(P9_DEBUG_9P
, ">>> TGETATTR fid %d, request_mask %lld\n",
1413 fid
->fid
, request_mask
);
1416 return ERR_PTR(-ENOMEM
);
1421 req
= p9_client_rpc(clnt
, P9_TGETATTR
, "dq", fid
->fid
, request_mask
);
1427 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "A", ret
);
1429 p9pdu_dump(1, req
->rc
);
1430 p9_free_req(clnt
, req
);
1434 P9_DPRINTK(P9_DEBUG_9P
,
1435 "<<< RGETATTR st_result_mask=%lld\n"
1436 "<<< qid=%x.%llx.%x\n"
1437 "<<< st_mode=%8.8x st_nlink=%llu\n"
1438 "<<< st_uid=%d st_gid=%d\n"
1439 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1440 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1441 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1442 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1443 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1444 "<<< st_gen=%lld st_data_version=%lld",
1445 ret
->st_result_mask
, ret
->qid
.type
, ret
->qid
.path
,
1446 ret
->qid
.version
, ret
->st_mode
, ret
->st_nlink
, ret
->st_uid
,
1447 ret
->st_gid
, ret
->st_rdev
, ret
->st_size
, ret
->st_blksize
,
1448 ret
->st_blocks
, ret
->st_atime_sec
, ret
->st_atime_nsec
,
1449 ret
->st_mtime_sec
, ret
->st_mtime_nsec
, ret
->st_ctime_sec
,
1450 ret
->st_ctime_nsec
, ret
->st_btime_sec
, ret
->st_btime_nsec
,
1451 ret
->st_gen
, ret
->st_data_version
);
1453 p9_free_req(clnt
, req
);
1458 return ERR_PTR(err
);
1460 EXPORT_SYMBOL(p9_client_getattr_dotl
);
1462 static int p9_client_statsize(struct p9_wstat
*wst
, int proto_version
)
1466 /* NOTE: size shouldn't include its own length */
1467 /* size[2] type[2] dev[4] qid[13] */
1468 /* mode[4] atime[4] mtime[4] length[8]*/
1469 /* name[s] uid[s] gid[s] muid[s] */
1470 ret
= 2+4+13+4+4+4+8+2+2+2+2;
1473 ret
+= strlen(wst
->name
);
1475 ret
+= strlen(wst
->uid
);
1477 ret
+= strlen(wst
->gid
);
1479 ret
+= strlen(wst
->muid
);
1481 if ((proto_version
== p9_proto_2000u
) ||
1482 (proto_version
== p9_proto_2000L
)) {
1483 ret
+= 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1485 ret
+= strlen(wst
->extension
);
1491 int p9_client_wstat(struct p9_fid
*fid
, struct p9_wstat
*wst
)
1494 struct p9_req_t
*req
;
1495 struct p9_client
*clnt
;
1499 wst
->size
= p9_client_statsize(wst
, clnt
->proto_version
);
1500 P9_DPRINTK(P9_DEBUG_9P
, ">>> TWSTAT fid %d\n", fid
->fid
);
1501 P9_DPRINTK(P9_DEBUG_9P
,
1502 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1503 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1504 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1505 " uid=%d gid=%d n_muid=%d\n",
1506 wst
->size
, wst
->type
, wst
->dev
, wst
->qid
.type
,
1507 (unsigned long long)wst
->qid
.path
, wst
->qid
.version
, wst
->mode
,
1508 wst
->atime
, wst
->mtime
, (unsigned long long)wst
->length
,
1509 wst
->name
, wst
->uid
, wst
->gid
, wst
->muid
, wst
->extension
,
1510 wst
->n_uid
, wst
->n_gid
, wst
->n_muid
);
1512 req
= p9_client_rpc(clnt
, P9_TWSTAT
, "dwS", fid
->fid
, wst
->size
+2, wst
);
1518 P9_DPRINTK(P9_DEBUG_9P
, "<<< RWSTAT fid %d\n", fid
->fid
);
1520 p9_free_req(clnt
, req
);
1524 EXPORT_SYMBOL(p9_client_wstat
);
1526 int p9_client_setattr(struct p9_fid
*fid
, struct p9_iattr_dotl
*p9attr
)
1529 struct p9_req_t
*req
;
1530 struct p9_client
*clnt
;
1534 P9_DPRINTK(P9_DEBUG_9P
, ">>> TSETATTR fid %d\n", fid
->fid
);
1535 P9_DPRINTK(P9_DEBUG_9P
,
1536 " valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1537 " atime_sec=%lld atime_nsec=%lld\n"
1538 " mtime_sec=%lld mtime_nsec=%lld\n",
1539 p9attr
->valid
, p9attr
->mode
, p9attr
->uid
, p9attr
->gid
,
1540 p9attr
->size
, p9attr
->atime_sec
, p9attr
->atime_nsec
,
1541 p9attr
->mtime_sec
, p9attr
->mtime_nsec
);
1543 req
= p9_client_rpc(clnt
, P9_TSETATTR
, "dI", fid
->fid
, p9attr
);
1549 P9_DPRINTK(P9_DEBUG_9P
, "<<< RSETATTR fid %d\n", fid
->fid
);
1550 p9_free_req(clnt
, req
);
1554 EXPORT_SYMBOL(p9_client_setattr
);
1556 int p9_client_statfs(struct p9_fid
*fid
, struct p9_rstatfs
*sb
)
1559 struct p9_req_t
*req
;
1560 struct p9_client
*clnt
;
1565 P9_DPRINTK(P9_DEBUG_9P
, ">>> TSTATFS fid %d\n", fid
->fid
);
1567 req
= p9_client_rpc(clnt
, P9_TSTATFS
, "d", fid
->fid
);
1573 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "ddqqqqqqd", &sb
->type
,
1574 &sb
->bsize
, &sb
->blocks
, &sb
->bfree
, &sb
->bavail
,
1575 &sb
->files
, &sb
->ffree
, &sb
->fsid
, &sb
->namelen
);
1577 p9pdu_dump(1, req
->rc
);
1578 p9_free_req(clnt
, req
);
1582 P9_DPRINTK(P9_DEBUG_9P
, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1583 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1584 "fsid %llu namelen %ld\n",
1585 fid
->fid
, (long unsigned int)sb
->type
, (long int)sb
->bsize
,
1586 sb
->blocks
, sb
->bfree
, sb
->bavail
, sb
->files
, sb
->ffree
,
1587 sb
->fsid
, (long int)sb
->namelen
);
1589 p9_free_req(clnt
, req
);
1593 EXPORT_SYMBOL(p9_client_statfs
);
1595 int p9_client_rename(struct p9_fid
*fid
, struct p9_fid
*newdirfid
, char *name
)
1598 struct p9_req_t
*req
;
1599 struct p9_client
*clnt
;
1604 P9_DPRINTK(P9_DEBUG_9P
, ">>> TRENAME fid %d newdirfid %d name %s\n",
1605 fid
->fid
, newdirfid
->fid
, name
);
1607 req
= p9_client_rpc(clnt
, P9_TRENAME
, "dds", fid
->fid
,
1608 newdirfid
->fid
, name
);
1614 P9_DPRINTK(P9_DEBUG_9P
, "<<< RRENAME fid %d\n", fid
->fid
);
1616 p9_free_req(clnt
, req
);
1620 EXPORT_SYMBOL(p9_client_rename
);
1623 * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
1625 struct p9_fid
*p9_client_xattrwalk(struct p9_fid
*file_fid
,
1626 const char *attr_name
, u64
*attr_size
)
1629 struct p9_req_t
*req
;
1630 struct p9_client
*clnt
;
1631 struct p9_fid
*attr_fid
;
1634 clnt
= file_fid
->clnt
;
1635 attr_fid
= p9_fid_create(clnt
);
1636 if (IS_ERR(attr_fid
)) {
1637 err
= PTR_ERR(attr_fid
);
1641 P9_DPRINTK(P9_DEBUG_9P
,
1642 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
1643 file_fid
->fid
, attr_fid
->fid
, attr_name
);
1645 req
= p9_client_rpc(clnt
, P9_TXATTRWALK
, "dds",
1646 file_fid
->fid
, attr_fid
->fid
, attr_name
);
1651 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "q", attr_size
);
1653 p9pdu_dump(1, req
->rc
);
1654 p9_free_req(clnt
, req
);
1657 p9_free_req(clnt
, req
);
1658 P9_DPRINTK(P9_DEBUG_9P
, "<<< RXATTRWALK fid %d size %llu\n",
1659 attr_fid
->fid
, *attr_size
);
1662 p9_client_clunk(attr_fid
);
1665 if (attr_fid
&& (attr_fid
!= file_fid
))
1666 p9_fid_destroy(attr_fid
);
1668 return ERR_PTR(err
);
1670 EXPORT_SYMBOL_GPL(p9_client_xattrwalk
);
1672 int p9_client_xattrcreate(struct p9_fid
*fid
, const char *name
,
1673 u64 attr_size
, int flags
)
1676 struct p9_req_t
*req
;
1677 struct p9_client
*clnt
;
1679 P9_DPRINTK(P9_DEBUG_9P
,
1680 ">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
1681 fid
->fid
, name
, (long long)attr_size
, flags
);
1684 req
= p9_client_rpc(clnt
, P9_TXATTRCREATE
, "dsqd",
1685 fid
->fid
, name
, attr_size
, flags
);
1690 P9_DPRINTK(P9_DEBUG_9P
, "<<< RXATTRCREATE fid %d\n", fid
->fid
);
1691 p9_free_req(clnt
, req
);
1695 EXPORT_SYMBOL_GPL(p9_client_xattrcreate
);
1697 int p9_client_readdir(struct p9_fid
*fid
, char *data
, u32 count
, u64 offset
)
1699 int err
, rsize
, total
;
1700 struct p9_client
*clnt
;
1701 struct p9_req_t
*req
;
1704 P9_DPRINTK(P9_DEBUG_9P
, ">>> TREADDIR fid %d offset %llu count %d\n",
1705 fid
->fid
, (long long unsigned) offset
, count
);
1711 rsize
= fid
->iounit
;
1712 if (!rsize
|| rsize
> clnt
->msize
-P9_READDIRHDRSZ
)
1713 rsize
= clnt
->msize
- P9_READDIRHDRSZ
;
1718 req
= p9_client_rpc(clnt
, P9_TREADDIR
, "dqd", fid
->fid
, offset
, rsize
);
1724 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "D", &count
, &dataptr
);
1726 p9pdu_dump(1, req
->rc
);
1727 goto free_and_error
;
1730 P9_DPRINTK(P9_DEBUG_9P
, "<<< RREADDIR count %d\n", count
);
1733 memmove(data
, dataptr
, count
);
1735 p9_free_req(clnt
, req
);
1739 p9_free_req(clnt
, req
);
1743 EXPORT_SYMBOL(p9_client_readdir
);
1745 int p9_client_mknod_dotl(struct p9_fid
*fid
, char *name
, int mode
,
1746 dev_t rdev
, gid_t gid
, struct p9_qid
*qid
)
1749 struct p9_client
*clnt
;
1750 struct p9_req_t
*req
;
1754 P9_DPRINTK(P9_DEBUG_9P
, ">>> TMKNOD fid %d name %s mode %d major %d "
1755 "minor %d\n", fid
->fid
, name
, mode
, MAJOR(rdev
), MINOR(rdev
));
1756 req
= p9_client_rpc(clnt
, P9_TMKNOD
, "dsdddd", fid
->fid
, name
, mode
,
1757 MAJOR(rdev
), MINOR(rdev
), gid
);
1759 return PTR_ERR(req
);
1761 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
1763 p9pdu_dump(1, req
->rc
);
1766 P9_DPRINTK(P9_DEBUG_9P
, "<<< RMKNOD qid %x.%llx.%x\n", qid
->type
,
1767 (unsigned long long)qid
->path
, qid
->version
);
1770 p9_free_req(clnt
, req
);
1774 EXPORT_SYMBOL(p9_client_mknod_dotl
);
1776 int p9_client_mkdir_dotl(struct p9_fid
*fid
, char *name
, int mode
,
1777 gid_t gid
, struct p9_qid
*qid
)
1780 struct p9_client
*clnt
;
1781 struct p9_req_t
*req
;
1785 P9_DPRINTK(P9_DEBUG_9P
, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
1786 fid
->fid
, name
, mode
, gid
);
1787 req
= p9_client_rpc(clnt
, P9_TMKDIR
, "dsdd", fid
->fid
, name
, mode
,
1790 return PTR_ERR(req
);
1792 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "Q", qid
);
1794 p9pdu_dump(1, req
->rc
);
1797 P9_DPRINTK(P9_DEBUG_9P
, "<<< RMKDIR qid %x.%llx.%x\n", qid
->type
,
1798 (unsigned long long)qid
->path
, qid
->version
);
1801 p9_free_req(clnt
, req
);
1805 EXPORT_SYMBOL(p9_client_mkdir_dotl
);
1807 int p9_client_lock_dotl(struct p9_fid
*fid
, struct p9_flock
*flock
, u8
*status
)
1810 struct p9_client
*clnt
;
1811 struct p9_req_t
*req
;
1815 P9_DPRINTK(P9_DEBUG_9P
, ">>> TLOCK fid %d type %i flags %d "
1816 "start %lld length %lld proc_id %d client_id %s\n",
1817 fid
->fid
, flock
->type
, flock
->flags
, flock
->start
,
1818 flock
->length
, flock
->proc_id
, flock
->client_id
);
1820 req
= p9_client_rpc(clnt
, P9_TLOCK
, "dbdqqds", fid
->fid
, flock
->type
,
1821 flock
->flags
, flock
->start
, flock
->length
,
1822 flock
->proc_id
, flock
->client_id
);
1825 return PTR_ERR(req
);
1827 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "b", status
);
1829 p9pdu_dump(1, req
->rc
);
1832 P9_DPRINTK(P9_DEBUG_9P
, "<<< RLOCK status %i\n", *status
);
1834 p9_free_req(clnt
, req
);
1838 EXPORT_SYMBOL(p9_client_lock_dotl
);
1840 int p9_client_getlock_dotl(struct p9_fid
*fid
, struct p9_getlock
*glock
)
1843 struct p9_client
*clnt
;
1844 struct p9_req_t
*req
;
1848 P9_DPRINTK(P9_DEBUG_9P
, ">>> TGETLOCK fid %d, type %i start %lld "
1849 "length %lld proc_id %d client_id %s\n", fid
->fid
, glock
->type
,
1850 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
1852 req
= p9_client_rpc(clnt
, P9_TGETLOCK
, "dbqqds", fid
->fid
, glock
->type
,
1853 glock
->start
, glock
->length
, glock
->proc_id
, glock
->client_id
);
1856 return PTR_ERR(req
);
1858 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "bqqds", &glock
->type
,
1859 &glock
->start
, &glock
->length
, &glock
->proc_id
,
1862 p9pdu_dump(1, req
->rc
);
1865 P9_DPRINTK(P9_DEBUG_9P
, "<<< RGETLOCK type %i start %lld length %lld "
1866 "proc_id %d client_id %s\n", glock
->type
, glock
->start
,
1867 glock
->length
, glock
->proc_id
, glock
->client_id
);
1869 p9_free_req(clnt
, req
);
1872 EXPORT_SYMBOL(p9_client_getlock_dotl
);
1874 int p9_client_readlink(struct p9_fid
*fid
, char **target
)
1877 struct p9_client
*clnt
;
1878 struct p9_req_t
*req
;
1882 P9_DPRINTK(P9_DEBUG_9P
, ">>> TREADLINK fid %d\n", fid
->fid
);
1884 req
= p9_client_rpc(clnt
, P9_TREADLINK
, "d", fid
->fid
);
1886 return PTR_ERR(req
);
1888 err
= p9pdu_readf(req
->rc
, clnt
->proto_version
, "s", target
);
1890 p9pdu_dump(1, req
->rc
);
1893 P9_DPRINTK(P9_DEBUG_9P
, "<<< RREADLINK target %s\n", *target
);
1895 p9_free_req(clnt
, req
);
1898 EXPORT_SYMBOL(p9_client_readlink
);