]> git.proxmox.com Git - qemu.git/blame - hw/9pfs/virtio-9p.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'kwolf/for-anthony' into staging
[qemu.git] / hw / 9pfs / 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
873c3213
SW		 14#include "hw/virtio.h"
15#include "hw/pc.h"
9f107513 16#include "qemu_socket.h"
873c3213 17#include "hw/virtio-pci.h"
9f107513
AL		 18#include "virtio-9p.h"
19#include "fsdev/qemu-fsdev.h"
20#include "virtio-9p-debug.h"
fc22118d 21#include "virtio-9p-xattr.h"
ff06030f 22#include "virtio-9p-coth.h"
9f107513 23
9f107513 24int debug_9p_pdu;
7a462745
AK		 25int open_fd_hw;
26int total_open_fd;
27static int open_fd_rc;
9f107513 28
fac4f111
VJJ		 29enum {
30 Oread = 0x00,
31 Owrite = 0x01,
32 Ordwr = 0x02,
33 Oexec = 0x03,
34 Oexcl = 0x04,
35 Otrunc = 0x10,
36 Orexec = 0x20,
37 Orclose = 0x40,
38 Oappend = 0x80,
39};
40
41static int omode_to_uflags(int8_t mode)
42{
43 int ret = 0;
44
45 switch (mode & 3) {
46 case Oread:
47 ret = O_RDONLY;
48 break;
49 case Ordwr:
50 ret = O_RDWR;
51 break;
52 case Owrite:
53 ret = O_WRONLY;
54 break;
55 case Oexec:
56 ret = O_RDONLY;
57 break;
58 }
59
60 if (mode & Otrunc) {
61 ret |= O_TRUNC;
62 }
63
64 if (mode & Oappend) {
65 ret |= O_APPEND;
66 }
67
68 if (mode & Oexcl) {
69 ret |= O_EXCL;
70 }
71
72 return ret;
73}
74
758e8e38 75void cred_init(FsCred *credp)
131dcb25 76{
758e8e38
VJJ		 77 credp->fc_uid = -1;
78 credp->fc_gid = -1;
79 credp->fc_mode = -1;
80 credp->fc_rdev = -1;
131dcb25
AL		 81}
82
a03f7874
AL		 83static void v9fs_string_init(V9fsString *str)
84{
85 str->data = NULL;
86 str->size = 0;
87}
88
89static void v9fs_string_free(V9fsString *str)
90{
7267c094 91 g_free(str->data);
a03f7874
AL		 92 str->data = NULL;
93 str->size = 0;
94}
95
96static void v9fs_string_null(V9fsString *str)
97{
98 v9fs_string_free(str);
99}
100
101static int number_to_string(void *arg, char type)
102{
103 unsigned int ret = 0;
104
105 switch (type) {
106 case 'u': {
107 unsigned int num = *(unsigned int *)arg;
108
109 do {
110 ret++;
111 num = num/10;
112 } while (num);
113 break;
114 }
45b23ff8
VJJ		 115 case 'U': {
116 unsigned long num = *(unsigned long *)arg;
117 do {
118 ret++;
119 num = num/10;
120 } while (num);
121 break;
122 }
a03f7874
AL		 123 default:
124 printf("Number_to_string: Unknown number format\n");
125 return -1;
126 }
127
128 return ret;
129}
130
c9ba47dc
SW		 131static int GCC_FMT_ATTR(2, 0)
132v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
a03f7874
AL		 133{
134 va_list ap2;
135 char *iter = (char *)fmt;
136 int len = 0;
137 int nr_args = 0;
138 char *arg_char_ptr;
139 unsigned int arg_uint;
45b23ff8 140 unsigned long arg_ulong;
a03f7874
AL		 141
142 /* Find the number of %'s that denotes an argument */
143 for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
144 nr_args++;
145 iter++;
146 }
147
148 len = strlen(fmt) - 2*nr_args;
149
150 if (!nr_args) {
151 goto alloc_print;
152 }
153
154 va_copy(ap2, ap);
155
156 iter = (char *)fmt;
157
158 /* Now parse the format string */
159 for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
160 iter++;
161 switch (*iter) {
162 case 'u':
163 arg_uint = va_arg(ap2, unsigned int);
164 len += number_to_string((void *)&arg_uint, 'u');
165 break;
45b23ff8
VJJ		 166 case 'l':
167 if (*++iter == 'u') {
168 arg_ulong = va_arg(ap2, unsigned long);
169 len += number_to_string((void *)&arg_ulong, 'U');
170 } else {
171 return -1;
172 }
173 break;
a03f7874
AL		 174 case 's':
175 arg_char_ptr = va_arg(ap2, char *);
176 len += strlen(arg_char_ptr);
177 break;
178 case 'c':
179 len += 1;
180 break;
181 default:
182 fprintf(stderr,
183 "v9fs_string_alloc_printf:Incorrect format %c", *iter);
184 return -1;
185 }
186 iter++;
187 }
188
189alloc_print:
7267c094 190 *strp = g_malloc((len + 1) * sizeof(**strp));
a03f7874
AL		 191
192 return vsprintf(*strp, fmt, ap);
193}
194
c9ba47dc
SW		 195static void GCC_FMT_ATTR(2, 3)
196v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
a03f7874
AL		 197{
198 va_list ap;
199 int err;
200
201 v9fs_string_free(str);
202
203 va_start(ap, fmt);
204 err = v9fs_string_alloc_printf(&str->data, fmt, ap);
205 BUG_ON(err == -1);
206 va_end(ap);
207
208 str->size = err;
209}
210
211static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
212{
213 v9fs_string_free(lhs);
214 v9fs_string_sprintf(lhs, "%s", rhs->data);
215}
216
936532a4
MN		 217/*
218 * Return TRUE if s1 is an ancestor of s2.
219 *
220 * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".
221 * As a special case, We treat s1 as ancestor of s2 if they are same!
222 */
223static int v9fs_path_is_ancestor(V9fsString *s1, V9fsString *s2)
224{
225 if (!strncmp(s1->data, s2->data, s1->size)) {
226 if (s2->data[s1->size] == '\0' || s2->data[s1->size] == '/') {
227 return 1;
228 }
229 }
230 return 0;
231}
232
a03f7874
AL		 233static size_t v9fs_string_size(V9fsString *str)
234{
235 return str->size;
236}
237
b9cb88b0
AK		 238/*
239 * returns 0 if fid got re-opened, 1 if not, < 0 on error */
240static int v9fs_reopen_fid(V9fsState *s, V9fsFidState *f)
241{
242 int err = 1;
243 if (f->fid_type == P9_FID_FILE) {
244 if (f->fs.fd == -1) {
245 do {
246 err = v9fs_co_open(s, f, f->open_flags);
247 } while (err == -EINTR);
248 }
249 } else if (f->fid_type == P9_FID_DIR) {
250 if (f->fs.dir == NULL) {
251 do {
252 err = v9fs_co_opendir(s, f);
253 } while (err == -EINTR);
254 }
255 }
256 return err;
257}
258
84dfb926 259static V9fsFidState *get_fid(V9fsState *s, int32_t fid)
286d5652 260{
7a462745 261 int err;
286d5652
AL		 262 V9fsFidState *f;
263
264 for (f = s->fid_list; f; f = f->next) {
84dfb926 265 BUG_ON(f->clunked);
286d5652 266 if (f->fid == fid) {
7a462745
AK		 267 /*
268 * Update the fid ref upfront so that
269 * we don't get reclaimed when we yield
270 * in open later.
271 */
84dfb926 272 f->ref++;
7a462745
AK		 273 /*
274 * check whether we need to reopen the
275 * file. We might have closed the fd
276 * while trying to free up some file
277 * descriptors.
278 */
b9cb88b0
AK		 279 err = v9fs_reopen_fid(s, f);
280 if (err < 0) {
281 f->ref--;
282 return NULL;
283 }
7a462745
AK		 284 /*
285 * Mark the fid as referenced so that the LRU
286 * reclaim won't close the file descriptor
287 */
288 f->flags |= FID_REFERENCED;
286d5652
AL		 289 return f;
290 }
291 }
286d5652
AL		 292 return NULL;
293}
294
295static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
296{
297 V9fsFidState *f;
298
84dfb926
AK		 299 for (f = s->fid_list; f; f = f->next) {
300 /* If fid is already there return NULL */
301 BUG_ON(f->clunked);
302 if (f->fid == fid) {
303 return NULL;
304 }
286d5652 305 }
7267c094 306 f = g_malloc0(sizeof(V9fsFidState));
286d5652 307 f->fid = fid;
d62dbb51 308 f->fid_type = P9_FID_NONE;
84dfb926 309 f->ref = 1;
7a462745
AK		 310 /*
311 * Mark the fid as referenced so that the LRU
312 * reclaim won't close the file descriptor
313 */
314 f->flags |= FID_REFERENCED;
286d5652
AL		 315 f->next = s->fid_list;
316 s->fid_list = f;
317
318 return f;
319}
320
10b468bd
AK		 321static int v9fs_xattr_fid_clunk(V9fsState *s, V9fsFidState *fidp)
322{
323 int retval = 0;
324
325 if (fidp->fs.xattr.copied_len == -1) {
326 /* getxattr/listxattr fid */
327 goto free_value;
328 }
329 /*
330 * if this is fid for setxattr. clunk should
331 * result in setxattr localcall
332 */
333 if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
334 /* clunk after partial write */
335 retval = -EINVAL;
336 goto free_out;
337 }
9ed3ef26 338 if (fidp->fs.xattr.len) {
c540ee51 339 retval = v9fs_co_lsetxattr(s, &fidp->path, &fidp->fs.xattr.name,
9ed3ef26
AK		 340 fidp->fs.xattr.value,
341 fidp->fs.xattr.len,
342 fidp->fs.xattr.flags);
343 } else {
c540ee51 344 retval = v9fs_co_lremovexattr(s, &fidp->path, &fidp->fs.xattr.name);
9ed3ef26 345 }
10b468bd
AK		 346free_out:
347 v9fs_string_free(&fidp->fs.xattr.name);
348free_value:
349 if (fidp->fs.xattr.value) {
7267c094 350 g_free(fidp->fs.xattr.value);
10b468bd
AK		 351 }
352 return retval;
353}
354
84dfb926 355static int free_fid(V9fsState *s, V9fsFidState *fidp)
286d5652 356{
10b468bd 357 int retval = 0;
84dfb926
AK		 358
359 if (fidp->fid_type == P9_FID_FILE) {
7a462745
AK		 360 /* If we reclaimed the fd no need to close */
361 if (fidp->fs.fd != -1) {
362 retval = v9fs_co_close(s, fidp->fs.fd);
363 }
84dfb926 364 } else if (fidp->fid_type == P9_FID_DIR) {
95f65511
AK		 365 if (fidp->fs.dir != NULL) {
366 retval = v9fs_co_closedir(s, fidp->fs.dir);
367 }
84dfb926
AK		 368 } else if (fidp->fid_type == P9_FID_XATTR) {
369 retval = v9fs_xattr_fid_clunk(s, fidp);
370 }
371 v9fs_string_free(&fidp->path);
372 g_free(fidp);
373 return retval;
374}
375
376static void put_fid(V9fsState *s, V9fsFidState *fidp)
377{
378 BUG_ON(!fidp->ref);
379 fidp->ref--;
7a462745
AK		 380 /*
381 * Don't free the fid if it is in reclaim list
382 */
84dfb926
AK		 383 if (!fidp->ref && fidp->clunked) {
384 free_fid(s, fidp);
385 }
386}
387
388static int clunk_fid(V9fsState *s, int32_t fid)
389{
286d5652
AL		 390 V9fsFidState **fidpp, *fidp;
391
392 for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
393 if ((*fidpp)->fid == fid) {
394 break;
395 }
396 }
397
398 if (*fidpp == NULL) {
399 return -ENOENT;
400 }
286d5652
AL		 401 fidp = *fidpp;
402 *fidpp = fidp->next;
84dfb926
AK		 403 fidp->clunked = 1;
404 return 0;
286d5652
AL		 405}
406
7a462745
AK		 407void v9fs_reclaim_fd(V9fsState *s)
408{
409 int reclaim_count = 0;
410 V9fsFidState *f, *reclaim_list = NULL;
411
412 for (f = s->fid_list; f; f = f->next) {
413 /*
414 * Unlink fids cannot be reclaimed. Check
415 * for them and skip them. Also skip fids
416 * currently being operated on.
417 */
418 if (f->ref || f->flags & FID_NON_RECLAIMABLE) {
419 continue;
420 }
421 /*
422 * if it is a recently referenced fid
423 * we leave the fid untouched and clear the
424 * reference bit. We come back to it later
425 * in the next iteration. (a simple LRU without
426 * moving list elements around)
427 */
428 if (f->flags & FID_REFERENCED) {
429 f->flags &= ~FID_REFERENCED;
430 continue;
431 }
432 /*
433 * Add fids to reclaim list.
434 */
435 if (f->fid_type == P9_FID_FILE) {
436 if (f->fs.fd != -1) {
437 /*
438 * Up the reference count so that
439 * a clunk request won't free this fid
440 */
441 f->ref++;
442 f->rclm_lst = reclaim_list;
443 reclaim_list = f;
444 f->fs_reclaim.fd = f->fs.fd;
445 f->fs.fd = -1;
446 reclaim_count++;
447 }
95f65511
AK		 448 } else if (f->fid_type == P9_FID_DIR) {
449 if (f->fs.dir != NULL) {
450 /*
451 * Up the reference count so that
452 * a clunk request won't free this fid
453 */
454 f->ref++;
455 f->rclm_lst = reclaim_list;
456 reclaim_list = f;
457 f->fs_reclaim.dir = f->fs.dir;
458 f->fs.dir = NULL;
459 reclaim_count++;
460 }
7a462745
AK		 461 }
462 if (reclaim_count >= open_fd_rc) {
463 break;
464 }
465 }
466 /*
467 * Now close the fid in reclaim list. Free them if they
468 * are already clunked.
469 */
470 while (reclaim_list) {
471 f = reclaim_list;
472 reclaim_list = f->rclm_lst;
473 if (f->fid_type == P9_FID_FILE) {
474 v9fs_co_close(s, f->fs_reclaim.fd);
95f65511
AK		 475 } else if (f->fid_type == P9_FID_DIR) {
476 v9fs_co_closedir(s, f->fs_reclaim.dir);
7a462745
AK		 477 }
478 f->rclm_lst = NULL;
479 /*
480 * Now drop the fid reference, free it
481 * if clunked.
482 */
483 put_fid(s, f);
484 }
485}
486
487static int v9fs_mark_fids_unreclaim(V9fsState *s, V9fsString *str)
488{
489 int err;
490 V9fsFidState *fidp, head_fid;
491
492 head_fid.next = s->fid_list;
493 for (fidp = s->fid_list; fidp; fidp = fidp->next) {
494 if (!strcmp(fidp->path.data, str->data)) {
495 /* Mark the fid non reclaimable. */
496 fidp->flags |= FID_NON_RECLAIMABLE;
b9cb88b0
AK		 497
498 /* reopen the file/dir if already closed */
499 err = v9fs_reopen_fid(s, fidp);
500 if (err < 0) {
501 return -1;
502 }
503 /*
504 * Go back to head of fid list because
505 * the list could have got updated when
506 * switched to the worker thread
507 */
508 if (err == 0) {
7a462745
AK		 509 fidp = &head_fid;
510 }
511 }
512 }
513 return 0;
514}
515
286d5652
AL		 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
25427ec1 546 memset(&qidp->path, 0, sizeof(qidp->path));
286d5652
AL		 547 size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
548 memcpy(&qidp->path, &stbuf->st_ino, size);
549 qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
550 qidp->type = 0;
551 if (S_ISDIR(stbuf->st_mode)) {
552 qidp->type |= P9_QID_TYPE_DIR;
553 }
554 if (S_ISLNK(stbuf->st_mode)) {
555 qidp->type |= P9_QID_TYPE_SYMLINK;
556 }
557}
558
559static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp)
560{
561 struct stat stbuf;
562 int err;
563
8c158561
AK		 564 err = v9fs_co_lstat(s, &fidp->path, &stbuf);
565 if (err < 0) {
286d5652
AL		 566 return err;
567 }
286d5652
AL		 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) {
39792515
AK		 586 if (debug_9p_pdu) {
587 pprint_pdu(pdu);
588 }
589 QLIST_INSERT_HEAD(&s->free_list, pdu, next);
9f107513
AL		 590 }
591}
592
593size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
594 size_t offset, size_t size, int pack)
595{
596 int i = 0;
597 size_t copied = 0;
598
599 for (i = 0; size && i < sg_count; i++) {
600 size_t len;
601 if (offset >= sg[i].iov_len) {
602 /* skip this sg */
603 offset -= sg[i].iov_len;
604 continue;
605 } else {
606 len = MIN(sg[i].iov_len - offset, size);
607 if (pack) {
608 memcpy(sg[i].iov_base + offset, addr, len);
609 } else {
610 memcpy(addr, sg[i].iov_base + offset, len);
611 }
612 size -= len;
613 copied += len;
614 addr += len;
615 if (size) {
616 offset = 0;
617 continue;
618 }
619 }
620 }
621
622 return copied;
623}
624
405a549a
AL		 625static size_t pdu_unpack(void *dst, V9fsPDU *pdu, size_t offset, size_t size)
626{
627 return pdu_packunpack(dst, pdu->elem.out_sg, pdu->elem.out_num,
628 offset, size, 0);
629}
630
631static size_t pdu_pack(V9fsPDU *pdu, size_t offset, const void *src,
632 size_t size)
633{
634 return pdu_packunpack((void *)src, pdu->elem.in_sg, pdu->elem.in_num,
635 offset, size, 1);
636}
637
638static int pdu_copy_sg(V9fsPDU *pdu, size_t offset, int rx, struct iovec *sg)
639{
640 size_t pos = 0;
641 int i, j;
642 struct iovec *src_sg;
643 unsigned int num;
644
645 if (rx) {
646 src_sg = pdu->elem.in_sg;
647 num = pdu->elem.in_num;
648 } else {
649 src_sg = pdu->elem.out_sg;
650 num = pdu->elem.out_num;
651 }
652
653 j = 0;
654 for (i = 0; i < num; i++) {
655 if (offset <= pos) {
656 sg[j].iov_base = src_sg[i].iov_base;
657 sg[j].iov_len = src_sg[i].iov_len;
658 j++;
659 } else if (offset < (src_sg[i].iov_len + pos)) {
660 sg[j].iov_base = src_sg[i].iov_base;
661 sg[j].iov_len = src_sg[i].iov_len;
662 sg[j].iov_base += (offset - pos);
663 sg[j].iov_len -= (offset - pos);
664 j++;
665 }
666 pos += src_sg[i].iov_len;
667 }
668
669 return j;
670}
671
672static size_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
673{
674 size_t old_offset = offset;
675 va_list ap;
676 int i;
677
678 va_start(ap, fmt);
679 for (i = 0; fmt[i]; i++) {
680 switch (fmt[i]) {
681 case 'b': {
682 uint8_t *valp = va_arg(ap, uint8_t *);
683 offset += pdu_unpack(valp, pdu, offset, sizeof(*valp));
684 break;
685 }
686 case 'w': {
687 uint16_t val, *valp;
688 valp = va_arg(ap, uint16_t *);
405a549a 689 offset += pdu_unpack(&val, pdu, offset, sizeof(val));
4e37bfc1 690 *valp = le16_to_cpu(val);
405a549a
AL		 691 break;
692 }
693 case 'd': {
694 uint32_t val, *valp;
695 valp = va_arg(ap, uint32_t *);
405a549a 696 offset += pdu_unpack(&val, pdu, offset, sizeof(val));
4e37bfc1 697 *valp = le32_to_cpu(val);
405a549a
AL		 698 break;
699 }
700 case 'q': {
701 uint64_t val, *valp;
702 valp = va_arg(ap, uint64_t *);
405a549a 703 offset += pdu_unpack(&val, pdu, offset, sizeof(val));
4e37bfc1 704 *valp = le64_to_cpu(val);
405a549a
AL		 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 */
7267c094 717 str->data = g_malloc(str->size + 1);
405a549a
AL		 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 1026 if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
7a5ca31e
VJ		 1027 err = v9fs_co_readlink(s, name, &v9stat->extension);
1028 if (err < 0) {
cf03eb2c 1029 return err;
bb9e3216 1030 }
cf03eb2c
AB		 1031 } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
1032 v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
1033 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
1034 major(stbuf->st_rdev), minor(stbuf->st_rdev));
1035 } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
c9ba47dc
SW		 1036 v9fs_string_sprintf(&v9stat->extension, "%s %lu",
1037 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
bb9e3216
AL		 1038 }
1039
1040 str = strrchr(name->data, '/');
1041 if (str) {
1042 str += 1;
1043 } else {
1044 str = name->data;
1045 }
1046
1047 v9fs_string_sprintf(&v9stat->name, "%s", str);
1048
1049 v9stat->size = 61 +
1050 v9fs_string_size(&v9stat->name) +
1051 v9fs_string_size(&v9stat->uid) +
1052 v9fs_string_size(&v9stat->gid) +
1053 v9fs_string_size(&v9stat->muid) +
1054 v9fs_string_size(&v9stat->extension);
1055 return 0;
1056}
1057
00ede4c2
SK		 1058#define P9_STATS_MODE 0x00000001ULL
1059#define P9_STATS_NLINK 0x00000002ULL
1060#define P9_STATS_UID 0x00000004ULL
1061#define P9_STATS_GID 0x00000008ULL
1062#define P9_STATS_RDEV 0x00000010ULL
1063#define P9_STATS_ATIME 0x00000020ULL
1064#define P9_STATS_MTIME 0x00000040ULL
1065#define P9_STATS_CTIME 0x00000080ULL
1066#define P9_STATS_INO 0x00000100ULL
1067#define P9_STATS_SIZE 0x00000200ULL
1068#define P9_STATS_BLOCKS 0x00000400ULL
1069
1070#define P9_STATS_BTIME 0x00000800ULL
1071#define P9_STATS_GEN 0x00001000ULL
1072#define P9_STATS_DATA_VERSION 0x00002000ULL
1073
1074#define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */
1075#define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */
1076
1077
1078static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,
8db21ce7 1079 V9fsStatDotl *v9lstat)
00ede4c2
SK		 1080{
1081 memset(v9lstat, 0, sizeof(*v9lstat));
1082
1083 v9lstat->st_mode = stbuf->st_mode;
1084 v9lstat->st_nlink = stbuf->st_nlink;
1085 v9lstat->st_uid = stbuf->st_uid;
1086 v9lstat->st_gid = stbuf->st_gid;
1087 v9lstat->st_rdev = stbuf->st_rdev;
1088 v9lstat->st_size = stbuf->st_size;
1089 v9lstat->st_blksize = stbuf->st_blksize;
1090 v9lstat->st_blocks = stbuf->st_blocks;
1091 v9lstat->st_atime_sec = stbuf->st_atime;
1092 v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
1093 v9lstat->st_mtime_sec = stbuf->st_mtime;
1094 v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
1095 v9lstat->st_ctime_sec = stbuf->st_ctime;
1096 v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
1097 /* Currently we only support BASIC fields in stat */
1098 v9lstat->st_result_mask = P9_STATS_BASIC;
1099
1100 stat_to_qid(stbuf, &v9lstat->qid);
1101}
1102
1f5a89bf
AL		 1103static struct iovec *adjust_sg(struct iovec *sg, int len, int *iovcnt)
1104{
1105 while (len && *iovcnt) {
1106 if (len < sg->iov_len) {
1107 sg->iov_len -= len;
1108 sg->iov_base += len;
1109 len = 0;
1110 } else {
1111 len -= sg->iov_len;
1112 sg++;
1113 *iovcnt -= 1;
1114 }
1115 }
1116
1117 return sg;
1118}
1119
1120static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
1121{
1122 int i;
1123 int total = 0;
1124
1125 for (i = 0; i < *cnt; i++) {
1126 if ((total + sg[i].iov_len) > cap) {
1127 sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
1128 i++;
1129 break;
1130 }
1131 total += sg[i].iov_len;
1132 }
1133
1134 *cnt = i;
1135
1136 return sg;
1137}
1138
1139static void print_sg(struct iovec *sg, int cnt)
1140{
1141 int i;
1142
1143 printf("sg[%d]: {", cnt);
1144 for (i = 0; i < cnt; i++) {
1145 if (i) {
1146 printf(", ");
1147 }
1148 printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
1149 }
1150 printf("}\n");
1151}
1152
8cf89e00
AL		 1153static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
1154{
1155 V9fsString str;
1156 v9fs_string_init(&str);
1157 v9fs_string_copy(&str, dst);
1158 v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
1159 v9fs_string_free(&str);
1160}
1161
ff06030f 1162static void v9fs_version(void *opaque)
9f107513 1163{
ff06030f
VJJ		 1164 V9fsPDU *pdu = opaque;
1165 V9fsState *s = pdu->s;
92c1ad03
AL		 1166 V9fsString version;
1167 size_t offset = 7;
1168
5e94c103 1169 pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
92c1ad03 1170
84151514
MK		 1171 if (!strcmp(version.data, "9P2000.u")) {
1172 s->proto_version = V9FS_PROTO_2000U;
1173 } else if (!strcmp(version.data, "9P2000.L")) {
1174 s->proto_version = V9FS_PROTO_2000L;
1175 } else {
92c1ad03 1176 v9fs_string_sprintf(&version, "unknown");
9f107513 1177 }
92c1ad03 1178
5e94c103 1179 offset += pdu_marshal(pdu, offset, "ds", s->msize, &version);
92c1ad03
AL		 1180 complete_pdu(s, pdu, offset);
1181
1182 v9fs_string_free(&version);
ff06030f 1183 return;
9f107513
AL		 1184}
1185
ff06030f 1186static void v9fs_attach(void *opaque)
9f107513 1187{
ff06030f
VJJ		 1188 V9fsPDU *pdu = opaque;
1189 V9fsState *s = pdu->s;
955efc47
AL		 1190 int32_t fid, afid, n_uname;
1191 V9fsString uname, aname;
1192 V9fsFidState *fidp;
955efc47 1193 size_t offset = 7;
8c158561 1194 V9fsQID qid;
955efc47
AL		 1195 ssize_t err;
1196
1197 pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
1198
1199 fidp = alloc_fid(s, fid);
1200 if (fidp == NULL) {
1201 err = -EINVAL;
84dfb926 1202 goto out_nofid;
9f107513 1203 }
955efc47 1204 fidp->uid = n_uname;
955efc47
AL		 1205 v9fs_string_sprintf(&fidp->path, "%s", "/");
1206 err = fid_to_qid(s, fidp, &qid);
8c158561 1207 if (err < 0) {
955efc47 1208 err = -EINVAL;
84dfb926 1209 clunk_fid(s, fid);
955efc47
AL		 1210 goto out;
1211 }
955efc47 1212 offset += pdu_marshal(pdu, offset, "Q", &qid);
955efc47
AL		 1213 err = offset;
1214out:
84dfb926
AK		 1215 put_fid(s, fidp);
1216out_nofid:
955efc47
AL		 1217 complete_pdu(s, pdu, err);
1218 v9fs_string_free(&uname);
1219 v9fs_string_free(&aname);
9f107513
AL		 1220}
1221
ff06030f 1222static void v9fs_stat(void *opaque)
9f107513 1223{
4da7d3fa 1224 int32_t fid;
d8e0c29e 1225 V9fsStat v9stat;
4da7d3fa 1226 ssize_t err = 0;
d8e0c29e
AK		 1227 size_t offset = 7;
1228 struct stat stbuf;
1229 V9fsFidState *fidp;
1230 V9fsPDU *pdu = opaque;
1231 V9fsState *s = pdu->s;
4da7d3fa 1232
d8e0c29e 1233 pdu_unmarshal(pdu, offset, "d", &fid);
84dfb926
AK		 1234
1235 fidp = get_fid(s, fid);
d8e0c29e 1236 if (fidp == NULL) {
4da7d3fa 1237 err = -ENOENT;
84dfb926 1238 goto out_nofid;
9f107513 1239 }
d8e0c29e
AK		 1240 err = v9fs_co_lstat(s, &fidp->path, &stbuf);
1241 if (err < 0) {
1242 goto out;
1243 }
1244 err = stat_to_v9stat(s, &fidp->path, &stbuf, &v9stat);
1245 if (err < 0) {
1246 goto out;
1247 }
1248 offset += pdu_marshal(pdu, offset, "wS", 0, &v9stat);
1249 err = offset;
1250 v9fs_stat_free(&v9stat);
4da7d3fa 1251out:
84dfb926
AK		 1252 put_fid(s, fidp);
1253out_nofid:
d8e0c29e 1254 complete_pdu(s, pdu, err);
9f107513
AL		 1255}
1256
ff06030f 1257static void v9fs_getattr(void *opaque)
00ede4c2
SK		 1258{
1259 int32_t fid;
8db21ce7
AK		 1260 size_t offset = 7;
1261 ssize_t retval = 0;
1262 struct stat stbuf;
00ede4c2
SK		 1263 V9fsFidState *fidp;
1264 uint64_t request_mask;
8db21ce7
AK		 1265 V9fsStatDotl v9stat_dotl;
1266 V9fsPDU *pdu = opaque;
1267 V9fsState *s = pdu->s;
00ede4c2 1268
8db21ce7 1269 pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask);
00ede4c2 1270
84dfb926 1271 fidp = get_fid(s, fid);
00ede4c2 1272 if (fidp == NULL) {
8db21ce7 1273 retval = -ENOENT;
84dfb926 1274 goto out_nofid;
00ede4c2 1275 }
8db21ce7
AK		 1276 /*
1277 * Currently we only support BASIC fields in stat, so there is no
00ede4c2
SK		 1278 * need to look at request_mask.
1279 */
8db21ce7
AK		 1280 retval = v9fs_co_lstat(s, &fidp->path, &stbuf);
1281 if (retval < 0) {
1282 goto out;
1283 }
1284 stat_to_v9stat_dotl(s, &stbuf, &v9stat_dotl);
1285 retval = offset;
1286 retval += pdu_marshal(pdu, offset, "A", &v9stat_dotl);
00ede4c2 1287out:
84dfb926
AK		 1288 put_fid(s, fidp);
1289out_nofid:
8db21ce7 1290 complete_pdu(s, pdu, retval);
00ede4c2
SK		 1291}
1292
c79ce737
SK		 1293/* From Linux kernel code */
1294#define ATTR_MODE (1 << 0)
1295#define ATTR_UID (1 << 1)
1296#define ATTR_GID (1 << 2)
1297#define ATTR_SIZE (1 << 3)
1298#define ATTR_ATIME (1 << 4)
1299#define ATTR_MTIME (1 << 5)
1300#define ATTR_CTIME (1 << 6)
1301#define ATTR_MASK 127
1302#define ATTR_ATIME_SET (1 << 7)
1303#define ATTR_MTIME_SET (1 << 8)
1304
65c05f9a 1305static void v9fs_setattr(void *opaque)
c79ce737 1306{
65c05f9a
AK		 1307 int err = 0;
1308 int32_t fid;
1309 V9fsFidState *fidp;
1310 size_t offset = 7;
1311 V9fsIattr v9iattr;
1312 V9fsPDU *pdu = opaque;
1313 V9fsState *s = pdu->s;
c79ce737 1314
65c05f9a 1315 pdu_unmarshal(pdu, offset, "dI", &fid, &v9iattr);
c79ce737 1316
84dfb926 1317 fidp = get_fid(s, fid);
65c05f9a
AK		 1318 if (fidp == NULL) {
1319 err = -EINVAL;
84dfb926 1320 goto out_nofid;
c79ce737 1321 }
65c05f9a
AK		 1322 if (v9iattr.valid & ATTR_MODE) {
1323 err = v9fs_co_chmod(s, &fidp->path, v9iattr.mode);
1324 if (err < 0) {
1325 goto out;
c79ce737 1326 }
c79ce737 1327 }
65c05f9a 1328 if (v9iattr.valid & (ATTR_ATIME | ATTR_MTIME)) {
c79ce737 1329 struct timespec times[2];
65c05f9a
AK		 1330 if (v9iattr.valid & ATTR_ATIME) {
1331 if (v9iattr.valid & ATTR_ATIME_SET) {
1332 times[0].tv_sec = v9iattr.atime_sec;
1333 times[0].tv_nsec = v9iattr.atime_nsec;
c79ce737
SK		 1334 } else {
1335 times[0].tv_nsec = UTIME_NOW;
1336 }
1337 } else {
1338 times[0].tv_nsec = UTIME_OMIT;
1339 }
65c05f9a
AK		 1340 if (v9iattr.valid & ATTR_MTIME) {
1341 if (v9iattr.valid & ATTR_MTIME_SET) {
1342 times[1].tv_sec = v9iattr.mtime_sec;
1343 times[1].tv_nsec = v9iattr.mtime_nsec;
c79ce737
SK		 1344 } else {
1345 times[1].tv_nsec = UTIME_NOW;
1346 }
1347 } else {
1348 times[1].tv_nsec = UTIME_OMIT;
1349 }
65c05f9a
AK		 1350 err = v9fs_co_utimensat(s, &fidp->path, times);
1351 if (err < 0) {
1352 goto out;
1353 }
c79ce737 1354 }
65c05f9a
AK		 1355 /*
1356 * If the only valid entry in iattr is ctime we can call
1357 * chown(-1,-1) to update the ctime of the file
1358 */
1359 if ((v9iattr.valid & (ATTR_UID | ATTR_GID)) ||
1360 ((v9iattr.valid & ATTR_CTIME)
1361 && !((v9iattr.valid & ATTR_MASK) & ~ATTR_CTIME))) {
1362 if (!(v9iattr.valid & ATTR_UID)) {
1363 v9iattr.uid = -1;
1364 }
1365 if (!(v9iattr.valid & ATTR_GID)) {
1366 v9iattr.gid = -1;
1367 }
1368 err = v9fs_co_chown(s, &fidp->path, v9iattr.uid,
1369 v9iattr.gid);
1370 if (err < 0) {
1371 goto out;
1372 }
c79ce737 1373 }
65c05f9a
AK		 1374 if (v9iattr.valid & (ATTR_SIZE)) {
1375 err = v9fs_co_truncate(s, &fidp->path, v9iattr.size);
1376 if (err < 0) {
1377 goto out;
1378 }
c79ce737 1379 }
65c05f9a 1380 err = offset;
c79ce737 1381out:
84dfb926
AK		 1382 put_fid(s, fidp);
1383out_nofid:
65c05f9a 1384 complete_pdu(s, pdu, err);
c79ce737
SK		 1385}
1386
3cc19c0c 1387static int v9fs_walk_marshal(V9fsPDU *pdu, uint16_t nwnames, V9fsQID *qids)
ff5e54c9
AL		 1388{
1389 int i;
3cc19c0c
AK		 1390 size_t offset = 7;
1391 offset += pdu_marshal(pdu, offset, "w", nwnames);
1392 for (i = 0; i < nwnames; i++) {
1393 offset += pdu_marshal(pdu, offset, "Q", &qids[i]);
ff5e54c9 1394 }
3cc19c0c 1395 return offset;
ff5e54c9
AL		 1396}
1397
ff06030f 1398static void v9fs_walk(void *opaque)
9f107513 1399{
3cc19c0c
AK		 1400 int name_idx;
1401 V9fsQID *qids = NULL;
1402 int i, err = 0;
1403 V9fsString path;
1404 uint16_t nwnames;
1405 struct stat stbuf;
1406 size_t offset = 7;
1407 int32_t fid, newfid;
1408 V9fsString *wnames = NULL;
1409 V9fsFidState *fidp;
84dfb926 1410 V9fsFidState *newfidp = NULL;;
ff06030f
VJJ		 1411 V9fsPDU *pdu = opaque;
1412 V9fsState *s = pdu->s;
ff5e54c9 1413
3cc19c0c
AK		 1414 offset += pdu_unmarshal(pdu, offset, "ddw", &fid,
1415 &newfid, &nwnames);
ff5e54c9 1416
3cc19c0c
AK		 1417 if (nwnames && nwnames <= P9_MAXWELEM) {
1418 wnames = g_malloc0(sizeof(wnames[0]) * nwnames);
1419 qids = g_malloc0(sizeof(qids[0]) * nwnames);
1420 for (i = 0; i < nwnames; i++) {
1421 offset += pdu_unmarshal(pdu, offset, "s", &wnames[i]);
ff5e54c9 1422 }
3cc19c0c
AK		 1423
1424 } else if (nwnames > P9_MAXWELEM) {
4f8dee2d 1425 err = -EINVAL;
84dfb926 1426 goto out_nofid;
ff5e54c9 1427 }
84dfb926 1428 fidp = get_fid(s, fid);
3cc19c0c 1429 if (fidp == NULL) {
ff5e54c9 1430 err = -ENOENT;
84dfb926 1431 goto out_nofid;
ff5e54c9 1432 }
ff5e54c9 1433 if (fid == newfid) {
3cc19c0c
AK		 1434 BUG_ON(fidp->fid_type != P9_FID_NONE);
1435 v9fs_string_init(&path);
1436 for (name_idx = 0; name_idx < nwnames; name_idx++) {
1437 v9fs_string_sprintf(&path, "%s/%s",
1438 fidp->path.data, wnames[name_idx].data);
1439 v9fs_string_copy(&fidp->path, &path);
1440
1441 err = v9fs_co_lstat(s, &fidp->path, &stbuf);
1442 if (err < 0) {
1443 v9fs_string_free(&path);
1444 goto out;
1445 }
1446 stat_to_qid(&stbuf, &qids[name_idx]);
ff5e54c9 1447 }
3cc19c0c 1448 v9fs_string_free(&path);
ff5e54c9 1449 } else {
3cc19c0c
AK		 1450 newfidp = alloc_fid(s, newfid);
1451 if (newfidp == NULL) {
ff5e54c9
AL		 1452 err = -EINVAL;
1453 goto out;
1454 }
3cc19c0c
AK		 1455 newfidp->uid = fidp->uid;
1456 v9fs_string_init(&path);
1457 v9fs_string_copy(&newfidp->path, &fidp->path);
1458 for (name_idx = 0; name_idx < nwnames; name_idx++) {
1459 v9fs_string_sprintf(&path, "%s/%s", newfidp->path.data,
1460 wnames[name_idx].data);
1461 v9fs_string_copy(&newfidp->path, &path);
1462 err = v9fs_co_lstat(s, &newfidp->path, &stbuf);
1463 if (err < 0) {
84dfb926 1464 clunk_fid(s, newfidp->fid);
3cc19c0c
AK		 1465 v9fs_string_free(&path);
1466 goto out;
1467 }
1468 stat_to_qid(&stbuf, &qids[name_idx]);
ff5e54c9 1469 }
3cc19c0c 1470 v9fs_string_free(&path);
9f107513 1471 }
3cc19c0c 1472 err = v9fs_walk_marshal(pdu, nwnames, qids);
ff5e54c9 1473out:
84dfb926
AK		 1474 put_fid(s, fidp);
1475 if (newfidp) {
1476 put_fid(s, newfidp);
1477 }
1478out_nofid:
3cc19c0c
AK		 1479 complete_pdu(s, pdu, err);
1480 if (nwnames && nwnames <= P9_MAXWELEM) {
1481 for (name_idx = 0; name_idx < nwnames; name_idx++) {
1482 v9fs_string_free(&wnames[name_idx]);
1483 }
1484 g_free(wnames);
1485 g_free(qids);
1486 }
9f107513
AL		 1487}
1488
5e94c103
MK		 1489static int32_t get_iounit(V9fsState *s, V9fsString *name)
1490{
1491 struct statfs stbuf;
1492 int32_t iounit = 0;
1493
1494 /*
1495 * iounit should be multiples of f_bsize (host filesystem block size
1496 * and as well as less than (client msize - P9_IOHDRSZ))
1497 */
857bc158 1498 if (!v9fs_co_statfs(s, name, &stbuf)) {
5e94c103
MK		 1499 iounit = stbuf.f_bsize;
1500 iounit *= (s->msize - P9_IOHDRSZ)/stbuf.f_bsize;
1501 }
5e94c103
MK		 1502 if (!iounit) {
1503 iounit = s->msize - P9_IOHDRSZ;
1504 }
1505 return iounit;
1506}
1507
857bc158 1508static void v9fs_open(void *opaque)
5e94c103 1509{
857bc158
AK		 1510 int flags;
1511 int iounit;
1512 int32_t fid;
1513 int32_t mode;
1514 V9fsQID qid;
1515 ssize_t err = 0;
1516 size_t offset = 7;
1517 struct stat stbuf;
1518 V9fsFidState *fidp;
1519 V9fsPDU *pdu = opaque;
1520 V9fsState *s = pdu->s;
5e94c103 1521
857bc158
AK		 1522 if (s->proto_version == V9FS_PROTO_2000L) {
1523 pdu_unmarshal(pdu, offset, "dd", &fid, &mode);
1524 } else {
1525 pdu_unmarshal(pdu, offset, "db", &fid, &mode);
1526 }
84dfb926 1527 fidp = get_fid(s, fid);
857bc158
AK		 1528 if (fidp == NULL) {
1529 err = -ENOENT;
84dfb926 1530 goto out_nofid;
a6568fe2 1531 }
857bc158 1532 BUG_ON(fidp->fid_type != P9_FID_NONE);
a6568fe2 1533
857bc158
AK		 1534 err = v9fs_co_lstat(s, &fidp->path, &stbuf);
1535 if (err < 0) {
a6568fe2
AL		 1536 goto out;
1537 }
857bc158
AK		 1538 stat_to_qid(&stbuf, &qid);
1539 if (S_ISDIR(stbuf.st_mode)) {
1540 err = v9fs_co_opendir(s, fidp);
1541 if (err < 0) {
1542 goto out;
1543 }
1544 fidp->fid_type = P9_FID_DIR;
1545 offset += pdu_marshal(pdu, offset, "Qd", &qid, 0);
1546 err = offset;
a6568fe2 1547 } else {
771e9d4c 1548 if (s->proto_version == V9FS_PROTO_2000L) {
857bc158 1549 flags = mode;
630c2689 1550 flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
0f8151cb
VJJ		 1551 /* Ignore direct disk access hint until the server supports it. */
1552 flags &= ~O_DIRECT;
771e9d4c 1553 } else {
857bc158 1554 flags = omode_to_uflags(mode);
771e9d4c 1555 }
857bc158
AK		 1556 err = v9fs_co_open(s, fidp, flags);
1557 if (err < 0) {
1558 goto out;
1559 }
1560 fidp->fid_type = P9_FID_FILE;
7a462745
AK		 1561 fidp->open_flags = flags;
1562 if (flags & O_EXCL) {
1563 /*
1564 * We let the host file system do O_EXCL check
1565 * We should not reclaim such fd
1566 */
1567 fidp->flags |= FID_NON_RECLAIMABLE;
1568 }
857bc158
AK		 1569 iounit = get_iounit(s, &fidp->path);
1570 offset += pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1571 err = offset;
a6568fe2 1572 }
a6568fe2 1573out:
84dfb926
AK		 1574 put_fid(s, fidp);
1575out_nofid:
a6568fe2 1576 complete_pdu(s, pdu, err);
a6568fe2
AL		 1577}
1578
ff06030f 1579static void v9fs_lcreate(void *opaque)
c1568af5
VJJ		 1580{
1581 int32_t dfid, flags, mode;
1582 gid_t gid;
c1568af5 1583 ssize_t err = 0;
36f8981f
VJ		 1584 ssize_t offset = 7;
1585 V9fsString fullname;
1586 V9fsString name;
1587 V9fsFidState *fidp;
1588 struct stat stbuf;
1589 V9fsQID qid;
1590 int32_t iounit;
1591 V9fsPDU *pdu = opaque;
c1568af5 1592
36f8981f
VJ		 1593 v9fs_string_init(&fullname);
1594 pdu_unmarshal(pdu, offset, "dsddd", &dfid, &name, &flags,
1595 &mode, &gid);
c1568af5 1596
84dfb926 1597 fidp = get_fid(pdu->s, dfid);
36f8981f 1598 if (fidp == NULL) {
c1568af5 1599 err = -ENOENT;
84dfb926 1600 goto out_nofid;
c1568af5 1601 }
36f8981f 1602 v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
c1568af5 1603
0f8151cb
VJJ		 1604 /* Ignore direct disk access hint until the server supports it. */
1605 flags &= ~O_DIRECT;
1606
36f8981f
VJ		 1607 err = v9fs_co_open2(pdu->s, fidp, fullname.data, gid, flags, mode);
1608 if (err < 0) {
1609 goto out;
1610 }
1611 fidp->fid_type = P9_FID_FILE;
7a462745
AK		 1612 fidp->open_flags = flags;
1613 if (flags & O_EXCL) {
1614 /*
1615 * We let the host file system do O_EXCL check
1616 * We should not reclaim such fd
1617 */
1618 fidp->flags |= FID_NON_RECLAIMABLE;
1619 }
36f8981f 1620 iounit = get_iounit(pdu->s, &fullname);
c1568af5 1621
36f8981f
VJ		 1622 err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
1623 if (err < 0) {
1624 fidp->fid_type = P9_FID_NONE;
1625 if (fidp->fs.fd > 0) {
9b54ffaa 1626 v9fs_co_close(pdu->s, fidp->fs.fd);
36f8981f
VJ		 1627 }
1628 goto out;
1629 }
1630 v9fs_string_copy(&fidp->path, &fullname);
1631 stat_to_qid(&stbuf, &qid);
1632 offset += pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1633 err = offset;
c1568af5 1634out:
84dfb926
AK		 1635 put_fid(pdu->s, fidp);
1636out_nofid:
36f8981f
VJ		 1637 complete_pdu(pdu->s, pdu, err);
1638 v9fs_string_free(&name);
1639 v9fs_string_free(&fullname);
c1568af5
VJJ		 1640}
1641
ff06030f 1642static void v9fs_fsync(void *opaque)
b41e95d3 1643{
4e9ad444 1644 int err;
b41e95d3 1645 int32_t fid;
4e9ad444 1646 int datasync;
b41e95d3
VJJ		 1647 size_t offset = 7;
1648 V9fsFidState *fidp;
4e9ad444
AK		 1649 V9fsPDU *pdu = opaque;
1650 V9fsState *s = pdu->s;
b41e95d3 1651
49594973 1652 pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
84dfb926 1653 fidp = get_fid(s, fid);
b41e95d3
VJJ		 1654 if (fidp == NULL) {
1655 err = -ENOENT;
84dfb926 1656 goto out_nofid;
b41e95d3 1657 }
4e9ad444
AK		 1658 err = v9fs_co_fsync(s, fidp, datasync);
1659 if (!err) {
1660 err = offset;
1661 }
84dfb926
AK		 1662 put_fid(s, fidp);
1663out_nofid:
4e9ad444 1664 complete_pdu(s, pdu, err);
b41e95d3
VJJ		 1665}
1666
ff06030f 1667static void v9fs_clunk(void *opaque)
a6568fe2 1668{
c540ee51 1669 int err;
bbd5697b
AL		 1670 int32_t fid;
1671 size_t offset = 7;
84dfb926 1672 V9fsFidState *fidp;
c540ee51
AK		 1673 V9fsPDU *pdu = opaque;
1674 V9fsState *s = pdu->s;
bbd5697b
AL		 1675
1676 pdu_unmarshal(pdu, offset, "d", &fid);
84dfb926
AK		 1677
1678 fidp = get_fid(s, fid);
1679 if (fidp == NULL) {
1680 err = -ENOENT;
1681 goto out_nofid;
1682 }
1683 err = clunk_fid(s, fidp->fid);
bbd5697b
AL		 1684 if (err < 0) {
1685 goto out;
a6568fe2 1686 }
bbd5697b
AL		 1687 err = offset;
1688out:
84dfb926
AK		 1689 put_fid(s, fidp);
1690out_nofid:
bbd5697b 1691 complete_pdu(s, pdu, err);
9f107513
AL		 1692}
1693
d208a0e0
AK		 1694static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu,
1695 V9fsFidState *fidp, int64_t off, int32_t max_count)
a9231555 1696{
d208a0e0
AK		 1697 size_t offset = 7;
1698 int read_count;
1699 int64_t xattr_len;
a9231555 1700
d208a0e0
AK		 1701 xattr_len = fidp->fs.xattr.len;
1702 read_count = xattr_len - off;
1703 if (read_count > max_count) {
1704 read_count = max_count;
1705 } else if (read_count < 0) {
1706 /*
1707 * read beyond XATTR value
1708 */
1709 read_count = 0;
a9231555 1710 }
d208a0e0
AK		 1711 offset += pdu_marshal(pdu, offset, "d", read_count);
1712 offset += pdu_pack(pdu, offset,
1713 ((char *)fidp->fs.xattr.value) + off,
1714 read_count);
1715 return offset;
a9231555
AL		 1716}
1717
d208a0e0
AK		 1718static int v9fs_do_readdir_with_stat(V9fsState *s, V9fsPDU *pdu,
1719 V9fsFidState *fidp, int32_t max_count)
a9231555 1720{
d208a0e0
AK		 1721 V9fsString name;
1722 V9fsStat v9stat;
1723 int len, err = 0;
1724 int32_t count = 0;
1725 struct stat stbuf;
1726 off_t saved_dir_pos;
5f524c1e 1727 struct dirent *dent, *result;
a9231555 1728
d208a0e0
AK		 1729 /* save the directory position */
1730 saved_dir_pos = v9fs_co_telldir(s, fidp);
1731 if (saved_dir_pos < 0) {
1732 return saved_dir_pos;
a9231555 1733 }
5f524c1e
HPB		 1734
1735 dent = g_malloc(sizeof(struct dirent));
1736
d208a0e0
AK		 1737 while (1) {
1738 v9fs_string_init(&name);
5f524c1e
HPB		 1739 err = v9fs_co_readdir_r(s, fidp, dent, &result);
1740 if (err || !result) {
d208a0e0
AK		 1741 break;
1742 }
1743 v9fs_string_sprintf(&name, "%s/%s", fidp->path.data, dent->d_name);
1744 err = v9fs_co_lstat(s, &name, &stbuf);
1745 if (err < 0) {
1746 goto out;
1747 }
1748 err = stat_to_v9stat(s, &name, &stbuf, &v9stat);
1749 if (err < 0) {
1750 goto out;
a9231555 1751 }
d208a0e0
AK		 1752 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1753 len = pdu_marshal(pdu, 11 + count, "S", &v9stat);
1754 if ((len != (v9stat.size + 2)) || ((count + len) > max_count)) {
1755 /* Ran out of buffer. Set dir back to old position and return */
1756 v9fs_co_seekdir(s, fidp, saved_dir_pos);
1757 v9fs_stat_free(&v9stat);
1758 v9fs_string_free(&name);
5f524c1e 1759 g_free(dent);
d208a0e0
AK		 1760 return count;
1761 }
1762 count += len;
1763 v9fs_stat_free(&v9stat);
1764 v9fs_string_free(&name);
1765 saved_dir_pos = dent->d_off;
a9231555 1766 }
a9231555 1767out:
5f524c1e 1768 g_free(dent);
d208a0e0
AK		 1769 v9fs_string_free(&name);
1770 if (err < 0) {
1771 return err;
fa32ef88 1772 }
d208a0e0 1773 return count;
fa32ef88
AK		 1774}
1775
ff06030f 1776static void v9fs_read(void *opaque)
9f107513 1777{
a9231555 1778 int32_t fid;
d208a0e0 1779 int64_t off;
a9231555 1780 ssize_t err = 0;
d208a0e0
AK		 1781 int32_t count = 0;
1782 size_t offset = 7;
1783 int32_t max_count;
1784 V9fsFidState *fidp;
1785 V9fsPDU *pdu = opaque;
1786 V9fsState *s = pdu->s;
a9231555 1787
d208a0e0 1788 pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &max_count);
84dfb926
AK		 1789
1790 fidp = get_fid(s, fid);
d208a0e0 1791 if (fidp == NULL) {
a9231555 1792 err = -EINVAL;
84dfb926 1793 goto out_nofid;
a9231555 1794 }
d208a0e0 1795 if (fidp->fid_type == P9_FID_DIR) {
a9231555 1796
d208a0e0
AK		 1797 if (off == 0) {
1798 v9fs_co_rewinddir(s, fidp);
a9231555 1799 }
d208a0e0
AK		 1800 count = v9fs_do_readdir_with_stat(s, pdu, fidp, max_count);
1801 if (count < 0) {
1802 err = count;
1803 goto out;
56d15a53 1804 }
d208a0e0
AK		 1805 err = offset;
1806 err += pdu_marshal(pdu, offset, "d", count);
1807 err += count;
1808 } else if (fidp->fid_type == P9_FID_FILE) {
1809 int32_t cnt;
1810 int32_t len;
1811 struct iovec *sg;
1812 struct iovec iov[128]; /* FIXME: bad, bad, bad */
1813
1814 sg = iov;
1815 pdu_marshal(pdu, offset + 4, "v", sg, &cnt);
1816 sg = cap_sg(sg, max_count, &cnt);
1817 do {
1818 if (0) {
1819 print_sg(sg, cnt);
1820 }
1821 /* Loop in case of EINTR */
1822 do {
1823 len = v9fs_co_preadv(s, fidp, sg, cnt, off);
1824 if (len >= 0) {
1825 off += len;
1826 count += len;
1827 }
1828 } while (len == -EINTR);
1829 if (len < 0) {
1830 /* IO error return the error */
1831 err = len;
1832 goto out;
1833 }
1834 sg = adjust_sg(sg, len, &cnt);
1835 } while (count < max_count && len > 0);
1836 err = offset;
1837 err += pdu_marshal(pdu, offset, "d", count);
1838 err += count;
1839 } else if (fidp->fid_type == P9_FID_XATTR) {
1840 err = v9fs_xattr_read(s, pdu, fidp, off, max_count);
a9231555
AL		 1841 } else {
1842 err = -EINVAL;
9f107513 1843 }
a9231555 1844out:
84dfb926
AK		 1845 put_fid(s, fidp);
1846out_nofid:
a9231555 1847 complete_pdu(s, pdu, err);
9f107513
AL		 1848}
1849
5e4eaa79 1850static size_t v9fs_readdir_data_size(V9fsString *name)
c18e2f94 1851{
5e4eaa79
AK		 1852 /*
1853 * Size of each dirent on the wire: size of qid (13) + size of offset (8)
1854 * size of type (1) + size of name.size (2) + strlen(name.data)
1855 */
1856 return 24 + v9fs_string_size(name);
c18e2f94
SK		 1857}
1858
5e4eaa79
AK		 1859static int v9fs_do_readdir(V9fsState *s, V9fsPDU *pdu,
1860 V9fsFidState *fidp, int32_t max_count)
c18e2f94 1861{
c18e2f94 1862 size_t size;
5e4eaa79
AK		 1863 V9fsQID qid;
1864 V9fsString name;
1865 int len, err = 0;
1866 int32_t count = 0;
1867 off_t saved_dir_pos;
5f524c1e 1868 struct dirent *dent, *result;
c18e2f94 1869
5e4eaa79
AK		 1870 /* save the directory position */
1871 saved_dir_pos = v9fs_co_telldir(s, fidp);
1872 if (saved_dir_pos < 0) {
1873 return saved_dir_pos;
1874 }
5f524c1e
HPB		 1875
1876 dent = g_malloc(sizeof(struct dirent));
1877
5e4eaa79 1878 while (1) {
5f524c1e
HPB		 1879 err = v9fs_co_readdir_r(s, fidp, dent, &result);
1880 if (err || !result) {
5e4eaa79
AK		 1881 break;
1882 }
1883 v9fs_string_init(&name);
1884 v9fs_string_sprintf(&name, "%s", dent->d_name);
1885 if ((count + v9fs_readdir_data_size(&name)) > max_count) {
c18e2f94 1886 /* Ran out of buffer. Set dir back to old position and return */
5e4eaa79
AK		 1887 v9fs_co_seekdir(s, fidp, saved_dir_pos);
1888 v9fs_string_free(&name);
5f524c1e 1889 g_free(dent);
5e4eaa79 1890 return count;
c18e2f94 1891 }
5e4eaa79
AK		 1892 /*
1893 * Fill up just the path field of qid because the client uses
c18e2f94
SK		 1894 * only that. To fill the entire qid structure we will have
1895 * to stat each dirent found, which is expensive
1896 */
5e4eaa79
AK		 1897 size = MIN(sizeof(dent->d_ino), sizeof(qid.path));
1898 memcpy(&qid.path, &dent->d_ino, size);
c18e2f94 1899 /* Fill the other fields with dummy values */
5e4eaa79
AK		 1900 qid.type = 0;
1901 qid.version = 0;
c18e2f94 1902
5e4eaa79
AK		 1903 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1904 len = pdu_marshal(pdu, 11 + count, "Qqbs",
1905 &qid, dent->d_off,
1906 dent->d_type, &name);
1907 count += len;
1908 v9fs_string_free(&name);
1909 saved_dir_pos = dent->d_off;
1910 }
5f524c1e 1911 g_free(dent);
5e4eaa79
AK		 1912 if (err < 0) {
1913 return err;
1914 }
1915 return count;
c18e2f94
SK		 1916}
1917
ff06030f 1918static void v9fs_readdir(void *opaque)
c18e2f94
SK		 1919{
1920 int32_t fid;
5e4eaa79
AK		 1921 V9fsFidState *fidp;
1922 ssize_t retval = 0;
c18e2f94 1923 size_t offset = 7;
5e4eaa79
AK		 1924 int64_t initial_offset;
1925 int32_t count, max_count;
1926 V9fsPDU *pdu = opaque;
1927 V9fsState *s = pdu->s;
c18e2f94 1928
5e4eaa79 1929 pdu_unmarshal(pdu, offset, "dqd", &fid, &initial_offset, &max_count);
c18e2f94 1930
84dfb926
AK		 1931 fidp = get_fid(s, fid);
1932 if (fidp == NULL) {
1933 retval = -EINVAL;
1934 goto out_nofid;
1935 }
1936 if (!fidp->fs.dir) {
5e4eaa79 1937 retval = -EINVAL;
c18e2f94
SK		 1938 goto out;
1939 }
5e4eaa79
AK		 1940 if (initial_offset == 0) {
1941 v9fs_co_rewinddir(s, fidp);
c18e2f94 1942 } else {
5e4eaa79 1943 v9fs_co_seekdir(s, fidp, initial_offset);
c18e2f94 1944 }
5e4eaa79
AK		 1945 count = v9fs_do_readdir(s, pdu, fidp, max_count);
1946 if (count < 0) {
1947 retval = count;
1948 goto out;
1949 }
1950 retval = offset;
1951 retval += pdu_marshal(pdu, offset, "d", count);
1952 retval += count;
c18e2f94 1953out:
84dfb926
AK		 1954 put_fid(s, fidp);
1955out_nofid:
5e4eaa79 1956 complete_pdu(s, pdu, retval);
c18e2f94
SK		 1957}
1958
d7a90491
AK		 1959static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
1960 int64_t off, int32_t count,
1961 struct iovec *sg, int cnt)
10b468bd
AK		 1962{
1963 int i, to_copy;
1964 ssize_t err = 0;
1965 int write_count;
1966 int64_t xattr_len;
d7a90491 1967 size_t offset = 7;
10b468bd 1968
d7a90491
AK		 1969
1970 xattr_len = fidp->fs.xattr.len;
1971 write_count = xattr_len - off;
1972 if (write_count > count) {
1973 write_count = count;
10b468bd
AK		 1974 } else if (write_count < 0) {
1975 /*
1976 * write beyond XATTR value len specified in
1977 * xattrcreate
1978 */
1979 err = -ENOSPC;
1980 goto out;
1981 }
d7a90491
AK		 1982 offset += pdu_marshal(pdu, offset, "d", write_count);
1983 err = offset;
1984 fidp->fs.xattr.copied_len += write_count;
10b468bd
AK		 1985 /*
1986 * Now copy the content from sg list
1987 */
d7a90491
AK		 1988 for (i = 0; i < cnt; i++) {
1989 if (write_count > sg[i].iov_len) {
1990 to_copy = sg[i].iov_len;
10b468bd
AK		 1991 } else {
1992 to_copy = write_count;
1993 }
d7a90491 1994 memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
10b468bd 1995 /* updating vs->off since we are not using below */
d7a90491 1996 off += to_copy;
10b468bd
AK		 1997 write_count -= to_copy;
1998 }
1999out:
d7a90491 2000 return err;
10b468bd
AK		 2001}
2002
ff06030f 2003static void v9fs_write(void *opaque)
9f107513 2004{
d7a90491
AK		 2005 int cnt;
2006 ssize_t err;
2007 int32_t fid;
2008 int64_t off;
2009 int32_t count;
2010 int32_t len = 0;
2011 int32_t total = 0;
2012 size_t offset = 7;
2013 V9fsFidState *fidp;
2014 struct iovec iov[128]; /* FIXME: bad, bad, bad */
2015 struct iovec *sg = iov;
ff06030f
VJJ		 2016 V9fsPDU *pdu = opaque;
2017 V9fsState *s = pdu->s;
8449360c 2018
d7a90491 2019 pdu_unmarshal(pdu, offset, "dqdv", &fid, &off, &count, sg, &cnt);
84dfb926
AK		 2020
2021 fidp = get_fid(s, fid);
d7a90491 2022 if (fidp == NULL) {
8449360c 2023 err = -EINVAL;
84dfb926 2024 goto out_nofid;
9f107513 2025 }
d7a90491
AK		 2026 if (fidp->fid_type == P9_FID_FILE) {
2027 if (fidp->fs.fd == -1) {
10b468bd
AK		 2028 err = -EINVAL;
2029 goto out;
2030 }
d7a90491 2031 } else if (fidp->fid_type == P9_FID_XATTR) {
10b468bd
AK		 2032 /*
2033 * setxattr operation
2034 */
d7a90491
AK		 2035 err = v9fs_xattr_write(s, pdu, fidp, off, count, sg, cnt);
2036 goto out;
10b468bd 2037 } else {
8449360c
AL		 2038 err = -EINVAL;
2039 goto out;
2040 }
d7a90491
AK		 2041 sg = cap_sg(sg, count, &cnt);
2042 do {
2043 if (0) {
2044 print_sg(sg, cnt);
56d15a53 2045 }
d7a90491
AK		 2046 /* Loop in case of EINTR */
2047 do {
2048 len = v9fs_co_pwritev(s, fidp, sg, cnt, off);
2049 if (len >= 0) {
2050 off += len;
2051 total += len;
2052 }
2053 } while (len == -EINTR);
2054 if (len < 0) {
2055 /* IO error return the error */
2056 err = len;
2057 goto out;
2058 }
2059 sg = adjust_sg(sg, len, &cnt);
2060 } while (total < count && len > 0);
2061 offset += pdu_marshal(pdu, offset, "d", total);
2062 err = offset;
8449360c 2063out:
84dfb926
AK		 2064 put_fid(s, fidp);
2065out_nofid:
d7a90491 2066 complete_pdu(s, pdu, err);
9f107513
AL		 2067}
2068
baaa86d9 2069static void v9fs_create(void *opaque)
5e94c103 2070{
baaa86d9
VJ		 2071 int32_t fid;
2072 int err = 0;
2073 size_t offset = 7;
2074 V9fsFidState *fidp;
2075 V9fsQID qid;
2076 int32_t perm;
2077 int8_t mode;
2078 struct stat stbuf;
2079 V9fsString name;
2080 V9fsString extension;
2081 V9fsString fullname;
2082 int iounit;
2083 V9fsPDU *pdu = opaque;
c494dd6f 2084
baaa86d9 2085 v9fs_string_init(&fullname);
c494dd6f 2086
baaa86d9
VJ		 2087 pdu_unmarshal(pdu, offset, "dsdbs", &fid, &name,
2088 &perm, &mode, &extension);
c494dd6f 2089
84dfb926 2090 fidp = get_fid(pdu->s, fid);
baaa86d9
VJ		 2091 if (fidp == NULL) {
2092 err = -EINVAL;
84dfb926 2093 goto out_nofid;
c494dd6f
AL		 2094 }
2095
baaa86d9
VJ		 2096 v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
2097 err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
2098 if (!err) {
2099 err = -EEXIST;
c494dd6f 2100 goto out;
baaa86d9 2101 } else if (err != -ENOENT) {
c494dd6f
AL		 2102 goto out;
2103 }
baaa86d9
VJ		 2104 if (perm & P9_STAT_MODE_DIR) {
2105 err = v9fs_co_mkdir(pdu->s, fullname.data, perm & 0777,
2106 fidp->uid, -1);
2107 if (err < 0) {
2108 goto out;
2109 }
407fee0f 2110 v9fs_string_copy(&fidp->path, &fullname);
baaa86d9
VJ		 2111 err = v9fs_co_opendir(pdu->s, fidp);
2112 if (err < 0) {
2113 goto out;
2114 }
2115 fidp->fid_type = P9_FID_DIR;
2116 } else if (perm & P9_STAT_MODE_SYMLINK) {
3fa2a8d1 2117 err = v9fs_co_symlink(pdu->s, fidp, extension.data,
baaa86d9
VJ		 2118 fullname.data, -1);
2119 if (err < 0) {
baaa86d9
VJ		 2120 goto out;
2121 }
2122 } else if (perm & P9_STAT_MODE_LINK) {
2123 int32_t nfid = atoi(extension.data);
84dfb926 2124 V9fsFidState *nfidp = get_fid(pdu->s, nfid);
c494dd6f 2125 if (nfidp == NULL) {
baaa86d9
VJ		 2126 err = -EINVAL;
2127 goto out;
2128 }
ffd66876 2129 err = v9fs_co_link(pdu->s, &nfidp->path, &fullname);
baaa86d9 2130 if (err < 0) {
84dfb926 2131 put_fid(pdu->s, nfidp);
baaa86d9 2132 goto out;
c494dd6f 2133 }
84dfb926 2134 put_fid(pdu->s, nfidp);
baaa86d9 2135 } else if (perm & P9_STAT_MODE_DEVICE) {
c494dd6f
AL		 2136 char ctype;
2137 uint32_t major, minor;
2138 mode_t nmode = 0;
2139
baaa86d9 2140 if (sscanf(extension.data, "%c %u %u", &ctype, &major, &minor) != 3) {
c494dd6f 2141 err = -errno;
baaa86d9 2142 goto out;
c494dd6f
AL		 2143 }
2144
2145 switch (ctype) {
2146 case 'c':
2147 nmode = S_IFCHR;
2148 break;
2149 case 'b':
2150 nmode = S_IFBLK;
2151 break;
2152 default:
2153 err = -EIO;
baaa86d9
VJ		 2154 goto out;
2155 }
c1568af5 2156
baaa86d9
VJ		 2157 nmode |= perm & 0777;
2158 err = v9fs_co_mknod(pdu->s, &fullname, fidp->uid, -1,
2159 makedev(major, minor), nmode);
2160 if (err < 0) {
2161 goto out;
2162 }
2163 } else if (perm & P9_STAT_MODE_NAMED_PIPE) {
2164 err = v9fs_co_mknod(pdu->s, &fullname, fidp->uid, -1,
2165 0, S_IFIFO | (perm & 0777));
2166 if (err < 0) {
2167 goto out;
2168 }
2169 } else if (perm & P9_STAT_MODE_SOCKET) {
2170 err = v9fs_co_mknod(pdu->s, &fullname, fidp->uid, -1,
2171 0, S_IFSOCK | (perm & 0777));
2172 if (err < 0) {
2173 goto out;
2174 }
2175 } else {
2176 err = v9fs_co_open2(pdu->s, fidp, fullname.data, -1,
2177 omode_to_uflags(mode)|O_CREAT, perm);
2178 if (err < 0) {
2179 goto out;
2180 }
2181 fidp->fid_type = P9_FID_FILE;
7a462745
AK		 2182 fidp->open_flags = omode_to_uflags(mode);
2183 if (fidp->open_flags & O_EXCL) {
2184 /*
2185 * We let the host file system do O_EXCL check
2186 * We should not reclaim such fd
2187 */
2188 fidp->flags |= FID_NON_RECLAIMABLE;
2189 }
c494dd6f 2190 }
baaa86d9
VJ		 2191 err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
2192 if (err < 0) {
2193 fidp->fid_type = P9_FID_NONE;
2194 if (fidp->fs.fd) {
9b54ffaa 2195 v9fs_co_close(pdu->s, fidp->fs.fd);
baaa86d9 2196 }
c494dd6f 2197 goto out;
9f107513 2198 }
baaa86d9
VJ		 2199 iounit = get_iounit(pdu->s, &fidp->path);
2200 v9fs_string_copy(&fidp->path, &fullname);
2201 stat_to_qid(&stbuf, &qid);
2202 offset += pdu_marshal(pdu, offset, "Qd", &qid, iounit);
2203 err = offset;
c494dd6f 2204out:
84dfb926
AK		 2205 put_fid(pdu->s, fidp);
2206out_nofid:
baaa86d9
VJ		 2207 complete_pdu(pdu->s, pdu, err);
2208 v9fs_string_free(&name);
2209 v9fs_string_free(&extension);
2210 v9fs_string_free(&fullname);
9f107513
AL		 2211}
2212
ff06030f 2213static void v9fs_symlink(void *opaque)
08c60fc9 2214{
ff06030f 2215 V9fsPDU *pdu = opaque;
3fa2a8d1
VJ		 2216 V9fsString name;
2217 V9fsString symname;
2218 V9fsString fullname;
2219 V9fsFidState *dfidp;
2220 V9fsQID qid;
2221 struct stat stbuf;
08c60fc9 2222 int32_t dfid;
08c60fc9
VJJ		 2223 int err = 0;
2224 gid_t gid;
3fa2a8d1 2225 size_t offset = 7;
08c60fc9 2226
3fa2a8d1
VJ		 2227 v9fs_string_init(&fullname);
2228 pdu_unmarshal(pdu, offset, "dssd", &dfid, &name, &symname, &gid);
08c60fc9 2229
84dfb926 2230 dfidp = get_fid(pdu->s, dfid);
3fa2a8d1 2231 if (dfidp == NULL) {
08c60fc9 2232 err = -EINVAL;
84dfb926 2233 goto out_nofid;
08c60fc9
VJJ		 2234 }
2235
3fa2a8d1
VJ		 2236 v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
2237 err = v9fs_co_symlink(pdu->s, dfidp, symname.data, fullname.data, gid);
2238 if (err < 0) {
2239 goto out;
2240 }
2241 err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
2242 if (err < 0) {
2243 goto out;
2244 }
2245 stat_to_qid(&stbuf, &qid);
2246 offset += pdu_marshal(pdu, offset, "Q", &qid);
2247 err = offset;
08c60fc9 2248out:
84dfb926
AK		 2249 put_fid(pdu->s, dfidp);
2250out_nofid:
3fa2a8d1
VJ		 2251 complete_pdu(pdu->s, pdu, err);
2252 v9fs_string_free(&name);
2253 v9fs_string_free(&symname);
2254 v9fs_string_free(&fullname);
08c60fc9
VJJ		 2255}
2256
ff06030f 2257static void v9fs_flush(void *opaque)
9f107513 2258{
ff06030f
VJJ		 2259 V9fsPDU *pdu = opaque;
2260 V9fsState *s = pdu->s;
9c5e9d89
AL		 2261 /* A nop call with no return */
2262 complete_pdu(s, pdu, 7);
ff06030f 2263 return;
9f107513
AL		 2264}
2265
ff06030f 2266static void v9fs_link(void *opaque)
b2c224be 2267{
ff06030f
VJJ		 2268 V9fsPDU *pdu = opaque;
2269 V9fsState *s = pdu->s;
b2c224be
VJJ		 2270 int32_t dfid, oldfid;
2271 V9fsFidState *dfidp, *oldfidp;
2272 V9fsString name, fullname;
2273 size_t offset = 7;
2274 int err = 0;
2275
2276 v9fs_string_init(&fullname);
2277
2278 pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2279
84dfb926 2280 dfidp = get_fid(s, dfid);
b2c224be 2281 if (dfidp == NULL) {
ffd66876 2282 err = -ENOENT;
84dfb926 2283 goto out_nofid;
b2c224be
VJJ		 2284 }
2285
84dfb926 2286 oldfidp = get_fid(s, oldfid);
b2c224be 2287 if (oldfidp == NULL) {
ffd66876 2288 err = -ENOENT;
b2c224be
VJJ		 2289 goto out;
2290 }
2291
2292 v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
ffd66876
VJJ		 2293 err = v9fs_co_link(s, &oldfidp->path, &fullname);
2294 if (!err) {
2295 err = offset;
b2c224be
VJJ		 2296 }
2297 v9fs_string_free(&fullname);
2298
2299out:
84dfb926
AK		 2300 put_fid(s, dfidp);
2301out_nofid:
b2c224be
VJJ		 2302 v9fs_string_free(&name);
2303 complete_pdu(s, pdu, err);
2304}
2305
ff06030f 2306static void v9fs_remove(void *opaque)
9f107513 2307{
5bae1900 2308 int32_t fid;
5bae1900 2309 int err = 0;
ae1ef571
VJ		 2310 size_t offset = 7;
2311 V9fsFidState *fidp;
2312 V9fsPDU *pdu = opaque;
5bae1900 2313
ae1ef571 2314 pdu_unmarshal(pdu, offset, "d", &fid);
5bae1900 2315
84dfb926 2316 fidp = get_fid(pdu->s, fid);
ae1ef571 2317 if (fidp == NULL) {
5bae1900 2318 err = -EINVAL;
84dfb926 2319 goto out_nofid;
9f107513 2320 }
7a462745
AK		 2321 /*
2322 * IF the file is unlinked, we cannot reopen
2323 * the file later. So don't reclaim fd
2324 */
2325 err = v9fs_mark_fids_unreclaim(pdu->s, &fidp->path);
2326 if (err < 0) {
2327 goto out_err;
2328 }
ae1ef571
VJ		 2329 err = v9fs_co_remove(pdu->s, &fidp->path);
2330 if (!err) {
2331 err = offset;
2332 }
7a462745 2333out_err:
ae1ef571 2334 /* For TREMOVE we need to clunk the fid even on failed remove */
84dfb926
AK		 2335 clunk_fid(pdu->s, fidp->fid);
2336 put_fid(pdu->s, fidp);
2337out_nofid:
ae1ef571 2338 complete_pdu(pdu->s, pdu, err);
9f107513
AL		 2339}
2340
7834cf77
AK		 2341static void v9fs_unlinkat(void *opaque)
2342{
2343 int err = 0;
2344 V9fsString name;
2345 int32_t dfid, flags;
2346 size_t offset = 7;
2347 V9fsFidState *dfidp;
2348 V9fsPDU *pdu = opaque;
2349 V9fsString full_name;
2350
2351 pdu_unmarshal(pdu, offset, "dsd", &dfid, &name, &flags);
2352
2353 dfidp = get_fid(pdu->s, dfid);
2354 if (dfidp == NULL) {
2355 err = -EINVAL;
2356 goto out_nofid;
2357 }
2358 v9fs_string_init(&full_name);
2359 v9fs_string_sprintf(&full_name, "%s/%s", dfidp->path.data, name.data);
2360 /*
2361 * IF the file is unlinked, we cannot reopen
2362 * the file later. So don't reclaim fd
2363 */
2364 err = v9fs_mark_fids_unreclaim(pdu->s, &full_name);
2365 if (err < 0) {
2366 goto out_err;
2367 }
2368 err = v9fs_co_remove(pdu->s, &full_name);
2369 if (!err) {
2370 err = offset;
2371 }
2372out_err:
2373 put_fid(pdu->s, dfidp);
2374 v9fs_string_free(&full_name);
2375out_nofid:
2376 complete_pdu(pdu->s, pdu, err);
2377 v9fs_string_free(&name);
2378}
2379
930b1e17
AK		 2380static int v9fs_complete_rename(V9fsState *s, V9fsFidState *fidp,
2381 int32_t newdirfid, V9fsString *name)
8cf89e00 2382{
930b1e17 2383 char *end;
c7b4b0b3 2384 int err = 0;
84dfb926 2385 V9fsFidState *dirfidp = NULL;
c7b4b0b3 2386 char *old_name, *new_name;
8cf89e00 2387
930b1e17 2388 if (newdirfid != -1) {
84dfb926 2389 dirfidp = get_fid(s, newdirfid);
c7b4b0b3
MK		 2390 if (dirfidp == NULL) {
2391 err = -ENOENT;
84dfb926 2392 goto out_nofid;
c7b4b0b3 2393 }
d62dbb51 2394 BUG_ON(dirfidp->fid_type != P9_FID_NONE);
8cf89e00 2395
7267c094 2396 new_name = g_malloc0(dirfidp->path.size + name->size + 2);
c7b4b0b3
MK		 2397
2398 strcpy(new_name, dirfidp->path.data);
2399 strcat(new_name, "/");
930b1e17 2400 strcat(new_name + dirfidp->path.size, name->data);
c7b4b0b3 2401 } else {
930b1e17 2402 old_name = fidp->path.data;
8cf89e00
AL		 2403 end = strrchr(old_name, '/');
2404 if (end) {
2405 end++;
2406 } else {
2407 end = old_name;
2408 }
7267c094 2409 new_name = g_malloc0(end - old_name + name->size + 1);
8cf89e00 2410
c7b4b0b3 2411 strncat(new_name, old_name, end - old_name);
930b1e17 2412 strncat(new_name + (end - old_name), name->data, name->size);
c7b4b0b3 2413 }
8cf89e00 2414
930b1e17
AK		 2415 v9fs_string_free(name);
2416 name->data = new_name;
2417 name->size = strlen(new_name);
8cf89e00 2418
930b1e17
AK		 2419 if (strcmp(new_name, fidp->path.data) != 0) {
2420 err = v9fs_co_rename(s, &fidp->path, name);
2421 if (err < 0) {
2422 goto out;
2423 }
2424 V9fsFidState *tfidp;
2425 /*
2426 * Fixup fid's pointing to the old name to
2427 * start pointing to the new name
2428 */
2429 for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) {
2430 if (fidp == tfidp) {
2431 /*
2432 * we replace name of this fid towards the end
2433 * so that our below strcmp will work
2434 */
2435 continue;
2436 }
2437 if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) {
2438 /* replace the name */
2439 v9fs_fix_path(&tfidp->path, name, strlen(fidp->path.data));
8cf89e00
AL		 2440 }
2441 }
930b1e17 2442 v9fs_string_copy(&fidp->path, name);
8cf89e00 2443 }
c7b4b0b3 2444out:
84dfb926
AK		 2445 if (dirfidp) {
2446 put_fid(s, dirfidp);
2447 }
2448out_nofid:
c7b4b0b3
MK		 2449 return err;
2450}
2451
ff06030f 2452static void v9fs_rename(void *opaque)
c7b4b0b3
MK		 2453{
2454 int32_t fid;
c7b4b0b3 2455 ssize_t err = 0;
930b1e17
AK		 2456 size_t offset = 7;
2457 V9fsString name;
2458 int32_t newdirfid;
2459 V9fsFidState *fidp;
2460 V9fsPDU *pdu = opaque;
2461 V9fsState *s = pdu->s;
c7b4b0b3 2462
930b1e17 2463 pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name);
c7b4b0b3 2464
84dfb926 2465 fidp = get_fid(s, fid);
930b1e17 2466 if (fidp == NULL) {
c7b4b0b3 2467 err = -ENOENT;
84dfb926 2468 goto out_nofid;
c7b4b0b3 2469 }
930b1e17 2470 BUG_ON(fidp->fid_type != P9_FID_NONE);
c7b4b0b3 2471
930b1e17
AK		 2472 err = v9fs_complete_rename(s, fidp, newdirfid, &name);
2473 if (!err) {
2474 err = offset;
2475 }
84dfb926
AK		 2476 put_fid(s, fidp);
2477out_nofid:
930b1e17
AK		 2478 complete_pdu(s, pdu, err);
2479 v9fs_string_free(&name);
c7b4b0b3
MK		 2480}
2481
89bf6593
AK		 2482static int v9fs_complete_renameat(V9fsState *s, int32_t olddirfid,
2483 V9fsString *old_name, int32_t newdirfid,
2484 V9fsString *new_name)
2485{
2486 int err = 0;
2487 V9fsString old_full_name, new_full_name;
2488 V9fsFidState *newdirfidp = NULL, *olddirfidp = NULL;
2489
2490 olddirfidp = get_fid(s, olddirfid);
2491 if (olddirfidp == NULL) {
2492 err = -ENOENT;
2493 goto out;
2494 }
2495 v9fs_string_init(&old_full_name);
2496 v9fs_string_init(&new_full_name);
2497
2498 v9fs_string_sprintf(&old_full_name, "%s/%s",
2499 olddirfidp->path.data, old_name->data);
2500 if (newdirfid != -1) {
2501 newdirfidp = get_fid(s, newdirfid);
2502 if (newdirfidp == NULL) {
2503 err = -ENOENT;
2504 goto out;
2505 }
2506 v9fs_string_sprintf(&new_full_name, "%s/%s",
2507 newdirfidp->path.data, new_name->data);
2508 } else {
2509 v9fs_string_sprintf(&new_full_name, "%s/%s",
2510 olddirfidp->path.data, new_name->data);
2511 }
2512
2513 if (strcmp(old_full_name.data, new_full_name.data) != 0) {
2514 V9fsFidState *tfidp;
2515 err = v9fs_co_rename(s, &old_full_name, &new_full_name);
2516 if (err < 0) {
2517 goto out;
2518 }
2519 /*
2520 * Fixup fid's pointing to the old name to
2521 * start pointing to the new name
2522 */
2523 for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) {
2524 if (v9fs_path_is_ancestor(&old_full_name, &tfidp->path)) {
2525 /* replace the name */
2526 v9fs_fix_path(&tfidp->path, &new_full_name, old_full_name.size);
2527 }
2528 }
2529 }
2530out:
2531 if (olddirfidp) {
2532 put_fid(s, olddirfidp);
2533 }
2534 if (newdirfidp) {
2535 put_fid(s, newdirfidp);
2536 }
2537 v9fs_string_free(&old_full_name);
2538 v9fs_string_free(&new_full_name);
2539 return err;
2540}
2541
2542static void v9fs_renameat(void *opaque)
2543{
2544 ssize_t err = 0;
2545 size_t offset = 7;
2546 V9fsPDU *pdu = opaque;
2547 V9fsState *s = pdu->s;
2548 int32_t olddirfid, newdirfid;
2549 V9fsString old_name, new_name;
2550
2551 pdu_unmarshal(pdu, offset, "dsds", &olddirfid,
2552 &old_name, &newdirfid, &new_name);
2553
2554 err = v9fs_complete_renameat(s, olddirfid, &old_name, newdirfid, &new_name);
2555 if (!err) {
2556 err = offset;
2557 }
2558 complete_pdu(s, pdu, err);
2559 v9fs_string_free(&old_name);
2560 v9fs_string_free(&new_name);
2561}
2562
b81d685e 2563static void v9fs_wstat(void *opaque)
8cf89e00 2564{
b81d685e
AK		 2565 int32_t fid;
2566 int err = 0;
2567 int16_t unused;
2568 V9fsStat v9stat;
2569 size_t offset = 7;
2570 struct stat stbuf;
2571 V9fsFidState *fidp;
2572 V9fsPDU *pdu = opaque;
2573 V9fsState *s = pdu->s;
8cf89e00 2574
b81d685e 2575 pdu_unmarshal(pdu, offset, "dwS", &fid, &unused, &v9stat);
84dfb926
AK		 2576
2577 fidp = get_fid(s, fid);
b81d685e
AK		 2578 if (fidp == NULL) {
2579 err = -EINVAL;
84dfb926 2580 goto out_nofid;
8cf89e00 2581 }
b81d685e
AK		 2582 /* do we need to sync the file? */
2583 if (donttouch_stat(&v9stat)) {
2584 err = v9fs_co_fsync(s, fidp, 0);
8cf89e00
AL		 2585 goto out;
2586 }
b81d685e
AK		 2587 if (v9stat.mode != -1) {
2588 uint32_t v9_mode;
2589 err = v9fs_co_lstat(s, &fidp->path, &stbuf);
2590 if (err < 0) {
2591 goto out;
2592 }
2593 v9_mode = stat_to_v9mode(&stbuf);
2594 if ((v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2595 (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2596 /* Attempting to change the type */
2597 err = -EIO;
2598 goto out;
2599 }
2600 err = v9fs_co_chmod(s, &fidp->path,
2601 v9mode_to_mode(v9stat.mode,
2602 &v9stat.extension));
2603 if (err < 0) {
2604 goto out;
2605 }
2606 }
2607 if (v9stat.mtime != -1 || v9stat.atime != -1) {
8fc39ae4 2608 struct timespec times[2];
b81d685e
AK		 2609 if (v9stat.atime != -1) {
2610 times[0].tv_sec = v9stat.atime;
8fc39ae4
SK		 2611 times[0].tv_nsec = 0;
2612 } else {
2613 times[0].tv_nsec = UTIME_OMIT;
2614 }
b81d685e
AK		 2615 if (v9stat.mtime != -1) {
2616 times[1].tv_sec = v9stat.mtime;
8fc39ae4
SK		 2617 times[1].tv_nsec = 0;
2618 } else {
2619 times[1].tv_nsec = UTIME_OMIT;
2620 }
b81d685e
AK		 2621 err = v9fs_co_utimensat(s, &fidp->path, times);
2622 if (err < 0) {
2623 goto out;
8cf89e00
AL		 2624 }
2625 }
b81d685e
AK		 2626 if (v9stat.n_gid != -1 || v9stat.n_uid != -1) {
2627 err = v9fs_co_chown(s, &fidp->path, v9stat.n_uid, v9stat.n_gid);
2628 if (err < 0) {
8cf89e00 2629 goto out;
b81d685e 2630 }
8cf89e00 2631 }
b81d685e
AK		 2632 if (v9stat.name.size != 0) {
2633 err = v9fs_complete_rename(s, fidp, -1, &v9stat.name);
2634 if (err < 0) {
2635 goto out;
2636 }
8cf89e00 2637 }
b81d685e
AK		 2638 if (v9stat.length != -1) {
2639 err = v9fs_co_truncate(s, &fidp->path, v9stat.length);
2640 if (err < 0) {
2641 goto out;
2642 }
8cf89e00 2643 }
b81d685e 2644 err = offset;
8cf89e00 2645out:
84dfb926
AK		 2646 put_fid(s, fidp);
2647out_nofid:
b81d685e
AK		 2648 v9fs_stat_free(&v9stat);
2649 complete_pdu(s, pdu, err);
9f107513
AL		 2650}
2651
88a4763e
AK		 2652static int v9fs_fill_statfs(V9fsState *s, V9fsPDU *pdu, struct statfs *stbuf)
2653{
2654 uint32_t f_type;
2655 uint32_t f_bsize;
2656 uint64_t f_blocks;
2657 uint64_t f_bfree;
2658 uint64_t f_bavail;
2659 uint64_t f_files;
2660 uint64_t f_ffree;
2661 uint64_t fsid_val;
2662 uint32_t f_namelen;
2663 size_t offset = 7;
5e94c103
MK		 2664 int32_t bsize_factor;
2665
5e94c103
MK		 2666 /*
2667 * compute bsize factor based on host file system block size
2668 * and client msize
2669 */
88a4763e 2670 bsize_factor = (s->msize - P9_IOHDRSZ)/stbuf->f_bsize;
5e94c103
MK		 2671 if (!bsize_factor) {
2672 bsize_factor = 1;
2673 }
88a4763e
AK		 2674 f_type = stbuf->f_type;
2675 f_bsize = stbuf->f_bsize;
2676 f_bsize *= bsize_factor;
5e94c103
MK		 2677 /*
2678 * f_bsize is adjusted(multiplied) by bsize factor, so we need to
2679 * adjust(divide) the number of blocks, free blocks and available
2680 * blocks by bsize factor
2681 */
88a4763e
AK		 2682 f_blocks = stbuf->f_blocks/bsize_factor;
2683 f_bfree = stbuf->f_bfree/bsize_factor;
2684 f_bavail = stbuf->f_bavail/bsize_factor;
2685 f_files = stbuf->f_files;
2686 f_ffree = stbuf->f_ffree;
2687 fsid_val = (unsigned int) stbuf->f_fsid.__val[0] |
2688 (unsigned long long)stbuf->f_fsid.__val[1] << 32;
2689 f_namelen = stbuf->f_namelen;
be940c87 2690
88a4763e
AK		 2691 return pdu_marshal(pdu, offset, "ddqqqqqqd",
2692 f_type, f_bsize, f_blocks, f_bfree,
2693 f_bavail, f_files, f_ffree,
2694 fsid_val, f_namelen);
be940c87
MK		 2695}
2696
ff06030f 2697static void v9fs_statfs(void *opaque)
be940c87 2698{
88a4763e
AK		 2699 int32_t fid;
2700 ssize_t retval = 0;
2701 size_t offset = 7;
2702 V9fsFidState *fidp;
2703 struct statfs stbuf;
ff06030f
VJJ		 2704 V9fsPDU *pdu = opaque;
2705 V9fsState *s = pdu->s;
be940c87 2706
88a4763e 2707 pdu_unmarshal(pdu, offset, "d", &fid);
84dfb926 2708 fidp = get_fid(s, fid);
88a4763e
AK		 2709 if (fidp == NULL) {
2710 retval = -ENOENT;
84dfb926 2711 goto out_nofid;
be940c87 2712 }
88a4763e
AK		 2713 retval = v9fs_co_statfs(s, &fidp->path, &stbuf);
2714 if (retval < 0) {
2715 goto out;
2716 }
2717 retval = offset;
2718 retval += v9fs_fill_statfs(s, pdu, &stbuf);
be940c87 2719out:
84dfb926
AK		 2720 put_fid(s, fidp);
2721out_nofid:
88a4763e 2722 complete_pdu(s, pdu, retval);
ff06030f 2723 return;
be940c87
MK		 2724}
2725
ff06030f 2726static void v9fs_mknod(void *opaque)
5268cecc 2727{
1b733fed
AK		 2728
2729 int mode;
2730 gid_t gid;
5268cecc 2731 int32_t fid;
1b733fed 2732 V9fsQID qid;
5268cecc 2733 int err = 0;
5268cecc 2734 int major, minor;
1b733fed
AK		 2735 size_t offset = 7;
2736 V9fsString name;
2737 struct stat stbuf;
2738 V9fsString fullname;
2739 V9fsFidState *fidp;
2740 V9fsPDU *pdu = opaque;
2741 V9fsState *s = pdu->s;
5268cecc 2742
1b733fed
AK		 2743 v9fs_string_init(&fullname);
2744 pdu_unmarshal(pdu, offset, "dsdddd", &fid, &name, &mode,
2745 &major, &minor, &gid);
5268cecc 2746
84dfb926 2747 fidp = get_fid(s, fid);
5268cecc
MK		 2748 if (fidp == NULL) {
2749 err = -ENOENT;
84dfb926 2750 goto out_nofid;
5268cecc 2751 }
1b733fed
AK		 2752 v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
2753 err = v9fs_co_mknod(s, &fullname, fidp->uid, gid,
2754 makedev(major, minor), mode);
2755 if (err < 0) {
2756 goto out;
2757 }
2758 err = v9fs_co_lstat(s, &fullname, &stbuf);
2759 if (err < 0) {
2760 goto out;
2761 }
2762 stat_to_qid(&stbuf, &qid);
2763 err = offset;
2764 err += pdu_marshal(pdu, offset, "Q", &qid);
5268cecc 2765out:
84dfb926
AK		 2766 put_fid(s, fidp);
2767out_nofid:
1b733fed
AK		 2768 complete_pdu(s, pdu, err);
2769 v9fs_string_free(&fullname);
2770 v9fs_string_free(&name);
5268cecc
MK		 2771}
2772
82cc3ee8
MK		 2773/*
2774 * Implement posix byte range locking code
2775 * Server side handling of locking code is very simple, because 9p server in
2776 * QEMU can handle only one client. And most of the lock handling
2777 * (like conflict, merging) etc is done by the VFS layer itself, so no need to
2778 * do any thing in * qemu 9p server side lock code path.
2779 * So when a TLOCK request comes, always return success
2780 */
ff06030f 2781static void v9fs_lock(void *opaque)
82cc3ee8 2782{
0c27bf2a
AK		 2783 int8_t status;
2784 V9fsFlock *flock;
2785 size_t offset = 7;
2786 struct stat stbuf;
2787 V9fsFidState *fidp;
2788 int32_t fid, err = 0;
ff06030f
VJJ		 2789 V9fsPDU *pdu = opaque;
2790 V9fsState *s = pdu->s;
82cc3ee8 2791
0c27bf2a
AK		 2792 flock = g_malloc(sizeof(*flock));
2793 pdu_unmarshal(pdu, offset, "dbdqqds", &fid, &flock->type,
2794 &flock->flags, &flock->start, &flock->length,
2795 &flock->proc_id, &flock->client_id);
2796 status = P9_LOCK_ERROR;
82cc3ee8
MK		 2797
2798 /* We support only block flag now (that too ignored currently) */
0c27bf2a 2799 if (flock->flags & ~P9_LOCK_FLAGS_BLOCK) {
82cc3ee8 2800 err = -EINVAL;
84dfb926 2801 goto out_nofid;
82cc3ee8 2802 }
84dfb926 2803 fidp = get_fid(s, fid);
0c27bf2a 2804 if (fidp == NULL) {
82cc3ee8 2805 err = -ENOENT;
84dfb926 2806 goto out_nofid;
82cc3ee8 2807 }
0c27bf2a 2808 err = v9fs_co_fstat(s, fidp->fs.fd, &stbuf);
82cc3ee8 2809 if (err < 0) {
82cc3ee8
MK		 2810 goto out;
2811 }
0c27bf2a 2812 status = P9_LOCK_SUCCESS;
82cc3ee8 2813out:
84dfb926
AK		 2814 put_fid(s, fidp);
2815out_nofid:
0c27bf2a
AK		 2816 err = offset;
2817 err += pdu_marshal(pdu, offset, "b", status);
2818 complete_pdu(s, pdu, err);
10e72295 2819 v9fs_string_free(&flock->client_id);
0c27bf2a 2820 g_free(flock);
82cc3ee8
MK		 2821}
2822
8f354003
MK		 2823/*
2824 * When a TGETLOCK request comes, always return success because all lock
2825 * handling is done by client's VFS layer.
2826 */
ff06030f 2827static void v9fs_getlock(void *opaque)
8f354003 2828{
e4e414a4
AK		 2829 size_t offset = 7;
2830 struct stat stbuf;
2831 V9fsFidState *fidp;
2832 V9fsGetlock *glock;
2833 int32_t fid, err = 0;
ff06030f
VJJ		 2834 V9fsPDU *pdu = opaque;
2835 V9fsState *s = pdu->s;
8f354003 2836
e4e414a4
AK		 2837 glock = g_malloc(sizeof(*glock));
2838 pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock->type,
2839 &glock->start, &glock->length, &glock->proc_id,
2840 &glock->client_id);
8f354003 2841
84dfb926 2842 fidp = get_fid(s, fid);
e4e414a4 2843 if (fidp == NULL) {
8f354003 2844 err = -ENOENT;
84dfb926 2845 goto out_nofid;
8f354003 2846 }
e4e414a4 2847 err = v9fs_co_fstat(s, fidp->fs.fd, &stbuf);
8f354003 2848 if (err < 0) {
8f354003
MK		 2849 goto out;
2850 }
e4e414a4
AK		 2851 glock->type = F_UNLCK;
2852 offset += pdu_marshal(pdu, offset, "bqqds", glock->type,
2853 glock->start, glock->length, glock->proc_id,
2854 &glock->client_id);
2855 err = offset;
8f354003 2856out:
84dfb926
AK		 2857 put_fid(s, fidp);
2858out_nofid:
e4e414a4 2859 complete_pdu(s, pdu, err);
10e72295 2860 v9fs_string_free(&glock->client_id);
e4e414a4 2861 g_free(glock);
8f354003
MK		 2862}
2863
ff06030f 2864static void v9fs_mkdir(void *opaque)
b67592ea 2865{
ff06030f 2866 V9fsPDU *pdu = opaque;
e84861f7 2867 size_t offset = 7;
b67592ea 2868 int32_t fid;
e84861f7
VJ		 2869 struct stat stbuf;
2870 V9fsString name, fullname;
2871 V9fsQID qid;
b67592ea
MK		 2872 V9fsFidState *fidp;
2873 gid_t gid;
2874 int mode;
e84861f7 2875 int err = 0;
b67592ea 2876
e84861f7
VJ		 2877 v9fs_string_init(&fullname);
2878 pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid);
b67592ea 2879
84dfb926 2880 fidp = get_fid(pdu->s, fid);
b67592ea
MK		 2881 if (fidp == NULL) {
2882 err = -ENOENT;
84dfb926 2883 goto out_nofid;
b67592ea 2884 }
e84861f7
VJ		 2885 v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
2886 err = v9fs_co_mkdir(pdu->s, fullname.data, mode, fidp->uid, gid);
2887 if (err < 0) {
2888 goto out;
2889 }
2890 err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
2891 if (err < 0) {
2892 goto out;
2893 }
2894 stat_to_qid(&stbuf, &qid);
2895 offset += pdu_marshal(pdu, offset, "Q", &qid);
2896 err = offset;
b67592ea 2897out:
84dfb926
AK		 2898 put_fid(pdu->s, fidp);
2899out_nofid:
e84861f7
VJ		 2900 complete_pdu(pdu->s, pdu, err);
2901 v9fs_string_free(&fullname);
2902 v9fs_string_free(&name);
b67592ea
MK		 2903}
2904
ff06030f 2905static void v9fs_xattrwalk(void *opaque)
fa32ef88 2906{
670185a6
AK		 2907 int64_t size;
2908 V9fsString name;
fa32ef88 2909 ssize_t err = 0;
670185a6 2910 size_t offset = 7;
fa32ef88 2911 int32_t fid, newfid;
670185a6 2912 V9fsFidState *file_fidp;
84dfb926 2913 V9fsFidState *xattr_fidp = NULL;
670185a6
AK		 2914 V9fsPDU *pdu = opaque;
2915 V9fsState *s = pdu->s;
fa32ef88 2916
670185a6 2917 pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
84dfb926 2918 file_fidp = get_fid(s, fid);
670185a6 2919 if (file_fidp == NULL) {
fa32ef88 2920 err = -ENOENT;
84dfb926 2921 goto out_nofid;
fa32ef88 2922 }
670185a6
AK		 2923 xattr_fidp = alloc_fid(s, newfid);
2924 if (xattr_fidp == NULL) {
fa32ef88
AK		 2925 err = -EINVAL;
2926 goto out;
2927 }
670185a6
AK		 2928 v9fs_string_copy(&xattr_fidp->path, &file_fidp->path);
2929 if (name.data[0] == 0) {
fa32ef88
AK		 2930 /*
2931 * listxattr request. Get the size first
2932 */
670185a6
AK		 2933 size = v9fs_co_llistxattr(s, &xattr_fidp->path, NULL, 0);
2934 if (size < 0) {
2935 err = size;
84dfb926 2936 clunk_fid(s, xattr_fidp->fid);
670185a6 2937 goto out;
fa32ef88 2938 }
670185a6
AK		 2939 /*
2940 * Read the xattr value
2941 */
2942 xattr_fidp->fs.xattr.len = size;
2943 xattr_fidp->fid_type = P9_FID_XATTR;
2944 xattr_fidp->fs.xattr.copied_len = -1;
2945 if (size) {
7267c094 2946 xattr_fidp->fs.xattr.value = g_malloc(size);
670185a6
AK		 2947 err = v9fs_co_llistxattr(s, &xattr_fidp->path,
2948 xattr_fidp->fs.xattr.value,
2949 xattr_fidp->fs.xattr.len);
2950 if (err < 0) {
84dfb926 2951 clunk_fid(s, xattr_fidp->fid);
670185a6
AK		 2952 goto out;
2953 }
2954 }
2955 offset += pdu_marshal(pdu, offset, "q", size);
2956 err = offset;
fa32ef88
AK		 2957 } else {
2958 /*
2959 * specific xattr fid. We check for xattr
2960 * presence also collect the xattr size
2961 */
670185a6
AK		 2962 size = v9fs_co_lgetxattr(s, &xattr_fidp->path,
2963 &name, NULL, 0);
2964 if (size < 0) {
2965 err = size;
84dfb926 2966 clunk_fid(s, xattr_fidp->fid);
670185a6 2967 goto out;
fa32ef88 2968 }
670185a6
AK		 2969 /*
2970 * Read the xattr value
2971 */
2972 xattr_fidp->fs.xattr.len = size;
2973 xattr_fidp->fid_type = P9_FID_XATTR;
2974 xattr_fidp->fs.xattr.copied_len = -1;
2975 if (size) {
7267c094 2976 xattr_fidp->fs.xattr.value = g_malloc(size);
670185a6
AK		 2977 err = v9fs_co_lgetxattr(s, &xattr_fidp->path,
2978 &name, xattr_fidp->fs.xattr.value,
2979 xattr_fidp->fs.xattr.len);
2980 if (err < 0) {
84dfb926 2981 clunk_fid(s, xattr_fidp->fid);
670185a6
AK		 2982 goto out;
2983 }
2984 }
2985 offset += pdu_marshal(pdu, offset, "q", size);
2986 err = offset;
fa32ef88
AK		 2987 }
2988out:
84dfb926
AK		 2989 put_fid(s, file_fidp);
2990 if (xattr_fidp) {
2991 put_fid(s, xattr_fidp);
2992 }
2993out_nofid:
670185a6
AK		 2994 complete_pdu(s, pdu, err);
2995 v9fs_string_free(&name);
fa32ef88
AK		 2996}
2997
ff06030f 2998static void v9fs_xattrcreate(void *opaque)
10b468bd
AK		 2999{
3000 int flags;
3001 int32_t fid;
f10ff58d 3002 int64_t size;
10b468bd 3003 ssize_t err = 0;
f10ff58d
AK		 3004 V9fsString name;
3005 size_t offset = 7;
3006 V9fsFidState *file_fidp;
3007 V9fsFidState *xattr_fidp;
3008 V9fsPDU *pdu = opaque;
3009 V9fsState *s = pdu->s;
10b468bd 3010
f10ff58d
AK		 3011 pdu_unmarshal(pdu, offset, "dsqd",
3012 &fid, &name, &size, &flags);
10b468bd 3013
84dfb926 3014 file_fidp = get_fid(s, fid);
f10ff58d 3015 if (file_fidp == NULL) {
10b468bd 3016 err = -EINVAL;
84dfb926 3017 goto out_nofid;
10b468bd 3018 }
10b468bd 3019 /* Make the file fid point to xattr */
f10ff58d
AK		 3020 xattr_fidp = file_fidp;
3021 xattr_fidp->fid_type = P9_FID_XATTR;
3022 xattr_fidp->fs.xattr.copied_len = 0;
3023 xattr_fidp->fs.xattr.len = size;
3024 xattr_fidp->fs.xattr.flags = flags;
3025 v9fs_string_init(&xattr_fidp->fs.xattr.name);
3026 v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
3027 if (size) {
7267c094 3028 xattr_fidp->fs.xattr.value = g_malloc(size);
f10ff58d
AK		 3029 } else {
3030 xattr_fidp->fs.xattr.value = NULL;
3031 }
3032 err = offset;
84dfb926
AK		 3033 put_fid(s, file_fidp);
3034out_nofid:
f10ff58d
AK		 3035 complete_pdu(s, pdu, err);
3036 v9fs_string_free(&name);
10b468bd 3037}
fa32ef88 3038
ff06030f 3039static void v9fs_readlink(void *opaque)
df0973a4 3040{
ff06030f 3041 V9fsPDU *pdu = opaque;
7a5ca31e
VJ		 3042 size_t offset = 7;
3043 V9fsString target;
df0973a4 3044 int32_t fid;
df0973a4
MK		 3045 int err = 0;
3046 V9fsFidState *fidp;
3047
7a5ca31e 3048 pdu_unmarshal(pdu, offset, "d", &fid);
84dfb926 3049 fidp = get_fid(pdu->s, fid);
df0973a4
MK		 3050 if (fidp == NULL) {
3051 err = -ENOENT;
84dfb926 3052 goto out_nofid;
df0973a4
MK		 3053 }
3054
7a5ca31e
VJ		 3055 v9fs_string_init(&target);
3056 err = v9fs_co_readlink(pdu->s, &fidp->path, &target);
3057 if (err < 0) {
3058 goto out;
3059 }
3060 offset += pdu_marshal(pdu, offset, "s", &target);
3061 err = offset;
3062 v9fs_string_free(&target);
df0973a4 3063out:
84dfb926
AK		 3064 put_fid(pdu->s, fidp);
3065out_nofid:
7a5ca31e 3066 complete_pdu(pdu->s, pdu, err);
df0973a4
MK		 3067}
3068
ff06030f 3069static CoroutineEntry *pdu_co_handlers[] = {
c18e2f94 3070 [P9_TREADDIR] = v9fs_readdir,
be940c87 3071 [P9_TSTATFS] = v9fs_statfs,
00ede4c2 3072 [P9_TGETATTR] = v9fs_getattr,
c79ce737 3073 [P9_TSETATTR] = v9fs_setattr,
fa32ef88 3074 [P9_TXATTRWALK] = v9fs_xattrwalk,
10b468bd 3075 [P9_TXATTRCREATE] = v9fs_xattrcreate,
5268cecc 3076 [P9_TMKNOD] = v9fs_mknod,
c7b4b0b3 3077 [P9_TRENAME] = v9fs_rename,
82cc3ee8 3078 [P9_TLOCK] = v9fs_lock,
8f354003 3079 [P9_TGETLOCK] = v9fs_getlock,
89bf6593 3080 [P9_TRENAMEAT] = v9fs_renameat,
df0973a4 3081 [P9_TREADLINK] = v9fs_readlink,
7834cf77 3082 [P9_TUNLINKAT] = v9fs_unlinkat,
b67592ea 3083 [P9_TMKDIR] = v9fs_mkdir,
9f107513 3084 [P9_TVERSION] = v9fs_version,
771e9d4c 3085 [P9_TLOPEN] = v9fs_open,
9f107513
AL		 3086 [P9_TATTACH] = v9fs_attach,
3087 [P9_TSTAT] = v9fs_stat,
3088 [P9_TWALK] = v9fs_walk,
3089 [P9_TCLUNK] = v9fs_clunk,
b41e95d3 3090 [P9_TFSYNC] = v9fs_fsync,
9f107513
AL		 3091 [P9_TOPEN] = v9fs_open,
3092 [P9_TREAD] = v9fs_read,
3093#if 0
3094 [P9_TAUTH] = v9fs_auth,
3095#endif
3096 [P9_TFLUSH] = v9fs_flush,
b2c224be 3097 [P9_TLINK] = v9fs_link,
08c60fc9 3098 [P9_TSYMLINK] = v9fs_symlink,
9f107513 3099 [P9_TCREATE] = v9fs_create,
c1568af5 3100 [P9_TLCREATE] = v9fs_lcreate,
9f107513
AL		 3101 [P9_TWRITE] = v9fs_write,
3102 [P9_TWSTAT] = v9fs_wstat,
3103 [P9_TREMOVE] = v9fs_remove,
3104};
3105
ff06030f 3106static void v9fs_op_not_supp(void *opaque)
5c3234c6 3107{
ff06030f
VJJ		 3108 V9fsPDU *pdu = opaque;
3109 complete_pdu(pdu->s, pdu, -EOPNOTSUPP);
5c3234c6
AK		 3110}
3111
9f107513
AL		 3112static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
3113{
ff06030f
VJJ		 3114 Coroutine *co;
3115 CoroutineEntry *handler;
9f107513
AL		 3116
3117 if (debug_9p_pdu) {
3118 pprint_pdu(pdu);
3119 }
ff06030f
VJJ		 3120 if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) ||
3121 (pdu_co_handlers[pdu->id] == NULL)) {
5c3234c6
AK		 3122 handler = v9fs_op_not_supp;
3123 } else {
ff06030f 3124 handler = pdu_co_handlers[pdu->id];
5c3234c6 3125 }
ff06030f
VJJ		 3126 co = qemu_coroutine_create(handler);
3127 qemu_coroutine_enter(co, pdu);
9f107513
AL		 3128}
3129
f4f61d27 3130void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
9f107513
AL		 3131{
3132 V9fsState *s = (V9fsState *)vdev;
3133 V9fsPDU *pdu;
3134 ssize_t len;
3135
3136 while ((pdu = alloc_pdu(s)) &&
3137 (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
3138 uint8_t *ptr;
ff06030f 3139 pdu->s = s;
9f107513
AL		 3140 BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
3141 BUG_ON(pdu->elem.out_sg[0].iov_len < 7);
3142
3143 ptr = pdu->elem.out_sg[0].iov_base;
3144
3145 memcpy(&pdu->size, ptr, 4);
3146 pdu->id = ptr[4];
3147 memcpy(&pdu->tag, ptr + 5, 2);
9f107513
AL		 3148 submit_pdu(s, pdu);
3149 }
9f107513
AL		 3150 free_pdu(s, pdu);
3151}
7a462745
AK		 3152
3153void virtio_9p_set_fd_limit(void)
3154{
3155 struct rlimit rlim;
3156 if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
3157 fprintf(stderr, "Failed to get the resource limit\n");
3158 exit(1);
3159 }
3160 open_fd_hw = rlim.rlim_cur - MIN(400, rlim.rlim_cur/3);
3161 open_fd_rc = rlim.rlim_cur/2;
3162}
Qemu copy for testing