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
= le32_to_cpu(tmp_uid
);
140 if (getxattr(buffer
, "user.virtfs.gid", &tmp_gid
, sizeof(gid_t
)) > 0) {
141 stbuf
->st_gid
= le32_to_cpu(tmp_gid
);
143 if (getxattr(buffer
, "user.virtfs.mode",
144 &tmp_mode
, sizeof(mode_t
)) > 0) {
145 stbuf
->st_mode
= le32_to_cpu(tmp_mode
);
147 if (getxattr(buffer
, "user.virtfs.rdev", &tmp_dev
, sizeof(dev_t
)) > 0) {
148 stbuf
->st_rdev
= le64_to_cpu(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 uint32_t tmp_uid
= cpu_to_le32(credp
->fc_uid
);
259 err
= setxattr(path
, "user.virtfs.uid", &tmp_uid
, sizeof(uid_t
), 0);
264 if (credp
->fc_gid
!= -1) {
265 uint32_t tmp_gid
= cpu_to_le32(credp
->fc_gid
);
266 err
= setxattr(path
, "user.virtfs.gid", &tmp_gid
, sizeof(gid_t
), 0);
271 if (credp
->fc_mode
!= -1) {
272 uint32_t tmp_mode
= cpu_to_le32(credp
->fc_mode
);
273 err
= setxattr(path
, "user.virtfs.mode", &tmp_mode
, sizeof(mode_t
), 0);
278 if (credp
->fc_rdev
!= -1) {
279 uint64_t tmp_rdev
= cpu_to_le64(credp
->fc_rdev
);
280 err
= setxattr(path
, "user.virtfs.rdev", &tmp_rdev
, sizeof(dev_t
), 0);
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
);
335 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
336 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
337 buffer
= rpath(fs_ctx
, path
);
338 tsize
= readlink(buffer
, buf
, bufsz
);
344 static int local_close(FsContext
*ctx
, V9fsFidOpenState
*fs
)
346 return close(fs
->fd
);
349 static int local_closedir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
351 return closedir(fs
->dir
);
354 static int local_open(FsContext
*ctx
, V9fsPath
*fs_path
,
355 int flags
, V9fsFidOpenState
*fs
)
358 char *path
= fs_path
->data
;
360 buffer
= rpath(ctx
, path
);
361 fs
->fd
= open(buffer
, flags
| O_NOFOLLOW
);
366 static int local_opendir(FsContext
*ctx
,
367 V9fsPath
*fs_path
, V9fsFidOpenState
*fs
)
370 char *path
= fs_path
->data
;
372 buffer
= rpath(ctx
, path
);
373 fs
->dir
= opendir(buffer
);
381 static void local_rewinddir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
383 return rewinddir(fs
->dir
);
386 static off_t
local_telldir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
388 return telldir(fs
->dir
);
391 static int local_readdir_r(FsContext
*ctx
, V9fsFidOpenState
*fs
,
392 struct dirent
*entry
,
393 struct dirent
**result
)
398 ret
= readdir_r(fs
->dir
, entry
, result
);
399 if (ctx
->export_flags
& V9FS_SM_MAPPED
) {
400 entry
->d_type
= DT_UNKNOWN
;
401 } else if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
402 if (!ret
&& *result
!= NULL
&&
403 !strcmp(entry
->d_name
, VIRTFS_META_DIR
)) {
404 /* skp the meta data directory */
407 entry
->d_type
= DT_UNKNOWN
;
412 static void local_seekdir(FsContext
*ctx
, V9fsFidOpenState
*fs
, off_t off
)
414 return seekdir(fs
->dir
, off
);
417 static ssize_t
local_preadv(FsContext
*ctx
, V9fsFidOpenState
*fs
,
418 const struct iovec
*iov
,
419 int iovcnt
, off_t offset
)
422 return preadv(fs
->fd
, iov
, iovcnt
, offset
);
424 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
428 return readv(fs
->fd
, iov
, iovcnt
);
433 static ssize_t
local_pwritev(FsContext
*ctx
, V9fsFidOpenState
*fs
,
434 const struct iovec
*iov
,
435 int iovcnt
, off_t offset
)
440 ret
= pwritev(fs
->fd
, iov
, iovcnt
, offset
);
442 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
446 ret
= writev(fs
->fd
, iov
, iovcnt
);
449 #ifdef CONFIG_SYNC_FILE_RANGE
450 if (ret
> 0 && ctx
->export_flags
& V9FS_IMMEDIATE_WRITEOUT
) {
452 * Initiate a writeback. This is not a data integrity sync.
453 * We want to ensure that we don't leave dirty pages in the cache
454 * after write when writeout=immediate is sepcified.
456 sync_file_range(fs
->fd
, offset
, ret
,
457 SYNC_FILE_RANGE_WAIT_BEFORE
| SYNC_FILE_RANGE_WRITE
);
463 static int local_chmod(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
467 char *path
= fs_path
->data
;
469 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
470 buffer
= rpath(fs_ctx
, path
);
471 ret
= local_set_xattr(buffer
, credp
);
473 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
474 return local_set_mapped_file_attr(fs_ctx
, path
, credp
);
475 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
476 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
477 buffer
= rpath(fs_ctx
, path
);
478 ret
= chmod(buffer
, credp
->fc_mode
);
484 static int local_mknod(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
485 const char *name
, FsCred
*credp
)
493 v9fs_string_init(&fullname
);
494 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
495 path
= fullname
.data
;
497 /* Determine the security model */
498 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
499 buffer
= rpath(fs_ctx
, path
);
500 err
= mknod(buffer
, SM_LOCAL_MODE_BITS
|S_IFREG
, 0);
505 err
= local_set_xattr(buffer
, credp
);
510 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
512 buffer
= rpath(fs_ctx
, path
);
513 err
= mknod(buffer
, SM_LOCAL_MODE_BITS
|S_IFREG
, 0);
518 err
= local_set_mapped_file_attr(fs_ctx
, path
, credp
);
523 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
524 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
525 buffer
= rpath(fs_ctx
, path
);
526 err
= mknod(buffer
, credp
->fc_mode
, credp
->fc_rdev
);
531 err
= local_post_create_passthrough(fs_ctx
, path
, credp
);
544 v9fs_string_free(&fullname
);
548 static int local_mkdir(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
549 const char *name
, FsCred
*credp
)
557 v9fs_string_init(&fullname
);
558 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
559 path
= fullname
.data
;
561 /* Determine the security model */
562 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
563 buffer
= rpath(fs_ctx
, path
);
564 err
= mkdir(buffer
, SM_LOCAL_DIR_MODE_BITS
);
569 credp
->fc_mode
= credp
->fc_mode
|S_IFDIR
;
570 err
= local_set_xattr(buffer
, credp
);
575 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
576 buffer
= rpath(fs_ctx
, path
);
577 err
= mkdir(buffer
, SM_LOCAL_DIR_MODE_BITS
);
582 credp
->fc_mode
= credp
->fc_mode
|S_IFDIR
;
583 err
= local_set_mapped_file_attr(fs_ctx
, path
, credp
);
588 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
589 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
590 buffer
= rpath(fs_ctx
, path
);
591 err
= mkdir(buffer
, credp
->fc_mode
);
596 err
= local_post_create_passthrough(fs_ctx
, path
, credp
);
609 v9fs_string_free(&fullname
);
613 static int local_fstat(FsContext
*fs_ctx
, int fid_type
,
614 V9fsFidOpenState
*fs
, struct stat
*stbuf
)
618 if (fid_type
== P9_FID_DIR
) {
624 err
= fstat(fd
, stbuf
);
628 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
629 /* Actual credentials are part of extended attrs */
635 if (fgetxattr(fd
, "user.virtfs.uid", &tmp_uid
, sizeof(uid_t
)) > 0) {
636 stbuf
->st_uid
= le32_to_cpu(tmp_uid
);
638 if (fgetxattr(fd
, "user.virtfs.gid", &tmp_gid
, sizeof(gid_t
)) > 0) {
639 stbuf
->st_gid
= le32_to_cpu(tmp_gid
);
641 if (fgetxattr(fd
, "user.virtfs.mode", &tmp_mode
, sizeof(mode_t
)) > 0) {
642 stbuf
->st_mode
= le32_to_cpu(tmp_mode
);
644 if (fgetxattr(fd
, "user.virtfs.rdev", &tmp_dev
, sizeof(dev_t
)) > 0) {
645 stbuf
->st_rdev
= le64_to_cpu(tmp_dev
);
647 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
654 static int local_open2(FsContext
*fs_ctx
, V9fsPath
*dir_path
, const char *name
,
655 int flags
, FsCred
*credp
, V9fsFidOpenState
*fs
)
665 * Mark all the open to not follow symlinks
669 v9fs_string_init(&fullname
);
670 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
671 path
= fullname
.data
;
673 /* Determine the security model */
674 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
675 buffer
= rpath(fs_ctx
, path
);
676 fd
= open(buffer
, flags
, SM_LOCAL_MODE_BITS
);
682 credp
->fc_mode
= credp
->fc_mode
|S_IFREG
;
683 /* Set cleint credentials in xattr */
684 err
= local_set_xattr(buffer
, credp
);
689 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
690 buffer
= rpath(fs_ctx
, path
);
691 fd
= open(buffer
, flags
, SM_LOCAL_MODE_BITS
);
697 credp
->fc_mode
= credp
->fc_mode
|S_IFREG
;
698 /* Set client credentials in .virtfs_metadata directory files */
699 err
= local_set_mapped_file_attr(fs_ctx
, path
, credp
);
704 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
705 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
706 buffer
= rpath(fs_ctx
, path
);
707 fd
= open(buffer
, flags
, credp
->fc_mode
);
713 err
= local_post_create_passthrough(fs_ctx
, path
, credp
);
729 v9fs_string_free(&fullname
);
734 static int local_symlink(FsContext
*fs_ctx
, const char *oldpath
,
735 V9fsPath
*dir_path
, const char *name
, FsCred
*credp
)
743 v9fs_string_init(&fullname
);
744 v9fs_string_sprintf(&fullname
, "%s/%s", dir_path
->data
, name
);
745 newpath
= fullname
.data
;
747 /* Determine the security model */
748 if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
750 ssize_t oldpath_size
, write_size
;
751 buffer
= rpath(fs_ctx
, newpath
);
752 fd
= open(buffer
, O_CREAT
|O_EXCL
|O_RDWR
|O_NOFOLLOW
, SM_LOCAL_MODE_BITS
);
758 /* Write the oldpath (target) to the file. */
759 oldpath_size
= strlen(oldpath
);
761 write_size
= write(fd
, (void *)oldpath
, oldpath_size
);
762 } while (write_size
== -1 && errno
== EINTR
);
764 if (write_size
!= oldpath_size
) {
771 /* Set cleint credentials in symlink's xattr */
772 credp
->fc_mode
= credp
->fc_mode
|S_IFLNK
;
773 err
= local_set_xattr(buffer
, credp
);
778 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
780 ssize_t oldpath_size
, write_size
;
781 buffer
= rpath(fs_ctx
, newpath
);
782 fd
= open(buffer
, O_CREAT
|O_EXCL
|O_RDWR
|O_NOFOLLOW
, SM_LOCAL_MODE_BITS
);
788 /* Write the oldpath (target) to the file. */
789 oldpath_size
= strlen(oldpath
);
791 write_size
= write(fd
, (void *)oldpath
, oldpath_size
);
792 } while (write_size
== -1 && errno
== EINTR
);
794 if (write_size
!= oldpath_size
) {
801 /* Set cleint credentials in symlink's xattr */
802 credp
->fc_mode
= credp
->fc_mode
|S_IFLNK
;
803 err
= local_set_mapped_file_attr(fs_ctx
, newpath
, credp
);
808 } else if ((fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
809 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
810 buffer
= rpath(fs_ctx
, newpath
);
811 err
= symlink(oldpath
, buffer
);
816 err
= lchown(buffer
, credp
->fc_uid
, credp
->fc_gid
);
819 * If we fail to change ownership and if we are
820 * using security model none. Ignore the error
822 if ((fs_ctx
->export_flags
& V9FS_SEC_MASK
) != V9FS_SM_NONE
) {
836 v9fs_string_free(&fullname
);
840 static int local_link(FsContext
*ctx
, V9fsPath
*oldpath
,
841 V9fsPath
*dirpath
, const char *name
)
845 char *buffer
, *buffer1
;
847 v9fs_string_init(&newpath
);
848 v9fs_string_sprintf(&newpath
, "%s/%s", dirpath
->data
, name
);
850 buffer
= rpath(ctx
, oldpath
->data
);
851 buffer1
= rpath(ctx
, newpath
.data
);
852 ret
= link(buffer
, buffer1
);
856 /* now link the virtfs_metadata files */
857 if (!ret
&& (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
)) {
858 /* Link the .virtfs_metadata files. Create the metada directory */
859 ret
= local_create_mapped_attr_dir(ctx
, newpath
.data
);
863 buffer
= local_mapped_attr_path(ctx
, oldpath
->data
);
864 buffer1
= local_mapped_attr_path(ctx
, newpath
.data
);
865 ret
= link(buffer
, buffer1
);
868 if (ret
< 0 && errno
!= ENOENT
) {
873 v9fs_string_free(&newpath
);
877 static int local_truncate(FsContext
*ctx
, V9fsPath
*fs_path
, off_t size
)
881 char *path
= fs_path
->data
;
883 buffer
= rpath(ctx
, path
);
884 ret
= truncate(buffer
, size
);
889 static int local_rename(FsContext
*ctx
, const char *oldpath
,
893 char *buffer
, *buffer1
;
895 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
896 err
= local_create_mapped_attr_dir(ctx
, newpath
);
900 /* rename the .virtfs_metadata files */
901 buffer
= local_mapped_attr_path(ctx
, oldpath
);
902 buffer1
= local_mapped_attr_path(ctx
, newpath
);
903 err
= rename(buffer
, buffer1
);
906 if (err
< 0 && errno
!= ENOENT
) {
911 buffer
= rpath(ctx
, oldpath
);
912 buffer1
= rpath(ctx
, newpath
);
913 err
= rename(buffer
, buffer1
);
919 static int local_chown(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
923 char *path
= fs_path
->data
;
925 if ((credp
->fc_uid
== -1 && credp
->fc_gid
== -1) ||
926 (fs_ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) ||
927 (fs_ctx
->export_flags
& V9FS_SM_NONE
)) {
928 buffer
= rpath(fs_ctx
, path
);
929 ret
= lchown(buffer
, credp
->fc_uid
, credp
->fc_gid
);
931 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED
) {
932 buffer
= rpath(fs_ctx
, path
);
933 ret
= local_set_xattr(buffer
, credp
);
935 } else if (fs_ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
936 return local_set_mapped_file_attr(fs_ctx
, path
, credp
);
941 static int local_utimensat(FsContext
*s
, V9fsPath
*fs_path
,
942 const struct timespec
*buf
)
946 char *path
= fs_path
->data
;
948 buffer
= rpath(s
, path
);
949 ret
= qemu_utimens(buffer
, buf
);
954 static int local_remove(FsContext
*ctx
, const char *path
)
960 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
961 buffer
= rpath(ctx
, path
);
962 err
= lstat(buffer
, &stbuf
);
968 * If directory remove .virtfs_metadata contained in the
971 if (S_ISDIR(stbuf
.st_mode
)) {
972 buffer
= g_strdup_printf("%s/%s/%s", ctx
->fs_root
,
973 path
, VIRTFS_META_DIR
);
974 err
= remove(buffer
);
976 if (err
< 0 && errno
!= ENOENT
) {
978 * We didn't had the .virtfs_metadata file. May be file created
979 * in non-mapped mode ?. Ignore ENOENT.
985 * Now remove the name from parent directory
986 * .virtfs_metadata directory
988 buffer
= local_mapped_attr_path(ctx
, path
);
989 err
= remove(buffer
);
991 if (err
< 0 && errno
!= ENOENT
) {
993 * We didn't had the .virtfs_metadata file. May be file created
994 * in non-mapped mode ?. Ignore ENOENT.
1000 buffer
= rpath(ctx
, path
);
1001 err
= remove(buffer
);
1007 static int local_fsync(FsContext
*ctx
, int fid_type
,
1008 V9fsFidOpenState
*fs
, int datasync
)
1012 if (fid_type
== P9_FID_DIR
) {
1013 fd
= dirfd(fs
->dir
);
1019 return qemu_fdatasync(fd
);
1025 static int local_statfs(FsContext
*s
, V9fsPath
*fs_path
, struct statfs
*stbuf
)
1029 char *path
= fs_path
->data
;
1031 buffer
= rpath(s
, path
);
1032 ret
= statfs(buffer
, stbuf
);
1037 static ssize_t
local_lgetxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1038 const char *name
, void *value
, size_t size
)
1040 char *path
= fs_path
->data
;
1042 return v9fs_get_xattr(ctx
, path
, name
, value
, size
);
1045 static ssize_t
local_llistxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1046 void *value
, size_t size
)
1048 char *path
= fs_path
->data
;
1050 return v9fs_list_xattr(ctx
, path
, value
, size
);
1053 static int local_lsetxattr(FsContext
*ctx
, V9fsPath
*fs_path
, const char *name
,
1054 void *value
, size_t size
, int flags
)
1056 char *path
= fs_path
->data
;
1058 return v9fs_set_xattr(ctx
, path
, name
, value
, size
, flags
);
1061 static int local_lremovexattr(FsContext
*ctx
, V9fsPath
*fs_path
,
1064 char *path
= fs_path
->data
;
1066 return v9fs_remove_xattr(ctx
, path
, name
);
1069 static int local_name_to_path(FsContext
*ctx
, V9fsPath
*dir_path
,
1070 const char *name
, V9fsPath
*target
)
1073 v9fs_string_sprintf((V9fsString
*)target
, "%s/%s",
1074 dir_path
->data
, name
);
1076 v9fs_string_sprintf((V9fsString
*)target
, "%s", name
);
1078 /* Bump the size for including terminating NULL */
1083 static int local_renameat(FsContext
*ctx
, V9fsPath
*olddir
,
1084 const char *old_name
, V9fsPath
*newdir
,
1085 const char *new_name
)
1088 V9fsString old_full_name
, new_full_name
;
1090 v9fs_string_init(&old_full_name
);
1091 v9fs_string_init(&new_full_name
);
1093 v9fs_string_sprintf(&old_full_name
, "%s/%s", olddir
->data
, old_name
);
1094 v9fs_string_sprintf(&new_full_name
, "%s/%s", newdir
->data
, new_name
);
1096 ret
= local_rename(ctx
, old_full_name
.data
, new_full_name
.data
);
1097 v9fs_string_free(&old_full_name
);
1098 v9fs_string_free(&new_full_name
);
1102 static int local_unlinkat(FsContext
*ctx
, V9fsPath
*dir
,
1103 const char *name
, int flags
)
1106 V9fsString fullname
;
1109 v9fs_string_init(&fullname
);
1111 v9fs_string_sprintf(&fullname
, "%s/%s", dir
->data
, name
);
1112 if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
1113 if (flags
== AT_REMOVEDIR
) {
1115 * If directory remove .virtfs_metadata contained in the
1118 buffer
= g_strdup_printf("%s/%s/%s", ctx
->fs_root
,
1119 fullname
.data
, VIRTFS_META_DIR
);
1120 ret
= remove(buffer
);
1122 if (ret
< 0 && errno
!= ENOENT
) {
1124 * We didn't had the .virtfs_metadata file. May be file created
1125 * in non-mapped mode ?. Ignore ENOENT.
1131 * Now remove the name from parent directory
1132 * .virtfs_metadata directory.
1134 buffer
= local_mapped_attr_path(ctx
, fullname
.data
);
1135 ret
= remove(buffer
);
1137 if (ret
< 0 && errno
!= ENOENT
) {
1139 * We didn't had the .virtfs_metadata file. May be file created
1140 * in non-mapped mode ?. Ignore ENOENT.
1145 /* Remove the name finally */
1146 buffer
= rpath(ctx
, fullname
.data
);
1147 ret
= remove(buffer
);
1151 v9fs_string_free(&fullname
);
1155 static int local_ioc_getversion(FsContext
*ctx
, V9fsPath
*path
,
1156 mode_t st_mode
, uint64_t *st_gen
)
1158 #ifdef FS_IOC_GETVERSION
1160 V9fsFidOpenState fid_open
;
1163 * Do not try to open special files like device nodes, fifos etc
1164 * We can get fd for regular files and directories only
1166 if (!S_ISREG(st_mode
) && !S_ISDIR(st_mode
)) {
1170 err
= local_open(ctx
, path
, O_RDONLY
, &fid_open
);
1174 err
= ioctl(fid_open
.fd
, FS_IOC_GETVERSION
, st_gen
);
1175 local_close(ctx
, &fid_open
);
1183 static int local_init(FsContext
*ctx
)
1186 struct statfs stbuf
;
1188 if (ctx
->export_flags
& V9FS_SM_PASSTHROUGH
) {
1189 ctx
->xops
= passthrough_xattr_ops
;
1190 } else if (ctx
->export_flags
& V9FS_SM_MAPPED
) {
1191 ctx
->xops
= mapped_xattr_ops
;
1192 } else if (ctx
->export_flags
& V9FS_SM_NONE
) {
1193 ctx
->xops
= none_xattr_ops
;
1194 } else if (ctx
->export_flags
& V9FS_SM_MAPPED_FILE
) {
1196 * xattr operation for mapped-file and passthrough
1199 ctx
->xops
= passthrough_xattr_ops
;
1201 ctx
->export_flags
|= V9FS_PATHNAME_FSCONTEXT
;
1202 #ifdef FS_IOC_GETVERSION
1204 * use ioc_getversion only if the iocl is definied
1206 err
= statfs(ctx
->fs_root
, &stbuf
);
1208 switch (stbuf
.f_type
) {
1209 case EXT2_SUPER_MAGIC
:
1210 case BTRFS_SUPER_MAGIC
:
1211 case REISERFS_SUPER_MAGIC
:
1212 case XFS_SUPER_MAGIC
:
1213 ctx
->exops
.get_st_gen
= local_ioc_getversion
;
1221 static int local_parse_opts(QemuOpts
*opts
, struct FsDriverEntry
*fse
)
1223 const char *sec_model
= qemu_opt_get(opts
, "security_model");
1224 const char *path
= qemu_opt_get(opts
, "path");
1227 fprintf(stderr
, "security model not specified, "
1228 "local fs needs security model\nvalid options are:"
1229 "\tsecurity_model=[passthrough|mapped|none]\n");
1233 if (!strcmp(sec_model
, "passthrough")) {
1234 fse
->export_flags
|= V9FS_SM_PASSTHROUGH
;
1235 } else if (!strcmp(sec_model
, "mapped") ||
1236 !strcmp(sec_model
, "mapped-xattr")) {
1237 fse
->export_flags
|= V9FS_SM_MAPPED
;
1238 } else if (!strcmp(sec_model
, "none")) {
1239 fse
->export_flags
|= V9FS_SM_NONE
;
1240 } else if (!strcmp(sec_model
, "mapped-file")) {
1241 fse
->export_flags
|= V9FS_SM_MAPPED_FILE
;
1243 fprintf(stderr
, "Invalid security model %s specified, valid options are"
1244 "\n\t [passthrough|mapped-xattr|mapped-file|none]\n",
1250 fprintf(stderr
, "fsdev: No path specified.\n");
1253 fse
->path
= g_strdup(path
);
1258 FileOperations local_ops
= {
1259 .parse_opts
= local_parse_opts
,
1261 .lstat
= local_lstat
,
1262 .readlink
= local_readlink
,
1263 .close
= local_close
,
1264 .closedir
= local_closedir
,
1266 .opendir
= local_opendir
,
1267 .rewinddir
= local_rewinddir
,
1268 .telldir
= local_telldir
,
1269 .readdir_r
= local_readdir_r
,
1270 .seekdir
= local_seekdir
,
1271 .preadv
= local_preadv
,
1272 .pwritev
= local_pwritev
,
1273 .chmod
= local_chmod
,
1274 .mknod
= local_mknod
,
1275 .mkdir
= local_mkdir
,
1276 .fstat
= local_fstat
,
1277 .open2
= local_open2
,
1278 .symlink
= local_symlink
,
1280 .truncate
= local_truncate
,
1281 .rename
= local_rename
,
1282 .chown
= local_chown
,
1283 .utimensat
= local_utimensat
,
1284 .remove
= local_remove
,
1285 .fsync
= local_fsync
,
1286 .statfs
= local_statfs
,
1287 .lgetxattr
= local_lgetxattr
,
1288 .llistxattr
= local_llistxattr
,
1289 .lsetxattr
= local_lsetxattr
,
1290 .lremovexattr
= local_lremovexattr
,
1291 .name_to_path
= local_name_to_path
,
1292 .renameat
= local_renameat
,
1293 .unlinkat
= local_unlinkat
,