module/os/linux/zfs/zpl_inode.c

   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 https://opensource.org/licenses/CDDL-1.0.
  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  * Copyright (c) 2011, Lawrence Livermore National Security, LLC.
  23  * Copyright (c) 2015 by Chunwei Chen. All rights reserved.
  24  */
  25
  26
  27 #include <sys/sysmacros.h>
  28 #include <sys/zfs_ctldir.h>
  29 #include <sys/zfs_vfsops.h>
  30 #include <sys/zfs_vnops.h>
  31 #include <sys/zfs_znode.h>
  32 #include <sys/dmu_objset.h>
  33 #include <sys/vfs.h>
  34 #include <sys/zpl.h>
  35 #include <sys/file.h>
  36
  37 static struct dentry *
  38 zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
  39 {
  40         cred_t *cr = CRED();
  41         struct inode *ip;
  42         znode_t *zp;
  43         int error;
  44         fstrans_cookie_t cookie;
  45         pathname_t *ppn = NULL;
  46         pathname_t pn;
  47         int zfs_flags = 0;
  48         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
  49
  50         if (dlen(dentry) >= ZAP_MAXNAMELEN)
  51                 return (ERR_PTR(-ENAMETOOLONG));
  52
  53         crhold(cr);
  54         cookie = spl_fstrans_mark();
  55
  56         /* If we are a case insensitive fs, we need the real name */
  57         if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
  58                 zfs_flags = FIGNORECASE;
  59                 pn_alloc(&pn);
  60                 ppn = &pn;
  61         }
  62
  63         error = -zfs_lookup(ITOZ(dir), dname(dentry), &zp,
  64             zfs_flags, cr, NULL, ppn);
  65         spl_fstrans_unmark(cookie);
  66         ASSERT3S(error, <=, 0);
  67         crfree(cr);
  68
  69         spin_lock(&dentry->d_lock);
  70         dentry->d_time = jiffies;
  71         spin_unlock(&dentry->d_lock);
  72
  73         if (error) {
  74                 /*
  75                  * If we have a case sensitive fs, we do not want to
  76                  * insert negative entries, so return NULL for ENOENT.
  77                  * Fall through if the error is not ENOENT. Also free memory.
  78                  */
  79                 if (ppn) {
  80                         pn_free(ppn);
  81                         if (error == -ENOENT)
  82                                 return (NULL);
  83                 }
  84
  85                 if (error == -ENOENT)
  86                         return (d_splice_alias(NULL, dentry));
  87                 else
  88                         return (ERR_PTR(error));
  89         }
  90         ip = ZTOI(zp);
  91
  92         /*
  93          * If we are case insensitive, call the correct function
  94          * to install the name.
  95          */
  96         if (ppn) {
  97                 struct dentry *new_dentry;
  98                 struct qstr ci_name;
  99
 100                 if (strcmp(dname(dentry), pn.pn_buf) == 0) {
 101                         new_dentry = d_splice_alias(ip,  dentry);
 102                 } else {
 103                         ci_name.name = pn.pn_buf;
 104                         ci_name.len = strlen(pn.pn_buf);
 105                         new_dentry = d_add_ci(dentry, ip, &ci_name);
 106                 }
 107                 pn_free(ppn);
 108                 return (new_dentry);
 109         } else {
 110                 return (d_splice_alias(ip, dentry));
 111         }
 112 }
 113
 114 void
 115 zpl_vap_init(vattr_t *vap, struct inode *dir, umode_t mode, cred_t *cr,
 116     zidmap_t *mnt_ns)
 117 {
 118         vap->va_mask = ATTR_MODE;
 119         vap->va_mode = mode;
 120
 121         vap->va_uid = zfs_vfsuid_to_uid(mnt_ns,
 122             zfs_i_user_ns(dir), crgetuid(cr));
 123
 124         if (dir->i_mode & S_ISGID) {
 125                 vap->va_gid = KGID_TO_SGID(dir->i_gid);
 126                 if (S_ISDIR(mode))
 127                         vap->va_mode |= S_ISGID;
 128         } else {
 129                 vap->va_gid = zfs_vfsgid_to_gid(mnt_ns,
 130                     zfs_i_user_ns(dir), crgetgid(cr));
 131         }
 132 }
 133
 134 static int
 135 #ifdef HAVE_IOPS_CREATE_USERNS
 136 zpl_create(struct user_namespace *user_ns, struct inode *dir,
 137     struct dentry *dentry, umode_t mode, bool flag)
 138 #elif defined(HAVE_IOPS_CREATE_IDMAP)
 139 zpl_create(struct mnt_idmap *user_ns, struct inode *dir,
 140     struct dentry *dentry, umode_t mode, bool flag)
 141 #else
 142 zpl_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool flag)
 143 #endif
 144 {
 145         cred_t *cr = CRED();
 146         znode_t *zp;
 147         vattr_t *vap;
 148         int error;
 149         fstrans_cookie_t cookie;
 150 #if !(defined(HAVE_IOPS_CREATE_USERNS) || defined(HAVE_IOPS_CREATE_IDMAP))
 151         zidmap_t *user_ns = kcred->user_ns;
 152 #endif
 153
 154         crhold(cr);
 155         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 156         zpl_vap_init(vap, dir, mode, cr, user_ns);
 157
 158         cookie = spl_fstrans_mark();
 159         error = -zfs_create(ITOZ(dir), dname(dentry), vap, 0,
 160             mode, &zp, cr, 0, NULL, user_ns);
 161         if (error == 0) {
 162                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 163                 if (error == 0)
 164                         error = zpl_init_acl(ZTOI(zp), dir);
 165
 166                 if (error) {
 167                         (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 168                         remove_inode_hash(ZTOI(zp));
 169                         iput(ZTOI(zp));
 170                 } else {
 171                         d_instantiate(dentry, ZTOI(zp));
 172                 }
 173         }
 174
 175         spl_fstrans_unmark(cookie);
 176         kmem_free(vap, sizeof (vattr_t));
 177         crfree(cr);
 178         ASSERT3S(error, <=, 0);
 179
 180         return (error);
 181 }
 182
 183 static int
 184 #ifdef HAVE_IOPS_MKNOD_USERNS
 185 zpl_mknod(struct user_namespace *user_ns, struct inode *dir,
 186     struct dentry *dentry, umode_t mode,
 187 #elif defined(HAVE_IOPS_MKNOD_IDMAP)
 188 zpl_mknod(struct mnt_idmap *user_ns, struct inode *dir,
 189     struct dentry *dentry, umode_t mode,
 190 #else
 191 zpl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 192 #endif
 193     dev_t rdev)
 194 {
 195         cred_t *cr = CRED();
 196         znode_t *zp;
 197         vattr_t *vap;
 198         int error;
 199         fstrans_cookie_t cookie;
 200 #if !(defined(HAVE_IOPS_MKNOD_USERNS) || defined(HAVE_IOPS_MKNOD_IDMAP))
 201         zidmap_t *user_ns = kcred->user_ns;
 202 #endif
 203
 204         /*
 205          * We currently expect Linux to supply rdev=0 for all sockets
 206          * and fifos, but we want to know if this behavior ever changes.
 207          */
 208         if (S_ISSOCK(mode) || S_ISFIFO(mode))
 209                 ASSERT(rdev == 0);
 210
 211         crhold(cr);
 212         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 213         zpl_vap_init(vap, dir, mode, cr, user_ns);
 214         vap->va_rdev = rdev;
 215
 216         cookie = spl_fstrans_mark();
 217         error = -zfs_create(ITOZ(dir), dname(dentry), vap, 0,
 218             mode, &zp, cr, 0, NULL, user_ns);
 219         if (error == 0) {
 220                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 221                 if (error == 0)
 222                         error = zpl_init_acl(ZTOI(zp), dir);
 223
 224                 if (error) {
 225                         (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 226                         remove_inode_hash(ZTOI(zp));
 227                         iput(ZTOI(zp));
 228                 } else {
 229                         d_instantiate(dentry, ZTOI(zp));
 230                 }
 231         }
 232
 233         spl_fstrans_unmark(cookie);
 234         kmem_free(vap, sizeof (vattr_t));
 235         crfree(cr);
 236         ASSERT3S(error, <=, 0);
 237
 238         return (error);
 239 }
 240
 241 #ifdef HAVE_TMPFILE
 242 static int
 243 #ifdef HAVE_TMPFILE_IDMAP
 244 zpl_tmpfile(struct mnt_idmap *userns, struct inode *dir,
 245     struct file *file, umode_t mode)
 246 #elif !defined(HAVE_TMPFILE_DENTRY)
 247 zpl_tmpfile(struct user_namespace *userns, struct inode *dir,
 248     struct file *file, umode_t mode)
 249 #else
 250 #ifdef HAVE_TMPFILE_USERNS
 251 zpl_tmpfile(struct user_namespace *userns, struct inode *dir,
 252     struct dentry *dentry, umode_t mode)
 253 #else
 254 zpl_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
 255 #endif
 256 #endif
 257 {
 258         cred_t *cr = CRED();
 259         struct inode *ip;
 260         vattr_t *vap;
 261         int error;
 262         fstrans_cookie_t cookie;
 263 #if !(defined(HAVE_TMPFILE_USERNS) || defined(HAVE_TMPFILE_IDMAP))
 264         zidmap_t *userns = kcred->user_ns;
 265 #endif
 266
 267         crhold(cr);
 268         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 269         /*
 270          * The VFS does not apply the umask, therefore it is applied here
 271          * when POSIX ACLs are not enabled.
 272          */
 273         if (!IS_POSIXACL(dir))
 274                 mode &= ~current_umask();
 275         zpl_vap_init(vap, dir, mode, cr, userns);
 276
 277         cookie = spl_fstrans_mark();
 278         error = -zfs_tmpfile(dir, vap, 0, mode, &ip, cr, 0, NULL, userns);
 279         if (error == 0) {
 280                 /* d_tmpfile will do drop_nlink, so we should set it first */
 281                 set_nlink(ip, 1);
 282 #ifndef HAVE_TMPFILE_DENTRY
 283                 d_tmpfile(file, ip);
 284
 285                 error = zpl_xattr_security_init(ip, dir,
 286                     &file->f_path.dentry->d_name);
 287 #else
 288                 d_tmpfile(dentry, ip);
 289
 290                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 291 #endif
 292                 if (error == 0)
 293                         error = zpl_init_acl(ip, dir);
 294 #ifndef HAVE_TMPFILE_DENTRY
 295                 error = finish_open_simple(file, error);
 296 #endif
 297                 /*
 298                  * don't need to handle error here, file is already in
 299                  * unlinked set.
 300                  */
 301         }
 302
 303         spl_fstrans_unmark(cookie);
 304         kmem_free(vap, sizeof (vattr_t));
 305         crfree(cr);
 306         ASSERT3S(error, <=, 0);
 307
 308         return (error);
 309 }
 310 #endif
 311
 312 static int
 313 zpl_unlink(struct inode *dir, struct dentry *dentry)
 314 {
 315         cred_t *cr = CRED();
 316         int error;
 317         fstrans_cookie_t cookie;
 318         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 319
 320         crhold(cr);
 321         cookie = spl_fstrans_mark();
 322         error = -zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 323
 324         /*
 325          * For a CI FS we must invalidate the dentry to prevent the
 326          * creation of negative entries.
 327          */
 328         if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
 329                 d_invalidate(dentry);
 330
 331         spl_fstrans_unmark(cookie);
 332         crfree(cr);
 333         ASSERT3S(error, <=, 0);
 334
 335         return (error);
 336 }
 337
 338 static int
 339 #ifdef HAVE_IOPS_MKDIR_USERNS
 340 zpl_mkdir(struct user_namespace *user_ns, struct inode *dir,
 341     struct dentry *dentry, umode_t mode)
 342 #elif defined(HAVE_IOPS_MKDIR_IDMAP)
 343 zpl_mkdir(struct mnt_idmap *user_ns, struct inode *dir,
 344     struct dentry *dentry, umode_t mode)
 345 #else
 346 zpl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 347 #endif
 348 {
 349         cred_t *cr = CRED();
 350         vattr_t *vap;
 351         znode_t *zp;
 352         int error;
 353         fstrans_cookie_t cookie;
 354 #if !(defined(HAVE_IOPS_MKDIR_USERNS) || defined(HAVE_IOPS_MKDIR_IDMAP))
 355         zidmap_t *user_ns = kcred->user_ns;
 356 #endif
 357
 358         crhold(cr);
 359         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 360         zpl_vap_init(vap, dir, mode | S_IFDIR, cr, user_ns);
 361
 362         cookie = spl_fstrans_mark();
 363         error = -zfs_mkdir(ITOZ(dir), dname(dentry), vap, &zp, cr, 0, NULL,
 364             user_ns);
 365         if (error == 0) {
 366                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 367                 if (error == 0)
 368                         error = zpl_init_acl(ZTOI(zp), dir);
 369
 370                 if (error) {
 371                         (void) zfs_rmdir(ITOZ(dir), dname(dentry), NULL, cr, 0);
 372                         remove_inode_hash(ZTOI(zp));
 373                         iput(ZTOI(zp));
 374                 } else {
 375                         d_instantiate(dentry, ZTOI(zp));
 376                 }
 377         }
 378
 379         spl_fstrans_unmark(cookie);
 380         kmem_free(vap, sizeof (vattr_t));
 381         crfree(cr);
 382         ASSERT3S(error, <=, 0);
 383
 384         return (error);
 385 }
 386
 387 static int
 388 zpl_rmdir(struct inode *dir, struct dentry *dentry)
 389 {
 390         cred_t *cr = CRED();
 391         int error;
 392         fstrans_cookie_t cookie;
 393         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 394
 395         crhold(cr);
 396         cookie = spl_fstrans_mark();
 397         error = -zfs_rmdir(ITOZ(dir), dname(dentry), NULL, cr, 0);
 398
 399         /*
 400          * For a CI FS we must invalidate the dentry to prevent the
 401          * creation of negative entries.
 402          */
 403         if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
 404                 d_invalidate(dentry);
 405
 406         spl_fstrans_unmark(cookie);
 407         crfree(cr);
 408         ASSERT3S(error, <=, 0);
 409
 410         return (error);
 411 }
 412
 413 static int
 414 #ifdef HAVE_USERNS_IOPS_GETATTR
 415 zpl_getattr_impl(struct user_namespace *user_ns,
 416     const struct path *path, struct kstat *stat, u32 request_mask,
 417     unsigned int query_flags)
 418 #elif defined(HAVE_IDMAP_IOPS_GETATTR)
 419 zpl_getattr_impl(struct mnt_idmap *user_ns,
 420     const struct path *path, struct kstat *stat, u32 request_mask,
 421     unsigned int query_flags)
 422 #else
 423 zpl_getattr_impl(const struct path *path, struct kstat *stat, u32 request_mask,
 424     unsigned int query_flags)
 425 #endif
 426 {
 427         int error;
 428         fstrans_cookie_t cookie;
 429         struct inode *ip = path->dentry->d_inode;
 430         znode_t *zp __maybe_unused = ITOZ(ip);
 431
 432         cookie = spl_fstrans_mark();
 433
 434         /*
 435          * XXX query_flags currently ignored.
 436          */
 437
 438 #if (defined(HAVE_USERNS_IOPS_GETATTR) || defined(HAVE_IDMAP_IOPS_GETATTR))
 439         error = -zfs_getattr_fast(user_ns, ip, stat);
 440 #else
 441         error = -zfs_getattr_fast(kcred->user_ns, ip, stat);
 442 #endif
 443
 444 #ifdef STATX_BTIME
 445         if (request_mask & STATX_BTIME) {
 446                 stat->btime = zp->z_btime;
 447                 stat->result_mask |= STATX_BTIME;
 448         }
 449 #endif
 450
 451 #ifdef STATX_ATTR_IMMUTABLE
 452         if (zp->z_pflags & ZFS_IMMUTABLE)
 453                 stat->attributes |= STATX_ATTR_IMMUTABLE;
 454         stat->attributes_mask |= STATX_ATTR_IMMUTABLE;
 455 #endif
 456
 457 #ifdef STATX_ATTR_APPEND
 458         if (zp->z_pflags & ZFS_APPENDONLY)
 459                 stat->attributes |= STATX_ATTR_APPEND;
 460         stat->attributes_mask |= STATX_ATTR_APPEND;
 461 #endif
 462
 463 #ifdef STATX_ATTR_NODUMP
 464         if (zp->z_pflags & ZFS_NODUMP)
 465                 stat->attributes |= STATX_ATTR_NODUMP;
 466         stat->attributes_mask |= STATX_ATTR_NODUMP;
 467 #endif
 468
 469         spl_fstrans_unmark(cookie);
 470         ASSERT3S(error, <=, 0);
 471
 472         return (error);
 473 }
 474 ZPL_GETATTR_WRAPPER(zpl_getattr);
 475
 476 static int
 477 #ifdef HAVE_USERNS_IOPS_SETATTR
 478 zpl_setattr(struct user_namespace *user_ns, struct dentry *dentry,
 479     struct iattr *ia)
 480 #elif defined(HAVE_IDMAP_IOPS_SETATTR)
 481 zpl_setattr(struct mnt_idmap *user_ns, struct dentry *dentry,
 482     struct iattr *ia)
 483 #else
 484 zpl_setattr(struct dentry *dentry, struct iattr *ia)
 485 #endif
 486 {
 487         struct inode *ip = dentry->d_inode;
 488         cred_t *cr = CRED();
 489         vattr_t *vap;
 490         int error;
 491         fstrans_cookie_t cookie;
 492
 493 #ifdef HAVE_SETATTR_PREPARE_USERNS
 494         error = zpl_setattr_prepare(user_ns, dentry, ia);
 495 #elif defined(HAVE_SETATTR_PREPARE_IDMAP)
 496         error = zpl_setattr_prepare(user_ns, dentry, ia);
 497 #else
 498         error = zpl_setattr_prepare(zfs_init_idmap, dentry, ia);
 499 #endif
 500         if (error)
 501                 return (error);
 502
 503         crhold(cr);
 504         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 505         vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK;
 506         vap->va_mode = ia->ia_mode;
 507         if (ia->ia_valid & ATTR_UID)
 508 #ifdef HAVE_IATTR_VFSID
 509                 vap->va_uid = zfs_vfsuid_to_uid(user_ns, zfs_i_user_ns(ip),
 510                     __vfsuid_val(ia->ia_vfsuid));
 511 #else
 512                 vap->va_uid = KUID_TO_SUID(ia->ia_uid);
 513 #endif
 514         if (ia->ia_valid & ATTR_GID)
 515 #ifdef HAVE_IATTR_VFSID
 516                 vap->va_gid = zfs_vfsgid_to_gid(user_ns, zfs_i_user_ns(ip),
 517                     __vfsgid_val(ia->ia_vfsgid));
 518 #else
 519                 vap->va_gid = KGID_TO_SGID(ia->ia_gid);
 520 #endif
 521         vap->va_size = ia->ia_size;
 522         vap->va_atime = ia->ia_atime;
 523         vap->va_mtime = ia->ia_mtime;
 524         vap->va_ctime = ia->ia_ctime;
 525
 526         if (vap->va_mask & ATTR_ATIME)
 527                 ip->i_atime = zpl_inode_timestamp_truncate(ia->ia_atime, ip);
 528
 529         cookie = spl_fstrans_mark();
 530 #ifdef HAVE_USERNS_IOPS_SETATTR
 531         error = -zfs_setattr(ITOZ(ip), vap, 0, cr, user_ns);
 532 #elif defined(HAVE_IDMAP_IOPS_SETATTR)
 533         error = -zfs_setattr(ITOZ(ip), vap, 0, cr, user_ns);
 534 #else
 535         error = -zfs_setattr(ITOZ(ip), vap, 0, cr, zfs_init_idmap);
 536 #endif
 537         if (!error && (ia->ia_valid & ATTR_MODE))
 538                 error = zpl_chmod_acl(ip);
 539
 540         spl_fstrans_unmark(cookie);
 541         kmem_free(vap, sizeof (vattr_t));
 542         crfree(cr);
 543         ASSERT3S(error, <=, 0);
 544
 545         return (error);
 546 }
 547
 548 static int
 549 #ifdef HAVE_IOPS_RENAME_USERNS
 550 zpl_rename2(struct user_namespace *user_ns, struct inode *sdip,
 551     struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
 552     unsigned int rflags)
 553 #elif defined(HAVE_IOPS_RENAME_IDMAP)
 554 zpl_rename2(struct mnt_idmap *user_ns, struct inode *sdip,
 555     struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
 556     unsigned int rflags)
 557 #else
 558 zpl_rename2(struct inode *sdip, struct dentry *sdentry,
 559     struct inode *tdip, struct dentry *tdentry, unsigned int rflags)
 560 #endif
 561 {
 562         cred_t *cr = CRED();
 563         vattr_t *wo_vap = NULL;
 564         int error;
 565         fstrans_cookie_t cookie;
 566 #if !(defined(HAVE_IOPS_RENAME_USERNS) || defined(HAVE_IOPS_RENAME_IDMAP))
 567         zidmap_t *user_ns = kcred->user_ns;
 568 #endif
 569
 570         crhold(cr);
 571         if (rflags & RENAME_WHITEOUT) {
 572                 wo_vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 573                 zpl_vap_init(wo_vap, sdip, S_IFCHR, cr, user_ns);
 574                 wo_vap->va_rdev = makedevice(0, 0);
 575         }
 576
 577         cookie = spl_fstrans_mark();
 578         error = -zfs_rename(ITOZ(sdip), dname(sdentry), ITOZ(tdip),
 579             dname(tdentry), cr, 0, rflags, wo_vap, user_ns);
 580         spl_fstrans_unmark(cookie);
 581         if (wo_vap)
 582                 kmem_free(wo_vap, sizeof (vattr_t));
 583         crfree(cr);
 584         ASSERT3S(error, <=, 0);
 585
 586         return (error);
 587 }
 588
 589 #if !defined(HAVE_IOPS_RENAME_USERNS) && \
 590         !defined(HAVE_RENAME_WANTS_FLAGS) && \
 591         !defined(HAVE_RENAME2) && \
 592         !defined(HAVE_IOPS_RENAME_IDMAP)
 593 static int
 594 zpl_rename(struct inode *sdip, struct dentry *sdentry,
 595     struct inode *tdip, struct dentry *tdentry)
 596 {
 597         return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0));
 598 }
 599 #endif
 600
 601 static int
 602 #ifdef HAVE_IOPS_SYMLINK_USERNS
 603 zpl_symlink(struct user_namespace *user_ns, struct inode *dir,
 604     struct dentry *dentry, const char *name)
 605 #elif defined(HAVE_IOPS_SYMLINK_IDMAP)
 606 zpl_symlink(struct mnt_idmap *user_ns, struct inode *dir,
 607     struct dentry *dentry, const char *name)
 608 #else
 609 zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
 610 #endif
 611 {
 612         cred_t *cr = CRED();
 613         vattr_t *vap;
 614         znode_t *zp;
 615         int error;
 616         fstrans_cookie_t cookie;
 617 #if !(defined(HAVE_IOPS_SYMLINK_USERNS) || defined(HAVE_IOPS_SYMLINK_IDMAP))
 618         zidmap_t *user_ns = kcred->user_ns;
 619 #endif
 620
 621         crhold(cr);
 622         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 623         zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr, user_ns);
 624
 625         cookie = spl_fstrans_mark();
 626         error = -zfs_symlink(ITOZ(dir), dname(dentry), vap,
 627             (char *)name, &zp, cr, 0, user_ns);
 628         if (error == 0) {
 629                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 630                 if (error) {
 631                         (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 632                         remove_inode_hash(ZTOI(zp));
 633                         iput(ZTOI(zp));
 634                 } else {
 635                         d_instantiate(dentry, ZTOI(zp));
 636                 }
 637         }
 638
 639         spl_fstrans_unmark(cookie);
 640         kmem_free(vap, sizeof (vattr_t));
 641         crfree(cr);
 642         ASSERT3S(error, <=, 0);
 643
 644         return (error);
 645 }
 646
 647 #if defined(HAVE_PUT_LINK_COOKIE)
 648 static void
 649 zpl_put_link(struct inode *unused, void *cookie)
 650 {
 651         kmem_free(cookie, MAXPATHLEN);
 652 }
 653 #elif defined(HAVE_PUT_LINK_NAMEIDATA)
 654 static void
 655 zpl_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
 656 {
 657         const char *link = nd_get_link(nd);
 658
 659         if (!IS_ERR(link))
 660                 kmem_free(link, MAXPATHLEN);
 661 }
 662 #elif defined(HAVE_PUT_LINK_DELAYED)
 663 static void
 664 zpl_put_link(void *ptr)
 665 {
 666         kmem_free(ptr, MAXPATHLEN);
 667 }
 668 #endif
 669
 670 static int
 671 zpl_get_link_common(struct dentry *dentry, struct inode *ip, char **link)
 672 {
 673         fstrans_cookie_t cookie;
 674         cred_t *cr = CRED();
 675         int error;
 676
 677         crhold(cr);
 678         *link = NULL;
 679
 680         struct iovec iov;
 681         iov.iov_len = MAXPATHLEN;
 682         iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 683
 684         zfs_uio_t uio;
 685         zfs_uio_iovec_init(&uio, &iov, 1, 0, UIO_SYSSPACE, MAXPATHLEN - 1, 0);
 686
 687         cookie = spl_fstrans_mark();
 688         error = -zfs_readlink(ip, &uio, cr);
 689         spl_fstrans_unmark(cookie);
 690         crfree(cr);
 691
 692         if (error)
 693                 kmem_free(iov.iov_base, MAXPATHLEN);
 694         else
 695                 *link = iov.iov_base;
 696
 697         return (error);
 698 }
 699
 700 #if defined(HAVE_GET_LINK_DELAYED)
 701 static const char *
 702 zpl_get_link(struct dentry *dentry, struct inode *inode,
 703     struct delayed_call *done)
 704 {
 705         char *link = NULL;
 706         int error;
 707
 708         if (!dentry)
 709                 return (ERR_PTR(-ECHILD));
 710
 711         error = zpl_get_link_common(dentry, inode, &link);
 712         if (error)
 713                 return (ERR_PTR(error));
 714
 715         set_delayed_call(done, zpl_put_link, link);
 716
 717         return (link);
 718 }
 719 #elif defined(HAVE_GET_LINK_COOKIE)
 720 static const char *
 721 zpl_get_link(struct dentry *dentry, struct inode *inode, void **cookie)
 722 {
 723         char *link = NULL;
 724         int error;
 725
 726         if (!dentry)
 727                 return (ERR_PTR(-ECHILD));
 728
 729         error = zpl_get_link_common(dentry, inode, &link);
 730         if (error)
 731                 return (ERR_PTR(error));
 732
 733         return (*cookie = link);
 734 }
 735 #elif defined(HAVE_FOLLOW_LINK_COOKIE)
 736 static const char *
 737 zpl_follow_link(struct dentry *dentry, void **cookie)
 738 {
 739         char *link = NULL;
 740         int error;
 741
 742         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 743         if (error)
 744                 return (ERR_PTR(error));
 745
 746         return (*cookie = link);
 747 }
 748 #elif defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 749 static void *
 750 zpl_follow_link(struct dentry *dentry, struct nameidata *nd)
 751 {
 752         char *link = NULL;
 753         int error;
 754
 755         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 756         if (error)
 757                 nd_set_link(nd, ERR_PTR(error));
 758         else
 759                 nd_set_link(nd, link);
 760
 761         return (NULL);
 762 }
 763 #endif
 764
 765 static int
 766 zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 767 {
 768         cred_t *cr = CRED();
 769         struct inode *ip = old_dentry->d_inode;
 770         int error;
 771         fstrans_cookie_t cookie;
 772
 773         if (ip->i_nlink >= ZFS_LINK_MAX)
 774                 return (-EMLINK);
 775
 776         crhold(cr);
 777         zpl_inode_set_ctime_to_ts(ip, current_time(ip));
 778         /* Must have an existing ref, so igrab() cannot return NULL */
 779         VERIFY3P(igrab(ip), !=, NULL);
 780
 781         cookie = spl_fstrans_mark();
 782         error = -zfs_link(ITOZ(dir), ITOZ(ip), dname(dentry), cr, 0);
 783         if (error) {
 784                 iput(ip);
 785                 goto out;
 786         }
 787
 788         d_instantiate(dentry, ip);
 789 out:
 790         spl_fstrans_unmark(cookie);
 791         crfree(cr);
 792         ASSERT3S(error, <=, 0);
 793
 794         return (error);
 795 }
 796
 797 const struct inode_operations zpl_inode_operations = {
 798         .setattr        = zpl_setattr,
 799         .getattr        = zpl_getattr,
 800 #ifdef HAVE_GENERIC_SETXATTR
 801         .setxattr       = generic_setxattr,
 802         .getxattr       = generic_getxattr,
 803         .removexattr    = generic_removexattr,
 804 #endif
 805         .listxattr      = zpl_xattr_list,
 806 #if defined(CONFIG_FS_POSIX_ACL)
 807 #if defined(HAVE_SET_ACL)
 808         .set_acl        = zpl_set_acl,
 809 #endif /* HAVE_SET_ACL */
 810 #if defined(HAVE_GET_INODE_ACL)
 811         .get_inode_acl  = zpl_get_acl,
 812 #else
 813         .get_acl        = zpl_get_acl,
 814 #endif /* HAVE_GET_INODE_ACL */
 815 #endif /* CONFIG_FS_POSIX_ACL */
 816 };
 817
 818 #ifdef HAVE_RENAME2_OPERATIONS_WRAPPER
 819 const struct inode_operations_wrapper zpl_dir_inode_operations = {
 820         .ops = {
 821 #else
 822 const struct inode_operations zpl_dir_inode_operations = {
 823 #endif
 824         .create         = zpl_create,
 825         .lookup         = zpl_lookup,
 826         .link           = zpl_link,
 827         .unlink         = zpl_unlink,
 828         .symlink        = zpl_symlink,
 829         .mkdir          = zpl_mkdir,
 830         .rmdir          = zpl_rmdir,
 831         .mknod          = zpl_mknod,
 832 #ifdef HAVE_RENAME2
 833         .rename2        = zpl_rename2,
 834 #elif defined(HAVE_RENAME_WANTS_FLAGS) || defined(HAVE_IOPS_RENAME_USERNS)
 835         .rename         = zpl_rename2,
 836 #elif defined(HAVE_IOPS_RENAME_IDMAP)
 837         .rename         = zpl_rename2,
 838 #else
 839         .rename         = zpl_rename,
 840 #endif
 841 #ifdef HAVE_TMPFILE
 842         .tmpfile        = zpl_tmpfile,
 843 #endif
 844         .setattr        = zpl_setattr,
 845         .getattr        = zpl_getattr,
 846 #ifdef HAVE_GENERIC_SETXATTR
 847         .setxattr       = generic_setxattr,
 848         .getxattr       = generic_getxattr,
 849         .removexattr    = generic_removexattr,
 850 #endif
 851         .listxattr      = zpl_xattr_list,
 852 #if defined(CONFIG_FS_POSIX_ACL)
 853 #if defined(HAVE_SET_ACL)
 854         .set_acl        = zpl_set_acl,
 855 #endif /* HAVE_SET_ACL */
 856 #if defined(HAVE_GET_INODE_ACL)
 857         .get_inode_acl  = zpl_get_acl,
 858 #else
 859         .get_acl        = zpl_get_acl,
 860 #endif /* HAVE_GET_INODE_ACL */
 861 #endif /* CONFIG_FS_POSIX_ACL */
 862 #ifdef HAVE_RENAME2_OPERATIONS_WRAPPER
 863         },
 864         .rename2        = zpl_rename2,
 865 #endif
 866 };
 867
 868 const struct inode_operations zpl_symlink_inode_operations = {
 869 #ifdef HAVE_GENERIC_READLINK
 870         .readlink       = generic_readlink,
 871 #endif
 872 #if defined(HAVE_GET_LINK_DELAYED) || defined(HAVE_GET_LINK_COOKIE)
 873         .get_link       = zpl_get_link,
 874 #elif defined(HAVE_FOLLOW_LINK_COOKIE) || defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 875         .follow_link    = zpl_follow_link,
 876 #endif
 877 #if defined(HAVE_PUT_LINK_COOKIE) || defined(HAVE_PUT_LINK_NAMEIDATA)
 878         .put_link       = zpl_put_link,
 879 #endif
 880         .setattr        = zpl_setattr,
 881         .getattr        = zpl_getattr,
 882 #ifdef HAVE_GENERIC_SETXATTR
 883         .setxattr       = generic_setxattr,
 884         .getxattr       = generic_getxattr,
 885         .removexattr    = generic_removexattr,
 886 #endif
 887         .listxattr      = zpl_xattr_list,
 888 };
 889
 890 const struct inode_operations zpl_special_inode_operations = {
 891         .setattr        = zpl_setattr,
 892         .getattr        = zpl_getattr,
 893 #ifdef HAVE_GENERIC_SETXATTR
 894         .setxattr       = generic_setxattr,
 895         .getxattr       = generic_getxattr,
 896         .removexattr    = generic_removexattr,
 897 #endif
 898         .listxattr      = zpl_xattr_list,
 899 #if defined(CONFIG_FS_POSIX_ACL)
 900 #if defined(HAVE_SET_ACL)
 901         .set_acl        = zpl_set_acl,
 902 #endif /* HAVE_SET_ACL */
 903 #if defined(HAVE_GET_INODE_ACL)
 904         .get_inode_acl  = zpl_get_acl,
 905 #else
 906         .get_acl        = zpl_get_acl,
 907 #endif /* HAVE_GET_INODE_ACL */
 908 #endif /* CONFIG_FS_POSIX_ACL */
 909 };