4 * Copyright IBM, Corp. 2011
7 * Aneesh Kumar K.V <aneesh.kumar@linux.vnet.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"
17 #include <arpa/inet.h>
20 #include <sys/socket.h>
22 #include "qapi/error.h"
23 #include "qemu/xattr.h"
24 #include "qemu/cutils.h"
25 #include "qemu/error-report.h"
26 #include "qemu/option.h"
28 #ifdef CONFIG_LINUX_MAGIC_H
29 #include <linux/magic.h>
31 #include <sys/ioctl.h>
33 #ifndef XFS_SUPER_MAGIC
34 #define XFS_SUPER_MAGIC 0x58465342
36 #ifndef EXT2_SUPER_MAGIC
37 #define EXT2_SUPER_MAGIC 0xEF53
39 #ifndef REISERFS_SUPER_MAGIC
40 #define REISERFS_SUPER_MAGIC 0x52654973
42 #ifndef BTRFS_SUPER_MAGIC
43 #define BTRFS_SUPER_MAGIC 0x9123683E
46 typedef struct HandleData
{
51 static inline int name_to_handle(int dirfd
, const char *name
,
52 struct file_handle
*fh
, int *mnt_id
, int flags
)
54 return name_to_handle_at(dirfd
, name
, fh
, mnt_id
, flags
);
57 static inline int open_by_handle(int mountfd
, const char *fh
, int flags
)
59 return open_by_handle_at(mountfd
, (struct file_handle
*)fh
, flags
);
62 static int handle_update_file_cred(int dirfd
, const char *name
, FsCred
*credp
)
65 fd
= openat(dirfd
, name
, O_NONBLOCK
| O_NOFOLLOW
);
69 ret
= fchownat(fd
, "", credp
->fc_uid
, credp
->fc_gid
, AT_EMPTY_PATH
);
73 ret
= fchmod(fd
, credp
->fc_mode
& 07777);
80 static int handle_lstat(FsContext
*fs_ctx
, V9fsPath
*fs_path
,
84 HandleData
*data
= (HandleData
*) fs_ctx
->private;
86 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_PATH
);
90 ret
= fstatat(fd
, "", stbuf
, AT_EMPTY_PATH
);
95 static ssize_t
handle_readlink(FsContext
*fs_ctx
, V9fsPath
*fs_path
,
96 char *buf
, size_t bufsz
)
99 HandleData
*data
= (HandleData
*) fs_ctx
->private;
101 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_PATH
);
105 ret
= readlinkat(fd
, "", buf
, bufsz
);
110 static int handle_close(FsContext
*ctx
, V9fsFidOpenState
*fs
)
112 return close(fs
->fd
);
115 static int handle_closedir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
117 return closedir(fs
->dir
.stream
);
120 static int handle_open(FsContext
*ctx
, V9fsPath
*fs_path
,
121 int flags
, V9fsFidOpenState
*fs
)
123 HandleData
*data
= (HandleData
*) ctx
->private;
125 fs
->fd
= open_by_handle(data
->mountfd
, fs_path
->data
, flags
);
129 static int handle_opendir(FsContext
*ctx
,
130 V9fsPath
*fs_path
, V9fsFidOpenState
*fs
)
133 ret
= handle_open(ctx
, fs_path
, O_DIRECTORY
, fs
);
137 fs
->dir
.stream
= fdopendir(ret
);
138 if (!fs
->dir
.stream
) {
144 static void handle_rewinddir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
146 rewinddir(fs
->dir
.stream
);
149 static off_t
handle_telldir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
151 return telldir(fs
->dir
.stream
);
154 static struct dirent
*handle_readdir(FsContext
*ctx
, V9fsFidOpenState
*fs
)
156 return readdir(fs
->dir
.stream
);
159 static void handle_seekdir(FsContext
*ctx
, V9fsFidOpenState
*fs
, off_t off
)
161 seekdir(fs
->dir
.stream
, off
);
164 static ssize_t
handle_preadv(FsContext
*ctx
, V9fsFidOpenState
*fs
,
165 const struct iovec
*iov
,
166 int iovcnt
, off_t offset
)
169 return preadv(fs
->fd
, iov
, iovcnt
, offset
);
171 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
175 return readv(fs
->fd
, iov
, iovcnt
);
180 static ssize_t
handle_pwritev(FsContext
*ctx
, V9fsFidOpenState
*fs
,
181 const struct iovec
*iov
,
182 int iovcnt
, off_t offset
)
186 ret
= pwritev(fs
->fd
, iov
, iovcnt
, offset
);
188 int err
= lseek(fs
->fd
, offset
, SEEK_SET
);
192 ret
= writev(fs
->fd
, iov
, iovcnt
);
195 #ifdef CONFIG_SYNC_FILE_RANGE
196 if (ret
> 0 && ctx
->export_flags
& V9FS_IMMEDIATE_WRITEOUT
) {
198 * Initiate a writeback. This is not a data integrity sync.
199 * We want to ensure that we don't leave dirty pages in the cache
200 * after write when writeout=immediate is sepcified.
202 sync_file_range(fs
->fd
, offset
, ret
,
203 SYNC_FILE_RANGE_WAIT_BEFORE
| SYNC_FILE_RANGE_WRITE
);
209 static int handle_chmod(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
212 HandleData
*data
= (HandleData
*) fs_ctx
->private;
214 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
218 ret
= fchmod(fd
, credp
->fc_mode
);
223 static int handle_mknod(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
224 const char *name
, FsCred
*credp
)
227 HandleData
*data
= (HandleData
*) fs_ctx
->private;
229 dirfd
= open_by_handle(data
->mountfd
, dir_path
->data
, O_PATH
);
233 ret
= mknodat(dirfd
, name
, credp
->fc_mode
, credp
->fc_rdev
);
235 ret
= handle_update_file_cred(dirfd
, name
, credp
);
241 static int handle_mkdir(FsContext
*fs_ctx
, V9fsPath
*dir_path
,
242 const char *name
, FsCred
*credp
)
245 HandleData
*data
= (HandleData
*) fs_ctx
->private;
247 dirfd
= open_by_handle(data
->mountfd
, dir_path
->data
, O_PATH
);
251 ret
= mkdirat(dirfd
, name
, credp
->fc_mode
);
253 ret
= handle_update_file_cred(dirfd
, name
, credp
);
259 static int handle_fstat(FsContext
*fs_ctx
, int fid_type
,
260 V9fsFidOpenState
*fs
, struct stat
*stbuf
)
264 if (fid_type
== P9_FID_DIR
) {
265 fd
= dirfd(fs
->dir
.stream
);
269 return fstat(fd
, stbuf
);
272 static int handle_open2(FsContext
*fs_ctx
, V9fsPath
*dir_path
, const char *name
,
273 int flags
, FsCred
*credp
, V9fsFidOpenState
*fs
)
277 HandleData
*data
= (HandleData
*) fs_ctx
->private;
279 dirfd
= open_by_handle(data
->mountfd
, dir_path
->data
, O_PATH
);
283 fd
= openat(dirfd
, name
, flags
| O_NOFOLLOW
, credp
->fc_mode
);
285 ret
= handle_update_file_cred(dirfd
, name
, credp
);
298 static int handle_symlink(FsContext
*fs_ctx
, const char *oldpath
,
299 V9fsPath
*dir_path
, const char *name
, FsCred
*credp
)
302 HandleData
*data
= (HandleData
*) fs_ctx
->private;
304 dirfd
= open_by_handle(data
->mountfd
, dir_path
->data
, O_PATH
);
308 ret
= symlinkat(oldpath
, dirfd
, name
);
310 fd
= openat(dirfd
, name
, O_PATH
| O_NOFOLLOW
);
315 ret
= fchownat(fd
, "", credp
->fc_uid
, credp
->fc_gid
, AT_EMPTY_PATH
);
323 static int handle_link(FsContext
*ctx
, V9fsPath
*oldpath
,
324 V9fsPath
*dirpath
, const char *name
)
326 int oldfd
, newdirfd
, ret
;
327 HandleData
*data
= (HandleData
*) ctx
->private;
329 oldfd
= open_by_handle(data
->mountfd
, oldpath
->data
, O_PATH
);
333 newdirfd
= open_by_handle(data
->mountfd
, dirpath
->data
, O_PATH
);
338 ret
= linkat(oldfd
, "", newdirfd
, name
, AT_EMPTY_PATH
);
344 static int handle_truncate(FsContext
*ctx
, V9fsPath
*fs_path
, off_t size
)
347 HandleData
*data
= (HandleData
*) ctx
->private;
349 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
| O_WRONLY
);
353 ret
= ftruncate(fd
, size
);
358 static int handle_rename(FsContext
*ctx
, const char *oldpath
,
365 static int handle_chown(FsContext
*fs_ctx
, V9fsPath
*fs_path
, FsCred
*credp
)
368 HandleData
*data
= (HandleData
*) fs_ctx
->private;
370 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_PATH
);
374 ret
= fchownat(fd
, "", credp
->fc_uid
, credp
->fc_gid
, AT_EMPTY_PATH
);
379 static int handle_utimensat(FsContext
*ctx
, V9fsPath
*fs_path
,
380 const struct timespec
*buf
)
384 HandleData
*data
= (HandleData
*) ctx
->private;
386 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
390 ret
= futimens(fd
, buf
);
395 static int handle_remove(FsContext
*ctx
, const char *path
)
401 static int handle_fsync(FsContext
*ctx
, int fid_type
,
402 V9fsFidOpenState
*fs
, int datasync
)
406 if (fid_type
== P9_FID_DIR
) {
407 fd
= dirfd(fs
->dir
.stream
);
413 return qemu_fdatasync(fd
);
419 static int handle_statfs(FsContext
*ctx
, V9fsPath
*fs_path
,
420 struct statfs
*stbuf
)
423 HandleData
*data
= (HandleData
*) ctx
->private;
425 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
429 ret
= fstatfs(fd
, stbuf
);
434 static ssize_t
handle_lgetxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
435 const char *name
, void *value
, size_t size
)
438 HandleData
*data
= (HandleData
*) ctx
->private;
440 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
444 ret
= fgetxattr(fd
, name
, value
, size
);
449 static ssize_t
handle_llistxattr(FsContext
*ctx
, V9fsPath
*fs_path
,
450 void *value
, size_t size
)
453 HandleData
*data
= (HandleData
*) ctx
->private;
455 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
459 ret
= flistxattr(fd
, value
, size
);
464 static int handle_lsetxattr(FsContext
*ctx
, V9fsPath
*fs_path
, const char *name
,
465 void *value
, size_t size
, int flags
)
468 HandleData
*data
= (HandleData
*) ctx
->private;
470 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
474 ret
= fsetxattr(fd
, name
, value
, size
, flags
);
479 static int handle_lremovexattr(FsContext
*ctx
, V9fsPath
*fs_path
,
483 HandleData
*data
= (HandleData
*) ctx
->private;
485 fd
= open_by_handle(data
->mountfd
, fs_path
->data
, O_NONBLOCK
);
489 ret
= fremovexattr(fd
, name
);
494 static int handle_name_to_path(FsContext
*ctx
, V9fsPath
*dir_path
,
495 const char *name
, V9fsPath
*target
)
498 struct file_handle
*fh
;
499 int dirfd
, ret
, mnt_id
;
500 HandleData
*data
= (HandleData
*) ctx
->private;
502 /* "." and ".." are not allowed */
503 if (!strcmp(name
, ".") || !strcmp(name
, "..")) {
509 dirfd
= open_by_handle(data
->mountfd
, dir_path
->data
, O_PATH
);
511 /* relative to export root */
512 buffer
= rpath(ctx
, ".");
513 dirfd
= open(buffer
, O_DIRECTORY
);
519 fh
= g_malloc(sizeof(struct file_handle
) + data
->handle_bytes
);
520 fh
->handle_bytes
= data
->handle_bytes
;
521 /* add a "./" at the beginning of the path */
522 buffer
= g_strdup_printf("./%s", name
);
523 /* flag = 0 imply don't follow symlink */
524 ret
= name_to_handle(dirfd
, buffer
, fh
, &mnt_id
, 0);
526 target
->data
= (char *)fh
;
527 target
->size
= sizeof(struct file_handle
) + data
->handle_bytes
;
536 static int handle_renameat(FsContext
*ctx
, V9fsPath
*olddir
,
537 const char *old_name
, V9fsPath
*newdir
,
538 const char *new_name
)
540 int olddirfd
, newdirfd
, ret
;
541 HandleData
*data
= (HandleData
*) ctx
->private;
543 olddirfd
= open_by_handle(data
->mountfd
, olddir
->data
, O_PATH
);
547 newdirfd
= open_by_handle(data
->mountfd
, newdir
->data
, O_PATH
);
552 ret
= renameat(olddirfd
, old_name
, newdirfd
, new_name
);
558 static int handle_unlinkat(FsContext
*ctx
, V9fsPath
*dir
,
559 const char *name
, int flags
)
562 HandleData
*data
= (HandleData
*) ctx
->private;
564 dirfd
= open_by_handle(data
->mountfd
, dir
->data
, O_PATH
);
569 ret
= unlinkat(dirfd
, name
, flags
);
575 static int handle_ioc_getversion(FsContext
*ctx
, V9fsPath
*path
,
576 mode_t st_mode
, uint64_t *st_gen
)
578 #ifdef FS_IOC_GETVERSION
580 V9fsFidOpenState fid_open
;
583 * Do not try to open special files like device nodes, fifos etc
584 * We can get fd for regular files and directories only
586 if (!S_ISREG(st_mode
) && !S_ISDIR(st_mode
)) {
590 err
= handle_open(ctx
, path
, O_RDONLY
, &fid_open
);
594 err
= ioctl(fid_open
.fd
, FS_IOC_GETVERSION
, st_gen
);
595 handle_close(ctx
, &fid_open
);
603 static int handle_init(FsContext
*ctx
, Error
**errp
)
607 struct file_handle fh
;
608 HandleData
*data
= g_malloc(sizeof(HandleData
));
610 data
->mountfd
= open(ctx
->fs_root
, O_DIRECTORY
);
611 if (data
->mountfd
< 0) {
615 ret
= statfs(ctx
->fs_root
, &stbuf
);
617 switch (stbuf
.f_type
) {
618 case EXT2_SUPER_MAGIC
:
619 case BTRFS_SUPER_MAGIC
:
620 case REISERFS_SUPER_MAGIC
:
621 case XFS_SUPER_MAGIC
:
622 ctx
->exops
.get_st_gen
= handle_ioc_getversion
;
626 memset(&fh
, 0, sizeof(struct file_handle
));
627 ret
= name_to_handle(data
->mountfd
, ".", &fh
, &mnt_id
, 0);
628 if (ret
&& errno
== EOVERFLOW
) {
629 data
->handle_bytes
= fh
.handle_bytes
;
634 /* we got 0 byte handle ? */
636 close(data
->mountfd
);
643 static void handle_cleanup(FsContext
*ctx
)
645 HandleData
*data
= ctx
->private;
647 close(data
->mountfd
);
651 static int handle_parse_opts(QemuOpts
*opts
, FsDriverEntry
*fse
, Error
**errp
)
653 const char *sec_model
= qemu_opt_get(opts
, "security_model");
654 const char *path
= qemu_opt_get(opts
, "path");
656 warn_report("handle backend is deprecated");
660 "Invalid argument security_model specified with handle fsdriver");
665 error_setg(errp
, "fsdev: No path specified");
668 fse
->path
= g_strdup(path
);
673 FileOperations handle_ops
= {
674 .parse_opts
= handle_parse_opts
,
676 .cleanup
= handle_cleanup
,
677 .lstat
= handle_lstat
,
678 .readlink
= handle_readlink
,
679 .close
= handle_close
,
680 .closedir
= handle_closedir
,
682 .opendir
= handle_opendir
,
683 .rewinddir
= handle_rewinddir
,
684 .telldir
= handle_telldir
,
685 .readdir
= handle_readdir
,
686 .seekdir
= handle_seekdir
,
687 .preadv
= handle_preadv
,
688 .pwritev
= handle_pwritev
,
689 .chmod
= handle_chmod
,
690 .mknod
= handle_mknod
,
691 .mkdir
= handle_mkdir
,
692 .fstat
= handle_fstat
,
693 .open2
= handle_open2
,
694 .symlink
= handle_symlink
,
696 .truncate
= handle_truncate
,
697 .rename
= handle_rename
,
698 .chown
= handle_chown
,
699 .utimensat
= handle_utimensat
,
700 .remove
= handle_remove
,
701 .fsync
= handle_fsync
,
702 .statfs
= handle_statfs
,
703 .lgetxattr
= handle_lgetxattr
,
704 .llistxattr
= handle_llistxattr
,
705 .lsetxattr
= handle_lsetxattr
,
706 .lremovexattr
= handle_lremovexattr
,
707 .name_to_path
= handle_name_to_path
,
708 .renameat
= handle_renameat
,
709 .unlinkat
= handle_unlinkat
,