xref: /openbmc/linux/net/9p/protocol.c (revision 565d76cb) 
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
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
74 p9pdu_dump(int way, struct p9_fcall *pdu)
75 {
76 }
77 #endif
78 EXPORT_SYMBOL(p9pdu_dump);
79 
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 
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 
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
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
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
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
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 				int16_t *nwname = va_arg(ap, int16_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
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 *u = va_arg(ap, const void *);
472 				 errcode = p9pdu_writef(pdu, proto_version, "d",
473 						 cnt);
474 				 if (!errcode && pdu_write_urw(pdu, k, u, cnt))
475 					errcode = -EFAULT;
476 			 }
477 			 break;
478 		case 'F':{
479 				 int32_t cnt = va_arg(ap, int32_t);
480 				 const char *k = va_arg(ap, const void *);
481 				 errcode = p9pdu_writef(pdu, proto_version, "d",
482 						 cnt);
483 				 if (!errcode && pdu_write_readdir(pdu, k, cnt))
484 					errcode = -EFAULT;
485 			 }
486 			 break;
487 		case 'U':{
488 				int32_t count = va_arg(ap, int32_t);
489 				const char __user *udata =
490 						va_arg(ap, const void __user *);
491 				errcode = p9pdu_writef(pdu, proto_version, "d",
492 									count);
493 				if (!errcode && pdu_write_u(pdu, udata, count))
494 					errcode = -EFAULT;
495 			}
496 			break;
497 		case 'T':{
498 				int16_t nwname = va_arg(ap, int);
499 				const char **wnames = va_arg(ap, const char **);
500 
501 				errcode = p9pdu_writef(pdu, proto_version, "w",
502 									nwname);
503 				if (!errcode) {
504 					int i;
505 
506 					for (i = 0; i < nwname; i++) {
507 						errcode =
508 						    p9pdu_writef(pdu,
509 								proto_version,
510 								 "s",
511 								 wnames[i]);
512 						if (errcode)
513 							break;
514 					}
515 				}
516 			}
517 			break;
518 		case 'R':{
519 				int16_t nwqid = va_arg(ap, int);
520 				struct p9_qid *wqids =
521 				    va_arg(ap, struct p9_qid *);
522 
523 				errcode = p9pdu_writef(pdu, proto_version, "w",
524 									nwqid);
525 				if (!errcode) {
526 					int i;
527 
528 					for (i = 0; i < nwqid; i++) {
529 						errcode =
530 						    p9pdu_writef(pdu,
531 								proto_version,
532 								 "Q",
533 								 &wqids[i]);
534 						if (errcode)
535 							break;
536 					}
537 				}
538 			}
539 			break;
540 		case 'I':{
541 				struct p9_iattr_dotl *p9attr = va_arg(ap,
542 							struct p9_iattr_dotl *);
543 
544 				errcode = p9pdu_writef(pdu, proto_version,
545 							"ddddqqqqq",
546 							p9attr->valid,
547 							p9attr->mode,
548 							p9attr->uid,
549 							p9attr->gid,
550 							p9attr->size,
551 							p9attr->atime_sec,
552 							p9attr->atime_nsec,
553 							p9attr->mtime_sec,
554 							p9attr->mtime_nsec);
555 			}
556 			break;
557 		case '?':
558 			if ((proto_version != p9_proto_2000u) &&
559 				(proto_version != p9_proto_2000L))
560 				return 0;
561 			break;
562 		default:
563 			BUG();
564 			break;
565 		}
566 
567 		if (errcode)
568 			break;
569 	}
570 
571 	return errcode;
572 }
573 
574 int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
575 {
576 	va_list ap;
577 	int ret;
578 
579 	va_start(ap, fmt);
580 	ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
581 	va_end(ap);
582 
583 	return ret;
584 }
585 
586 static int
587 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
588 {
589 	va_list ap;
590 	int ret;
591 
592 	va_start(ap, fmt);
593 	ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
594 	va_end(ap);
595 
596 	return ret;
597 }
598 
599 int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
600 {
601 	struct p9_fcall fake_pdu;
602 	int ret;
603 
604 	fake_pdu.size = len;
605 	fake_pdu.capacity = len;
606 	fake_pdu.sdata = buf;
607 	fake_pdu.offset = 0;
608 
609 	ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
610 	if (ret) {
611 		P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
612 		p9pdu_dump(1, &fake_pdu);
613 	}
614 
615 	return ret;
616 }
617 EXPORT_SYMBOL(p9stat_read);
618 
619 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
620 {
621 	pdu->id = type;
622 	return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
623 }
624 
625 int p9pdu_finalize(struct p9_fcall *pdu)
626 {
627 	int size = pdu->size;
628 	int err;
629 
630 	pdu->size = 0;
631 	err = p9pdu_writef(pdu, 0, "d", size);
632 	pdu->size = size;
633 
634 #ifdef CONFIG_NET_9P_DEBUG
635 	if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT)
636 		p9pdu_dump(0, pdu);
637 #endif
638 
639 	P9_DPRINTK(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", pdu->size,
640 							pdu->id, pdu->tag);
641 
642 	return err;
643 }
644 
645 void p9pdu_reset(struct p9_fcall *pdu)
646 {
647 	pdu->offset = 0;
648 	pdu->size = 0;
649 	pdu->private = NULL;
650 	pdu->pubuf = NULL;
651 	pdu->pkbuf = NULL;
652 	pdu->pbuf_size = 0;
653 }
654 
655 int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
656 						int proto_version)
657 {
658 	struct p9_fcall fake_pdu;
659 	int ret;
660 	char *nameptr;
661 
662 	fake_pdu.size = len;
663 	fake_pdu.capacity = len;
664 	fake_pdu.sdata = buf;
665 	fake_pdu.offset = 0;
666 
667 	ret = p9pdu_readf(&fake_pdu, proto_version, "Qqbs", &dirent->qid,
668 			&dirent->d_off, &dirent->d_type, &nameptr);
669 	if (ret) {
670 		P9_DPRINTK(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
671 		p9pdu_dump(1, &fake_pdu);
672 		goto out;
673 	}
674 
675 	strcpy(dirent->d_name, nameptr);
676 
677 out:
678 	return fake_pdu.offset;
679 }
680 EXPORT_SYMBOL(p9dirent_read);
681