module/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 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  * Copyright (c) 2011, Lawrence Livermore National Security, LLC.
  23  * Copyright (c) 2015 by Chunwei Chen. All rights reserved.
  24  */
  25
  26
  27 #include <sys/zfs_ctldir.h>
  28 #include <sys/zfs_vfsops.h>
  29 #include <sys/zfs_vnops.h>
  30 #include <sys/zfs_znode.h>
  31 #include <sys/dmu_objset.h>
  32 #include <sys/vfs.h>
  33 #include <sys/zpl.h>
  34 #include <sys/file.h>
  35
  36
  37 static struct dentry *
  38 #ifdef HAVE_LOOKUP_NAMEIDATA
  39 zpl_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
  40 #else
  41 zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
  42 #endif
  43 {
  44         cred_t *cr = CRED();
  45         struct inode *ip;
  46         int error;
  47         fstrans_cookie_t cookie;
  48         pathname_t *ppn = NULL;
  49         pathname_t pn;
  50         int zfs_flags = 0;
  51         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
  52
  53         if (dlen(dentry) >= ZAP_MAXNAMELEN)
  54                 return (ERR_PTR(-ENAMETOOLONG));
  55
  56         crhold(cr);
  57         cookie = spl_fstrans_mark();
  58
  59         /* If we are a case insensitive fs, we need the real name */
  60         if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
  61                 zfs_flags = FIGNORECASE;
  62                 pn_alloc(&pn);
  63                 ppn = &pn;
  64         }
  65
  66         error = -zfs_lookup(dir, dname(dentry), &ip, zfs_flags, cr, NULL, ppn);
  67         spl_fstrans_unmark(cookie);
  68         ASSERT3S(error, <=, 0);
  69         crfree(cr);
  70
  71         spin_lock(&dentry->d_lock);
  72         dentry->d_time = jiffies;
  73 #ifndef HAVE_S_D_OP
  74         d_set_d_op(dentry, &zpl_dentry_operations);
  75 #endif /* HAVE_S_D_OP */
  76         spin_unlock(&dentry->d_lock);
  77
  78         if (error) {
  79                 /*
  80                  * If we have a case sensitive fs, we do not want to
  81                  * insert negative entries, so return NULL for ENOENT.
  82                  * Fall through if the error is not ENOENT. Also free memory.
  83                  */
  84                 if (ppn) {
  85                         pn_free(ppn);
  86                         if (error == -ENOENT)
  87                                 return (NULL);
  88                 }
  89
  90                 if (error == -ENOENT)
  91                         return (d_splice_alias(NULL, dentry));
  92                 else
  93                         return (ERR_PTR(error));
  94         }
  95
  96         /*
  97          * If we are case insensitive, call the correct function
  98          * to install the name.
  99          */
 100         if (ppn) {
 101                 struct dentry *new_dentry;
 102                 struct qstr ci_name;
 103
 104                 if (strcmp(dname(dentry), pn.pn_buf) == 0) {
 105                         new_dentry = d_splice_alias(ip,  dentry);
 106                 } else {
 107                         ci_name.name = pn.pn_buf;
 108                         ci_name.len = strlen(pn.pn_buf);
 109                         new_dentry = d_add_ci(dentry, ip, &ci_name);
 110                 }
 111                 pn_free(ppn);
 112                 return (new_dentry);
 113         } else {
 114                 return (d_splice_alias(ip, dentry));
 115         }
 116 }
 117
 118 void
 119 zpl_vap_init(vattr_t *vap, struct inode *dir, zpl_umode_t mode, cred_t *cr)
 120 {
 121         vap->va_mask = ATTR_MODE;
 122         vap->va_mode = mode;
 123         vap->va_uid = crgetfsuid(cr);
 124
 125         if (dir && dir->i_mode & S_ISGID) {
 126                 vap->va_gid = KGID_TO_SGID(dir->i_gid);
 127                 if (S_ISDIR(mode))
 128                         vap->va_mode |= S_ISGID;
 129         } else {
 130                 vap->va_gid = crgetfsgid(cr);
 131         }
 132 }
 133
 134 static int
 135 #ifdef HAVE_CREATE_NAMEIDATA
 136 zpl_create(struct inode *dir, struct dentry *dentry, zpl_umode_t mode,
 137     struct nameidata *nd)
 138 #else
 139 zpl_create(struct inode *dir, struct dentry *dentry, zpl_umode_t mode,
 140     bool flag)
 141 #endif
 142 {
 143         cred_t *cr = CRED();
 144         struct inode *ip;
 145         vattr_t *vap;
 146         int error;
 147         fstrans_cookie_t cookie;
 148
 149         crhold(cr);
 150         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 151         zpl_vap_init(vap, dir, mode, cr);
 152
 153         cookie = spl_fstrans_mark();
 154         error = -zfs_create(dir, dname(dentry), vap, 0, mode, &ip, cr, 0, NULL);
 155         if (error == 0) {
 156                 d_instantiate(dentry, ip);
 157
 158                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 159                 if (error == 0)
 160                         error = zpl_init_acl(ip, dir);
 161
 162                 if (error)
 163                         (void) zfs_remove(dir, dname(dentry), cr, 0);
 164         }
 165
 166         spl_fstrans_unmark(cookie);
 167         kmem_free(vap, sizeof (vattr_t));
 168         crfree(cr);
 169         ASSERT3S(error, <=, 0);
 170
 171         return (error);
 172 }
 173
 174 static int
 175 zpl_mknod(struct inode *dir, struct dentry *dentry, zpl_umode_t mode,
 176     dev_t rdev)
 177 {
 178         cred_t *cr = CRED();
 179         struct inode *ip;
 180         vattr_t *vap;
 181         int error;
 182         fstrans_cookie_t cookie;
 183
 184         /*
 185          * We currently expect Linux to supply rdev=0 for all sockets
 186          * and fifos, but we want to know if this behavior ever changes.
 187          */
 188         if (S_ISSOCK(mode) || S_ISFIFO(mode))
 189                 ASSERT(rdev == 0);
 190
 191         crhold(cr);
 192         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 193         zpl_vap_init(vap, dir, mode, cr);
 194         vap->va_rdev = rdev;
 195
 196         cookie = spl_fstrans_mark();
 197         error = -zfs_create(dir, dname(dentry), vap, 0, mode, &ip, cr, 0, NULL);
 198         if (error == 0) {
 199                 d_instantiate(dentry, ip);
 200
 201                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 202                 if (error == 0)
 203                         error = zpl_init_acl(ip, dir);
 204
 205                 if (error)
 206                         (void) zfs_remove(dir, dname(dentry), cr, 0);
 207         }
 208
 209         spl_fstrans_unmark(cookie);
 210         kmem_free(vap, sizeof (vattr_t));
 211         crfree(cr);
 212         ASSERT3S(error, <=, 0);
 213
 214         return (error);
 215 }
 216
 217 #ifdef HAVE_TMPFILE
 218 static int
 219 zpl_tmpfile(struct inode *dir, struct dentry *dentry, zpl_umode_t mode)
 220 {
 221         cred_t *cr = CRED();
 222         struct inode *ip;
 223         vattr_t *vap;
 224         int error;
 225         fstrans_cookie_t cookie;
 226
 227         crhold(cr);
 228         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 229         zpl_vap_init(vap, dir, mode, cr);
 230
 231         cookie = spl_fstrans_mark();
 232         error = -zfs_tmpfile(dir, vap, 0, mode, &ip, cr, 0, NULL);
 233         if (error == 0) {
 234                 /* d_tmpfile will do drop_nlink, so we should set it first */
 235                 set_nlink(ip, 1);
 236                 d_tmpfile(dentry, ip);
 237
 238                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 239                 if (error == 0)
 240                         error = zpl_init_acl(ip, dir);
 241                 /*
 242                  * don't need to handle error here, file is already in
 243                  * unlinked set.
 244                  */
 245         }
 246
 247         spl_fstrans_unmark(cookie);
 248         kmem_free(vap, sizeof (vattr_t));
 249         crfree(cr);
 250         ASSERT3S(error, <=, 0);
 251
 252         return (error);
 253 }
 254 #endif
 255
 256 static int
 257 zpl_unlink(struct inode *dir, struct dentry *dentry)
 258 {
 259         cred_t *cr = CRED();
 260         int error;
 261         fstrans_cookie_t cookie;
 262         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 263
 264         crhold(cr);
 265         cookie = spl_fstrans_mark();
 266         error = -zfs_remove(dir, dname(dentry), cr, 0);
 267
 268         /*
 269          * For a CI FS we must invalidate the dentry to prevent the
 270          * creation of negative entries.
 271          */
 272         if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
 273                 d_invalidate(dentry);
 274
 275         spl_fstrans_unmark(cookie);
 276         crfree(cr);
 277         ASSERT3S(error, <=, 0);
 278
 279         return (error);
 280 }
 281
 282 static int
 283 zpl_mkdir(struct inode *dir, struct dentry *dentry, zpl_umode_t mode)
 284 {
 285         cred_t *cr = CRED();
 286         vattr_t *vap;
 287         struct inode *ip;
 288         int error;
 289         fstrans_cookie_t cookie;
 290
 291         crhold(cr);
 292         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 293         zpl_vap_init(vap, dir, mode | S_IFDIR, cr);
 294
 295         cookie = spl_fstrans_mark();
 296         error = -zfs_mkdir(dir, dname(dentry), vap, &ip, cr, 0, NULL);
 297         if (error == 0) {
 298                 d_instantiate(dentry, ip);
 299
 300                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 301                 if (error == 0)
 302                         error = zpl_init_acl(ip, dir);
 303
 304                 if (error)
 305                         (void) zfs_rmdir(dir, dname(dentry), NULL, cr, 0);
 306         }
 307
 308         spl_fstrans_unmark(cookie);
 309         kmem_free(vap, sizeof (vattr_t));
 310         crfree(cr);
 311         ASSERT3S(error, <=, 0);
 312
 313         return (error);
 314 }
 315
 316 static int
 317 zpl_rmdir(struct inode *dir, struct dentry *dentry)
 318 {
 319         cred_t *cr = CRED();
 320         int error;
 321         fstrans_cookie_t cookie;
 322         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 323
 324         crhold(cr);
 325         cookie = spl_fstrans_mark();
 326         error = -zfs_rmdir(dir, dname(dentry), NULL, cr, 0);
 327
 328         /*
 329          * For a CI FS we must invalidate the dentry to prevent the
 330          * creation of negative entries.
 331          */
 332         if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
 333                 d_invalidate(dentry);
 334
 335         spl_fstrans_unmark(cookie);
 336         crfree(cr);
 337         ASSERT3S(error, <=, 0);
 338
 339         return (error);
 340 }
 341
 342 static int
 343 zpl_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 344 {
 345         int error;
 346         fstrans_cookie_t cookie;
 347
 348         cookie = spl_fstrans_mark();
 349         error = -zfs_getattr_fast(dentry->d_inode, stat);
 350         spl_fstrans_unmark(cookie);
 351         ASSERT3S(error, <=, 0);
 352
 353         return (error);
 354 }
 355
 356 static int
 357 zpl_setattr(struct dentry *dentry, struct iattr *ia)
 358 {
 359         struct inode *ip = dentry->d_inode;
 360         cred_t *cr = CRED();
 361         vattr_t *vap;
 362         int error;
 363         fstrans_cookie_t cookie;
 364
 365         error = setattr_prepare(dentry, ia);
 366         if (error)
 367                 return (error);
 368
 369         crhold(cr);
 370         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 371         vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK;
 372         vap->va_mode = ia->ia_mode;
 373         vap->va_uid = KUID_TO_SUID(ia->ia_uid);
 374         vap->va_gid = KGID_TO_SGID(ia->ia_gid);
 375         vap->va_size = ia->ia_size;
 376         vap->va_atime = ia->ia_atime;
 377         vap->va_mtime = ia->ia_mtime;
 378         vap->va_ctime = ia->ia_ctime;
 379
 380         if (vap->va_mask & ATTR_ATIME)
 381                 ip->i_atime = timespec_trunc(ia->ia_atime,
 382                     ip->i_sb->s_time_gran);
 383
 384         cookie = spl_fstrans_mark();
 385         error = -zfs_setattr(ip, vap, 0, cr);
 386         if (!error && (ia->ia_valid & ATTR_MODE))
 387                 error = zpl_chmod_acl(ip);
 388
 389         spl_fstrans_unmark(cookie);
 390         kmem_free(vap, sizeof (vattr_t));
 391         crfree(cr);
 392         ASSERT3S(error, <=, 0);
 393
 394         return (error);
 395 }
 396
 397 static int
 398 zpl_rename2(struct inode *sdip, struct dentry *sdentry,
 399     struct inode *tdip, struct dentry *tdentry, unsigned int flags)
 400 {
 401         cred_t *cr = CRED();
 402         int error;
 403         fstrans_cookie_t cookie;
 404
 405         /* We don't have renameat2(2) support */
 406         if (flags)
 407                 return (-EINVAL);
 408
 409         crhold(cr);
 410         cookie = spl_fstrans_mark();
 411         error = -zfs_rename(sdip, dname(sdentry), tdip, dname(tdentry), cr, 0);
 412         spl_fstrans_unmark(cookie);
 413         crfree(cr);
 414         ASSERT3S(error, <=, 0);
 415
 416         return (error);
 417 }
 418
 419 #ifndef HAVE_RENAME_WANTS_FLAGS
 420 static int
 421 zpl_rename(struct inode *sdip, struct dentry *sdentry,
 422     struct inode *tdip, struct dentry *tdentry)
 423 {
 424         return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0));
 425 }
 426 #endif
 427
 428 static int
 429 zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
 430 {
 431         cred_t *cr = CRED();
 432         vattr_t *vap;
 433         struct inode *ip;
 434         int error;
 435         fstrans_cookie_t cookie;
 436
 437         crhold(cr);
 438         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 439         zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr);
 440
 441         cookie = spl_fstrans_mark();
 442         error = -zfs_symlink(dir, dname(dentry), vap, (char *)name, &ip, cr, 0);
 443         if (error == 0) {
 444                 d_instantiate(dentry, ip);
 445
 446                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 447                 if (error)
 448                         (void) zfs_remove(dir, dname(dentry), cr, 0);
 449         }
 450
 451         spl_fstrans_unmark(cookie);
 452         kmem_free(vap, sizeof (vattr_t));
 453         crfree(cr);
 454         ASSERT3S(error, <=, 0);
 455
 456         return (error);
 457 }
 458
 459 #if defined(HAVE_PUT_LINK_COOKIE)
 460 static void
 461 zpl_put_link(struct inode *unused, void *cookie)
 462 {
 463         kmem_free(cookie, MAXPATHLEN);
 464 }
 465 #elif defined(HAVE_PUT_LINK_NAMEIDATA)
 466 static void
 467 zpl_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
 468 {
 469         const char *link = nd_get_link(nd);
 470
 471         if (!IS_ERR(link))
 472                 kmem_free(link, MAXPATHLEN);
 473 }
 474 #elif defined(HAVE_PUT_LINK_DELAYED)
 475 static void
 476 zpl_put_link(void *ptr)
 477 {
 478         kmem_free(ptr, MAXPATHLEN);
 479 }
 480 #endif
 481
 482 static int
 483 zpl_get_link_common(struct dentry *dentry, struct inode *ip, char **link)
 484 {
 485         fstrans_cookie_t cookie;
 486         cred_t *cr = CRED();
 487         struct iovec iov;
 488         uio_t uio;
 489         int error;
 490
 491         crhold(cr);
 492         *link = NULL;
 493         iov.iov_len = MAXPATHLEN;
 494         iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 495
 496         uio.uio_iov = &iov;
 497         uio.uio_iovcnt = 1;
 498         uio.uio_skip = 0;
 499         uio.uio_resid = (MAXPATHLEN - 1);
 500         uio.uio_segflg = UIO_SYSSPACE;
 501
 502         cookie = spl_fstrans_mark();
 503         error = -zfs_readlink(ip, &uio, cr);
 504         spl_fstrans_unmark(cookie);
 505         crfree(cr);
 506
 507         if (error)
 508                 kmem_free(iov.iov_base, MAXPATHLEN);
 509         else
 510                 *link = iov.iov_base;
 511
 512         return (error);
 513 }
 514
 515 #if defined(HAVE_GET_LINK_DELAYED)
 516 const char *
 517 zpl_get_link(struct dentry *dentry, struct inode *inode,
 518     struct delayed_call *done)
 519 {
 520         char *link = NULL;
 521         int error;
 522
 523         if (!dentry)
 524                 return (ERR_PTR(-ECHILD));
 525
 526         error = zpl_get_link_common(dentry, inode, &link);
 527         if (error)
 528                 return (ERR_PTR(error));
 529
 530         set_delayed_call(done, zpl_put_link, link);
 531
 532         return (link);
 533 }
 534 #elif defined(HAVE_GET_LINK_COOKIE)
 535 const char *
 536 zpl_get_link(struct dentry *dentry, struct inode *inode, void **cookie)
 537 {
 538         char *link = NULL;
 539         int error;
 540
 541         if (!dentry)
 542                 return (ERR_PTR(-ECHILD));
 543
 544         error = zpl_get_link_common(dentry, inode, &link);
 545         if (error)
 546                 return (ERR_PTR(error));
 547
 548         return (*cookie = link);
 549 }
 550 #elif defined(HAVE_FOLLOW_LINK_COOKIE)
 551 const char *
 552 zpl_follow_link(struct dentry *dentry, void **cookie)
 553 {
 554         char *link = NULL;
 555         int error;
 556
 557         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 558         if (error)
 559                 return (ERR_PTR(error));
 560
 561         return (*cookie = link);
 562 }
 563 #elif defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 564 static void *
 565 zpl_follow_link(struct dentry *dentry, struct nameidata *nd)
 566 {
 567         char *link = NULL;
 568         int error;
 569
 570         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 571         if (error)
 572                 nd_set_link(nd, ERR_PTR(error));
 573         else
 574                 nd_set_link(nd, link);
 575
 576         return (NULL);
 577 }
 578 #endif
 579
 580 static int
 581 zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 582 {
 583         cred_t *cr = CRED();
 584         struct inode *ip = old_dentry->d_inode;
 585         int error;
 586         fstrans_cookie_t cookie;
 587
 588         if (ip->i_nlink >= ZFS_LINK_MAX)
 589                 return (-EMLINK);
 590
 591         crhold(cr);
 592         ip->i_ctime = CURRENT_TIME_SEC;
 593         igrab(ip); /* Use ihold() if available */
 594
 595         cookie = spl_fstrans_mark();
 596         error = -zfs_link(dir, ip, dname(dentry), cr, 0);
 597         if (error) {
 598                 iput(ip);
 599                 goto out;
 600         }
 601
 602         d_instantiate(dentry, ip);
 603 out:
 604         spl_fstrans_unmark(cookie);
 605         crfree(cr);
 606         ASSERT3S(error, <=, 0);
 607
 608         return (error);
 609 }
 610
 611 #ifdef HAVE_INODE_TRUNCATE_RANGE
 612 static void
 613 zpl_truncate_range(struct inode *ip, loff_t start, loff_t end)
 614 {
 615         cred_t *cr = CRED();
 616         flock64_t bf;
 617         fstrans_cookie_t cookie;
 618
 619         ASSERT3S(start, <=, end);
 620
 621         /*
 622          * zfs_freesp() will interpret (len == 0) as meaning "truncate until
 623          * the end of the file". We don't want that.
 624          */
 625         if (start == end)
 626                 return;
 627
 628         crhold(cr);
 629
 630         bf.l_type = F_WRLCK;
 631         bf.l_whence = 0;
 632         bf.l_start = start;
 633         bf.l_len = end - start;
 634         bf.l_pid = 0;
 635         cookie = spl_fstrans_mark();
 636         zfs_space(ip, F_FREESP, &bf, FWRITE, start, cr);
 637         spl_fstrans_unmark(cookie);
 638
 639         crfree(cr);
 640 }
 641 #endif /* HAVE_INODE_TRUNCATE_RANGE */
 642
 643 #ifdef HAVE_INODE_FALLOCATE
 644 static long
 645 zpl_fallocate(struct inode *ip, int mode, loff_t offset, loff_t len)
 646 {
 647         return (zpl_fallocate_common(ip, mode, offset, len));
 648 }
 649 #endif /* HAVE_INODE_FALLOCATE */
 650
 651 static int
 652 #ifdef HAVE_D_REVALIDATE_NAMEIDATA
 653 zpl_revalidate(struct dentry *dentry, struct nameidata *nd)
 654 {
 655         unsigned int flags = (nd ? nd->flags : 0);
 656 #else
 657 zpl_revalidate(struct dentry *dentry, unsigned int flags)
 658 {
 659 #endif /* HAVE_D_REVALIDATE_NAMEIDATA */
 660         /* CSTYLED */
 661         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 662         int error;
 663
 664         if (flags & LOOKUP_RCU)
 665                 return (-ECHILD);
 666
 667         /*
 668          * Automounted snapshots rely on periodic dentry revalidation
 669          * to defer snapshots from being automatically unmounted.
 670          */
 671         if (zfsvfs->z_issnap) {
 672                 if (time_after(jiffies, zfsvfs->z_snap_defer_time +
 673                     MAX(zfs_expire_snapshot * HZ / 2, HZ))) {
 674                         zfsvfs->z_snap_defer_time = jiffies;
 675                         zfsctl_snapshot_unmount_delay(zfsvfs->z_os->os_spa,
 676                             dmu_objset_id(zfsvfs->z_os), zfs_expire_snapshot);
 677                 }
 678         }
 679
 680         /*
 681          * After a rollback negative dentries created before the rollback
 682          * time must be invalidated.  Otherwise they can obscure files which
 683          * are only present in the rolled back dataset.
 684          */
 685         if (dentry->d_inode == NULL) {
 686                 spin_lock(&dentry->d_lock);
 687                 error = time_before(dentry->d_time, zfsvfs->z_rollback_time);
 688                 spin_unlock(&dentry->d_lock);
 689
 690                 if (error)
 691                         return (0);
 692         }
 693
 694         /*
 695          * The dentry may reference a stale inode if a mounted file system
 696          * was rolled back to a point in time where the object didn't exist.
 697          */
 698         if (dentry->d_inode && ITOZ(dentry->d_inode)->z_is_stale)
 699                 return (0);
 700
 701         return (1);
 702 }
 703
 704 const struct inode_operations zpl_inode_operations = {
 705         .setattr        = zpl_setattr,
 706         .getattr        = zpl_getattr,
 707 #ifdef HAVE_GENERIC_SETXATTR
 708         .setxattr       = generic_setxattr,
 709         .getxattr       = generic_getxattr,
 710         .removexattr    = generic_removexattr,
 711 #endif
 712         .listxattr      = zpl_xattr_list,
 713 #ifdef HAVE_INODE_TRUNCATE_RANGE
 714         .truncate_range = zpl_truncate_range,
 715 #endif /* HAVE_INODE_TRUNCATE_RANGE */
 716 #ifdef HAVE_INODE_FALLOCATE
 717         .fallocate      = zpl_fallocate,
 718 #endif /* HAVE_INODE_FALLOCATE */
 719 #if defined(CONFIG_FS_POSIX_ACL)
 720 #if defined(HAVE_SET_ACL)
 721         .set_acl        = zpl_set_acl,
 722 #endif
 723 #if defined(HAVE_GET_ACL)
 724         .get_acl        = zpl_get_acl,
 725 #elif defined(HAVE_CHECK_ACL)
 726         .check_acl      = zpl_check_acl,
 727 #elif defined(HAVE_PERMISSION)
 728         .permission     = zpl_permission,
 729 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
 730 #endif /* CONFIG_FS_POSIX_ACL */
 731 };
 732
 733 const struct inode_operations zpl_dir_inode_operations = {
 734         .create         = zpl_create,
 735         .lookup         = zpl_lookup,
 736         .link           = zpl_link,
 737         .unlink         = zpl_unlink,
 738         .symlink        = zpl_symlink,
 739         .mkdir          = zpl_mkdir,
 740         .rmdir          = zpl_rmdir,
 741         .mknod          = zpl_mknod,
 742 #ifdef HAVE_RENAME_WANTS_FLAGS
 743         .rename         = zpl_rename2,
 744 #else
 745         .rename         = zpl_rename,
 746 #endif
 747 #ifdef HAVE_TMPFILE
 748         .tmpfile        = zpl_tmpfile,
 749 #endif
 750         .setattr        = zpl_setattr,
 751         .getattr        = zpl_getattr,
 752 #ifdef HAVE_GENERIC_SETXATTR
 753         .setxattr       = generic_setxattr,
 754         .getxattr       = generic_getxattr,
 755         .removexattr    = generic_removexattr,
 756 #endif
 757         .listxattr      = zpl_xattr_list,
 758 #if defined(CONFIG_FS_POSIX_ACL)
 759 #if defined(HAVE_SET_ACL)
 760         .set_acl        = zpl_set_acl,
 761 #endif
 762 #if defined(HAVE_GET_ACL)
 763         .get_acl        = zpl_get_acl,
 764 #elif defined(HAVE_CHECK_ACL)
 765         .check_acl      = zpl_check_acl,
 766 #elif defined(HAVE_PERMISSION)
 767         .permission     = zpl_permission,
 768 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
 769 #endif /* CONFIG_FS_POSIX_ACL */
 770 };
 771
 772 const struct inode_operations zpl_symlink_inode_operations = {
 773 #ifdef HAVE_GENERIC_READLINK
 774         .readlink       = generic_readlink,
 775 #endif
 776 #if defined(HAVE_GET_LINK_DELAYED) || defined(HAVE_GET_LINK_COOKIE)
 777         .get_link       = zpl_get_link,
 778 #elif defined(HAVE_FOLLOW_LINK_COOKIE) || defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 779         .follow_link    = zpl_follow_link,
 780 #endif
 781 #if defined(HAVE_PUT_LINK_COOKIE) || defined(HAVE_PUT_LINK_NAMEIDATA)
 782         .put_link       = zpl_put_link,
 783 #endif
 784         .setattr        = zpl_setattr,
 785         .getattr        = zpl_getattr,
 786 #ifdef HAVE_GENERIC_SETXATTR
 787         .setxattr       = generic_setxattr,
 788         .getxattr       = generic_getxattr,
 789         .removexattr    = generic_removexattr,
 790 #endif
 791         .listxattr      = zpl_xattr_list,
 792 };
 793
 794 const struct inode_operations zpl_special_inode_operations = {
 795         .setattr        = zpl_setattr,
 796         .getattr        = zpl_getattr,
 797 #ifdef HAVE_GENERIC_SETXATTR
 798         .setxattr       = generic_setxattr,
 799         .getxattr       = generic_getxattr,
 800         .removexattr    = generic_removexattr,
 801 #endif
 802         .listxattr      = zpl_xattr_list,
 803 #if defined(CONFIG_FS_POSIX_ACL)
 804 #if defined(HAVE_SET_ACL)
 805         .set_acl        = zpl_set_acl,
 806 #endif
 807 #if defined(HAVE_GET_ACL)
 808         .get_acl        = zpl_get_acl,
 809 #elif defined(HAVE_CHECK_ACL)
 810         .check_acl      = zpl_check_acl,
 811 #elif defined(HAVE_PERMISSION)
 812         .permission     = zpl_permission,
 813 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
 814 #endif /* CONFIG_FS_POSIX_ACL */
 815 };
 816
 817 dentry_operations_t zpl_dentry_operations = {
 818         .d_revalidate   = zpl_revalidate,
 819 };