Loading...
1/*
2 * net/9p/protocol.c
3 *
4 * 9P Protocol Support Code
5 *
6 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 *
8 * Base on code from Anthony Liguori <aliguori@us.ibm.com>
9 * Copyright (C) 2008 by IBM, Corp.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2
13 * as published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to:
22 * Free Software Foundation
23 * 51 Franklin Street, Fifth Floor
24 * Boston, MA 02111-1301 USA
25 *
26 */
27
28#include <linux/module.h>
29#include <linux/errno.h>
30#include <linux/kernel.h>
31#include <linux/uaccess.h>
32#include <linux/slab.h>
33#include <linux/sched.h>
34#include <linux/stddef.h>
35#include <linux/types.h>
36#include <net/9p/9p.h>
37#include <net/9p/client.h>
38#include "protocol.h"
39
40static int
41p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
42
43#ifdef CONFIG_NET_9P_DEBUG
44void
45p9pdu_dump(int way, struct p9_fcall *pdu)
46{
47 int len = pdu->size;
48
49 if ((p9_debug_level & P9_DEBUG_VPKT) != P9_DEBUG_VPKT) {
50 if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT) {
51 if (len > 32)
52 len = 32;
53 } else {
54 /* shouldn't happen */
55 return;
56 }
57 }
58
59 if (way)
60 print_hex_dump_bytes("[9P] ", DUMP_PREFIX_OFFSET, pdu->sdata,
61 len);
62 else
63 print_hex_dump_bytes("]9P[ ", DUMP_PREFIX_OFFSET, pdu->sdata,
64 len);
65}
66#else
67void
68p9pdu_dump(int way, struct p9_fcall *pdu)
69{
70}
71#endif
72EXPORT_SYMBOL(p9pdu_dump);
73
74void p9stat_free(struct p9_wstat *stbuf)
75{
76 kfree(stbuf->name);
77 kfree(stbuf->uid);
78 kfree(stbuf->gid);
79 kfree(stbuf->muid);
80 kfree(stbuf->extension);
81}
82EXPORT_SYMBOL(p9stat_free);
83
84static size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
85{
86 size_t len = min(pdu->size - pdu->offset, size);
87 memcpy(data, &pdu->sdata[pdu->offset], len);
88 pdu->offset += len;
89 return size - len;
90}
91
92static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
93{
94 size_t len = min(pdu->capacity - pdu->size, size);
95 memcpy(&pdu->sdata[pdu->size], data, len);
96 pdu->size += len;
97 return size - len;
98}
99
100static size_t
101pdu_write_u(struct p9_fcall *pdu, const char __user *udata, size_t size)
102{
103 size_t len = min(pdu->capacity - pdu->size, size);
104 if (copy_from_user(&pdu->sdata[pdu->size], udata, len))
105 len = 0;
106
107 pdu->size += len;
108 return size - len;
109}
110
111static size_t
112pdu_write_urw(struct p9_fcall *pdu, const char *kdata, const char __user *udata,
113 size_t size)
114{
115 BUG_ON(pdu->size > P9_IOHDRSZ);
116 pdu->pubuf = (char __user *)udata;
117 pdu->pkbuf = (char *)kdata;
118 pdu->pbuf_size = size;
119 return 0;
120}
121
122static size_t
123pdu_write_readdir(struct p9_fcall *pdu, const char *kdata, size_t size)
124{
125 BUG_ON(pdu->size > P9_READDIRHDRSZ);
126 pdu->pkbuf = (char *)kdata;
127 pdu->pbuf_size = size;
128 return 0;
129}
130
131/*
132 b - int8_t
133 w - int16_t
134 d - int32_t
135 q - int64_t
136 s - string
137 S - stat
138 Q - qid
139 D - data blob (int32_t size followed by void *, results are not freed)
140 T - array of strings (int16_t count, followed by strings)
141 R - array of qids (int16_t count, followed by qids)
142 A - stat for 9p2000.L (p9_stat_dotl)
143 ? - if optional = 1, continue parsing
144*/
145
146static int
147p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
148 va_list ap)
149{
150 const char *ptr;
151 int errcode = 0;
152
153 for (ptr = fmt; *ptr; ptr++) {
154 switch (*ptr) {
155 case 'b':{
156 int8_t *val = va_arg(ap, int8_t *);
157 if (pdu_read(pdu, val, sizeof(*val))) {
158 errcode = -EFAULT;
159 break;
160 }
161 }
162 break;
163 case 'w':{
164 int16_t *val = va_arg(ap, int16_t *);
165 __le16 le_val;
166 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
167 errcode = -EFAULT;
168 break;
169 }
170 *val = le16_to_cpu(le_val);
171 }
172 break;
173 case 'd':{
174 int32_t *val = va_arg(ap, int32_t *);
175 __le32 le_val;
176 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
177 errcode = -EFAULT;
178 break;
179 }
180 *val = le32_to_cpu(le_val);
181 }
182 break;
183 case 'q':{
184 int64_t *val = va_arg(ap, int64_t *);
185 __le64 le_val;
186 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
187 errcode = -EFAULT;
188 break;
189 }
190 *val = le64_to_cpu(le_val);
191 }
192 break;
193 case 's':{
194 char **sptr = va_arg(ap, char **);
195 uint16_t len;
196
197 errcode = p9pdu_readf(pdu, proto_version,
198 "w", &len);
199 if (errcode)
200 break;
201
202 *sptr = kmalloc(len + 1, GFP_NOFS);
203 if (*sptr == NULL) {
204 errcode = -EFAULT;
205 break;
206 }
207 if (pdu_read(pdu, *sptr, len)) {
208 errcode = -EFAULT;
209 kfree(*sptr);
210 *sptr = NULL;
211 } else
212 (*sptr)[len] = 0;
213 }
214 break;
215 case 'Q':{
216 struct p9_qid *qid =
217 va_arg(ap, struct p9_qid *);
218
219 errcode = p9pdu_readf(pdu, proto_version, "bdq",
220 &qid->type, &qid->version,
221 &qid->path);
222 }
223 break;
224 case 'S':{
225 struct p9_wstat *stbuf =
226 va_arg(ap, struct p9_wstat *);
227
228 memset(stbuf, 0, sizeof(struct p9_wstat));
229 stbuf->n_uid = stbuf->n_gid = stbuf->n_muid =
230 -1;
231 errcode =
232 p9pdu_readf(pdu, proto_version,
233 "wwdQdddqssss?sddd",
234 &stbuf->size, &stbuf->type,
235 &stbuf->dev, &stbuf->qid,
236 &stbuf->mode, &stbuf->atime,
237 &stbuf->mtime, &stbuf->length,
238 &stbuf->name, &stbuf->uid,
239 &stbuf->gid, &stbuf->muid,
240 &stbuf->extension,
241 &stbuf->n_uid, &stbuf->n_gid,
242 &stbuf->n_muid);
243 if (errcode)
244 p9stat_free(stbuf);
245 }
246 break;
247 case 'D':{
248 uint32_t *count = va_arg(ap, uint32_t *);
249 void **data = va_arg(ap, void **);
250
251 errcode =
252 p9pdu_readf(pdu, proto_version, "d", count);
253 if (!errcode) {
254 *count =
255 min_t(uint32_t, *count,
256 pdu->size - pdu->offset);
257 *data = &pdu->sdata[pdu->offset];
258 }
259 }
260 break;
261 case 'T':{
262 uint16_t *nwname = va_arg(ap, uint16_t *);
263 char ***wnames = va_arg(ap, char ***);
264
265 errcode = p9pdu_readf(pdu, proto_version,
266 "w", nwname);
267 if (!errcode) {
268 *wnames =
269 kmalloc(sizeof(char *) * *nwname,
270 GFP_NOFS);
271 if (!*wnames)
272 errcode = -ENOMEM;
273 }
274
275 if (!errcode) {
276 int i;
277
278 for (i = 0; i < *nwname; i++) {
279 errcode =
280 p9pdu_readf(pdu,
281 proto_version,
282 "s",
283 &(*wnames)[i]);
284 if (errcode)
285 break;
286 }
287 }
288
289 if (errcode) {
290 if (*wnames) {
291 int i;
292
293 for (i = 0; i < *nwname; i++)
294 kfree((*wnames)[i]);
295 }
296 kfree(*wnames);
297 *wnames = NULL;
298 }
299 }
300 break;
301 case 'R':{
302 int16_t *nwqid = va_arg(ap, int16_t *);
303 struct p9_qid **wqids =
304 va_arg(ap, struct p9_qid **);
305
306 *wqids = NULL;
307
308 errcode =
309 p9pdu_readf(pdu, proto_version, "w", nwqid);
310 if (!errcode) {
311 *wqids =
312 kmalloc(*nwqid *
313 sizeof(struct p9_qid),
314 GFP_NOFS);
315 if (*wqids == NULL)
316 errcode = -ENOMEM;
317 }
318
319 if (!errcode) {
320 int i;
321
322 for (i = 0; i < *nwqid; i++) {
323 errcode =
324 p9pdu_readf(pdu,
325 proto_version,
326 "Q",
327 &(*wqids)[i]);
328 if (errcode)
329 break;
330 }
331 }
332
333 if (errcode) {
334 kfree(*wqids);
335 *wqids = NULL;
336 }
337 }
338 break;
339 case 'A': {
340 struct p9_stat_dotl *stbuf =
341 va_arg(ap, struct p9_stat_dotl *);
342
343 memset(stbuf, 0, sizeof(struct p9_stat_dotl));
344 errcode =
345 p9pdu_readf(pdu, proto_version,
346 "qQdddqqqqqqqqqqqqqqq",
347 &stbuf->st_result_mask,
348 &stbuf->qid,
349 &stbuf->st_mode,
350 &stbuf->st_uid, &stbuf->st_gid,
351 &stbuf->st_nlink,
352 &stbuf->st_rdev, &stbuf->st_size,
353 &stbuf->st_blksize, &stbuf->st_blocks,
354 &stbuf->st_atime_sec,
355 &stbuf->st_atime_nsec,
356 &stbuf->st_mtime_sec,
357 &stbuf->st_mtime_nsec,
358 &stbuf->st_ctime_sec,
359 &stbuf->st_ctime_nsec,
360 &stbuf->st_btime_sec,
361 &stbuf->st_btime_nsec,
362 &stbuf->st_gen,
363 &stbuf->st_data_version);
364 }
365 break;
366 case '?':
367 if ((proto_version != p9_proto_2000u) &&
368 (proto_version != p9_proto_2000L))
369 return 0;
370 break;
371 default:
372 BUG();
373 break;
374 }
375
376 if (errcode)
377 break;
378 }
379
380 return errcode;
381}
382
383int
384p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
385 va_list ap)
386{
387 const char *ptr;
388 int errcode = 0;
389
390 for (ptr = fmt; *ptr; ptr++) {
391 switch (*ptr) {
392 case 'b':{
393 int8_t val = va_arg(ap, int);
394 if (pdu_write(pdu, &val, sizeof(val)))
395 errcode = -EFAULT;
396 }
397 break;
398 case 'w':{
399 __le16 val = cpu_to_le16(va_arg(ap, int));
400 if (pdu_write(pdu, &val, sizeof(val)))
401 errcode = -EFAULT;
402 }
403 break;
404 case 'd':{
405 __le32 val = cpu_to_le32(va_arg(ap, int32_t));
406 if (pdu_write(pdu, &val, sizeof(val)))
407 errcode = -EFAULT;
408 }
409 break;
410 case 'q':{
411 __le64 val = cpu_to_le64(va_arg(ap, int64_t));
412 if (pdu_write(pdu, &val, sizeof(val)))
413 errcode = -EFAULT;
414 }
415 break;
416 case 's':{
417 const char *sptr = va_arg(ap, const char *);
418 uint16_t len = 0;
419 if (sptr)
420 len = min_t(uint16_t, strlen(sptr),
421 USHRT_MAX);
422
423 errcode = p9pdu_writef(pdu, proto_version,
424 "w", len);
425 if (!errcode && pdu_write(pdu, sptr, len))
426 errcode = -EFAULT;
427 }
428 break;
429 case 'Q':{
430 const struct p9_qid *qid =
431 va_arg(ap, const struct p9_qid *);
432 errcode =
433 p9pdu_writef(pdu, proto_version, "bdq",
434 qid->type, qid->version,
435 qid->path);
436 } break;
437 case 'S':{
438 const struct p9_wstat *stbuf =
439 va_arg(ap, const struct p9_wstat *);
440 errcode =
441 p9pdu_writef(pdu, proto_version,
442 "wwdQdddqssss?sddd",
443 stbuf->size, stbuf->type,
444 stbuf->dev, &stbuf->qid,
445 stbuf->mode, stbuf->atime,
446 stbuf->mtime, stbuf->length,
447 stbuf->name, stbuf->uid,
448 stbuf->gid, stbuf->muid,
449 stbuf->extension, stbuf->n_uid,
450 stbuf->n_gid, stbuf->n_muid);
451 } break;
452 case 'D':{
453 uint32_t count = va_arg(ap, uint32_t);
454 const void *data = va_arg(ap, const void *);
455
456 errcode = p9pdu_writef(pdu, proto_version, "d",
457 count);
458 if (!errcode && pdu_write(pdu, data, count))
459 errcode = -EFAULT;
460 }
461 break;
462 case 'E':{
463 int32_t cnt = va_arg(ap, int32_t);
464 const char *k = va_arg(ap, const void *);
465 const char __user *u = va_arg(ap,
466 const void __user *);
467 errcode = p9pdu_writef(pdu, proto_version, "d",
468 cnt);
469 if (!errcode && pdu_write_urw(pdu, k, u, cnt))
470 errcode = -EFAULT;
471 }
472 break;
473 case 'F':{
474 int32_t cnt = va_arg(ap, int32_t);
475 const char *k = va_arg(ap, const void *);
476 errcode = p9pdu_writef(pdu, proto_version, "d",
477 cnt);
478 if (!errcode && pdu_write_readdir(pdu, k, cnt))
479 errcode = -EFAULT;
480 }
481 break;
482 case 'U':{
483 int32_t count = va_arg(ap, int32_t);
484 const char __user *udata =
485 va_arg(ap, const void __user *);
486 errcode = p9pdu_writef(pdu, proto_version, "d",
487 count);
488 if (!errcode && pdu_write_u(pdu, udata, count))
489 errcode = -EFAULT;
490 }
491 break;
492 case 'T':{
493 uint16_t nwname = va_arg(ap, int);
494 const char **wnames = va_arg(ap, const char **);
495
496 errcode = p9pdu_writef(pdu, proto_version, "w",
497 nwname);
498 if (!errcode) {
499 int i;
500
501 for (i = 0; i < nwname; i++) {
502 errcode =
503 p9pdu_writef(pdu,
504 proto_version,
505 "s",
506 wnames[i]);
507 if (errcode)
508 break;
509 }
510 }
511 }
512 break;
513 case 'R':{
514 int16_t nwqid = va_arg(ap, int);
515 struct p9_qid *wqids =
516 va_arg(ap, struct p9_qid *);
517
518 errcode = p9pdu_writef(pdu, proto_version, "w",
519 nwqid);
520 if (!errcode) {
521 int i;
522
523 for (i = 0; i < nwqid; i++) {
524 errcode =
525 p9pdu_writef(pdu,
526 proto_version,
527 "Q",
528 &wqids[i]);
529 if (errcode)
530 break;
531 }
532 }
533 }
534 break;
535 case 'I':{
536 struct p9_iattr_dotl *p9attr = va_arg(ap,
537 struct p9_iattr_dotl *);
538
539 errcode = p9pdu_writef(pdu, proto_version,
540 "ddddqqqqq",
541 p9attr->valid,
542 p9attr->mode,
543 p9attr->uid,
544 p9attr->gid,
545 p9attr->size,
546 p9attr->atime_sec,
547 p9attr->atime_nsec,
548 p9attr->mtime_sec,
549 p9attr->mtime_nsec);
550 }
551 break;
552 case '?':
553 if ((proto_version != p9_proto_2000u) &&
554 (proto_version != p9_proto_2000L))
555 return 0;
556 break;
557 default:
558 BUG();
559 break;
560 }
561
562 if (errcode)
563 break;
564 }
565
566 return errcode;
567}
568
569int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
570{
571 va_list ap;
572 int ret;
573
574 va_start(ap, fmt);
575 ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
576 va_end(ap);
577
578 return ret;
579}
580
581static int
582p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
583{
584 va_list ap;
585 int ret;
586
587 va_start(ap, fmt);
588 ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
589 va_end(ap);
590
591 return ret;
592}
593
594int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
595{
596 struct p9_fcall fake_pdu;
597 int ret;
598
599 fake_pdu.size = len;
600 fake_pdu.capacity = len;
601 fake_pdu.sdata = buf;
602 fake_pdu.offset = 0;
603
604 ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
605 if (ret) {
606 P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
607 P9_DUMP_PKT(0, &fake_pdu);
608 }
609
610 return ret;
611}
612EXPORT_SYMBOL(p9stat_read);
613
614int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
615{
616 pdu->id = type;
617 return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
618}
619
620int p9pdu_finalize(struct p9_fcall *pdu)
621{
622 int size = pdu->size;
623 int err;
624
625 pdu->size = 0;
626 err = p9pdu_writef(pdu, 0, "d", size);
627 pdu->size = size;
628
629 P9_DUMP_PKT(0, pdu);
630 P9_DPRINTK(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", pdu->size,
631 pdu->id, pdu->tag);
632
633 return err;
634}
635
636void p9pdu_reset(struct p9_fcall *pdu)
637{
638 pdu->offset = 0;
639 pdu->size = 0;
640 pdu->private = NULL;
641 pdu->pubuf = NULL;
642 pdu->pkbuf = NULL;
643 pdu->pbuf_size = 0;
644}
645
646int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
647 int proto_version)
648{
649 struct p9_fcall fake_pdu;
650 int ret;
651 char *nameptr;
652
653 fake_pdu.size = len;
654 fake_pdu.capacity = len;
655 fake_pdu.sdata = buf;
656 fake_pdu.offset = 0;
657
658 ret = p9pdu_readf(&fake_pdu, proto_version, "Qqbs", &dirent->qid,
659 &dirent->d_off, &dirent->d_type, &nameptr);
660 if (ret) {
661 P9_DPRINTK(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
662 P9_DUMP_PKT(1, &fake_pdu);
663 goto out;
664 }
665
666 strcpy(dirent->d_name, nameptr);
667 kfree(nameptr);
668
669out:
670 return fake_pdu.offset;
671}
672EXPORT_SYMBOL(p9dirent_read);
1/*
2 * net/9p/protocol.c
3 *
4 * 9P Protocol Support Code
5 *
6 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 *
8 * Base on code from Anthony Liguori <aliguori@us.ibm.com>
9 * Copyright (C) 2008 by IBM, Corp.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2
13 * as published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to:
22 * Free Software Foundation
23 * 51 Franklin Street, Fifth Floor
24 * Boston, MA 02111-1301 USA
25 *
26 */
27
28#include <linux/module.h>
29#include <linux/errno.h>
30#include <linux/kernel.h>
31#include <linux/uaccess.h>
32#include <linux/slab.h>
33#include <linux/sched.h>
34#include <linux/stddef.h>
35#include <linux/types.h>
36#include <net/9p/9p.h>
37#include <net/9p/client.h>
38#include "protocol.h"
39
40#include <trace/events/9p.h>
41
42static int
43p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
44
45void p9stat_free(struct p9_wstat *stbuf)
46{
47 kfree(stbuf->name);
48 kfree(stbuf->uid);
49 kfree(stbuf->gid);
50 kfree(stbuf->muid);
51 kfree(stbuf->extension);
52}
53EXPORT_SYMBOL(p9stat_free);
54
55size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
56{
57 size_t len = min(pdu->size - pdu->offset, size);
58 memcpy(data, &pdu->sdata[pdu->offset], len);
59 pdu->offset += len;
60 return size - len;
61}
62
63static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
64{
65 size_t len = min(pdu->capacity - pdu->size, size);
66 memcpy(&pdu->sdata[pdu->size], data, len);
67 pdu->size += len;
68 return size - len;
69}
70
71static size_t
72pdu_write_u(struct p9_fcall *pdu, const char __user *udata, size_t size)
73{
74 size_t len = min(pdu->capacity - pdu->size, size);
75 if (copy_from_user(&pdu->sdata[pdu->size], udata, len))
76 len = 0;
77
78 pdu->size += len;
79 return size - len;
80}
81
82/*
83 b - int8_t
84 w - int16_t
85 d - int32_t
86 q - int64_t
87 s - string
88 u - numeric uid
89 g - numeric gid
90 S - stat
91 Q - qid
92 D - data blob (int32_t size followed by void *, results are not freed)
93 T - array of strings (int16_t count, followed by strings)
94 R - array of qids (int16_t count, followed by qids)
95 A - stat for 9p2000.L (p9_stat_dotl)
96 ? - if optional = 1, continue parsing
97*/
98
99static int
100p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
101 va_list ap)
102{
103 const char *ptr;
104 int errcode = 0;
105
106 for (ptr = fmt; *ptr; ptr++) {
107 switch (*ptr) {
108 case 'b':{
109 int8_t *val = va_arg(ap, int8_t *);
110 if (pdu_read(pdu, val, sizeof(*val))) {
111 errcode = -EFAULT;
112 break;
113 }
114 }
115 break;
116 case 'w':{
117 int16_t *val = va_arg(ap, int16_t *);
118 __le16 le_val;
119 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
120 errcode = -EFAULT;
121 break;
122 }
123 *val = le16_to_cpu(le_val);
124 }
125 break;
126 case 'd':{
127 int32_t *val = va_arg(ap, int32_t *);
128 __le32 le_val;
129 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
130 errcode = -EFAULT;
131 break;
132 }
133 *val = le32_to_cpu(le_val);
134 }
135 break;
136 case 'q':{
137 int64_t *val = va_arg(ap, int64_t *);
138 __le64 le_val;
139 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
140 errcode = -EFAULT;
141 break;
142 }
143 *val = le64_to_cpu(le_val);
144 }
145 break;
146 case 's':{
147 char **sptr = va_arg(ap, char **);
148 uint16_t len;
149
150 errcode = p9pdu_readf(pdu, proto_version,
151 "w", &len);
152 if (errcode)
153 break;
154
155 *sptr = kmalloc(len + 1, GFP_NOFS);
156 if (*sptr == NULL) {
157 errcode = -EFAULT;
158 break;
159 }
160 if (pdu_read(pdu, *sptr, len)) {
161 errcode = -EFAULT;
162 kfree(*sptr);
163 *sptr = NULL;
164 } else
165 (*sptr)[len] = 0;
166 }
167 break;
168 case 'u': {
169 kuid_t *uid = va_arg(ap, kuid_t *);
170 __le32 le_val;
171 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
172 errcode = -EFAULT;
173 break;
174 }
175 *uid = make_kuid(&init_user_ns,
176 le32_to_cpu(le_val));
177 } break;
178 case 'g': {
179 kgid_t *gid = va_arg(ap, kgid_t *);
180 __le32 le_val;
181 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
182 errcode = -EFAULT;
183 break;
184 }
185 *gid = make_kgid(&init_user_ns,
186 le32_to_cpu(le_val));
187 } break;
188 case 'Q':{
189 struct p9_qid *qid =
190 va_arg(ap, struct p9_qid *);
191
192 errcode = p9pdu_readf(pdu, proto_version, "bdq",
193 &qid->type, &qid->version,
194 &qid->path);
195 }
196 break;
197 case 'S':{
198 struct p9_wstat *stbuf =
199 va_arg(ap, struct p9_wstat *);
200
201 memset(stbuf, 0, sizeof(struct p9_wstat));
202 stbuf->n_uid = stbuf->n_muid = INVALID_UID;
203 stbuf->n_gid = INVALID_GID;
204
205 errcode =
206 p9pdu_readf(pdu, proto_version,
207 "wwdQdddqssss?sugu",
208 &stbuf->size, &stbuf->type,
209 &stbuf->dev, &stbuf->qid,
210 &stbuf->mode, &stbuf->atime,
211 &stbuf->mtime, &stbuf->length,
212 &stbuf->name, &stbuf->uid,
213 &stbuf->gid, &stbuf->muid,
214 &stbuf->extension,
215 &stbuf->n_uid, &stbuf->n_gid,
216 &stbuf->n_muid);
217 if (errcode)
218 p9stat_free(stbuf);
219 }
220 break;
221 case 'D':{
222 uint32_t *count = va_arg(ap, uint32_t *);
223 void **data = va_arg(ap, void **);
224
225 errcode =
226 p9pdu_readf(pdu, proto_version, "d", count);
227 if (!errcode) {
228 *count =
229 min_t(uint32_t, *count,
230 pdu->size - pdu->offset);
231 *data = &pdu->sdata[pdu->offset];
232 }
233 }
234 break;
235 case 'T':{
236 uint16_t *nwname = va_arg(ap, uint16_t *);
237 char ***wnames = va_arg(ap, char ***);
238
239 errcode = p9pdu_readf(pdu, proto_version,
240 "w", nwname);
241 if (!errcode) {
242 *wnames =
243 kmalloc(sizeof(char *) * *nwname,
244 GFP_NOFS);
245 if (!*wnames)
246 errcode = -ENOMEM;
247 }
248
249 if (!errcode) {
250 int i;
251
252 for (i = 0; i < *nwname; i++) {
253 errcode =
254 p9pdu_readf(pdu,
255 proto_version,
256 "s",
257 &(*wnames)[i]);
258 if (errcode)
259 break;
260 }
261 }
262
263 if (errcode) {
264 if (*wnames) {
265 int i;
266
267 for (i = 0; i < *nwname; i++)
268 kfree((*wnames)[i]);
269 }
270 kfree(*wnames);
271 *wnames = NULL;
272 }
273 }
274 break;
275 case 'R':{
276 int16_t *nwqid = va_arg(ap, int16_t *);
277 struct p9_qid **wqids =
278 va_arg(ap, struct p9_qid **);
279
280 *wqids = NULL;
281
282 errcode =
283 p9pdu_readf(pdu, proto_version, "w", nwqid);
284 if (!errcode) {
285 *wqids =
286 kmalloc(*nwqid *
287 sizeof(struct p9_qid),
288 GFP_NOFS);
289 if (*wqids == NULL)
290 errcode = -ENOMEM;
291 }
292
293 if (!errcode) {
294 int i;
295
296 for (i = 0; i < *nwqid; i++) {
297 errcode =
298 p9pdu_readf(pdu,
299 proto_version,
300 "Q",
301 &(*wqids)[i]);
302 if (errcode)
303 break;
304 }
305 }
306
307 if (errcode) {
308 kfree(*wqids);
309 *wqids = NULL;
310 }
311 }
312 break;
313 case 'A': {
314 struct p9_stat_dotl *stbuf =
315 va_arg(ap, struct p9_stat_dotl *);
316
317 memset(stbuf, 0, sizeof(struct p9_stat_dotl));
318 errcode =
319 p9pdu_readf(pdu, proto_version,
320 "qQdugqqqqqqqqqqqqqqq",
321 &stbuf->st_result_mask,
322 &stbuf->qid,
323 &stbuf->st_mode,
324 &stbuf->st_uid, &stbuf->st_gid,
325 &stbuf->st_nlink,
326 &stbuf->st_rdev, &stbuf->st_size,
327 &stbuf->st_blksize, &stbuf->st_blocks,
328 &stbuf->st_atime_sec,
329 &stbuf->st_atime_nsec,
330 &stbuf->st_mtime_sec,
331 &stbuf->st_mtime_nsec,
332 &stbuf->st_ctime_sec,
333 &stbuf->st_ctime_nsec,
334 &stbuf->st_btime_sec,
335 &stbuf->st_btime_nsec,
336 &stbuf->st_gen,
337 &stbuf->st_data_version);
338 }
339 break;
340 case '?':
341 if ((proto_version != p9_proto_2000u) &&
342 (proto_version != p9_proto_2000L))
343 return 0;
344 break;
345 default:
346 BUG();
347 break;
348 }
349
350 if (errcode)
351 break;
352 }
353
354 return errcode;
355}
356
357int
358p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
359 va_list ap)
360{
361 const char *ptr;
362 int errcode = 0;
363
364 for (ptr = fmt; *ptr; ptr++) {
365 switch (*ptr) {
366 case 'b':{
367 int8_t val = va_arg(ap, int);
368 if (pdu_write(pdu, &val, sizeof(val)))
369 errcode = -EFAULT;
370 }
371 break;
372 case 'w':{
373 __le16 val = cpu_to_le16(va_arg(ap, int));
374 if (pdu_write(pdu, &val, sizeof(val)))
375 errcode = -EFAULT;
376 }
377 break;
378 case 'd':{
379 __le32 val = cpu_to_le32(va_arg(ap, int32_t));
380 if (pdu_write(pdu, &val, sizeof(val)))
381 errcode = -EFAULT;
382 }
383 break;
384 case 'q':{
385 __le64 val = cpu_to_le64(va_arg(ap, int64_t));
386 if (pdu_write(pdu, &val, sizeof(val)))
387 errcode = -EFAULT;
388 }
389 break;
390 case 's':{
391 const char *sptr = va_arg(ap, const char *);
392 uint16_t len = 0;
393 if (sptr)
394 len = min_t(size_t, strlen(sptr),
395 USHRT_MAX);
396
397 errcode = p9pdu_writef(pdu, proto_version,
398 "w", len);
399 if (!errcode && pdu_write(pdu, sptr, len))
400 errcode = -EFAULT;
401 }
402 break;
403 case 'u': {
404 kuid_t uid = va_arg(ap, kuid_t);
405 __le32 val = cpu_to_le32(
406 from_kuid(&init_user_ns, uid));
407 if (pdu_write(pdu, &val, sizeof(val)))
408 errcode = -EFAULT;
409 } break;
410 case 'g': {
411 kgid_t gid = va_arg(ap, kgid_t);
412 __le32 val = cpu_to_le32(
413 from_kgid(&init_user_ns, gid));
414 if (pdu_write(pdu, &val, sizeof(val)))
415 errcode = -EFAULT;
416 } break;
417 case 'Q':{
418 const struct p9_qid *qid =
419 va_arg(ap, const struct p9_qid *);
420 errcode =
421 p9pdu_writef(pdu, proto_version, "bdq",
422 qid->type, qid->version,
423 qid->path);
424 } break;
425 case 'S':{
426 const struct p9_wstat *stbuf =
427 va_arg(ap, const struct p9_wstat *);
428 errcode =
429 p9pdu_writef(pdu, proto_version,
430 "wwdQdddqssss?sugu",
431 stbuf->size, stbuf->type,
432 stbuf->dev, &stbuf->qid,
433 stbuf->mode, stbuf->atime,
434 stbuf->mtime, stbuf->length,
435 stbuf->name, stbuf->uid,
436 stbuf->gid, stbuf->muid,
437 stbuf->extension, stbuf->n_uid,
438 stbuf->n_gid, stbuf->n_muid);
439 } break;
440 case 'D':{
441 uint32_t count = va_arg(ap, uint32_t);
442 const void *data = va_arg(ap, const void *);
443
444 errcode = p9pdu_writef(pdu, proto_version, "d",
445 count);
446 if (!errcode && pdu_write(pdu, data, count))
447 errcode = -EFAULT;
448 }
449 break;
450 case 'U':{
451 int32_t count = va_arg(ap, int32_t);
452 const char __user *udata =
453 va_arg(ap, const void __user *);
454 errcode = p9pdu_writef(pdu, proto_version, "d",
455 count);
456 if (!errcode && pdu_write_u(pdu, udata, count))
457 errcode = -EFAULT;
458 }
459 break;
460 case 'T':{
461 uint16_t nwname = va_arg(ap, int);
462 const char **wnames = va_arg(ap, const char **);
463
464 errcode = p9pdu_writef(pdu, proto_version, "w",
465 nwname);
466 if (!errcode) {
467 int i;
468
469 for (i = 0; i < nwname; i++) {
470 errcode =
471 p9pdu_writef(pdu,
472 proto_version,
473 "s",
474 wnames[i]);
475 if (errcode)
476 break;
477 }
478 }
479 }
480 break;
481 case 'R':{
482 int16_t nwqid = va_arg(ap, int);
483 struct p9_qid *wqids =
484 va_arg(ap, struct p9_qid *);
485
486 errcode = p9pdu_writef(pdu, proto_version, "w",
487 nwqid);
488 if (!errcode) {
489 int i;
490
491 for (i = 0; i < nwqid; i++) {
492 errcode =
493 p9pdu_writef(pdu,
494 proto_version,
495 "Q",
496 &wqids[i]);
497 if (errcode)
498 break;
499 }
500 }
501 }
502 break;
503 case 'I':{
504 struct p9_iattr_dotl *p9attr = va_arg(ap,
505 struct p9_iattr_dotl *);
506
507 errcode = p9pdu_writef(pdu, proto_version,
508 "ddugqqqqq",
509 p9attr->valid,
510 p9attr->mode,
511 p9attr->uid,
512 p9attr->gid,
513 p9attr->size,
514 p9attr->atime_sec,
515 p9attr->atime_nsec,
516 p9attr->mtime_sec,
517 p9attr->mtime_nsec);
518 }
519 break;
520 case '?':
521 if ((proto_version != p9_proto_2000u) &&
522 (proto_version != p9_proto_2000L))
523 return 0;
524 break;
525 default:
526 BUG();
527 break;
528 }
529
530 if (errcode)
531 break;
532 }
533
534 return errcode;
535}
536
537int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
538{
539 va_list ap;
540 int ret;
541
542 va_start(ap, fmt);
543 ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
544 va_end(ap);
545
546 return ret;
547}
548
549static int
550p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
551{
552 va_list ap;
553 int ret;
554
555 va_start(ap, fmt);
556 ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
557 va_end(ap);
558
559 return ret;
560}
561
562int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
563{
564 struct p9_fcall fake_pdu;
565 int ret;
566
567 fake_pdu.size = len;
568 fake_pdu.capacity = len;
569 fake_pdu.sdata = buf;
570 fake_pdu.offset = 0;
571
572 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
573 if (ret) {
574 p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
575 trace_9p_protocol_dump(clnt, &fake_pdu);
576 }
577
578 return ret;
579}
580EXPORT_SYMBOL(p9stat_read);
581
582int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
583{
584 pdu->id = type;
585 return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
586}
587
588int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
589{
590 int size = pdu->size;
591 int err;
592
593 pdu->size = 0;
594 err = p9pdu_writef(pdu, 0, "d", size);
595 pdu->size = size;
596
597 trace_9p_protocol_dump(clnt, pdu);
598 p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
599 pdu->size, pdu->id, pdu->tag);
600
601 return err;
602}
603
604void p9pdu_reset(struct p9_fcall *pdu)
605{
606 pdu->offset = 0;
607 pdu->size = 0;
608}
609
610int p9dirent_read(struct p9_client *clnt, char *buf, int len,
611 struct p9_dirent *dirent)
612{
613 struct p9_fcall fake_pdu;
614 int ret;
615 char *nameptr;
616
617 fake_pdu.size = len;
618 fake_pdu.capacity = len;
619 fake_pdu.sdata = buf;
620 fake_pdu.offset = 0;
621
622 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
623 &dirent->d_off, &dirent->d_type, &nameptr);
624 if (ret) {
625 p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
626 trace_9p_protocol_dump(clnt, &fake_pdu);
627 goto out;
628 }
629
630 strcpy(dirent->d_name, nameptr);
631 kfree(nameptr);
632
633out:
634 return fake_pdu.offset;
635}
636EXPORT_SYMBOL(p9dirent_read);