?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 5.1-rc1
[linux/fpc-iii.git] / net / 9p / client.c
blobb85d51f4b8ebe969e167f03379084633e34b1549
1 /*
2 * net/9p/clnt.c
3 *
4 * 9P Client
5 *
6 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
8 *
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.
12 *
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.
17 *
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
23 *
24 */
25
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28 #include <linux/module.h>
29 #include <linux/errno.h>
30 #include <linux/fs.h>
31 #include <linux/poll.h>
32 #include <linux/idr.h>
33 #include <linux/mutex.h>
34 #include <linux/slab.h>
35 #include <linux/sched/signal.h>
36 #include <linux/uaccess.h>
37 #include <linux/uio.h>
38 #include <net/9p/9p.h>
39 #include <linux/parser.h>
40 #include <linux/seq_file.h>
41 #include <net/9p/client.h>
42 #include <net/9p/transport.h>
43 #include "protocol.h"
44
45 #define CREATE_TRACE_POINTS
46 #include <trace/events/9p.h>
47
48 /*
49 * Client Option Parsing (code inspired by NFS code)
50 * - a little lazy - parse all client options
51 */
52
53 enum {
54 Opt_msize,
55 Opt_trans,
56 Opt_legacy,
57 Opt_version,
58 Opt_err,
59 };
60
61 static const match_table_t tokens = {
62 {Opt_msize, "msize=%u"},
63 {Opt_legacy, "noextend"},
64 {Opt_trans, "trans=%s"},
65 {Opt_version, "version=%s"},
66 {Opt_err, NULL},
67 };
68
69 inline int p9_is_proto_dotl(struct p9_client *clnt)
70 {
71 return clnt->proto_version == p9_proto_2000L;
72 }
73 EXPORT_SYMBOL(p9_is_proto_dotl);
74
75 inline int p9_is_proto_dotu(struct p9_client *clnt)
76 {
77 return clnt->proto_version == p9_proto_2000u;
78 }
79 EXPORT_SYMBOL(p9_is_proto_dotu);
80
81 int p9_show_client_options(struct seq_file *m, struct p9_client *clnt)
82 {
83 if (clnt->msize != 8192)
84 seq_printf(m, ",msize=%u", clnt->msize);
85 seq_printf(m, ",trans=%s", clnt->trans_mod->name);
86
87 switch (clnt->proto_version) {
88 case p9_proto_legacy:
89 seq_puts(m, ",noextend");
90 break;
91 case p9_proto_2000u:
92 seq_puts(m, ",version=9p2000.u");
93 break;
94 case p9_proto_2000L:
95 /* Default */
96 break;
97 }
98
99 if (clnt->trans_mod->show_options)
100 return clnt->trans_mod->show_options(m, clnt);
101 return 0;
102 }
103 EXPORT_SYMBOL(p9_show_client_options);
104
105 /*
106 * Some error codes are taken directly from the server replies,
107 * make sure they are valid.
108 */
109 static int safe_errno(int err)
110 {
111 if ((err > 0) || (err < -MAX_ERRNO)) {
112 p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err);
113 return -EPROTO;
114 }
115 return err;
116 }
117
118
119 /* Interpret mount option for protocol version */
120 static int get_protocol_version(char *s)
121 {
122 int version = -EINVAL;
123
124 if (!strcmp(s, "9p2000")) {
125 version = p9_proto_legacy;
126 p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n");
127 } else if (!strcmp(s, "9p2000.u")) {
128 version = p9_proto_2000u;
129 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
130 } else if (!strcmp(s, "9p2000.L")) {
131 version = p9_proto_2000L;
132 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
133 } else
134 pr_info("Unknown protocol version %s\n", s);
135
136 return version;
137 }
138
139 /**
140 * parse_options - parse mount options into client structure
141 * @opts: options string passed from mount
142 * @clnt: existing v9fs client information
143 *
144 * Return 0 upon success, -ERRNO upon failure
145 */
146
147 static int parse_opts(char *opts, struct p9_client *clnt)
148 {
149 char *options, *tmp_options;
150 char *p;
151 substring_t args[MAX_OPT_ARGS];
152 int option;
153 char *s;
154 int ret = 0;
155
156 clnt->proto_version = p9_proto_2000L;
157 clnt->msize = 8192;
158
159 if (!opts)
160 return 0;
161
162 tmp_options = kstrdup(opts, GFP_KERNEL);
163 if (!tmp_options) {
164 p9_debug(P9_DEBUG_ERROR,
165 "failed to allocate copy of option string\n");
166 return -ENOMEM;
167 }
168 options = tmp_options;
169
170 while ((p = strsep(&options, ",")) != NULL) {
171 int token, r;
172 if (!*p)
173 continue;
174 token = match_token(p, tokens, args);
175 switch (token) {
176 case Opt_msize:
177 r = match_int(&args[0], &option);
178 if (r < 0) {
179 p9_debug(P9_DEBUG_ERROR,
180 "integer field, but no integer?\n");
181 ret = r;
182 continue;
183 }
184 if (option < 4096) {
185 p9_debug(P9_DEBUG_ERROR,
186 "msize should be at least 4k\n");
187 ret = -EINVAL;
188 continue;
189 }
190 clnt->msize = option;
191 break;
192 case Opt_trans:
193 s = match_strdup(&args[0]);
194 if (!s) {
195 ret = -ENOMEM;
196 p9_debug(P9_DEBUG_ERROR,
197 "problem allocating copy of trans arg\n");
198 goto free_and_return;
199 }
200
201 v9fs_put_trans(clnt->trans_mod);
202 clnt->trans_mod = v9fs_get_trans_by_name(s);
203 if (clnt->trans_mod == NULL) {
204 pr_info("Could not find request transport: %s\n",
205 s);
206 ret = -EINVAL;
207 }
208 kfree(s);
209 break;
210 case Opt_legacy:
211 clnt->proto_version = p9_proto_legacy;
212 break;
213 case Opt_version:
214 s = match_strdup(&args[0]);
215 if (!s) {
216 ret = -ENOMEM;
217 p9_debug(P9_DEBUG_ERROR,
218 "problem allocating copy of version arg\n");
219 goto free_and_return;
220 }
221 r = get_protocol_version(s);
222 if (r < 0)
223 ret = r;
224 else
225 clnt->proto_version = r;
226 kfree(s);
227 break;
228 default:
229 continue;
230 }
231 }
232
233 free_and_return:
234 if (ret)
235 v9fs_put_trans(clnt->trans_mod);
236 kfree(tmp_options);
237 return ret;
238 }
239
240 static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc,
241 int alloc_msize)
242 {
243 if (likely(c->fcall_cache) && alloc_msize == c->msize) {
244 fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS);
245 fc->cache = c->fcall_cache;
246 } else {
247 fc->sdata = kmalloc(alloc_msize, GFP_NOFS);
248 fc->cache = NULL;
249 }
250 if (!fc->sdata)
251 return -ENOMEM;
252 fc->capacity = alloc_msize;
253 return 0;
254 }
255
256 void p9_fcall_fini(struct p9_fcall *fc)
257 {
258 /* sdata can be NULL for interrupted requests in trans_rdma,
259 * and kmem_cache_free does not do NULL-check for us
260 */
261 if (unlikely(!fc->sdata))
262 return;
263
264 if (fc->cache)
265 kmem_cache_free(fc->cache, fc->sdata);
266 else
267 kfree(fc->sdata);
268 }
269 EXPORT_SYMBOL(p9_fcall_fini);
270
271 static struct kmem_cache *p9_req_cache;
272
273 /**
274 * p9_req_alloc - Allocate a new request.
275 * @c: Client session.
276 * @type: Transaction type.
277 * @max_size: Maximum packet size for this request.
278 *
279 * Context: Process context.
280 * Return: Pointer to new request.
281 */
282 static struct p9_req_t *
283 p9_tag_alloc(struct p9_client *c, int8_t type, unsigned int max_size)
284 {
285 struct p9_req_t *req = kmem_cache_alloc(p9_req_cache, GFP_NOFS);
286 int alloc_msize = min(c->msize, max_size);
287 int tag;
288
289 if (!req)
290 return ERR_PTR(-ENOMEM);
291
292 if (p9_fcall_init(c, &req->tc, alloc_msize))
293 goto free_req;
294 if (p9_fcall_init(c, &req->rc, alloc_msize))
295 goto free;
296
297 p9pdu_reset(&req->tc);
298 p9pdu_reset(&req->rc);
299 req->status = REQ_STATUS_ALLOC;
300 init_waitqueue_head(&req->wq);
301 INIT_LIST_HEAD(&req->req_list);
302
303 idr_preload(GFP_NOFS);
304 spin_lock_irq(&c->lock);
305 if (type == P9_TVERSION)
306 tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1,
307 GFP_NOWAIT);
308 else
309 tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT);
310 req->tc.tag = tag;
311 spin_unlock_irq(&c->lock);
312 idr_preload_end();
313 if (tag < 0)
314 goto free;
315
316 /* Init ref to two because in the general case there is one ref
317 * that is put asynchronously by a writer thread, one ref
318 * temporarily given by p9_tag_lookup and put by p9_client_cb
319 * in the recv thread, and one ref put by p9_tag_remove in the
320 * main thread. The only exception is virtio that does not use
321 * p9_tag_lookup but does not have a writer thread either
322 * (the write happens synchronously in the request/zc_request
323 * callback), so p9_client_cb eats the second ref there
324 * as the pointer is duplicated directly by virtqueue_add_sgs()
325 */
326 refcount_set(&req->refcount.refcount, 2);
327
328 return req;
329
330 free:
331 p9_fcall_fini(&req->tc);
332 p9_fcall_fini(&req->rc);
333 free_req:
334 kmem_cache_free(p9_req_cache, req);
335 return ERR_PTR(-ENOMEM);
336 }
337
338 /**
339 * p9_tag_lookup - Look up a request by tag.
340 * @c: Client session.
341 * @tag: Transaction ID.
342 *
343 * Context: Any context.
344 * Return: A request, or %NULL if there is no request with that tag.
345 */
346 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
347 {
348 struct p9_req_t *req;
349
350 rcu_read_lock();
351 again:
352 req = idr_find(&c->reqs, tag);
353 if (req) {
354 /* We have to be careful with the req found under rcu_read_lock
355 * Thanks to SLAB_TYPESAFE_BY_RCU we can safely try to get the
356 * ref again without corrupting other data, then check again
357 * that the tag matches once we have the ref
358 */
359 if (!p9_req_try_get(req))
360 goto again;
361 if (req->tc.tag != tag) {
362 p9_req_put(req);
363 goto again;
364 }
365 }
366 rcu_read_unlock();
367
368 return req;
369 }
370 EXPORT_SYMBOL(p9_tag_lookup);
371
372 /**
373 * p9_tag_remove - Remove a tag.
374 * @c: Client session.
375 * @r: Request of reference.
376 *
377 * Context: Any context.
378 */
379 static int p9_tag_remove(struct p9_client *c, struct p9_req_t *r)
380 {
381 unsigned long flags;
382 u16 tag = r->tc.tag;
383
384 p9_debug(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
385 spin_lock_irqsave(&c->lock, flags);
386 idr_remove(&c->reqs, tag);
387 spin_unlock_irqrestore(&c->lock, flags);
388 return p9_req_put(r);
389 }
390
391 static void p9_req_free(struct kref *ref)
392 {
393 struct p9_req_t *r = container_of(ref, struct p9_req_t, refcount);
394 p9_fcall_fini(&r->tc);
395 p9_fcall_fini(&r->rc);
396 kmem_cache_free(p9_req_cache, r);
397 }
398
399 int p9_req_put(struct p9_req_t *r)
400 {
401 return kref_put(&r->refcount, p9_req_free);
402 }
403 EXPORT_SYMBOL(p9_req_put);
404
405 /**
406 * p9_tag_cleanup - cleans up tags structure and reclaims resources
407 * @c: v9fs client struct
408 *
409 * This frees resources associated with the tags structure
410 *
411 */
412 static void p9_tag_cleanup(struct p9_client *c)
413 {
414 struct p9_req_t *req;
415 int id;
416
417 rcu_read_lock();
418 idr_for_each_entry(&c->reqs, req, id) {
419 pr_info("Tag %d still in use\n", id);
420 if (p9_tag_remove(c, req) == 0)
421 pr_warn("Packet with tag %d has still references",
422 req->tc.tag);
423 }
424 rcu_read_unlock();
425 }
426
427 /**
428 * p9_client_cb - call back from transport to client
429 * c: client state
430 * req: request received
431 *
432 */
433 void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status)
434 {
435 p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag);
436
437 /*
438 * This barrier is needed to make sure any change made to req before
439 * the status change is visible to another thread
440 */
441 smp_wmb();
442 req->status = status;
443
444 wake_up(&req->wq);
445 p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag);
446 p9_req_put(req);
447 }
448 EXPORT_SYMBOL(p9_client_cb);
449
450 /**
451 * p9_parse_header - parse header arguments out of a packet
452 * @pdu: packet to parse
453 * @size: size of packet
454 * @type: type of request
455 * @tag: tag of packet
456 * @rewind: set if we need to rewind offset afterwards
457 */
458
459 int
460 p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
461 int rewind)
462 {
463 int8_t r_type;
464 int16_t r_tag;
465 int32_t r_size;
466 int offset = pdu->offset;
467 int err;
468
469 pdu->offset = 0;
470
471 err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
472 if (err)
473 goto rewind_and_exit;
474
475 if (type)
476 *type = r_type;
477 if (tag)
478 *tag = r_tag;
479 if (size)
480 *size = r_size;
481
482 if (pdu->size != r_size || r_size < 7) {
483 err = -EINVAL;
484 goto rewind_and_exit;
485 }
486
487 pdu->id = r_type;
488 pdu->tag = r_tag;
489
490 p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n",
491 pdu->size, pdu->id, pdu->tag);
492
493 rewind_and_exit:
494 if (rewind)
495 pdu->offset = offset;
496 return err;
497 }
498 EXPORT_SYMBOL(p9_parse_header);
499
500 /**
501 * p9_check_errors - check 9p packet for error return and process it
502 * @c: current client instance
503 * @req: request to parse and check for error conditions
504 *
505 * returns error code if one is discovered, otherwise returns 0
506 *
507 * this will have to be more complicated if we have multiple
508 * error packet types
509 */
510
511 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
512 {
513 int8_t type;
514 int err;
515 int ecode;
516
517 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
518 if (req->rc.size >= c->msize) {
519 p9_debug(P9_DEBUG_ERROR,
520 "requested packet size too big: %d\n",
521 req->rc.size);
522 return -EIO;
523 }
524 /*
525 * dump the response from server
526 * This should be after check errors which poplulate pdu_fcall.
527 */
528 trace_9p_protocol_dump(c, &req->rc);
529 if (err) {
530 p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
531 return err;
532 }
533 if (type != P9_RERROR && type != P9_RLERROR)
534 return 0;
535
536 if (!p9_is_proto_dotl(c)) {
537 char *ename;
538 err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
539 &ename, &ecode);
540 if (err)
541 goto out_err;
542
543 if (p9_is_proto_dotu(c) && ecode < 512)
544 err = -ecode;
545
546 if (!err) {
547 err = p9_errstr2errno(ename, strlen(ename));
548
549 p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
550 -ecode, ename);
551 }
552 kfree(ename);
553 } else {
554 err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode);
555 err = -ecode;
556
557 p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
558 }
559
560 return err;
561
562 out_err:
563 p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
564
565 return err;
566 }
567
568 /**
569 * p9_check_zc_errors - check 9p packet for error return and process it
570 * @c: current client instance
571 * @req: request to parse and check for error conditions
572 * @in_hdrlen: Size of response protocol buffer.
573 *
574 * returns error code if one is discovered, otherwise returns 0
575 *
576 * this will have to be more complicated if we have multiple
577 * error packet types
578 */
579
580 static int p9_check_zc_errors(struct p9_client *c, struct p9_req_t *req,
581 struct iov_iter *uidata, int in_hdrlen)
582 {
583 int err;
584 int ecode;
585 int8_t type;
586 char *ename = NULL;
587
588 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
589 /*
590 * dump the response from server
591 * This should be after parse_header which poplulate pdu_fcall.
592 */
593 trace_9p_protocol_dump(c, &req->rc);
594 if (err) {
595 p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
596 return err;
597 }
598
599 if (type != P9_RERROR && type != P9_RLERROR)
600 return 0;
601
602 if (!p9_is_proto_dotl(c)) {
603 /* Error is reported in string format */
604 int len;
605 /* 7 = header size for RERROR; */
606 int inline_len = in_hdrlen - 7;
607
608 len = req->rc.size - req->rc.offset;
609 if (len > (P9_ZC_HDR_SZ - 7)) {
610 err = -EFAULT;
611 goto out_err;
612 }
613
614 ename = &req->rc.sdata[req->rc.offset];
615 if (len > inline_len) {
616 /* We have error in external buffer */
617 if (!copy_from_iter_full(ename + inline_len,
618 len - inline_len, uidata)) {
619 err = -EFAULT;
620 goto out_err;
621 }
622 }
623 ename = NULL;
624 err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
625 &ename, &ecode);
626 if (err)
627 goto out_err;
628
629 if (p9_is_proto_dotu(c) && ecode < 512)
630 err = -ecode;
631
632 if (!err) {
633 err = p9_errstr2errno(ename, strlen(ename));
634
635 p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
636 -ecode, ename);
637 }
638 kfree(ename);
639 } else {
640 err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode);
641 err = -ecode;
642
643 p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
644 }
645 return err;
646
647 out_err:
648 p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
649 return err;
650 }
651
652 static struct p9_req_t *
653 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
654
655 /**
656 * p9_client_flush - flush (cancel) a request
657 * @c: client state
658 * @oldreq: request to cancel
659 *
660 * This sents a flush for a particular request and links
661 * the flush request to the original request. The current
662 * code only supports a single flush request although the protocol
663 * allows for multiple flush requests to be sent for a single request.
664 *
665 */
666
667 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
668 {
669 struct p9_req_t *req;
670 int16_t oldtag;
671 int err;
672
673 err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1);
674 if (err)
675 return err;
676
677 p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
678
679 req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
680 if (IS_ERR(req))
681 return PTR_ERR(req);
682
683 /*
684 * if we haven't received a response for oldreq,
685 * remove it from the list
686 */
687 if (oldreq->status == REQ_STATUS_SENT) {
688 if (c->trans_mod->cancelled)
689 c->trans_mod->cancelled(c, oldreq);
690 }
691
692 p9_tag_remove(c, req);
693 return 0;
694 }
695
696 static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
697 int8_t type, int req_size,
698 const char *fmt, va_list ap)
699 {
700 int err;
701 struct p9_req_t *req;
702
703 p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type);
704
705 /* we allow for any status other than disconnected */
706 if (c->status == Disconnected)
707 return ERR_PTR(-EIO);
708
709 /* if status is begin_disconnected we allow only clunk request */
710 if ((c->status == BeginDisconnect) && (type != P9_TCLUNK))
711 return ERR_PTR(-EIO);
712
713 req = p9_tag_alloc(c, type, req_size);
714 if (IS_ERR(req))
715 return req;
716
717 /* marshall the data */
718 p9pdu_prepare(&req->tc, req->tc.tag, type);
719 err = p9pdu_vwritef(&req->tc, c->proto_version, fmt, ap);
720 if (err)
721 goto reterr;
722 p9pdu_finalize(c, &req->tc);
723 trace_9p_client_req(c, type, req->tc.tag);
724 return req;
725 reterr:
726 p9_tag_remove(c, req);
727 /* We have to put also the 2nd reference as it won't be used */
728 p9_req_put(req);
729 return ERR_PTR(err);
730 }
731
732 /**
733 * p9_client_rpc - issue a request and wait for a response
734 * @c: client session
735 * @type: type of request
736 * @fmt: protocol format string (see protocol.c)
737 *
738 * Returns request structure (which client must free using p9_tag_remove)
739 */
740
741 static struct p9_req_t *
742 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
743 {
744 va_list ap;
745 int sigpending, err;
746 unsigned long flags;
747 struct p9_req_t *req;
748
749 va_start(ap, fmt);
750 req = p9_client_prepare_req(c, type, c->msize, fmt, ap);
751 va_end(ap);
752 if (IS_ERR(req))
753 return req;
754
755 if (signal_pending(current)) {
756 sigpending = 1;
757 clear_thread_flag(TIF_SIGPENDING);
758 } else
759 sigpending = 0;
760
761 err = c->trans_mod->request(c, req);
762 if (err < 0) {
763 /* write won't happen */
764 p9_req_put(req);
765 if (err != -ERESTARTSYS && err != -EFAULT)
766 c->status = Disconnected;
767 goto recalc_sigpending;
768 }
769 again:
770 /* Wait for the response */
771 err = wait_event_killable(req->wq, req->status >= REQ_STATUS_RCVD);
772
773 /*
774 * Make sure our req is coherent with regard to updates in other
775 * threads - echoes to wmb() in the callback
776 */
777 smp_rmb();
778
779 if ((err == -ERESTARTSYS) && (c->status == Connected)
780 && (type == P9_TFLUSH)) {
781 sigpending = 1;
782 clear_thread_flag(TIF_SIGPENDING);
783 goto again;
784 }
785
786 if (req->status == REQ_STATUS_ERROR) {
787 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
788 err = req->t_err;
789 }
790 if ((err == -ERESTARTSYS) && (c->status == Connected)) {
791 p9_debug(P9_DEBUG_MUX, "flushing\n");
792 sigpending = 1;
793 clear_thread_flag(TIF_SIGPENDING);
794
795 if (c->trans_mod->cancel(c, req))
796 p9_client_flush(c, req);
797
798 /* if we received the response anyway, don't signal error */
799 if (req->status == REQ_STATUS_RCVD)
800 err = 0;
801 }
802 recalc_sigpending:
803 if (sigpending) {
804 spin_lock_irqsave(&current->sighand->siglock, flags);
805 recalc_sigpending();
806 spin_unlock_irqrestore(&current->sighand->siglock, flags);
807 }
808 if (err < 0)
809 goto reterr;
810
811 err = p9_check_errors(c, req);
812 trace_9p_client_res(c, type, req->rc.tag, err);
813 if (!err)
814 return req;
815 reterr:
816 p9_tag_remove(c, req);
817 return ERR_PTR(safe_errno(err));
818 }
819
820 /**
821 * p9_client_zc_rpc - issue a request and wait for a response
822 * @c: client session
823 * @type: type of request
824 * @uidata: destination for zero copy read
825 * @uodata: source for zero copy write
826 * @inlen: read buffer size
827 * @olen: write buffer size
828 * @hdrlen: reader header size, This is the size of response protocol data
829 * @fmt: protocol format string (see protocol.c)
830 *
831 * Returns request structure (which client must free using p9_tag_remove)
832 */
833 static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
834 struct iov_iter *uidata,
835 struct iov_iter *uodata,
836 int inlen, int olen, int in_hdrlen,
837 const char *fmt, ...)
838 {
839 va_list ap;
840 int sigpending, err;
841 unsigned long flags;
842 struct p9_req_t *req;
843
844 va_start(ap, fmt);
845 /*
846 * We allocate a inline protocol data of only 4k bytes.
847 * The actual content is passed in zero-copy fashion.
848 */
849 req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, fmt, ap);
850 va_end(ap);
851 if (IS_ERR(req))
852 return req;
853
854 if (signal_pending(current)) {
855 sigpending = 1;
856 clear_thread_flag(TIF_SIGPENDING);
857 } else
858 sigpending = 0;
859
860 err = c->trans_mod->zc_request(c, req, uidata, uodata,
861 inlen, olen, in_hdrlen);
862 if (err < 0) {
863 if (err == -EIO)
864 c->status = Disconnected;
865 if (err != -ERESTARTSYS)
866 goto recalc_sigpending;
867 }
868 if (req->status == REQ_STATUS_ERROR) {
869 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
870 err = req->t_err;
871 }
872 if ((err == -ERESTARTSYS) && (c->status == Connected)) {
873 p9_debug(P9_DEBUG_MUX, "flushing\n");
874 sigpending = 1;
875 clear_thread_flag(TIF_SIGPENDING);
876
877 if (c->trans_mod->cancel(c, req))
878 p9_client_flush(c, req);
879
880 /* if we received the response anyway, don't signal error */
881 if (req->status == REQ_STATUS_RCVD)
882 err = 0;
883 }
884 recalc_sigpending:
885 if (sigpending) {
886 spin_lock_irqsave(&current->sighand->siglock, flags);
887 recalc_sigpending();
888 spin_unlock_irqrestore(&current->sighand->siglock, flags);
889 }
890 if (err < 0)
891 goto reterr;
892
893 err = p9_check_zc_errors(c, req, uidata, in_hdrlen);
894 trace_9p_client_res(c, type, req->rc.tag, err);
895 if (!err)
896 return req;
897 reterr:
898 p9_tag_remove(c, req);
899 return ERR_PTR(safe_errno(err));
900 }
901
902 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
903 {
904 int ret;
905 struct p9_fid *fid;
906
907 p9_debug(P9_DEBUG_FID, "clnt %p\n", clnt);
908 fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
909 if (!fid)
910 return NULL;
911
912 memset(&fid->qid, 0, sizeof(struct p9_qid));
913 fid->mode = -1;
914 fid->uid = current_fsuid();
915 fid->clnt = clnt;
916 fid->rdir = NULL;
917 fid->fid = 0;
918
919 idr_preload(GFP_KERNEL);
920 spin_lock_irq(&clnt->lock);
921 ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1,
922 GFP_NOWAIT);
923 spin_unlock_irq(&clnt->lock);
924 idr_preload_end();
925
926 if (!ret)
927 return fid;
928
929 kfree(fid);
930 return NULL;
931 }
932
933 static void p9_fid_destroy(struct p9_fid *fid)
934 {
935 struct p9_client *clnt;
936 unsigned long flags;
937
938 p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid);
939 clnt = fid->clnt;
940 spin_lock_irqsave(&clnt->lock, flags);
941 idr_remove(&clnt->fids, fid->fid);
942 spin_unlock_irqrestore(&clnt->lock, flags);
943 kfree(fid->rdir);
944 kfree(fid);
945 }
946
947 static int p9_client_version(struct p9_client *c)
948 {
949 int err = 0;
950 struct p9_req_t *req;
951 char *version = NULL;
952 int msize;
953
954 p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
955 c->msize, c->proto_version);
956
957 switch (c->proto_version) {
958 case p9_proto_2000L:
959 req = p9_client_rpc(c, P9_TVERSION, "ds",
960 c->msize, "9P2000.L");
961 break;
962 case p9_proto_2000u:
963 req = p9_client_rpc(c, P9_TVERSION, "ds",
964 c->msize, "9P2000.u");
965 break;
966 case p9_proto_legacy:
967 req = p9_client_rpc(c, P9_TVERSION, "ds",
968 c->msize, "9P2000");
969 break;
970 default:
971 return -EINVAL;
972 }
973
974 if (IS_ERR(req))
975 return PTR_ERR(req);
976
977 err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version);
978 if (err) {
979 p9_debug(P9_DEBUG_9P, "version error %d\n", err);
980 trace_9p_protocol_dump(c, &req->rc);
981 goto error;
982 }
983
984 p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
985 if (!strncmp(version, "9P2000.L", 8))
986 c->proto_version = p9_proto_2000L;
987 else if (!strncmp(version, "9P2000.u", 8))
988 c->proto_version = p9_proto_2000u;
989 else if (!strncmp(version, "9P2000", 6))
990 c->proto_version = p9_proto_legacy;
991 else {
992 p9_debug(P9_DEBUG_ERROR,
993 "server returned an unknown version: %s\n", version);
994 err = -EREMOTEIO;
995 goto error;
996 }
997
998 if (msize < 4096) {
999 p9_debug(P9_DEBUG_ERROR,
1000 "server returned a msize < 4096: %d\n", msize);
1001 err = -EREMOTEIO;
1002 goto error;
1003 }
1004 if (msize < c->msize)
1005 c->msize = msize;
1006
1007 error:
1008 kfree(version);
1009 p9_tag_remove(c, req);
1010
1011 return err;
1012 }
1013
1014 struct p9_client *p9_client_create(const char *dev_name, char *options)
1015 {
1016 int err;
1017 struct p9_client *clnt;
1018 char *client_id;
1019
1020 err = 0;
1021 clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
1022 if (!clnt)
1023 return ERR_PTR(-ENOMEM);
1024
1025 clnt->trans_mod = NULL;
1026 clnt->trans = NULL;
1027 clnt->fcall_cache = NULL;
1028
1029 client_id = utsname()->nodename;
1030 memcpy(clnt->name, client_id, strlen(client_id) + 1);
1031
1032 spin_lock_init(&clnt->lock);
1033 idr_init(&clnt->fids);
1034 idr_init(&clnt->reqs);
1035
1036 err = parse_opts(options, clnt);
1037 if (err < 0)
1038 goto free_client;
1039
1040 if (!clnt->trans_mod)
1041 clnt->trans_mod = v9fs_get_default_trans();
1042
1043 if (clnt->trans_mod == NULL) {
1044 err = -EPROTONOSUPPORT;
1045 p9_debug(P9_DEBUG_ERROR,
1046 "No transport defined or default transport\n");
1047 goto free_client;
1048 }
1049
1050 p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
1051 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
1052
1053 err = clnt->trans_mod->create(clnt, dev_name, options);
1054 if (err)
1055 goto put_trans;
1056
1057 if (clnt->msize > clnt->trans_mod->maxsize)
1058 clnt->msize = clnt->trans_mod->maxsize;
1059
1060 if (clnt->msize < 4096) {
1061 p9_debug(P9_DEBUG_ERROR,
1062 "Please specify a msize of at least 4k\n");
1063 err = -EINVAL;
1064 goto close_trans;
1065 }
1066
1067 err = p9_client_version(clnt);
1068 if (err)
1069 goto close_trans;
1070
1071 /* P9_HDRSZ + 4 is the smallest packet header we can have that is
1072 * followed by data accessed from userspace by read
1073 */
1074 clnt->fcall_cache =
1075 kmem_cache_create_usercopy("9p-fcall-cache", clnt->msize,
1076 0, 0, P9_HDRSZ + 4,
1077 clnt->msize - (P9_HDRSZ + 4),
1078 NULL);
1079
1080 return clnt;
1081
1082 close_trans:
1083 clnt->trans_mod->close(clnt);
1084 put_trans:
1085 v9fs_put_trans(clnt->trans_mod);
1086 free_client:
1087 kfree(clnt);
1088 return ERR_PTR(err);
1089 }
1090 EXPORT_SYMBOL(p9_client_create);
1091
1092 void p9_client_destroy(struct p9_client *clnt)
1093 {
1094 struct p9_fid *fid;
1095 int id;
1096
1097 p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt);
1098
1099 if (clnt->trans_mod)
1100 clnt->trans_mod->close(clnt);
1101
1102 v9fs_put_trans(clnt->trans_mod);
1103
1104 idr_for_each_entry(&clnt->fids, fid, id) {
1105 pr_info("Found fid %d not clunked\n", fid->fid);
1106 p9_fid_destroy(fid);
1107 }
1108
1109 p9_tag_cleanup(clnt);
1110
1111 kmem_cache_destroy(clnt->fcall_cache);
1112 kfree(clnt);
1113 }
1114 EXPORT_SYMBOL(p9_client_destroy);
1115
1116 void p9_client_disconnect(struct p9_client *clnt)
1117 {
1118 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
1119 clnt->status = Disconnected;
1120 }
1121 EXPORT_SYMBOL(p9_client_disconnect);
1122
1123 void p9_client_begin_disconnect(struct p9_client *clnt)
1124 {
1125 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
1126 clnt->status = BeginDisconnect;
1127 }
1128 EXPORT_SYMBOL(p9_client_begin_disconnect);
1129
1130 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
1131 const char *uname, kuid_t n_uname, const char *aname)
1132 {
1133 int err = 0;
1134 struct p9_req_t *req;
1135 struct p9_fid *fid;
1136 struct p9_qid qid;
1137
1138
1139 p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
1140 afid ? afid->fid : -1, uname, aname);
1141 fid = p9_fid_create(clnt);
1142 if (!fid) {
1143 err = -ENOMEM;
1144 goto error;
1145 }
1146 fid->uid = n_uname;
1147
1148 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
1149 afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
1150 if (IS_ERR(req)) {
1151 err = PTR_ERR(req);
1152 goto error;
1153 }
1154
1155 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", &qid);
1156 if (err) {
1157 trace_9p_protocol_dump(clnt, &req->rc);
1158 p9_tag_remove(clnt, req);
1159 goto error;
1160 }
1161
1162 p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
1163 qid.type, (unsigned long long)qid.path, qid.version);
1164
1165 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1166
1167 p9_tag_remove(clnt, req);
1168 return fid;
1169
1170 error:
1171 if (fid)
1172 p9_fid_destroy(fid);
1173 return ERR_PTR(err);
1174 }
1175 EXPORT_SYMBOL(p9_client_attach);
1176
1177 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
1178 const unsigned char * const *wnames, int clone)
1179 {
1180 int err;
1181 struct p9_client *clnt;
1182 struct p9_fid *fid;
1183 struct p9_qid *wqids;
1184 struct p9_req_t *req;
1185 uint16_t nwqids, count;
1186
1187 err = 0;
1188 wqids = NULL;
1189 clnt = oldfid->clnt;
1190 if (clone) {
1191 fid = p9_fid_create(clnt);
1192 if (!fid) {
1193 err = -ENOMEM;
1194 goto error;
1195 }
1196
1197 fid->uid = oldfid->uid;
1198 } else
1199 fid = oldfid;
1200
1201
1202 p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
1203 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
1204
1205 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
1206 nwname, wnames);
1207 if (IS_ERR(req)) {
1208 err = PTR_ERR(req);
1209 goto error;
1210 }
1211
1212 err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids);
1213 if (err) {
1214 trace_9p_protocol_dump(clnt, &req->rc);
1215 p9_tag_remove(clnt, req);
1216 goto clunk_fid;
1217 }
1218 p9_tag_remove(clnt, req);
1219
1220 p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
1221
1222 if (nwqids != nwname) {
1223 err = -ENOENT;
1224 goto clunk_fid;
1225 }
1226
1227 for (count = 0; count < nwqids; count++)
1228 p9_debug(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n",
1229 count, wqids[count].type,
1230 (unsigned long long)wqids[count].path,
1231 wqids[count].version);
1232
1233 if (nwname)
1234 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
1235 else
1236 fid->qid = oldfid->qid;
1237
1238 kfree(wqids);
1239 return fid;
1240
1241 clunk_fid:
1242 kfree(wqids);
1243 p9_client_clunk(fid);
1244 fid = NULL;
1245
1246 error:
1247 if (fid && (fid != oldfid))
1248 p9_fid_destroy(fid);
1249
1250 return ERR_PTR(err);
1251 }
1252 EXPORT_SYMBOL(p9_client_walk);
1253
1254 int p9_client_open(struct p9_fid *fid, int mode)
1255 {
1256 int err;
1257 struct p9_client *clnt;
1258 struct p9_req_t *req;
1259 struct p9_qid qid;
1260 int iounit;
1261
1262 clnt = fid->clnt;
1263 p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
1264 p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
1265 err = 0;
1266
1267 if (fid->mode != -1)
1268 return -EINVAL;
1269
1270 if (p9_is_proto_dotl(clnt))
1271 req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
1272 else
1273 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
1274 if (IS_ERR(req)) {
1275 err = PTR_ERR(req);
1276 goto error;
1277 }
1278
1279 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1280 if (err) {
1281 trace_9p_protocol_dump(clnt, &req->rc);
1282 goto free_and_error;
1283 }
1284
1285 p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
1286 p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN", qid.type,
1287 (unsigned long long)qid.path, qid.version, iounit);
1288
1289 fid->mode = mode;
1290 fid->iounit = iounit;
1291
1292 free_and_error:
1293 p9_tag_remove(clnt, req);
1294 error:
1295 return err;
1296 }
1297 EXPORT_SYMBOL(p9_client_open);
1298
1299 int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags, u32 mode,
1300 kgid_t gid, struct p9_qid *qid)
1301 {
1302 int err = 0;
1303 struct p9_client *clnt;
1304 struct p9_req_t *req;
1305 int iounit;
1306
1307 p9_debug(P9_DEBUG_9P,
1308 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1309 ofid->fid, name, flags, mode,
1310 from_kgid(&init_user_ns, gid));
1311 clnt = ofid->clnt;
1312
1313 if (ofid->mode != -1)
1314 return -EINVAL;
1315
1316 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
1317 mode, gid);
1318 if (IS_ERR(req)) {
1319 err = PTR_ERR(req);
1320 goto error;
1321 }
1322
1323 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit);
1324 if (err) {
1325 trace_9p_protocol_dump(clnt, &req->rc);
1326 goto free_and_error;
1327 }
1328
1329 p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1330 qid->type,
1331 (unsigned long long)qid->path,
1332 qid->version, iounit);
1333
1334 ofid->mode = mode;
1335 ofid->iounit = iounit;
1336
1337 free_and_error:
1338 p9_tag_remove(clnt, req);
1339 error:
1340 return err;
1341 }
1342 EXPORT_SYMBOL(p9_client_create_dotl);
1343
1344 int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode,
1345 char *extension)
1346 {
1347 int err;
1348 struct p9_client *clnt;
1349 struct p9_req_t *req;
1350 struct p9_qid qid;
1351 int iounit;
1352
1353 p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1354 fid->fid, name, perm, mode);
1355 err = 0;
1356 clnt = fid->clnt;
1357
1358 if (fid->mode != -1)
1359 return -EINVAL;
1360
1361 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1362 mode, extension);
1363 if (IS_ERR(req)) {
1364 err = PTR_ERR(req);
1365 goto error;
1366 }
1367
1368 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1369 if (err) {
1370 trace_9p_protocol_dump(clnt, &req->rc);
1371 goto free_and_error;
1372 }
1373
1374 p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1375 qid.type,
1376 (unsigned long long)qid.path,
1377 qid.version, iounit);
1378
1379 fid->mode = mode;
1380 fid->iounit = iounit;
1381
1382 free_and_error:
1383 p9_tag_remove(clnt, req);
1384 error:
1385 return err;
1386 }
1387 EXPORT_SYMBOL(p9_client_fcreate);
1388
1389 int p9_client_symlink(struct p9_fid *dfid, const char *name,
1390 const char *symtgt, kgid_t gid, struct p9_qid *qid)
1391 {
1392 int err = 0;
1393 struct p9_client *clnt;
1394 struct p9_req_t *req;
1395
1396 p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
1397 dfid->fid, name, symtgt);
1398 clnt = dfid->clnt;
1399
1400 req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
1401 gid);
1402 if (IS_ERR(req)) {
1403 err = PTR_ERR(req);
1404 goto error;
1405 }
1406
1407 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
1408 if (err) {
1409 trace_9p_protocol_dump(clnt, &req->rc);
1410 goto free_and_error;
1411 }
1412
1413 p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
1414 qid->type, (unsigned long long)qid->path, qid->version);
1415
1416 free_and_error:
1417 p9_tag_remove(clnt, req);
1418 error:
1419 return err;
1420 }
1421 EXPORT_SYMBOL(p9_client_symlink);
1422
1423 int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, const char *newname)
1424 {
1425 struct p9_client *clnt;
1426 struct p9_req_t *req;
1427
1428 p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
1429 dfid->fid, oldfid->fid, newname);
1430 clnt = dfid->clnt;
1431 req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
1432 newname);
1433 if (IS_ERR(req))
1434 return PTR_ERR(req);
1435
1436 p9_debug(P9_DEBUG_9P, "<<< RLINK\n");
1437 p9_tag_remove(clnt, req);
1438 return 0;
1439 }
1440 EXPORT_SYMBOL(p9_client_link);
1441
1442 int p9_client_fsync(struct p9_fid *fid, int datasync)
1443 {
1444 int err;
1445 struct p9_client *clnt;
1446 struct p9_req_t *req;
1447
1448 p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d\n",
1449 fid->fid, datasync);
1450 err = 0;
1451 clnt = fid->clnt;
1452
1453 req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
1454 if (IS_ERR(req)) {
1455 err = PTR_ERR(req);
1456 goto error;
1457 }
1458
1459 p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);
1460
1461 p9_tag_remove(clnt, req);
1462
1463 error:
1464 return err;
1465 }
1466 EXPORT_SYMBOL(p9_client_fsync);
1467
1468 int p9_client_clunk(struct p9_fid *fid)
1469 {
1470 int err;
1471 struct p9_client *clnt;
1472 struct p9_req_t *req;
1473 int retries = 0;
1474
1475 if (!fid) {
1476 pr_warn("%s (%d): Trying to clunk with NULL fid\n",
1477 __func__, task_pid_nr(current));
1478 dump_stack();
1479 return 0;
1480 }
1481
1482 again:
1483 p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n", fid->fid,
1484 retries);
1485 err = 0;
1486 clnt = fid->clnt;
1487
1488 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1489 if (IS_ERR(req)) {
1490 err = PTR_ERR(req);
1491 goto error;
1492 }
1493
1494 p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1495
1496 p9_tag_remove(clnt, req);
1497 error:
1498 /*
1499 * Fid is not valid even after a failed clunk
1500 * If interrupted, retry once then give up and
1501 * leak fid until umount.
1502 */
1503 if (err == -ERESTARTSYS) {
1504 if (retries++ == 0)
1505 goto again;
1506 } else
1507 p9_fid_destroy(fid);
1508 return err;
1509 }
1510 EXPORT_SYMBOL(p9_client_clunk);
1511
1512 int p9_client_remove(struct p9_fid *fid)
1513 {
1514 int err;
1515 struct p9_client *clnt;
1516 struct p9_req_t *req;
1517
1518 p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1519 err = 0;
1520 clnt = fid->clnt;
1521
1522 req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1523 if (IS_ERR(req)) {
1524 err = PTR_ERR(req);
1525 goto error;
1526 }
1527
1528 p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1529
1530 p9_tag_remove(clnt, req);
1531 error:
1532 if (err == -ERESTARTSYS)
1533 p9_client_clunk(fid);
1534 else
1535 p9_fid_destroy(fid);
1536 return err;
1537 }
1538 EXPORT_SYMBOL(p9_client_remove);
1539
1540 int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
1541 {
1542 int err = 0;
1543 struct p9_req_t *req;
1544 struct p9_client *clnt;
1545
1546 p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
1547 dfid->fid, name, flags);
1548
1549 clnt = dfid->clnt;
1550 req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
1551 if (IS_ERR(req)) {
1552 err = PTR_ERR(req);
1553 goto error;
1554 }
1555 p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
1556
1557 p9_tag_remove(clnt, req);
1558 error:
1559 return err;
1560 }
1561 EXPORT_SYMBOL(p9_client_unlinkat);
1562
1563 int
1564 p9_client_read(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err)
1565 {
1566 struct p9_client *clnt = fid->clnt;
1567 struct p9_req_t *req;
1568 int total = 0;
1569 *err = 0;
1570
1571 p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n",
1572 fid->fid, (unsigned long long) offset, (int)iov_iter_count(to));
1573
1574 while (iov_iter_count(to)) {
1575 int count = iov_iter_count(to);
1576 int rsize, non_zc = 0;
1577 char *dataptr;
1578
1579 rsize = fid->iounit;
1580 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1581 rsize = clnt->msize - P9_IOHDRSZ;
1582
1583 if (count < rsize)
1584 rsize = count;
1585
1586 /* Don't bother zerocopy for small IO (< 1024) */
1587 if (clnt->trans_mod->zc_request && rsize > 1024) {
1588 /*
1589 * response header len is 11
1590 * PDU Header(7) + IO Size (4)
1591 */
1592 req = p9_client_zc_rpc(clnt, P9_TREAD, to, NULL, rsize,
1593 0, 11, "dqd", fid->fid,
1594 offset, rsize);
1595 } else {
1596 non_zc = 1;
1597 req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
1598 rsize);
1599 }
1600 if (IS_ERR(req)) {
1601 *err = PTR_ERR(req);
1602 break;
1603 }
1604
1605 *err = p9pdu_readf(&req->rc, clnt->proto_version,
1606 "D", &count, &dataptr);
1607 if (*err) {
1608 trace_9p_protocol_dump(clnt, &req->rc);
1609 p9_tag_remove(clnt, req);
1610 break;
1611 }
1612 if (rsize < count) {
1613 pr_err("bogus RREAD count (%d > %d)\n", count, rsize);
1614 count = rsize;
1615 }
1616
1617 p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
1618 if (!count) {
1619 p9_tag_remove(clnt, req);
1620 break;
1621 }
1622
1623 if (non_zc) {
1624 int n = copy_to_iter(dataptr, count, to);
1625 total += n;
1626 offset += n;
1627 if (n != count) {
1628 *err = -EFAULT;
1629 p9_tag_remove(clnt, req);
1630 break;
1631 }
1632 } else {
1633 iov_iter_advance(to, count);
1634 total += count;
1635 offset += count;
1636 }
1637 p9_tag_remove(clnt, req);
1638 }
1639 return total;
1640 }
1641 EXPORT_SYMBOL(p9_client_read);
1642
1643 int
1644 p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err)
1645 {
1646 struct p9_client *clnt = fid->clnt;
1647 struct p9_req_t *req;
1648 int total = 0;
1649 *err = 0;
1650
1651 p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %zd\n",
1652 fid->fid, (unsigned long long) offset,
1653 iov_iter_count(from));
1654
1655 while (iov_iter_count(from)) {
1656 int count = iov_iter_count(from);
1657 int rsize = fid->iounit;
1658 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1659 rsize = clnt->msize - P9_IOHDRSZ;
1660
1661 if (count < rsize)
1662 rsize = count;
1663
1664 /* Don't bother zerocopy for small IO (< 1024) */
1665 if (clnt->trans_mod->zc_request && rsize > 1024) {
1666 req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, from, 0,
1667 rsize, P9_ZC_HDR_SZ, "dqd",
1668 fid->fid, offset, rsize);
1669 } else {
1670 req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
1671 offset, rsize, from);
1672 }
1673 if (IS_ERR(req)) {
1674 *err = PTR_ERR(req);
1675 break;
1676 }
1677
1678 *err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &count);
1679 if (*err) {
1680 trace_9p_protocol_dump(clnt, &req->rc);
1681 p9_tag_remove(clnt, req);
1682 break;
1683 }
1684 if (rsize < count) {
1685 pr_err("bogus RWRITE count (%d > %d)\n", count, rsize);
1686 count = rsize;
1687 }
1688
1689 p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
1690
1691 p9_tag_remove(clnt, req);
1692 iov_iter_advance(from, count);
1693 total += count;
1694 offset += count;
1695 }
1696 return total;
1697 }
1698 EXPORT_SYMBOL(p9_client_write);
1699
1700 struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1701 {
1702 int err;
1703 struct p9_client *clnt;
1704 struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
1705 struct p9_req_t *req;
1706 u16 ignored;
1707
1708 p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1709
1710 if (!ret)
1711 return ERR_PTR(-ENOMEM);
1712
1713 err = 0;
1714 clnt = fid->clnt;
1715
1716 req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1717 if (IS_ERR(req)) {
1718 err = PTR_ERR(req);
1719 goto error;
1720 }
1721
1722 err = p9pdu_readf(&req->rc, clnt->proto_version, "wS", &ignored, ret);
1723 if (err) {
1724 trace_9p_protocol_dump(clnt, &req->rc);
1725 p9_tag_remove(clnt, req);
1726 goto error;
1727 }
1728
1729 p9_debug(P9_DEBUG_9P,
1730 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1731 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1732 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1733 "<<< uid=%d gid=%d n_muid=%d\n",
1734 ret->size, ret->type, ret->dev, ret->qid.type,
1735 (unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
1736 ret->atime, ret->mtime, (unsigned long long)ret->length,
1737 ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
1738 from_kuid(&init_user_ns, ret->n_uid),
1739 from_kgid(&init_user_ns, ret->n_gid),
1740 from_kuid(&init_user_ns, ret->n_muid));
1741
1742 p9_tag_remove(clnt, req);
1743 return ret;
1744
1745 error:
1746 kfree(ret);
1747 return ERR_PTR(err);
1748 }
1749 EXPORT_SYMBOL(p9_client_stat);
1750
1751 struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
1752 u64 request_mask)
1753 {
1754 int err;
1755 struct p9_client *clnt;
1756 struct p9_stat_dotl *ret = kmalloc(sizeof(struct p9_stat_dotl),
1757 GFP_KERNEL);
1758 struct p9_req_t *req;
1759
1760 p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
1761 fid->fid, request_mask);
1762
1763 if (!ret)
1764 return ERR_PTR(-ENOMEM);
1765
1766 err = 0;
1767 clnt = fid->clnt;
1768
1769 req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
1770 if (IS_ERR(req)) {
1771 err = PTR_ERR(req);
1772 goto error;
1773 }
1774
1775 err = p9pdu_readf(&req->rc, clnt->proto_version, "A", ret);
1776 if (err) {
1777 trace_9p_protocol_dump(clnt, &req->rc);
1778 p9_tag_remove(clnt, req);
1779 goto error;
1780 }
1781
1782 p9_debug(P9_DEBUG_9P,
1783 "<<< RGETATTR st_result_mask=%lld\n"
1784 "<<< qid=%x.%llx.%x\n"
1785 "<<< st_mode=%8.8x st_nlink=%llu\n"
1786 "<<< st_uid=%d st_gid=%d\n"
1787 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1788 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1789 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1790 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1791 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1792 "<<< st_gen=%lld st_data_version=%lld\n",
1793 ret->st_result_mask, ret->qid.type, ret->qid.path,
1794 ret->qid.version, ret->st_mode, ret->st_nlink,
1795 from_kuid(&init_user_ns, ret->st_uid),
1796 from_kgid(&init_user_ns, ret->st_gid),
1797 ret->st_rdev, ret->st_size, ret->st_blksize,
1798 ret->st_blocks, ret->st_atime_sec, ret->st_atime_nsec,
1799 ret->st_mtime_sec, ret->st_mtime_nsec, ret->st_ctime_sec,
1800 ret->st_ctime_nsec, ret->st_btime_sec, ret->st_btime_nsec,
1801 ret->st_gen, ret->st_data_version);
1802
1803 p9_tag_remove(clnt, req);
1804 return ret;
1805
1806 error:
1807 kfree(ret);
1808 return ERR_PTR(err);
1809 }
1810 EXPORT_SYMBOL(p9_client_getattr_dotl);
1811
1812 static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
1813 {
1814 int ret;
1815
1816 /* NOTE: size shouldn't include its own length */
1817 /* size[2] type[2] dev[4] qid[13] */
1818 /* mode[4] atime[4] mtime[4] length[8]*/
1819 /* name[s] uid[s] gid[s] muid[s] */
1820 ret = 2+4+13+4+4+4+8+2+2+2+2;
1821
1822 if (wst->name)
1823 ret += strlen(wst->name);
1824 if (wst->uid)
1825 ret += strlen(wst->uid);
1826 if (wst->gid)
1827 ret += strlen(wst->gid);
1828 if (wst->muid)
1829 ret += strlen(wst->muid);
1830
1831 if ((proto_version == p9_proto_2000u) ||
1832 (proto_version == p9_proto_2000L)) {
1833 ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1834 if (wst->extension)
1835 ret += strlen(wst->extension);
1836 }
1837
1838 return ret;
1839 }
1840
1841 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
1842 {
1843 int err;
1844 struct p9_req_t *req;
1845 struct p9_client *clnt;
1846
1847 err = 0;
1848 clnt = fid->clnt;
1849 wst->size = p9_client_statsize(wst, clnt->proto_version);
1850 p9_debug(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
1851 p9_debug(P9_DEBUG_9P,
1852 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1853 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1854 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1855 " uid=%d gid=%d n_muid=%d\n",
1856 wst->size, wst->type, wst->dev, wst->qid.type,
1857 (unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
1858 wst->atime, wst->mtime, (unsigned long long)wst->length,
1859 wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
1860 from_kuid(&init_user_ns, wst->n_uid),
1861 from_kgid(&init_user_ns, wst->n_gid),
1862 from_kuid(&init_user_ns, wst->n_muid));
1863
1864 req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size+2, wst);
1865 if (IS_ERR(req)) {
1866 err = PTR_ERR(req);
1867 goto error;
1868 }
1869
1870 p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1871
1872 p9_tag_remove(clnt, req);
1873 error:
1874 return err;
1875 }
1876 EXPORT_SYMBOL(p9_client_wstat);
1877
1878 int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
1879 {
1880 int err;
1881 struct p9_req_t *req;
1882 struct p9_client *clnt;
1883
1884 err = 0;
1885 clnt = fid->clnt;
1886 p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
1887 p9_debug(P9_DEBUG_9P,
1888 " valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1889 " atime_sec=%lld atime_nsec=%lld\n"
1890 " mtime_sec=%lld mtime_nsec=%lld\n",
1891 p9attr->valid, p9attr->mode,
1892 from_kuid(&init_user_ns, p9attr->uid),
1893 from_kgid(&init_user_ns, p9attr->gid),
1894 p9attr->size, p9attr->atime_sec, p9attr->atime_nsec,
1895 p9attr->mtime_sec, p9attr->mtime_nsec);
1896
1897 req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
1898
1899 if (IS_ERR(req)) {
1900 err = PTR_ERR(req);
1901 goto error;
1902 }
1903 p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
1904 p9_tag_remove(clnt, req);
1905 error:
1906 return err;
1907 }
1908 EXPORT_SYMBOL(p9_client_setattr);
1909
1910 int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
1911 {
1912 int err;
1913 struct p9_req_t *req;
1914 struct p9_client *clnt;
1915
1916 err = 0;
1917 clnt = fid->clnt;
1918
1919 p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
1920
1921 req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
1922 if (IS_ERR(req)) {
1923 err = PTR_ERR(req);
1924 goto error;
1925 }
1926
1927 err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
1928 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
1929 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
1930 if (err) {
1931 trace_9p_protocol_dump(clnt, &req->rc);
1932 p9_tag_remove(clnt, req);
1933 goto error;
1934 }
1935
1936 p9_debug(P9_DEBUG_9P, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1937 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1938 "fsid %llu namelen %ld\n",
1939 fid->fid, (long unsigned int)sb->type, (long int)sb->bsize,
1940 sb->blocks, sb->bfree, sb->bavail, sb->files, sb->ffree,
1941 sb->fsid, (long int)sb->namelen);
1942
1943 p9_tag_remove(clnt, req);
1944 error:
1945 return err;
1946 }
1947 EXPORT_SYMBOL(p9_client_statfs);
1948
1949 int p9_client_rename(struct p9_fid *fid,
1950 struct p9_fid *newdirfid, const char *name)
1951 {
1952 int err;
1953 struct p9_req_t *req;
1954 struct p9_client *clnt;
1955
1956 err = 0;
1957 clnt = fid->clnt;
1958
1959 p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
1960 fid->fid, newdirfid->fid, name);
1961
1962 req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
1963 newdirfid->fid, name);
1964 if (IS_ERR(req)) {
1965 err = PTR_ERR(req);
1966 goto error;
1967 }
1968
1969 p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
1970
1971 p9_tag_remove(clnt, req);
1972 error:
1973 return err;
1974 }
1975 EXPORT_SYMBOL(p9_client_rename);
1976
1977 int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
1978 struct p9_fid *newdirfid, const char *new_name)
1979 {
1980 int err;
1981 struct p9_req_t *req;
1982 struct p9_client *clnt;
1983
1984 err = 0;
1985 clnt = olddirfid->clnt;
1986
1987 p9_debug(P9_DEBUG_9P, ">>> TRENAMEAT olddirfid %d old name %s"
1988 " newdirfid %d new name %s\n", olddirfid->fid, old_name,
1989 newdirfid->fid, new_name);
1990
1991 req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
1992 old_name, newdirfid->fid, new_name);
1993 if (IS_ERR(req)) {
1994 err = PTR_ERR(req);
1995 goto error;
1996 }
1997
1998 p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
1999 newdirfid->fid, new_name);
2000
2001 p9_tag_remove(clnt, req);
2002 error:
2003 return err;
2004 }
2005 EXPORT_SYMBOL(p9_client_renameat);
2006
2007 /*
2008 * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
2009 */
2010 struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
2011 const char *attr_name, u64 *attr_size)
2012 {
2013 int err;
2014 struct p9_req_t *req;
2015 struct p9_client *clnt;
2016 struct p9_fid *attr_fid;
2017
2018 err = 0;
2019 clnt = file_fid->clnt;
2020 attr_fid = p9_fid_create(clnt);
2021 if (!attr_fid) {
2022 err = -ENOMEM;
2023 goto error;
2024 }
2025 p9_debug(P9_DEBUG_9P,
2026 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
2027 file_fid->fid, attr_fid->fid, attr_name);
2028
2029 req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
2030 file_fid->fid, attr_fid->fid, attr_name);
2031 if (IS_ERR(req)) {
2032 err = PTR_ERR(req);
2033 goto error;
2034 }
2035 err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size);
2036 if (err) {
2037 trace_9p_protocol_dump(clnt, &req->rc);
2038 p9_tag_remove(clnt, req);
2039 goto clunk_fid;
2040 }
2041 p9_tag_remove(clnt, req);
2042 p9_debug(P9_DEBUG_9P, "<<< RXATTRWALK fid %d size %llu\n",
2043 attr_fid->fid, *attr_size);
2044 return attr_fid;
2045 clunk_fid:
2046 p9_client_clunk(attr_fid);
2047 attr_fid = NULL;
2048 error:
2049 if (attr_fid && (attr_fid != file_fid))
2050 p9_fid_destroy(attr_fid);
2051
2052 return ERR_PTR(err);
2053 }
2054 EXPORT_SYMBOL_GPL(p9_client_xattrwalk);
2055
2056 int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
2057 u64 attr_size, int flags)
2058 {
2059 int err;
2060 struct p9_req_t *req;
2061 struct p9_client *clnt;
2062
2063 p9_debug(P9_DEBUG_9P,
2064 ">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
2065 fid->fid, name, (long long)attr_size, flags);
2066 err = 0;
2067 clnt = fid->clnt;
2068 req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
2069 fid->fid, name, attr_size, flags);
2070 if (IS_ERR(req)) {
2071 err = PTR_ERR(req);
2072 goto error;
2073 }
2074 p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
2075 p9_tag_remove(clnt, req);
2076 error:
2077 return err;
2078 }
2079 EXPORT_SYMBOL_GPL(p9_client_xattrcreate);
2080
2081 int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
2082 {
2083 int err, rsize, non_zc = 0;
2084 struct p9_client *clnt;
2085 struct p9_req_t *req;
2086 char *dataptr;
2087 struct kvec kv = {.iov_base = data, .iov_len = count};
2088 struct iov_iter to;
2089
2090 iov_iter_kvec(&to, READ, &kv, 1, count);
2091
2092 p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
2093 fid->fid, (unsigned long long) offset, count);
2094
2095 err = 0;
2096 clnt = fid->clnt;
2097
2098 rsize = fid->iounit;
2099 if (!rsize || rsize > clnt->msize-P9_READDIRHDRSZ)
2100 rsize = clnt->msize - P9_READDIRHDRSZ;
2101
2102 if (count < rsize)
2103 rsize = count;
2104
2105 /* Don't bother zerocopy for small IO (< 1024) */
2106 if (clnt->trans_mod->zc_request && rsize > 1024) {
2107 /*
2108 * response header len is 11
2109 * PDU Header(7) + IO Size (4)
2110 */
2111 req = p9_client_zc_rpc(clnt, P9_TREADDIR, &to, NULL, rsize, 0,
2112 11, "dqd", fid->fid, offset, rsize);
2113 } else {
2114 non_zc = 1;
2115 req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
2116 offset, rsize);
2117 }
2118 if (IS_ERR(req)) {
2119 err = PTR_ERR(req);
2120 goto error;
2121 }
2122
2123 err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr);
2124 if (err) {
2125 trace_9p_protocol_dump(clnt, &req->rc);
2126 goto free_and_error;
2127 }
2128 if (rsize < count) {
2129 pr_err("bogus RREADDIR count (%d > %d)\n", count, rsize);
2130 count = rsize;
2131 }
2132
2133 p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
2134
2135 if (non_zc)
2136 memmove(data, dataptr, count);
2137
2138 p9_tag_remove(clnt, req);
2139 return count;
2140
2141 free_and_error:
2142 p9_tag_remove(clnt, req);
2143 error:
2144 return err;
2145 }
2146 EXPORT_SYMBOL(p9_client_readdir);
2147
2148 int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode,
2149 dev_t rdev, kgid_t gid, struct p9_qid *qid)
2150 {
2151 int err;
2152 struct p9_client *clnt;
2153 struct p9_req_t *req;
2154
2155 err = 0;
2156 clnt = fid->clnt;
2157 p9_debug(P9_DEBUG_9P, ">>> TMKNOD fid %d name %s mode %d major %d "
2158 "minor %d\n", fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
2159 req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
2160 MAJOR(rdev), MINOR(rdev), gid);
2161 if (IS_ERR(req))
2162 return PTR_ERR(req);
2163
2164 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
2165 if (err) {
2166 trace_9p_protocol_dump(clnt, &req->rc);
2167 goto error;
2168 }
2169 p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
2170 (unsigned long long)qid->path, qid->version);
2171
2172 error:
2173 p9_tag_remove(clnt, req);
2174 return err;
2175
2176 }
2177 EXPORT_SYMBOL(p9_client_mknod_dotl);
2178
2179 int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode,
2180 kgid_t gid, struct p9_qid *qid)
2181 {
2182 int err;
2183 struct p9_client *clnt;
2184 struct p9_req_t *req;
2185
2186 err = 0;
2187 clnt = fid->clnt;
2188 p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
2189 fid->fid, name, mode, from_kgid(&init_user_ns, gid));
2190 req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg", fid->fid, name, mode,
2191 gid);
2192 if (IS_ERR(req))
2193 return PTR_ERR(req);
2194
2195 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
2196 if (err) {
2197 trace_9p_protocol_dump(clnt, &req->rc);
2198 goto error;
2199 }
2200 p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
2201 (unsigned long long)qid->path, qid->version);
2202
2203 error:
2204 p9_tag_remove(clnt, req);
2205 return err;
2206
2207 }
2208 EXPORT_SYMBOL(p9_client_mkdir_dotl);
2209
2210 int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
2211 {
2212 int err;
2213 struct p9_client *clnt;
2214 struct p9_req_t *req;
2215
2216 err = 0;
2217 clnt = fid->clnt;
2218 p9_debug(P9_DEBUG_9P, ">>> TLOCK fid %d type %i flags %d "
2219 "start %lld length %lld proc_id %d client_id %s\n",
2220 fid->fid, flock->type, flock->flags, flock->start,
2221 flock->length, flock->proc_id, flock->client_id);
2222
2223 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
2224 flock->flags, flock->start, flock->length,
2225 flock->proc_id, flock->client_id);
2226
2227 if (IS_ERR(req))
2228 return PTR_ERR(req);
2229
2230 err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status);
2231 if (err) {
2232 trace_9p_protocol_dump(clnt, &req->rc);
2233 goto error;
2234 }
2235 p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
2236 error:
2237 p9_tag_remove(clnt, req);
2238 return err;
2239
2240 }
2241 EXPORT_SYMBOL(p9_client_lock_dotl);
2242
2243 int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
2244 {
2245 int err;
2246 struct p9_client *clnt;
2247 struct p9_req_t *req;
2248
2249 err = 0;
2250 clnt = fid->clnt;
2251 p9_debug(P9_DEBUG_9P, ">>> TGETLOCK fid %d, type %i start %lld "
2252 "length %lld proc_id %d client_id %s\n", fid->fid, glock->type,
2253 glock->start, glock->length, glock->proc_id, glock->client_id);
2254
2255 req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid, glock->type,
2256 glock->start, glock->length, glock->proc_id, glock->client_id);
2257
2258 if (IS_ERR(req))
2259 return PTR_ERR(req);
2260
2261 err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type,
2262 &glock->start, &glock->length, &glock->proc_id,
2263 &glock->client_id);
2264 if (err) {
2265 trace_9p_protocol_dump(clnt, &req->rc);
2266 goto error;
2267 }
2268 p9_debug(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "
2269 "proc_id %d client_id %s\n", glock->type, glock->start,
2270 glock->length, glock->proc_id, glock->client_id);
2271 error:
2272 p9_tag_remove(clnt, req);
2273 return err;
2274 }
2275 EXPORT_SYMBOL(p9_client_getlock_dotl);
2276
2277 int p9_client_readlink(struct p9_fid *fid, char **target)
2278 {
2279 int err;
2280 struct p9_client *clnt;
2281 struct p9_req_t *req;
2282
2283 err = 0;
2284 clnt = fid->clnt;
2285 p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);
2286
2287 req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
2288 if (IS_ERR(req))
2289 return PTR_ERR(req);
2290
2291 err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target);
2292 if (err) {
2293 trace_9p_protocol_dump(clnt, &req->rc);
2294 goto error;
2295 }
2296 p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
2297 error:
2298 p9_tag_remove(clnt, req);
2299 return err;
2300 }
2301 EXPORT_SYMBOL(p9_client_readlink);
2302
2303 int __init p9_client_init(void)
2304 {
2305 p9_req_cache = KMEM_CACHE(p9_req_t, SLAB_TYPESAFE_BY_RCU);
2306 return p9_req_cache ? 0 : -ENOMEM;
2307 }
2308
2309 void __exit p9_client_exit(void)
2310 {
2311 kmem_cache_destroy(p9_req_cache);
2312 }
Linux with added FPC-III support