xref: /openbmc/linux/net/9p/protocol.c (revision 7d545e77) 
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 
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 
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 
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
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
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 				errcode = p9pdu_readf(pdu, proto_version,
232 								"w", nwname);
233 				if (!errcode) {
234 					*wnames =
235 					    kmalloc_array(*nwname,
236 							  sizeof(char *),
237 							  GFP_NOFS);
238 					if (!*wnames)
239 						errcode = -ENOMEM;
240 				}
241 
242 				if (!errcode) {
243 					int i;
244 
245 					for (i = 0; i < *nwname; i++) {
246 						errcode =
247 						    p9pdu_readf(pdu,
248 								proto_version,
249 								"s",
250 								&(*wnames)[i]);
251 						if (errcode)
252 							break;
253 					}
254 				}
255 
256 				if (errcode) {
257 					if (*wnames) {
258 						int i;
259 
260 						for (i = 0; i < *nwname; i++)
261 							kfree((*wnames)[i]);
262 					}
263 					kfree(*wnames);
264 					*wnames = NULL;
265 				}
266 			}
267 			break;
268 		case 'R':{
269 				uint16_t *nwqid = va_arg(ap, uint16_t *);
270 				struct p9_qid **wqids =
271 				    va_arg(ap, struct p9_qid **);
272 
273 				*wqids = NULL;
274 
275 				errcode =
276 				    p9pdu_readf(pdu, proto_version, "w", nwqid);
277 				if (!errcode) {
278 					*wqids =
279 					    kmalloc_array(*nwqid,
280 							  sizeof(struct p9_qid),
281 							  GFP_NOFS);
282 					if (*wqids == NULL)
283 						errcode = -ENOMEM;
284 				}
285 
286 				if (!errcode) {
287 					int i;
288 
289 					for (i = 0; i < *nwqid; i++) {
290 						errcode =
291 						    p9pdu_readf(pdu,
292 								proto_version,
293 								"Q",
294 								&(*wqids)[i]);
295 						if (errcode)
296 							break;
297 					}
298 				}
299 
300 				if (errcode) {
301 					kfree(*wqids);
302 					*wqids = NULL;
303 				}
304 			}
305 			break;
306 		case 'A': {
307 				struct p9_stat_dotl *stbuf =
308 				    va_arg(ap, struct p9_stat_dotl *);
309 
310 				memset(stbuf, 0, sizeof(struct p9_stat_dotl));
311 				errcode =
312 				    p9pdu_readf(pdu, proto_version,
313 					"qQdugqqqqqqqqqqqqqqq",
314 					&stbuf->st_result_mask,
315 					&stbuf->qid,
316 					&stbuf->st_mode,
317 					&stbuf->st_uid, &stbuf->st_gid,
318 					&stbuf->st_nlink,
319 					&stbuf->st_rdev, &stbuf->st_size,
320 					&stbuf->st_blksize, &stbuf->st_blocks,
321 					&stbuf->st_atime_sec,
322 					&stbuf->st_atime_nsec,
323 					&stbuf->st_mtime_sec,
324 					&stbuf->st_mtime_nsec,
325 					&stbuf->st_ctime_sec,
326 					&stbuf->st_ctime_nsec,
327 					&stbuf->st_btime_sec,
328 					&stbuf->st_btime_nsec,
329 					&stbuf->st_gen,
330 					&stbuf->st_data_version);
331 			}
332 			break;
333 		case '?':
334 			if ((proto_version != p9_proto_2000u) &&
335 				(proto_version != p9_proto_2000L))
336 				return 0;
337 			break;
338 		default:
339 			BUG();
340 			break;
341 		}
342 
343 		if (errcode)
344 			break;
345 	}
346 
347 	return errcode;
348 }
349 
350 int
351 p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
352 	va_list ap)
353 {
354 	const char *ptr;
355 	int errcode = 0;
356 
357 	for (ptr = fmt; *ptr; ptr++) {
358 		switch (*ptr) {
359 		case 'b':{
360 				int8_t val = va_arg(ap, int);
361 				if (pdu_write(pdu, &val, sizeof(val)))
362 					errcode = -EFAULT;
363 			}
364 			break;
365 		case 'w':{
366 				__le16 val = cpu_to_le16(va_arg(ap, int));
367 				if (pdu_write(pdu, &val, sizeof(val)))
368 					errcode = -EFAULT;
369 			}
370 			break;
371 		case 'd':{
372 				__le32 val = cpu_to_le32(va_arg(ap, int32_t));
373 				if (pdu_write(pdu, &val, sizeof(val)))
374 					errcode = -EFAULT;
375 			}
376 			break;
377 		case 'q':{
378 				__le64 val = cpu_to_le64(va_arg(ap, int64_t));
379 				if (pdu_write(pdu, &val, sizeof(val)))
380 					errcode = -EFAULT;
381 			}
382 			break;
383 		case 's':{
384 				const char *sptr = va_arg(ap, const char *);
385 				uint16_t len = 0;
386 				if (sptr)
387 					len = min_t(size_t, strlen(sptr),
388 								USHRT_MAX);
389 
390 				errcode = p9pdu_writef(pdu, proto_version,
391 								"w", len);
392 				if (!errcode && pdu_write(pdu, sptr, len))
393 					errcode = -EFAULT;
394 			}
395 			break;
396 		case 'u': {
397 				kuid_t uid = va_arg(ap, kuid_t);
398 				__le32 val = cpu_to_le32(
399 						from_kuid(&init_user_ns, uid));
400 				if (pdu_write(pdu, &val, sizeof(val)))
401 					errcode = -EFAULT;
402 			} break;
403 		case 'g': {
404 				kgid_t gid = va_arg(ap, kgid_t);
405 				__le32 val = cpu_to_le32(
406 						from_kgid(&init_user_ns, gid));
407 				if (pdu_write(pdu, &val, sizeof(val)))
408 					errcode = -EFAULT;
409 			} break;
410 		case 'Q':{
411 				const struct p9_qid *qid =
412 				    va_arg(ap, const struct p9_qid *);
413 				errcode =
414 				    p9pdu_writef(pdu, proto_version, "bdq",
415 						 qid->type, qid->version,
416 						 qid->path);
417 			} break;
418 		case 'S':{
419 				const struct p9_wstat *stbuf =
420 				    va_arg(ap, const struct p9_wstat *);
421 				errcode =
422 				    p9pdu_writef(pdu, proto_version,
423 						 "wwdQdddqssss?sugu",
424 						 stbuf->size, stbuf->type,
425 						 stbuf->dev, &stbuf->qid,
426 						 stbuf->mode, stbuf->atime,
427 						 stbuf->mtime, stbuf->length,
428 						 stbuf->name, stbuf->uid,
429 						 stbuf->gid, stbuf->muid,
430 						 stbuf->extension, stbuf->n_uid,
431 						 stbuf->n_gid, stbuf->n_muid);
432 			} break;
433 		case 'V':{
434 				uint32_t count = va_arg(ap, uint32_t);
435 				struct iov_iter *from =
436 						va_arg(ap, struct iov_iter *);
437 				errcode = p9pdu_writef(pdu, proto_version, "d",
438 									count);
439 				if (!errcode && pdu_write_u(pdu, from, count))
440 					errcode = -EFAULT;
441 			}
442 			break;
443 		case 'T':{
444 				uint16_t nwname = va_arg(ap, int);
445 				const char **wnames = va_arg(ap, const char **);
446 
447 				errcode = p9pdu_writef(pdu, proto_version, "w",
448 									nwname);
449 				if (!errcode) {
450 					int i;
451 
452 					for (i = 0; i < nwname; i++) {
453 						errcode =
454 						    p9pdu_writef(pdu,
455 								proto_version,
456 								 "s",
457 								 wnames[i]);
458 						if (errcode)
459 							break;
460 					}
461 				}
462 			}
463 			break;
464 		case 'R':{
465 				uint16_t nwqid = va_arg(ap, int);
466 				struct p9_qid *wqids =
467 				    va_arg(ap, struct p9_qid *);
468 
469 				errcode = p9pdu_writef(pdu, proto_version, "w",
470 									nwqid);
471 				if (!errcode) {
472 					int i;
473 
474 					for (i = 0; i < nwqid; i++) {
475 						errcode =
476 						    p9pdu_writef(pdu,
477 								proto_version,
478 								 "Q",
479 								 &wqids[i]);
480 						if (errcode)
481 							break;
482 					}
483 				}
484 			}
485 			break;
486 		case 'I':{
487 				struct p9_iattr_dotl *p9attr = va_arg(ap,
488 							struct p9_iattr_dotl *);
489 
490 				errcode = p9pdu_writef(pdu, proto_version,
491 							"ddugqqqqq",
492 							p9attr->valid,
493 							p9attr->mode,
494 							p9attr->uid,
495 							p9attr->gid,
496 							p9attr->size,
497 							p9attr->atime_sec,
498 							p9attr->atime_nsec,
499 							p9attr->mtime_sec,
500 							p9attr->mtime_nsec);
501 			}
502 			break;
503 		case '?':
504 			if ((proto_version != p9_proto_2000u) &&
505 				(proto_version != p9_proto_2000L))
506 				return 0;
507 			break;
508 		default:
509 			BUG();
510 			break;
511 		}
512 
513 		if (errcode)
514 			break;
515 	}
516 
517 	return errcode;
518 }
519 
520 int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
521 {
522 	va_list ap;
523 	int ret;
524 
525 	va_start(ap, fmt);
526 	ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
527 	va_end(ap);
528 
529 	return ret;
530 }
531 
532 static int
533 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
534 {
535 	va_list ap;
536 	int ret;
537 
538 	va_start(ap, fmt);
539 	ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
540 	va_end(ap);
541 
542 	return ret;
543 }
544 
545 int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
546 {
547 	struct p9_fcall fake_pdu;
548 	int ret;
549 
550 	fake_pdu.size = len;
551 	fake_pdu.capacity = len;
552 	fake_pdu.sdata = buf;
553 	fake_pdu.offset = 0;
554 
555 	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
556 	if (ret) {
557 		p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
558 		trace_9p_protocol_dump(clnt, &fake_pdu);
559 		return ret;
560 	}
561 
562 	return fake_pdu.offset;
563 }
564 EXPORT_SYMBOL(p9stat_read);
565 
566 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
567 {
568 	pdu->id = type;
569 	return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
570 }
571 
572 int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
573 {
574 	int size = pdu->size;
575 	int err;
576 
577 	pdu->size = 0;
578 	err = p9pdu_writef(pdu, 0, "d", size);
579 	pdu->size = size;
580 
581 	trace_9p_protocol_dump(clnt, pdu);
582 	p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
583 		 pdu->size, pdu->id, pdu->tag);
584 
585 	return err;
586 }
587 
588 void p9pdu_reset(struct p9_fcall *pdu)
589 {
590 	pdu->offset = 0;
591 	pdu->size = 0;
592 }
593 
594 int p9dirent_read(struct p9_client *clnt, char *buf, int len,
595 		  struct p9_dirent *dirent)
596 {
597 	struct p9_fcall fake_pdu;
598 	int ret;
599 	char *nameptr;
600 
601 	fake_pdu.size = len;
602 	fake_pdu.capacity = len;
603 	fake_pdu.sdata = buf;
604 	fake_pdu.offset = 0;
605 
606 	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
607 			  &dirent->d_off, &dirent->d_type, &nameptr);
608 	if (ret) {
609 		p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
610 		trace_9p_protocol_dump(clnt, &fake_pdu);
611 		return ret;
612 	}
613 
614 	ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
615 	if (ret < 0) {
616 		p9_debug(P9_DEBUG_ERROR,
617 			 "On the wire dirent name too long: %s\n",
618 			 nameptr);
619 		kfree(nameptr);
620 		return ret;
621 	}
622 	kfree(nameptr);
623 
624 	return fake_pdu.offset;
625 }
626 EXPORT_SYMBOL(p9dirent_read);
627