]> git.proxmox.com Git - mirror_qemu.git/blame - hw/virtio-9p.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[virtio-9p] Introduce server side TFSYNC/RFSYNC for dotl
[mirror_qemu.git] / hw / virtio-9p.c
CommitLineData
9f107513
AL		 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
9f107513
AL		 21int debug_9p_pdu;
22
fac4f111
VJ		 23enum {
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
35static 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
758e8e38 69void cred_init(FsCred *credp)
131dcb25 70{
758e8e38
VJ		 71 credp->fc_uid = -1;
72 credp->fc_gid = -1;
73 credp->fc_mode = -1;
74 credp->fc_rdev = -1;
131dcb25
AL		 75}
76
758e8e38 77static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf)
131dcb25 78{
758e8e38 79 return s->ops->lstat(&s->ctx, path->data, stbuf);
131dcb25
AL		 80}
81
82static 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
97static int v9fs_do_close(V9fsState *s, int fd)
98{
99 return s->ops->close(&s->ctx, fd);
100}
101
102static int v9fs_do_closedir(V9fsState *s, DIR *dir)
103{
104 return s->ops->closedir(&s->ctx, dir);
105}
106
a6568fe2
AL		 107static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags)
108{
109 return s->ops->open(&s->ctx, path->data, flags);
110}
111
112static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path)
113{
114 return s->ops->opendir(&s->ctx, path->data);
115}
116
a9231555
AL		 117static void v9fs_do_rewinddir(V9fsState *s, DIR *dir)
118{
119 return s->ops->rewinddir(&s->ctx, dir);
120}
121
122static off_t v9fs_do_telldir(V9fsState *s, DIR *dir)
123{
124 return s->ops->telldir(&s->ctx, dir);
125}
126
127static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir)
128{
129 return s->ops->readdir(&s->ctx, dir);
130}
131
132static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off)
133{
134 return s->ops->seekdir(&s->ctx, dir, off);
135}
136
137static 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
143static 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
8449360c
AL		 148static 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
c494dd6f
AL		 154static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
155{
e95ead32
VJ		 156 FsCred cred;
157 cred_init(&cred);
158 cred.fc_mode = mode;
159 return s->ops->chmod(&s->ctx, path->data, &cred);
c494dd6f
AL		 160}
161
5268cecc
MK		 162static int v9fs_do_mknod(V9fsState *s, char *name,
163 mode_t mode, dev_t dev, uid_t uid, gid_t gid)
c494dd6f 164{
1c293312
VJ		 165 FsCred cred;
166 cred_init(&cred);
5268cecc
MK		 167 cred.fc_uid = uid;
168 cred.fc_gid = gid;
1c293312
VJ		 169 cred.fc_mode = mode;
170 cred.fc_rdev = dev;
5268cecc 171 return s->ops->mknod(&s->ctx, name, &cred);
c494dd6f
AL		 172}
173
b67592ea
MK		 174static int v9fs_do_mkdir(V9fsState *s, char *name, mode_t mode,
175 uid_t uid, gid_t gid)
c494dd6f 176{
00ec5c37
VJ		 177 FsCred cred;
178
179 cred_init(&cred);
b67592ea
MK		 180 cred.fc_uid = uid;
181 cred.fc_gid = gid;
182 cred.fc_mode = mode;
00ec5c37 183
b67592ea 184 return s->ops->mkdir(&s->ctx, name, &cred);
c494dd6f
AL		 185}
186
187static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
188{
189 return s->ops->fstat(&s->ctx, fd, stbuf);
190}
191
c1568af5
VJ		 192static int v9fs_do_open2(V9fsState *s, char *fullname, uid_t uid, gid_t gid,
193 int flags, int mode)
c494dd6f 194{
4750a96f 195 FsCred cred;
4750a96f
VJ		 196
197 cred_init(&cred);
c1568af5
VJ		 198 cred.fc_uid = uid;
199 cred.fc_gid = gid;
200 cred.fc_mode = mode & 07777;
201 flags = flags;
4750a96f 202
c1568af5 203 return s->ops->open2(&s->ctx, fullname, flags, &cred);
c494dd6f
AL		 204}
205
08c60fc9
VJ		 206static int v9fs_do_symlink(V9fsState *s, V9fsFidState *fidp,
207 const char *oldpath, const char *newpath, gid_t gid)
c494dd6f 208{
879c2813
VJ		 209 FsCred cred;
210 cred_init(&cred);
08c60fc9
VJ		 211 cred.fc_uid = fidp->uid;
212 cred.fc_gid = gid;
213 cred.fc_mode = 0777;
879c2813 214
08c60fc9 215 return s->ops->symlink(&s->ctx, oldpath, newpath, &cred);
c494dd6f
AL		 216}
217
218static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
219{
220 return s->ops->link(&s->ctx, oldpath->data, newpath->data);
221}
222
8cf89e00
AL		 223static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size)
224{
225 return s->ops->truncate(&s->ctx, path->data, size);
226}
227
228static 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
234static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid)
235{
f7613bee
VJ		 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);
8cf89e00
AL		 242}
243
8fc39ae4
SK		 244static int v9fs_do_utimensat(V9fsState *s, V9fsString *path,
245 const struct timespec times[2])
8cf89e00 246{
8fc39ae4 247 return s->ops->utimensat(&s->ctx, path->data, times);
8cf89e00
AL		 248}
249
5bae1900
AL		 250static int v9fs_do_remove(V9fsState *s, V9fsString *path)
251{
252 return s->ops->remove(&s->ctx, path->data);
253}
254
8cf89e00
AL		 255static int v9fs_do_fsync(V9fsState *s, int fd)
256{
257 return s->ops->fsync(&s->ctx, fd);
258}
259
5e94c103
MK		 260static int v9fs_do_statfs(V9fsState *s, V9fsString *path, struct statfs *stbuf)
261{
262 return s->ops->statfs(&s->ctx, path->data, stbuf);
263}
264
fa32ef88
AK		 265static 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
273static 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
10b468bd
AK		 280static 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
9ed3ef26
AK		 288static 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
a03f7874
AL		 296static void v9fs_string_init(V9fsString *str)
297{
298 str->data = NULL;
299 str->size = 0;
300}
301
302static void v9fs_string_free(V9fsString *str)
303{
304 qemu_free(str->data);
305 str->data = NULL;
306 str->size = 0;
307}
308
309static void v9fs_string_null(V9fsString *str)
310{
311 v9fs_string_free(str);
312}
313
314static 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
c9ba47dc
SW		 336static int GCC_FMT_ATTR(2, 0)
337v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
a03f7874
AL		 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
385alloc_print:
386 *strp = qemu_malloc((len + 1) * sizeof(**strp));
387
388 return vsprintf(*strp, fmt, ap);
389}
390
c9ba47dc
SW		 391static void GCC_FMT_ATTR(2, 3)
392v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
a03f7874
AL		 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
407static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
408{
409 v9fs_string_free(lhs);
410 v9fs_string_sprintf(lhs, "%s", rhs->data);
411}
412
413static size_t v9fs_string_size(V9fsString *str)
414{
415 return str->size;
416}
417
286d5652
AL		 418static 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) {
286d5652
AL		 424 return f;
425 }
426 }
427
428 return NULL;
429}
430
431static 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;
d62dbb51 443 f->fid_type = P9_FID_NONE;
286d5652
AL		 444
445 f->next = s->fid_list;
446 s->fid_list = f;
447
448 return f;
449}
450
10b468bd
AK		 451static 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 }
9ed3ef26
AK		 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 }
10b468bd
AK		 476free_out:
477 v9fs_string_free(&fidp->fs.xattr.name);
478free_value:
479 if (fidp->fs.xattr.value) {
480 qemu_free(fidp->fs.xattr.value);
481 }
482 return retval;
483}
484
286d5652
AL		 485static int free_fid(V9fsState *s, int32_t fid)
486{
10b468bd 487 int retval = 0;
286d5652
AL		 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
d62dbb51
AK		 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) {
10b468bd 508 retval = v9fs_xattr_fid_clunk(s, fidp);
286d5652
AL		 509 }
510 v9fs_string_free(&fidp->path);
511 qemu_free(fidp);
512
10b468bd 513 return retval;
286d5652
AL		 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 */
542static 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
558static 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
9f107513
AL		 572static 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
583static void free_pdu(V9fsState *s, V9fsPDU *pdu)
584{
585 if (pdu) {
586 QLIST_INSERT_HEAD(&s->free_list, pdu, next);
587 }
588}
589
590size_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
405a549a
AL		 622static 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
628static 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
635static 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
669static 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 }
c79ce737
SK		 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 }
405a549a
AL		 749 default:
750 break;
751 }
752 }
753
754 va_end(ap);
755
756 return offset - old_offset;
757}
758
759static 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 }
00ede4c2
SK		 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 }
405a549a
AL		 835 default:
836 break;
837 }
838 }
839 va_end(ap);
840
841 return offset - old_offset;
842}
843
844static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
845{
846 int8_t id = pdu->id + 1; /* Response */
847
848 if (len < 0) {
405a549a 849 int err = -len;
8f4d1ca5 850 len = 7;
405a549a 851
8f4d1ca5
AB		 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 }
405a549a 861
cf03eb2c 862 len += pdu_marshal(pdu, len, "d", err);
405a549a 863
8f4d1ca5
AB		 864 if (s->proto_version == V9FS_PROTO_2000L) {
865 id = P9_RLERROR;
866 }
405a549a
AL		 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
bb9e3216
AL		 885static 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
cf03eb2c
AB		 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;
bb9e3216
AL		 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
928static 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
952static 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
961static 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
cf03eb2c
AB		 970 if (S_ISLNK(stbuf->st_mode)) {
971 mode |= P9_STAT_MODE_SYMLINK;
972 }
bb9e3216 973
cf03eb2c
AB		 974 if (S_ISSOCK(stbuf->st_mode)) {
975 mode |= P9_STAT_MODE_SOCKET;
976 }
bb9e3216 977
cf03eb2c
AB		 978 if (S_ISFIFO(stbuf->st_mode)) {
979 mode |= P9_STAT_MODE_NAMED_PIPE;
980 }
bb9e3216 981
cf03eb2c
AB		 982 if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
983 mode |= P9_STAT_MODE_DEVICE;
984 }
bb9e3216 985
cf03eb2c
AB		 986 if (stbuf->st_mode & S_ISUID) {
987 mode |= P9_STAT_MODE_SETUID;
988 }
bb9e3216 989
cf03eb2c
AB		 990 if (stbuf->st_mode & S_ISGID) {
991 mode |= P9_STAT_MODE_SETGID;
992 }
bb9e3216 993
cf03eb2c
AB		 994 if (stbuf->st_mode & S_ISVTX) {
995 mode |= P9_STAT_MODE_SETVTX;
bb9e3216
AL		 996 }
997
998 return mode;
999}
1000
1001static 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
cf03eb2c
AB		 1020 v9stat->n_uid = stbuf->st_uid;
1021 v9stat->n_gid = stbuf->st_gid;
1022 v9stat->n_muid = 0;
bb9e3216 1023
cf03eb2c 1024 v9fs_string_null(&v9stat->extension);
bb9e3216 1025
cf03eb2c
AB		 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;
bb9e3216 1031 }
cf03eb2c
AB		 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)) {
c9ba47dc
SW		 1039 v9fs_string_sprintf(&v9stat->extension, "%s %lu",
1040 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
bb9e3216
AL		 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
00ede4c2
SK		 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
1081static 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
1f5a89bf
AL		 1106static 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
1123static 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
1142static 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
8cf89e00
AL		 1156static 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
9f107513
AL		 1165static void v9fs_version(V9fsState *s, V9fsPDU *pdu)
1166{
92c1ad03
AL		 1167 V9fsString version;
1168 size_t offset = 7;
1169
5e94c103 1170 pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
92c1ad03 1171
84151514
MK		 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 {
92c1ad03 1177 v9fs_string_sprintf(&version, "unknown");
9f107513 1178 }
92c1ad03 1179
5e94c103 1180 offset += pdu_marshal(pdu, offset, "ds", s->msize, &version);
92c1ad03
AL		 1181 complete_pdu(s, pdu, offset);
1182
1183 v9fs_string_free(&version);
9f107513
AL		 1184}
1185
1186static void v9fs_attach(V9fsState *s, V9fsPDU *pdu)
1187{
955efc47
AL		 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;
9f107513 1201 }
955efc47
AL		 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;
1216out:
1217 complete_pdu(s, pdu, err);
1218 v9fs_string_free(&uname);
1219 v9fs_string_free(&aname);
9f107513
AL		 1220}
1221
4da7d3fa
AL		 1222static 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
1236out:
1237 complete_pdu(s, vs->pdu, err);
1238 v9fs_stat_free(&vs->v9stat);
1239 qemu_free(vs);
1240}
1241
9f107513
AL		 1242static void v9fs_stat(V9fsState *s, V9fsPDU *pdu)
1243{
4da7d3fa
AL		 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;
9f107513 1260 }
4da7d3fa
AL		 1261
1262 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1263 v9fs_stat_post_lstat(s, vs, err);
1264 return;
1265
1266out:
1267 complete_pdu(s, vs->pdu, err);
1268 v9fs_stat_free(&vs->v9stat);
1269 qemu_free(vs);
9f107513
AL		 1270}
1271
00ede4c2
SK		 1272static 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
1284out:
1285 complete_pdu(s, vs->pdu, err);
1286 qemu_free(vs);
1287}
1288
1289static 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
1318out:
1319 complete_pdu(s, vs->pdu, err);
1320 qemu_free(vs);
1321}
1322
c79ce737
SK		 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
1335static 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
1344out:
1345 complete_pdu(s, vs->pdu, err);
1346 qemu_free(vs);
1347}
1348
1349static 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
1362out:
1363 complete_pdu(s, vs->pdu, err);
1364 qemu_free(vs);
1365}
1366
1367static 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
1393out:
1394 complete_pdu(s, vs->pdu, err);
1395 qemu_free(vs);
1396}
1397
1398static 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
1433out:
1434 complete_pdu(s, vs->pdu, err);
1435 qemu_free(vs);
1436}
1437
1438static 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
1463out:
1464 complete_pdu(s, vs->pdu, err);
1465 qemu_free(vs);
1466}
1467
ff5e54c9
AL		 1468static 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
1482static 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
1493static 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;
1519out:
1520 v9fs_walk_complete(s, vs, err);
1521}
1522
1523static 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;
1548out:
1549 v9fs_walk_complete(s, vs, err);
1550}
1551
9f107513
AL		 1552static void v9fs_walk(V9fsState *s, V9fsPDU *pdu)
1553{
ff5e54c9
AL		 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
d62dbb51 1588 BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
ff5e54c9
AL		 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 }
9f107513 1622 }
ff5e54c9
AL		 1623
1624 v9fs_walk_marshal(vs);
1625 err = vs->offset;
1626out:
1627 v9fs_walk_complete(s, vs, err);
9f107513
AL		 1628}
1629
5e94c103
MK		 1630static 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
a6568fe2
AL		 1650static void v9fs_open_post_opendir(V9fsState *s, V9fsOpenState *vs, int err)
1651{
d62dbb51 1652 if (vs->fidp->fs.dir == NULL) {
a6568fe2
AL		 1653 err = -errno;
1654 goto out;
1655 }
d62dbb51 1656 vs->fidp->fid_type = P9_FID_DIR;
a6568fe2
AL		 1657 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1658 err = vs->offset;
1659out:
1660 complete_pdu(s, vs->pdu, err);
1661 qemu_free(vs);
1662
1663}
1664
5e94c103
MK		 1665static 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
a6568fe2
AL		 1674static void v9fs_open_post_open(V9fsState *s, V9fsOpenState *vs, int err)
1675{
d62dbb51 1676 if (vs->fidp->fs.fd == -1) {
a6568fe2
AL		 1677 err = -errno;
1678 goto out;
1679 }
d62dbb51 1680 vs->fidp->fid_type = P9_FID_FILE;
5e94c103
MK		 1681 vs->iounit = get_iounit(s, &vs->fidp->path);
1682 v9fs_open_post_getiounit(s, vs);
1683 return;
a6568fe2
AL		 1684out:
1685 complete_pdu(s, vs->pdu, err);
1686 qemu_free(vs);
1687}
1688
1689static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err)
1690{
771e9d4c
MK		 1691 int flags;
1692
a6568fe2
AL		 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)) {
d62dbb51 1701 vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fidp->path);
a6568fe2
AL		 1702 v9fs_open_post_opendir(s, vs, err);
1703 } else {
771e9d4c 1704 if (s->proto_version == V9FS_PROTO_2000L) {
771e9d4c 1705 flags = vs->mode;
630c2689 1706 flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
771e9d4c
MK		 1707 } else {
1708 flags = omode_to_uflags(vs->mode);
1709 }
d62dbb51 1710 vs->fidp->fs.fd = v9fs_do_open(s, &vs->fidp->path, flags);
a6568fe2
AL		 1711 v9fs_open_post_open(s, vs, err);
1712 }
1713 return;
1714out:
1715 complete_pdu(s, vs->pdu, err);
1716 qemu_free(vs);
9f107513
AL		 1717}
1718
1719static void v9fs_open(V9fsState *s, V9fsPDU *pdu)
a6568fe2
AL		 1720{
1721 int32_t fid;
1722 V9fsOpenState *vs;
1723 ssize_t err = 0;
1724
a6568fe2
AL		 1725 vs = qemu_malloc(sizeof(*vs));
1726 vs->pdu = pdu;
1727 vs->offset = 7;
771e9d4c 1728 vs->mode = 0;
a6568fe2 1729
771e9d4c
MK		 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 }
a6568fe2
AL		 1735
1736 vs->fidp = lookup_fid(s, fid);
1737 if (vs->fidp == NULL) {
1738 err = -ENOENT;
1739 goto out;
1740 }
1741
d62dbb51 1742 BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
a6568fe2
AL		 1743
1744 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1745
1746 v9fs_open_post_lstat(s, vs, err);
1747 return;
1748out:
1749 complete_pdu(s, pdu, err);
1750 qemu_free(vs);
1751}
1752
c1568af5
VJ		 1753static 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 {
d62dbb51 1762 vs->fidp->fid_type = P9_FID_NONE;
c1568af5 1763 err = -errno;
ab03b63d
SK		 1764 if (vs->fidp->fs.fd > 0) {
1765 close(vs->fidp->fs.fd);
1766 }
c1568af5
VJ		 1767 }
1768
1769 complete_pdu(s, vs->pdu, err);
1770 v9fs_string_free(&vs->name);
1771 v9fs_string_free(&vs->fullname);
1772 qemu_free(vs);
1773}
1774
1775static void v9fs_lcreate_post_get_iounit(V9fsState *s, V9fsLcreateState *vs,
1776 int err)
1777{
1778 if (err) {
1779 err = -errno;
1780 goto out;
1781 }
1782 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
1783
1784out:
1785 v9fs_post_lcreate(s, vs, err);
1786}
1787
1788static void v9fs_lcreate_post_do_open2(V9fsState *s, V9fsLcreateState *vs,
1789 int err)
1790{
d62dbb51 1791 if (vs->fidp->fs.fd == -1) {
c1568af5
VJ		 1792 err = -errno;
1793 goto out;
1794 }
d62dbb51 1795 vs->fidp->fid_type = P9_FID_FILE;
c1568af5
VJ		 1796 vs->iounit = get_iounit(s, &vs->fullname);
1797 v9fs_lcreate_post_get_iounit(s, vs, err);
1798 return;
1799
1800out:
1801 v9fs_post_lcreate(s, vs, err);
1802}
1803
1804static void v9fs_lcreate(V9fsState *s, V9fsPDU *pdu)
1805{
1806 int32_t dfid, flags, mode;
1807 gid_t gid;
1808 V9fsLcreateState *vs;
1809 ssize_t err = 0;
1810
1811 vs = qemu_malloc(sizeof(*vs));
1812 vs->pdu = pdu;
1813 vs->offset = 7;
1814
1815 v9fs_string_init(&vs->fullname);
1816
1817 pdu_unmarshal(vs->pdu, vs->offset, "dsddd", &dfid, &vs->name, &flags,
1818 &mode, &gid);
1819
1820 vs->fidp = lookup_fid(s, dfid);
1821 if (vs->fidp == NULL) {
1822 err = -ENOENT;
1823 goto out;
1824 }
1825
1826 v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
1827 vs->name.data);
1828
d62dbb51 1829 vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
c1568af5
VJ		 1830 gid, flags, mode);
1831 v9fs_lcreate_post_do_open2(s, vs, err);
1832 return;
1833
1834out:
1835 complete_pdu(s, vs->pdu, err);
1836 v9fs_string_free(&vs->name);
1837 qemu_free(vs);
1838}
1839
b41e95d3
VJ		 1840static void v9fs_post_do_fsync(V9fsState *s, V9fsPDU *pdu, int err)
1841{
1842 if (err == -1) {
1843 err = -errno;
1844 }
1845 complete_pdu(s, pdu, err);
1846}
1847
1848static void v9fs_fsync(V9fsState *s, V9fsPDU *pdu)
1849{
1850 int32_t fid;
1851 size_t offset = 7;
1852 V9fsFidState *fidp;
1853 int err;
1854
1855 pdu_unmarshal(pdu, offset, "d", &fid);
1856 fidp = lookup_fid(s, fid);
1857 if (fidp == NULL) {
1858 err = -ENOENT;
1859 v9fs_post_do_fsync(s, pdu, err);
1860 return;
1861 }
1862 err = v9fs_do_fsync(s, fidp->fs.fd);
1863 v9fs_post_do_fsync(s, pdu, err);
1864}
1865
a6568fe2
AL		 1866static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
1867{
bbd5697b
AL		 1868 int32_t fid;
1869 size_t offset = 7;
1870 int err;
1871
1872 pdu_unmarshal(pdu, offset, "d", &fid);
1873
1874 err = free_fid(s, fid);
1875 if (err < 0) {
1876 goto out;
a6568fe2 1877 }
bbd5697b
AL		 1878
1879 offset = 7;
1880 err = offset;
1881out:
1882 complete_pdu(s, pdu, err);
9f107513
AL		 1883}
1884
a9231555
AL		 1885static void v9fs_read_post_readdir(V9fsState *, V9fsReadState *, ssize_t);
1886
1887static void v9fs_read_post_seekdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1888{
1889 if (err) {
1890 goto out;
1891 }
1892 v9fs_stat_free(&vs->v9stat);
1893 v9fs_string_free(&vs->name);
1894 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1895 vs->offset += vs->count;
1896 err = vs->offset;
1897out:
1898 complete_pdu(s, vs->pdu, err);
1899 qemu_free(vs);
1900 return;
1901}
1902
1903static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs,
1904 ssize_t err)
1905{
1906 if (err) {
1907 err = -errno;
1908 goto out;
1909 }
1910 err = stat_to_v9stat(s, &vs->name, &vs->stbuf, &vs->v9stat);
1911 if (err) {
1912 goto out;
1913 }
1914
1915 vs->len = pdu_marshal(vs->pdu, vs->offset + 4 + vs->count, "S",
1916 &vs->v9stat);
1917 if ((vs->len != (vs->v9stat.size + 2)) ||
1918 ((vs->count + vs->len) > vs->max_count)) {
d62dbb51 1919 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
a9231555
AL		 1920 v9fs_read_post_seekdir(s, vs, err);
1921 return;
1922 }
1923 vs->count += vs->len;
1924 v9fs_stat_free(&vs->v9stat);
1925 v9fs_string_free(&vs->name);
1926 vs->dir_pos = vs->dent->d_off;
d62dbb51 1927 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
a9231555
AL		 1928 v9fs_read_post_readdir(s, vs, err);
1929 return;
1930out:
d62dbb51 1931 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
a9231555
AL		 1932 v9fs_read_post_seekdir(s, vs, err);
1933 return;
1934
1935}
1936
1937static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1938{
1939 if (vs->dent) {
1940 memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1941 v9fs_string_init(&vs->name);
1942 v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data,
1943 vs->dent->d_name);
1944 err = v9fs_do_lstat(s, &vs->name, &vs->stbuf);
1945 v9fs_read_post_dir_lstat(s, vs, err);
1946 return;
1947 }
1948
1949 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1950 vs->offset += vs->count;
1951 err = vs->offset;
1952 complete_pdu(s, vs->pdu, err);
1953 qemu_free(vs);
1954 return;
1955}
1956
1957static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1958{
d62dbb51 1959 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
a9231555
AL		 1960 v9fs_read_post_readdir(s, vs, err);
1961 return;
1962}
1963
1964static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs,
1965 ssize_t err)
1966{
d62dbb51 1967 vs->dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
a9231555
AL		 1968 v9fs_read_post_telldir(s, vs, err);
1969 return;
1970}
1971
1972static void v9fs_read_post_readv(V9fsState *s, V9fsReadState *vs, ssize_t err)
1973{
1974 if (err < 0) {
1975 /* IO error return the error */
1976 err = -errno;
1977 goto out;
1978 }
1979 vs->total += vs->len;
1980 vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
1981 if (vs->total < vs->count && vs->len > 0) {
1982 do {
1983 if (0) {
1984 print_sg(vs->sg, vs->cnt);
1985 }
d62dbb51 1986 vs->len = v9fs_do_readv(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
a9231555
AL		 1987 } while (vs->len == -1 && errno == EINTR);
1988 if (vs->len == -1) {
1989 err = -errno;
1990 }
1991 v9fs_read_post_readv(s, vs, err);
1992 return;
1993 }
1994 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
1995 vs->offset += vs->count;
1996 err = vs->offset;
1997
1998out:
1999 complete_pdu(s, vs->pdu, err);
2000 qemu_free(vs);
2001}
2002
2003static void v9fs_read_post_lseek(V9fsState *s, V9fsReadState *vs, ssize_t err)
2004{
2005 if (err == -1) {
2006 err = -errno;
2007 goto out;
2008 }
2009 vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2010
2011 if (vs->total < vs->count) {
2012 do {
2013 if (0) {
2014 print_sg(vs->sg, vs->cnt);
2015 }
d62dbb51 2016 vs->len = v9fs_do_readv(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
a9231555
AL		 2017 } while (vs->len == -1 && errno == EINTR);
2018 if (vs->len == -1) {
2019 err = -errno;
2020 }
2021 v9fs_read_post_readv(s, vs, err);
2022 return;
2023 }
2024out:
2025 complete_pdu(s, vs->pdu, err);
2026 qemu_free(vs);
2027}
2028
fa32ef88
AK		 2029static void v9fs_xattr_read(V9fsState *s, V9fsReadState *vs)
2030{
2031 ssize_t err = 0;
2032 int read_count;
2033 int64_t xattr_len;
2034
2035 xattr_len = vs->fidp->fs.xattr.len;
2036 read_count = xattr_len - vs->off;
2037 if (read_count > vs->count) {
2038 read_count = vs->count;
2039 } else if (read_count < 0) {
2040 /*
2041 * read beyond XATTR value
2042 */
2043 read_count = 0;
2044 }
2045 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", read_count);
2046 vs->offset += pdu_pack(vs->pdu, vs->offset,
2047 ((char *)vs->fidp->fs.xattr.value) + vs->off,
2048 read_count);
2049 err = vs->offset;
2050 complete_pdu(s, vs->pdu, err);
2051 qemu_free(vs);
2052}
2053
9f107513
AL		 2054static void v9fs_read(V9fsState *s, V9fsPDU *pdu)
2055{
a9231555
AL		 2056 int32_t fid;
2057 V9fsReadState *vs;
2058 ssize_t err = 0;
2059
2060 vs = qemu_malloc(sizeof(*vs));
2061 vs->pdu = pdu;
2062 vs->offset = 7;
2063 vs->total = 0;
2064 vs->len = 0;
2065 vs->count = 0;
2066
2067 pdu_unmarshal(vs->pdu, vs->offset, "dqd", &fid, &vs->off, &vs->count);
2068
2069 vs->fidp = lookup_fid(s, fid);
2070 if (vs->fidp == NULL) {
2071 err = -EINVAL;
2072 goto out;
2073 }
2074
fa32ef88 2075 if (vs->fidp->fid_type == P9_FID_DIR) {
a9231555
AL		 2076 vs->max_count = vs->count;
2077 vs->count = 0;
2078 if (vs->off == 0) {
d62dbb51 2079 v9fs_do_rewinddir(s, vs->fidp->fs.dir);
a9231555
AL		 2080 }
2081 v9fs_read_post_rewinddir(s, vs, err);
2082 return;
fa32ef88 2083 } else if (vs->fidp->fid_type == P9_FID_FILE) {
a9231555
AL		 2084 vs->sg = vs->iov;
2085 pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt);
d62dbb51 2086 err = v9fs_do_lseek(s, vs->fidp->fs.fd, vs->off, SEEK_SET);
a9231555
AL		 2087 v9fs_read_post_lseek(s, vs, err);
2088 return;
fa32ef88
AK		 2089 } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2090 v9fs_xattr_read(s, vs);
2091 return;
a9231555
AL		 2092 } else {
2093 err = -EINVAL;
9f107513 2094 }
a9231555
AL		 2095out:
2096 complete_pdu(s, pdu, err);
2097 qemu_free(vs);
9f107513
AL		 2098}
2099
c18e2f94
SK		 2100typedef struct V9fsReadDirState {
2101 V9fsPDU *pdu;
2102 V9fsFidState *fidp;
2103 V9fsQID qid;
2104 off_t saved_dir_pos;
2105 struct dirent *dent;
2106 int32_t count;
2107 int32_t max_count;
2108 size_t offset;
2109 int64_t initial_offset;
2110 V9fsString name;
2111} V9fsReadDirState;
2112
2113static void v9fs_readdir_post_seekdir(V9fsState *s, V9fsReadDirState *vs)
2114{
2115 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2116 vs->offset += vs->count;
2117 complete_pdu(s, vs->pdu, vs->offset);
2118 qemu_free(vs);
2119 return;
2120}
2121
2122/* Size of each dirent on the wire: size of qid (13) + size of offset (8)
2123 * size of type (1) + size of name.size (2) + strlen(name.data)
2124 */
2125#define V9_READDIR_DATA_SZ (24 + strlen(vs->name.data))
2126
2127static void v9fs_readdir_post_readdir(V9fsState *s, V9fsReadDirState *vs)
2128{
2129 int len;
2130 size_t size;
2131
2132 if (vs->dent) {
2133 v9fs_string_init(&vs->name);
2134 v9fs_string_sprintf(&vs->name, "%s", vs->dent->d_name);
2135
2136 if ((vs->count + V9_READDIR_DATA_SZ) > vs->max_count) {
2137 /* Ran out of buffer. Set dir back to old position and return */
d62dbb51 2138 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->saved_dir_pos);
c18e2f94
SK		 2139 v9fs_readdir_post_seekdir(s, vs);
2140 return;
2141 }
2142
2143 /* Fill up just the path field of qid because the client uses
2144 * only that. To fill the entire qid structure we will have
2145 * to stat each dirent found, which is expensive
2146 */
2147 size = MIN(sizeof(vs->dent->d_ino), sizeof(vs->qid.path));
2148 memcpy(&vs->qid.path, &vs->dent->d_ino, size);
2149 /* Fill the other fields with dummy values */
2150 vs->qid.type = 0;
2151 vs->qid.version = 0;
2152
2153 len = pdu_marshal(vs->pdu, vs->offset+4+vs->count, "Qqbs",
2154 &vs->qid, vs->dent->d_off,
2155 vs->dent->d_type, &vs->name);
2156 vs->count += len;
2157 v9fs_string_free(&vs->name);
2158 vs->saved_dir_pos = vs->dent->d_off;
d62dbb51 2159 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
c18e2f94
SK		 2160 v9fs_readdir_post_readdir(s, vs);
2161 return;
2162 }
2163
2164 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2165 vs->offset += vs->count;
2166 complete_pdu(s, vs->pdu, vs->offset);
2167 qemu_free(vs);
2168 return;
2169}
2170
2171static void v9fs_readdir_post_telldir(V9fsState *s, V9fsReadDirState *vs)
2172{
d62dbb51 2173 vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
c18e2f94
SK		 2174 v9fs_readdir_post_readdir(s, vs);
2175 return;
2176}
2177
2178static void v9fs_readdir_post_setdir(V9fsState *s, V9fsReadDirState *vs)
2179{
d62dbb51 2180 vs->saved_dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
c18e2f94
SK		 2181 v9fs_readdir_post_telldir(s, vs);
2182 return;
2183}
2184
2185static void v9fs_readdir(V9fsState *s, V9fsPDU *pdu)
2186{
2187 int32_t fid;
2188 V9fsReadDirState *vs;
2189 ssize_t err = 0;
2190 size_t offset = 7;
2191
2192 vs = qemu_malloc(sizeof(*vs));
2193 vs->pdu = pdu;
2194 vs->offset = 7;
2195 vs->count = 0;
2196
2197 pdu_unmarshal(vs->pdu, offset, "dqd", &fid, &vs->initial_offset,
2198 &vs->max_count);
2199
2200 vs->fidp = lookup_fid(s, fid);
d62dbb51 2201 if (vs->fidp == NULL || !(vs->fidp->fs.dir)) {
c18e2f94
SK		 2202 err = -EINVAL;
2203 goto out;
2204 }
2205
2206 if (vs->initial_offset == 0) {
d62dbb51 2207 v9fs_do_rewinddir(s, vs->fidp->fs.dir);
c18e2f94 2208 } else {
d62dbb51 2209 v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->initial_offset);
c18e2f94
SK		 2210 }
2211
2212 v9fs_readdir_post_setdir(s, vs);
2213 return;
2214
2215out:
2216 complete_pdu(s, pdu, err);
2217 qemu_free(vs);
2218 return;
2219}
2220
8449360c
AL		 2221static void v9fs_write_post_writev(V9fsState *s, V9fsWriteState *vs,
2222 ssize_t err)
2223{
2224 if (err < 0) {
2225 /* IO error return the error */
2226 err = -errno;
2227 goto out;
2228 }
2229 vs->total += vs->len;
2230 vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
2231 if (vs->total < vs->count && vs->len > 0) {
2232 do {
2233 if (0) {
2234 print_sg(vs->sg, vs->cnt);
2235 }
d62dbb51 2236 vs->len = v9fs_do_writev(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
8449360c
AL		 2237 } while (vs->len == -1 && errno == EINTR);
2238 if (vs->len == -1) {
2239 err = -errno;
2240 }
2241 v9fs_write_post_writev(s, vs, err);
2242 return;
2243 }
2244 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
2245
2246 err = vs->offset;
2247out:
2248 complete_pdu(s, vs->pdu, err);
2249 qemu_free(vs);
2250}
2251
2252static void v9fs_write_post_lseek(V9fsState *s, V9fsWriteState *vs, ssize_t err)
2253{
2254 if (err == -1) {
2255 err = -errno;
2256 goto out;
2257 }
2258 vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2259
2260 if (vs->total < vs->count) {
2261 do {
2262 if (0) {
2263 print_sg(vs->sg, vs->cnt);
2264 }
d62dbb51 2265 vs->len = v9fs_do_writev(s, vs->fidp->fs.fd, vs->sg, vs->cnt);
8449360c
AL		 2266 } while (vs->len == -1 && errno == EINTR);
2267 if (vs->len == -1) {
2268 err = -errno;
2269 }
2270 v9fs_write_post_writev(s, vs, err);
2271 return;
2272 }
2273
2274out:
2275 complete_pdu(s, vs->pdu, err);
2276 qemu_free(vs);
2277}
2278
10b468bd
AK		 2279static void v9fs_xattr_write(V9fsState *s, V9fsWriteState *vs)
2280{
2281 int i, to_copy;
2282 ssize_t err = 0;
2283 int write_count;
2284 int64_t xattr_len;
2285
2286 xattr_len = vs->fidp->fs.xattr.len;
2287 write_count = xattr_len - vs->off;
2288 if (write_count > vs->count) {
2289 write_count = vs->count;
2290 } else if (write_count < 0) {
2291 /*
2292 * write beyond XATTR value len specified in
2293 * xattrcreate
2294 */
2295 err = -ENOSPC;
2296 goto out;
2297 }
2298 vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", write_count);
2299 err = vs->offset;
2300 vs->fidp->fs.xattr.copied_len += write_count;
2301 /*
2302 * Now copy the content from sg list
2303 */
2304 for (i = 0; i < vs->cnt; i++) {
2305 if (write_count > vs->sg[i].iov_len) {
2306 to_copy = vs->sg[i].iov_len;
2307 } else {
2308 to_copy = write_count;
2309 }
2310 memcpy((char *)vs->fidp->fs.xattr.value + vs->off,
2311 vs->sg[i].iov_base, to_copy);
2312 /* updating vs->off since we are not using below */
2313 vs->off += to_copy;
2314 write_count -= to_copy;
2315 }
2316out:
2317 complete_pdu(s, vs->pdu, err);
2318 qemu_free(vs);
2319}
2320
9f107513
AL		 2321static void v9fs_write(V9fsState *s, V9fsPDU *pdu)
2322{
8449360c
AL		 2323 int32_t fid;
2324 V9fsWriteState *vs;
2325 ssize_t err;
2326
2327 vs = qemu_malloc(sizeof(*vs));
2328
2329 vs->pdu = pdu;
2330 vs->offset = 7;
2331 vs->sg = vs->iov;
2332 vs->total = 0;
2333 vs->len = 0;
2334
2335 pdu_unmarshal(vs->pdu, vs->offset, "dqdv", &fid, &vs->off, &vs->count,
10b468bd 2336 vs->sg, &vs->cnt);
8449360c
AL		 2337
2338 vs->fidp = lookup_fid(s, fid);
2339 if (vs->fidp == NULL) {
2340 err = -EINVAL;
2341 goto out;
9f107513 2342 }
8449360c 2343
10b468bd
AK		 2344 if (vs->fidp->fid_type == P9_FID_FILE) {
2345 if (vs->fidp->fs.fd == -1) {
2346 err = -EINVAL;
2347 goto out;
2348 }
2349 } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2350 /*
2351 * setxattr operation
2352 */
2353 v9fs_xattr_write(s, vs);
2354 return;
2355 } else {
8449360c
AL		 2356 err = -EINVAL;
2357 goto out;
2358 }
d62dbb51 2359 err = v9fs_do_lseek(s, vs->fidp->fs.fd, vs->off, SEEK_SET);
8449360c
AL		 2360
2361 v9fs_write_post_lseek(s, vs, err);
2362 return;
2363
2364out:
2365 complete_pdu(s, vs->pdu, err);
2366 qemu_free(vs);
9f107513
AL		 2367}
2368
5e94c103 2369static void v9fs_create_post_getiounit(V9fsState *s, V9fsCreateState *vs)
c494dd6f 2370{
5e94c103
MK		 2371 int err;
2372 v9fs_string_copy(&vs->fidp->path, &vs->fullname);
2373 stat_to_qid(&vs->stbuf, &vs->qid);
c494dd6f 2374
5e94c103
MK		 2375 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
2376 err = vs->offset;
c494dd6f 2377
5e94c103
MK		 2378 complete_pdu(s, vs->pdu, err);
2379 v9fs_string_free(&vs->name);
2380 v9fs_string_free(&vs->extension);
2381 v9fs_string_free(&vs->fullname);
2382 qemu_free(vs);
2383}
2384
2385static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
2386{
2387 if (err == 0) {
2388 vs->iounit = get_iounit(s, &vs->fidp->path);
2389 v9fs_create_post_getiounit(s, vs);
2390 return;
c494dd6f
AL		 2391 }
2392
2393 complete_pdu(s, vs->pdu, err);
2394 v9fs_string_free(&vs->name);
2395 v9fs_string_free(&vs->extension);
2396 v9fs_string_free(&vs->fullname);
2397 qemu_free(vs);
2398}
2399
2400static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
2401{
2402 if (err) {
2403 err = -errno;
2404 }
2405 v9fs_post_create(s, vs, err);
2406}
2407
2408static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
2409 int err)
2410{
d62dbb51 2411 if (!vs->fidp->fs.dir) {
c494dd6f
AL		 2412 err = -errno;
2413 }
d62dbb51 2414 vs->fidp->fid_type = P9_FID_DIR;
c494dd6f
AL		 2415 v9fs_post_create(s, vs, err);
2416}
2417
2418static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
2419 int err)
2420{
2421 if (err) {
2422 err = -errno;
2423 goto out;
2424 }
2425
d62dbb51 2426 vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fullname);
c494dd6f
AL		 2427 v9fs_create_post_opendir(s, vs, err);
2428 return;
2429
2430out:
2431 v9fs_post_create(s, vs, err);
2432}
2433
2434static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
2435{
2436 if (err) {
2437 err = -errno;
2438 goto out;
2439 }
2440
2441 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2442 v9fs_create_post_dir_lstat(s, vs, err);
2443 return;
2444
2445out:
2446 v9fs_post_create(s, vs, err);
2447}
2448
c494dd6f
AL		 2449static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
2450{
2451 if (err) {
d62dbb51
AK		 2452 vs->fidp->fid_type = P9_FID_NONE;
2453 close(vs->fidp->fs.fd);
c494dd6f
AL		 2454 err = -errno;
2455 }
c494dd6f
AL		 2456 v9fs_post_create(s, vs, err);
2457 return;
2458}
2459
2460static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
2461{
d62dbb51 2462 if (vs->fidp->fs.fd == -1) {
c494dd6f
AL		 2463 err = -errno;
2464 goto out;
2465 }
d62dbb51
AK		 2466 vs->fidp->fid_type = P9_FID_FILE;
2467 err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
c494dd6f
AL		 2468 v9fs_create_post_fstat(s, vs, err);
2469
2470 return;
2471
2472out:
2473 v9fs_post_create(s, vs, err);
2474
2475}
2476
2477static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
2478{
2479
2480 if (err == 0 || errno != ENOENT) {
2481 err = -errno;
2482 goto out;
2483 }
2484
2485 if (vs->perm & P9_STAT_MODE_DIR) {
b67592ea
MK		 2486 err = v9fs_do_mkdir(s, vs->fullname.data, vs->perm & 0777,
2487 vs->fidp->uid, -1);
c494dd6f
AL		 2488 v9fs_create_post_mkdir(s, vs, err);
2489 } else if (vs->perm & P9_STAT_MODE_SYMLINK) {
08c60fc9
VJ		 2490 err = v9fs_do_symlink(s, vs->fidp, vs->extension.data,
2491 vs->fullname.data, -1);
c494dd6f
AL		 2492 v9fs_create_post_perms(s, vs, err);
2493 } else if (vs->perm & P9_STAT_MODE_LINK) {
2494 int32_t nfid = atoi(vs->extension.data);
2495 V9fsFidState *nfidp = lookup_fid(s, nfid);
2496 if (nfidp == NULL) {
2497 err = -errno;
2498 v9fs_post_create(s, vs, err);
2499 }
2500 err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
2501 v9fs_create_post_perms(s, vs, err);
2502 } else if (vs->perm & P9_STAT_MODE_DEVICE) {
2503 char ctype;
2504 uint32_t major, minor;
2505 mode_t nmode = 0;
2506
2507 if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
2508 &minor) != 3) {
2509 err = -errno;
2510 v9fs_post_create(s, vs, err);
2511 }
2512
2513 switch (ctype) {
2514 case 'c':
2515 nmode = S_IFCHR;
2516 break;
2517 case 'b':
2518 nmode = S_IFBLK;
2519 break;
2520 default:
2521 err = -EIO;
2522 v9fs_post_create(s, vs, err);
2523 }
2524
2525 nmode |= vs->perm & 0777;
5268cecc
MK		 2526 err = v9fs_do_mknod(s, vs->fullname.data, nmode,
2527 makedev(major, minor), vs->fidp->uid, -1);
c494dd6f
AL		 2528 v9fs_create_post_perms(s, vs, err);
2529 } else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
5268cecc
MK		 2530 err = v9fs_do_mknod(s, vs->fullname.data, S_IFIFO | (vs->perm & 0777),
2531 0, vs->fidp->uid, -1);
c494dd6f
AL		 2532 v9fs_post_create(s, vs, err);
2533 } else if (vs->perm & P9_STAT_MODE_SOCKET) {
5268cecc
MK		 2534 err = v9fs_do_mknod(s, vs->fullname.data, S_IFSOCK | (vs->perm & 0777),
2535 0, vs->fidp->uid, -1);
63729c36 2536 v9fs_post_create(s, vs, err);
c494dd6f 2537 } else {
d62dbb51 2538 vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
c1568af5
VJ		 2539 -1, omode_to_uflags(vs->mode)|O_CREAT, vs->perm);
2540
c494dd6f
AL		 2541 v9fs_create_post_open2(s, vs, err);
2542 }
2543
2544 return;
2545
2546out:
2547 v9fs_post_create(s, vs, err);
2548}
2549
9f107513
AL		 2550static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
2551{
c494dd6f
AL		 2552 int32_t fid;
2553 V9fsCreateState *vs;
2554 int err = 0;
2555
2556 vs = qemu_malloc(sizeof(*vs));
2557 vs->pdu = pdu;
2558 vs->offset = 7;
2559
2560 v9fs_string_init(&vs->fullname);
2561
2562 pdu_unmarshal(vs->pdu, vs->offset, "dsdbs", &fid, &vs->name,
2563 &vs->perm, &vs->mode, &vs->extension);
2564
2565 vs->fidp = lookup_fid(s, fid);
2566 if (vs->fidp == NULL) {
2567 err = -EINVAL;
2568 goto out;
9f107513 2569 }
c494dd6f
AL		 2570
2571 v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
2572 vs->name.data);
2573
2574 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2575 v9fs_create_post_lstat(s, vs, err);
2576 return;
2577
2578out:
2579 complete_pdu(s, vs->pdu, err);
2580 v9fs_string_free(&vs->name);
2581 v9fs_string_free(&vs->extension);
2582 qemu_free(vs);
9f107513
AL		 2583}
2584
08c60fc9
VJ		 2585static void v9fs_post_symlink(V9fsState *s, V9fsSymlinkState *vs, int err)
2586{
2587 if (err == 0) {
2588 stat_to_qid(&vs->stbuf, &vs->qid);
2589 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
2590 err = vs->offset;
2591 } else {
2592 err = -errno;
2593 }
2594 complete_pdu(s, vs->pdu, err);
2595 v9fs_string_free(&vs->name);
2596 v9fs_string_free(&vs->symname);
2597 v9fs_string_free(&vs->fullname);
2598 qemu_free(vs);
2599}
2600
2601static void v9fs_symlink_post_do_symlink(V9fsState *s, V9fsSymlinkState *vs,
2602 int err)
2603{
2604 if (err) {
2605 goto out;
2606 }
2607 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2608out:
2609 v9fs_post_symlink(s, vs, err);
2610}
2611
2612static void v9fs_symlink(V9fsState *s, V9fsPDU *pdu)
2613{
2614 int32_t dfid;
2615 V9fsSymlinkState *vs;
2616 int err = 0;
2617 gid_t gid;
2618
2619 vs = qemu_malloc(sizeof(*vs));
2620 vs->pdu = pdu;
2621 vs->offset = 7;
2622
2623 v9fs_string_init(&vs->fullname);
2624
2625 pdu_unmarshal(vs->pdu, vs->offset, "dssd", &dfid, &vs->name,
2626 &vs->symname, &gid);
2627
2628 vs->dfidp = lookup_fid(s, dfid);
2629 if (vs->dfidp == NULL) {
2630 err = -EINVAL;
2631 goto out;
2632 }
2633
2634 v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->dfidp->path.data,
2635 vs->name.data);
2636 err = v9fs_do_symlink(s, vs->dfidp, vs->symname.data,
2637 vs->fullname.data, gid);
2638 v9fs_symlink_post_do_symlink(s, vs, err);
2639 return;
2640
2641out:
2642 complete_pdu(s, vs->pdu, err);
2643 v9fs_string_free(&vs->name);
2644 v9fs_string_free(&vs->symname);
2645 qemu_free(vs);
2646}
2647
9f107513
AL		 2648static void v9fs_flush(V9fsState *s, V9fsPDU *pdu)
2649{
9c5e9d89
AL		 2650 /* A nop call with no return */
2651 complete_pdu(s, pdu, 7);
9f107513
AL		 2652}
2653
b2c224be
VJ		 2654static void v9fs_link(V9fsState *s, V9fsPDU *pdu)
2655{
2656 int32_t dfid, oldfid;
2657 V9fsFidState *dfidp, *oldfidp;
2658 V9fsString name, fullname;
2659 size_t offset = 7;
2660 int err = 0;
2661
2662 v9fs_string_init(&fullname);
2663
2664 pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2665
2666 dfidp = lookup_fid(s, dfid);
2667 if (dfidp == NULL) {
2668 err = -errno;
2669 goto out;
2670 }
2671
2672 oldfidp = lookup_fid(s, oldfid);
2673 if (oldfidp == NULL) {
2674 err = -errno;
2675 goto out;
2676 }
2677
2678 v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
2679 err = offset;
2680 err = v9fs_do_link(s, &oldfidp->path, &fullname);
2681 if (err) {
2682 err = -errno;
2683 }
2684 v9fs_string_free(&fullname);
2685
2686out:
2687 v9fs_string_free(&name);
2688 complete_pdu(s, pdu, err);
2689}
2690
5bae1900
AL		 2691static void v9fs_remove_post_remove(V9fsState *s, V9fsRemoveState *vs,
2692 int err)
2693{
5bae1900 2694 if (err < 0) {
926487b7
SK		 2695 err = -errno;
2696 } else {
2697 err = vs->offset;
5bae1900
AL		 2698 }
2699
926487b7
SK		 2700 /* For TREMOVE we need to clunk the fid even on failed remove */
2701 free_fid(s, vs->fidp->fid);
2702
5bae1900
AL		 2703 complete_pdu(s, vs->pdu, err);
2704 qemu_free(vs);
2705}
2706
9f107513
AL		 2707static void v9fs_remove(V9fsState *s, V9fsPDU *pdu)
2708{
5bae1900
AL		 2709 int32_t fid;
2710 V9fsRemoveState *vs;
2711 int err = 0;
2712
2713 vs = qemu_malloc(sizeof(*vs));
2714 vs->pdu = pdu;
2715 vs->offset = 7;
2716
2717 pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
2718
2719 vs->fidp = lookup_fid(s, fid);
2720 if (vs->fidp == NULL) {
2721 err = -EINVAL;
2722 goto out;
9f107513 2723 }
5bae1900
AL		 2724
2725 err = v9fs_do_remove(s, &vs->fidp->path);
2726 v9fs_remove_post_remove(s, vs, err);
2727 return;
2728
2729out:
2730 complete_pdu(s, pdu, err);
2731 qemu_free(vs);
9f107513
AL		 2732}
2733
8cf89e00
AL		 2734static void v9fs_wstat_post_truncate(V9fsState *s, V9fsWstatState *vs, int err)
2735{
2736 if (err < 0) {
2737 goto out;
2738 }
2739
2740 err = vs->offset;
2741
2742out:
2743 v9fs_stat_free(&vs->v9stat);
2744 complete_pdu(s, vs->pdu, err);
2745 qemu_free(vs);
2746}
2747
2748static void v9fs_wstat_post_rename(V9fsState *s, V9fsWstatState *vs, int err)
2749{
2750 if (err < 0) {
2751 goto out;
2752 }
8cf89e00
AL		 2753 if (vs->v9stat.length != -1) {
2754 if (v9fs_do_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) {
2755 err = -errno;
2756 }
2757 }
2758 v9fs_wstat_post_truncate(s, vs, err);
2759 return;
2760
2761out:
2762 v9fs_stat_free(&vs->v9stat);
2763 complete_pdu(s, vs->pdu, err);
2764 qemu_free(vs);
2765}
2766
c7b4b0b3 2767static int v9fs_complete_rename(V9fsState *s, V9fsRenameState *vs)
8cf89e00 2768{
c7b4b0b3
MK		 2769 int err = 0;
2770 char *old_name, *new_name;
2771 char *end;
8cf89e00 2772
c7b4b0b3
MK		 2773 if (vs->newdirfid != -1) {
2774 V9fsFidState *dirfidp;
2775 dirfidp = lookup_fid(s, vs->newdirfid);
2776
2777 if (dirfidp == NULL) {
2778 err = -ENOENT;
2779 goto out;
2780 }
2781
d62dbb51 2782 BUG_ON(dirfidp->fid_type != P9_FID_NONE);
8cf89e00 2783
c7b4b0b3
MK		 2784 new_name = qemu_mallocz(dirfidp->path.size + vs->name.size + 2);
2785
2786 strcpy(new_name, dirfidp->path.data);
2787 strcat(new_name, "/");
2788 strcat(new_name + dirfidp->path.size, vs->name.data);
2789 } else {
8cf89e00
AL		 2790 old_name = vs->fidp->path.data;
2791 end = strrchr(old_name, '/');
2792 if (end) {
2793 end++;
2794 } else {
2795 end = old_name;
2796 }
c7b4b0b3 2797 new_name = qemu_mallocz(end - old_name + vs->name.size + 1);
8cf89e00 2798
c7b4b0b3
MK		 2799 strncat(new_name, old_name, end - old_name);
2800 strncat(new_name + (end - old_name), vs->name.data, vs->name.size);
2801 }
8cf89e00 2802
c7b4b0b3
MK		 2803 v9fs_string_free(&vs->name);
2804 vs->name.data = qemu_strdup(new_name);
2805 vs->name.size = strlen(new_name);
8cf89e00 2806
c7b4b0b3
MK		 2807 if (strcmp(new_name, vs->fidp->path.data) != 0) {
2808 if (v9fs_do_rename(s, &vs->fidp->path, &vs->name)) {
2809 err = -errno;
2810 } else {
2811 V9fsFidState *fidp;
2812 /*
2813 * Fixup fid's pointing to the old name to
2814 * start pointing to the new name
2815 */
2816 for (fidp = s->fid_list; fidp; fidp = fidp->next) {
2817 if (vs->fidp == fidp) {
2818 /*
2819 * we replace name of this fid towards the end
2820 * so that our below strcmp will work
2821 */
2822 continue;
2823 }
2824 if (!strncmp(vs->fidp->path.data, fidp->path.data,
2825 strlen(vs->fidp->path.data))) {
2826 /* replace the name */
2827 v9fs_fix_path(&fidp->path, &vs->name,
2828 strlen(vs->fidp->path.data));
8cf89e00 2829 }
8cf89e00 2830 }
c7b4b0b3 2831 v9fs_string_copy(&vs->fidp->path, &vs->name);
8cf89e00
AL		 2832 }
2833 }
c7b4b0b3
MK		 2834out:
2835 v9fs_string_free(&vs->name);
2836 return err;
2837}
2838
2839static void v9fs_rename_post_rename(V9fsState *s, V9fsRenameState *vs, int err)
2840{
2841 complete_pdu(s, vs->pdu, err);
2842 qemu_free(vs);
2843}
2844
2845static void v9fs_wstat_post_chown(V9fsState *s, V9fsWstatState *vs, int err)
2846{
2847 if (err < 0) {
2848 goto out;
2849 }
2850
2851 if (vs->v9stat.name.size != 0) {
2852 V9fsRenameState *vr;
2853
783f04e1 2854 vr = qemu_mallocz(sizeof(V9fsRenameState));
c7b4b0b3
MK		 2855 vr->newdirfid = -1;
2856 vr->pdu = vs->pdu;
2857 vr->fidp = vs->fidp;
2858 vr->offset = vs->offset;
2859 vr->name.size = vs->v9stat.name.size;
2860 vr->name.data = qemu_strdup(vs->v9stat.name.data);
2861
2862 err = v9fs_complete_rename(s, vr);
2863 qemu_free(vr);
2864 }
8cf89e00
AL		 2865 v9fs_wstat_post_rename(s, vs, err);
2866 return;
2867
2868out:
2869 v9fs_stat_free(&vs->v9stat);
2870 complete_pdu(s, vs->pdu, err);
2871 qemu_free(vs);
2872}
2873
c7b4b0b3
MK		 2874static void v9fs_rename(V9fsState *s, V9fsPDU *pdu)
2875{
2876 int32_t fid;
2877 V9fsRenameState *vs;
2878 ssize_t err = 0;
2879
2880 vs = qemu_malloc(sizeof(*vs));
2881 vs->pdu = pdu;
2882 vs->offset = 7;
2883
2884 pdu_unmarshal(vs->pdu, vs->offset, "dds", &fid, &vs->newdirfid, &vs->name);
2885
2886 vs->fidp = lookup_fid(s, fid);
2887 if (vs->fidp == NULL) {
2888 err = -ENOENT;
2889 goto out;
2890 }
2891
d62dbb51 2892 BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
c7b4b0b3
MK		 2893
2894 err = v9fs_complete_rename(s, vs);
2895 v9fs_rename_post_rename(s, vs, err);
2896 return;
2897out:
2898 complete_pdu(s, vs->pdu, err);
2899 qemu_free(vs);
2900}
2901
8cf89e00
AL		 2902static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err)
2903{
2904 if (err < 0) {
2905 goto out;
2906 }
2907
f7613bee 2908 if (vs->v9stat.n_gid != -1 || vs->v9stat.n_uid != -1) {
8cf89e00
AL		 2909 if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid,
2910 vs->v9stat.n_gid)) {
2911 err = -errno;
2912 }
2913 }
2914 v9fs_wstat_post_chown(s, vs, err);
2915 return;
2916
2917out:
2918 v9fs_stat_free(&vs->v9stat);
2919 complete_pdu(s, vs->pdu, err);
2920 qemu_free(vs);
2921}
2922
2923static void v9fs_wstat_post_chmod(V9fsState *s, V9fsWstatState *vs, int err)
2924{
2925 if (err < 0) {
2926 goto out;
2927 }
2928
74bc02b2 2929 if (vs->v9stat.mtime != -1 || vs->v9stat.atime != -1) {
8fc39ae4
SK		 2930 struct timespec times[2];
2931 if (vs->v9stat.atime != -1) {
2932 times[0].tv_sec = vs->v9stat.atime;
2933 times[0].tv_nsec = 0;
2934 } else {
2935 times[0].tv_nsec = UTIME_OMIT;
2936 }
2937 if (vs->v9stat.mtime != -1) {
2938 times[1].tv_sec = vs->v9stat.mtime;
2939 times[1].tv_nsec = 0;
2940 } else {
2941 times[1].tv_nsec = UTIME_OMIT;
2942 }
2943
2944 if (v9fs_do_utimensat(s, &vs->fidp->path, times)) {
8cf89e00
AL		 2945 err = -errno;
2946 }
2947 }
2948
2949 v9fs_wstat_post_utime(s, vs, err);
2950 return;
2951
2952out:
2953 v9fs_stat_free(&vs->v9stat);
2954 complete_pdu(s, vs->pdu, err);
2955 qemu_free(vs);
2956}
2957
2958static void v9fs_wstat_post_fsync(V9fsState *s, V9fsWstatState *vs, int err)
2959{
2960 if (err == -1) {
2961 err = -errno;
2962 }
2963 v9fs_stat_free(&vs->v9stat);
2964 complete_pdu(s, vs->pdu, err);
2965 qemu_free(vs);
2966}
2967
2968static void v9fs_wstat_post_lstat(V9fsState *s, V9fsWstatState *vs, int err)
2969{
2970 uint32_t v9_mode;
2971
2972 if (err == -1) {
2973 err = -errno;
2974 goto out;
2975 }
2976
2977 v9_mode = stat_to_v9mode(&vs->stbuf);
2978
2979 if ((vs->v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2980 (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2981 /* Attempting to change the type */
2982 err = -EIO;
2983 goto out;
2984 }
2985
2986 if (v9fs_do_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode,
2987 &vs->v9stat.extension))) {
2988 err = -errno;
2989 }
2990 v9fs_wstat_post_chmod(s, vs, err);
2991 return;
2992
2993out:
2994 v9fs_stat_free(&vs->v9stat);
2995 complete_pdu(s, vs->pdu, err);
2996 qemu_free(vs);
2997}
2998
9f107513
AL		 2999static void v9fs_wstat(V9fsState *s, V9fsPDU *pdu)
3000{
8cf89e00
AL		 3001 int32_t fid;
3002 V9fsWstatState *vs;
3003 int err = 0;
3004
3005 vs = qemu_malloc(sizeof(*vs));
3006 vs->pdu = pdu;
3007 vs->offset = 7;
3008
3009 pdu_unmarshal(pdu, vs->offset, "dwS", &fid, &vs->unused, &vs->v9stat);
3010
3011 vs->fidp = lookup_fid(s, fid);
3012 if (vs->fidp == NULL) {
3013 err = -EINVAL;
3014 goto out;
9f107513 3015 }
8cf89e00
AL		 3016
3017 /* do we need to sync the file? */
3018 if (donttouch_stat(&vs->v9stat)) {
d62dbb51 3019 err = v9fs_do_fsync(s, vs->fidp->fs.fd);
8cf89e00
AL		 3020 v9fs_wstat_post_fsync(s, vs, err);
3021 return;
3022 }
3023
3024 if (vs->v9stat.mode != -1) {
3025 err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
3026 v9fs_wstat_post_lstat(s, vs, err);
3027 return;
3028 }
3029
3030 v9fs_wstat_post_chmod(s, vs, err);
3031 return;
3032
3033out:
3034 v9fs_stat_free(&vs->v9stat);
3035 complete_pdu(s, vs->pdu, err);
3036 qemu_free(vs);
9f107513
AL		 3037}
3038
be940c87
MK		 3039static void v9fs_statfs_post_statfs(V9fsState *s, V9fsStatfsState *vs, int err)
3040{
5e94c103
MK		 3041 int32_t bsize_factor;
3042
be940c87
MK		 3043 if (err) {
3044 err = -errno;
3045 goto out;
3046 }
3047
5e94c103
MK		 3048 /*
3049 * compute bsize factor based on host file system block size
3050 * and client msize
3051 */
3052 bsize_factor = (s->msize - P9_IOHDRSZ)/vs->stbuf.f_bsize;
3053 if (!bsize_factor) {
3054 bsize_factor = 1;
3055 }
be940c87
MK		 3056 vs->v9statfs.f_type = vs->stbuf.f_type;
3057 vs->v9statfs.f_bsize = vs->stbuf.f_bsize;
5e94c103
MK		 3058 vs->v9statfs.f_bsize *= bsize_factor;
3059 /*
3060 * f_bsize is adjusted(multiplied) by bsize factor, so we need to
3061 * adjust(divide) the number of blocks, free blocks and available
3062 * blocks by bsize factor
3063 */
3064 vs->v9statfs.f_blocks = vs->stbuf.f_blocks/bsize_factor;
3065 vs->v9statfs.f_bfree = vs->stbuf.f_bfree/bsize_factor;
3066 vs->v9statfs.f_bavail = vs->stbuf.f_bavail/bsize_factor;
be940c87
MK		 3067 vs->v9statfs.f_files = vs->stbuf.f_files;
3068 vs->v9statfs.f_ffree = vs->stbuf.f_ffree;
3069 vs->v9statfs.fsid_val = (unsigned int) vs->stbuf.f_fsid.__val[0] |
3070 (unsigned long long)vs->stbuf.f_fsid.__val[1] << 32;
3071 vs->v9statfs.f_namelen = vs->stbuf.f_namelen;
3072
3073 vs->offset += pdu_marshal(vs->pdu, vs->offset, "ddqqqqqqd",
3074 vs->v9statfs.f_type, vs->v9statfs.f_bsize, vs->v9statfs.f_blocks,
3075 vs->v9statfs.f_bfree, vs->v9statfs.f_bavail, vs->v9statfs.f_files,
3076 vs->v9statfs.f_ffree, vs->v9statfs.fsid_val,
3077 vs->v9statfs.f_namelen);
3078
3079out:
3080 complete_pdu(s, vs->pdu, vs->offset);
3081 qemu_free(vs);
3082}
3083
3084static void v9fs_statfs(V9fsState *s, V9fsPDU *pdu)
3085{
3086 V9fsStatfsState *vs;
3087 ssize_t err = 0;
3088
3089 vs = qemu_malloc(sizeof(*vs));
3090 vs->pdu = pdu;
3091 vs->offset = 7;
3092
3093 memset(&vs->v9statfs, 0, sizeof(vs->v9statfs));
3094
3095 pdu_unmarshal(vs->pdu, vs->offset, "d", &vs->fid);
3096
3097 vs->fidp = lookup_fid(s, vs->fid);
3098 if (vs->fidp == NULL) {
3099 err = -ENOENT;
3100 goto out;
3101 }
3102
3103 err = v9fs_do_statfs(s, &vs->fidp->path, &vs->stbuf);
3104 v9fs_statfs_post_statfs(s, vs, err);
3105 return;
3106
3107out:
3108 complete_pdu(s, vs->pdu, err);
3109 qemu_free(vs);
3110}
3111
5268cecc
MK		 3112static void v9fs_mknod_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
3113{
3114 if (err == -1) {
3115 err = -errno;
3116 goto out;
3117 }
3118
3119 stat_to_qid(&vs->stbuf, &vs->qid);
3120 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
3121 err = vs->offset;
3122out:
3123 complete_pdu(s, vs->pdu, err);
3124 v9fs_string_free(&vs->fullname);
3125 v9fs_string_free(&vs->name);
3126 qemu_free(vs);
3127}
3128
3129static void v9fs_mknod_post_mknod(V9fsState *s, V9fsMkState *vs, int err)
3130{
3131 if (err == -1) {
3132 err = -errno;
3133 goto out;
3134 }
3135
3136 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
3137 v9fs_mknod_post_lstat(s, vs, err);
3138 return;
3139out:
3140 complete_pdu(s, vs->pdu, err);
3141 v9fs_string_free(&vs->fullname);
3142 v9fs_string_free(&vs->name);
3143 qemu_free(vs);
3144}
3145
3146static void v9fs_mknod(V9fsState *s, V9fsPDU *pdu)
3147{
3148 int32_t fid;
3149 V9fsMkState *vs;
3150 int err = 0;
3151 V9fsFidState *fidp;
3152 gid_t gid;
3153 int mode;
3154 int major, minor;
3155
3156 vs = qemu_malloc(sizeof(*vs));
3157 vs->pdu = pdu;
3158 vs->offset = 7;
3159
3160 v9fs_string_init(&vs->fullname);
3161 pdu_unmarshal(vs->pdu, vs->offset, "dsdddd", &fid, &vs->name, &mode,
3162 &major, &minor, &gid);
3163
3164 fidp = lookup_fid(s, fid);
3165 if (fidp == NULL) {
3166 err = -ENOENT;
3167 goto out;
3168 }
3169
3170 v9fs_string_sprintf(&vs->fullname, "%s/%s", fidp->path.data, vs->name.data);
3171 err = v9fs_do_mknod(s, vs->fullname.data, mode, makedev(major, minor),
3172 fidp->uid, gid);
3173 v9fs_mknod_post_mknod(s, vs, err);
3174 return;
3175
3176out:
3177 complete_pdu(s, vs->pdu, err);
3178 v9fs_string_free(&vs->fullname);
3179 v9fs_string_free(&vs->name);
3180 qemu_free(vs);
3181}
3182
82cc3ee8
MK		 3183/*
3184 * Implement posix byte range locking code
3185 * Server side handling of locking code is very simple, because 9p server in
3186 * QEMU can handle only one client. And most of the lock handling
3187 * (like conflict, merging) etc is done by the VFS layer itself, so no need to
3188 * do any thing in * qemu 9p server side lock code path.
3189 * So when a TLOCK request comes, always return success
3190 */
3191
3192static void v9fs_lock(V9fsState *s, V9fsPDU *pdu)
3193{
3194 int32_t fid, err = 0;
3195 V9fsLockState *vs;
3196
3197 vs = qemu_mallocz(sizeof(*vs));
3198 vs->pdu = pdu;
3199 vs->offset = 7;
3200
3201 vs->flock = qemu_malloc(sizeof(*vs->flock));
3202 pdu_unmarshal(vs->pdu, vs->offset, "dbdqqds", &fid, &vs->flock->type,
3203 &vs->flock->flags, &vs->flock->start, &vs->flock->length,
3204 &vs->flock->proc_id, &vs->flock->client_id);
3205
3206 vs->status = P9_LOCK_ERROR;
3207
3208 /* We support only block flag now (that too ignored currently) */
3209 if (vs->flock->flags & ~P9_LOCK_FLAGS_BLOCK) {
3210 err = -EINVAL;
3211 goto out;
3212 }
3213 vs->fidp = lookup_fid(s, fid);
3214 if (vs->fidp == NULL) {
3215 err = -ENOENT;
3216 goto out;
3217 }
3218
3219 err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
3220 if (err < 0) {
3221 err = -errno;
3222 goto out;
3223 }
3224 vs->status = P9_LOCK_SUCCESS;
3225out:
3226 vs->offset += pdu_marshal(vs->pdu, vs->offset, "b", vs->status);
3227 complete_pdu(s, vs->pdu, err);
3228 qemu_free(vs->flock);
3229 qemu_free(vs);
3230}
3231
8f354003
MK		 3232/*
3233 * When a TGETLOCK request comes, always return success because all lock
3234 * handling is done by client's VFS layer.
3235 */
3236
3237static void v9fs_getlock(V9fsState *s, V9fsPDU *pdu)
3238{
3239 int32_t fid, err = 0;
3240 V9fsGetlockState *vs;
3241
3242 vs = qemu_mallocz(sizeof(*vs));
3243 vs->pdu = pdu;
3244 vs->offset = 7;
3245
3246 vs->glock = qemu_malloc(sizeof(*vs->glock));
3247 pdu_unmarshal(vs->pdu, vs->offset, "dbqqds", &fid, &vs->glock->type,
3248 &vs->glock->start, &vs->glock->length, &vs->glock->proc_id,
3249 &vs->glock->client_id);
3250
3251 vs->fidp = lookup_fid(s, fid);
3252 if (vs->fidp == NULL) {
3253 err = -ENOENT;
3254 goto out;
3255 }
3256
3257 err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
3258 if (err < 0) {
3259 err = -errno;
3260 goto out;
3261 }
3262 vs->glock->type = F_UNLCK;
3263 vs->offset += pdu_marshal(vs->pdu, vs->offset, "bqqds", vs->glock->type,
3264 vs->glock->start, vs->glock->length, vs->glock->proc_id,
3265 &vs->glock->client_id);
3266out:
3267 complete_pdu(s, vs->pdu, err);
3268 qemu_free(vs->glock);
3269 qemu_free(vs);
3270}
3271
b67592ea
MK		 3272static void v9fs_mkdir_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
3273{
3274 if (err == -1) {
3275 err = -errno;
3276 goto out;
3277 }
3278
3279 stat_to_qid(&vs->stbuf, &vs->qid);
3280 vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
3281 err = vs->offset;
3282out:
3283 complete_pdu(s, vs->pdu, err);
3284 v9fs_string_free(&vs->fullname);
3285 v9fs_string_free(&vs->name);
3286 qemu_free(vs);
3287}
3288
3289static void v9fs_mkdir_post_mkdir(V9fsState *s, V9fsMkState *vs, int err)
3290{
3291 if (err == -1) {
3292 err = -errno;
3293 goto out;
3294 }
3295
3296 err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
3297 v9fs_mkdir_post_lstat(s, vs, err);
3298 return;
3299out:
3300 complete_pdu(s, vs->pdu, err);
3301 v9fs_string_free(&vs->fullname);
3302 v9fs_string_free(&vs->name);
3303 qemu_free(vs);
3304}
3305
3306static void v9fs_mkdir(V9fsState *s, V9fsPDU *pdu)
3307{
3308 int32_t fid;
3309 V9fsMkState *vs;
3310 int err = 0;
3311 V9fsFidState *fidp;
3312 gid_t gid;
3313 int mode;
3314
3315 vs = qemu_malloc(sizeof(*vs));
3316 vs->pdu = pdu;
3317 vs->offset = 7;
3318
3319 v9fs_string_init(&vs->fullname);
3320 pdu_unmarshal(vs->pdu, vs->offset, "dsdd", &fid, &vs->name, &mode,
3321 &gid);
3322
3323 fidp = lookup_fid(s, fid);
3324 if (fidp == NULL) {
3325 err = -ENOENT;
3326 goto out;
3327 }
3328
3329 v9fs_string_sprintf(&vs->fullname, "%s/%s", fidp->path.data, vs->name.data);
3330 err = v9fs_do_mkdir(s, vs->fullname.data, mode, fidp->uid, gid);
3331 v9fs_mkdir_post_mkdir(s, vs, err);
3332 return;
3333
3334out:
3335 complete_pdu(s, vs->pdu, err);
3336 v9fs_string_free(&vs->fullname);
3337 v9fs_string_free(&vs->name);
3338 qemu_free(vs);
3339}
3340
fa32ef88
AK		 3341static void v9fs_post_xattr_getvalue(V9fsState *s, V9fsXattrState *vs, int err)
3342{
3343
3344 if (err < 0) {
3345 err = -errno;
3346 free_fid(s, vs->xattr_fidp->fid);
3347 goto out;
3348 }
3349 vs->offset += pdu_marshal(vs->pdu, vs->offset, "q", vs->size);
3350 err = vs->offset;
3351out:
3352 complete_pdu(s, vs->pdu, err);
3353 v9fs_string_free(&vs->name);
3354 qemu_free(vs);
3355 return;
3356}
3357
3358static void v9fs_post_xattr_check(V9fsState *s, V9fsXattrState *vs, ssize_t err)
3359{
3360 if (err < 0) {
3361 err = -errno;
3362 free_fid(s, vs->xattr_fidp->fid);
3363 goto out;
3364 }
3365 /*
3366 * Read the xattr value
3367 */
3368 vs->xattr_fidp->fs.xattr.len = vs->size;
3369 vs->xattr_fidp->fid_type = P9_FID_XATTR;
3370 vs->xattr_fidp->fs.xattr.copied_len = -1;
3371 if (vs->size) {
3372 vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3373 err = v9fs_do_lgetxattr(s, &vs->xattr_fidp->path,
3374 &vs->name, vs->xattr_fidp->fs.xattr.value,
3375 vs->xattr_fidp->fs.xattr.len);
3376 }
3377 v9fs_post_xattr_getvalue(s, vs, err);
3378 return;
3379out:
3380 complete_pdu(s, vs->pdu, err);
3381 v9fs_string_free(&vs->name);
3382 qemu_free(vs);
3383}
3384
3385static void v9fs_post_lxattr_getvalue(V9fsState *s,
3386 V9fsXattrState *vs, int err)
3387{
3388 if (err < 0) {
3389 err = -errno;
3390 free_fid(s, vs->xattr_fidp->fid);
3391 goto out;
3392 }
3393 vs->offset += pdu_marshal(vs->pdu, vs->offset, "q", vs->size);
3394 err = vs->offset;
3395out:
3396 complete_pdu(s, vs->pdu, err);
3397 v9fs_string_free(&vs->name);
3398 qemu_free(vs);
3399 return;
3400}
3401
3402static void v9fs_post_lxattr_check(V9fsState *s,
3403 V9fsXattrState *vs, ssize_t err)
3404{
3405 if (err < 0) {
3406 err = -errno;
3407 free_fid(s, vs->xattr_fidp->fid);
3408 goto out;
3409 }
3410 /*
3411 * Read the xattr value
3412 */
3413 vs->xattr_fidp->fs.xattr.len = vs->size;
3414 vs->xattr_fidp->fid_type = P9_FID_XATTR;
3415 vs->xattr_fidp->fs.xattr.copied_len = -1;
3416 if (vs->size) {
3417 vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3418 err = v9fs_do_llistxattr(s, &vs->xattr_fidp->path,
3419 vs->xattr_fidp->fs.xattr.value,
3420 vs->xattr_fidp->fs.xattr.len);
3421 }
3422 v9fs_post_lxattr_getvalue(s, vs, err);
3423 return;
3424out:
3425 complete_pdu(s, vs->pdu, err);
3426 v9fs_string_free(&vs->name);
3427 qemu_free(vs);
3428}
3429
3430static void v9fs_xattrwalk(V9fsState *s, V9fsPDU *pdu)
3431{
3432 ssize_t err = 0;
3433 V9fsXattrState *vs;
3434 int32_t fid, newfid;
3435
3436 vs = qemu_malloc(sizeof(*vs));
3437 vs->pdu = pdu;
3438 vs->offset = 7;
3439
3440 pdu_unmarshal(vs->pdu, vs->offset, "dds", &fid, &newfid, &vs->name);
3441 vs->file_fidp = lookup_fid(s, fid);
3442 if (vs->file_fidp == NULL) {
3443 err = -ENOENT;
3444 goto out;
3445 }
3446
3447 vs->xattr_fidp = alloc_fid(s, newfid);
3448 if (vs->xattr_fidp == NULL) {
3449 err = -EINVAL;
3450 goto out;
3451 }
3452
3453 v9fs_string_copy(&vs->xattr_fidp->path, &vs->file_fidp->path);
3454 if (vs->name.data[0] == 0) {
3455 /*
3456 * listxattr request. Get the size first
3457 */
3458 vs->size = v9fs_do_llistxattr(s, &vs->xattr_fidp->path,
3459 NULL, 0);
3460 if (vs->size < 0) {
3461 err = vs->size;
3462 }
3463 v9fs_post_lxattr_check(s, vs, err);
3464 return;
3465 } else {
3466 /*
3467 * specific xattr fid. We check for xattr
3468 * presence also collect the xattr size
3469 */
3470 vs->size = v9fs_do_lgetxattr(s, &vs->xattr_fidp->path,
3471 &vs->name, NULL, 0);
3472 if (vs->size < 0) {
3473 err = vs->size;
3474 }
3475 v9fs_post_xattr_check(s, vs, err);
3476 return;
3477 }
3478out:
3479 complete_pdu(s, vs->pdu, err);
3480 v9fs_string_free(&vs->name);
3481 qemu_free(vs);
3482}
3483
10b468bd
AK		 3484static void v9fs_xattrcreate(V9fsState *s, V9fsPDU *pdu)
3485{
3486 int flags;
3487 int32_t fid;
3488 ssize_t err = 0;
3489 V9fsXattrState *vs;
3490
3491 vs = qemu_malloc(sizeof(*vs));
3492 vs->pdu = pdu;
3493 vs->offset = 7;
3494
3495 pdu_unmarshal(vs->pdu, vs->offset, "dsqd",
3496 &fid, &vs->name, &vs->size, &flags);
3497
3498 vs->file_fidp = lookup_fid(s, fid);
3499 if (vs->file_fidp == NULL) {
3500 err = -EINVAL;
3501 goto out;
3502 }
3503
3504 /* Make the file fid point to xattr */
3505 vs->xattr_fidp = vs->file_fidp;
3506 vs->xattr_fidp->fid_type = P9_FID_XATTR;
3507 vs->xattr_fidp->fs.xattr.copied_len = 0;
3508 vs->xattr_fidp->fs.xattr.len = vs->size;
3509 vs->xattr_fidp->fs.xattr.flags = flags;
3510 v9fs_string_init(&vs->xattr_fidp->fs.xattr.name);
3511 v9fs_string_copy(&vs->xattr_fidp->fs.xattr.name, &vs->name);
9ed3ef26
AK		 3512 if (vs->size)
3513 vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3514 else
3515 vs->xattr_fidp->fs.xattr.value = NULL;
10b468bd
AK		 3516
3517out:
3518 complete_pdu(s, vs->pdu, err);
3519 v9fs_string_free(&vs->name);
3520 qemu_free(vs);
3521}
fa32ef88 3522
9f107513
AL		 3523typedef void (pdu_handler_t)(V9fsState *s, V9fsPDU *pdu);
3524
3525static pdu_handler_t *pdu_handlers[] = {
c18e2f94 3526 [P9_TREADDIR] = v9fs_readdir,
be940c87 3527 [P9_TSTATFS] = v9fs_statfs,
00ede4c2 3528 [P9_TGETATTR] = v9fs_getattr,
c79ce737 3529 [P9_TSETATTR] = v9fs_setattr,
fa32ef88 3530 [P9_TXATTRWALK] = v9fs_xattrwalk,
10b468bd 3531 [P9_TXATTRCREATE] = v9fs_xattrcreate,
5268cecc 3532 [P9_TMKNOD] = v9fs_mknod,
c7b4b0b3 3533 [P9_TRENAME] = v9fs_rename,
82cc3ee8 3534 [P9_TLOCK] = v9fs_lock,
8f354003 3535 [P9_TGETLOCK] = v9fs_getlock,
b67592ea 3536 [P9_TMKDIR] = v9fs_mkdir,
9f107513 3537 [P9_TVERSION] = v9fs_version,
771e9d4c 3538 [P9_TLOPEN] = v9fs_open,
9f107513
AL		 3539 [P9_TATTACH] = v9fs_attach,
3540 [P9_TSTAT] = v9fs_stat,
3541 [P9_TWALK] = v9fs_walk,
3542 [P9_TCLUNK] = v9fs_clunk,
b41e95d3 3543 [P9_TFSYNC] = v9fs_fsync,
9f107513
AL		 3544 [P9_TOPEN] = v9fs_open,
3545 [P9_TREAD] = v9fs_read,
3546#if 0
3547 [P9_TAUTH] = v9fs_auth,
3548#endif
3549 [P9_TFLUSH] = v9fs_flush,
b2c224be 3550 [P9_TLINK] = v9fs_link,
08c60fc9 3551 [P9_TSYMLINK] = v9fs_symlink,
9f107513 3552 [P9_TCREATE] = v9fs_create,
c1568af5 3553 [P9_TLCREATE] = v9fs_lcreate,
9f107513
AL		 3554 [P9_TWRITE] = v9fs_write,
3555 [P9_TWSTAT] = v9fs_wstat,
3556 [P9_TREMOVE] = v9fs_remove,
3557};
3558
3559static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
3560{
3561 pdu_handler_t *handler;
3562
3563 if (debug_9p_pdu) {
3564 pprint_pdu(pdu);
3565 }
3566
3567 BUG_ON(pdu->id >= ARRAY_SIZE(pdu_handlers));
3568
3569 handler = pdu_handlers[pdu->id];
3570 BUG_ON(handler == NULL);
3571
3572 handler(s, pdu);
3573}
3574
3575static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
3576{
3577 V9fsState *s = (V9fsState *)vdev;
3578 V9fsPDU *pdu;
3579 ssize_t len;
3580
3581 while ((pdu = alloc_pdu(s)) &&
3582 (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
3583 uint8_t *ptr;
3584
3585 BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
3586 BUG_ON(pdu->elem.out_sg[0].iov_len < 7);
3587
3588 ptr = pdu->elem.out_sg[0].iov_base;
3589
3590 memcpy(&pdu->size, ptr, 4);
3591 pdu->id = ptr[4];
3592 memcpy(&pdu->tag, ptr + 5, 2);
3593
3594 submit_pdu(s, pdu);
3595 }
3596
3597 free_pdu(s, pdu);
3598}
3599
3600static uint32_t virtio_9p_get_features(VirtIODevice *vdev, uint32_t features)
3601{
3602 features |= 1 << VIRTIO_9P_MOUNT_TAG;
3603 return features;
3604}
3605
3606static V9fsState *to_virtio_9p(VirtIODevice *vdev)
3607{
3608 return (V9fsState *)vdev;
3609}
3610
3611static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config)
3612{
3613 struct virtio_9p_config *cfg;
3614 V9fsState *s = to_virtio_9p(vdev);
3615
3616 cfg = qemu_mallocz(sizeof(struct virtio_9p_config) +
3617 s->tag_len);
3618 stw_raw(&cfg->tag_len, s->tag_len);
3619 memcpy(cfg->tag, s->tag, s->tag_len);
3620 memcpy(config, cfg, s->config_size);
3621 qemu_free(cfg);
3622}
3623
3624VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf)
3625 {
3626 V9fsState *s;
3627 int i, len;
3628 struct stat stat;
3629 FsTypeEntry *fse;
3630
3631
3632 s = (V9fsState *)virtio_common_init("virtio-9p",
3633 VIRTIO_ID_9P,
3634 sizeof(struct virtio_9p_config)+
3635 MAX_TAG_LEN,
3636 sizeof(V9fsState));
3637
3638 /* initialize pdu allocator */
3639 QLIST_INIT(&s->free_list);
3640 for (i = 0; i < (MAX_REQ - 1); i++) {
3641 QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next);
3642 }
3643
3644 s->vq = virtio_add_queue(&s->vdev, MAX_REQ, handle_9p_output);
3645
3646 fse = get_fsdev_fsentry(conf->fsdev_id);
3647
3648 if (!fse) {
3649 /* We don't have a fsdev identified by fsdev_id */
3650 fprintf(stderr, "Virtio-9p device couldn't find fsdev "
3651 "with the id %s\n", conf->fsdev_id);
3652 exit(1);
3653 }
3654
3655 if (!fse->path || !conf->tag) {
3656 /* we haven't specified a mount_tag or the path */
3657 fprintf(stderr, "fsdev with id %s needs path "
3658 "and Virtio-9p device needs mount_tag arguments\n",
3659 conf->fsdev_id);
3660 exit(1);
3661 }
3662
758e8e38
VJ		 3663 if (!strcmp(fse->security_model, "passthrough")) {
3664 /* Files on the Fileserver set to client user credentials */
3665 s->ctx.fs_sm = SM_PASSTHROUGH;
3666 } else if (!strcmp(fse->security_model, "mapped")) {
3667 /* Files on the fileserver are set to QEMU credentials.
3668 * Client user credentials are saved in extended attributes.
3669 */
3670 s->ctx.fs_sm = SM_MAPPED;
12848bfc
AK		 3671 } else if (!strcmp(fse->security_model, "none")) {
3672 /*
3673 * Files on the fileserver are set to QEMU credentials.
3674 */
3675 s->ctx.fs_sm = SM_NONE;
3676
758e8e38 3677 } else {
12848bfc
AK		 3678 fprintf(stderr, "Default to security_model=none. You may want"
3679 " enable advanced security model using "
9ce56db6
VJ		 3680 "security option:\n\t security_model=passthrough \n\t "
3681 "security_model=mapped\n");
12848bfc 3682 s->ctx.fs_sm = SM_NONE;
9ce56db6
VJ		 3683 }
3684
9f107513
AL		 3685 if (lstat(fse->path, &stat)) {
3686 fprintf(stderr, "share path %s does not exist\n", fse->path);
3687 exit(1);
3688 } else if (!S_ISDIR(stat.st_mode)) {
3689 fprintf(stderr, "share path %s is not a directory \n", fse->path);
3690 exit(1);
3691 }
3692
3693 s->ctx.fs_root = qemu_strdup(fse->path);
3694 len = strlen(conf->tag);
3695 if (len > MAX_TAG_LEN) {
3696 len = MAX_TAG_LEN;
3697 }
3698 /* s->tag is non-NULL terminated string */
3699 s->tag = qemu_malloc(len);
3700 memcpy(s->tag, conf->tag, len);
3701 s->tag_len = len;
3702 s->ctx.uid = -1;
3703
3704 s->ops = fse->ops;
3705 s->vdev.get_features = virtio_9p_get_features;
3706 s->config_size = sizeof(struct virtio_9p_config) +
3707 s->tag_len;
3708 s->vdev.get_config = virtio_9p_get_config;
3709
3710 return &s->vdev;
3711}
QEMU mirror