[linux-block.git] / fs / overlayfs / file.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2017 Red Hat, Inc.
 */

#include <linux/cred.h>
#include <linux/file.h>
#include <linux/mount.h>
#include <linux/xattr.h>
#include <linux/uio.h>
#include <linux/uaccess.h>
#include <linux/splice.h>
#include <linux/security.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include "overlayfs.h"

struct ovl_aio_req {
	struct kiocb iocb;
	refcount_t ref;
	struct kiocb *orig_iocb;
	struct fd fd;
};

static struct kmem_cache *ovl_aio_request_cachep;

static char ovl_whatisit(struct inode *inode, struct inode *realinode)
{
	if (realinode != ovl_inode_upper(inode))
		return 'l';
	if (ovl_has_upperdata(inode))
		return 'u';
	else
		return 'm';
}

/* No atime modification nor notify on underlying */
#define OVL_OPEN_FLAGS (O_NOATIME | FMODE_NONOTIFY)

static struct file *ovl_open_realfile(const struct file *file,
				      const struct path *realpath)
{
	struct inode *realinode = d_inode(realpath->dentry);
	struct inode *inode = file_inode(file);
	struct mnt_idmap *real_idmap;
	struct file *realfile;
	const struct cred *old_cred;
	int flags = file->f_flags | OVL_OPEN_FLAGS;
	int acc_mode = ACC_MODE(flags);
	int err;

	if (flags & O_APPEND)
		acc_mode |= MAY_APPEND;

	old_cred = ovl_override_creds(inode->i_sb);
	real_idmap = mnt_idmap(realpath->mnt);
	err = inode_permission(real_idmap, realinode, MAY_OPEN | acc_mode);
	if (err) {
		realfile = ERR_PTR(err);
	} else {
		if (!inode_owner_or_capable(real_idmap, realinode))
			flags &= ~O_NOATIME;

		realfile = open_with_fake_path(&file->f_path, flags, realinode,
					       current_cred());
	}
	revert_creds(old_cred);

	pr_debug("open(%p[%pD2/%c], 0%o) -> (%p, 0%o)\n",
		 file, file, ovl_whatisit(inode, realinode), file->f_flags,
		 realfile, IS_ERR(realfile) ? 0 : realfile->f_flags);

	return realfile;
}

#define OVL_SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT)

static int ovl_change_flags(struct file *file, unsigned int flags)
{
	struct inode *inode = file_inode(file);
	int err;

	flags &= OVL_SETFL_MASK;

	if (((flags ^ file->f_flags) & O_APPEND) && IS_APPEND(inode))
		return -EPERM;

	if ((flags & O_DIRECT) && !(file->f_mode & FMODE_CAN_ODIRECT))
		return -EINVAL;

	if (file->f_op->check_flags) {
		err = file->f_op->check_flags(flags);
		if (err)
			return err;
	}

	spin_lock(&file->f_lock);
	file->f_flags = (file->f_flags & ~OVL_SETFL_MASK) | flags;
	file->f_iocb_flags = iocb_flags(file);
	spin_unlock(&file->f_lock);

	return 0;
}

static int ovl_real_fdget_meta(const struct file *file, struct fd *real,
			       bool allow_meta)
{
	struct dentry *dentry = file_dentry(file);
	struct path realpath;

	real->flags = 0;
	real->file = file->private_data;

	if (allow_meta)
		ovl_path_real(dentry, &realpath);
	else
		ovl_path_realdata(dentry, &realpath);

	/* Has it been copied up since we'd opened it? */
	if (unlikely(file_inode(real->file) != d_inode(realpath.dentry))) {
		real->flags = FDPUT_FPUT;
		real->file = ovl_open_realfile(file, &realpath);

		return PTR_ERR_OR_ZERO(real->file);
	}

	/* Did the flags change since open? */
	if (unlikely((file->f_flags ^ real->file->f_flags) & ~OVL_OPEN_FLAGS))
		return ovl_change_flags(real->file, file->f_flags);

	return 0;
}

static int ovl_real_fdget(const struct file *file, struct fd *real)
{
	if (d_is_dir(file_dentry(file))) {
		real->flags = 0;
		real->file = ovl_dir_real_file(file, false);

		return PTR_ERR_OR_ZERO(real->file);
	}

	return ovl_real_fdget_meta(file, real, false);
}

static int ovl_open(struct inode *inode, struct file *file)
{
	struct dentry *dentry = file_dentry(file);
	struct file *realfile;
	struct path realpath;
	int err;

	err = ovl_maybe_copy_up(dentry, file->f_flags);
	if (err)
		return err;

	/* No longer need these flags, so don't pass them on to underlying fs */
	file->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);

	ovl_path_realdata(dentry, &realpath);
	realfile = ovl_open_realfile(file, &realpath);
	if (IS_ERR(realfile))
		return PTR_ERR(realfile);

	file->private_data = realfile;

	return 0;
}

static int ovl_release(struct inode *inode, struct file *file)
{
	fput(file->private_data);

	return 0;
}

static loff_t ovl_llseek(struct file *file, loff_t offset, int whence)
{
	struct inode *inode = file_inode(file);
	struct fd real;
	const struct cred *old_cred;
	loff_t ret;

	/*
	 * The two special cases below do not need to involve real fs,
	 * so we can optimizing concurrent callers.
	 */
	if (offset == 0) {
		if (whence == SEEK_CUR)
			return file->f_pos;

		if (whence == SEEK_SET)
			return vfs_setpos(file, 0, 0);
	}

	ret = ovl_real_fdget(file, &real);
	if (ret)
		return ret;

	/*
	 * Overlay file f_pos is the master copy that is preserved
	 * through copy up and modified on read/write, but only real
	 * fs knows how to SEEK_HOLE/SEEK_DATA and real fs may impose
	 * limitations that are more strict than ->s_maxbytes for specific
	 * files, so we use the real file to perform seeks.
	 */
	ovl_inode_lock(inode);
	real.file->f_pos = file->f_pos;

	old_cred = ovl_override_creds(inode->i_sb);
	ret = vfs_llseek(real.file, offset, whence);
	revert_creds(old_cred);

	file->f_pos = real.file->f_pos;
	ovl_inode_unlock(inode);

	fdput(real);

	return ret;
}

static void ovl_file_accessed(struct file *file)
{
	struct inode *inode, *upperinode;

	if (file->f_flags & O_NOATIME)
		return;

	inode = file_inode(file);
	upperinode = ovl_inode_upper(inode);

	if (!upperinode)
		return;

	if ((!timespec64_equal(&inode->i_mtime, &upperinode->i_mtime) ||
	     !timespec64_equal(&inode->i_ctime, &upperinode->i_ctime))) {
		inode->i_mtime = upperinode->i_mtime;
		inode->i_ctime = upperinode->i_ctime;
	}

	touch_atime(&file->f_path);
}

static rwf_t ovl_iocb_to_rwf(int ifl)
{
	rwf_t flags = 0;

	if (ifl & IOCB_NOWAIT)
		flags |= RWF_NOWAIT;
	if (ifl & IOCB_HIPRI)
		flags |= RWF_HIPRI;
	if (ifl & IOCB_DSYNC)
		flags |= RWF_DSYNC;
	if (ifl & IOCB_SYNC)
		flags |= RWF_SYNC;

	return flags;
}

static inline void ovl_aio_put(struct ovl_aio_req *aio_req)
{
	if (refcount_dec_and_test(&aio_req->ref)) {
		fdput(aio_req->fd);
		kmem_cache_free(ovl_aio_request_cachep, aio_req);
	}
}

static void ovl_aio_cleanup_handler(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) {
		struct inode *inode = file_inode(orig_iocb->ki_filp);

		/* Actually acquired in ovl_write_iter() */
		__sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
				      SB_FREEZE_WRITE);
		file_end_write(iocb->ki_filp);
		ovl_copyattr(inode);
	}

	orig_iocb->ki_pos = iocb->ki_pos;
	ovl_aio_put(aio_req);
}

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_handler(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;
	struct fd real;
	const struct cred *old_cred;
	ssize_t ret;

	if (!iov_iter_count(iter))
		return 0;

	ret = ovl_real_fdget(file, &real);
	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)) {
		ret = vfs_iter_read(real.file, iter, &iocb->ki_pos,
				    ovl_iocb_to_rwf(iocb->ki_flags));
	} 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;

		aio_req->fd = real;
		real.flags = 0;
		aio_req->orig_iocb = iocb;
		kiocb_clone(&aio_req->iocb, iocb, 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_handler(aio_req);
	}
out:
	revert_creds(old_cred);
	ovl_file_accessed(file);
out_fdput:
	fdput(real);

	return ret;
}

static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter)
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file_inode(file);
	struct fd real;
	const struct cred *old_cred;
	ssize_t ret;
	int ifl = iocb->ki_flags;

	if (!iov_iter_count(iter))
		return 0;

	inode_lock(inode);
	/* Update mode */
	ovl_copyattr(inode);
	ret = file_remove_privs(file);
	if (ret)
		goto out_unlock;

	ret = ovl_real_fdget(file, &real);
	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)))
		ifl &= ~(IOCB_DSYNC | IOCB_SYNC);

	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	if (is_sync_kiocb(iocb)) {
		file_start_write(real.file);
		ret = vfs_iter_write(real.file, iter, &iocb->ki_pos,
				     ovl_iocb_to_rwf(ifl));
		file_end_write(real.file);
		/* Update size */
		ovl_copyattr(inode);
	} 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;

		file_start_write(real.file);
		/* Pacify lockdep, same trick as done in aio_write() */
		__sb_writers_release(file_inode(real.file)->i_sb,
				     SB_FREEZE_WRITE);
		aio_req->fd = real;
		real.flags = 0;
		aio_req->orig_iocb = iocb;
		kiocb_clone(&aio_req->iocb, iocb, real.file);
		aio_req->iocb.ki_flags = ifl;
		aio_req->iocb.ki_complete = ovl_aio_rw_complete;
		refcount_set(&aio_req->ref, 2);
		ret = vfs_iocb_iter_write(real.file, &aio_req->iocb, iter);
		ovl_aio_put(aio_req);
		if (ret != -EIOCBQUEUED)
			ovl_aio_cleanup_handler(aio_req);
	}
out:
	revert_creds(old_cred);
out_fdput:
	fdput(real);

out_unlock:
	inode_unlock(inode);

	return ret;
}

/*
 * Calling iter_file_splice_write() directly from overlay's f_op may deadlock
 * due to lock order inversion between pipe->mutex in iter_file_splice_write()
 * and file_start_write(real.file) in ovl_write_iter().
 *
 * So do everything ovl_write_iter() does and call iter_file_splice_write() on
 * the real file.
 */
static ssize_t ovl_splice_write(struct pipe_inode_info *pipe, struct file *out,
				loff_t *ppos, size_t len, unsigned int flags)
{
	struct fd real;
	const struct cred *old_cred;
	struct inode *inode = file_inode(out);
	ssize_t ret;

	inode_lock(inode);
	/* Update mode */
	ovl_copyattr(inode);
	ret = file_remove_privs(out);
	if (ret)
		goto out_unlock;

	ret = ovl_real_fdget(out, &real);
	if (ret)
		goto out_unlock;

	old_cred = ovl_override_creds(inode->i_sb);
	file_start_write(real.file);

	ret = iter_file_splice_write(pipe, real.file, ppos, len, flags);

	file_end_write(real.file);
	/* Update size */
	ovl_copyattr(inode);
	revert_creds(old_cred);
	fdput(real);

out_unlock:
	inode_unlock(inode);

	return ret;
}

static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync)
{
	struct fd real;
	const struct cred *old_cred;
	int ret;

	ret = ovl_sync_status(OVL_FS(file_inode(file)->i_sb));
	if (ret <= 0)
		return ret;

	ret = ovl_real_fdget_meta(file, &real, !datasync);
	if (ret)
		return ret;

	/* Don't sync lower file for fear of receiving EROFS error */
	if (file_inode(real.file) == ovl_inode_upper(file_inode(file))) {
		old_cred = ovl_override_creds(file_inode(file)->i_sb);
		ret = vfs_fsync_range(real.file, start, end, datasync);
		revert_creds(old_cred);
	}

	fdput(real);

	return ret;
}

static int ovl_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct file *realfile = file->private_data;
	const struct cred *old_cred;
	int ret;

	if (!realfile->f_op->mmap)
		return -ENODEV;

	if (WARN_ON(file != vma->vm_file))
		return -EIO;

	vma_set_file(vma, realfile);

	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	ret = call_mmap(vma->vm_file, vma);
	revert_creds(old_cred);
	ovl_file_accessed(file);

	return ret;
}

static long ovl_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
{
	struct inode *inode = file_inode(file);
	struct fd real;
	const struct cred *old_cred;
	int ret;

	inode_lock(inode);
	/* Update mode */
	ovl_copyattr(inode);
	ret = file_remove_privs(file);
	if (ret)
		goto out_unlock;

	ret = ovl_real_fdget(file, &real);
	if (ret)
		goto out_unlock;

	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	ret = vfs_fallocate(real.file, mode, offset, len);
	revert_creds(old_cred);

	/* Update size */
	ovl_copyattr(inode);

	fdput(real);

out_unlock:
	inode_unlock(inode);

	return ret;
}

static int ovl_fadvise(struct file *file, loff_t offset, loff_t len, int advice)
{
	struct fd real;
	const struct cred *old_cred;
	int ret;

	ret = ovl_real_fdget(file, &real);
	if (ret)
		return ret;

	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	ret = vfs_fadvise(real.file, offset, len, advice);
	revert_creds(old_cred);

	fdput(real);

	return ret;
}

enum ovl_copyop {
	OVL_COPY,
	OVL_CLONE,
	OVL_DEDUPE,
};

static loff_t ovl_copyfile(struct file *file_in, loff_t pos_in,
			    struct file *file_out, loff_t pos_out,
			    loff_t len, unsigned int flags, enum ovl_copyop op)
{
	struct inode *inode_out = file_inode(file_out);
	struct fd real_in, real_out;
	const struct cred *old_cred;
	loff_t ret;

	inode_lock(inode_out);
	if (op != OVL_DEDUPE) {
		/* Update mode */
		ovl_copyattr(inode_out);
		ret = file_remove_privs(file_out);
		if (ret)
			goto out_unlock;
	}

	ret = ovl_real_fdget(file_out, &real_out);
	if (ret)
		goto out_unlock;

	ret = ovl_real_fdget(file_in, &real_in);
	if (ret) {
		fdput(real_out);
		goto out_unlock;
	}

	old_cred = ovl_override_creds(file_inode(file_out)->i_sb);
	switch (op) {
	case OVL_COPY:
		ret = vfs_copy_file_range(real_in.file, pos_in,
					  real_out.file, pos_out, len, flags);
		break;

	case OVL_CLONE:
		ret = vfs_clone_file_range(real_in.file, pos_in,
					   real_out.file, pos_out, len, flags);
		break;

	case OVL_DEDUPE:
		ret = vfs_dedupe_file_range_one(real_in.file, pos_in,
						real_out.file, pos_out, len,
						flags);
		break;
	}
	revert_creds(old_cred);

	/* Update size */
	ovl_copyattr(inode_out);

	fdput(real_in);
	fdput(real_out);

out_unlock:
	inode_unlock(inode_out);

	return ret;
}

static ssize_t ovl_copy_file_range(struct file *file_in, loff_t pos_in,
				   struct file *file_out, loff_t pos_out,
				   size_t len, unsigned int flags)
{
	return ovl_copyfile(file_in, pos_in, file_out, pos_out, len, flags,
			    OVL_COPY);
}

static loff_t ovl_remap_file_range(struct file *file_in, loff_t pos_in,
				   struct file *file_out, loff_t pos_out,
				   loff_t len, unsigned int remap_flags)
{
	enum ovl_copyop op;

	if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
		return -EINVAL;

	if (remap_flags & REMAP_FILE_DEDUP)
		op = OVL_DEDUPE;
	else
		op = OVL_CLONE;

	/*
	 * Don't copy up because of a dedupe request, this wouldn't make sense
	 * most of the time (data would be duplicated instead of deduplicated).
	 */
	if (op == OVL_DEDUPE &&
	    (!ovl_inode_upper(file_inode(file_in)) ||
	     !ovl_inode_upper(file_inode(file_out))))
		return -EPERM;

	return ovl_copyfile(file_in, pos_in, file_out, pos_out, len,
			    remap_flags, op);
}

static int ovl_flush(struct file *file, fl_owner_t id)
{
	struct fd real;
	const struct cred *old_cred;
	int err;

	err = ovl_real_fdget(file, &real);
	if (err)
		return err;

	if (real.file->f_op->flush) {
		old_cred = ovl_override_creds(file_inode(file)->i_sb);
		err = real.file->f_op->flush(real.file, id);
		revert_creds(old_cred);
	}
	fdput(real);

	return err;
}

const struct file_operations ovl_file_operations = {
	.open		= ovl_open,
	.release	= ovl_release,
	.llseek		= ovl_llseek,
	.read_iter	= ovl_read_iter,
	.write_iter	= ovl_write_iter,
	.fsync		= ovl_fsync,
	.mmap		= ovl_mmap,
	.fallocate	= ovl_fallocate,
	.fadvise	= ovl_fadvise,
	.flush		= ovl_flush,
	.splice_read    = generic_file_splice_read,
	.splice_write   = ovl_splice_write,

	.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);
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
d1d04ef8 MS	2	/*
d1d04ef8 MS	3	* Copyright (C) 2017 Red Hat, Inc.
d1d04ef8 MS	4	*/
	5
	6	#include <linux/cred.h>
	7	#include <linux/file.h>
dab5ca8f	8	#include <linux/mount.h>
d1d04ef8	9	#include <linux/xattr.h>
16914e6f	10	#include <linux/uio.h>
98487de3	11	#include <linux/uaccess.h>
1a980b8c	12	#include <linux/splice.h>
292f902a	13	#include <linux/security.h>
1a980b8c MZ	14	#include <linux/mm.h>
1a980b8c MZ	15	#include <linux/fs.h>
d1d04ef8 MS	16	#include "overlayfs.h"
d1d04ef8 MS	17
2406a307 JX	18	struct ovl_aio_req {
2406a307 JX	19	struct kiocb iocb;
9a254403	20	refcount_t ref;
2406a307 JX	21	struct kiocb *orig_iocb;
	22	struct fd fd;
	23	};
	24
	25	static struct kmem_cache *ovl_aio_request_cachep;
	26
8c444d2a VG	27	static char ovl_whatisit(struct inode inode, struct inode realinode)
	28	{
	29	if (realinode != ovl_inode_upper(inode))
	30	return 'l';
	31	if (ovl_has_upperdata(inode))
	32	return 'u';
	33	else
	34	return 'm';
	35	}
	36
cdf5c9d1	37	/* No atime modification nor notify on underlying */
81a33c1e AG	38	#define OVL_OPEN_FLAGS (O_NOATIME \| FMODE_NONOTIFY)
81a33c1e AG	39
8c444d2a	40	static struct file ovl_open_realfile(const struct file file,
2d343087	41	const struct path *realpath)
d1d04ef8	42	{
1248ea4b	43	struct inode *realinode = d_inode(realpath->dentry);
d1d04ef8	44	struct inode *inode = file_inode(file);
4609e1f1	45	struct mnt_idmap *real_idmap;
d1d04ef8 MS	46	struct file *realfile;
d1d04ef8 MS	47	const struct cred *old_cred;
81a33c1e	48	int flags = file->f_flags \| OVL_OPEN_FLAGS;
05acefb4 MS	49	int acc_mode = ACC_MODE(flags);
	50	int err;
	51
	52	if (flags & O_APPEND)
	53	acc_mode \|= MAY_APPEND;
d1d04ef8 MS	54
d1d04ef8 MS	55	old_cred = ovl_override_creds(inode->i_sb);
4609e1f1	56	real_idmap = mnt_idmap(realpath->mnt);
4609e1f1	57	err = inode_permission(real_idmap, realinode, MAY_OPEN \| acc_mode);
05acefb4 MS	58	if (err) {
05acefb4 MS	59	realfile = ERR_PTR(err);
05acefb4	60	} else {
01beba79	61	if (!inode_owner_or_capable(real_idmap, realinode))
b6650dab MS	62	flags &= ~O_NOATIME;
b6650dab MS	63
05acefb4 MS	64	realfile = open_with_fake_path(&file->f_path, flags, realinode,
	65	current_cred());
	66	}
d1d04ef8 MS	67	revert_creds(old_cred);
	68
	69	pr_debug("open(%p[%pD2/%c], 0%o) -> (%p, 0%o)\n",
8c444d2a	70	file, file, ovl_whatisit(inode, realinode), file->f_flags,
d1d04ef8 MS	71	realfile, IS_ERR(realfile) ? 0 : realfile->f_flags);
	72
	73	return realfile;
	74	}
	75
2ef66b8a MS	76	#define OVL_SETFL_MASK (O_APPEND \| O_NONBLOCK \| O_NDELAY \| O_DIRECT)
	77
	78	static int ovl_change_flags(struct file *file, unsigned int flags)
	79	{
	80	struct inode *inode = file_inode(file);
	81	int err;
	82
2ef66b8a MS	83	flags &= OVL_SETFL_MASK;
	84
	85	if (((flags ^ file->f_flags) & O_APPEND) && IS_APPEND(inode))
	86	return -EPERM;
	87
a2ad63da N	88	if ((flags & O_DIRECT) && !(file->f_mode & FMODE_CAN_ODIRECT))
a2ad63da N	89	return -EINVAL;
2ef66b8a MS	90
	91	if (file->f_op->check_flags) {
	92	err = file->f_op->check_flags(flags);
	93	if (err)
	94	return err;
	95	}
	96
	97	spin_lock(&file->f_lock);
	98	file->f_flags = (file->f_flags & ~OVL_SETFL_MASK) \| flags;
456b59e7	99	file->f_iocb_flags = iocb_flags(file);
2ef66b8a MS	100	spin_unlock(&file->f_lock);
	101
	102	return 0;
	103	}
	104
8c444d2a VG	105	static int ovl_real_fdget_meta(const struct file file, struct fd real,
8c444d2a VG	106	bool allow_meta)
2ef66b8a	107	{
1248ea4b AG	108	struct dentry *dentry = file_dentry(file);
1248ea4b AG	109	struct path realpath;
2ef66b8a MS	110
	111	real->flags = 0;
	112	real->file = file->private_data;
	113
8c444d2a	114	if (allow_meta)
1248ea4b	115	ovl_path_real(dentry, &realpath);
8c444d2a	116	else
1248ea4b	117	ovl_path_realdata(dentry, &realpath);
8c444d2a	118
2ef66b8a	119	/* Has it been copied up since we'd opened it? */
1248ea4b	120	if (unlikely(file_inode(real->file) != d_inode(realpath.dentry))) {
2ef66b8a	121	real->flags = FDPUT_FPUT;
1248ea4b	122	real->file = ovl_open_realfile(file, &realpath);
2ef66b8a MS	123
	124	return PTR_ERR_OR_ZERO(real->file);
	125	}
	126
	127	/* Did the flags change since open? */
81a33c1e	128	if (unlikely((file->f_flags ^ real->file->f_flags) & ~OVL_OPEN_FLAGS))
2ef66b8a MS	129	return ovl_change_flags(real->file, file->f_flags);
	130
	131	return 0;
	132	}
	133
8c444d2a VG	134	static int ovl_real_fdget(const struct file file, struct fd real)
8c444d2a VG	135	{
61536bed AG	136	if (d_is_dir(file_dentry(file))) {
	137	real->flags = 0;
	138	real->file = ovl_dir_real_file(file, false);
	139
	140	return PTR_ERR_OR_ZERO(real->file);
	141	}
	142
8c444d2a VG	143	return ovl_real_fdget_meta(file, real, false);
	144	}
	145
d1d04ef8 MS	146	static int ovl_open(struct inode inode, struct file file)
d1d04ef8 MS	147	{
1248ea4b	148	struct dentry *dentry = file_dentry(file);
d1d04ef8	149	struct file *realfile;
1248ea4b	150	struct path realpath;
d1d04ef8 MS	151	int err;
d1d04ef8 MS	152
1248ea4b	153	err = ovl_maybe_copy_up(dentry, file->f_flags);
d1d04ef8 MS	154	if (err)
	155	return err;
	156
	157	/* No longer need these flags, so don't pass them on to underlying fs */
	158	file->f_flags &= ~(O_CREAT \| O_EXCL \| O_NOCTTY \| O_TRUNC);
	159
1248ea4b AG	160	ovl_path_realdata(dentry, &realpath);
1248ea4b AG	161	realfile = ovl_open_realfile(file, &realpath);
d1d04ef8 MS	162	if (IS_ERR(realfile))
	163	return PTR_ERR(realfile);
	164
	165	file->private_data = realfile;
	166
	167	return 0;
	168	}
	169
	170	static int ovl_release(struct inode inode, struct file file)
	171	{
	172	fput(file->private_data);
	173
	174	return 0;
	175	}
	176
	177	static loff_t ovl_llseek(struct file *file, loff_t offset, int whence)
	178	{
9e46b840 AG	179	struct inode *inode = file_inode(file);
	180	struct fd real;
	181	const struct cred *old_cred;
a4ac9d45	182	loff_t ret;
9e46b840 AG	183
	184	/*
	185	* The two special cases below do not need to involve real fs,
	186	* so we can optimizing concurrent callers.
	187	*/
	188	if (offset == 0) {
	189	if (whence == SEEK_CUR)
	190	return file->f_pos;
	191
	192	if (whence == SEEK_SET)
	193	return vfs_setpos(file, 0, 0);
	194	}
	195
	196	ret = ovl_real_fdget(file, &real);
	197	if (ret)
	198	return ret;
	199
	200	/*
	201	* Overlay file f_pos is the master copy that is preserved
	202	* through copy up and modified on read/write, but only real
	203	* fs knows how to SEEK_HOLE/SEEK_DATA and real fs may impose
	204	* limitations that are more strict than ->s_maxbytes for specific
	205	* files, so we use the real file to perform seeks.
	206	*/
b1f9d385	207	ovl_inode_lock(inode);
9e46b840 AG	208	real.file->f_pos = file->f_pos;
	209
	210	old_cred = ovl_override_creds(inode->i_sb);
	211	ret = vfs_llseek(real.file, offset, whence);
	212	revert_creds(old_cred);
	213
	214	file->f_pos = real.file->f_pos;
b1f9d385	215	ovl_inode_unlock(inode);
9e46b840 AG	216
9e46b840 AG	217	fdput(real);
d1d04ef8	218
9e46b840	219	return ret;
d1d04ef8 MS	220	}
d1d04ef8 MS	221
16914e6f MS	222	static void ovl_file_accessed(struct file *file)
	223	{
	224	struct inode inode, upperinode;
	225
	226	if (file->f_flags & O_NOATIME)
	227	return;
	228
	229	inode = file_inode(file);
	230	upperinode = ovl_inode_upper(inode);
	231
	232	if (!upperinode)
	233	return;
	234
	235	if ((!timespec64_equal(&inode->i_mtime, &upperinode->i_mtime) \|\|
	236	!timespec64_equal(&inode->i_ctime, &upperinode->i_ctime))) {
	237	inode->i_mtime = upperinode->i_mtime;
	238	inode->i_ctime = upperinode->i_ctime;
	239	}
	240
	241	touch_atime(&file->f_path);
	242	}
	243
b778e1ee	244	static rwf_t ovl_iocb_to_rwf(int ifl)
16914e6f	245	{
16914e6f MS	246	rwf_t flags = 0;
	247
	248	if (ifl & IOCB_NOWAIT)
	249	flags \|= RWF_NOWAIT;
	250	if (ifl & IOCB_HIPRI)
	251	flags \|= RWF_HIPRI;
	252	if (ifl & IOCB_DSYNC)
	253	flags \|= RWF_DSYNC;
	254	if (ifl & IOCB_SYNC)
	255	flags \|= RWF_SYNC;
	256
	257	return flags;
	258	}
	259
9a254403	260	static inline void ovl_aio_put(struct ovl_aio_req *aio_req)
	261	{
	262	if (refcount_dec_and_test(&aio_req->ref)) {
	263	fdput(aio_req->fd);
	264	kmem_cache_free(ovl_aio_request_cachep, aio_req);
	265	}
	266	}
	267
2406a307 JX	268	static void ovl_aio_cleanup_handler(struct ovl_aio_req *aio_req)
	269	{
	270	struct kiocb *iocb = &aio_req->iocb;
	271	struct kiocb *orig_iocb = aio_req->orig_iocb;
	272
	273	if (iocb->ki_flags & IOCB_WRITE) {
	274	struct inode *inode = file_inode(orig_iocb->ki_filp);
	275
c8536804 MS	276	/* Actually acquired in ovl_write_iter() */
	277	__sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
	278	SB_FREEZE_WRITE);
2406a307	279	file_end_write(iocb->ki_filp);
2878dffc	280	ovl_copyattr(inode);
2406a307 JX	281	}
	282
	283	orig_iocb->ki_pos = iocb->ki_pos;
9a254403	284	ovl_aio_put(aio_req);
2406a307 JX	285	}
2406a307 JX	286
6b19b766	287	static void ovl_aio_rw_complete(struct kiocb *iocb, long res)
2406a307 JX	288	{
	289	struct ovl_aio_req *aio_req = container_of(iocb,
	290	struct ovl_aio_req, iocb);
	291	struct kiocb *orig_iocb = aio_req->orig_iocb;
	292
	293	ovl_aio_cleanup_handler(aio_req);
6b19b766	294	orig_iocb->ki_complete(orig_iocb, res);
2406a307 JX	295	}
2406a307 JX	296
16914e6f MS	297	static ssize_t ovl_read_iter(struct kiocb iocb, struct iov_iter iter)
	298	{
	299	struct file *file = iocb->ki_filp;
	300	struct fd real;
	301	const struct cred *old_cred;
	302	ssize_t ret;
	303
	304	if (!iov_iter_count(iter))
	305	return 0;
	306
	307	ret = ovl_real_fdget(file, &real);
	308	if (ret)
	309	return ret;
	310
1dc1eed4 MS	311	ret = -EINVAL;
1dc1eed4 MS	312	if (iocb->ki_flags & IOCB_DIRECT &&
a2ad63da	313	!(real.file->f_mode & FMODE_CAN_ODIRECT))
1dc1eed4 MS	314	goto out_fdput;
1dc1eed4 MS	315
16914e6f	316	old_cred = ovl_override_creds(file_inode(file)->i_sb);
2406a307 JX	317	if (is_sync_kiocb(iocb)) {
2406a307 JX	318	ret = vfs_iter_read(real.file, iter, &iocb->ki_pos,
b778e1ee	319	ovl_iocb_to_rwf(iocb->ki_flags));
2406a307 JX	320	} else {
	321	struct ovl_aio_req *aio_req;
	322
	323	ret = -ENOMEM;
	324	aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);
	325	if (!aio_req)
	326	goto out;
	327
	328	aio_req->fd = real;
	329	real.flags = 0;
	330	aio_req->orig_iocb = iocb;
	331	kiocb_clone(&aio_req->iocb, iocb, real.file);
	332	aio_req->iocb.ki_complete = ovl_aio_rw_complete;
9a254403	333	refcount_set(&aio_req->ref, 2);
2406a307	334	ret = vfs_iocb_iter_read(real.file, &aio_req->iocb, iter);
9a254403	335	ovl_aio_put(aio_req);
2406a307 JX	336	if (ret != -EIOCBQUEUED)
	337	ovl_aio_cleanup_handler(aio_req);
	338	}
	339	out:
16914e6f	340	revert_creds(old_cred);
16914e6f	341	ovl_file_accessed(file);
1dc1eed4	342	out_fdput:
16914e6f MS	343	fdput(real);
	344
	345	return ret;
	346	}
	347
2a92e07e MS	348	static ssize_t ovl_write_iter(struct kiocb iocb, struct iov_iter iter)
	349	{
	350	struct file *file = iocb->ki_filp;
	351	struct inode *inode = file_inode(file);
	352	struct fd real;
	353	const struct cred *old_cred;
	354	ssize_t ret;
c86243b0	355	int ifl = iocb->ki_flags;
2a92e07e MS	356
	357	if (!iov_iter_count(iter))
	358	return 0;
	359
	360	inode_lock(inode);
	361	/* Update mode */
2878dffc	362	ovl_copyattr(inode);
2a92e07e MS	363	ret = file_remove_privs(file);
	364	if (ret)
	365	goto out_unlock;
	366
	367	ret = ovl_real_fdget(file, &real);
	368	if (ret)
	369	goto out_unlock;
	370
1dc1eed4 MS	371	ret = -EINVAL;
1dc1eed4 MS	372	if (iocb->ki_flags & IOCB_DIRECT &&
a2ad63da	373	!(real.file->f_mode & FMODE_CAN_ODIRECT))
1dc1eed4 MS	374	goto out_fdput;
1dc1eed4 MS	375
c86243b0 VG	376	if (!ovl_should_sync(OVL_FS(inode->i_sb)))
	377	ifl &= ~(IOCB_DSYNC \| IOCB_SYNC);
	378
2a92e07e	379	old_cred = ovl_override_creds(file_inode(file)->i_sb);
2406a307 JX	380	if (is_sync_kiocb(iocb)) {
	381	file_start_write(real.file);
	382	ret = vfs_iter_write(real.file, iter, &iocb->ki_pos,
c86243b0	383	ovl_iocb_to_rwf(ifl));
2406a307 JX	384	file_end_write(real.file);
2406a307 JX	385	/* Update size */
2878dffc	386	ovl_copyattr(inode);
2406a307 JX	387	} else {
	388	struct ovl_aio_req *aio_req;
	389
	390	ret = -ENOMEM;
	391	aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);
	392	if (!aio_req)
	393	goto out;
	394
	395	file_start_write(real.file);
c8536804 MS	396	/* Pacify lockdep, same trick as done in aio_write() */
	397	__sb_writers_release(file_inode(real.file)->i_sb,
	398	SB_FREEZE_WRITE);
2406a307 JX	399	aio_req->fd = real;
	400	real.flags = 0;
	401	aio_req->orig_iocb = iocb;
	402	kiocb_clone(&aio_req->iocb, iocb, real.file);
c86243b0	403	aio_req->iocb.ki_flags = ifl;
2406a307	404	aio_req->iocb.ki_complete = ovl_aio_rw_complete;
9a254403	405	refcount_set(&aio_req->ref, 2);
2406a307	406	ret = vfs_iocb_iter_write(real.file, &aio_req->iocb, iter);
9a254403	407	ovl_aio_put(aio_req);
2406a307 JX	408	if (ret != -EIOCBQUEUED)
	409	ovl_aio_cleanup_handler(aio_req);
	410	}
	411	out:
2a92e07e	412	revert_creds(old_cred);
1dc1eed4	413	out_fdput:
2a92e07e MS	414	fdput(real);
	415
	416	out_unlock:
	417	inode_unlock(inode);
	418
	419	return ret;
	420	}
	421
9b91b6b0 MS	422	/*
	423	* Calling iter_file_splice_write() directly from overlay's f_op may deadlock
	424	* due to lock order inversion between pipe->mutex in iter_file_splice_write()
	425	* and file_start_write(real.file) in ovl_write_iter().
	426	*
	427	* So do everything ovl_write_iter() does and call iter_file_splice_write() on
	428	* the real file.
	429	*/
	430	static ssize_t ovl_splice_write(struct pipe_inode_info pipe, struct file out,
	431	loff_t *ppos, size_t len, unsigned int flags)
	432	{
	433	struct fd real;
	434	const struct cred *old_cred;
	435	struct inode *inode = file_inode(out);
9b91b6b0 MS	436	ssize_t ret;
	437
	438	inode_lock(inode);
	439	/* Update mode */
2878dffc	440	ovl_copyattr(inode);
9b91b6b0 MS	441	ret = file_remove_privs(out);
	442	if (ret)
	443	goto out_unlock;
	444
	445	ret = ovl_real_fdget(out, &real);
	446	if (ret)
	447	goto out_unlock;
	448
	449	old_cred = ovl_override_creds(inode->i_sb);
	450	file_start_write(real.file);
	451
	452	ret = iter_file_splice_write(pipe, real.file, ppos, len, flags);
	453
	454	file_end_write(real.file);
	455	/* Update size */
2878dffc	456	ovl_copyattr(inode);
9b91b6b0 MS	457	revert_creds(old_cred);
	458	fdput(real);
	459
	460	out_unlock:
	461	inode_unlock(inode);
	462
	463	return ret;
	464	}
	465
de30dfd6 MS	466	static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync)
	467	{
	468	struct fd real;
	469	const struct cred *old_cred;
	470	int ret;
	471
335d3fc5 SD	472	ret = ovl_sync_status(OVL_FS(file_inode(file)->i_sb));
	473	if (ret <= 0)
	474	return ret;
c86243b0	475
8c444d2a	476	ret = ovl_real_fdget_meta(file, &real, !datasync);
de30dfd6 MS	477	if (ret)
	478	return ret;
	479
	480	/* Don't sync lower file for fear of receiving EROFS error */
	481	if (file_inode(real.file) == ovl_inode_upper(file_inode(file))) {
	482	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	483	ret = vfs_fsync_range(real.file, start, end, datasync);
	484	revert_creds(old_cred);
	485	}
	486
	487	fdput(real);
	488
	489	return ret;
	490	}
	491
2f502839 MS	492	static int ovl_mmap(struct file file, struct vm_area_struct vma)
	493	{
	494	struct file *realfile = file->private_data;
	495	const struct cred *old_cred;
	496	int ret;
	497
	498	if (!realfile->f_op->mmap)
	499	return -ENODEV;
	500
	501	if (WARN_ON(file != vma->vm_file))
	502	return -EIO;
	503
2896900e	504	vma_set_file(vma, realfile);
2f502839 MS	505
	506	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	507	ret = call_mmap(vma->vm_file, vma);
	508	revert_creds(old_cred);
2f502839 MS	509	ovl_file_accessed(file);
	510
	511	return ret;
	512	}
	513
aab8848c MS	514	static long ovl_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
	515	{
	516	struct inode *inode = file_inode(file);
	517	struct fd real;
	518	const struct cred *old_cred;
	519	int ret;
	520
23a8ce16 AG	521	inode_lock(inode);
	522	/* Update mode */
	523	ovl_copyattr(inode);
	524	ret = file_remove_privs(file);
	525	if (ret)
	526	goto out_unlock;
	527
aab8848c MS	528	ret = ovl_real_fdget(file, &real);
aab8848c MS	529	if (ret)
23a8ce16	530	goto out_unlock;
aab8848c MS	531
	532	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	533	ret = vfs_fallocate(real.file, mode, offset, len);
	534	revert_creds(old_cred);
	535
	536	/* Update size */
2878dffc	537	ovl_copyattr(inode);
aab8848c MS	538
	539	fdput(real);
	540
23a8ce16 AG	541	out_unlock:
	542	inode_unlock(inode);
	543
aab8848c MS	544	return ret;
	545	}
	546
b833a366 AG	547	static int ovl_fadvise(struct file *file, loff_t offset, loff_t len, int advice)
	548	{
	549	struct fd real;
	550	const struct cred *old_cred;
	551	int ret;
	552
	553	ret = ovl_real_fdget(file, &real);
	554	if (ret)
	555	return ret;
	556
	557	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	558	ret = vfs_fadvise(real.file, offset, len, advice);
	559	revert_creds(old_cred);
	560
	561	fdput(real);
	562
	563	return ret;
	564	}
	565
8ede2055 MS	566	enum ovl_copyop {
	567	OVL_COPY,
	568	OVL_CLONE,
	569	OVL_DEDUPE,
	570	};
	571
42ec3d4c	572	static loff_t ovl_copyfile(struct file *file_in, loff_t pos_in,
8ede2055	573	struct file *file_out, loff_t pos_out,
42ec3d4c	574	loff_t len, unsigned int flags, enum ovl_copyop op)
8ede2055 MS	575	{
	576	struct inode *inode_out = file_inode(file_out);
	577	struct fd real_in, real_out;
	578	const struct cred *old_cred;
42ec3d4c	579	loff_t ret;
8ede2055	580
b306e90f AG	581	inode_lock(inode_out);
	582	if (op != OVL_DEDUPE) {
	583	/* Update mode */
	584	ovl_copyattr(inode_out);
	585	ret = file_remove_privs(file_out);
	586	if (ret)
	587	goto out_unlock;
	588	}
	589
8ede2055 MS	590	ret = ovl_real_fdget(file_out, &real_out);
8ede2055 MS	591	if (ret)
b306e90f	592	goto out_unlock;
8ede2055 MS	593
	594	ret = ovl_real_fdget(file_in, &real_in);
	595	if (ret) {
	596	fdput(real_out);
b306e90f	597	goto out_unlock;
8ede2055 MS	598	}
	599
	600	old_cred = ovl_override_creds(file_inode(file_out)->i_sb);
	601	switch (op) {
	602	case OVL_COPY:
	603	ret = vfs_copy_file_range(real_in.file, pos_in,
	604	real_out.file, pos_out, len, flags);
	605	break;
	606
	607	case OVL_CLONE:
a725356b	608	ret = vfs_clone_file_range(real_in.file, pos_in,
452ce659	609	real_out.file, pos_out, len, flags);
8ede2055 MS	610	break;
	611
	612	case OVL_DEDUPE:
	613	ret = vfs_dedupe_file_range_one(real_in.file, pos_in,
df365836 DW	614	real_out.file, pos_out, len,
df365836 DW	615	flags);
8ede2055 MS	616	break;
	617	}
	618	revert_creds(old_cred);
	619
	620	/* Update size */
2878dffc	621	ovl_copyattr(inode_out);
8ede2055 MS	622
	623	fdput(real_in);
	624	fdput(real_out);
	625
b306e90f AG	626	out_unlock:
	627	inode_unlock(inode_out);
	628
8ede2055 MS	629	return ret;
	630	}
	631
	632	static ssize_t ovl_copy_file_range(struct file *file_in, loff_t pos_in,
	633	struct file *file_out, loff_t pos_out,
	634	size_t len, unsigned int flags)
	635	{
	636	return ovl_copyfile(file_in, pos_in, file_out, pos_out, len, flags,
	637	OVL_COPY);
	638	}
	639
42ec3d4c DW	640	static loff_t ovl_remap_file_range(struct file *file_in, loff_t pos_in,
	641	struct file *file_out, loff_t pos_out,
	642	loff_t len, unsigned int remap_flags)
8ede2055	643	{
2e5dfc99 DW	644	enum ovl_copyop op;
	645
	646	if (remap_flags & ~(REMAP_FILE_DEDUP \| REMAP_FILE_ADVISORY))
	647	return -EINVAL;
	648
	649	if (remap_flags & REMAP_FILE_DEDUP)
	650	op = OVL_DEDUPE;
	651	else
	652	op = OVL_CLONE;
8ede2055	653
8ede2055 MS	654	/*
	655	* Don't copy up because of a dedupe request, this wouldn't make sense
	656	* most of the time (data would be duplicated instead of deduplicated).
	657	*/
2e5dfc99 DW	658	if (op == OVL_DEDUPE &&
	659	(!ovl_inode_upper(file_inode(file_in)) \|\|
	660	!ovl_inode_upper(file_inode(file_out))))
8ede2055 MS	661	return -EPERM;
8ede2055 MS	662
452ce659 DW	663	return ovl_copyfile(file_in, pos_in, file_out, pos_out, len,
452ce659 DW	664	remap_flags, op);
8ede2055 MS	665	}
8ede2055 MS	666
1f0cb8bc SD	667	static int ovl_flush(struct file *file, fl_owner_t id)
	668	{
	669	struct fd real;
	670	const struct cred *old_cred;
	671	int err;
	672
	673	err = ovl_real_fdget(file, &real);
	674	if (err)
	675	return err;
	676
	677	if (real.file->f_op->flush) {
	678	old_cred = ovl_override_creds(file_inode(file)->i_sb);
	679	err = real.file->f_op->flush(real.file, id);
	680	revert_creds(old_cred);
	681	}
	682	fdput(real);
	683
	684	return err;
	685	}
	686
d1d04ef8 MS	687	const struct file_operations ovl_file_operations = {
	688	.open = ovl_open,
	689	.release = ovl_release,
	690	.llseek = ovl_llseek,
16914e6f	691	.read_iter = ovl_read_iter,
2a92e07e	692	.write_iter = ovl_write_iter,
de30dfd6	693	.fsync = ovl_fsync,
2f502839	694	.mmap = ovl_mmap,
aab8848c	695	.fallocate = ovl_fallocate,
b833a366	696	.fadvise = ovl_fadvise,
1f0cb8bc	697	.flush = ovl_flush,
82a763e6	698	.splice_read = generic_file_splice_read,
9b91b6b0	699	.splice_write = ovl_splice_write,
8ede2055 MS	700
8ede2055 MS	701	.copy_file_range = ovl_copy_file_range,
2e5dfc99	702	.remap_file_range = ovl_remap_file_range,
d1d04ef8	703	};
2406a307 JX	704
	705	int __init ovl_aio_request_cache_init(void)
	706	{
	707	ovl_aio_request_cachep = kmem_cache_create("ovl_aio_req",
	708	sizeof(struct ovl_aio_req),
	709	0, SLAB_HWCACHE_ALIGN, NULL);
	710	if (!ovl_aio_request_cachep)
	711	return -ENOMEM;
	712
	713	return 0;
	714	}
	715
	716	void ovl_aio_request_cache_destroy(void)
	717	{
	718	kmem_cache_destroy(ovl_aio_request_cachep);
	719	}