xref: /illumos-kvm-cmd/hw/virtio-9p.c (revision 68396ea9)
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 #include "virtio-9p-xattr.h"
21 
22 int debug_9p_pdu;
23 
24 enum {
25     Oread   = 0x00,
26     Owrite  = 0x01,
27     Ordwr   = 0x02,
28     Oexec   = 0x03,
29     Oexcl   = 0x04,
30     Otrunc  = 0x10,
31     Orexec  = 0x20,
32     Orclose = 0x40,
33     Oappend = 0x80,
34 };
35 
omode_to_uflags(int8_t mode)36 static int omode_to_uflags(int8_t mode)
37 {
38     int ret = 0;
39 
40     switch (mode & 3) {
41     case Oread:
42         ret = O_RDONLY;
43         break;
44     case Ordwr:
45         ret = O_RDWR;
46         break;
47     case Owrite:
48         ret = O_WRONLY;
49         break;
50     case Oexec:
51         ret = O_RDONLY;
52         break;
53     }
54 
55     if (mode & Otrunc) {
56         ret |= O_TRUNC;
57     }
58 
59     if (mode & Oappend) {
60         ret |= O_APPEND;
61     }
62 
63     if (mode & Oexcl) {
64         ret |= O_EXCL;
65     }
66 
67     return ret;
68 }
69 
cred_init(FsCred * credp)70 void cred_init(FsCred *credp)
71 {
72     credp->fc_uid = -1;
73     credp->fc_gid = -1;
74     credp->fc_mode = -1;
75     credp->fc_rdev = -1;
76 }
77 
v9fs_do_lstat(V9fsState * s,V9fsString * path,struct stat * stbuf)78 static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf)
79 {
80     return s->ops->lstat(&s->ctx, path->data, stbuf);
81 }
82 
v9fs_do_readlink(V9fsState * s,V9fsString * path,V9fsString * buf)83 static ssize_t v9fs_do_readlink(V9fsState *s, V9fsString *path, V9fsString *buf)
84 {
85     ssize_t len;
86 
87     buf->data = qemu_malloc(1024);
88 
89     len = s->ops->readlink(&s->ctx, path->data, buf->data, 1024 - 1);
90     if (len > -1) {
91         buf->size = len;
92         buf->data[len] = 0;
93     }
94 
95     return len;
96 }
97 
v9fs_do_close(V9fsState * s,int fd)98 static int v9fs_do_close(V9fsState *s, int fd)
99 {
100     return s->ops->close(&s->ctx, fd);
101 }
102 
v9fs_do_closedir(V9fsState * s,DIR * dir)103 static int v9fs_do_closedir(V9fsState *s, DIR *dir)
104 {
105     return s->ops->closedir(&s->ctx, dir);
106 }
107 
v9fs_do_open(V9fsState * s,V9fsString * path,int flags)108 static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags)
109 {
110     return s->ops->open(&s->ctx, path->data, flags);
111 }
112 
v9fs_do_opendir(V9fsState * s,V9fsString * path)113 static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path)
114 {
115     return s->ops->opendir(&s->ctx, path->data);
116 }
117 
v9fs_do_rewinddir(V9fsState * s,DIR * dir)118 static void v9fs_do_rewinddir(V9fsState *s, DIR *dir)
119 {
120     return s->ops->rewinddir(&s->ctx, dir);
121 }
122 
v9fs_do_telldir(V9fsState * s,DIR * dir)123 static off_t v9fs_do_telldir(V9fsState *s, DIR *dir)
124 {
125     return s->ops->telldir(&s->ctx, dir);
126 }
127 
v9fs_do_readdir(V9fsState * s,DIR * dir)128 static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir)
129 {
130     return s->ops->readdir(&s->ctx, dir);
131 }
132 
v9fs_do_seekdir(V9fsState * s,DIR * dir,off_t off)133 static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off)
134 {
135     return s->ops->seekdir(&s->ctx, dir, off);
136 }
137 
v9fs_do_preadv(V9fsState * s,int fd,const struct iovec * iov,int iovcnt,int64_t offset)138 static int v9fs_do_preadv(V9fsState *s, int fd, const struct iovec *iov,
139                             int iovcnt, int64_t offset)
140 {
141     return s->ops->preadv(&s->ctx, fd, iov, iovcnt, offset);
142 }
143 
v9fs_do_pwritev(V9fsState * s,int fd,const struct iovec * iov,int iovcnt,int64_t offset)144 static int v9fs_do_pwritev(V9fsState *s, int fd, const struct iovec *iov,
145                        int iovcnt, int64_t offset)
146 {
147     return s->ops->pwritev(&s->ctx, fd, iov, iovcnt, offset);
148 }
149 
v9fs_do_chmod(V9fsState * s,V9fsString * path,mode_t mode)150 static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
151 {
152     FsCred cred;
153     cred_init(&cred);
154     cred.fc_mode = mode;
155     return s->ops->chmod(&s->ctx, path->data, &cred);
156 }
157 
v9fs_do_mknod(V9fsState * s,char * name,mode_t mode,dev_t dev,uid_t uid,gid_t gid)158 static int v9fs_do_mknod(V9fsState *s, char *name,
159         mode_t mode, dev_t dev, uid_t uid, gid_t gid)
160 {
161     FsCred cred;
162     cred_init(&cred);
163     cred.fc_uid = uid;
164     cred.fc_gid = gid;
165     cred.fc_mode = mode;
166     cred.fc_rdev = dev;
167     return s->ops->mknod(&s->ctx, name, &cred);
168 }
169 
v9fs_do_mkdir(V9fsState * s,char * name,mode_t mode,uid_t uid,gid_t gid)170 static int v9fs_do_mkdir(V9fsState *s, char *name, mode_t mode,
171                 uid_t uid, gid_t gid)
172 {
173     FsCred cred;
174 
175     cred_init(&cred);
176     cred.fc_uid = uid;
177     cred.fc_gid = gid;
178     cred.fc_mode = mode;
179 
180     return s->ops->mkdir(&s->ctx, name, &cred);
181 }
182 
v9fs_do_fstat(V9fsState * s,int fd,struct stat * stbuf)183 static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
184 {
185     return s->ops->fstat(&s->ctx, fd, stbuf);
186 }
187 
v9fs_do_open2(V9fsState * s,char * fullname,uid_t uid,gid_t gid,int flags,int mode)188 static int v9fs_do_open2(V9fsState *s, char *fullname, uid_t uid, gid_t gid,
189         int flags, int mode)
190 {
191     FsCred cred;
192 
193     cred_init(&cred);
194     cred.fc_uid = uid;
195     cred.fc_gid = gid;
196     cred.fc_mode = mode & 07777;
197     flags = flags;
198 
199     return s->ops->open2(&s->ctx, fullname, flags, &cred);
200 }
201 
v9fs_do_symlink(V9fsState * s,V9fsFidState * fidp,const char * oldpath,const char * newpath,gid_t gid)202 static int v9fs_do_symlink(V9fsState *s, V9fsFidState *fidp,
203         const char *oldpath, const char *newpath, gid_t gid)
204 {
205     FsCred cred;
206     cred_init(&cred);
207     cred.fc_uid = fidp->uid;
208     cred.fc_gid = gid;
209     cred.fc_mode = 0777;
210 
211     return s->ops->symlink(&s->ctx, oldpath, newpath, &cred);
212 }
213 
v9fs_do_link(V9fsState * s,V9fsString * oldpath,V9fsString * newpath)214 static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
215 {
216     return s->ops->link(&s->ctx, oldpath->data, newpath->data);
217 }
218 
v9fs_do_truncate(V9fsState * s,V9fsString * path,off_t size)219 static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size)
220 {
221     return s->ops->truncate(&s->ctx, path->data, size);
222 }
223 
v9fs_do_rename(V9fsState * s,V9fsString * oldpath,V9fsString * newpath)224 static int v9fs_do_rename(V9fsState *s, V9fsString *oldpath,
225                             V9fsString *newpath)
226 {
227     return s->ops->rename(&s->ctx, oldpath->data, newpath->data);
228 }
229 
v9fs_do_chown(V9fsState * s,V9fsString * path,uid_t uid,gid_t gid)230 static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid)
231 {
232     FsCred cred;
233     cred_init(&cred);
234     cred.fc_uid = uid;
235     cred.fc_gid = gid;
236 
237     return s->ops->chown(&s->ctx, path->data, &cred);
238 }
239 
v9fs_do_utimensat(V9fsState * s,V9fsString * path,const struct timespec times[2])240 static int v9fs_do_utimensat(V9fsState *s, V9fsString *path,
241                                            const struct timespec times[2])
242 {
243     return s->ops->utimensat(&s->ctx, path->data, times);
244 }
245 
v9fs_do_remove(V9fsState * s,V9fsString * path)246 static int v9fs_do_remove(V9fsState *s, V9fsString *path)
247 {
248     return s->ops->remove(&s->ctx, path->data);
249 }
250 
v9fs_do_fsync(V9fsState * s,int fd,int datasync)251 static int v9fs_do_fsync(V9fsState *s, int fd, int datasync)
252 {
253     return s->ops->fsync(&s->ctx, fd, datasync);
254 }
255 
v9fs_do_statfs(V9fsState * s,V9fsString * path,struct statfs * stbuf)256 static int v9fs_do_statfs(V9fsState *s, V9fsString *path, struct statfs *stbuf)
257 {
258     return s->ops->statfs(&s->ctx, path->data, stbuf);
259 }
260 
v9fs_do_lgetxattr(V9fsState * s,V9fsString * path,V9fsString * xattr_name,void * value,size_t size)261 static ssize_t v9fs_do_lgetxattr(V9fsState *s, V9fsString *path,
262                              V9fsString *xattr_name,
263                              void *value, size_t size)
264 {
265     return s->ops->lgetxattr(&s->ctx, path->data,
266                              xattr_name->data, value, size);
267 }
268 
v9fs_do_llistxattr(V9fsState * s,V9fsString * path,void * value,size_t size)269 static ssize_t v9fs_do_llistxattr(V9fsState *s, V9fsString *path,
270                               void *value, size_t size)
271 {
272     return s->ops->llistxattr(&s->ctx, path->data,
273                               value, size);
274 }
275 
v9fs_do_lsetxattr(V9fsState * s,V9fsString * path,V9fsString * xattr_name,void * value,size_t size,int flags)276 static int v9fs_do_lsetxattr(V9fsState *s, V9fsString *path,
277                              V9fsString *xattr_name,
278                              void *value, size_t size, int flags)
279 {
280     return s->ops->lsetxattr(&s->ctx, path->data,
281                              xattr_name->data, value, size, flags);
282 }
283 
v9fs_do_lremovexattr(V9fsState * s,V9fsString * path,V9fsString * xattr_name)284 static int v9fs_do_lremovexattr(V9fsState *s, V9fsString *path,
285                                 V9fsString *xattr_name)
286 {
287     return s->ops->lremovexattr(&s->ctx, path->data,
288                                 xattr_name->data);
289 }
290 
291 
v9fs_string_init(V9fsString * str)292 static void v9fs_string_init(V9fsString *str)
293 {
294     str->data = NULL;
295     str->size = 0;
296 }
297 
v9fs_string_free(V9fsString * str)298 static void v9fs_string_free(V9fsString *str)
299 {
300     qemu_free(str->data);
301     str->data = NULL;
302     str->size = 0;
303 }
304 
v9fs_string_null(V9fsString * str)305 static void v9fs_string_null(V9fsString *str)
306 {
307     v9fs_string_free(str);
308 }
309 
number_to_string(void * arg,char type)310 static int number_to_string(void *arg, char type)
311 {
312     unsigned int ret = 0;
313 
314     switch (type) {
315     case 'u': {
316         unsigned int num = *(unsigned int *)arg;
317 
318         do {
319             ret++;
320             num = num/10;
321         } while (num);
322         break;
323     }
324     case 'U': {
325         unsigned long num = *(unsigned long *)arg;
326         do {
327             ret++;
328             num = num/10;
329         } while (num);
330         break;
331     }
332     default:
333         printf("Number_to_string: Unknown number format\n");
334         return -1;
335     }
336 
337     return ret;
338 }
339 
340 static int GCC_FMT_ATTR(2, 0)
v9fs_string_alloc_printf(char ** strp,const char * fmt,va_list ap)341 v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
342 {
343     va_list ap2;
344     char *iter = (char *)fmt;
345     int len = 0;
346     int nr_args = 0;
347     char *arg_char_ptr;
348     unsigned int arg_uint;
349     unsigned long arg_ulong;
350 
351     /* Find the number of %'s that denotes an argument */
352     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
353         nr_args++;
354         iter++;
355     }
356 
357     len = strlen(fmt) - 2*nr_args;
358 
359     if (!nr_args) {
360         goto alloc_print;
361     }
362 
363     va_copy(ap2, ap);
364 
365     iter = (char *)fmt;
366 
367     /* Now parse the format string */
368     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
369         iter++;
370         switch (*iter) {
371         case 'u':
372             arg_uint = va_arg(ap2, unsigned int);
373             len += number_to_string((void *)&arg_uint, 'u');
374             break;
375         case 'l':
376             if (*++iter == 'u') {
377                 arg_ulong = va_arg(ap2, unsigned long);
378                 len += number_to_string((void *)&arg_ulong, 'U');
379             } else {
380                 return -1;
381             }
382             break;
383         case 's':
384             arg_char_ptr = va_arg(ap2, char *);
385             len += strlen(arg_char_ptr);
386             break;
387         case 'c':
388             len += 1;
389             break;
390         default:
391             fprintf(stderr,
392 		    "v9fs_string_alloc_printf:Incorrect format %c", *iter);
393             return -1;
394         }
395         iter++;
396     }
397 
398 alloc_print:
399     *strp = qemu_malloc((len + 1) * sizeof(**strp));
400 
401     return vsprintf(*strp, fmt, ap);
402 }
403 
404 static void GCC_FMT_ATTR(2, 3)
v9fs_string_sprintf(V9fsString * str,const char * fmt,...)405 v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
406 {
407     va_list ap;
408     int err;
409 
410     v9fs_string_free(str);
411 
412     va_start(ap, fmt);
413     err = v9fs_string_alloc_printf(&str->data, fmt, ap);
414     BUG_ON(err == -1);
415     va_end(ap);
416 
417     str->size = err;
418 }
419 
v9fs_string_copy(V9fsString * lhs,V9fsString * rhs)420 static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
421 {
422     v9fs_string_free(lhs);
423     v9fs_string_sprintf(lhs, "%s", rhs->data);
424 }
425 
v9fs_string_size(V9fsString * str)426 static size_t v9fs_string_size(V9fsString *str)
427 {
428     return str->size;
429 }
430 
lookup_fid(V9fsState * s,int32_t fid)431 static V9fsFidState *lookup_fid(V9fsState *s, int32_t fid)
432 {
433     V9fsFidState *f;
434 
435     for (f = s->fid_list; f; f = f->next) {
436         if (f->fid == fid) {
437             return f;
438         }
439     }
440 
441     return NULL;
442 }
443 
alloc_fid(V9fsState * s,int32_t fid)444 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
445 {
446     V9fsFidState *f;
447 
448     f = lookup_fid(s, fid);
449     if (f) {
450         return NULL;
451     }
452 
453     f = qemu_mallocz(sizeof(V9fsFidState));
454 
455     f->fid = fid;
456     f->fid_type = P9_FID_NONE;
457 
458     f->next = s->fid_list;
459     s->fid_list = f;
460 
461     return f;
462 }
463 
v9fs_xattr_fid_clunk(V9fsState * s,V9fsFidState * fidp)464 static int v9fs_xattr_fid_clunk(V9fsState *s, V9fsFidState *fidp)
465 {
466     int retval = 0;
467 
468     if (fidp->fs.xattr.copied_len == -1) {
469         /* getxattr/listxattr fid */
470         goto free_value;
471     }
472     /*
473      * if this is fid for setxattr. clunk should
474      * result in setxattr localcall
475      */
476     if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
477         /* clunk after partial write */
478         retval = -EINVAL;
479         goto free_out;
480     }
481     if (fidp->fs.xattr.len) {
482         retval = v9fs_do_lsetxattr(s, &fidp->path, &fidp->fs.xattr.name,
483                                    fidp->fs.xattr.value,
484                                    fidp->fs.xattr.len,
485                                    fidp->fs.xattr.flags);
486     } else {
487         retval = v9fs_do_lremovexattr(s, &fidp->path, &fidp->fs.xattr.name);
488     }
489 free_out:
490     v9fs_string_free(&fidp->fs.xattr.name);
491 free_value:
492     if (fidp->fs.xattr.value) {
493         qemu_free(fidp->fs.xattr.value);
494     }
495     return retval;
496 }
497 
free_fid(V9fsState * s,int32_t fid)498 static int free_fid(V9fsState *s, int32_t fid)
499 {
500     int retval = 0;
501     V9fsFidState **fidpp, *fidp;
502 
503     for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
504         if ((*fidpp)->fid == fid) {
505             break;
506         }
507     }
508 
509     if (*fidpp == NULL) {
510         return -ENOENT;
511     }
512 
513     fidp = *fidpp;
514     *fidpp = fidp->next;
515 
516     if (fidp->fid_type == P9_FID_FILE) {
517         v9fs_do_close(s, fidp->fs.fd);
518     } else if (fidp->fid_type == P9_FID_DIR) {
519         v9fs_do_closedir(s, fidp->fs.dir);
520     } else if (fidp->fid_type == P9_FID_XATTR) {
521         retval = v9fs_xattr_fid_clunk(s, fidp);
522     }
523     v9fs_string_free(&fidp->path);
524     qemu_free(fidp);
525 
526     return retval;
527 }
528 
529 #define P9_QID_TYPE_DIR         0x80
530 #define P9_QID_TYPE_SYMLINK     0x02
531 
532 #define P9_STAT_MODE_DIR        0x80000000
533 #define P9_STAT_MODE_APPEND     0x40000000
534 #define P9_STAT_MODE_EXCL       0x20000000
535 #define P9_STAT_MODE_MOUNT      0x10000000
536 #define P9_STAT_MODE_AUTH       0x08000000
537 #define P9_STAT_MODE_TMP        0x04000000
538 #define P9_STAT_MODE_SYMLINK    0x02000000
539 #define P9_STAT_MODE_LINK       0x01000000
540 #define P9_STAT_MODE_DEVICE     0x00800000
541 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
542 #define P9_STAT_MODE_SOCKET     0x00100000
543 #define P9_STAT_MODE_SETUID     0x00080000
544 #define P9_STAT_MODE_SETGID     0x00040000
545 #define P9_STAT_MODE_SETVTX     0x00010000
546 
547 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR |          \
548                                 P9_STAT_MODE_SYMLINK |      \
549                                 P9_STAT_MODE_LINK |         \
550                                 P9_STAT_MODE_DEVICE |       \
551                                 P9_STAT_MODE_NAMED_PIPE |   \
552                                 P9_STAT_MODE_SOCKET)
553 
554 /* This is the algorithm from ufs in spfs */
stat_to_qid(const struct stat * stbuf,V9fsQID * qidp)555 static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)
556 {
557     size_t size;
558 
559     size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
560     memcpy(&qidp->path, &stbuf->st_ino, size);
561     qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
562     qidp->type = 0;
563     if (S_ISDIR(stbuf->st_mode)) {
564         qidp->type |= P9_QID_TYPE_DIR;
565     }
566     if (S_ISLNK(stbuf->st_mode)) {
567         qidp->type |= P9_QID_TYPE_SYMLINK;
568     }
569 }
570 
fid_to_qid(V9fsState * s,V9fsFidState * fidp,V9fsQID * qidp)571 static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp)
572 {
573     struct stat stbuf;
574     int err;
575 
576     err = v9fs_do_lstat(s, &fidp->path, &stbuf);
577     if (err) {
578         return err;
579     }
580 
581     stat_to_qid(&stbuf, qidp);
582     return 0;
583 }
584 
alloc_pdu(V9fsState * s)585 static V9fsPDU *alloc_pdu(V9fsState *s)
586 {
587     V9fsPDU *pdu = NULL;
588 
589     if (!QLIST_EMPTY(&s->free_list)) {
590 	pdu = QLIST_FIRST(&s->free_list);
591 	QLIST_REMOVE(pdu, next);
592     }
593     return pdu;
594 }
595 
free_pdu(V9fsState * s,V9fsPDU * pdu)596 static void free_pdu(V9fsState *s, V9fsPDU *pdu)
597 {
598     if (pdu) {
599 	QLIST_INSERT_HEAD(&s->free_list, pdu, next);
600     }
601 }
602 
pdu_packunpack(void * addr,struct iovec * sg,int sg_count,size_t offset,size_t size,int pack)603 size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
604                         size_t offset, size_t size, int pack)
605 {
606     int i = 0;
607     size_t copied = 0;
608 
609     for (i = 0; size && i < sg_count; i++) {
610         size_t len;
611         if (offset >= sg[i].iov_len) {
612             /* skip this sg */
613             offset -= sg[i].iov_len;
614             continue;
615         } else {
616             len = MIN(sg[i].iov_len - offset, size);
617             if (pack) {
618                 memcpy(sg[i].iov_base + offset, addr, len);
619             } else {
620                 memcpy(addr, sg[i].iov_base + offset, len);
621             }
622             size -= len;
623             copied += len;
624             addr += len;
625             if (size) {
626                 offset = 0;
627                 continue;
628             }
629         }
630     }
631 
632     return copied;
633 }
634 
pdu_unpack(void * dst,V9fsPDU * pdu,size_t offset,size_t size)635 static size_t pdu_unpack(void *dst, V9fsPDU *pdu, size_t offset, size_t size)
636 {
637     return pdu_packunpack(dst, pdu->elem.out_sg, pdu->elem.out_num,
638                          offset, size, 0);
639 }
640 
pdu_pack(V9fsPDU * pdu,size_t offset,const void * src,size_t size)641 static size_t pdu_pack(V9fsPDU *pdu, size_t offset, const void *src,
642                         size_t size)
643 {
644     return pdu_packunpack((void *)src, pdu->elem.in_sg, pdu->elem.in_num,
645                              offset, size, 1);
646 }
647 
pdu_copy_sg(V9fsPDU * pdu,size_t offset,int rx,struct iovec * sg)648 static int pdu_copy_sg(V9fsPDU *pdu, size_t offset, int rx, struct iovec *sg)
649 {
650     size_t pos = 0;
651     int i, j;
652     struct iovec *src_sg;
653     unsigned int num;
654 
655     if (rx) {
656         src_sg = pdu->elem.in_sg;
657         num = pdu->elem.in_num;
658     } else {
659         src_sg = pdu->elem.out_sg;
660         num = pdu->elem.out_num;
661     }
662 
663     j = 0;
664     for (i = 0; i < num; i++) {
665         if (offset <= pos) {
666             sg[j].iov_base = src_sg[i].iov_base;
667             sg[j].iov_len = src_sg[i].iov_len;
668             j++;
669         } else if (offset < (src_sg[i].iov_len + pos)) {
670             sg[j].iov_base = src_sg[i].iov_base;
671             sg[j].iov_len = src_sg[i].iov_len;
672             sg[j].iov_base += (offset - pos);
673             sg[j].iov_len -= (offset - pos);
674             j++;
675         }
676         pos += src_sg[i].iov_len;
677     }
678 
679     return j;
680 }
681 
pdu_unmarshal(V9fsPDU * pdu,size_t offset,const char * fmt,...)682 static size_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
683 {
684     size_t old_offset = offset;
685     va_list ap;
686     int i;
687 
688     va_start(ap, fmt);
689     for (i = 0; fmt[i]; i++) {
690         switch (fmt[i]) {
691         case 'b': {
692             uint8_t *valp = va_arg(ap, uint8_t *);
693             offset += pdu_unpack(valp, pdu, offset, sizeof(*valp));
694             break;
695         }
696         case 'w': {
697             uint16_t val, *valp;
698             valp = va_arg(ap, uint16_t *);
699             val = le16_to_cpupu(valp);
700             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
701             *valp = val;
702             break;
703         }
704         case 'd': {
705             uint32_t val, *valp;
706             valp = va_arg(ap, uint32_t *);
707             val = le32_to_cpupu(valp);
708             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
709             *valp = val;
710             break;
711         }
712         case 'q': {
713             uint64_t val, *valp;
714             valp = va_arg(ap, uint64_t *);
715             val = le64_to_cpup(valp);
716             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
717             *valp = val;
718             break;
719         }
720         case 'v': {
721             struct iovec *iov = va_arg(ap, struct iovec *);
722             int *iovcnt = va_arg(ap, int *);
723             *iovcnt = pdu_copy_sg(pdu, offset, 0, iov);
724             break;
725         }
726         case 's': {
727             V9fsString *str = va_arg(ap, V9fsString *);
728             offset += pdu_unmarshal(pdu, offset, "w", &str->size);
729             /* FIXME: sanity check str->size */
730             str->data = qemu_malloc(str->size + 1);
731             offset += pdu_unpack(str->data, pdu, offset, str->size);
732             str->data[str->size] = 0;
733             break;
734         }
735         case 'Q': {
736             V9fsQID *qidp = va_arg(ap, V9fsQID *);
737             offset += pdu_unmarshal(pdu, offset, "bdq",
738                         &qidp->type, &qidp->version, &qidp->path);
739             break;
740         }
741         case 'S': {
742             V9fsStat *statp = va_arg(ap, V9fsStat *);
743             offset += pdu_unmarshal(pdu, offset, "wwdQdddqsssssddd",
744                         &statp->size, &statp->type, &statp->dev,
745                         &statp->qid, &statp->mode, &statp->atime,
746                         &statp->mtime, &statp->length,
747                         &statp->name, &statp->uid, &statp->gid,
748                         &statp->muid, &statp->extension,
749                         &statp->n_uid, &statp->n_gid,
750                         &statp->n_muid);
751             break;
752         }
753         case 'I': {
754             V9fsIattr *iattr = va_arg(ap, V9fsIattr *);
755             offset += pdu_unmarshal(pdu, offset, "ddddqqqqq",
756                         &iattr->valid, &iattr->mode,
757                         &iattr->uid, &iattr->gid, &iattr->size,
758                         &iattr->atime_sec, &iattr->atime_nsec,
759                         &iattr->mtime_sec, &iattr->mtime_nsec);
760             break;
761         }
762         default:
763             break;
764         }
765     }
766 
767     va_end(ap);
768 
769     return offset - old_offset;
770 }
771 
pdu_marshal(V9fsPDU * pdu,size_t offset,const char * fmt,...)772 static size_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
773 {
774     size_t old_offset = offset;
775     va_list ap;
776     int i;
777 
778     va_start(ap, fmt);
779     for (i = 0; fmt[i]; i++) {
780         switch (fmt[i]) {
781         case 'b': {
782             uint8_t val = va_arg(ap, int);
783             offset += pdu_pack(pdu, offset, &val, sizeof(val));
784             break;
785         }
786         case 'w': {
787             uint16_t val;
788             cpu_to_le16w(&val, va_arg(ap, int));
789             offset += pdu_pack(pdu, offset, &val, sizeof(val));
790             break;
791         }
792         case 'd': {
793             uint32_t val;
794             cpu_to_le32w(&val, va_arg(ap, uint32_t));
795             offset += pdu_pack(pdu, offset, &val, sizeof(val));
796             break;
797         }
798         case 'q': {
799             uint64_t val;
800             cpu_to_le64w(&val, va_arg(ap, uint64_t));
801             offset += pdu_pack(pdu, offset, &val, sizeof(val));
802             break;
803         }
804         case 'v': {
805             struct iovec *iov = va_arg(ap, struct iovec *);
806             int *iovcnt = va_arg(ap, int *);
807             *iovcnt = pdu_copy_sg(pdu, offset, 1, iov);
808             break;
809         }
810         case 's': {
811             V9fsString *str = va_arg(ap, V9fsString *);
812             offset += pdu_marshal(pdu, offset, "w", str->size);
813             offset += pdu_pack(pdu, offset, str->data, str->size);
814             break;
815         }
816         case 'Q': {
817             V9fsQID *qidp = va_arg(ap, V9fsQID *);
818             offset += pdu_marshal(pdu, offset, "bdq",
819                         qidp->type, qidp->version, qidp->path);
820             break;
821         }
822         case 'S': {
823             V9fsStat *statp = va_arg(ap, V9fsStat *);
824             offset += pdu_marshal(pdu, offset, "wwdQdddqsssssddd",
825                         statp->size, statp->type, statp->dev,
826                         &statp->qid, statp->mode, statp->atime,
827                         statp->mtime, statp->length, &statp->name,
828                         &statp->uid, &statp->gid, &statp->muid,
829                         &statp->extension, statp->n_uid,
830                         statp->n_gid, statp->n_muid);
831             break;
832         }
833         case 'A': {
834             V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);
835             offset += pdu_marshal(pdu, offset, "qQdddqqqqqqqqqqqqqqq",
836                         statp->st_result_mask,
837                         &statp->qid, statp->st_mode,
838                         statp->st_uid, statp->st_gid,
839                         statp->st_nlink, statp->st_rdev,
840                         statp->st_size, statp->st_blksize, statp->st_blocks,
841                         statp->st_atime_sec, statp->st_atime_nsec,
842                         statp->st_mtime_sec, statp->st_mtime_nsec,
843                         statp->st_ctime_sec, statp->st_ctime_nsec,
844                         statp->st_btime_sec, statp->st_btime_nsec,
845                         statp->st_gen, statp->st_data_version);
846             break;
847         }
848         default:
849             break;
850         }
851     }
852     va_end(ap);
853 
854     return offset - old_offset;
855 }
856 
complete_pdu(V9fsState * s,V9fsPDU * pdu,ssize_t len)857 static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
858 {
859     int8_t id = pdu->id + 1; /* Response */
860 
861     if (len < 0) {
862         int err = -len;
863         len = 7;
864 
865         if (s->proto_version != V9FS_PROTO_2000L) {
866             V9fsString str;
867 
868             str.data = strerror(err);
869             str.size = strlen(str.data);
870 
871             len += pdu_marshal(pdu, len, "s", &str);
872             id = P9_RERROR;
873         }
874 
875         len += pdu_marshal(pdu, len, "d", err);
876 
877         if (s->proto_version == V9FS_PROTO_2000L) {
878             id = P9_RLERROR;
879         }
880     }
881 
882     /* fill out the header */
883     pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);
884 
885     /* keep these in sync */
886     pdu->size = len;
887     pdu->id = id;
888 
889     /* push onto queue and notify */
890     virtqueue_push(s->vq, &pdu->elem, len);
891 
892     /* FIXME: we should batch these completions */
893     virtio_notify(&s->vdev, s->vq);
894 
895     free_pdu(s, pdu);
896 }
897 
v9mode_to_mode(uint32_t mode,V9fsString * extension)898 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
899 {
900     mode_t ret;
901 
902     ret = mode & 0777;
903     if (mode & P9_STAT_MODE_DIR) {
904         ret |= S_IFDIR;
905     }
906 
907     if (mode & P9_STAT_MODE_SYMLINK) {
908         ret |= S_IFLNK;
909     }
910     if (mode & P9_STAT_MODE_SOCKET) {
911         ret |= S_IFSOCK;
912     }
913     if (mode & P9_STAT_MODE_NAMED_PIPE) {
914         ret |= S_IFIFO;
915     }
916     if (mode & P9_STAT_MODE_DEVICE) {
917         if (extension && extension->data[0] == 'c') {
918             ret |= S_IFCHR;
919         } else {
920             ret |= S_IFBLK;
921         }
922     }
923 
924     if (!(ret&~0777)) {
925         ret |= S_IFREG;
926     }
927 
928     if (mode & P9_STAT_MODE_SETUID) {
929         ret |= S_ISUID;
930     }
931     if (mode & P9_STAT_MODE_SETGID) {
932         ret |= S_ISGID;
933     }
934     if (mode & P9_STAT_MODE_SETVTX) {
935         ret |= S_ISVTX;
936     }
937 
938     return ret;
939 }
940 
donttouch_stat(V9fsStat * stat)941 static int donttouch_stat(V9fsStat *stat)
942 {
943     if (stat->type == -1 &&
944         stat->dev == -1 &&
945         stat->qid.type == -1 &&
946         stat->qid.version == -1 &&
947         stat->qid.path == -1 &&
948         stat->mode == -1 &&
949         stat->atime == -1 &&
950         stat->mtime == -1 &&
951         stat->length == -1 &&
952         !stat->name.size &&
953         !stat->uid.size &&
954         !stat->gid.size &&
955         !stat->muid.size &&
956         stat->n_uid == -1 &&
957         stat->n_gid == -1 &&
958         stat->n_muid == -1) {
959         return 1;
960     }
961 
962     return 0;
963 }
964 
v9fs_stat_free(V9fsStat * stat)965 static void v9fs_stat_free(V9fsStat *stat)
966 {
967     v9fs_string_free(&stat->name);
968     v9fs_string_free(&stat->uid);
969     v9fs_string_free(&stat->gid);
970     v9fs_string_free(&stat->muid);
971     v9fs_string_free(&stat->extension);
972 }
973 
stat_to_v9mode(const struct stat * stbuf)974 static uint32_t stat_to_v9mode(const struct stat *stbuf)
975 {
976     uint32_t mode;
977 
978     mode = stbuf->st_mode & 0777;
979     if (S_ISDIR(stbuf->st_mode)) {
980         mode |= P9_STAT_MODE_DIR;
981     }
982 
983     if (S_ISLNK(stbuf->st_mode)) {
984         mode |= P9_STAT_MODE_SYMLINK;
985     }
986 
987     if (S_ISSOCK(stbuf->st_mode)) {
988         mode |= P9_STAT_MODE_SOCKET;
989     }
990 
991     if (S_ISFIFO(stbuf->st_mode)) {
992         mode |= P9_STAT_MODE_NAMED_PIPE;
993     }
994 
995     if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
996         mode |= P9_STAT_MODE_DEVICE;
997     }
998 
999     if (stbuf->st_mode & S_ISUID) {
1000         mode |= P9_STAT_MODE_SETUID;
1001     }
1002 
1003     if (stbuf->st_mode & S_ISGID) {
1004         mode |= P9_STAT_MODE_SETGID;
1005     }
1006 
1007     if (stbuf->st_mode & S_ISVTX) {
1008         mode |= P9_STAT_MODE_SETVTX;
1009     }
1010 
1011     return mode;
1012 }
1013 
stat_to_v9stat(V9fsState * s,V9fsString * name,const struct stat * stbuf,V9fsStat * v9stat)1014 static int stat_to_v9stat(V9fsState *s, V9fsString *name,
1015                             const struct stat *stbuf,
1016                             V9fsStat *v9stat)
1017 {
1018     int err;
1019     const char *str;
1020 
1021     memset(v9stat, 0, sizeof(*v9stat));
1022 
1023     stat_to_qid(stbuf, &v9stat->qid);
1024     v9stat->mode = stat_to_v9mode(stbuf);
1025     v9stat->atime = stbuf->st_atime;
1026     v9stat->mtime = stbuf->st_mtime;
1027     v9stat->length = stbuf->st_size;
1028 
1029     v9fs_string_null(&v9stat->uid);
1030     v9fs_string_null(&v9stat->gid);
1031     v9fs_string_null(&v9stat->muid);
1032 
1033     v9stat->n_uid = stbuf->st_uid;
1034     v9stat->n_gid = stbuf->st_gid;
1035     v9stat->n_muid = 0;
1036 
1037     v9fs_string_null(&v9stat->extension);
1038 
1039     if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
1040         err = v9fs_do_readlink(s, name, &v9stat->extension);
1041         if (err == -1) {
1042             err = -errno;
1043             return err;
1044         }
1045         v9stat->extension.data[err] = 0;
1046         v9stat->extension.size = err;
1047     } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
1048         v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
1049                 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
1050                 major(stbuf->st_rdev), minor(stbuf->st_rdev));
1051     } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
1052         v9fs_string_sprintf(&v9stat->extension, "%s %lu",
1053                 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
1054     }
1055 
1056     str = strrchr(name->data, '/');
1057     if (str) {
1058         str += 1;
1059     } else {
1060         str = name->data;
1061     }
1062 
1063     v9fs_string_sprintf(&v9stat->name, "%s", str);
1064 
1065     v9stat->size = 61 +
1066         v9fs_string_size(&v9stat->name) +
1067         v9fs_string_size(&v9stat->uid) +
1068         v9fs_string_size(&v9stat->gid) +
1069         v9fs_string_size(&v9stat->muid) +
1070         v9fs_string_size(&v9stat->extension);
1071     return 0;
1072 }
1073 
1074 #define P9_STATS_MODE          0x00000001ULL
1075 #define P9_STATS_NLINK         0x00000002ULL
1076 #define P9_STATS_UID           0x00000004ULL
1077 #define P9_STATS_GID           0x00000008ULL
1078 #define P9_STATS_RDEV          0x00000010ULL
1079 #define P9_STATS_ATIME         0x00000020ULL
1080 #define P9_STATS_MTIME         0x00000040ULL
1081 #define P9_STATS_CTIME         0x00000080ULL
1082 #define P9_STATS_INO           0x00000100ULL
1083 #define P9_STATS_SIZE          0x00000200ULL
1084 #define P9_STATS_BLOCKS        0x00000400ULL
1085 
1086 #define P9_STATS_BTIME         0x00000800ULL
1087 #define P9_STATS_GEN           0x00001000ULL
1088 #define P9_STATS_DATA_VERSION  0x00002000ULL
1089 
1090 #define P9_STATS_BASIC         0x000007ffULL /* Mask for fields up to BLOCKS */
1091 #define P9_STATS_ALL           0x00003fffULL /* Mask for All fields above */
1092 
1093 
stat_to_v9stat_dotl(V9fsState * s,const struct stat * stbuf,V9fsStatDotl * v9lstat)1094 static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,
1095                             V9fsStatDotl *v9lstat)
1096 {
1097     memset(v9lstat, 0, sizeof(*v9lstat));
1098 
1099     v9lstat->st_mode = stbuf->st_mode;
1100     v9lstat->st_nlink = stbuf->st_nlink;
1101     v9lstat->st_uid = stbuf->st_uid;
1102     v9lstat->st_gid = stbuf->st_gid;
1103     v9lstat->st_rdev = stbuf->st_rdev;
1104     v9lstat->st_size = stbuf->st_size;
1105     v9lstat->st_blksize = stbuf->st_blksize;
1106     v9lstat->st_blocks = stbuf->st_blocks;
1107     v9lstat->st_atime_sec = stbuf->st_atime;
1108     v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
1109     v9lstat->st_mtime_sec = stbuf->st_mtime;
1110     v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
1111     v9lstat->st_ctime_sec = stbuf->st_ctime;
1112     v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
1113     /* Currently we only support BASIC fields in stat */
1114     v9lstat->st_result_mask = P9_STATS_BASIC;
1115 
1116     stat_to_qid(stbuf, &v9lstat->qid);
1117 }
1118 
adjust_sg(struct iovec * sg,int len,int * iovcnt)1119 static struct iovec *adjust_sg(struct iovec *sg, int len, int *iovcnt)
1120 {
1121     while (len && *iovcnt) {
1122         if (len < sg->iov_len) {
1123             sg->iov_len -= len;
1124             sg->iov_base += len;
1125             len = 0;
1126         } else {
1127             len -= sg->iov_len;
1128             sg++;
1129             *iovcnt -= 1;
1130         }
1131     }
1132 
1133     return sg;
1134 }
1135 
cap_sg(struct iovec * sg,int cap,int * cnt)1136 static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
1137 {
1138     int i;
1139     int total = 0;
1140 
1141     for (i = 0; i < *cnt; i++) {
1142         if ((total + sg[i].iov_len) > cap) {
1143             sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
1144             i++;
1145             break;
1146         }
1147         total += sg[i].iov_len;
1148     }
1149 
1150     *cnt = i;
1151 
1152     return sg;
1153 }
1154 
print_sg(struct iovec * sg,int cnt)1155 static void print_sg(struct iovec *sg, int cnt)
1156 {
1157     int i;
1158 
1159     printf("sg[%d]: {", cnt);
1160     for (i = 0; i < cnt; i++) {
1161         if (i) {
1162             printf(", ");
1163         }
1164         printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
1165     }
1166     printf("}\n");
1167 }
1168 
v9fs_fix_path(V9fsString * dst,V9fsString * src,int len)1169 static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
1170 {
1171     V9fsString str;
1172     v9fs_string_init(&str);
1173     v9fs_string_copy(&str, dst);
1174     v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
1175     v9fs_string_free(&str);
1176 }
1177 
v9fs_version(V9fsState * s,V9fsPDU * pdu)1178 static void v9fs_version(V9fsState *s, V9fsPDU *pdu)
1179 {
1180     V9fsString version;
1181     size_t offset = 7;
1182 
1183     pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
1184 
1185     if (!strcmp(version.data, "9P2000.u")) {
1186         s->proto_version = V9FS_PROTO_2000U;
1187     } else if (!strcmp(version.data, "9P2000.L")) {
1188         s->proto_version = V9FS_PROTO_2000L;
1189     } else {
1190         v9fs_string_sprintf(&version, "unknown");
1191     }
1192 
1193     offset += pdu_marshal(pdu, offset, "ds", s->msize, &version);
1194     complete_pdu(s, pdu, offset);
1195 
1196     v9fs_string_free(&version);
1197 }
1198 
v9fs_attach(V9fsState * s,V9fsPDU * pdu)1199 static void v9fs_attach(V9fsState *s, V9fsPDU *pdu)
1200 {
1201     int32_t fid, afid, n_uname;
1202     V9fsString uname, aname;
1203     V9fsFidState *fidp;
1204     V9fsQID qid;
1205     size_t offset = 7;
1206     ssize_t err;
1207 
1208     pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
1209 
1210     fidp = alloc_fid(s, fid);
1211     if (fidp == NULL) {
1212         err = -EINVAL;
1213         goto out;
1214     }
1215 
1216     fidp->uid = n_uname;
1217 
1218     v9fs_string_sprintf(&fidp->path, "%s", "/");
1219     err = fid_to_qid(s, fidp, &qid);
1220     if (err) {
1221         err = -EINVAL;
1222         free_fid(s, fid);
1223         goto out;
1224     }
1225 
1226     offset += pdu_marshal(pdu, offset, "Q", &qid);
1227 
1228     err = offset;
1229 out:
1230     complete_pdu(s, pdu, err);
1231     v9fs_string_free(&uname);
1232     v9fs_string_free(&aname);
1233 }
1234 
v9fs_stat_post_lstat(V9fsState * s,V9fsStatState * vs,int err)1235 static void v9fs_stat_post_lstat(V9fsState *s, V9fsStatState *vs, int err)
1236 {
1237     if (err == -1) {
1238         err = -errno;
1239         goto out;
1240     }
1241 
1242     err = stat_to_v9stat(s, &vs->fidp->path, &vs->stbuf, &vs->v9stat);
1243     if (err) {
1244         goto out;
1245     }
1246     vs->offset += pdu_marshal(vs->pdu, vs->offset, "wS", 0, &vs->v9stat);
1247     err = vs->offset;
1248 
1249 out:
1250     complete_pdu(s, vs->pdu, err);
1251     v9fs_stat_free(&vs->v9stat);
1252     qemu_free(vs);
1253 }
1254 
v9fs_stat(V9fsState * s,V9fsPDU * pdu)1255 static void v9fs_stat(V9fsState *s, V9fsPDU *pdu)
1256 {
1257     int32_t fid;
1258     V9fsStatState *vs;
1259     ssize_t err = 0;
1260 
1261     vs = qemu_malloc(sizeof(*vs));
1262     vs->pdu = pdu;
1263     vs->offset = 7;
1264 
1265     memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1266 
1267     pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
1268 
1269     vs->fidp = lookup_fid(s, fid);
1270     if (vs->fidp == NULL) {
1271         err = -ENOENT;
1272         goto out;
1273     }
1274 
1275     err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1276     v9fs_stat_post_lstat(s, vs, err);
1277     return;
1278 
1279 out:
1280     complete_pdu(s, vs->pdu, err);
1281     v9fs_stat_free(&vs->v9stat);
1282     qemu_free(vs);
1283 }
1284 
v9fs_getattr_post_lstat(V9fsState * s,V9fsStatStateDotl * vs,int err)1285 static void v9fs_getattr_post_lstat(V9fsState *s, V9fsStatStateDotl *vs,
1286                                                                 int err)
1287 {
1288     if (err == -1) {
1289         err = -errno;
1290         goto out;
1291     }
1292 
1293     stat_to_v9stat_dotl(s, &vs->stbuf, &vs->v9stat_dotl);
1294     vs->offset += pdu_marshal(vs->pdu, vs->offset, "A", &vs->v9stat_dotl);
1295     err = vs->offset;
1296 
1297 out:
1298     complete_pdu(s, vs->pdu, err);
1299     qemu_free(vs);
1300 }
1301 
v9fs_getattr(V9fsState * s,V9fsPDU * pdu)1302 static void v9fs_getattr(V9fsState *s, V9fsPDU *pdu)
1303 {
1304     int32_t fid;
1305     V9fsStatStateDotl *vs;
1306     ssize_t err = 0;
1307     V9fsFidState *fidp;
1308     uint64_t request_mask;
1309 
1310     vs = qemu_malloc(sizeof(*vs));
1311     vs->pdu = pdu;
1312     vs->offset = 7;
1313 
1314     memset(&vs->v9stat_dotl, 0, sizeof(vs->v9stat_dotl));
1315 
1316     pdu_unmarshal(vs->pdu, vs->offset, "dq", &fid, &request_mask);
1317 
1318     fidp = lookup_fid(s, fid);
1319     if (fidp == NULL) {
1320         err = -ENOENT;
1321         goto out;
1322     }
1323 
1324     /* Currently we only support BASIC fields in stat, so there is no
1325      * need to look at request_mask.
1326      */
1327     err = v9fs_do_lstat(s, &fidp->path, &vs->stbuf);
1328     v9fs_getattr_post_lstat(s, vs, err);
1329     return;
1330 
1331 out:
1332     complete_pdu(s, vs->pdu, err);
1333     qemu_free(vs);
1334 }
1335 
1336 /* From Linux kernel code */
1337 #define ATTR_MODE    (1 << 0)
1338 #define ATTR_UID     (1 << 1)
1339 #define ATTR_GID     (1 << 2)
1340 #define ATTR_SIZE    (1 << 3)
1341 #define ATTR_ATIME   (1 << 4)
1342 #define ATTR_MTIME   (1 << 5)
1343 #define ATTR_CTIME   (1 << 6)
1344 #define ATTR_MASK    127
1345 #define ATTR_ATIME_SET  (1 << 7)
1346 #define ATTR_MTIME_SET  (1 << 8)
1347 
v9fs_setattr_post_truncate(V9fsState * s,V9fsSetattrState * vs,int err)1348 static void v9fs_setattr_post_truncate(V9fsState *s, V9fsSetattrState *vs,
1349                                                                   int err)
1350 {
1351     if (err == -1) {
1352         err = -errno;
1353         goto out;
1354     }
1355     err = vs->offset;
1356 
1357 out:
1358     complete_pdu(s, vs->pdu, err);
1359     qemu_free(vs);
1360 }
1361 
v9fs_setattr_post_chown(V9fsState * s,V9fsSetattrState * vs,int err)1362 static void v9fs_setattr_post_chown(V9fsState *s, V9fsSetattrState *vs, int err)
1363 {
1364     if (err == -1) {
1365         err = -errno;
1366         goto out;
1367     }
1368 
1369     if (vs->v9iattr.valid & (ATTR_SIZE)) {
1370         err = v9fs_do_truncate(s, &vs->fidp->path, vs->v9iattr.size);
1371     }
1372     v9fs_setattr_post_truncate(s, vs, err);
1373     return;
1374 
1375 out:
1376     complete_pdu(s, vs->pdu, err);
1377     qemu_free(vs);
1378 }
1379 
v9fs_setattr_post_utimensat(V9fsState * s,V9fsSetattrState * vs,int err)1380 static void v9fs_setattr_post_utimensat(V9fsState *s, V9fsSetattrState *vs,
1381                                                                    int err)
1382 {
1383     if (err == -1) {
1384         err = -errno;
1385         goto out;
1386     }
1387 
1388     /* If the only valid entry in iattr is ctime we can call
1389      * chown(-1,-1) to update the ctime of the file
1390      */
1391     if ((vs->v9iattr.valid & (ATTR_UID | ATTR_GID)) ||
1392             ((vs->v9iattr.valid & ATTR_CTIME)
1393             && !((vs->v9iattr.valid & ATTR_MASK) & ~ATTR_CTIME))) {
1394         if (!(vs->v9iattr.valid & ATTR_UID)) {
1395             vs->v9iattr.uid = -1;
1396         }
1397         if (!(vs->v9iattr.valid & ATTR_GID)) {
1398             vs->v9iattr.gid = -1;
1399         }
1400         err = v9fs_do_chown(s, &vs->fidp->path, vs->v9iattr.uid,
1401                                                 vs->v9iattr.gid);
1402     }
1403     v9fs_setattr_post_chown(s, vs, err);
1404     return;
1405 
1406 out:
1407     complete_pdu(s, vs->pdu, err);
1408     qemu_free(vs);
1409 }
1410 
v9fs_setattr_post_chmod(V9fsState * s,V9fsSetattrState * vs,int err)1411 static void v9fs_setattr_post_chmod(V9fsState *s, V9fsSetattrState *vs, int err)
1412 {
1413     if (err == -1) {
1414         err = -errno;
1415         goto out;
1416     }
1417 
1418     if (vs->v9iattr.valid & (ATTR_ATIME | ATTR_MTIME)) {
1419         struct timespec times[2];
1420         if (vs->v9iattr.valid & ATTR_ATIME) {
1421             if (vs->v9iattr.valid & ATTR_ATIME_SET) {
1422                 times[0].tv_sec = vs->v9iattr.atime_sec;
1423                 times[0].tv_nsec = vs->v9iattr.atime_nsec;
1424             } else {
1425                 times[0].tv_nsec = UTIME_NOW;
1426             }
1427         } else {
1428             times[0].tv_nsec = UTIME_OMIT;
1429         }
1430 
1431         if (vs->v9iattr.valid & ATTR_MTIME) {
1432             if (vs->v9iattr.valid & ATTR_MTIME_SET) {
1433                 times[1].tv_sec = vs->v9iattr.mtime_sec;
1434                 times[1].tv_nsec = vs->v9iattr.mtime_nsec;
1435             } else {
1436                 times[1].tv_nsec = UTIME_NOW;
1437             }
1438         } else {
1439             times[1].tv_nsec = UTIME_OMIT;
1440         }
1441         err = v9fs_do_utimensat(s, &vs->fidp->path, times);
1442     }
1443     v9fs_setattr_post_utimensat(s, vs, err);
1444     return;
1445 
1446 out:
1447     complete_pdu(s, vs->pdu, err);
1448     qemu_free(vs);
1449 }
1450 
v9fs_setattr(V9fsState * s,V9fsPDU * pdu)1451 static void v9fs_setattr(V9fsState *s, V9fsPDU *pdu)
1452 {
1453     int32_t fid;
1454     V9fsSetattrState *vs;
1455     int err = 0;
1456 
1457     vs = qemu_malloc(sizeof(*vs));
1458     vs->pdu = pdu;
1459     vs->offset = 7;
1460 
1461     pdu_unmarshal(pdu, vs->offset, "dI", &fid, &vs->v9iattr);
1462 
1463     vs->fidp = lookup_fid(s, fid);
1464     if (vs->fidp == NULL) {
1465         err = -EINVAL;
1466         goto out;
1467     }
1468 
1469     if (vs->v9iattr.valid & ATTR_MODE) {
1470         err = v9fs_do_chmod(s, &vs->fidp->path, vs->v9iattr.mode);
1471     }
1472 
1473     v9fs_setattr_post_chmod(s, vs, err);
1474     return;
1475 
1476 out:
1477     complete_pdu(s, vs->pdu, err);
1478     qemu_free(vs);
1479 }
1480 
v9fs_walk_complete(V9fsState * s,V9fsWalkState * vs,int err)1481 static void v9fs_walk_complete(V9fsState *s, V9fsWalkState *vs, int err)
1482 {
1483     complete_pdu(s, vs->pdu, err);
1484 
1485     if (vs->nwnames) {
1486         for (vs->name_idx = 0; vs->name_idx < vs->nwnames; vs->name_idx++) {
1487             v9fs_string_free(&vs->wnames[vs->name_idx]);
1488         }
1489 
1490         qemu_free(vs->wnames);
1491         qemu_free(vs->qids);
1492     }
1493 }
1494 
v9fs_walk_marshal(V9fsWalkState * vs)1495 static void v9fs_walk_marshal(V9fsWalkState *vs)
1496 {
1497     int i;
1498     vs->offset = 7;
1499     vs->offset += pdu_marshal(vs->pdu, vs->offset, "w", vs->nwnames);
1500 
1501     for (i = 0; i < vs->nwnames; i++) {
1502         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qids[i]);
1503     }
1504 }
1505 
v9fs_walk_post_newfid_lstat(V9fsState * s,V9fsWalkState * vs,int err)1506 static void v9fs_walk_post_newfid_lstat(V9fsState *s, V9fsWalkState *vs,
1507                                                                 int err)
1508 {
1509     if (err == -1) {
1510         free_fid(s, vs->newfidp->fid);
1511         v9fs_string_free(&vs->path);
1512         err = -ENOENT;
1513         goto out;
1514     }
1515 
1516     stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1517 
1518     vs->name_idx++;
1519     if (vs->name_idx < vs->nwnames) {
1520         v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1521                                             vs->wnames[vs->name_idx].data);
1522         v9fs_string_copy(&vs->newfidp->path, &vs->path);
1523 
1524         err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1525         v9fs_walk_post_newfid_lstat(s, vs, err);
1526         return;
1527     }
1528 
1529     v9fs_string_free(&vs->path);
1530     v9fs_walk_marshal(vs);
1531     err = vs->offset;
1532 out:
1533     v9fs_walk_complete(s, vs, err);
1534 }
1535 
v9fs_walk_post_oldfid_lstat(V9fsState * s,V9fsWalkState * vs,int err)1536 static void v9fs_walk_post_oldfid_lstat(V9fsState *s, V9fsWalkState *vs,
1537         int err)
1538 {
1539     if (err == -1) {
1540         v9fs_string_free(&vs->path);
1541         err = -ENOENT;
1542         goto out;
1543     }
1544 
1545     stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1546     vs->name_idx++;
1547     if (vs->name_idx < vs->nwnames) {
1548 
1549         v9fs_string_sprintf(&vs->path, "%s/%s",
1550                 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1551         v9fs_string_copy(&vs->fidp->path, &vs->path);
1552 
1553         err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1554         v9fs_walk_post_oldfid_lstat(s, vs, err);
1555         return;
1556     }
1557 
1558     v9fs_string_free(&vs->path);
1559     v9fs_walk_marshal(vs);
1560     err = vs->offset;
1561 out:
1562     v9fs_walk_complete(s, vs, err);
1563 }
1564 
v9fs_walk(V9fsState * s,V9fsPDU * pdu)1565 static void v9fs_walk(V9fsState *s, V9fsPDU *pdu)
1566 {
1567     int32_t fid, newfid;
1568     V9fsWalkState *vs;
1569     int err = 0;
1570     int i;
1571 
1572     vs = qemu_malloc(sizeof(*vs));
1573     vs->pdu = pdu;
1574     vs->wnames = NULL;
1575     vs->qids = NULL;
1576     vs->offset = 7;
1577 
1578     vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "ddw", &fid,
1579                                             &newfid, &vs->nwnames);
1580 
1581     if (vs->nwnames) {
1582         vs->wnames = qemu_mallocz(sizeof(vs->wnames[0]) * vs->nwnames);
1583 
1584         vs->qids = qemu_mallocz(sizeof(vs->qids[0]) * vs->nwnames);
1585 
1586         for (i = 0; i < vs->nwnames; i++) {
1587             vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "s",
1588                                             &vs->wnames[i]);
1589         }
1590     }
1591 
1592     vs->fidp = lookup_fid(s, fid);
1593     if (vs->fidp == NULL) {
1594         err = -ENOENT;
1595         goto out;
1596     }
1597 
1598     /* FIXME: is this really valid? */
1599     if (fid == newfid) {
1600 
1601         BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
1602         v9fs_string_init(&vs->path);
1603         vs->name_idx = 0;
1604 
1605         if (vs->name_idx < vs->nwnames) {
1606             v9fs_string_sprintf(&vs->path, "%s/%s",
1607                 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1608             v9fs_string_copy(&vs->fidp->path, &vs->path);
1609 
1610             err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1611             v9fs_walk_post_oldfid_lstat(s, vs, err);
1612             return;
1613         }
1614     } else {
1615         vs->newfidp = alloc_fid(s, newfid);
1616         if (vs->newfidp == NULL) {
1617             err = -EINVAL;
1618             goto out;
1619         }
1620 
1621         vs->newfidp->uid = vs->fidp->uid;
1622         v9fs_string_init(&vs->path);
1623         vs->name_idx = 0;
1624         v9fs_string_copy(&vs->newfidp->path, &vs->fidp->path);
1625 
1626         if (vs->name_idx < vs->nwnames) {
1627             v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1628                                 vs->wnames[vs->name_idx].data);
1629             v9fs_string_copy(&vs->newfidp->path, &vs->path);
1630 
1631             err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1632             v9fs_walk_post_newfid_lstat(s, vs, err);
1633             return;
1634         }
1635     }
1636 
1637     v9fs_walk_marshal(vs);
1638     err = vs->offset;
1639 out:
1640     v9fs_walk_complete(s, vs, err);
1641 }
1642 
get_iounit(V9fsState * s,V9fsString * name)1643 static int32_t get_iounit(V9fsState *s, V9fsString *name)
1644 {
1645     struct statfs stbuf;
1646     int32_t iounit = 0;
1647 
1648     /*
1649      * iounit should be multiples of f_bsize (host filesystem block size
1650      * and as well as less than (client msize - P9_IOHDRSZ))
1651      */
1652     if (!v9fs_do_statfs(s, name, &stbuf)) {
1653         iounit = stbuf.f_bsize;
1654         iounit *= (s->msize - P9_IOHDRSZ)/stbuf.f_bsize;
1655     }
1656 
1657     if (!iounit) {
1658         iounit = s->msize - P9_IOHDRSZ;
1659     }
1660     return iounit;
1661 }
1662 
v9fs_open_post_opendir(V9fsState * s,V9fsOpenState * vs,int err)1663 static void v9fs_open_post_opendir(V9fsState *s, V9fsOpenState *vs, int err)
1664 {
1665     if (vs->fidp->fs.dir == NULL) {
1666         err = -errno;
1667         goto out;
1668     }
1669     vs->fidp->fid_type = P9_FID_DIR;
1670     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1671     err = vs->offset;
1672 out:
1673     complete_pdu(s, vs->pdu, err);
1674     qemu_free(vs);
1675 
1676 }
1677 
v9fs_open_post_getiounit(V9fsState * s,V9fsOpenState * vs)1678 static void v9fs_open_post_getiounit(V9fsState *s, V9fsOpenState *vs)
1679 {
1680     int err;
1681     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
1682     err = vs->offset;
1683     complete_pdu(s, vs->pdu, err);
1684     qemu_free(vs);
1685 }
1686 
v9fs_open_post_open(V9fsState * s,V9fsOpenState * vs,int err)1687 static void v9fs_open_post_open(V9fsState *s, V9fsOpenState *vs, int err)
1688 {
1689     if (vs->fidp->fs.fd == -1) {
1690         err = -errno;
1691         goto out;
1692     }
1693     vs->fidp->fid_type = P9_FID_FILE;
1694     vs->iounit = get_iounit(s, &vs->fidp->path);
1695     v9fs_open_post_getiounit(s, vs);
1696     return;
1697 out:
1698     complete_pdu(s, vs->pdu, err);
1699     qemu_free(vs);
1700 }
1701 
v9fs_open_post_lstat(V9fsState * s,V9fsOpenState * vs,int err)1702 static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err)
1703 {
1704     int flags;
1705 
1706     if (err) {
1707         err = -errno;
1708         goto out;
1709     }
1710 
1711     stat_to_qid(&vs->stbuf, &vs->qid);
1712 
1713     if (S_ISDIR(vs->stbuf.st_mode)) {
1714         vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fidp->path);
1715         v9fs_open_post_opendir(s, vs, err);
1716     } else {
1717         if (s->proto_version == V9FS_PROTO_2000L) {
1718             flags = vs->mode;
1719             flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
1720             /* Ignore direct disk access hint until the server supports it. */
1721             flags &= ~O_DIRECT;
1722         } else {
1723             flags = omode_to_uflags(vs->mode);
1724         }
1725         vs->fidp->fs.fd = v9fs_do_open(s, &vs->fidp->path, flags);
1726         v9fs_open_post_open(s, vs, err);
1727     }
1728     return;
1729 out:
1730     complete_pdu(s, vs->pdu, err);
1731     qemu_free(vs);
1732 }
1733 
v9fs_open(V9fsState * s,V9fsPDU * pdu)1734 static void v9fs_open(V9fsState *s, V9fsPDU *pdu)
1735 {
1736     int32_t fid;
1737     V9fsOpenState *vs;
1738     ssize_t err = 0;
1739 
1740     vs = qemu_malloc(sizeof(*vs));
1741     vs->pdu = pdu;
1742     vs->offset = 7;
1743     vs->mode = 0;
1744 
1745     if (s->proto_version == V9FS_PROTO_2000L) {
1746         pdu_unmarshal(vs->pdu, vs->offset, "dd", &fid, &vs->mode);
1747     } else {
1748         pdu_unmarshal(vs->pdu, vs->offset, "db", &fid, &vs->mode);
1749     }
1750 
1751     vs->fidp = lookup_fid(s, fid);
1752     if (vs->fidp == NULL) {
1753         err = -ENOENT;
1754         goto out;
1755     }
1756 
1757     BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
1758 
1759     err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1760 
1761     v9fs_open_post_lstat(s, vs, err);
1762     return;
1763 out:
1764     complete_pdu(s, pdu, err);
1765     qemu_free(vs);
1766 }
1767 
v9fs_post_lcreate(V9fsState * s,V9fsLcreateState * vs,int err)1768 static void v9fs_post_lcreate(V9fsState *s, V9fsLcreateState *vs, int err)
1769 {
1770     if (err == 0) {
1771         v9fs_string_copy(&vs->fidp->path, &vs->fullname);
1772         stat_to_qid(&vs->stbuf, &vs->qid);
1773         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid,
1774                 &vs->iounit);
1775         err = vs->offset;
1776     } else {
1777         vs->fidp->fid_type = P9_FID_NONE;
1778         err = -errno;
1779         if (vs->fidp->fs.fd > 0) {
1780             close(vs->fidp->fs.fd);
1781         }
1782     }
1783 
1784     complete_pdu(s, vs->pdu, err);
1785     v9fs_string_free(&vs->name);
1786     v9fs_string_free(&vs->fullname);
1787     qemu_free(vs);
1788 }
1789 
v9fs_lcreate_post_get_iounit(V9fsState * s,V9fsLcreateState * vs,int err)1790 static void v9fs_lcreate_post_get_iounit(V9fsState *s, V9fsLcreateState *vs,
1791         int err)
1792 {
1793     if (err) {
1794         err = -errno;
1795         goto out;
1796     }
1797     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
1798 
1799 out:
1800     v9fs_post_lcreate(s, vs, err);
1801 }
1802 
v9fs_lcreate_post_do_open2(V9fsState * s,V9fsLcreateState * vs,int err)1803 static void v9fs_lcreate_post_do_open2(V9fsState *s, V9fsLcreateState *vs,
1804         int err)
1805 {
1806     if (vs->fidp->fs.fd == -1) {
1807         err = -errno;
1808         goto out;
1809     }
1810     vs->fidp->fid_type = P9_FID_FILE;
1811     vs->iounit =  get_iounit(s, &vs->fullname);
1812     v9fs_lcreate_post_get_iounit(s, vs, err);
1813     return;
1814 
1815 out:
1816     v9fs_post_lcreate(s, vs, err);
1817 }
1818 
v9fs_lcreate(V9fsState * s,V9fsPDU * pdu)1819 static void v9fs_lcreate(V9fsState *s, V9fsPDU *pdu)
1820 {
1821     int32_t dfid, flags, mode;
1822     gid_t gid;
1823     V9fsLcreateState *vs;
1824     ssize_t err = 0;
1825 
1826     vs = qemu_malloc(sizeof(*vs));
1827     vs->pdu = pdu;
1828     vs->offset = 7;
1829 
1830     v9fs_string_init(&vs->fullname);
1831 
1832     pdu_unmarshal(vs->pdu, vs->offset, "dsddd", &dfid, &vs->name, &flags,
1833             &mode, &gid);
1834 
1835     vs->fidp = lookup_fid(s, dfid);
1836     if (vs->fidp == NULL) {
1837         err = -ENOENT;
1838         goto out;
1839     }
1840 
1841     v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
1842              vs->name.data);
1843 
1844     /* Ignore direct disk access hint until the server supports it. */
1845     flags &= ~O_DIRECT;
1846 
1847     vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
1848             gid, flags, mode);
1849     v9fs_lcreate_post_do_open2(s, vs, err);
1850     return;
1851 
1852 out:
1853     complete_pdu(s, vs->pdu, err);
1854     v9fs_string_free(&vs->name);
1855     qemu_free(vs);
1856 }
1857 
v9fs_post_do_fsync(V9fsState * s,V9fsPDU * pdu,int err)1858 static void v9fs_post_do_fsync(V9fsState *s, V9fsPDU *pdu, int err)
1859 {
1860     if (err == -1) {
1861         err = -errno;
1862     }
1863     complete_pdu(s, pdu, err);
1864 }
1865 
v9fs_fsync(V9fsState * s,V9fsPDU * pdu)1866 static void v9fs_fsync(V9fsState *s, V9fsPDU *pdu)
1867 {
1868     int32_t fid;
1869     size_t offset = 7;
1870     V9fsFidState *fidp;
1871     int datasync;
1872     int err;
1873 
1874     pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
1875     fidp = lookup_fid(s, fid);
1876     if (fidp == NULL) {
1877         err = -ENOENT;
1878         v9fs_post_do_fsync(s, pdu, err);
1879         return;
1880     }
1881     err = v9fs_do_fsync(s, fidp->fs.fd, datasync);
1882     v9fs_post_do_fsync(s, pdu, err);
1883 }
1884 
v9fs_clunk(V9fsState * s,V9fsPDU * pdu)1885 static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
1886 {
1887     int32_t fid;
1888     size_t offset = 7;
1889     int err;
1890 
1891     pdu_unmarshal(pdu, offset, "d", &fid);
1892 
1893     err = free_fid(s, fid);
1894     if (err < 0) {
1895         goto out;
1896     }
1897 
1898     offset = 7;
1899     err = offset;
1900 out:
1901     complete_pdu(s, pdu, err);
1902 }
1903 
1904 static void v9fs_read_post_readdir(V9fsState *, V9fsReadState *, ssize_t);
1905 
v9fs_read_post_seekdir(V9fsState * s,V9fsReadState * vs,ssize_t err)1906 static void v9fs_read_post_seekdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1907 {
1908     if (err) {
1909         goto out;
1910     }
1911     v9fs_stat_free(&vs->v9stat);
1912     v9fs_string_free(&vs->name);
1913     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1914     vs->offset += vs->count;
1915     err = vs->offset;
1916 out:
1917     complete_pdu(s, vs->pdu, err);
1918     qemu_free(vs);
1919     return;
1920 }
1921 
v9fs_read_post_dir_lstat(V9fsState * s,V9fsReadState * vs,ssize_t err)1922 static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs,
1923                                     ssize_t err)
1924 {
1925     if (err) {
1926         err = -errno;
1927         goto out;
1928     }
1929     err = stat_to_v9stat(s, &vs->name, &vs->stbuf, &vs->v9stat);
1930     if (err) {
1931         goto out;
1932     }
1933 
1934     vs->len = pdu_marshal(vs->pdu, vs->offset + 4 + vs->count, "S",
1935                             &vs->v9stat);
1936     if ((vs->len != (vs->v9stat.size + 2)) ||
1937             ((vs->count + vs->len) > vs->max_count)) {
1938         v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
1939         v9fs_read_post_seekdir(s, vs, err);
1940         return;
1941     }
1942     vs->count += vs->len;
1943     v9fs_stat_free(&vs->v9stat);
1944     v9fs_string_free(&vs->name);
1945     vs->dir_pos = vs->dent->d_off;
1946     vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
1947     v9fs_read_post_readdir(s, vs, err);
1948     return;
1949 out:
1950     v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
1951     v9fs_read_post_seekdir(s, vs, err);
1952     return;
1953 
1954 }
1955 
v9fs_read_post_readdir(V9fsState * s,V9fsReadState * vs,ssize_t err)1956 static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1957 {
1958     if (vs->dent) {
1959         memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1960         v9fs_string_init(&vs->name);
1961         v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data,
1962                             vs->dent->d_name);
1963         err = v9fs_do_lstat(s, &vs->name, &vs->stbuf);
1964         v9fs_read_post_dir_lstat(s, vs, err);
1965         return;
1966     }
1967 
1968     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1969     vs->offset += vs->count;
1970     err = vs->offset;
1971     complete_pdu(s, vs->pdu, err);
1972     qemu_free(vs);
1973     return;
1974 }
1975 
v9fs_read_post_telldir(V9fsState * s,V9fsReadState * vs,ssize_t err)1976 static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1977 {
1978     vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
1979     v9fs_read_post_readdir(s, vs, err);
1980     return;
1981 }
1982 
v9fs_read_post_rewinddir(V9fsState * s,V9fsReadState * vs,ssize_t err)1983 static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs,
1984                                        ssize_t err)
1985 {
1986     vs->dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
1987     v9fs_read_post_telldir(s, vs, err);
1988     return;
1989 }
1990 
v9fs_read_post_preadv(V9fsState * s,V9fsReadState * vs,ssize_t err)1991 static void v9fs_read_post_preadv(V9fsState *s, V9fsReadState *vs, ssize_t err)
1992 {
1993     if (err  < 0) {
1994         /* IO error return the error */
1995         err = -errno;
1996         goto out;
1997     }
1998     vs->total += vs->len;
1999     vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
2000     if (vs->total < vs->count && vs->len > 0) {
2001         do {
2002             if (0) {
2003                 print_sg(vs->sg, vs->cnt);
2004             }
2005             vs->len = v9fs_do_preadv(s, vs->fidp->fs.fd, vs->sg, vs->cnt,
2006                       vs->off);
2007             if (vs->len > 0) {
2008                 vs->off += vs->len;
2009             }
2010         } while (vs->len == -1 && errno == EINTR);
2011         if (vs->len == -1) {
2012             err  = -errno;
2013         }
2014         v9fs_read_post_preadv(s, vs, err);
2015         return;
2016     }
2017     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
2018     vs->offset += vs->count;
2019     err = vs->offset;
2020 
2021 out:
2022     complete_pdu(s, vs->pdu, err);
2023     qemu_free(vs);
2024 }
2025 
v9fs_xattr_read(V9fsState * s,V9fsReadState * vs)2026 static void v9fs_xattr_read(V9fsState *s, V9fsReadState *vs)
2027 {
2028     ssize_t err = 0;
2029     int read_count;
2030     int64_t xattr_len;
2031 
2032     xattr_len = vs->fidp->fs.xattr.len;
2033     read_count = xattr_len - vs->off;
2034     if (read_count > vs->count) {
2035         read_count = vs->count;
2036     } else if (read_count < 0) {
2037         /*
2038          * read beyond XATTR value
2039          */
2040         read_count = 0;
2041     }
2042     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", read_count);
2043     vs->offset += pdu_pack(vs->pdu, vs->offset,
2044                            ((char *)vs->fidp->fs.xattr.value) + vs->off,
2045                            read_count);
2046     err = vs->offset;
2047     complete_pdu(s, vs->pdu, err);
2048     qemu_free(vs);
2049 }
2050 
v9fs_read(V9fsState * s,V9fsPDU * pdu)2051 static void v9fs_read(V9fsState *s, V9fsPDU *pdu)
2052 {
2053     int32_t fid;
2054     V9fsReadState *vs;
2055     ssize_t err = 0;
2056 
2057     vs = qemu_malloc(sizeof(*vs));
2058     vs->pdu = pdu;
2059     vs->offset = 7;
2060     vs->total = 0;
2061     vs->len = 0;
2062     vs->count = 0;
2063 
2064     pdu_unmarshal(vs->pdu, vs->offset, "dqd", &fid, &vs->off, &vs->count);
2065 
2066     vs->fidp = lookup_fid(s, fid);
2067     if (vs->fidp == NULL) {
2068         err = -EINVAL;
2069         goto out;
2070     }
2071 
2072     if (vs->fidp->fid_type == P9_FID_DIR) {
2073         vs->max_count = vs->count;
2074         vs->count = 0;
2075         if (vs->off == 0) {
2076             v9fs_do_rewinddir(s, vs->fidp->fs.dir);
2077         }
2078         v9fs_read_post_rewinddir(s, vs, err);
2079         return;
2080     } else if (vs->fidp->fid_type == P9_FID_FILE) {
2081         vs->sg = vs->iov;
2082         pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt);
2083         vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2084         if (vs->total <= vs->count) {
2085             vs->len = v9fs_do_preadv(s, vs->fidp->fs.fd, vs->sg, vs->cnt,
2086                                     vs->off);
2087             if (vs->len > 0) {
2088                 vs->off += vs->len;
2089             }
2090             err = vs->len;
2091             v9fs_read_post_preadv(s, vs, err);
2092         }
2093         return;
2094     } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2095         v9fs_xattr_read(s, vs);
2096         return;
2097     } else {
2098         err = -EINVAL;
2099     }
2100 out:
2101     complete_pdu(s, pdu, err);
2102     qemu_free(vs);
2103 }
2104 
2105 typedef struct V9fsReadDirState {
2106     V9fsPDU *pdu;
2107     V9fsFidState *fidp;
2108     V9fsQID qid;
2109     off_t saved_dir_pos;
2110     struct dirent *dent;
2111     int32_t count;
2112     int32_t max_count;
2113     size_t offset;
2114     int64_t initial_offset;
2115     V9fsString name;
2116 } V9fsReadDirState;
2117 
v9fs_readdir_post_seekdir(V9fsState * s,V9fsReadDirState * vs)2118 static void v9fs_readdir_post_seekdir(V9fsState *s, V9fsReadDirState *vs)
2119 {
2120     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2121     vs->offset += vs->count;
2122     complete_pdu(s, vs->pdu, vs->offset);
2123     qemu_free(vs);
2124     return;
2125 }
2126 
2127 /* Size of each dirent on the wire: size of qid (13) + size of offset (8)
2128  * size of type (1) + size of name.size (2) + strlen(name.data)
2129  */
2130 #define V9_READDIR_DATA_SZ (24 + strlen(vs->name.data))
2131 
v9fs_readdir_post_readdir(V9fsState * s,V9fsReadDirState * vs)2132 static void v9fs_readdir_post_readdir(V9fsState *s, V9fsReadDirState *vs)
2133 {
2134     int len;
2135     size_t size;
2136 
2137     if (vs->dent) {
2138         v9fs_string_init(&vs->name);
2139         v9fs_string_sprintf(&vs->name, "%s", vs->dent->d_name);
2140 
2141         if ((vs->count + V9_READDIR_DATA_SZ) > vs->max_count) {
2142             /* Ran out of buffer. Set dir back to old position and return */
2143             v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->saved_dir_pos);
2144             v9fs_readdir_post_seekdir(s, vs);
2145             return;
2146         }
2147 
2148         /* Fill up just the path field of qid because the client uses
2149          * only that. To fill the entire qid structure we will have
2150          * to stat each dirent found, which is expensive
2151          */
2152         size = MIN(sizeof(vs->dent->d_ino), sizeof(vs->qid.path));
2153         memcpy(&vs->qid.path, &vs->dent->d_ino, size);
2154         /* Fill the other fields with dummy values */
2155         vs->qid.type = 0;
2156         vs->qid.version = 0;
2157 
2158         len = pdu_marshal(vs->pdu, vs->offset+4+vs->count, "Qqbs",
2159                               &vs->qid, vs->dent->d_off,
2160                               vs->dent->d_type, &vs->name);
2161         vs->count += len;
2162         v9fs_string_free(&vs->name);
2163         vs->saved_dir_pos = vs->dent->d_off;
2164         vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
2165         v9fs_readdir_post_readdir(s, vs);
2166         return;
2167     }
2168 
2169     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2170     vs->offset += vs->count;
2171     complete_pdu(s, vs->pdu, vs->offset);
2172     qemu_free(vs);
2173     return;
2174 }
2175 
v9fs_readdir_post_telldir(V9fsState * s,V9fsReadDirState * vs)2176 static void v9fs_readdir_post_telldir(V9fsState *s, V9fsReadDirState *vs)
2177 {
2178     vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
2179     v9fs_readdir_post_readdir(s, vs);
2180     return;
2181 }
2182 
v9fs_readdir_post_setdir(V9fsState * s,V9fsReadDirState * vs)2183 static void v9fs_readdir_post_setdir(V9fsState *s, V9fsReadDirState *vs)
2184 {
2185     vs->saved_dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
2186     v9fs_readdir_post_telldir(s, vs);
2187     return;
2188 }
2189 
v9fs_readdir(V9fsState * s,V9fsPDU * pdu)2190 static void v9fs_readdir(V9fsState *s, V9fsPDU *pdu)
2191 {
2192     int32_t fid;
2193     V9fsReadDirState *vs;
2194     ssize_t err = 0;
2195     size_t offset = 7;
2196 
2197     vs = qemu_malloc(sizeof(*vs));
2198     vs->pdu = pdu;
2199     vs->offset = 7;
2200     vs->count = 0;
2201 
2202     pdu_unmarshal(vs->pdu, offset, "dqd", &fid, &vs->initial_offset,
2203                                                         &vs->max_count);
2204 
2205     vs->fidp = lookup_fid(s, fid);
2206     if (vs->fidp == NULL || !(vs->fidp->fs.dir)) {
2207         err = -EINVAL;
2208         goto out;
2209     }
2210 
2211     if (vs->initial_offset == 0) {
2212         v9fs_do_rewinddir(s, vs->fidp->fs.dir);
2213     } else {
2214         v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->initial_offset);
2215     }
2216 
2217     v9fs_readdir_post_setdir(s, vs);
2218     return;
2219 
2220 out:
2221     complete_pdu(s, pdu, err);
2222     qemu_free(vs);
2223     return;
2224 }
2225 
v9fs_write_post_pwritev(V9fsState * s,V9fsWriteState * vs,ssize_t err)2226 static void v9fs_write_post_pwritev(V9fsState *s, V9fsWriteState *vs,
2227                                    ssize_t err)
2228 {
2229     if (err  < 0) {
2230         /* IO error return the error */
2231         err = -errno;
2232         goto out;
2233     }
2234     vs->total += vs->len;
2235     vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
2236     if (vs->total < vs->count && vs->len > 0) {
2237         do {
2238             if (0) {
2239                 print_sg(vs->sg, vs->cnt);
2240             }
2241             vs->len = v9fs_do_pwritev(s, vs->fidp->fs.fd, vs->sg, vs->cnt,
2242                       vs->off);
2243             if (vs->len > 0) {
2244                 vs->off += vs->len;
2245             }
2246         } while (vs->len == -1 && errno == EINTR);
2247         if (vs->len == -1) {
2248             err  = -errno;
2249         }
2250         v9fs_write_post_pwritev(s, vs, err);
2251         return;
2252     }
2253     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
2254     err = vs->offset;
2255 out:
2256     complete_pdu(s, vs->pdu, err);
2257     qemu_free(vs);
2258 }
2259 
v9fs_xattr_write(V9fsState * s,V9fsWriteState * vs)2260 static void v9fs_xattr_write(V9fsState *s, V9fsWriteState *vs)
2261 {
2262     int i, to_copy;
2263     ssize_t err = 0;
2264     int write_count;
2265     int64_t xattr_len;
2266 
2267     xattr_len = vs->fidp->fs.xattr.len;
2268     write_count = xattr_len - vs->off;
2269     if (write_count > vs->count) {
2270         write_count = vs->count;
2271     } else if (write_count < 0) {
2272         /*
2273          * write beyond XATTR value len specified in
2274          * xattrcreate
2275          */
2276         err = -ENOSPC;
2277         goto out;
2278     }
2279     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", write_count);
2280     err = vs->offset;
2281     vs->fidp->fs.xattr.copied_len += write_count;
2282     /*
2283      * Now copy the content from sg list
2284      */
2285     for (i = 0; i < vs->cnt; i++) {
2286         if (write_count > vs->sg[i].iov_len) {
2287             to_copy = vs->sg[i].iov_len;
2288         } else {
2289             to_copy = write_count;
2290         }
2291         memcpy((char *)vs->fidp->fs.xattr.value + vs->off,
2292                vs->sg[i].iov_base, to_copy);
2293         /* updating vs->off since we are not using below */
2294         vs->off += to_copy;
2295         write_count -= to_copy;
2296     }
2297 out:
2298     complete_pdu(s, vs->pdu, err);
2299     qemu_free(vs);
2300 }
2301 
v9fs_write(V9fsState * s,V9fsPDU * pdu)2302 static void v9fs_write(V9fsState *s, V9fsPDU *pdu)
2303 {
2304     int32_t fid;
2305     V9fsWriteState *vs;
2306     ssize_t err;
2307 
2308     vs = qemu_malloc(sizeof(*vs));
2309 
2310     vs->pdu = pdu;
2311     vs->offset = 7;
2312     vs->sg = vs->iov;
2313     vs->total = 0;
2314     vs->len = 0;
2315 
2316     pdu_unmarshal(vs->pdu, vs->offset, "dqdv", &fid, &vs->off, &vs->count,
2317                   vs->sg, &vs->cnt);
2318 
2319     vs->fidp = lookup_fid(s, fid);
2320     if (vs->fidp == NULL) {
2321         err = -EINVAL;
2322         goto out;
2323     }
2324 
2325     if (vs->fidp->fid_type == P9_FID_FILE) {
2326         if (vs->fidp->fs.fd == -1) {
2327             err = -EINVAL;
2328             goto out;
2329         }
2330     } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2331         /*
2332          * setxattr operation
2333          */
2334         v9fs_xattr_write(s, vs);
2335         return;
2336     } else {
2337         err = -EINVAL;
2338         goto out;
2339     }
2340     vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2341     if (vs->total <= vs->count) {
2342         vs->len = v9fs_do_pwritev(s, vs->fidp->fs.fd, vs->sg, vs->cnt, vs->off);
2343         if (vs->len > 0) {
2344             vs->off += vs->len;
2345         }
2346         err = vs->len;
2347         v9fs_write_post_pwritev(s, vs, err);
2348     }
2349     return;
2350 out:
2351     complete_pdu(s, vs->pdu, err);
2352     qemu_free(vs);
2353 }
2354 
v9fs_create_post_getiounit(V9fsState * s,V9fsCreateState * vs)2355 static void v9fs_create_post_getiounit(V9fsState *s, V9fsCreateState *vs)
2356 {
2357     int err;
2358     v9fs_string_copy(&vs->fidp->path, &vs->fullname);
2359     stat_to_qid(&vs->stbuf, &vs->qid);
2360 
2361     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
2362     err = vs->offset;
2363 
2364     complete_pdu(s, vs->pdu, err);
2365     v9fs_string_free(&vs->name);
2366     v9fs_string_free(&vs->extension);
2367     v9fs_string_free(&vs->fullname);
2368     qemu_free(vs);
2369 }
2370 
v9fs_post_create(V9fsState * s,V9fsCreateState * vs,int err)2371 static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
2372 {
2373     if (err == 0) {
2374         vs->iounit = get_iounit(s, &vs->fidp->path);
2375         v9fs_create_post_getiounit(s, vs);
2376         return;
2377     }
2378 
2379     complete_pdu(s, vs->pdu, err);
2380     v9fs_string_free(&vs->name);
2381     v9fs_string_free(&vs->extension);
2382     v9fs_string_free(&vs->fullname);
2383     qemu_free(vs);
2384 }
2385 
v9fs_create_post_perms(V9fsState * s,V9fsCreateState * vs,int err)2386 static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
2387 {
2388     if (err) {
2389         err = -errno;
2390     }
2391     v9fs_post_create(s, vs, err);
2392 }
2393 
v9fs_create_post_opendir(V9fsState * s,V9fsCreateState * vs,int err)2394 static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
2395                                                                     int err)
2396 {
2397     if (!vs->fidp->fs.dir) {
2398         err = -errno;
2399     }
2400     vs->fidp->fid_type = P9_FID_DIR;
2401     v9fs_post_create(s, vs, err);
2402 }
2403 
v9fs_create_post_dir_lstat(V9fsState * s,V9fsCreateState * vs,int err)2404 static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
2405                                                                     int err)
2406 {
2407     if (err) {
2408         err = -errno;
2409         goto out;
2410     }
2411 
2412     vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fullname);
2413     v9fs_create_post_opendir(s, vs, err);
2414     return;
2415 
2416 out:
2417     v9fs_post_create(s, vs, err);
2418 }
2419 
v9fs_create_post_mkdir(V9fsState * s,V9fsCreateState * vs,int err)2420 static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
2421 {
2422     if (err) {
2423         err = -errno;
2424         goto out;
2425     }
2426 
2427     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2428     v9fs_create_post_dir_lstat(s, vs, err);
2429     return;
2430 
2431 out:
2432     v9fs_post_create(s, vs, err);
2433 }
2434 
v9fs_create_post_fstat(V9fsState * s,V9fsCreateState * vs,int err)2435 static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
2436 {
2437     if (err) {
2438         vs->fidp->fid_type = P9_FID_NONE;
2439         close(vs->fidp->fs.fd);
2440         err = -errno;
2441     }
2442     v9fs_post_create(s, vs, err);
2443     return;
2444 }
2445 
v9fs_create_post_open2(V9fsState * s,V9fsCreateState * vs,int err)2446 static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
2447 {
2448     if (vs->fidp->fs.fd == -1) {
2449         err = -errno;
2450         goto out;
2451     }
2452     vs->fidp->fid_type = P9_FID_FILE;
2453     err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
2454     v9fs_create_post_fstat(s, vs, err);
2455 
2456     return;
2457 
2458 out:
2459     v9fs_post_create(s, vs, err);
2460 
2461 }
2462 
v9fs_create_post_lstat(V9fsState * s,V9fsCreateState * vs,int err)2463 static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
2464 {
2465 
2466     if (err == 0 || errno != ENOENT) {
2467         err = -errno;
2468         goto out;
2469     }
2470 
2471     if (vs->perm & P9_STAT_MODE_DIR) {
2472         err = v9fs_do_mkdir(s, vs->fullname.data, vs->perm & 0777,
2473                 vs->fidp->uid, -1);
2474         v9fs_create_post_mkdir(s, vs, err);
2475     } else if (vs->perm & P9_STAT_MODE_SYMLINK) {
2476         err = v9fs_do_symlink(s, vs->fidp, vs->extension.data,
2477                 vs->fullname.data, -1);
2478         v9fs_create_post_perms(s, vs, err);
2479     } else if (vs->perm & P9_STAT_MODE_LINK) {
2480         int32_t nfid = atoi(vs->extension.data);
2481         V9fsFidState *nfidp = lookup_fid(s, nfid);
2482         if (nfidp == NULL) {
2483             err = -errno;
2484             v9fs_post_create(s, vs, err);
2485         }
2486         err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
2487         v9fs_create_post_perms(s, vs, err);
2488     } else if (vs->perm & P9_STAT_MODE_DEVICE) {
2489         char ctype;
2490         uint32_t major, minor;
2491         mode_t nmode = 0;
2492 
2493         if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
2494                                         &minor) != 3) {
2495             err = -errno;
2496             v9fs_post_create(s, vs, err);
2497         }
2498 
2499         switch (ctype) {
2500         case 'c':
2501             nmode = S_IFCHR;
2502             break;
2503         case 'b':
2504             nmode = S_IFBLK;
2505             break;
2506         default:
2507             err = -EIO;
2508             v9fs_post_create(s, vs, err);
2509         }
2510 
2511         nmode |= vs->perm & 0777;
2512         err = v9fs_do_mknod(s, vs->fullname.data, nmode,
2513                 makedev(major, minor), vs->fidp->uid, -1);
2514         v9fs_create_post_perms(s, vs, err);
2515     } else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
2516         err = v9fs_do_mknod(s, vs->fullname.data, S_IFIFO | (vs->perm & 0777),
2517                 0, vs->fidp->uid, -1);
2518         v9fs_post_create(s, vs, err);
2519     } else if (vs->perm & P9_STAT_MODE_SOCKET) {
2520         err = v9fs_do_mknod(s, vs->fullname.data, S_IFSOCK | (vs->perm & 0777),
2521                 0, vs->fidp->uid, -1);
2522         v9fs_post_create(s, vs, err);
2523     } else {
2524         vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
2525                 -1, omode_to_uflags(vs->mode)|O_CREAT, vs->perm);
2526 
2527         v9fs_create_post_open2(s, vs, err);
2528     }
2529 
2530     return;
2531 
2532 out:
2533     v9fs_post_create(s, vs, err);
2534 }
2535 
v9fs_create(V9fsState * s,V9fsPDU * pdu)2536 static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
2537 {
2538     int32_t fid;
2539     V9fsCreateState *vs;
2540     int err = 0;