[mirror_ubuntu-artful-kernel.git] / zfs / include / linux / vfs_compat.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (C) 2011 Lawrence Livermore National Security, LLC.
 * Copyright (C) 2015 Jörg Thalheim.
 */

#ifndef _ZFS_VFS_H
#define	_ZFS_VFS_H

#include <sys/taskq.h>
#include <linux/backing-dev.h>

/*
 * 2.6.28 API change,
 * Added insert_inode_locked() helper function, prior to this most callers
 * used insert_inode_hash().  The older method doesn't check for collisions
 * in the inode_hashtable but it still acceptible for use.
 */
#ifndef HAVE_INSERT_INODE_LOCKED
static inline int
insert_inode_locked(struct inode *ip)
{
	insert_inode_hash(ip);
	return (0);
}
#endif /* HAVE_INSERT_INODE_LOCKED */

/*
 * 2.6.35 API change,
 * Add truncate_setsize() if it is not exported by the Linux kernel.
 *
 * Truncate the inode and pages associated with the inode. The pages are
 * unmapped and removed from cache.
 */
#ifndef HAVE_TRUNCATE_SETSIZE
static inline void
truncate_setsize(struct inode *ip, loff_t new)
{
	struct address_space *mapping = ip->i_mapping;

	i_size_write(ip, new);

	unmap_mapping_range(mapping, new + PAGE_SIZE - 1, 0, 1);
	truncate_inode_pages(mapping, new);
	unmap_mapping_range(mapping, new + PAGE_SIZE - 1, 0, 1);
}
#endif /* HAVE_TRUNCATE_SETSIZE */

/*
 * 2.6.32 - 2.6.33, bdi_setup_and_register() is not available.
 * 2.6.34 - 3.19, bdi_setup_and_register() takes 3 arguments.
 * 4.0 - 4.11, bdi_setup_and_register() takes 2 arguments.
 * 4.12 - x.y, super_setup_bdi_name() new interface.
 */
#if defined(HAVE_SUPER_SETUP_BDI_NAME)
extern atomic_long_t zfs_bdi_seq;

static inline int
zpl_bdi_setup(struct super_block *sb, char *name)
{
	return super_setup_bdi_name(sb, "%.28s-%ld", name,
		atomic_long_inc_return(&zfs_bdi_seq));
}
static inline void
zpl_bdi_destroy(struct super_block *sb)
{
}
#elif defined(HAVE_2ARGS_BDI_SETUP_AND_REGISTER)
static inline int
zpl_bdi_setup(struct super_block *sb, char *name)
{
	struct backing_dev_info *bdi;
	int error;

	bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
	error = bdi_setup_and_register(bdi, name);
	if (error) {
		kmem_free(bdi, sizeof (struct backing_dev_info));
		return (error);
	}

	sb->s_bdi = bdi;

	return (0);
}
static inline void
zpl_bdi_destroy(struct super_block *sb)
{
	struct backing_dev_info *bdi = sb->s_bdi;

	bdi_destroy(bdi);
	kmem_free(bdi, sizeof (struct backing_dev_info));
	sb->s_bdi = NULL;
}
#elif defined(HAVE_3ARGS_BDI_SETUP_AND_REGISTER)
static inline int
zpl_bdi_setup(struct super_block *sb, char *name)
{
	struct backing_dev_info *bdi;
	int error;

	bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
	error = bdi_setup_and_register(bdi, name, BDI_CAP_MAP_COPY);
	if (error) {
		kmem_free(sb->s_bdi, sizeof (struct backing_dev_info));
		return (error);
	}

	sb->s_bdi = bdi;

	return (0);
}
static inline void
zpl_bdi_destroy(struct super_block *sb)
{
	struct backing_dev_info *bdi = sb->s_bdi;

	bdi_destroy(bdi);
	kmem_free(bdi, sizeof (struct backing_dev_info));
	sb->s_bdi = NULL;
}
#else
extern atomic_long_t zfs_bdi_seq;

static inline int
zpl_bdi_setup(struct super_block *sb, char *name)
{
	struct backing_dev_info *bdi;
	int error;

	bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
	bdi->name = name;
	bdi->capabilities = BDI_CAP_MAP_COPY;

	error = bdi_init(bdi);
	if (error) {
		kmem_free(bdi, sizeof (struct backing_dev_info));
		return (error);
	}

	error = bdi_register(bdi, NULL, "%.28s-%ld", name,
	    atomic_long_inc_return(&zfs_bdi_seq));
	if (error) {
		bdi_destroy(bdi);
		kmem_free(bdi, sizeof (struct backing_dev_info));
		return (error);
	}

	sb->s_bdi = bdi;

	return (0);
}
static inline void
zpl_bdi_destroy(struct super_block *sb)
{
	struct backing_dev_info *bdi = sb->s_bdi;

	bdi_destroy(bdi);
	kmem_free(bdi, sizeof (struct backing_dev_info));
	sb->s_bdi = NULL;
}
#endif

/*
 * 2.6.38 API change,
 * LOOKUP_RCU flag introduced to distinguish rcu-walk from ref-walk cases.
 */
#ifndef LOOKUP_RCU
#define	LOOKUP_RCU	0x0
#endif /* LOOKUP_RCU */

/*
 * 3.2-rc1 API change,
 * Add set_nlink() if it is not exported by the Linux kernel.
 *
 * i_nlink is read-only in Linux 3.2, but it can be set directly in
 * earlier kernels.
 */
#ifndef HAVE_SET_NLINK
static inline void
set_nlink(struct inode *inode, unsigned int nlink)
{
	inode->i_nlink = nlink;
}
#endif /* HAVE_SET_NLINK */

/*
 * 3.3 API change,
 * The VFS .create, .mkdir and .mknod callbacks were updated to take a
 * umode_t type rather than an int.  To cleanly handle both definitions
 * the zpl_umode_t type is introduced and set accordingly.
 */
#ifdef HAVE_MKDIR_UMODE_T
typedef	umode_t		zpl_umode_t;
#else
typedef	int		zpl_umode_t;
#endif

/*
 * 3.5 API change,
 * The clear_inode() function replaces end_writeback() and introduces an
 * ordering change regarding when the inode_sync_wait() occurs.  See the
 * configure check in config/kernel-clear-inode.m4 for full details.
 */
#if defined(HAVE_EVICT_INODE) && !defined(HAVE_CLEAR_INODE)
#define	clear_inode(ip)		end_writeback(ip)
#endif /* HAVE_EVICT_INODE && !HAVE_CLEAR_INODE */

/*
 * 3.6 API change,
 * The sget() helper function now takes the mount flags as an argument.
 */
#ifdef HAVE_5ARG_SGET
#define	zpl_sget(type, cmp, set, fl, mtd)	sget(type, cmp, set, fl, mtd)
#else
#define	zpl_sget(type, cmp, set, fl, mtd)	sget(type, cmp, set, mtd)
#endif /* HAVE_5ARG_SGET */

#if defined(SEEK_HOLE) && defined(SEEK_DATA) && !defined(HAVE_LSEEK_EXECUTE)
static inline loff_t
lseek_execute(
	struct file *filp,
	struct inode *inode,
	loff_t offset,
	loff_t maxsize)
{
	if (offset < 0 && !(filp->f_mode & FMODE_UNSIGNED_OFFSET))
		return (-EINVAL);

	if (offset > maxsize)
		return (-EINVAL);

	if (offset != filp->f_pos) {
		spin_lock(&filp->f_lock);
		filp->f_pos = offset;
		filp->f_version = 0;
		spin_unlock(&filp->f_lock);
	}

	return (offset);
}
#endif /* SEEK_HOLE && SEEK_DATA && !HAVE_LSEEK_EXECUTE */

#if defined(CONFIG_FS_POSIX_ACL)
/*
 * These functions safely approximates the behavior of posix_acl_release()
 * which cannot be used because it calls the GPL-only symbol kfree_rcu().
 * The in-kernel version, which can access the RCU, frees the ACLs after
 * the grace period expires.  Because we're unsure how long that grace
 * period may be this implementation conservatively delays for 60 seconds.
 * This is several orders of magnitude larger than expected grace period.
 * At 60 seconds the kernel will also begin issuing RCU stall warnings.
 */
#include <linux/posix_acl.h>

#if defined(HAVE_POSIX_ACL_RELEASE) && !defined(HAVE_POSIX_ACL_RELEASE_GPL_ONLY)
#define	zpl_posix_acl_release(arg)		posix_acl_release(arg)
#else
void zpl_posix_acl_release_impl(struct posix_acl *);

static inline void
zpl_posix_acl_release(struct posix_acl *acl)
{
	if ((acl == NULL) || (acl == ACL_NOT_CACHED))
		return;

	if (atomic_dec_and_test(&acl->a_refcount))
		zpl_posix_acl_release_impl(acl);
}
#endif /* HAVE_POSIX_ACL_RELEASE */

#ifdef HAVE_SET_CACHED_ACL_USABLE
#define	zpl_set_cached_acl(ip, ty, n)		set_cached_acl(ip, ty, n)
#define	zpl_forget_cached_acl(ip, ty)		forget_cached_acl(ip, ty)
#else
static inline void
zpl_set_cached_acl(struct inode *ip, int type, struct posix_acl *newer) {
	struct posix_acl *older = NULL;

	spin_lock(&ip->i_lock);

	if ((newer != ACL_NOT_CACHED) && (newer != NULL))
		posix_acl_dup(newer);

	switch (type) {
	case ACL_TYPE_ACCESS:
		older = ip->i_acl;
		rcu_assign_pointer(ip->i_acl, newer);
		break;
	case ACL_TYPE_DEFAULT:
		older = ip->i_default_acl;
		rcu_assign_pointer(ip->i_default_acl, newer);
		break;
	}

	spin_unlock(&ip->i_lock);

	zpl_posix_acl_release(older);
}

static inline void
zpl_forget_cached_acl(struct inode *ip, int type) {
	zpl_set_cached_acl(ip, type, (struct posix_acl *)ACL_NOT_CACHED);
}
#endif /* HAVE_SET_CACHED_ACL_USABLE */

#ifndef HAVE___POSIX_ACL_CHMOD
#ifdef HAVE_POSIX_ACL_CHMOD
#define	__posix_acl_chmod(acl, gfp, mode)	posix_acl_chmod(acl, gfp, mode)
#define	__posix_acl_create(acl, gfp, mode)	posix_acl_create(acl, gfp, mode)
#else
static inline int
__posix_acl_chmod(struct posix_acl **acl, int flags, umode_t umode) {
	struct posix_acl *oldacl = *acl;
	mode_t mode = umode;
	int error;

	*acl = posix_acl_clone(*acl, flags);
	zpl_posix_acl_release(oldacl);

	if (!(*acl))
		return (-ENOMEM);

	error = posix_acl_chmod_masq(*acl, mode);
	if (error) {
		zpl_posix_acl_release(*acl);
		*acl = NULL;
	}

	return (error);
}

static inline int
__posix_acl_create(struct posix_acl **acl, int flags, umode_t *umodep) {
	struct posix_acl *oldacl = *acl;
	mode_t mode = *umodep;
	int error;

	*acl = posix_acl_clone(*acl, flags);
	zpl_posix_acl_release(oldacl);

	if (!(*acl))
		return (-ENOMEM);

	error = posix_acl_create_masq(*acl, &mode);
	*umodep = mode;

	if (error < 0) {
		zpl_posix_acl_release(*acl);
		*acl = NULL;
	}

	return (error);
}
#endif /* HAVE_POSIX_ACL_CHMOD */
#endif /* HAVE___POSIX_ACL_CHMOD */

#ifdef HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T
typedef umode_t zpl_equivmode_t;
#else
typedef mode_t zpl_equivmode_t;
#endif /* HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T */

/*
 * 4.8 API change,
 * posix_acl_valid() now must be passed a namespace, the namespace from
 * from super block associated with the given inode is used for this purpose.
 */
#ifdef HAVE_POSIX_ACL_VALID_WITH_NS
#define	zpl_posix_acl_valid(ip, acl)  posix_acl_valid(ip->i_sb->s_user_ns, acl)
#else
#define	zpl_posix_acl_valid(ip, acl)  posix_acl_valid(acl)
#endif

#endif /* CONFIG_FS_POSIX_ACL */

/*
 * 2.6.38 API change,
 * The is_owner_or_cap() function was renamed to inode_owner_or_capable().
 */
#ifdef HAVE_INODE_OWNER_OR_CAPABLE
#define	zpl_inode_owner_or_capable(ip)		inode_owner_or_capable(ip)
#else
#define	zpl_inode_owner_or_capable(ip)		is_owner_or_cap(ip)
#endif /* HAVE_INODE_OWNER_OR_CAPABLE */

/*
 * 3.19 API change
 * struct access f->f_dentry->d_inode was replaced by accessor function
 * file_inode(f)
 */
#ifndef HAVE_FILE_INODE
static inline struct inode *file_inode(const struct file *f)
{
	return (f->f_dentry->d_inode);
}
#endif /* HAVE_FILE_INODE */

/*
 * 2.6.38 API change
 */
#ifdef HAVE_FOLLOW_DOWN_ONE
#define	zpl_follow_down_one(path)		follow_down_one(path)
#define	zpl_follow_up(path)			follow_up(path)
#else
#define	zpl_follow_down_one(path)		follow_down(path)
#define	zpl_follow_up(path)			follow_up(path)
#endif

/*
 * 4.9 API change
 */
#ifndef HAVE_SETATTR_PREPARE
static inline int
setattr_prepare(struct dentry *dentry, struct iattr *ia)
{
	return (inode_change_ok(dentry->d_inode, ia));
}
#endif

/*
 * 4.11 API change
 * These macros are defined by kernel 4.11.  We define them so that the same
 * code builds under kernels < 4.11 and >= 4.11.  The macros are set to 0 so
 * that it will create obvious failures if they are accidentally used when built
 * against a kernel >= 4.11.
 */

#ifndef STATX_BASIC_STATS
#define	STATX_BASIC_STATS	0
#endif

#ifndef AT_STATX_SYNC_AS_STAT
#define	AT_STATX_SYNC_AS_STAT	0
#endif

/*
 * 4.11 API change
 * 4.11 takes struct path *, < 4.11 takes vfsmount *
 */

#ifdef HAVE_VFSMOUNT_IOPS_GETATTR
#define	ZPL_GETATTR_WRAPPER(func)					\
static int								\
func(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)	\
{									\
	struct path path = { .mnt = mnt, .dentry = dentry };		\
	return func##_impl(&path, stat, STATX_BASIC_STATS,		\
	    AT_STATX_SYNC_AS_STAT);					\
}
#elif defined(HAVE_PATH_IOPS_GETATTR)
#define	ZPL_GETATTR_WRAPPER(func)					\
static int								\
func(const struct path *path, struct kstat *stat, u32 request_mask,	\
    unsigned int query_flags)						\
{									\
	return (func##_impl(path, stat, request_mask, query_flags));	\
}
#else
#error
#endif

/*
 * 4.9 API change
 * Preferred interface to get the current FS time.
 */
#if !defined(HAVE_CURRENT_TIME)
static inline struct timespec
current_time(struct inode *ip)
{
	return (timespec_trunc(current_kernel_time(), ip->i_sb->s_time_gran));
}
#endif

#endif /* _ZFS_VFS_H */
Commit	Line	Data
87d546d8 TG	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License (the "License").
	6	* You may not use this file except in compliance with the License.
	7	*
	8	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
	9	* or http://www.opensolaris.org/os/licensing.
	10	* See the License for the specific language governing permissions
	11	* and limitations under the License.
	12	*
	13	* When distributing Covered Code, include this CDDL HEADER in each
	14	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	15	* If applicable, add the following below this CDDL HEADER, with the
	16	* fields enclosed by brackets "[]" replaced with your own identifying
	17	* information: Portions Copyright [yyyy] [name of copyright owner]
	18	*
	19	* CDDL HEADER END
	20	*/
	21
	22	/*
	23	* Copyright (C) 2011 Lawrence Livermore National Security, LLC.
	24	* Copyright (C) 2015 Jörg Thalheim.
	25	*/
	26
	27	#ifndef _ZFS_VFS_H
	28	#define _ZFS_VFS_H
	29
	30	#include <sys/taskq.h>
	31	#include <linux/backing-dev.h>
	32
	33	/*
	34	* 2.6.28 API change,
	35	* Added insert_inode_locked() helper function, prior to this most callers
	36	* used insert_inode_hash(). The older method doesn't check for collisions
	37	* in the inode_hashtable but it still acceptible for use.
	38	*/
	39	#ifndef HAVE_INSERT_INODE_LOCKED
	40	static inline int
	41	insert_inode_locked(struct inode *ip)
	42	{
	43	insert_inode_hash(ip);
	44	return (0);
	45	}
	46	#endif /* HAVE_INSERT_INODE_LOCKED */
	47
	48	/*
	49	* 2.6.35 API change,
	50	* Add truncate_setsize() if it is not exported by the Linux kernel.
	51	*
	52	* Truncate the inode and pages associated with the inode. The pages are
	53	* unmapped and removed from cache.
	54	*/
	55	#ifndef HAVE_TRUNCATE_SETSIZE
	56	static inline void
	57	truncate_setsize(struct inode *ip, loff_t new)
	58	{
	59	struct address_space *mapping = ip->i_mapping;
	60
	61	i_size_write(ip, new);
	62
	63	unmap_mapping_range(mapping, new + PAGE_SIZE - 1, 0, 1);
	64	truncate_inode_pages(mapping, new);
65	unmap_mapping_range(mapping, new + PAGE_SIZE - 1, 0, 1);
66	}
67	#endif /* HAVE_TRUNCATE_SETSIZE */
68
69	/*
70	* 2.6.32 - 2.6.33, bdi_setup_and_register() is not available.
71	* 2.6.34 - 3.19, bdi_setup_and_register() takes 3 arguments.
df9d7621 CIK	72	* 4.0 - 4.11, bdi_setup_and_register() takes 2 arguments.
df9d7621 CIK	73	* 4.12 - x.y, super_setup_bdi_name() new interface.
87d546d8	74	*/
df9d7621 CIK	75	#if defined(HAVE_SUPER_SETUP_BDI_NAME)
	76	extern atomic_long_t zfs_bdi_seq;
	77
	78	static inline int
	79	zpl_bdi_setup(struct super_block sb, char name)
	80	{
	81	return super_setup_bdi_name(sb, "%.28s-%ld", name,
	82	atomic_long_inc_return(&zfs_bdi_seq));
	83	}
	84	static inline void
	85	zpl_bdi_destroy(struct super_block *sb)
	86	{
	87	}
	88	#elif defined(HAVE_2ARGS_BDI_SETUP_AND_REGISTER)
87d546d8	89	static inline int
df9d7621 CIK	90	zpl_bdi_setup(struct super_block sb, char name)
	91	{
	92	struct backing_dev_info *bdi;
	93	int error;
	94
	95	bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
	96	error = bdi_setup_and_register(bdi, name);
	97	if (error) {
	98	kmem_free(bdi, sizeof (struct backing_dev_info));
	99	return (error);
	100	}
	101
	102	sb->s_bdi = bdi;
	103
	104	return (0);
	105	}
	106	static inline void
	107	zpl_bdi_destroy(struct super_block *sb)
87d546d8	108	{
df9d7621 CIK	109	struct backing_dev_info *bdi = sb->s_bdi;
	110
	111	bdi_destroy(bdi);
	112	kmem_free(bdi, sizeof (struct backing_dev_info));
	113	sb->s_bdi = NULL;
87d546d8 TG	114	}
	115	#elif defined(HAVE_3ARGS_BDI_SETUP_AND_REGISTER)
	116	static inline int
df9d7621	117	zpl_bdi_setup(struct super_block sb, char name)
87d546d8	118	{
df9d7621 CIK	119	struct backing_dev_info *bdi;
	120	int error;
	121
	122	bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
	123	error = bdi_setup_and_register(bdi, name, BDI_CAP_MAP_COPY);
	124	if (error) {
	125	kmem_free(sb->s_bdi, sizeof (struct backing_dev_info));
	126	return (error);
	127	}
	128
	129	sb->s_bdi = bdi;
	130
	131	return (0);
	132	}
	133	static inline void
	134	zpl_bdi_destroy(struct super_block *sb)
	135	{
	136	struct backing_dev_info *bdi = sb->s_bdi;
	137
	138	bdi_destroy(bdi);
	139	kmem_free(bdi, sizeof (struct backing_dev_info));
	140	sb->s_bdi = NULL;
87d546d8 TG	141	}
	142	#else
	143	extern atomic_long_t zfs_bdi_seq;
	144
	145	static inline int
df9d7621	146	zpl_bdi_setup(struct super_block sb, char name)
87d546d8	147	{
df9d7621	148	struct backing_dev_info *bdi;
87d546d8 TG	149	int error;
87d546d8 TG	150
df9d7621	151	bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
87d546d8 TG	152	bdi->name = name;
	153	bdi->capabilities = BDI_CAP_MAP_COPY;
	154
	155	error = bdi_init(bdi);
df9d7621 CIK	156	if (error) {
df9d7621 CIK	157	kmem_free(bdi, sizeof (struct backing_dev_info));
87d546d8	158	return (error);
df9d7621	159	}
87d546d8	160
df9d7621	161	error = bdi_register(bdi, NULL, "%.28s-%ld", name,
87d546d8 TG	162	atomic_long_inc_return(&zfs_bdi_seq));
	163	if (error) {
	164	bdi_destroy(bdi);
df9d7621	165	kmem_free(bdi, sizeof (struct backing_dev_info));
87d546d8 TG	166	return (error);
	167	}
	168
df9d7621 CIK	169	sb->s_bdi = bdi;
	170
	171	return (0);
	172	}
	173	static inline void
	174	zpl_bdi_destroy(struct super_block *sb)
	175	{
	176	struct backing_dev_info *bdi = sb->s_bdi;
	177
	178	bdi_destroy(bdi);
	179	kmem_free(bdi, sizeof (struct backing_dev_info));
	180	sb->s_bdi = NULL;
87d546d8 TG	181	}
	182	#endif
	183
	184	/*
	185	* 2.6.38 API change,
	186	* LOOKUP_RCU flag introduced to distinguish rcu-walk from ref-walk cases.
	187	*/
	188	#ifndef LOOKUP_RCU
	189	#define LOOKUP_RCU 0x0
	190	#endif /* LOOKUP_RCU */
	191
	192	/*
	193	* 3.2-rc1 API change,
	194	* Add set_nlink() if it is not exported by the Linux kernel.
	195	*
	196	* i_nlink is read-only in Linux 3.2, but it can be set directly in
	197	* earlier kernels.
	198	*/
	199	#ifndef HAVE_SET_NLINK
	200	static inline void
	201	set_nlink(struct inode *inode, unsigned int nlink)
	202	{
	203	inode->i_nlink = nlink;
	204	}
	205	#endif /* HAVE_SET_NLINK */
	206
	207	/*
	208	* 3.3 API change,
	209	* The VFS .create, .mkdir and .mknod callbacks were updated to take a
	210	* umode_t type rather than an int. To cleanly handle both definitions
	211	* the zpl_umode_t type is introduced and set accordingly.
	212	*/
	213	#ifdef HAVE_MKDIR_UMODE_T
	214	typedef umode_t zpl_umode_t;
	215	#else
	216	typedef int zpl_umode_t;
	217	#endif
	218
	219	/*
	220	* 3.5 API change,
	221	* The clear_inode() function replaces end_writeback() and introduces an
	222	* ordering change regarding when the inode_sync_wait() occurs. See the
	223	* configure check in config/kernel-clear-inode.m4 for full details.
	224	*/
	225	#if defined(HAVE_EVICT_INODE) && !defined(HAVE_CLEAR_INODE)
	226	#define clear_inode(ip) end_writeback(ip)
	227	#endif /* HAVE_EVICT_INODE && !HAVE_CLEAR_INODE */
	228
	229	/*
	230	* 3.6 API change,
	231	* The sget() helper function now takes the mount flags as an argument.
	232	*/
	233	#ifdef HAVE_5ARG_SGET
	234	#define zpl_sget(type, cmp, set, fl, mtd) sget(type, cmp, set, fl, mtd)
	235	#else
	236	#define zpl_sget(type, cmp, set, fl, mtd) sget(type, cmp, set, mtd)
	237	#endif /* HAVE_5ARG_SGET */
	238
	239	#if defined(SEEK_HOLE) && defined(SEEK_DATA) && !defined(HAVE_LSEEK_EXECUTE)
	240	static inline loff_t
	241	lseek_execute(
	242	struct file *filp,
	243	struct inode *inode,
	244	loff_t offset,
245	loff_t maxsize)
246	{
247	if (offset < 0 && !(filp->f_mode & FMODE_UNSIGNED_OFFSET))
248	return (-EINVAL);
249
250	if (offset > maxsize)
251	return (-EINVAL);
252
253	if (offset != filp->f_pos) {
254	spin_lock(&filp->f_lock);
255	filp->f_pos = offset;
256	filp->f_version = 0;
257	spin_unlock(&filp->f_lock);
258	}
259
260	return (offset);
261	}
262	#endif /* SEEK_HOLE && SEEK_DATA && !HAVE_LSEEK_EXECUTE */
263
264	#if defined(CONFIG_FS_POSIX_ACL)
265	/*
266	* These functions safely approximates the behavior of posix_acl_release()
267	* which cannot be used because it calls the GPL-only symbol kfree_rcu().
268	* The in-kernel version, which can access the RCU, frees the ACLs after
269	* the grace period expires. Because we're unsure how long that grace
270	* period may be this implementation conservatively delays for 60 seconds.
271	* This is several orders of magnitude larger than expected grace period.
272	* At 60 seconds the kernel will also begin issuing RCU stall warnings.
273	*/
274	#include <linux/posix_acl.h>
275
276	#if defined(HAVE_POSIX_ACL_RELEASE) && !defined(HAVE_POSIX_ACL_RELEASE_GPL_ONLY)
277	#define zpl_posix_acl_release(arg) posix_acl_release(arg)
278	#else
279	void zpl_posix_acl_release_impl(struct posix_acl *);
280
281	static inline void
282	zpl_posix_acl_release(struct posix_acl *acl)
283	{
284	if ((acl == NULL) \|\| (acl == ACL_NOT_CACHED))
285	return;
286
287	if (atomic_dec_and_test(&acl->a_refcount))
288	zpl_posix_acl_release_impl(acl);
289	}
290	#endif /* HAVE_POSIX_ACL_RELEASE */
291
292	#ifdef HAVE_SET_CACHED_ACL_USABLE
293	#define zpl_set_cached_acl(ip, ty, n) set_cached_acl(ip, ty, n)
294	#define zpl_forget_cached_acl(ip, ty) forget_cached_acl(ip, ty)
295	#else
296	static inline void
297	zpl_set_cached_acl(struct inode ip, int type, struct posix_acl newer) {
298	struct posix_acl *older = NULL;
299
300	spin_lock(&ip->i_lock);
301
302	if ((newer != ACL_NOT_CACHED) && (newer != NULL))
303	posix_acl_dup(newer);
304
305	switch (type) {
306	case ACL_TYPE_ACCESS:
307	older = ip->i_acl;
308	rcu_assign_pointer(ip->i_acl, newer);
309	break;
310	case ACL_TYPE_DEFAULT:
311	older = ip->i_default_acl;
312	rcu_assign_pointer(ip->i_default_acl, newer);
313	break;
314	}
315
316	spin_unlock(&ip->i_lock);
317
318	zpl_posix_acl_release(older);
319	}
320
321	static inline void
322	zpl_forget_cached_acl(struct inode *ip, int type) {
323	zpl_set_cached_acl(ip, type, (struct posix_acl *)ACL_NOT_CACHED);
324	}
325	#endif /* HAVE_SET_CACHED_ACL_USABLE */
326
327	#ifndef HAVE___POSIX_ACL_CHMOD
328	#ifdef HAVE_POSIX_ACL_CHMOD
329	#define __posix_acl_chmod(acl, gfp, mode) posix_acl_chmod(acl, gfp, mode)
330	#define __posix_acl_create(acl, gfp, mode) posix_acl_create(acl, gfp, mode)
331	#else
332	static inline int
333	__posix_acl_chmod(struct posix_acl **acl, int flags, umode_t umode) {
334	struct posix_acl oldacl = acl;
335	mode_t mode = umode;
336	int error;
337
338	acl = posix_acl_clone(acl, flags);
339	zpl_posix_acl_release(oldacl);
340
341	if (!(*acl))
342	return (-ENOMEM);
343
344	error = posix_acl_chmod_masq(*acl, mode);
345	if (error) {
346	zpl_posix_acl_release(*acl);
347	*acl = NULL;
348	}
349
350	return (error);
351	}
352
353	static inline int
354	__posix_acl_create(struct posix_acl *acl, int flags, umode_t umodep) {
355	struct posix_acl oldacl = acl;
356	mode_t mode = *umodep;
357	int error;
358
359	acl = posix_acl_clone(acl, flags);
360	zpl_posix_acl_release(oldacl);
361
362	if (!(*acl))
363	return (-ENOMEM);
364
365	error = posix_acl_create_masq(*acl, &mode);
366	*umodep = mode;
367
368	if (error < 0) {
369	zpl_posix_acl_release(*acl);
370	*acl = NULL;
371	}
372
373	return (error);
374	}
375	#endif /* HAVE_POSIX_ACL_CHMOD */
376	#endif /* HAVE___POSIX_ACL_CHMOD */
377
378	#ifdef HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T
379	typedef umode_t zpl_equivmode_t;
380	#else
381	typedef mode_t zpl_equivmode_t;
382	#endif /* HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T */
383
384	/*
385	* 4.8 API change,
386	* posix_acl_valid() now must be passed a namespace, the namespace from
387	* from super block associated with the given inode is used for this purpose.
388	*/
389	#ifdef HAVE_POSIX_ACL_VALID_WITH_NS
390	#define zpl_posix_acl_valid(ip, acl) posix_acl_valid(ip->i_sb->s_user_ns, acl)
391	#else
392	#define zpl_posix_acl_valid(ip, acl) posix_acl_valid(acl)
393	#endif
394
395	#endif /* CONFIG_FS_POSIX_ACL */
396
397	/*
398	* 2.6.38 API change,
399	* The is_owner_or_cap() function was renamed to inode_owner_or_capable().
400	*/
401	#ifdef HAVE_INODE_OWNER_OR_CAPABLE
402	#define zpl_inode_owner_or_capable(ip) inode_owner_or_capable(ip)
403	#else
404	#define zpl_inode_owner_or_capable(ip) is_owner_or_cap(ip)
405	#endif /* HAVE_INODE_OWNER_OR_CAPABLE */
406
407	/*
408	* 3.19 API change
409	* struct access f->f_dentry->d_inode was replaced by accessor function
410	* file_inode(f)
411	*/
412	#ifndef HAVE_FILE_INODE
413	static inline struct inode file_inode(const struct file f)
414	{
415	return (f->f_dentry->d_inode);
416	}
417	#endif /* HAVE_FILE_INODE */
418
419	/*
420	* 2.6.38 API change
421	*/
422	#ifdef HAVE_FOLLOW_DOWN_ONE
423	#define zpl_follow_down_one(path) follow_down_one(path)
424	#define zpl_follow_up(path) follow_up(path)
425	#else
426	#define zpl_follow_down_one(path) follow_down(path)
427	#define zpl_follow_up(path) follow_up(path)
428	#endif
429
430	/*
431	* 4.9 API change
432	*/
433	#ifndef HAVE_SETATTR_PREPARE
434	static inline int
435	setattr_prepare(struct dentry dentry, struct iattr ia)
436	{
437	return (inode_change_ok(dentry->d_inode, ia));
438	}
439	#endif
440
3e990ae0 CIK	441	/*
	442	* 4.11 API change
	443	* These macros are defined by kernel 4.11. We define them so that the same
	444	* code builds under kernels < 4.11 and >= 4.11. The macros are set to 0 so
	445	* that it will create obvious failures if they are accidentally used when built
	446	* against a kernel >= 4.11.
	447	*/
	448
	449	#ifndef STATX_BASIC_STATS
	450	#define STATX_BASIC_STATS 0
	451	#endif
	452
	453	#ifndef AT_STATX_SYNC_AS_STAT
	454	#define AT_STATX_SYNC_AS_STAT 0
	455	#endif
	456
	457	/*
	458	* 4.11 API change
	459	* 4.11 takes struct path , < 4.11 takes vfsmount
	460	*/
	461
	462	#ifdef HAVE_VFSMOUNT_IOPS_GETATTR
	463	#define ZPL_GETATTR_WRAPPER(func) \
	464	static int \
	465	func(struct vfsmount mnt, struct dentry dentry, struct kstat *stat) \
	466	{ \
	467	struct path path = { .mnt = mnt, .dentry = dentry }; \
	468	return func##_impl(&path, stat, STATX_BASIC_STATS, \
	469	AT_STATX_SYNC_AS_STAT); \
	470	}
	471	#elif defined(HAVE_PATH_IOPS_GETATTR)
	472	#define ZPL_GETATTR_WRAPPER(func) \
	473	static int \
	474	func(const struct path path, struct kstat stat, u32 request_mask, \
	475	unsigned int query_flags) \
	476	{ \
	477	return (func##_impl(path, stat, request_mask, query_flags)); \
	478	}
	479	#else
	480	#error
	481	#endif
	482
df9d7621 CIK	483	/*
	484	* 4.9 API change
	485	* Preferred interface to get the current FS time.
	486	*/
	487	#if !defined(HAVE_CURRENT_TIME)
	488	static inline struct timespec
	489	current_time(struct inode *ip)
	490	{
	491	return (timespec_trunc(current_kernel_time(), ip->i_sb->s_time_gran));
	492	}
	493	#endif
3e990ae0	494
87d546d8	495	#endif /* _ZFS_VFS_H */