Generic name to handle and open by handle syscalls
Subsystems (14)
PATCH 1/1 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://lists.gnu.org/archive/html/qemu-devel/2010-03/msg01087.html
TODO:
I guess we would need to optimize how we get the vfsmount for the filesystem uuid specified. Searching the file system list and task name space may be a big overhead for each open by handle call.
Changes from V3:
a) Code cleanup suggested by Andreas
b) x86_64 syscall support
c) add compat syscall
Chages from V2:
a) Support system wide unique handle.
Changes from v1:
a) handle size is now specified in bytes
b) returns -EOVERFLOW if the handle size is small
c) dropped open_handle syscall and added open_by_handle_at syscall open_by_handle_at takes mount_fd as the directory fd of the mount point containing the file
e) handle will only be unique in a given file system. So for an NFS server exporting multiple file system, NFS server will have to internally track the mount point to which a file handle belongs to. We should be able to do it much easily than expecting kernel to give a system wide unique file handle. System wide unique file handle would need much larger changes to the exportfs or VFS interface and I was not sure whether we really need to do that in the kernel or in the user space
f) open_handle_at now only check for DAC_OVERRIDE capability
Example program: (x86_32). (x86_64 would need a different syscall number)
----------------
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
struct uuid {
char uuid[16];
};
struct file_handle {
int handle_size;
int handle_type;
struct uuid fsid;
void *handle;
};static int name_to_handle(const char *name, struct file_handle *fh)
{
return syscall(338, name, fh);
}static int open_by_handle(struct file_handle *fh, int flags)
{
return syscall(339, fh, flags);
}int main(int argc, char *argv[])
{
int ret;
int fd, dirfd;
char buf[100];
struct file_handle fh;
fh.handle_size = 0;
again:
if (fh.handle_size)
fh.handle = malloc(fh.handle_size);
fh.handle_type = 0;
errno = 0;
ret = name_to_handle(argv[1], &fh);
if (ret) {
perror("Error:");
printf("Found the handle size needed to be %d\n", fh.handle_size);
printf("Trying again..\n");
goto again;
exit(1);
}
fd = open_by_handle(&fh, O_RDONLY);
if (fd <= 0 ) {
perror("Error:");
exit(1);
}
memset(buf, 0 , 100);
while (read(fd, buf, 100) > 0) {
printf("%s", buf);
memset(buf, 0 , 100);
}
return 0;
}-aneesh
PATCH 1/6 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 +++- mm/shmem.c | 4 +++- 11 files changed, 56 insertions(+), 15 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
@@ -738,8 +738,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
@@ -638,8 +638,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
@@ -1588,8 +1588,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
@@ -1360,8 +1360,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 = lenreturn 255 ; + } *max_len = len;switch (fileid_type) {
mm/shmem.c +3 -1
@@ -2125,8 +2125,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.360.g11766c
PATCH 2/6 vfs: Add name to file handle conversion support
In reply to Aneesh Kumar K.V--- fs/open.c | 95 ++++++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 19 ++++++++++ 2 files changed, 114 insertions(+), 0 deletions(-)
fs/open.c +95 -0
@@ -30,6 +30,8 @@#include <linux/falloc.h> #include <linux/fs_struct.h> #include <linux/ima.h> +#include <linux/exportfs.h> +#include <linux/mnt_namespace.h> #include "internal.h"
@@ -1206,3 +1208,96 @@ int nonseekable_open(struct inode *inode, struct file *filp) }EXPORT_SYMBOL (nonseekable_open); + +/* limit the handle size to some value */ +#define MAX_HANDLE_SZ 4096 +long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh) +{ +int retval; +int handle_size; +struct path path; +struct inode *inode; +void *handle =NULL ; +struct super_block *sb; +struct uuid *this_fs_id; + +if (fh->handle_size >MAX_HANDLE_SZ ) +return -EINVAL ; + + retval =user_lpath (name, &path); +if (retval) +return retval; + + inode = path.dentry->d_inode; +/* +* name to handle conversion only done for regular files +* directories and symbolic links +*/ +if (!S_ISREG (inode->i_mode) && !S_ISDIR (inode->i_mode) && + !S_ISLNK (inode->i_mode)) { + retval = -EINVAL ; + goto err_out; + } +if (fh->handle_size >0 ) { + handle =kmalloc (fh->handle_size,GFP_KERNEL ); +if (!handle) { + retval = -ENOMEM ; + goto err_out; + } + + handle_size = fh->handle_size; + }else + handle_size =0 ; +/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path.dentry, (struct fid *)handle, + &handle_size,0 ); +/* convert handle size to bytes */ + handle_size *=sizeof (u32); + fh->handle_type = retval; +if (handle_size <= fh->handle_size) { +if (copy_to_user (fh->f_handle, handle, + handle_size)) + retval = -EFAULT ; +else + retval =0 ; + }else + retval = -EOVERFLOW ; + fh->handle_size = handle_size; + sb = path.mnt->mnt_sb; +if (!retval && sb->s_op->get_fsid) { + this_fs_id = sb->s_op->get_fsid (sb); +memcpy (fh->fsid.uuid, this_fs_id->uuid,sizeof (fh->fsid.uuid)); + }else +memset (fh->fsid.uuid,0 ,sizeof (fh->fsid.uuid)); +kfree (handle); + +err_out: +path_put (&path); +return retval; +} + +SYSCALL_DEFINE2(name_to_handle, const char __user *, name, + struct file_handle __user *, handle) +{ +long ret; +struct file_handle f_handle; +if (copy_from_user (&f_handle, handle,sizeof (struct file_handle ))) { + ret = -EFAULT ; + goto err_out; + } + ret =do_sys_name_to_handle (name, &f_handle); +if (copy_to_user (&handle->handle_type, + &f_handle.handle_type,sizeof (f_handle.handle_type)) || +copy_to_user (&handle->handle_size, + &f_handle.handle_size,sizeof (f_handle.handle_size)) || +copy_to_user (handle->fsid.uuid, + f_handle.fsid.uuid,sizeof (f_handle.fsid.uuid))) { + + ret = -EFAULT ; + } +err_out: +/* avoid REGPARM breakage on x86: */ +asmlinkage_protect (2 , ret, name, handle); +return ret; +}
include/linux/fs.h +19 -0
@@ -948,6 +948,20 @@ struct file {unsigned long f_mnt_write_state;#endif }; + +struct uuid { +char uuid[16 ]; +}; + +struct file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +void *f_handle; +}; +extern spinlock_t files_lock;#define file_list_lock () spin_lock(&files_lock);#define file_list_unlock () spin_unlock(&files_lock);
@@ -1580,6 +1594,7 @@ struct super_operations {ssize_t (*quota_write)(struct super_block *,int ,const char *,size_t ,loff_t );#endif int (*bdev_try_to_free_page)(struct super_block *,struct page *,gfp_t ); +struct uuid *(*get_fsid)(struct super_block *); };/*
@@ -1918,6 +1933,8 @@ extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, const struct cred *);extern int filp_close (struct file *,fl_owner_t id);extern char *getname (const char __user *); +extern long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh);/* fs/ioctl.c */
@@ -2328,6 +2345,8 @@ extern struct super_block *get_super(struct block_device *);extern struct super_block *get_active_super (struct block_device *bdev);extern struct super_block *user_get_super (dev_t );extern void drop_super (struct super_block *sb); +extern struct super_block *fs_get_sb (struct uuid *fsid); +extern int dcache_dir_open (struct inode *,struct file *);extern int dcache_dir_close (struct inode *,struct file *);
Signature · 1 line
1.7.0.4.360.g11766c
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1236
Quoted 7 lines · Aneesh Kumar K.V
fs/open.c +7
-0+long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh) +{ +/* +* name to handle conversion only done for regular files +* directories and symbolic links +*/
Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
I'd always thought it would be cool to have a distributed filesystem where named pipes/sockets work across clients by using the IO transport of the filesystem, making single-system image environments a lot easier to implement.
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1254
Quoted 3 lines
fs/open.c +3
-0+/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path.dentry, (struct fid *)handle, + &handle_size,0 );
Since there is virtually no overhead to do so, why not always return a connected handle? This will allow the kernel to reconnect the looked-up dentries into the tree, instead of creating all disconnected dentries.
Cheers, Andreas
--
Andreas Dilger
Sr. Staff Engineer, Lustre Group
Sun Microsystems of Canada, Inc.
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
Quoted 1 line · Andreas Dilger
Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
This limitation seems to be copied from the original XFS handle code, but I don't see any good reason to stay with it.
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
Quoted 6 lines · Christoph Hellwig
Quoted 1 line · Andreas Dilger
Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
This limitation seems to be copied from the original XFS handle code, but I don't see any good reason to stay with it.
The limitation came from the original XFS handle code. So to support symlink and regular files better i added the below syscalls to the patch set. sys_name_to_handle, sys_lname_to_handle and sys_freadlink. The last to return the link target name from an fd. This enables to use handle for symlink and then use the fd returned from open_by_handle to get the target name. Let me know what you think
-aneesh
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
In reply to Andreas DilgerQuoted 14 lines · Andreas Dilger
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1236
Quoted 7 lines · Aneesh Kumar K.V
fs/open.c +7
-0+long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh) +{ +/* +* name to handle conversion only done for regular files +* directories and symbolic links +*/ Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
The limitation directly came from the XFS ioctl. But I don't see a reason why we should limit it for this syscall. To better support symlink and regular files i now have did sys_name_to_handle and sys_lname_to_handle syscalls. I also did a freadlink syscall that will return the symlink target name from the handle.
Quoted 9 lines
I'd always thought it would be cool to have a distributed filesystem where named pipes/sockets work across clients by using the IO transport of the filesystem, making single-system image environments a lot easier to implement.
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1254
Quoted 3 lines
fs/open.c +3
-0+/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path.dentry, (struct fid *)handle, + &handle_size,0 );Since there is virtually no overhead to do so, why not always return a connected handle? This will allow the kernel to reconnect the looked-up dentries into the tree, instead of creating all disconnected dentries.
open by handle would return a connected dentry for directory. Since we use a simple acceptable function that accept any dentry alias with exportfs_decode_fh I was wondering whether we should return a connected handle ? It would be simply increasing the size of the handle ?
-aneesh
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
Quoted 34 lines · Aneesh Kumar K. V
Quoted 14 lines · Andreas Dilger
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1236
Quoted 7 lines · Aneesh Kumar K.V
fs/open.c +7
-0+long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh) +{ +/* +* name to handle conversion only done for regular files +* directories and symbolic links +*/ Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
The limitation directly came from the XFS ioctl. But I don't see a reason why we should limit it for this syscall. To better support symlink and regular files i now have did
sys_name_to_handleandsys_lname_to_handlesyscalls. I also did a freadlink syscall that will return the symlink target name from the handle.Quoted 9 lines
I'd always thought it would be cool to have a distributed filesystem where named pipes/sockets work across clients by using the IO transport of the filesystem, making single-system image environments a lot easier to implement.
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1254
Quoted 3 lines
fs/open.c +3
-0+/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path.dentry, (struct fid *)handle, + &handle_size,0 );Since there is virtually no overhead to do so, why not always return a connected handle? This will allow the kernel to reconnect the looked-up dentries into the tree, instead of creating all disconnected dentries.
Quoted 4 lines
open by handle would return a connected dentry for directory. Since we use a simple acceptable function that accept any dentry alias with
exportfs_decode_fhI was wondering whether we should return a connected handle ? It would be simply increasing the size of the handle ?
Well, and it means the filehandle changes when you rename the file to a different directory. Do you really want that?
--b.
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
Quoted 35 lines · J. Bruce Fields
Quoted 34 lines · Aneesh Kumar K. V
Quoted 14 lines · Andreas Dilger
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1236
Quoted 7 lines · Aneesh Kumar K.V
fs/open.c +7
-0+long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh) +{ +/* +* name to handle conversion only done for regular files +* directories and symbolic links +*/ Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
The limitation directly came from the XFS ioctl. But I don't see a reason why we should limit it for this syscall. To better support symlink and regular files i now have did
sys_name_to_handleandsys_lname_to_handlesyscalls. I also did a freadlink syscall that will return the symlink target name from the handle.Quoted 9 lines
I'd always thought it would be cool to have a distributed filesystem where named pipes/sockets work across clients by using the IO transport of the filesystem, making single-system image environments a lot easier to implement.
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1254
Quoted 3 lines
fs/open.c +3
-0+/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path.dentry, (struct fid *)handle, + &handle_size,0 );Since there is virtually no overhead to do so, why not always return a connected handle? This will allow the kernel to reconnect the looked-up dentries into the tree, instead of creating all disconnected dentries.
Quoted 8 lines
Quoted 4 lines
open by handle would return a connected dentry for directory. Since we use a simple acceptable function that accept any dentry alias with
exportfs_decode_fhI was wondering whether we should return a connected handle ? It would be simply increasing the size of the handle ?Well, and it means the filehandle changes when you rename the file to a different directory. Do you really want that?
Atleast the usecase i am looking to we should retain the same handle even after rename. So i guess getting a non connected handle is the right thing
-aneesh
Re: [PATCH -V4 2/6] vfs: Add name to file handle conversion support
Quoted 41 lines · Aneesh Kumar K. V
Quoted 40 lines · J. Bruce Fields
Quoted 38 lines · Aneesh Kumar K. V
Quoted 14 lines · Andreas Dilger
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1236
Quoted 7 lines · Aneesh Kumar K.V
fs/open.c +7
-0+long do_sys_name_to_handle (const char __user *name, +struct file_handle *fh) +{ +/* +* name to handle conversion only done for regular files +* directories and symbolic links +*/ Out of curiosity, why not do this for other types of files? It makes sense from a consistency POV, so that the userspace code doesn't have to special-case each file by checking the type first (which would mean doing an extra path traversal and stat for each file first, adding overhead).
The limitation directly came from the XFS ioctl. But I don't see a reason why we should limit it for this syscall. To better support symlink and regular files i now have did
sys_name_to_handleandsys_lname_to_handlesyscalls. I also did a freadlink syscall that will return the symlink target name from the handle.Quoted 9 lines
I'd always thought it would be cool to have a distributed filesystem where named pipes/sockets work across clients by using the IO transport of the filesystem, making single-system image environments a lot easier to implement.
fs/open.c int nonseekable_open(struct inode *inode, struct file *filp) · line 1254
Quoted 3 lines
fs/open.c +3
-0+/* we ask for a non connected handle */ + retval =exportfs_encode_fh (path.dentry, (struct fid *)handle, + &handle_size,0 );Since there is virtually no overhead to do so, why not always return a connected handle? This will allow the kernel to reconnect the looked-up dentries into the tree, instead of creating all disconnected dentries.
open by handle would return a connected dentry for directory. Since we use a simple acceptable function that accept any dentry alias with
exportfs_decode_fhI was wondering whether we should return a connected handle ? It would be simply increasing the size of the handle ?
Quoted 7 lines
Quoted 3 lines
Well, and it means the filehandle changes when you rename the file to a different directory. Do you really want that?
Atleast the usecase i am looking to we should retain the same handle even after rename. So i guess getting a non connected handle is the right thing
I think so. And if somebody really had to have the other behavior, I think it could probably be implented in userspace.
--b.
PATCH 3/6 vfs: Add open by file handle support
In reply to Aneesh Kumar K.V--- fs/filesystems.c | 32 ++++++++- fs/namei.c | 24 ------ fs/namespace.c | 38 ++++++++++ fs/open.c | 155 +++++++++++++++++++++++++++++++++++++++++ fs/pnode.c | 2 +- include/linux/fs.h | 1 + include/linux/mnt_namespace.h | 2 + include/linux/namei.h | 24 ++++++ 8 files changed, 252 insertions(+), 26 deletions(-)
fs/filesystems.c +31 -1
@@ -281,5 +281,35 @@ struct file_system_type *get_fs_type(const char *name) }return fs; } -EXPORT_SYMBOL (get_fs_type); + +struct super_block *fs_get_sb (struct uuid *fsid) +{ +struct uuid *this_fsid; +struct file_system_type *fs_type; +struct super_block *sb, *found_sb =NULL ; + +read_lock (&file_systems_lock); + fs_type = file_systems; +while (fs_type) { +spin_lock (&sb_lock); +list_for_each_entry (sb, &fs_type->fs_supers, s_instances) { +if (!sb->s_op->get_fsid) +continue ; + this_fsid = sb->s_op->get_fsid (sb); +if (!memcmp (fsid->uuid, this_fsid->uuid, +sizeof (this_fsid->uuid))) { +/* found the matching super_block */ +atomic_inc (&sb->s_active); + found_sb = sb; +spin_unlock (&sb_lock); + goto out; + } + } +spin_unlock (&sb_lock); + fs_type = fs_type->next; + } +out: +read_unlock (&file_systems_lock); +return found_sb; +}
fs/namei.c +0 -24
@@ -1521,30 +1521,6 @@ out_unlock:return may_open (&nd->path,0 , open_flag & ~O_TRUNC ); } -/* -* Note that while the flag value (low two bits) for sys_open means: -* 00 - read-only -* 01 - write-only -* 10 - read-write -* 11 - special -* it is changed into -* 00 - no permissions needed -* 01 - read-permission -* 10 - write-permission -* 11 - read-write -* for the internal routines (ie open_namei()/follow_link() etc) -* This is more logical, and also allows the 00 "no perm needed" -* to be used for symlinks (where the permissions are checked -* later). -* -*/ -static inline int open_to_namei_flags (int flag) -{ -if ((flag+1 ) &O_ACCMODE ) - flag++; -return flag; -} -static int open_will_truncate (int flag,struct inode *inode) {/*
fs/namespace.c +38 -0
@@ -2364,3 +2364,41 @@ void put_mnt_ns(struct mnt_namespace *ns)kfree (ns); }EXPORT_SYMBOL (put_mnt_ns); + +/* +* Get any vfsmount mapping the superblock in the +* task namespace +*/ +struct vfsmount *fs_get_vfsmount (struct task_struct *task, +struct super_block *sb) +{ +struct nsproxy *nsp; +struct list_head *mount_list; +struct mnt_namespace *ns =NULL ; +struct vfsmount *mnt, *sb_mnt =NULL ; + +rcu_read_lock (); + nsp =task_nsproxy (task); +if (nsp) { + ns = nsp->mnt_ns; +if (ns) +get_mnt_ns (ns); + } +rcu_read_unlock (); +if (!ns) +return NULL ; +down_read (&namespace_sem); +list_for_each (mount_list, &ns->list) { + mnt = list_entry(mount_list, struct vfsmount, mnt_list); +if (mnt->mnt_sb == sb) { +/* found the matching super block */ + sb_mnt = mnt; +mntget (sb_mnt); +break ; + } + } +up_read (&namespace_sem); + +put_mnt_ns (ns); +return sb_mnt; +}
fs/open.c +155 -0
158 lines not on this page · raw message
fs/pnode.c +1 -1
@@ -6,9 +6,9 @@* Author : Ram Pai ([email protected]) * */ +#include <linux/fs.h> #include <linux/mnt_namespace.h> #include <linux/mount.h> -#include <linux/fs.h> #include "internal.h" #include "pnode.h"
include/linux/fs.h +1 -0
@@ -1935,6 +1935,7 @@ extern int filp_close(struct file *, fl_owner_t id);extern char *getname (const char __user *);extern long do_sys_name_to_handle (const char __user *name,struct file_handle *fh); +extern long do_sys_open_by_handle (struct file_handle *fh,int flags);/* fs/ioctl.c */
include/linux/mnt_namespace.h +2 -0
@@ -36,6 +36,8 @@ extern const struct seq_operations mounts_op;extern const struct seq_operations mountinfo_op;extern const struct seq_operations mountstats_op;extern int mnt_had_events (struct proc_mounts *); +extern struct vfsmount *fs_get_vfsmount (struct task_struct *task, +struct super_block *sb);#endif #endif
include/linux/namei.h +24 -0
@@ -4,6 +4,7 @@#include <linux/dcache.h> #include <linux/linkage.h> #include <linux/path.h> +#include <asm-generic/fcntl.h> struct vfsmount ;
@@ -96,4 +97,27 @@ static inline void nd_terminate_link(void *name, size_t len, size_t maxlen) ((char *) name)[min(len, maxlen)] = '\0'; } +/* +* Note that while the flag value (low two bits) for sys_open means: +* 00 - read-only +* 01 - write-only +* 10 - read-write +* 11 - special +* it is changed into +* 00 - no permissions needed +* 01 - read-permission +* 10 - write-permission +* 11 - read-write +* for the internal routines (ie open_namei()/follow_link() etc) +* This is more logical, and also allows the 00 "no perm needed" +* to be used for symlinks (where the permissions are checked +* later). +* +*/ +static inline int open_to_namei_flags (int flag) +{ +if ((flag+1 ) &O_ACCMODE ) + flag++; +return flag; +}#endif /* _LINUX_NAMEI_H */
Signature · 1 line
1.7.0.4.360.g11766c
PATCH 4/6 ext4: Add get_fsid callback
In reply to Aneesh Kumar K.V--- fs/ext4/super.c | 10 ++++++++++ 1 files changed, 10 insertions(+), 0 deletions(-)
fs/ext4/super.c +10 -0
@@ -1049,6 +1049,14 @@ static int bdev_try_to_free_page(struct super_block *sb, struct page *page,return try_to_free_buffers (page); } +static struct uuid *ext4_get_fsid (struct super_block *sb) +{ +struct ext4_sb_info *sbi =EXT4_SB (sb); +struct ext4_super_block *es = sbi->s_es; + +return (struct uuid *)es->s_uuid; +} +#ifdef CONFIG_QUOTA #define QTYPE2NAME (t) ((t) == USRQUOTA ? "user" : "group")#define QTYPE2MOPT (on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
@@ -1109,6 +1117,7 @@ static const struct super_operations ext4_sops = { .quota_write = ext4_quota_write, #endif .bdev_try_to_free_page = bdev_try_to_free_page, + .get_fsid = ext4_get_fsid, }; static const struct super_operations ext4_nojournal_sops = {
@@ -1128,6 +1137,7 @@ static const struct super_operations ext4_nojournal_sops = { .quota_write = ext4_quota_write, #endif .bdev_try_to_free_page = bdev_try_to_free_page, + .get_fsid = ext4_get_fsid, }; static const struct export_operations ext4_export_ops = {
Signature · 1 line
1.7.0.4.360.g11766c
PATCH 5/6 x86: Add new syscalls for x86_32
In reply to Aneesh Kumar K.VThis patch adds sys_name_to_handle and sys_open_by_handle syscalls to x86_32
--- arch/x86/include/asm/unistd_32.h | 4 +++- arch/x86/kernel/syscall_table_32.S | 2 ++ 2 files changed, 5 insertions(+), 1 deletions(-)
arch/x86/include/asm/unistd_32.h +3 -1
@@ -343,10 +343,12 @@#define __NR_rt_tgsigqueueinfo 335#define __NR_perf_event_open 336#define __NR_recvmmsg 337 +#define __NR_name_to_handle 338 +#define __NR_open_by_handle 339#ifdef __KERNEL__ -#define NR_syscalls 338 +#define NR_syscalls 340#define __ARCH_WANT_IPC_PARSE_VERSION#define __ARCH_WANT_OLD_READDIR
arch/x86/kernel/syscall_table_32.S +2 -0
@@ -337,3 +337,5 @@ ENTRY(sys_call_table) .long sys_rt_tgsigqueueinfo /* 335 */ .long sys_perf_event_open .long sys_recvmmsg + .long sys_name_to_handle + .long sys_open_by_handle /* 339 */
Signature · 1 line
1.7.0.4.360.g11766c
PATCH 6/6 x86: Add new syscalls for x86_64
In reply to Aneesh Kumar K.VAdd sys_name_to_handle and sys_open_by_handle syscall for x86_64 Add necessary compat syscall support
--- arch/x86/ia32/ia32entry.S | 2 + arch/x86/include/asm/unistd_64.h | 4 ++ fs/compat.c | 72 ++++++++++++++++++++++++++++++++++++++ include/linux/compat.h | 14 +++++++ 4 files changed, 92 insertions(+), 0 deletions(-)
arch/x86/ia32/ia32entry.S +2 -0
@@ -842,4 +842,6 @@ ia32_sys_call_table: .quad compat_sys_rt_tgsigqueueinfo /* 335 */ .quad sys_perf_event_open .quad compat_sys_recvmmsg + .quad compat_sys_name_to_handle + .quad compat_sys_open_by_handle /* 339 */ ia32_syscall_end:
arch/x86/include/asm/unistd_64.h +4 -0
@@ -663,6 +663,10 @@ __SYSCALL(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo) __SYSCALL(__NR_perf_event_open, sys_perf_event_open)#define __NR_recvmmsg 299 __SYSCALL(__NR_recvmmsg, sys_recvmmsg) +#define __NR_name_to_handle 300 +__SYSCALL(__NR_name_to_handle, sys_name_to_handle) +#define __NR_open_by_handle 301 +__SYSCALL(__NR_open_by_handle, sys_open_by_handle)#ifndef __NO_STUBS#define __ARCH_WANT_OLD_READDIR
fs/compat.c +72 -0
75 lines not on this page · raw message
include/linux/compat.h +14 -0
@@ -12,6 +12,7 @@#include <linux/sem.h> #include <linux/socket.h> #include <linux/if.h> +#include <linux/fs.h> #include <asm/compat.h> #include <asm/siginfo.h>
@@ -209,6 +210,15 @@ struct compat_robust_list_head {compat_uptr_t list_op_pending; }; +struct compat_file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +compat_uptr_t f_handle; +}; +extern void compat_exit_robust_list (struct task_struct *curr);asmlinkage long
@@ -355,6 +365,10 @@ asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user * filename, int flag);asmlinkage long compat_sys_openat (unsigned int dfd,const char __user *filename,int flags,int mode); +asmlinkage long compat_sys_name_to_handle (const char __user *name, +struct compat_file_handle __user *uh); +asmlinkage long compat_sys_open_by_handle (struct compat_file_handle __user *uh, +int flags);#endif /* CONFIG_COMPAT */ #endif /* _LINUX_COMPAT_H */
Signature · 1 line
1.7.0.4.360.g11766c
Re: [PATCH -V4 6/6] x86: Add new syscalls for x86_64
Quoted 1 line · Aneesh Kumar K.V
Add necessary compat syscall support
Maybe I'm missing something, but why would we add a new syscall that immediately needs a compat interface? I thought the kernel would simply return the packed file handle to userspace, instead of returning a pointer?
include/linux/compat.h struct compat_robust_list_head { · line 220
Quoted 8 lines
include/linux/compat.h +8
-0+struct compat_file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +compat_uptr_t f_handle; +};
Cheers, Andreas
--
Andreas Dilger
Sr. Staff Engineer, Lustre Group
Sun Microsystems of Canada, Inc.
Re: [PATCH -V4 6/6] x86: Add new syscalls for x86_64
Quoted 5 lines · Andreas Dilger
Quoted 1 line · Aneesh Kumar K.V
Add necessary compat syscall support
Maybe I'm missing something, but why would we add a new syscall that immediately needs a compat interface? I thought the kernel would simply return the packed file handle to userspace, instead of returning a pointer?
Quoted 9 lines
include/linux/compat.h struct compat_robust_list_head { · line 220
Quoted 8 lines
include/linux/compat.h +8
-0+struct compat_file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +compat_uptr_t f_handle; +};
I want to make sure we put uuid part of the fs as a separate member. I guess we could avoid compat interface if we define the syscall as
open_by_handle(struct file_handle *handle, int size, int flags);
But the handle in the above case will not be usable if the file handle returned is too big to be usable by a cluster file system because of the UUID part of handle. Having uuid as a seperate member allows such userspace to generate a smaller unique identifier for the filesystem and still use the void *f_handle part of the struct file_handle.
With struct file_handle since we have void * usage i guess we would need a compat interface.
-aneesh
Re: [PATCH -V4 6/6] x86: Add new syscalls for x86_64
Quoted 22 lines · Aneesh Kumar K. V
Quoted 5 lines · Andreas Dilger
Quoted 1 line · Aneesh Kumar K.V
Add necessary compat syscall support
Maybe I'm missing something, but why would we add a new syscall that immediately needs a compat interface? I thought the kernel would simply return the packed file handle to userspace, instead of returning a pointer?
Quoted 9 lines
include/linux/compat.h struct compat_robust_list_head { · line 220
Quoted 8 lines
include/linux/compat.h +8
-0+struct compat_file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +compat_uptr_t f_handle; +};I want to make sure we put uuid part of the fs as a separate member. I guess we could avoid compat interface if we define the syscall as
open_by_handle(struct file_handle *handle, int size, int flags);
Quoted 8 lines
But the handle in the above case will not be usable if the file handle returned is too big to be usable by a cluster file system because of the UUID part of handle. Having uuid as a seperate member allows such userspace to generate a smaller unique identifier for the filesystem and still use the void
*f_handlepart of the structfile_handle.With struct
file_handlesince we have void * usage i guess we would need a compat interface.
You can juse make the handle a
char f_handle[0];
member and the structure variable size.
Re: [PATCH -V4 6/6] x86: Add new syscalls for x86_64
Quoted 28 lines · Christoph Hellwig
Quoted 27 lines · Aneesh Kumar K. V
Quoted 5 lines · Andreas Dilger
Quoted 1 line · Aneesh Kumar K.V
Add necessary compat syscall support
Maybe I'm missing something, but why would we add a new syscall that immediately needs a compat interface? I thought the kernel would simply return the packed file handle to userspace, instead of returning a pointer?
Quoted 8 lines
include/linux/compat.h struct compat_robust_list_head { · line 220
Quoted 8 lines
include/linux/compat.h +8
-0+struct compat_file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +compat_uptr_t f_handle; +};I want to make sure we put uuid part of the fs as a separate member. I guess we could avoid compat interface if we define the syscall as
open_by_handle(struct file_handle *handle, int size, int flags);But the handle in the above case will not be usable if the file handle returned is too big to be usable by a cluster file system because of the UUID part of handle. Having uuid as a seperate member allows such userspace to generate a smaller unique identifier for the filesystem and still use the void
*f_handlepart of the structfile_handle.
Quoted 8 lines
Quoted 2 lines
With struct
file_handlesince we have void * usage i guess we would need a compat interface.You can juse make the handle a
char f_handle[0];member and the structure variable size.
Exactly. The filesystem knows what the total size is including the UUID (in fact it would be better to allow the UUIDs to be variable-sized also), and userspace should be able to treat this as an opaque blob, beyond the the size.
By having userspace "decode" the file handle in order to determine the handle size, copy the pointer data, etc. then you introduce much more complexity into the whole process.
It makes me wonder if we should have some sort of "handle version" in order to allow the kernel to verify what it is being passed, in case we want to change the interface in the future.
Cheers, Andreas
--
Andreas Dilger
Sr. Staff Engineer, Lustre Group
Sun Microsystems of Canada, Inc.
Re: [PATCH -V4 6/6] x86: Add new syscalls for x86_64
In reply to Christoph HellwigQuoted 29 lines · Christoph Hellwig
Quoted 28 lines · Aneesh Kumar K. V
Quoted 5 lines · Andreas Dilger
Quoted 1 line · Aneesh Kumar K.V
Add necessary compat syscall support
Maybe I'm missing something, but why would we add a new syscall that immediately needs a compat interface? I thought the kernel would simply return the packed file handle to userspace, instead of returning a pointer?
Quoted 9 lines
include/linux/compat.h struct compat_robust_list_head { · line 220
Quoted 8 lines
include/linux/compat.h +8
-0+struct compat_file_handle { +int handle_size; +int handle_type; +/* File system identifier */ +struct uuid fsid; +/* file identifier */ +compat_uptr_t f_handle; +};I want to make sure we put uuid part of the fs as a separate member. I guess we could avoid compat interface if we define the syscall as
open_by_handle(struct file_handle *handle, int size, int flags);But the handle in the above case will not be usable if the file handle returned is too big to be usable by a cluster file system because of the UUID part of handle. Having uuid as a seperate member allows such userspace to generate a smaller unique identifier for the filesystem and still use the void
*f_handlepart of the structfile_handle.
Quoted 9 lines
Quoted 2 lines
With struct
file_handlesince we have void * usage i guess we would need a compat interface.You can juse make the handle a
char f_handle[0];member and the structure variable size.
Even with the above change i guess we would need a compat_sys_open_by_handle to make sure we don't pass O_LARGEFILE similar to what is done in compat_sys_open
-aneesh