Re: [PATCH] ovl: factor out some common helpers for backing files io

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



[forgot to CC overlayfs list]

On Tue, Sep 12, 2023 at 9:54 PM Amir Goldstein <amir73il@xxxxxxxxx> wrote:
>
> Overlayfs stores its files data in backing files on other filesystems.
>
> Factor out some common helpers to perform io to backing files, that will
> later be reused by fuse passthrough code.
>
> Suggested-by: Miklos Szeredi <miklos@xxxxxxxxxx>
> Link: https://lore.kernel.org/r/CAJfpeguhmZbjP3JLqtUy0AdWaHOkAPWeP827BBWwRFEAUgnUcQ@xxxxxxxxxxxxxx
> Signed-off-by: Amir Goldstein <amir73il@xxxxxxxxx>
> ---
>
> Miklos,
>
> This is the re-factoring that you suggested in the FUSE passthrough
> patches discussion linked above.
>
> This patch is based on the overlayfs prep patch set I just posted [1].
>
> Although overlayfs currently is the only user of these backing file
> helpers, I am sending this patch to a wider audience in case other
> filesystem developers want to comment on the abstraction.
>
> We could perhaps later considering moving backing_file_open() helper
> and related code to backing_file.c.
>
> In any case, if there are no objections, I plan to queue this work
> for 6.7 via the overlayfs tree.
>
> Thanks,
> Amir.
>
> [1] https://lore.kernel.org/linux-unionfs/20230912173653.3317828-1-amir73il@xxxxxxxxx/
>
>
>  MAINTAINERS                  |   2 +
>  fs/Kconfig                   |   4 +
>  fs/Makefile                  |   1 +
>  fs/backing_file.c            | 160 +++++++++++++++++++++++++++++++++++
>  fs/overlayfs/Kconfig         |   1 +
>  fs/overlayfs/file.c          | 137 ++----------------------------
>  fs/overlayfs/overlayfs.h     |   2 -
>  fs/overlayfs/super.c         |  11 +--
>  include/linux/backing_file.h |  22 +++++
>  9 files changed, 199 insertions(+), 141 deletions(-)
>  create mode 100644 fs/backing_file.c
>  create mode 100644 include/linux/backing_file.h
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 90f13281d297..4e1d21773e0e 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -16092,7 +16092,9 @@ L:      linux-unionfs@xxxxxxxxxxxxxxx
>  S:     Supported
>  T:     git git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs.git
>  F:     Documentation/filesystems/overlayfs.rst
> +F:     fs/backing_file.c
>  F:     fs/overlayfs/
> +F:     include/linux/backing_file.h
>
>  P54 WIRELESS DRIVER
>  M:     Christian Lamparter <chunkeey@xxxxxxxxxxxxxx>
> diff --git a/fs/Kconfig b/fs/Kconfig
> index aa7e03cc1941..9027a88ffa47 100644
> --- a/fs/Kconfig
> +++ b/fs/Kconfig
> @@ -26,6 +26,10 @@ config LEGACY_DIRECT_IO
>         depends on BUFFER_HEAD
>         bool
>
> +# Common backing file helpers
> +config FS_BACKING_FILE
> +       bool
> +
>  if BLOCK
>
>  source "fs/ext2/Kconfig"
> diff --git a/fs/Makefile b/fs/Makefile
> index f9541f40be4e..95ef06cff388 100644
> --- a/fs/Makefile
> +++ b/fs/Makefile
> @@ -39,6 +39,7 @@ obj-$(CONFIG_COMPAT_BINFMT_ELF)       += compat_binfmt_elf.o
>  obj-$(CONFIG_BINFMT_ELF_FDPIC) += binfmt_elf_fdpic.o
>  obj-$(CONFIG_BINFMT_FLAT)      += binfmt_flat.o
>
> +obj-$(CONFIG_FS_BACKING_FILE)  += backing_file.o
>  obj-$(CONFIG_FS_MBCACHE)       += mbcache.o
>  obj-$(CONFIG_FS_POSIX_ACL)     += posix_acl.o
>  obj-$(CONFIG_NFS_COMMON)       += nfs_common/
> diff --git a/fs/backing_file.c b/fs/backing_file.c
> new file mode 100644
> index 000000000000..ea895ca1639d
> --- /dev/null
> +++ b/fs/backing_file.c
> @@ -0,0 +1,160 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Common helpers for backing file io.
> + * Forked from fs/overlayfs/file.c.
> + *
> + * Copyright (C) 2017 Red Hat, Inc.
> + * Copyright (C) 2023 CTERA Networks.
> + */
> +
> +#include <linux/backing_file.h>
> +
> +struct backing_aio_req {
> +       struct kiocb iocb;
> +       refcount_t ref;
> +       struct kiocb *orig_iocb;
> +       void (*cleanup)(struct kiocb *, long);
> +};
> +
> +static struct kmem_cache *backing_aio_req_cachep;
> +
> +#define BACKING_IOCB_MASK \
> +       (IOCB_NOWAIT | IOCB_HIPRI | IOCB_DSYNC | IOCB_SYNC | IOCB_APPEND)
> +
> +static rwf_t iocb_to_rw_flags(int flags)
> +{
> +       return (__force rwf_t)(flags & BACKING_IOCB_MASK);
> +}
> +
> +static void backing_aio_put(struct backing_aio_req *aio_req)
> +{
> +       if (refcount_dec_and_test(&aio_req->ref)) {
> +               fput(aio_req->iocb.ki_filp);
> +               kmem_cache_free(backing_aio_req_cachep, aio_req);
> +       }
> +}
> +
> +/* Completion for submitted/failed async rw io */
> +static void backing_aio_cleanup(struct backing_aio_req *aio_req, long res)
> +{
> +       struct kiocb *iocb = &aio_req->iocb;
> +       struct kiocb *orig_iocb = aio_req->orig_iocb;
> +
> +       if (iocb->ki_flags & IOCB_WRITE)
> +               kiocb_end_write(iocb);
> +
> +       orig_iocb->ki_pos = iocb->ki_pos;
> +       if (aio_req->cleanup)
> +               aio_req->cleanup(orig_iocb, res);
> +
> +       backing_aio_put(aio_req);
> +}
> +
> +/* Completion for submitted async rw io */
> +static void backing_aio_rw_complete(struct kiocb *iocb, long res)
> +{
> +       struct backing_aio_req *aio_req = container_of(iocb,
> +                                              struct backing_aio_req, iocb);
> +       struct kiocb *orig_iocb = aio_req->orig_iocb;
> +
> +       backing_aio_cleanup(aio_req, res);
> +       orig_iocb->ki_complete(orig_iocb, res);
> +}
> +
> +
> +ssize_t backing_file_read_iter(struct file *file, struct iov_iter *iter,
> +                              struct kiocb *iocb, int flags,
> +                              void (*cleanup)(struct kiocb *, long))
> +{
> +       struct backing_aio_req *aio_req = NULL;
> +       ssize_t ret;
> +
> +       if (!iov_iter_count(iter))
> +               return 0;
> +
> +       if (iocb->ki_flags & IOCB_DIRECT &&
> +           !(file->f_mode & FMODE_CAN_ODIRECT))
> +               return -EINVAL;
> +
> +       if (is_sync_kiocb(iocb)) {
> +               rwf_t rwf = iocb_to_rw_flags(flags);
> +
> +               ret = vfs_iter_read(file, iter, &iocb->ki_pos, rwf);
> +               if (cleanup)
> +                       cleanup(iocb, ret);
> +       } else {
> +               aio_req = kmem_cache_zalloc(backing_aio_req_cachep, GFP_KERNEL);
> +               if (!aio_req)
> +                       return -ENOMEM;
> +
> +               aio_req->orig_iocb = iocb;
> +               aio_req->cleanup = cleanup;
> +               kiocb_clone(&aio_req->iocb, iocb, get_file(file));
> +               aio_req->iocb.ki_complete = backing_aio_rw_complete;
> +               refcount_set(&aio_req->ref, 2);
> +               ret = vfs_iocb_iter_read(file, &aio_req->iocb, iter);
> +               backing_aio_put(aio_req);
> +               if (ret != -EIOCBQUEUED)
> +                       backing_aio_cleanup(aio_req, ret);
> +       }
> +
> +       return ret;
> +}
> +EXPORT_SYMBOL_GPL(backing_file_read_iter);
> +
> +ssize_t backing_file_write_iter(struct file *file, struct iov_iter *iter,
> +                               struct kiocb *iocb, int flags,
> +                               void (*cleanup)(struct kiocb *, long))
> +{
> +       ssize_t ret;
> +
> +       if (!iov_iter_count(iter))
> +               return 0;
> +
> +       if (iocb->ki_flags & IOCB_DIRECT &&
> +           !(file->f_mode & FMODE_CAN_ODIRECT))
> +               return -EINVAL;
> +
> +       if (is_sync_kiocb(iocb)) {
> +               rwf_t rwf = iocb_to_rw_flags(flags);
> +
> +               file_start_write(file);
> +               ret = vfs_iter_write(file, iter, &iocb->ki_pos, rwf);
> +               file_end_write(file);
> +               if (cleanup)
> +                       cleanup(iocb, ret);
> +       } else {
> +               struct backing_aio_req *aio_req;
> +
> +               aio_req = kmem_cache_zalloc(backing_aio_req_cachep, GFP_KERNEL);
> +               if (!aio_req)
> +                       return -ENOMEM;
> +
> +               aio_req->orig_iocb = iocb;
> +               aio_req->cleanup = cleanup;
> +               kiocb_clone(&aio_req->iocb, iocb, get_file(file));
> +               aio_req->iocb.ki_flags = flags;
> +               aio_req->iocb.ki_complete = backing_aio_rw_complete;
> +               refcount_set(&aio_req->ref, 2);
> +               kiocb_start_write(&aio_req->iocb);
> +               ret = vfs_iocb_iter_write(file, &aio_req->iocb, iter);
> +               backing_aio_put(aio_req);
> +               if (ret != -EIOCBQUEUED)
> +                       backing_aio_cleanup(aio_req, ret);
> +       }
> +
> +       return ret;
> +}
> +EXPORT_SYMBOL_GPL(backing_file_write_iter);
> +
> +static int __init backing_aio_init(void)
> +{
> +       backing_aio_req_cachep = kmem_cache_create("backing_aio_req",
> +                                          sizeof(struct backing_aio_req),
> +                                          0, SLAB_HWCACHE_ALIGN, NULL);
> +       if (!backing_aio_req_cachep)
> +               return -ENOMEM;
> +
> +       return 0;
> +}
> +fs_initcall(backing_aio_init);
> diff --git a/fs/overlayfs/Kconfig b/fs/overlayfs/Kconfig
> index fec5020c3495..7f52d9031cff 100644
> --- a/fs/overlayfs/Kconfig
> +++ b/fs/overlayfs/Kconfig
> @@ -1,6 +1,7 @@
>  # SPDX-License-Identifier: GPL-2.0-only
>  config OVERLAY_FS
>         tristate "Overlay filesystem support"
> +       select FS_BACKING_FILE
>         select EXPORTFS
>         help
>           An overlay filesystem combines two filesystems - an 'upper' filesystem
> diff --git a/fs/overlayfs/file.c b/fs/overlayfs/file.c
> index 05ec614f7054..81fe6a85cad9 100644
> --- a/fs/overlayfs/file.c
> +++ b/fs/overlayfs/file.c
> @@ -13,16 +13,9 @@
>  #include <linux/security.h>
>  #include <linux/mm.h>
>  #include <linux/fs.h>
> +#include <linux/backing_file.h>
>  #include "overlayfs.h"
>
> -struct ovl_aio_req {
> -       struct kiocb iocb;
> -       refcount_t ref;
> -       struct kiocb *orig_iocb;
> -};
> -
> -static struct kmem_cache *ovl_aio_request_cachep;
> -
>  static char ovl_whatisit(struct inode *inode, struct inode *realinode)
>  {
>         if (realinode != ovl_inode_upper(inode))
> @@ -262,24 +255,8 @@ static void ovl_file_accessed(struct file *file)
>         touch_atime(&file->f_path);
>  }
>
> -#define OVL_IOCB_MASK \
> -       (IOCB_NOWAIT | IOCB_HIPRI | IOCB_DSYNC | IOCB_SYNC | IOCB_APPEND)
> -
> -static rwf_t iocb_to_rw_flags(int flags)
> -{
> -       return (__force rwf_t)(flags & OVL_IOCB_MASK);
> -}
> -
> -static inline void ovl_aio_put(struct ovl_aio_req *aio_req)
> -{
> -       if (refcount_dec_and_test(&aio_req->ref)) {
> -               fput(aio_req->iocb.ki_filp);
> -               kmem_cache_free(ovl_aio_request_cachep, aio_req);
> -       }
> -}
> -
>  /* Completion for submitted/failed sync/async rw io */
> -static void ovl_rw_complete(struct kiocb *orig_iocb)
> +static void ovl_rw_complete(struct kiocb *orig_iocb, long res)
>  {
>         struct file *file = orig_iocb->ki_filp;
>
> @@ -292,32 +269,6 @@ static void ovl_rw_complete(struct kiocb *orig_iocb)
>         }
>  }
>
> -/* Completion for submitted/failed async rw io */
> -static void ovl_aio_cleanup(struct ovl_aio_req *aio_req)
> -{
> -       struct kiocb *iocb = &aio_req->iocb;
> -       struct kiocb *orig_iocb = aio_req->orig_iocb;
> -
> -       if (iocb->ki_flags & IOCB_WRITE)
> -               kiocb_end_write(iocb);
> -
> -       orig_iocb->ki_pos = iocb->ki_pos;
> -       ovl_rw_complete(orig_iocb);
> -
> -       ovl_aio_put(aio_req);
> -}
> -
> -/* Completion for submitted async rw io */
> -static void ovl_aio_rw_complete(struct kiocb *iocb, long res)
> -{
> -       struct ovl_aio_req *aio_req = container_of(iocb,
> -                                                  struct ovl_aio_req, iocb);
> -       struct kiocb *orig_iocb = aio_req->orig_iocb;
> -
> -       ovl_aio_cleanup(aio_req);
> -       orig_iocb->ki_complete(orig_iocb, res);
> -}
> -
>  static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter)
>  {
>         struct file *file = iocb->ki_filp;
> @@ -332,38 +283,10 @@ static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter)
>         if (ret)
>                 return ret;
>
> -       ret = -EINVAL;
> -       if (iocb->ki_flags & IOCB_DIRECT &&
> -           !(real.file->f_mode & FMODE_CAN_ODIRECT))
> -               goto out_fdput;
> -
>         old_cred = ovl_override_creds(file_inode(file)->i_sb);
> -       if (is_sync_kiocb(iocb)) {
> -               rwf_t rwf = iocb_to_rw_flags(iocb->ki_flags);
> -
> -               ret = vfs_iter_read(real.file, iter, &iocb->ki_pos, rwf);
> -               ovl_rw_complete(iocb);
> -       } else {
> -               struct ovl_aio_req *aio_req;
> -
> -               ret = -ENOMEM;
> -               aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);
> -               if (!aio_req)
> -                       goto out;
> -
> -               real.flags = 0;
> -               aio_req->orig_iocb = iocb;
> -               kiocb_clone(&aio_req->iocb, iocb, get_file(real.file));
> -               aio_req->iocb.ki_complete = ovl_aio_rw_complete;
> -               refcount_set(&aio_req->ref, 2);
> -               ret = vfs_iocb_iter_read(real.file, &aio_req->iocb, iter);
> -               ovl_aio_put(aio_req);
> -               if (ret != -EIOCBQUEUED)
> -                       ovl_aio_cleanup(aio_req);
> -       }
> -out:
> +       ret = backing_file_read_iter(real.file, iter, iocb, iocb->ki_flags,
> +                                    ovl_rw_complete);
>         revert_creds(old_cred);
> -out_fdput:
>         fdput(real);
>
>         return ret;
> @@ -392,45 +315,13 @@ static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter)
>         if (ret)
>                 goto out_unlock;
>
> -       ret = -EINVAL;
> -       if (iocb->ki_flags & IOCB_DIRECT &&
> -           !(real.file->f_mode & FMODE_CAN_ODIRECT))
> -               goto out_fdput;
> -
>         if (!ovl_should_sync(OVL_FS(inode->i_sb)))
>                 flags &= ~(IOCB_DSYNC | IOCB_SYNC);
>
>         old_cred = ovl_override_creds(inode->i_sb);
> -       if (is_sync_kiocb(iocb)) {
> -               rwf_t rwf = iocb_to_rw_flags(flags);
> -
> -               file_start_write(real.file);
> -               ret = vfs_iter_write(real.file, iter, &iocb->ki_pos, rwf);
> -               file_end_write(real.file);
> -               ovl_rw_complete(iocb);
> -       } else {
> -               struct ovl_aio_req *aio_req;
> -
> -               ret = -ENOMEM;
> -               aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);
> -               if (!aio_req)
> -                       goto out;
> -
> -               real.flags = 0;
> -               aio_req->orig_iocb = iocb;
> -               kiocb_clone(&aio_req->iocb, iocb, get_file(real.file));
> -               aio_req->iocb.ki_flags = flags;
> -               aio_req->iocb.ki_complete = ovl_aio_rw_complete;
> -               refcount_set(&aio_req->ref, 2);
> -               kiocb_start_write(&aio_req->iocb);
> -               ret = vfs_iocb_iter_write(real.file, &aio_req->iocb, iter);
> -               ovl_aio_put(aio_req);
> -               if (ret != -EIOCBQUEUED)
> -                       ovl_aio_cleanup(aio_req);
> -       }
> -out:
> +       ret = backing_file_write_iter(real.file, iter, iocb, flags,
> +                                     ovl_rw_complete);
>         revert_creds(old_cred);
> -out_fdput:
>         fdput(real);
>
>  out_unlock:
> @@ -742,19 +633,3 @@ const struct file_operations ovl_file_operations = {
>         .copy_file_range        = ovl_copy_file_range,
>         .remap_file_range       = ovl_remap_file_range,
>  };
> -
> -int __init ovl_aio_request_cache_init(void)
> -{
> -       ovl_aio_request_cachep = kmem_cache_create("ovl_aio_req",
> -                                                  sizeof(struct ovl_aio_req),
> -                                                  0, SLAB_HWCACHE_ALIGN, NULL);
> -       if (!ovl_aio_request_cachep)
> -               return -ENOMEM;
> -
> -       return 0;
> -}
> -
> -void ovl_aio_request_cache_destroy(void)
> -{
> -       kmem_cache_destroy(ovl_aio_request_cachep);
> -}
> diff --git a/fs/overlayfs/overlayfs.h b/fs/overlayfs/overlayfs.h
> index 9817b2dcb132..64b98e67e826 100644
> --- a/fs/overlayfs/overlayfs.h
> +++ b/fs/overlayfs/overlayfs.h
> @@ -799,8 +799,6 @@ struct dentry *ovl_create_temp(struct ovl_fs *ofs, struct dentry *workdir,
>
>  /* file.c */
>  extern const struct file_operations ovl_file_operations;
> -int __init ovl_aio_request_cache_init(void);
> -void ovl_aio_request_cache_destroy(void);
>  int ovl_real_fileattr_get(const struct path *realpath, struct fileattr *fa);
>  int ovl_real_fileattr_set(const struct path *realpath, struct fileattr *fa);
>  int ovl_fileattr_get(struct dentry *dentry, struct fileattr *fa);
> diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
> index def266b5e2a3..8c132467fca1 100644
> --- a/fs/overlayfs/super.c
> +++ b/fs/overlayfs/super.c
> @@ -1530,14 +1530,10 @@ static int __init ovl_init(void)
>         if (ovl_inode_cachep == NULL)
>                 return -ENOMEM;
>
> -       err = ovl_aio_request_cache_init();
> -       if (!err) {
> -               err = register_filesystem(&ovl_fs_type);
> -               if (!err)
> -                       return 0;
> +       err = register_filesystem(&ovl_fs_type);
> +       if (!err)
> +               return 0;
>
> -               ovl_aio_request_cache_destroy();
> -       }
>         kmem_cache_destroy(ovl_inode_cachep);
>
>         return err;
> @@ -1553,7 +1549,6 @@ static void __exit ovl_exit(void)
>          */
>         rcu_barrier();
>         kmem_cache_destroy(ovl_inode_cachep);
> -       ovl_aio_request_cache_destroy();
>  }
>
>  module_init(ovl_init);
> diff --git a/include/linux/backing_file.h b/include/linux/backing_file.h
> new file mode 100644
> index 000000000000..1428fe7b26bb
> --- /dev/null
> +++ b/include/linux/backing_file.h
> @@ -0,0 +1,22 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Common helpers for backing file io.
> + *
> + * Copyright (C) 2023 CTERA Networks.
> + */
> +
> +#ifndef _LINUX_BACKING_FILE_H
> +#define _LINUX_BACKING_FILE_H
> +
> +#include <linux/file.h>
> +#include <linux/uio.h>
> +#include <linux/fs.h>
> +
> +ssize_t backing_file_read_iter(struct file *file, struct iov_iter *iter,
> +                              struct kiocb *iocb, int flags,
> +                              void (*cleanup)(struct kiocb *, long));
> +ssize_t backing_file_write_iter(struct file *file, struct iov_iter *iter,
> +                               struct kiocb *iocb, int flags,
> +                               void (*cleanup)(struct kiocb *, long));
> +
> +#endif /* _LINUX_BACKING_FILE_H */
> --
> 2.34.1
>




[Index of Archives]     [Linux Ext4 Filesystem]     [Union Filesystem]     [Filesystem Testing]     [Ceph Users]     [Ecryptfs]     [NTFS 3]     [AutoFS]     [Kernel Newbies]     [Share Photos]     [Security]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux Cachefs]     [Reiser Filesystem]     [Linux RAID]     [NTFS 3]     [Samba]     [Device Mapper]     [CEPH Development]

  Powered by Linux