?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
console: Avoid dereferencing NULL active_console
[qemu-kvm/stefanha.git] / hw / virtio-9p.c
blob3b2d49cde02c65d87920b92fc51964912653d832
1 /*
2 * Virtio 9p backend
3 *
4 * Copyright IBM, Corp. 2010
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "virtio.h"
15 #include "pc.h"
16 #include "qemu_socket.h"
17 #include "virtio-9p.h"
18 #include "fsdev/qemu-fsdev.h"
19 #include "virtio-9p-debug.h"
20
21 int debug_9p_pdu;
22
23 enum {
24 Oread = 0x00,
25 Owrite = 0x01,
26 Ordwr = 0x02,
27 Oexec = 0x03,
28 Oexcl = 0x04,
29 Otrunc = 0x10,
30 Orexec = 0x20,
31 Orclose = 0x40,
32 Oappend = 0x80,
33 };
34
35 static int omode_to_uflags(int8_t mode)
36 {
37 int ret = 0;
38
39 switch (mode & 3) {
40 case Oread:
41 ret = O_RDONLY;
42 break;
43 case Ordwr:
44 ret = O_RDWR;
45 break;
46 case Owrite:
47 ret = O_WRONLY;
48 break;
49 case Oexec:
50 ret = O_RDONLY;
51 break;
52 }
53
54 if (mode & Otrunc) {
55 ret |= O_TRUNC;
56 }
57
58 if (mode & Oappend) {
59 ret |= O_APPEND;
60 }
61
62 if (mode & Oexcl) {
63 ret |= O_EXCL;
64 }
65
66 return ret;
67 }
68
69 void cred_init(FsCred *credp)
70 {
71 credp->fc_uid = -1;
72 credp->fc_gid = -1;
73 credp->fc_mode = -1;
74 credp->fc_rdev = -1;
75 }
76
77 static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf)
78 {
79 return s->ops->lstat(&s->ctx, path->data, stbuf);
80 }
81
82 static ssize_t v9fs_do_readlink(V9fsState *s, V9fsString *path, V9fsString *buf)
83 {
84 ssize_t len;
85
86 buf->data = qemu_malloc(1024);
87
88 len = s->ops->readlink(&s->ctx, path->data, buf->data, 1024 - 1);
89 if (len > -1) {
90 buf->size = len;
91 buf->data[len] = 0;
92 }
93
94 return len;
95 }
96
97 static int v9fs_do_close(V9fsState *s, int fd)
98 {
99 return s->ops->close(&s->ctx, fd);
100 }
101
102 static int v9fs_do_closedir(V9fsState *s, DIR *dir)
103 {
104 return s->ops->closedir(&s->ctx, dir);
105 }
106
107 static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags)
108 {
109 return s->ops->open(&s->ctx, path->data, flags);
110 }
111
112 static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path)
113 {
114 return s->ops->opendir(&s->ctx, path->data);
115 }
116
117 static void v9fs_do_rewinddir(V9fsState *s, DIR *dir)
118 {
119 return s->ops->rewinddir(&s->ctx, dir);
120 }
121
122 static off_t v9fs_do_telldir(V9fsState *s, DIR *dir)
123 {
124 return s->ops->telldir(&s->ctx, dir);
125 }
126
127 static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir)
128 {
129 return s->ops->readdir(&s->ctx, dir);
130 }
131
132 static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off)
133 {
134 return s->ops->seekdir(&s->ctx, dir, off);
135 }
136
137 static int v9fs_do_readv(V9fsState *s, int fd, const struct iovec *iov,
138 int iovcnt)
139 {
140 return s->ops->readv(&s->ctx, fd, iov, iovcnt);
141 }
142
143 static off_t v9fs_do_lseek(V9fsState *s, int fd, off_t offset, int whence)
144 {
145 return s->ops->lseek(&s->ctx, fd, offset, whence);
146 }
147
148 static int v9fs_do_writev(V9fsState *s, int fd, const struct iovec *iov,
149 int iovcnt)
150 {
151 return s->ops->writev(&s->ctx, fd, iov, iovcnt);
152 }
153
154 static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
155 {
156 FsCred cred;
157 cred_init(&cred);
158 cred.fc_mode = mode;
159 return s->ops->chmod(&s->ctx, path->data, &cred);
160 }
161
162 static int v9fs_do_mknod(V9fsState *s, char *name,
163 mode_t mode, dev_t dev, uid_t uid, gid_t gid)
164 {
165 FsCred cred;
166 cred_init(&cred);
167 cred.fc_uid = uid;
168 cred.fc_gid = gid;
169 cred.fc_mode = mode;
170 cred.fc_rdev = dev;
171 return s->ops->mknod(&s->ctx, name, &cred);
172 }
173
174 static int v9fs_do_mkdir(V9fsState *s, char *name, mode_t mode,
175 uid_t uid, gid_t gid)
176 {
177 FsCred cred;
178
179 cred_init(&cred);
180 cred.fc_uid = uid;
181 cred.fc_gid = gid;
182 cred.fc_mode = mode;
183
184 return s->ops->mkdir(&s->ctx, name, &cred);
185 }
186
187 static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
188 {
189 return s->ops->fstat(&s->ctx, fd, stbuf);
190 }
191
192 static int v9fs_do_open2(V9fsState *s, char *fullname, uid_t uid, gid_t gid,
193 int flags, int mode)
194 {
195 FsCred cred;
196
197 cred_init(&cred);
198 cred.fc_uid = uid;
199 cred.fc_gid = gid;
200 cred.fc_mode = mode & 07777;
201 flags = flags;
202
203 return s->ops->open2(&s->ctx, fullname, flags, &cred);
204 }
205
206 static int v9fs_do_symlink(V9fsState *s, V9fsFidState *fidp,
207 const char *oldpath, const char *newpath, gid_t gid)
208 {
209 FsCred cred;
210 cred_init(&cred);
211 cred.fc_uid = fidp->uid;
212 cred.fc_gid = gid;
213 cred.fc_mode = 0777;
214
215 return s->ops->symlink(&s->ctx, oldpath, newpath, &cred);
216 }
217
218 static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
219 {
220 return s->ops->link(&s->ctx, oldpath->data, newpath->data);
221 }
222
223 static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size)
224 {
225 return s->ops->truncate(&s->ctx, path->data, size);
226 }
227
228 static int v9fs_do_rename(V9fsState *s, V9fsString *oldpath,
229 V9fsString *newpath)
230 {
231 return s->ops->rename(&s->ctx, oldpath->data, newpath->data);
232 }
233
234 static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid)
235 {
236 FsCred cred;
237 cred_init(&cred);
238 cred.fc_uid = uid;
239 cred.fc_gid = gid;
240
241 return s->ops->chown(&s->ctx, path->data, &cred);
242 }
243
244 static int v9fs_do_utimensat(V9fsState *s, V9fsString *path,
245 const struct timespec times[2])
246 {
247 return s->ops->utimensat(&s->ctx, path->data, times);
248 }
249
250 static int v9fs_do_remove(V9fsState *s, V9fsString *path)
251 {
252 return s->ops->remove(&s->ctx, path->data);
253 }
254
255 static int v9fs_do_fsync(V9fsState *s, int fd)
256 {
257 return s->ops->fsync(&s->ctx, fd);
258 }
259
260 static int v9fs_do_statfs(V9fsState *s, V9fsString *path, struct statfs *stbuf)
261 {
262 return s->ops->statfs(&s->ctx, path->data, stbuf);
263 }
264
265 static ssize_t v9fs_do_lgetxattr(V9fsState *s, V9fsString *path,
266 V9fsString *xattr_name,
267 void *value, size_t size)
268 {
269 return s->ops->lgetxattr(&s->ctx, path->data,
270 xattr_name->data, value, size);
271 }
272
273 static ssize_t v9fs_do_llistxattr(V9fsState *s, V9fsString *path,
274 void *value, size_t size)
275 {
276 return s->ops->llistxattr(&s->ctx, path->data,
277 value, size);
278 }
279
280 static int v9fs_do_lsetxattr(V9fsState *s, V9fsString *path,
281 V9fsString *xattr_name,
282 void *value, size_t size, int flags)
283 {
284 return s->ops->lsetxattr(&s->ctx, path->data,
285 xattr_name->data, value, size, flags);
286 }
287
288 static int v9fs_do_lremovexattr(V9fsState *s, V9fsString *path,
289 V9fsString *xattr_name)
290 {
291 return s->ops->lremovexattr(&s->ctx, path->data,
292 xattr_name->data);
293 }
294
295
296 static void v9fs_string_init(V9fsString *str)
297 {
298 str->data = NULL;
299 str->size = 0;
300 }
301
302 static void v9fs_string_free(V9fsString *str)
303 {
304 qemu_free(str->data);
305 str->data = NULL;
306 str->size = 0;
307 }
308
309 static void v9fs_string_null(V9fsString *str)
310 {
311 v9fs_string_free(str);
312 }
313
314 static int number_to_string(void *arg, char type)
315 {
316 unsigned int ret = 0;
317
318 switch (type) {
319 case 'u': {
320 unsigned int num = *(unsigned int *)arg;
321
322 do {
323 ret++;
324 num = num/10;
325 } while (num);
326 break;
327 }
328 default:
329 printf("Number_to_string: Unknown number format\n");
330 return -1;
331 }
332
333 return ret;
334 }
335
336 static int GCC_FMT_ATTR(2, 0)
337 v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
338 {
339 va_list ap2;
340 char *iter = (char *)fmt;
341 int len = 0;
342 int nr_args = 0;
343 char *arg_char_ptr;
344 unsigned int arg_uint;
345
346 /* Find the number of %'s that denotes an argument */
347 for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
348 nr_args++;
349 iter++;
350 }
351
352 len = strlen(fmt) - 2*nr_args;
353
354 if (!nr_args) {
355 goto alloc_print;
356 }
357
358 va_copy(ap2, ap);
359
360 iter = (char *)fmt;
361
362 /* Now parse the format string */
363 for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
364 iter++;
365 switch (*iter) {
366 case 'u':
367 arg_uint = va_arg(ap2, unsigned int);
368 len += number_to_string((void *)&arg_uint, 'u');
369 break;
370 case 's':
371 arg_char_ptr = va_arg(ap2, char *);
372 len += strlen(arg_char_ptr);
373 break;
374 case 'c':
375 len += 1;
376 break;
377 default:
378 fprintf(stderr,
379 "v9fs_string_alloc_printf:Incorrect format %c", *iter);
380 return -1;
381 }
382 iter++;
383 }
384
385 alloc_print:
386 *strp = qemu_malloc((len + 1) * sizeof(**strp));
387
388 return vsprintf(*strp, fmt, ap);
389 }
390
391 static void GCC_FMT_ATTR(2, 3)
392 v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
393 {
394 va_list ap;
395 int err;
396
397 v9fs_string_free(str);
398
399 va_start(ap, fmt);
400 err = v9fs_string_alloc_printf(&str->data, fmt, ap);
401 BUG_ON(err == -1);
402 va_end(ap);
403
404 str->size = err;
405 }
406
407 static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
408 {
409 v9fs_string_free(lhs);
410 v9fs_string_sprintf(lhs, "%s", rhs->data);
411 }
412
413 static size_t v9fs_string_size(V9fsString *str)
414 {
415 return str->size;
416 }
417
418 static V9fsFidState *lookup_fid(V9fsState *s, int32_t fid)
419 {
420 V9fsFidState *f;
421
422 for (f = s->fid_list; f; f = f->next) {
423 if (f->fid == fid) {
424 return f;
425 }
426 }
427
428 return NULL;
429 }
430
431 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
432 {
433 V9fsFidState *f;
434
435 f = lookup_fid(s, fid);
436 if (f) {
437 return NULL;
438 }
439
440 f = qemu_mallocz(sizeof(V9fsFidState));
441
442 f->fid = fid;
443 f->fid_type = P9_FID_NONE;
444
445 f->next = s->fid_list;
446 s->fid_list = f;
447
448 return f;
449 }
450
451 static int v9fs_xattr_fid_clunk(V9fsState *s, V9fsFidState *fidp)
452 {
453 int retval = 0;
454
455 if (fidp->fs.xattr.copied_len == -1) {
456 /* getxattr/listxattr fid */
457 goto free_value;
458 }
459 /*
460 * if this is fid for setxattr. clunk should
461 * result in setxattr localcall
462 */
463 if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
464 /* clunk after partial write */
465 retval = -EINVAL;
466 goto free_out;
467 }
468 if (fidp->fs.xattr.len) {
469 retval = v9fs_do_lsetxattr(s, &fidp->path, &fidp->fs.xattr.name,
470 fidp->fs.xattr.value,
471 fidp->fs.xattr.len,
472 fidp->fs.xattr.flags);
473 } else {
474 retval = v9fs_do_lremovexattr(s, &fidp->path, &fidp->fs.xattr.name);
475 }
476 free_out:
477 v9fs_string_free(&fidp->fs.xattr.name);
478 free_value:
479 if (fidp->fs.xattr.value) {
480 qemu_free(fidp->fs.xattr.value);
481 }
482 return retval;
483 }
484
485 static int free_fid(V9fsState *s, int32_t fid)
486 {
487 int retval = 0;
488 V9fsFidState **fidpp, *fidp;
489
490 for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
491 if ((*fidpp)->fid == fid) {
492 break;
493 }
494 }
495
496 if (*fidpp == NULL) {
497 return -ENOENT;
498 }
499
500 fidp = *fidpp;
501 *fidpp = fidp->next;
502
503 if (fidp->fid_type == P9_FID_FILE) {
504 v9fs_do_close(s, fidp->fs.fd);
505 } else if (fidp->fid_type == P9_FID_DIR) {
506 v9fs_do_closedir(s, fidp->fs.dir);
507 } else if (fidp->fid_type == P9_FID_XATTR) {
508 retval = v9fs_xattr_fid_clunk(s, fidp);
509 }
510 v9fs_string_free(&fidp->path);
511 qemu_free(fidp);
512
513 return retval;
514 }
515
516 #define P9_QID_TYPE_DIR 0x80
517 #define P9_QID_TYPE_SYMLINK 0x02
518
519 #define P9_STAT_MODE_DIR 0x80000000
520 #define P9_STAT_MODE_APPEND 0x40000000
521 #define P9_STAT_MODE_EXCL 0x20000000
522 #define P9_STAT_MODE_MOUNT 0x10000000
523 #define P9_STAT_MODE_AUTH 0x08000000
524 #define P9_STAT_MODE_TMP 0x04000000
525 #define P9_STAT_MODE_SYMLINK 0x02000000
526 #define P9_STAT_MODE_LINK 0x01000000
527 #define P9_STAT_MODE_DEVICE 0x00800000
528 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
529 #define P9_STAT_MODE_SOCKET 0x00100000
530 #define P9_STAT_MODE_SETUID 0x00080000
531 #define P9_STAT_MODE_SETGID 0x00040000
532 #define P9_STAT_MODE_SETVTX 0x00010000
533
534 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR | \
535 P9_STAT_MODE_SYMLINK | \
536 P9_STAT_MODE_LINK | \
537 P9_STAT_MODE_DEVICE | \
538 P9_STAT_MODE_NAMED_PIPE | \
539 P9_STAT_MODE_SOCKET)
540
541 /* This is the algorithm from ufs in spfs */
542 static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)
543 {
544 size_t size;
545
546 size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
547 memcpy(&qidp->path, &stbuf->st_ino, size);
548 qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
549 qidp->type = 0;
550 if (S_ISDIR(stbuf->st_mode)) {
551 qidp->type |= P9_QID_TYPE_DIR;
552 }
553 if (S_ISLNK(stbuf->st_mode)) {
554 qidp->type |= P9_QID_TYPE_SYMLINK;
555 }
556 }
557
558 static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp)
559 {
560 struct stat stbuf;
561 int err;
562
563 err = v9fs_do_lstat(s, &fidp->path, &stbuf);
564 if (err) {
565 return err;
566 }
567
568 stat_to_qid(&stbuf, qidp);
569 return 0;
570 }
571
572 static V9fsPDU *alloc_pdu(V9fsState *s)
573 {
574 V9fsPDU *pdu = NULL;
575
576 if (!QLIST_EMPTY(&s->free_list)) {
577 pdu = QLIST_FIRST(&s->free_list);
578 QLIST_REMOVE(pdu, next);
579 }
580 return pdu;
581 }
582
583 static void free_pdu(V9fsState *s, V9fsPDU *pdu)
584 {
585 if (pdu) {
586 QLIST_INSERT_HEAD(&s->free_list, pdu, next);
587 }
588 }
589
590 size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
591 size_t offset, size_t size, int pack)
592 {
593 int i = 0;
594 size_t copied = 0;
595
596 for (i = 0; size && i < sg_count; i++) {
597 size_t len;
598 if (offset >= sg[i].iov_len) {
599 /* skip this sg */
600 offset -= sg[i].iov_len;
601 continue;
602 } else {
603 len = MIN(sg[i].iov_len - offset, size);
604 if (pack) {
605 memcpy(sg[i].iov_base + offset, addr, len);
606 } else {
607 memcpy(addr, sg[i].iov_base + offset, len);
608 }
609 size -= len;
610 copied += len;
611 addr += len;
612 if (size) {
613 offset = 0;
614 continue;
615 }
616 }
617 }
618
619 return copied;
620 }
621
622 static size_t pdu_unpack(void *dst, V9fsPDU *pdu, size_t offset, size_t size)
623 {
624 return pdu_packunpack(dst, pdu->elem.out_sg, pdu->elem.out_num,
625 offset, size, 0);
626 }
627
628 static size_t pdu_pack(V9fsPDU *pdu, size_t offset, const void *src,
629 size_t size)
630 {
631 return pdu_packunpack((void *)src, pdu->elem.in_sg, pdu->elem.in_num,
632 offset, size, 1);
633 }
634
635 static int pdu_copy_sg(V9fsPDU *pdu, size_t offset, int rx, struct iovec *sg)
636 {
637 size_t pos = 0;
638 int i, j;
639 struct iovec *src_sg;
640 unsigned int num;
641
642 if (rx) {
643 src_sg = pdu->elem.in_sg;
644 num = pdu->elem.in_num;
645 } else {
646 src_sg = pdu->elem.out_sg;
647 num = pdu->elem.out_num;
648 }
649
650 j = 0;
651 for (i = 0; i < num; i++) {
652 if (offset <= pos) {
653 sg[j].iov_base = src_sg[i].iov_base;
654 sg[j].iov_len = src_sg[i].iov_len;
655 j++;
656 } else if (offset < (src_sg[i].iov_len + pos)) {
657 sg[j].iov_base = src_sg[i].iov_base;
658 sg[j].iov_len = src_sg[i].iov_len;
659 sg[j].iov_base += (offset - pos);
660 sg[j].iov_len -= (offset - pos);
661 j++;
662 }
663 pos += src_sg[i].iov_len;
664 }
665
666 return j;
667 }
668
669 static size_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
670 {
671 size_t old_offset = offset;
672 va_list ap;
673 int i;
674
675 va_start(ap, fmt);
676 for (i = 0; fmt[i]; i++) {
677 switch (fmt[i]) {
678 case 'b': {
679 uint8_t *valp = va_arg(ap, uint8_t *);
680 offset += pdu_unpack(valp, pdu, offset, sizeof(*valp));
681 break;
682 }
683 case 'w': {
684 uint16_t val, *valp;
685 valp = va_arg(ap, uint16_t *);
686 val = le16_to_cpupu(valp);
687 offset += pdu_unpack(&val, pdu, offset, sizeof(val));
688 *valp = val;
689 break;
690 }
691 case 'd': {
692 uint32_t val, *valp;
693 valp = va_arg(ap, uint32_t *);
694 val = le32_to_cpupu(valp);
695 offset += pdu_unpack(&val, pdu, offset, sizeof(val));
696 *valp = val;
697 break;
698 }
699 case 'q': {
700 uint64_t val, *valp;
701 valp = va_arg(ap, uint64_t *);
702 val = le64_to_cpup(valp);
703 offset += pdu_unpack(&val, pdu, offset, sizeof(val));
704 *valp = val;
705 break;
706 }
707 case 'v': {
708 struct iovec *iov = va_arg(ap, struct iovec *);
709 int *iovcnt = va_arg(ap, int *);
710 *iovcnt = pdu_copy_sg(pdu, offset, 0, iov);
711 break;
712 }
713 case 's': {
714 V9fsString *str = va_arg(ap, V9fsString *);
715 offset += pdu_unmarshal(pdu, offset, "w", &str->size);
716 /* FIXME: sanity check str->size */
717 str->data = qemu_malloc(str->size + 1);
718 offset += pdu_unpack(str->data, pdu, offset, str->size);
719 str->data[str->size] = 0;
720 break;
721 }
722 case 'Q': {
723 V9fsQID *qidp = va_arg(ap, V9fsQID *);
724 offset += pdu_unmarshal(pdu, offset, "bdq",
725 &qidp->type, &qidp->version, &qidp->path);
726 break;
727 }
728 case 'S': {
729 V9fsStat *statp = va_arg(ap, V9fsStat *);
730 offset += pdu_unmarshal(pdu, offset, "wwdQdddqsssssddd",
731 &statp->size, &statp->type, &statp->dev,
732 &statp->qid, &statp->mode, &statp->atime,
733 &statp->mtime, &statp->length,
734 &statp->name, &statp->uid, &statp->gid,
735 &statp->muid, &statp->extension,
736 &statp->n_uid, &statp->n_gid,
737 &statp->n_muid);
738 break;
739 }
740 case 'I': {
741 V9fsIattr *iattr = va_arg(ap, V9fsIattr *);
742 offset += pdu_unmarshal(pdu, offset, "ddddqqqqq",
743 &iattr->valid, &iattr->mode,
744 &iattr->uid, &iattr->gid, &iattr->size,
745 &iattr->atime_sec, &iattr->atime_nsec,
746 &iattr->mtime_sec, &iattr->mtime_nsec);
747 break;
748 }
749 default:
750 break;
751 }
752 }
753
754 va_end(ap);
755
756 return offset - old_offset;
757 }
758
759 static size_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
760 {
761 size_t old_offset = offset;
762 va_list ap;
763 int i;
764
765 va_start(ap, fmt);
766 for (i = 0; fmt[i]; i++) {
767 switch (fmt[i]) {
768 case 'b': {
769 uint8_t val = va_arg(ap, int);
770 offset += pdu_pack(pdu, offset, &val, sizeof(val));
771 break;
772 }
773 case 'w': {
774 uint16_t val;
775 cpu_to_le16w(&val, va_arg(ap, int));
776 offset += pdu_pack(pdu, offset, &val, sizeof(val));
777 break;
778 }
779 case 'd': {
780 uint32_t val;
781 cpu_to_le32w(&val, va_arg(ap, uint32_t));
782 offset += pdu_pack(pdu, offset, &val, sizeof(val));
783 break;
784 }
785 case 'q': {
786 uint64_t val;
787 cpu_to_le64w(&val, va_arg(ap, uint64_t));
788 offset += pdu_pack(pdu, offset, &val, sizeof(val));
789 break;
790 }
791 case 'v': {
792 struct iovec *iov = va_arg(ap, struct iovec *);
793 int *iovcnt = va_arg(ap, int *);
794 *iovcnt = pdu_copy_sg(pdu, offset, 1, iov);
795 break;
796 }
797 case 's': {
798 V9fsString *str = va_arg(ap, V9fsString *);
799 offset += pdu_marshal(pdu, offset, "w", str->size);
800 offset += pdu_pack(pdu, offset, str->data, str->size);
801 break;
802 }
803 case 'Q': {
804 V9fsQID *qidp = va_arg(ap, V9fsQID *);
805 offset += pdu_marshal(pdu, offset, "bdq",
806 qidp->type, qidp->version, qidp->path);
807 break;
808 }
809 case 'S': {
810 V9fsStat *statp = va_arg(ap, V9fsStat *);
811 offset += pdu_marshal(pdu, offset, "wwdQdddqsssssddd",
812 statp->size, statp->type, statp->dev,
813 &statp->qid, statp->mode, statp->atime,
814 statp->mtime, statp->length, &statp->name,
815 &statp->uid, &statp->gid, &statp->muid,
816 &statp->extension, statp->n_uid,
817 statp->n_gid, statp->n_muid);
818 break;
819 }
820 case 'A': {
821 V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);
822 offset += pdu_marshal(pdu, offset, "qQdddqqqqqqqqqqqqqqq",
823 statp->st_result_mask,
824 &statp->qid, statp->st_mode,
825 statp->st_uid, statp->st_gid,
826 statp->st_nlink, statp->st_rdev,
827 statp->st_size, statp->st_blksize, statp->st_blocks,
828 statp->st_atime_sec, statp->st_atime_nsec,
829 statp->st_mtime_sec, statp->st_mtime_nsec,
830 statp->st_ctime_sec, statp->st_ctime_nsec,
831 statp->st_btime_sec, statp->st_btime_nsec,
832 statp->st_gen, statp->st_data_version);
833 break;
834 }
835 default:
836 break;
837 }
838 }
839 va_end(ap);
840
841 return offset - old_offset;
842 }
843
844 static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
845 {
846 int8_t id = pdu->id + 1; /* Response */
847
848 if (len < 0) {
849 int err = -len;
850 len = 7;
851
852 if (s->proto_version != V9FS_PROTO_2000L) {
853 V9fsString str;
854
855 str.data = strerror(err);
856 str.size = strlen(str.data);
857
858 len += pdu_marshal(pdu, len, "s", &str);
859 id = P9_RERROR;
860 }
861
862 len += pdu_marshal(pdu, len, "d", err);
863
864 if (s->proto_version == V9FS_PROTO_2000L) {
865 id = P9_RLERROR;
866 }
867 }
868
869 /* fill out the header */
870 pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);
871
872 /* keep these in sync */
873 pdu->size = len;
874 pdu->id = id;
875
876 /* push onto queue and notify */
877 virtqueue_push(s->vq, &pdu->elem, len);
878
879 /* FIXME: we should batch these completions */
880 virtio_notify(&s->vdev, s->vq);
881
882 free_pdu(s, pdu);
883 }
884
885 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
886 {
887 mode_t ret;
888
889 ret = mode & 0777;
890 if (mode & P9_STAT_MODE_DIR) {
891 ret |= S_IFDIR;
892 }
893
894 if (mode & P9_STAT_MODE_SYMLINK) {
895 ret |= S_IFLNK;
896 }
897 if (mode & P9_STAT_MODE_SOCKET) {
898 ret |= S_IFSOCK;
899 }
900 if (mode & P9_STAT_MODE_NAMED_PIPE) {
901 ret |= S_IFIFO;
902 }
903 if (mode & P9_STAT_MODE_DEVICE) {
904 if (extension && extension->data[0] == 'c') {
905 ret |= S_IFCHR;
906 } else {
907 ret |= S_IFBLK;
908 }
909 }
910
911 if (!(ret&~0777)) {
912 ret |= S_IFREG;
913 }
914
915 if (mode & P9_STAT_MODE_SETUID) {
916 ret |= S_ISUID;
917 }
918 if (mode & P9_STAT_MODE_SETGID) {
919 ret |= S_ISGID;
920 }
921 if (mode & P9_STAT_MODE_SETVTX) {
922 ret |= S_ISVTX;
923 }
924
925 return ret;
926 }
927
928 static int donttouch_stat(V9fsStat *stat)
929 {
930 if (stat->type == -1 &&
931 stat->dev == -1 &&
932 stat->qid.type == -1 &&
933 stat->qid.version == -1 &&
934 stat->qid.path == -1 &&
935 stat->mode == -1 &&
936 stat->atime == -1 &&
937 stat->mtime == -1 &&
938 stat->length == -1 &&
939 !stat->name.size &&
940 !stat->uid.size &&
941 !stat->gid.size &&
942 !stat->muid.size &&
943 stat->n_uid == -1 &&
944 stat->n_gid == -1 &&
945 stat->n_muid == -1) {
946 return 1;
947 }
948
949 return 0;
950 }
951
952 static void v9fs_stat_free(V9fsStat *stat)
953 {
954 v9fs_string_free(&stat->name);
955 v9fs_string_free(&stat->uid);
956 v9fs_string_free(&stat->gid);
957 v9fs_string_free(&stat->muid);
958 v9fs_string_free(&stat->extension);
959 }
960
961 static uint32_t stat_to_v9mode(const struct stat *stbuf)
962 {
963 uint32_t mode;
964
965 mode = stbuf->st_mode & 0777;
966 if (S_ISDIR(stbuf->st_mode)) {
967 mode |= P9_STAT_MODE_DIR;
968 }
969
970 if (S_ISLNK(stbuf->st_mode)) {
971 mode |= P9_STAT_MODE_SYMLINK;
972 }
973
974 if (S_ISSOCK(stbuf->st_mode)) {
975 mode |= P9_STAT_MODE_SOCKET;
976 }
977
978 if (S_ISFIFO(stbuf->st_mode)) {
979 mode |= P9_STAT_MODE_NAMED_PIPE;
980 }
981
982 if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
983 mode |= P9_STAT_MODE_DEVICE;
984 }
985
986 if (stbuf->st_mode & S_ISUID) {
987 mode |= P9_STAT_MODE_SETUID;
988 }
989
990 if (stbuf->st_mode & S_ISGID) {
991 mode |= P9_STAT_MODE_SETGID;
992 }
993
994 if (stbuf->st_mode & S_ISVTX) {
995 mode |= P9_STAT_MODE_SETVTX;
996 }
997
998 return mode;
999 }
1000
1001 static int stat_to_v9stat(V9fsState *s, V9fsString *name,
1002 const struct stat *stbuf,
1003 V9fsStat *v9stat)
1004 {
1005 int err;
1006 const char *str;
1007
1008 memset(v9stat, 0, sizeof(*v9stat));
1009
1010 stat_to_qid(stbuf, &v9stat->qid);
1011 v9stat->mode = stat_to_v9mode(stbuf);
1012 v9stat->atime = stbuf->st_atime;
1013 v9stat->mtime = stbuf->st_mtime;
1014 v9stat->length = stbuf->st_size;
1015
1016 v9fs_string_null(&v9stat->uid);
1017 v9fs_string_null(&v9stat->gid);
1018 v9fs_string_null(&v9stat->muid);
1019
1020 v9stat->n_uid = stbuf->st_uid;
1021 v9stat->n_gid = stbuf->st_gid;
1022 v9stat->n_muid = 0;
1023
1024 v9fs_string_null(&v9stat->extension);
1025
1026 if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
1027 err = v9fs_do_readlink(s, name, &v9stat->extension);
1028 if (err == -1) {
1029 err = -errno;
1030 return err;
1031 }
1032 v9stat->extension.data[err] = 0;
1033 v9stat->extension.size = err;
1034 } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
1035 v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
1036 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
1037 major(stbuf->st_rdev), minor(stbuf->st_rdev));
1038 } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
1039 v9fs_string_sprintf(&v9stat->extension, "%s %lu",
1040 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
1041 }
1042
1043 str = strrchr(name->data, '/');
1044 if (str) {
1045 str += 1;
1046 } else {
1047 str = name->data;
1048 }
1049
1050 v9fs_string_sprintf(&v9stat->name, "%s", str);
1051
1052 v9stat->size = 61 +
1053 v9fs_string_size(&v9stat->name) +
1054 v9fs_string_size(&v9stat->uid) +
1055 v9fs_string_size(&v9stat->gid) +
1056 v9fs_string_size(&v9stat->muid) +
1057 v9fs_string_size(&v9stat->extension);
1058 return 0;
1059 }
1060
1061 #define P9_STATS_MODE 0x00000001ULL
1062 #define P9_STATS_NLINK 0x00000002ULL
1063 #define P9_STATS_UID 0x00000004ULL
1064 #define P9_STATS_GID 0x00000008ULL
1065 #define P9_STATS_RDEV 0x00000010ULL
1066 #define P9_STATS_ATIME 0x00000020ULL
1067 #define P9_STATS_MTIME 0x00000040ULL
1068 #define P9_STATS_CTIME 0x00000080ULL
1069 #define P9_STATS_INO 0x00000100ULL
1070 #define P9_STATS_SIZE 0x00000200ULL
1071 #define P9_STATS_BLOCKS 0x00000400ULL
1072
1073 #define P9_STATS_BTIME 0x00000800ULL
1074 #define P9_STATS_GEN 0x00001000ULL
1075 #define P9_STATS_DATA_VERSION 0x00002000ULL
1076
1077 #define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */
1078 #define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */
1079
1080
1081 static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,
1082 V9fsStatDotl *v9lstat)
1083 {
1084 memset(v9lstat, 0, sizeof(*v9lstat));
1085
1086 v9lstat->st_mode = stbuf->st_mode;
1087 v9lstat->st_nlink = stbuf->st_nlink;
1088 v9lstat->st_uid = stbuf->st_uid;
1089 v9lstat->st_gid = stbuf->st_gid;
1090 v9lstat->st_rdev = stbuf->st_rdev;
1091 v9lstat->st_size = stbuf->st_size;
1092 v9lstat->st_blksize = stbuf->st_blksize;
1093 v9lstat->st_blocks = stbuf->st_blocks;
1094 v9lstat->st_atime_sec = stbuf->st_atime;
1095 v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
1096 v9lstat->st_mtime_sec = stbuf->st_mtime;
1097 v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
1098 v9lstat->st_ctime_sec = stbuf->st_ctime;
1099 v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
1100 /* Currently we only support BASIC fields in stat */
1101 v9lstat->st_result_mask = P9_STATS_BASIC;
1102
1103 stat_to_qid(stbuf, &v9lstat->qid);
1104 }
1105
1106 static struct iovec *adjust_sg(struct iovec *sg, int len, int *iovcnt)
1107 {
1108 while (len && *iovcnt) {
1109 if (len < sg->iov_len) {
1110 sg->iov_len -= len;
1111 sg->iov_base += len;
1112 len = 0;
1113 } else {
1114 len -= sg->iov_len;
1115 sg++;
1116 *iovcnt -= 1;
1117 }
1118 }
1119
1120 return sg;
1121 }
1122
1123 static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
1124 {
1125 int i;
1126 int total = 0;
1127
1128 for (i = 0; i < *cnt; i++) {
1129 if ((total + sg[i].iov_len) > cap) {
1130 sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
1131 i++;
1132 break;
1133 }
1134 total += sg[i].iov_len;
1135 }
1136
1137 *cnt = i;
1138
1139 return sg;
1140 }
1141
1142 static void print_sg(struct iovec *sg, int cnt)
1143 {
1144 int i;
1145
1146 printf("sg[%d]: {", cnt);
1147 for (i = 0; i < cnt; i++) {
1148 if (i) {
1149 printf(", ");
1150 }
1151 printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
1152 }
1153 printf("}\n");
1154 }
1155
1156 static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
1157 {
1158 V9fsString str;
1159 v9fs_string_init(&str);
1160 v9fs_string_copy(&str, dst);
1161 v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
1162 v9fs_string_free(&str);
1163 }
1164
1165 static void v9fs_version(V9fsState *s, V9fsPDU *pdu)
1166 {
1167 V9fsString version;
1168 size_t offset = 7;
1169
1170 pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
1171
1172 if (!strcmp(version.data, "9P2000.u")) {
1173 s->proto_version = V9FS_PROTO_2000U;
1174 } else if (!strcmp(version.data, "9P2000.L")) {
1175 s->proto_version = V9FS_PROTO_2000L;
1176 } else {
1177 v9fs_string_sprintf(&version, "unknown");
1178 }
1179
1180 offset += pdu_marshal(pdu, offset, "ds", s->msize, &version);
1181 complete_pdu(s, pdu, offset);
1182
1183 v9fs_string_free(&version);
1184 }
1185
1186 static void v9fs_attach(V9fsState *s, V9fsPDU *pdu)
1187 {
1188 int32_t fid, afid, n_uname;
1189 V9fsString uname, aname;
1190 V9fsFidState *fidp;
1191 V9fsQID qid;
1192 size_t offset = 7;
1193 ssize_t err;
1194
1195 pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
1196
1197 fidp = alloc_fid(s, fid);
1198 if (fidp == NULL) {
1199 err = -EINVAL;
1200 goto out;
1201 }
1202
1203 fidp->uid = n_uname;
1204
1205 v9fs_string_sprintf(&fidp->path, "%s", "/");
1206 err = fid_to_qid(s, fidp, &qid);
1207 if (err) {
1208 err = -EINVAL;
1209 free_fid(s, fid);
1210 goto out;
1211 }
1212
1213 offset += pdu_marshal(pdu, offset, "Q", &qid);
1214
1215 err = offset;
1216 out:
1217 complete_pdu(s, pdu, err);
1218 v9fs_string_free(&uname);
1219 v9fs_string_free(&aname);
1220 }
1221
1222 static void v9fs_stat_post_lstat(V9fsState *s, V9fsStatState *vs, int err)
1223 {
1224 if (err == -1) {
1225 err = -errno;
1226 goto out;
1227 }
1228
1229 err = stat_to_v9stat(s, &vs->fidp->path, &vs->stbuf, &vs->v9stat);
1230 if (err) {
1231 goto out;
1232 }
1233 vs->offset += pdu_marshal(vs->pdu, vs->offset, "wS", 0, &vs->v9stat);
1234 err = vs->offset;
1235
1236 out:
1237 complete_pdu(s, vs->pdu, err);
1238 v9fs_stat_free(&vs->v9stat);
1239 qemu_free(vs);
1240 }
1241
1242 static void v9fs_stat(V9fsState *s, V9fsPDU *pdu)
1243 {
1244 int32_t fid;
1245 V9fsStatState *vs;
1246 ssize_t err = 0;
1247
1248 vs = qemu_malloc(sizeof(*vs));
1249 vs->pdu = pdu;
1250 vs->offset = 7;
1251
1252 memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1253
1254 pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
1255
1256 vs->fidp = lookup_fid(s, fid);
1257 if (vs->fidp == NULL) {
1258 err = -ENOENT;
1259 goto out;
1260 }
1261
1262 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1263 v9fs_stat_post_lstat(s, vs, err);
1264 return;
1265
1266 out:
1267 complete_pdu(s, vs->pdu, err);
1268 v9fs_stat_free(&vs->v9stat);
1269 qemu_free(vs);
1270 }
1271
1272 static void v9fs_getattr_post_lstat(V9fsState *s, V9fsStatStateDotl *vs,
1273 int err)
1274 {
1275 if (err == -1) {
1276 err = -errno;
1277 goto out;
1278 }
1279
1280 stat_to_v9stat_dotl(s, &vs->stbuf, &vs->v9stat_dotl);
1281 vs->offset += pdu_marshal(vs->pdu, vs->offset, "A", &vs->v9stat_dotl);
1282 err = vs->offset;
1283
1284 out:
1285 complete_pdu(s, vs->pdu, err);
1286 qemu_free(vs);
1287 }
1288
1289 static void v9fs_getattr(V9fsState *s, V9fsPDU *pdu)
1290 {
1291 int32_t fid;
1292 V9fsStatStateDotl *vs;
1293 ssize_t err = 0;
1294 V9fsFidState *fidp;
1295 uint64_t request_mask;
1296
1297 vs = qemu_malloc(sizeof(*vs));
1298 vs->pdu = pdu;
1299 vs->offset = 7;
1300
1301 memset(&vs->v9stat_dotl, 0, sizeof(vs->v9stat_dotl));
1302
1303 pdu_unmarshal(vs->pdu, vs->offset, "dq", &fid, &request_mask);
1304
1305 fidp = lookup_fid(s, fid);
1306 if (fidp == NULL) {
1307 err = -ENOENT;
1308 goto out;
1309 }
1310
1311 /* Currently we only support BASIC fields in stat, so there is no
1312 * need to look at request_mask.
1313 */
1314 err = v9fs_do_lstat(s, &fidp->path, &vs->stbuf);
1315 v9fs_getattr_post_lstat(s, vs, err);
1316 return;
1317
1318 out:
1319 complete_pdu(s, vs->pdu, err);
1320 qemu_free(vs);
1321 }
1322
1323 /* From Linux kernel code */
1324 #define ATTR_MODE (1 << 0)
1325 #define ATTR_UID (1 << 1)
1326 #define ATTR_GID (1 << 2)
1327 #define ATTR_SIZE (1 << 3)
1328 #define ATTR_ATIME (1 << 4)
1329 #define ATTR_MTIME (1 << 5)
1330 #define ATTR_CTIME (1 << 6)
1331 #define ATTR_MASK 127
1332 #define ATTR_ATIME_SET (1 << 7)
1333 #define ATTR_MTIME_SET (1 << 8)
1334
1335 static void v9fs_setattr_post_truncate(V9fsState *s, V9fsSetattrState *vs,
1336 int err)
1337 {
1338 if (err == -1) {
1339 err = -errno;
1340 goto out;
1341 }
1342 err = vs->offset;
1343
1344 out:
1345 complete_pdu(s, vs->pdu, err);
1346 qemu_free(vs);
1347 }
1348
1349 static void v9fs_setattr_post_chown(V9fsState *s, V9fsSetattrState *vs, int err)
1350 {
1351 if (err == -1) {
1352 err = -errno;
1353 goto out;
1354 }
1355
1356 if (vs->v9iattr.valid & (ATTR_SIZE)) {
1357 err = v9fs_do_truncate(s, &vs->fidp->path, vs->v9iattr.size);
1358 }
1359 v9fs_setattr_post_truncate(s, vs, err);
1360 return;
1361
1362 out:
1363 complete_pdu(s, vs->pdu, err);
1364 qemu_free(vs);
1365 }
1366
1367 static void v9fs_setattr_post_utimensat(V9fsState *s, V9fsSetattrState *vs,
1368 int err)
1369 {
1370 if (err == -1) {
1371 err = -errno;
1372 goto out;
1373 }
1374
1375 /* If the only valid entry in iattr is ctime we can call
1376 * chown(-1,-1) to update the ctime of the file
1377 */
1378 if ((vs->v9iattr.valid & (ATTR_UID | ATTR_GID)) ||
1379 ((vs->v9iattr.valid & ATTR_CTIME)
1380 && !((vs->v9iattr.valid & ATTR_MASK) & ~ATTR_CTIME))) {
1381 if (!(vs->v9iattr.valid & ATTR_UID)) {
1382 vs->v9iattr.uid = -1;
1383 }
1384 if (!(vs->v9iattr.valid & ATTR_GID)) {
1385 vs->v9iattr.gid = -1;
1386 }
1387 err = v9fs_do_chown(s, &vs->fidp->path, vs->v9iattr.uid,
1388 vs->v9iattr.gid);
1389 }
1390 v9fs_setattr_post_chown(s, vs, err);
1391 return;
1392
1393 out:
1394 complete_pdu(s, vs->pdu, err);
1395 qemu_free(vs);
1396 }
1397
1398 static void v9fs_setattr_post_chmod(V9fsState *s, V9fsSetattrState *vs, int err)
1399 {
1400 if (err == -1) {
1401 err = -errno;
1402 goto out;
1403 }
1404
1405 if (vs->v9iattr.valid & (ATTR_ATIME | ATTR_MTIME)) {
1406 struct timespec times[2];
1407 if (vs->v9iattr.valid & ATTR_ATIME) {
1408 if (vs->v9iattr.valid & ATTR_ATIME_SET) {
1409 times[0].tv_sec = vs->v9iattr.atime_sec;
1410 times[0].tv_nsec = vs->v9iattr.atime_nsec;
1411 } else {
1412 times[0].tv_nsec = UTIME_NOW;
1413 }
1414 } else {
1415 times[0].tv_nsec = UTIME_OMIT;
1416 }
1417
1418 if (vs->v9iattr.valid & ATTR_MTIME) {
1419 if (vs->v9iattr.valid & ATTR_MTIME_SET) {
1420 times[1].tv_sec = vs->v9iattr.mtime_sec;
1421 times[1].tv_nsec = vs->v9iattr.mtime_nsec;
1422 } else {
1423 times[1].tv_nsec = UTIME_NOW;
1424 }
1425 } else {
1426 times[1].tv_nsec = UTIME_OMIT;
1427 }
1428 err = v9fs_do_utimensat(s, &vs->fidp->path, times);
1429 }
1430 v9fs_setattr_post_utimensat(s, vs, err);
1431 return;
1432
1433 out:
1434 complete_pdu(s, vs->pdu, err);
1435 qemu_free(vs);
1436 }
1437
1438 static void v9fs_setattr(V9fsState *s, V9fsPDU *pdu)
1439 {
1440 int32_t fid;
1441 V9fsSetattrState *vs;
1442 int err = 0;
1443
1444 vs = qemu_malloc(sizeof(*vs));
1445 vs->pdu = pdu;
1446 vs->offset = 7;
1447
1448 pdu_unmarshal(pdu, vs->offset, "dI", &fid, &vs->v9iattr);
1449
1450 vs->fidp = lookup_fid(s, fid);
1451 if (vs->fidp == NULL) {
1452 err = -EINVAL;
1453 goto out;
1454 }
1455
1456 if (vs->v9iattr.valid & ATTR_MODE) {
1457 err = v9fs_do_chmod(s, &vs->fidp->path, vs->v9iattr.mode);
1458 }
1459
1460 v9fs_setattr_post_chmod(s, vs, err);
1461 return;
1462
1463 out:
1464 complete_pdu(s, vs->pdu, err);
1465 qemu_free(vs);
1466 }
1467
1468 static void v9fs_walk_complete(V9fsState *s, V9fsWalkState *vs, int err)
1469 {
1470 complete_pdu(s, vs->pdu, err);
1471
1472 if (vs->nwnames) {
1473 for (vs->name_idx = 0; vs->name_idx < vs->nwnames; vs->name_idx++) {
1474 v9fs_string_free(&vs->wnames[vs->name_idx]);
1475 }
1476
1477 qemu_free(vs->wnames);
1478 qemu_free(vs->qids);
1479 }
1480 }
1481
1482 static void v9fs_walk_marshal(V9fsWalkState *vs)
1483 {
1484 int i;
1485 vs->offset = 7;
1486 vs->offset += pdu_marshal(vs->pdu, vs->offset, "w", vs->nwnames);
1487
1488 for (i = 0; i < vs->nwnames; i++) {
1489 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qids[i]);
1490 }
1491 }
1492
1493 static void v9fs_walk_post_newfid_lstat(V9fsState *s, V9fsWalkState *vs,
1494 int err)
1495 {
1496 if (err == -1) {
1497 free_fid(s, vs->newfidp->fid);
1498 v9fs_string_free(&vs->path);
1499 err = -ENOENT;
1500 goto out;
1501 }
1502
1503 stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1504
1505 vs->name_idx++;
1506 if (vs->name_idx < vs->nwnames) {
1507 v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1508 vs->wnames[vs->name_idx].data);
1509 v9fs_string_copy(&vs->newfidp->path, &vs->path);
1510
1511 err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1512 v9fs_walk_post_newfid_lstat(s, vs, err);
1513 return;
1514 }
1515
1516 v9fs_string_free(&vs->path);
1517 v9fs_walk_marshal(vs);
1518 err = vs->offset;
1519 out:
1520 v9fs_walk_complete(s, vs, err);
1521 }
1522
1523 static void v9fs_walk_post_oldfid_lstat(V9fsState *s, V9fsWalkState *vs,
1524 int err)
1525 {
1526 if (err == -1) {
1527 v9fs_string_free(&vs->path);
1528 err = -ENOENT;
1529 goto out;
1530 }
1531
1532 stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1533 vs->name_idx++;
1534 if (vs->name_idx < vs->nwnames) {
1535
1536 v9fs_string_sprintf(&vs->path, "%s/%s",
1537 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1538 v9fs_string_copy(&vs->fidp->path, &vs->path);
1539
1540 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1541 v9fs_walk_post_oldfid_lstat(s, vs, err);
1542 return;
1543 }
1544
1545 v9fs_string_free(&vs->path);
1546 v9fs_walk_marshal(vs);
1547 err = vs->offset;
1548 out:
1549 v9fs_walk_complete(s, vs, err);
1550 }
1551
1552 static void v9fs_walk(V9fsState *s, V9fsPDU *pdu)
1553 {
1554 int32_t fid, newfid;
1555 V9fsWalkState *vs;
1556 int err = 0;
1557 int i;
1558
1559 vs = qemu_malloc(sizeof(*vs));
1560 vs->pdu = pdu;
1561 vs->wnames = NULL;
1562 vs->qids = NULL;
1563 vs->offset = 7;
1564
1565 vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "ddw", &fid,
1566 &newfid, &vs->nwnames);
1567
1568 if (vs->nwnames) {
1569 vs->wnames = qemu_mallocz(sizeof(vs->wnames[0]) * vs->nwnames);
1570
1571 vs->qids = qemu_mallocz(sizeof(vs->qids[0]) * vs->nwnames);
1572
1573 for (i = 0; i < vs->nwnames; i++) {
1574 vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "s",
1575 &vs->wnames[i]);
1576 }
1577 }
1578
1579 vs->fidp = lookup_fid(s, fid);
1580 if (vs->fidp == NULL) {
1581 err = -ENOENT;
1582 goto out;
1583 }
1584
1585 /* FIXME: is this really valid? */
1586 if (fid == newfid) {
1587
1588 BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
1589 v9fs_string_init(&vs->path);
1590 vs->name_idx = 0;
1591
1592 if (vs->name_idx < vs->nwnames) {
1593 v9fs_string_sprintf(&vs->path, "%s/%s",
1594 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1595 v9fs_string_copy(&vs->fidp->path, &vs->path);
1596
1597 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1598 v9fs_walk_post_oldfid_lstat(s, vs, err);
1599 return;
1600 }
1601 } else {
1602 vs->newfidp = alloc_fid(s, newfid);
1603 if (vs->newfidp == NULL) {
1604 err = -EINVAL;
1605 goto out;
1606 }
1607
1608 vs->newfidp->uid = vs->fidp->uid;
1609 v9fs_string_init(&vs->path);
1610 vs->name_idx = 0;
1611 v9fs_string_copy(&vs->newfidp->path, &vs->fidp->path);
1612
1613 if (vs->name_idx < vs->nwnames) {
1614 v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1615 vs->wnames[vs->name_idx].data);
1616 v9fs_string_copy(&vs->newfidp->path, &vs->path);
1617
1618 err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1619 v9fs_walk_post_newfid_lstat(s, vs, err);
1620 return;
1621 }
1622 }
1623
1624 v9fs_walk_marshal(vs);
1625 err = vs->offset;
1626 out:
1627 v9fs_walk_complete(s, vs, err);
1628 }
1629
1630 static int32_t get_iounit(V9fsState *s, V9fsString *name)
1631 {
1632 struct statfs stbuf;
1633 int32_t iounit = 0;
1634
1635 /*
1636 * iounit should be multiples of f_bsize (host filesystem block size
1637 * and as well as less than (client msize - P9_IOHDRSZ))
1638 */
1639 if (!v9fs_do_statfs(s, name, &stbuf)) {
1640 iounit = stbuf.f_bsize;
1641 iounit *= (s->msize - P9_IOHDRSZ)/stbuf.f_bsize;
1642 }
1643
1644 if (!iounit) {
1645 iounit = s->msize - P9_IOHDRSZ;
1646 }
1647 return iounit;
1648 }
1649
1650 static void v9fs_open_post_opendir(V9fsState *s, V9fsOpenState *vs, int err)
1651 {
1652 if (vs->fidp->fs.dir == NULL) {
1653 err = -errno;
1654 goto out;
1655 }
1656 vs->fidp->fid_type = P9_FID_DIR;
1657 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1658 err = vs->offset;
1659 out:
1660 complete_pdu(s, vs->pdu, err);
1661 qemu_free(vs);
1662
1663 }
1664
1665 static void v9fs_open_post_getiounit(V9fsState *s, V9fsOpenState *vs)
1666 {
1667 int err;
1668 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
1669 err = vs->offset;
1670 complete_pdu(s, vs->pdu, err);
1671 qemu_free(vs);
1672 }
1673
1674 static void v9fs_open_post_open(V9fsState *s, V9fsOpenState *vs, int err)
1675 {
1676 if (vs->fidp->fs.fd == -1) {
1677 err = -errno;
1678 goto out;
1679 }
1680 vs->fidp->fid_type = P9_FID_FILE;
1681 vs->iounit = get_iounit(s, &vs->fidp->path);
1682 v9fs_open_post_getiounit(s, vs);
1683 return;
1684 out:
1685 complete_pdu(s, vs->pdu, err);
1686 qemu_free(vs);
1687 }
1688
1689 static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err)
1690 {
1691 int flags;
1692
1693 if (err) {
1694 err = -errno;
1695 goto out;
1696 }
1697
1698 stat_to_qid(&vs->stbuf, &vs->qid);
1699
1700 if (S_ISDIR(vs->stbuf.st_mode)) {
1701 vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fidp->path);
1702 v9fs_open_post_opendir(s, vs, err);
1703 } else {
1704 if (s->proto_version == V9FS_PROTO_2000L) {
1705 flags = vs->mode;
1706 flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
1707 } else {
1708 flags = omode_to_uflags(vs->mode);
1709 }
1710 vs->fidp->fs.fd = v9fs_do_open(s, &vs->fidp->path, flags);
1711 v9fs_open_post_open(s, vs, err);
1712 }
1713 return;
1714 out:
1715 complete_pdu(s, vs->pdu, err);
1716 qemu_free(vs);
1717 }
1718
1719 static void v9fs_open(V9fsState *s, V9fsPDU *pdu)
1720 {
1721 int32_t fid;
1722 V9fsOpenState *vs;
1723 ssize_t err = 0;
1724
1725 vs = qemu_malloc(sizeof(*vs));
1726 vs->pdu = pdu;
1727 vs->offset = 7;
1728 vs->mode = 0;
1729
1730 if (s->proto_version == V9FS_PROTO_2000L) {
1731 pdu_unmarshal(vs->pdu, vs->offset, "dd", &fid, &vs->mode);
1732 } else {
1733 pdu_unmarshal(vs->pdu, vs->offset, "db", &fid, &vs->mode);
1734 }
1735
1736 vs->fidp = lookup_fid(s, fid);
1737 if (vs->fidp == NULL) {
1738 err = -ENOENT;
1739 goto out;
1740 }
1741
1742 BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
1743
1744 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1745
1746 v9fs_open_post_lstat(s, vs, err);
1747 return;
1748 out:
1749 complete_pdu(s, pdu, err);
1750 qemu_free(vs);
1751 }
1752
1753 static void v9fs_post_lcreate(V9fsState *s, V9fsLcreateState *vs, int err)
1754 {
1755 if (err == 0) {
1756 v9fs_string_copy(&vs->fidp->path, &vs->fullname);
1757 stat_to_qid(&vs->stbuf, &vs->qid);
1758 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid,
1759 &vs->iounit);
1760 err = vs->offset;
1761 } else {
1762 vs->fidp->fid_type = P9_FID_NONE;
1763 close(vs->fidp->fs.fd);
1764 err = -errno;
1765 }
1766
1767 complete_pdu(s, vs->pdu, err);
1768 v9fs_string_free(&vs->name);
1769 v9fs_string_free(&vs->fullname);
1770 qemu_free(vs);
1771 }
1772
1773 static void v9fs_lcreate_post_get_iounit(V9fsState *s, V9fsLcreateState *vs,
1774 int err)
1775 {
1776 if (err) {
1777 err = -errno;
1778 goto out;
1779 }
1780 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
1781
1782 out:
1783 v9fs_post_lcreate(s, vs, err);
1784 }
1785
1786 static void v9fs_lcreate_post_do_open2(V9fsState *s, V9fsLcreateState *vs,
1787 int err)
1788 {
1789 if (vs->fidp->fs.fd == -1) {
1790 err = -errno;
1791 goto out;
1792 }
1793 vs->fidp->fid_type = P9_FID_FILE;
1794 vs->iounit = get_iounit(s, &vs->fullname);
1795 v9fs_lcreate_post_get_iounit(s, vs, err);
1796 return;
1797
1798 out:
1799 v9fs_post_lcreate(s, vs, err);
1800 }
1801
1802 static void v9fs_lcreate(V9fsState *s, V9fsPDU *pdu)
1803 {
1804 int32_t dfid, flags, mode;
1805 gid_t gid;
1806 V9fsLcreateState *vs;
1807 ssize_t err = 0;
1808
1809 vs = qemu_malloc(sizeof(*vs));
1810 vs->pdu = pdu;
1811 vs->offset = 7;
1812
1813 v9fs_string_init(&vs->fullname);
1814
1815 pdu_unmarshal(vs->pdu, vs->offset, "dsddd", &dfid, &vs->name, &flags,
1816 &mode, &gid);
1817
1818 vs->fidp = lookup_fid(s, dfid);
1819 if (vs->fidp == NULL) {
1820 err = -ENOENT;
1821 goto out;
1822 }
1823
1824 v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
1825 vs->name.data);
1826
1827 vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
1828 gid, flags, mode);
1829 v9fs_lcreate_post_do_open2(s, vs, err);
1830 return;
1831
1832 out:
1833 complete_pdu(s, vs->pdu, err);
1834 v9fs_string_free(&vs->name);
1835 qemu_free(vs);
1836 }
1837
1838 static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
1839 {
1840 int32_t fid;
1841 size_t offset = 7;
1842 int err;
1843
1844 pdu_unmarshal(pdu, offset, "d", &fid);
1845
1846 err = free_fid(s, fid);
1847 if (err < 0) {
1848 goto out;
1849 }
1850
1851 offset = 7;
1852 err = offset;
1853 out:
1854 complete_pdu(s, pdu, err);
1855 }
1856
1857 static void v9fs_read_post_readdir(V9fsState *, V9fsReadState *, ssize_t);
1858
1859 static void v9fs_read_post_seekdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1860 {
1861 if (err) {
1862 goto out;
1863 }
1864 v9fs_stat_free(&vs->v9stat);
1865 v9fs_string_free(&vs->name);
1866 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1867 vs->offset += vs->count;
1868 err = vs->offset;
1869 out:
1870 complete_pdu(s, vs->pdu, err);
1871 qemu_free(vs);
1872 return;
1873 }
1874
1875 static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs,
1876 ssize_t err)
1877 {
1878 if (err) {
1879 err = -errno;
1880 goto out;
1881 }
1882 err = stat_to_v9stat(s, &vs->name, &vs->stbuf, &vs->v9stat);
1883 if (err) {
1884 goto out;
1885 }
1886
1887 vs->len = pdu_marshal(vs->pdu, vs->offset + 4 + vs->count, "S",
1888 &vs->v9stat);
1889 if ((vs->len != (vs->v9stat.size + 2)) ||
1890 ((vs->count + vs->len) > vs->max_count)) {
1891 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
1892 v9fs_read_post_seekdir(s, vs, err);
1893 return;
1894 }
1895 vs->count += vs->len;
1896 v9fs_stat_free(&vs->v9stat);
1897 v9fs_string_free(&vs->name);
1898 vs->dir_pos = vs->dent->d_off;
1899 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
1900 v9fs_read_post_readdir(s, vs, err);
1901 return;
1902 out:
1903 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
1904 v9fs_read_post_seekdir(s, vs, err);
1905 return;
1906
1907 }
1908
1909 static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1910 {
1911 if (vs->dent) {
1912 memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1913 v9fs_string_init(&vs->name);
1914 v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data,
1915 vs->dent->d_name);
1916 err = v9fs_do_lstat(s, &vs->name, &vs->stbuf);
1917 v9fs_read_post_dir_lstat(s, vs, err);
1918 return;
1919 }
1920
1921 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1922 vs->offset += vs->count;
1923 err = vs->offset;
1924 complete_pdu(s, vs->pdu, err);
1925 qemu_free(vs);
1926 return;
1927 }
1928
1929 static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1930 {
1931 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
1932 v9fs_read_post_readdir(s, vs, err);
1933 return;
1934 }
1935
1936 static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs,
1937 ssize_t err)
1938 {
1939 vs->dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
1940 v9fs_read_post_telldir(s, vs, err);
1941 return;
1942 }
1943
1944 static void v9fs_read_post_readv(V9fsState *s, V9fsReadState *vs, ssize_t err)
1945 {
1946 if (err < 0) {
1947 /* IO error return the error */
1948 err = -errno;
1949 goto out;
1950 }
1951 vs->total += vs->len;
1952 vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
1953 if (vs->total < vs->count && vs->len > 0) {
1954 do {
1955 if (0) {
1956 print_sg(vs->sg, vs->cnt);
1957 }
1958 vs->len = v9fs_do_readv(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
1959 } while (vs->len == -1 && errno == EINTR);
1960 if (vs->len == -1) {
1961 err = -errno;
1962 }
1963 v9fs_read_post_readv(s, vs, err);
1964 return;
1965 }
1966 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
1967 vs->offset += vs->count;
1968 err = vs->offset;
1969
1970 out:
1971 complete_pdu(s, vs->pdu, err);
1972 qemu_free(vs);
1973 }
1974
1975 static void v9fs_read_post_lseek(V9fsState *s, V9fsReadState *vs, ssize_t err)
1976 {
1977 if (err == -1) {
1978 err = -errno;
1979 goto out;
1980 }
1981 vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
1982
1983 if (vs->total < vs->count) {
1984 do {
1985 if (0) {
1986 print_sg(vs->sg, vs->cnt);
1987 }
1988 vs->len = v9fs_do_readv(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
1989 } while (vs->len == -1 && errno == EINTR);
1990 if (vs->len == -1) {
1991 err = -errno;
1992 }
1993 v9fs_read_post_readv(s, vs, err);
1994 return;
1995 }
1996 out:
1997 complete_pdu(s, vs->pdu, err);
1998 qemu_free(vs);
1999 }
2000
2001 static void v9fs_xattr_read(V9fsState *s, V9fsReadState *vs)
2002 {
2003 ssize_t err = 0;
2004 int read_count;
2005 int64_t xattr_len;
2006
2007 xattr_len = vs->fidp->fs.xattr.len;
2008 read_count = xattr_len - vs->off;
2009 if (read_count > vs->count) {
2010 read_count = vs->count;
2011 } else if (read_count < 0) {
2012 /*
2013 * read beyond XATTR value
2014 */
2015 read_count = 0;
2016 }
2017 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", read_count);
2018 vs->offset += pdu_pack(vs->pdu, vs->offset,
2019 ((char *)vs->fidp->fs.xattr.value) + vs->off,
2020 read_count);
2021 err = vs->offset;
2022 complete_pdu(s, vs->pdu, err);
2023 qemu_free(vs);
2024 }
2025
2026 static void v9fs_read(V9fsState *s, V9fsPDU *pdu)
2027 {
2028 int32_t fid;
2029 V9fsReadState *vs;
2030 ssize_t err = 0;
2031
2032 vs = qemu_malloc(sizeof(*vs));
2033 vs->pdu = pdu;
2034 vs->offset = 7;
2035 vs->total = 0;
2036 vs->len = 0;
2037 vs->count = 0;
2038
2039 pdu_unmarshal(vs->pdu, vs->offset, "dqd", &fid, &vs->off, &vs->count);
2040
2041 vs->fidp = lookup_fid(s, fid);
2042 if (vs->fidp == NULL) {
2043 err = -EINVAL;
2044 goto out;
2045 }
2046
2047 if (vs->fidp->fid_type == P9_FID_DIR) {
2048 vs->max_count = vs->count;
2049 vs->count = 0;
2050 if (vs->off == 0) {
2051 v9fs_do_rewinddir(s, vs->fidp->fs.dir);
2052 }
2053 v9fs_read_post_rewinddir(s, vs, err);
2054 return;
2055 } else if (vs->fidp->fid_type == P9_FID_FILE) {
2056 vs->sg = vs->iov;
2057 pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt);
2058 err = v9fs_do_lseek(s, vs->fidp->fs.fd, vs->off, SEEK_SET);
2059 v9fs_read_post_lseek(s, vs, err);
2060 return;
2061 } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2062 v9fs_xattr_read(s, vs);
2063 return;
2064 } else {
2065 err = -EINVAL;
2066 }
2067 out:
2068 complete_pdu(s, pdu, err);
2069 qemu_free(vs);
2070 }
2071
2072 typedef struct V9fsReadDirState {
2073 V9fsPDU *pdu;
2074 V9fsFidState *fidp;
2075 V9fsQID qid;
2076 off_t saved_dir_pos;
2077 struct dirent *dent;
2078 int32_t count;
2079 int32_t max_count;
2080 size_t offset;
2081 int64_t initial_offset;
2082 V9fsString name;
2083 } V9fsReadDirState;
2084
2085 static void v9fs_readdir_post_seekdir(V9fsState *s, V9fsReadDirState *vs)
2086 {
2087 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2088 vs->offset += vs->count;
2089 complete_pdu(s, vs->pdu, vs->offset);
2090 qemu_free(vs);
2091 return;
2092 }
2093
2094 /* Size of each dirent on the wire: size of qid (13) + size of offset (8)
2095 * size of type (1) + size of name.size (2) + strlen(name.data)
2096 */
2097 #define V9_READDIR_DATA_SZ (24 + strlen(vs->name.data))
2098
2099 static void v9fs_readdir_post_readdir(V9fsState *s, V9fsReadDirState *vs)
2100 {
2101 int len;
2102 size_t size;
2103
2104 if (vs->dent) {
2105 v9fs_string_init(&vs->name);
2106 v9fs_string_sprintf(&vs->name, "%s", vs->dent->d_name);
2107
2108 if ((vs->count + V9_READDIR_DATA_SZ) > vs->max_count) {
2109 /* Ran out of buffer. Set dir back to old position and return */
2110 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->saved_dir_pos);
2111 v9fs_readdir_post_seekdir(s, vs);
2112 return;
2113 }
2114
2115 /* Fill up just the path field of qid because the client uses
2116 * only that. To fill the entire qid structure we will have
2117 * to stat each dirent found, which is expensive
2118 */
2119 size = MIN(sizeof(vs->dent->d_ino), sizeof(vs->qid.path));
2120 memcpy(&vs->qid.path, &vs->dent->d_ino, size);
2121 /* Fill the other fields with dummy values */
2122 vs->qid.type = 0;
2123 vs->qid.version = 0;
2124
2125 len = pdu_marshal(vs->pdu, vs->offset+4+vs->count, "Qqbs",
2126 &vs->qid, vs->dent->d_off,
2127 vs->dent->d_type, &vs->name);
2128 vs->count += len;
2129 v9fs_string_free(&vs->name);
2130 vs->saved_dir_pos = vs->dent->d_off;
2131 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
2132 v9fs_readdir_post_readdir(s, vs);
2133 return;
2134 }
2135
2136 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2137 vs->offset += vs->count;
2138 complete_pdu(s, vs->pdu, vs->offset);
2139 qemu_free(vs);
2140 return;
2141 }
2142
2143 static void v9fs_readdir_post_telldir(V9fsState *s, V9fsReadDirState *vs)
2144 {
2145 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
2146 v9fs_readdir_post_readdir(s, vs);
2147 return;
2148 }
2149
2150 static void v9fs_readdir_post_setdir(V9fsState *s, V9fsReadDirState *vs)
2151 {
2152 vs->saved_dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
2153 v9fs_readdir_post_telldir(s, vs);
2154 return;
2155 }
2156
2157 static void v9fs_readdir(V9fsState *s, V9fsPDU *pdu)
2158 {
2159 int32_t fid;
2160 V9fsReadDirState *vs;
2161 ssize_t err = 0;
2162 size_t offset = 7;
2163
2164 vs = qemu_malloc(sizeof(*vs));
2165 vs->pdu = pdu;
2166 vs->offset = 7;
2167 vs->count = 0;
2168
2169 pdu_unmarshal(vs->pdu, offset, "dqd", &fid, &vs->initial_offset,
2170 &vs->max_count);
2171
2172 vs->fidp = lookup_fid(s, fid);
2173 if (vs->fidp == NULL || !(vs->fidp->fs.dir)) {
2174 err = -EINVAL;
2175 goto out;
2176 }
2177
2178 if (vs->initial_offset == 0) {
2179 v9fs_do_rewinddir(s, vs->fidp->fs.dir);
2180 } else {
2181 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->initial_offset);
2182 }
2183
2184 v9fs_readdir_post_setdir(s, vs);
2185 return;
2186
2187 out:
2188 complete_pdu(s, pdu, err);
2189 qemu_free(vs);
2190 return;
2191 }
2192
2193 static void v9fs_write_post_writev(V9fsState *s, V9fsWriteState *vs,
2194 ssize_t err)
2195 {
2196 if (err < 0) {
2197 /* IO error return the error */
2198 err = -errno;
2199 goto out;
2200 }
2201 vs->total += vs->len;
2202 vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
2203 if (vs->total < vs->count && vs->len > 0) {
2204 do {
2205 if (0) {
2206 print_sg(vs->sg, vs->cnt);
2207 }
2208 vs->len = v9fs_do_writev(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
2209 } while (vs->len == -1 && errno == EINTR);
2210 if (vs->len == -1) {
2211 err = -errno;
2212 }
2213 v9fs_write_post_writev(s, vs, err);
2214 return;
2215 }
2216 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
2217
2218 err = vs->offset;
2219 out:
2220 complete_pdu(s, vs->pdu, err);
2221 qemu_free(vs);
2222 }
2223
2224 static void v9fs_write_post_lseek(V9fsState *s, V9fsWriteState *vs, ssize_t err)
2225 {
2226 if (err == -1) {
2227 err = -errno;
2228 goto out;
2229 }
2230 vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2231
2232 if (vs->total < vs->count) {
2233 do {
2234 if (0) {
2235 print_sg(vs->sg, vs->cnt);
2236 }
2237 vs->len = v9fs_do_writev(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
2238 } while (vs->len == -1 && errno == EINTR);
2239 if (vs->len == -1) {
2240 err = -errno;
2241 }
2242 v9fs_write_post_writev(s, vs, err);
2243 return;
2244 }
2245
2246 out:
2247 complete_pdu(s, vs->pdu, err);
2248 qemu_free(vs);
2249 }
2250
2251 static void v9fs_xattr_write(V9fsState *s, V9fsWriteState *vs)
2252 {
2253 int i, to_copy;
2254 ssize_t err = 0;
2255 int write_count;
2256 int64_t xattr_len;
2257
2258 xattr_len = vs->fidp->fs.xattr.len;
2259 write_count = xattr_len - vs->off;
2260 if (write_count > vs->count) {
2261 write_count = vs->count;
2262 } else if (write_count < 0) {
2263 /*
2264 * write beyond XATTR value len specified in
2265 * xattrcreate
2266 */
2267 err = -ENOSPC;
2268 goto out;
2269 }
2270 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", write_count);
2271 err = vs->offset;
2272 vs->fidp->fs.xattr.copied_len += write_count;
2273 /*
2274 * Now copy the content from sg list
2275 */
2276 for (i = 0; i < vs->cnt; i++) {
2277 if (write_count > vs->sg[i].iov_len) {
2278 to_copy = vs->sg[i].iov_len;
2279 } else {
2280 to_copy = write_count;
2281 }
2282 memcpy((char *)vs->fidp->fs.xattr.value + vs->off,
2283 vs->sg[i].iov_base, to_copy);
2284 /* updating vs->off since we are not using below */
2285 vs->off += to_copy;
2286 write_count -= to_copy;
2287 }
2288 out:
2289 complete_pdu(s, vs->pdu, err);
2290 qemu_free(vs);
2291 }
2292
2293 static void v9fs_write(V9fsState *s, V9fsPDU *pdu)
2294 {
2295 int32_t fid;
2296 V9fsWriteState *vs;
2297 ssize_t err;
2298
2299 vs = qemu_malloc(sizeof(*vs));
2300
2301 vs->pdu = pdu;
2302 vs->offset = 7;
2303 vs->sg = vs->iov;
2304 vs->total = 0;
2305 vs->len = 0;
2306
2307 pdu_unmarshal(vs->pdu, vs->offset, "dqdv", &fid, &vs->off, &vs->count,
2308 vs->sg, &vs->cnt);
2309
2310 vs->fidp = lookup_fid(s, fid);
2311 if (vs->fidp == NULL) {
2312 err = -EINVAL;
2313 goto out;
2314 }
2315
2316 if (vs->fidp->fid_type == P9_FID_FILE) {
2317 if (vs->fidp->fs.fd == -1) {
2318 err = -EINVAL;
2319 goto out;
2320 }
2321 } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2322 /*
2323 * setxattr operation
2324 */
2325 v9fs_xattr_write(s, vs);
2326 return;
2327 } else {
2328 err = -EINVAL;
2329 goto out;
2330 }
2331 err = v9fs_do_lseek(s, vs->fidp->fs.fd, vs->off, SEEK_SET);
2332
2333 v9fs_write_post_lseek(s, vs, err);
2334 return;
2335
2336 out:
2337 complete_pdu(s, vs->pdu, err);
2338 qemu_free(vs);
2339 }
2340
2341 static void v9fs_create_post_getiounit(V9fsState *s, V9fsCreateState *vs)
2342 {
2343 int err;
2344 v9fs_string_copy(&vs->fidp->path, &vs->fullname);
2345 stat_to_qid(&vs->stbuf, &vs->qid);
2346
2347 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
2348 err = vs->offset;
2349
2350 complete_pdu(s, vs->pdu, err);
2351 v9fs_string_free(&vs->name);
2352 v9fs_string_free(&vs->extension);
2353 v9fs_string_free(&vs->fullname);
2354 qemu_free(vs);
2355 }
2356
2357 static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
2358 {
2359 if (err == 0) {
2360 vs->iounit = get_iounit(s, &vs->fidp->path);
2361 v9fs_create_post_getiounit(s, vs);
2362 return;
2363 }
2364
2365 complete_pdu(s, vs->pdu, err);
2366 v9fs_string_free(&vs->name);
2367 v9fs_string_free(&vs->extension);
2368 v9fs_string_free(&vs->fullname);
2369 qemu_free(vs);
2370 }
2371
2372 static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
2373 {
2374 if (err) {
2375 err = -errno;
2376 }
2377 v9fs_post_create(s, vs, err);
2378 }
2379
2380 static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
2381 int err)
2382 {
2383 if (!vs->fidp->fs.dir) {
2384 err = -errno;
2385 }
2386 vs->fidp->fid_type = P9_FID_DIR;
2387 v9fs_post_create(s, vs, err);
2388 }
2389
2390 static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
2391 int err)
2392 {
2393 if (err) {
2394 err = -errno;
2395 goto out;
2396 }
2397
2398 vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fullname);
2399 v9fs_create_post_opendir(s, vs, err);
2400 return;
2401
2402 out:
2403 v9fs_post_create(s, vs, err);
2404 }
2405
2406 static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
2407 {
2408 if (err) {
2409 err = -errno;
2410 goto out;
2411 }
2412
2413 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2414 v9fs_create_post_dir_lstat(s, vs, err);
2415 return;
2416
2417 out:
2418 v9fs_post_create(s, vs, err);
2419 }
2420
2421 static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
2422 {
2423 if (err) {
2424 vs->fidp->fid_type = P9_FID_NONE;
2425 close(vs->fidp->fs.fd);
2426 err = -errno;
2427 }
2428 v9fs_post_create(s, vs, err);
2429 return;
2430 }
2431
2432 static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
2433 {
2434 if (vs->fidp->fs.fd == -1) {
2435 err = -errno;
2436 goto out;
2437 }
2438 vs->fidp->fid_type = P9_FID_FILE;
2439 err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
2440 v9fs_create_post_fstat(s, vs, err);
2441
2442 return;
2443
2444 out:
2445 v9fs_post_create(s, vs, err);
2446
2447 }
2448
2449 static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
2450 {
2451
2452 if (err == 0 || errno != ENOENT) {
2453 err = -errno;
2454 goto out;
2455 }
2456
2457 if (vs->perm & P9_STAT_MODE_DIR) {
2458 err = v9fs_do_mkdir(s, vs->fullname.data, vs->perm & 0777,
2459 vs->fidp->uid, -1);
2460 v9fs_create_post_mkdir(s, vs, err);
2461 } else if (vs->perm & P9_STAT_MODE_SYMLINK) {
2462 err = v9fs_do_symlink(s, vs->fidp, vs->extension.data,
2463 vs->fullname.data, -1);
2464 v9fs_create_post_perms(s, vs, err);
2465 } else if (vs->perm & P9_STAT_MODE_LINK) {
2466 int32_t nfid = atoi(vs->extension.data);
2467 V9fsFidState *nfidp = lookup_fid(s, nfid);
2468 if (nfidp == NULL) {
2469 err = -errno;
2470 v9fs_post_create(s, vs, err);
2471 }
2472 err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
2473 v9fs_create_post_perms(s, vs, err);
2474 } else if (vs->perm & P9_STAT_MODE_DEVICE) {
2475 char ctype;
2476 uint32_t major, minor;
2477 mode_t nmode = 0;
2478
2479 if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
2480 &minor) != 3) {
2481 err = -errno;
2482 v9fs_post_create(s, vs, err);
2483 }
2484
2485 switch (ctype) {
2486 case 'c':
2487 nmode = S_IFCHR;
2488 break;
2489 case 'b':
2490 nmode = S_IFBLK;
2491 break;
2492 default:
2493 err = -EIO;
2494 v9fs_post_create(s, vs, err);
2495 }
2496
2497 nmode |= vs->perm & 0777;
2498 err = v9fs_do_mknod(s, vs->fullname.data, nmode,
2499 makedev(major, minor), vs->fidp->uid, -1);
2500 v9fs_create_post_perms(s, vs, err);
2501 } else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
2502 err = v9fs_do_mknod(s, vs->fullname.data, S_IFIFO | (vs->perm & 0777),
2503 0, vs->fidp->uid, -1);
2504 v9fs_post_create(s, vs, err);
2505 } else if (vs->perm & P9_STAT_MODE_SOCKET) {
2506 err = v9fs_do_mknod(s, vs->fullname.data, S_IFSOCK | (vs->perm & 0777),
2507 0, vs->fidp->uid, -1);
2508 v9fs_post_create(s, vs, err);
2509 } else {
2510 vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
2511 -1, omode_to_uflags(vs->mode)|O_CREAT, vs->perm);
2512
2513 v9fs_create_post_open2(s, vs, err);
2514 }
2515
2516 return;
2517
2518 out:
2519 v9fs_post_create(s, vs, err);
2520 }
2521
2522 static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
2523 {
2524 int32_t fid;
2525 V9fsCreateState *vs;
2526 int err = 0;
2527
2528 vs = qemu_malloc(sizeof(*vs));
2529 vs->pdu = pdu;
2530 vs->offset = 7;
2531
2532 v9fs_string_init(&vs->fullname);
2533
2534 pdu_unmarshal(vs->pdu, vs->offset, "dsdbs", &fid, &vs->name,
2535 &vs->perm, &vs->mode, &vs->extension);
2536
2537 vs->fidp = lookup_fid(s, fid);
2538 if (vs->fidp == NULL) {
2539 err = -EINVAL;
2540 goto out;
2541 }
2542
2543 v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
2544 vs->name.data);
2545
2546 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2547 v9fs_create_post_lstat(s, vs, err);
2548 return;
2549
2550 out:
2551 complete_pdu(s, vs->pdu, err);
2552 v9fs_string_free(&vs->name);
2553 v9fs_string_free(&vs->extension);
2554 qemu_free(vs);
2555 }
2556
2557 static void v9fs_post_symlink(V9fsState *s, V9fsSymlinkState *vs, int err)
2558 {
2559 if (err == 0) {
2560 stat_to_qid(&vs->stbuf, &vs->qid);
2561 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
2562 err = vs->offset;
2563 } else {
2564 err = -errno;
2565 }
2566 complete_pdu(s, vs->pdu, err);
2567 v9fs_string_free(&vs->name);
2568 v9fs_string_free(&vs->symname);
2569 v9fs_string_free(&vs->fullname);
2570 qemu_free(vs);
2571 }
2572
2573 static void v9fs_symlink_post_do_symlink(V9fsState *s, V9fsSymlinkState *vs,
2574 int err)
2575 {
2576 if (err) {
2577 goto out;
2578 }
2579 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2580 out:
2581 v9fs_post_symlink(s, vs, err);
2582 }
2583
2584 static void v9fs_symlink(V9fsState *s, V9fsPDU *pdu)
2585 {
2586 int32_t dfid;
2587 V9fsSymlinkState *vs;
2588 int err = 0;
2589 gid_t gid;
2590
2591 vs = qemu_malloc(sizeof(*vs));
2592 vs->pdu = pdu;
2593 vs->offset = 7;
2594
2595 v9fs_string_init(&vs->fullname);
2596
2597 pdu_unmarshal(vs->pdu, vs->offset, "dssd", &dfid, &vs->name,
2598 &vs->symname, &gid);
2599
2600 vs->dfidp = lookup_fid(s, dfid);
2601 if (vs->dfidp == NULL) {
2602 err = -EINVAL;
2603 goto out;
2604 }
2605
2606 v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->dfidp->path.data,
2607 vs->name.data);
2608 err = v9fs_do_symlink(s, vs->dfidp, vs->symname.data,
2609 vs->fullname.data, gid);
2610 v9fs_symlink_post_do_symlink(s, vs, err);
2611 return;
2612
2613 out:
2614 complete_pdu(s, vs->pdu, err);
2615 v9fs_string_free(&vs->name);
2616 v9fs_string_free(&vs->symname);
2617 qemu_free(vs);
2618 }
2619
2620 static void v9fs_flush(V9fsState *s, V9fsPDU *pdu)
2621 {
2622 /* A nop call with no return */
2623 complete_pdu(s, pdu, 7);
2624 }
2625
2626 static void v9fs_link(V9fsState *s, V9fsPDU *pdu)
2627 {
2628 int32_t dfid, oldfid;
2629 V9fsFidState *dfidp, *oldfidp;
2630 V9fsString name, fullname;
2631 size_t offset = 7;
2632 int err = 0;
2633
2634 v9fs_string_init(&fullname);
2635
2636 pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2637
2638 dfidp = lookup_fid(s, dfid);
2639 if (dfidp == NULL) {
2640 err = -errno;
2641 goto out;
2642 }
2643
2644 oldfidp = lookup_fid(s, oldfid);
2645 if (oldfidp == NULL) {
2646 err = -errno;
2647 goto out;
2648 }
2649
2650 v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
2651 err = offset;
2652 err = v9fs_do_link(s, &oldfidp->path, &fullname);
2653 if (err) {
2654 err = -errno;
2655 }
2656 v9fs_string_free(&fullname);
2657
2658 out:
2659 v9fs_string_free(&name);
2660 complete_pdu(s, pdu, err);
2661 }
2662
2663 static void v9fs_remove_post_remove(V9fsState *s, V9fsRemoveState *vs,
2664 int err)
2665 {
2666 if (err < 0) {
2667 err = -errno;
2668 } else {
2669 err = vs->offset;
2670 }
2671
2672 /* For TREMOVE we need to clunk the fid even on failed remove */
2673 free_fid(s, vs->fidp->fid);
2674
2675 complete_pdu(s, vs->pdu, err);
2676 qemu_free(vs);
2677 }
2678
2679 static void v9fs_remove(V9fsState *s, V9fsPDU *pdu)
2680 {
2681 int32_t fid;
2682 V9fsRemoveState *vs;
2683 int err = 0;
2684
2685 vs = qemu_malloc(sizeof(*vs));
2686 vs->pdu = pdu;
2687 vs->offset = 7;
2688
2689 pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
2690
2691 vs->fidp = lookup_fid(s, fid);
2692 if (vs->fidp == NULL) {
2693 err = -EINVAL;
2694 goto out;
2695 }
2696
2697 err = v9fs_do_remove(s, &vs->fidp->path);
2698 v9fs_remove_post_remove(s, vs, err);
2699 return;
2700
2701 out:
2702 complete_pdu(s, pdu, err);
2703 qemu_free(vs);
2704 }
2705
2706 static void v9fs_wstat_post_truncate(V9fsState *s, V9fsWstatState *vs, int err)
2707 {
2708 if (err < 0) {
2709 goto out;
2710 }
2711
2712 err = vs->offset;
2713
2714 out:
2715 v9fs_stat_free(&vs->v9stat);
2716 complete_pdu(s, vs->pdu, err);
2717 qemu_free(vs);
2718 }
2719
2720 static void v9fs_wstat_post_rename(V9fsState *s, V9fsWstatState *vs, int err)
2721 {
2722 if (err < 0) {
2723 goto out;
2724 }
2725 if (vs->v9stat.length != -1) {
2726 if (v9fs_do_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) {
2727 err = -errno;
2728 }
2729 }
2730 v9fs_wstat_post_truncate(s, vs, err);
2731 return;
2732
2733 out:
2734 v9fs_stat_free(&vs->v9stat);
2735 complete_pdu(s, vs->pdu, err);
2736 qemu_free(vs);
2737 }
2738
2739 static int v9fs_complete_rename(V9fsState *s, V9fsRenameState *vs)
2740 {
2741 int err = 0;
2742 char *old_name, *new_name;
2743 char *end;
2744
2745 if (vs->newdirfid != -1) {
2746 V9fsFidState *dirfidp;
2747 dirfidp = lookup_fid(s, vs->newdirfid);
2748
2749 if (dirfidp == NULL) {
2750 err = -ENOENT;
2751 goto out;
2752 }
2753
2754 BUG_ON(dirfidp->fid_type != P9_FID_NONE);
2755
2756 new_name = qemu_mallocz(dirfidp->path.size + vs->name.size + 2);
2757
2758 strcpy(new_name, dirfidp->path.data);
2759 strcat(new_name, "/");
2760 strcat(new_name + dirfidp->path.size, vs->name.data);
2761 } else {
2762 old_name = vs->fidp->path.data;
2763 end = strrchr(old_name, '/');
2764 if (end) {
2765 end++;
2766 } else {
2767 end = old_name;
2768 }
2769 new_name = qemu_mallocz(end - old_name + vs->name.size + 1);
2770
2771 strncat(new_name, old_name, end - old_name);
2772 strncat(new_name + (end - old_name), vs->name.data, vs->name.size);
2773 }
2774
2775 v9fs_string_free(&vs->name);
2776 vs->name.data = qemu_strdup(new_name);
2777 vs->name.size = strlen(new_name);
2778
2779 if (strcmp(new_name, vs->fidp->path.data) != 0) {
2780 if (v9fs_do_rename(s, &vs->fidp->path, &vs->name)) {
2781 err = -errno;
2782 } else {
2783 V9fsFidState *fidp;
2784 /*
2785 * Fixup fid's pointing to the old name to
2786 * start pointing to the new name
2787 */
2788 for (fidp = s->fid_list; fidp; fidp = fidp->next) {
2789 if (vs->fidp == fidp) {
2790 /*
2791 * we replace name of this fid towards the end
2792 * so that our below strcmp will work
2793 */
2794 continue;
2795 }
2796 if (!strncmp(vs->fidp->path.data, fidp->path.data,
2797 strlen(vs->fidp->path.data))) {
2798 /* replace the name */
2799 v9fs_fix_path(&fidp->path, &vs->name,
2800 strlen(vs->fidp->path.data));
2801 }
2802 }
2803 v9fs_string_copy(&vs->fidp->path, &vs->name);
2804 }
2805 }
2806 out:
2807 v9fs_string_free(&vs->name);
2808 return err;
2809 }
2810
2811 static void v9fs_rename_post_rename(V9fsState *s, V9fsRenameState *vs, int err)
2812 {
2813 complete_pdu(s, vs->pdu, err);
2814 qemu_free(vs);
2815 }
2816
2817 static void v9fs_wstat_post_chown(V9fsState *s, V9fsWstatState *vs, int err)
2818 {
2819 if (err < 0) {
2820 goto out;
2821 }
2822
2823 if (vs->v9stat.name.size != 0) {
2824 V9fsRenameState *vr;
2825
2826 vr = qemu_mallocz(sizeof(V9fsRenameState));
2827 vr->newdirfid = -1;
2828 vr->pdu = vs->pdu;
2829 vr->fidp = vs->fidp;
2830 vr->offset = vs->offset;
2831 vr->name.size = vs->v9stat.name.size;
2832 vr->name.data = qemu_strdup(vs->v9stat.name.data);
2833
2834 err = v9fs_complete_rename(s, vr);
2835 qemu_free(vr);
2836 }
2837 v9fs_wstat_post_rename(s, vs, err);
2838 return;
2839
2840 out:
2841 v9fs_stat_free(&vs->v9stat);
2842 complete_pdu(s, vs->pdu, err);
2843 qemu_free(vs);
2844 }
2845
2846 static void v9fs_rename(V9fsState *s, V9fsPDU *pdu)
2847 {
2848 int32_t fid;
2849 V9fsRenameState *vs;
2850 ssize_t err = 0;
2851
2852 vs = qemu_malloc(sizeof(*vs));
2853 vs->pdu = pdu;
2854 vs->offset = 7;
2855
2856 pdu_unmarshal(vs->pdu, vs->offset, "dds", &fid, &vs->newdirfid, &vs->name);
2857
2858 vs->fidp = lookup_fid(s, fid);
2859 if (vs->fidp == NULL) {
2860 err = -ENOENT;
2861 goto out;
2862 }
2863
2864 BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
2865
2866 err = v9fs_complete_rename(s, vs);
2867 v9fs_rename_post_rename(s, vs, err);
2868 return;
2869 out:
2870 complete_pdu(s, vs->pdu, err);
2871 qemu_free(vs);
2872 }
2873
2874 static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err)
2875 {
2876 if (err < 0) {
2877 goto out;
2878 }
2879
2880 if (vs->v9stat.n_gid != -1 || vs->v9stat.n_uid != -1) {
2881 if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid,
2882 vs->v9stat.n_gid)) {
2883 err = -errno;
2884 }
2885 }
2886 v9fs_wstat_post_chown(s, vs, err);
2887 return;
2888
2889 out:
2890 v9fs_stat_free(&vs->v9stat);
2891 complete_pdu(s, vs->pdu, err);
2892 qemu_free(vs);
2893 }
2894
2895 static void v9fs_wstat_post_chmod(V9fsState *s, V9fsWstatState *vs, int err)
2896 {
2897 if (err < 0) {
2898 goto out;
2899 }
2900
2901 if (vs->v9stat.mtime != -1 || vs->v9stat.atime != -1) {
2902 struct timespec times[2];
2903 if (vs->v9stat.atime != -1) {
2904 times[0].tv_sec = vs->v9stat.atime;
2905 times[0].tv_nsec = 0;
2906 } else {
2907 times[0].tv_nsec = UTIME_OMIT;
2908 }
2909 if (vs->v9stat.mtime != -1) {
2910 times[1].tv_sec = vs->v9stat.mtime;
2911 times[1].tv_nsec = 0;
2912 } else {
2913 times[1].tv_nsec = UTIME_OMIT;
2914 }
2915
2916 if (v9fs_do_utimensat(s, &vs->fidp->path, times)) {
2917 err = -errno;
2918 }
2919 }
2920
2921 v9fs_wstat_post_utime(s, vs, err);
2922 return;
2923
2924 out:
2925 v9fs_stat_free(&vs->v9stat);
2926 complete_pdu(s, vs->pdu, err);
2927 qemu_free(vs);
2928 }
2929
2930 static void v9fs_wstat_post_fsync(V9fsState *s, V9fsWstatState *vs, int err)
2931 {
2932 if (err == -1) {
2933 err = -errno;
2934 }
2935 v9fs_stat_free(&vs->v9stat);
2936 complete_pdu(s, vs->pdu, err);
2937 qemu_free(vs);
2938 }
2939
2940 static void v9fs_wstat_post_lstat(V9fsState *s, V9fsWstatState *vs, int err)
2941 {
2942 uint32_t v9_mode;
2943
2944 if (err == -1) {
2945 err = -errno;
2946 goto out;
2947 }
2948
2949 v9_mode = stat_to_v9mode(&vs->stbuf);
2950
2951 if ((vs->v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2952 (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2953 /* Attempting to change the type */
2954 err = -EIO;
2955 goto out;
2956 }
2957
2958 if (v9fs_do_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode,
2959 &vs->v9stat.extension))) {
2960 err = -errno;
2961 }
2962 v9fs_wstat_post_chmod(s, vs, err);
2963 return;
2964
2965 out:
2966 v9fs_stat_free(&vs->v9stat);
2967 complete_pdu(s, vs->pdu, err);
2968 qemu_free(vs);
2969 }
2970
2971 static void v9fs_wstat(V9fsState *s, V9fsPDU *pdu)
2972 {
2973 int32_t fid;
2974 V9fsWstatState *vs;
2975 int err = 0;
2976
2977 vs = qemu_malloc(sizeof(*vs));
2978 vs->pdu = pdu;
2979 vs->offset = 7;
2980
2981 pdu_unmarshal(pdu, vs->offset, "dwS", &fid, &vs->unused, &vs->v9stat);
2982
2983 vs->fidp = lookup_fid(s, fid);
2984 if (vs->fidp == NULL) {
2985 err = -EINVAL;
2986 goto out;
2987 }
2988
2989 /* do we need to sync the file? */
2990 if (donttouch_stat(&vs->v9stat)) {
2991 err = v9fs_do_fsync(s, vs->fidp->fs.fd);
2992 v9fs_wstat_post_fsync(s, vs, err);
2993 return;
2994 }
2995
2996 if (vs->v9stat.mode != -1) {
2997 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
2998 v9fs_wstat_post_lstat(s, vs, err);
2999 return;
3000 }
3001
3002 v9fs_wstat_post_chmod(s, vs, err);
3003 return;
3004
3005 out:
3006 v9fs_stat_free(&vs->v9stat);
3007 complete_pdu(s, vs->pdu, err);
3008 qemu_free(vs);
3009 }
3010
3011 static void v9fs_statfs_post_statfs(V9fsState *s, V9fsStatfsState *vs, int err)
3012 {
3013 int32_t bsize_factor;
3014
3015 if (err) {
3016 err = -errno;
3017 goto out;
3018 }
3019
3020 /*
3021 * compute bsize factor based on host file system block size
3022 * and client msize
3023 */
3024 bsize_factor = (s->msize - P9_IOHDRSZ)/vs->stbuf.f_bsize;
3025 if (!bsize_factor) {
3026 bsize_factor = 1;
3027 }
3028 vs->v9statfs.f_type = vs->stbuf.f_type;
3029 vs->v9statfs.f_bsize = vs->stbuf.f_bsize;
3030 vs->v9statfs.f_bsize *= bsize_factor;
3031 /*
3032 * f_bsize is adjusted(multiplied) by bsize factor, so we need to
3033 * adjust(divide) the number of blocks, free blocks and available
3034 * blocks by bsize factor
3035 */
3036 vs->v9statfs.f_blocks = vs->stbuf.f_blocks/bsize_factor;
3037 vs->v9statfs.f_bfree = vs->stbuf.f_bfree/bsize_factor;
3038 vs->v9statfs.f_bavail = vs->stbuf.f_bavail/bsize_factor;
3039 vs->v9statfs.f_files = vs->stbuf.f_files;
3040 vs->v9statfs.f_ffree = vs->stbuf.f_ffree;
3041 vs->v9statfs.fsid_val = (unsigned int) vs->stbuf.f_fsid.__val[0] |
3042 (unsigned long long)vs->stbuf.f_fsid.__val[1] << 32;
3043 vs->v9statfs.f_namelen = vs->stbuf.f_namelen;
3044
3045 vs->offset += pdu_marshal(vs->pdu, vs->offset, "ddqqqqqqd",
3046 vs->v9statfs.f_type, vs->v9statfs.f_bsize, vs->v9statfs.f_blocks,
3047 vs->v9statfs.f_bfree, vs->v9statfs.f_bavail, vs->v9statfs.f_files,
3048 vs->v9statfs.f_ffree, vs->v9statfs.fsid_val,
3049 vs->v9statfs.f_namelen);
3050
3051 out:
3052 complete_pdu(s, vs->pdu, vs->offset);
3053 qemu_free(vs);
3054 }
3055
3056 static void v9fs_statfs(V9fsState *s, V9fsPDU *pdu)
3057 {
3058 V9fsStatfsState *vs;
3059 ssize_t err = 0;
3060
3061 vs = qemu_malloc(sizeof(*vs));
3062 vs->pdu = pdu;
3063 vs->offset = 7;
3064
3065 memset(&vs->v9statfs, 0, sizeof(vs->v9statfs));
3066
3067 pdu_unmarshal(vs->pdu, vs->offset, "d", &vs->fid);
3068
3069 vs->fidp = lookup_fid(s, vs->fid);
3070 if (vs->fidp == NULL) {
3071 err = -ENOENT;
3072 goto out;
3073 }
3074
3075 err = v9fs_do_statfs(s, &vs->fidp->path, &vs->stbuf);
3076 v9fs_statfs_post_statfs(s, vs, err);
3077 return;
3078
3079 out:
3080 complete_pdu(s, vs->pdu, err);
3081 qemu_free(vs);
3082 }
3083
3084 static void v9fs_mknod_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
3085 {
3086 if (err == -1) {
3087 err = -errno;
3088 goto out;
3089 }
3090
3091 stat_to_qid(&vs->stbuf, &vs->qid);
3092 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
3093 err = vs->offset;
3094 out:
3095 complete_pdu(s, vs->pdu, err);
3096 v9fs_string_free(&vs->fullname);
3097 v9fs_string_free(&vs->name);
3098 qemu_free(vs);
3099 }
3100
3101 static void v9fs_mknod_post_mknod(V9fsState *s, V9fsMkState *vs, int err)
3102 {
3103 if (err == -1) {
3104 err = -errno;
3105 goto out;
3106 }
3107
3108 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
3109 v9fs_mknod_post_lstat(s, vs, err);
3110 return;
3111 out:
3112 complete_pdu(s, vs->pdu, err);
3113 v9fs_string_free(&vs->fullname);
3114 v9fs_string_free(&vs->name);
3115 qemu_free(vs);
3116 }
3117
3118 static void v9fs_mknod(V9fsState *s, V9fsPDU *pdu)
3119 {
3120 int32_t fid;
3121 V9fsMkState *vs;
3122 int err = 0;
3123 V9fsFidState *fidp;
3124 gid_t gid;
3125 int mode;
3126 int major, minor;
3127
3128 vs = qemu_malloc(sizeof(*vs));
3129 vs->pdu = pdu;
3130 vs->offset = 7;
3131
3132 v9fs_string_init(&vs->fullname);
3133 pdu_unmarshal(vs->pdu, vs->offset, "dsdddd", &fid, &vs->name, &mode,
3134 &major, &minor, &gid);
3135
3136 fidp = lookup_fid(s, fid);
3137 if (fidp == NULL) {
3138 err = -ENOENT;
3139 goto out;
3140 }
3141
3142 v9fs_string_sprintf(&vs->fullname, "%s/%s", fidp->path.data, vs->name.data);
3143 err = v9fs_do_mknod(s, vs->fullname.data, mode, makedev(major, minor),
3144 fidp->uid, gid);
3145 v9fs_mknod_post_mknod(s, vs, err);
3146 return;
3147
3148 out:
3149 complete_pdu(s, vs->pdu, err);
3150 v9fs_string_free(&vs->fullname);
3151 v9fs_string_free(&vs->name);
3152 qemu_free(vs);
3153 }
3154
3155 static void v9fs_mkdir_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
3156 {
3157 if (err == -1) {
3158 err = -errno;
3159 goto out;
3160 }
3161
3162 stat_to_qid(&vs->stbuf, &vs->qid);
3163 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
3164 err = vs->offset;
3165 out:
3166 complete_pdu(s, vs->pdu, err);
3167 v9fs_string_free(&vs->fullname);
3168 v9fs_string_free(&vs->name);
3169 qemu_free(vs);
3170 }
3171
3172 static void v9fs_mkdir_post_mkdir(V9fsState *s, V9fsMkState *vs, int err)
3173 {
3174 if (err == -1) {
3175 err = -errno;
3176 goto out;
3177 }
3178
3179 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
3180 v9fs_mkdir_post_lstat(s, vs, err);
3181 return;
3182 out:
3183 complete_pdu(s, vs->pdu, err);
3184 v9fs_string_free(&vs->fullname);
3185 v9fs_string_free(&vs->name);
3186 qemu_free(vs);
3187 }
3188
3189 static void v9fs_mkdir(V9fsState *s, V9fsPDU *pdu)
3190 {
3191 int32_t fid;
3192 V9fsMkState *vs;
3193 int err = 0;
3194 V9fsFidState *fidp;
3195 gid_t gid;
3196 int mode;
3197
3198 vs = qemu_malloc(sizeof(*vs));
3199 vs->pdu = pdu;
3200 vs->offset = 7;
3201
3202 v9fs_string_init(&vs->fullname);
3203 pdu_unmarshal(vs->pdu, vs->offset, "dsdd", &fid, &vs->name, &mode,
3204 &gid);
3205
3206 fidp = lookup_fid(s, fid);
3207 if (fidp == NULL) {
3208 err = -ENOENT;
3209 goto out;
3210 }
3211
3212 v9fs_string_sprintf(&vs->fullname, "%s/%s", fidp->path.data, vs->name.data);
3213 err = v9fs_do_mkdir(s, vs->fullname.data, mode, fidp->uid, gid);
3214 v9fs_mkdir_post_mkdir(s, vs, err);
3215 return;
3216
3217 out:
3218 complete_pdu(s, vs->pdu, err);
3219 v9fs_string_free(&vs->fullname);
3220 v9fs_string_free(&vs->name);
3221 qemu_free(vs);
3222 }
3223
3224 static void v9fs_post_xattr_getvalue(V9fsState *s, V9fsXattrState *vs, int err)
3225 {
3226
3227 if (err < 0) {
3228 err = -errno;
3229 free_fid(s, vs->xattr_fidp->fid);
3230 goto out;
3231 }
3232 vs->offset += pdu_marshal(vs->pdu, vs->offset, "q", vs->size);
3233 err = vs->offset;
3234 out:
3235 complete_pdu(s, vs->pdu, err);
3236 v9fs_string_free(&vs->name);
3237 qemu_free(vs);
3238 return;
3239 }
3240
3241 static void v9fs_post_xattr_check(V9fsState *s, V9fsXattrState *vs, ssize_t err)
3242 {
3243 if (err < 0) {
3244 err = -errno;
3245 free_fid(s, vs->xattr_fidp->fid);
3246 goto out;
3247 }
3248 /*
3249 * Read the xattr value
3250 */
3251 vs->xattr_fidp->fs.xattr.len = vs->size;
3252 vs->xattr_fidp->fid_type = P9_FID_XATTR;
3253 vs->xattr_fidp->fs.xattr.copied_len = -1;
3254 if (vs->size) {
3255 vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3256 err = v9fs_do_lgetxattr(s, &vs->xattr_fidp->path,
3257 &vs->name, vs->xattr_fidp->fs.xattr.value,
3258 vs->xattr_fidp->fs.xattr.len);
3259 }
3260 v9fs_post_xattr_getvalue(s, vs, err);
3261 return;
3262 out:
3263 complete_pdu(s, vs->pdu, err);
3264 v9fs_string_free(&vs->name);
3265 qemu_free(vs);
3266 }
3267
3268 static void v9fs_post_lxattr_getvalue(V9fsState *s,
3269 V9fsXattrState *vs, int err)
3270 {
3271 if (err < 0) {
3272 err = -errno;
3273 free_fid(s, vs->xattr_fidp->fid);
3274 goto out;
3275 }
3276 vs->offset += pdu_marshal(vs->pdu, vs->offset, "q", vs->size);
3277 err = vs->offset;
3278 out:
3279 complete_pdu(s, vs->pdu, err);
3280 v9fs_string_free(&vs->name);
3281 qemu_free(vs);
3282 return;
3283 }
3284
3285 static void v9fs_post_lxattr_check(V9fsState *s,
3286 V9fsXattrState *vs, ssize_t err)
3287 {
3288 if (err < 0) {
3289 err = -errno;
3290 free_fid(s, vs->xattr_fidp->fid);
3291 goto out;
3292 }
3293 /*
3294 * Read the xattr value
3295 */
3296 vs->xattr_fidp->fs.xattr.len = vs->size;
3297 vs->xattr_fidp->fid_type = P9_FID_XATTR;
3298 vs->xattr_fidp->fs.xattr.copied_len = -1;
3299 if (vs->size) {
3300 vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3301 err = v9fs_do_llistxattr(s, &vs->xattr_fidp->path,
3302 vs->xattr_fidp->fs.xattr.value,
3303 vs->xattr_fidp->fs.xattr.len);
3304 }
3305 v9fs_post_lxattr_getvalue(s, vs, err);
3306 return;
3307 out:
3308 complete_pdu(s, vs->pdu, err);
3309 v9fs_string_free(&vs->name);
3310 qemu_free(vs);
3311 }
3312
3313 static void v9fs_xattrwalk(V9fsState *s, V9fsPDU *pdu)
3314 {
3315 ssize_t err = 0;
3316 V9fsXattrState *vs;
3317 int32_t fid, newfid;
3318
3319 vs = qemu_malloc(sizeof(*vs));
3320 vs->pdu = pdu;
3321 vs->offset = 7;
3322
3323 pdu_unmarshal(vs->pdu, vs->offset, "dds", &fid, &newfid, &vs->name);
3324 vs->file_fidp = lookup_fid(s, fid);
3325 if (vs->file_fidp == NULL) {
3326 err = -ENOENT;
3327 goto out;
3328 }
3329
3330 vs->xattr_fidp = alloc_fid(s, newfid);
3331 if (vs->xattr_fidp == NULL) {
3332 err = -EINVAL;
3333 goto out;
3334 }
3335
3336 v9fs_string_copy(&vs->xattr_fidp->path, &vs->file_fidp->path);
3337 if (vs->name.data[0] == 0) {
3338 /*
3339 * listxattr request. Get the size first
3340 */
3341 vs->size = v9fs_do_llistxattr(s, &vs->xattr_fidp->path,
3342 NULL, 0);
3343 if (vs->size < 0) {
3344 err = vs->size;
3345 }
3346 v9fs_post_lxattr_check(s, vs, err);
3347 return;
3348 } else {
3349 /*
3350 * specific xattr fid. We check for xattr
3351 * presence also collect the xattr size
3352 */
3353 vs->size = v9fs_do_lgetxattr(s, &vs->xattr_fidp->path,
3354 &vs->name, NULL, 0);
3355 if (vs->size < 0) {
3356 err = vs->size;
3357 }
3358 v9fs_post_xattr_check(s, vs, err);
3359 return;
3360 }
3361 out:
3362 complete_pdu(s, vs->pdu, err);
3363 v9fs_string_free(&vs->name);
3364 qemu_free(vs);
3365 }
3366
3367 static void v9fs_xattrcreate(V9fsState *s, V9fsPDU *pdu)
3368 {
3369 int flags;
3370 int32_t fid;
3371 ssize_t err = 0;
3372 V9fsXattrState *vs;
3373
3374 vs = qemu_malloc(sizeof(*vs));
3375 vs->pdu = pdu;
3376 vs->offset = 7;
3377
3378 pdu_unmarshal(vs->pdu, vs->offset, "dsqd",
3379 &fid, &vs->name, &vs->size, &flags);
3380
3381 vs->file_fidp = lookup_fid(s, fid);
3382 if (vs->file_fidp == NULL) {
3383 err = -EINVAL;
3384 goto out;
3385 }
3386
3387 /* Make the file fid point to xattr */
3388 vs->xattr_fidp = vs->file_fidp;
3389 vs->xattr_fidp->fid_type = P9_FID_XATTR;
3390 vs->xattr_fidp->fs.xattr.copied_len = 0;
3391 vs->xattr_fidp->fs.xattr.len = vs->size;
3392 vs->xattr_fidp->fs.xattr.flags = flags;
3393 v9fs_string_init(&vs->xattr_fidp->fs.xattr.name);
3394 v9fs_string_copy(&vs->xattr_fidp->fs.xattr.name, &vs->name);
3395 if (vs->size)
3396 vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3397 else
3398 vs->xattr_fidp->fs.xattr.value = NULL;
3399
3400 out:
3401 complete_pdu(s, vs->pdu, err);
3402 v9fs_string_free(&vs->name);
3403 qemu_free(vs);
3404 }
3405
3406 typedef void (pdu_handler_t)(V9fsState *s, V9fsPDU *pdu);
3407
3408 static pdu_handler_t *pdu_handlers[] = {
3409 [P9_TREADDIR] = v9fs_readdir,
3410 [P9_TSTATFS] = v9fs_statfs,
3411 [P9_TGETATTR] = v9fs_getattr,
3412 [P9_TSETATTR] = v9fs_setattr,
3413 [P9_TXATTRWALK] = v9fs_xattrwalk,
3414 [P9_TXATTRCREATE] = v9fs_xattrcreate,
3415 [P9_TMKNOD] = v9fs_mknod,
3416 [P9_TRENAME] = v9fs_rename,
3417 [P9_TMKDIR] = v9fs_mkdir,
3418 [P9_TVERSION] = v9fs_version,
3419 [P9_TLOPEN] = v9fs_open,
3420 [P9_TATTACH] = v9fs_attach,
3421 [P9_TSTAT] = v9fs_stat,
3422 [P9_TWALK] = v9fs_walk,
3423 [P9_TCLUNK] = v9fs_clunk,
3424 [P9_TOPEN] = v9fs_open,
3425 [P9_TREAD] = v9fs_read,
3426 #if 0
3427 [P9_TAUTH] = v9fs_auth,
3428 #endif
3429 [P9_TFLUSH] = v9fs_flush,
3430 [P9_TLINK] = v9fs_link,
3431 [P9_TSYMLINK] = v9fs_symlink,
3432 [P9_TCREATE] = v9fs_create,
3433 [P9_TLCREATE] = v9fs_lcreate,
3434 [P9_TWRITE] = v9fs_write,
3435 [P9_TWSTAT] = v9fs_wstat,
3436 [P9_TREMOVE] = v9fs_remove,
3437 };
3438
3439 static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
3440 {
3441 pdu_handler_t *handler;
3442
3443 if (debug_9p_pdu) {
3444 pprint_pdu(pdu);
3445 }
3446
3447 BUG_ON(pdu->id >= ARRAY_SIZE(pdu_handlers));
3448
3449 handler = pdu_handlers[pdu->id];
3450 BUG_ON(handler == NULL);
3451
3452 handler(s, pdu);
3453 }
3454
3455 static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
3456 {
3457 V9fsState *s = (V9fsState *)vdev;
3458 V9fsPDU *pdu;
3459 ssize_t len;
3460
3461 while ((pdu = alloc_pdu(s)) &&
3462 (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
3463 uint8_t *ptr;
3464
3465 BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
3466 BUG_ON(pdu->elem.out_sg[0].iov_len < 7);
3467
3468 ptr = pdu->elem.out_sg[0].iov_base;
3469
3470 memcpy(&pdu->size, ptr, 4);
3471 pdu->id = ptr[4];
3472 memcpy(&pdu->tag, ptr + 5, 2);
3473
3474 submit_pdu(s, pdu);
3475 }
3476
3477 free_pdu(s, pdu);
3478 }
3479
3480 static uint32_t virtio_9p_get_features(VirtIODevice *vdev, uint32_t features)
3481 {
3482 features |= 1 << VIRTIO_9P_MOUNT_TAG;
3483 return features;
3484 }
3485
3486 static V9fsState *to_virtio_9p(VirtIODevice *vdev)
3487 {
3488 return (V9fsState *)vdev;
3489 }
3490
3491 static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config)
3492 {
3493 struct virtio_9p_config *cfg;
3494 V9fsState *s = to_virtio_9p(vdev);
3495
3496 cfg = qemu_mallocz(sizeof(struct virtio_9p_config) +
3497 s->tag_len);
3498 stw_raw(&cfg->tag_len, s->tag_len);
3499 memcpy(cfg->tag, s->tag, s->tag_len);
3500 memcpy(config, cfg, s->config_size);
3501 qemu_free(cfg);
3502 }
3503
3504 VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf)
3505 {
3506 V9fsState *s;
3507 int i, len;
3508 struct stat stat;
3509 FsTypeEntry *fse;
3510
3511
3512 s = (V9fsState *)virtio_common_init("virtio-9p",
3513 VIRTIO_ID_9P,
3514 sizeof(struct virtio_9p_config)+
3515 MAX_TAG_LEN,
3516 sizeof(V9fsState));
3517
3518 /* initialize pdu allocator */
3519 QLIST_INIT(&s->free_list);
3520 for (i = 0; i < (MAX_REQ - 1); i++) {
3521 QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next);
3522 }
3523
3524 s->vq = virtio_add_queue(&s->vdev, MAX_REQ, handle_9p_output);
3525
3526 fse = get_fsdev_fsentry(conf->fsdev_id);
3527
3528 if (!fse) {
3529 /* We don't have a fsdev identified by fsdev_id */
3530 fprintf(stderr, "Virtio-9p device couldn't find fsdev "
3531 "with the id %s\n", conf->fsdev_id);
3532 exit(1);
3533 }
3534
3535 if (!fse->path || !conf->tag) {
3536 /* we haven't specified a mount_tag or the path */
3537 fprintf(stderr, "fsdev with id %s needs path "
3538 "and Virtio-9p device needs mount_tag arguments\n",
3539 conf->fsdev_id);
3540 exit(1);
3541 }
3542
3543 if (!strcmp(fse->security_model, "passthrough")) {
3544 /* Files on the Fileserver set to client user credentials */
3545 s->ctx.fs_sm = SM_PASSTHROUGH;
3546 } else if (!strcmp(fse->security_model, "mapped")) {
3547 /* Files on the fileserver are set to QEMU credentials.
3548 * Client user credentials are saved in extended attributes.
3549 */
3550 s->ctx.fs_sm = SM_MAPPED;
3551 } else if (!strcmp(fse->security_model, "none")) {
3552 /*
3553 * Files on the fileserver are set to QEMU credentials.
3554 */
3555 s->ctx.fs_sm = SM_NONE;
3556
3557 } else {
3558 fprintf(stderr, "Default to security_model=none. You may want"
3559 " enable advanced security model using "
3560 "security option:\n\t security_model=passthrough \n\t "
3561 "security_model=mapped\n");
3562 s->ctx.fs_sm = SM_NONE;
3563 }
3564
3565 if (lstat(fse->path, &stat)) {
3566 fprintf(stderr, "share path %s does not exist\n", fse->path);
3567 exit(1);
3568 } else if (!S_ISDIR(stat.st_mode)) {
3569 fprintf(stderr, "share path %s is not a directory \n", fse->path);
3570 exit(1);
3571 }
3572
3573 s->ctx.fs_root = qemu_strdup(fse->path);
3574 len = strlen(conf->tag);
3575 if (len > MAX_TAG_LEN) {
3576 len = MAX_TAG_LEN;
3577 }
3578 /* s->tag is non-NULL terminated string */
3579 s->tag = qemu_malloc(len);
3580 memcpy(s->tag, conf->tag, len);
3581 s->tag_len = len;
3582 s->ctx.uid = -1;
3583
3584 s->ops = fse->ops;
3585 s->vdev.get_features = virtio_9p_get_features;
3586 s->config_size = sizeof(struct virtio_9p_config) +
3587 s->tag_len;
3588 s->vdev.get_config = virtio_9p_get_config;
3589
3590 return &s->vdev;
3591 }
Stefan Hajnoczi's qemu-kvm.git repo