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