projects/linux·blob master · refs

2212 lines · 52.3 KiB

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