X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flustre_compat.h;h=df20146d716cf3c9f118658ce9b2fd554243dcc4;hp=bdd3d789a91f21719555494131c689a2f24cfb2c;hb=65a8ff5fbe8ca014bd01150ab102d8aa43f78cff;hpb=8bc4b26453fb9d3296475ab3b9c9f3a9bf905afc

diff --git a/lustre/include/lustre_compat.h b/lustre/include/lustre_compat.h
index bdd3d78..df20146 100644
--- a/lustre/include/lustre_compat.h
+++ b/lustre/include/lustre_compat.h
@@ -23,7 +23,7 @@
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -33,13 +33,17 @@
 #ifndef _LUSTRE_COMPAT_H
 #define _LUSTRE_COMPAT_H
 
+#include <linux/aio.h>
+#include <linux/fs.h>
 #include <linux/fs_struct.h>
 #include <linux/namei.h>
 #include <linux/pagemap.h>
 #include <linux/bio.h>
 #include <linux/xattr.h>
+#include <linux/workqueue.h>
+#include <linux/blkdev.h>
 
-#include <libcfs/libcfs.h>
+#include <libcfs/linux/linux-fs.h>
 #include <lustre_patchless_compat.h>
 #include <obd_support.h>
 
@@ -51,30 +55,33 @@
 # define UNLOCK_FS_STRUCT(fs)	spin_unlock(&(fs)->lock)
 #endif
 
+#ifdef HAVE_FS_STRUCT_SEQCOUNT
+# define WRITE_FS_SEQ_BEGIN(fs)	write_seqcount_begin(&(fs)->seq)
+# define WRITE_FS_SEQ_END(fs)	write_seqcount_end(&(fs)->seq)
+#else
+# define WRITE_FS_SEQ_BEGIN(fs)
+# define WRITE_FS_SEQ_END(fs)
+#endif
 static inline void ll_set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
                                  struct dentry *dentry)
 {
-        struct path path;
-        struct path old_pwd;
-
-        path.mnt = mnt;
-        path.dentry = dentry;
-        LOCK_FS_STRUCT(fs);
-        old_pwd = fs->pwd;
-        path_get(&path);
-        fs->pwd = path;
-        UNLOCK_FS_STRUCT(fs);
-
-        if (old_pwd.dentry)
-                path_put(&old_pwd);
+	struct path path;
+	struct path old_pwd;
+
+	path.mnt = mnt;
+	path.dentry = dentry;
+	path_get(&path);
+	LOCK_FS_STRUCT(fs);
+	WRITE_FS_SEQ_BEGIN(fs);
+	old_pwd = fs->pwd;
+	fs->pwd = path;
+	WRITE_FS_SEQ_END(fs);
+	UNLOCK_FS_STRUCT(fs);
+
+	if (old_pwd.dentry)
+		path_put(&old_pwd);
 }
 
-/*
- * set ATTR_BLOCKS to a high value to avoid any risk of collision with other
- * ATTR_* attributes (see bug 13828)
- */
-#define ATTR_BLOCKS    (1 << 27)
-
 #define current_ngroups current_cred()->group_info->ngroups
 #define current_groups current_cred()->group_info->small_block
 
@@ -92,8 +99,6 @@ static inline void ll_set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
 #define MODULE_ALIAS_FS(name)
 #endif
 
-#define LTIME_S(time)                   (time.tv_sec)
-
 #ifdef HAVE_GENERIC_PERMISSION_2ARGS
 # define ll_generic_permission(inode, mask, flags, check_acl) \
 	 generic_permission(inode, mask)
@@ -141,6 +146,14 @@ static inline void ll_set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
 #define SLAB_DESTROY_BY_RCU 0
 #endif
 
+#ifndef HAVE_INIT_LIST_HEAD_RCU
+static inline void INIT_LIST_HEAD_RCU(struct list_head *list)
+{
+	WRITE_ONCE(list->next, list);
+	WRITE_ONCE(list->prev, list);
+}
+#endif
+
 #ifndef HAVE_DQUOT_SUSPEND
 # define ll_vfs_dq_init             vfs_dq_init
 # define ll_vfs_dq_drop             vfs_dq_drop
@@ -171,6 +184,12 @@ static inline void ll_set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
 #define bvl_to_page(bvl)		(bvl->bv_page)
 #endif
 
+#ifdef HAVE_BVEC_ITER
+#define bio_start_sector(bio) (bio->bi_iter.bi_sector)
+#else
+#define bio_start_sector(bio) (bio->bi_sector)
+#endif
+
 #ifndef HAVE_BLK_QUEUE_MAX_SEGMENTS
 #define blk_queue_max_segments(rq, seg)                      \
         do { blk_queue_max_phys_segments(rq, seg);           \
@@ -290,19 +309,6 @@ static inline int ll_namei_to_lookup_intent_flag(int flag)
 	return flag;
 }
 
-#ifdef HAVE_QC_MAKE_REQUEST_FN
-# define ll_mrf_ret blk_qc_t
-# define LL_MRF_RETURN(rc) RETURN(BLK_QC_T_NONE)
-#else
-# ifdef HAVE_VOID_MAKE_REQUEST_FN
-#  define ll_mrf_ret void
-#  define LL_MRF_RETURN(rc)
-# else
-#  define ll_mrf_ret int
-#  define LL_MRF_RETURN(rc) RETURN(rc)
-# endif
-#endif
-
 #include <linux/fs.h>
 #ifndef HAVE_PROTECT_I_NLINK
 static inline void set_nlink(struct inode *inode, unsigned int nlink)
@@ -386,11 +392,16 @@ static inline int radix_tree_exceptional_entry(void *arg)
 static inline void truncate_inode_pages_final(struct address_space *map)
 {
 	truncate_inode_pages(map, 0);
-		/* Workaround for LU-118 */
-	if (map->nrpages) {
-		spin_lock_irq(&map->tree_lock);
-		spin_unlock_irq(&map->tree_lock);
-	}	/* Workaround end */
+}
+#endif
+
+#ifndef HAVE_PTR_ERR_OR_ZERO
+static inline int __must_check PTR_ERR_OR_ZERO(__force const void *ptr)
+{
+	if (IS_ERR(ptr))
+		return PTR_ERR(ptr);
+	else
+		return 0;
 }
 #endif
 
@@ -443,6 +454,73 @@ static inline void truncate_inode_pages_final(struct address_space *map)
 # define GET_POSIX_ACL_XATTR_ENTRY(head) ((head)->a_entries)
 #endif
 
+#ifdef HAVE_IOP_XATTR
+#ifdef HAVE_XATTR_HANDLER_FLAGS
+#define ll_setxattr     generic_setxattr
+#define ll_getxattr     generic_getxattr
+#define ll_removexattr  generic_removexattr
+#else
+int ll_setxattr(struct dentry *dentry, const char *name,
+		const void *value, size_t size, int flags);
+ssize_t ll_getxattr(struct dentry *dentry, const char *name,
+		    void *buf, size_t buf_size);
+int ll_removexattr(struct dentry *dentry, const char *name);
+#endif /* ! HAVE_XATTR_HANDLER_FLAGS */
+#endif /* HAVE_IOP_XATTR */
+
+#ifndef HAVE_VFS_SETXATTR
+const struct xattr_handler *get_xattr_type(const char *name);
+
+static inline int
+__vfs_setxattr(struct dentry *dentry, struct inode *inode, const char *name,
+	       const void *value, size_t size, int flags)
+{
+# ifdef HAVE_XATTR_HANDLER_FLAGS
+	const struct xattr_handler *handler;
+	int rc;
+
+	handler = get_xattr_type(name);
+	if (!handler)
+		return -EOPNOTSUPP;
+
+#  if defined(HAVE_XATTR_HANDLER_INODE_PARAM)
+	rc = handler->set(handler, dentry, inode, name, value, size, flags);
+#  elif defined(HAVE_XATTR_HANDLER_SIMPLIFIED)
+	rc = handler->set(handler, dentry, name, value, size, flags);
+#  else
+	rc = handler->set(dentry, name, value, size, flags, handler->flags);
+#  endif /* !HAVE_XATTR_HANDLER_INODE_PARAM */
+	return rc;
+# else /* !HAVE_XATTR_HANDLER_FLAGS */
+	return ll_setxattr(dentry, name, value, size, flags);
+# endif /* HAVE_XATTR_HANDLER_FLAGS */
+}
+#endif /* HAVE_VFS_SETXATTR */
+
+#ifdef HAVE_IOP_SET_ACL
+#ifdef CONFIG_FS_POSIX_ACL
+#ifndef HAVE_POSIX_ACL_UPDATE_MODE
+static inline int posix_acl_update_mode(struct inode *inode, umode_t *mode_p,
+			  struct posix_acl **acl)
+{
+	umode_t mode = inode->i_mode;
+	int error;
+
+	error = posix_acl_equiv_mode(*acl, &mode);
+	if (error < 0)
+		return error;
+	if (error == 0)
+		*acl = NULL;
+	if (!in_group_p(inode->i_gid) &&
+	    !capable_wrt_inode_uidgid(inode, CAP_FSETID))
+		mode &= ~S_ISGID;
+	*mode_p = mode;
+	return 0;
+}
+#endif /* HAVE_POSIX_ACL_UPDATE_MODE */
+#endif
+#endif
+
 #ifndef HAVE_IOV_ITER_TRUNCATE
 static inline void iov_iter_truncate(struct iov_iter *i, u64 count)
 {
@@ -568,4 +646,147 @@ __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
 }
 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
 
+static inline void __user *get_vmf_address(struct vm_fault *vmf)
+{
+#ifdef HAVE_VM_FAULT_ADDRESS
+	return (void __user *)vmf->address;
+#else
+	return vmf->virtual_address;
+#endif
+}
+
+#ifdef HAVE_VM_OPS_USE_VM_FAULT_ONLY
+# define ll_filemap_fault(vma, vmf) filemap_fault(vmf)
+#else
+# define ll_filemap_fault(vma, vmf) filemap_fault(vma, vmf)
+#endif
+
+#ifndef HAVE_CURRENT_TIME
+static inline struct timespec current_time(struct inode *inode)
+{
+	return CURRENT_TIME;
+}
+#endif
+
+#ifndef time_after32
+/**
+ * time_after32 - compare two 32-bit relative times
+ * @a: the time which may be after @b
+ * @b: the time which may be before @a
+ *
+ * time_after32(a, b) returns true if the time @a is after time @b.
+ * time_before32(b, a) returns true if the time @b is before time @a.
+ *
+ * Similar to time_after(), compare two 32-bit timestamps for relative
+ * times.  This is useful for comparing 32-bit seconds values that can't
+ * be converted to 64-bit values (e.g. due to disk format or wire protocol
+ * issues) when it is known that the times are less than 68 years apart.
+ */
+#define time_after32(a, b)     ((s32)((u32)(b) - (u32)(a)) < 0)
+#define time_before32(b, a)    time_after32(a, b)
+
+#endif
+
+#ifndef __GFP_COLD
+#define __GFP_COLD 0
+#endif
+
+#ifndef alloc_workqueue
+#define alloc_workqueue(name, flags, max_active) create_workqueue(name)
+#endif
+
+#ifndef READ_ONCE
+#define READ_ONCE ACCESS_ONCE
+#endif
+
+#ifdef HAVE_BLK_INTEGRITY_ENABLED
+static inline unsigned short blk_integrity_interval(struct blk_integrity *bi)
+{
+#ifdef HAVE_INTERVAL_EXP_BLK_INTEGRITY
+	return bi->interval_exp ? 1 << bi->interval_exp : 0;
+#elif defined(HAVE_INTERVAL_BLK_INTEGRITY)
+	return bi->interval;
+#else
+	return bi->sector_size;
+#endif
+}
+
+static inline const char *blk_integrity_name(struct blk_integrity *bi)
+{
+#ifdef HAVE_INTERVAL_EXP_BLK_INTEGRITY
+	return bi->profile->name;
+#else
+	return bi->name;
+#endif
+}
+#else
+static inline unsigned short blk_integrity_interval(struct blk_integrity *bi)
+{
+	return 0;
+}
+static inline const char *blk_integrity_name(struct blk_integrity *bi)
+{
+	/* gcc8 dislikes when strcmp() is called against NULL */
+	return "";
+}
+#endif
+
+static inline unsigned int bip_size(struct bio_integrity_payload *bip)
+{
+#ifdef HAVE_BIP_ITER_BIO_INTEGRITY_PAYLOAD
+	return bip->bip_iter.bi_size;
+#else
+	return bip->bip_size;
+#endif
+}
+
+#ifdef HAVE_BLK_INTEGRITY_ENABLED
+#ifndef INTEGRITY_FLAG_READ
+#define INTEGRITY_FLAG_READ BLK_INTEGRITY_VERIFY
+#endif
+
+#ifndef INTEGRITY_FLAG_WRITE
+#define INTEGRITY_FLAG_WRITE BLK_INTEGRITY_GENERATE
+#endif
+
+static inline bool bdev_integrity_enabled(struct block_device *bdev, int rw)
+{
+	struct blk_integrity *bi = bdev_get_integrity(bdev);
+
+	if (bi == NULL)
+		return false;
+
+#ifdef HAVE_INTERVAL_EXP_BLK_INTEGRITY
+	if (rw == 0 && bi->profile->verify_fn != NULL &&
+	    (bi->flags & INTEGRITY_FLAG_READ))
+		return true;
+
+	if (rw == 1 && bi->profile->generate_fn != NULL &&
+	    (bi->flags & INTEGRITY_FLAG_WRITE))
+		return true;
+#else
+	if (rw == 0 && bi->verify_fn != NULL &&
+	    (bi->flags & INTEGRITY_FLAG_READ))
+		return true;
+
+	if (rw == 1 && bi->generate_fn != NULL &&
+	    (bi->flags & INTEGRITY_FLAG_WRITE))
+		return true;
+#endif
+
+	return false;
+}
+#else
+static inline bool bdev_integrity_enabled(struct block_device *bdev, int rw)
+{
+	return false;
+}
+#endif /* HAVE_BLK_INTEGRITY_ENABLED */
+
+#ifdef HAVE_PAGEVEC_INIT_ONE_PARAM
+#define ll_pagevec_init(pvec, n) pagevec_init(pvec)
+#else
+#define ll_pagevec_init(pvec, n) pagevec_init(pvec, n)
+#endif
+
 #endif /* _LUSTRE_COMPAT_H */