qapi/error: Check format string argument in error_*prepend()
[qemu/armbru.git] / hw / 9pfs / 9p-local.c
blob3107637209bbb2eeb81aa6274a23e60a8e27c5a6
1 /*
2 * 9p Posix callback
4 * Copyright IBM, Corp. 2010
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "9p.h"
15 #include "9p-local.h"
16 #include "9p-xattr.h"
17 #include "9p-util.h"
18 #include "fsdev/qemu-fsdev.h" /* local_ops */
19 #include <arpa/inet.h>
20 #include <pwd.h>
21 #include <grp.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 #include "qemu/xattr.h"
25 #include "qapi/error.h"
26 #include "qemu/cutils.h"
27 #include "qemu/error-report.h"
28 #include "qemu/option.h"
29 #include <libgen.h>
30 #include <linux/fs.h>
31 #ifdef CONFIG_LINUX_MAGIC_H
32 #include <linux/magic.h>
33 #endif
34 #include <sys/ioctl.h>
36 #ifndef XFS_SUPER_MAGIC
37 #define XFS_SUPER_MAGIC 0x58465342
38 #endif
39 #ifndef EXT2_SUPER_MAGIC
40 #define EXT2_SUPER_MAGIC 0xEF53
41 #endif
42 #ifndef REISERFS_SUPER_MAGIC
43 #define REISERFS_SUPER_MAGIC 0x52654973
44 #endif
45 #ifndef BTRFS_SUPER_MAGIC
46 #define BTRFS_SUPER_MAGIC 0x9123683E
47 #endif
49 typedef struct {
50 int mountfd;
51 } LocalData;
53 int local_open_nofollow(FsContext *fs_ctx, const char *path, int flags,
54 mode_t mode)
56 LocalData *data = fs_ctx->private;
57 int fd = data->mountfd;
59 while (*path && fd != -1) {
60 const char *c;
61 int next_fd;
62 char *head;
64 /* Only relative paths without consecutive slashes */
65 assert(*path != '/');
67 head = g_strdup(path);
68 c = qemu_strchrnul(path, '/');
69 if (*c) {
70 /* Intermediate path element */
71 head[c - path] = 0;
72 path = c + 1;
73 next_fd = openat_dir(fd, head);
74 } else {
75 /* Rightmost path element */
76 next_fd = openat_file(fd, head, flags, mode);
77 path = c;
79 g_free(head);
80 if (fd != data->mountfd) {
81 close_preserve_errno(fd);
83 fd = next_fd;
86 assert(fd != data->mountfd);
87 return fd;
90 int local_opendir_nofollow(FsContext *fs_ctx, const char *path)
92 return local_open_nofollow(fs_ctx, path, O_DIRECTORY | O_RDONLY, 0);
95 static void renameat_preserve_errno(int odirfd, const char *opath, int ndirfd,
96 const char *npath)
98 int serrno = errno;
99 renameat(odirfd, opath, ndirfd, npath);
100 errno = serrno;
103 static void unlinkat_preserve_errno(int dirfd, const char *path, int flags)
105 int serrno = errno;
106 unlinkat(dirfd, path, flags);
107 errno = serrno;
110 #define VIRTFS_META_DIR ".virtfs_metadata"
111 #define VIRTFS_META_ROOT_FILE VIRTFS_META_DIR "_root"
113 static FILE *local_fopenat(int dirfd, const char *name, const char *mode)
115 int fd, o_mode = 0;
116 FILE *fp;
117 int flags;
119 * only supports two modes
121 if (mode[0] == 'r') {
122 flags = O_RDONLY;
123 } else if (mode[0] == 'w') {
124 flags = O_WRONLY | O_TRUNC | O_CREAT;
125 o_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
126 } else {
127 return NULL;
129 fd = openat_file(dirfd, name, flags, o_mode);
130 if (fd == -1) {
131 return NULL;
133 fp = fdopen(fd, mode);
134 if (!fp) {
135 close(fd);
137 return fp;
140 #define ATTR_MAX 100
141 static void local_mapped_file_attr(int dirfd, const char *name,
142 struct stat *stbuf)
144 FILE *fp;
145 char buf[ATTR_MAX];
146 int map_dirfd;
148 if (strcmp(name, ".")) {
149 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
150 if (map_dirfd == -1) {
151 return;
154 fp = local_fopenat(map_dirfd, name, "r");
155 close_preserve_errno(map_dirfd);
156 } else {
157 fp = local_fopenat(dirfd, VIRTFS_META_ROOT_FILE, "r");
159 if (!fp) {
160 return;
162 memset(buf, 0, ATTR_MAX);
163 while (fgets(buf, ATTR_MAX, fp)) {
164 if (!strncmp(buf, "virtfs.uid", 10)) {
165 stbuf->st_uid = atoi(buf+11);
166 } else if (!strncmp(buf, "virtfs.gid", 10)) {
167 stbuf->st_gid = atoi(buf+11);
168 } else if (!strncmp(buf, "virtfs.mode", 11)) {
169 stbuf->st_mode = atoi(buf+12);
170 } else if (!strncmp(buf, "virtfs.rdev", 11)) {
171 stbuf->st_rdev = atoi(buf+12);
173 memset(buf, 0, ATTR_MAX);
175 fclose(fp);
178 static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
180 int err = -1;
181 char *dirpath = g_path_get_dirname(fs_path->data);
182 char *name = g_path_get_basename(fs_path->data);
183 int dirfd;
185 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
186 if (dirfd == -1) {
187 goto out;
190 err = fstatat(dirfd, name, stbuf, AT_SYMLINK_NOFOLLOW);
191 if (err) {
192 goto err_out;
194 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
195 /* Actual credentials are part of extended attrs */
196 uid_t tmp_uid;
197 gid_t tmp_gid;
198 mode_t tmp_mode;
199 dev_t tmp_dev;
201 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.uid", &tmp_uid,
202 sizeof(uid_t)) > 0) {
203 stbuf->st_uid = le32_to_cpu(tmp_uid);
205 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.gid", &tmp_gid,
206 sizeof(gid_t)) > 0) {
207 stbuf->st_gid = le32_to_cpu(tmp_gid);
209 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.mode", &tmp_mode,
210 sizeof(mode_t)) > 0) {
211 stbuf->st_mode = le32_to_cpu(tmp_mode);
213 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.rdev", &tmp_dev,
214 sizeof(dev_t)) > 0) {
215 stbuf->st_rdev = le64_to_cpu(tmp_dev);
217 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
218 local_mapped_file_attr(dirfd, name, stbuf);
221 err_out:
222 close_preserve_errno(dirfd);
223 out:
224 g_free(name);
225 g_free(dirpath);
226 return err;
229 static int local_set_mapped_file_attrat(int dirfd, const char *name,
230 FsCred *credp)
232 FILE *fp;
233 int ret;
234 char buf[ATTR_MAX];
235 int uid = -1, gid = -1, mode = -1, rdev = -1;
236 int map_dirfd = -1, map_fd;
237 bool is_root = !strcmp(name, ".");
239 if (is_root) {
240 fp = local_fopenat(dirfd, VIRTFS_META_ROOT_FILE, "r");
241 if (!fp) {
242 if (errno == ENOENT) {
243 goto update_map_file;
244 } else {
245 return -1;
248 } else {
249 ret = mkdirat(dirfd, VIRTFS_META_DIR, 0700);
250 if (ret < 0 && errno != EEXIST) {
251 return -1;
254 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
255 if (map_dirfd == -1) {
256 return -1;
259 fp = local_fopenat(map_dirfd, name, "r");
260 if (!fp) {
261 if (errno == ENOENT) {
262 goto update_map_file;
263 } else {
264 close_preserve_errno(map_dirfd);
265 return -1;
269 memset(buf, 0, ATTR_MAX);
270 while (fgets(buf, ATTR_MAX, fp)) {
271 if (!strncmp(buf, "virtfs.uid", 10)) {
272 uid = atoi(buf + 11);
273 } else if (!strncmp(buf, "virtfs.gid", 10)) {
274 gid = atoi(buf + 11);
275 } else if (!strncmp(buf, "virtfs.mode", 11)) {
276 mode = atoi(buf + 12);
277 } else if (!strncmp(buf, "virtfs.rdev", 11)) {
278 rdev = atoi(buf + 12);
280 memset(buf, 0, ATTR_MAX);
282 fclose(fp);
284 update_map_file:
285 if (is_root) {
286 fp = local_fopenat(dirfd, VIRTFS_META_ROOT_FILE, "w");
287 } else {
288 fp = local_fopenat(map_dirfd, name, "w");
289 /* We can't go this far with map_dirfd not being a valid file descriptor
290 * but some versions of gcc aren't smart enough to see it.
292 if (map_dirfd != -1) {
293 close_preserve_errno(map_dirfd);
296 if (!fp) {
297 return -1;
300 map_fd = fileno(fp);
301 assert(map_fd != -1);
302 ret = fchmod(map_fd, 0600);
303 assert(ret == 0);
305 if (credp->fc_uid != -1) {
306 uid = credp->fc_uid;
308 if (credp->fc_gid != -1) {
309 gid = credp->fc_gid;
311 if (credp->fc_mode != (mode_t)-1) {
312 mode = credp->fc_mode;
314 if (credp->fc_rdev != -1) {
315 rdev = credp->fc_rdev;
318 if (uid != -1) {
319 fprintf(fp, "virtfs.uid=%d\n", uid);
321 if (gid != -1) {
322 fprintf(fp, "virtfs.gid=%d\n", gid);
324 if (mode != -1) {
325 fprintf(fp, "virtfs.mode=%d\n", mode);
327 if (rdev != -1) {
328 fprintf(fp, "virtfs.rdev=%d\n", rdev);
330 fclose(fp);
332 return 0;
335 static int fchmodat_nofollow(int dirfd, const char *name, mode_t mode)
337 struct stat stbuf;
338 int fd, ret;
340 /* FIXME: this should be handled with fchmodat(AT_SYMLINK_NOFOLLOW).
341 * Unfortunately, the linux kernel doesn't implement it yet.
344 /* First, we clear non-racing symlinks out of the way. */
345 if (fstatat(dirfd, name, &stbuf, AT_SYMLINK_NOFOLLOW)) {
346 return -1;
348 if (S_ISLNK(stbuf.st_mode)) {
349 errno = ELOOP;
350 return -1;
353 fd = openat_file(dirfd, name, O_RDONLY | O_PATH_9P_UTIL | O_NOFOLLOW, 0);
354 #if O_PATH_9P_UTIL == 0
355 /* Fallback for systems that don't support O_PATH: we depend on the file
356 * being readable or writable.
358 if (fd == -1) {
359 /* In case the file is writable-only and isn't a directory. */
360 if (errno == EACCES) {
361 fd = openat_file(dirfd, name, O_WRONLY, 0);
363 if (fd == -1 && errno == EISDIR) {
364 errno = EACCES;
367 if (fd == -1) {
368 return -1;
370 ret = fchmod(fd, mode);
371 #else
372 /* Access modes are ignored when O_PATH is supported. If name is a symbolic
373 * link, O_PATH | O_NOFOLLOW causes openat(2) to return a file descriptor
374 * referring to the symbolic link.
376 if (fd == -1) {
377 return -1;
380 /* Now we handle racing symlinks. */
381 ret = fstat(fd, &stbuf);
382 if (!ret) {
383 if (S_ISLNK(stbuf.st_mode)) {
384 errno = ELOOP;
385 ret = -1;
386 } else {
387 char *proc_path = g_strdup_printf("/proc/self/fd/%d", fd);
388 ret = chmod(proc_path, mode);
389 g_free(proc_path);
392 #endif
393 close_preserve_errno(fd);
394 return ret;
397 static int local_set_xattrat(int dirfd, const char *path, FsCred *credp)
399 int err;
401 if (credp->fc_uid != -1) {
402 uint32_t tmp_uid = cpu_to_le32(credp->fc_uid);
403 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.uid", &tmp_uid,
404 sizeof(uid_t), 0);
405 if (err) {
406 return err;
409 if (credp->fc_gid != -1) {
410 uint32_t tmp_gid = cpu_to_le32(credp->fc_gid);
411 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.gid", &tmp_gid,
412 sizeof(gid_t), 0);
413 if (err) {
414 return err;
417 if (credp->fc_mode != (mode_t)-1) {
418 uint32_t tmp_mode = cpu_to_le32(credp->fc_mode);
419 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.mode", &tmp_mode,
420 sizeof(mode_t), 0);
421 if (err) {
422 return err;
425 if (credp->fc_rdev != -1) {
426 uint64_t tmp_rdev = cpu_to_le64(credp->fc_rdev);
427 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.rdev", &tmp_rdev,
428 sizeof(dev_t), 0);
429 if (err) {
430 return err;
433 return 0;
436 static int local_set_cred_passthrough(FsContext *fs_ctx, int dirfd,
437 const char *name, FsCred *credp)
439 if (fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
440 AT_SYMLINK_NOFOLLOW) < 0) {
442 * If we fail to change ownership and if we are
443 * using security model none. Ignore the error
445 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
446 return -1;
450 return fchmodat_nofollow(dirfd, name, credp->fc_mode & 07777);
453 static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
454 char *buf, size_t bufsz)
456 ssize_t tsize = -1;
458 if ((fs_ctx->export_flags & V9FS_SM_MAPPED) ||
459 (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE)) {
460 int fd;
462 fd = local_open_nofollow(fs_ctx, fs_path->data, O_RDONLY, 0);
463 if (fd == -1) {
464 return -1;
466 do {
467 tsize = read(fd, (void *)buf, bufsz);
468 } while (tsize == -1 && errno == EINTR);
469 close_preserve_errno(fd);
470 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
471 (fs_ctx->export_flags & V9FS_SM_NONE)) {
472 char *dirpath = g_path_get_dirname(fs_path->data);
473 char *name = g_path_get_basename(fs_path->data);
474 int dirfd;
476 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
477 if (dirfd == -1) {
478 goto out;
481 tsize = readlinkat(dirfd, name, buf, bufsz);
482 close_preserve_errno(dirfd);
483 out:
484 g_free(name);
485 g_free(dirpath);
487 return tsize;
490 static int local_close(FsContext *ctx, V9fsFidOpenState *fs)
492 return close(fs->fd);
495 static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs)
497 return closedir(fs->dir.stream);
500 static int local_open(FsContext *ctx, V9fsPath *fs_path,
501 int flags, V9fsFidOpenState *fs)
503 int fd;
505 fd = local_open_nofollow(ctx, fs_path->data, flags, 0);
506 if (fd == -1) {
507 return -1;
509 fs->fd = fd;
510 return fs->fd;
513 static int local_opendir(FsContext *ctx,
514 V9fsPath *fs_path, V9fsFidOpenState *fs)
516 int dirfd;
517 DIR *stream;
519 dirfd = local_opendir_nofollow(ctx, fs_path->data);
520 if (dirfd == -1) {
521 return -1;
524 stream = fdopendir(dirfd);
525 if (!stream) {
526 close(dirfd);
527 return -1;
529 fs->dir.stream = stream;
530 return 0;
533 static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
535 rewinddir(fs->dir.stream);
538 static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs)
540 return telldir(fs->dir.stream);
543 static bool local_is_mapped_file_metadata(FsContext *fs_ctx, const char *name)
545 return
546 !strcmp(name, VIRTFS_META_DIR) || !strcmp(name, VIRTFS_META_ROOT_FILE);
549 static struct dirent *local_readdir(FsContext *ctx, V9fsFidOpenState *fs)
551 struct dirent *entry;
553 again:
554 entry = readdir(fs->dir.stream);
555 if (!entry) {
556 return NULL;
559 if (ctx->export_flags & V9FS_SM_MAPPED) {
560 entry->d_type = DT_UNKNOWN;
561 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
562 if (local_is_mapped_file_metadata(ctx, entry->d_name)) {
563 /* skip the meta data */
564 goto again;
566 entry->d_type = DT_UNKNOWN;
569 return entry;
572 static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
574 seekdir(fs->dir.stream, off);
577 static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs,
578 const struct iovec *iov,
579 int iovcnt, off_t offset)
581 #ifdef CONFIG_PREADV
582 return preadv(fs->fd, iov, iovcnt, offset);
583 #else
584 int err = lseek(fs->fd, offset, SEEK_SET);
585 if (err == -1) {
586 return err;
587 } else {
588 return readv(fs->fd, iov, iovcnt);
590 #endif
593 static ssize_t local_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
594 const struct iovec *iov,
595 int iovcnt, off_t offset)
597 ssize_t ret;
598 #ifdef CONFIG_PREADV
599 ret = pwritev(fs->fd, iov, iovcnt, offset);
600 #else
601 int err = lseek(fs->fd, offset, SEEK_SET);
602 if (err == -1) {
603 return err;
604 } else {
605 ret = writev(fs->fd, iov, iovcnt);
607 #endif
608 #ifdef CONFIG_SYNC_FILE_RANGE
609 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
611 * Initiate a writeback. This is not a data integrity sync.
612 * We want to ensure that we don't leave dirty pages in the cache
613 * after write when writeout=immediate is sepcified.
615 sync_file_range(fs->fd, offset, ret,
616 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
618 #endif
619 return ret;
622 static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
624 char *dirpath = g_path_get_dirname(fs_path->data);
625 char *name = g_path_get_basename(fs_path->data);
626 int ret = -1;
627 int dirfd;
629 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
630 if (dirfd == -1) {
631 goto out;
634 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
635 ret = local_set_xattrat(dirfd, name, credp);
636 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
637 ret = local_set_mapped_file_attrat(dirfd, name, credp);
638 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
639 fs_ctx->export_flags & V9FS_SM_NONE) {
640 ret = fchmodat_nofollow(dirfd, name, credp->fc_mode);
642 close_preserve_errno(dirfd);
644 out:
645 g_free(dirpath);
646 g_free(name);
647 return ret;
650 static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
651 const char *name, FsCred *credp)
653 int err = -1;
654 int dirfd;
656 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
657 local_is_mapped_file_metadata(fs_ctx, name)) {
658 errno = EINVAL;
659 return -1;
662 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
663 if (dirfd == -1) {
664 return -1;
667 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
668 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
669 err = mknodat(dirfd, name, fs_ctx->fmode | S_IFREG, 0);
670 if (err == -1) {
671 goto out;
674 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
675 err = local_set_xattrat(dirfd, name, credp);
676 } else {
677 err = local_set_mapped_file_attrat(dirfd, name, credp);
679 if (err == -1) {
680 goto err_end;
682 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
683 fs_ctx->export_flags & V9FS_SM_NONE) {
684 err = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
685 if (err == -1) {
686 goto out;
688 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
689 if (err == -1) {
690 goto err_end;
693 goto out;
695 err_end:
696 unlinkat_preserve_errno(dirfd, name, 0);
697 out:
698 close_preserve_errno(dirfd);
699 return err;
702 static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
703 const char *name, FsCred *credp)
705 int err = -1;
706 int dirfd;
708 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
709 local_is_mapped_file_metadata(fs_ctx, name)) {
710 errno = EINVAL;
711 return -1;
714 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
715 if (dirfd == -1) {
716 return -1;
719 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
720 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
721 err = mkdirat(dirfd, name, fs_ctx->dmode);
722 if (err == -1) {
723 goto out;
725 credp->fc_mode = credp->fc_mode | S_IFDIR;
727 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
728 err = local_set_xattrat(dirfd, name, credp);
729 } else {
730 err = local_set_mapped_file_attrat(dirfd, name, credp);
732 if (err == -1) {
733 goto err_end;
735 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
736 fs_ctx->export_flags & V9FS_SM_NONE) {
737 err = mkdirat(dirfd, name, credp->fc_mode);
738 if (err == -1) {
739 goto out;
741 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
742 if (err == -1) {
743 goto err_end;
746 goto out;
748 err_end:
749 unlinkat_preserve_errno(dirfd, name, AT_REMOVEDIR);
750 out:
751 close_preserve_errno(dirfd);
752 return err;
755 static int local_fstat(FsContext *fs_ctx, int fid_type,
756 V9fsFidOpenState *fs, struct stat *stbuf)
758 int err, fd;
760 if (fid_type == P9_FID_DIR) {
761 fd = dirfd(fs->dir.stream);
762 } else {
763 fd = fs->fd;
766 err = fstat(fd, stbuf);
767 if (err) {
768 return err;
770 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
771 /* Actual credentials are part of extended attrs */
772 uid_t tmp_uid;
773 gid_t tmp_gid;
774 mode_t tmp_mode;
775 dev_t tmp_dev;
777 if (fgetxattr(fd, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > 0) {
778 stbuf->st_uid = le32_to_cpu(tmp_uid);
780 if (fgetxattr(fd, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > 0) {
781 stbuf->st_gid = le32_to_cpu(tmp_gid);
783 if (fgetxattr(fd, "user.virtfs.mode", &tmp_mode, sizeof(mode_t)) > 0) {
784 stbuf->st_mode = le32_to_cpu(tmp_mode);
786 if (fgetxattr(fd, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > 0) {
787 stbuf->st_rdev = le64_to_cpu(tmp_dev);
789 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
790 errno = EOPNOTSUPP;
791 return -1;
793 return err;
796 static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
797 int flags, FsCred *credp, V9fsFidOpenState *fs)
799 int fd = -1;
800 int err = -1;
801 int dirfd;
803 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
804 local_is_mapped_file_metadata(fs_ctx, name)) {
805 errno = EINVAL;
806 return -1;
810 * Mark all the open to not follow symlinks
812 flags |= O_NOFOLLOW;
814 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
815 if (dirfd == -1) {
816 return -1;
819 /* Determine the security model */
820 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
821 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
822 fd = openat_file(dirfd, name, flags, fs_ctx->fmode);
823 if (fd == -1) {
824 goto out;
826 credp->fc_mode = credp->fc_mode|S_IFREG;
827 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
828 /* Set cleint credentials in xattr */
829 err = local_set_xattrat(dirfd, name, credp);
830 } else {
831 err = local_set_mapped_file_attrat(dirfd, name, credp);
833 if (err == -1) {
834 goto err_end;
836 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
837 (fs_ctx->export_flags & V9FS_SM_NONE)) {
838 fd = openat_file(dirfd, name, flags, credp->fc_mode);
839 if (fd == -1) {
840 goto out;
842 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
843 if (err == -1) {
844 goto err_end;
847 err = fd;
848 fs->fd = fd;
849 goto out;
851 err_end:
852 unlinkat_preserve_errno(dirfd, name,
853 flags & O_DIRECTORY ? AT_REMOVEDIR : 0);
854 close_preserve_errno(fd);
855 out:
856 close_preserve_errno(dirfd);
857 return err;
861 static int local_symlink(FsContext *fs_ctx, const char *oldpath,
862 V9fsPath *dir_path, const char *name, FsCred *credp)
864 int err = -1;
865 int dirfd;
867 if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE &&
868 local_is_mapped_file_metadata(fs_ctx, name)) {
869 errno = EINVAL;
870 return -1;
873 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
874 if (dirfd == -1) {
875 return -1;
878 /* Determine the security model */
879 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
880 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
881 int fd;
882 ssize_t oldpath_size, write_size;
884 fd = openat_file(dirfd, name, O_CREAT | O_EXCL | O_RDWR,
885 fs_ctx->fmode);
886 if (fd == -1) {
887 goto out;
889 /* Write the oldpath (target) to the file. */
890 oldpath_size = strlen(oldpath);
891 do {
892 write_size = write(fd, (void *)oldpath, oldpath_size);
893 } while (write_size == -1 && errno == EINTR);
894 close_preserve_errno(fd);
896 if (write_size != oldpath_size) {
897 goto err_end;
899 /* Set cleint credentials in symlink's xattr */
900 credp->fc_mode = credp->fc_mode | S_IFLNK;
902 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
903 err = local_set_xattrat(dirfd, name, credp);
904 } else {
905 err = local_set_mapped_file_attrat(dirfd, name, credp);
907 if (err == -1) {
908 goto err_end;
910 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
911 fs_ctx->export_flags & V9FS_SM_NONE) {
912 err = symlinkat(oldpath, dirfd, name);
913 if (err) {
914 goto out;
916 err = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
917 AT_SYMLINK_NOFOLLOW);
918 if (err == -1) {
920 * If we fail to change ownership and if we are
921 * using security model none. Ignore the error
923 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
924 goto err_end;
925 } else {
926 err = 0;
930 goto out;
932 err_end:
933 unlinkat_preserve_errno(dirfd, name, 0);
934 out:
935 close_preserve_errno(dirfd);
936 return err;
939 static int local_link(FsContext *ctx, V9fsPath *oldpath,
940 V9fsPath *dirpath, const char *name)
942 char *odirpath = g_path_get_dirname(oldpath->data);
943 char *oname = g_path_get_basename(oldpath->data);
944 int ret = -1;
945 int odirfd, ndirfd;
947 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
948 local_is_mapped_file_metadata(ctx, name)) {
949 errno = EINVAL;
950 goto out;
953 odirfd = local_opendir_nofollow(ctx, odirpath);
954 if (odirfd == -1) {
955 goto out;
958 ndirfd = local_opendir_nofollow(ctx, dirpath->data);
959 if (ndirfd == -1) {
960 close_preserve_errno(odirfd);
961 goto out;
964 ret = linkat(odirfd, oname, ndirfd, name, 0);
965 if (ret < 0) {
966 goto out_close;
969 /* now link the virtfs_metadata files */
970 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
971 int omap_dirfd, nmap_dirfd;
973 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
974 if (ret < 0 && errno != EEXIST) {
975 goto err_undo_link;
978 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
979 if (omap_dirfd == -1) {
980 goto err;
983 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
984 if (nmap_dirfd == -1) {
985 close_preserve_errno(omap_dirfd);
986 goto err;
989 ret = linkat(omap_dirfd, oname, nmap_dirfd, name, 0);
990 close_preserve_errno(nmap_dirfd);
991 close_preserve_errno(omap_dirfd);
992 if (ret < 0 && errno != ENOENT) {
993 goto err_undo_link;
996 ret = 0;
998 goto out_close;
1000 err:
1001 ret = -1;
1002 err_undo_link:
1003 unlinkat_preserve_errno(ndirfd, name, 0);
1004 out_close:
1005 close_preserve_errno(ndirfd);
1006 close_preserve_errno(odirfd);
1007 out:
1008 g_free(oname);
1009 g_free(odirpath);
1010 return ret;
1013 static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
1015 int fd, ret;
1017 fd = local_open_nofollow(ctx, fs_path->data, O_WRONLY, 0);
1018 if (fd == -1) {
1019 return -1;
1021 ret = ftruncate(fd, size);
1022 close_preserve_errno(fd);
1023 return ret;
1026 static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
1028 char *dirpath = g_path_get_dirname(fs_path->data);
1029 char *name = g_path_get_basename(fs_path->data);
1030 int ret = -1;
1031 int dirfd;
1033 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
1034 if (dirfd == -1) {
1035 goto out;
1038 if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
1039 (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
1040 (fs_ctx->export_flags & V9FS_SM_NONE)) {
1041 ret = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
1042 AT_SYMLINK_NOFOLLOW);
1043 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
1044 ret = local_set_xattrat(dirfd, name, credp);
1045 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1046 ret = local_set_mapped_file_attrat(dirfd, name, credp);
1049 close_preserve_errno(dirfd);
1050 out:
1051 g_free(name);
1052 g_free(dirpath);
1053 return ret;
1056 static int local_utimensat(FsContext *s, V9fsPath *fs_path,
1057 const struct timespec *buf)
1059 char *dirpath = g_path_get_dirname(fs_path->data);
1060 char *name = g_path_get_basename(fs_path->data);
1061 int dirfd, ret = -1;
1063 dirfd = local_opendir_nofollow(s, dirpath);
1064 if (dirfd == -1) {
1065 goto out;
1068 ret = utimensat(dirfd, name, buf, AT_SYMLINK_NOFOLLOW);
1069 close_preserve_errno(dirfd);
1070 out:
1071 g_free(dirpath);
1072 g_free(name);
1073 return ret;
1076 static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name,
1077 int flags)
1079 int ret;
1081 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1082 int map_dirfd;
1084 /* We need to remove the metadata as well:
1085 * - the metadata directory if we're removing a directory
1086 * - the metadata file in the parent's metadata directory
1088 * If any of these are missing (ie, ENOENT) then we're probably
1089 * trying to remove something that wasn't created in mapped-file
1090 * mode. We just ignore the error.
1092 if (flags == AT_REMOVEDIR) {
1093 int fd;
1095 fd = openat_dir(dirfd, name);
1096 if (fd == -1) {
1097 return -1;
1099 ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR);
1100 close_preserve_errno(fd);
1101 if (ret < 0 && errno != ENOENT) {
1102 return -1;
1105 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
1106 if (map_dirfd != -1) {
1107 ret = unlinkat(map_dirfd, name, 0);
1108 close_preserve_errno(map_dirfd);
1109 if (ret < 0 && errno != ENOENT) {
1110 return -1;
1112 } else if (errno != ENOENT) {
1113 return -1;
1117 return unlinkat(dirfd, name, flags);
1120 static int local_remove(FsContext *ctx, const char *path)
1122 struct stat stbuf;
1123 char *dirpath = g_path_get_dirname(path);
1124 char *name = g_path_get_basename(path);
1125 int flags = 0;
1126 int dirfd;
1127 int err = -1;
1129 dirfd = local_opendir_nofollow(ctx, dirpath);
1130 if (dirfd == -1) {
1131 goto out;
1134 if (fstatat(dirfd, name, &stbuf, AT_SYMLINK_NOFOLLOW) < 0) {
1135 goto err_out;
1138 if (S_ISDIR(stbuf.st_mode)) {
1139 flags |= AT_REMOVEDIR;
1142 err = local_unlinkat_common(ctx, dirfd, name, flags);
1143 err_out:
1144 close_preserve_errno(dirfd);
1145 out:
1146 g_free(name);
1147 g_free(dirpath);
1148 return err;
1151 static int local_fsync(FsContext *ctx, int fid_type,
1152 V9fsFidOpenState *fs, int datasync)
1154 int fd;
1156 if (fid_type == P9_FID_DIR) {
1157 fd = dirfd(fs->dir.stream);
1158 } else {
1159 fd = fs->fd;
1162 if (datasync) {
1163 return qemu_fdatasync(fd);
1164 } else {
1165 return fsync(fd);
1169 static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
1171 int fd, ret;
1173 fd = local_open_nofollow(s, fs_path->data, O_RDONLY, 0);
1174 if (fd == -1) {
1175 return -1;
1177 ret = fstatfs(fd, stbuf);
1178 close_preserve_errno(fd);
1179 return ret;
1182 static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
1183 const char *name, void *value, size_t size)
1185 char *path = fs_path->data;
1187 return v9fs_get_xattr(ctx, path, name, value, size);
1190 static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path,
1191 void *value, size_t size)
1193 char *path = fs_path->data;
1195 return v9fs_list_xattr(ctx, path, value, size);
1198 static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
1199 void *value, size_t size, int flags)
1201 char *path = fs_path->data;
1203 return v9fs_set_xattr(ctx, path, name, value, size, flags);
1206 static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1207 const char *name)
1209 char *path = fs_path->data;
1211 return v9fs_remove_xattr(ctx, path, name);
1214 static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1215 const char *name, V9fsPath *target)
1217 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
1218 local_is_mapped_file_metadata(ctx, name)) {
1219 errno = EINVAL;
1220 return -1;
1223 if (dir_path) {
1224 if (!strcmp(name, ".")) {
1225 /* "." relative to "foo/bar" is "foo/bar" */
1226 v9fs_path_copy(target, dir_path);
1227 } else if (!strcmp(name, "..")) {
1228 if (!strcmp(dir_path->data, ".")) {
1229 /* ".." relative to the root is "." */
1230 v9fs_path_sprintf(target, ".");
1231 } else {
1232 char *tmp = g_path_get_dirname(dir_path->data);
1233 /* Symbolic links are resolved by the client. We can assume
1234 * that ".." relative to "foo/bar" is equivalent to "foo"
1236 v9fs_path_sprintf(target, "%s", tmp);
1237 g_free(tmp);
1239 } else {
1240 assert(!strchr(name, '/'));
1241 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name);
1243 } else if (!strcmp(name, "/") || !strcmp(name, ".") ||
1244 !strcmp(name, "..")) {
1245 /* This is the root fid */
1246 v9fs_path_sprintf(target, ".");
1247 } else {
1248 assert(!strchr(name, '/'));
1249 v9fs_path_sprintf(target, "./%s", name);
1251 return 0;
1254 static int local_renameat(FsContext *ctx, V9fsPath *olddir,
1255 const char *old_name, V9fsPath *newdir,
1256 const char *new_name)
1258 int ret;
1259 int odirfd, ndirfd;
1261 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
1262 (local_is_mapped_file_metadata(ctx, old_name) ||
1263 local_is_mapped_file_metadata(ctx, new_name))) {
1264 errno = EINVAL;
1265 return -1;
1268 odirfd = local_opendir_nofollow(ctx, olddir->data);
1269 if (odirfd == -1) {
1270 return -1;
1273 ndirfd = local_opendir_nofollow(ctx, newdir->data);
1274 if (ndirfd == -1) {
1275 close_preserve_errno(odirfd);
1276 return -1;
1279 ret = renameat(odirfd, old_name, ndirfd, new_name);
1280 if (ret < 0) {
1281 goto out;
1284 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1285 int omap_dirfd, nmap_dirfd;
1287 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
1288 if (ret < 0 && errno != EEXIST) {
1289 goto err_undo_rename;
1292 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
1293 if (omap_dirfd == -1) {
1294 goto err;
1297 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
1298 if (nmap_dirfd == -1) {
1299 close_preserve_errno(omap_dirfd);
1300 goto err;
1303 /* rename the .virtfs_metadata files */
1304 ret = renameat(omap_dirfd, old_name, nmap_dirfd, new_name);
1305 close_preserve_errno(nmap_dirfd);
1306 close_preserve_errno(omap_dirfd);
1307 if (ret < 0 && errno != ENOENT) {
1308 goto err_undo_rename;
1311 ret = 0;
1313 goto out;
1315 err:
1316 ret = -1;
1317 err_undo_rename:
1318 renameat_preserve_errno(ndirfd, new_name, odirfd, old_name);
1319 out:
1320 close_preserve_errno(ndirfd);
1321 close_preserve_errno(odirfd);
1322 return ret;
1325 static void v9fs_path_init_dirname(V9fsPath *path, const char *str)
1327 path->data = g_path_get_dirname(str);
1328 path->size = strlen(path->data) + 1;
1331 static int local_rename(FsContext *ctx, const char *oldpath,
1332 const char *newpath)
1334 int err;
1335 char *oname = g_path_get_basename(oldpath);
1336 char *nname = g_path_get_basename(newpath);
1337 V9fsPath olddir, newdir;
1339 v9fs_path_init_dirname(&olddir, oldpath);
1340 v9fs_path_init_dirname(&newdir, newpath);
1342 err = local_renameat(ctx, &olddir, oname, &newdir, nname);
1344 v9fs_path_free(&newdir);
1345 v9fs_path_free(&olddir);
1346 g_free(nname);
1347 g_free(oname);
1349 return err;
1352 static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
1353 const char *name, int flags)
1355 int ret;
1356 int dirfd;
1358 if (ctx->export_flags & V9FS_SM_MAPPED_FILE &&
1359 local_is_mapped_file_metadata(ctx, name)) {
1360 errno = EINVAL;
1361 return -1;
1364 dirfd = local_opendir_nofollow(ctx, dir->data);
1365 if (dirfd == -1) {
1366 return -1;
1369 ret = local_unlinkat_common(ctx, dirfd, name, flags);
1370 close_preserve_errno(dirfd);
1371 return ret;
1374 #ifdef FS_IOC_GETVERSION
1375 static int local_ioc_getversion(FsContext *ctx, V9fsPath *path,
1376 mode_t st_mode, uint64_t *st_gen)
1378 int err;
1379 V9fsFidOpenState fid_open;
1382 * Do not try to open special files like device nodes, fifos etc
1383 * We can get fd for regular files and directories only
1385 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1386 errno = ENOTTY;
1387 return -1;
1389 err = local_open(ctx, path, O_RDONLY, &fid_open);
1390 if (err < 0) {
1391 return err;
1393 err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
1394 local_close(ctx, &fid_open);
1395 return err;
1397 #endif
1399 static int local_ioc_getversion_init(FsContext *ctx, LocalData *data, Error **errp)
1401 #ifdef FS_IOC_GETVERSION
1402 struct statfs stbuf;
1405 * use ioc_getversion only if the ioctl is definied
1407 if (fstatfs(data->mountfd, &stbuf) < 0) {
1408 error_setg_errno(errp, errno,
1409 "failed to stat file system at '%s'", ctx->fs_root);
1410 return -1;
1412 switch (stbuf.f_type) {
1413 case EXT2_SUPER_MAGIC:
1414 case BTRFS_SUPER_MAGIC:
1415 case REISERFS_SUPER_MAGIC:
1416 case XFS_SUPER_MAGIC:
1417 ctx->exops.get_st_gen = local_ioc_getversion;
1418 break;
1420 #endif
1421 return 0;
1424 static int local_init(FsContext *ctx, Error **errp)
1426 LocalData *data = g_malloc(sizeof(*data));
1428 data->mountfd = open(ctx->fs_root, O_DIRECTORY | O_RDONLY);
1429 if (data->mountfd == -1) {
1430 error_setg_errno(errp, errno, "failed to open '%s'", ctx->fs_root);
1431 goto err;
1434 if (local_ioc_getversion_init(ctx, data, errp) < 0) {
1435 close(data->mountfd);
1436 goto err;
1439 if (ctx->export_flags & V9FS_SM_PASSTHROUGH) {
1440 ctx->xops = passthrough_xattr_ops;
1441 } else if (ctx->export_flags & V9FS_SM_MAPPED) {
1442 ctx->xops = mapped_xattr_ops;
1443 } else if (ctx->export_flags & V9FS_SM_NONE) {
1444 ctx->xops = none_xattr_ops;
1445 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1447 * xattr operation for mapped-file and passthrough
1448 * remain same.
1450 ctx->xops = passthrough_xattr_ops;
1452 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1454 ctx->private = data;
1455 return 0;
1457 err:
1458 g_free(data);
1459 return -1;
1462 static void local_cleanup(FsContext *ctx)
1464 LocalData *data = ctx->private;
1466 if (!data) {
1467 return;
1470 close(data->mountfd);
1471 g_free(data);
1474 static void error_append_security_model_hint(Error *const *errp)
1476 error_append_hint(errp, "Valid options are: security_model="
1477 "[passthrough|mapped-xattr|mapped-file|none]\n");
1480 static int local_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp)
1482 ERRP_GUARD();
1483 const char *sec_model = qemu_opt_get(opts, "security_model");
1484 const char *path = qemu_opt_get(opts, "path");
1485 const char *multidevs = qemu_opt_get(opts, "multidevs");
1487 if (!sec_model) {
1488 error_setg(errp, "security_model property not set");
1489 error_append_security_model_hint(errp);
1490 return -1;
1493 if (!strcmp(sec_model, "passthrough")) {
1494 fse->export_flags |= V9FS_SM_PASSTHROUGH;
1495 } else if (!strcmp(sec_model, "mapped") ||
1496 !strcmp(sec_model, "mapped-xattr")) {
1497 fse->export_flags |= V9FS_SM_MAPPED;
1498 } else if (!strcmp(sec_model, "none")) {
1499 fse->export_flags |= V9FS_SM_NONE;
1500 } else if (!strcmp(sec_model, "mapped-file")) {
1501 fse->export_flags |= V9FS_SM_MAPPED_FILE;
1502 } else {
1503 error_setg(errp, "invalid security_model property '%s'", sec_model);
1504 error_append_security_model_hint(errp);
1505 return -1;
1508 if (multidevs) {
1509 if (!strcmp(multidevs, "remap")) {
1510 fse->export_flags &= ~V9FS_FORBID_MULTIDEVS;
1511 fse->export_flags |= V9FS_REMAP_INODES;
1512 } else if (!strcmp(multidevs, "forbid")) {
1513 fse->export_flags &= ~V9FS_REMAP_INODES;
1514 fse->export_flags |= V9FS_FORBID_MULTIDEVS;
1515 } else if (!strcmp(multidevs, "warn")) {
1516 fse->export_flags &= ~V9FS_FORBID_MULTIDEVS;
1517 fse->export_flags &= ~V9FS_REMAP_INODES;
1518 } else {
1519 error_setg(errp, "invalid multidevs property '%s'",
1520 multidevs);
1521 error_append_hint(errp, "Valid options are: multidevs="
1522 "[remap|forbid|warn]\n");
1523 return -1;
1527 if (!path) {
1528 error_setg(errp, "path property not set");
1529 return -1;
1532 if (fsdev_throttle_parse_opts(opts, &fse->fst, errp)) {
1533 error_prepend(errp, "invalid throttle configuration: ");
1534 return -1;
1537 if (fse->export_flags & V9FS_SM_MAPPED ||
1538 fse->export_flags & V9FS_SM_MAPPED_FILE) {
1539 fse->fmode =
1540 qemu_opt_get_number(opts, "fmode", SM_LOCAL_MODE_BITS) & 0777;
1541 fse->dmode =
1542 qemu_opt_get_number(opts, "dmode", SM_LOCAL_DIR_MODE_BITS) & 0777;
1543 } else {
1544 if (qemu_opt_find(opts, "fmode")) {
1545 error_setg(errp, "fmode is only valid for mapped security modes");
1546 return -1;
1548 if (qemu_opt_find(opts, "dmode")) {
1549 error_setg(errp, "dmode is only valid for mapped security modes");
1550 return -1;
1554 fse->path = g_strdup(path);
1556 return 0;
1559 FileOperations local_ops = {
1560 .parse_opts = local_parse_opts,
1561 .init = local_init,
1562 .cleanup = local_cleanup,
1563 .lstat = local_lstat,
1564 .readlink = local_readlink,
1565 .close = local_close,
1566 .closedir = local_closedir,
1567 .open = local_open,
1568 .opendir = local_opendir,
1569 .rewinddir = local_rewinddir,
1570 .telldir = local_telldir,
1571 .readdir = local_readdir,
1572 .seekdir = local_seekdir,
1573 .preadv = local_preadv,
1574 .pwritev = local_pwritev,
1575 .chmod = local_chmod,
1576 .mknod = local_mknod,
1577 .mkdir = local_mkdir,
1578 .fstat = local_fstat,
1579 .open2 = local_open2,
1580 .symlink = local_symlink,
1581 .link = local_link,
1582 .truncate = local_truncate,
1583 .rename = local_rename,
1584 .chown = local_chown,
1585 .utimensat = local_utimensat,
1586 .remove = local_remove,
1587 .fsync = local_fsync,
1588 .statfs = local_statfs,
1589 .lgetxattr = local_lgetxattr,
1590 .llistxattr = local_llistxattr,
1591 .lsetxattr = local_lsetxattr,
1592 .lremovexattr = local_lremovexattr,
1593 .name_to_path = local_name_to_path,
1594 .renameat = local_renameat,
1595 .unlinkat = local_unlinkat,