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_impl(const struct path *path, struct kstat *stat, u32 request_mask,
 344     unsigned int query_flags)
 345 {
 346         int error;
 347         fstrans_cookie_t cookie;
 348
 349         cookie = spl_fstrans_mark();
 350
 351         /*
 352          * XXX request_mask and query_flags currently ignored.
 353          */
 354
 355         error = -zfs_getattr_fast(path->dentry->d_inode, stat);
 356         spl_fstrans_unmark(cookie);
 357         ASSERT3S(error, <=, 0);
 358
 359         return (error);
 360 }
 361 ZPL_GETATTR_WRAPPER(zpl_getattr);
 362
 363 static int
 364 zpl_setattr(struct dentry *dentry, struct iattr *ia)
 365 {
 366         struct inode *ip = dentry->d_inode;
 367         cred_t *cr = CRED();
 368         vattr_t *vap;
 369         int error;
 370         fstrans_cookie_t cookie;
 371
 372         error = setattr_prepare(dentry, ia);
 373         if (error)
 374                 return (error);
 375
 376         crhold(cr);
 377         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 378         vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK;
 379         vap->va_mode = ia->ia_mode;
 380         vap->va_uid = KUID_TO_SUID(ia->ia_uid);
 381         vap->va_gid = KGID_TO_SGID(ia->ia_gid);
 382         vap->va_size = ia->ia_size;
 383         vap->va_atime = ia->ia_atime;
 384         vap->va_mtime = ia->ia_mtime;
 385         vap->va_ctime = ia->ia_ctime;
 386
 387         if (vap->va_mask & ATTR_ATIME) {
 388                 ip->i_atime = zpl_inode_timespec_trunc(ia->ia_atime,
 389                     ip->i_sb->s_time_gran);
 390         }
 391
 392         cookie = spl_fstrans_mark();
 393         error = -zfs_setattr(ip, vap, 0, cr);
 394         if (!error && (ia->ia_valid & ATTR_MODE))
 395                 error = zpl_chmod_acl(ip);
 396
 397         spl_fstrans_unmark(cookie);
 398         kmem_free(vap, sizeof (vattr_t));
 399         crfree(cr);
 400         ASSERT3S(error, <=, 0);
 401
 402         return (error);
 403 }
 404
 405 static int
 406 zpl_rename2(struct inode *sdip, struct dentry *sdentry,
 407     struct inode *tdip, struct dentry *tdentry, unsigned int flags)
 408 {
 409         cred_t *cr = CRED();
 410         int error;
 411         fstrans_cookie_t cookie;
 412
 413         /* We don't have renameat2(2) support */
 414         if (flags)
 415                 return (-EINVAL);
 416
 417         crhold(cr);
 418         cookie = spl_fstrans_mark();
 419         error = -zfs_rename(sdip, dname(sdentry), tdip, dname(tdentry), cr, 0);
 420         spl_fstrans_unmark(cookie);
 421         crfree(cr);
 422         ASSERT3S(error, <=, 0);
 423
 424         return (error);
 425 }
 426
 427 #ifndef HAVE_RENAME_WANTS_FLAGS
 428 static int
 429 zpl_rename(struct inode *sdip, struct dentry *sdentry,
 430     struct inode *tdip, struct dentry *tdentry)
 431 {
 432         return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0));
 433 }
 434 #endif
 435
 436 static int
 437 zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
 438 {
 439         cred_t *cr = CRED();
 440         vattr_t *vap;
 441         struct inode *ip;
 442         int error;
 443         fstrans_cookie_t cookie;
 444
 445         crhold(cr);
 446         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 447         zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr);
 448
 449         cookie = spl_fstrans_mark();
 450         error = -zfs_symlink(dir, dname(dentry), vap, (char *)name, &ip, cr, 0);
 451         if (error == 0) {
 452                 d_instantiate(dentry, ip);
 453
 454                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 455                 if (error)
 456                         (void) zfs_remove(dir, dname(dentry), cr, 0);
 457         }
 458
 459         spl_fstrans_unmark(cookie);
 460         kmem_free(vap, sizeof (vattr_t));
 461         crfree(cr);
 462         ASSERT3S(error, <=, 0);
 463
 464         return (error);
 465 }
 466
 467 #if defined(HAVE_PUT_LINK_COOKIE)
 468 static void
 469 zpl_put_link(struct inode *unused, void *cookie)
 470 {
 471         kmem_free(cookie, MAXPATHLEN);
 472 }
 473 #elif defined(HAVE_PUT_LINK_NAMEIDATA)
 474 static void
 475 zpl_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
 476 {
 477         const char *link = nd_get_link(nd);
 478
 479         if (!IS_ERR(link))
 480                 kmem_free(link, MAXPATHLEN);
 481 }
 482 #elif defined(HAVE_PUT_LINK_DELAYED)
 483 static void
 484 zpl_put_link(void *ptr)
 485 {
 486         kmem_free(ptr, MAXPATHLEN);
 487 }
 488 #endif
 489
 490 static int
 491 zpl_get_link_common(struct dentry *dentry, struct inode *ip, char **link)
 492 {
 493         fstrans_cookie_t cookie;
 494         cred_t *cr = CRED();
 495         struct iovec iov;
 496         uio_t uio;
 497         int error;
 498
 499         crhold(cr);
 500         *link = NULL;
 501         iov.iov_len = MAXPATHLEN;
 502         iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 503
 504         uio.uio_iov = &iov;
 505         uio.uio_iovcnt = 1;
 506         uio.uio_skip = 0;
 507         uio.uio_resid = (MAXPATHLEN - 1);
 508         uio.uio_segflg = UIO_SYSSPACE;
 509
 510         cookie = spl_fstrans_mark();
 511         error = -zfs_readlink(ip, &uio, cr);
 512         spl_fstrans_unmark(cookie);
 513         crfree(cr);
 514
 515         if (error)
 516                 kmem_free(iov.iov_base, MAXPATHLEN);
 517         else
 518                 *link = iov.iov_base;
 519
 520         return (error);
 521 }
 522
 523 #if defined(HAVE_GET_LINK_DELAYED)
 524 const char *
 525 zpl_get_link(struct dentry *dentry, struct inode *inode,
 526     struct delayed_call *done)
 527 {
 528         char *link = NULL;
 529         int error;
 530
 531         if (!dentry)
 532                 return (ERR_PTR(-ECHILD));
 533
 534         error = zpl_get_link_common(dentry, inode, &link);
 535         if (error)
 536                 return (ERR_PTR(error));
 537
 538         set_delayed_call(done, zpl_put_link, link);
 539
 540         return (link);
 541 }
 542 #elif defined(HAVE_GET_LINK_COOKIE)
 543 const char *
 544 zpl_get_link(struct dentry *dentry, struct inode *inode, void **cookie)
 545 {
 546         char *link = NULL;
 547         int error;
 548
 549         if (!dentry)
 550                 return (ERR_PTR(-ECHILD));
 551
 552         error = zpl_get_link_common(dentry, inode, &link);
 553         if (error)
 554                 return (ERR_PTR(error));
 555
 556         return (*cookie = link);
 557 }
 558 #elif defined(HAVE_FOLLOW_LINK_COOKIE)
 559 const char *
 560 zpl_follow_link(struct dentry *dentry, void **cookie)
 561 {
 562         char *link = NULL;
 563         int error;
 564
 565         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 566         if (error)
 567                 return (ERR_PTR(error));
 568
 569         return (*cookie = link);
 570 }
 571 #elif defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 572 static void *
 573 zpl_follow_link(struct dentry *dentry, struct nameidata *nd)
 574 {
 575         char *link = NULL;
 576         int error;
 577
 578         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 579         if (error)
 580                 nd_set_link(nd, ERR_PTR(error));
 581         else
 582                 nd_set_link(nd, link);
 583
 584         return (NULL);
 585 }
 586 #endif
 587
 588 static int
 589 zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 590 {
 591         cred_t *cr = CRED();
 592         struct inode *ip = old_dentry->d_inode;
 593         int error;
 594         fstrans_cookie_t cookie;
 595
 596         if (ip->i_nlink >= ZFS_LINK_MAX)
 597                 return (-EMLINK);
 598
 599         crhold(cr);
 600         ip->i_ctime = current_time(ip);
 601         igrab(ip); /* Use ihold() if available */
 602
 603         cookie = spl_fstrans_mark();
 604         error = -zfs_link(dir, ip, dname(dentry), cr, 0);
 605         if (error) {
 606                 iput(ip);
 607                 goto out;
 608         }
 609
 610         d_instantiate(dentry, ip);
 611 out:
 612         spl_fstrans_unmark(cookie);
 613         crfree(cr);
 614         ASSERT3S(error, <=, 0);
 615
 616         return (error);
 617 }
 618
 619 #ifdef HAVE_INODE_TRUNCATE_RANGE
 620 static void
 621 zpl_truncate_range(struct inode *ip, loff_t start, loff_t end)
 622 {
 623         cred_t *cr = CRED();
 624         flock64_t bf;
 625         fstrans_cookie_t cookie;
 626
 627         ASSERT3S(start, <=, end);
 628
 629         /*
 630          * zfs_freesp() will interpret (len == 0) as meaning "truncate until
 631          * the end of the file". We don't want that.
 632          */
 633         if (start == end)
 634                 return;
 635
 636         crhold(cr);
 637
 638         bf.l_type = F_WRLCK;
 639         bf.l_whence = SEEK_SET;
 640         bf.l_start = start;
 641         bf.l_len = end - start;
 642         bf.l_pid = 0;
 643         cookie = spl_fstrans_mark();
 644         zfs_space(ip, F_FREESP, &bf, FWRITE, start, cr);
 645         spl_fstrans_unmark(cookie);
 646
 647         crfree(cr);
 648 }
 649 #endif /* HAVE_INODE_TRUNCATE_RANGE */
 650
 651 #ifdef HAVE_INODE_FALLOCATE
 652 static long
 653 zpl_fallocate(struct inode *ip, int mode, loff_t offset, loff_t len)
 654 {
 655         return (zpl_fallocate_common(ip, mode, offset, len));
 656 }
 657 #endif /* HAVE_INODE_FALLOCATE */
 658
 659 static int
 660 #ifdef HAVE_D_REVALIDATE_NAMEIDATA
 661 zpl_revalidate(struct dentry *dentry, struct nameidata *nd)
 662 {
 663         unsigned int flags = (nd ? nd->flags : 0);
 664 #else
 665 zpl_revalidate(struct dentry *dentry, unsigned int flags)
 666 {
 667 #endif /* HAVE_D_REVALIDATE_NAMEIDATA */
 668         /* CSTYLED */
 669         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 670         int error;
 671
 672         if (flags & LOOKUP_RCU)
 673                 return (-ECHILD);
 674
 675         /*
 676          * Automounted snapshots rely on periodic dentry revalidation
 677          * to defer snapshots from being automatically unmounted.
 678          */
 679         if (zfsvfs->z_issnap) {
 680                 if (time_after(jiffies, zfsvfs->z_snap_defer_time +
 681                     MAX(zfs_expire_snapshot * HZ / 2, HZ))) {
 682                         zfsvfs->z_snap_defer_time = jiffies;
 683                         zfsctl_snapshot_unmount_delay(zfsvfs->z_os->os_spa,
 684                             dmu_objset_id(zfsvfs->z_os), zfs_expire_snapshot);
 685                 }
 686         }
 687
 688         /*
 689          * After a rollback negative dentries created before the rollback
 690          * time must be invalidated.  Otherwise they can obscure files which
 691          * are only present in the rolled back dataset.
 692          */
 693         if (dentry->d_inode == NULL) {
 694                 spin_lock(&dentry->d_lock);
 695                 error = time_before(dentry->d_time, zfsvfs->z_rollback_time);
 696                 spin_unlock(&dentry->d_lock);
 697
 698                 if (error)
 699                         return (0);
 700         }
 701
 702         /*
 703          * The dentry may reference a stale inode if a mounted file system
 704          * was rolled back to a point in time where the object didn't exist.
 705          */
 706         if (dentry->d_inode && ITOZ(dentry->d_inode)->z_is_stale)
 707                 return (0);
 708
 709         return (1);
 710 }
 711
 712 const struct inode_operations zpl_inode_operations = {
 713         .setattr        = zpl_setattr,
 714         .getattr        = zpl_getattr,
 715 #ifdef HAVE_GENERIC_SETXATTR
 716         .setxattr       = generic_setxattr,
 717         .getxattr       = generic_getxattr,
 718         .removexattr    = generic_removexattr,
 719 #endif
 720         .listxattr      = zpl_xattr_list,
 721 #ifdef HAVE_INODE_TRUNCATE_RANGE
 722         .truncate_range = zpl_truncate_range,
 723 #endif /* HAVE_INODE_TRUNCATE_RANGE */
 724 #ifdef HAVE_INODE_FALLOCATE
 725         .fallocate      = zpl_fallocate,
 726 #endif /* HAVE_INODE_FALLOCATE */
 727 #if defined(CONFIG_FS_POSIX_ACL)
 728 #if defined(HAVE_SET_ACL)
 729         .set_acl        = zpl_set_acl,
 730 #endif
 731 #if defined(HAVE_GET_ACL)
 732         .get_acl        = zpl_get_acl,
 733 #elif defined(HAVE_CHECK_ACL)
 734         .check_acl      = zpl_check_acl,
 735 #elif defined(HAVE_PERMISSION)
 736         .permission     = zpl_permission,
 737 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
 738 #endif /* CONFIG_FS_POSIX_ACL */
 739 };
 740
 741 const struct inode_operations zpl_dir_inode_operations = {
 742         .create         = zpl_create,
 743         .lookup         = zpl_lookup,
 744         .link           = zpl_link,
 745         .unlink         = zpl_unlink,
 746         .symlink        = zpl_symlink,
 747         .mkdir          = zpl_mkdir,
 748         .rmdir          = zpl_rmdir,
 749         .mknod          = zpl_mknod,
 750 #ifdef HAVE_RENAME_WANTS_FLAGS
 751         .rename         = zpl_rename2,
 752 #else
 753         .rename         = zpl_rename,
 754 #endif
 755 #ifdef HAVE_TMPFILE
 756         .tmpfile        = zpl_tmpfile,
 757 #endif
 758         .setattr        = zpl_setattr,
 759         .getattr        = zpl_getattr,
 760 #ifdef HAVE_GENERIC_SETXATTR
 761         .setxattr       = generic_setxattr,
 762         .getxattr       = generic_getxattr,
 763         .removexattr    = generic_removexattr,
 764 #endif
 765         .listxattr      = zpl_xattr_list,
 766 #if defined(CONFIG_FS_POSIX_ACL)
 767 #if defined(HAVE_SET_ACL)
 768         .set_acl        = zpl_set_acl,
 769 #endif
 770 #if defined(HAVE_GET_ACL)
 771         .get_acl        = zpl_get_acl,
 772 #elif defined(HAVE_CHECK_ACL)
 773         .check_acl      = zpl_check_acl,
 774 #elif defined(HAVE_PERMISSION)
 775         .permission     = zpl_permission,
 776 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
 777 #endif /* CONFIG_FS_POSIX_ACL */
 778 };
 779
 780 const struct inode_operations zpl_symlink_inode_operations = {
 781 #ifdef HAVE_GENERIC_READLINK
 782         .readlink       = generic_readlink,
 783 #endif
 784 #if defined(HAVE_GET_LINK_DELAYED) || defined(HAVE_GET_LINK_COOKIE)
 785         .get_link       = zpl_get_link,
 786 #elif defined(HAVE_FOLLOW_LINK_COOKIE) || defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 787         .follow_link    = zpl_follow_link,
 788 #endif
 789 #if defined(HAVE_PUT_LINK_COOKIE) || defined(HAVE_PUT_LINK_NAMEIDATA)
 790         .put_link       = zpl_put_link,
 791 #endif
 792         .setattr        = zpl_setattr,
 793         .getattr        = zpl_getattr,
 794 #ifdef HAVE_GENERIC_SETXATTR
 795         .setxattr       = generic_setxattr,
 796         .getxattr       = generic_getxattr,
 797         .removexattr    = generic_removexattr,
 798 #endif
 799         .listxattr      = zpl_xattr_list,
 800 };
 801
 802 const struct inode_operations zpl_special_inode_operations = {
 803         .setattr        = zpl_setattr,
 804         .getattr        = zpl_getattr,
 805 #ifdef HAVE_GENERIC_SETXATTR
 806         .setxattr       = generic_setxattr,
 807         .getxattr       = generic_getxattr,
 808         .removexattr    = generic_removexattr,
 809 #endif
 810         .listxattr      = zpl_xattr_list,
 811 #if defined(CONFIG_FS_POSIX_ACL)
 812 #if defined(HAVE_SET_ACL)
 813         .set_acl        = zpl_set_acl,
 814 #endif
 815 #if defined(HAVE_GET_ACL)
 816         .get_acl        = zpl_get_acl,
 817 #elif defined(HAVE_CHECK_ACL)
 818         .check_acl      = zpl_check_acl,
 819 #elif defined(HAVE_PERMISSION)
 820         .permission     = zpl_permission,
 821 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
 822 #endif /* CONFIG_FS_POSIX_ACL */
 823 };
 824
 825 dentry_operations_t zpl_dentry_operations = {
 826         .d_revalidate   = zpl_revalidate,
 827 };