xen/pt: allow QEMU to request MSI unmasking at bind time
[qemu.git] / hw / 9pfs / 9p-local.c
1 /*
2 * 9p Posix callback
3 *
4 * Copyright IBM, Corp. 2010
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15 #include "9p.h"
16 #include "9p-local.h"
17 #include "9p-xattr.h"
18 #include "9p-util.h"
19 #include "fsdev/qemu-fsdev.h" /* local_ops */
20 #include <arpa/inet.h>
21 #include <pwd.h>
22 #include <grp.h>
23 #include <sys/socket.h>
24 #include <sys/un.h>
25 #include "qemu/xattr.h"
26 #include "qemu/cutils.h"
27 #include "qemu/error-report.h"
28 #include <libgen.h>
29 #include <linux/fs.h>
30 #ifdef CONFIG_LINUX_MAGIC_H
31 #include <linux/magic.h>
32 #endif
33 #include <sys/ioctl.h>
34
35 #ifndef XFS_SUPER_MAGIC
36 #define XFS_SUPER_MAGIC 0x58465342
37 #endif
38 #ifndef EXT2_SUPER_MAGIC
39 #define EXT2_SUPER_MAGIC 0xEF53
40 #endif
41 #ifndef REISERFS_SUPER_MAGIC
42 #define REISERFS_SUPER_MAGIC 0x52654973
43 #endif
44 #ifndef BTRFS_SUPER_MAGIC
45 #define BTRFS_SUPER_MAGIC 0x9123683E
46 #endif
47
48 typedef struct {
49 int mountfd;
50 } LocalData;
51
52 int local_open_nofollow(FsContext *fs_ctx, const char *path, int flags,
53 mode_t mode)
54 {
55 LocalData *data = fs_ctx->private;
56 int fd = data->mountfd;
57
58 while (*path && fd != -1) {
59 const char *c;
60 int next_fd;
61 char *head;
62
63 /* Only relative paths without consecutive slashes */
64 assert(*path != '/');
65
66 head = g_strdup(path);
67 c = strchrnul(path, '/');
68 if (*c) {
69 /* Intermediate path element */
70 head[c - path] = 0;
71 path = c + 1;
72 next_fd = openat_dir(fd, head);
73 } else {
74 /* Rightmost path element */
75 next_fd = openat_file(fd, head, flags, mode);
76 path = c;
77 }
78 g_free(head);
79 if (fd != data->mountfd) {
80 close_preserve_errno(fd);
81 }
82 fd = next_fd;
83 }
84
85 assert(fd != data->mountfd);
86 return fd;
87 }
88
89 int local_opendir_nofollow(FsContext *fs_ctx, const char *path)
90 {
91 return local_open_nofollow(fs_ctx, path, O_DIRECTORY | O_RDONLY, 0);
92 }
93
94 static void renameat_preserve_errno(int odirfd, const char *opath, int ndirfd,
95 const char *npath)
96 {
97 int serrno = errno;
98 renameat(odirfd, opath, ndirfd, npath);
99 errno = serrno;
100 }
101
102 static void unlinkat_preserve_errno(int dirfd, const char *path, int flags)
103 {
104 int serrno = errno;
105 unlinkat(dirfd, path, flags);
106 errno = serrno;
107 }
108
109 #define VIRTFS_META_DIR ".virtfs_metadata"
110 #define VIRTFS_META_ROOT_FILE VIRTFS_META_DIR "_root"
111
112 static FILE *local_fopenat(int dirfd, const char *name, const char *mode)
113 {
114 int fd, o_mode = 0;
115 FILE *fp;
116 int flags;
117 /*
118 * only supports two modes
119 */
120 if (mode[0] == 'r') {
121 flags = O_RDONLY;
122 } else if (mode[0] == 'w') {
123 flags = O_WRONLY | O_TRUNC | O_CREAT;
124 o_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
125 } else {
126 return NULL;
127 }
128 fd = openat_file(dirfd, name, flags, o_mode);
129 if (fd == -1) {
130 return NULL;
131 }
132 fp = fdopen(fd, mode);
133 if (!fp) {
134 close(fd);
135 }
136 return fp;
137 }
138
139 #define ATTR_MAX 100
140 static void local_mapped_file_attr(int dirfd, const char *name,
141 struct stat *stbuf)
142 {
143 FILE *fp;
144 char buf[ATTR_MAX];
145 int map_dirfd;
146
147 if (strcmp(name, ".")) {
148 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
149 if (map_dirfd == -1) {
150 return;
151 }
152
153 fp = local_fopenat(map_dirfd, name, "r");
154 close_preserve_errno(map_dirfd);
155 } else {
156 fp = local_fopenat(dirfd, VIRTFS_META_ROOT_FILE, "r");
157 }
158 if (!fp) {
159 return;
160 }
161 memset(buf, 0, ATTR_MAX);
162 while (fgets(buf, ATTR_MAX, fp)) {
163 if (!strncmp(buf, "virtfs.uid", 10)) {
164 stbuf->st_uid = atoi(buf+11);
165 } else if (!strncmp(buf, "virtfs.gid", 10)) {
166 stbuf->st_gid = atoi(buf+11);
167 } else if (!strncmp(buf, "virtfs.mode", 11)) {
168 stbuf->st_mode = atoi(buf+12);
169 } else if (!strncmp(buf, "virtfs.rdev", 11)) {
170 stbuf->st_rdev = atoi(buf+12);
171 }
172 memset(buf, 0, ATTR_MAX);
173 }
174 fclose(fp);
175 }
176
177 static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
178 {
179 int err = -1;
180 char *dirpath = g_path_get_dirname(fs_path->data);
181 char *name = g_path_get_basename(fs_path->data);
182 int dirfd;
183
184 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
185 if (dirfd == -1) {
186 goto out;
187 }
188
189 err = fstatat(dirfd, name, stbuf, AT_SYMLINK_NOFOLLOW);
190 if (err) {
191 goto err_out;
192 }
193 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
194 /* Actual credentials are part of extended attrs */
195 uid_t tmp_uid;
196 gid_t tmp_gid;
197 mode_t tmp_mode;
198 dev_t tmp_dev;
199
200 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.uid", &tmp_uid,
201 sizeof(uid_t)) > 0) {
202 stbuf->st_uid = le32_to_cpu(tmp_uid);
203 }
204 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.gid", &tmp_gid,
205 sizeof(gid_t)) > 0) {
206 stbuf->st_gid = le32_to_cpu(tmp_gid);
207 }
208 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.mode", &tmp_mode,
209 sizeof(mode_t)) > 0) {
210 stbuf->st_mode = le32_to_cpu(tmp_mode);
211 }
212 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.rdev", &tmp_dev,
213 sizeof(dev_t)) > 0) {
214 stbuf->st_rdev = le64_to_cpu(tmp_dev);
215 }
216 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
217 local_mapped_file_attr(dirfd, name, stbuf);
218 }
219
220 err_out:
221 close_preserve_errno(dirfd);
222 out:
223 g_free(name);
224 g_free(dirpath);
225 return err;
226 }
227
228 static int local_set_mapped_file_attrat(int dirfd, const char *name,
229 FsCred *credp)
230 {
231 FILE *fp;
232 int ret;
233 char buf[ATTR_MAX];
234 int uid = -1, gid = -1, mode = -1, rdev = -1;
235 int map_dirfd = -1, map_fd;
236 bool is_root = !strcmp(name, ".");
237
238 if (is_root) {
239 fp = local_fopenat(dirfd, VIRTFS_META_ROOT_FILE, "r");
240 if (!fp) {
241 if (errno == ENOENT) {
242 goto update_map_file;
243 } else {
244 return -1;
245 }
246 }
247 } else {
248 ret = mkdirat(dirfd, VIRTFS_META_DIR, 0700);
249 if (ret < 0 && errno != EEXIST) {
250 return -1;
251 }
252
253 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
254 if (map_dirfd == -1) {
255 return -1;
256 }
257
258 fp = local_fopenat(map_dirfd, name, "r");
259 if (!fp) {
260 if (errno == ENOENT) {
261 goto update_map_file;
262 } else {
263 close_preserve_errno(map_dirfd);
264 return -1;
265 }
266 }
267 }
268 memset(buf, 0, ATTR_MAX);
269 while (fgets(buf, ATTR_MAX, fp)) {
270 if (!strncmp(buf, "virtfs.uid", 10)) {
271 uid = atoi(buf + 11);
272 } else if (!strncmp(buf, "virtfs.gid", 10)) {
273 gid = atoi(buf + 11);
274 } else if (!strncmp(buf, "virtfs.mode", 11)) {
275 mode = atoi(buf + 12);
276 } else if (!strncmp(buf, "virtfs.rdev", 11)) {
277 rdev = atoi(buf + 12);
278 }
279 memset(buf, 0, ATTR_MAX);
280 }
281 fclose(fp);
282
283 update_map_file:
284 if (is_root) {
285 fp = local_fopenat(dirfd, VIRTFS_META_ROOT_FILE, "w");
286 } else {
287 fp = local_fopenat(map_dirfd, name, "w");
288 /* We can't go this far with map_dirfd not being a valid file descriptor
289 * but some versions of gcc aren't smart enough to see it.
290 */
291 if (map_dirfd != -1) {
292 close_preserve_errno(map_dirfd);
293 }
294 }
295 if (!fp) {
296 return -1;
297 }
298
299 map_fd = fileno(fp);
300 assert(map_fd != -1);
301 ret = fchmod(map_fd, 0600);
302 assert(ret == 0);
303
304 if (credp->fc_uid != -1) {
305 uid = credp->fc_uid;
306 }
307 if (credp->fc_gid != -1) {
308 gid = credp->fc_gid;
309 }
310 if (credp->fc_mode != -1) {
311 mode = credp->fc_mode;
312 }
313 if (credp->fc_rdev != -1) {
314 rdev = credp->fc_rdev;
315 }
316
317 if (uid != -1) {
318 fprintf(fp, "virtfs.uid=%d\n", uid);
319 }
320 if (gid != -1) {
321 fprintf(fp, "virtfs.gid=%d\n", gid);
322 }
323 if (mode != -1) {
324 fprintf(fp, "virtfs.mode=%d\n", mode);
325 }
326 if (rdev != -1) {
327 fprintf(fp, "virtfs.rdev=%d\n", rdev);
328 }
329 fclose(fp);
330
331 return 0;
332 }
333
334 static int fchmodat_nofollow(int dirfd, const char *name, mode_t mode)
335 {
336 struct stat stbuf;
337 int fd, ret;
338
339 /* FIXME: this should be handled with fchmodat(AT_SYMLINK_NOFOLLOW).
340 * Unfortunately, the linux kernel doesn't implement it yet.
341 */
342
343 /* First, we clear non-racing symlinks out of the way. */
344 if (fstatat(dirfd, name, &stbuf, AT_SYMLINK_NOFOLLOW)) {
345 return -1;
346 }
347 if (S_ISLNK(stbuf.st_mode)) {
348 errno = ELOOP;
349 return -1;
350 }
351
352 fd = openat_file(dirfd, name, O_RDONLY | O_PATH_9P_UTIL | O_NOFOLLOW, 0);
353 #if O_PATH_9P_UTIL == 0
354 /* Fallback for systems that don't support O_PATH: we depend on the file
355 * being readable or writable.
356 */
357 if (fd == -1) {
358 /* In case the file is writable-only and isn't a directory. */
359 if (errno == EACCES) {
360 fd = openat_file(dirfd, name, O_WRONLY, 0);
361 }
362 if (fd == -1 && errno == EISDIR) {
363 errno = EACCES;
364 }
365 }
366 if (fd == -1) {
367 return -1;
368 }
369 ret = fchmod(fd, mode);
370 #else
371 /* Access modes are ignored when O_PATH is supported. If name is a symbolic
372 * link, O_PATH | O_NOFOLLOW causes openat(2) to return a file descriptor
373 * referring to the symbolic link.
374 */
375 if (fd == -1) {
376 return -1;
377 }
378
379 /* Now we handle racing symlinks. */
380 ret = fstat(fd, &stbuf);
381 if (!ret) {
382 if (S_ISLNK(stbuf.st_mode)) {
383 errno = ELOOP;
384 ret = -1;
385 } else {
386 char *proc_path = g_strdup_printf("/proc/self/fd/%d", fd);
387 ret = chmod(proc_path, mode);
388 g_free(proc_path);
389 }
390 }
391 #endif
392 close_preserve_errno(fd);
393 return ret;
394 }
395
396 static int local_set_xattrat(int dirfd, const char *path, FsCred *credp)
397 {
398 int err;
399
400 if (credp->fc_uid != -1) {
401 uint32_t tmp_uid = cpu_to_le32(credp->fc_uid);
402 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.uid", &tmp_uid,
403 sizeof(uid_t), 0);
404 if (err) {
405 return err;
406 }
407 }
408 if (credp->fc_gid != -1) {
409 uint32_t tmp_gid = cpu_to_le32(credp->fc_gid);
410 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.gid", &tmp_gid,
411 sizeof(gid_t), 0);
412 if (err) {
413 return err;
414 }
415 }
416 if (credp->fc_mode != -1) {
417 uint32_t tmp_mode = cpu_to_le32(credp->fc_mode);
418 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.mode", &tmp_mode,
419 sizeof(mode_t), 0);
420 if (err) {
421 return err;
422 }
423 }
424 if (credp->fc_rdev != -1) {
425 uint64_t tmp_rdev = cpu_to_le64(credp->fc_rdev);
426 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.rdev", &tmp_rdev,
427 sizeof(dev_t), 0);
428 if (err) {
429 return err;
430 }
431 }
432 return 0;
433 }
434
435 static int local_set_cred_passthrough(FsContext *fs_ctx, int dirfd,
436 const char *name, FsCred *credp)
437 {
438 if (fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
439 AT_SYMLINK_NOFOLLOW) < 0) {
440 /*
441 * If we fail to change ownership and if we are
442 * using security model none. Ignore the error
443 */
444 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
445 return -1;
446 }
447 }
448
449 return fchmodat_nofollow(dirfd, name, credp->fc_mode & 07777);
450 }
451
452 static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
453 char *buf, size_t bufsz)
454 {
455 ssize_t tsize = -1;
456
457 if ((fs_ctx->export_flags & V9FS_SM_MAPPED) ||
458 (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE)) {
459 int fd;
460
461 fd = local_open_nofollow(fs_ctx, fs_path->data, O_RDONLY, 0);
462 if (fd == -1) {
463 return -1;
464 }
465 do {
466 tsize = read(fd, (void *)buf, bufsz);
467 } while (tsize == -1 && errno == EINTR);
468 close_preserve_errno(fd);
469 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
470 (fs_ctx->export_flags & V9FS_SM_NONE)) {
471 char *dirpath = g_path_get_dirname(fs_path->data);
472 char *name = g_path_get_basename(fs_path->data);
473 int dirfd;
474
475 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
476 if (dirfd == -1) {
477 goto out;
478 }
479
480 tsize = readlinkat(dirfd, name, buf, bufsz);
481 close_preserve_errno(dirfd);
482 out:
483 g_free(name);
484 g_free(dirpath);
485 }
486 return tsize;
487 }
488
489 static int local_close(FsContext *ctx, V9fsFidOpenState *fs)
490 {
491 return close(fs->fd);
492 }
493
494 static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs)
495 {
496 return closedir(fs->dir.stream);
497 }
498
499 static int local_open(FsContext *ctx, V9fsPath *fs_path,
500 int flags, V9fsFidOpenState *fs)
501 {
502 int fd;
503
504 fd = local_open_nofollow(ctx, fs_path->data, flags, 0);
505 if (fd == -1) {
506 return -1;
507 }
508 fs->fd = fd;
509 return fs->fd;
510 }
511
512 static int local_opendir(FsContext *ctx,
513 V9fsPath *fs_path, V9fsFidOpenState *fs)
514 {
515 int dirfd;
516 DIR *stream;
517
518 dirfd = local_opendir_nofollow(ctx, fs_path->data);
519 if (dirfd == -1) {
520 return -1;
521 }
522
523 stream = fdopendir(dirfd);
524 if (!stream) {
525 close(dirfd);
526 return -1;
527 }
528 fs->dir.stream = stream;
529 return 0;
530 }
531
532 static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
533 {
534 rewinddir(fs->dir.stream);
535 }
536
537 static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs)
538 {
539 return telldir(fs->dir.stream);
540 }
541
542 static bool local_is_mapped_file_metadata(FsContext *fs_ctx, const char *name)
543 {
544 return
545 !strcmp(name, VIRTFS_META_DIR) || !strcmp(name, VIRTFS_META_ROOT_FILE);
546 }
547
548 static struct dirent *local_readdir(FsContext *ctx, V9fsFidOpenState *fs)
549 {
550 struct dirent *entry;
551
552 again:
553 entry = readdir(fs->dir.stream);
554 if (!entry) {
555 return NULL;
556 }
557
558 if (ctx->export_flags & V9FS_SM_MAPPED) {
559 entry->d_type = DT_UNKNOWN;
560 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
561 if (local_is_mapped_file_metadata(ctx, entry->d_name)) {
562 /* skip the meta data */
563 goto again;
564 }
565 entry->d_type = DT_UNKNOWN;
566 }
567
568 return entry;
569 }
570
571 static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
572 {
573 seekdir(fs->dir.stream, off);
574 }
575
576 static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs,
577 const struct iovec *iov,
578 int iovcnt, off_t offset)
579 {
580 #ifdef CONFIG_PREADV
581 return preadv(fs->fd, iov, iovcnt, offset);
582 #else
583 int err = lseek(fs->fd, offset, SEEK_SET);
584 if (err == -1) {
585 return err;
586 } else {
587 return readv(fs->fd, iov, iovcnt);
588 }
589 #endif
590 }
591
592 static ssize_t local_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
593 const struct iovec *iov,
594 int iovcnt, off_t offset)
595 {
596 ssize_t ret;
597 #ifdef CONFIG_PREADV
598 ret = pwritev(fs->fd, iov, iovcnt, offset);
599 #else
600 int err = lseek(fs->fd, offset, SEEK_SET);
601 if (err == -1) {
602 return err;
603 } else {
604 ret = writev(fs->fd, iov, iovcnt);
605 }
606 #endif
607 #ifdef CONFIG_SYNC_FILE_RANGE
608 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
609 /*
610 * Initiate a writeback. This is not a data integrity sync.
611 * We want to ensure that we don't leave dirty pages in the cache
612 * after write when writeout=immediate is sepcified.
613 */
614 sync_file_range(fs->fd, offset, ret,
615 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
616 }
617 #endif
618 return ret;
619 }
620
621 static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
622 {
623 char *dirpath = g_path_get_dirname(fs_path->data);
624 char *name = g_path_get_basename(fs_path->data);
625 int ret = -1;
626 int dirfd;
627
628 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
629 if (dirfd == -1) {
630 goto out;
631 }
632
633 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
634 ret = local_set_xattrat(dirfd, name, credp);
635 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
636 ret = local_set_mapped_file_attrat(dirfd, name, credp);
637 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
638 fs_ctx->export_flags & V9FS_SM_NONE) {
639 ret = fchmodat_nofollow(dirfd, name, credp->fc_mode);
640 }
641 close_preserve_errno(dirfd);
642
643 out:
644 g_free(dirpath);
645 g_free(name);
646 return ret;
647 }
648
649 static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
650 const char *name, FsCred *credp)
651 {
652 int err = -1;
653 int dirfd;
654
655 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
656 local_is_mapped_file_metadata(fs_ctx, name)) {
657 errno = EINVAL;
658 return -1;
659 }
660
661 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
662 if (dirfd == -1) {
663 return -1;
664 }
665
666 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
667 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
668 err = mknodat(dirfd, name, fs_ctx->fmode | S_IFREG, 0);
669 if (err == -1) {
670 goto out;
671 }
672
673 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
674 err = local_set_xattrat(dirfd, name, credp);
675 } else {
676 err = local_set_mapped_file_attrat(dirfd, name, credp);
677 }
678 if (err == -1) {
679 goto err_end;
680 }
681 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
682 fs_ctx->export_flags & V9FS_SM_NONE) {
683 err = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
684 if (err == -1) {
685 goto out;
686 }
687 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
688 if (err == -1) {
689 goto err_end;
690 }
691 }
692 goto out;
693
694 err_end:
695 unlinkat_preserve_errno(dirfd, name, 0);
696 out:
697 close_preserve_errno(dirfd);
698 return err;
699 }
700
701 static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
702 const char *name, FsCred *credp)
703 {
704 int err = -1;
705 int dirfd;
706
707 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
708 local_is_mapped_file_metadata(fs_ctx, name)) {
709 errno = EINVAL;
710 return -1;
711 }
712
713 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
714 if (dirfd == -1) {
715 return -1;
716 }
717
718 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
719 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
720 err = mkdirat(dirfd, name, fs_ctx->dmode);
721 if (err == -1) {
722 goto out;
723 }
724 credp->fc_mode = credp->fc_mode | S_IFDIR;
725
726 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
727 err = local_set_xattrat(dirfd, name, credp);
728 } else {
729 err = local_set_mapped_file_attrat(dirfd, name, credp);
730 }
731 if (err == -1) {
732 goto err_end;
733 }
734 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
735 fs_ctx->export_flags & V9FS_SM_NONE) {
736 err = mkdirat(dirfd, name, credp->fc_mode);
737 if (err == -1) {
738 goto out;
739 }
740 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
741 if (err == -1) {
742 goto err_end;
743 }
744 }
745 goto out;
746
747 err_end:
748 unlinkat_preserve_errno(dirfd, name, AT_REMOVEDIR);
749 out:
750 close_preserve_errno(dirfd);
751 return err;
752 }
753
754 static int local_fstat(FsContext *fs_ctx, int fid_type,
755 V9fsFidOpenState *fs, struct stat *stbuf)
756 {
757 int err, fd;
758
759 if (fid_type == P9_FID_DIR) {
760 fd = dirfd(fs->dir.stream);
761 } else {
762 fd = fs->fd;
763 }
764
765 err = fstat(fd, stbuf);
766 if (err) {
767 return err;
768 }
769 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
770 /* Actual credentials are part of extended attrs */
771 uid_t tmp_uid;
772 gid_t tmp_gid;
773 mode_t tmp_mode;
774 dev_t tmp_dev;
775
776 if (fgetxattr(fd, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > 0) {
777 stbuf->st_uid = le32_to_cpu(tmp_uid);
778 }
779 if (fgetxattr(fd, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > 0) {
780 stbuf->st_gid = le32_to_cpu(tmp_gid);
781 }
782 if (fgetxattr(fd, "user.virtfs.mode", &tmp_mode, sizeof(mode_t)) > 0) {
783 stbuf->st_mode = le32_to_cpu(tmp_mode);
784 }
785 if (fgetxattr(fd, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > 0) {
786 stbuf->st_rdev = le64_to_cpu(tmp_dev);
787 }
788 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
789 errno = EOPNOTSUPP;
790 return -1;
791 }
792 return err;
793 }
794
795 static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
796 int flags, FsCred *credp, V9fsFidOpenState *fs)
797 {
798 int fd = -1;
799 int err = -1;
800 int dirfd;
801
802 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
803 local_is_mapped_file_metadata(fs_ctx, name)) {
804 errno = EINVAL;
805 return -1;
806 }
807
808 /*
809 * Mark all the open to not follow symlinks
810 */
811 flags |= O_NOFOLLOW;
812
813 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
814 if (dirfd == -1) {
815 return -1;
816 }
817
818 /* Determine the security model */
819 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
820 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
821 fd = openat_file(dirfd, name, flags, fs_ctx->fmode);
822 if (fd == -1) {
823 goto out;
824 }
825 credp->fc_mode = credp->fc_mode|S_IFREG;
826 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
827 /* Set cleint credentials in xattr */
828 err = local_set_xattrat(dirfd, name, credp);
829 } else {
830 err = local_set_mapped_file_attrat(dirfd, name, credp);
831 }
832 if (err == -1) {
833 goto err_end;
834 }
835 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
836 (fs_ctx->export_flags & V9FS_SM_NONE)) {
837 fd = openat_file(dirfd, name, flags, credp->fc_mode);
838 if (fd == -1) {
839 goto out;
840 }
841 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
842 if (err == -1) {
843 goto err_end;
844 }
845 }
846 err = fd;
847 fs->fd = fd;
848 goto out;
849
850 err_end:
851 unlinkat_preserve_errno(dirfd, name,
852 flags & O_DIRECTORY ? AT_REMOVEDIR : 0);
853 close_preserve_errno(fd);
854 out:
855 close_preserve_errno(dirfd);
856 return err;
857 }
858
859
860 static int local_symlink(FsContext *fs_ctx, const char *oldpath,
861 V9fsPath *dir_path, const char *name, FsCred *credp)
862 {
863 int err = -1;
864 int dirfd;
865
866 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
867 local_is_mapped_file_metadata(fs_ctx, name)) {
868 errno = EINVAL;
869 return -1;
870 }
871
872 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
873 if (dirfd == -1) {
874 return -1;
875 }
876
877 /* Determine the security model */
878 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
879 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
880 int fd;
881 ssize_t oldpath_size, write_size;
882
883 fd = openat_file(dirfd, name, O_CREAT | O_EXCL | O_RDWR,
884 fs_ctx->fmode);
885 if (fd == -1) {
886 goto out;
887 }
888 /* Write the oldpath (target) to the file. */
889 oldpath_size = strlen(oldpath);
890 do {
891 write_size = write(fd, (void *)oldpath, oldpath_size);
892 } while (write_size == -1 && errno == EINTR);
893 close_preserve_errno(fd);
894
895 if (write_size != oldpath_size) {
896 goto err_end;
897 }
898 /* Set cleint credentials in symlink's xattr */
899 credp->fc_mode = credp->fc_mode | S_IFLNK;
900
901 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
902 err = local_set_xattrat(dirfd, name, credp);
903 } else {
904 err = local_set_mapped_file_attrat(dirfd, name, credp);
905 }
906 if (err == -1) {
907 goto err_end;
908 }
909 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
910 fs_ctx->export_flags & V9FS_SM_NONE) {
911 err = symlinkat(oldpath, dirfd, name);
912 if (err) {
913 goto out;
914 }
915 err = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
916 AT_SYMLINK_NOFOLLOW);
917 if (err == -1) {
918 /*
919 * If we fail to change ownership and if we are
920 * using security model none. Ignore the error
921 */
922 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
923 goto err_end;
924 } else {
925 err = 0;
926 }
927 }
928 }
929 goto out;
930
931 err_end:
932 unlinkat_preserve_errno(dirfd, name, 0);
933 out:
934 close_preserve_errno(dirfd);
935 return err;
936 }
937
938 static int local_link(FsContext *ctx, V9fsPath *oldpath,
939 V9fsPath *dirpath, const char *name)
940 {
941 char *odirpath = g_path_get_dirname(oldpath->data);
942 char *oname = g_path_get_basename(oldpath->data);
943 int ret = -1;
944 int odirfd, ndirfd;
945
946 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
947 local_is_mapped_file_metadata(ctx, name)) {
948 errno = EINVAL;
949 return -1;
950 }
951
952 odirfd = local_opendir_nofollow(ctx, odirpath);
953 if (odirfd == -1) {
954 goto out;
955 }
956
957 ndirfd = local_opendir_nofollow(ctx, dirpath->data);
958 if (ndirfd == -1) {
959 close_preserve_errno(odirfd);
960 goto out;
961 }
962
963 ret = linkat(odirfd, oname, ndirfd, name, 0);
964 if (ret < 0) {
965 goto out_close;
966 }
967
968 /* now link the virtfs_metadata files */
969 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
970 int omap_dirfd, nmap_dirfd;
971
972 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
973 if (ret < 0 && errno != EEXIST) {
974 goto err_undo_link;
975 }
976
977 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
978 if (omap_dirfd == -1) {
979 goto err;
980 }
981
982 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
983 if (nmap_dirfd == -1) {
984 close_preserve_errno(omap_dirfd);
985 goto err;
986 }
987
988 ret = linkat(omap_dirfd, oname, nmap_dirfd, name, 0);
989 close_preserve_errno(nmap_dirfd);
990 close_preserve_errno(omap_dirfd);
991 if (ret < 0 && errno != ENOENT) {
992 goto err_undo_link;
993 }
994
995 ret = 0;
996 }
997 goto out_close;
998
999 err:
1000 ret = -1;
1001 err_undo_link:
1002 unlinkat_preserve_errno(ndirfd, name, 0);
1003 out_close:
1004 close_preserve_errno(ndirfd);
1005 close_preserve_errno(odirfd);
1006 out:
1007 g_free(oname);
1008 g_free(odirpath);
1009 return ret;
1010 }
1011
1012 static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
1013 {
1014 int fd, ret;
1015
1016 fd = local_open_nofollow(ctx, fs_path->data, O_WRONLY, 0);
1017 if (fd == -1) {
1018 return -1;
1019 }
1020 ret = ftruncate(fd, size);
1021 close_preserve_errno(fd);
1022 return ret;
1023 }
1024
1025 static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
1026 {
1027 char *dirpath = g_path_get_dirname(fs_path->data);
1028 char *name = g_path_get_basename(fs_path->data);
1029 int ret = -1;
1030 int dirfd;
1031
1032 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
1033 if (dirfd == -1) {
1034 goto out;
1035 }
1036
1037 if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
1038 (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
1039 (fs_ctx->export_flags & V9FS_SM_NONE)) {
1040 ret = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
1041 AT_SYMLINK_NOFOLLOW);
1042 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
1043 ret = local_set_xattrat(dirfd, name, credp);
1044 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1045 ret = local_set_mapped_file_attrat(dirfd, name, credp);
1046 }
1047
1048 close_preserve_errno(dirfd);
1049 out:
1050 g_free(name);
1051 g_free(dirpath);
1052 return ret;
1053 }
1054
1055 static int local_utimensat(FsContext *s, V9fsPath *fs_path,
1056 const struct timespec *buf)
1057 {
1058 char *dirpath = g_path_get_dirname(fs_path->data);
1059 char *name = g_path_get_basename(fs_path->data);
1060 int dirfd, ret = -1;
1061
1062 dirfd = local_opendir_nofollow(s, dirpath);
1063 if (dirfd == -1) {
1064 goto out;
1065 }
1066
1067 ret = utimensat(dirfd, name, buf, AT_SYMLINK_NOFOLLOW);
1068 close_preserve_errno(dirfd);
1069 out:
1070 g_free(dirpath);
1071 g_free(name);
1072 return ret;
1073 }
1074
1075 static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name,
1076 int flags)
1077 {
1078 int ret = -1;
1079
1080 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1081 int map_dirfd;
1082
1083 /* We need to remove the metadata as well:
1084 * - the metadata directory if we're removing a directory
1085 * - the metadata file in the parent's metadata directory
1086 *
1087 * If any of these are missing (ie, ENOENT) then we're probably
1088 * trying to remove something that wasn't created in mapped-file
1089 * mode. We just ignore the error.
1090 */
1091 if (flags == AT_REMOVEDIR) {
1092 int fd;
1093
1094 fd = openat_dir(dirfd, name);
1095 if (fd == -1) {
1096 goto err_out;
1097 }
1098 ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR);
1099 close_preserve_errno(fd);
1100 if (ret < 0 && errno != ENOENT) {
1101 goto err_out;
1102 }
1103 }
1104 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
1105 if (map_dirfd != -1) {
1106 ret = unlinkat(map_dirfd, name, 0);
1107 close_preserve_errno(map_dirfd);
1108 if (ret < 0 && errno != ENOENT) {
1109 goto err_out;
1110 }
1111 } else if (errno != ENOENT) {
1112 goto err_out;
1113 }
1114 }
1115
1116 ret = unlinkat(dirfd, name, flags);
1117 err_out:
1118 return ret;
1119 }
1120
1121 static int local_remove(FsContext *ctx, const char *path)
1122 {
1123 struct stat stbuf;
1124 char *dirpath = g_path_get_dirname(path);
1125 char *name = g_path_get_basename(path);
1126 int flags = 0;
1127 int dirfd;
1128 int err = -1;
1129
1130 dirfd = local_opendir_nofollow(ctx, dirpath);
1131 if (dirfd == -1) {
1132 goto out;
1133 }
1134
1135 if (fstatat(dirfd, name, &stbuf, AT_SYMLINK_NOFOLLOW) < 0) {
1136 goto err_out;
1137 }
1138
1139 if (S_ISDIR(stbuf.st_mode)) {
1140 flags |= AT_REMOVEDIR;
1141 }
1142
1143 err = local_unlinkat_common(ctx, dirfd, name, flags);
1144 err_out:
1145 close_preserve_errno(dirfd);
1146 out:
1147 g_free(name);
1148 g_free(dirpath);
1149 return err;
1150 }
1151
1152 static int local_fsync(FsContext *ctx, int fid_type,
1153 V9fsFidOpenState *fs, int datasync)
1154 {
1155 int fd;
1156
1157 if (fid_type == P9_FID_DIR) {
1158 fd = dirfd(fs->dir.stream);
1159 } else {
1160 fd = fs->fd;
1161 }
1162
1163 if (datasync) {
1164 return qemu_fdatasync(fd);
1165 } else {
1166 return fsync(fd);
1167 }
1168 }
1169
1170 static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
1171 {
1172 int fd, ret;
1173
1174 fd = local_open_nofollow(s, fs_path->data, O_RDONLY, 0);
1175 if (fd == -1) {
1176 return -1;
1177 }
1178 ret = fstatfs(fd, stbuf);
1179 close_preserve_errno(fd);
1180 return ret;
1181 }
1182
1183 static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
1184 const char *name, void *value, size_t size)
1185 {
1186 char *path = fs_path->data;
1187
1188 return v9fs_get_xattr(ctx, path, name, value, size);
1189 }
1190
1191 static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path,
1192 void *value, size_t size)
1193 {
1194 char *path = fs_path->data;
1195
1196 return v9fs_list_xattr(ctx, path, value, size);
1197 }
1198
1199 static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
1200 void *value, size_t size, int flags)
1201 {
1202 char *path = fs_path->data;
1203
1204 return v9fs_set_xattr(ctx, path, name, value, size, flags);
1205 }
1206
1207 static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1208 const char *name)
1209 {
1210 char *path = fs_path->data;
1211
1212 return v9fs_remove_xattr(ctx, path, name);
1213 }
1214
1215 static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1216 const char *name, V9fsPath *target)
1217 {
1218 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
1219 local_is_mapped_file_metadata(ctx, name)) {
1220 errno = EINVAL;
1221 return -1;
1222 }
1223
1224 if (dir_path) {
1225 if (!strcmp(name, ".")) {
1226 /* "." relative to "foo/bar" is "foo/bar" */
1227 v9fs_path_copy(target, dir_path);
1228 } else if (!strcmp(name, "..")) {
1229 if (!strcmp(dir_path->data, ".")) {
1230 /* ".." relative to the root is "." */
1231 v9fs_path_sprintf(target, ".");
1232 } else {
1233 char *tmp = g_path_get_dirname(dir_path->data);
1234 /* Symbolic links are resolved by the client. We can assume
1235 * that ".." relative to "foo/bar" is equivalent to "foo"
1236 */
1237 v9fs_path_sprintf(target, "%s", tmp);
1238 g_free(tmp);
1239 }
1240 } else {
1241 assert(!strchr(name, '/'));
1242 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name);
1243 }
1244 } else if (!strcmp(name, "/") || !strcmp(name, ".") ||
1245 !strcmp(name, "..")) {
1246 /* This is the root fid */
1247 v9fs_path_sprintf(target, ".");
1248 } else {
1249 assert(!strchr(name, '/'));
1250 v9fs_path_sprintf(target, "./%s", name);
1251 }
1252 return 0;
1253 }
1254
1255 static int local_renameat(FsContext *ctx, V9fsPath *olddir,
1256 const char *old_name, V9fsPath *newdir,
1257 const char *new_name)
1258 {
1259 int ret;
1260 int odirfd, ndirfd;
1261
1262 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
1263 (local_is_mapped_file_metadata(ctx, old_name) ||
1264 local_is_mapped_file_metadata(ctx, new_name))) {
1265 errno = EINVAL;
1266 return -1;
1267 }
1268
1269 odirfd = local_opendir_nofollow(ctx, olddir->data);
1270 if (odirfd == -1) {
1271 return -1;
1272 }
1273
1274 ndirfd = local_opendir_nofollow(ctx, newdir->data);
1275 if (ndirfd == -1) {
1276 close_preserve_errno(odirfd);
1277 return -1;
1278 }
1279
1280 ret = renameat(odirfd, old_name, ndirfd, new_name);
1281 if (ret < 0) {
1282 goto out;
1283 }
1284
1285 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1286 int omap_dirfd, nmap_dirfd;
1287
1288 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
1289 if (ret < 0 && errno != EEXIST) {
1290 goto err_undo_rename;
1291 }
1292
1293 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
1294 if (omap_dirfd == -1) {
1295 goto err;
1296 }
1297
1298 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
1299 if (nmap_dirfd == -1) {
1300 close_preserve_errno(omap_dirfd);
1301 goto err;
1302 }
1303
1304 /* rename the .virtfs_metadata files */
1305 ret = renameat(omap_dirfd, old_name, nmap_dirfd, new_name);
1306 close_preserve_errno(nmap_dirfd);
1307 close_preserve_errno(omap_dirfd);
1308 if (ret < 0 && errno != ENOENT) {
1309 goto err_undo_rename;
1310 }
1311
1312 ret = 0;
1313 }
1314 goto out;
1315
1316 err:
1317 ret = -1;
1318 err_undo_rename:
1319 renameat_preserve_errno(ndirfd, new_name, odirfd, old_name);
1320 out:
1321 close_preserve_errno(ndirfd);
1322 close_preserve_errno(odirfd);
1323 return ret;
1324 }
1325
1326 static void v9fs_path_init_dirname(V9fsPath *path, const char *str)
1327 {
1328 path->data = g_path_get_dirname(str);
1329 path->size = strlen(path->data) + 1;
1330 }
1331
1332 static int local_rename(FsContext *ctx, const char *oldpath,
1333 const char *newpath)
1334 {
1335 int err;
1336 char *oname = g_path_get_basename(oldpath);
1337 char *nname = g_path_get_basename(newpath);
1338 V9fsPath olddir, newdir;
1339
1340 v9fs_path_init_dirname(&olddir, oldpath);
1341 v9fs_path_init_dirname(&newdir, newpath);
1342
1343 err = local_renameat(ctx, &olddir, oname, &newdir, nname);
1344
1345 v9fs_path_free(&newdir);
1346 v9fs_path_free(&olddir);
1347 g_free(nname);
1348 g_free(oname);
1349
1350 return err;
1351 }
1352
1353 static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
1354 const char *name, int flags)
1355 {
1356 int ret;
1357 int dirfd;
1358
1359 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
1360 local_is_mapped_file_metadata(ctx, name)) {
1361 errno = EINVAL;
1362 return -1;
1363 }
1364
1365 dirfd = local_opendir_nofollow(ctx, dir->data);
1366 if (dirfd == -1) {
1367 return -1;
1368 }
1369
1370 ret = local_unlinkat_common(ctx, dirfd, name, flags);
1371 close_preserve_errno(dirfd);
1372 return ret;
1373 }
1374
1375 static int local_ioc_getversion(FsContext *ctx, V9fsPath *path,
1376 mode_t st_mode, uint64_t *st_gen)
1377 {
1378 #ifdef FS_IOC_GETVERSION
1379 int err;
1380 V9fsFidOpenState fid_open;
1381
1382 /*
1383 * Do not try to open special files like device nodes, fifos etc
1384 * We can get fd for regular files and directories only
1385 */
1386 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1387 errno = ENOTTY;
1388 return -1;
1389 }
1390 err = local_open(ctx, path, O_RDONLY, &fid_open);
1391 if (err < 0) {
1392 return err;
1393 }
1394 err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
1395 local_close(ctx, &fid_open);
1396 return err;
1397 #else
1398 errno = ENOTTY;
1399 return -1;
1400 #endif
1401 }
1402
1403 static int local_init(FsContext *ctx)
1404 {
1405 struct statfs stbuf;
1406 LocalData *data = g_malloc(sizeof(*data));
1407
1408 data->mountfd = open(ctx->fs_root, O_DIRECTORY | O_RDONLY);
1409 if (data->mountfd == -1) {
1410 goto err;
1411 }
1412
1413 #ifdef FS_IOC_GETVERSION
1414 /*
1415 * use ioc_getversion only if the ioctl is definied
1416 */
1417 if (fstatfs(data->mountfd, &stbuf) < 0) {
1418 close_preserve_errno(data->mountfd);
1419 goto err;
1420 }
1421 switch (stbuf.f_type) {
1422 case EXT2_SUPER_MAGIC:
1423 case BTRFS_SUPER_MAGIC:
1424 case REISERFS_SUPER_MAGIC:
1425 case XFS_SUPER_MAGIC:
1426 ctx->exops.get_st_gen = local_ioc_getversion;
1427 break;
1428 }
1429 #endif
1430
1431 if (ctx->export_flags & V9FS_SM_PASSTHROUGH) {
1432 ctx->xops = passthrough_xattr_ops;
1433 } else if (ctx->export_flags & V9FS_SM_MAPPED) {
1434 ctx->xops = mapped_xattr_ops;
1435 } else if (ctx->export_flags & V9FS_SM_NONE) {
1436 ctx->xops = none_xattr_ops;
1437 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1438 /*
1439 * xattr operation for mapped-file and passthrough
1440 * remain same.
1441 */
1442 ctx->xops = passthrough_xattr_ops;
1443 }
1444 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1445
1446 ctx->private = data;
1447 return 0;
1448
1449 err:
1450 g_free(data);
1451 return -1;
1452 }
1453
1454 static void local_cleanup(FsContext *ctx)
1455 {
1456 LocalData *data = ctx->private;
1457
1458 close(data->mountfd);
1459 g_free(data);
1460 }
1461
1462 static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
1463 {
1464 const char *sec_model = qemu_opt_get(opts, "security_model");
1465 const char *path = qemu_opt_get(opts, "path");
1466 Error *err = NULL;
1467
1468 if (!sec_model) {
1469 error_report("Security model not specified, local fs needs security model");
1470 error_printf("valid options are:"
1471 "\tsecurity_model=[passthrough|mapped-xattr|mapped-file|none]\n");
1472 return -1;
1473 }
1474
1475 if (!strcmp(sec_model, "passthrough")) {
1476 fse->export_flags |= V9FS_SM_PASSTHROUGH;
1477 } else if (!strcmp(sec_model, "mapped") ||
1478 !strcmp(sec_model, "mapped-xattr")) {
1479 fse->export_flags |= V9FS_SM_MAPPED;
1480 } else if (!strcmp(sec_model, "none")) {
1481 fse->export_flags |= V9FS_SM_NONE;
1482 } else if (!strcmp(sec_model, "mapped-file")) {
1483 fse->export_flags |= V9FS_SM_MAPPED_FILE;
1484 } else {
1485 error_report("Invalid security model %s specified", sec_model);
1486 error_printf("valid options are:"
1487 "\t[passthrough|mapped-xattr|mapped-file|none]\n");
1488 return -1;
1489 }
1490
1491 if (!path) {
1492 error_report("fsdev: No path specified");
1493 return -1;
1494 }
1495
1496 fsdev_throttle_parse_opts(opts, &fse->fst, &err);
1497 if (err) {
1498 error_reportf_err(err, "Throttle configuration is not valid: ");
1499 return -1;
1500 }
1501
1502 if (fse->export_flags & V9FS_SM_MAPPED ||
1503 fse->export_flags & V9FS_SM_MAPPED_FILE) {
1504 fse->fmode =
1505 qemu_opt_get_number(opts, "fmode", SM_LOCAL_MODE_BITS) & 0777;
1506 fse->dmode =
1507 qemu_opt_get_number(opts, "dmode", SM_LOCAL_DIR_MODE_BITS) & 0777;
1508 } else {
1509 if (qemu_opt_find(opts, "fmode")) {
1510 error_report("fmode is only valid for mapped 9p modes");
1511 return -1;
1512 }
1513 if (qemu_opt_find(opts, "dmode")) {
1514 error_report("dmode is only valid for mapped 9p modes");
1515 return -1;
1516 }
1517 }
1518
1519 fse->path = g_strdup(path);
1520
1521 return 0;
1522 }
1523
1524 FileOperations local_ops = {
1525 .parse_opts = local_parse_opts,
1526 .init = local_init,
1527 .cleanup = local_cleanup,
1528 .lstat = local_lstat,
1529 .readlink = local_readlink,
1530 .close = local_close,
1531 .closedir = local_closedir,
1532 .open = local_open,
1533 .opendir = local_opendir,
1534 .rewinddir = local_rewinddir,
1535 .telldir = local_telldir,
1536 .readdir = local_readdir,
1537 .seekdir = local_seekdir,
1538 .preadv = local_preadv,
1539 .pwritev = local_pwritev,
1540 .chmod = local_chmod,
1541 .mknod = local_mknod,
1542 .mkdir = local_mkdir,
1543 .fstat = local_fstat,
1544 .open2 = local_open2,
1545 .symlink = local_symlink,
1546 .link = local_link,
1547 .truncate = local_truncate,
1548 .rename = local_rename,
1549 .chown = local_chown,
1550 .utimensat = local_utimensat,
1551 .remove = local_remove,
1552 .fsync = local_fsync,
1553 .statfs = local_statfs,
1554 .lgetxattr = local_lgetxattr,
1555 .llistxattr = local_llistxattr,
1556 .lsetxattr = local_lsetxattr,
1557 .lremovexattr = local_lremovexattr,
1558 .name_to_path = local_name_to_path,
1559 .renameat = local_renameat,
1560 .unlinkat = local_unlinkat,
1561 };