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 - 4.11, bdi_setup_and_register() takes 2 arguments.
  74  * 4.12 - x.y, super_setup_bdi_name() new interface.
  75  */
  76 #if defined(HAVE_SUPER_SETUP_BDI_NAME)
  77 extern atomic_long_t zfs_bdi_seq;
  78
  79 static inline int
  80 zpl_bdi_setup(struct super_block *sb, char *name)
  81 {
  82         return super_setup_bdi_name(sb, "%.28s-%ld", name,
  83             atomic_long_inc_return(&zfs_bdi_seq));
  84 }
  85 static inline void
  86 zpl_bdi_destroy(struct super_block *sb)
  87 {
  88 }
  89 #elif defined(HAVE_2ARGS_BDI_SETUP_AND_REGISTER)
  90 static inline int
  91 zpl_bdi_setup(struct super_block *sb, char *name)
  92 {
  93         struct backing_dev_info *bdi;
  94         int error;
  95
  96         bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
  97         error = bdi_setup_and_register(bdi, name);
  98         if (error) {
  99                 kmem_free(bdi, sizeof (struct backing_dev_info));
 100                 return (error);
 101         }
 102
 103         sb->s_bdi = bdi;
 104
 105         return (0);
 106 }
 107 static inline void
 108 zpl_bdi_destroy(struct super_block *sb)
 109 {
 110         struct backing_dev_info *bdi = sb->s_bdi;
 111
 112         bdi_destroy(bdi);
 113         kmem_free(bdi, sizeof (struct backing_dev_info));
 114         sb->s_bdi = NULL;
 115 }
 116 #elif defined(HAVE_3ARGS_BDI_SETUP_AND_REGISTER)
 117 static inline int
 118 zpl_bdi_setup(struct super_block *sb, char *name)
 119 {
 120         struct backing_dev_info *bdi;
 121         int error;
 122
 123         bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
 124         error = bdi_setup_and_register(bdi, name, BDI_CAP_MAP_COPY);
 125         if (error) {
 126                 kmem_free(sb->s_bdi, sizeof (struct backing_dev_info));
 127                 return (error);
 128         }
 129
 130         sb->s_bdi = bdi;
 131
 132         return (0);
 133 }
 134 static inline void
 135 zpl_bdi_destroy(struct super_block *sb)
 136 {
 137         struct backing_dev_info *bdi = sb->s_bdi;
 138
 139         bdi_destroy(bdi);
 140         kmem_free(bdi, sizeof (struct backing_dev_info));
 141         sb->s_bdi = NULL;
 142 }
 143 #else
 144 extern atomic_long_t zfs_bdi_seq;
 145
 146 static inline int
 147 zpl_bdi_setup(struct super_block *sb, char *name)
 148 {
 149         struct backing_dev_info *bdi;
 150         int error;
 151
 152         bdi = kmem_zalloc(sizeof (struct backing_dev_info), KM_SLEEP);
 153         bdi->name = name;
 154         bdi->capabilities = BDI_CAP_MAP_COPY;
 155
 156         error = bdi_init(bdi);
 157         if (error) {
 158                 kmem_free(bdi, sizeof (struct backing_dev_info));
 159                 return (error);
 160         }
 161
 162         error = bdi_register(bdi, NULL, "%.28s-%ld", name,
 163             atomic_long_inc_return(&zfs_bdi_seq));
 164         if (error) {
 165                 bdi_destroy(bdi);
 166                 kmem_free(bdi, sizeof (struct backing_dev_info));
 167                 return (error);
 168         }
 169
 170         sb->s_bdi = bdi;
 171
 172         return (0);
 173 }
 174 static inline void
 175 zpl_bdi_destroy(struct super_block *sb)
 176 {
 177         struct backing_dev_info *bdi = sb->s_bdi;
 178
 179         bdi_destroy(bdi);
 180         kmem_free(bdi, sizeof (struct backing_dev_info));
 181         sb->s_bdi = NULL;
 182 }
 183 #endif
 184
 185 /*
 186  * 2.6.38 API change,
 187  * LOOKUP_RCU flag introduced to distinguish rcu-walk from ref-walk cases.
 188  */
 189 #ifndef LOOKUP_RCU
 190 #define LOOKUP_RCU      0x0
 191 #endif /* LOOKUP_RCU */
 192
 193 /*
 194  * 3.2-rc1 API change,
 195  * Add set_nlink() if it is not exported by the Linux kernel.
 196  *
 197  * i_nlink is read-only in Linux 3.2, but it can be set directly in
 198  * earlier kernels.
 199  */
 200 #ifndef HAVE_SET_NLINK
 201 static inline void
 202 set_nlink(struct inode *inode, unsigned int nlink)
 203 {
 204         inode->i_nlink = nlink;
 205 }
 206 #endif /* HAVE_SET_NLINK */
 207
 208 /*
 209  * 3.3 API change,
 210  * The VFS .create, .mkdir and .mknod callbacks were updated to take a
 211  * umode_t type rather than an int.  To cleanly handle both definitions
 212  * the zpl_umode_t type is introduced and set accordingly.
 213  */
 214 #ifdef HAVE_MKDIR_UMODE_T
 215 typedef umode_t         zpl_umode_t;
 216 #else
 217 typedef int             zpl_umode_t;
 218 #endif
 219
 220 /*
 221  * 3.5 API change,
 222  * The clear_inode() function replaces end_writeback() and introduces an
 223  * ordering change regarding when the inode_sync_wait() occurs.  See the
 224  * configure check in config/kernel-clear-inode.m4 for full details.
 225  */
 226 #if defined(HAVE_EVICT_INODE) && !defined(HAVE_CLEAR_INODE)
 227 #define clear_inode(ip)         end_writeback(ip)
 228 #endif /* HAVE_EVICT_INODE && !HAVE_CLEAR_INODE */
 229
 230 /*
 231  * 3.6 API change,
 232  * The sget() helper function now takes the mount flags as an argument.
 233  */
 234 #ifdef HAVE_5ARG_SGET
 235 #define zpl_sget(type, cmp, set, fl, mtd)       sget(type, cmp, set, fl, mtd)
 236 #else
 237 #define zpl_sget(type, cmp, set, fl, mtd)       sget(type, cmp, set, mtd)
 238 #endif /* HAVE_5ARG_SGET */
 239
 240 #if defined(SEEK_HOLE) && defined(SEEK_DATA) && !defined(HAVE_LSEEK_EXECUTE)
 241 static inline loff_t
 242 lseek_execute(
 243         struct file *filp,
 244         struct inode *inode,
 245         loff_t offset,
 246         loff_t maxsize)
 247 {
 248         if (offset < 0 && !(filp->f_mode & FMODE_UNSIGNED_OFFSET))
 249                 return (-EINVAL);
 250
 251         if (offset > maxsize)
 252                 return (-EINVAL);
 253
 254         if (offset != filp->f_pos) {
 255                 spin_lock(&filp->f_lock);
 256                 filp->f_pos = offset;
 257                 filp->f_version = 0;
 258                 spin_unlock(&filp->f_lock);
 259         }
 260
 261         return (offset);
 262 }
 263 #endif /* SEEK_HOLE && SEEK_DATA && !HAVE_LSEEK_EXECUTE */
 264
 265 #if defined(CONFIG_FS_POSIX_ACL)
 266 /*
 267  * These functions safely approximates the behavior of posix_acl_release()
 268  * which cannot be used because it calls the GPL-only symbol kfree_rcu().
 269  * The in-kernel version, which can access the RCU, frees the ACLs after
 270  * the grace period expires.  Because we're unsure how long that grace
 271  * period may be this implementation conservatively delays for 60 seconds.
 272  * This is several orders of magnitude larger than expected grace period.
 273  * At 60 seconds the kernel will also begin issuing RCU stall warnings.
 274  */
 275 #ifdef refcount_t
 276 #undef refcount_t
 277 #endif
 278
 279 #include <linux/posix_acl.h>
 280
 281 #if defined(HAVE_POSIX_ACL_RELEASE) && !defined(HAVE_POSIX_ACL_RELEASE_GPL_ONLY)
 282 #define zpl_posix_acl_release(arg)              posix_acl_release(arg)
 283 #else
 284 void zpl_posix_acl_release_impl(struct posix_acl *);
 285
 286 static inline void
 287 zpl_posix_acl_release(struct posix_acl *acl)
 288 {
 289         if ((acl == NULL) || (acl == ACL_NOT_CACHED))
 290                 return;
 291 #ifdef HAVE_ACL_REFCOUNT
 292         if (refcount_dec_and_test(&acl->a_refcount))
 293                 zpl_posix_acl_release_impl(acl);
 294 #else
 295         if (atomic_dec_and_test(&acl->a_refcount))
 296                 zpl_posix_acl_release_impl(acl);
 297 #endif
 298 }
 299 #endif /* HAVE_POSIX_ACL_RELEASE */
 300
 301 #ifdef HAVE_SET_CACHED_ACL_USABLE
 302 #define zpl_set_cached_acl(ip, ty, n)           set_cached_acl(ip, ty, n)
 303 #define zpl_forget_cached_acl(ip, ty)           forget_cached_acl(ip, ty)
 304 #else
 305 static inline void
 306 zpl_set_cached_acl(struct inode *ip, int type, struct posix_acl *newer)
 307 {
 308         struct posix_acl *older = NULL;
 309
 310         spin_lock(&ip->i_lock);
 311
 312         if ((newer != ACL_NOT_CACHED) && (newer != NULL))
 313                 posix_acl_dup(newer);
 314
 315         switch (type) {
 316         case ACL_TYPE_ACCESS:
 317                 older = ip->i_acl;
 318                 rcu_assign_pointer(ip->i_acl, newer);
 319                 break;
 320         case ACL_TYPE_DEFAULT:
 321                 older = ip->i_default_acl;
 322                 rcu_assign_pointer(ip->i_default_acl, newer);
 323                 break;
 324         }
 325
 326         spin_unlock(&ip->i_lock);
 327
 328         zpl_posix_acl_release(older);
 329 }
 330
 331 static inline void
 332 zpl_forget_cached_acl(struct inode *ip, int type)
 333 {
 334         zpl_set_cached_acl(ip, type, (struct posix_acl *)ACL_NOT_CACHED);
 335 }
 336 #endif /* HAVE_SET_CACHED_ACL_USABLE */
 337
 338 #ifndef HAVE___POSIX_ACL_CHMOD
 339 #ifdef HAVE_POSIX_ACL_CHMOD
 340 #define __posix_acl_chmod(acl, gfp, mode)       posix_acl_chmod(acl, gfp, mode)
 341 #define __posix_acl_create(acl, gfp, mode)      posix_acl_create(acl, gfp, mode)
 342 #else
 343 static inline int
 344 __posix_acl_chmod(struct posix_acl **acl, int flags, umode_t umode)
 345 {
 346         struct posix_acl *oldacl = *acl;
 347         mode_t mode = umode;
 348         int error;
 349
 350         *acl = posix_acl_clone(*acl, flags);
 351         zpl_posix_acl_release(oldacl);
 352
 353         if (!(*acl))
 354                 return (-ENOMEM);
 355
 356         error = posix_acl_chmod_masq(*acl, mode);
 357         if (error) {
 358                 zpl_posix_acl_release(*acl);
 359                 *acl = NULL;
 360         }
 361
 362         return (error);
 363 }
 364
 365 static inline int
 366 __posix_acl_create(struct posix_acl **acl, int flags, umode_t *umodep)
 367 {
 368         struct posix_acl *oldacl = *acl;
 369         mode_t mode = *umodep;
 370         int error;
 371
 372         *acl = posix_acl_clone(*acl, flags);
 373         zpl_posix_acl_release(oldacl);
 374
 375         if (!(*acl))
 376                 return (-ENOMEM);
 377
 378         error = posix_acl_create_masq(*acl, &mode);
 379         *umodep = mode;
 380
 381         if (error < 0) {
 382                 zpl_posix_acl_release(*acl);
 383                 *acl = NULL;
 384         }
 385
 386         return (error);
 387 }
 388 #endif /* HAVE_POSIX_ACL_CHMOD */
 389 #endif /* HAVE___POSIX_ACL_CHMOD */
 390
 391 #ifdef HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T
 392 typedef umode_t zpl_equivmode_t;
 393 #else
 394 typedef mode_t zpl_equivmode_t;
 395 #endif /* HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T */
 396
 397 /*
 398  * 4.8 API change,
 399  * posix_acl_valid() now must be passed a namespace, the namespace from
 400  * from super block associated with the given inode is used for this purpose.
 401  */
 402 #ifdef HAVE_POSIX_ACL_VALID_WITH_NS
 403 #define zpl_posix_acl_valid(ip, acl)  posix_acl_valid(ip->i_sb->s_user_ns, acl)
 404 #else
 405 #define zpl_posix_acl_valid(ip, acl)  posix_acl_valid(acl)
 406 #endif
 407
 408 #define refcount_t      zfs_refcount_t
 409
 410 #endif /* CONFIG_FS_POSIX_ACL */
 411
 412 /*
 413  * 2.6.38 API change,
 414  * The is_owner_or_cap() function was renamed to inode_owner_or_capable().
 415  */
 416 #ifdef HAVE_INODE_OWNER_OR_CAPABLE
 417 #define zpl_inode_owner_or_capable(ip)          inode_owner_or_capable(ip)
 418 #else
 419 #define zpl_inode_owner_or_capable(ip)          is_owner_or_cap(ip)
 420 #endif /* HAVE_INODE_OWNER_OR_CAPABLE */
 421
 422 /*
 423  * 3.19 API change
 424  * struct access f->f_dentry->d_inode was replaced by accessor function
 425  * file_inode(f)
 426  */
 427 #ifndef HAVE_FILE_INODE
 428 static inline struct inode *file_inode(const struct file *f)
 429 {
 430         return (f->f_dentry->d_inode);
 431 }
 432 #endif /* HAVE_FILE_INODE */
 433
 434 /*
 435  * 4.1 API change
 436  * struct access file->f_path.dentry was replaced by accessor function
 437  * file_dentry(f)
 438  */
 439 #ifndef HAVE_FILE_DENTRY
 440 static inline struct dentry *file_dentry(const struct file *f)
 441 {
 442         return (f->f_path.dentry);
 443 }
 444 #endif /* HAVE_FILE_DENTRY */
 445
 446 #ifdef HAVE_KUID_HELPERS
 447 static inline uid_t zfs_uid_read_impl(struct inode *ip)
 448 {
 449 #ifdef HAVE_SUPER_USER_NS
 450         return (from_kuid(ip->i_sb->s_user_ns, ip->i_uid));
 451 #else
 452         return (from_kuid(kcred->user_ns, ip->i_uid));
 453 #endif
 454 }
 455
 456 static inline uid_t zfs_uid_read(struct inode *ip)
 457 {
 458         return (zfs_uid_read_impl(ip));
 459 }
 460
 461 static inline gid_t zfs_gid_read_impl(struct inode *ip)
 462 {
 463 #ifdef HAVE_SUPER_USER_NS
 464         return (from_kgid(ip->i_sb->s_user_ns, ip->i_gid));
 465 #else
 466         return (from_kgid(kcred->user_ns, ip->i_gid));
 467 #endif
 468 }
 469
 470 static inline gid_t zfs_gid_read(struct inode *ip)
 471 {
 472         return (zfs_gid_read_impl(ip));
 473 }
 474
 475 static inline void zfs_uid_write(struct inode *ip, uid_t uid)
 476 {
 477 #ifdef HAVE_SUPER_USER_NS
 478         ip->i_uid = make_kuid(ip->i_sb->s_user_ns, uid);
 479 #else
 480         ip->i_uid = make_kuid(kcred->user_ns, uid);
 481 #endif
 482 }
 483
 484 static inline void zfs_gid_write(struct inode *ip, gid_t gid)
 485 {
 486 #ifdef HAVE_SUPER_USER_NS
 487         ip->i_gid = make_kgid(ip->i_sb->s_user_ns, gid);
 488 #else
 489         ip->i_gid = make_kgid(kcred->user_ns, gid);
 490 #endif
 491 }
 492
 493 #else
 494 static inline uid_t zfs_uid_read(struct inode *ip)
 495 {
 496         return (ip->i_uid);
 497 }
 498
 499 static inline gid_t zfs_gid_read(struct inode *ip)
 500 {
 501         return (ip->i_gid);
 502 }
 503
 504 static inline void zfs_uid_write(struct inode *ip, uid_t uid)
 505 {
 506         ip->i_uid = uid;
 507 }
 508
 509 static inline void zfs_gid_write(struct inode *ip, gid_t gid)
 510 {
 511         ip->i_gid = gid;
 512 }
 513 #endif
 514
 515 /*
 516  * 2.6.38 API change
 517  */
 518 #ifdef HAVE_FOLLOW_DOWN_ONE
 519 #define zpl_follow_down_one(path)               follow_down_one(path)
 520 #define zpl_follow_up(path)                     follow_up(path)
 521 #else
 522 #define zpl_follow_down_one(path)               follow_down(path)
 523 #define zpl_follow_up(path)                     follow_up(path)
 524 #endif
 525
 526 /*
 527  * 4.9 API change
 528  */
 529 #ifndef HAVE_SETATTR_PREPARE
 530 static inline int
 531 setattr_prepare(struct dentry *dentry, struct iattr *ia)
 532 {
 533         return (inode_change_ok(dentry->d_inode, ia));
 534 }
 535 #endif
 536
 537 /*
 538  * 4.11 API change
 539  * These macros are defined by kernel 4.11.  We define them so that the same
 540  * code builds under kernels < 4.11 and >= 4.11.  The macros are set to 0 so
 541  * that it will create obvious failures if they are accidentally used when built
 542  * against a kernel >= 4.11.
 543  */
 544
 545 #ifndef STATX_BASIC_STATS
 546 #define STATX_BASIC_STATS       0
 547 #endif
 548
 549 #ifndef AT_STATX_SYNC_AS_STAT
 550 #define AT_STATX_SYNC_AS_STAT   0
 551 #endif
 552
 553 /*
 554  * 4.11 API change
 555  * 4.11 takes struct path *, < 4.11 takes vfsmount *
 556  */
 557
 558 #ifdef HAVE_VFSMOUNT_IOPS_GETATTR
 559 #define ZPL_GETATTR_WRAPPER(func)                                       \
 560 static int                                                              \
 561 func(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)   \
 562 {                                                                       \
 563         struct path path = { .mnt = mnt, .dentry = dentry };            \
 564         return func##_impl(&path, stat, STATX_BASIC_STATS,              \
 565             AT_STATX_SYNC_AS_STAT);                                     \
 566 }
 567 #elif defined(HAVE_PATH_IOPS_GETATTR)
 568 #define ZPL_GETATTR_WRAPPER(func)                                       \
 569 static int                                                              \
 570 func(const struct path *path, struct kstat *stat, u32 request_mask,     \
 571     unsigned int query_flags)                                           \
 572 {                                                                       \
 573         return (func##_impl(path, stat, request_mask, query_flags));    \
 574 }
 575 #else
 576 #error
 577 #endif
 578
 579 /*
 580  * 4.9 API change
 581  * Preferred interface to get the current FS time.
 582  */
 583 #if !defined(HAVE_CURRENT_TIME)
 584 static inline struct timespec
 585 current_time(struct inode *ip)
 586 {
 587         return (timespec_trunc(current_kernel_time(), ip->i_sb->s_time_gran));
 588 }
 589 #endif
 590
 591 /*
 592  * 4.16 API change
 593  * Added iversion interface for managing inode version field.
 594  */
 595 #ifdef HAVE_INODE_SET_IVERSION
 596 #include <linux/iversion.h>
 597 #else
 598 static inline void
 599 inode_set_iversion(struct inode *ip, u64 val)
 600 {
 601         ip->i_version = val;
 602 }
 603 #endif
 604
 605 #endif /* _ZFS_VFS_H */