]> git.proxmox.com Git - mirror_qemu.git/blame_incremental - hw/9pfs/9p.c
projects / mirror_qemu.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
9p: linux: Fix a couple Linux assumptions
[mirror_qemu.git] / hw / 9pfs / 9p.c
... / ...
CommitLineData
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/*
15 * Not so fast! You might want to read the 9p developer docs first:
16 * https://wiki.qemu.org/Documentation/9p
17 */
18
19#include "qemu/osdep.h"
20#include <glib/gprintf.h>
21#include "hw/virtio/virtio.h"
22#include "qapi/error.h"
23#include "qemu/error-report.h"
24#include "qemu/iov.h"
25#include "qemu/main-loop.h"
26#include "qemu/sockets.h"
27#include "virtio-9p.h"
28#include "fsdev/qemu-fsdev.h"
29#include "9p-xattr.h"
30#include "coth.h"
31#include "trace.h"
32#include "migration/blocker.h"
33#include "qemu/xxhash.h"
34#include <math.h>
35#ifdef CONFIG_LINUX
36#include <linux/limits.h>
37#else
38#include <limits.h>
39#endif
40
41int open_fd_hw;
42int total_open_fd;
43static int open_fd_rc;
44
45enum {
46 Oread = 0x00,
47 Owrite = 0x01,
48 Ordwr = 0x02,
49 Oexec = 0x03,
50 Oexcl = 0x04,
51 Otrunc = 0x10,
52 Orexec = 0x20,
53 Orclose = 0x40,
54 Oappend = 0x80,
55};
56
57P9ARRAY_DEFINE_TYPE(V9fsPath, v9fs_path_free);
58
59static ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
60{
61 ssize_t ret;
62 va_list ap;
63
64 va_start(ap, fmt);
65 ret = pdu->s->transport->pdu_vmarshal(pdu, offset, fmt, ap);
66 va_end(ap);
67
68 return ret;
69}
70
71static ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
72{
73 ssize_t ret;
74 va_list ap;
75
76 va_start(ap, fmt);
77 ret = pdu->s->transport->pdu_vunmarshal(pdu, offset, fmt, ap);
78 va_end(ap);
79
80 return ret;
81}
82
83static int omode_to_uflags(int8_t mode)
84{
85 int ret = 0;
86
87 switch (mode & 3) {
88 case Oread:
89 ret = O_RDONLY;
90 break;
91 case Ordwr:
92 ret = O_RDWR;
93 break;
94 case Owrite:
95 ret = O_WRONLY;
96 break;
97 case Oexec:
98 ret = O_RDONLY;
99 break;
100 }
101
102 if (mode & Otrunc) {
103 ret |= O_TRUNC;
104 }
105
106 if (mode & Oappend) {
107 ret |= O_APPEND;
108 }
109
110 if (mode & Oexcl) {
111 ret |= O_EXCL;
112 }
113
114 return ret;
115}
116
117typedef struct DotlOpenflagMap {
118 int dotl_flag;
119 int open_flag;
120} DotlOpenflagMap;
121
122static int dotl_to_open_flags(int flags)
123{
124 int i;
125 /*
126 * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY
127 * and P9_DOTL_NOACCESS
128 */
129 int oflags = flags & O_ACCMODE;
130
131 DotlOpenflagMap dotl_oflag_map[] = {
132 { P9_DOTL_CREATE, O_CREAT },
133 { P9_DOTL_EXCL, O_EXCL },
134 { P9_DOTL_NOCTTY , O_NOCTTY },
135 { P9_DOTL_TRUNC, O_TRUNC },
136 { P9_DOTL_APPEND, O_APPEND },
137 { P9_DOTL_NONBLOCK, O_NONBLOCK } ,
138 { P9_DOTL_DSYNC, O_DSYNC },
139 { P9_DOTL_FASYNC, FASYNC },
140 { P9_DOTL_DIRECT, O_DIRECT },
141 { P9_DOTL_LARGEFILE, O_LARGEFILE },
142 { P9_DOTL_DIRECTORY, O_DIRECTORY },
143 { P9_DOTL_NOFOLLOW, O_NOFOLLOW },
144 { P9_DOTL_NOATIME, O_NOATIME },
145 { P9_DOTL_SYNC, O_SYNC },
146 };
147
148 for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) {
149 if (flags & dotl_oflag_map[i].dotl_flag) {
150 oflags |= dotl_oflag_map[i].open_flag;
151 }
152 }
153
154 return oflags;
155}
156
157void cred_init(FsCred *credp)
158{
159 credp->fc_uid = -1;
160 credp->fc_gid = -1;
161 credp->fc_mode = -1;
162 credp->fc_rdev = -1;
163}
164
165static int get_dotl_openflags(V9fsState *s, int oflags)
166{
167 int flags;
168 /*
169 * Filter the client open flags
170 */
171 flags = dotl_to_open_flags(oflags);
172 flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
173 /*
174 * Ignore direct disk access hint until the server supports it.
175 */
176 flags &= ~O_DIRECT;
177 return flags;
178}
179
180void v9fs_path_init(V9fsPath *path)
181{
182 path->data = NULL;
183 path->size = 0;
184}
185
186void v9fs_path_free(V9fsPath *path)
187{
188 g_free(path->data);
189 path->data = NULL;
190 path->size = 0;
191}
192
193
194void GCC_FMT_ATTR(2, 3)
195v9fs_path_sprintf(V9fsPath *path, const char *fmt, ...)
196{
197 va_list ap;
198
199 v9fs_path_free(path);
200
201 va_start(ap, fmt);
202 /* Bump the size for including terminating NULL */
203 path->size = g_vasprintf(&path->data, fmt, ap) + 1;
204 va_end(ap);
205}
206
207void v9fs_path_copy(V9fsPath *dst, const V9fsPath *src)
208{
209 v9fs_path_free(dst);
210 dst->size = src->size;
211 dst->data = g_memdup(src->data, src->size);
212}
213
214int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath,
215 const char *name, V9fsPath *path)
216{
217 int err;
218 err = s->ops->name_to_path(&s->ctx, dirpath, name, path);
219 if (err < 0) {
220 err = -errno;
221 }
222 return err;
223}
224
225/*
226 * Return TRUE if s1 is an ancestor of s2.
227 *
228 * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".
229 * As a special case, We treat s1 as ancestor of s2 if they are same!
230 */
231static int v9fs_path_is_ancestor(V9fsPath *s1, V9fsPath *s2)
232{
233 if (!strncmp(s1->data, s2->data, s1->size - 1)) {
234 if (s2->data[s1->size - 1] == '\0' || s2->data[s1->size - 1] == '/') {
235 return 1;
236 }
237 }
238 return 0;
239}
240
241static size_t v9fs_string_size(V9fsString *str)
242{
243 return str->size;
244}
245
246/*
247 * returns 0 if fid got re-opened, 1 if not, < 0 on error */
248static int coroutine_fn v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f)
249{
250 int err = 1;
251 if (f->fid_type == P9_FID_FILE) {
252 if (f->fs.fd == -1) {
253 do {
254 err = v9fs_co_open(pdu, f, f->open_flags);
255 } while (err == -EINTR && !pdu->cancelled);
256 }
257 } else if (f->fid_type == P9_FID_DIR) {
258 if (f->fs.dir.stream == NULL) {
259 do {
260 err = v9fs_co_opendir(pdu, f);
261 } while (err == -EINTR && !pdu->cancelled);
262 }
263 }
264 return err;
265}
266
267static V9fsFidState *coroutine_fn get_fid(V9fsPDU *pdu, int32_t fid)
268{
269 int err;
270 V9fsFidState *f;
271 V9fsState *s = pdu->s;
272
273 QSIMPLEQ_FOREACH(f, &s->fid_list, next) {
274 BUG_ON(f->clunked);
275 if (f->fid == fid) {
276 /*
277 * Update the fid ref upfront so that
278 * we don't get reclaimed when we yield
279 * in open later.
280 */
281 f->ref++;
282 /*
283 * check whether we need to reopen the
284 * file. We might have closed the fd
285 * while trying to free up some file
286 * descriptors.
287 */
288 err = v9fs_reopen_fid(pdu, f);
289 if (err < 0) {
290 f->ref--;
291 return NULL;
292 }
293 /*
294 * Mark the fid as referenced so that the LRU
295 * reclaim won't close the file descriptor
296 */
297 f->flags |= FID_REFERENCED;
298 return f;
299 }
300 }
301 return NULL;
302}
303
304static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
305{
306 V9fsFidState *f;
307
308 QSIMPLEQ_FOREACH(f, &s->fid_list, next) {
309 /* If fid is already there return NULL */
310 BUG_ON(f->clunked);
311 if (f->fid == fid) {
312 return NULL;
313 }
314 }
315 f = g_malloc0(sizeof(V9fsFidState));
316 f->fid = fid;
317 f->fid_type = P9_FID_NONE;
318 f->ref = 1;
319 /*
320 * Mark the fid as referenced so that the LRU
321 * reclaim won't close the file descriptor
322 */
323 f->flags |= FID_REFERENCED;
324 QSIMPLEQ_INSERT_TAIL(&s->fid_list, f, next);
325
326 v9fs_readdir_init(s->proto_version, &f->fs.dir);
327 v9fs_readdir_init(s->proto_version, &f->fs_reclaim.dir);
328
329 return f;
330}
331
332static int coroutine_fn v9fs_xattr_fid_clunk(V9fsPDU *pdu, V9fsFidState *fidp)
333{
334 int retval = 0;
335
336 if (fidp->fs.xattr.xattrwalk_fid) {
337 /* getxattr/listxattr fid */
338 goto free_value;
339 }
340 /*
341 * if this is fid for setxattr. clunk should
342 * result in setxattr localcall
343 */
344 if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
345 /* clunk after partial write */
346 retval = -EINVAL;
347 goto free_out;
348 }
349 if (fidp->fs.xattr.len) {
350 retval = v9fs_co_lsetxattr(pdu, &fidp->path, &fidp->fs.xattr.name,
351 fidp->fs.xattr.value,
352 fidp->fs.xattr.len,
353 fidp->fs.xattr.flags);
354 } else {
355 retval = v9fs_co_lremovexattr(pdu, &fidp->path, &fidp->fs.xattr.name);
356 }
357free_out:
358 v9fs_string_free(&fidp->fs.xattr.name);
359free_value:
360 g_free(fidp->fs.xattr.value);
361 return retval;
362}
363
364static int coroutine_fn free_fid(V9fsPDU *pdu, V9fsFidState *fidp)
365{
366 int retval = 0;
367
368 if (fidp->fid_type == P9_FID_FILE) {
369 /* If we reclaimed the fd no need to close */
370 if (fidp->fs.fd != -1) {
371 retval = v9fs_co_close(pdu, &fidp->fs);
372 }
373 } else if (fidp->fid_type == P9_FID_DIR) {
374 if (fidp->fs.dir.stream != NULL) {
375 retval = v9fs_co_closedir(pdu, &fidp->fs);
376 }
377 } else if (fidp->fid_type == P9_FID_XATTR) {
378 retval = v9fs_xattr_fid_clunk(pdu, fidp);
379 }
380 v9fs_path_free(&fidp->path);
381 g_free(fidp);
382 return retval;
383}
384
385static int coroutine_fn put_fid(V9fsPDU *pdu, V9fsFidState *fidp)
386{
387 BUG_ON(!fidp->ref);
388 fidp->ref--;
389 /*
390 * Don't free the fid if it is in reclaim list
391 */
392 if (!fidp->ref && fidp->clunked) {
393 if (fidp->fid == pdu->s->root_fid) {
394 /*
395 * if the clunked fid is root fid then we
396 * have unmounted the fs on the client side.
397 * delete the migration blocker. Ideally, this
398 * should be hooked to transport close notification
399 */
400 if (pdu->s->migration_blocker) {
401 migrate_del_blocker(pdu->s->migration_blocker);
402 error_free(pdu->s->migration_blocker);
403 pdu->s->migration_blocker = NULL;
404 }
405 }
406 return free_fid(pdu, fidp);
407 }
408 return 0;
409}
410
411static V9fsFidState *clunk_fid(V9fsState *s, int32_t fid)
412{
413 V9fsFidState *fidp;
414
415 QSIMPLEQ_FOREACH(fidp, &s->fid_list, next) {
416 if (fidp->fid == fid) {
417 QSIMPLEQ_REMOVE(&s->fid_list, fidp, V9fsFidState, next);
418 fidp->clunked = true;
419 return fidp;
420 }
421 }
422 return NULL;
423}
424
425void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu)
426{
427 int reclaim_count = 0;
428 V9fsState *s = pdu->s;
429 V9fsFidState *f;
430 QSLIST_HEAD(, V9fsFidState) reclaim_list =
431 QSLIST_HEAD_INITIALIZER(reclaim_list);
432
433 QSIMPLEQ_FOREACH(f, &s->fid_list, next) {
434 /*
435 * Unlink fids cannot be reclaimed. Check
436 * for them and skip them. Also skip fids
437 * currently being operated on.
438 */
439 if (f->ref || f->flags & FID_NON_RECLAIMABLE) {
440 continue;
441 }
442 /*
443 * if it is a recently referenced fid
444 * we leave the fid untouched and clear the
445 * reference bit. We come back to it later
446 * in the next iteration. (a simple LRU without
447 * moving list elements around)
448 */
449 if (f->flags & FID_REFERENCED) {
450 f->flags &= ~FID_REFERENCED;
451 continue;
452 }
453 /*
454 * Add fids to reclaim list.
455 */
456 if (f->fid_type == P9_FID_FILE) {
457 if (f->fs.fd != -1) {
458 /*
459 * Up the reference count so that
460 * a clunk request won't free this fid
461 */
462 f->ref++;
463 QSLIST_INSERT_HEAD(&reclaim_list, f, reclaim_next);
464 f->fs_reclaim.fd = f->fs.fd;
465 f->fs.fd = -1;
466 reclaim_count++;
467 }
468 } else if (f->fid_type == P9_FID_DIR) {
469 if (f->fs.dir.stream != NULL) {
470 /*
471 * Up the reference count so that
472 * a clunk request won't free this fid
473 */
474 f->ref++;
475 QSLIST_INSERT_HEAD(&reclaim_list, f, reclaim_next);
476 f->fs_reclaim.dir.stream = f->fs.dir.stream;
477 f->fs.dir.stream = NULL;
478 reclaim_count++;
479 }
480 }
481 if (reclaim_count >= open_fd_rc) {
482 break;
483 }
484 }
485 /*
486 * Now close the fid in reclaim list. Free them if they
487 * are already clunked.
488 */
489 while (!QSLIST_EMPTY(&reclaim_list)) {
490 f = QSLIST_FIRST(&reclaim_list);
491 QSLIST_REMOVE(&reclaim_list, f, V9fsFidState, reclaim_next);
492 if (f->fid_type == P9_FID_FILE) {
493 v9fs_co_close(pdu, &f->fs_reclaim);
494 } else if (f->fid_type == P9_FID_DIR) {
495 v9fs_co_closedir(pdu, &f->fs_reclaim);
496 }
497 /*
498 * Now drop the fid reference, free it
499 * if clunked.
500 */
501 put_fid(pdu, f);
502 }
503}
504
505static int coroutine_fn v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *path)
506{
507 int err;
508 V9fsState *s = pdu->s;
509 V9fsFidState *fidp, *fidp_next;
510
511 fidp = QSIMPLEQ_FIRST(&s->fid_list);
512 if (!fidp) {
513 return 0;
514 }
515
516 /*
517 * v9fs_reopen_fid() can yield : a reference on the fid must be held
518 * to ensure its pointer remains valid and we can safely pass it to
519 * QSIMPLEQ_NEXT(). The corresponding put_fid() can also yield so
520 * we must keep a reference on the next fid as well. So the logic here
521 * is to get a reference on a fid and only put it back during the next
522 * iteration after we could get a reference on the next fid. Start with
523 * the first one.
524 */
525 for (fidp->ref++; fidp; fidp = fidp_next) {
526 if (fidp->path.size == path->size &&
527 !memcmp(fidp->path.data, path->data, path->size)) {
528 /* Mark the fid non reclaimable. */
529 fidp->flags |= FID_NON_RECLAIMABLE;
530
531 /* reopen the file/dir if already closed */
532 err = v9fs_reopen_fid(pdu, fidp);
533 if (err < 0) {
534 put_fid(pdu, fidp);
535 return err;
536 }
537 }
538
539 fidp_next = QSIMPLEQ_NEXT(fidp, next);
540
541 if (fidp_next) {
542 /*
543 * Ensure the next fid survives a potential clunk request during
544 * put_fid() below and v9fs_reopen_fid() in the next iteration.
545 */
546 fidp_next->ref++;
547 }
548
549 /* We're done with this fid */
550 put_fid(pdu, fidp);
551 }
552
553 return 0;
554}
555
556static void coroutine_fn virtfs_reset(V9fsPDU *pdu)
557{
558 V9fsState *s = pdu->s;
559 V9fsFidState *fidp;
560
561 /* Free all fids */
562 while (!QSIMPLEQ_EMPTY(&s->fid_list)) {
563 /* Get fid */
564 fidp = QSIMPLEQ_FIRST(&s->fid_list);
565 fidp->ref++;
566
567 /* Clunk fid */
568 QSIMPLEQ_REMOVE(&s->fid_list, fidp, V9fsFidState, next);
569 fidp->clunked = true;
570
571 put_fid(pdu, fidp);
572 }
573}
574
575#define P9_QID_TYPE_DIR 0x80
576#define P9_QID_TYPE_SYMLINK 0x02
577
578#define P9_STAT_MODE_DIR 0x80000000
579#define P9_STAT_MODE_APPEND 0x40000000
580#define P9_STAT_MODE_EXCL 0x20000000
581#define P9_STAT_MODE_MOUNT 0x10000000
582#define P9_STAT_MODE_AUTH 0x08000000
583#define P9_STAT_MODE_TMP 0x04000000
584#define P9_STAT_MODE_SYMLINK 0x02000000
585#define P9_STAT_MODE_LINK 0x01000000
586#define P9_STAT_MODE_DEVICE 0x00800000
587#define P9_STAT_MODE_NAMED_PIPE 0x00200000
588#define P9_STAT_MODE_SOCKET 0x00100000
589#define P9_STAT_MODE_SETUID 0x00080000
590#define P9_STAT_MODE_SETGID 0x00040000
591#define P9_STAT_MODE_SETVTX 0x00010000
592
593#define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR | \
594 P9_STAT_MODE_SYMLINK | \
595 P9_STAT_MODE_LINK | \
596 P9_STAT_MODE_DEVICE | \
597 P9_STAT_MODE_NAMED_PIPE | \
598 P9_STAT_MODE_SOCKET)
599
600/* Mirrors all bits of a byte. So e.g. binary 10100000 would become 00000101. */
601static inline uint8_t mirror8bit(uint8_t byte)
602{
603 return (byte * 0x0202020202ULL & 0x010884422010ULL) % 1023;
604}
605
606/* Same as mirror8bit() just for a 64 bit data type instead for a byte. */
607static inline uint64_t mirror64bit(uint64_t value)
608{
609 return ((uint64_t)mirror8bit(value & 0xff) << 56) |
610 ((uint64_t)mirror8bit((value >> 8) & 0xff) << 48) |
611 ((uint64_t)mirror8bit((value >> 16) & 0xff) << 40) |
612 ((uint64_t)mirror8bit((value >> 24) & 0xff) << 32) |
613 ((uint64_t)mirror8bit((value >> 32) & 0xff) << 24) |
614 ((uint64_t)mirror8bit((value >> 40) & 0xff) << 16) |
615 ((uint64_t)mirror8bit((value >> 48) & 0xff) << 8) |
616 ((uint64_t)mirror8bit((value >> 56) & 0xff));
617}
618
619/**
620 * @brief Parameter k for the Exponential Golomb algorihm to be used.
621 *
622 * The smaller this value, the smaller the minimum bit count for the Exp.
623 * Golomb generated affixes will be (at lowest index) however for the
624 * price of having higher maximum bit count of generated affixes (at highest
625 * index). Likewise increasing this parameter yields in smaller maximum bit
626 * count for the price of having higher minimum bit count.
627 *
628 * In practice that means: a good value for k depends on the expected amount
629 * of devices to be exposed by one export. For a small amount of devices k
630 * should be small, for a large amount of devices k might be increased
631 * instead. The default of k=0 should be fine for most users though.
632 *
633 * @b IMPORTANT: In case this ever becomes a runtime parameter; the value of
634 * k should not change as long as guest is still running! Because that would
635 * cause completely different inode numbers to be generated on guest.
636 */
637#define EXP_GOLOMB_K 0
638
639/**
640 * @brief Exponential Golomb algorithm for arbitrary k (including k=0).
641 *
642 * The Exponential Golomb algorithm generates @b prefixes (@b not suffixes!)
643 * with growing length and with the mathematical property of being
644 * "prefix-free". The latter means the generated prefixes can be prepended
645 * in front of arbitrary numbers and the resulting concatenated numbers are
646 * guaranteed to be always unique.
647 *
648 * This is a minor adjustment to the original Exp. Golomb algorithm in the
649 * sense that lowest allowed index (@param n) starts with 1, not with zero.
650 *
651 * @param n - natural number (or index) of the prefix to be generated
652 * (1, 2, 3, ...)
653 * @param k - parameter k of Exp. Golomb algorithm to be used
654 * (see comment on EXP_GOLOMB_K macro for details about k)
655 */
656static VariLenAffix expGolombEncode(uint64_t n, int k)
657{
658 const uint64_t value = n + (1 << k) - 1;
659 const int bits = (int) log2(value) + 1;
660 return (VariLenAffix) {
661 .type = AffixType_Prefix,
662 .value = value,
663 .bits = bits + MAX((bits - 1 - k), 0)
664 };
665}
666
667/**
668 * @brief Converts a suffix into a prefix, or a prefix into a suffix.
669 *
670 * Simply mirror all bits of the affix value, for the purpose to preserve
671 * respectively the mathematical "prefix-free" or "suffix-free" property
672 * after the conversion.
673 *
674 * If a passed prefix is suitable to create unique numbers, then the
675 * returned suffix is suitable to create unique numbers as well (and vice
676 * versa).
677 */
678static VariLenAffix invertAffix(const VariLenAffix *affix)
679{
680 return (VariLenAffix) {
681 .type =
682 (affix->type == AffixType_Suffix) ?
683 AffixType_Prefix : AffixType_Suffix,
684 .value =
685 mirror64bit(affix->value) >>
686 ((sizeof(affix->value) * 8) - affix->bits),
687 .bits = affix->bits
688 };
689}
690
691/**
692 * @brief Generates suffix numbers with "suffix-free" property.
693 *
694 * This is just a wrapper function on top of the Exp. Golomb algorithm.
695 *
696 * Since the Exp. Golomb algorithm generates prefixes, but we need suffixes,
697 * this function converts the Exp. Golomb prefixes into appropriate suffixes
698 * which are still suitable for generating unique numbers.
699 *
700 * @param n - natural number (or index) of the suffix to be generated
701 * (1, 2, 3, ...)
702 */
703static VariLenAffix affixForIndex(uint64_t index)
704{
705 VariLenAffix prefix;
706 prefix = expGolombEncode(index, EXP_GOLOMB_K);
707 return invertAffix(&prefix); /* convert prefix to suffix */
708}
709
710/* creative abuse of tb_hash_func7, which is based on xxhash */
711static uint32_t qpp_hash(QppEntry e)
712{
713 return qemu_xxhash7(e.ino_prefix, e.dev, 0, 0, 0);
714}
715
716static uint32_t qpf_hash(QpfEntry e)
717{
718 return qemu_xxhash7(e.ino, e.dev, 0, 0, 0);
719}
720
721static bool qpd_cmp_func(const void *obj, const void *userp)
722{
723 const QpdEntry *e1 = obj, *e2 = userp;
724 return e1->dev == e2->dev;
725}
726
727static bool qpp_cmp_func(const void *obj, const void *userp)
728{
729 const QppEntry *e1 = obj, *e2 = userp;
730 return e1->dev == e2->dev && e1->ino_prefix == e2->ino_prefix;
731}
732
733static bool qpf_cmp_func(const void *obj, const void *userp)
734{
735 const QpfEntry *e1 = obj, *e2 = userp;
736 return e1->dev == e2->dev && e1->ino == e2->ino;
737}
738
739static void qp_table_remove(void *p, uint32_t h, void *up)
740{
741 g_free(p);
742}
743
744static void qp_table_destroy(struct qht *ht)
745{
746 if (!ht || !ht->map) {
747 return;
748 }
749 qht_iter(ht, qp_table_remove, NULL);
750 qht_destroy(ht);
751}
752
753static void qpd_table_init(struct qht *ht)
754{
755 qht_init(ht, qpd_cmp_func, 1, QHT_MODE_AUTO_RESIZE);
756}
757
758static void qpp_table_init(struct qht *ht)
759{
760 qht_init(ht, qpp_cmp_func, 1, QHT_MODE_AUTO_RESIZE);
761}
762
763static void qpf_table_init(struct qht *ht)
764{
765 qht_init(ht, qpf_cmp_func, 1 << 16, QHT_MODE_AUTO_RESIZE);
766}
767
768/*
769 * Returns how many (high end) bits of inode numbers of the passed fs
770 * device shall be used (in combination with the device number) to
771 * generate hash values for qpp_table entries.
772 *
773 * This function is required if variable length suffixes are used for inode
774 * number mapping on guest level. Since a device may end up having multiple
775 * entries in qpp_table, each entry most probably with a different suffix
776 * length, we thus need this function in conjunction with qpd_table to
777 * "agree" about a fix amount of bits (per device) to be always used for
778 * generating hash values for the purpose of accessing qpp_table in order
779 * get consistent behaviour when accessing qpp_table.
780 */
781static int qid_inode_prefix_hash_bits(V9fsPDU *pdu, dev_t dev)
782{
783 QpdEntry lookup = {
784 .dev = dev
785 }, *val;
786 uint32_t hash = dev;
787 VariLenAffix affix;
788
789 val = qht_lookup(&pdu->s->qpd_table, &lookup, hash);
790 if (!val) {
791 val = g_malloc0(sizeof(QpdEntry));
792 *val = lookup;
793 affix = affixForIndex(pdu->s->qp_affix_next);
794 val->prefix_bits = affix.bits;
795 qht_insert(&pdu->s->qpd_table, val, hash, NULL);
796 pdu->s->qp_ndevices++;
797 }
798 return val->prefix_bits;
799}
800
801/**
802 * @brief Slow / full mapping host inode nr -> guest inode nr.
803 *
804 * This function performs a slower and much more costly remapping of an
805 * original file inode number on host to an appropriate different inode
806 * number on guest. For every (dev, inode) combination on host a new
807 * sequential number is generated, cached and exposed as inode number on
808 * guest.
809 *
810 * This is just a "last resort" fallback solution if the much faster/cheaper
811 * qid_path_suffixmap() failed. In practice this slow / full mapping is not
812 * expected ever to be used at all though.
813 *
814 * @see qid_path_suffixmap() for details
815 *
816 */
817static int qid_path_fullmap(V9fsPDU *pdu, const struct stat *stbuf,
818 uint64_t *path)
819{
820 QpfEntry lookup = {
821 .dev = stbuf->st_dev,
822 .ino = stbuf->st_ino
823 }, *val;
824 uint32_t hash = qpf_hash(lookup);
825 VariLenAffix affix;
826
827 val = qht_lookup(&pdu->s->qpf_table, &lookup, hash);
828
829 if (!val) {
830 if (pdu->s->qp_fullpath_next == 0) {
831 /* no more files can be mapped :'( */
832 error_report_once(
833 "9p: No more prefixes available for remapping inodes from "
834 "host to guest."
835 );
836 return -ENFILE;
837 }
838
839 val = g_malloc0(sizeof(QppEntry));
840 *val = lookup;
841
842 /* new unique inode and device combo */
843 affix = affixForIndex(
844 1ULL << (sizeof(pdu->s->qp_affix_next) * 8)
845 );
846 val->path = (pdu->s->qp_fullpath_next++ << affix.bits) | affix.value;
847 pdu->s->qp_fullpath_next &= ((1ULL << (64 - affix.bits)) - 1);
848 qht_insert(&pdu->s->qpf_table, val, hash, NULL);
849 }
850
851 *path = val->path;
852 return 0;
853}
854
855/**
856 * @brief Quick mapping host inode nr -> guest inode nr.
857 *
858 * This function performs quick remapping of an original file inode number
859 * on host to an appropriate different inode number on guest. This remapping
860 * of inodes is required to avoid inode nr collisions on guest which would
861 * happen if the 9p export contains more than 1 exported file system (or
862 * more than 1 file system data set), because unlike on host level where the
863 * files would have different device nrs, all files exported by 9p would
864 * share the same device nr on guest (the device nr of the virtual 9p device
865 * that is).
866 *
867 * Inode remapping is performed by chopping off high end bits of the original
868 * inode number from host, shifting the result upwards and then assigning a
869 * generated suffix number for the low end bits, where the same suffix number
870 * will be shared by all inodes with the same device id AND the same high end
871 * bits that have been chopped off. That approach utilizes the fact that inode
872 * numbers very likely share the same high end bits (i.e. due to their common
873 * sequential generation by file systems) and hence we only have to generate
874 * and track a very limited amount of suffixes in practice due to that.
875 *
876 * We generate variable size suffixes for that purpose. The 1st generated
877 * suffix will only have 1 bit and hence we only need to chop off 1 bit from
878 * the original inode number. The subsequent suffixes being generated will
879 * grow in (bit) size subsequently, i.e. the 2nd and 3rd suffix being
880 * generated will have 3 bits and hence we have to chop off 3 bits from their
881 * original inodes, and so on. That approach of using variable length suffixes
882 * (i.e. over fixed size ones) utilizes the fact that in practice only a very
883 * limited amount of devices are shared by the same export (e.g. typically
884 * less than 2 dozen devices per 9p export), so in practice we need to chop
885 * off less bits than with fixed size prefixes and yet are flexible to add
886 * new devices at runtime below host's export directory at any time without
887 * having to reboot guest nor requiring to reconfigure guest for that. And due
888 * to the very limited amount of original high end bits that we chop off that
889 * way, the total amount of suffixes we need to generate is less than by using
890 * fixed size prefixes and hence it also improves performance of the inode
891 * remapping algorithm, and finally has the nice side effect that the inode
892 * numbers on guest will be much smaller & human friendly. ;-)
893 */
894static int qid_path_suffixmap(V9fsPDU *pdu, const struct stat *stbuf,
895 uint64_t *path)
896{
897 const int ino_hash_bits = qid_inode_prefix_hash_bits(pdu, stbuf->st_dev);
898 QppEntry lookup = {
899 .dev = stbuf->st_dev,
900 .ino_prefix = (uint16_t) (stbuf->st_ino >> (64 - ino_hash_bits))
901 }, *val;
902 uint32_t hash = qpp_hash(lookup);
903
904 val = qht_lookup(&pdu->s->qpp_table, &lookup, hash);
905
906 if (!val) {
907 if (pdu->s->qp_affix_next == 0) {
908 /* we ran out of affixes */
909 warn_report_once(
910 "9p: Potential degraded performance of inode remapping"
911 );
912 return -ENFILE;
913 }
914
915 val = g_malloc0(sizeof(QppEntry));
916 *val = lookup;
917
918 /* new unique inode affix and device combo */
919 val->qp_affix_index = pdu->s->qp_affix_next++;
920 val->qp_affix = affixForIndex(val->qp_affix_index);
921 qht_insert(&pdu->s->qpp_table, val, hash, NULL);
922 }
923 /* assuming generated affix to be suffix type, not prefix */
924 *path = (stbuf->st_ino << val->qp_affix.bits) | val->qp_affix.value;
925 return 0;
926}
927
928static int stat_to_qid(V9fsPDU *pdu, const struct stat *stbuf, V9fsQID *qidp)
929{
930 int err;
931 size_t size;
932
933 if (pdu->s->ctx.export_flags & V9FS_REMAP_INODES) {
934 /* map inode+device to qid path (fast path) */
935 err = qid_path_suffixmap(pdu, stbuf, &qidp->path);
936 if (err == -ENFILE) {
937 /* fast path didn't work, fall back to full map */
938 err = qid_path_fullmap(pdu, stbuf, &qidp->path);
939 }
940 if (err) {
941 return err;
942 }
943 } else {
944 if (pdu->s->dev_id != stbuf->st_dev) {
945 if (pdu->s->ctx.export_flags & V9FS_FORBID_MULTIDEVS) {
946 error_report_once(
947 "9p: Multiple devices detected in same VirtFS export. "
948 "Access of guest to additional devices is (partly) "
949 "denied due to virtfs option 'multidevs=forbid' being "
950 "effective."
951 );
952 return -ENODEV;
953 } else {
954 warn_report_once(
955 "9p: Multiple devices detected in same VirtFS export, "
956 "which might lead to file ID collisions and severe "
957 "misbehaviours on guest! You should either use a "
958 "separate export for each device shared from host or "
959 "use virtfs option 'multidevs=remap'!"
960 );
961 }
962 }
963 memset(&qidp->path, 0, sizeof(qidp->path));
964 size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
965 memcpy(&qidp->path, &stbuf->st_ino, size);
966 }
967
968 qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
969 qidp->type = 0;
970 if (S_ISDIR(stbuf->st_mode)) {
971 qidp->type |= P9_QID_TYPE_DIR;
972 }
973 if (S_ISLNK(stbuf->st_mode)) {
974 qidp->type |= P9_QID_TYPE_SYMLINK;
975 }
976
977 return 0;
978}
979
980V9fsPDU *pdu_alloc(V9fsState *s)
981{
982 V9fsPDU *pdu = NULL;
983
984 if (!QLIST_EMPTY(&s->free_list)) {
985 pdu = QLIST_FIRST(&s->free_list);
986 QLIST_REMOVE(pdu, next);
987 QLIST_INSERT_HEAD(&s->active_list, pdu, next);
988 }
989 return pdu;
990}
991
992void pdu_free(V9fsPDU *pdu)
993{
994 V9fsState *s = pdu->s;
995
996 g_assert(!pdu->cancelled);
997 QLIST_REMOVE(pdu, next);
998 QLIST_INSERT_HEAD(&s->free_list, pdu, next);
999}
1000
1001static void coroutine_fn pdu_complete(V9fsPDU *pdu, ssize_t len)
1002{
1003 int8_t id = pdu->id + 1; /* Response */
1004 V9fsState *s = pdu->s;
1005 int ret;
1006
1007 /*
1008 * The 9p spec requires that successfully cancelled pdus receive no reply.
1009 * Sending a reply would confuse clients because they would
1010 * assume that any EINTR is the actual result of the operation,
1011 * rather than a consequence of the cancellation. However, if
1012 * the operation completed (succesfully or with an error other
1013 * than caused be cancellation), we do send out that reply, both
1014 * for efficiency and to avoid confusing the rest of the state machine
1015 * that assumes passing a non-error here will mean a successful
1016 * transmission of the reply.
1017 */
1018 bool discard = pdu->cancelled && len == -EINTR;
1019 if (discard) {
1020 trace_v9fs_rcancel(pdu->tag, pdu->id);
1021 pdu->size = 0;
1022 goto out_notify;
1023 }
1024
1025 if (len < 0) {
1026 int err = -len;
1027 len = 7;
1028
1029 if (s->proto_version != V9FS_PROTO_2000L) {
1030 V9fsString str;
1031
1032 str.data = strerror(err);
1033 str.size = strlen(str.data);
1034
1035 ret = pdu_marshal(pdu, len, "s", &str);
1036 if (ret < 0) {
1037 goto out_notify;
1038 }
1039 len += ret;
1040 id = P9_RERROR;
1041 }
1042
1043 ret = pdu_marshal(pdu, len, "d", err);
1044 if (ret < 0) {
1045 goto out_notify;
1046 }
1047 len += ret;
1048
1049 if (s->proto_version == V9FS_PROTO_2000L) {
1050 id = P9_RLERROR;
1051 }
1052 trace_v9fs_rerror(pdu->tag, pdu->id, err); /* Trace ERROR */
1053 }
1054
1055 /* fill out the header */
1056 if (pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag) < 0) {
1057 goto out_notify;
1058 }
1059
1060 /* keep these in sync */
1061 pdu->size = len;
1062 pdu->id = id;
1063
1064out_notify:
1065 pdu->s->transport->push_and_notify(pdu);
1066
1067 /* Now wakeup anybody waiting in flush for this request */
1068 if (!qemu_co_queue_next(&pdu->complete)) {
1069 pdu_free(pdu);
1070 }
1071}
1072
1073static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
1074{
1075 mode_t ret;
1076
1077 ret = mode & 0777;
1078 if (mode & P9_STAT_MODE_DIR) {
1079 ret |= S_IFDIR;
1080 }
1081
1082 if (mode & P9_STAT_MODE_SYMLINK) {
1083 ret |= S_IFLNK;
1084 }
1085 if (mode & P9_STAT_MODE_SOCKET) {
1086 ret |= S_IFSOCK;
1087 }
1088 if (mode & P9_STAT_MODE_NAMED_PIPE) {
1089 ret |= S_IFIFO;
1090 }
1091 if (mode & P9_STAT_MODE_DEVICE) {
1092 if (extension->size && extension->data[0] == 'c') {
1093 ret |= S_IFCHR;
1094 } else {
1095 ret |= S_IFBLK;
1096 }
1097 }
1098
1099 if (!(ret & ~0777)) {
1100 ret |= S_IFREG;
1101 }
1102
1103 if (mode & P9_STAT_MODE_SETUID) {
1104 ret |= S_ISUID;
1105 }
1106 if (mode & P9_STAT_MODE_SETGID) {
1107 ret |= S_ISGID;
1108 }
1109 if (mode & P9_STAT_MODE_SETVTX) {
1110 ret |= S_ISVTX;
1111 }
1112
1113 return ret;
1114}
1115
1116static int donttouch_stat(V9fsStat *stat)
1117{
1118 if (stat->type == -1 &&
1119 stat->dev == -1 &&
1120 stat->qid.type == 0xff &&
1121 stat->qid.version == (uint32_t) -1 &&
1122 stat->qid.path == (uint64_t) -1 &&
1123 stat->mode == -1 &&
1124 stat->atime == -1 &&
1125 stat->mtime == -1 &&
1126 stat->length == -1 &&
1127 !stat->name.size &&
1128 !stat->uid.size &&
1129 !stat->gid.size &&
1130 !stat->muid.size &&
1131 stat->n_uid == -1 &&
1132 stat->n_gid == -1 &&
1133 stat->n_muid == -1) {
1134 return 1;
1135 }
1136
1137 return 0;
1138}
1139
1140static void v9fs_stat_init(V9fsStat *stat)
1141{
1142 v9fs_string_init(&stat->name);
1143 v9fs_string_init(&stat->uid);
1144 v9fs_string_init(&stat->gid);
1145 v9fs_string_init(&stat->muid);
1146 v9fs_string_init(&stat->extension);
1147}
1148
1149static void v9fs_stat_free(V9fsStat *stat)
1150{
1151 v9fs_string_free(&stat->name);
1152 v9fs_string_free(&stat->uid);
1153 v9fs_string_free(&stat->gid);
1154 v9fs_string_free(&stat->muid);
1155 v9fs_string_free(&stat->extension);
1156}
1157
1158static uint32_t stat_to_v9mode(const struct stat *stbuf)
1159{
1160 uint32_t mode;
1161
1162 mode = stbuf->st_mode & 0777;
1163 if (S_ISDIR(stbuf->st_mode)) {
1164 mode |= P9_STAT_MODE_DIR;
1165 }
1166
1167 if (S_ISLNK(stbuf->st_mode)) {
1168 mode |= P9_STAT_MODE_SYMLINK;
1169 }
1170
1171 if (S_ISSOCK(stbuf->st_mode)) {
1172 mode |= P9_STAT_MODE_SOCKET;
1173 }
1174
1175 if (S_ISFIFO(stbuf->st_mode)) {
1176 mode |= P9_STAT_MODE_NAMED_PIPE;
1177 }
1178
1179 if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
1180 mode |= P9_STAT_MODE_DEVICE;
1181 }
1182
1183 if (stbuf->st_mode & S_ISUID) {
1184 mode |= P9_STAT_MODE_SETUID;
1185 }
1186
1187 if (stbuf->st_mode & S_ISGID) {
1188 mode |= P9_STAT_MODE_SETGID;
1189 }
1190
1191 if (stbuf->st_mode & S_ISVTX) {
1192 mode |= P9_STAT_MODE_SETVTX;
1193 }
1194
1195 return mode;
1196}
1197
1198static int coroutine_fn stat_to_v9stat(V9fsPDU *pdu, V9fsPath *path,
1199 const char *basename,
1200 const struct stat *stbuf,
1201 V9fsStat *v9stat)
1202{
1203 int err;
1204
1205 memset(v9stat, 0, sizeof(*v9stat));
1206
1207 err = stat_to_qid(pdu, stbuf, &v9stat->qid);
1208 if (err < 0) {
1209 return err;
1210 }
1211 v9stat->mode = stat_to_v9mode(stbuf);
1212 v9stat->atime = stbuf->st_atime;
1213 v9stat->mtime = stbuf->st_mtime;
1214 v9stat->length = stbuf->st_size;
1215
1216 v9fs_string_free(&v9stat->uid);
1217 v9fs_string_free(&v9stat->gid);
1218 v9fs_string_free(&v9stat->muid);
1219
1220 v9stat->n_uid = stbuf->st_uid;
1221 v9stat->n_gid = stbuf->st_gid;
1222 v9stat->n_muid = 0;
1223
1224 v9fs_string_free(&v9stat->extension);
1225
1226 if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
1227 err = v9fs_co_readlink(pdu, path, &v9stat->extension);
1228 if (err < 0) {
1229 return err;
1230 }
1231 } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
1232 v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
1233 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
1234 major(stbuf->st_rdev), minor(stbuf->st_rdev));
1235 } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
1236 v9fs_string_sprintf(&v9stat->extension, "%s %lu",
1237 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
1238 }
1239
1240 v9fs_string_sprintf(&v9stat->name, "%s", basename);
1241
1242 v9stat->size = 61 +
1243 v9fs_string_size(&v9stat->name) +
1244 v9fs_string_size(&v9stat->uid) +
1245 v9fs_string_size(&v9stat->gid) +
1246 v9fs_string_size(&v9stat->muid) +
1247 v9fs_string_size(&v9stat->extension);
1248 return 0;
1249}
1250
1251#define P9_STATS_MODE 0x00000001ULL
1252#define P9_STATS_NLINK 0x00000002ULL
1253#define P9_STATS_UID 0x00000004ULL
1254#define P9_STATS_GID 0x00000008ULL
1255#define P9_STATS_RDEV 0x00000010ULL
1256#define P9_STATS_ATIME 0x00000020ULL
1257#define P9_STATS_MTIME 0x00000040ULL
1258#define P9_STATS_CTIME 0x00000080ULL
1259#define P9_STATS_INO 0x00000100ULL
1260#define P9_STATS_SIZE 0x00000200ULL
1261#define P9_STATS_BLOCKS 0x00000400ULL
1262
1263#define P9_STATS_BTIME 0x00000800ULL
1264#define P9_STATS_GEN 0x00001000ULL
1265#define P9_STATS_DATA_VERSION 0x00002000ULL
1266
1267#define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */
1268#define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */
1269
1270
1271/**
1272 * Convert host filesystem's block size into an appropriate block size for
1273 * 9p client (guest OS side). The value returned suggests an "optimum" block
1274 * size for 9p I/O, i.e. to maximize performance.
1275 *
1276 * @pdu: 9p client request
1277 * @blksize: host filesystem's block size
1278 */
1279static int32_t blksize_to_iounit(const V9fsPDU *pdu, int32_t blksize)
1280{
1281 int32_t iounit = 0;
1282 V9fsState *s = pdu->s;
1283
1284 /*
1285 * iounit should be multiples of blksize (host filesystem block size)
1286 * as well as less than (client msize - P9_IOHDRSZ)
1287 */
1288 if (blksize) {
1289 iounit = QEMU_ALIGN_DOWN(s->msize - P9_IOHDRSZ, blksize);
1290 }
1291 if (!iounit) {
1292 iounit = s->msize - P9_IOHDRSZ;
1293 }
1294 return iounit;
1295}
1296
1297static int32_t stat_to_iounit(const V9fsPDU *pdu, const struct stat *stbuf)
1298{
1299 return blksize_to_iounit(pdu, stbuf->st_blksize);
1300}
1301
1302static int stat_to_v9stat_dotl(V9fsPDU *pdu, const struct stat *stbuf,
1303 V9fsStatDotl *v9lstat)
1304{
1305 memset(v9lstat, 0, sizeof(*v9lstat));
1306
1307 v9lstat->st_mode = stbuf->st_mode;
1308 v9lstat->st_nlink = stbuf->st_nlink;
1309 v9lstat->st_uid = stbuf->st_uid;
1310 v9lstat->st_gid = stbuf->st_gid;
1311 v9lstat->st_rdev = stbuf->st_rdev;
1312 v9lstat->st_size = stbuf->st_size;
1313 v9lstat->st_blksize = stat_to_iounit(pdu, stbuf);
1314 v9lstat->st_blocks = stbuf->st_blocks;
1315 v9lstat->st_atime_sec = stbuf->st_atime;
1316 v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
1317 v9lstat->st_mtime_sec = stbuf->st_mtime;
1318 v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
1319 v9lstat->st_ctime_sec = stbuf->st_ctime;
1320 v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
1321 /* Currently we only support BASIC fields in stat */
1322 v9lstat->st_result_mask = P9_STATS_BASIC;
1323
1324 return stat_to_qid(pdu, stbuf, &v9lstat->qid);
1325}
1326
1327static void print_sg(struct iovec *sg, int cnt)
1328{
1329 int i;
1330
1331 printf("sg[%d]: {", cnt);
1332 for (i = 0; i < cnt; i++) {
1333 if (i) {
1334 printf(", ");
1335 }
1336 printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
1337 }
1338 printf("}\n");
1339}
1340
1341/* Will call this only for path name based fid */
1342static void v9fs_fix_path(V9fsPath *dst, V9fsPath *src, int len)
1343{
1344 V9fsPath str;
1345 v9fs_path_init(&str);
1346 v9fs_path_copy(&str, dst);
1347 v9fs_path_sprintf(dst, "%s%s", src->data, str.data + len);
1348 v9fs_path_free(&str);
1349}
1350
1351static inline bool is_ro_export(FsContext *ctx)
1352{
1353 return ctx->export_flags & V9FS_RDONLY;
1354}
1355
1356static void coroutine_fn v9fs_version(void *opaque)
1357{
1358 ssize_t err;
1359 V9fsPDU *pdu = opaque;
1360 V9fsState *s = pdu->s;
1361 V9fsString version;
1362 size_t offset = 7;
1363
1364 v9fs_string_init(&version);
1365 err = pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
1366 if (err < 0) {
1367 goto out;
1368 }
1369 trace_v9fs_version(pdu->tag, pdu->id, s->msize, version.data);
1370
1371 virtfs_reset(pdu);
1372
1373 if (!strcmp(version.data, "9P2000.u")) {
1374 s->proto_version = V9FS_PROTO_2000U;
1375 } else if (!strcmp(version.data, "9P2000.L")) {
1376 s->proto_version = V9FS_PROTO_2000L;
1377 } else {
1378 v9fs_string_sprintf(&version, "unknown");
1379 /* skip min. msize check, reporting invalid version has priority */
1380 goto marshal;
1381 }
1382
1383 if (s->msize < P9_MIN_MSIZE) {
1384 err = -EMSGSIZE;
1385 error_report(
1386 "9pfs: Client requested msize < minimum msize ("
1387 stringify(P9_MIN_MSIZE) ") supported by this server."
1388 );
1389 goto out;
1390 }
1391
1392 /* 8192 is the default msize of Linux clients */
1393 if (s->msize <= 8192 && !(s->ctx.export_flags & V9FS_NO_PERF_WARN)) {
1394 warn_report_once(
1395 "9p: degraded performance: a reasonable high msize should be "
1396 "chosen on client/guest side (chosen msize is <= 8192). See "
1397 "https://wiki.qemu.org/Documentation/9psetup#msize for details."
1398 );
1399 }
1400
1401marshal:
1402 err = pdu_marshal(pdu, offset, "ds", s->msize, &version);
1403 if (err < 0) {
1404 goto out;
1405 }
1406 err += offset;
1407 trace_v9fs_version_return(pdu->tag, pdu->id, s->msize, version.data);
1408out:
1409 pdu_complete(pdu, err);
1410 v9fs_string_free(&version);
1411}
1412
1413static void coroutine_fn v9fs_attach(void *opaque)
1414{
1415 V9fsPDU *pdu = opaque;
1416 V9fsState *s = pdu->s;
1417 int32_t fid, afid, n_uname;
1418 V9fsString uname, aname;
1419 V9fsFidState *fidp;
1420 size_t offset = 7;
1421 V9fsQID qid;
1422 ssize_t err;
1423 struct stat stbuf;
1424
1425 v9fs_string_init(&uname);
1426 v9fs_string_init(&aname);
1427 err = pdu_unmarshal(pdu, offset, "ddssd", &fid,
1428 &afid, &uname, &aname, &n_uname);
1429 if (err < 0) {
1430 goto out_nofid;
1431 }
1432 trace_v9fs_attach(pdu->tag, pdu->id, fid, afid, uname.data, aname.data);
1433
1434 fidp = alloc_fid(s, fid);
1435 if (fidp == NULL) {
1436 err = -EINVAL;
1437 goto out_nofid;
1438 }
1439 fidp->uid = n_uname;
1440 err = v9fs_co_name_to_path(pdu, NULL, "/", &fidp->path);
1441 if (err < 0) {
1442 err = -EINVAL;
1443 clunk_fid(s, fid);
1444 goto out;
1445 }
1446 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1447 if (err < 0) {
1448 err = -EINVAL;
1449 clunk_fid(s, fid);
1450 goto out;
1451 }
1452 err = stat_to_qid(pdu, &stbuf, &qid);
1453 if (err < 0) {
1454 err = -EINVAL;
1455 clunk_fid(s, fid);
1456 goto out;
1457 }
1458
1459 /*
1460 * disable migration if we haven't done already.
1461 * attach could get called multiple times for the same export.
1462 */
1463 if (!s->migration_blocker) {
1464 error_setg(&s->migration_blocker,
1465 "Migration is disabled when VirtFS export path '%s' is mounted in the guest using mount_tag '%s'",
1466 s->ctx.fs_root ? s->ctx.fs_root : "NULL", s->tag);
1467 err = migrate_add_blocker(s->migration_blocker, NULL);
1468 if (err < 0) {
1469 error_free(s->migration_blocker);
1470 s->migration_blocker = NULL;
1471 clunk_fid(s, fid);
1472 goto out;
1473 }
1474 s->root_fid = fid;
1475 }
1476
1477 err = pdu_marshal(pdu, offset, "Q", &qid);
1478 if (err < 0) {
1479 clunk_fid(s, fid);
1480 goto out;
1481 }
1482 err += offset;
1483
1484 memcpy(&s->root_st, &stbuf, sizeof(stbuf));
1485 trace_v9fs_attach_return(pdu->tag, pdu->id,
1486 qid.type, qid.version, qid.path);
1487out:
1488 put_fid(pdu, fidp);
1489out_nofid:
1490 pdu_complete(pdu, err);
1491 v9fs_string_free(&uname);
1492 v9fs_string_free(&aname);
1493}
1494
1495static void coroutine_fn v9fs_stat(void *opaque)
1496{
1497 int32_t fid;
1498 V9fsStat v9stat;
1499 ssize_t err = 0;
1500 size_t offset = 7;
1501 struct stat stbuf;
1502 V9fsFidState *fidp;
1503 V9fsPDU *pdu = opaque;
1504 char *basename;
1505
1506 err = pdu_unmarshal(pdu, offset, "d", &fid);
1507 if (err < 0) {
1508 goto out_nofid;
1509 }
1510 trace_v9fs_stat(pdu->tag, pdu->id, fid);
1511
1512 fidp = get_fid(pdu, fid);
1513 if (fidp == NULL) {
1514 err = -ENOENT;
1515 goto out_nofid;
1516 }
1517 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1518 if (err < 0) {
1519 goto out;
1520 }
1521 basename = g_path_get_basename(fidp->path.data);
1522 err = stat_to_v9stat(pdu, &fidp->path, basename, &stbuf, &v9stat);
1523 g_free(basename);
1524 if (err < 0) {
1525 goto out;
1526 }
1527 err = pdu_marshal(pdu, offset, "wS", 0, &v9stat);
1528 if (err < 0) {
1529 v9fs_stat_free(&v9stat);
1530 goto out;
1531 }
1532 trace_v9fs_stat_return(pdu->tag, pdu->id, v9stat.mode,
1533 v9stat.atime, v9stat.mtime, v9stat.length);
1534 err += offset;
1535 v9fs_stat_free(&v9stat);
1536out:
1537 put_fid(pdu, fidp);
1538out_nofid:
1539 pdu_complete(pdu, err);
1540}
1541
1542static void coroutine_fn v9fs_getattr(void *opaque)
1543{
1544 int32_t fid;
1545 size_t offset = 7;
1546 ssize_t retval = 0;
1547 struct stat stbuf;
1548 V9fsFidState *fidp;
1549 uint64_t request_mask;
1550 V9fsStatDotl v9stat_dotl;
1551 V9fsPDU *pdu = opaque;
1552
1553 retval = pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask);
1554 if (retval < 0) {
1555 goto out_nofid;
1556 }
1557 trace_v9fs_getattr(pdu->tag, pdu->id, fid, request_mask);
1558
1559 fidp = get_fid(pdu, fid);
1560 if (fidp == NULL) {
1561 retval = -ENOENT;
1562 goto out_nofid;
1563 }
1564 /*
1565 * Currently we only support BASIC fields in stat, so there is no
1566 * need to look at request_mask.
1567 */
1568 retval = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1569 if (retval < 0) {
1570 goto out;
1571 }
1572 retval = stat_to_v9stat_dotl(pdu, &stbuf, &v9stat_dotl);
1573 if (retval < 0) {
1574 goto out;
1575 }
1576
1577 /* fill st_gen if requested and supported by underlying fs */
1578 if (request_mask & P9_STATS_GEN) {
1579 retval = v9fs_co_st_gen(pdu, &fidp->path, stbuf.st_mode, &v9stat_dotl);
1580 switch (retval) {
1581 case 0:
1582 /* we have valid st_gen: update result mask */
1583 v9stat_dotl.st_result_mask |= P9_STATS_GEN;
1584 break;
1585 case -EINTR:
1586 /* request cancelled, e.g. by Tflush */
1587 goto out;
1588 default:
1589 /* failed to get st_gen: not fatal, ignore */
1590 break;
1591 }
1592 }
1593 retval = pdu_marshal(pdu, offset, "A", &v9stat_dotl);
1594 if (retval < 0) {
1595 goto out;
1596 }
1597 retval += offset;
1598 trace_v9fs_getattr_return(pdu->tag, pdu->id, v9stat_dotl.st_result_mask,
1599 v9stat_dotl.st_mode, v9stat_dotl.st_uid,
1600 v9stat_dotl.st_gid);
1601out:
1602 put_fid(pdu, fidp);
1603out_nofid:
1604 pdu_complete(pdu, retval);
1605}
1606
1607/* Attribute flags */
1608#define P9_ATTR_MODE (1 << 0)
1609#define P9_ATTR_UID (1 << 1)
1610#define P9_ATTR_GID (1 << 2)
1611#define P9_ATTR_SIZE (1 << 3)
1612#define P9_ATTR_ATIME (1 << 4)
1613#define P9_ATTR_MTIME (1 << 5)
1614#define P9_ATTR_CTIME (1 << 6)
1615#define P9_ATTR_ATIME_SET (1 << 7)
1616#define P9_ATTR_MTIME_SET (1 << 8)
1617
1618#define P9_ATTR_MASK 127
1619
1620static void coroutine_fn v9fs_setattr(void *opaque)
1621{
1622 int err = 0;
1623 int32_t fid;
1624 V9fsFidState *fidp;
1625 size_t offset = 7;
1626 V9fsIattr v9iattr;
1627 V9fsPDU *pdu = opaque;
1628
1629 err = pdu_unmarshal(pdu, offset, "dI", &fid, &v9iattr);
1630 if (err < 0) {
1631 goto out_nofid;
1632 }
1633
1634 trace_v9fs_setattr(pdu->tag, pdu->id, fid,
1635 v9iattr.valid, v9iattr.mode, v9iattr.uid, v9iattr.gid,
1636 v9iattr.size, v9iattr.atime_sec, v9iattr.mtime_sec);
1637
1638 fidp = get_fid(pdu, fid);
1639 if (fidp == NULL) {
1640 err = -EINVAL;
1641 goto out_nofid;
1642 }
1643 if (v9iattr.valid & P9_ATTR_MODE) {
1644 err = v9fs_co_chmod(pdu, &fidp->path, v9iattr.mode);
1645 if (err < 0) {
1646 goto out;
1647 }
1648 }
1649 if (v9iattr.valid & (P9_ATTR_ATIME | P9_ATTR_MTIME)) {
1650 struct timespec times[2];
1651 if (v9iattr.valid & P9_ATTR_ATIME) {
1652 if (v9iattr.valid & P9_ATTR_ATIME_SET) {
1653 times[0].tv_sec = v9iattr.atime_sec;
1654 times[0].tv_nsec = v9iattr.atime_nsec;
1655 } else {
1656 times[0].tv_nsec = UTIME_NOW;
1657 }
1658 } else {
1659 times[0].tv_nsec = UTIME_OMIT;
1660 }
1661 if (v9iattr.valid & P9_ATTR_MTIME) {
1662 if (v9iattr.valid & P9_ATTR_MTIME_SET) {
1663 times[1].tv_sec = v9iattr.mtime_sec;
1664 times[1].tv_nsec = v9iattr.mtime_nsec;
1665 } else {
1666 times[1].tv_nsec = UTIME_NOW;
1667 }
1668 } else {
1669 times[1].tv_nsec = UTIME_OMIT;
1670 }
1671 err = v9fs_co_utimensat(pdu, &fidp->path, times);
1672 if (err < 0) {
1673 goto out;
1674 }
1675 }
1676 /*
1677 * If the only valid entry in iattr is ctime we can call
1678 * chown(-1,-1) to update the ctime of the file
1679 */
1680 if ((v9iattr.valid & (P9_ATTR_UID | P9_ATTR_GID)) ||
1681 ((v9iattr.valid & P9_ATTR_CTIME)
1682 && !((v9iattr.valid & P9_ATTR_MASK) & ~P9_ATTR_CTIME))) {
1683 if (!(v9iattr.valid & P9_ATTR_UID)) {
1684 v9iattr.uid = -1;
1685 }
1686 if (!(v9iattr.valid & P9_ATTR_GID)) {
1687 v9iattr.gid = -1;
1688 }
1689 err = v9fs_co_chown(pdu, &fidp->path, v9iattr.uid,
1690 v9iattr.gid);
1691 if (err < 0) {
1692 goto out;
1693 }
1694 }
1695 if (v9iattr.valid & (P9_ATTR_SIZE)) {
1696 err = v9fs_co_truncate(pdu, &fidp->path, v9iattr.size);
1697 if (err < 0) {
1698 goto out;
1699 }
1700 }
1701 err = offset;
1702 trace_v9fs_setattr_return(pdu->tag, pdu->id);
1703out:
1704 put_fid(pdu, fidp);
1705out_nofid:
1706 pdu_complete(pdu, err);
1707}
1708
1709static int v9fs_walk_marshal(V9fsPDU *pdu, uint16_t nwnames, V9fsQID *qids)
1710{
1711 int i;
1712 ssize_t err;
1713 size_t offset = 7;
1714
1715 err = pdu_marshal(pdu, offset, "w", nwnames);
1716 if (err < 0) {
1717 return err;
1718 }
1719 offset += err;
1720 for (i = 0; i < nwnames; i++) {
1721 err = pdu_marshal(pdu, offset, "Q", &qids[i]);
1722 if (err < 0) {
1723 return err;
1724 }
1725 offset += err;
1726 }
1727 return offset;
1728}
1729
1730static bool name_is_illegal(const char *name)
1731{
1732 return !*name || strchr(name, '/') != NULL;
1733}
1734
1735static bool same_stat_id(const struct stat *a, const struct stat *b)
1736{
1737 return a->st_dev == b->st_dev && a->st_ino == b->st_ino;
1738}
1739
1740static void coroutine_fn v9fs_walk(void *opaque)
1741{
1742 int name_idx;
1743 g_autofree V9fsQID *qids = NULL;
1744 int i, err = 0;
1745 V9fsPath dpath, path;
1746 P9ARRAY_REF(V9fsPath) pathes = NULL;
1747 uint16_t nwnames;
1748 struct stat stbuf, fidst;
1749 g_autofree struct stat *stbufs = NULL;
1750 size_t offset = 7;
1751 int32_t fid, newfid;
1752 P9ARRAY_REF(V9fsString) wnames = NULL;
1753 V9fsFidState *fidp;
1754 V9fsFidState *newfidp = NULL;
1755 V9fsPDU *pdu = opaque;
1756 V9fsState *s = pdu->s;
1757 V9fsQID qid;
1758
1759 err = pdu_unmarshal(pdu, offset, "ddw", &fid, &newfid, &nwnames);
1760 if (err < 0) {
1761 pdu_complete(pdu, err);
1762 return ;
1763 }
1764 offset += err;
1765
1766 trace_v9fs_walk(pdu->tag, pdu->id, fid, newfid, nwnames);
1767
1768 if (nwnames > P9_MAXWELEM) {
1769 err = -EINVAL;
1770 goto out_nofid;
1771 }
1772 if (nwnames) {
1773 P9ARRAY_NEW(V9fsString, wnames, nwnames);
1774 qids = g_new0(V9fsQID, nwnames);
1775 stbufs = g_new0(struct stat, nwnames);
1776 P9ARRAY_NEW(V9fsPath, pathes, nwnames);
1777 for (i = 0; i < nwnames; i++) {
1778 err = pdu_unmarshal(pdu, offset, "s", &wnames[i]);
1779 if (err < 0) {
1780 goto out_nofid;
1781 }
1782 if (name_is_illegal(wnames[i].data)) {
1783 err = -ENOENT;
1784 goto out_nofid;
1785 }
1786 offset += err;
1787 }
1788 }
1789 fidp = get_fid(pdu, fid);
1790 if (fidp == NULL) {
1791 err = -ENOENT;
1792 goto out_nofid;
1793 }
1794
1795 v9fs_path_init(&dpath);
1796 v9fs_path_init(&path);
1797 /*
1798 * Both dpath and path initially point to fidp.
1799 * Needed to handle request with nwnames == 0
1800 */
1801 v9fs_path_copy(&dpath, &fidp->path);
1802 v9fs_path_copy(&path, &fidp->path);
1803
1804 /*
1805 * To keep latency (i.e. overall execution time for processing this
1806 * Twalk client request) as small as possible, run all the required fs
1807 * driver code altogether inside the following block.
1808 */
1809 v9fs_co_run_in_worker({
1810 if (v9fs_request_cancelled(pdu)) {
1811 err = -EINTR;
1812 break;
1813 }
1814 err = s->ops->lstat(&s->ctx, &dpath, &fidst);
1815 if (err < 0) {
1816 err = -errno;
1817 break;
1818 }
1819 stbuf = fidst;
1820 for (name_idx = 0; name_idx < nwnames; name_idx++) {
1821 if (v9fs_request_cancelled(pdu)) {
1822 err = -EINTR;
1823 break;
1824 }
1825 if (!same_stat_id(&pdu->s->root_st, &stbuf) ||
1826 strcmp("..", wnames[name_idx].data))
1827 {
1828 err = s->ops->name_to_path(&s->ctx, &dpath,
1829 wnames[name_idx].data,
1830 &pathes[name_idx]);
1831 if (err < 0) {
1832 err = -errno;
1833 break;
1834 }
1835 if (v9fs_request_cancelled(pdu)) {
1836 err = -EINTR;
1837 break;
1838 }
1839 err = s->ops->lstat(&s->ctx, &pathes[name_idx], &stbuf);
1840 if (err < 0) {
1841 err = -errno;
1842 break;
1843 }
1844 stbufs[name_idx] = stbuf;
1845 v9fs_path_copy(&dpath, &pathes[name_idx]);
1846 }
1847 }
1848 });
1849 /*
1850 * Handle all the rest of this Twalk request on main thread ...
1851 */
1852 if (err < 0) {
1853 goto out;
1854 }
1855
1856 err = stat_to_qid(pdu, &fidst, &qid);
1857 if (err < 0) {
1858 goto out;
1859 }
1860 stbuf = fidst;
1861
1862 /* reset dpath and path */
1863 v9fs_path_copy(&dpath, &fidp->path);
1864 v9fs_path_copy(&path, &fidp->path);
1865
1866 for (name_idx = 0; name_idx < nwnames; name_idx++) {
1867 if (!same_stat_id(&pdu->s->root_st, &stbuf) ||
1868 strcmp("..", wnames[name_idx].data))
1869 {
1870 stbuf = stbufs[name_idx];
1871 err = stat_to_qid(pdu, &stbuf, &qid);
1872 if (err < 0) {
1873 goto out;
1874 }
1875 v9fs_path_copy(&path, &pathes[name_idx]);
1876 v9fs_path_copy(&dpath, &path);
1877 }
1878 memcpy(&qids[name_idx], &qid, sizeof(qid));
1879 }
1880 if (fid == newfid) {
1881 if (fidp->fid_type != P9_FID_NONE) {
1882 err = -EINVAL;
1883 goto out;
1884 }
1885 v9fs_path_write_lock(s);
1886 v9fs_path_copy(&fidp->path, &path);
1887 v9fs_path_unlock(s);
1888 } else {
1889 newfidp = alloc_fid(s, newfid);
1890 if (newfidp == NULL) {
1891 err = -EINVAL;
1892 goto out;
1893 }
1894 newfidp->uid = fidp->uid;
1895 v9fs_path_copy(&newfidp->path, &path);
1896 }
1897 err = v9fs_walk_marshal(pdu, nwnames, qids);
1898 trace_v9fs_walk_return(pdu->tag, pdu->id, nwnames, qids);
1899out:
1900 put_fid(pdu, fidp);
1901 if (newfidp) {
1902 put_fid(pdu, newfidp);
1903 }
1904 v9fs_path_free(&dpath);
1905 v9fs_path_free(&path);
1906out_nofid:
1907 pdu_complete(pdu, err);
1908}
1909
1910static int32_t coroutine_fn get_iounit(V9fsPDU *pdu, V9fsPath *path)
1911{
1912 struct statfs stbuf;
1913 int err = v9fs_co_statfs(pdu, path, &stbuf);
1914
1915 return blksize_to_iounit(pdu, (err >= 0) ? stbuf.f_bsize : 0);
1916}
1917
1918static void coroutine_fn v9fs_open(void *opaque)
1919{
1920 int flags;
1921 int32_t fid;
1922 int32_t mode;
1923 V9fsQID qid;
1924 int iounit = 0;
1925 ssize_t err = 0;
1926 size_t offset = 7;
1927 struct stat stbuf;
1928 V9fsFidState *fidp;
1929 V9fsPDU *pdu = opaque;
1930 V9fsState *s = pdu->s;
1931
1932 if (s->proto_version == V9FS_PROTO_2000L) {
1933 err = pdu_unmarshal(pdu, offset, "dd", &fid, &mode);
1934 } else {
1935 uint8_t modebyte;
1936 err = pdu_unmarshal(pdu, offset, "db", &fid, &modebyte);
1937 mode = modebyte;
1938 }
1939 if (err < 0) {
1940 goto out_nofid;
1941 }
1942 trace_v9fs_open(pdu->tag, pdu->id, fid, mode);
1943
1944 fidp = get_fid(pdu, fid);
1945 if (fidp == NULL) {
1946 err = -ENOENT;
1947 goto out_nofid;
1948 }
1949 if (fidp->fid_type != P9_FID_NONE) {
1950 err = -EINVAL;
1951 goto out;
1952 }
1953
1954 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1955 if (err < 0) {
1956 goto out;
1957 }
1958 err = stat_to_qid(pdu, &stbuf, &qid);
1959 if (err < 0) {
1960 goto out;
1961 }
1962 if (S_ISDIR(stbuf.st_mode)) {
1963 err = v9fs_co_opendir(pdu, fidp);
1964 if (err < 0) {
1965 goto out;
1966 }
1967 fidp->fid_type = P9_FID_DIR;
1968 err = pdu_marshal(pdu, offset, "Qd", &qid, 0);
1969 if (err < 0) {
1970 goto out;
1971 }
1972 err += offset;
1973 } else {
1974 if (s->proto_version == V9FS_PROTO_2000L) {
1975 flags = get_dotl_openflags(s, mode);
1976 } else {
1977 flags = omode_to_uflags(mode);
1978 }
1979 if (is_ro_export(&s->ctx)) {
1980 if (mode & O_WRONLY || mode & O_RDWR ||
1981 mode & O_APPEND || mode & O_TRUNC) {
1982 err = -EROFS;
1983 goto out;
1984 }
1985 }
1986 err = v9fs_co_open(pdu, fidp, flags);
1987 if (err < 0) {
1988 goto out;
1989 }
1990 fidp->fid_type = P9_FID_FILE;
1991 fidp->open_flags = flags;
1992 if (flags & O_EXCL) {
1993 /*
1994 * We let the host file system do O_EXCL check
1995 * We should not reclaim such fd
1996 */
1997 fidp->flags |= FID_NON_RECLAIMABLE;
1998 }
1999 iounit = get_iounit(pdu, &fidp->path);
2000 err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
2001 if (err < 0) {
2002 goto out;
2003 }
2004 err += offset;
2005 }
2006 trace_v9fs_open_return(pdu->tag, pdu->id,
2007 qid.type, qid.version, qid.path, iounit);
2008out:
2009 put_fid(pdu, fidp);
2010out_nofid:
2011 pdu_complete(pdu, err);
2012}
2013
2014static void coroutine_fn v9fs_lcreate(void *opaque)
2015{
2016 int32_t dfid, flags, mode;
2017 gid_t gid;
2018 ssize_t err = 0;
2019 ssize_t offset = 7;
2020 V9fsString name;
2021 V9fsFidState *fidp;
2022 struct stat stbuf;
2023 V9fsQID qid;
2024 int32_t iounit;
2025 V9fsPDU *pdu = opaque;
2026
2027 v9fs_string_init(&name);
2028 err = pdu_unmarshal(pdu, offset, "dsddd", &dfid,
2029 &name, &flags, &mode, &gid);
2030 if (err < 0) {
2031 goto out_nofid;
2032 }
2033 trace_v9fs_lcreate(pdu->tag, pdu->id, dfid, flags, mode, gid);
2034
2035 if (name_is_illegal(name.data)) {
2036 err = -ENOENT;
2037 goto out_nofid;
2038 }
2039
2040 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
2041 err = -EEXIST;
2042 goto out_nofid;
2043 }
2044
2045 fidp = get_fid(pdu, dfid);
2046 if (fidp == NULL) {
2047 err = -ENOENT;
2048 goto out_nofid;
2049 }
2050 if (fidp->fid_type != P9_FID_NONE) {
2051 err = -EINVAL;
2052 goto out;
2053 }
2054
2055 flags = get_dotl_openflags(pdu->s, flags);
2056 err = v9fs_co_open2(pdu, fidp, &name, gid,
2057 flags | O_CREAT, mode, &stbuf);
2058 if (err < 0) {
2059 goto out;
2060 }
2061 fidp->fid_type = P9_FID_FILE;
2062 fidp->open_flags = flags;
2063 if (flags & O_EXCL) {
2064 /*
2065 * We let the host file system do O_EXCL check
2066 * We should not reclaim such fd
2067 */
2068 fidp->flags |= FID_NON_RECLAIMABLE;
2069 }
2070 iounit = get_iounit(pdu, &fidp->path);
2071 err = stat_to_qid(pdu, &stbuf, &qid);
2072 if (err < 0) {
2073 goto out;
2074 }
2075 err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
2076 if (err < 0) {
2077 goto out;
2078 }
2079 err += offset;
2080 trace_v9fs_lcreate_return(pdu->tag, pdu->id,
2081 qid.type, qid.version, qid.path, iounit);
2082out:
2083 put_fid(pdu, fidp);
2084out_nofid:
2085 pdu_complete(pdu, err);
2086 v9fs_string_free(&name);
2087}
2088
2089static void coroutine_fn v9fs_fsync(void *opaque)
2090{
2091 int err;
2092 int32_t fid;
2093 int datasync;
2094 size_t offset = 7;
2095 V9fsFidState *fidp;
2096 V9fsPDU *pdu = opaque;
2097
2098 err = pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
2099 if (err < 0) {
2100 goto out_nofid;
2101 }
2102 trace_v9fs_fsync(pdu->tag, pdu->id, fid, datasync);
2103
2104 fidp = get_fid(pdu, fid);
2105 if (fidp == NULL) {
2106 err = -ENOENT;
2107 goto out_nofid;
2108 }
2109 err = v9fs_co_fsync(pdu, fidp, datasync);
2110 if (!err) {
2111 err = offset;
2112 }
2113 put_fid(pdu, fidp);
2114out_nofid:
2115 pdu_complete(pdu, err);
2116}
2117
2118static void coroutine_fn v9fs_clunk(void *opaque)
2119{
2120 int err;
2121 int32_t fid;
2122 size_t offset = 7;
2123 V9fsFidState *fidp;
2124 V9fsPDU *pdu = opaque;
2125 V9fsState *s = pdu->s;
2126
2127 err = pdu_unmarshal(pdu, offset, "d", &fid);
2128 if (err < 0) {
2129 goto out_nofid;
2130 }
2131 trace_v9fs_clunk(pdu->tag, pdu->id, fid);
2132
2133 fidp = clunk_fid(s, fid);
2134 if (fidp == NULL) {
2135 err = -ENOENT;
2136 goto out_nofid;
2137 }
2138 /*
2139 * Bump the ref so that put_fid will
2140 * free the fid.
2141 */
2142 fidp->ref++;
2143 err = put_fid(pdu, fidp);
2144 if (!err) {
2145 err = offset;
2146 }
2147out_nofid:
2148 pdu_complete(pdu, err);
2149}
2150
2151/*
2152 * Create a QEMUIOVector for a sub-region of PDU iovecs
2153 *
2154 * @qiov: uninitialized QEMUIOVector
2155 * @skip: number of bytes to skip from beginning of PDU
2156 * @size: number of bytes to include
2157 * @is_write: true - write, false - read
2158 *
2159 * The resulting QEMUIOVector has heap-allocated iovecs and must be cleaned up
2160 * with qemu_iovec_destroy().
2161 */
2162static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
2163 size_t skip, size_t size,
2164 bool is_write)
2165{
2166 QEMUIOVector elem;
2167 struct iovec *iov;
2168 unsigned int niov;
2169
2170 if (is_write) {
2171 pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size + skip);
2172 } else {
2173 pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size + skip);
2174 }
2175
2176 qemu_iovec_init_external(&elem, iov, niov);
2177 qemu_iovec_init(qiov, niov);
2178 qemu_iovec_concat(qiov, &elem, skip, size);
2179}
2180
2181static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
2182 uint64_t off, uint32_t max_count)
2183{
2184 ssize_t err;
2185 size_t offset = 7;
2186 uint64_t read_count;
2187 QEMUIOVector qiov_full;
2188
2189 if (fidp->fs.xattr.len < off) {
2190 read_count = 0;
2191 } else {
2192 read_count = fidp->fs.xattr.len - off;
2193 }
2194 if (read_count > max_count) {
2195 read_count = max_count;
2196 }
2197 err = pdu_marshal(pdu, offset, "d", read_count);
2198 if (err < 0) {
2199 return err;
2200 }
2201 offset += err;
2202
2203 v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false);
2204 err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0,
2205 ((char *)fidp->fs.xattr.value) + off,
2206 read_count);
2207 qemu_iovec_destroy(&qiov_full);
2208 if (err < 0) {
2209 return err;
2210 }
2211 offset += err;
2212 return offset;
2213}
2214
2215static int coroutine_fn v9fs_do_readdir_with_stat(V9fsPDU *pdu,
2216 V9fsFidState *fidp,
2217 uint32_t max_count)
2218{
2219 V9fsPath path;
2220 V9fsStat v9stat;
2221 int len, err = 0;
2222 int32_t count = 0;
2223 struct stat stbuf;
2224 off_t saved_dir_pos;
2225 struct dirent *dent;
2226
2227 /* save the directory position */
2228 saved_dir_pos = v9fs_co_telldir(pdu, fidp);
2229 if (saved_dir_pos < 0) {
2230 return saved_dir_pos;
2231 }
2232
2233 while (1) {
2234 v9fs_path_init(&path);
2235
2236 v9fs_readdir_lock(&fidp->fs.dir);
2237
2238 err = v9fs_co_readdir(pdu, fidp, &dent);
2239 if (err || !dent) {
2240 break;
2241 }
2242 err = v9fs_co_name_to_path(pdu, &fidp->path, dent->d_name, &path);
2243 if (err < 0) {
2244 break;
2245 }
2246 err = v9fs_co_lstat(pdu, &path, &stbuf);
2247 if (err < 0) {
2248 break;
2249 }
2250 err = stat_to_v9stat(pdu, &path, dent->d_name, &stbuf, &v9stat);
2251 if (err < 0) {
2252 break;
2253 }
2254 if ((count + v9stat.size + 2) > max_count) {
2255 v9fs_readdir_unlock(&fidp->fs.dir);
2256
2257 /* Ran out of buffer. Set dir back to old position and return */
2258 v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
2259 v9fs_stat_free(&v9stat);
2260 v9fs_path_free(&path);
2261 return count;
2262 }
2263
2264 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
2265 len = pdu_marshal(pdu, 11 + count, "S", &v9stat);
2266
2267 v9fs_readdir_unlock(&fidp->fs.dir);
2268
2269 if (len < 0) {
2270 v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
2271 v9fs_stat_free(&v9stat);
2272 v9fs_path_free(&path);
2273 return len;
2274 }
2275 count += len;
2276 v9fs_stat_free(&v9stat);
2277 v9fs_path_free(&path);
2278 saved_dir_pos = dent->d_off;
2279 }
2280
2281 v9fs_readdir_unlock(&fidp->fs.dir);
2282
2283 v9fs_path_free(&path);
2284 if (err < 0) {
2285 return err;
2286 }
2287 return count;
2288}
2289
2290static void coroutine_fn v9fs_read(void *opaque)
2291{
2292 int32_t fid;
2293 uint64_t off;
2294 ssize_t err = 0;
2295 int32_t count = 0;
2296 size_t offset = 7;
2297 uint32_t max_count;
2298 V9fsFidState *fidp;
2299 V9fsPDU *pdu = opaque;
2300 V9fsState *s = pdu->s;
2301
2302 err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &max_count);
2303 if (err < 0) {
2304 goto out_nofid;
2305 }
2306 trace_v9fs_read(pdu->tag, pdu->id, fid, off, max_count);
2307
2308 fidp = get_fid(pdu, fid);
2309 if (fidp == NULL) {
2310 err = -EINVAL;
2311 goto out_nofid;
2312 }
2313 if (fidp->fid_type == P9_FID_DIR) {
2314 if (s->proto_version != V9FS_PROTO_2000U) {
2315 warn_report_once(
2316 "9p: bad client: T_read request on directory only expected "
2317 "with 9P2000.u protocol version"
2318 );
2319 err = -EOPNOTSUPP;
2320 goto out;
2321 }
2322 if (off == 0) {
2323 v9fs_co_rewinddir(pdu, fidp);
2324 }
2325 count = v9fs_do_readdir_with_stat(pdu, fidp, max_count);
2326 if (count < 0) {
2327 err = count;
2328 goto out;
2329 }
2330 err = pdu_marshal(pdu, offset, "d", count);
2331 if (err < 0) {
2332 goto out;
2333 }
2334 err += offset + count;
2335 } else if (fidp->fid_type == P9_FID_FILE) {
2336 QEMUIOVector qiov_full;
2337 QEMUIOVector qiov;
2338 int32_t len;
2339
2340 v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count, false);
2341 qemu_iovec_init(&qiov, qiov_full.niov);
2342 do {
2343 qemu_iovec_reset(&qiov);
2344 qemu_iovec_concat(&qiov, &qiov_full, count, qiov_full.size - count);
2345 if (0) {
2346 print_sg(qiov.iov, qiov.niov);
2347 }
2348 /* Loop in case of EINTR */
2349 do {
2350 len = v9fs_co_preadv(pdu, fidp, qiov.iov, qiov.niov, off);
2351 if (len >= 0) {
2352 off += len;
2353 count += len;
2354 }
2355 } while (len == -EINTR && !pdu->cancelled);
2356 if (len < 0) {
2357 /* IO error return the error */
2358 err = len;
2359 goto out_free_iovec;
2360 }
2361 } while (count < max_count && len > 0);
2362 err = pdu_marshal(pdu, offset, "d", count);
2363 if (err < 0) {
2364 goto out_free_iovec;
2365 }
2366 err += offset + count;
2367out_free_iovec:
2368 qemu_iovec_destroy(&qiov);
2369 qemu_iovec_destroy(&qiov_full);
2370 } else if (fidp->fid_type == P9_FID_XATTR) {
2371 err = v9fs_xattr_read(s, pdu, fidp, off, max_count);
2372 } else {
2373 err = -EINVAL;
2374 }
2375 trace_v9fs_read_return(pdu->tag, pdu->id, count, err);
2376out:
2377 put_fid(pdu, fidp);
2378out_nofid:
2379 pdu_complete(pdu, err);
2380}
2381
2382/**
2383 * Returns size required in Rreaddir response for the passed dirent @p name.
2384 *
2385 * @param name - directory entry's name (i.e. file name, directory name)
2386 * @returns required size in bytes
2387 */
2388size_t v9fs_readdir_response_size(V9fsString *name)
2389{
2390 /*
2391 * Size of each dirent on the wire: size of qid (13) + size of offset (8)
2392 * size of type (1) + size of name.size (2) + strlen(name.data)
2393 */
2394 return 24 + v9fs_string_size(name);
2395}
2396
2397static void v9fs_free_dirents(struct V9fsDirEnt *e)
2398{
2399 struct V9fsDirEnt *next = NULL;
2400
2401 for (; e; e = next) {
2402 next = e->next;
2403 g_free(e->dent);
2404 g_free(e->st);
2405 g_free(e);
2406 }
2407}
2408
2409static int coroutine_fn v9fs_do_readdir(V9fsPDU *pdu, V9fsFidState *fidp,
2410 off_t offset, int32_t max_count)
2411{
2412 size_t size;
2413 V9fsQID qid;
2414 V9fsString name;
2415 int len, err = 0;
2416 int32_t count = 0;
2417 struct dirent *dent;
2418 struct stat *st;
2419 struct V9fsDirEnt *entries = NULL;
2420
2421 /*
2422 * inode remapping requires the device id, which in turn might be
2423 * different for different directory entries, so if inode remapping is
2424 * enabled we have to make a full stat for each directory entry
2425 */
2426 const bool dostat = pdu->s->ctx.export_flags & V9FS_REMAP_INODES;
2427
2428 /*
2429 * Fetch all required directory entries altogether on a background IO
2430 * thread from fs driver. We don't want to do that for each entry
2431 * individually, because hopping between threads (this main IO thread
2432 * and background IO driver thread) would sum up to huge latencies.
2433 */
2434 count = v9fs_co_readdir_many(pdu, fidp, &entries, offset, max_count,
2435 dostat);
2436 if (count < 0) {
2437 err = count;
2438 count = 0;
2439 goto out;
2440 }
2441 count = 0;
2442
2443 for (struct V9fsDirEnt *e = entries; e; e = e->next) {
2444 dent = e->dent;
2445
2446 if (pdu->s->ctx.export_flags & V9FS_REMAP_INODES) {
2447 st = e->st;
2448 /* e->st should never be NULL, but just to be sure */
2449 if (!st) {
2450 err = -1;
2451 break;
2452 }
2453
2454 /* remap inode */
2455 err = stat_to_qid(pdu, st, &qid);
2456 if (err < 0) {
2457 break;
2458 }
2459 } else {
2460 /*
2461 * Fill up just the path field of qid because the client uses
2462 * only that. To fill the entire qid structure we will have
2463 * to stat each dirent found, which is expensive. For the
2464 * latter reason we don't call stat_to_qid() here. Only drawback
2465 * is that no multi-device export detection of stat_to_qid()
2466 * would be done and provided as error to the user here. But
2467 * user would get that error anyway when accessing those
2468 * files/dirs through other ways.
2469 */
2470 size = MIN(sizeof(dent->d_ino), sizeof(qid.path));
2471 memcpy(&qid.path, &dent->d_ino, size);
2472 /* Fill the other fields with dummy values */
2473 qid.type = 0;
2474 qid.version = 0;
2475 }
2476
2477 v9fs_string_init(&name);
2478 v9fs_string_sprintf(&name, "%s", dent->d_name);
2479
2480 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
2481 len = pdu_marshal(pdu, 11 + count, "Qqbs",
2482 &qid, dent->d_off,
2483 dent->d_type, &name);
2484
2485 v9fs_string_free(&name);
2486
2487 if (len < 0) {
2488 err = len;
2489 break;
2490 }
2491
2492 count += len;
2493 }
2494
2495out:
2496 v9fs_free_dirents(entries);
2497 if (err < 0) {
2498 return err;
2499 }
2500 return count;
2501}
2502
2503static void coroutine_fn v9fs_readdir(void *opaque)
2504{
2505 int32_t fid;
2506 V9fsFidState *fidp;
2507 ssize_t retval = 0;
2508 size_t offset = 7;
2509 uint64_t initial_offset;
2510 int32_t count;
2511 uint32_t max_count;
2512 V9fsPDU *pdu = opaque;
2513 V9fsState *s = pdu->s;
2514
2515 retval = pdu_unmarshal(pdu, offset, "dqd", &fid,
2516 &initial_offset, &max_count);
2517 if (retval < 0) {
2518 goto out_nofid;
2519 }
2520 trace_v9fs_readdir(pdu->tag, pdu->id, fid, initial_offset, max_count);
2521
2522 /* Enough space for a R_readdir header: size[4] Rreaddir tag[2] count[4] */
2523 if (max_count > s->msize - 11) {
2524 max_count = s->msize - 11;
2525 warn_report_once(
2526 "9p: bad client: T_readdir with count > msize - 11"
2527 );
2528 }
2529
2530 fidp = get_fid(pdu, fid);
2531 if (fidp == NULL) {
2532 retval = -EINVAL;
2533 goto out_nofid;
2534 }
2535 if (!fidp->fs.dir.stream) {
2536 retval = -EINVAL;
2537 goto out;
2538 }
2539 if (s->proto_version != V9FS_PROTO_2000L) {
2540 warn_report_once(
2541 "9p: bad client: T_readdir request only expected with 9P2000.L "
2542 "protocol version"
2543 );
2544 retval = -EOPNOTSUPP;
2545 goto out;
2546 }
2547 count = v9fs_do_readdir(pdu, fidp, (off_t) initial_offset, max_count);
2548 if (count < 0) {
2549 retval = count;
2550 goto out;
2551 }
2552 retval = pdu_marshal(pdu, offset, "d", count);
2553 if (retval < 0) {
2554 goto out;
2555 }
2556 retval += count + offset;
2557 trace_v9fs_readdir_return(pdu->tag, pdu->id, count, retval);
2558out:
2559 put_fid(pdu, fidp);
2560out_nofid:
2561 pdu_complete(pdu, retval);
2562}
2563
2564static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
2565 uint64_t off, uint32_t count,
2566 struct iovec *sg, int cnt)
2567{
2568 int i, to_copy;
2569 ssize_t err = 0;
2570 uint64_t write_count;
2571 size_t offset = 7;
2572
2573
2574 if (fidp->fs.xattr.len < off) {
2575 return -ENOSPC;
2576 }
2577 write_count = fidp->fs.xattr.len - off;
2578 if (write_count > count) {
2579 write_count = count;
2580 }
2581 err = pdu_marshal(pdu, offset, "d", write_count);
2582 if (err < 0) {
2583 return err;
2584 }
2585 err += offset;
2586 fidp->fs.xattr.copied_len += write_count;
2587 /*
2588 * Now copy the content from sg list
2589 */
2590 for (i = 0; i < cnt; i++) {
2591 if (write_count > sg[i].iov_len) {
2592 to_copy = sg[i].iov_len;
2593 } else {
2594 to_copy = write_count;
2595 }
2596 memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
2597 /* updating vs->off since we are not using below */
2598 off += to_copy;
2599 write_count -= to_copy;
2600 }
2601
2602 return err;
2603}
2604
2605static void coroutine_fn v9fs_write(void *opaque)
2606{
2607 ssize_t err;
2608 int32_t fid;
2609 uint64_t off;
2610 uint32_t count;
2611 int32_t len = 0;
2612 int32_t total = 0;
2613 size_t offset = 7;
2614 V9fsFidState *fidp;
2615 V9fsPDU *pdu = opaque;
2616 V9fsState *s = pdu->s;
2617 QEMUIOVector qiov_full;
2618 QEMUIOVector qiov;
2619
2620 err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &count);
2621 if (err < 0) {
2622 pdu_complete(pdu, err);
2623 return;
2624 }
2625 offset += err;
2626 v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
2627 trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
2628
2629 fidp = get_fid(pdu, fid);
2630 if (fidp == NULL) {
2631 err = -EINVAL;
2632 goto out_nofid;
2633 }
2634 if (fidp->fid_type == P9_FID_FILE) {
2635 if (fidp->fs.fd == -1) {
2636 err = -EINVAL;
2637 goto out;
2638 }
2639 } else if (fidp->fid_type == P9_FID_XATTR) {
2640 /*
2641 * setxattr operation
2642 */
2643 err = v9fs_xattr_write(s, pdu, fidp, off, count,
2644 qiov_full.iov, qiov_full.niov);
2645 goto out;
2646 } else {
2647 err = -EINVAL;
2648 goto out;
2649 }
2650 qemu_iovec_init(&qiov, qiov_full.niov);
2651 do {
2652 qemu_iovec_reset(&qiov);
2653 qemu_iovec_concat(&qiov, &qiov_full, total, qiov_full.size - total);
2654 if (0) {
2655 print_sg(qiov.iov, qiov.niov);
2656 }
2657 /* Loop in case of EINTR */
2658 do {
2659 len = v9fs_co_pwritev(pdu, fidp, qiov.iov, qiov.niov, off);
2660 if (len >= 0) {
2661 off += len;
2662 total += len;
2663 }
2664 } while (len == -EINTR && !pdu->cancelled);
2665 if (len < 0) {
2666 /* IO error return the error */
2667 err = len;
2668 goto out_qiov;
2669 }
2670 } while (total < count && len > 0);
2671
2672 offset = 7;
2673 err = pdu_marshal(pdu, offset, "d", total);
2674 if (err < 0) {
2675 goto out_qiov;
2676 }
2677 err += offset;
2678 trace_v9fs_write_return(pdu->tag, pdu->id, total, err);
2679out_qiov:
2680 qemu_iovec_destroy(&qiov);
2681out:
2682 put_fid(pdu, fidp);
2683out_nofid:
2684 qemu_iovec_destroy(&qiov_full);
2685 pdu_complete(pdu, err);
2686}
2687
2688static void coroutine_fn v9fs_create(void *opaque)
2689{
2690 int32_t fid;
2691 int err = 0;
2692 size_t offset = 7;
2693 V9fsFidState *fidp;
2694 V9fsQID qid;
2695 int32_t perm;
2696 int8_t mode;
2697 V9fsPath path;
2698 struct stat stbuf;
2699 V9fsString name;
2700 V9fsString extension;
2701 int iounit;
2702 V9fsPDU *pdu = opaque;
2703 V9fsState *s = pdu->s;
2704
2705 v9fs_path_init(&path);
2706 v9fs_string_init(&name);
2707 v9fs_string_init(&extension);
2708 err = pdu_unmarshal(pdu, offset, "dsdbs", &fid, &name,
2709 &perm, &mode, &extension);
2710 if (err < 0) {
2711 goto out_nofid;
2712 }
2713 trace_v9fs_create(pdu->tag, pdu->id, fid, name.data, perm, mode);
2714
2715 if (name_is_illegal(name.data)) {
2716 err = -ENOENT;
2717 goto out_nofid;
2718 }
2719
2720 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
2721 err = -EEXIST;
2722 goto out_nofid;
2723 }
2724
2725 fidp = get_fid(pdu, fid);
2726 if (fidp == NULL) {
2727 err = -EINVAL;
2728 goto out_nofid;
2729 }
2730 if (fidp->fid_type != P9_FID_NONE) {
2731 err = -EINVAL;
2732 goto out;
2733 }
2734 if (perm & P9_STAT_MODE_DIR) {
2735 err = v9fs_co_mkdir(pdu, fidp, &name, perm & 0777,
2736 fidp->uid, -1, &stbuf);
2737 if (err < 0) {
2738 goto out;
2739 }
2740 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2741 if (err < 0) {
2742 goto out;
2743 }
2744 v9fs_path_write_lock(s);
2745 v9fs_path_copy(&fidp->path, &path);
2746 v9fs_path_unlock(s);
2747 err = v9fs_co_opendir(pdu, fidp);
2748 if (err < 0) {
2749 goto out;
2750 }
2751 fidp->fid_type = P9_FID_DIR;
2752 } else if (perm & P9_STAT_MODE_SYMLINK) {
2753 err = v9fs_co_symlink(pdu, fidp, &name,
2754 extension.data, -1 , &stbuf);
2755 if (err < 0) {
2756 goto out;
2757 }
2758 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2759 if (err < 0) {
2760 goto out;
2761 }
2762 v9fs_path_write_lock(s);
2763 v9fs_path_copy(&fidp->path, &path);
2764 v9fs_path_unlock(s);
2765 } else if (perm & P9_STAT_MODE_LINK) {
2766 int32_t ofid = atoi(extension.data);
2767 V9fsFidState *ofidp = get_fid(pdu, ofid);
2768 if (ofidp == NULL) {
2769 err = -EINVAL;
2770 goto out;
2771 }
2772 err = v9fs_co_link(pdu, ofidp, fidp, &name);
2773 put_fid(pdu, ofidp);
2774 if (err < 0) {
2775 goto out;
2776 }
2777 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2778 if (err < 0) {
2779 fidp->fid_type = P9_FID_NONE;
2780 goto out;
2781 }
2782 v9fs_path_write_lock(s);
2783 v9fs_path_copy(&fidp->path, &path);
2784 v9fs_path_unlock(s);
2785 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
2786 if (err < 0) {
2787 fidp->fid_type = P9_FID_NONE;
2788 goto out;
2789 }
2790 } else if (perm & P9_STAT_MODE_DEVICE) {
2791 char ctype;
2792 uint32_t major, minor;
2793 mode_t nmode = 0;
2794
2795 if (sscanf(extension.data, "%c %u %u", &ctype, &major, &minor) != 3) {
2796 err = -errno;
2797 goto out;
2798 }
2799
2800 switch (ctype) {
2801 case 'c':
2802 nmode = S_IFCHR;
2803 break;
2804 case 'b':
2805 nmode = S_IFBLK;
2806 break;
2807 default:
2808 err = -EIO;
2809 goto out;
2810 }
2811
2812 nmode |= perm & 0777;
2813 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
2814 makedev(major, minor), nmode, &stbuf);
2815 if (err < 0) {
2816 goto out;
2817 }
2818 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2819 if (err < 0) {
2820 goto out;
2821 }
2822 v9fs_path_write_lock(s);
2823 v9fs_path_copy(&fidp->path, &path);
2824 v9fs_path_unlock(s);
2825 } else if (perm & P9_STAT_MODE_NAMED_PIPE) {
2826 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
2827 0, S_IFIFO | (perm & 0777), &stbuf);
2828 if (err < 0) {
2829 goto out;
2830 }
2831 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2832 if (err < 0) {
2833 goto out;
2834 }
2835 v9fs_path_write_lock(s);
2836 v9fs_path_copy(&fidp->path, &path);
2837 v9fs_path_unlock(s);
2838 } else if (perm & P9_STAT_MODE_SOCKET) {
2839 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
2840 0, S_IFSOCK | (perm & 0777), &stbuf);
2841 if (err < 0) {
2842 goto out;
2843 }
2844 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2845 if (err < 0) {
2846 goto out;
2847 }
2848 v9fs_path_write_lock(s);
2849 v9fs_path_copy(&fidp->path, &path);
2850 v9fs_path_unlock(s);
2851 } else {
2852 err = v9fs_co_open2(pdu, fidp, &name, -1,
2853 omode_to_uflags(mode) | O_CREAT, perm, &stbuf);
2854 if (err < 0) {
2855 goto out;
2856 }
2857 fidp->fid_type = P9_FID_FILE;
2858 fidp->open_flags = omode_to_uflags(mode);
2859 if (fidp->open_flags & O_EXCL) {
2860 /*
2861 * We let the host file system do O_EXCL check
2862 * We should not reclaim such fd
2863 */
2864 fidp->flags |= FID_NON_RECLAIMABLE;
2865 }
2866 }
2867 iounit = get_iounit(pdu, &fidp->path);
2868 err = stat_to_qid(pdu, &stbuf, &qid);
2869 if (err < 0) {
2870 goto out;
2871 }
2872 err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
2873 if (err < 0) {
2874 goto out;
2875 }
2876 err += offset;
2877 trace_v9fs_create_return(pdu->tag, pdu->id,
2878 qid.type, qid.version, qid.path, iounit);
2879out:
2880 put_fid(pdu, fidp);
2881out_nofid:
2882 pdu_complete(pdu, err);
2883 v9fs_string_free(&name);
2884 v9fs_string_free(&extension);
2885 v9fs_path_free(&path);
2886}
2887
2888static void coroutine_fn v9fs_symlink(void *opaque)
2889{
2890 V9fsPDU *pdu = opaque;
2891 V9fsString name;
2892 V9fsString symname;
2893 V9fsFidState *dfidp;
2894 V9fsQID qid;
2895 struct stat stbuf;
2896 int32_t dfid;
2897 int err = 0;
2898 gid_t gid;
2899 size_t offset = 7;
2900
2901 v9fs_string_init(&name);
2902 v9fs_string_init(&symname);
2903 err = pdu_unmarshal(pdu, offset, "dssd", &dfid, &name, &symname, &gid);
2904 if (err < 0) {
2905 goto out_nofid;
2906 }
2907 trace_v9fs_symlink(pdu->tag, pdu->id, dfid, name.data, symname.data, gid);
2908
2909 if (name_is_illegal(name.data)) {
2910 err = -ENOENT;
2911 goto out_nofid;
2912 }
2913
2914 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
2915 err = -EEXIST;
2916 goto out_nofid;
2917 }
2918
2919 dfidp = get_fid(pdu, dfid);
2920 if (dfidp == NULL) {
2921 err = -EINVAL;
2922 goto out_nofid;
2923 }
2924 err = v9fs_co_symlink(pdu, dfidp, &name, symname.data, gid, &stbuf);
2925 if (err < 0) {
2926 goto out;
2927 }
2928 err = stat_to_qid(pdu, &stbuf, &qid);
2929 if (err < 0) {
2930 goto out;
2931 }
2932 err = pdu_marshal(pdu, offset, "Q", &qid);
2933 if (err < 0) {
2934 goto out;
2935 }
2936 err += offset;
2937 trace_v9fs_symlink_return(pdu->tag, pdu->id,
2938 qid.type, qid.version, qid.path);
2939out:
2940 put_fid(pdu, dfidp);
2941out_nofid:
2942 pdu_complete(pdu, err);
2943 v9fs_string_free(&name);
2944 v9fs_string_free(&symname);
2945}
2946
2947static void coroutine_fn v9fs_flush(void *opaque)
2948{
2949 ssize_t err;
2950 int16_t tag;
2951 size_t offset = 7;
2952 V9fsPDU *cancel_pdu = NULL;
2953 V9fsPDU *pdu = opaque;
2954 V9fsState *s = pdu->s;
2955
2956 err = pdu_unmarshal(pdu, offset, "w", &tag);
2957 if (err < 0) {
2958 pdu_complete(pdu, err);
2959 return;
2960 }
2961 trace_v9fs_flush(pdu->tag, pdu->id, tag);
2962
2963 if (pdu->tag == tag) {
2964 warn_report("the guest sent a self-referencing 9P flush request");
2965 } else {
2966 QLIST_FOREACH(cancel_pdu, &s->active_list, next) {
2967 if (cancel_pdu->tag == tag) {
2968 break;
2969 }
2970 }
2971 }
2972 if (cancel_pdu) {
2973 cancel_pdu->cancelled = 1;
2974 /*
2975 * Wait for pdu to complete.
2976 */
2977 qemu_co_queue_wait(&cancel_pdu->complete, NULL);
2978 if (!qemu_co_queue_next(&cancel_pdu->complete)) {
2979 cancel_pdu->cancelled = 0;
2980 pdu_free(cancel_pdu);
2981 }
2982 }
2983 pdu_complete(pdu, 7);
2984}
2985
2986static void coroutine_fn v9fs_link(void *opaque)
2987{
2988 V9fsPDU *pdu = opaque;
2989 int32_t dfid, oldfid;
2990 V9fsFidState *dfidp, *oldfidp;
2991 V9fsString name;
2992 size_t offset = 7;
2993 int err = 0;
2994
2995 v9fs_string_init(&name);
2996 err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2997 if (err < 0) {
2998 goto out_nofid;
2999 }
3000 trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);
3001
3002 if (name_is_illegal(name.data)) {
3003 err = -ENOENT;
3004 goto out_nofid;
3005 }
3006
3007 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
3008 err = -EEXIST;
3009 goto out_nofid;
3010 }
3011
3012 dfidp = get_fid(pdu, dfid);
3013 if (dfidp == NULL) {
3014 err = -ENOENT;
3015 goto out_nofid;
3016 }
3017
3018 oldfidp = get_fid(pdu, oldfid);
3019 if (oldfidp == NULL) {
3020 err = -ENOENT;
3021 goto out;
3022 }
3023 err = v9fs_co_link(pdu, oldfidp, dfidp, &name);
3024 if (!err) {
3025 err = offset;
3026 }
3027 put_fid(pdu, oldfidp);
3028out:
3029 put_fid(pdu, dfidp);
3030out_nofid:
3031 v9fs_string_free(&name);
3032 pdu_complete(pdu, err);
3033}
3034
3035/* Only works with path name based fid */
3036static void coroutine_fn v9fs_remove(void *opaque)
3037{
3038 int32_t fid;
3039 int err = 0;
3040 size_t offset = 7;
3041 V9fsFidState *fidp;
3042 V9fsPDU *pdu = opaque;
3043
3044 err = pdu_unmarshal(pdu, offset, "d", &fid);
3045 if (err < 0) {
3046 goto out_nofid;
3047 }
3048 trace_v9fs_remove(pdu->tag, pdu->id, fid);
3049
3050 fidp = get_fid(pdu, fid);
3051 if (fidp == NULL) {
3052 err = -EINVAL;
3053 goto out_nofid;
3054 }
3055 /* if fs driver is not path based, return EOPNOTSUPP */
3056 if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {
3057 err = -EOPNOTSUPP;
3058 goto out_err;
3059 }
3060 /*
3061 * IF the file is unlinked, we cannot reopen
3062 * the file later. So don't reclaim fd
3063 */
3064 err = v9fs_mark_fids_unreclaim(pdu, &fidp->path);
3065 if (err < 0) {
3066 goto out_err;
3067 }
3068 err = v9fs_co_remove(pdu, &fidp->path);
3069 if (!err) {
3070 err = offset;
3071 }
3072out_err:
3073 /* For TREMOVE we need to clunk the fid even on failed remove */
3074 clunk_fid(pdu->s, fidp->fid);
3075 put_fid(pdu, fidp);
3076out_nofid:
3077 pdu_complete(pdu, err);
3078}
3079
3080static void coroutine_fn v9fs_unlinkat(void *opaque)
3081{
3082 int err = 0;
3083 V9fsString name;
3084 int32_t dfid, flags, rflags = 0;
3085 size_t offset = 7;
3086 V9fsPath path;
3087 V9fsFidState *dfidp;
3088 V9fsPDU *pdu = opaque;
3089
3090 v9fs_string_init(&name);
3091 err = pdu_unmarshal(pdu, offset, "dsd", &dfid, &name, &flags);
3092 if (err < 0) {
3093 goto out_nofid;
3094 }
3095
3096 if (name_is_illegal(name.data)) {
3097 err = -ENOENT;
3098 goto out_nofid;
3099 }
3100
3101 if (!strcmp(".", name.data)) {
3102 err = -EINVAL;
3103 goto out_nofid;
3104 }
3105
3106 if (!strcmp("..", name.data)) {
3107 err = -ENOTEMPTY;
3108 goto out_nofid;
3109 }
3110
3111 if (flags & ~P9_DOTL_AT_REMOVEDIR) {
3112 err = -EINVAL;
3113 goto out_nofid;
3114 }
3115
3116 if (flags & P9_DOTL_AT_REMOVEDIR) {
3117 rflags |= AT_REMOVEDIR;
3118 }
3119
3120 dfidp = get_fid(pdu, dfid);
3121 if (dfidp == NULL) {
3122 err = -EINVAL;
3123 goto out_nofid;
3124 }
3125 /*
3126 * IF the file is unlinked, we cannot reopen
3127 * the file later. So don't reclaim fd
3128 */
3129 v9fs_path_init(&path);
3130 err = v9fs_co_name_to_path(pdu, &dfidp->path, name.data, &path);
3131 if (err < 0) {
3132 goto out_err;
3133 }
3134 err = v9fs_mark_fids_unreclaim(pdu, &path);
3135 if (err < 0) {
3136 goto out_err;
3137 }
3138 err = v9fs_co_unlinkat(pdu, &dfidp->path, &name, rflags);
3139 if (!err) {
3140 err = offset;
3141 }
3142out_err:
3143 put_fid(pdu, dfidp);
3144 v9fs_path_free(&path);
3145out_nofid:
3146 pdu_complete(pdu, err);
3147 v9fs_string_free(&name);
3148}
3149
3150
3151/* Only works with path name based fid */
3152static int coroutine_fn v9fs_complete_rename(V9fsPDU *pdu, V9fsFidState *fidp,
3153 int32_t newdirfid,
3154 V9fsString *name)
3155{
3156 int err = 0;
3157 V9fsPath new_path;
3158 V9fsFidState *tfidp;
3159 V9fsState *s = pdu->s;
3160 V9fsFidState *dirfidp = NULL;
3161
3162 v9fs_path_init(&new_path);
3163 if (newdirfid != -1) {
3164 dirfidp = get_fid(pdu, newdirfid);
3165 if (dirfidp == NULL) {
3166 return -ENOENT;
3167 }
3168 if (fidp->fid_type != P9_FID_NONE) {
3169 err = -EINVAL;
3170 goto out;
3171 }
3172 err = v9fs_co_name_to_path(pdu, &dirfidp->path, name->data, &new_path);
3173 if (err < 0) {
3174 goto out;
3175 }
3176 } else {
3177 char *dir_name = g_path_get_dirname(fidp->path.data);
3178 V9fsPath dir_path;
3179
3180 v9fs_path_init(&dir_path);
3181 v9fs_path_sprintf(&dir_path, "%s", dir_name);
3182 g_free(dir_name);
3183
3184 err = v9fs_co_name_to_path(pdu, &dir_path, name->data, &new_path);
3185 v9fs_path_free(&dir_path);
3186 if (err < 0) {
3187 goto out;
3188 }
3189 }
3190 err = v9fs_co_rename(pdu, &fidp->path, &new_path);
3191 if (err < 0) {
3192 goto out;
3193 }
3194 /*
3195 * Fixup fid's pointing to the old name to
3196 * start pointing to the new name
3197 */
3198 QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) {
3199 if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) {
3200 /* replace the name */
3201 v9fs_fix_path(&tfidp->path, &new_path, strlen(fidp->path.data));
3202 }
3203 }
3204out:
3205 if (dirfidp) {
3206 put_fid(pdu, dirfidp);
3207 }
3208 v9fs_path_free(&new_path);
3209 return err;
3210}
3211
3212/* Only works with path name based fid */
3213static void coroutine_fn v9fs_rename(void *opaque)
3214{
3215 int32_t fid;
3216 ssize_t err = 0;
3217 size_t offset = 7;
3218 V9fsString name;
3219 int32_t newdirfid;
3220 V9fsFidState *fidp;
3221 V9fsPDU *pdu = opaque;
3222 V9fsState *s = pdu->s;
3223
3224 v9fs_string_init(&name);
3225 err = pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name);
3226 if (err < 0) {
3227 goto out_nofid;
3228 }
3229
3230 if (name_is_illegal(name.data)) {
3231 err = -ENOENT;
3232 goto out_nofid;
3233 }
3234
3235 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
3236 err = -EISDIR;
3237 goto out_nofid;
3238 }
3239
3240 fidp = get_fid(pdu, fid);
3241 if (fidp == NULL) {
3242 err = -ENOENT;
3243 goto out_nofid;
3244 }
3245 if (fidp->fid_type != P9_FID_NONE) {
3246 err = -EINVAL;
3247 goto out;
3248 }
3249 /* if fs driver is not path based, return EOPNOTSUPP */
3250 if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {
3251 err = -EOPNOTSUPP;
3252 goto out;
3253 }
3254 v9fs_path_write_lock(s);
3255 err = v9fs_complete_rename(pdu, fidp, newdirfid, &name);
3256 v9fs_path_unlock(s);
3257 if (!err) {
3258 err = offset;
3259 }
3260out:
3261 put_fid(pdu, fidp);
3262out_nofid:
3263 pdu_complete(pdu, err);
3264 v9fs_string_free(&name);
3265}
3266
3267static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *pdu, V9fsPath *olddir,
3268 V9fsString *old_name,
3269 V9fsPath *newdir,
3270 V9fsString *new_name)
3271{
3272 V9fsFidState *tfidp;
3273 V9fsPath oldpath, newpath;
3274 V9fsState *s = pdu->s;
3275 int err;
3276
3277 v9fs_path_init(&oldpath);
3278 v9fs_path_init(&newpath);
3279 err = v9fs_co_name_to_path(pdu, olddir, old_name->data, &oldpath);
3280 if (err < 0) {
3281 goto out;
3282 }
3283 err = v9fs_co_name_to_path(pdu, newdir, new_name->data, &newpath);
3284 if (err < 0) {
3285 goto out;
3286 }
3287
3288 /*
3289 * Fixup fid's pointing to the old name to
3290 * start pointing to the new name
3291 */
3292 QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) {
3293 if (v9fs_path_is_ancestor(&oldpath, &tfidp->path)) {
3294 /* replace the name */
3295 v9fs_fix_path(&tfidp->path, &newpath, strlen(oldpath.data));
3296 }
3297 }
3298out:
3299 v9fs_path_free(&oldpath);
3300 v9fs_path_free(&newpath);
3301 return err;
3302}
3303
3304static int coroutine_fn v9fs_complete_renameat(V9fsPDU *pdu, int32_t olddirfid,
3305 V9fsString *old_name,
3306 int32_t newdirfid,
3307 V9fsString *new_name)
3308{
3309 int err = 0;
3310 V9fsState *s = pdu->s;
3311 V9fsFidState *newdirfidp = NULL, *olddirfidp = NULL;
3312
3313 olddirfidp = get_fid(pdu, olddirfid);
3314 if (olddirfidp == NULL) {
3315 err = -ENOENT;
3316 goto out;
3317 }
3318 if (newdirfid != -1) {
3319 newdirfidp = get_fid(pdu, newdirfid);
3320 if (newdirfidp == NULL) {
3321 err = -ENOENT;
3322 goto out;
3323 }
3324 } else {
3325 newdirfidp = get_fid(pdu, olddirfid);
3326 }
3327
3328 err = v9fs_co_renameat(pdu, &olddirfidp->path, old_name,
3329 &newdirfidp->path, new_name);
3330 if (err < 0) {
3331 goto out;
3332 }
3333 if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
3334 /* Only for path based fid we need to do the below fixup */
3335 err = v9fs_fix_fid_paths(pdu, &olddirfidp->path, old_name,
3336 &newdirfidp->path, new_name);
3337 }
3338out:
3339 if (olddirfidp) {
3340 put_fid(pdu, olddirfidp);
3341 }
3342 if (newdirfidp) {
3343 put_fid(pdu, newdirfidp);
3344 }
3345 return err;
3346}
3347
3348static void coroutine_fn v9fs_renameat(void *opaque)
3349{
3350 ssize_t err = 0;
3351 size_t offset = 7;
3352 V9fsPDU *pdu = opaque;
3353 V9fsState *s = pdu->s;
3354 int32_t olddirfid, newdirfid;
3355 V9fsString old_name, new_name;
3356
3357 v9fs_string_init(&old_name);
3358 v9fs_string_init(&new_name);
3359 err = pdu_unmarshal(pdu, offset, "dsds", &olddirfid,
3360 &old_name, &newdirfid, &new_name);
3361 if (err < 0) {
3362 goto out_err;
3363 }
3364
3365 if (name_is_illegal(old_name.data) || name_is_illegal(new_name.data)) {
3366 err = -ENOENT;
3367 goto out_err;
3368 }
3369
3370 if (!strcmp(".", old_name.data) || !strcmp("..", old_name.data) ||
3371 !strcmp(".", new_name.data) || !strcmp("..", new_name.data)) {
3372 err = -EISDIR;
3373 goto out_err;
3374 }
3375
3376 v9fs_path_write_lock(s);
3377 err = v9fs_complete_renameat(pdu, olddirfid,
3378 &old_name, newdirfid, &new_name);
3379 v9fs_path_unlock(s);
3380 if (!err) {
3381 err = offset;
3382 }
3383
3384out_err:
3385 pdu_complete(pdu, err);
3386 v9fs_string_free(&old_name);
3387 v9fs_string_free(&new_name);
3388}
3389
3390static void coroutine_fn v9fs_wstat(void *opaque)
3391{
3392 int32_t fid;
3393 int err = 0;
3394 int16_t unused;
3395 V9fsStat v9stat;
3396 size_t offset = 7;
3397 struct stat stbuf;
3398 V9fsFidState *fidp;
3399 V9fsPDU *pdu = opaque;
3400 V9fsState *s = pdu->s;
3401
3402 v9fs_stat_init(&v9stat);
3403 err = pdu_unmarshal(pdu, offset, "dwS", &fid, &unused, &v9stat);
3404 if (err < 0) {
3405 goto out_nofid;
3406 }
3407 trace_v9fs_wstat(pdu->tag, pdu->id, fid,
3408 v9stat.mode, v9stat.atime, v9stat.mtime);
3409
3410 fidp = get_fid(pdu, fid);
3411 if (fidp == NULL) {
3412 err = -EINVAL;
3413 goto out_nofid;
3414 }
3415 /* do we need to sync the file? */
3416 if (donttouch_stat(&v9stat)) {
3417 err = v9fs_co_fsync(pdu, fidp, 0);
3418 goto out;
3419 }
3420 if (v9stat.mode != -1) {
3421 uint32_t v9_mode;
3422 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
3423 if (err < 0) {
3424 goto out;
3425 }
3426 v9_mode = stat_to_v9mode(&stbuf);
3427 if ((v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
3428 (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
3429 /* Attempting to change the type */
3430 err = -EIO;
3431 goto out;
3432 }
3433 err = v9fs_co_chmod(pdu, &fidp->path,
3434 v9mode_to_mode(v9stat.mode,
3435 &v9stat.extension));
3436 if (err < 0) {
3437 goto out;
3438 }
3439 }
3440 if (v9stat.mtime != -1 || v9stat.atime != -1) {
3441 struct timespec times[2];
3442 if (v9stat.atime != -1) {
3443 times[0].tv_sec = v9stat.atime;
3444 times[0].tv_nsec = 0;
3445 } else {
3446 times[0].tv_nsec = UTIME_OMIT;
3447 }
3448 if (v9stat.mtime != -1) {
3449 times[1].tv_sec = v9stat.mtime;
3450 times[1].tv_nsec = 0;
3451 } else {
3452 times[1].tv_nsec = UTIME_OMIT;
3453 }
3454 err = v9fs_co_utimensat(pdu, &fidp->path, times);
3455 if (err < 0) {
3456 goto out;
3457 }
3458 }
3459 if (v9stat.n_gid != -1 || v9stat.n_uid != -1) {
3460 err = v9fs_co_chown(pdu, &fidp->path, v9stat.n_uid, v9stat.n_gid);
3461 if (err < 0) {
3462 goto out;
3463 }
3464 }
3465 if (v9stat.name.size != 0) {
3466 v9fs_path_write_lock(s);
3467 err = v9fs_complete_rename(pdu, fidp, -1, &v9stat.name);
3468 v9fs_path_unlock(s);
3469 if (err < 0) {
3470 goto out;
3471 }
3472 }
3473 if (v9stat.length != -1) {
3474 err = v9fs_co_truncate(pdu, &fidp->path, v9stat.length);
3475 if (err < 0) {
3476 goto out;
3477 }
3478 }
3479 err = offset;
3480out:
3481 put_fid(pdu, fidp);
3482out_nofid:
3483 v9fs_stat_free(&v9stat);
3484 pdu_complete(pdu, err);
3485}
3486
3487static int v9fs_fill_statfs(V9fsState *s, V9fsPDU *pdu, struct statfs *stbuf)
3488{
3489 uint32_t f_type;
3490 uint32_t f_bsize;
3491 uint64_t f_blocks;
3492 uint64_t f_bfree;
3493 uint64_t f_bavail;
3494 uint64_t f_files;
3495 uint64_t f_ffree;
3496 uint64_t fsid_val;
3497 uint32_t f_namelen;
3498 size_t offset = 7;
3499 int32_t bsize_factor;
3500
3501 /*
3502 * compute bsize factor based on host file system block size
3503 * and client msize
3504 */
3505 bsize_factor = (s->msize - P9_IOHDRSZ) / stbuf->f_bsize;
3506 if (!bsize_factor) {
3507 bsize_factor = 1;
3508 }
3509 f_type = stbuf->f_type;
3510 f_bsize = stbuf->f_bsize;
3511 f_bsize *= bsize_factor;
3512 /*
3513 * f_bsize is adjusted(multiplied) by bsize factor, so we need to
3514 * adjust(divide) the number of blocks, free blocks and available
3515 * blocks by bsize factor
3516 */
3517 f_blocks = stbuf->f_blocks / bsize_factor;
3518 f_bfree = stbuf->f_bfree / bsize_factor;
3519 f_bavail = stbuf->f_bavail / bsize_factor;
3520 f_files = stbuf->f_files;
3521 f_ffree = stbuf->f_ffree;
3522 fsid_val = (unsigned int) stbuf->f_fsid.__val[0] |
3523 (unsigned long long)stbuf->f_fsid.__val[1] << 32;
3524 f_namelen = stbuf->f_namelen;
3525
3526 return pdu_marshal(pdu, offset, "ddqqqqqqd",
3527 f_type, f_bsize, f_blocks, f_bfree,
3528 f_bavail, f_files, f_ffree,
3529 fsid_val, f_namelen);
3530}
3531
3532static void coroutine_fn v9fs_statfs(void *opaque)
3533{
3534 int32_t fid;
3535 ssize_t retval = 0;
3536 size_t offset = 7;
3537 V9fsFidState *fidp;
3538 struct statfs stbuf;
3539 V9fsPDU *pdu = opaque;
3540 V9fsState *s = pdu->s;
3541
3542 retval = pdu_unmarshal(pdu, offset, "d", &fid);
3543 if (retval < 0) {
3544 goto out_nofid;
3545 }
3546 fidp = get_fid(pdu, fid);
3547 if (fidp == NULL) {
3548 retval = -ENOENT;
3549 goto out_nofid;
3550 }
3551 retval = v9fs_co_statfs(pdu, &fidp->path, &stbuf);
3552 if (retval < 0) {
3553 goto out;
3554 }
3555 retval = v9fs_fill_statfs(s, pdu, &stbuf);
3556 if (retval < 0) {
3557 goto out;
3558 }
3559 retval += offset;
3560out:
3561 put_fid(pdu, fidp);
3562out_nofid:
3563 pdu_complete(pdu, retval);
3564}
3565
3566static void coroutine_fn v9fs_mknod(void *opaque)
3567{
3568
3569 int mode;
3570 gid_t gid;
3571 int32_t fid;
3572 V9fsQID qid;
3573 int err = 0;
3574 int major, minor;
3575 size_t offset = 7;
3576 V9fsString name;
3577 struct stat stbuf;
3578 V9fsFidState *fidp;
3579 V9fsPDU *pdu = opaque;
3580
3581 v9fs_string_init(&name);
3582 err = pdu_unmarshal(pdu, offset, "dsdddd", &fid, &name, &mode,
3583 &major, &minor, &gid);
3584 if (err < 0) {
3585 goto out_nofid;
3586 }
3587 trace_v9fs_mknod(pdu->tag, pdu->id, fid, mode, major, minor);
3588
3589 if (name_is_illegal(name.data)) {
3590 err = -ENOENT;
3591 goto out_nofid;
3592 }
3593
3594 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
3595 err = -EEXIST;
3596 goto out_nofid;
3597 }
3598
3599 fidp = get_fid(pdu, fid);
3600 if (fidp == NULL) {
3601 err = -ENOENT;
3602 goto out_nofid;
3603 }
3604 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, gid,
3605 makedev(major, minor), mode, &stbuf);
3606 if (err < 0) {
3607 goto out;
3608 }
3609 err = stat_to_qid(pdu, &stbuf, &qid);
3610 if (err < 0) {
3611 goto out;
3612 }
3613 err = pdu_marshal(pdu, offset, "Q", &qid);
3614 if (err < 0) {
3615 goto out;
3616 }
3617 err += offset;
3618 trace_v9fs_mknod_return(pdu->tag, pdu->id,
3619 qid.type, qid.version, qid.path);
3620out:
3621 put_fid(pdu, fidp);
3622out_nofid:
3623 pdu_complete(pdu, err);
3624 v9fs_string_free(&name);
3625}
3626
3627/*
3628 * Implement posix byte range locking code
3629 * Server side handling of locking code is very simple, because 9p server in
3630 * QEMU can handle only one client. And most of the lock handling
3631 * (like conflict, merging) etc is done by the VFS layer itself, so no need to
3632 * do any thing in * qemu 9p server side lock code path.
3633 * So when a TLOCK request comes, always return success
3634 */
3635static void coroutine_fn v9fs_lock(void *opaque)
3636{
3637 V9fsFlock flock;
3638 size_t offset = 7;
3639 struct stat stbuf;
3640 V9fsFidState *fidp;
3641 int32_t fid, err = 0;
3642 V9fsPDU *pdu = opaque;
3643
3644 v9fs_string_init(&flock.client_id);
3645 err = pdu_unmarshal(pdu, offset, "dbdqqds", &fid, &flock.type,
3646 &flock.flags, &flock.start, &flock.length,
3647 &flock.proc_id, &flock.client_id);
3648 if (err < 0) {
3649 goto out_nofid;
3650 }
3651 trace_v9fs_lock(pdu->tag, pdu->id, fid,
3652 flock.type, flock.start, flock.length);
3653
3654
3655 /* We support only block flag now (that too ignored currently) */
3656 if (flock.flags & ~P9_LOCK_FLAGS_BLOCK) {
3657 err = -EINVAL;
3658 goto out_nofid;
3659 }
3660 fidp = get_fid(pdu, fid);
3661 if (fidp == NULL) {
3662 err = -ENOENT;
3663 goto out_nofid;
3664 }
3665 err = v9fs_co_fstat(pdu, fidp, &stbuf);
3666 if (err < 0) {
3667 goto out;
3668 }
3669 err = pdu_marshal(pdu, offset, "b", P9_LOCK_SUCCESS);
3670 if (err < 0) {
3671 goto out;
3672 }
3673 err += offset;
3674 trace_v9fs_lock_return(pdu->tag, pdu->id, P9_LOCK_SUCCESS);
3675out:
3676 put_fid(pdu, fidp);
3677out_nofid:
3678 pdu_complete(pdu, err);
3679 v9fs_string_free(&flock.client_id);
3680}
3681
3682/*
3683 * When a TGETLOCK request comes, always return success because all lock
3684 * handling is done by client's VFS layer.
3685 */
3686static void coroutine_fn v9fs_getlock(void *opaque)
3687{
3688 size_t offset = 7;
3689 struct stat stbuf;
3690 V9fsFidState *fidp;
3691 V9fsGetlock glock;
3692 int32_t fid, err = 0;
3693 V9fsPDU *pdu = opaque;
3694
3695 v9fs_string_init(&glock.client_id);
3696 err = pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock.type,
3697 &glock.start, &glock.length, &glock.proc_id,
3698 &glock.client_id);
3699 if (err < 0) {
3700 goto out_nofid;
3701 }
3702 trace_v9fs_getlock(pdu->tag, pdu->id, fid,
3703 glock.type, glock.start, glock.length);
3704
3705 fidp = get_fid(pdu, fid);
3706 if (fidp == NULL) {
3707 err = -ENOENT;
3708 goto out_nofid;
3709 }
3710 err = v9fs_co_fstat(pdu, fidp, &stbuf);
3711 if (err < 0) {
3712 goto out;
3713 }
3714 glock.type = P9_LOCK_TYPE_UNLCK;
3715 err = pdu_marshal(pdu, offset, "bqqds", glock.type,
3716 glock.start, glock.length, glock.proc_id,
3717 &glock.client_id);
3718 if (err < 0) {
3719 goto out;
3720 }
3721 err += offset;
3722 trace_v9fs_getlock_return(pdu->tag, pdu->id, glock.type, glock.start,
3723 glock.length, glock.proc_id);
3724out:
3725 put_fid(pdu, fidp);
3726out_nofid:
3727 pdu_complete(pdu, err);
3728 v9fs_string_free(&glock.client_id);
3729}
3730
3731static void coroutine_fn v9fs_mkdir(void *opaque)
3732{
3733 V9fsPDU *pdu = opaque;
3734 size_t offset = 7;
3735 int32_t fid;
3736 struct stat stbuf;
3737 V9fsQID qid;
3738 V9fsString name;
3739 V9fsFidState *fidp;
3740 gid_t gid;
3741 int mode;
3742 int err = 0;
3743
3744 v9fs_string_init(&name);
3745 err = pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid);
3746 if (err < 0) {
3747 goto out_nofid;
3748 }
3749 trace_v9fs_mkdir(pdu->tag, pdu->id, fid, name.data, mode, gid);
3750
3751 if (name_is_illegal(name.data)) {
3752 err = -ENOENT;
3753 goto out_nofid;
3754 }
3755
3756 if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
3757 err = -EEXIST;
3758 goto out_nofid;
3759 }
3760
3761 fidp = get_fid(pdu, fid);
3762 if (fidp == NULL) {
3763 err = -ENOENT;
3764 goto out_nofid;
3765 }
3766 err = v9fs_co_mkdir(pdu, fidp, &name, mode, fidp->uid, gid, &stbuf);
3767 if (err < 0) {
3768 goto out;
3769 }
3770 err = stat_to_qid(pdu, &stbuf, &qid);
3771 if (err < 0) {
3772 goto out;
3773 }
3774 err = pdu_marshal(pdu, offset, "Q", &qid);
3775 if (err < 0) {
3776 goto out;
3777 }
3778 err += offset;
3779 trace_v9fs_mkdir_return(pdu->tag, pdu->id,
3780 qid.type, qid.version, qid.path, err);
3781out:
3782 put_fid(pdu, fidp);
3783out_nofid:
3784 pdu_complete(pdu, err);
3785 v9fs_string_free(&name);
3786}
3787
3788static void coroutine_fn v9fs_xattrwalk(void *opaque)
3789{
3790 int64_t size;
3791 V9fsString name;
3792 ssize_t err = 0;
3793 size_t offset = 7;
3794 int32_t fid, newfid;
3795 V9fsFidState *file_fidp;
3796 V9fsFidState *xattr_fidp = NULL;
3797 V9fsPDU *pdu = opaque;
3798 V9fsState *s = pdu->s;
3799
3800 v9fs_string_init(&name);
3801 err = pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
3802 if (err < 0) {
3803 goto out_nofid;
3804 }
3805 trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);
3806
3807 file_fidp = get_fid(pdu, fid);
3808 if (file_fidp == NULL) {
3809 err = -ENOENT;
3810 goto out_nofid;
3811 }
3812 xattr_fidp = alloc_fid(s, newfid);
3813 if (xattr_fidp == NULL) {
3814 err = -EINVAL;
3815 goto out;
3816 }
3817 v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);
3818 if (!v9fs_string_size(&name)) {
3819 /*
3820 * listxattr request. Get the size first
3821 */
3822 size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);
3823 if (size < 0) {
3824 err = size;
3825 clunk_fid(s, xattr_fidp->fid);
3826 goto out;
3827 }
3828 /*
3829 * Read the xattr value
3830 */
3831 xattr_fidp->fs.xattr.len = size;
3832 xattr_fidp->fid_type = P9_FID_XATTR;
3833 xattr_fidp->fs.xattr.xattrwalk_fid = true;
3834 xattr_fidp->fs.xattr.value = g_malloc0(size);
3835 if (size) {
3836 err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,
3837 xattr_fidp->fs.xattr.value,
3838 xattr_fidp->fs.xattr.len);
3839 if (err < 0) {
3840 clunk_fid(s, xattr_fidp->fid);
3841 goto out;
3842 }
3843 }
3844 err = pdu_marshal(pdu, offset, "q", size);
3845 if (err < 0) {
3846 goto out;
3847 }
3848 err += offset;
3849 } else {
3850 /*
3851 * specific xattr fid. We check for xattr
3852 * presence also collect the xattr size
3853 */
3854 size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
3855 &name, NULL, 0);
3856 if (size < 0) {
3857 err = size;
3858 clunk_fid(s, xattr_fidp->fid);
3859 goto out;
3860 }
3861 /*
3862 * Read the xattr value
3863 */
3864 xattr_fidp->fs.xattr.len = size;
3865 xattr_fidp->fid_type = P9_FID_XATTR;
3866 xattr_fidp->fs.xattr.xattrwalk_fid = true;
3867 xattr_fidp->fs.xattr.value = g_malloc0(size);
3868 if (size) {
3869 err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
3870 &name, xattr_fidp->fs.xattr.value,
3871 xattr_fidp->fs.xattr.len);
3872 if (err < 0) {
3873 clunk_fid(s, xattr_fidp->fid);
3874 goto out;
3875 }
3876 }
3877 err = pdu_marshal(pdu, offset, "q", size);
3878 if (err < 0) {
3879 goto out;
3880 }
3881 err += offset;
3882 }
3883 trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);
3884out:
3885 put_fid(pdu, file_fidp);
3886 if (xattr_fidp) {
3887 put_fid(pdu, xattr_fidp);
3888 }
3889out_nofid:
3890 pdu_complete(pdu, err);
3891 v9fs_string_free(&name);
3892}
3893
3894static void coroutine_fn v9fs_xattrcreate(void *opaque)
3895{
3896 int flags, rflags = 0;
3897 int32_t fid;
3898 uint64_t size;
3899 ssize_t err = 0;
3900 V9fsString name;
3901 size_t offset = 7;
3902 V9fsFidState *file_fidp;
3903 V9fsFidState *xattr_fidp;
3904 V9fsPDU *pdu = opaque;
3905
3906 v9fs_string_init(&name);
3907 err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags);
3908 if (err < 0) {
3909 goto out_nofid;
3910 }
3911 trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags);
3912
3913 if (flags & ~(P9_XATTR_CREATE | P9_XATTR_REPLACE)) {
3914 err = -EINVAL;
3915 goto out_nofid;
3916 }
3917
3918 if (flags & P9_XATTR_CREATE) {
3919 rflags |= XATTR_CREATE;
3920 }
3921
3922 if (flags & P9_XATTR_REPLACE) {
3923 rflags |= XATTR_REPLACE;
3924 }
3925
3926 if (size > XATTR_SIZE_MAX) {
3927 err = -E2BIG;
3928 goto out_nofid;
3929 }
3930
3931 file_fidp = get_fid(pdu, fid);
3932 if (file_fidp == NULL) {
3933 err = -EINVAL;
3934 goto out_nofid;
3935 }
3936 if (file_fidp->fid_type != P9_FID_NONE) {
3937 err = -EINVAL;
3938 goto out_put_fid;
3939 }
3940
3941 /* Make the file fid point to xattr */
3942 xattr_fidp = file_fidp;
3943 xattr_fidp->fid_type = P9_FID_XATTR;
3944 xattr_fidp->fs.xattr.copied_len = 0;
3945 xattr_fidp->fs.xattr.xattrwalk_fid = false;
3946 xattr_fidp->fs.xattr.len = size;
3947 xattr_fidp->fs.xattr.flags = rflags;
3948 v9fs_string_init(&xattr_fidp->fs.xattr.name);
3949 v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
3950 xattr_fidp->fs.xattr.value = g_malloc0(size);
3951 err = offset;
3952out_put_fid:
3953 put_fid(pdu, file_fidp);
3954out_nofid:
3955 pdu_complete(pdu, err);
3956 v9fs_string_free(&name);
3957}
3958
3959static void coroutine_fn v9fs_readlink(void *opaque)
3960{
3961 V9fsPDU *pdu = opaque;
3962 size_t offset = 7;
3963 V9fsString target;
3964 int32_t fid;
3965 int err = 0;
3966 V9fsFidState *fidp;
3967
3968 err = pdu_unmarshal(pdu, offset, "d", &fid);
3969 if (err < 0) {
3970 goto out_nofid;
3971 }
3972 trace_v9fs_readlink(pdu->tag, pdu->id, fid);
3973 fidp = get_fid(pdu, fid);
3974 if (fidp == NULL) {
3975 err = -ENOENT;
3976 goto out_nofid;
3977 }
3978
3979 v9fs_string_init(&target);
3980 err = v9fs_co_readlink(pdu, &fidp->path, &target);
3981 if (err < 0) {
3982 goto out;
3983 }
3984 err = pdu_marshal(pdu, offset, "s", &target);
3985 if (err < 0) {
3986 v9fs_string_free(&target);
3987 goto out;
3988 }
3989 err += offset;
3990 trace_v9fs_readlink_return(pdu->tag, pdu->id, target.data);
3991 v9fs_string_free(&target);
3992out:
3993 put_fid(pdu, fidp);
3994out_nofid:
3995 pdu_complete(pdu, err);
3996}
3997
3998static CoroutineEntry *pdu_co_handlers[] = {
3999 [P9_TREADDIR] = v9fs_readdir,
4000 [P9_TSTATFS] = v9fs_statfs,
4001 [P9_TGETATTR] = v9fs_getattr,
4002 [P9_TSETATTR] = v9fs_setattr,
4003 [P9_TXATTRWALK] = v9fs_xattrwalk,
4004 [P9_TXATTRCREATE] = v9fs_xattrcreate,
4005 [P9_TMKNOD] = v9fs_mknod,
4006 [P9_TRENAME] = v9fs_rename,
4007 [P9_TLOCK] = v9fs_lock,
4008 [P9_TGETLOCK] = v9fs_getlock,
4009 [P9_TRENAMEAT] = v9fs_renameat,
4010 [P9_TREADLINK] = v9fs_readlink,
4011 [P9_TUNLINKAT] = v9fs_unlinkat,
4012 [P9_TMKDIR] = v9fs_mkdir,
4013 [P9_TVERSION] = v9fs_version,
4014 [P9_TLOPEN] = v9fs_open,
4015 [P9_TATTACH] = v9fs_attach,
4016 [P9_TSTAT] = v9fs_stat,
4017 [P9_TWALK] = v9fs_walk,
4018 [P9_TCLUNK] = v9fs_clunk,
4019 [P9_TFSYNC] = v9fs_fsync,
4020 [P9_TOPEN] = v9fs_open,
4021 [P9_TREAD] = v9fs_read,
4022#if 0
4023 [P9_TAUTH] = v9fs_auth,
4024#endif
4025 [P9_TFLUSH] = v9fs_flush,
4026 [P9_TLINK] = v9fs_link,
4027 [P9_TSYMLINK] = v9fs_symlink,
4028 [P9_TCREATE] = v9fs_create,
4029 [P9_TLCREATE] = v9fs_lcreate,
4030 [P9_TWRITE] = v9fs_write,
4031 [P9_TWSTAT] = v9fs_wstat,
4032 [P9_TREMOVE] = v9fs_remove,
4033};
4034
4035static void coroutine_fn v9fs_op_not_supp(void *opaque)
4036{
4037 V9fsPDU *pdu = opaque;
4038 pdu_complete(pdu, -EOPNOTSUPP);
4039}
4040
4041static void coroutine_fn v9fs_fs_ro(void *opaque)
4042{
4043 V9fsPDU *pdu = opaque;
4044 pdu_complete(pdu, -EROFS);
4045}
4046
4047static inline bool is_read_only_op(V9fsPDU *pdu)
4048{
4049 switch (pdu->id) {
4050 case P9_TREADDIR:
4051 case P9_TSTATFS:
4052 case P9_TGETATTR:
4053 case P9_TXATTRWALK:
4054 case P9_TLOCK:
4055 case P9_TGETLOCK:
4056 case P9_TREADLINK:
4057 case P9_TVERSION:
4058 case P9_TLOPEN:
4059 case P9_TATTACH:
4060 case P9_TSTAT:
4061 case P9_TWALK:
4062 case P9_TCLUNK:
4063 case P9_TFSYNC:
4064 case P9_TOPEN:
4065 case P9_TREAD:
4066 case P9_TAUTH:
4067 case P9_TFLUSH:
4068 return 1;
4069 default:
4070 return 0;
4071 }
4072}
4073
4074void pdu_submit(V9fsPDU *pdu, P9MsgHeader *hdr)
4075{
4076 Coroutine *co;
4077 CoroutineEntry *handler;
4078 V9fsState *s = pdu->s;
4079
4080 pdu->size = le32_to_cpu(hdr->size_le);
4081 pdu->id = hdr->id;
4082 pdu->tag = le16_to_cpu(hdr->tag_le);
4083
4084 if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) ||
4085 (pdu_co_handlers[pdu->id] == NULL)) {
4086 handler = v9fs_op_not_supp;
4087 } else if (is_ro_export(&s->ctx) && !is_read_only_op(pdu)) {
4088 handler = v9fs_fs_ro;
4089 } else {
4090 handler = pdu_co_handlers[pdu->id];
4091 }
4092
4093 qemu_co_queue_init(&pdu->complete);
4094 co = qemu_coroutine_create(handler, pdu);
4095 qemu_coroutine_enter(co);
4096}
4097
4098/* Returns 0 on success, 1 on failure. */
4099int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t,
4100 Error **errp)
4101{
4102 ERRP_GUARD();
4103 int i, len;
4104 struct stat stat;
4105 FsDriverEntry *fse;
4106 V9fsPath path;
4107 int rc = 1;
4108
4109 assert(!s->transport);
4110 s->transport = t;
4111
4112 /* initialize pdu allocator */
4113 QLIST_INIT(&s->free_list);
4114 QLIST_INIT(&s->active_list);
4115 for (i = 0; i < MAX_REQ; i++) {
4116 QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next);
4117 s->pdus[i].s = s;
4118 s->pdus[i].idx = i;
4119 }
4120
4121 v9fs_path_init(&path);
4122
4123 fse = get_fsdev_fsentry(s->fsconf.fsdev_id);
4124
4125 if (!fse) {
4126 /* We don't have a fsdev identified by fsdev_id */
4127 error_setg(errp, "9pfs device couldn't find fsdev with the "
4128 "id = %s",
4129 s->fsconf.fsdev_id ? s->fsconf.fsdev_id : "NULL");
4130 goto out;
4131 }
4132
4133 if (!s->fsconf.tag) {
4134 /* we haven't specified a mount_tag */
4135 error_setg(errp, "fsdev with id %s needs mount_tag arguments",
4136 s->fsconf.fsdev_id);
4137 goto out;
4138 }
4139
4140 s->ctx.export_flags = fse->export_flags;
4141 s->ctx.fs_root = g_strdup(fse->path);
4142 s->ctx.exops.get_st_gen = NULL;
4143 len = strlen(s->fsconf.tag);
4144 if (len > MAX_TAG_LEN - 1) {
4145 error_setg(errp, "mount tag '%s' (%d bytes) is longer than "
4146 "maximum (%d bytes)", s->fsconf.tag, len, MAX_TAG_LEN - 1);
4147 goto out;
4148 }
4149
4150 s->tag = g_strdup(s->fsconf.tag);
4151 s->ctx.uid = -1;
4152
4153 s->ops = fse->ops;
4154
4155 s->ctx.fmode = fse->fmode;
4156 s->ctx.dmode = fse->dmode;
4157
4158 QSIMPLEQ_INIT(&s->fid_list);
4159 qemu_co_rwlock_init(&s->rename_lock);
4160
4161 if (s->ops->init(&s->ctx, errp) < 0) {
4162 error_prepend(errp, "cannot initialize fsdev '%s': ",
4163 s->fsconf.fsdev_id);
4164 goto out;
4165 }
4166
4167 /*
4168 * Check details of export path, We need to use fs driver
4169 * call back to do that. Since we are in the init path, we don't
4170 * use co-routines here.
4171 */
4172 if (s->ops->name_to_path(&s->ctx, NULL, "/", &path) < 0) {
4173 error_setg(errp,
4174 "error in converting name to path %s", strerror(errno));
4175 goto out;
4176 }
4177 if (s->ops->lstat(&s->ctx, &path, &stat)) {
4178 error_setg(errp, "share path %s does not exist", fse->path);
4179 goto out;
4180 } else if (!S_ISDIR(stat.st_mode)) {
4181 error_setg(errp, "share path %s is not a directory", fse->path);
4182 goto out;
4183 }
4184
4185 s->dev_id = stat.st_dev;
4186
4187 /* init inode remapping : */
4188 /* hash table for variable length inode suffixes */
4189 qpd_table_init(&s->qpd_table);
4190 /* hash table for slow/full inode remapping (most users won't need it) */
4191 qpf_table_init(&s->qpf_table);
4192 /* hash table for quick inode remapping */
4193 qpp_table_init(&s->qpp_table);
4194 s->qp_ndevices = 0;
4195 s->qp_affix_next = 1; /* reserve 0 to detect overflow */
4196 s->qp_fullpath_next = 1;
4197
4198 s->ctx.fst = &fse->fst;
4199 fsdev_throttle_init(s->ctx.fst);
4200
4201 rc = 0;
4202out:
4203 if (rc) {
4204 v9fs_device_unrealize_common(s);
4205 }
4206 v9fs_path_free(&path);
4207 return rc;
4208}
4209
4210void v9fs_device_unrealize_common(V9fsState *s)
4211{
4212 if (s->ops && s->ops->cleanup) {
4213 s->ops->cleanup(&s->ctx);
4214 }
4215 if (s->ctx.fst) {
4216 fsdev_throttle_cleanup(s->ctx.fst);
4217 }
4218 g_free(s->tag);
4219 qp_table_destroy(&s->qpd_table);
4220 qp_table_destroy(&s->qpp_table);
4221 qp_table_destroy(&s->qpf_table);
4222 g_free(s->ctx.fs_root);
4223}
4224
4225typedef struct VirtfsCoResetData {
4226 V9fsPDU pdu;
4227 bool done;
4228} VirtfsCoResetData;
4229
4230static void coroutine_fn virtfs_co_reset(void *opaque)
4231{
4232 VirtfsCoResetData *data = opaque;
4233
4234 virtfs_reset(&data->pdu);
4235 data->done = true;
4236}
4237
4238void v9fs_reset(V9fsState *s)
4239{
4240 VirtfsCoResetData data = { .pdu = { .s = s }, .done = false };
4241 Coroutine *co;
4242
4243 while (!QLIST_EMPTY(&s->active_list)) {
4244 aio_poll(qemu_get_aio_context(), true);
4245 }
4246
4247 co = qemu_coroutine_create(virtfs_co_reset, &data);
4248 qemu_coroutine_enter(co);
4249
4250 while (!data.done) {
4251 aio_poll(qemu_get_aio_context(), true);
4252 }
4253}
4254
4255static void __attribute__((__constructor__)) v9fs_set_fd_limit(void)
4256{
4257 struct rlimit rlim;
4258 if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
4259 error_report("Failed to get the resource limit");
4260 exit(1);
4261 }
4262 open_fd_hw = rlim.rlim_cur - MIN(400, rlim.rlim_cur / 3);
4263 open_fd_rc = rlim.rlim_cur / 2;
4264}
QEMU mirror