Generic name to handle and open by handle syscalls
Subsystems (17)
cover Generic name to handle and open by handle syscalls
Hi,
The below set of patches implement open by handle support using exportfs operations. This allows user space application to map a file name to file handle and later open the file using handle. This should be usable for userspace NFS [1] and 9P server [2]. XFS already support this with the ioctls XFS_IOC_PATH_TO_HANDLE and XFS_IOC_OPEN_BY_HANDLE.
[1] http://nfs-ganesha.sourceforge.net/
[2] http://thread.gmane.org/gmane.comp.emulators.qemu/68992
git repo for the patchset at:git://git.kernel.org/pub/scm/linux/kernel/git/kvaneesh/linux-open-handle.git open-by-handle
Test case can be found at
http://git.kernel.org/?p=fs/ext2/kvaneesh/handle-test.gitgit://git.kernel.org/pub/scm/fs/ext2/kvaneesh/handle-test.git
Changes from V18:
a) Drop open on symlink patch
b) Drop other patches that added support for NULL pathname in *at syscalls
c) Add new handle based syscalls. All of them are restricted to CAP_DAC_READ_SEARCH
-aneesh
PATCH 1/15 exportfs: Return the minimum required handle size
The exportfs encode handle function should return the minimum required handle size. This helps user to find out the handle size by passing 0 handle size in the first step and then redoing to the call again with the returned handle size value.
--- fs/btrfs/export.c | 8 ++++++-- fs/exportfs/expfs.c | 9 +++++++-- fs/fat/inode.c | 4 +++- fs/fuse/inode.c | 4 +++- fs/gfs2/export.c | 8 ++++++-- fs/isofs/export.c | 8 ++++++-- fs/ocfs2/export.c | 8 +++++++- fs/reiserfs/inode.c | 7 ++++++- fs/udf/namei.c | 7 ++++++- fs/xfs/linux-2.6/xfs_export.c | 4 +++- include/linux/exportfs.h | 6 ++++-- mm/shmem.c | 4 +++- 12 files changed, 60 insertions(+), 17 deletions(-)
fs/btrfs/export.c +6 -2
@@ -21,9 +21,13 @@ static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,int len = *max_len;int type; -if ((len <BTRFS_FID_SIZE_NON_CONNECTABLE ) || - (connectable && len <BTRFS_FID_SIZE_CONNECTABLE )) +if (connectable && (len <BTRFS_FID_SIZE_CONNECTABLE )) { + *max_len =BTRFS_FID_SIZE_CONNECTABLE ;return 255 ; + }else if (len <BTRFS_FID_SIZE_NON_CONNECTABLE ) { + *max_len =BTRFS_FID_SIZE_NON_CONNECTABLE ; +return 255 ; + } len =BTRFS_FID_SIZE_NON_CONNECTABLE ; type =FILEID_BTRFS_WITHOUT_PARENT ;
fs/exportfs/expfs.c +7 -2
@@ -319,9 +319,14 @@ static int export_encode_fh(struct dentry *dentry, struct fid *fid,struct inode * inode = dentry->d_inode;int len = *max_len;int type =FILEID_INO32_GEN ; - -if (len <2 || (connectable && len <4 )) + +if (connectable && (len <4 )) { + *max_len =4 ; +return 255 ; + }else if (len <2 ) { + *max_len =2 ;return 255 ; + } len =2 ; fid->i32.ino = inode->i_ino;
fs/fat/inode.c +3 -1
@@ -759,8 +759,10 @@ fat_encode_fh(struct dentry *de, __u32 *fh, int *lenp, int connectable)struct inode *inode = de->d_inode;u32 ipos_h, ipos_m, ipos_l; -if (len <5 ) +if (len <5 ) { + *lenp =5 ;return 255 ;/* no room */ + } ipos_h =MSDOS_I (inode)->i_pos >>8 ; ipos_m = (MSDOS_I (inode)->i_pos &0xf0 ) <<24 ;
fs/fuse/inode.c +3 -1
@@ -640,8 +640,10 @@ static int fuse_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,u64 nodeid;u32 generation; -if (*max_len < len) +if (*max_len < len) { + *max_len = len;return 255 ; + } nodeid =get_fuse_inode (inode)->nodeid; generation = inode->i_generation;
fs/gfs2/export.c +6 -2
@@ -36,9 +36,13 @@ static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len,struct super_block *sb = inode->i_sb;struct gfs2_inode *ip =GFS2_I (inode); -if (*len <GFS2_SMALL_FH_SIZE || - (connectable && *len <GFS2_LARGE_FH_SIZE )) +if (connectable && (*len <GFS2_LARGE_FH_SIZE )) { + *len =GFS2_LARGE_FH_SIZE ;return 255 ; + }else if (*len <GFS2_SMALL_FH_SIZE ) { + *len =GFS2_SMALL_FH_SIZE ; +return 255 ; + } fh[0 ] =cpu_to_be32 (ip->i_no_formal_ino >>32 ); fh[1 ] =cpu_to_be32 (ip->i_no_formal_ino &0xFFFFFFFF );
fs/isofs/export.c +6 -2
@@ -124,9 +124,13 @@ isofs_export_encode_fh(struct dentry *dentry,* offset of the inode and the upper 16 bits of fh32[1] to * hold the offset of the parent. */ - -if (len <3 || (connectable && len <5 )) +if (connectable && (len <5 )) { + *max_len =5 ; +return 255 ; + }else if (len <3 ) { + *max_len =3 ;return 255 ; + } len =3 ; fh32[0 ] = ei->i_iget5_block;
fs/ocfs2/export.c +7 -1
@@ -201,8 +201,14 @@ static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len, dentry->d_name.len, dentry->d_name.name, fh, len, connectable); -if (len <3 || (connectable && len <6 )) { +if (connectable && (len <6 )) {mlog (ML_ERROR ,"fh buffer is too small for encoding\n" ); + *max_len =6 ; + type =255 ; + goto bail; + }else if (len <3 ) { +mlog (ML_ERROR ,"fh buffer is too small for encoding\n" ); + *max_len =3 ; type =255 ; goto bail; }
fs/reiserfs/inode.c +6 -1
@@ -1594,8 +1594,13 @@ int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,struct inode *inode = dentry->d_inode;int maxlen = *lenp; -if (maxlen <3 ) +if (need_parent && (maxlen <5 )) { + *lenp =5 ;return 255 ; + }else if (maxlen <3 ) { + *lenp =3 ; +return 255 ; + } data[0 ] = inode->i_ino; data[1 ] =le32_to_cpu (INODE_PKEY (inode)->k_dir_id);
fs/udf/namei.c +6 -1
@@ -1336,8 +1336,13 @@ static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,struct fid *fid = (struct fid *)fh;int type =FILEID_UDF_WITHOUT_PARENT ; -if (len <3 || (connectable && len <5 )) +if (connectable && (len <5 )) { + *lenp =5 ; +return 255 ; + }else if (len <3 ) { + *lenp =3 ;return 255 ; + } *lenp =3 ; fid->udf.block = location.logicalBlockNum;
fs/xfs/linux-2.6/xfs_export.c +3 -1
@@ -81,8 +81,10 @@ xfs_fs_encode_fh(* seven combinations work. The real answer is "don't use v2". */ len =xfs_fileid_length (fileid_type); -if (*max_len < len) +if (*max_len < len) { + *max_len = len;return 255 ; + } *max_len = len;switch (fileid_type) {
include/linux/exportfs.h +4 -2
@@ -108,8 +108,10 @@ struct fid {* set, the encode_fh() should store sufficient information so that a good * attempt can be made to find not only the file but also it's place in the * filesystem. This typically means storing a reference to de->d_parent in -* the filehandle fragment. encode_fh() should return the number of bytes -* stored or a negative error code such as %-ENOSPC +* the filehandle fragment. encode_fh() should return the fileid_type on +* success and on error returns 255 (if the space needed to encode fh is +* greater than @max_len*4 bytes). On error @max_len contain the minimum +* size(in 4 byte unit) needed to encode the file handle. * * fh_to_dentry: * @fh_to_dentry is given a &struct super_block (@sb) and a file handle
mm/shmem.c +3 -1
@@ -2143,8 +2143,10 @@ static int shmem_encode_fh(struct dentry *dentry, __u32 *fh, int *len, {struct inode *inode = dentry->d_inode; -if (*len <3 ) +if (*len <3 ) { + *len =3 ;return 255 ; + }if (hlist_unhashed (&inode->i_hash)) {/* Unfortunately insert_inode_hash is not idempotent,
Signature · 1 line
1.7.0.4
PATCH 2/15 vfs: Add name to file handle conversion support
In reply to Aneesh Kumar K.VThe syscall also return mount id which can be used to lookup file system specific information such as uuid in /proc/<pid>/mountinfo
--- fs/open.c | 129 ++++++++++++++++++++++++++++++++++++++++++++++ include/linux/exportfs.h | 3 + include/linux/fs.h | 8 +++ include/linux/syscalls.h | 5 ++- 4 files changed, 144 insertions(+), 1 deletions(-)
fs/open.c +129 -0
@@ -30,6 +30,7 @@#include <linux/fs_struct.h> #include <linux/ima.h> #include <linux/dnotify.h> +#include <linux/exportfs.h> #include "internal.h"
@@ -1042,3 +1043,131 @@ int nonseekable_open(struct inode *inode, struct file *filp) }EXPORT_SYMBOL (nonseekable_open); + +#ifdef CONFIG_EXPORTFS +static long do_sys_name_to_handle (struct path *path, +struct file_handle __user *ufh, +int __user *mnt_id) +{ +long retval; +int handle_size; +struct file_handle f_handle; +struct file_handle *handle =NULL ; + +if (copy_from_user (&f_handle, ufh,sizeof (struct file_handle ))) { + retval = -EFAULT ; + goto err_out; + } +if (f_handle.handle_size >MAX_HANDLE_SZ ) { + retval = -EINVAL ; + goto err_out; + } + handle =kmalloc (sizeof (struct file_handle ) + f_handle.handle_size, +GFP_KERNEL ); +if (!handle) { + retval = -ENOMEM ; + goto err_out; + } + +/* convert handle size to multiple of sizeof(u32) */ + handle_size = f_handle.handle_size >>2 ; + +/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path->dentry, + (struct fid *)handle->f_handle, + &handle_size,0 ); +/* convert handle size to bytes */ + handle_size *=sizeof (u32); + handle->handle_type = retval; + handle->handle_size = handle_size; +if (handle_size > f_handle.handle_size) { +/* +* set the handle_size to zero so we copy only +* non variable part of the file_handle +*/ + handle_size =0 ; + retval = -EOVERFLOW ; + }else + retval =0 ; +/* copy the mount id */ +if (copy_to_user (mnt_id, &path->mnt->mnt_id,sizeof (*mnt_id))) { + retval = -EFAULT ; + goto err_free_out; + } +if (copy_to_user (ufh, handle, +sizeof (struct file_handle ) + handle_size)) + retval = -EFAULT ; +err_free_out: +kfree (handle); +err_out: +return retval; +} + +/** +* sys_name_to_handle_at: convert name to handle +* @dfd: directory relative to which name is interpreted if not absolute +* @name: name that should be converted to handle. +* @handle: resulting file handle +* @mnt_id: mount id of the file system containing the file +* @flag: flag value to indicate whether to follow symlink or not +* +* @handle->handle_size indicate the space available to store the +* variable part of the file handle in bytes. If there is not +* enough space, the field is updated to return the minimum +* value required. +*/ +SYSCALL_DEFINE5(name_to_handle_at, int, dfd, const char __user *, name, + struct file_handle __user *, handle, int __user*, mnt_id, + int, flag) +{ + +int follow; +int fput_needed; +long ret = -EINVAL ; +struct path path, *pp; +struct file *file =NULL ; + +if ((flag & ~AT_SYMLINK_FOLLOW ) !=0 ) + goto err_out; + +if (name ==NULL && dfd !=AT_FDCWD ) { + file =fget_light (dfd, &fput_needed); +if (file) { + pp = &file->f_path; + ret =0 ; + }else + ret = -EBADF ; + }else { + follow = (flag &AT_SYMLINK_FOLLOW ) ?LOOKUP_FOLLOW :0 ; + ret =user_path_at (dfd, name, follow, &path); + pp = &path; + } +if (ret) + goto err_out; +/* +* We need t make sure wether the file system +* support decoding of the file handle +*/ +if (!pp->mnt->mnt_sb->s_export_op || + !pp->mnt->mnt_sb->s_export_op->fh_to_dentry) { + ret = -EOPNOTSUPP ; + goto out_path; + } + ret =do_sys_name_to_handle (pp, handle, mnt_id); + +out_path: +if (file) +fput_light (file, fput_needed); +else +path_put (&path); +err_out: +return ret; +} +#else +SYSCALL_DEFINE5(name_to_handle_at, int, dfd, const char __user *, name, + struct file_handle __user *, handle, int __user *, mnt_id, + int, flag) +{ +return -ENOSYS ; +} +#endif
include/linux/exportfs.h +3 -0
@@ -8,6 +8,9 @@ struct inode;struct super_block ;struct vfsmount ; +/* limit the handle size to some value */ +#define MAX_HANDLE_SZ 4096 +/* * The fileid_type identifies how the file within the filesystem is encoded. * In theory this is freely set and parsed by the filesystem, but we try to
include/linux/fs.h +8 -0
@@ -953,6 +953,14 @@ struct file {unsigned long f_mnt_write_state;#endif }; + +struct file_handle { +int handle_size; +int handle_type; +/* file identifier */ +unsigned char f_handle[0 ]; +}; +extern spinlock_t files_lock;#define file_list_lock () spin_lock(&files_lock);#define file_list_unlock () spin_unlock(&files_lock);
include/linux/syscalls.h +4 -1
@@ -62,6 +62,7 @@ struct robust_list_head;struct getcpu_cache ;struct old_linux_dirent ;struct perf_event_attr ; +struct file_handle ;#include <linux/types.h> #include <linux/aio_abi.h>
@@ -831,5 +832,7 @@ asmlinkage long sys_mmap_pgoff(unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff);asmlinkage long sys_old_mmap (struct mmap_arg_struct __user *arg); - +asmlinkage long sys_name_to_handle_at (int dfd,const char __user *name, +struct file_handle __user *handle, +int __user *mnt_id,int flag);#endif
Signature · 1 line
1.7.0.4
PATCH 3/15 vfs: Add open by file handle support
In reply to Aneesh Kumar K.V--- fs/compat.c | 11 +++ fs/exportfs/expfs.c | 2 + fs/namei.c | 223 +++++++++++++++++++++++++++++++++++++++++++--- fs/open.c | 32 ++++++- include/linux/fs.h | 10 ++- include/linux/namei.h | 1 + include/linux/syscalls.h | 3 + 7 files changed, 263 insertions(+), 19 deletions(-)
fs/compat.c +11 -0
@@ -2334,3 +2334,14 @@ asmlinkage long compat_sys_timerfd_gettime(int ufd, }#endif /* CONFIG_TIMERFD */ + +/* +* Exactly like fs/open.c:sys_open_by_handle_at(), except that it +* doesn't set the O_LARGEFILE flag. +*/ +asmlinkage long +compat_sys_open_by_handle_at (int mountdirfd, +struct file_handle __user *handle,int flags) +{ +return do_handle_open (mountdirfd, handle, flags); +}
fs/exportfs/expfs.c +2 -0
@@ -373,6 +373,8 @@ struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,/* * Try to get any dentry for the given file handle from the filesystem. */ +if (!nop || !nop->fh_to_dentry) +return ERR_PTR (-ESTALE ); result = nop->fh_to_dentry (mnt->mnt_sb, fid, fh_len, fileid_type);if (!result) result =ERR_PTR (-ESTALE );
fs/namei.c +209 -14
280 lines not on this page · raw message
fs/open.c +28 -4
@@ -652,10 +652,10 @@ static inline int __get_file_write_access(struct inode *inode,return error; } -static struct file *__dentry_open (struct dentry *dentry,struct vfsmount *mnt, -struct file *f, -int (*open)(struct inode *,struct file *), -const struct cred *cred) +struct file *__dentry_open (struct dentry *dentry,struct vfsmount *mnt, +struct file *f, +int (*open)(struct inode *,struct file *), +const struct cred *cred) {struct inode *inode;int error;
@@ -1171,3 +1171,27 @@ SYSCALL_DEFINE5(name_to_handle_at, int, dfd, const char __user *, name,return -ENOSYS ; }#endif + +/** +* sys_open_by_handle_at: Open the file handle +* @mountdirfd: directory file descriptor +* @handle: file handle to be opened +* @flag: open flags. +* +* @mountdirfd indicate the directory file descriptor +* of the mount point. file handle is decoded relative +* to the vfsmount pointed by the @mountdirfd. @flags +* value is same as the open(2) flags. +*/ +SYSCALL_DEFINE3 (open_by_handle_at, int, mountdirfd, + struct file_handle __user *, handle, + int, flags) +{ +long ret; + +if (force_o_largefile ()) + flags |=O_LARGEFILE ; + + ret =do_handle_open (mountdirfd, handle, flags); +return ret; +}
include/linux/fs.h +9 -1
@@ -1939,6 +1939,10 @@ extern int do_fallocate(struct file *file, int mode, loff_t offset,extern long do_sys_open (int dfd,const char __user *filename,int flags,int mode);extern struct file *filp_open (const char *,int ,int ); +struct file *__dentry_open (struct dentry *dentry,struct vfsmount *mnt, +struct file *f, +int (*open)(struct inode *,struct file *), +const struct cred *cred);extern struct file *dentry_open (struct dentry *,struct vfsmount *,int ,const struct cred *);extern int filp_close (struct file *,fl_owner_t id);
@@ -2150,11 +2154,15 @@ extern void free_write_pipe(struct file *);extern struct file *do_filp_open (int dfd,const char *pathname,int open_flag,int mode,int acc_mode); +extern int handle_to_path (int mountdirfd,struct file_handle __user *ufh, +struct path *path); +extern long do_handle_open (int mountdirfd, +struct file_handle __user *ufh,int open_flag);extern int may_open (struct path *,int ,int );extern int kernel_read (struct file *,loff_t ,char *,unsigned long );extern struct file *open_exec (const char *); - +/* fs/dcache.c -- generic fs support functions */ extern int is_subdir (struct dentry *,struct dentry *);extern int path_is_under (struct path *,struct path *);
include/linux/namei.h +1 -0
@@ -64,6 +64,7 @@ extern int user_path_at(int, const char __user *, unsigned, struct path *);#define user_path_dir (name, path) \ user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, path) +extern struct vfsmount *get_vfsmount_from_fd (int );extern int kern_path (const char *,unsigned ,struct path *);extern int path_lookup (const char *,unsigned ,struct nameidata *);
include/linux/syscalls.h +3 -0
@@ -835,4 +835,7 @@ asmlinkage long sys_old_mmap(struct mmap_arg_struct __user *arg);asmlinkage long sys_name_to_handle_at (int dfd,const char __user *name,struct file_handle __user *handle,int __user *mnt_id,int flag); +asmlinkage long sys_open_by_handle_at (int mountdirfd, +struct file_handle __user *handle, +int flags);#endif
Signature · 1 line
1.7.0.4
PATCH 4/15 vfs: Add handle based readlink syscall
In reply to Aneesh Kumar K.V--- fs/stat.c | 28 ++++++++++++++++++++++++++++ include/linux/syscalls.h | 3 +++ 2 files changed, 31 insertions(+), 0 deletions(-)
fs/stat.c +28 -0
@@ -319,6 +319,34 @@ SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,return sys_readlinkat (AT_FDCWD , path, buf, bufsiz); } +SYSCALL_DEFINE4 (handle_readlink, int, mountdirfd, + struct file_handle __user *, ufh, + char __user *, buf, int, bufsiz) +{ +long retval =0 ; +struct path path; +struct inode *inode; + +if (bufsiz <=0 ) +return -EINVAL ; + retval =handle_to_path (mountdirfd, ufh, &path); +if (retval) + goto out_err; + + inode = path.dentry->d_inode; + retval = -EINVAL ; +if (inode->i_op->readlink) { + retval =security_inode_readlink (path.dentry); +if (!retval) { +touch_atime (path.mnt, path.dentry); + retval = inode->i_op->readlink (path.dentry, + buf, bufsiz); + } + } +path_put (&path); +out_err: +return retval; +}/* ---------- LFS-64 ----------- */ #ifdef __ARCH_WANT_STAT64
include/linux/syscalls.h +3 -0
@@ -838,4 +838,7 @@ asmlinkage long sys_name_to_handle_at(int dfd, const char __user *name,asmlinkage long sys_open_by_handle_at (int mountdirfd,struct file_handle __user *handle,int flags); +asmlinkage long sys_handle_readlink (int mountdirfd, +struct file_handle __user *ufh, +char __user *buf,int bufsiz);#endif
Signature · 1 line
1.7.0.4
PATCH 5/15 vfs: Add handle based stat syscall
In reply to Aneesh Kumar K.V--- arch/x86/ia32/sys_ia32.c | 13 +++++++++++++ fs/stat.c | 42 ++++++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 3 +++ include/linux/syscalls.h | 9 +++++++++ 4 files changed, 67 insertions(+), 0 deletions(-)
arch/x86/ia32/sys_ia32.c +13 -0
@@ -138,6 +138,19 @@ asmlinkage long sys32_fstatat(unsigned int dfd, const char __user *filename,return cp_stat64 (statbuf, &stat); } +asmlinkage long sys32_handle_stat64 (int mountdirfd, +struct file_handle __user *ufh, +struct stat64 __user *statbuf) +{ +struct kstat stat; +int error; + + error =do_handle_stat (mountdirfd, ufh, &stat); +if (error) +return error; +return cp_stat64 (statbuf, &stat); +} +/* * Linux/i386 didn't use to be able to handle more than * 4 system call parameters, so these system calls used a memory
fs/stat.c +42 -0
54 lines not on this page · raw message
include/linux/fs.h +3 -0
@@ -2339,6 +2339,9 @@ extern int vfs_stat(const char __user *, struct kstat *);extern int vfs_lstat (const char __user *,struct kstat *);extern int vfs_fstat (unsigned int ,struct kstat *);extern int vfs_fstatat (int ,const char __user *,struct kstat *,int ); +extern int do_handle_stat (int mountdirfd, +struct file_handle __user *ufh, +struct kstat *stat);extern int do_vfs_ioctl (struct file *filp,unsigned int fd,unsigned int cmd,unsigned long arg);
include/linux/syscalls.h +9 -0
@@ -841,4 +841,13 @@ asmlinkage long sys_open_by_handle_at(int mountdirfd,asmlinkage long sys_handle_readlink (int mountdirfd,struct file_handle __user *ufh,char __user *buf,int bufsiz); +#if BITS_PER_LONG ==32 +asmlinkage long sys_handle_stat64 (int mountdirfd, +struct file_handle __user *ufh, +struct stat64 __user *statbuf); +#else +asmlinkage long sys_handle_stat (int mountdirfd, +struct file_handle __user *ufh, +struct stat __user *statbuf); +#endif #endif
Signature · 1 line
1.7.0.4
PATCH 6/15 vfs: Add handle based link syscall
In reply to Aneesh Kumar K.V--- fs/namei.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ include/linux/syscalls.h | 2 ++ 2 files changed, 47 insertions(+), 0 deletions(-)
fs/namei.c +45 -0
@@ -2706,6 +2706,51 @@ SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newnamereturn sys_linkat (AT_FDCWD , oldname,AT_FDCWD , newname,0 ); } +SYSCALL_DEFINE4(handle_link, int, mountdirfd, struct file_handle __user *, uofh, + int, newdfd, const char __user *, newname) +{ +char *to; +int error; +struct dentry *new_dentry; +struct nameidata nd; +struct path old_path; + + error =handle_to_path (mountdirfd, uofh, &old_path); +if (error) +return error; + + error =user_path_parent (newdfd, newname, &nd, &to); +if (error) + goto out; + error = -EXDEV ; +if (old_path.mnt != nd.path.mnt) + goto out_release; + new_dentry =lookup_create (&nd,0 ); + error =PTR_ERR (new_dentry); +if (IS_ERR (new_dentry)) + goto out_unlock; + error =mnt_want_write (nd.path.mnt); +if (error) + goto out_dput; + error =security_path_link (old_path.dentry, &nd.path, new_dentry); +if (error) + goto out_drop_write; + error =vfs_link (old_path.dentry, nd.path.dentry->d_inode, new_dentry); +out_drop_write: +mnt_drop_write (nd.path.mnt); +out_dput: +dput (new_dentry); +out_unlock: +mutex_unlock (&nd.path.dentry->d_inode->i_mutex); +out_release: +path_put (&nd.path); +putname (to); +out: +path_put (&old_path); + +return error; +} +/* * The worst of all namespace operations - renaming directory. "Perverted" * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
include/linux/syscalls.h +2 -0
@@ -850,4 +850,6 @@ asmlinkage long sys_handle_stat(int mountdirfd,struct file_handle __user *ufh, struct stat __user *statbuf);#endif +asmlinkage long sys_handle_link (int mountdirfd,struct file_handle __user *uofh, +int newfd,const char __user *newname);#endif
Signature · 1 line
1.7.0.4
PATCH 7/15 vfs: Add handle based chown syscall
In reply to Aneesh Kumar K.V--- fs/open.c | 20 ++++++++++++++++++++ include/linux/syscalls.h | 2 ++ 2 files changed, 22 insertions(+), 0 deletions(-)
fs/open.c +20 -0
@@ -623,6 +623,26 @@ out:return error; } +SYSCALL_DEFINE4(handle_chown, int, mountdirfd, struct file_handle __user *, ufh, + uid_t, user, gid_t, group) +{ +struct path path; +int error = -EINVAL ; + + error =handle_to_path (mountdirfd, ufh, &path); +if (error) + goto out; + error =mnt_want_write (path.mnt); +if (error) + goto out_release; + error =chown_common (&path, user, group); +mnt_drop_write (path.mnt); +out_release: +path_put (&path); +out: +return error; +} +/* * You have to be very careful that these write * counts get cleaned up in error cases and
include/linux/syscalls.h +2 -0
@@ -852,4 +852,6 @@ asmlinkage long sys_handle_stat(int mountdirfd,#endif asmlinkage long sys_handle_link (int mountdirfd,struct file_handle __user *uofh,int newfd,const char __user *newname); +asmlinkage long sys_handle_chown (int mountdirfd,struct file_handle __user *ufh, +uid_t user,gid_t group);#endif
Signature · 1 line
1.7.0.4
PATCH 8/15 vfs: Add handle based xattr syscalls
In reply to Aneesh Kumar K.V--- fs/xattr.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++ include/linux/syscalls.h | 15 ++++++++++ 2 files changed, 85 insertions(+), 0 deletions(-)
fs/xattr.c +70 -0
@@ -335,6 +335,26 @@ SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,return error; } +SYSCALL_DEFINE6 (handle_setxattr, int, mountdirfd, + struct file_handle __user *, ufh, + const char __user *, name, const void __user *, value, + size_t, size, int, flags) +{ +struct path path; +int error; + + error =handle_to_path (mountdirfd, ufh, &path); +if (error) +return error; + error =mnt_want_write (path.mnt); +if (!error) { + error =setxattr (path.dentry, name, value, size, flags); +mnt_drop_write (path.mnt); + } +path_put (&path); +return error; +} +/* * Extended attribute GET operations */
@@ -416,6 +436,22 @@ SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,return error; } +SYSCALL_DEFINE5 (handle_getxattr, int, mountdirfd, + struct file_handle __user *, ufh, + const char __user *, name, + void __user *, value, size_t, size) +{ +struct path path; +ssize_t error; + + error =handle_to_path (mountdirfd, ufh, &path); +if (error) +return error; + error =getxattr (path.dentry, name, value, size); +path_put (&path); +return error; +} +/* * Extended attribute LIST operations */
@@ -488,6 +524,21 @@ SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)return error; } +SYSCALL_DEFINE4 (handle_listxattr, int, mountdirfd, + struct file_handle __user *, ufh, + char __user *, list, size_t, size) +{ +struct path path; +ssize_t error; + + error =handle_to_path (mountdirfd, ufh, &path); +if (error) +return error; + error =listxattr (path.dentry, list, size); +path_put (&path); +return error; +} +/* * Extended attribute REMOVE operations */
@@ -562,6 +613,25 @@ SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)return error; } +SYSCALL_DEFINE3 (handle_removexattr, int, mountdirfd, + struct file_handle __user *, ufh, + const char __user *, name) +{ +struct path path; +int error; + + error =handle_to_path (mountdirfd, ufh, &path); +if (error) +return error; + error =mnt_want_write (path.mnt); +if (!error) { + error =removexattr (path.dentry, name); +mnt_drop_write (path.mnt); + } +path_put (&path); +return error; +} +static const char *strcmp_prefix (const char *a,const char *a_prefix)
include/linux/syscalls.h +15 -0
@@ -854,4 +854,19 @@ asmlinkage long sys_handle_link(int mountdirfd, struct file_handle __user *uofh, int newfd, const char __user *newname);asmlinkage long sys_handle_chown (int mountdirfd,struct file_handle __user *ufh,uid_t user,gid_t group); +asmlinkage long sys_handle_setxattr (int mountdirfd, +struct file_handle __user *ufh, +const char __user *name, +const void __user *value, +size_t size,int flags); +asmlinkage long sys_handle_getxattr (int mountdirfd, +struct file_handle __user *ufh, +const char __user *name, +void __user *value,size_t size); +asmlinkage long sys_handle_listxattr (int mountdirfd, +struct file_handle __user *ufh, +char __user *list,size_t size); +asmlinkage long sys_handle_removexattr (int mountdirfd, +struct file_handle __user *ufh, +const char __user *name);#endif
Signature · 1 line
1.7.0.4
PATCH 9/15 vfs: Add file access and modification time update via handle syscall
In reply to Aneesh Kumar K.V--- fs/compat.c | 20 ++++++++++++++++++ fs/utimes.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++ include/linux/syscalls.h | 3 ++ include/linux/time.h | 3 ++ 4 files changed, 75 insertions(+), 0 deletions(-)
fs/compat.c +20 -0
@@ -131,6 +131,26 @@ asmlinkage long compat_sys_utimes(const char __user *filename, struct compat_timreturn compat_sys_futimesat (AT_FDCWD , filename, t); } +asmlinkage long compat_sys_handle_utimes (unsigned int mountdirfd, +struct file_handle __user *ufh, +struct compat_timeval __user *t) +{ +struct timespec tv[2 ]; +if (t) { +if (get_user (tv[0 ].tv_sec, &t[0 ].tv_sec) || +get_user (tv[0 ].tv_nsec, &t[0 ].tv_usec) || +get_user (tv[1 ].tv_sec, &t[1 ].tv_sec) || +get_user (tv[1 ].tv_nsec, &t[1 ].tv_usec)) +return -EFAULT ; +if (tv[0 ].tv_nsec >=1000000 || tv[0 ].tv_nsec <0 || + tv[1 ].tv_nsec >=1000000 || tv[1 ].tv_nsec <0 ) +return -EINVAL ; + tv[0 ].tv_nsec *=1000 ; + tv[1 ].tv_nsec *=1000 ; + } +return do_handle_utimes (mountdirfd, ufh, t ? tv :NULL ); +} +static int cp_compat_stat (struct kstat *stat,struct compat_stat __user *ubuf) {compat_ino_t ino = stat->ino;
fs/utimes.c +49 -0
52 lines not on this page · raw message
include/linux/syscalls.h +3 -0
@@ -869,4 +869,7 @@ asmlinkage long sys_handle_listxattr(int mountdirfd,asmlinkage long sys_handle_removexattr (int mountdirfd,struct file_handle __user *ufh,const char __user *name); +asmlinkage long sys_handle_utimes (int mountdirfd, +struct file_handle __user *ufh, +struct timeval __user *utimes);#endif
include/linux/time.h +3 -0
@@ -151,6 +151,9 @@ extern int do_settimeofday(struct timespec *tv);extern int do_sys_settimeofday (struct timespec *tv,struct timezone *tz);#define do_posix_clock_monotonic_gettime (ts) ktime_get_ts(ts)extern long do_utimes (int dfd,const char __user *filename,struct timespec *times,int flags); +struct file_handle ; +extern long do_handle_utimes (int mountdirfd,struct file_handle __user *ufh, +struct timespec *times);struct itimerval ;extern int do_setitimer (int which,struct itimerval *value,struct itimerval *ovalue);
Signature · 1 line
1.7.0.4
PATCH 10/15 x86: Add new syscalls for x86_32
In reply to Aneesh Kumar K.VThis patch adds new syscalls to x86_32
--- arch/x86/include/asm/unistd_32.h | 14 +++++++++++++- arch/x86/kernel/syscall_table_32.S | 11 +++++++++++ 2 files changed, 24 insertions(+), 1 deletions(-)
arch/x86/include/asm/unistd_32.h +13 -1
@@ -346,10 +346,22 @@#define __NR_fanotify_init 338#define __NR_fanotify_mark 339#define __NR_prlimit64 340 +#define __NR_name_to_handle_at 341 +#define __NR_open_by_handle_at 342 +#define __NR_readlink_by_handle 343 +#define __NR_stat64_by_handle 344 +#define __NR_link_by_handle 345 +#define __NR_chown_by_handle 346 +#define __NR_setxattr_by_handle 347 +#define __NR_getxattr_by_handle 348 +#define __NR_listxattr_by_handle 349 +#define __NR_removexattr_by_handle 350 +#define __NR_utimes_by_handle 351 +#ifdef __KERNEL__ -#define NR_syscalls 341 +#define NR_syscalls 352#define __ARCH_WANT_IPC_PARSE_VERSION#define __ARCH_WANT_OLD_READDIR
arch/x86/kernel/syscall_table_32.S +11 -0
@@ -340,3 +340,14 @@ ENTRY(sys_call_table) .long sys_fanotify_init .long sys_fanotify_mark .long sys_prlimit64 /* 340 */ + .long sys_name_to_handle_at + .long sys_open_by_handle_at + .long sys_handle_readlink + .long sys_handle_stat64 + .long sys_handle_link /* 345 */ + .long sys_handle_chown + .long sys_handle_setxattr + .long sys_handle_getxattr + .long sys_handle_listxattr + .long sys_handle_removexattr /* 350 */ + .long sys_handle_utimes
Signature · 1 line
1.7.0.4
PATCH 11/15 x86: Add new syscalls for x86_64
In reply to Aneesh Kumar K.VThis patch add new syscalls to x86_64
--- arch/x86/ia32/ia32entry.S | 11 +++++++++++ arch/x86/include/asm/unistd_64.h | 24 ++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 0 deletions(-)
arch/x86/ia32/ia32entry.S +11 -0
@@ -845,4 +845,15 @@ ia32_sys_call_table: .quad sys_fanotify_init .quad sys32_fanotify_mark .quad sys_prlimit64 /* 340 */ + .quad sys_name_to_handle_at + .quad compat_sys_open_by_handle_at + .quad sys_handle_readlink + .quad sys32_handle_stat64 + .quad sys_handle_link /* 345 */ + .quad sys_handle_chown + .quad sys_handle_setxattr + .quad sys_handle_getxattr + .quad sys_handle_listxattr + .quad sys_handle_removexattr /* 350 */ + .quad compat_sys_handle_utimes ia32_syscall_end:
arch/x86/include/asm/unistd_64.h +24 -0
@@ -669,6 +669,30 @@ __SYSCALL(__NR_fanotify_init, sys_fanotify_init) __SYSCALL(__NR_fanotify_mark, sys_fanotify_mark)#define __NR_prlimit64 302 __SYSCALL(__NR_prlimit64, sys_prlimit64) +#define __NR_name_to_handle_at 303 +__SYSCALL(__NR_name_to_handle_at, sys_name_to_handle_at) +#define __NR_open_by_handle_at 304 +__SYSCALL(__NR_open_by_handle_at, sys_open_by_handle_at) +#define __NR_readlink_by_handle 305 +__SYSCALL(__NR_readlink_by_handle, sys_handle_readlink) +#define __NR_stat_by_handle 306 +__SYSCALL(__NR_stat_by_handle, sys_handle_stat) +#define __NR_link_by_handle 307 +__SYSCALL(__NR_link_by_handle, sys_handle_link) +#define __NR_chown_by_handle 308 +__SYSCALL(__NR_chown_by_handle, sys_handle_chown) +#define __NR_setxattr_by_handle 309 +__SYSCALL(__NR_setxattr_by_handle, sys_handle_setxattr) +#define __NR_getxattr_by_handle 310 +__SYSCALL(__NR_getxattr_by_handle, sys_handle_getxattr) +#define __NR_listxattr_by_handle 311 +__SYSCALL(__NR_listxattr_by_handle, sys_handle_listxattr) +#define __NR_removexattr_by_handle 312 +__SYSCALL(__NR_removexattr_by_handle, sys_handle_removexattr) +#define __NR_utimes_by_handle 313 +__SYSCALL(__NR_utimes_by_handle, sys_handle_utimes) + +#ifndef __NO_STUBS#define __ARCH_WANT_OLD_READDIR
Signature · 1 line
1.7.0.4
PATCH 12/15 unistd.h: Add new syscalls numbers to asm-generic
In reply to Aneesh Kumar K.V--- include/asm-generic/unistd.h | 25 ++++++++++++++++++++++++- 1 files changed, 24 insertions(+), 1 deletions(-)
include/asm-generic/unistd.h +24 -1
@@ -646,9 +646,32 @@ __SYSCALL(__NR_prlimit64, sys_prlimit64) __SYSCALL(__NR_fanotify_init, sys_fanotify_init)#define __NR_fanotify_mark 263 __SYSCALL(__NR_fanotify_mark, sys_fanotify_mark) +#define __NR_name_to_handle_at 264 +__SYSCALL(__NR_name_to_handle_at, sys_name_to_handle_at) +#define __NR_open_by_handle_at 265 +__SYSCALL(__NR_open_by_handle_at, sys_open_by_handle_at) +#define __NR_readlink_by_handle 266 +__SYSCALL(__NR_readlink_by_handle, sys_handle_readlink) +#define __NR_stat64_by_handle 267 +__SYSCALL(__NR_stat64_by_handle, sys_handle_stat64) +#define __NR_link_by_handle 268 +__SYSCALL(__NR_link_by_handle, sys_handle_link) +#define __NR_chown_by_handle 269 +__SYSCALL(__NR_chown_by_handle, sys_handle_chown) +#define __NR_setxattr_by_handle 270 +__SYSCALL(__NR_setxattr_by_handle, sys_handle_setxattr) +#define __NR_getxattr_by_handle 271 +__SYSCALL(__NR_getxattr_by_handle, sys_handle_getxattr) +#define __NR_listxattr_by_handle 272 +__SYSCALL(__NR_listxattr_by_handle, sys_handle_listxattr) +#define __NR_removexattr_by_handle 273 +__SYSCALL(__NR_removexattr_by_handle, sys_handle_removexattr) +#define __NR_utimes_by_handle 274 +__SYSCALL(__NR_utimes_by_handle, sys_handle_utimes) +#undef __NR_syscalls -#define __NR_syscalls 264 +#define __NR_syscalls 275/* * All syscalls below here should go away really,
Signature · 1 line
1.7.0.4
PATCH 13/15 vfs: Export file system uuid via /proc/<pid>/mountinfo
In reply to Aneesh Kumar K.VWe add a per superblock uuid field. File systems should update the uuid in the fill_super callback
--- fs/namespace.c | 16 ++++++++++++++++ include/linux/fs.h | 1 + 2 files changed, 17 insertions(+), 0 deletions(-)
fs/namespace.c +16 -0
@@ -837,6 +837,18 @@ const struct seq_operations mounts_op = { .show = show_vfsmnt }; +static int uuid_is_nil (u8 *uuid) +{ +int i; +u8 *cp = (u8 *)uuid; + +for (i =0 ; i <16 ; i++) { +if (*cp++) +return 0 ; + } +return 1 ; +} +static int show_mountinfo (struct seq_file *m,void *v) {struct proc_mounts *p = m->private;
@@ -875,6 +887,10 @@ static int show_mountinfo(struct seq_file *m, void *v)if (IS_MNT_UNBINDABLE (mnt))seq_puts (m," unbindable" ); +if (!uuid_is_nil (mnt->mnt_sb->s_uuid)) +/* print the uuid */ +seq_printf (m," uuid:%pU" , mnt->mnt_sb->s_uuid); +/* Filesystem specific data */ seq_puts (m," - " );show_type (m, sb);
include/linux/fs.h +1 -0
@@ -1369,6 +1369,7 @@ struct super_block {wait_queue_head_t s_wait_unfrozen;char s_id[32 ];/* Informational name */ +u8 s_uuid[16 ];/* UUID */ void *s_fs_info;/* Filesystem private info */ fmode_t s_mode;
Signature · 1 line
1.7.0.4
PATCH 14/15 ext3: Copy fs UUID to superblock.
In reply to Aneesh Kumar K.VFile system UUID is made available to application
via /proc/<pid>/mountinfo
--- fs/ext3/super.c | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)
fs/ext3/super.c +1 -0
@@ -1918,6 +1918,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent) sb->s_qcop = &ext3_qctl_operations; sb->dq_op = &ext3_quota_operations;#endif +memcpy (sb->s_uuid, es->s_uuid,sizeof (es->s_uuid));INIT_LIST_HEAD (&sbi->s_orphan);/* unlinked but open files */ mutex_init (&sbi->s_orphan_lock);mutex_init (&sbi->s_resize_lock);
Signature · 1 line
1.7.0.4
PATCH 15/15 ext4: Copy fs UUID to superblock
In reply to Aneesh Kumar K.VFile system UUID is made available to application
via /proc/<pid>/mountinfo
--- fs/ext4/super.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
fs/ext4/super.c +2 -0
@@ -2941,6 +2941,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) sb->s_qcop = &ext4_qctl_operations; sb->dq_op = &ext4_quota_operations;#endif +memcpy (sb->s_uuid, es->s_uuid,sizeof (es->s_uuid)); +INIT_LIST_HEAD (&sbi->s_orphan);/* unlinked but open files */ mutex_init (&sbi->s_orphan_lock);mutex_init (&sbi->s_resize_lock);
Signature · 1 line
1.7.0.4
Quoted 14 lines · Aneesh Kumar K.V
Hi,
The below set of patches implement open by handle support using exportfs operations. This allows user space application to map a file name to file handle and later open the file using handle. This should be usable for userspace NFS [1] and 9P server [2]. XFS already support this with the ioctls
XFS_IOC_PATH_TO_HANDLEandXFS_IOC_OPEN_BY_HANDLE.[1] http://nfs-ganesha.sourceforge.net/
[2] http://thread.gmane.org/gmane.comp.emulators.qemu/68992git repo for the patchset at:
git://git.kernel.org/pub/scm/linux/kernel/git/kvaneesh/linux-open-handle.gitopen-by-handle
Quoted 9 lines
Test case can be found at
http://git.kernel.org/?p=fs/ext2/kvaneesh/handle-test.gitgit://git.kernel.org/pub/scm/fs/ext2/kvaneesh/handle-test.gitChanges from V18:
a) Drop open on symlink patch
b) Drop other patches that added support for NULL pathname in *at syscalls
c) Add new handle based syscalls. All of them are restricted toCAP_DAC_READ_SEARCH
Hi Al,
Any update on this. Are you ok with syscall approach which is limitted to CAP_DAC_READ_SEARCH ?
-aneesh
Miklos Szeredi
maintainerQuoted 2 lines · Aneesh Kumar K. V
Any update on this. Are you ok with syscall approach which is limitted to
CAP_DAC_READ_SEARCH?
My gut reaction is: "not another bunch of xattr syscalls!". It doesn't feel right, this interface is too specialized to warrant a full set of filesystem syscalls.
Al Viro is right that there are problems with symlinks. What we really want here is a sort of symlink that doesn't get followed. One way to provide that is to create a kernel internal "handle" filesystem and direct open_by_handle() to that for anything not a directory or a regular file.
Thanks,
Miklos
Quoted 7 lines · Miklos Szeredi
Quoted 2 lines · Aneesh Kumar K. V
Any update on this. Are you ok with syscall approach which is limitted to
CAP_DAC_READ_SEARCH?My gut reaction is: "not another bunch of xattr syscalls!". It doesn't feel right, this interface is too specialized to warrant a full set of filesystem syscalls.
Are you ok with rest of syscalls other than the handle based xattr one ? In that case can we get rest of the patches merged and rework xattr patches later ?. That is xattr support for symlink can follow as a separate patch series ?
Quoted 7 lines
Al Viro is right that there are problems with symlinks. What we really want here is a sort of symlink that doesn't get followed. One way to provide that is to create a kernel internal "handle" filesystem and direct
open_by_handle()to that for anything not a directory or a regular file.
-aneesh
Miklos Szeredi
maintainerQuoted 11 lines · Aneesh Kumar K. V
Quoted 7 lines · Miklos Szeredi
Quoted 2 lines · Aneesh Kumar K. V
Any update on this. Are you ok with syscall approach which is limitted to
CAP_DAC_READ_SEARCH?My gut reaction is: "not another bunch of xattr syscalls!". It doesn't feel right, this interface is too specialized to warrant a full set of filesystem syscalls.
Are you ok with rest of syscalls other than the handle based xattr one ?
No, not really. Only xattrs stand out from the rest as the "API that shouldn't be" and adding more to that pile makes me feel especially bad.
But xattrs aside, I still don't think we need another interface for file handles that duplicates the existing filesystem APIs.
Thanks,
Miklos
Quoted 11 lines · Miklos Szeredi
Quoted 10 lines · Aneesh Kumar K. V
Quoted 7 lines · Miklos Szeredi
Quoted 2 lines · Aneesh Kumar K. V
Any update on this. Are you ok with syscall approach which is limitted to
CAP_DAC_READ_SEARCH?My gut reaction is: "not another bunch of xattr syscalls!". It doesn't feel right, this interface is too specialized to warrant a full set of filesystem syscalls.
Quoted 9 lines
Quoted 1 line
Are you ok with rest of syscalls other than the handle based xattr one ?
No, not really. Only xattrs stand out from the rest as the "API that shouldn't be" and adding more to that pile makes me feel especially bad.
But xattrs aside, I still don't think we need another interface for file handles that duplicates the existing filesystem APIs.
As per your suggestion i started looking at handlefs details and below is my take on the approach.
handlefs would be an internal kernel mount like pipefs and would have inode object mapping to the returned file descriptor of open_by_handle_at syscall for symlinks. For regular files we can do what we already does and for symlinks we will create inodes in handlefs and their inode operation will in turn result in call out of inode operations of the actual symlinks. Based on the above
a) We still need open_by_handle_at syscall
b) We still need handle based link syscall, because we need to support creating hardlinks based on handle, and the existing linkat syscall takes the oldpath name.
c) We still need handle based readlink syscall, because the existing readlinkat syscall takes pathname.
d) we can drop stat, chown and xattr syscall because they are introduced specially for symlinks as we don't allow open on symlinks.
e) It would be nice to have handle based stat syscall to avoid two syscall overhead for fetching file attributes when implementing a file server, where fetching file attribute is a common operation.
With the above from the current patch series we can drop chown and xattr syscalls. Would it be ok if we get the series with the those two syscall patches dropped upstream as i work on supporting symlinks with handlefs approach ?
-aneesh
Miklos Szeredi
maintainerQuoted 10 lines · Aneesh Kumar K. V
As per your suggestion i started looking at handlefs details and below is my take on the approach.
handlefs would be an internal kernel mount like pipefs and would have inode object mapping to the returned file descriptor of
open_by_handle_atsyscall for symlinks. For regular files we can do what we already does and for symlinks we will create inodes in handlefs and their inode operation will in turn result in call out of inode operations of the actual symlinks. Based on the above
Quoted 6 lines
a) We still need
open_by_handle_atsyscall
b) We still need handle based link syscall, because we need to support creating hardlinks based on handle, and the existing linkat syscall takes the oldpath name.
c) We still need handle based readlink syscall, because the existing readlinkat syscall takes pathname.
You can implement ->read() on the symlink file instead.
Quoted 5 lines
d) we can drop stat, chown and xattr syscall because they are introduced specially for symlinks as we don't allow open on symlinks.
e) It would be nice to have handle based stat syscall to avoid two syscall overhead for fetching file attributes when implementing a file server, where fetching file attribute is a common operation.
Syscall overhead is generally insignificant compared to other effects. The server can also cache open files for commonly used handles.
Quoted 5 lines
With the above from the current patch series we can drop chown and xattr syscalls. Would it be ok if we get the series with the those two syscall patches dropped upstream as i work on supporting symlinks with handlefs approach ?
Try it.
Al seems to only be active to the outside world around the merge window, so that's the best time to ask him to pull.
Thanks,
Miklos
Quoted 11 lines · On Mon, 13 Sep 2010 08:01:18 +0200 Miklos Szeredi <[email protected]> wrote:
Quoted 10 lines · Aneesh Kumar K. V
As per your suggestion i started looking at handlefs details and below is my take on the approach.
handlefs would be an internal kernel mount like pipefs and would have inode object mapping to the returned file descriptor of
open_by_handle_atsyscall for symlinks. For regular files we can do what we already does and for symlinks we will create inodes in handlefs and their inode operation will in turn result in call out of inode operations of the actual symlinks. Based on the above
Quoted 8 lines
Quoted 6 lines
a) We still need
open_by_handle_atsyscall
b) We still need handle based link syscall, because we need to support creating hardlinks based on handle, and the existing linkat syscall takes the oldpath name.
c) We still need handle based readlink syscall, because the existing readlinkat syscall takes pathname.You can implement ->read() on the symlink file instead.
I would suggest that is a much uglier hack than changed readlinkat to accept a NULL pathname.
NeilBrown
Quoted 23 lines
Quoted 6 lines
d) we can drop stat, chown and xattr syscall because they are introduced specially for symlinks as we don't allow open on symlinks.
e) It would be nice to have handle based stat syscall to avoid two syscall overhead for fetching file attributes when implementing a file server, where fetching file attribute is a common operation.Syscall overhead is generally insignificant compared to other effects. The server can also cache open files for commonly used handles.
Quoted 5 lines
With the above from the current patch series we can drop chown and xattr syscalls. Would it be ok if we get the series with the those two syscall patches dropped upstream as i work on supporting symlinks with handlefs approach ?
Try it.
Al seems to only be active to the outside world around the merge window, so that's the best time to ask him to pull.
Thanks,
Miklos
Miklos Szeredi
maintainerQuoted 4 lines · Neil Brown
Quoted 1 line
You can implement ->read() on the symlink file instead.
I would suggest that is a much uglier hack than changed readlinkat to accept a NULL pathname.
I think read(2) is a natural interface for reading symlinks and would have been a perfectly fine API to choose instead of a specialized syscall.
Thanks,
Miklos
Quoted 10 lines · Miklos Szeredi
Quoted 5 lines · Aneesh Kumar K. V
d) we can drop stat, chown and xattr syscall because they are introduced specially for symlinks as we don't allow open on symlinks.
e) It would be nice to have handle based stat syscall to avoid two syscall overhead for fetching file attributes when implementing a file server, where fetching file attribute is a common operation.Syscall overhead is generally insignificant compared to other effects. The server can also cache open files for commonly used handles.
For some client/server file system an open would require communication to the server where as we can get stat result based on the values cached on the client if we support handle based stat.
-aneesh