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