Lines Matching +full:c +full:- +full:version +full:- +full:name
1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
6 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
38 * - a little lazy - parse all client options
53 {Opt_version, "version=%s"},
59 return clnt->proto_version == p9_proto_2000L; in p9_is_proto_dotl()
65 return clnt->proto_version == p9_proto_2000u; in p9_is_proto_dotu()
71 if (clnt->msize != DEFAULT_MSIZE) in p9_show_client_options()
72 seq_printf(m, ",msize=%u", clnt->msize); in p9_show_client_options()
73 seq_printf(m, ",trans=%s", clnt->trans_mod->name); in p9_show_client_options()
75 switch (clnt->proto_version) { in p9_show_client_options()
80 seq_puts(m, ",version=9p2000.u"); in p9_show_client_options()
87 if (clnt->trans_mod->show_options) in p9_show_client_options()
88 return clnt->trans_mod->show_options(m, clnt); in p9_show_client_options()
98 if (err > 0 || err < -MAX_ERRNO) { in safe_errno()
100 return -EPROTO; in safe_errno()
105 /* Interpret mount option for protocol version */
108 int version = -EINVAL; in get_protocol_version() local
111 version = p9_proto_legacy; in get_protocol_version()
112 p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n"); in get_protocol_version()
114 version = p9_proto_2000u; in get_protocol_version()
115 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n"); in get_protocol_version()
117 version = p9_proto_2000L; in get_protocol_version()
118 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n"); in get_protocol_version()
120 pr_info("Unknown protocol version %s\n", s); in get_protocol_version()
123 return version; in get_protocol_version()
127 * parse_opts - parse mount options into client structure
131 * Return 0 upon success, -ERRNO upon failure
143 clnt->proto_version = p9_proto_2000L; in parse_opts()
144 clnt->msize = DEFAULT_MSIZE; in parse_opts()
151 return -ENOMEM; in parse_opts()
172 ret = -EINVAL; in parse_opts()
175 clnt->msize = option; in parse_opts()
180 ret = -ENOMEM; in parse_opts()
186 v9fs_put_trans(clnt->trans_mod); in parse_opts()
187 clnt->trans_mod = v9fs_get_trans_by_name(s); in parse_opts()
188 if (!clnt->trans_mod) { in parse_opts()
191 ret = -EINVAL; in parse_opts()
196 clnt->proto_version = p9_proto_legacy; in parse_opts()
201 ret = -ENOMEM; in parse_opts()
203 "problem allocating copy of version arg\n"); in parse_opts()
210 clnt->proto_version = r; in parse_opts()
220 v9fs_put_trans(clnt->trans_mod); in parse_opts()
225 static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc, in p9_fcall_init() argument
228 if (likely(c->fcall_cache) && alloc_msize == c->msize) { in p9_fcall_init()
229 fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS); in p9_fcall_init()
230 fc->cache = c->fcall_cache; in p9_fcall_init()
232 fc->sdata = kmalloc(alloc_msize, GFP_NOFS); in p9_fcall_init()
233 fc->cache = NULL; in p9_fcall_init()
235 if (!fc->sdata) in p9_fcall_init()
236 return -ENOMEM; in p9_fcall_init()
237 fc->capacity = alloc_msize; in p9_fcall_init()
244 * and kmem_cache_free does not do NULL-check for us in p9_fcall_fini()
246 if (unlikely(!fc->sdata)) in p9_fcall_fini()
249 if (fc->cache) in p9_fcall_fini()
250 kmem_cache_free(fc->cache, fc->sdata); in p9_fcall_fini()
252 kfree(fc->sdata); in p9_fcall_fini()
259 * p9_tag_alloc - Allocate a new request.
260 * @c: Client session.
275 p9_tag_alloc(struct p9_client *c, int8_t type, uint t_size, uint r_size, in p9_tag_alloc() argument
285 alloc_tsize = min_t(size_t, c->msize, in p9_tag_alloc()
286 t_size ?: p9_msg_buf_size(c, type, fmt, apc)); in p9_tag_alloc()
289 alloc_rsize = min_t(size_t, c->msize, in p9_tag_alloc()
290 r_size ?: p9_msg_buf_size(c, type + 1, fmt, ap)); in p9_tag_alloc()
293 return ERR_PTR(-ENOMEM); in p9_tag_alloc()
295 if (p9_fcall_init(c, &req->tc, alloc_tsize)) in p9_tag_alloc()
297 if (p9_fcall_init(c, &req->rc, alloc_rsize)) in p9_tag_alloc()
300 p9pdu_reset(&req->tc); in p9_tag_alloc()
301 p9pdu_reset(&req->rc); in p9_tag_alloc()
302 req->t_err = 0; in p9_tag_alloc()
303 req->status = REQ_STATUS_ALLOC; in p9_tag_alloc()
308 refcount_set(&req->refcount, 0); in p9_tag_alloc()
309 init_waitqueue_head(&req->wq); in p9_tag_alloc()
310 INIT_LIST_HEAD(&req->req_list); in p9_tag_alloc()
313 spin_lock_irq(&c->lock); in p9_tag_alloc()
315 tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1, in p9_tag_alloc()
318 tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT); in p9_tag_alloc()
319 req->tc.tag = tag; in p9_tag_alloc()
320 spin_unlock_irq(&c->lock); in p9_tag_alloc()
335 refcount_set(&req->refcount, 2); in p9_tag_alloc()
340 p9_fcall_fini(&req->tc); in p9_tag_alloc()
341 p9_fcall_fini(&req->rc); in p9_tag_alloc()
344 return ERR_PTR(-ENOMEM); in p9_tag_alloc()
348 * p9_tag_lookup - Look up a request by tag.
349 * @c: Client session.
355 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag) in p9_tag_lookup() argument
361 req = idr_find(&c->reqs, tag); in p9_tag_lookup()
370 if (req->tc.tag != tag) { in p9_tag_lookup()
371 p9_req_put(c, req); in p9_tag_lookup()
382 * p9_tag_remove - Remove a tag.
383 * @c: Client session.
388 static void p9_tag_remove(struct p9_client *c, struct p9_req_t *r) in p9_tag_remove() argument
391 u16 tag = r->tc.tag; in p9_tag_remove()
393 p9_debug(P9_DEBUG_MUX, "freeing clnt %p req %p tag: %d\n", c, r, tag); in p9_tag_remove()
394 spin_lock_irqsave(&c->lock, flags); in p9_tag_remove()
395 idr_remove(&c->reqs, tag); in p9_tag_remove()
396 spin_unlock_irqrestore(&c->lock, flags); in p9_tag_remove()
399 int p9_req_put(struct p9_client *c, struct p9_req_t *r) in p9_req_put() argument
401 if (refcount_dec_and_test(&r->refcount)) { in p9_req_put()
402 p9_tag_remove(c, r); in p9_req_put()
404 p9_fcall_fini(&r->tc); in p9_req_put()
405 p9_fcall_fini(&r->rc); in p9_req_put()
414 * p9_tag_cleanup - cleans up tags structure and reclaims resources
415 * @c: v9fs client struct
420 static void p9_tag_cleanup(struct p9_client *c) in p9_tag_cleanup() argument
426 idr_for_each_entry(&c->reqs, req, id) { in p9_tag_cleanup()
428 if (p9_req_put(c, req) == 0) in p9_tag_cleanup()
430 req->tc.tag); in p9_tag_cleanup()
436 * p9_client_cb - call back from transport to client
437 * @c: client state
442 void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status) in p9_client_cb() argument
444 p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag); in p9_client_cb()
450 WRITE_ONCE(req->status, status); in p9_client_cb()
452 wake_up(&req->wq); in p9_client_cb()
453 p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag); in p9_client_cb()
454 p9_req_put(c, req); in p9_client_cb()
459 * p9_parse_header - parse header arguments out of a packet
474 int offset = pdu->offset; in p9_parse_header()
477 pdu->offset = 0; in p9_parse_header()
490 if (pdu->size != r_size || r_size < 7) { in p9_parse_header()
491 err = -EINVAL; in p9_parse_header()
495 pdu->id = r_type; in p9_parse_header()
496 pdu->tag = r_tag; in p9_parse_header()
499 pdu->size, pdu->id, pdu->tag); in p9_parse_header()
503 pdu->offset = offset; in p9_parse_header()
509 * p9_check_errors - check 9p packet for error return and process it
510 * @c: current client instance
519 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req) in p9_check_errors() argument
525 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0); in p9_check_errors()
526 if (req->rc.size > req->rc.capacity && !req->rc.zc) { in p9_check_errors()
528 req->rc.size, req->rc.capacity, req->rc.id); in p9_check_errors()
529 return -EIO; in p9_check_errors()
534 trace_9p_protocol_dump(c, &req->rc); in p9_check_errors()
542 if (!p9_is_proto_dotl(c)) { in p9_check_errors()
545 err = p9pdu_readf(&req->rc, c->proto_version, "s?d", in p9_check_errors()
552 if (p9_is_proto_dotu(c) && ecode < 512) in p9_check_errors()
553 err = -ecode; in p9_check_errors()
559 -ecode, ename); in p9_check_errors()
563 err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode); in p9_check_errors()
566 err = -ecode; in p9_check_errors()
568 p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode); in p9_check_errors()
580 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
583 * p9_client_flush - flush (cancel) a request
584 * @c: client state
594 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq) in p9_client_flush() argument
600 err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1); in p9_client_flush()
606 req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag); in p9_client_flush()
613 if (READ_ONCE(oldreq->status) == REQ_STATUS_SENT) { in p9_client_flush()
614 if (c->trans_mod->cancelled) in p9_client_flush()
615 c->trans_mod->cancelled(c, oldreq); in p9_client_flush()
618 p9_req_put(c, req); in p9_client_flush()
622 static struct p9_req_t *p9_client_prepare_req(struct p9_client *c, in p9_client_prepare_req() argument
630 p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type); in p9_client_prepare_req()
633 if (c->status == Disconnected) in p9_client_prepare_req()
634 return ERR_PTR(-EIO); in p9_client_prepare_req()
637 if (c->status == BeginDisconnect && type != P9_TCLUNK) in p9_client_prepare_req()
638 return ERR_PTR(-EIO); in p9_client_prepare_req()
641 req = p9_tag_alloc(c, type, t_size, r_size, fmt, apc); in p9_client_prepare_req()
647 p9pdu_prepare(&req->tc, req->tc.tag, type); in p9_client_prepare_req()
648 err = p9pdu_vwritef(&req->tc, c->proto_version, fmt, ap); in p9_client_prepare_req()
651 p9pdu_finalize(c, &req->tc); in p9_client_prepare_req()
652 trace_9p_client_req(c, type, req->tc.tag); in p9_client_prepare_req()
655 p9_req_put(c, req); in p9_client_prepare_req()
657 p9_req_put(c, req); in p9_client_prepare_req()
662 * p9_client_rpc - issue a request and wait for a response
663 * @c: client session
665 * @fmt: protocol format string (see protocol.c)
671 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...) in p9_client_rpc() argument
685 const uint rsize = c->trans_mod->pooled_rbuffers ? c->msize : 0; in p9_client_rpc()
688 req = p9_client_prepare_req(c, type, tsize, rsize, fmt, ap); in p9_client_rpc()
693 req->tc.zc = false; in p9_client_rpc()
694 req->rc.zc = false; in p9_client_rpc()
703 err = c->trans_mod->request(c, req); in p9_client_rpc()
706 p9_req_put(c, req); in p9_client_rpc()
707 if (err != -ERESTARTSYS && err != -EFAULT) in p9_client_rpc()
708 c->status = Disconnected; in p9_client_rpc()
713 err = wait_event_killable(req->wq, in p9_client_rpc()
714 READ_ONCE(req->status) >= REQ_STATUS_RCVD); in p9_client_rpc()
717 * threads - echoes to wmb() in the callback in p9_client_rpc()
721 if (err == -ERESTARTSYS && c->status == Connected && in p9_client_rpc()
728 if (READ_ONCE(req->status) == REQ_STATUS_ERROR) { in p9_client_rpc()
729 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err); in p9_client_rpc()
730 err = req->t_err; in p9_client_rpc()
732 if (err == -ERESTARTSYS && c->status == Connected) { in p9_client_rpc()
737 if (c->trans_mod->cancel(c, req)) in p9_client_rpc()
738 p9_client_flush(c, req); in p9_client_rpc()
741 if (READ_ONCE(req->status) == REQ_STATUS_RCVD) in p9_client_rpc()
746 spin_lock_irqsave(¤t->sighand->siglock, flags); in p9_client_rpc()
748 spin_unlock_irqrestore(¤t->sighand->siglock, flags); in p9_client_rpc()
753 err = p9_check_errors(c, req); in p9_client_rpc()
754 trace_9p_client_res(c, type, req->rc.tag, err); in p9_client_rpc()
758 p9_req_put(c, req); in p9_client_rpc()
763 * p9_client_zc_rpc - issue a request and wait for a response
764 * @c: client session
771 * @fmt: protocol format string (see protocol.c)
775 static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type, in p9_client_zc_rpc() argument
788 * The actual content is passed in zero-copy fashion. in p9_client_zc_rpc()
790 req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, P9_ZC_HDR_SZ, fmt, ap); in p9_client_zc_rpc()
795 req->tc.zc = true; in p9_client_zc_rpc()
796 req->rc.zc = true; in p9_client_zc_rpc()
805 err = c->trans_mod->zc_request(c, req, uidata, uodata, in p9_client_zc_rpc()
808 if (err == -EIO) in p9_client_zc_rpc()
809 c->status = Disconnected; in p9_client_zc_rpc()
810 if (err != -ERESTARTSYS) in p9_client_zc_rpc()
813 if (READ_ONCE(req->status) == REQ_STATUS_ERROR) { in p9_client_zc_rpc()
814 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err); in p9_client_zc_rpc()
815 err = req->t_err; in p9_client_zc_rpc()
817 if (err == -ERESTARTSYS && c->status == Connected) { in p9_client_zc_rpc()
822 if (c->trans_mod->cancel(c, req)) in p9_client_zc_rpc()
823 p9_client_flush(c, req); in p9_client_zc_rpc()
826 if (READ_ONCE(req->status) == REQ_STATUS_RCVD) in p9_client_zc_rpc()
831 spin_lock_irqsave(¤t->sighand->siglock, flags); in p9_client_zc_rpc()
833 spin_unlock_irqrestore(¤t->sighand->siglock, flags); in p9_client_zc_rpc()
838 err = p9_check_errors(c, req); in p9_client_zc_rpc()
839 trace_9p_client_res(c, type, req->rc.tag, err); in p9_client_zc_rpc()
843 p9_req_put(c, req); in p9_client_zc_rpc()
857 fid->mode = -1; in p9_fid_create()
858 fid->uid = current_fsuid(); in p9_fid_create()
859 fid->clnt = clnt; in p9_fid_create()
860 refcount_set(&fid->count, 1); in p9_fid_create()
863 spin_lock_irq(&clnt->lock); in p9_fid_create()
864 ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1, in p9_fid_create()
866 spin_unlock_irq(&clnt->lock); in p9_fid_create()
882 p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid); in p9_fid_destroy()
884 clnt = fid->clnt; in p9_fid_destroy()
885 spin_lock_irqsave(&clnt->lock, flags); in p9_fid_destroy()
886 idr_remove(&clnt->fids, fid->fid); in p9_fid_destroy()
887 spin_unlock_irqrestore(&clnt->lock, flags); in p9_fid_destroy()
888 kfree(fid->rdir); in p9_fid_destroy()
907 static int p9_client_version(struct p9_client *c) in p9_client_version() argument
911 char *version = NULL; in p9_client_version() local
915 c->msize, c->proto_version); in p9_client_version()
917 switch (c->proto_version) { in p9_client_version()
919 req = p9_client_rpc(c, P9_TVERSION, "ds", in p9_client_version()
920 c->msize, "9P2000.L"); in p9_client_version()
923 req = p9_client_rpc(c, P9_TVERSION, "ds", in p9_client_version()
924 c->msize, "9P2000.u"); in p9_client_version()
927 req = p9_client_rpc(c, P9_TVERSION, "ds", in p9_client_version()
928 c->msize, "9P2000"); in p9_client_version()
931 return -EINVAL; in p9_client_version()
937 err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version); in p9_client_version()
939 p9_debug(P9_DEBUG_9P, "version error %d\n", err); in p9_client_version()
940 trace_9p_protocol_dump(c, &req->rc); in p9_client_version()
944 p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version); in p9_client_version()
945 if (!strncmp(version, "9P2000.L", 8)) { in p9_client_version()
946 c->proto_version = p9_proto_2000L; in p9_client_version()
947 } else if (!strncmp(version, "9P2000.u", 8)) { in p9_client_version()
948 c->proto_version = p9_proto_2000u; in p9_client_version()
949 } else if (!strncmp(version, "9P2000", 6)) { in p9_client_version()
950 c->proto_version = p9_proto_legacy; in p9_client_version()
953 "server returned an unknown version: %s\n", version); in p9_client_version()
954 err = -EREMOTEIO; in p9_client_version()
961 err = -EREMOTEIO; in p9_client_version()
964 if (msize < c->msize) in p9_client_version()
965 c->msize = msize; in p9_client_version()
968 kfree(version); in p9_client_version()
969 p9_req_put(c, req); in p9_client_version()
982 return ERR_PTR(-ENOMEM); in p9_client_create()
984 clnt->trans_mod = NULL; in p9_client_create()
985 clnt->trans = NULL; in p9_client_create()
986 clnt->fcall_cache = NULL; in p9_client_create()
988 client_id = utsname()->nodename; in p9_client_create()
989 memcpy(clnt->name, client_id, strlen(client_id) + 1); in p9_client_create()
991 spin_lock_init(&clnt->lock); in p9_client_create()
992 idr_init(&clnt->fids); in p9_client_create()
993 idr_init(&clnt->reqs); in p9_client_create()
999 if (!clnt->trans_mod) in p9_client_create()
1000 clnt->trans_mod = v9fs_get_default_trans(); in p9_client_create()
1002 if (!clnt->trans_mod) { in p9_client_create()
1003 err = -EPROTONOSUPPORT; in p9_client_create()
1010 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version); in p9_client_create()
1012 err = clnt->trans_mod->create(clnt, dev_name, options); in p9_client_create()
1016 if (clnt->msize > clnt->trans_mod->maxsize) { in p9_client_create()
1017 clnt->msize = clnt->trans_mod->maxsize; in p9_client_create()
1020 clnt->msize, clnt->trans_mod->name in p9_client_create()
1024 if (clnt->msize < 4096) { in p9_client_create()
1027 err = -EINVAL; in p9_client_create()
1038 clnt->fcall_cache = in p9_client_create()
1039 kmem_cache_create_usercopy("9p-fcall-cache", clnt->msize, in p9_client_create()
1041 clnt->msize - (P9_HDRSZ + 4), in p9_client_create()
1047 clnt->trans_mod->close(clnt); in p9_client_create()
1049 v9fs_put_trans(clnt->trans_mod); in p9_client_create()
1063 if (clnt->trans_mod) in p9_client_destroy()
1064 clnt->trans_mod->close(clnt); in p9_client_destroy()
1066 v9fs_put_trans(clnt->trans_mod); in p9_client_destroy()
1068 idr_for_each_entry(&clnt->fids, fid, id) { in p9_client_destroy()
1069 pr_info("Found fid %d not clunked\n", fid->fid); in p9_client_destroy()
1075 kmem_cache_destroy(clnt->fcall_cache); in p9_client_destroy()
1083 clnt->status = Disconnected; in p9_client_disconnect()
1090 clnt->status = BeginDisconnect; in p9_client_begin_disconnect()
1104 afid ? afid->fid : -1, uname, aname); in p9_client_attach()
1107 err = -ENOMEM; in p9_client_attach()
1110 fid->uid = n_uname; in p9_client_attach()
1112 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid, in p9_client_attach()
1113 afid ? afid->fid : P9_NOFID, uname, aname, n_uname); in p9_client_attach()
1119 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", &qid); in p9_client_attach()
1121 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_attach()
1127 qid.type, qid.path, qid.version); in p9_client_attach()
1129 memmove(&fid->qid, &qid, sizeof(struct p9_qid)); in p9_client_attach()
1152 clnt = oldfid->clnt; in p9_client_walk()
1156 err = -ENOMEM; in p9_client_walk()
1160 fid->uid = oldfid->uid; in p9_client_walk()
1166 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL); in p9_client_walk()
1167 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid, in p9_client_walk()
1174 err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids); in p9_client_walk()
1176 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_walk()
1185 err = -ENOENT; in p9_client_walk()
1193 wqids[count].version); in p9_client_walk()
1196 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid)); in p9_client_walk()
1198 memmove(&fid->qid, &oldfid->qid, sizeof(struct p9_qid)); in p9_client_walk()
1224 clnt = fid->clnt; in p9_client_open()
1226 p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode); in p9_client_open()
1228 if (fid->mode != -1) in p9_client_open()
1229 return -EINVAL; in p9_client_open()
1232 req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode & P9L_MODE_MASK); in p9_client_open()
1234 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode & P9L_MODE_MASK); in p9_client_open()
1240 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit); in p9_client_open()
1242 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_open()
1248 qid.path, qid.version, iounit); in p9_client_open()
1250 memmove(&fid->qid, &qid, sizeof(struct p9_qid)); in p9_client_open()
1251 fid->mode = mode; in p9_client_open()
1252 fid->iounit = iounit; in p9_client_open()
1261 int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags, in p9_client_create_dotl() argument
1270 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n", in p9_client_create_dotl()
1271 ofid->fid, name, flags, mode, in p9_client_create_dotl()
1273 clnt = ofid->clnt; in p9_client_create_dotl()
1275 if (ofid->mode != -1) in p9_client_create_dotl()
1276 return -EINVAL; in p9_client_create_dotl()
1278 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags, in p9_client_create_dotl()
1285 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit); in p9_client_create_dotl()
1287 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_create_dotl()
1292 qid->type, qid->path, qid->version, iounit); in p9_client_create_dotl()
1294 memmove(&ofid->qid, qid, sizeof(struct p9_qid)); in p9_client_create_dotl()
1295 ofid->mode = flags; in p9_client_create_dotl()
1296 ofid->iounit = iounit; in p9_client_create_dotl()
1305 int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode, in p9_client_fcreate() argument
1314 p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n", in p9_client_fcreate()
1315 fid->fid, name, perm, mode); in p9_client_fcreate()
1316 clnt = fid->clnt; in p9_client_fcreate()
1318 if (fid->mode != -1) in p9_client_fcreate()
1319 return -EINVAL; in p9_client_fcreate()
1321 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm, in p9_client_fcreate()
1328 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit); in p9_client_fcreate()
1330 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_fcreate()
1335 qid.type, qid.path, qid.version, iounit); in p9_client_fcreate()
1337 memmove(&fid->qid, &qid, sizeof(struct p9_qid)); in p9_client_fcreate()
1338 fid->mode = mode; in p9_client_fcreate()
1339 fid->iounit = iounit; in p9_client_fcreate()
1348 int p9_client_symlink(struct p9_fid *dfid, const char *name, in p9_client_symlink() argument
1355 p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n", in p9_client_symlink()
1356 dfid->fid, name, symtgt); in p9_client_symlink()
1357 clnt = dfid->clnt; in p9_client_symlink()
1359 req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt, in p9_client_symlink()
1366 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid); in p9_client_symlink()
1368 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_symlink()
1373 qid->type, qid->path, qid->version); in p9_client_symlink()
1388 dfid->fid, oldfid->fid, newname); in p9_client_link()
1389 clnt = dfid->clnt; in p9_client_link()
1390 req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid, in p9_client_link()
1408 fid->fid, datasync); in p9_client_fsync()
1409 clnt = fid->clnt; in p9_client_fsync()
1411 req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync); in p9_client_fsync()
1417 p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid); in p9_client_fsync()
1435 fid->fid, retries); in p9_client_clunk()
1436 clnt = fid->clnt; in p9_client_clunk()
1438 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid); in p9_client_clunk()
1444 p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid); in p9_client_clunk()
1452 if (err == -ERESTARTSYS) { in p9_client_clunk()
1468 p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid); in p9_client_remove()
1469 clnt = fid->clnt; in p9_client_remove()
1471 req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid); in p9_client_remove()
1477 p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid); in p9_client_remove()
1481 if (err == -ERESTARTSYS) in p9_client_remove()
1489 int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags) in p9_client_unlinkat() argument
1496 dfid->fid, name, flags); in p9_client_unlinkat()
1498 clnt = dfid->clnt; in p9_client_unlinkat()
1499 req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags); in p9_client_unlinkat()
1504 p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name); in p9_client_unlinkat()
1535 struct p9_client *clnt = fid->clnt; in p9_client_read_once()
1543 fid->fid, offset, iov_iter_count(to)); in p9_client_read_once()
1545 rsize = fid->iounit; in p9_client_read_once()
1546 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ) in p9_client_read_once()
1547 rsize = clnt->msize - P9_IOHDRSZ; in p9_client_read_once()
1553 if (clnt->trans_mod->zc_request && rsize > 1024) { in p9_client_read_once()
1558 0, 11, "dqd", fid->fid, in p9_client_read_once()
1562 req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, in p9_client_read_once()
1568 iov_iter_revert(to, count - iov_iter_count(to)); in p9_client_read_once()
1572 *err = p9pdu_readf(&req->rc, clnt->proto_version, in p9_client_read_once()
1576 iov_iter_revert(to, count - iov_iter_count(to)); in p9_client_read_once()
1577 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_read_once()
1592 *err = -EFAULT; in p9_client_read_once()
1597 iov_iter_revert(to, count - received - iov_iter_count(to)); in p9_client_read_once()
1607 struct p9_client *clnt = fid->clnt; in p9_client_write()
1613 fid->fid, offset, iov_iter_count(from)); in p9_client_write()
1617 int rsize = fid->iounit; in p9_client_write()
1620 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ) in p9_client_write()
1621 rsize = clnt->msize - P9_IOHDRSZ; in p9_client_write()
1627 if (clnt->trans_mod->zc_request && rsize > 1024) { in p9_client_write()
1630 fid->fid, offset, rsize); in p9_client_write()
1632 req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid, in p9_client_write()
1636 iov_iter_revert(from, count - iov_iter_count(from)); in p9_client_write()
1641 *err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &written); in p9_client_write()
1643 iov_iter_revert(from, count - iov_iter_count(from)); in p9_client_write()
1644 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_write()
1656 iov_iter_revert(from, count - written - iov_iter_count(from)); in p9_client_write()
1672 p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid); in p9_client_stat()
1676 return ERR_PTR(-ENOMEM); in p9_client_stat()
1678 clnt = fid->clnt; in p9_client_stat()
1680 req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid); in p9_client_stat()
1686 err = p9pdu_readf(&req->rc, clnt->proto_version, "wS", &ignored, ret); in p9_client_stat()
1688 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_stat()
1696 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n" in p9_client_stat()
1698 ret->size, ret->type, ret->dev, ret->qid.type, ret->qid.path, in p9_client_stat()
1699 ret->qid.version, ret->mode, in p9_client_stat()
1700 ret->atime, ret->mtime, ret->length, in p9_client_stat()
1701 ret->name, ret->uid, ret->gid, ret->muid, ret->extension, in p9_client_stat()
1702 from_kuid(&init_user_ns, ret->n_uid), in p9_client_stat()
1703 from_kgid(&init_user_ns, ret->n_gid), in p9_client_stat()
1704 from_kuid(&init_user_ns, ret->n_muid)); in p9_client_stat()
1724 fid->fid, request_mask); in p9_client_getattr_dotl()
1728 return ERR_PTR(-ENOMEM); in p9_client_getattr_dotl()
1730 clnt = fid->clnt; in p9_client_getattr_dotl()
1732 req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask); in p9_client_getattr_dotl()
1738 err = p9pdu_readf(&req->rc, clnt->proto_version, "A", ret); in p9_client_getattr_dotl()
1740 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_getattr_dotl()
1755 ret->st_result_mask, in p9_client_getattr_dotl()
1756 ret->qid.type, ret->qid.path, ret->qid.version, in p9_client_getattr_dotl()
1757 ret->st_mode, ret->st_nlink, in p9_client_getattr_dotl()
1758 from_kuid(&init_user_ns, ret->st_uid), in p9_client_getattr_dotl()
1759 from_kgid(&init_user_ns, ret->st_gid), in p9_client_getattr_dotl()
1760 ret->st_rdev, ret->st_size, ret->st_blksize, ret->st_blocks, in p9_client_getattr_dotl()
1761 ret->st_atime_sec, ret->st_atime_nsec, in p9_client_getattr_dotl()
1762 ret->st_mtime_sec, ret->st_mtime_nsec, in p9_client_getattr_dotl()
1763 ret->st_ctime_sec, ret->st_ctime_nsec, in p9_client_getattr_dotl()
1764 ret->st_btime_sec, ret->st_btime_nsec, in p9_client_getattr_dotl()
1765 ret->st_gen, ret->st_data_version); in p9_client_getattr_dotl()
1783 /* name[s] uid[s] gid[s] muid[s] */ in p9_client_statsize()
1786 if (wst->name) in p9_client_statsize()
1787 ret += strlen(wst->name); in p9_client_statsize()
1788 if (wst->uid) in p9_client_statsize()
1789 ret += strlen(wst->uid); in p9_client_statsize()
1790 if (wst->gid) in p9_client_statsize()
1791 ret += strlen(wst->gid); in p9_client_statsize()
1792 if (wst->muid) in p9_client_statsize()
1793 ret += strlen(wst->muid); in p9_client_statsize()
1799 if (wst->extension) in p9_client_statsize()
1800 ret += strlen(wst->extension); in p9_client_statsize()
1812 clnt = fid->clnt; in p9_client_wstat()
1813 wst->size = p9_client_statsize(wst, clnt->proto_version); in p9_client_wstat()
1815 fid->fid); in p9_client_wstat()
1819 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n" in p9_client_wstat()
1821 wst->size, wst->type, wst->dev, wst->qid.type, in p9_client_wstat()
1822 wst->qid.path, wst->qid.version, in p9_client_wstat()
1823 wst->mode, wst->atime, wst->mtime, wst->length, in p9_client_wstat()
1824 wst->name, wst->uid, wst->gid, wst->muid, wst->extension, in p9_client_wstat()
1825 from_kuid(&init_user_ns, wst->n_uid), in p9_client_wstat()
1826 from_kgid(&init_user_ns, wst->n_gid), in p9_client_wstat()
1827 from_kuid(&init_user_ns, wst->n_muid)); in p9_client_wstat()
1830 fid->fid, wst->size + 2, wst); in p9_client_wstat()
1836 p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid); in p9_client_wstat()
1850 clnt = fid->clnt; in p9_client_setattr()
1851 p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid); in p9_client_setattr()
1853 p9attr->valid, p9attr->mode, in p9_client_setattr()
1854 from_kuid(&init_user_ns, p9attr->uid), in p9_client_setattr()
1855 from_kgid(&init_user_ns, p9attr->gid), in p9_client_setattr()
1856 p9attr->size); in p9_client_setattr()
1858 p9attr->atime_sec, p9attr->atime_nsec); in p9_client_setattr()
1860 p9attr->mtime_sec, p9attr->mtime_nsec); in p9_client_setattr()
1862 req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr); in p9_client_setattr()
1868 p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid); in p9_client_setattr()
1881 clnt = fid->clnt; in p9_client_statfs()
1883 p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid); in p9_client_statfs()
1885 req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid); in p9_client_statfs()
1891 err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type, in p9_client_statfs()
1892 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail, in p9_client_statfs()
1893 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen); in p9_client_statfs()
1895 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_statfs()
1902 fid->fid, sb->type, sb->bsize, sb->blocks, sb->bfree, in p9_client_statfs()
1903 sb->bavail, sb->files, sb->ffree, sb->fsid, sb->namelen); in p9_client_statfs()
1912 struct p9_fid *newdirfid, const char *name) in p9_client_rename() argument
1918 clnt = fid->clnt; in p9_client_rename()
1920 p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n", in p9_client_rename()
1921 fid->fid, newdirfid->fid, name); in p9_client_rename()
1923 req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid, in p9_client_rename()
1924 newdirfid->fid, name); in p9_client_rename()
1930 p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid); in p9_client_rename()
1945 clnt = olddirfid->clnt; in p9_client_renameat()
1948 ">>> TRENAMEAT olddirfid %d old name %s newdirfid %d new name %s\n", in p9_client_renameat()
1949 olddirfid->fid, old_name, newdirfid->fid, new_name); in p9_client_renameat()
1951 req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid, in p9_client_renameat()
1952 old_name, newdirfid->fid, new_name); in p9_client_renameat()
1958 p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n", in p9_client_renameat()
1959 newdirfid->fid, new_name); in p9_client_renameat()
1977 clnt = file_fid->clnt; in p9_client_xattrwalk()
1980 err = -ENOMEM; in p9_client_xattrwalk()
1984 ">>> TXATTRWALK file_fid %d, attr_fid %d name '%s'\n", in p9_client_xattrwalk()
1985 file_fid->fid, attr_fid->fid, attr_name); in p9_client_xattrwalk()
1988 file_fid->fid, attr_fid->fid, attr_name); in p9_client_xattrwalk()
1993 err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size); in p9_client_xattrwalk()
1995 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_xattrwalk()
2001 attr_fid->fid, *attr_size); in p9_client_xattrwalk()
2014 int p9_client_xattrcreate(struct p9_fid *fid, const char *name, in p9_client_xattrcreate() argument
2022 ">>> TXATTRCREATE fid %d name %s size %llu flag %d\n", in p9_client_xattrcreate()
2023 fid->fid, name, attr_size, flags); in p9_client_xattrcreate()
2024 clnt = fid->clnt; in p9_client_xattrcreate()
2026 fid->fid, name, attr_size, flags); in p9_client_xattrcreate()
2031 p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid); in p9_client_xattrcreate()
2050 fid->fid, offset, count); in p9_client_readdir()
2052 clnt = fid->clnt; in p9_client_readdir()
2054 rsize = fid->iounit; in p9_client_readdir()
2055 if (!rsize || rsize > clnt->msize - P9_READDIRHDRSZ) in p9_client_readdir()
2056 rsize = clnt->msize - P9_READDIRHDRSZ; in p9_client_readdir()
2062 if (clnt->trans_mod->zc_request && rsize > 1024) { in p9_client_readdir()
2067 11, "dqd", fid->fid, offset, rsize); in p9_client_readdir()
2070 req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid, in p9_client_readdir()
2078 err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr); in p9_client_readdir()
2080 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_readdir()
2103 int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode, in p9_client_mknod_dotl() argument
2110 clnt = fid->clnt; in p9_client_mknod_dotl()
2112 ">>> TMKNOD fid %d name %s mode %d major %d minor %d\n", in p9_client_mknod_dotl()
2113 fid->fid, name, mode, MAJOR(rdev), MINOR(rdev)); in p9_client_mknod_dotl()
2114 req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode, in p9_client_mknod_dotl()
2119 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid); in p9_client_mknod_dotl()
2121 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_mknod_dotl()
2125 qid->type, qid->path, qid->version); in p9_client_mknod_dotl()
2133 int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode, in p9_client_mkdir_dotl() argument
2140 clnt = fid->clnt; in p9_client_mkdir_dotl()
2141 p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n", in p9_client_mkdir_dotl()
2142 fid->fid, name, mode, from_kgid(&init_user_ns, gid)); in p9_client_mkdir_dotl()
2144 fid->fid, name, mode, gid); in p9_client_mkdir_dotl()
2148 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid); in p9_client_mkdir_dotl()
2150 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_mkdir_dotl()
2153 p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type, in p9_client_mkdir_dotl()
2154 qid->path, qid->version); in p9_client_mkdir_dotl()
2168 clnt = fid->clnt; in p9_client_lock_dotl()
2171 fid->fid, flock->type, flock->flags, flock->start, in p9_client_lock_dotl()
2172 flock->length, flock->proc_id, flock->client_id); in p9_client_lock_dotl()
2174 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type, in p9_client_lock_dotl()
2175 flock->flags, flock->start, flock->length, in p9_client_lock_dotl()
2176 flock->proc_id, flock->client_id); in p9_client_lock_dotl()
2181 err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status); in p9_client_lock_dotl()
2183 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_lock_dotl()
2199 clnt = fid->clnt; in p9_client_getlock_dotl()
2202 fid->fid, glock->type, glock->start, glock->length, in p9_client_getlock_dotl()
2203 glock->proc_id, glock->client_id); in p9_client_getlock_dotl()
2205 req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid, in p9_client_getlock_dotl()
2206 glock->type, glock->start, glock->length, in p9_client_getlock_dotl()
2207 glock->proc_id, glock->client_id); in p9_client_getlock_dotl()
2212 err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type, in p9_client_getlock_dotl()
2213 &glock->start, &glock->length, &glock->proc_id, in p9_client_getlock_dotl()
2214 &glock->client_id); in p9_client_getlock_dotl()
2216 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_getlock_dotl()
2221 glock->type, glock->start, glock->length, in p9_client_getlock_dotl()
2222 glock->proc_id, glock->client_id); in p9_client_getlock_dotl()
2235 clnt = fid->clnt; in p9_client_readlink()
2236 p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid); in p9_client_readlink()
2238 req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid); in p9_client_readlink()
2242 err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target); in p9_client_readlink()
2244 trace_9p_protocol_dump(clnt, &req->rc); in p9_client_readlink()
2257 return p9_req_cache ? 0 : -ENOMEM; in p9_client_init()