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