2 * Virtio 9p Posix callback
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 "hw/virtio/virtio.h"
15 #include "virtio-9p.h"
16 #include "virtio-9p-xattr.h"
17 #include "fsdev/qemu-fsdev.h" /* local_ops */
18 #include <arpa/inet.h>
21 #include <sys/socket.h>
23 #include "qemu/xattr.h"
26 #ifdef CONFIG_LINUX_MAGIC_H
27 #include <linux/magic.h>
29 #include <sys/ioctl.h>
31 #ifndef XFS_SUPER_MAGIC
32 #define XFS_SUPER_MAGIC 0x58465342
34 #ifndef EXT2_SUPER_MAGIC
35 #define EXT2_SUPER_MAGIC 0xEF53
37 #ifndef REISERFS_SUPER_MAGIC
38 #define REISERFS_SUPER_MAGIC 0x52654973
40 #ifndef BTRFS_SUPER_MAGIC
41 #define BTRFS_SUPER_MAGIC 0x9123683E
44 #define VIRTFS_META_DIR ".virtfs_metadata"
46 static char *local_mapped_attr_path(FsContext
*ctx
, const char *path
)
49 char *tmp_path
= g_strdup(path
);
50 char *base_name
= basename(tmp_path
);
53 /* NULL terminate the directory */
55 *(base_name
- 1) = '\0';
57 buffer
= g_strdup_printf("%s/%s/%s/%s",
58 ctx
->fs_root
, dir_name
, VIRTFS_META_DIR
, base_name
);
63 static FILE *local_fopen(const char *path
, const char *mode
)
67 int flags
= O_NOFOLLOW
;
69 * only supports two modes
73 } else if (mode
[0] == 'w') {
74 flags
|= O_WRONLY
| O_TRUNC
| O_CREAT
;
75 o_mode
= S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
| S_IROTH
| S_IWOTH
;
79 fd
= open(path
, flags
, o_mode
);
83 fp
= fdopen(fd
, mode
);
91 static void local_mapped_file_attr(FsContext
*ctx
, const char *path
,
98 attr_path
= local_mapped_attr_path(ctx
, path
);
99 fp
= local_fopen(attr_path
, "r");
104 memset(buf
, 0, ATTR_MAX
);
105 while (fgets(buf
, ATTR_MAX
, fp
)) {
106 if (!strncmp(buf
, "virtfs.uid", 10)) {
107 stbuf
->st_uid
= atoi(buf
+11);
108 } else if (!strncmp(buf
, "virtfs.gid", 10)) {
109 stbuf
->st_gid
= atoi(buf
+11);
110 } else if (!strncmp(buf
, "virtfs.mode", 11)) {
111 stbuf
->st_mode
= atoi(buf
+12);
112 } else if (!strncmp(buf
, "virtfs.rdev", 11)) {
113 stbuf
->st_rdev
= atoi(buf
+12);
115 memset(buf
, 0, ATTR_MAX
);
120 static int local_lstat(FsContext
*fs_ctx
, V9fsPath
*fs_path
, struct stat
*stbuf
)
124 char *path
= fs_path
->data
;
126 buffer
= rpath(fs_ctx
, path
);
127 err
= lstat(buffer
, stbuf
);
131 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
132 /* Actual credentials are part of extended attrs */
137 if (getxattr(buffer
, "user.virtfs.uid", &tmp_uid
, sizeof(uid_t
)) > 0) {
138 stbuf
->st_uid
= tmp_uid
;
140 if (getxattr(buffer
, "user.virtfs.gid", &tmp_gid
, sizeof(gid_t
)) > 0) {
141 stbuf
->st_gid
= tmp_gid
;
143 if (getxattr(buffer
, "user.virtfs.mode",
144 &tmp_mode
, sizeof(mode_t
)) > 0) {
145 stbuf
->st_mode
= tmp_mode
;
147 if (getxattr(buffer
, "user.virtfs.rdev", &tmp_dev
, sizeof(dev_t
)) > 0) {
148 stbuf
->st_rdev
= tmp_dev
;
150 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
151 local_mapped_file_attr(fs_ctx
, path
, stbuf
);
159 static int local_create_mapped_attr_dir(FsContext
*ctx
, const char *path
)
163 char *tmp_path
= g_strdup(path
);
165 attr_dir
= g_strdup_printf("%s/%s/%s",
166 ctx
->fs_root
, dirname(tmp_path
), VIRTFS_META_DIR
);
168 err
= mkdir(attr_dir
, 0700);
169 if (err
< 0 && errno
== EEXIST
) {
177 static int local_set_mapped_file_attr(FsContext
*ctx
,
178 const char *path
, FsCred
*credp
)
184 int uid
= -1, gid
= -1, mode
= -1, rdev
= -1;
186 attr_path
= local_mapped_attr_path(ctx
, path
);
187 fp
= local_fopen(attr_path
, "r");
189 goto create_map_file
;
191 memset(buf
, 0, ATTR_MAX
);
192 while (fgets(buf
, ATTR_MAX
, fp
)) {
193 if (!strncmp(buf
, "virtfs.uid", 10)) {
195 } else if (!strncmp(buf
, "virtfs.gid", 10)) {
197 } else if (!strncmp(buf
, "virtfs.mode", 11)) {
199 } else if (!strncmp(buf
, "virtfs.rdev", 11)) {
202 memset(buf
, 0, ATTR_MAX
);
205 goto update_map_file
;
208 ret
= local_create_mapped_attr_dir(ctx
, path
);
214 fp
= local_fopen(attr_path
, "w");
220 if (credp
->fc_uid
!= -1) {
223 if (credp
->fc_gid
!= -1) {
226 if (credp
->fc_mode
!= -1) {
227 mode
= credp
->fc_mode
;
229 if (credp
->fc_rdev
!= -1) {
230 rdev
= credp
->fc_rdev
;
235 fprintf(fp
, "virtfs.uid=%d\n", uid
);
238 fprintf(fp
, "virtfs.gid=%d\n", gid
);
241 fprintf(fp
, "virtfs.mode=%d\n", mode
);
244 fprintf(fp
, "virtfs.rdev=%d\n", rdev
);
253 static int local_set_xattr(const char *path
, FsCred
*credp
)
257 if (credp
->fc_uid
!= -1) {
258 err
= setxattr(path
, "user.virtfs.uid", &credp
->fc_uid
, sizeof(uid_t
),
264 if (credp
->fc_gid
!= -1) {
265 err
= setxattr(path
, "user.virtfs.gid", &credp
->fc_gid
, sizeof(gid_t
),
271 if (credp
->fc_mode
!= -1) {
272 err
= setxattr(path
, "user.virtfs.mode", &credp
->fc_mode
,
278 if (credp
->fc_rdev
!= -1) {
279 err
= setxattr(path
, "user.virtfs.rdev", &credp
->fc_rdev
,
288 static int local_post_create_passthrough(FsContext
*fs_ctx
, const char *path
,
293 buffer
= rpath(fs_ctx
, path
);
294 if (lchown(buffer
, credp
->fc_uid
, credp
->fc_gid
) < 0) {
296 * If we fail to change ownership and if we are
297 * using security model none. Ignore the error
299 if ((fs_ctx
->export_flags
& V9FS_SEC_MASK
) != V9FS_SM_NONE
) {
304 if (chmod(buffer
, credp
->fc_mode
& 07777) < 0) {
315 static ssize_t
local_readlink(FsContext
*fs_ctx
, V9fsPath
*fs_path
,
316 char *buf
, size_t bufsz
)
320 char *path
= fs_path
->data
;
322 if ((fs_ctx
->export_flags
& V9FS_SM_MAPPED
) ||
323 (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
)) {
325 buffer
= rpath(fs_ctx
, path
);
326 fd
= open(buffer
, O_RDONLY
| O_NOFOLLOW
);
332 tsize
= read(fd
, (void *)buf
, bufsz
);
333 } while (tsize
== -1 && errno
== EINTR
);
336 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
337 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
338 buffer
= rpath(fs_ctx
, path
);
339 tsize
= readlink(buffer
, buf
, bufsz
);
345 static int local_close(FsContext
*ctx
, V9fsFidOpenState
*fs
)
347 return close(fs
->fd
);
350 static int local_closedir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
352 return closedir(fs
->dir
);
355 static int local_open(FsContext
*ctx
, V9fsPath
*fs_path
,
356 int flags
, V9fsFidOpenState
*fs
)
359 char *path
= fs_path
->data
;
361 buffer
= rpath(ctx
, path
);
362 fs
->fd
= open(buffer
, flags
| O_NOFOLLOW
);
367 static int local_opendir(FsContext
*ctx
,
368 V9fsPath
*fs_path
, V9fsFidOpenState
*fs
)
371 char *path
= fs_path
->data
;
373 buffer
= rpath(ctx
, path
);
374 fs
->dir
= opendir(buffer
);
382 static void local_rewinddir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
384 return rewinddir(fs
->dir
);
387 static off_t
local_telldir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
389 return telldir(fs
->dir
);
392 static int local_readdir_r(FsContext
*ctx
, V9fsFidOpenState
*fs
,
393 struct dirent
*entry
,
394 struct dirent
**result
)
399 ret
= readdir_r(fs
->dir
, entry
, result
);
400 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
401 if (!ret
&& *result
!= NULL
&&
402 !strcmp(entry
->d_name
, VIRTFS_META_DIR
)) {
403 /* skp the meta data directory */
410 static void local_seekdir(FsContext
*ctx
, V9fsFidOpenState
*fs
, off_t off
)
412 return seekdir(fs
->dir
, off
);
415 static ssize_t
local_preadv(FsContext
*ctx
, V9fsFidOpenState
*fs
,
416 const struct iovec
*iov
,
417 int iovcnt
, off_t offset
)
420 return preadv(fs
->fd
, iov
, iovcnt
, offset
);
422 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
426 return readv(fs
->fd
, iov
, iovcnt
);
431 static ssize_t
local_pwritev(FsContext
*ctx
, V9fsFidOpenState
*fs
,
432 const struct iovec
*iov
,
433 int iovcnt
, off_t offset
)
438 ret
= pwritev(fs
->fd
, iov
, iovcnt
, offset
);
440 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
444 ret
= writev(fs
->fd
, iov
, iovcnt
);
447 #ifdef CONFIG_SYNC_FILE_RANGE
448 if (ret
> 0 && ctx
->export_flags
& V9FS_IMMEDIATE_WRITEOUT
) {
450 * Initiate a writeback. This is not a data integrity sync.
451 * We want to ensure that we don't leave dirty pages in the cache
452 * after write when writeout=immediate is sepcified.
454 sync_file_range(fs
->fd
, offset
, ret
,
455 SYNC_FILE_RANGE_WAIT_BEFORE
| SYNC_FILE_RANGE_WRITE
);
461 static int local_chmod(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
465 char *path
= fs_path
->data
;
467 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
468 buffer
= rpath(fs_ctx
, path
);
469 ret
= local_set_xattr(buffer
, credp
);
471 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
472 return local_set_mapped_file_attr(fs_ctx
, path
, credp
);
473 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
474 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
475 buffer
= rpath(fs_ctx
, path
);
476 ret
= chmod(buffer
, credp
->fc_mode
);
482 static int local_mknod(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
483 const char *name
, FsCred
*credp
)
491 v9fs_string_init(&fullname
);
492 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
493 path
= fullname
.data
;
495 /* Determine the security model */
496 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
497 buffer
= rpath(fs_ctx
, path
);
498 err
= mknod(buffer
, SM_LOCAL_MODE_BITS
|S_IFREG
, 0);
503 err
= local_set_xattr(buffer
, credp
);
508 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
510 buffer
= rpath(fs_ctx
, path
);
511 err
= mknod(buffer
, SM_LOCAL_MODE_BITS
|S_IFREG
, 0);
516 err
= local_set_mapped_file_attr(fs_ctx
, path
, credp
);
521 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
522 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
523 buffer
= rpath(fs_ctx
, path
);
524 err
= mknod(buffer
, credp
->fc_mode
, credp
->fc_rdev
);
529 err
= local_post_create_passthrough(fs_ctx
, path
, credp
);
542 v9fs_string_free(&fullname
);
546 static int local_mkdir(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
547 const char *name
, FsCred
*credp
)
555 v9fs_string_init(&fullname
);
556 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
557 path
= fullname
.data
;
559 /* Determine the security model */
560 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
561 buffer
= rpath(fs_ctx
, path
);
562 err
= mkdir(buffer
, SM_LOCAL_DIR_MODE_BITS
);
567 credp
->fc_mode
= credp
->fc_mode
|S_IFDIR
;
568 err
= local_set_xattr(buffer
, credp
);
573 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
574 buffer
= rpath(fs_ctx
, path
);
575 err
= mkdir(buffer
, SM_LOCAL_DIR_MODE_BITS
);
580 credp
->fc_mode
= credp
->fc_mode
|S_IFDIR
;
581 err
= local_set_mapped_file_attr(fs_ctx
, path
, credp
);
586 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
587 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
588 buffer
= rpath(fs_ctx
, path
);
589 err
= mkdir(buffer
, credp
->fc_mode
);
594 err
= local_post_create_passthrough(fs_ctx
, path
, credp
);
607 v9fs_string_free(&fullname
);
611 static int local_fstat(FsContext
*fs_ctx
, int fid_type
,
612 V9fsFidOpenState
*fs
, struct stat
*stbuf
)
616 if (fid_type
== P9_FID_DIR
) {
622 err
= fstat(fd
, stbuf
);
626 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
627 /* Actual credentials are part of extended attrs */
633 if (fgetxattr(fd
, "user.virtfs.uid",
634 &tmp_uid
, sizeof(uid_t
)) > 0) {
635 stbuf
->st_uid
= tmp_uid
;
637 if (fgetxattr(fd
, "user.virtfs.gid",
638 &tmp_gid
, sizeof(gid_t
)) > 0) {
639 stbuf
->st_gid
= tmp_gid
;
641 if (fgetxattr(fd
, "user.virtfs.mode",
642 &tmp_mode
, sizeof(mode_t
)) > 0) {
643 stbuf
->st_mode
= tmp_mode
;
645 if (fgetxattr(fd
, "user.virtfs.rdev",
646 &tmp_dev
, sizeof(dev_t
)) > 0) {
647 stbuf
->st_rdev
= tmp_dev
;
649 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
656 static int local_open2(FsContext
*fs_ctx
, V9fsPath
*dir_path
, const char *name
,
657 int flags
, FsCred
*credp
, V9fsFidOpenState
*fs
)
667 * Mark all the open to not follow symlinks
671 v9fs_string_init(&fullname
);
672 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
673 path
= fullname
.data
;
675 /* Determine the security model */
676 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
677 buffer
= rpath(fs_ctx
, path
);
678 fd
= open(buffer
, flags
, SM_LOCAL_MODE_BITS
);
684 credp
->fc_mode
= credp
->fc_mode
|S_IFREG
;
685 /* Set cleint credentials in xattr */
686 err
= local_set_xattr(buffer
, credp
);
691 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
692 buffer
= rpath(fs_ctx
, path
);
693 fd
= open(buffer
, flags
, SM_LOCAL_MODE_BITS
);
699 credp
->fc_mode
= credp
->fc_mode
|S_IFREG
;
700 /* Set client credentials in .virtfs_metadata directory files */
701 err
= local_set_mapped_file_attr(fs_ctx
, path
, credp
);
706 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
707 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
708 buffer
= rpath(fs_ctx
, path
);
709 fd
= open(buffer
, flags
, credp
->fc_mode
);
715 err
= local_post_create_passthrough(fs_ctx
, path
, credp
);
731 v9fs_string_free(&fullname
);
736 static int local_symlink(FsContext
*fs_ctx
, const char *oldpath
,
737 V9fsPath
*dir_path
, const char *name
, FsCred
*credp
)
745 v9fs_string_init(&fullname
);
746 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
747 newpath
= fullname
.data
;
749 /* Determine the security model */
750 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
752 ssize_t oldpath_size
, write_size
;
753 buffer
= rpath(fs_ctx
, newpath
);
754 fd
= open(buffer
, O_CREAT
|O_EXCL
|O_RDWR
|O_NOFOLLOW
, SM_LOCAL_MODE_BITS
);
760 /* Write the oldpath (target) to the file. */
761 oldpath_size
= strlen(oldpath
);
763 write_size
= write(fd
, (void *)oldpath
, oldpath_size
);
764 } while (write_size
== -1 && errno
== EINTR
);
766 if (write_size
!= oldpath_size
) {
773 /* Set cleint credentials in symlink's xattr */
774 credp
->fc_mode
= credp
->fc_mode
|S_IFLNK
;
775 err
= local_set_xattr(buffer
, credp
);
780 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
782 ssize_t oldpath_size
, write_size
;
783 buffer
= rpath(fs_ctx
, newpath
);
784 fd
= open(buffer
, O_CREAT
|O_EXCL
|O_RDWR
|O_NOFOLLOW
, SM_LOCAL_MODE_BITS
);
790 /* Write the oldpath (target) to the file. */
791 oldpath_size
= strlen(oldpath
);
793 write_size
= write(fd
, (void *)oldpath
, oldpath_size
);
794 } while (write_size
== -1 && errno
== EINTR
);
796 if (write_size
!= oldpath_size
) {
803 /* Set cleint credentials in symlink's xattr */
804 credp
->fc_mode
= credp
->fc_mode
|S_IFLNK
;
805 err
= local_set_mapped_file_attr(fs_ctx
, newpath
, credp
);
810 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
811 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
812 buffer
= rpath(fs_ctx
, newpath
);
813 err
= symlink(oldpath
, buffer
);
818 err
= lchown(buffer
, credp
->fc_uid
, credp
->fc_gid
);
821 * If we fail to change ownership and if we are
822 * using security model none. Ignore the error
824 if ((fs_ctx
->export_flags
& V9FS_SEC_MASK
) != V9FS_SM_NONE
) {
838 v9fs_string_free(&fullname
);
842 static int local_link(FsContext
*ctx
, V9fsPath
*oldpath
,
843 V9fsPath
*dirpath
, const char *name
)
847 char *buffer
, *buffer1
;
849 v9fs_string_init(&newpath
);
850 v9fs_string_sprintf(&newpath
, "%s/%s", dirpath
->data
, name
);
852 buffer
= rpath(ctx
, oldpath
->data
);
853 buffer1
= rpath(ctx
, newpath
.data
);
854 ret
= link(buffer
, buffer1
);
858 /* now link the virtfs_metadata files */
859 if (!ret
&& (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
)) {
860 /* Link the .virtfs_metadata files. Create the metada directory */
861 ret
= local_create_mapped_attr_dir(ctx
, newpath
.data
);
865 buffer
= local_mapped_attr_path(ctx
, oldpath
->data
);
866 buffer1
= local_mapped_attr_path(ctx
, newpath
.data
);
867 ret
= link(buffer
, buffer1
);
870 if (ret
< 0 && errno
!= ENOENT
) {
875 v9fs_string_free(&newpath
);
879 static int local_truncate(FsContext
*ctx
, V9fsPath
*fs_path
, off_t size
)
883 char *path
= fs_path
->data
;
885 buffer
= rpath(ctx
, path
);
886 ret
= truncate(buffer
, size
);
891 static int local_rename(FsContext
*ctx
, const char *oldpath
,
895 char *buffer
, *buffer1
;
897 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
898 err
= local_create_mapped_attr_dir(ctx
, newpath
);
902 /* rename the .virtfs_metadata files */
903 buffer
= local_mapped_attr_path(ctx
, oldpath
);
904 buffer1
= local_mapped_attr_path(ctx
, newpath
);
905 err
= rename(buffer
, buffer1
);
908 if (err
< 0 && errno
!= ENOENT
) {
913 buffer
= rpath(ctx
, oldpath
);
914 buffer1
= rpath(ctx
, newpath
);
915 err
= rename(buffer
, buffer1
);
921 static int local_chown(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
925 char *path
= fs_path
->data
;
927 if ((credp
->fc_uid
== -1 && credp
->fc_gid
== -1) ||
928 (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
929 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
930 buffer
= rpath(fs_ctx
, path
);
931 ret
= lchown(buffer
, credp
->fc_uid
, credp
->fc_gid
);
933 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
934 buffer
= rpath(fs_ctx
, path
);
935 ret
= local_set_xattr(buffer
, credp
);
937 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
938 return local_set_mapped_file_attr(fs_ctx
, path
, credp
);
943 static int local_utimensat(FsContext
*s
, V9fsPath
*fs_path
,
944 const struct timespec
*buf
)
948 char *path
= fs_path
->data
;
950 buffer
= rpath(s
, path
);
951 ret
= qemu_utimens(buffer
, buf
);
956 static int local_remove(FsContext
*ctx
, const char *path
)
962 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
963 buffer
= rpath(ctx
, path
);
964 err
= lstat(buffer
, &stbuf
);
970 * If directory remove .virtfs_metadata contained in the
973 if (S_ISDIR(stbuf
.st_mode
)) {
974 buffer
= g_strdup_printf("%s/%s/%s", ctx
->fs_root
,
975 path
, VIRTFS_META_DIR
);
976 err
= remove(buffer
);
978 if (err
< 0 && errno
!= ENOENT
) {
980 * We didn't had the .virtfs_metadata file. May be file created
981 * in non-mapped mode ?. Ignore ENOENT.
987 * Now remove the name from parent directory
988 * .virtfs_metadata directory
990 buffer
= local_mapped_attr_path(ctx
, path
);
991 err
= remove(buffer
);
993 if (err
< 0 && errno
!= ENOENT
) {
995 * We didn't had the .virtfs_metadata file. May be file created
996 * in non-mapped mode ?. Ignore ENOENT.
1002 buffer
= rpath(ctx
, path
);
1003 err
= remove(buffer
);
1009 static int local_fsync(FsContext
*ctx
, int fid_type
,
1010 V9fsFidOpenState
*fs
, int datasync
)
1014 if (fid_type
== P9_FID_DIR
) {
1015 fd
= dirfd(fs
->dir
);
1021 return qemu_fdatasync(fd
);
1027 static int local_statfs(FsContext
*s
, V9fsPath
*fs_path
, struct statfs
*stbuf
)
1031 char *path
= fs_path
->data
;
1033 buffer
= rpath(s
, path
);
1034 ret
= statfs(buffer
, stbuf
);
1039 static ssize_t
local_lgetxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1040 const char *name
, void *value
, size_t size
)
1042 char *path
= fs_path
->data
;
1044 return v9fs_get_xattr(ctx
, path
, name
, value
, size
);
1047 static ssize_t
local_llistxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1048 void *value
, size_t size
)
1050 char *path
= fs_path
->data
;
1052 return v9fs_list_xattr(ctx
, path
, value
, size
);
1055 static int local_lsetxattr(FsContext
*ctx
, V9fsPath
*fs_path
, const char *name
,
1056 void *value
, size_t size
, int flags
)
1058 char *path
= fs_path
->data
;
1060 return v9fs_set_xattr(ctx
, path
, name
, value
, size
, flags
);
1063 static int local_lremovexattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1066 char *path
= fs_path
->data
;
1068 return v9fs_remove_xattr(ctx
, path
, name
);
1071 static int local_name_to_path(FsContext
*ctx
, V9fsPath
*dir_path
,
1072 const char *name
, V9fsPath
*target
)
1075 v9fs_string_sprintf((V9fsString
*)target
, "%s/%s",
1076 dir_path
->data
, name
);
1078 v9fs_string_sprintf((V9fsString
*)target
, "%s", name
);
1080 /* Bump the size for including terminating NULL */
1085 static int local_renameat(FsContext
*ctx
, V9fsPath
*olddir
,
1086 const char *old_name
, V9fsPath
*newdir
,
1087 const char *new_name
)
1090 V9fsString old_full_name
, new_full_name
;
1092 v9fs_string_init(&old_full_name
);
1093 v9fs_string_init(&new_full_name
);
1095 v9fs_string_sprintf(&old_full_name
, "%s/%s", olddir
->data
, old_name
);
1096 v9fs_string_sprintf(&new_full_name
, "%s/%s", newdir
->data
, new_name
);
1098 ret
= local_rename(ctx
, old_full_name
.data
, new_full_name
.data
);
1099 v9fs_string_free(&old_full_name
);
1100 v9fs_string_free(&new_full_name
);
1104 static int local_unlinkat(FsContext
*ctx
, V9fsPath
*dir
,
1105 const char *name
, int flags
)
1108 V9fsString fullname
;
1111 v9fs_string_init(&fullname
);
1113 v9fs_string_sprintf(&fullname
, "%s/%s", dir
->data
, name
);
1114 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
1115 if (flags
== AT_REMOVEDIR
) {
1117 * If directory remove .virtfs_metadata contained in the
1120 buffer
= g_strdup_printf("%s/%s/%s", ctx
->fs_root
,
1121 fullname
.data
, VIRTFS_META_DIR
);
1122 ret
= remove(buffer
);
1124 if (ret
< 0 && errno
!= ENOENT
) {
1126 * We didn't had the .virtfs_metadata file. May be file created
1127 * in non-mapped mode ?. Ignore ENOENT.
1133 * Now remove the name from parent directory
1134 * .virtfs_metadata directory.
1136 buffer
= local_mapped_attr_path(ctx
, fullname
.data
);
1137 ret
= remove(buffer
);
1139 if (ret
< 0 && errno
!= ENOENT
) {
1141 * We didn't had the .virtfs_metadata file. May be file created
1142 * in non-mapped mode ?. Ignore ENOENT.
1147 /* Remove the name finally */
1148 buffer
= rpath(ctx
, fullname
.data
);
1149 ret
= remove(buffer
);
1153 v9fs_string_free(&fullname
);
1157 static int local_ioc_getversion(FsContext
*ctx
, V9fsPath
*path
,
1158 mode_t st_mode
, uint64_t *st_gen
)
1160 #ifdef FS_IOC_GETVERSION
1162 V9fsFidOpenState fid_open
;
1165 * Do not try to open special files like device nodes, fifos etc
1166 * We can get fd for regular files and directories only
1168 if (!S_ISREG(st_mode
) && !S_ISDIR(st_mode
)) {
1172 err
= local_open(ctx
, path
, O_RDONLY
, &fid_open
);
1176 err
= ioctl(fid_open
.fd
, FS_IOC_GETVERSION
, st_gen
);
1177 local_close(ctx
, &fid_open
);
1185 static int local_init(FsContext
*ctx
)
1188 struct statfs stbuf
;
1190 if (ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) {
1191 ctx
->xops
= passthrough_xattr_ops
;
1192 } else if (ctx
->export_flags
& V9FS_SM_MAPPED
) {
1193 ctx
->xops
= mapped_xattr_ops
;
1194 } else if (ctx
->export_flags
& V9FS_SM_NONE
) {
1195 ctx
->xops
= none_xattr_ops
;
1196 } else if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
1198 * xattr operation for mapped-file and passthrough
1201 ctx
->xops
= passthrough_xattr_ops
;
1203 ctx
->export_flags
|= V9FS_PATHNAME_FSCONTEXT
;
1204 #ifdef FS_IOC_GETVERSION
1206 * use ioc_getversion only if the iocl is definied
1208 err
= statfs(ctx
->fs_root
, &stbuf
);
1210 switch (stbuf
.f_type
) {
1211 case EXT2_SUPER_MAGIC
:
1212 case BTRFS_SUPER_MAGIC
:
1213 case REISERFS_SUPER_MAGIC
:
1214 case XFS_SUPER_MAGIC
:
1215 ctx
->exops
.get_st_gen
= local_ioc_getversion
;
1223 static int local_parse_opts(QemuOpts
*opts
, struct FsDriverEntry
*fse
)
1225 const char *sec_model
= qemu_opt_get(opts
, "security_model");
1226 const char *path
= qemu_opt_get(opts
, "path");
1229 fprintf(stderr
, "security model not specified, "
1230 "local fs needs security model\nvalid options are:"
1231 "\tsecurity_model=[passthrough|mapped|none]\n");
1235 if (!strcmp(sec_model
, "passthrough")) {
1236 fse
->export_flags
|= V9FS_SM_PASSTHROUGH
;
1237 } else if (!strcmp(sec_model
, "mapped") ||
1238 !strcmp(sec_model
, "mapped-xattr")) {
1239 fse
->export_flags
|= V9FS_SM_MAPPED
;
1240 } else if (!strcmp(sec_model
, "none")) {
1241 fse
->export_flags
|= V9FS_SM_NONE
;
1242 } else if (!strcmp(sec_model
, "mapped-file")) {
1243 fse
->export_flags
|= V9FS_SM_MAPPED_FILE
;
1245 fprintf(stderr
, "Invalid security model %s specified, valid options are"
1246 "\n\t [passthrough|mapped-xattr|mapped-file|none]\n",
1252 fprintf(stderr
, "fsdev: No path specified.\n");
1255 fse
->path
= g_strdup(path
);
1260 FileOperations local_ops
= {
1261 .parse_opts
= local_parse_opts
,
1263 .lstat
= local_lstat
,
1264 .readlink
= local_readlink
,
1265 .close
= local_close
,
1266 .closedir
= local_closedir
,
1268 .opendir
= local_opendir
,
1269 .rewinddir
= local_rewinddir
,
1270 .telldir
= local_telldir
,
1271 .readdir_r
= local_readdir_r
,
1272 .seekdir
= local_seekdir
,
1273 .preadv
= local_preadv
,
1274 .pwritev
= local_pwritev
,
1275 .chmod
= local_chmod
,
1276 .mknod
= local_mknod
,
1277 .mkdir
= local_mkdir
,
1278 .fstat
= local_fstat
,
1279 .open2
= local_open2
,
1280 .symlink
= local_symlink
,
1282 .truncate
= local_truncate
,
1283 .rename
= local_rename
,
1284 .chown
= local_chown
,
1285 .utimensat
= local_utimensat
,
1286 .remove
= local_remove
,
1287 .fsync
= local_fsync
,
1288 .statfs
= local_statfs
,
1289 .lgetxattr
= local_lgetxattr
,
1290 .llistxattr
= local_llistxattr
,
1291 .lsetxattr
= local_lsetxattr
,
1292 .lremovexattr
= local_lremovexattr
,
1293 .name_to_path
= local_name_to_path
,
1294 .renameat
= local_renameat
,
1295 .unlinkat
= local_unlinkat
,