[mirror_ubuntu-zesty-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 <sys/cred.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 - x.y, bdi_setup_and_register() takes 2 arguments.
 */
#if defined(HAVE_2ARGS_BDI_SETUP_AND_REGISTER)
static inline int
zpl_bdi_setup_and_register(struct backing_dev_info *bdi, char *name)
{
	return (bdi_setup_and_register(bdi, name));
}
#elif defined(HAVE_3ARGS_BDI_SETUP_AND_REGISTER)
static inline int
zpl_bdi_setup_and_register(struct backing_dev_info *bdi, char *name)
{
	return (bdi_setup_and_register(bdi, name, BDI_CAP_MAP_COPY));
}
#else
extern atomic_long_t zfs_bdi_seq;

static inline int
zpl_bdi_setup_and_register(struct backing_dev_info *bdi, char *name)
{
	char tmp[32];
	int error;

	bdi->name = name;
	bdi->capabilities = BDI_CAP_MAP_COPY;

	error = bdi_init(bdi);
	if (error)
		return (error);

	sprintf(tmp, "%.28s%s", name, "-%d");
	error = bdi_register(bdi, NULL, tmp,
	    atomic_long_inc_return(&zfs_bdi_seq));
	if (error) {
		bdi_destroy(bdi);
		return (error);
	}

	return (error);
}
#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)
#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_posix_acl_free(void *arg) {
	kfree(arg);
}

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)) {
		taskq_dispatch_delay(system_taskq, zpl_posix_acl_free, acl,
		    TQ_SLEEP, ddi_get_lbolt() + 60*HZ);
	}
}

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_POSIX_ACL_RELEASE */

#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 */

/*
 * 4.1 API change
 * struct access file->f_path.dentry was replaced by accessor function
 * file_dentry(f)
 */
#ifndef HAVE_FILE_DENTRY
static inline struct dentry *file_dentry(const struct file *f)
{
	return (f->f_path.dentry);
}
#endif /* HAVE_FILE_DENTRY */

#ifdef HAVE_KUID_HELPERS
static inline uid_t zfs_uid_read_impl(struct inode *ip)
{
#ifdef HAVE_SUPER_USER_NS
	return (from_kuid(ip->i_sb->s_user_ns, ip->i_uid));
#else
	return (from_kuid(kcred->user_ns, ip->i_uid));
#endif
}

static inline uid_t zfs_uid_read(struct inode *ip)
{
	return (zfs_uid_read_impl(ip));
}

static inline gid_t zfs_gid_read_impl(struct inode *ip)
{
#ifdef HAVE_SUPER_USER_NS
	return (from_kgid(ip->i_sb->s_user_ns, ip->i_gid));
#else
	return (from_kgid(kcred->user_ns, ip->i_gid));
#endif
}

static inline gid_t zfs_gid_read(struct inode *ip)
{
	return (zfs_gid_read_impl(ip));
}

static inline void zfs_uid_write(struct inode *ip, uid_t uid)
{
#ifdef HAVE_SUPER_USER_NS
	ip->i_uid = make_kuid(ip->i_sb->s_user_ns, uid);
#else
	ip->i_uid = make_kuid(kcred->user_ns, uid);
#endif
}

static inline void zfs_gid_write(struct inode *ip, gid_t gid)
{
#ifdef HAVE_SUPER_USER_NS
	ip->i_gid = make_kgid(ip->i_sb->s_user_ns, gid);
#else
	ip->i_gid = make_kgid(kcred->user_ns, gid);
#endif
}

#else
static inline uid_t zfs_uid_read(struct inode *ip)
{
	return (ip->i_uid);
}

static inline gid_t zfs_gid_read(struct inode *ip)
{
	return (ip->i_gid);
}

static inline void zfs_uid_write(struct inode *ip, uid_t uid)
{
	ip->i_uid = uid;
}

static inline void zfs_gid_write(struct inode *ip, gid_t gid)
{
	ip->i_gid = gid;
}
#endif

/*
 * 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

#endif /* _ZFS_VFS_H */
Commit	Line	Data
7bdf406d 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>
51d97d8f	31	#include <sys/cred.h>
7bdf406d TG	32	#include <linux/backing-dev.h>
	33
	34	/*
	35	* 2.6.28 API change,
	36	* Added insert_inode_locked() helper function, prior to this most callers
	37	* used insert_inode_hash(). The older method doesn't check for collisions
	38	* in the inode_hashtable but it still acceptible for use.
	39	*/
	40	#ifndef HAVE_INSERT_INODE_LOCKED
	41	static inline int
	42	insert_inode_locked(struct inode *ip)
	43	{
	44	insert_inode_hash(ip);
	45	return (0);
	46	}
	47	#endif /* HAVE_INSERT_INODE_LOCKED */
	48
	49	/*
	50	* 2.6.35 API change,
	51	* Add truncate_setsize() if it is not exported by the Linux kernel.
	52	*
	53	* Truncate the inode and pages associated with the inode. The pages are
	54	* unmapped and removed from cache.
	55	*/
	56	#ifndef HAVE_TRUNCATE_SETSIZE
	57	static inline void
	58	truncate_setsize(struct inode *ip, loff_t new)
	59	{
	60	struct address_space *mapping = ip->i_mapping;
	61
	62	i_size_write(ip, new);
	63
	64	unmap_mapping_range(mapping, new + PAGE_SIZE - 1, 0, 1);
	65	truncate_inode_pages(mapping, new);
	66	unmap_mapping_range(mapping, new + PAGE_SIZE - 1, 0, 1);
	67	}
	68	#endif /* HAVE_TRUNCATE_SETSIZE */
	69
	70	/*
	71	* 2.6.32 - 2.6.33, bdi_setup_and_register() is not available.
	72	* 2.6.34 - 3.19, bdi_setup_and_register() takes 3 arguments.
	73	* 4.0 - x.y, bdi_setup_and_register() takes 2 arguments.
	74	*/
	75	#if defined(HAVE_2ARGS_BDI_SETUP_AND_REGISTER)
	76	static inline int
	77	zpl_bdi_setup_and_register(struct backing_dev_info bdi, char name)
	78	{
	79	return (bdi_setup_and_register(bdi, name));
	80	}
	81	#elif defined(HAVE_3ARGS_BDI_SETUP_AND_REGISTER)
	82	static inline int
	83	zpl_bdi_setup_and_register(struct backing_dev_info bdi, char name)
	84	{
	85	return (bdi_setup_and_register(bdi, name, BDI_CAP_MAP_COPY));
	86	}
	87	#else
	88	extern atomic_long_t zfs_bdi_seq;
	89
	90	static inline int
	91	zpl_bdi_setup_and_register(struct backing_dev_info bdi, char name)
	92	{
	93	char tmp[32];
	94	int error;
	95
96	bdi->name = name;
97	bdi->capabilities = BDI_CAP_MAP_COPY;
98
99	error = bdi_init(bdi);
100	if (error)
101	return (error);
102
103	sprintf(tmp, "%.28s%s", name, "-%d");
104	error = bdi_register(bdi, NULL, tmp,
105	atomic_long_inc_return(&zfs_bdi_seq));
106	if (error) {
107	bdi_destroy(bdi);
108	return (error);
109	}
110
111	return (error);
112	}
113	#endif
114
115	/*
116	* 2.6.38 API change,
117	* LOOKUP_RCU flag introduced to distinguish rcu-walk from ref-walk cases.
118	*/
119	#ifndef LOOKUP_RCU
120	#define LOOKUP_RCU 0x0
121	#endif /* LOOKUP_RCU */
122
123	/*
124	* 3.2-rc1 API change,
125	* Add set_nlink() if it is not exported by the Linux kernel.
126	*
127	* i_nlink is read-only in Linux 3.2, but it can be set directly in
128	* earlier kernels.
129	*/
130	#ifndef HAVE_SET_NLINK
131	static inline void
132	set_nlink(struct inode *inode, unsigned int nlink)
133	{
134	inode->i_nlink = nlink;
135	}
136	#endif /* HAVE_SET_NLINK */
137
138	/*
139	* 3.3 API change,
140	* The VFS .create, .mkdir and .mknod callbacks were updated to take a
141	* umode_t type rather than an int. To cleanly handle both definitions
142	* the zpl_umode_t type is introduced and set accordingly.
143	*/
144	#ifdef HAVE_MKDIR_UMODE_T
145	typedef umode_t zpl_umode_t;
146	#else
147	typedef int zpl_umode_t;
148	#endif
149
150	/*
151	* 3.5 API change,
152	* The clear_inode() function replaces end_writeback() and introduces an
153	* ordering change regarding when the inode_sync_wait() occurs. See the
154	* configure check in config/kernel-clear-inode.m4 for full details.
155	*/
156	#if defined(HAVE_EVICT_INODE) && !defined(HAVE_CLEAR_INODE)
157	#define clear_inode(ip) end_writeback(ip)
158	#endif /* HAVE_EVICT_INODE && !HAVE_CLEAR_INODE */
159
160	/*
161	* 3.6 API change,
162	* The sget() helper function now takes the mount flags as an argument.
163	*/
164	#ifdef HAVE_5ARG_SGET
165	#define zpl_sget(type, cmp, set, fl, mtd) sget(type, cmp, set, fl, mtd)
166	#else
167	#define zpl_sget(type, cmp, set, fl, mtd) sget(type, cmp, set, mtd)
168	#endif /* HAVE_5ARG_SGET */
169
170	#if defined(SEEK_HOLE) && defined(SEEK_DATA) && !defined(HAVE_LSEEK_EXECUTE)
171	static inline loff_t
172	lseek_execute(
173	struct file *filp,
174	struct inode *inode,
175	loff_t offset,
176	loff_t maxsize)
177	{
178	if (offset < 0 && !(filp->f_mode & FMODE_UNSIGNED_OFFSET))
179	return (-EINVAL);
180
181	if (offset > maxsize)
182	return (-EINVAL);
183
184	if (offset != filp->f_pos) {
185	spin_lock(&filp->f_lock);
186	filp->f_pos = offset;
187	filp->f_version = 0;
188	spin_unlock(&filp->f_lock);
189	}
190
191	return (offset);
192	}
193	#endif /* SEEK_HOLE && SEEK_DATA && !HAVE_LSEEK_EXECUTE */
194
195	#if defined(CONFIG_FS_POSIX_ACL)
196	/*
197	* These functions safely approximates the behavior of posix_acl_release()
198	* which cannot be used because it calls the GPL-only symbol kfree_rcu().
199	* The in-kernel version, which can access the RCU, frees the ACLs after
200	* the grace period expires. Because we're unsure how long that grace
201	* period may be this implementation conservatively delays for 60 seconds.
202	* This is several orders of magnitude larger than expected grace period.
203	* At 60 seconds the kernel will also begin issuing RCU stall warnings.
204	*/
205	#include <linux/posix_acl.h>
206
207	#if defined(HAVE_POSIX_ACL_RELEASE) && !defined(HAVE_POSIX_ACL_RELEASE_GPL_ONLY)
208
209	#define zpl_posix_acl_release(arg) posix_acl_release(arg)
210	#define zpl_set_cached_acl(ip, ty, n) set_cached_acl(ip, ty, n)
211	#define zpl_forget_cached_acl(ip, ty) forget_cached_acl(ip, ty)
212
213	#else
214
215	static inline void
216	zpl_posix_acl_free(void *arg) {
217	kfree(arg);
218	}
219
220	static inline void
221	zpl_posix_acl_release(struct posix_acl *acl)
222	{
223	if ((acl == NULL) \|\| (acl == ACL_NOT_CACHED))
224	return;
225
226	if (atomic_dec_and_test(&acl->a_refcount)) {
227	taskq_dispatch_delay(system_taskq, zpl_posix_acl_free, acl,
228	TQ_SLEEP, ddi_get_lbolt() + 60*HZ);
229	}
230	}
231
232	static inline void
233	zpl_set_cached_acl(struct inode ip, int type, struct posix_acl newer) {
234	struct posix_acl *older = NULL;
235
236	spin_lock(&ip->i_lock);
237
238	if ((newer != ACL_NOT_CACHED) && (newer != NULL))
239	posix_acl_dup(newer);
240
241	switch (type) {
242	case ACL_TYPE_ACCESS:
243	older = ip->i_acl;
244	rcu_assign_pointer(ip->i_acl, newer);
245	break;
246	case ACL_TYPE_DEFAULT:
247	older = ip->i_default_acl;
248	rcu_assign_pointer(ip->i_default_acl, newer);
249	break;
250	}
251
252	spin_unlock(&ip->i_lock);
253
254	zpl_posix_acl_release(older);
255	}
256
257	static inline void
258	zpl_forget_cached_acl(struct inode *ip, int type) {
259	zpl_set_cached_acl(ip, type, (struct posix_acl *)ACL_NOT_CACHED);
260	}
261	#endif /* HAVE_POSIX_ACL_RELEASE */
262
263	#ifndef HAVE___POSIX_ACL_CHMOD
264	#ifdef HAVE_POSIX_ACL_CHMOD
265	#define __posix_acl_chmod(acl, gfp, mode) posix_acl_chmod(acl, gfp, mode)
266	#define __posix_acl_create(acl, gfp, mode) posix_acl_create(acl, gfp, mode)
267	#else
268	static inline int
269	__posix_acl_chmod(struct posix_acl **acl, int flags, umode_t umode) {
270	struct posix_acl oldacl = acl;
271	mode_t mode = umode;
272	int error;
273
274	acl = posix_acl_clone(acl, flags);
275	zpl_posix_acl_release(oldacl);
276
277	if (!(*acl))
278	return (-ENOMEM);
279
280	error = posix_acl_chmod_masq(*acl, mode);
281	if (error) {
282	zpl_posix_acl_release(*acl);
283	*acl = NULL;
284	}
285
286	return (error);
287	}
288
289	static inline int
290	__posix_acl_create(struct posix_acl *acl, int flags, umode_t umodep) {
291	struct posix_acl oldacl = acl;
292	mode_t mode = *umodep;
293	int error;
294
295	acl = posix_acl_clone(acl, flags);
296	zpl_posix_acl_release(oldacl);
297
298	if (!(*acl))
299	return (-ENOMEM);
300
301	error = posix_acl_create_masq(*acl, &mode);
302	*umodep = mode;
303
304	if (error < 0) {
305	zpl_posix_acl_release(*acl);
306	*acl = NULL;
307	}
308
309	return (error);
310	}
311	#endif /* HAVE_POSIX_ACL_CHMOD */
312	#endif /* HAVE___POSIX_ACL_CHMOD */
313
314	#ifdef HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T
315	typedef umode_t zpl_equivmode_t;
316	#else
317	typedef mode_t zpl_equivmode_t;
318	#endif /* HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T */
319
320	/*
321	* 4.8 API change,
322	* posix_acl_valid() now must be passed a namespace, the namespace from
323	* from super block associated with the given inode is used for this purpose.
324	*/
325	#ifdef HAVE_POSIX_ACL_VALID_WITH_NS
326	#define zpl_posix_acl_valid(ip, acl) posix_acl_valid(ip->i_sb->s_user_ns, acl)
327	#else
328	#define zpl_posix_acl_valid(ip, acl) posix_acl_valid(acl)
329	#endif
330
331	#endif /* CONFIG_FS_POSIX_ACL */
332
333	/*
334	* 2.6.38 API change,
335	* The is_owner_or_cap() function was renamed to inode_owner_or_capable().
336	*/
337	#ifdef HAVE_INODE_OWNER_OR_CAPABLE
338	#define zpl_inode_owner_or_capable(ip) inode_owner_or_capable(ip)
339	#else
340	#define zpl_inode_owner_or_capable(ip) is_owner_or_cap(ip)
341	#endif /* HAVE_INODE_OWNER_OR_CAPABLE */
342
343	/*
344	* 3.19 API change
345	* struct access f->f_dentry->d_inode was replaced by accessor function
346	* file_inode(f)
347	*/
348	#ifndef HAVE_FILE_INODE
349	static inline struct inode file_inode(const struct file f)
350	{
351	return (f->f_dentry->d_inode);
352	}
353	#endif /* HAVE_FILE_INODE */
354
51d97d8f TG	355	/*
	356	* 4.1 API change
	357	* struct access file->f_path.dentry was replaced by accessor function
	358	* file_dentry(f)
	359	*/
	360	#ifndef HAVE_FILE_DENTRY
	361	static inline struct dentry file_dentry(const struct file f)
	362	{
	363	return (f->f_path.dentry);
	364	}
	365	#endif /* HAVE_FILE_DENTRY */
	366
	367	#ifdef HAVE_KUID_HELPERS
	368	static inline uid_t zfs_uid_read_impl(struct inode *ip)
	369	{
	370	#ifdef HAVE_SUPER_USER_NS
	371	return (from_kuid(ip->i_sb->s_user_ns, ip->i_uid));
	372	#else
	373	return (from_kuid(kcred->user_ns, ip->i_uid));
	374	#endif
	375	}
	376
	377	static inline uid_t zfs_uid_read(struct inode *ip)
	378	{
	379	return (zfs_uid_read_impl(ip));
	380	}
	381
	382	static inline gid_t zfs_gid_read_impl(struct inode *ip)
	383	{
	384	#ifdef HAVE_SUPER_USER_NS
	385	return (from_kgid(ip->i_sb->s_user_ns, ip->i_gid));
	386	#else
	387	return (from_kgid(kcred->user_ns, ip->i_gid));
	388	#endif
	389	}
	390
	391	static inline gid_t zfs_gid_read(struct inode *ip)
	392	{
	393	return (zfs_gid_read_impl(ip));
	394	}
	395
	396	static inline void zfs_uid_write(struct inode *ip, uid_t uid)
	397	{
	398	#ifdef HAVE_SUPER_USER_NS
	399	ip->i_uid = make_kuid(ip->i_sb->s_user_ns, uid);
	400	#else
	401	ip->i_uid = make_kuid(kcred->user_ns, uid);
	402	#endif
	403	}
	404
	405	static inline void zfs_gid_write(struct inode *ip, gid_t gid)
	406	{
	407	#ifdef HAVE_SUPER_USER_NS
	408	ip->i_gid = make_kgid(ip->i_sb->s_user_ns, gid);
	409	#else
	410	ip->i_gid = make_kgid(kcred->user_ns, gid);
	411	#endif
	412	}
	413
	414	#else
	415	static inline uid_t zfs_uid_read(struct inode *ip)
	416	{
	417	return (ip->i_uid);
	418	}
419
420	static inline gid_t zfs_gid_read(struct inode *ip)
421	{
422	return (ip->i_gid);
423	}
424
425	static inline void zfs_uid_write(struct inode *ip, uid_t uid)
426	{
427	ip->i_uid = uid;
428	}
429
430	static inline void zfs_gid_write(struct inode *ip, gid_t gid)
431	{
432	ip->i_gid = gid;
433	}
434	#endif
435
7bdf406d TG	436	/*
	437	* 2.6.38 API change
	438	*/
	439	#ifdef HAVE_FOLLOW_DOWN_ONE
	440	#define zpl_follow_down_one(path) follow_down_one(path)
	441	#define zpl_follow_up(path) follow_up(path)
	442	#else
	443	#define zpl_follow_down_one(path) follow_down(path)
	444	#define zpl_follow_up(path) follow_up(path)
	445	#endif
	446
51d97d8f TG	447	/*
	448	* 4.9 API change
	449	*/
	450	#ifndef HAVE_SETATTR_PREPARE
	451	static inline int
	452	setattr_prepare(struct dentry dentry, struct iattr ia)
	453	{
	454	return (inode_change_ok(dentry->d_inode, ia));
	455	}
	456	#endif
	457
7bdf406d	458	#endif /* _ZFS_VFS_H */