Lines Matching +full:dsd +full:- +full:path
1 // SPDX-License-Identifier: GPL-2.0-only
39 * - a little lazy - parse all client options
60 return clnt->proto_version == p9_proto_2000L;
66 return clnt->proto_version == p9_proto_2000u;
72 if (clnt->msize != DEFAULT_MSIZE)
73 seq_printf(m, ",msize=%u", clnt->msize);
74 seq_printf(m, ",trans=%s", clnt->trans_mod->name);
76 switch (clnt->proto_version) {
88 if (clnt->trans_mod->show_options)
89 return clnt->trans_mod->show_options(m, clnt);
99 if (err > 0 || err < -MAX_ERRNO) {
101 return -EPROTO;
109 int version = -EINVAL;
128 * parse_opts - parse mount options into client structure
132 * Return 0 upon success, -ERRNO upon failure
144 clnt->proto_version = p9_proto_2000L;
145 clnt->msize = DEFAULT_MSIZE;
152 return -ENOMEM;
173 ret = -EINVAL;
176 clnt->msize = option;
181 ret = -ENOMEM;
187 v9fs_put_trans(clnt->trans_mod);
188 clnt->trans_mod = v9fs_get_trans_by_name(s);
189 if (!clnt->trans_mod) {
192 ret = -EINVAL;
197 clnt->proto_version = p9_proto_legacy;
202 ret = -ENOMEM;
211 clnt->proto_version = r;
221 v9fs_put_trans(clnt->trans_mod);
229 if (likely(c->fcall_cache) && alloc_msize == c->msize) {
230 fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS);
231 fc->cache = c->fcall_cache;
233 fc->sdata = kmalloc(alloc_msize, GFP_NOFS);
234 fc->cache = NULL;
236 if (!fc->sdata)
237 return -ENOMEM;
238 fc->capacity = alloc_msize;
239 fc->id = 0;
240 fc->tag = P9_NOTAG;
247 * and kmem_cache_free does not do NULL-check for us
249 if (unlikely(!fc->sdata))
252 if (fc->cache)
253 kmem_cache_free(fc->cache, fc->sdata);
255 kfree(fc->sdata);
262 * p9_tag_alloc - Allocate a new request.
288 alloc_tsize = min_t(size_t, c->msize,
292 alloc_rsize = min_t(size_t, c->msize,
296 return ERR_PTR(-ENOMEM);
298 if (p9_fcall_init(c, &req->tc, alloc_tsize))
300 if (p9_fcall_init(c, &req->rc, alloc_rsize))
303 p9pdu_reset(&req->tc);
304 p9pdu_reset(&req->rc);
305 req->t_err = 0;
306 req->status = REQ_STATUS_ALLOC;
311 refcount_set(&req->refcount, 0);
312 init_waitqueue_head(&req->wq);
313 INIT_LIST_HEAD(&req->req_list);
316 spin_lock_irq(&c->lock);
318 tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1,
321 tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT);
322 req->tc.tag = tag;
323 spin_unlock_irq(&c->lock);
338 refcount_set(&req->refcount, 2);
343 p9_fcall_fini(&req->tc);
344 p9_fcall_fini(&req->rc);
347 return ERR_PTR(-ENOMEM);
351 * p9_tag_lookup - Look up a request by tag.
364 req = idr_find(&c->reqs, tag);
373 if (req->tc.tag != tag) {
385 * p9_tag_remove - Remove a tag.
394 u16 tag = r->tc.tag;
397 spin_lock_irqsave(&c->lock, flags);
398 idr_remove(&c->reqs, tag);
399 spin_unlock_irqrestore(&c->lock, flags);
404 if (refcount_dec_and_test(&r->refcount)) {
407 p9_fcall_fini(&r->tc);
408 p9_fcall_fini(&r->rc);
417 * p9_tag_cleanup - cleans up tags structure and reclaims resources
429 idr_for_each_entry(&c->reqs, req, id) {
433 req->tc.tag);
439 * p9_client_cb - call back from transport to client
447 p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag);
453 WRITE_ONCE(req->status, status);
455 wake_up(&req->wq);
456 p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag);
462 * p9_parse_header - parse header arguments out of a packet
477 int offset = pdu->offset;
480 pdu->offset = 0;
493 if (pdu->size != r_size || r_size < 7) {
494 err = -EINVAL;
498 pdu->id = r_type;
499 pdu->tag = r_tag;
502 pdu->size, pdu->id, pdu->tag);
506 pdu->offset = offset;
512 * p9_check_errors - check 9p packet for error return and process it
528 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
529 if (req->rc.size > req->rc.capacity && !req->rc.zc) {
531 req->rc.size, req->rc.capacity, req->rc.id);
532 return -EIO;
537 trace_9p_protocol_dump(c, &req->rc);
548 err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
556 err = -ecode;
562 -ecode, ename);
566 err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode);
569 err = -ecode;
571 p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
586 * p9_client_flush - flush (cancel) a request
603 err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1);
616 if (READ_ONCE(oldreq->status) == REQ_STATUS_SENT) {
617 if (c->trans_mod->cancelled)
618 c->trans_mod->cancelled(c, oldreq);
636 if (c->status == Disconnected)
637 return ERR_PTR(-EIO);
640 if (c->status == BeginDisconnect && type != P9_TCLUNK)
641 return ERR_PTR(-EIO);
650 p9pdu_prepare(&req->tc, req->tc.tag, type);
651 err = p9pdu_vwritef(&req->tc, c->proto_version, fmt, ap);
654 p9pdu_finalize(c, &req->tc);
655 trace_9p_client_req(c, type, req->tc.tag);
665 * p9_client_rpc - issue a request and wait for a response
688 const uint rsize = c->trans_mod->pooled_rbuffers ? c->msize : 0;
696 req->tc.zc = false;
697 req->rc.zc = false;
706 err = c->trans_mod->request(c, req);
710 if (err != -ERESTARTSYS && err != -EFAULT)
711 c->status = Disconnected;
716 err = wait_event_killable(req->wq,
717 READ_ONCE(req->status) >= REQ_STATUS_RCVD);
720 * threads - echoes to wmb() in the callback
724 if (err == -ERESTARTSYS && c->status == Connected &&
731 if (READ_ONCE(req->status) == REQ_STATUS_ERROR) {
732 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
733 err = req->t_err;
735 if (err == -ERESTARTSYS && c->status == Connected) {
740 if (c->trans_mod->cancel(c, req))
744 if (READ_ONCE(req->status) == REQ_STATUS_RCVD)
749 spin_lock_irqsave(¤t->sighand->siglock, flags);
751 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
757 trace_9p_client_res(c, type, req->rc.tag, err);
766 * p9_client_zc_rpc - issue a request and wait for a response
791 * The actual content is passed in zero-copy fashion.
798 req->tc.zc = true;
799 req->rc.zc = true;
808 err = c->trans_mod->zc_request(c, req, uidata, uodata,
811 if (err == -EIO)
812 c->status = Disconnected;
813 if (err != -ERESTARTSYS)
816 if (READ_ONCE(req->status) == REQ_STATUS_ERROR) {
817 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
818 err = req->t_err;
820 if (err == -ERESTARTSYS && c->status == Connected) {
825 if (c->trans_mod->cancel(c, req))
829 if (READ_ONCE(req->status) == REQ_STATUS_RCVD)
834 spin_lock_irqsave(¤t->sighand->siglock, flags);
836 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
842 trace_9p_client_res(c, type, req->rc.tag, err);
860 fid->mode = -1;
861 fid->uid = current_fsuid();
862 fid->clnt = clnt;
863 refcount_set(&fid->count, 1);
866 spin_lock_irq(&clnt->lock);
867 ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1,
869 spin_unlock_irq(&clnt->lock);
885 p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid);
887 clnt = fid->clnt;
888 spin_lock_irqsave(&clnt->lock, flags);
889 idr_remove(&clnt->fids, fid->fid);
890 spin_unlock_irqrestore(&clnt->lock, flags);
891 kfree(fid->rdir);
918 c->msize, c->proto_version);
920 switch (c->proto_version) {
923 c->msize, "9P2000.L");
927 c->msize, "9P2000.u");
931 c->msize, "9P2000");
934 return -EINVAL;
940 err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version);
943 trace_9p_protocol_dump(c, &req->rc);
949 c->proto_version = p9_proto_2000L;
951 c->proto_version = p9_proto_2000u;
953 c->proto_version = p9_proto_legacy;
957 err = -EREMOTEIO;
964 err = -EREMOTEIO;
967 if (msize < c->msize)
968 c->msize = msize;
987 return ERR_PTR(-ENOMEM);
989 clnt->trans_mod = NULL;
990 clnt->trans = NULL;
991 clnt->fcall_cache = NULL;
993 client_id = utsname()->nodename;
994 memcpy(clnt->name, client_id, strlen(client_id) + 1);
996 spin_lock_init(&clnt->lock);
997 idr_init(&clnt->fids);
998 idr_init(&clnt->reqs);
1004 if (!clnt->trans_mod)
1005 clnt->trans_mod = v9fs_get_default_trans();
1007 if (!clnt->trans_mod) {
1008 err = -EPROTONOSUPPORT;
1015 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
1017 err = clnt->trans_mod->create(clnt, dev_name, options);
1021 if (clnt->msize > clnt->trans_mod->maxsize) {
1022 clnt->msize = clnt->trans_mod->maxsize;
1025 clnt->msize, clnt->trans_mod->name
1029 if (clnt->msize < 4096) {
1032 err = -EINVAL;
1041 "9p-fcall-cache-%u", atomic_inc_return(&seqno));
1043 err = -ENOMEM;
1050 clnt->fcall_cache =
1051 kmem_cache_create_usercopy(cache_name, clnt->msize,
1053 clnt->msize - (P9_HDRSZ + 4),
1060 clnt->trans_mod->close(clnt);
1062 v9fs_put_trans(clnt->trans_mod);
1076 if (clnt->trans_mod)
1077 clnt->trans_mod->close(clnt);
1079 v9fs_put_trans(clnt->trans_mod);
1081 idr_for_each_entry(&clnt->fids, fid, id) {
1082 pr_info("Found fid %d not clunked\n", fid->fid);
1088 kmem_cache_destroy(clnt->fcall_cache);
1096 clnt->status = Disconnected;
1103 clnt->status = BeginDisconnect;
1117 afid ? afid->fid : -1, uname, aname);
1120 err = -ENOMEM;
1123 fid->uid = n_uname;
1125 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
1126 afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
1132 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", &qid);
1134 trace_9p_protocol_dump(clnt, &req->rc);
1140 qid.type, qid.path, qid.version);
1142 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1165 clnt = oldfid->clnt;
1169 err = -ENOMEM;
1173 fid->uid = oldfid->uid;
1179 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
1180 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
1187 err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids);
1189 trace_9p_protocol_dump(clnt, &req->rc);
1198 err = -ENOENT;
1205 wqids[count].path,
1209 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
1211 memmove(&fid->qid, &oldfid->qid, sizeof(struct p9_qid));
1237 clnt = fid->clnt;
1239 p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
1241 if (fid->mode != -1)
1242 return -EINVAL;
1245 req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode & P9L_MODE_MASK);
1247 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode & P9L_MODE_MASK);
1253 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1255 trace_9p_protocol_dump(clnt, &req->rc);
1261 qid.path, qid.version, iounit);
1263 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1264 fid->mode = mode;
1265 fid->iounit = iounit;
1284 ofid->fid, name, flags, mode,
1286 clnt = ofid->clnt;
1288 if (ofid->mode != -1)
1289 return -EINVAL;
1291 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
1298 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit);
1300 trace_9p_protocol_dump(clnt, &req->rc);
1305 qid->type, qid->path, qid->version, iounit);
1307 memmove(&ofid->qid, qid, sizeof(struct p9_qid));
1308 ofid->mode = flags;
1309 ofid->iounit = iounit;
1328 fid->fid, name, perm, mode);
1329 clnt = fid->clnt;
1331 if (fid->mode != -1)
1332 return -EINVAL;
1334 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1341 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1343 trace_9p_protocol_dump(clnt, &req->rc);
1348 qid.type, qid.path, qid.version, iounit);
1350 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
1351 fid->mode = mode;
1352 fid->iounit = iounit;
1369 dfid->fid, name, symtgt);
1370 clnt = dfid->clnt;
1372 req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
1379 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
1381 trace_9p_protocol_dump(clnt, &req->rc);
1386 qid->type, qid->path, qid->version);
1401 dfid->fid, oldfid->fid, newname);
1402 clnt = dfid->clnt;
1403 req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
1421 fid->fid, datasync);
1422 clnt = fid->clnt;
1424 req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
1430 p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);
1448 fid->fid, retries);
1449 clnt = fid->clnt;
1451 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1457 p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1465 if (err == -ERESTARTSYS) {
1481 p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1482 clnt = fid->clnt;
1484 req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1490 p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1494 if (err == -ERESTARTSYS)
1509 dfid->fid, name, flags);
1511 clnt = dfid->clnt;
1512 req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
1517 p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
1548 struct p9_client *clnt = fid->clnt;
1557 fid->fid, offset, iov_iter_count(to));
1559 rsize = fid->iounit;
1560 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ)
1561 rsize = clnt->msize - P9_IOHDRSZ;
1567 if (clnt->trans_mod->zc_request && rsize > 1024) {
1572 0, 11, "dqd", fid->fid,
1576 req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
1582 iov_iter_revert(to, count - iov_iter_count(to));
1586 *err = p9pdu_readf(&req->rc, clnt->proto_version,
1590 iov_iter_revert(to, count - iov_iter_count(to));
1591 trace_9p_protocol_dump(clnt, &req->rc);
1597 *err = -EIO;
1608 *err = -EFAULT;
1613 iov_iter_revert(to, count - received - iov_iter_count(to));
1623 struct p9_client *clnt = fid->clnt;
1630 u32 rsize = fid->iounit;
1633 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ)
1634 rsize = clnt->msize - P9_IOHDRSZ;
1640 fid->fid, offset, rsize, count);
1643 if (clnt->trans_mod->zc_request && rsize > 1024) {
1646 fid->fid, offset, rsize);
1648 req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
1652 iov_iter_revert(from, count - iov_iter_count(from));
1657 *err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &written);
1659 iov_iter_revert(from, count - iov_iter_count(from));
1660 trace_9p_protocol_dump(clnt, &req->rc);
1666 *err = -EIO;
1667 iov_iter_revert(from, count - iov_iter_count(from));
1675 iov_iter_revert(from, count - written - iov_iter_count(from));
1686 struct netfs_io_request *wreq = subreq->rreq;
1687 struct p9_fid *fid = wreq->netfs_priv;
1688 struct p9_client *clnt = fid->clnt;
1690 unsigned long long start = subreq->start + subreq->transferred;
1691 int written, len = subreq->len - subreq->transferred;
1695 fid->fid, start, len);
1698 if (clnt->trans_mod->zc_request && len > 1024) {
1699 req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, &subreq->io_iter,
1700 0, wreq->len, P9_ZC_HDR_SZ, "dqd",
1701 fid->fid, start, len);
1703 req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
1704 start, len, &subreq->io_iter);
1711 err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &written);
1713 trace_9p_protocol_dump(clnt, &req->rc);
1721 written = -EIO;
1739 p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1743 return ERR_PTR(-ENOMEM);
1745 clnt = fid->clnt;
1747 req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1753 err = p9pdu_readf(&req->rc, clnt->proto_version, "wS", &ignored, ret);
1755 trace_9p_protocol_dump(clnt, &req->rc);
1765 ret->size, ret->type, ret->dev, ret->qid.type, ret->qid.path,
1766 ret->qid.version, ret->mode,
1767 ret->atime, ret->mtime, ret->length,
1768 ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
1769 from_kuid(&init_user_ns, ret->n_uid),
1770 from_kgid(&init_user_ns, ret->n_gid),
1771 from_kuid(&init_user_ns, ret->n_muid));
1791 fid->fid, request_mask);
1795 return ERR_PTR(-ENOMEM);
1797 clnt = fid->clnt;
1799 req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
1805 err = p9pdu_readf(&req->rc, clnt->proto_version, "A", ret);
1807 trace_9p_protocol_dump(clnt, &req->rc);
1822 ret->st_result_mask,
1823 ret->qid.type, ret->qid.path, ret->qid.version,
1824 ret->st_mode, ret->st_nlink,
1825 from_kuid(&init_user_ns, ret->st_uid),
1826 from_kgid(&init_user_ns, ret->st_gid),
1827 ret->st_rdev, ret->st_size, ret->st_blksize, ret->st_blocks,
1828 ret->st_atime_sec, ret->st_atime_nsec,
1829 ret->st_mtime_sec, ret->st_mtime_nsec,
1830 ret->st_ctime_sec, ret->st_ctime_nsec,
1831 ret->st_btime_sec, ret->st_btime_nsec,
1832 ret->st_gen, ret->st_data_version);
1853 if (wst->name)
1854 ret += strlen(wst->name);
1855 if (wst->uid)
1856 ret += strlen(wst->uid);
1857 if (wst->gid)
1858 ret += strlen(wst->gid);
1859 if (wst->muid)
1860 ret += strlen(wst->muid);
1866 if (wst->extension)
1867 ret += strlen(wst->extension);
1879 clnt = fid->clnt;
1880 wst->size = p9_client_statsize(wst, clnt->proto_version);
1882 fid->fid);
1888 wst->size, wst->type, wst->dev, wst->qid.type,
1889 wst->qid.path, wst->qid.version,
1890 wst->mode, wst->atime, wst->mtime, wst->length,
1891 wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
1892 from_kuid(&init_user_ns, wst->n_uid),
1893 from_kgid(&init_user_ns, wst->n_gid),
1894 from_kuid(&init_user_ns, wst->n_muid));
1897 fid->fid, wst->size + 2, wst);
1903 p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1917 clnt = fid->clnt;
1918 p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
1920 p9attr->valid, p9attr->mode,
1921 from_kuid(&init_user_ns, p9attr->uid),
1922 from_kgid(&init_user_ns, p9attr->gid),
1923 p9attr->size);
1925 p9attr->atime_sec, p9attr->atime_nsec);
1927 p9attr->mtime_sec, p9attr->mtime_nsec);
1929 req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
1935 p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
1948 clnt = fid->clnt;
1950 p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
1952 req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
1958 err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
1959 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
1960 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
1962 trace_9p_protocol_dump(clnt, &req->rc);
1969 fid->fid, sb->type, sb->bsize, sb->blocks, sb->bfree,
1970 sb->bavail, sb->files, sb->ffree, sb->fsid, sb->namelen);
1985 clnt = fid->clnt;
1988 fid->fid, newdirfid->fid, name);
1990 req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
1991 newdirfid->fid, name);
1997 p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
2012 clnt = olddirfid->clnt;
2016 olddirfid->fid, old_name, newdirfid->fid, new_name);
2018 req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
2019 old_name, newdirfid->fid, new_name);
2026 newdirfid->fid, new_name);
2044 clnt = file_fid->clnt;
2047 err = -ENOMEM;
2052 file_fid->fid, attr_fid->fid, attr_name);
2055 file_fid->fid, attr_fid->fid, attr_name);
2060 err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size);
2062 trace_9p_protocol_dump(clnt, &req->rc);
2068 attr_fid->fid, *attr_size);
2090 fid->fid, name, attr_size, flags);
2091 clnt = fid->clnt;
2093 fid->fid, name, attr_size, flags);
2098 p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
2118 fid->fid, offset, count);
2120 clnt = fid->clnt;
2122 rsize = fid->iounit;
2123 if (!rsize || rsize > clnt->msize - P9_READDIRHDRSZ)
2124 rsize = clnt->msize - P9_READDIRHDRSZ;
2130 if (clnt->trans_mod->zc_request && rsize > 1024) {
2135 11, "dqd", fid->fid, offset, rsize);
2138 req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
2146 err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr);
2148 trace_9p_protocol_dump(clnt, &req->rc);
2153 err = -EIO;
2179 clnt = fid->clnt;
2182 fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
2183 req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
2188 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
2190 trace_9p_protocol_dump(clnt, &req->rc);
2194 qid->type, qid->path, qid->version);
2209 clnt = fid->clnt;
2211 fid->fid, name, mode, from_kgid(&init_user_ns, gid));
2213 fid->fid, name, mode, gid);
2217 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
2219 trace_9p_protocol_dump(clnt, &req->rc);
2222 p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
2223 qid->path, qid->version);
2237 clnt = fid->clnt;
2240 fid->fid, flock->type, flock->flags, flock->start,
2241 flock->length, flock->proc_id, flock->client_id);
2243 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
2244 flock->flags, flock->start, flock->length,
2245 flock->proc_id, flock->client_id);
2250 err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status);
2252 trace_9p_protocol_dump(clnt, &req->rc);
2268 clnt = fid->clnt;
2271 fid->fid, glock->type, glock->start, glock->length,
2272 glock->proc_id, glock->client_id);
2274 req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid,
2275 glock->type, glock->start, glock->length,
2276 glock->proc_id, glock->client_id);
2281 err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type,
2282 &glock->start, &glock->length, &glock->proc_id,
2283 &glock->client_id);
2285 trace_9p_protocol_dump(clnt, &req->rc);
2290 glock->type, glock->start, glock->length,
2291 glock->proc_id, glock->client_id);
2304 clnt = fid->clnt;
2305 p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);
2307 req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
2311 err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target);
2313 trace_9p_protocol_dump(clnt, &req->rc);
2326 return p9_req_cache ? 0 : -ENOMEM;