4 * Copyright IBM, Corp. 2010
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.
14 #include "qemu/osdep.h"
19 #include "fsdev/qemu-fsdev.h" /* local_ops */
20 #include <arpa/inet.h>
23 #include <sys/socket.h>
25 #include "qemu/xattr.h"
26 #include "qemu/cutils.h"
27 #include "qemu/error-report.h"
30 #ifdef CONFIG_LINUX_MAGIC_H
31 #include <linux/magic.h>
33 #include <sys/ioctl.h>
35 #ifndef XFS_SUPER_MAGIC
36 #define XFS_SUPER_MAGIC 0x58465342
38 #ifndef EXT2_SUPER_MAGIC
39 #define EXT2_SUPER_MAGIC 0xEF53
41 #ifndef REISERFS_SUPER_MAGIC
42 #define REISERFS_SUPER_MAGIC 0x52654973
44 #ifndef BTRFS_SUPER_MAGIC
45 #define BTRFS_SUPER_MAGIC 0x9123683E
52 int local_open_nofollow(FsContext
*fs_ctx
, const char *path
, int flags
,
55 LocalData
*data
= fs_ctx
->private;
57 /* All paths are relative to the path data->mountfd points to */
58 while (*path
== '/') {
62 return relative_openat_nofollow(data
->mountfd
, path
, flags
, mode
);
65 int local_opendir_nofollow(FsContext
*fs_ctx
, const char *path
)
67 return local_open_nofollow(fs_ctx
, path
, O_DIRECTORY
| O_RDONLY
, 0);
70 static void renameat_preserve_errno(int odirfd
, const char *opath
, int ndirfd
,
74 renameat(odirfd
, opath
, ndirfd
, npath
);
78 static void unlinkat_preserve_errno(int dirfd
, const char *path
, int flags
)
81 unlinkat(dirfd
, path
, flags
);
85 #define VIRTFS_META_DIR ".virtfs_metadata"
87 static FILE *local_fopenat(int dirfd
, const char *name
, const char *mode
)
93 * only supports two modes
97 } else if (mode
[0] == 'w') {
98 flags
= O_WRONLY
| O_TRUNC
| O_CREAT
;
99 o_mode
= S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
| S_IROTH
| S_IWOTH
;
103 fd
= openat_file(dirfd
, name
, flags
, o_mode
);
107 fp
= fdopen(fd
, mode
);
115 static void local_mapped_file_attr(int dirfd
, const char *name
,
122 map_dirfd
= openat_dir(dirfd
, VIRTFS_META_DIR
);
123 if (map_dirfd
== -1) {
127 fp
= local_fopenat(map_dirfd
, name
, "r");
128 close_preserve_errno(map_dirfd
);
132 memset(buf
, 0, ATTR_MAX
);
133 while (fgets(buf
, ATTR_MAX
, fp
)) {
134 if (!strncmp(buf
, "virtfs.uid", 10)) {
135 stbuf
->st_uid
= atoi(buf
+11);
136 } else if (!strncmp(buf
, "virtfs.gid", 10)) {
137 stbuf
->st_gid
= atoi(buf
+11);
138 } else if (!strncmp(buf
, "virtfs.mode", 11)) {
139 stbuf
->st_mode
= atoi(buf
+12);
140 } else if (!strncmp(buf
, "virtfs.rdev", 11)) {
141 stbuf
->st_rdev
= atoi(buf
+12);
143 memset(buf
, 0, ATTR_MAX
);
148 static int local_lstat(FsContext
*fs_ctx
, V9fsPath
*fs_path
, struct stat
*stbuf
)
151 char *dirpath
= g_path_get_dirname(fs_path
->data
);
152 char *name
= g_path_get_basename(fs_path
->data
);
155 dirfd
= local_opendir_nofollow(fs_ctx
, dirpath
);
160 err
= fstatat(dirfd
, name
, stbuf
, AT_SYMLINK_NOFOLLOW
);
164 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
165 /* Actual credentials are part of extended attrs */
171 if (fgetxattrat_nofollow(dirfd
, name
, "user.virtfs.uid", &tmp_uid
,
172 sizeof(uid_t
)) > 0) {
173 stbuf
->st_uid
= le32_to_cpu(tmp_uid
);
175 if (fgetxattrat_nofollow(dirfd
, name
, "user.virtfs.gid", &tmp_gid
,
176 sizeof(gid_t
)) > 0) {
177 stbuf
->st_gid
= le32_to_cpu(tmp_gid
);
179 if (fgetxattrat_nofollow(dirfd
, name
, "user.virtfs.mode", &tmp_mode
,
180 sizeof(mode_t
)) > 0) {
181 stbuf
->st_mode
= le32_to_cpu(tmp_mode
);
183 if (fgetxattrat_nofollow(dirfd
, name
, "user.virtfs.rdev", &tmp_dev
,
184 sizeof(dev_t
)) > 0) {
185 stbuf
->st_rdev
= le64_to_cpu(tmp_dev
);
187 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
188 local_mapped_file_attr(dirfd
, name
, stbuf
);
192 close_preserve_errno(dirfd
);
199 static int local_set_mapped_file_attrat(int dirfd
, const char *name
,
205 int uid
= -1, gid
= -1, mode
= -1, rdev
= -1;
208 ret
= mkdirat(dirfd
, VIRTFS_META_DIR
, 0700);
209 if (ret
< 0 && errno
!= EEXIST
) {
213 map_dirfd
= openat_dir(dirfd
, VIRTFS_META_DIR
);
214 if (map_dirfd
== -1) {
218 fp
= local_fopenat(map_dirfd
, name
, "r");
220 if (errno
== ENOENT
) {
221 goto update_map_file
;
223 close_preserve_errno(map_dirfd
);
227 memset(buf
, 0, ATTR_MAX
);
228 while (fgets(buf
, ATTR_MAX
, fp
)) {
229 if (!strncmp(buf
, "virtfs.uid", 10)) {
230 uid
= atoi(buf
+ 11);
231 } else if (!strncmp(buf
, "virtfs.gid", 10)) {
232 gid
= atoi(buf
+ 11);
233 } else if (!strncmp(buf
, "virtfs.mode", 11)) {
234 mode
= atoi(buf
+ 12);
235 } else if (!strncmp(buf
, "virtfs.rdev", 11)) {
236 rdev
= atoi(buf
+ 12);
238 memset(buf
, 0, ATTR_MAX
);
243 fp
= local_fopenat(map_dirfd
, name
, "w");
244 close_preserve_errno(map_dirfd
);
249 if (credp
->fc_uid
!= -1) {
252 if (credp
->fc_gid
!= -1) {
255 if (credp
->fc_mode
!= -1) {
256 mode
= credp
->fc_mode
;
258 if (credp
->fc_rdev
!= -1) {
259 rdev
= credp
->fc_rdev
;
263 fprintf(fp
, "virtfs.uid=%d\n", uid
);
266 fprintf(fp
, "virtfs.gid=%d\n", gid
);
269 fprintf(fp
, "virtfs.mode=%d\n", mode
);
272 fprintf(fp
, "virtfs.rdev=%d\n", rdev
);
279 static int fchmodat_nofollow(int dirfd
, const char *name
, mode_t mode
)
283 /* FIXME: this should be handled with fchmodat(AT_SYMLINK_NOFOLLOW).
284 * Unfortunately, the linux kernel doesn't implement it yet. As an
285 * alternative, let's open the file and use fchmod() instead. This
286 * may fail depending on the permissions of the file, but it is the
287 * best we can do to avoid TOCTTOU. We first try to open read-only
288 * in case name points to a directory. If that fails, we try write-only
289 * in case name doesn't point to a directory.
291 fd
= openat_file(dirfd
, name
, O_RDONLY
, 0);
293 /* In case the file is writable-only and isn't a directory. */
294 if (errno
== EACCES
) {
295 fd
= openat_file(dirfd
, name
, O_WRONLY
, 0);
297 if (fd
== -1 && errno
== EISDIR
) {
304 ret
= fchmod(fd
, mode
);
305 close_preserve_errno(fd
);
309 static int local_set_xattrat(int dirfd
, const char *path
, FsCred
*credp
)
313 if (credp
->fc_uid
!= -1) {
314 uint32_t tmp_uid
= cpu_to_le32(credp
->fc_uid
);
315 err
= fsetxattrat_nofollow(dirfd
, path
, "user.virtfs.uid", &tmp_uid
,
321 if (credp
->fc_gid
!= -1) {
322 uint32_t tmp_gid
= cpu_to_le32(credp
->fc_gid
);
323 err
= fsetxattrat_nofollow(dirfd
, path
, "user.virtfs.gid", &tmp_gid
,
329 if (credp
->fc_mode
!= -1) {
330 uint32_t tmp_mode
= cpu_to_le32(credp
->fc_mode
);
331 err
= fsetxattrat_nofollow(dirfd
, path
, "user.virtfs.mode", &tmp_mode
,
337 if (credp
->fc_rdev
!= -1) {
338 uint64_t tmp_rdev
= cpu_to_le64(credp
->fc_rdev
);
339 err
= fsetxattrat_nofollow(dirfd
, path
, "user.virtfs.rdev", &tmp_rdev
,
348 static int local_set_cred_passthrough(FsContext
*fs_ctx
, int dirfd
,
349 const char *name
, FsCred
*credp
)
351 if (fchownat(dirfd
, name
, credp
->fc_uid
, credp
->fc_gid
,
352 AT_SYMLINK_NOFOLLOW
| AT_EMPTY_PATH
) < 0) {
354 * If we fail to change ownership and if we are
355 * using security model none. Ignore the error
357 if ((fs_ctx
->export_flags
& V9FS_SEC_MASK
) != V9FS_SM_NONE
) {
362 return fchmodat_nofollow(dirfd
, name
, credp
->fc_mode
& 07777);
365 static ssize_t
local_readlink(FsContext
*fs_ctx
, V9fsPath
*fs_path
,
366 char *buf
, size_t bufsz
)
370 if ((fs_ctx
->export_flags
& V9FS_SM_MAPPED
) ||
371 (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
)) {
374 fd
= local_open_nofollow(fs_ctx
, fs_path
->data
, O_RDONLY
, 0);
379 tsize
= read(fd
, (void *)buf
, bufsz
);
380 } while (tsize
== -1 && errno
== EINTR
);
381 close_preserve_errno(fd
);
382 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
383 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
384 char *dirpath
= g_path_get_dirname(fs_path
->data
);
385 char *name
= g_path_get_basename(fs_path
->data
);
388 dirfd
= local_opendir_nofollow(fs_ctx
, dirpath
);
393 tsize
= readlinkat(dirfd
, name
, buf
, bufsz
);
394 close_preserve_errno(dirfd
);
402 static int local_close(FsContext
*ctx
, V9fsFidOpenState
*fs
)
404 return close(fs
->fd
);
407 static int local_closedir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
409 return closedir(fs
->dir
.stream
);
412 static int local_open(FsContext
*ctx
, V9fsPath
*fs_path
,
413 int flags
, V9fsFidOpenState
*fs
)
417 fd
= local_open_nofollow(ctx
, fs_path
->data
, flags
, 0);
425 static int local_opendir(FsContext
*ctx
,
426 V9fsPath
*fs_path
, V9fsFidOpenState
*fs
)
431 dirfd
= local_opendir_nofollow(ctx
, fs_path
->data
);
436 stream
= fdopendir(dirfd
);
440 fs
->dir
.stream
= stream
;
444 static void local_rewinddir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
446 rewinddir(fs
->dir
.stream
);
449 static off_t
local_telldir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
451 return telldir(fs
->dir
.stream
);
454 static struct dirent
*local_readdir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
456 struct dirent
*entry
;
459 entry
= readdir(fs
->dir
.stream
);
464 if (ctx
->export_flags
& V9FS_SM_MAPPED
) {
465 entry
->d_type
= DT_UNKNOWN
;
466 } else if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
467 if (!strcmp(entry
->d_name
, VIRTFS_META_DIR
)) {
468 /* skp the meta data directory */
471 entry
->d_type
= DT_UNKNOWN
;
477 static void local_seekdir(FsContext
*ctx
, V9fsFidOpenState
*fs
, off_t off
)
479 seekdir(fs
->dir
.stream
, off
);
482 static ssize_t
local_preadv(FsContext
*ctx
, V9fsFidOpenState
*fs
,
483 const struct iovec
*iov
,
484 int iovcnt
, off_t offset
)
487 return preadv(fs
->fd
, iov
, iovcnt
, offset
);
489 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
493 return readv(fs
->fd
, iov
, iovcnt
);
498 static ssize_t
local_pwritev(FsContext
*ctx
, V9fsFidOpenState
*fs
,
499 const struct iovec
*iov
,
500 int iovcnt
, off_t offset
)
504 ret
= pwritev(fs
->fd
, iov
, iovcnt
, offset
);
506 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
510 ret
= writev(fs
->fd
, iov
, iovcnt
);
513 #ifdef CONFIG_SYNC_FILE_RANGE
514 if (ret
> 0 && ctx
->export_flags
& V9FS_IMMEDIATE_WRITEOUT
) {
516 * Initiate a writeback. This is not a data integrity sync.
517 * We want to ensure that we don't leave dirty pages in the cache
518 * after write when writeout=immediate is sepcified.
520 sync_file_range(fs
->fd
, offset
, ret
,
521 SYNC_FILE_RANGE_WAIT_BEFORE
| SYNC_FILE_RANGE_WRITE
);
527 static int local_chmod(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
529 char *dirpath
= g_path_get_dirname(fs_path
->data
);
530 char *name
= g_path_get_basename(fs_path
->data
);
534 dirfd
= local_opendir_nofollow(fs_ctx
, dirpath
);
539 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
540 ret
= local_set_xattrat(dirfd
, name
, credp
);
541 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
542 ret
= local_set_mapped_file_attrat(dirfd
, name
, credp
);
543 } else if (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
||
544 fs_ctx
->export_flags
& V9FS_SM_NONE
) {
545 ret
= fchmodat_nofollow(dirfd
, name
, credp
->fc_mode
);
547 close_preserve_errno(dirfd
);
555 static int local_mknod(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
556 const char *name
, FsCred
*credp
)
561 dirfd
= local_opendir_nofollow(fs_ctx
, dir_path
->data
);
566 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
||
567 fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
568 err
= mknodat(dirfd
, name
, SM_LOCAL_MODE_BITS
| S_IFREG
, 0);
573 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
574 err
= local_set_xattrat(dirfd
, name
, credp
);
576 err
= local_set_mapped_file_attrat(dirfd
, name
, credp
);
581 } else if (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
||
582 fs_ctx
->export_flags
& V9FS_SM_NONE
) {
583 err
= mknodat(dirfd
, name
, credp
->fc_mode
, credp
->fc_rdev
);
587 err
= local_set_cred_passthrough(fs_ctx
, dirfd
, name
, credp
);
595 unlinkat_preserve_errno(dirfd
, name
, 0);
597 close_preserve_errno(dirfd
);
601 static int local_mkdir(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
602 const char *name
, FsCred
*credp
)
607 dirfd
= local_opendir_nofollow(fs_ctx
, dir_path
->data
);
612 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
||
613 fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
614 err
= mkdirat(dirfd
, name
, SM_LOCAL_DIR_MODE_BITS
);
618 credp
->fc_mode
= credp
->fc_mode
| S_IFDIR
;
620 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
621 err
= local_set_xattrat(dirfd
, name
, credp
);
623 err
= local_set_mapped_file_attrat(dirfd
, name
, credp
);
628 } else if (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
||
629 fs_ctx
->export_flags
& V9FS_SM_NONE
) {
630 err
= mkdirat(dirfd
, name
, credp
->fc_mode
);
634 err
= local_set_cred_passthrough(fs_ctx
, dirfd
, name
, credp
);
642 unlinkat_preserve_errno(dirfd
, name
, AT_REMOVEDIR
);
644 close_preserve_errno(dirfd
);
648 static int local_fstat(FsContext
*fs_ctx
, int fid_type
,
649 V9fsFidOpenState
*fs
, struct stat
*stbuf
)
653 if (fid_type
== P9_FID_DIR
) {
654 fd
= dirfd(fs
->dir
.stream
);
659 err
= fstat(fd
, stbuf
);
663 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
664 /* Actual credentials are part of extended attrs */
670 if (fgetxattr(fd
, "user.virtfs.uid", &tmp_uid
, sizeof(uid_t
)) > 0) {
671 stbuf
->st_uid
= le32_to_cpu(tmp_uid
);
673 if (fgetxattr(fd
, "user.virtfs.gid", &tmp_gid
, sizeof(gid_t
)) > 0) {
674 stbuf
->st_gid
= le32_to_cpu(tmp_gid
);
676 if (fgetxattr(fd
, "user.virtfs.mode", &tmp_mode
, sizeof(mode_t
)) > 0) {
677 stbuf
->st_mode
= le32_to_cpu(tmp_mode
);
679 if (fgetxattr(fd
, "user.virtfs.rdev", &tmp_dev
, sizeof(dev_t
)) > 0) {
680 stbuf
->st_rdev
= le64_to_cpu(tmp_dev
);
682 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
689 static int local_open2(FsContext
*fs_ctx
, V9fsPath
*dir_path
, const char *name
,
690 int flags
, FsCred
*credp
, V9fsFidOpenState
*fs
)
697 * Mark all the open to not follow symlinks
701 dirfd
= local_opendir_nofollow(fs_ctx
, dir_path
->data
);
706 /* Determine the security model */
707 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
||
708 fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
709 fd
= openat_file(dirfd
, name
, flags
, SM_LOCAL_MODE_BITS
);
713 credp
->fc_mode
= credp
->fc_mode
|S_IFREG
;
714 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
715 /* Set cleint credentials in xattr */
716 err
= local_set_xattrat(dirfd
, name
, credp
);
718 err
= local_set_mapped_file_attrat(dirfd
, name
, credp
);
723 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
724 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
725 fd
= openat_file(dirfd
, name
, flags
, credp
->fc_mode
);
729 err
= local_set_cred_passthrough(fs_ctx
, dirfd
, name
, credp
);
739 unlinkat_preserve_errno(dirfd
, name
,
740 flags
& O_DIRECTORY
? AT_REMOVEDIR
: 0);
741 close_preserve_errno(fd
);
743 close_preserve_errno(dirfd
);
748 static int local_symlink(FsContext
*fs_ctx
, const char *oldpath
,
749 V9fsPath
*dir_path
, const char *name
, FsCred
*credp
)
754 dirfd
= local_opendir_nofollow(fs_ctx
, dir_path
->data
);
759 /* Determine the security model */
760 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
||
761 fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
763 ssize_t oldpath_size
, write_size
;
765 fd
= openat_file(dirfd
, name
, O_CREAT
| O_EXCL
| O_RDWR
,
770 /* Write the oldpath (target) to the file. */
771 oldpath_size
= strlen(oldpath
);
773 write_size
= write(fd
, (void *)oldpath
, oldpath_size
);
774 } while (write_size
== -1 && errno
== EINTR
);
775 close_preserve_errno(fd
);
777 if (write_size
!= oldpath_size
) {
780 /* Set cleint credentials in symlink's xattr */
781 credp
->fc_mode
= credp
->fc_mode
| S_IFLNK
;
783 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
784 err
= local_set_xattrat(dirfd
, name
, credp
);
786 err
= local_set_mapped_file_attrat(dirfd
, name
, credp
);
791 } else if (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
||
792 fs_ctx
->export_flags
& V9FS_SM_NONE
) {
793 err
= symlinkat(oldpath
, dirfd
, name
);
797 err
= fchownat(dirfd
, name
, credp
->fc_uid
, credp
->fc_gid
,
798 AT_SYMLINK_NOFOLLOW
);
801 * If we fail to change ownership and if we are
802 * using security model none. Ignore the error
804 if ((fs_ctx
->export_flags
& V9FS_SEC_MASK
) != V9FS_SM_NONE
) {
814 unlinkat_preserve_errno(dirfd
, name
, 0);
816 close_preserve_errno(dirfd
);
820 static int local_link(FsContext
*ctx
, V9fsPath
*oldpath
,
821 V9fsPath
*dirpath
, const char *name
)
823 char *odirpath
= g_path_get_dirname(oldpath
->data
);
824 char *oname
= g_path_get_basename(oldpath
->data
);
828 odirfd
= local_opendir_nofollow(ctx
, odirpath
);
833 ndirfd
= local_opendir_nofollow(ctx
, dirpath
->data
);
835 close_preserve_errno(odirfd
);
839 ret
= linkat(odirfd
, oname
, ndirfd
, name
, 0);
844 /* now link the virtfs_metadata files */
845 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
846 int omap_dirfd
, nmap_dirfd
;
848 ret
= mkdirat(ndirfd
, VIRTFS_META_DIR
, 0700);
849 if (ret
< 0 && errno
!= EEXIST
) {
853 omap_dirfd
= openat_dir(odirfd
, VIRTFS_META_DIR
);
854 if (omap_dirfd
== -1) {
858 nmap_dirfd
= openat_dir(ndirfd
, VIRTFS_META_DIR
);
859 if (nmap_dirfd
== -1) {
860 close_preserve_errno(omap_dirfd
);
864 ret
= linkat(omap_dirfd
, oname
, nmap_dirfd
, name
, 0);
865 close_preserve_errno(nmap_dirfd
);
866 close_preserve_errno(omap_dirfd
);
867 if (ret
< 0 && errno
!= ENOENT
) {
878 unlinkat_preserve_errno(ndirfd
, name
, 0);
880 close_preserve_errno(ndirfd
);
881 close_preserve_errno(odirfd
);
888 static int local_truncate(FsContext
*ctx
, V9fsPath
*fs_path
, off_t size
)
892 fd
= local_open_nofollow(ctx
, fs_path
->data
, O_WRONLY
, 0);
896 ret
= ftruncate(fd
, size
);
897 close_preserve_errno(fd
);
901 static int local_chown(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
903 char *dirpath
= g_path_get_dirname(fs_path
->data
);
904 char *name
= g_path_get_basename(fs_path
->data
);
908 dirfd
= local_opendir_nofollow(fs_ctx
, dirpath
);
913 if ((credp
->fc_uid
== -1 && credp
->fc_gid
== -1) ||
914 (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
915 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
916 ret
= fchownat(dirfd
, name
, credp
->fc_uid
, credp
->fc_gid
,
917 AT_SYMLINK_NOFOLLOW
);
918 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
919 ret
= local_set_xattrat(dirfd
, name
, credp
);
920 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
921 ret
= local_set_mapped_file_attrat(dirfd
, name
, credp
);
924 close_preserve_errno(dirfd
);
931 static int local_utimensat(FsContext
*s
, V9fsPath
*fs_path
,
932 const struct timespec
*buf
)
934 char *dirpath
= g_path_get_dirname(fs_path
->data
);
935 char *name
= g_path_get_basename(fs_path
->data
);
938 dirfd
= local_opendir_nofollow(s
, dirpath
);
943 ret
= utimensat(dirfd
, name
, buf
, AT_SYMLINK_NOFOLLOW
);
944 close_preserve_errno(dirfd
);
951 static int local_unlinkat_common(FsContext
*ctx
, int dirfd
, const char *name
,
956 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
959 if (flags
== AT_REMOVEDIR
) {
962 fd
= openat(dirfd
, name
, O_RDONLY
| O_DIRECTORY
| O_PATH
);
967 * If directory remove .virtfs_metadata contained in the
970 ret
= unlinkat(fd
, VIRTFS_META_DIR
, AT_REMOVEDIR
);
971 close_preserve_errno(fd
);
972 if (ret
< 0 && errno
!= ENOENT
) {
974 * We didn't had the .virtfs_metadata file. May be file created
975 * in non-mapped mode ?. Ignore ENOENT.
981 * Now remove the name from parent directory
982 * .virtfs_metadata directory.
984 map_dirfd
= openat_dir(dirfd
, VIRTFS_META_DIR
);
985 ret
= unlinkat(map_dirfd
, name
, 0);
986 close_preserve_errno(map_dirfd
);
987 if (ret
< 0 && errno
!= ENOENT
) {
989 * We didn't had the .virtfs_metadata file. May be file created
990 * in non-mapped mode ?. Ignore ENOENT.
996 ret
= unlinkat(dirfd
, name
, flags
);
1001 static int local_remove(FsContext
*ctx
, const char *path
)
1004 char *dirpath
= g_path_get_dirname(path
);
1005 char *name
= g_path_get_basename(path
);
1010 dirfd
= local_opendir_nofollow(ctx
, dirpath
);
1015 if (fstatat(dirfd
, path
, &stbuf
, AT_SYMLINK_NOFOLLOW
) < 0) {
1019 if (S_ISDIR(stbuf
.st_mode
)) {
1020 flags
|= AT_REMOVEDIR
;
1023 err
= local_unlinkat_common(ctx
, dirfd
, name
, flags
);
1025 close_preserve_errno(dirfd
);
1032 static int local_fsync(FsContext
*ctx
, int fid_type
,
1033 V9fsFidOpenState
*fs
, int datasync
)
1037 if (fid_type
== P9_FID_DIR
) {
1038 fd
= dirfd(fs
->dir
.stream
);
1044 return qemu_fdatasync(fd
);
1050 static int local_statfs(FsContext
*s
, V9fsPath
*fs_path
, struct statfs
*stbuf
)
1054 fd
= local_open_nofollow(s
, fs_path
->data
, O_RDONLY
, 0);
1055 ret
= fstatfs(fd
, stbuf
);
1056 close_preserve_errno(fd
);
1060 static ssize_t
local_lgetxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1061 const char *name
, void *value
, size_t size
)
1063 char *path
= fs_path
->data
;
1065 return v9fs_get_xattr(ctx
, path
, name
, value
, size
);
1068 static ssize_t
local_llistxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1069 void *value
, size_t size
)
1071 char *path
= fs_path
->data
;
1073 return v9fs_list_xattr(ctx
, path
, value
, size
);
1076 static int local_lsetxattr(FsContext
*ctx
, V9fsPath
*fs_path
, const char *name
,
1077 void *value
, size_t size
, int flags
)
1079 char *path
= fs_path
->data
;
1081 return v9fs_set_xattr(ctx
, path
, name
, value
, size
, flags
);
1084 static int local_lremovexattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1087 char *path
= fs_path
->data
;
1089 return v9fs_remove_xattr(ctx
, path
, name
);
1092 static int local_name_to_path(FsContext
*ctx
, V9fsPath
*dir_path
,
1093 const char *name
, V9fsPath
*target
)
1096 v9fs_path_sprintf(target
, "%s/%s", dir_path
->data
, name
);
1098 v9fs_path_sprintf(target
, "%s", name
);
1103 static int local_renameat(FsContext
*ctx
, V9fsPath
*olddir
,
1104 const char *old_name
, V9fsPath
*newdir
,
1105 const char *new_name
)
1110 odirfd
= local_opendir_nofollow(ctx
, olddir
->data
);
1115 ndirfd
= local_opendir_nofollow(ctx
, newdir
->data
);
1117 close_preserve_errno(odirfd
);
1121 ret
= renameat(odirfd
, old_name
, ndirfd
, new_name
);
1126 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
1127 int omap_dirfd
, nmap_dirfd
;
1129 ret
= mkdirat(ndirfd
, VIRTFS_META_DIR
, 0700);
1130 if (ret
< 0 && errno
!= EEXIST
) {
1131 goto err_undo_rename
;
1134 omap_dirfd
= openat_dir(odirfd
, VIRTFS_META_DIR
);
1135 if (omap_dirfd
== -1) {
1139 nmap_dirfd
= openat_dir(ndirfd
, VIRTFS_META_DIR
);
1140 if (nmap_dirfd
== -1) {
1141 close_preserve_errno(omap_dirfd
);
1145 /* rename the .virtfs_metadata files */
1146 ret
= renameat(omap_dirfd
, old_name
, nmap_dirfd
, new_name
);
1147 close_preserve_errno(nmap_dirfd
);
1148 close_preserve_errno(omap_dirfd
);
1149 if (ret
< 0 && errno
!= ENOENT
) {
1150 goto err_undo_rename
;
1160 renameat_preserve_errno(ndirfd
, new_name
, odirfd
, old_name
);
1162 close_preserve_errno(ndirfd
);
1163 close_preserve_errno(odirfd
);
1167 static void v9fs_path_init_dirname(V9fsPath
*path
, const char *str
)
1169 path
->data
= g_path_get_dirname(str
);
1170 path
->size
= strlen(path
->data
) + 1;
1173 static int local_rename(FsContext
*ctx
, const char *oldpath
,
1174 const char *newpath
)
1177 char *oname
= g_path_get_basename(oldpath
);
1178 char *nname
= g_path_get_basename(newpath
);
1179 V9fsPath olddir
, newdir
;
1181 v9fs_path_init_dirname(&olddir
, oldpath
);
1182 v9fs_path_init_dirname(&newdir
, newpath
);
1184 err
= local_renameat(ctx
, &olddir
, oname
, &newdir
, nname
);
1186 v9fs_path_free(&newdir
);
1187 v9fs_path_free(&olddir
);
1194 static int local_unlinkat(FsContext
*ctx
, V9fsPath
*dir
,
1195 const char *name
, int flags
)
1200 dirfd
= local_opendir_nofollow(ctx
, dir
->data
);
1205 ret
= local_unlinkat_common(ctx
, dirfd
, name
, flags
);
1206 close_preserve_errno(dirfd
);
1210 static int local_ioc_getversion(FsContext
*ctx
, V9fsPath
*path
,
1211 mode_t st_mode
, uint64_t *st_gen
)
1213 #ifdef FS_IOC_GETVERSION
1215 V9fsFidOpenState fid_open
;
1218 * Do not try to open special files like device nodes, fifos etc
1219 * We can get fd for regular files and directories only
1221 if (!S_ISREG(st_mode
) && !S_ISDIR(st_mode
)) {
1225 err
= local_open(ctx
, path
, O_RDONLY
, &fid_open
);
1229 err
= ioctl(fid_open
.fd
, FS_IOC_GETVERSION
, st_gen
);
1230 local_close(ctx
, &fid_open
);
1238 static int local_init(FsContext
*ctx
)
1240 struct statfs stbuf
;
1241 LocalData
*data
= g_malloc(sizeof(*data
));
1243 data
->mountfd
= open(ctx
->fs_root
, O_DIRECTORY
| O_RDONLY
);
1244 if (data
->mountfd
== -1) {
1248 #ifdef FS_IOC_GETVERSION
1250 * use ioc_getversion only if the ioctl is definied
1252 if (fstatfs(data
->mountfd
, &stbuf
) < 0) {
1253 close_preserve_errno(data
->mountfd
);
1256 switch (stbuf
.f_type
) {
1257 case EXT2_SUPER_MAGIC
:
1258 case BTRFS_SUPER_MAGIC
:
1259 case REISERFS_SUPER_MAGIC
:
1260 case XFS_SUPER_MAGIC
:
1261 ctx
->exops
.get_st_gen
= local_ioc_getversion
;
1266 if (ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) {
1267 ctx
->xops
= passthrough_xattr_ops
;
1268 } else if (ctx
->export_flags
& V9FS_SM_MAPPED
) {
1269 ctx
->xops
= mapped_xattr_ops
;
1270 } else if (ctx
->export_flags
& V9FS_SM_NONE
) {
1271 ctx
->xops
= none_xattr_ops
;
1272 } else if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
1274 * xattr operation for mapped-file and passthrough
1277 ctx
->xops
= passthrough_xattr_ops
;
1279 ctx
->export_flags
|= V9FS_PATHNAME_FSCONTEXT
;
1281 ctx
->private = data
;
1289 static void local_cleanup(FsContext
*ctx
)
1291 LocalData
*data
= ctx
->private;
1293 close(data
->mountfd
);
1297 static int local_parse_opts(QemuOpts
*opts
, struct FsDriverEntry
*fse
)
1299 const char *sec_model
= qemu_opt_get(opts
, "security_model");
1300 const char *path
= qemu_opt_get(opts
, "path");
1304 error_report("Security model not specified, local fs needs security model");
1305 error_printf("valid options are:"
1306 "\tsecurity_model=[passthrough|mapped-xattr|mapped-file|none]\n");
1310 if (!strcmp(sec_model
, "passthrough")) {
1311 fse
->export_flags
|= V9FS_SM_PASSTHROUGH
;
1312 } else if (!strcmp(sec_model
, "mapped") ||
1313 !strcmp(sec_model
, "mapped-xattr")) {
1314 fse
->export_flags
|= V9FS_SM_MAPPED
;
1315 } else if (!strcmp(sec_model
, "none")) {
1316 fse
->export_flags
|= V9FS_SM_NONE
;
1317 } else if (!strcmp(sec_model
, "mapped-file")) {
1318 fse
->export_flags
|= V9FS_SM_MAPPED_FILE
;
1320 error_report("Invalid security model %s specified", sec_model
);
1321 error_printf("valid options are:"
1322 "\t[passthrough|mapped-xattr|mapped-file|none]\n");
1327 error_report("fsdev: No path specified");
1331 fsdev_throttle_parse_opts(opts
, &fse
->fst
, &err
);
1333 error_reportf_err(err
, "Throttle configuration is not valid: ");
1337 fse
->path
= g_strdup(path
);
1342 FileOperations local_ops
= {
1343 .parse_opts
= local_parse_opts
,
1345 .cleanup
= local_cleanup
,
1346 .lstat
= local_lstat
,
1347 .readlink
= local_readlink
,
1348 .close
= local_close
,
1349 .closedir
= local_closedir
,
1351 .opendir
= local_opendir
,
1352 .rewinddir
= local_rewinddir
,
1353 .telldir
= local_telldir
,
1354 .readdir
= local_readdir
,
1355 .seekdir
= local_seekdir
,
1356 .preadv
= local_preadv
,
1357 .pwritev
= local_pwritev
,
1358 .chmod
= local_chmod
,
1359 .mknod
= local_mknod
,
1360 .mkdir
= local_mkdir
,
1361 .fstat
= local_fstat
,
1362 .open2
= local_open2
,
1363 .symlink
= local_symlink
,
1365 .truncate
= local_truncate
,
1366 .rename
= local_rename
,
1367 .chown
= local_chown
,
1368 .utimensat
= local_utimensat
,
1369 .remove
= local_remove
,
1370 .fsync
= local_fsync
,
1371 .statfs
= local_statfs
,
1372 .lgetxattr
= local_lgetxattr
,
1373 .llistxattr
= local_llistxattr
,
1374 .lsetxattr
= local_lsetxattr
,
1375 .lremovexattr
= local_lremovexattr
,
1376 .name_to_path
= local_name_to_path
,
1377 .renameat
= local_renameat
,
1378 .unlinkat
= local_unlinkat
,