granicus.if.org Git - zfs/blob - include/linux/vfs_compat.h

   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 <sys/cred.h>
  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
 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
 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
 447 #endif /* _ZFS_VFS_H */