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/sched.h>
33 #include <linux/uaccess.h>
34 #include <net/9p/9p.h>
35 #include <linux/parser.h>
36 #include <net/9p/client.h>
37 #include <net/9p/transport.h>
41 * Client Option Parsing (code inspired by NFS code)
42 * - a little lazy - parse all client options
52 static const match_table_t tokens
= {
53 {Opt_msize
, "msize=%u"},
54 {Opt_legacy
, "noextend"},
55 {Opt_trans
, "trans=%s"},
59 static struct p9_req_t
*
60 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...);
63 * parse_options - parse mount options into client structure
64 * @opts: options string passed from mount
65 * @clnt: existing v9fs client information
67 * Return 0 upon success, -ERRNO upon failure
70 static int parse_opts(char *opts
, struct p9_client
*clnt
)
74 substring_t args
[MAX_OPT_ARGS
];
84 options
= kstrdup(opts
, GFP_KERNEL
);
86 P9_DPRINTK(P9_DEBUG_ERROR
,
87 "failed to allocate copy of option string\n");
91 while ((p
= strsep(&options
, ",")) != NULL
) {
95 token
= match_token(p
, tokens
, args
);
96 if (token
< Opt_trans
) {
97 int r
= match_int(&args
[0], &option
);
99 P9_DPRINTK(P9_DEBUG_ERROR
,
100 "integer field, but no integer?\n");
107 clnt
->msize
= option
;
110 clnt
->trans_mod
= v9fs_get_trans_by_name(&args
[0]);
125 * p9_tag_alloc - lookup/allocate a request by tag
126 * @c: client session to lookup tag within
127 * @tag: numeric id for transaction
129 * this is a simple array lookup, but will grow the
130 * request_slots as necessary to accomodate transaction
131 * ids which did not previously have a slot.
133 * this code relies on the client spinlock to manage locks, its
134 * possible we should switch to something else, but I'd rather
135 * stick with something low-overhead for the common case.
139 static struct p9_req_t
*p9_tag_alloc(struct p9_client
*c
, u16 tag
)
143 struct p9_req_t
*req
;
145 /* This looks up the original request by tag so we know which
146 * buffer to read the data into */
149 if (tag
>= c
->max_tag
) {
150 spin_lock_irqsave(&c
->lock
, flags
);
151 /* check again since original check was outside of lock */
152 while (tag
>= c
->max_tag
) {
153 row
= (tag
/ P9_ROW_MAXTAG
);
154 c
->reqs
[row
] = kcalloc(P9_ROW_MAXTAG
,
155 sizeof(struct p9_req_t
), GFP_ATOMIC
);
158 printk(KERN_ERR
"Couldn't grow tag array\n");
159 spin_unlock_irqrestore(&c
->lock
, flags
);
160 return ERR_PTR(-ENOMEM
);
162 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
163 c
->reqs
[row
][col
].status
= REQ_STATUS_IDLE
;
164 c
->reqs
[row
][col
].tc
= NULL
;
166 c
->max_tag
+= P9_ROW_MAXTAG
;
168 spin_unlock_irqrestore(&c
->lock
, flags
);
170 row
= tag
/ P9_ROW_MAXTAG
;
171 col
= tag
% P9_ROW_MAXTAG
;
173 req
= &c
->reqs
[row
][col
];
175 req
->wq
= kmalloc(sizeof(wait_queue_head_t
), GFP_KERNEL
);
177 printk(KERN_ERR
"Couldn't grow tag array\n");
178 return ERR_PTR(-ENOMEM
);
180 init_waitqueue_head(req
->wq
);
181 req
->tc
= kmalloc(sizeof(struct p9_fcall
)+c
->msize
,
183 req
->rc
= kmalloc(sizeof(struct p9_fcall
)+c
->msize
,
185 if ((!req
->tc
) || (!req
->rc
)) {
186 printk(KERN_ERR
"Couldn't grow tag array\n");
190 req
->tc
= req
->rc
= NULL
;
192 return ERR_PTR(-ENOMEM
);
194 req
->tc
->sdata
= (char *) req
->tc
+ sizeof(struct p9_fcall
);
195 req
->tc
->capacity
= c
->msize
;
196 req
->rc
->sdata
= (char *) req
->rc
+ sizeof(struct p9_fcall
);
197 req
->rc
->capacity
= c
->msize
;
200 p9pdu_reset(req
->tc
);
201 p9pdu_reset(req
->rc
);
203 req
->tc
->tag
= tag
-1;
204 req
->status
= REQ_STATUS_ALLOC
;
206 return &c
->reqs
[row
][col
];
210 * p9_tag_lookup - lookup a request by tag
211 * @c: client session to lookup tag within
212 * @tag: numeric id for transaction
216 struct p9_req_t
*p9_tag_lookup(struct p9_client
*c
, u16 tag
)
220 /* This looks up the original request by tag so we know which
221 * buffer to read the data into */
224 BUG_ON(tag
>= c
->max_tag
);
226 row
= tag
/ P9_ROW_MAXTAG
;
227 col
= tag
% P9_ROW_MAXTAG
;
229 return &c
->reqs
[row
][col
];
231 EXPORT_SYMBOL(p9_tag_lookup
);
234 * p9_tag_init - setup tags structure and contents
235 * @c: v9fs client struct
237 * This initializes the tags structure for each client instance.
241 static int p9_tag_init(struct p9_client
*c
)
245 c
->tagpool
= p9_idpool_create();
246 if (IS_ERR(c
->tagpool
)) {
247 err
= PTR_ERR(c
->tagpool
);
252 p9_idpool_get(c
->tagpool
); /* reserve tag 0 */
260 * p9_tag_cleanup - cleans up tags structure and reclaims resources
261 * @c: v9fs client struct
263 * This frees resources associated with the tags structure
266 static void p9_tag_cleanup(struct p9_client
*c
)
270 /* check to insure all requests are idle */
271 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
272 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
273 if (c
->reqs
[row
][col
].status
!= REQ_STATUS_IDLE
) {
274 P9_DPRINTK(P9_DEBUG_MUX
,
275 "Attempting to cleanup non-free tag %d,%d\n",
277 /* TODO: delay execution of cleanup */
284 p9_idpool_destroy(c
->tagpool
);
286 /* free requests associated with tags */
287 for (row
= 0; row
< (c
->max_tag
/P9_ROW_MAXTAG
); row
++) {
288 for (col
= 0; col
< P9_ROW_MAXTAG
; col
++) {
289 kfree(c
->reqs
[row
][col
].wq
);
290 kfree(c
->reqs
[row
][col
].tc
);
291 kfree(c
->reqs
[row
][col
].rc
);
299 * p9_free_req - free a request and clean-up as necessary
301 * r: request to release
305 static void p9_free_req(struct p9_client
*c
, struct p9_req_t
*r
)
307 int tag
= r
->tc
->tag
;
308 P9_DPRINTK(P9_DEBUG_MUX
, "clnt %p req %p tag: %d\n", c
, r
, tag
);
310 r
->status
= REQ_STATUS_IDLE
;
311 if (tag
!= P9_NOTAG
&& p9_idpool_check(tag
, c
->tagpool
))
312 p9_idpool_put(tag
, c
->tagpool
);
316 * p9_client_cb - call back from transport to client
318 * req: request received
321 void p9_client_cb(struct p9_client
*c
, struct p9_req_t
*req
)
323 P9_DPRINTK(P9_DEBUG_MUX
, " tag %d\n", req
->tc
->tag
);
325 P9_DPRINTK(P9_DEBUG_MUX
, "wakeup: %d\n", req
->tc
->tag
);
327 EXPORT_SYMBOL(p9_client_cb
);
330 * p9_parse_header - parse header arguments out of a packet
331 * @pdu: packet to parse
332 * @size: size of packet
333 * @type: type of request
334 * @tag: tag of packet
335 * @rewind: set if we need to rewind offset afterwards
339 p9_parse_header(struct p9_fcall
*pdu
, int32_t *size
, int8_t *type
, int16_t *tag
,
345 int offset
= pdu
->offset
;
352 err
= p9pdu_readf(pdu
, 0, "dbw", &r_size
, &r_type
, &r_tag
);
354 goto rewind_and_exit
;
360 P9_DPRINTK(P9_DEBUG_9P
, "<<< size=%d type: %d tag: %d\n", pdu
->size
,
373 pdu
->offset
= offset
;
376 EXPORT_SYMBOL(p9_parse_header
);
379 * p9_check_errors - check 9p packet for error return and process it
380 * @c: current client instance
381 * @req: request to parse and check for error conditions
383 * returns error code if one is discovered, otherwise returns 0
385 * this will have to be more complicated if we have multiple
389 static int p9_check_errors(struct p9_client
*c
, struct p9_req_t
*req
)
394 err
= p9_parse_header(req
->rc
, NULL
, &type
, NULL
, 0);
396 P9_DPRINTK(P9_DEBUG_ERROR
, "couldn't parse header %d\n", err
);
400 if (type
== P9_RERROR
) {
404 err
= p9pdu_readf(req
->rc
, c
->dotu
, "s?d", &ename
, &ecode
);
406 P9_DPRINTK(P9_DEBUG_ERROR
, "couldn't parse error%d\n",
414 if (!err
|| !IS_ERR_VALUE(err
))
415 err
= p9_errstr2errno(ename
, strlen(ename
));
417 P9_DPRINTK(P9_DEBUG_9P
, "<<< RERROR (%d) %s\n", -ecode
, ename
);
427 * p9_client_flush - flush (cancel) a request
429 * @oldreq: request to cancel
431 * This sents a flush for a particular requests and links
432 * the flush request to the original request. The current
433 * code only supports a single flush request although the protocol
434 * allows for multiple flush requests to be sent for a single request.
438 static int p9_client_flush(struct p9_client
*c
, struct p9_req_t
*oldreq
)
440 struct p9_req_t
*req
;
444 err
= p9_parse_header(oldreq
->tc
, NULL
, NULL
, &oldtag
, 1);
448 P9_DPRINTK(P9_DEBUG_9P
, ">>> TFLUSH tag %d\n", oldtag
);
450 req
= p9_client_rpc(c
, P9_TFLUSH
, "w", oldtag
);
455 /* if we haven't received a response for oldreq,
456 remove it from the list. */
458 if (oldreq
->status
== REQ_STATUS_FLSH
)
459 list_del(&oldreq
->req_list
);
460 spin_unlock(&c
->lock
);
467 * p9_client_rpc - issue a request and wait for a response
469 * @type: type of request
470 * @fmt: protocol format string (see protocol.c)
472 * Returns request structure (which client must free using p9_free_req)
475 static struct p9_req_t
*
476 p9_client_rpc(struct p9_client
*c
, int8_t type
, const char *fmt
, ...)
480 struct p9_req_t
*req
;
484 P9_DPRINTK(P9_DEBUG_MUX
, "client %p op %d\n", c
, type
);
486 if (c
->status
!= Connected
)
487 return ERR_PTR(-EIO
);
489 if (signal_pending(current
)) {
491 clear_thread_flag(TIF_SIGPENDING
);
496 if (type
!= P9_TVERSION
) {
497 tag
= p9_idpool_get(c
->tagpool
);
499 return ERR_PTR(-ENOMEM
);
502 req
= p9_tag_alloc(c
, tag
);
506 /* marshall the data */
507 p9pdu_prepare(req
->tc
, tag
, type
);
509 err
= p9pdu_vwritef(req
->tc
, c
->dotu
, fmt
, ap
);
511 p9pdu_finalize(req
->tc
);
513 err
= c
->trans_mod
->request(c
, req
);
515 c
->status
= Disconnected
;
519 P9_DPRINTK(P9_DEBUG_MUX
, "wait %p tag: %d\n", req
->wq
, tag
);
520 err
= wait_event_interruptible(*req
->wq
,
521 req
->status
>= REQ_STATUS_RCVD
);
522 P9_DPRINTK(P9_DEBUG_MUX
, "wait %p tag: %d returned %d\n",
525 if (req
->status
== REQ_STATUS_ERROR
) {
526 P9_DPRINTK(P9_DEBUG_ERROR
, "req_status error %d\n", req
->t_err
);
530 if ((err
== -ERESTARTSYS
) && (c
->status
== Connected
)) {
531 P9_DPRINTK(P9_DEBUG_MUX
, "flushing\n");
533 clear_thread_flag(TIF_SIGPENDING
);
535 if (c
->trans_mod
->cancel(c
, req
))
536 p9_client_flush(c
, req
);
538 /* if we received the response anyway, don't signal error */
539 if (req
->status
== REQ_STATUS_RCVD
)
544 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
546 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
552 err
= p9_check_errors(c
, req
);
554 P9_DPRINTK(P9_DEBUG_MUX
, "exit: client %p op %d\n", c
, type
);
559 P9_DPRINTK(P9_DEBUG_MUX
, "exit: client %p op %d error: %d\n", c
, type
,
565 static struct p9_fid
*p9_fid_create(struct p9_client
*clnt
)
571 P9_DPRINTK(P9_DEBUG_FID
, "clnt %p\n", clnt
);
572 fid
= kmalloc(sizeof(struct p9_fid
), GFP_KERNEL
);
574 return ERR_PTR(-ENOMEM
);
576 ret
= p9_idpool_get(clnt
->fidpool
);
583 memset(&fid
->qid
, 0, sizeof(struct p9_qid
));
585 fid
->uid
= current_fsuid();
588 spin_lock_irqsave(&clnt
->lock
, flags
);
589 list_add(&fid
->flist
, &clnt
->fidlist
);
590 spin_unlock_irqrestore(&clnt
->lock
, flags
);
599 static void p9_fid_destroy(struct p9_fid
*fid
)
601 struct p9_client
*clnt
;
604 P9_DPRINTK(P9_DEBUG_FID
, "fid %d\n", fid
->fid
);
606 p9_idpool_put(fid
->fid
, clnt
->fidpool
);
607 spin_lock_irqsave(&clnt
->lock
, flags
);
608 list_del(&fid
->flist
);
609 spin_unlock_irqrestore(&clnt
->lock
, flags
);
614 int p9_client_version(struct p9_client
*c
)
617 struct p9_req_t
*req
;
621 P9_DPRINTK(P9_DEBUG_9P
, ">>> TVERSION msize %d extended %d\n",
623 req
= p9_client_rpc(c
, P9_TVERSION
, "ds", c
->msize
,
624 c
->dotu
? "9P2000.u" : "9P2000");
628 err
= p9pdu_readf(req
->rc
, c
->dotu
, "ds", &msize
, &version
);
630 P9_DPRINTK(P9_DEBUG_9P
, "version error %d\n", err
);
631 p9pdu_dump(1, req
->rc
);
635 P9_DPRINTK(P9_DEBUG_9P
, "<<< RVERSION msize %d %s\n", msize
, version
);
636 if (!memcmp(version
, "9P2000.u", 8))
638 else if (!memcmp(version
, "9P2000", 6))
645 if (msize
< c
->msize
)
654 EXPORT_SYMBOL(p9_client_version
);
656 struct p9_client
*p9_client_create(const char *dev_name
, char *options
)
659 struct p9_client
*clnt
;
662 clnt
= kmalloc(sizeof(struct p9_client
), GFP_KERNEL
);
664 return ERR_PTR(-ENOMEM
);
666 clnt
->trans_mod
= NULL
;
668 spin_lock_init(&clnt
->lock
);
669 INIT_LIST_HEAD(&clnt
->fidlist
);
670 clnt
->fidpool
= p9_idpool_create();
671 if (IS_ERR(clnt
->fidpool
)) {
672 err
= PTR_ERR(clnt
->fidpool
);
673 clnt
->fidpool
= NULL
;
679 err
= parse_opts(options
, clnt
);
683 if (!clnt
->trans_mod
)
684 clnt
->trans_mod
= v9fs_get_default_trans();
686 if (clnt
->trans_mod
== NULL
) {
687 err
= -EPROTONOSUPPORT
;
688 P9_DPRINTK(P9_DEBUG_ERROR
,
689 "No transport defined or default transport\n");
693 P9_DPRINTK(P9_DEBUG_MUX
, "clnt %p trans %p msize %d dotu %d\n",
694 clnt
, clnt
->trans_mod
, clnt
->msize
, clnt
->dotu
);
696 err
= clnt
->trans_mod
->create(clnt
, dev_name
, options
);
700 if ((clnt
->msize
+P9_IOHDRSZ
) > clnt
->trans_mod
->maxsize
)
701 clnt
->msize
= clnt
->trans_mod
->maxsize
-P9_IOHDRSZ
;
703 err
= p9_client_version(clnt
);
710 p9_client_destroy(clnt
);
713 EXPORT_SYMBOL(p9_client_create
);
715 void p9_client_destroy(struct p9_client
*clnt
)
717 struct p9_fid
*fid
, *fidptr
;
719 P9_DPRINTK(P9_DEBUG_MUX
, "clnt %p\n", clnt
);
722 clnt
->trans_mod
->close(clnt
);
724 v9fs_put_trans(clnt
->trans_mod
);
726 list_for_each_entry_safe(fid
, fidptr
, &clnt
->fidlist
, flist
)
730 p9_idpool_destroy(clnt
->fidpool
);
732 p9_tag_cleanup(clnt
);
736 EXPORT_SYMBOL(p9_client_destroy
);
738 void p9_client_disconnect(struct p9_client
*clnt
)
740 P9_DPRINTK(P9_DEBUG_9P
, "clnt %p\n", clnt
);
741 clnt
->status
= Disconnected
;
743 EXPORT_SYMBOL(p9_client_disconnect
);
745 struct p9_fid
*p9_client_attach(struct p9_client
*clnt
, struct p9_fid
*afid
,
746 char *uname
, u32 n_uname
, char *aname
)
749 struct p9_req_t
*req
;
753 P9_DPRINTK(P9_DEBUG_9P
, ">>> TATTACH afid %d uname %s aname %s\n",
754 afid
? afid
->fid
: -1, uname
, aname
);
757 fid
= p9_fid_create(clnt
);
764 req
= p9_client_rpc(clnt
, P9_TATTACH
, "ddss?d", fid
->fid
,
765 afid
? afid
->fid
: P9_NOFID
, uname
, aname
, n_uname
);
771 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "Q", &qid
);
773 p9pdu_dump(1, req
->rc
);
774 p9_free_req(clnt
, req
);
778 P9_DPRINTK(P9_DEBUG_9P
, "<<< RATTACH qid %x.%llx.%x\n",
780 (unsigned long long)qid
.path
,
783 memmove(&fid
->qid
, &qid
, sizeof(struct p9_qid
));
785 p9_free_req(clnt
, req
);
793 EXPORT_SYMBOL(p9_client_attach
);
796 p9_client_auth(struct p9_client
*clnt
, char *uname
, u32 n_uname
, char *aname
)
799 struct p9_req_t
*req
;
803 P9_DPRINTK(P9_DEBUG_9P
, ">>> TAUTH uname %s aname %s\n", uname
, aname
);
806 afid
= p9_fid_create(clnt
);
813 req
= p9_client_rpc(clnt
, P9_TAUTH
, "dss?d",
814 afid
? afid
->fid
: P9_NOFID
, uname
, aname
, n_uname
);
820 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "Q", &qid
);
822 p9pdu_dump(1, req
->rc
);
823 p9_free_req(clnt
, req
);
827 P9_DPRINTK(P9_DEBUG_9P
, "<<< RAUTH qid %x.%llx.%x\n",
829 (unsigned long long)qid
.path
,
832 memmove(&afid
->qid
, &qid
, sizeof(struct p9_qid
));
833 p9_free_req(clnt
, req
);
838 p9_fid_destroy(afid
);
841 EXPORT_SYMBOL(p9_client_auth
);
843 struct p9_fid
*p9_client_walk(struct p9_fid
*oldfid
, int nwname
, char **wnames
,
847 struct p9_client
*clnt
;
849 struct p9_qid
*wqids
;
850 struct p9_req_t
*req
;
851 int16_t nwqids
, count
;
856 fid
= p9_fid_create(clnt
);
863 fid
->uid
= oldfid
->uid
;
868 P9_DPRINTK(P9_DEBUG_9P
, ">>> TWALK fids %d,%d nwname %d wname[0] %s\n",
869 oldfid
->fid
, fid
->fid
, nwname
, wnames
? wnames
[0] : NULL
);
871 req
= p9_client_rpc(clnt
, P9_TWALK
, "ddT", oldfid
->fid
, fid
->fid
,
878 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "R", &nwqids
, &wqids
);
880 p9pdu_dump(1, req
->rc
);
881 p9_free_req(clnt
, req
);
884 p9_free_req(clnt
, req
);
886 P9_DPRINTK(P9_DEBUG_9P
, "<<< RWALK nwqid %d:\n", nwqids
);
888 if (nwqids
!= nwname
) {
893 for (count
= 0; count
< nwqids
; count
++)
894 P9_DPRINTK(P9_DEBUG_9P
, "<<< [%d] %x.%llx.%x\n",
895 count
, wqids
[count
].type
,
896 (unsigned long long)wqids
[count
].path
,
897 wqids
[count
].version
);
900 memmove(&fid
->qid
, &wqids
[nwqids
- 1], sizeof(struct p9_qid
));
902 fid
->qid
= oldfid
->qid
;
907 p9_client_clunk(fid
);
911 if (fid
&& (fid
!= oldfid
))
916 EXPORT_SYMBOL(p9_client_walk
);
918 int p9_client_open(struct p9_fid
*fid
, int mode
)
921 struct p9_client
*clnt
;
922 struct p9_req_t
*req
;
926 P9_DPRINTK(P9_DEBUG_9P
, ">>> TOPEN fid %d mode %d\n", fid
->fid
, mode
);
933 req
= p9_client_rpc(clnt
, P9_TOPEN
, "db", fid
->fid
, mode
);
939 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "Qd", &qid
, &iounit
);
941 p9pdu_dump(1, req
->rc
);
945 P9_DPRINTK(P9_DEBUG_9P
, "<<< ROPEN qid %x.%llx.%x iounit %x\n",
947 (unsigned long long)qid
.path
,
948 qid
.version
, iounit
);
951 fid
->iounit
= iounit
;
954 p9_free_req(clnt
, req
);
958 EXPORT_SYMBOL(p9_client_open
);
960 int p9_client_fcreate(struct p9_fid
*fid
, char *name
, u32 perm
, int mode
,
964 struct p9_client
*clnt
;
965 struct p9_req_t
*req
;
969 P9_DPRINTK(P9_DEBUG_9P
, ">>> TCREATE fid %d name %s perm %d mode %d\n",
970 fid
->fid
, name
, perm
, mode
);
977 req
= p9_client_rpc(clnt
, P9_TCREATE
, "dsdb?s", fid
->fid
, name
, perm
,
984 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "Qd", &qid
, &iounit
);
986 p9pdu_dump(1, req
->rc
);
990 P9_DPRINTK(P9_DEBUG_9P
, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
992 (unsigned long long)qid
.path
,
993 qid
.version
, iounit
);
996 fid
->iounit
= iounit
;
999 p9_free_req(clnt
, req
);
1003 EXPORT_SYMBOL(p9_client_fcreate
);
1005 int p9_client_clunk(struct p9_fid
*fid
)
1008 struct p9_client
*clnt
;
1009 struct p9_req_t
*req
;
1011 P9_DPRINTK(P9_DEBUG_9P
, ">>> TCLUNK fid %d\n", fid
->fid
);
1015 req
= p9_client_rpc(clnt
, P9_TCLUNK
, "d", fid
->fid
);
1021 P9_DPRINTK(P9_DEBUG_9P
, "<<< RCLUNK fid %d\n", fid
->fid
);
1023 p9_free_req(clnt
, req
);
1024 p9_fid_destroy(fid
);
1029 EXPORT_SYMBOL(p9_client_clunk
);
1031 int p9_client_remove(struct p9_fid
*fid
)
1034 struct p9_client
*clnt
;
1035 struct p9_req_t
*req
;
1037 P9_DPRINTK(P9_DEBUG_9P
, ">>> TREMOVE fid %d\n", fid
->fid
);
1041 req
= p9_client_rpc(clnt
, P9_TREMOVE
, "d", fid
->fid
);
1047 P9_DPRINTK(P9_DEBUG_9P
, "<<< RREMOVE fid %d\n", fid
->fid
);
1049 p9_free_req(clnt
, req
);
1050 p9_fid_destroy(fid
);
1055 EXPORT_SYMBOL(p9_client_remove
);
1058 p9_client_read(struct p9_fid
*fid
, char *data
, char __user
*udata
, u64 offset
,
1061 int err
, rsize
, total
;
1062 struct p9_client
*clnt
;
1063 struct p9_req_t
*req
;
1066 P9_DPRINTK(P9_DEBUG_9P
, ">>> TREAD fid %d offset %llu %d\n", fid
->fid
,
1067 (long long unsigned) offset
, count
);
1072 rsize
= fid
->iounit
;
1073 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1074 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1079 req
= p9_client_rpc(clnt
, P9_TREAD
, "dqd", fid
->fid
, offset
, rsize
);
1085 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "D", &count
, &dataptr
);
1087 p9pdu_dump(1, req
->rc
);
1088 goto free_and_error
;
1091 P9_DPRINTK(P9_DEBUG_9P
, "<<< RREAD count %d\n", count
);
1094 memmove(data
, dataptr
, count
);
1098 err
= copy_to_user(udata
, dataptr
, count
);
1101 goto free_and_error
;
1105 p9_free_req(clnt
, req
);
1109 p9_free_req(clnt
, req
);
1113 EXPORT_SYMBOL(p9_client_read
);
1116 p9_client_write(struct p9_fid
*fid
, char *data
, const char __user
*udata
,
1117 u64 offset
, u32 count
)
1119 int err
, rsize
, total
;
1120 struct p9_client
*clnt
;
1121 struct p9_req_t
*req
;
1123 P9_DPRINTK(P9_DEBUG_9P
, ">>> TWRITE fid %d offset %llu count %d\n",
1124 fid
->fid
, (long long unsigned) offset
, count
);
1129 rsize
= fid
->iounit
;
1130 if (!rsize
|| rsize
> clnt
->msize
-P9_IOHDRSZ
)
1131 rsize
= clnt
->msize
- P9_IOHDRSZ
;
1136 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqD", fid
->fid
, offset
,
1139 req
= p9_client_rpc(clnt
, P9_TWRITE
, "dqU", fid
->fid
, offset
,
1146 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "d", &count
);
1148 p9pdu_dump(1, req
->rc
);
1149 goto free_and_error
;
1152 P9_DPRINTK(P9_DEBUG_9P
, "<<< RWRITE count %d\n", count
);
1154 p9_free_req(clnt
, req
);
1158 p9_free_req(clnt
, req
);
1162 EXPORT_SYMBOL(p9_client_write
);
1164 struct p9_wstat
*p9_client_stat(struct p9_fid
*fid
)
1167 struct p9_client
*clnt
;
1168 struct p9_wstat
*ret
= kmalloc(sizeof(struct p9_wstat
), GFP_KERNEL
);
1169 struct p9_req_t
*req
;
1172 P9_DPRINTK(P9_DEBUG_9P
, ">>> TSTAT fid %d\n", fid
->fid
);
1175 return ERR_PTR(-ENOMEM
);
1180 req
= p9_client_rpc(clnt
, P9_TSTAT
, "d", fid
->fid
);
1186 err
= p9pdu_readf(req
->rc
, clnt
->dotu
, "wS", &ignored
, ret
);
1188 p9pdu_dump(1, req
->rc
);
1189 p9_free_req(clnt
, req
);
1193 P9_DPRINTK(P9_DEBUG_9P
,
1194 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1195 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1196 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1197 "<<< uid=%d gid=%d n_muid=%d\n",
1198 ret
->size
, ret
->type
, ret
->dev
, ret
->qid
.type
,
1199 (unsigned long long)ret
->qid
.path
, ret
->qid
.version
, ret
->mode
,
1200 ret
->atime
, ret
->mtime
, (unsigned long long)ret
->length
,
1201 ret
->name
, ret
->uid
, ret
->gid
, ret
->muid
, ret
->extension
,
1202 ret
->n_uid
, ret
->n_gid
, ret
->n_muid
);
1204 p9_free_req(clnt
, req
);
1209 return ERR_PTR(err
);
1211 EXPORT_SYMBOL(p9_client_stat
);
1213 static int p9_client_statsize(struct p9_wstat
*wst
, int optional
)
1217 /* size[2] type[2] dev[4] qid[13] */
1218 /* mode[4] atime[4] mtime[4] length[8]*/
1219 /* name[s] uid[s] gid[s] muid[s] */
1220 ret
= 2+2+4+13+4+4+4+8+2+2+2+2;
1223 ret
+= strlen(wst
->name
);
1225 ret
+= strlen(wst
->uid
);
1227 ret
+= strlen(wst
->gid
);
1229 ret
+= strlen(wst
->muid
);
1232 ret
+= 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1234 ret
+= strlen(wst
->extension
);
1240 int p9_client_wstat(struct p9_fid
*fid
, struct p9_wstat
*wst
)
1243 struct p9_req_t
*req
;
1244 struct p9_client
*clnt
;
1248 wst
->size
= p9_client_statsize(wst
, clnt
->dotu
);
1249 P9_DPRINTK(P9_DEBUG_9P
, ">>> TWSTAT fid %d\n", fid
->fid
);
1250 P9_DPRINTK(P9_DEBUG_9P
,
1251 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1252 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1253 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1254 " uid=%d gid=%d n_muid=%d\n",
1255 wst
->size
, wst
->type
, wst
->dev
, wst
->qid
.type
,
1256 (unsigned long long)wst
->qid
.path
, wst
->qid
.version
, wst
->mode
,
1257 wst
->atime
, wst
->mtime
, (unsigned long long)wst
->length
,
1258 wst
->name
, wst
->uid
, wst
->gid
, wst
->muid
, wst
->extension
,
1259 wst
->n_uid
, wst
->n_gid
, wst
->n_muid
);
1261 req
= p9_client_rpc(clnt
, P9_TWSTAT
, "dwS", fid
->fid
, wst
->size
, wst
);
1267 P9_DPRINTK(P9_DEBUG_9P
, "<<< RWSTAT fid %d\n", fid
->fid
);
1269 p9_free_req(clnt
, req
);
1273 EXPORT_SYMBOL(p9_client_wstat
);
This page took 0.057453 seconds and 6 git commands to generate.