kernel-5.12.patch

   1 From e2a8296131e94ad785f5564156ed2db1fdb2e080 Mon Sep 17 00:00:00 2001
   2 From: Coleman Kane <ckane@colemankane.org>
   3 Date: Sat, 20 Mar 2021 00:00:59 -0400
   4 Subject: [PATCH] Linux 5.12 compat: idmapped mounts
   5
   6 In Linux 5.12, the filesystem API was modified to support ipmapped
   7 mounts by adding a "struct user_namespace *" parameter to a number
   8 functions and VFS handlers. This change adds the needed autoconf
   9 macros to detect the new interfaces and updates the code appropriately.
  10 This change does not add support for idmapped mounts, instead it
  11 preserves the existing behavior by passing the initial user namespace
  12 where needed.  A subsequent commit will be required to add support
  13 for idmapped mounted.
  14
  15 Reviewed-by: Tony Hutter <hutter2@llnl.gov>
  16 Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
  17 Co-authored-by: Brian Behlendorf <behlendorf1@llnl.gov>
  18 Signed-off-by: Coleman Kane <ckane@colemankane.org>
  19 Closes #11712
  20 ---
  21  config/kernel-generic_fillattr.m4            | 28 +++++++
  22  config/kernel-inode-create.m4                | 43 +++++++++--
  23  config/kernel-inode-getattr.m4               | 63 +++++++++++++---
  24  config/kernel-is_owner_or_cap.m4             | 23 +++++-
  25  config/kernel-mkdir-umode-t.m4               | 32 --------
  26  config/kernel-mkdir.m4                       | 65 ++++++++++++++++
  27  config/kernel-mknod.m4                       | 30 ++++++++
  28  config/kernel-rename.m4                      | 50 ++++++++++---
  29  config/kernel-setattr-prepare.m4             | 45 ++++++++---
  30  config/kernel-symlink.m4                     | 30 ++++++++
  31  config/kernel-xattr-handler.m4               | 78 +++++++++++++-------
  32  config/kernel.m4                             | 18 +++--
  33  include/os/linux/kernel/linux/vfs_compat.h   | 24 +++++-
  34  include/os/linux/kernel/linux/xattr_compat.h | 17 ++++-
  35  include/os/linux/zfs/sys/zfs_vnops_os.h      |  3 +-
  36  include/os/linux/zfs/sys/zpl.h               | 18 +++++
  37  module/os/linux/zfs/policy.c                 |  2 +-
  38  module/os/linux/zfs/zfs_vnops_os.c           |  5 +-
  39  module/os/linux/zfs/zpl_ctldir.c             | 51 ++++++++++++-
  40  module/os/linux/zfs/zpl_file.c               |  2 +-
  41  module/os/linux/zfs/zpl_inode.c              | 49 +++++++++++-
  42  module/os/linux/zfs/zpl_xattr.c              |  4 +-
  43  22 files changed, 557 insertions(+), 123 deletions(-)
  44  create mode 100644 config/kernel-generic_fillattr.m4
  45  delete mode 100644 config/kernel-mkdir-umode-t.m4
  46  create mode 100644 config/kernel-mkdir.m4
  47  create mode 100644 config/kernel-mknod.m4
  48  create mode 100644 config/kernel-symlink.m4
  49
  50 diff --git a/config/kernel-generic_fillattr.m4 b/config/kernel-generic_fillattr.m4
  51 new file mode 100644
  52 index 00000000000..50c8031305b
  53 --- /dev/null
  54 +++ b/config/kernel-generic_fillattr.m4
  55 @@ -0,0 +1,28 @@
  56 +dnl #
  57 +dnl # 5.12 API
  58 +dnl #
  59 +dnl # generic_fillattr in linux/fs.h now requires a struct user_namespace*
  60 +dnl # as the first arg, to support idmapped mounts.
  61 +dnl #
  62 +AC_DEFUN([ZFS_AC_KERNEL_SRC_GENERIC_FILLATTR_USERNS], [
  63 +       ZFS_LINUX_TEST_SRC([generic_fillattr_userns], [
  64 +               #include <linux/fs.h>
  65 +       ],[
  66 +               struct user_namespace *userns = NULL;
  67 +               struct inode *in = NULL;
  68 +               struct kstat *k = NULL;
  69 +               generic_fillattr(userns, in, k);
  70 +       ])
  71 +])
  72 +
  73 +AC_DEFUN([ZFS_AC_KERNEL_GENERIC_FILLATTR_USERNS], [
  74 +       AC_MSG_CHECKING([whether generic_fillattr requres struct user_namespace*])
  75 +       ZFS_LINUX_TEST_RESULT([generic_fillattr_userns], [
  76 +               AC_MSG_RESULT([yes])
  77 +               AC_DEFINE(HAVE_GENERIC_FILLATTR_USERNS, 1,
  78 +                   [generic_fillattr requires struct user_namespace*])
  79 +       ],[
  80 +               AC_MSG_RESULT([no])
  81 +       ])
  82 +])
  83 +
  84 diff --git a/config/kernel-inode-create.m4 b/config/kernel-inode-create.m4
  85 index 9f28bcbd4f7..a6ea11fb61b 100644
  86 --- a/config/kernel-inode-create.m4
  87 +++ b/config/kernel-inode-create.m4
  88 @@ -1,7 +1,25 @@
  89 -dnl #
  90 -dnl # 3.6 API change
  91 -dnl #
  92 -AC_DEFUN([ZFS_AC_KERNEL_SRC_CREATE_FLAGS], [
  93 +AC_DEFUN([ZFS_AC_KERNEL_SRC_CREATE], [
  94 +       dnl #
  95 +       dnl # 5.12 API change that added the struct user_namespace* arg
  96 +       dnl # to the front of this function type's arg list.
  97 +       dnl #
  98 +       ZFS_LINUX_TEST_SRC([create_userns], [
  99 +               #include <linux/fs.h>
 100 +               #include <linux/sched.h>
 101 +
 102 +               int inode_create(struct user_namespace *userns,
 103 +                   struct inode *inode ,struct dentry *dentry,
 104 +                   umode_t umode, bool flag) { return 0; }
 105 +
 106 +               static const struct inode_operations
 107 +                       iops __attribute__ ((unused)) = {
 108 +                       .create         = inode_create,
 109 +               };
 110 +       ],[])
 111 +
 112 +       dnl #
 113 +       dnl # 3.6 API change
 114 +       dnl #
 115         ZFS_LINUX_TEST_SRC([create_flags], [
 116                 #include <linux/fs.h>
 117                 #include <linux/sched.h>
 118 @@ -16,11 +34,20 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_CREATE_FLAGS], [
 119         ],[])
 120  ])
 121
 122 -AC_DEFUN([ZFS_AC_KERNEL_CREATE_FLAGS], [
 123 -       AC_MSG_CHECKING([whether iops->create() passes flags])
 124 -       ZFS_LINUX_TEST_RESULT([create_flags], [
 125 +AC_DEFUN([ZFS_AC_KERNEL_CREATE], [
 126 +       AC_MSG_CHECKING([whether iops->create() takes struct user_namespace*])
 127 +       ZFS_LINUX_TEST_RESULT([create_userns], [
 128                 AC_MSG_RESULT(yes)
 129 +               AC_DEFINE(HAVE_IOPS_CREATE_USERNS, 1,
 130 +                  [iops->create() takes struct user_namespace*])
 131         ],[
 132 -               ZFS_LINUX_TEST_ERROR([iops->create()])
 133 +               AC_MSG_RESULT(no)
 134 +
 135 +               AC_MSG_CHECKING([whether iops->create() passes flags])
 136 +               ZFS_LINUX_TEST_RESULT([create_flags], [
 137 +                       AC_MSG_RESULT(yes)
 138 +               ],[
 139 +                       ZFS_LINUX_TEST_ERROR([iops->create()])
 140 +               ])
 141         ])
 142  ])
 143 diff --git a/config/kernel-inode-getattr.m4 b/config/kernel-inode-getattr.m4
 144 index 48391d66f8b..f62e82f5230 100644
 145 --- a/config/kernel-inode-getattr.m4
 146 +++ b/config/kernel-inode-getattr.m4
 147 @@ -1,8 +1,29 @@
 148 -dnl #
 149 -dnl # Linux 4.11 API
 150 -dnl # See torvalds/linux@a528d35
 151 -dnl #
 152  AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_GETATTR], [
 153 +       dnl #
 154 +       dnl # Linux 5.12 API
 155 +       dnl # The getattr I/O operations handler type was extended to require
 156 +       dnl # a struct user_namespace* as its first arg, to support idmapped
 157 +       dnl # mounts.
 158 +       dnl #
 159 +       ZFS_LINUX_TEST_SRC([inode_operations_getattr_userns], [
 160 +               #include <linux/fs.h>
 161 +
 162 +               int test_getattr(
 163 +                       struct user_namespace *userns,
 164 +                   const struct path *p, struct kstat *k,
 165 +                   u32 request_mask, unsigned int query_flags)
 166 +                   { return 0; }
 167 +
 168 +               static const struct inode_operations
 169 +                   iops __attribute__ ((unused)) = {
 170 +                       .getattr = test_getattr,
 171 +               };
 172 +       ],[])
 173 +
 174 +       dnl #
 175 +       dnl # Linux 4.11 API
 176 +       dnl # See torvalds/linux@a528d35
 177 +       dnl #
 178         ZFS_LINUX_TEST_SRC([inode_operations_getattr_path], [
 179                 #include <linux/fs.h>
 180
 181 @@ -33,21 +54,39 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_GETATTR], [
 182  ])
 183
 184  AC_DEFUN([ZFS_AC_KERNEL_INODE_GETATTR], [
 185 -       AC_MSG_CHECKING([whether iops->getattr() takes a path])
 186 -       ZFS_LINUX_TEST_RESULT([inode_operations_getattr_path], [
 187 +       dnl #
 188 +       dnl # Kernel 5.12 test
 189 +       dnl #
 190 +       AC_MSG_CHECKING([whether iops->getattr() takes user_namespace])
 191 +       ZFS_LINUX_TEST_RESULT([inode_operations_getattr_userns], [
 192                 AC_MSG_RESULT(yes)
 193 -               AC_DEFINE(HAVE_PATH_IOPS_GETATTR, 1,
 194 -                   [iops->getattr() takes a path])
 195 +               AC_DEFINE(HAVE_USERNS_IOPS_GETATTR, 1,
 196 +                   [iops->getattr() takes struct user_namespace*])
 197         ],[
 198                 AC_MSG_RESULT(no)
 199
 200 -               AC_MSG_CHECKING([whether iops->getattr() takes a vfsmount])
 201 -               ZFS_LINUX_TEST_RESULT([inode_operations_getattr_vfsmount], [
 202 +               dnl #
 203 +               dnl # Kernel 4.11 test
 204 +               dnl #
 205 +               AC_MSG_CHECKING([whether iops->getattr() takes a path])
 206 +               ZFS_LINUX_TEST_RESULT([inode_operations_getattr_path], [
 207                         AC_MSG_RESULT(yes)
 208 -                       AC_DEFINE(HAVE_VFSMOUNT_IOPS_GETATTR, 1,
 209 -                           [iops->getattr() takes a vfsmount])
 210 +                       AC_DEFINE(HAVE_PATH_IOPS_GETATTR, 1,
 211 +                               [iops->getattr() takes a path])
 212                 ],[
 213                         AC_MSG_RESULT(no)
 214 +
 215 +                       dnl #
 216 +                       dnl # Kernel < 4.11 test
 217 +                       dnl #
 218 +                       AC_MSG_CHECKING([whether iops->getattr() takes a vfsmount])
 219 +                       ZFS_LINUX_TEST_RESULT([inode_operations_getattr_vfsmount], [
 220 +                               AC_MSG_RESULT(yes)
 221 +                               AC_DEFINE(HAVE_VFSMOUNT_IOPS_GETATTR, 1,
 222 +                                       [iops->getattr() takes a vfsmount])
 223 +                       ],[
 224 +                               AC_MSG_RESULT(no)
 225 +                       ])
 226                 ])
 227         ])
 228  ])
 229 diff --git a/config/kernel-is_owner_or_cap.m4 b/config/kernel-is_owner_or_cap.m4
 230 index 3df6163da27..3c3c6ad2240 100644
 231 --- a/config/kernel-is_owner_or_cap.m4
 232 +++ b/config/kernel-is_owner_or_cap.m4
 233 @@ -11,13 +11,32 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OWNER_OR_CAPABLE], [
 234                 struct inode *ip = NULL;
 235                 (void) inode_owner_or_capable(ip);
 236         ])
 237 +
 238 +       ZFS_LINUX_TEST_SRC([inode_owner_or_capable_idmapped], [
 239 +               #include <linux/fs.h>
 240 +       ],[
 241 +               struct inode *ip = NULL;
 242 +               (void) inode_owner_or_capable(&init_user_ns, ip);
 243 +       ])
 244  ])
 245
 246  AC_DEFUN([ZFS_AC_KERNEL_INODE_OWNER_OR_CAPABLE], [
 247         AC_MSG_CHECKING([whether inode_owner_or_capable() exists])
 248         ZFS_LINUX_TEST_RESULT([inode_owner_or_capable], [
 249                 AC_MSG_RESULT(yes)
 250 -       ],[
 251 -               ZFS_LINUX_TEST_ERROR([capability])
 252 +               AC_DEFINE(HAVE_INODE_OWNER_OR_CAPABLE, 1,
 253 +                   [inode_owner_or_capable() exists])
 254 +       ], [
 255 +               AC_MSG_RESULT(no)
 256 +
 257 +               AC_MSG_CHECKING(
 258 +                   [whether inode_owner_or_capable() takes user_ns])
 259 +               ZFS_LINUX_TEST_RESULT([inode_owner_or_capable_idmapped], [
 260 +                       AC_MSG_RESULT(yes)
 261 +                       AC_DEFINE(HAVE_INODE_OWNER_OR_CAPABLE_IDMAPPED, 1,
 262 +                           [inode_owner_or_capable() takes user_ns])
 263 +               ],[
 264 +                       ZFS_LINUX_TEST_ERROR([capability])
 265 +               ])
 266         ])
 267  ])
 268 diff --git a/config/kernel-mkdir-umode-t.m4 b/config/kernel-mkdir-umode-t.m4
 269 deleted file mode 100644
 270 index 19599670df3..00000000000
 271 --- a/config/kernel-mkdir-umode-t.m4
 272 +++ /dev/null
 273 @@ -1,32 +0,0 @@
 274 -dnl #
 275 -dnl # 3.3 API change
 276 -dnl # The VFS .create, .mkdir and .mknod callbacks were updated to take a
 277 -dnl # umode_t type rather than an int.  The expectation is that any backport
 278 -dnl # would also change all three prototypes.  However, if it turns out that
 279 -dnl # some distribution doesn't backport the whole thing this could be
 280 -dnl # broken apart into three separate checks.
 281 -dnl #
 282 -AC_DEFUN([ZFS_AC_KERNEL_SRC_MKDIR_UMODE_T], [
 283 -       ZFS_LINUX_TEST_SRC([inode_operations_mkdir], [
 284 -               #include <linux/fs.h>
 285 -
 286 -               int mkdir(struct inode *inode, struct dentry *dentry,
 287 -                   umode_t umode) { return 0; }
 288 -
 289 -               static const struct inode_operations
 290 -                   iops __attribute__ ((unused)) = {
 291 -                       .mkdir = mkdir,
 292 -               };
 293 -       ],[])
 294 -])
 295 -
 296 -AC_DEFUN([ZFS_AC_KERNEL_MKDIR_UMODE_T], [
 297 -       AC_MSG_CHECKING([whether iops->create()/mkdir()/mknod() take umode_t])
 298 -       ZFS_LINUX_TEST_RESULT([inode_operations_mkdir], [
 299 -               AC_MSG_RESULT(yes)
 300 -               AC_DEFINE(HAVE_MKDIR_UMODE_T, 1,
 301 -                   [iops->create()/mkdir()/mknod() take umode_t])
 302 -       ],[
 303 -               ZFS_LINUX_TEST_ERROR([mkdir()])
 304 -       ])
 305 -])
 306 diff --git a/config/kernel-mkdir.m4 b/config/kernel-mkdir.m4
 307 new file mode 100644
 308 index 00000000000..a162bcd880f
 309 --- /dev/null
 310 +++ b/config/kernel-mkdir.m4
 311 @@ -0,0 +1,65 @@
 312 +dnl #
 313 +dnl # Supported mkdir() interfaces checked newest to oldest.
 314 +dnl #
 315 +AC_DEFUN([ZFS_AC_KERNEL_SRC_MKDIR], [
 316 +       dnl #
 317 +       dnl # 5.12 API change
 318 +       dnl # The struct user_namespace arg was added as the first argument to
 319 +       dnl # mkdir()
 320 +       dnl #
 321 +       ZFS_LINUX_TEST_SRC([mkdir_user_namespace], [
 322 +               #include <linux/fs.h>
 323 +
 324 +               int mkdir(struct user_namespace *userns,
 325 +                       struct inode *inode, struct dentry *dentry,
 326 +                   umode_t umode) { return 0; }
 327 +
 328 +               static const struct inode_operations
 329 +                   iops __attribute__ ((unused)) = {
 330 +                       .mkdir = mkdir,
 331 +               };
 332 +       ],[])
 333 +
 334 +       dnl #
 335 +       dnl # 3.3 API change
 336 +       dnl # The VFS .create, .mkdir and .mknod callbacks were updated to take a
 337 +       dnl # umode_t type rather than an int.  The expectation is that any backport
 338 +       dnl # would also change all three prototypes.  However, if it turns out that
 339 +       dnl # some distribution doesn't backport the whole thing this could be
 340 +       dnl # broken apart into three separate checks.
 341 +       dnl #
 342 +       ZFS_LINUX_TEST_SRC([inode_operations_mkdir], [
 343 +               #include <linux/fs.h>
 344 +
 345 +               int mkdir(struct inode *inode, struct dentry *dentry,
 346 +                   umode_t umode) { return 0; }
 347 +
 348 +               static const struct inode_operations
 349 +                   iops __attribute__ ((unused)) = {
 350 +                       .mkdir = mkdir,
 351 +               };
 352 +       ],[])
 353 +])
 354 +
 355 +AC_DEFUN([ZFS_AC_KERNEL_MKDIR], [
 356 +       dnl #
 357 +       dnl # 5.12 API change
 358 +       dnl # The struct user_namespace arg was added as the first argument to
 359 +       dnl # mkdir() of the iops structure.
 360 +       dnl #
 361 +       AC_MSG_CHECKING([whether iops->mkdir() takes struct user_namespace*])
 362 +       ZFS_LINUX_TEST_RESULT([mkdir_user_namespace], [
 363 +               AC_MSG_RESULT(yes)
 364 +               AC_DEFINE(HAVE_IOPS_MKDIR_USERNS, 1,
 365 +                   [iops->mkdir() takes struct user_namespace*])
 366 +       ],[
 367 +               AC_MSG_CHECKING([whether iops->mkdir() takes umode_t])
 368 +               ZFS_LINUX_TEST_RESULT([inode_operations_mkdir], [
 369 +                       AC_MSG_RESULT(yes)
 370 +                       AC_DEFINE(HAVE_MKDIR_UMODE_T, 1,
 371 +                           [iops->mkdir() takes umode_t])
 372 +               ],[
 373 +                       ZFS_LINUX_TEST_ERROR([mkdir()])
 374 +               ])
 375 +       ])
 376 +])
 377 diff --git a/config/kernel-mknod.m4 b/config/kernel-mknod.m4
 378 new file mode 100644
 379 index 00000000000..ffe45106003
 380 --- /dev/null
 381 +++ b/config/kernel-mknod.m4
 382 @@ -0,0 +1,30 @@
 383 +AC_DEFUN([ZFS_AC_KERNEL_SRC_MKNOD], [
 384 +       dnl #
 385 +       dnl # 5.12 API change that added the struct user_namespace* arg
 386 +       dnl # to the front of this function type's arg list.
 387 +       dnl #
 388 +       ZFS_LINUX_TEST_SRC([mknod_userns], [
 389 +               #include <linux/fs.h>
 390 +               #include <linux/sched.h>
 391 +
 392 +               int tmp_mknod(struct user_namespace *userns,
 393 +                   struct inode *inode ,struct dentry *dentry,
 394 +                   umode_t u, dev_t d) { return 0; }
 395 +
 396 +               static const struct inode_operations
 397 +                       iops __attribute__ ((unused)) = {
 398 +                       .mknod          = tmp_mknod,
 399 +               };
 400 +       ],[])
 401 +])
 402 +
 403 +AC_DEFUN([ZFS_AC_KERNEL_MKNOD], [
 404 +       AC_MSG_CHECKING([whether iops->mknod() takes struct user_namespace*])
 405 +       ZFS_LINUX_TEST_RESULT([mknod_userns], [
 406 +               AC_MSG_RESULT(yes)
 407 +               AC_DEFINE(HAVE_IOPS_MKNOD_USERNS, 1,
 408 +                   [iops->mknod() takes struct user_namespace*])
 409 +       ],[
 410 +               AC_MSG_RESULT(no)
 411 +       ])
 412 +])
 413 diff --git a/config/kernel-rename.m4 b/config/kernel-rename.m4
 414 index f707391539d..31d199f33bb 100644
 415 --- a/config/kernel-rename.m4
 416 +++ b/config/kernel-rename.m4
 417 @@ -1,10 +1,10 @@
 418 -dnl #
 419 -dnl # 4.9 API change,
 420 -dnl # iops->rename2() merged into iops->rename(), and iops->rename() now wants
 421 -dnl # flags.
 422 -dnl #
 423 -AC_DEFUN([ZFS_AC_KERNEL_SRC_RENAME_WANTS_FLAGS], [
 424 -       ZFS_LINUX_TEST_SRC([inode_operations_rename], [
 425 +AC_DEFUN([ZFS_AC_KERNEL_SRC_RENAME], [
 426 +       dnl #
 427 +       dnl # 4.9 API change,
 428 +       dnl # iops->rename2() merged into iops->rename(), and iops->rename() now wants
 429 +       dnl # flags.
 430 +       dnl #
 431 +       ZFS_LINUX_TEST_SRC([inode_operations_rename_flags], [
 432                 #include <linux/fs.h>
 433                 int rename_fn(struct inode *sip, struct dentry *sdp,
 434                         struct inode *tip, struct dentry *tdp,
 435 @@ -15,15 +15,41 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_RENAME_WANTS_FLAGS], [
 436                         .rename = rename_fn,
 437                 };
 438         ],[])
 439 +
 440 +       dnl #
 441 +       dnl # 5.12 API change,
 442 +       dnl #
 443 +       dnl # Linux 5.12 introduced passing struct user_namespace* as the first argument
 444 +       dnl # of the rename() and other inode_operations members.
 445 +       dnl #
 446 +       ZFS_LINUX_TEST_SRC([inode_operations_rename_userns], [
 447 +               #include <linux/fs.h>
 448 +               int rename_fn(struct user_namespace *user_ns, struct inode *sip,
 449 +                       struct dentry *sdp, struct inode *tip, struct dentry *tdp,
 450 +                       unsigned int flags) { return 0; }
 451 +
 452 +               static const struct inode_operations
 453 +                   iops __attribute__ ((unused)) = {
 454 +                       .rename = rename_fn,
 455 +               };
 456 +       ],[])
 457  ])
 458
 459 -AC_DEFUN([ZFS_AC_KERNEL_RENAME_WANTS_FLAGS], [
 460 -       AC_MSG_CHECKING([whether iops->rename() wants flags])
 461 -       ZFS_LINUX_TEST_RESULT([inode_operations_rename], [
 462 +AC_DEFUN([ZFS_AC_KERNEL_RENAME], [
 463 +       AC_MSG_CHECKING([whether iops->rename() takes struct user_namespace*])
 464 +       ZFS_LINUX_TEST_RESULT([inode_operations_rename_userns], [
 465                 AC_MSG_RESULT(yes)
 466 -               AC_DEFINE(HAVE_RENAME_WANTS_FLAGS, 1,
 467 -                   [iops->rename() wants flags])
 468 +               AC_DEFINE(HAVE_IOPS_RENAME_USERNS, 1,
 469 +                   [iops->rename() takes struct user_namespace*])
 470         ],[
 471                 AC_MSG_RESULT(no)
 472 +
 473 +               ZFS_LINUX_TEST_RESULT([inode_operations_rename_flags], [
 474 +                       AC_MSG_RESULT(yes)
 475 +                       AC_DEFINE(HAVE_RENAME_WANTS_FLAGS, 1,
 476 +                               [iops->rename() wants flags])
 477 +               ],[
 478 +                       AC_MSG_RESULT(no)
 479 +               ])
 480         ])
 481  ])
 482 diff --git a/config/kernel-setattr-prepare.m4 b/config/kernel-setattr-prepare.m4
 483 index 45408c45c69..24245aa5344 100644
 484 --- a/config/kernel-setattr-prepare.m4
 485 +++ b/config/kernel-setattr-prepare.m4
 486 @@ -1,27 +1,52 @@
 487 -dnl #
 488 -dnl # 4.9 API change
 489 -dnl # The inode_change_ok() function has been renamed setattr_prepare()
 490 -dnl # and updated to take a dentry rather than an inode.
 491 -dnl #
 492  AC_DEFUN([ZFS_AC_KERNEL_SRC_SETATTR_PREPARE], [
 493 +       dnl #
 494 +       dnl # 4.9 API change
 495 +       dnl # The inode_change_ok() function has been renamed setattr_prepare()
 496 +       dnl # and updated to take a dentry rather than an inode.
 497 +       dnl #
 498         ZFS_LINUX_TEST_SRC([setattr_prepare], [
 499                 #include <linux/fs.h>
 500         ], [
 501                 struct dentry *dentry = NULL;
 502                 struct iattr *attr = NULL;
 503                 int error __attribute__ ((unused)) =
 504 -                   setattr_prepare(dentry, attr);
 505 +                       setattr_prepare(dentry, attr);
 506 +       ])
 507 +
 508 +       dnl #
 509 +       dnl # 5.12 API change
 510 +       dnl # The setattr_prepare() function has been changed to accept a new argument
 511 +       dnl # for struct user_namespace*
 512 +       dnl #
 513 +       ZFS_LINUX_TEST_SRC([setattr_prepare_userns], [
 514 +               #include <linux/fs.h>
 515 +       ], [
 516 +               struct dentry *dentry = NULL;
 517 +               struct iattr *attr = NULL;
 518 +               struct user_namespace *userns = NULL;
 519 +               int error __attribute__ ((unused)) =
 520 +                       setattr_prepare(userns, dentry, attr);
 521         ])
 522  ])
 523
 524  AC_DEFUN([ZFS_AC_KERNEL_SETATTR_PREPARE], [
 525 -       AC_MSG_CHECKING([whether setattr_prepare() is available])
 526 -       ZFS_LINUX_TEST_RESULT_SYMBOL([setattr_prepare],
 527 +       AC_MSG_CHECKING([whether setattr_prepare() is available and accepts struct user_namespace*])
 528 +       ZFS_LINUX_TEST_RESULT_SYMBOL([setattr_prepare_userns],
 529             [setattr_prepare], [fs/attr.c], [
 530                 AC_MSG_RESULT(yes)
 531 -               AC_DEFINE(HAVE_SETATTR_PREPARE, 1,
 532 -                   [setattr_prepare() is available])
 533 +               AC_DEFINE(HAVE_SETATTR_PREPARE_USERNS, 1,
 534 +                   [setattr_prepare() accepts user_namespace])
 535         ], [
 536                 AC_MSG_RESULT(no)
 537 +
 538 +               AC_MSG_CHECKING([whether setattr_prepare() is available, doesn't accept user_namespace])
 539 +               ZFS_LINUX_TEST_RESULT_SYMBOL([setattr_prepare],
 540 +                       [setattr_prepare], [fs/attr.c], [
 541 +                       AC_MSG_RESULT(yes)
 542 +                       AC_DEFINE(HAVE_SETATTR_PREPARE_NO_USERNS, 1,
 543 +                               [setattr_prepare() is available, doesn't accept user_namespace])
 544 +               ], [
 545 +                       AC_MSG_RESULT(no)
 546 +               ])
 547         ])
 548  ])
 549 diff --git a/config/kernel-symlink.m4 b/config/kernel-symlink.m4
 550 new file mode 100644
 551 index 00000000000..d90366d04b7
 552 --- /dev/null
 553 +++ b/config/kernel-symlink.m4
 554 @@ -0,0 +1,30 @@
 555 +AC_DEFUN([ZFS_AC_KERNEL_SRC_SYMLINK], [
 556 +       dnl #
 557 +       dnl # 5.12 API change that added the struct user_namespace* arg
 558 +       dnl # to the front of this function type's arg list.
 559 +       dnl #
 560 +       ZFS_LINUX_TEST_SRC([symlink_userns], [
 561 +               #include <linux/fs.h>
 562 +               #include <linux/sched.h>
 563 +
 564 +               int tmp_symlink(struct user_namespace *userns,
 565 +                   struct inode *inode ,struct dentry *dentry,
 566 +                   const char *path) { return 0; }
 567 +
 568 +               static const struct inode_operations
 569 +                       iops __attribute__ ((unused)) = {
 570 +                       .symlink                = tmp_symlink,
 571 +               };
 572 +       ],[])
 573 +])
 574 +
 575 +AC_DEFUN([ZFS_AC_KERNEL_SYMLINK], [
 576 +       AC_MSG_CHECKING([whether iops->symlink() takes struct user_namespace*])
 577 +       ZFS_LINUX_TEST_RESULT([symlink_userns], [
 578 +               AC_MSG_RESULT(yes)
 579 +               AC_DEFINE(HAVE_IOPS_SYMLINK_USERNS, 1,
 580 +                   [iops->symlink() takes struct user_namespace*])
 581 +       ],[
 582 +               AC_MSG_RESULT(no)
 583 +       ])
 584 +])
 585 diff --git a/config/kernel-xattr-handler.m4 b/config/kernel-xattr-handler.m4
 586 index 137bf4a8aff..00b1e74a9cc 100644
 587 --- a/config/kernel-xattr-handler.m4
 588 +++ b/config/kernel-xattr-handler.m4
 589 @@ -152,6 +152,21 @@ dnl #
 590  dnl # Supported xattr handler set() interfaces checked newest to oldest.
 591  dnl #
 592  AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET], [
 593 +       ZFS_LINUX_TEST_SRC([xattr_handler_set_userns], [
 594 +               #include <linux/xattr.h>
 595 +
 596 +               int set(const struct xattr_handler *handler,
 597 +                       struct user_namespace *mnt_userns,
 598 +                       struct dentry *dentry, struct inode *inode,
 599 +                       const char *name, const void *buffer,
 600 +                       size_t size, int flags)
 601 +                       { return 0; }
 602 +               static const struct xattr_handler
 603 +                       xops __attribute__ ((unused)) = {
 604 +                       .set = set,
 605 +               };
 606 +       ],[])
 607 +
 608         ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry_inode], [
 609                 #include <linux/xattr.h>
 610
 611 @@ -194,45 +209,58 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET], [
 612
 613  AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_SET], [
 614         dnl #
 615 -       dnl # 4.7 API change,
 616 -       dnl # The xattr_handler->set() callback was changed to take both
 617 -       dnl # dentry and inode.
 618 +       dnl # 5.12 API change,
 619 +       dnl # The xattr_handler->set() callback was changed to 8 arguments, and
 620 +       dnl # struct user_namespace* was inserted as arg #2
 621         dnl #
 622 -       AC_MSG_CHECKING([whether xattr_handler->set() wants dentry and inode])
 623 -       ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry_inode], [
 624 +       AC_MSG_CHECKING([whether xattr_handler->set() wants dentry, inode, and user_namespace])
 625 +       ZFS_LINUX_TEST_RESULT([xattr_handler_set_userns], [
 626                 AC_MSG_RESULT(yes)
 627 -               AC_DEFINE(HAVE_XATTR_SET_DENTRY_INODE, 1,
 628 -                   [xattr_handler->set() wants both dentry and inode])
 629 +               AC_DEFINE(HAVE_XATTR_SET_USERNS, 1,
 630 +                   [xattr_handler->set() takes user_namespace])
 631         ],[
 632                 dnl #
 633 -               dnl # 4.4 API change,
 634 -               dnl # The xattr_handler->set() callback was changed to take a
 635 -               dnl # xattr_handler, and handler_flags argument was removed and
 636 -               dnl # should be accessed by handler->flags.
 637 +               dnl # 4.7 API change,
 638 +               dnl # The xattr_handler->set() callback was changed to take both
 639 +               dnl # dentry and inode.
 640                 dnl #
 641                 AC_MSG_RESULT(no)
 642 -               AC_MSG_CHECKING(
 643 -                   [whether xattr_handler->set() wants xattr_handler])
 644 -               ZFS_LINUX_TEST_RESULT([xattr_handler_set_xattr_handler], [
 645 +               AC_MSG_CHECKING([whether xattr_handler->set() wants dentry and inode])
 646 +               ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry_inode], [
 647                         AC_MSG_RESULT(yes)
 648 -                       AC_DEFINE(HAVE_XATTR_SET_HANDLER, 1,
 649 -                           [xattr_handler->set() wants xattr_handler])
 650 +                       AC_DEFINE(HAVE_XATTR_SET_DENTRY_INODE, 1,
 651 +                           [xattr_handler->set() wants both dentry and inode])
 652                 ],[
 653                         dnl #
 654 -                       dnl # 2.6.33 API change,
 655 -                       dnl # The xattr_handler->set() callback was changed
 656 -                       dnl # to take a dentry instead of an inode, and a
 657 -                       dnl # handler_flags argument was added.
 658 +                       dnl # 4.4 API change,
 659 +                       dnl # The xattr_handler->set() callback was changed to take a
 660 +                       dnl # xattr_handler, and handler_flags argument was removed and
 661 +                       dnl # should be accessed by handler->flags.
 662                         dnl #
 663                         AC_MSG_RESULT(no)
 664                         AC_MSG_CHECKING(
 665 -                           [whether xattr_handler->set() wants dentry])
 666 -                       ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry], [
 667 +                           [whether xattr_handler->set() wants xattr_handler])
 668 +                       ZFS_LINUX_TEST_RESULT([xattr_handler_set_xattr_handler], [
 669                                 AC_MSG_RESULT(yes)
 670 -                               AC_DEFINE(HAVE_XATTR_SET_DENTRY, 1,
 671 -                                   [xattr_handler->set() wants dentry])
 672 +                               AC_DEFINE(HAVE_XATTR_SET_HANDLER, 1,
 673 +                                   [xattr_handler->set() wants xattr_handler])
 674                         ],[
 675 -                               ZFS_LINUX_TEST_ERROR([xattr set()])
 676 +                               dnl #
 677 +                               dnl # 2.6.33 API change,
 678 +                               dnl # The xattr_handler->set() callback was changed
 679 +                               dnl # to take a dentry instead of an inode, and a
 680 +                               dnl # handler_flags argument was added.
 681 +                               dnl #
 682 +                               AC_MSG_RESULT(no)
 683 +                               AC_MSG_CHECKING(
 684 +                                   [whether xattr_handler->set() wants dentry])
 685 +                               ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry], [
 686 +                                       AC_MSG_RESULT(yes)
 687 +                                       AC_DEFINE(HAVE_XATTR_SET_DENTRY, 1,
 688 +                                           [xattr_handler->set() wants dentry])
 689 +                               ],[
 690 +                                       ZFS_LINUX_TEST_ERROR([xattr set()])
 691 +                               ])
 692                         ])
 693                 ])
 694         ])
 695 diff --git a/config/kernel.m4 b/config/kernel.m4
 696 index f31be845f5d..24db38f09f4 100644
 697 --- a/config/kernel.m4
 698 +++ b/config/kernel.m4
 699 @@ -79,9 +79,9 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [
 700         ZFS_AC_KERNEL_SRC_EVICT_INODE
 701         ZFS_AC_KERNEL_SRC_DIRTY_INODE
 702         ZFS_AC_KERNEL_SRC_SHRINKER
 703 -       ZFS_AC_KERNEL_SRC_MKDIR_UMODE_T
 704 +       ZFS_AC_KERNEL_SRC_MKDIR
 705         ZFS_AC_KERNEL_SRC_LOOKUP_FLAGS
 706 -       ZFS_AC_KERNEL_SRC_CREATE_FLAGS
 707 +       ZFS_AC_KERNEL_SRC_CREATE
 708         ZFS_AC_KERNEL_SRC_GET_LINK
 709         ZFS_AC_KERNEL_SRC_PUT_LINK
 710         ZFS_AC_KERNEL_SRC_TMPFILE
 711 @@ -115,7 +115,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [
 712         ZFS_AC_KERNEL_SRC_KUIDGID_T
 713         ZFS_AC_KERNEL_SRC_KUID_HELPERS
 714         ZFS_AC_KERNEL_SRC_MODULE_PARAM_CALL_CONST
 715 -       ZFS_AC_KERNEL_SRC_RENAME_WANTS_FLAGS
 716 +       ZFS_AC_KERNEL_SRC_RENAME
 717         ZFS_AC_KERNEL_SRC_CURRENT_TIME
 718         ZFS_AC_KERNEL_SRC_USERNS_CAPABILITIES
 719         ZFS_AC_KERNEL_SRC_IN_COMPAT_SYSCALL
 720 @@ -125,6 +125,9 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [
 721         ZFS_AC_KERNEL_SRC_TOTALHIGH_PAGES
 722         ZFS_AC_KERNEL_SRC_KSTRTOUL
 723         ZFS_AC_KERNEL_SRC_PERCPU
 724 +       ZFS_AC_KERNEL_SRC_GENERIC_FILLATTR_USERNS
 725 +       ZFS_AC_KERNEL_SRC_MKNOD
 726 +       ZFS_AC_KERNEL_SRC_SYMLINK
 727
 728         AC_MSG_CHECKING([for available kernel interfaces])
 729         ZFS_LINUX_TEST_COMPILE_ALL([kabi])
 730 @@ -177,9 +180,9 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [
 731         ZFS_AC_KERNEL_EVICT_INODE
 732         ZFS_AC_KERNEL_DIRTY_INODE
 733         ZFS_AC_KERNEL_SHRINKER
 734 -       ZFS_AC_KERNEL_MKDIR_UMODE_T
 735 +       ZFS_AC_KERNEL_MKDIR
 736         ZFS_AC_KERNEL_LOOKUP_FLAGS
 737 -       ZFS_AC_KERNEL_CREATE_FLAGS
 738 +       ZFS_AC_KERNEL_CREATE
 739         ZFS_AC_KERNEL_GET_LINK
 740         ZFS_AC_KERNEL_PUT_LINK
 741         ZFS_AC_KERNEL_TMPFILE
 742 @@ -213,7 +216,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [
 743         ZFS_AC_KERNEL_KUIDGID_T
 744         ZFS_AC_KERNEL_KUID_HELPERS
 745         ZFS_AC_KERNEL_MODULE_PARAM_CALL_CONST
 746 -       ZFS_AC_KERNEL_RENAME_WANTS_FLAGS
 747 +       ZFS_AC_KERNEL_RENAME
 748         ZFS_AC_KERNEL_CURRENT_TIME
 749         ZFS_AC_KERNEL_USERNS_CAPABILITIES
 750         ZFS_AC_KERNEL_IN_COMPAT_SYSCALL
 751 @@ -223,6 +226,9 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [
 752         ZFS_AC_KERNEL_TOTALHIGH_PAGES
 753         ZFS_AC_KERNEL_KSTRTOUL
 754         ZFS_AC_KERNEL_PERCPU
 755 +       ZFS_AC_KERNEL_GENERIC_FILLATTR_USERNS
 756 +       ZFS_AC_KERNEL_MKNOD
 757 +       ZFS_AC_KERNEL_SYMLINK
 758  ])
 759
 760  dnl #
 761 diff --git a/include/os/linux/kernel/linux/vfs_compat.h b/include/os/linux/kernel/linux/vfs_compat.h
 762 index c35e80d31cd..91e908598fb 100644
 763 --- a/include/os/linux/kernel/linux/vfs_compat.h
 764 +++ b/include/os/linux/kernel/linux/vfs_compat.h
 765 @@ -343,7 +343,8 @@ static inline void zfs_gid_write(struct inode *ip, gid_t gid)
 766  /*
 767   * 4.9 API change
 768   */
 769 -#ifndef HAVE_SETATTR_PREPARE
 770 +#if !(defined(HAVE_SETATTR_PREPARE_NO_USERNS) || \
 771 +    defined(HAVE_SETATTR_PREPARE_USERNS))
 772  static inline int
 773  setattr_prepare(struct dentry *dentry, struct iattr *ia)
 774  {
 775 @@ -389,6 +390,15 @@ func(const struct path *path, struct kstat *stat, u32 request_mask,        \
 776  {                                                                      \
 777         return (func##_impl(path, stat, request_mask, query_flags));    \
 778  }
 779 +#elif defined(HAVE_USERNS_IOPS_GETATTR)
 780 +#define        ZPL_GETATTR_WRAPPER(func)                                       \
 781 +static int                                                             \
 782 +func(struct user_namespace *user_ns, const struct path *path,  \
 783 +    struct kstat *stat, u32 request_mask, unsigned int query_flags)    \
 784 +{                                                                      \
 785 +       return (func##_impl(user_ns, path, stat, request_mask, \
 786 +           query_flags));      \
 787 +}
 788  #else
 789  #error
 790  #endif
 791 @@ -436,4 +446,16 @@ zpl_is_32bit_api(void)
 792  #endif
 793  }
 794
 795 +/*
 796 + * 5.12 API change
 797 + * To support id-mapped mounts, generic_fillattr() was modified to
 798 + * accept a new struct user_namespace* as its first arg.
 799 + */
 800 +#ifdef HAVE_GENERIC_FILLATTR_USERNS
 801 +#define        zpl_generic_fillattr(user_ns, ip, sp)   \
 802 +    generic_fillattr(user_ns, ip, sp)
 803 +#else
 804 +#define        zpl_generic_fillattr(user_ns, ip, sp)   generic_fillattr(ip, sp)
 805 +#endif
 806 +
 807  #endif /* _ZFS_VFS_H */
 808 diff --git a/include/os/linux/kernel/linux/xattr_compat.h b/include/os/linux/kernel/linux/xattr_compat.h
 809 index 8348e99198a..54690727eab 100644
 810 --- a/include/os/linux/kernel/linux/xattr_compat.h
 811 +++ b/include/os/linux/kernel/linux/xattr_compat.h
 812 @@ -119,12 +119,27 @@ fn(struct dentry *dentry, const char *name, void *buffer, size_t size,    \
 813  #error "Unsupported kernel"
 814  #endif
 815
 816 +/*
 817 + * 5.12 API change,
 818 + * The xattr_handler->set() callback was changed to take the
 819 + * struct user_namespace* as the first arg, to support idmapped
 820 + * mounts.
 821 + */
 822 +#if defined(HAVE_XATTR_SET_USERNS)
 823 +#define        ZPL_XATTR_SET_WRAPPER(fn)                                       \
 824 +static int                                                             \
 825 +fn(const struct xattr_handler *handler, struct user_namespace *user_ns, \
 826 +    struct dentry *dentry, struct inode *inode, const char *name,      \
 827 +    const void *buffer, size_t size, int flags)        \
 828 +{                                                                      \
 829 +       return (__ ## fn(inode, name, buffer, size, flags));            \
 830 +}
 831  /*
 832   * 4.7 API change,
 833   * The xattr_handler->set() callback was changed to take a both dentry and
 834   * inode, because the dentry might not be attached to an inode yet.
 835   */
 836 -#if defined(HAVE_XATTR_SET_DENTRY_INODE)
 837 +#elif defined(HAVE_XATTR_SET_DENTRY_INODE)
 838  #define        ZPL_XATTR_SET_WRAPPER(fn)                                       \
 839  static int                                                             \
 840  fn(const struct xattr_handler *handler, struct dentry *dentry,         \
 841 diff --git a/include/os/linux/zfs/sys/zfs_vnops_os.h b/include/os/linux/zfs/sys/zfs_vnops_os.h
 842 index ef76de3e298..47f91e4a6cf 100644
 843 --- a/include/os/linux/zfs/sys/zfs_vnops_os.h
 844 +++ b/include/os/linux/zfs/sys/zfs_vnops_os.h
 845 @@ -54,7 +54,8 @@ extern int zfs_mkdir(znode_t *dzp, char *dirname, vattr_t *vap,
 846  extern int zfs_rmdir(znode_t *dzp, char *name, znode_t *cwd,
 847      cred_t *cr, int flags);
 848  extern int zfs_readdir(struct inode *ip, zpl_dir_context_t *ctx, cred_t *cr);
 849 -extern int zfs_getattr_fast(struct inode *ip, struct kstat *sp);
 850 +extern int zfs_getattr_fast(struct user_namespace *, struct inode *ip,
 851 +       struct kstat *sp);
 852  extern int zfs_setattr(znode_t *zp, vattr_t *vap, int flag, cred_t *cr);
 853  extern int zfs_rename(znode_t *sdzp, char *snm, znode_t *tdzp,
 854      char *tnm, cred_t *cr, int flags);
 855 diff --git a/include/os/linux/zfs/sys/zpl.h b/include/os/linux/zfs/sys/zpl.h
 856 index b0bb9c29c0b..21825d1f378 100644
 857 --- a/include/os/linux/zfs/sys/zpl.h
 858 +++ b/include/os/linux/zfs/sys/zpl.h
 859 @@ -171,4 +171,22 @@ zpl_dir_emit_dots(struct file *file, zpl_dir_context_t *ctx)
 860         timespec_trunc(ts, (ip)->i_sb->s_time_gran)
 861  #endif
 862
 863 +#if defined(HAVE_INODE_OWNER_OR_CAPABLE)
 864 +#define        zpl_inode_owner_or_capable(ns, ip)      inode_owner_or_capable(ip)
 865 +#elif defined(HAVE_INODE_OWNER_OR_CAPABLE_IDMAPPED)
 866 +#define        zpl_inode_owner_or_capable(ns, ip)      inode_owner_or_capable(ns, ip)
 867 +#else
 868 +#error "Unsupported kernel"
 869 +#endif
 870 +
 871 +#ifdef HAVE_SETATTR_PREPARE_USERNS
 872 +#define        zpl_setattr_prepare(ns, dentry, ia)     setattr_prepare(ns, dentry, ia)
 873 +#else
 874 +/*
 875 + * Use kernel-provided version, or our own from
 876 + * linux/vfs_compat.h
 877 + */
 878 +#define        zpl_setattr_prepare(ns, dentry, ia)     setattr_prepare(dentry, ia)
 879 +#endif
 880 +
 881  #endif /* _SYS_ZPL_H */
 882 diff --git a/module/os/linux/zfs/policy.c b/module/os/linux/zfs/policy.c
 883 index 8780d7f6c70..bbccb2e572d 100644
 884 --- a/module/os/linux/zfs/policy.c
 885 +++ b/module/os/linux/zfs/policy.c
 886 @@ -124,7 +124,7 @@ secpolicy_vnode_any_access(const cred_t *cr, struct inode *ip, uid_t owner)
 887         if (crgetfsuid(cr) == owner)
 888                 return (0);
 889
 890 -       if (inode_owner_or_capable(ip))
 891 +       if (zpl_inode_owner_or_capable(kcred->user_ns, ip))
 892                 return (0);
 893
 894  #if defined(CONFIG_USER_NS)
 895 diff --git a/module/os/linux/zfs/zfs_vnops_os.c b/module/os/linux/zfs/zfs_vnops_os.c
 896 index 84c33b541ea..8aeed6f568c 100644
 897 --- a/module/os/linux/zfs/zfs_vnops_os.c
 898 +++ b/module/os/linux/zfs/zfs_vnops_os.c
 899 @@ -1656,7 +1656,8 @@ zfs_readdir(struct inode *ip, zpl_dir_context_t *ctx, cred_t *cr)
 900   */
 901  /* ARGSUSED */
 902  int
 903 -zfs_getattr_fast(struct inode *ip, struct kstat *sp)
 904 +zfs_getattr_fast(struct user_namespace *user_ns, struct inode *ip,
 905 +    struct kstat *sp)
 906  {
 907         znode_t *zp = ITOZ(ip);
 908         zfsvfs_t *zfsvfs = ITOZSB(ip);
 909 @@ -1668,7 +1669,7 @@ zfs_getattr_fast(struct inode *ip, struct kstat *sp)
 910
 911         mutex_enter(&zp->z_lock);
 912
 913 -       generic_fillattr(ip, sp);
 914 +       zpl_generic_fillattr(user_ns, ip, sp);
 915         /*
 916          * +1 link count for root inode with visible '.zfs' directory.
 917          */
 918 diff --git a/module/os/linux/zfs/zpl_ctldir.c b/module/os/linux/zfs/zpl_ctldir.c
 919 index e6420f19ed8..9b526afd000 100644
 920 --- a/module/os/linux/zfs/zpl_ctldir.c
 921 +++ b/module/os/linux/zfs/zpl_ctldir.c
 922 @@ -101,12 +101,22 @@ zpl_root_readdir(struct file *filp, void *dirent, filldir_t filldir)
 923   */
 924  /* ARGSUSED */
 925  static int
 926 +#ifdef HAVE_USERNS_IOPS_GETATTR
 927 +zpl_root_getattr_impl(struct user_namespace *user_ns,
 928 +    const struct path *path, struct kstat *stat, u32 request_mask,
 929 +    unsigned int query_flags)
 930 +#else
 931  zpl_root_getattr_impl(const struct path *path, struct kstat *stat,
 932      u32 request_mask, unsigned int query_flags)
 933 +#endif
 934  {
 935         struct inode *ip = path->dentry->d_inode;
 936
 937 +#if defined(HAVE_GENERIC_FILLATTR_USERNS) && defined(HAVE_USERNS_IOPS_GETATTR)
 938 +       generic_fillattr(user_ns, ip, stat);
 939 +#else
 940         generic_fillattr(ip, stat);
 941 +#endif
 942         stat->atime = current_time(ip);
 943
 944         return (0);
 945 @@ -290,8 +300,14 @@ zpl_snapdir_readdir(struct file *filp, void *dirent, filldir_t filldir)
 946  #endif /* !HAVE_VFS_ITERATE && !HAVE_VFS_ITERATE_SHARED */
 947
 948  static int
 949 +#ifdef HAVE_IOPS_RENAME_USERNS
 950 +zpl_snapdir_rename2(struct user_namespace *user_ns, struct inode *sdip,
 951 +    struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
 952 +    unsigned int flags)
 953 +#else
 954  zpl_snapdir_rename2(struct inode *sdip, struct dentry *sdentry,
 955      struct inode *tdip, struct dentry *tdentry, unsigned int flags)
 956 +#endif
 957  {
 958         cred_t *cr = CRED();
 959         int error;
 960 @@ -309,7 +325,7 @@ zpl_snapdir_rename2(struct inode *sdip, struct dentry *sdentry,
 961         return (error);
 962  }
 963
 964 -#ifndef HAVE_RENAME_WANTS_FLAGS
 965 +#if !defined(HAVE_RENAME_WANTS_FLAGS) && !defined(HAVE_IOPS_RENAME_USERNS)
 966  static int
 967  zpl_snapdir_rename(struct inode *sdip, struct dentry *sdentry,
 968      struct inode *tdip, struct dentry *tdentry)
 969 @@ -333,7 +349,12 @@ zpl_snapdir_rmdir(struct inode *dip, struct dentry *dentry)
 970  }
 971
 972  static int
 973 +#ifdef HAVE_IOPS_MKDIR_USERNS
 974 +zpl_snapdir_mkdir(struct user_namespace *user_ns, struct inode *dip,
 975 +    struct dentry *dentry, umode_t mode)
 976 +#else
 977  zpl_snapdir_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
 978 +#endif
 979  {
 980         cred_t *cr = CRED();
 981         vattr_t *vap;
 982 @@ -363,14 +384,24 @@ zpl_snapdir_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
 983   */
 984  /* ARGSUSED */
 985  static int
 986 +#ifdef HAVE_USERNS_IOPS_GETATTR
 987 +zpl_snapdir_getattr_impl(struct user_namespace *user_ns,
 988 +    const struct path *path, struct kstat *stat, u32 request_mask,
 989 +    unsigned int query_flags)
 990 +#else
 991  zpl_snapdir_getattr_impl(const struct path *path, struct kstat *stat,
 992      u32 request_mask, unsigned int query_flags)
 993 +#endif
 994  {
 995         struct inode *ip = path->dentry->d_inode;
 996         zfsvfs_t *zfsvfs = ITOZSB(ip);
 997
 998         ZPL_ENTER(zfsvfs);
 999 +#if defined(HAVE_GENERIC_FILLATTR_USERNS) && defined(HAVE_USERNS_IOPS_GETATTR)
1000 +       generic_fillattr(user_ns, ip, stat);
1001 +#else
1002         generic_fillattr(ip, stat);
1003 +#endif
1004
1005         stat->nlink = stat->size = 2;
1006         stat->ctime = stat->mtime = dmu_objset_snap_cmtime(zfsvfs->z_os);
1007 @@ -408,7 +439,7 @@ const struct file_operations zpl_fops_snapdir = {
1008  const struct inode_operations zpl_ops_snapdir = {
1009         .lookup         = zpl_snapdir_lookup,
1010         .getattr        = zpl_snapdir_getattr,
1011 -#ifdef HAVE_RENAME_WANTS_FLAGS
1012 +#if defined(HAVE_RENAME_WANTS_FLAGS) || defined(HAVE_IOPS_RENAME_USERNS)
1013         .rename         = zpl_snapdir_rename2,
1014  #else
1015         .rename         = zpl_snapdir_rename,
1016 @@ -495,8 +526,14 @@ zpl_shares_readdir(struct file *filp, void *dirent, filldir_t filldir)
1017
1018  /* ARGSUSED */
1019  static int
1020 +#ifdef HAVE_USERNS_IOPS_GETATTR
1021 +zpl_shares_getattr_impl(struct user_namespace *user_ns,
1022 +    const struct path *path, struct kstat *stat, u32 request_mask,
1023 +    unsigned int query_flags)
1024 +#else
1025  zpl_shares_getattr_impl(const struct path *path, struct kstat *stat,
1026      u32 request_mask, unsigned int query_flags)
1027 +#endif
1028  {
1029         struct inode *ip = path->dentry->d_inode;
1030         zfsvfs_t *zfsvfs = ITOZSB(ip);
1031 @@ -506,7 +543,11 @@ zpl_shares_getattr_impl(const struct path *path, struct kstat *stat,
1032         ZPL_ENTER(zfsvfs);
1033
1034         if (zfsvfs->z_shares_dir == 0) {
1035 +#if defined(HAVE_GENERIC_FILLATTR_USERNS) && defined(HAVE_USERNS_IOPS_GETATTR)
1036 +               generic_fillattr(user_ns, path->dentry->d_inode, stat);
1037 +#else
1038                 generic_fillattr(path->dentry->d_inode, stat);
1039 +#endif
1040                 stat->nlink = stat->size = 2;
1041                 stat->atime = current_time(ip);
1042                 ZPL_EXIT(zfsvfs);
1043 @@ -515,7 +556,11 @@ zpl_shares_getattr_impl(const struct path *path, struct kstat *stat,
1044
1045         error = -zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp);
1046         if (error == 0) {
1047 -               error = -zfs_getattr_fast(ZTOI(dzp), stat);
1048 +#if defined(HAVE_GENERIC_FILLATTR_USERNS) && defined(HAVE_USERNS_IOPS_GETATTR)
1049 +               error = -zfs_getattr_fast(user_ns, ZTOI(dzp), stat);
1050 +#else
1051 +               error = -zfs_getattr_fast(kcred->user_ns, ZTOI(dzp), stat);
1052 +#endif
1053                 iput(ZTOI(dzp));
1054         }
1055
1056 diff --git a/module/os/linux/zfs/zpl_file.c b/module/os/linux/zfs/zpl_file.c
1057 index 970db4a8b73..ea6993ffa4b 100644
1058 --- a/module/os/linux/zfs/zpl_file.c
1059 +++ b/module/os/linux/zfs/zpl_file.c
1060 @@ -869,7 +869,7 @@ __zpl_ioctl_setflags(struct inode *ip, uint32_t ioctl_flags, xvattr_t *xva)
1061             !capable(CAP_LINUX_IMMUTABLE))
1062                 return (-EACCES);
1063
1064 -       if (!inode_owner_or_capable(ip))
1065 +       if (!zpl_inode_owner_or_capable(kcred->user_ns, ip))
1066                 return (-EACCES);
1067
1068         xva_init(xva);
1069 diff --git a/module/os/linux/zfs/zpl_inode.c b/module/os/linux/zfs/zpl_inode.c
1070 index 117963f44af..cf0eab3e8c9 100644
1071 --- a/module/os/linux/zfs/zpl_inode.c
1072 +++ b/module/os/linux/zfs/zpl_inode.c
1073 @@ -128,7 +128,12 @@ zpl_vap_init(vattr_t *vap, struct inode *dir, umode_t mode, cred_t *cr)
1074  }
1075
1076  static int
1077 +#ifdef HAVE_IOPS_CREATE_USERNS
1078 +zpl_create(struct user_namespace *user_ns, struct inode *dir,
1079 +    struct dentry *dentry, umode_t mode, bool flag)
1080 +#else
1081  zpl_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool flag)
1082 +#endif
1083  {
1084         cred_t *cr = CRED();
1085         znode_t *zp;
1086 @@ -163,7 +168,12 @@ zpl_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool flag)
1087  }
1088
1089  static int
1090 +#ifdef HAVE_IOPS_MKNOD_USERNS
1091 +zpl_mknod(struct user_namespace *user_ns, struct inode *dir,
1092 +    struct dentry *dentry, umode_t mode,
1093 +#else
1094  zpl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
1095 +#endif
1096      dev_t rdev)
1097  {
1098         cred_t *cr = CRED();
1099 @@ -278,7 +288,12 @@ zpl_unlink(struct inode *dir, struct dentry *dentry)
1100  }
1101
1102  static int
1103 +#ifdef HAVE_IOPS_MKDIR_USERNS
1104 +zpl_mkdir(struct user_namespace *user_ns, struct inode *dir,
1105 +    struct dentry *dentry, umode_t mode)
1106 +#else
1107  zpl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1108 +#endif
1109  {
1110         cred_t *cr = CRED();
1111         vattr_t *vap;
1112 @@ -338,8 +353,14 @@ zpl_rmdir(struct inode *dir, struct dentry *dentry)
1113  }
1114
1115  static int
1116 +#ifdef HAVE_USERNS_IOPS_GETATTR
1117 +zpl_getattr_impl(struct user_namespace *user_ns,
1118 +    const struct path *path, struct kstat *stat, u32 request_mask,
1119 +    unsigned int query_flags)
1120 +#else
1121  zpl_getattr_impl(const struct path *path, struct kstat *stat, u32 request_mask,
1122      unsigned int query_flags)
1123 +#endif
1124  {
1125         int error;
1126         fstrans_cookie_t cookie;
1127 @@ -350,7 +371,11 @@ zpl_getattr_impl(const struct path *path, struct kstat *stat, u32 request_mask,
1128          * XXX request_mask and query_flags currently ignored.
1129          */
1130
1131 -       error = -zfs_getattr_fast(path->dentry->d_inode, stat);
1132 +#ifdef HAVE_USERNS_IOPS_GETATTR
1133 +       error = -zfs_getattr_fast(user_ns, path->dentry->d_inode, stat);
1134 +#else
1135 +       error = -zfs_getattr_fast(kcred->user_ns, path->dentry->d_inode, stat);
1136 +#endif
1137         spl_fstrans_unmark(cookie);
1138         ASSERT3S(error, <=, 0);
1139
1140 @@ -359,7 +384,12 @@ zpl_getattr_impl(const struct path *path, struct kstat *stat, u32 request_mask,
1141  ZPL_GETATTR_WRAPPER(zpl_getattr);
1142
1143  static int
1144 +#ifdef HAVE_SETATTR_PREPARE_USERNS
1145 +zpl_setattr(struct user_namespace *user_ns, struct dentry *dentry,
1146 +    struct iattr *ia)
1147 +#else
1148  zpl_setattr(struct dentry *dentry, struct iattr *ia)
1149 +#endif
1150  {
1151         struct inode *ip = dentry->d_inode;
1152         cred_t *cr = CRED();
1153 @@ -367,7 +397,7 @@ zpl_setattr(struct dentry *dentry, struct iattr *ia)
1154         int error;
1155         fstrans_cookie_t cookie;
1156
1157 -       error = setattr_prepare(dentry, ia);
1158 +       error = zpl_setattr_prepare(kcred->user_ns, dentry, ia);
1159         if (error)
1160                 return (error);
1161
1162 @@ -399,8 +429,14 @@ zpl_setattr(struct dentry *dentry, struct iattr *ia)
1163  }
1164
1165  static int
1166 +#ifdef HAVE_IOPS_RENAME_USERNS
1167 +zpl_rename2(struct user_namespace *user_ns, struct inode *sdip,
1168 +    struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
1169 +    unsigned int flags)
1170 +#else
1171  zpl_rename2(struct inode *sdip, struct dentry *sdentry,
1172      struct inode *tdip, struct dentry *tdentry, unsigned int flags)
1173 +#endif
1174  {
1175         cred_t *cr = CRED();
1176         int error;
1177 @@ -421,7 +457,7 @@ zpl_rename2(struct inode *sdip, struct dentry *sdentry,
1178         return (error);
1179  }
1180
1181 -#ifndef HAVE_RENAME_WANTS_FLAGS
1182 +#if !defined(HAVE_RENAME_WANTS_FLAGS) && !defined(HAVE_IOPS_RENAME_USERNS)
1183  static int
1184  zpl_rename(struct inode *sdip, struct dentry *sdentry,
1185      struct inode *tdip, struct dentry *tdentry)
1186 @@ -431,7 +467,12 @@ zpl_rename(struct inode *sdip, struct dentry *sdentry,
1187  #endif
1188
1189  static int
1190 +#ifdef HAVE_IOPS_SYMLINK_USERNS
1191 +zpl_symlink(struct user_namespace *user_ns, struct inode *dir,
1192 +    struct dentry *dentry, const char *name)
1193 +#else
1194  zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
1195 +#endif
1196  {
1197         cred_t *cr = CRED();
1198         vattr_t *vap;
1199 @@ -678,7 +719,7 @@ const struct inode_operations zpl_dir_inode_operations = {
1200         .mkdir          = zpl_mkdir,
1201         .rmdir          = zpl_rmdir,
1202         .mknod          = zpl_mknod,
1203 -#ifdef HAVE_RENAME_WANTS_FLAGS
1204 +#if defined(HAVE_RENAME_WANTS_FLAGS) || defined(HAVE_IOPS_RENAME_USERNS)
1205         .rename         = zpl_rename2,
1206  #else
1207         .rename         = zpl_rename,
1208 diff --git a/module/os/linux/zfs/zpl_xattr.c b/module/os/linux/zfs/zpl_xattr.c
1209 index 83812f2dcba..971cd6ad031 100644
1210 --- a/module/os/linux/zfs/zpl_xattr.c
1211 +++ b/module/os/linux/zfs/zpl_xattr.c
1212 @@ -1233,7 +1233,7 @@ __zpl_xattr_acl_set_access(struct inode *ip, const char *name,
1213         if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
1214                 return (-EOPNOTSUPP);
1215
1216 -       if (!inode_owner_or_capable(ip))
1217 +       if (!zpl_inode_owner_or_capable(kcred->user_ns, ip))
1218                 return (-EPERM);
1219
1220         if (value) {
1221 @@ -1273,7 +1273,7 @@ __zpl_xattr_acl_set_default(struct inode *ip, const char *name,
1222         if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
1223                 return (-EOPNOTSUPP);
1224
1225 -       if (!inode_owner_or_capable(ip))
1226 +       if (!zpl_inode_owner_or_capable(kcred->user_ns, ip))
1227                 return (-EPERM);
1228
1229         if (value) {
1230 From ffd6978ef59cfe2773e984bf03de2f0b93b03f5c Mon Sep 17 00:00:00 2001
1231 From: Coleman Kane <ckane@colemankane.org>
1232 Date: Sat, 20 Mar 2021 01:33:42 -0400
1233 Subject: [PATCH] Linux 5.12 update: bio_max_segs() replaces BIO_MAX_PAGES
1234
1235 The BIO_MAX_PAGES macro is being retired in favor of a bio_max_segs()
1236 function that implements the typical MIN(x,y) logic used throughout the
1237 kernel for bounding the allocation, and also the new implementation is
1238 intended to be signed-safe (which the former was not).
1239
1240 Reviewed-by: Tony Hutter <hutter2@llnl.gov>
1241 Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
1242 Signed-off-by: Coleman Kane <ckane@colemankane.org>
1243 Closes #11765
1244 ---
1245  config/kernel-bio_max_segs.m4   | 23 +++++++++++++++++++++++
1246  config/kernel.m4                |  2 ++
1247  module/os/linux/zfs/vdev_disk.c |  5 +++++
1248  3 files changed, 30 insertions(+)
1249  create mode 100644 config/kernel-bio_max_segs.m4
1250
1251 diff --git a/config/kernel-bio_max_segs.m4 b/config/kernel-bio_max_segs.m4
1252 new file mode 100644
1253 index 00000000000..a90d75455c1
1254 --- /dev/null
1255 +++ b/config/kernel-bio_max_segs.m4
1256 @@ -0,0 +1,23 @@
1257 +dnl #
1258 +dnl # 5.12 API change removes BIO_MAX_PAGES in favor of bio_max_segs()
1259 +dnl # which will handle the logic of setting the upper-bound to a
1260 +dnl # BIO_MAX_PAGES, internally.
1261 +dnl #
1262 +AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_MAX_SEGS], [
1263 +       ZFS_LINUX_TEST_SRC([bio_max_segs], [
1264 +               #include <linux/bio.h>
1265 +       ],[
1266 +               bio_max_segs(1);
1267 +       ])
1268 +])
1269 +
1270 +AC_DEFUN([ZFS_AC_KERNEL_BIO_MAX_SEGS], [
1271 +       AC_MSG_CHECKING([whether bio_max_segs() exists])
1272 +       ZFS_LINUX_TEST_RESULT([bio_max_segs], [
1273 +               AC_MSG_RESULT(yes)
1274 +
1275 +               AC_DEFINE([HAVE_BIO_MAX_SEGS], 1, [bio_max_segs() is implemented])
1276 +       ],[
1277 +               AC_MSG_RESULT(no)
1278 +       ])
1279 +])
1280 diff --git a/config/kernel.m4 b/config/kernel.m4
1281 index 24db38f09f4..dfb6165d879 100644
1282 --- a/config/kernel.m4
1283 +++ b/config/kernel.m4
1284 @@ -128,6 +128,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [
1285         ZFS_AC_KERNEL_SRC_GENERIC_FILLATTR_USERNS
1286         ZFS_AC_KERNEL_SRC_MKNOD
1287         ZFS_AC_KERNEL_SRC_SYMLINK
1288 +       ZFS_AC_KERNEL_SRC_BIO_MAX_SEGS
1289
1290         AC_MSG_CHECKING([for available kernel interfaces])
1291         ZFS_LINUX_TEST_COMPILE_ALL([kabi])
1292 @@ -229,6 +230,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [
1293         ZFS_AC_KERNEL_GENERIC_FILLATTR_USERNS
1294         ZFS_AC_KERNEL_MKNOD
1295         ZFS_AC_KERNEL_SYMLINK
1296 +       ZFS_AC_KERNEL_BIO_MAX_SEGS
1297  ])
1298
1299  dnl #
1300 diff --git a/module/os/linux/zfs/vdev_disk.c b/module/os/linux/zfs/vdev_disk.c
1301 index ff71ef4cd06..c56fd3a6ff2 100644
1302 --- a/module/os/linux/zfs/vdev_disk.c
1303 +++ b/module/os/linux/zfs/vdev_disk.c
1304 @@ -589,9 +589,14 @@ __vdev_disk_physio(struct block_device *bdev, zio_t *zio,
1305                 }
1306
1307                 /* bio_alloc() with __GFP_WAIT never returns NULL */
1308 +#ifdef HAVE_BIO_MAX_SEGS
1309 +               dr->dr_bio[i] = bio_alloc(GFP_NOIO, bio_max_segs(
1310 +                   abd_nr_pages_off(zio->io_abd, bio_size, abd_offset)));
1311 +#else
1312                 dr->dr_bio[i] = bio_alloc(GFP_NOIO,
1313                     MIN(abd_nr_pages_off(zio->io_abd, bio_size, abd_offset),
1314                     BIO_MAX_PAGES));
1315 +#endif
1316                 if (unlikely(dr->dr_bio[i] == NULL)) {
1317                         vdev_disk_dio_free(dr);
1318                         return (SET_ERROR(ENOMEM));