module/zfs/zfs_vnops.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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
  24  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
  25  * Copyright (c) 2015 by Chunwei Chen. All rights reserved.
  26  */
  27
  28 /* Portions Copyright 2007 Jeremy Teo */
  29 /* Portions Copyright 2010 Robert Milkowski */
  30
  31
  32 #include <sys/types.h>
  33 #include <sys/param.h>
  34 #include <sys/time.h>
  35 #include <sys/systm.h>
  36 #include <sys/sysmacros.h>
  37 #include <sys/resource.h>
  38 #include <sys/vfs.h>
  39 #include <sys/vfs_opreg.h>
  40 #include <sys/file.h>
  41 #include <sys/stat.h>
  42 #include <sys/kmem.h>
  43 #include <sys/taskq.h>
  44 #include <sys/uio.h>
  45 #include <sys/vmsystm.h>
  46 #include <sys/atomic.h>
  47 #include <vm/pvn.h>
  48 #include <sys/pathname.h>
  49 #include <sys/cmn_err.h>
  50 #include <sys/errno.h>
  51 #include <sys/unistd.h>
  52 #include <sys/zfs_dir.h>
  53 #include <sys/zfs_acl.h>
  54 #include <sys/zfs_ioctl.h>
  55 #include <sys/fs/zfs.h>
  56 #include <sys/dmu.h>
  57 #include <sys/dmu_objset.h>
  58 #include <sys/spa.h>
  59 #include <sys/txg.h>
  60 #include <sys/dbuf.h>
  61 #include <sys/zap.h>
  62 #include <sys/sa.h>
  63 #include <sys/dirent.h>
  64 #include <sys/policy.h>
  65 #include <sys/sunddi.h>
  66 #include <sys/sid.h>
  67 #include <sys/mode.h>
  68 #include "fs/fs_subr.h"
  69 #include <sys/zfs_ctldir.h>
  70 #include <sys/zfs_fuid.h>
  71 #include <sys/zfs_sa.h>
  72 #include <sys/zfs_vnops.h>
  73 #include <sys/dnlc.h>
  74 #include <sys/zfs_rlock.h>
  75 #include <sys/extdirent.h>
  76 #include <sys/kidmap.h>
  77 #include <sys/cred.h>
  78 #include <sys/attr.h>
  79 #include <sys/zpl.h>
  80
  81 /*
  82  * Programming rules.
  83  *
  84  * Each vnode op performs some logical unit of work.  To do this, the ZPL must
  85  * properly lock its in-core state, create a DMU transaction, do the work,
  86  * record this work in the intent log (ZIL), commit the DMU transaction,
  87  * and wait for the intent log to commit if it is a synchronous operation.
  88  * Moreover, the vnode ops must work in both normal and log replay context.
  89  * The ordering of events is important to avoid deadlocks and references
  90  * to freed memory.  The example below illustrates the following Big Rules:
  91  *
  92  *  (1) A check must be made in each zfs thread for a mounted file system.
  93  *      This is done avoiding races using ZFS_ENTER(zsb).
  94  *      A ZFS_EXIT(zsb) is needed before all returns.  Any znodes
  95  *      must be checked with ZFS_VERIFY_ZP(zp).  Both of these macros
  96  *      can return EIO from the calling function.
  97  *
  98  *  (2) iput() should always be the last thing except for zil_commit()
  99  *      (if necessary) and ZFS_EXIT(). This is for 3 reasons:
 100  *      First, if it's the last reference, the vnode/znode
 101  *      can be freed, so the zp may point to freed memory.  Second, the last
 102  *      reference will call zfs_zinactive(), which may induce a lot of work --
 103  *      pushing cached pages (which acquires range locks) and syncing out
 104  *      cached atime changes.  Third, zfs_zinactive() may require a new tx,
 105  *      which could deadlock the system if you were already holding one.
 106  *      If you must call iput() within a tx then use zfs_iput_async().
 107  *
 108  *  (3) All range locks must be grabbed before calling dmu_tx_assign(),
 109  *      as they can span dmu_tx_assign() calls.
 110  *
 111  *  (4) If ZPL locks are held, pass TXG_NOWAIT as the second argument to
 112  *      dmu_tx_assign().  This is critical because we don't want to block
 113  *      while holding locks.
 114  *
 115  *      If no ZPL locks are held (aside from ZFS_ENTER()), use TXG_WAIT.  This
 116  *      reduces lock contention and CPU usage when we must wait (note that if
 117  *      throughput is constrained by the storage, nearly every transaction
 118  *      must wait).
 119  *
 120  *      Note, in particular, that if a lock is sometimes acquired before
 121  *      the tx assigns, and sometimes after (e.g. z_lock), then failing
 122  *      to use a non-blocking assign can deadlock the system.  The scenario:
 123  *
 124  *      Thread A has grabbed a lock before calling dmu_tx_assign().
 125  *      Thread B is in an already-assigned tx, and blocks for this lock.
 126  *      Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()
 127  *      forever, because the previous txg can't quiesce until B's tx commits.
 128  *
 129  *      If dmu_tx_assign() returns ERESTART and zsb->z_assign is TXG_NOWAIT,
 130  *      then drop all locks, call dmu_tx_wait(), and try again.  On subsequent
 131  *      calls to dmu_tx_assign(), pass TXG_WAITED rather than TXG_NOWAIT,
 132  *      to indicate that this operation has already called dmu_tx_wait().
 133  *      This will ensure that we don't retry forever, waiting a short bit
 134  *      each time.
 135  *
 136  *  (5) If the operation succeeded, generate the intent log entry for it
 137  *      before dropping locks.  This ensures that the ordering of events
 138  *      in the intent log matches the order in which they actually occurred.
 139  *      During ZIL replay the zfs_log_* functions will update the sequence
 140  *      number to indicate the zil transaction has replayed.
 141  *
 142  *  (6) At the end of each vnode op, the DMU tx must always commit,
 143  *      regardless of whether there were any errors.
 144  *
 145  *  (7) After dropping all locks, invoke zil_commit(zilog, foid)
 146  *      to ensure that synchronous semantics are provided when necessary.
 147  *
 148  * In general, this is how things should be ordered in each vnode op:
 149  *
 150  *      ZFS_ENTER(zsb);         // exit if unmounted
 151  * top:
 152  *      zfs_dirent_lock(&dl, ...)       // lock directory entry (may igrab())
 153  *      rw_enter(...);                  // grab any other locks you need
 154  *      tx = dmu_tx_create(...);        // get DMU tx
 155  *      dmu_tx_hold_*();                // hold each object you might modify
 156  *      error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
 157  *      if (error) {
 158  *              rw_exit(...);           // drop locks
 159  *              zfs_dirent_unlock(dl);  // unlock directory entry
 160  *              iput(...);              // release held vnodes
 161  *              if (error == ERESTART) {
 162  *                      waited = B_TRUE;
 163  *                      dmu_tx_wait(tx);
 164  *                      dmu_tx_abort(tx);
 165  *                      goto top;
 166  *              }
 167  *              dmu_tx_abort(tx);       // abort DMU tx
 168  *              ZFS_EXIT(zsb);  // finished in zfs
 169  *              return (error);         // really out of space
 170  *      }
 171  *      error = do_real_work();         // do whatever this VOP does
 172  *      if (error == 0)
 173  *              zfs_log_*(...);         // on success, make ZIL entry
 174  *      dmu_tx_commit(tx);              // commit DMU tx -- error or not
 175  *      rw_exit(...);                   // drop locks
 176  *      zfs_dirent_unlock(dl);          // unlock directory entry
 177  *      iput(...);                      // release held vnodes
 178  *      zil_commit(zilog, foid);        // synchronous when necessary
 179  *      ZFS_EXIT(zsb);          // finished in zfs
 180  *      return (error);                 // done, report error
 181  */
 182
 183 /*
 184  * Virus scanning is unsupported.  It would be possible to add a hook
 185  * here to performance the required virus scan.  This could be done
 186  * entirely in the kernel or potentially as an update to invoke a
 187  * scanning utility.
 188  */
 189 static int
 190 zfs_vscan(struct inode *ip, cred_t *cr, int async)
 191 {
 192         return (0);
 193 }
 194
 195 /* ARGSUSED */
 196 int
 197 zfs_open(struct inode *ip, int mode, int flag, cred_t *cr)
 198 {
 199         znode_t *zp = ITOZ(ip);
 200         zfs_sb_t *zsb = ITOZSB(ip);
 201
 202         ZFS_ENTER(zsb);
 203         ZFS_VERIFY_ZP(zp);
 204
 205         /* Honor ZFS_APPENDONLY file attribute */
 206         if ((mode & FMODE_WRITE) && (zp->z_pflags & ZFS_APPENDONLY) &&
 207             ((flag & O_APPEND) == 0)) {
 208                 ZFS_EXIT(zsb);
 209                 return (SET_ERROR(EPERM));
 210         }
 211
 212         /* Virus scan eligible files on open */
 213         if (!zfs_has_ctldir(zp) && zsb->z_vscan && S_ISREG(ip->i_mode) &&
 214             !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) {
 215                 if (zfs_vscan(ip, cr, 0) != 0) {
 216                         ZFS_EXIT(zsb);
 217                         return (SET_ERROR(EACCES));
 218                 }
 219         }
 220
 221         /* Keep a count of the synchronous opens in the znode */
 222         if (flag & O_SYNC)
 223                 atomic_inc_32(&zp->z_sync_cnt);
 224
 225         ZFS_EXIT(zsb);
 226         return (0);
 227 }
 228 EXPORT_SYMBOL(zfs_open);
 229
 230 /* ARGSUSED */
 231 int
 232 zfs_close(struct inode *ip, int flag, cred_t *cr)
 233 {
 234         znode_t *zp = ITOZ(ip);
 235         zfs_sb_t *zsb = ITOZSB(ip);
 236
 237         ZFS_ENTER(zsb);
 238         ZFS_VERIFY_ZP(zp);
 239
 240         /* Decrement the synchronous opens in the znode */
 241         if (flag & O_SYNC)
 242                 atomic_dec_32(&zp->z_sync_cnt);
 243
 244         if (!zfs_has_ctldir(zp) && zsb->z_vscan && S_ISREG(ip->i_mode) &&
 245             !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0)
 246                 VERIFY(zfs_vscan(ip, cr, 1) == 0);
 247
 248         ZFS_EXIT(zsb);
 249         return (0);
 250 }
 251 EXPORT_SYMBOL(zfs_close);
 252
 253 #if defined(SEEK_HOLE) && defined(SEEK_DATA)
 254 /*
 255  * Lseek support for finding holes (cmd == SEEK_HOLE) and
 256  * data (cmd == SEEK_DATA). "off" is an in/out parameter.
 257  */
 258 static int
 259 zfs_holey_common(struct inode *ip, int cmd, loff_t *off)
 260 {
 261         znode_t *zp = ITOZ(ip);
 262         uint64_t noff = (uint64_t)*off; /* new offset */
 263         uint64_t file_sz;
 264         int error;
 265         boolean_t hole;
 266
 267         file_sz = zp->z_size;
 268         if (noff >= file_sz)  {
 269                 return (SET_ERROR(ENXIO));
 270         }
 271
 272         if (cmd == SEEK_HOLE)
 273                 hole = B_TRUE;
 274         else
 275                 hole = B_FALSE;
 276
 277         error = dmu_offset_next(ZTOZSB(zp)->z_os, zp->z_id, hole, &noff);
 278
 279         if (error == ESRCH)
 280                 return (SET_ERROR(ENXIO));
 281
 282         /*
 283          * We could find a hole that begins after the logical end-of-file,
 284          * because dmu_offset_next() only works on whole blocks.  If the
 285          * EOF falls mid-block, then indicate that the "virtual hole"
 286          * at the end of the file begins at the logical EOF, rather than
 287          * at the end of the last block.
 288          */
 289         if (noff > file_sz) {
 290                 ASSERT(hole);
 291                 noff = file_sz;
 292         }
 293
 294         if (noff < *off)
 295                 return (error);
 296         *off = noff;
 297         return (error);
 298 }
 299
 300 int
 301 zfs_holey(struct inode *ip, int cmd, loff_t *off)
 302 {
 303         znode_t *zp = ITOZ(ip);
 304         zfs_sb_t *zsb = ITOZSB(ip);
 305         int error;
 306
 307         ZFS_ENTER(zsb);
 308         ZFS_VERIFY_ZP(zp);
 309
 310         error = zfs_holey_common(ip, cmd, off);
 311
 312         ZFS_EXIT(zsb);
 313         return (error);
 314 }
 315 EXPORT_SYMBOL(zfs_holey);
 316 #endif /* SEEK_HOLE && SEEK_DATA */
 317
 318 #if defined(_KERNEL)
 319 /*
 320  * When a file is memory mapped, we must keep the IO data synchronized
 321  * between the DMU cache and the memory mapped pages.  What this means:
 322  *
 323  * On Write:    If we find a memory mapped page, we write to *both*
 324  *              the page and the dmu buffer.
 325  */
 326 static void
 327 update_pages(struct inode *ip, int64_t start, int len,
 328     objset_t *os, uint64_t oid)
 329 {
 330         struct address_space *mp = ip->i_mapping;
 331         struct page *pp;
 332         uint64_t nbytes;
 333         int64_t off;
 334         void *pb;
 335
 336         off = start & (PAGE_SIZE-1);
 337         for (start &= PAGE_MASK; len > 0; start += PAGE_SIZE) {
 338                 nbytes = MIN(PAGE_SIZE - off, len);
 339
 340                 pp = find_lock_page(mp, start >> PAGE_SHIFT);
 341                 if (pp) {
 342                         if (mapping_writably_mapped(mp))
 343                                 flush_dcache_page(pp);
 344
 345                         pb = kmap(pp);
 346                         (void) dmu_read(os, oid, start+off, nbytes, pb+off,
 347                             DMU_READ_PREFETCH);
 348                         kunmap(pp);
 349
 350                         if (mapping_writably_mapped(mp))
 351                                 flush_dcache_page(pp);
 352
 353                         mark_page_accessed(pp);
 354                         SetPageUptodate(pp);
 355                         ClearPageError(pp);
 356                         unlock_page(pp);
 357                         put_page(pp);
 358                 }
 359
 360                 len -= nbytes;
 361                 off = 0;
 362         }
 363 }
 364
 365 /*
 366  * When a file is memory mapped, we must keep the IO data synchronized
 367  * between the DMU cache and the memory mapped pages.  What this means:
 368  *
 369  * On Read:     We "read" preferentially from memory mapped pages,
 370  *              else we default from the dmu buffer.
 371  *
 372  * NOTE: We will always "break up" the IO into PAGESIZE uiomoves when
 373  *       the file is memory mapped.
 374  */
 375 static int
 376 mappedread(struct inode *ip, int nbytes, uio_t *uio)
 377 {
 378         struct address_space *mp = ip->i_mapping;
 379         struct page *pp;
 380         znode_t *zp = ITOZ(ip);
 381         int64_t start, off;
 382         uint64_t bytes;
 383         int len = nbytes;
 384         int error = 0;
 385         void *pb;
 386
 387         start = uio->uio_loffset;
 388         off = start & (PAGE_SIZE-1);
 389         for (start &= PAGE_MASK; len > 0; start += PAGE_SIZE) {
 390                 bytes = MIN(PAGE_SIZE - off, len);
 391
 392                 pp = find_lock_page(mp, start >> PAGE_SHIFT);
 393                 if (pp) {
 394                         ASSERT(PageUptodate(pp));
 395
 396                         pb = kmap(pp);
 397                         error = uiomove(pb + off, bytes, UIO_READ, uio);
 398                         kunmap(pp);
 399
 400                         if (mapping_writably_mapped(mp))
 401                                 flush_dcache_page(pp);
 402
 403                         mark_page_accessed(pp);
 404                         unlock_page(pp);
 405                         put_page(pp);
 406                 } else {
 407                         error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
 408                             uio, bytes);
 409                 }
 410
 411                 len -= bytes;
 412                 off = 0;
 413                 if (error)
 414                         break;
 415         }
 416         return (error);
 417 }
 418 #endif /* _KERNEL */
 419
 420 unsigned long zfs_read_chunk_size = 1024 * 1024; /* Tunable */
 421 unsigned long zfs_delete_blocks = DMU_MAX_DELETEBLKCNT;
 422
 423 /*
 424  * Read bytes from specified file into supplied buffer.
 425  *
 426  *      IN:     ip      - inode of file to be read from.
 427  *              uio     - structure supplying read location, range info,
 428  *                        and return buffer.
 429  *              ioflag  - FSYNC flags; used to provide FRSYNC semantics.
 430  *                        O_DIRECT flag; used to bypass page cache.
 431  *              cr      - credentials of caller.
 432  *
 433  *      OUT:    uio     - updated offset and range, buffer filled.
 434  *
 435  *      RETURN: 0 on success, error code on failure.
 436  *
 437  * Side Effects:
 438  *      inode - atime updated if byte count > 0
 439  */
 440 /* ARGSUSED */
 441 int
 442 zfs_read(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
 443 {
 444         znode_t         *zp = ITOZ(ip);
 445         zfs_sb_t        *zsb = ITOZSB(ip);
 446         ssize_t         n, nbytes;
 447         int             error = 0;
 448         rl_t            *rl;
 449 #ifdef HAVE_UIO_ZEROCOPY
 450         xuio_t          *xuio = NULL;
 451 #endif /* HAVE_UIO_ZEROCOPY */
 452
 453         ZFS_ENTER(zsb);
 454         ZFS_VERIFY_ZP(zp);
 455
 456         if (zp->z_pflags & ZFS_AV_QUARANTINED) {
 457                 ZFS_EXIT(zsb);
 458                 return (SET_ERROR(EACCES));
 459         }
 460
 461         /*
 462          * Validate file offset
 463          */
 464         if (uio->uio_loffset < (offset_t)0) {
 465                 ZFS_EXIT(zsb);
 466                 return (SET_ERROR(EINVAL));
 467         }
 468
 469         /*
 470          * Fasttrack empty reads
 471          */
 472         if (uio->uio_resid == 0) {
 473                 ZFS_EXIT(zsb);
 474                 return (0);
 475         }
 476
 477         /*
 478          * If we're in FRSYNC mode, sync out this znode before reading it.
 479          */
 480         if (ioflag & FRSYNC || zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
 481                 zil_commit(zsb->z_log, zp->z_id);
 482
 483         /*
 484          * Lock the range against changes.
 485          */
 486         rl = zfs_range_lock(&zp->z_range_lock, uio->uio_loffset, uio->uio_resid,
 487             RL_READER);
 488
 489         /*
 490          * If we are reading past end-of-file we can skip
 491          * to the end; but we might still need to set atime.
 492          */
 493         if (uio->uio_loffset >= zp->z_size) {
 494                 error = 0;
 495                 goto out;
 496         }
 497
 498         ASSERT(uio->uio_loffset < zp->z_size);
 499         n = MIN(uio->uio_resid, zp->z_size - uio->uio_loffset);
 500
 501 #ifdef HAVE_UIO_ZEROCOPY
 502         if ((uio->uio_extflg == UIO_XUIO) &&
 503             (((xuio_t *)uio)->xu_type == UIOTYPE_ZEROCOPY)) {
 504                 int nblk;
 505                 int blksz = zp->z_blksz;
 506                 uint64_t offset = uio->uio_loffset;
 507
 508                 xuio = (xuio_t *)uio;
 509                 if ((ISP2(blksz))) {
 510                         nblk = (P2ROUNDUP(offset + n, blksz) - P2ALIGN(offset,
 511                             blksz)) / blksz;
 512                 } else {
 513                         ASSERT(offset + n <= blksz);
 514                         nblk = 1;
 515                 }
 516                 (void) dmu_xuio_init(xuio, nblk);
 517
 518                 if (vn_has_cached_data(ip)) {
 519                         /*
 520                          * For simplicity, we always allocate a full buffer
 521                          * even if we only expect to read a portion of a block.
 522                          */
 523                         while (--nblk >= 0) {
 524                                 (void) dmu_xuio_add(xuio,
 525                                     dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
 526                                     blksz), 0, blksz);
 527                         }
 528                 }
 529         }
 530 #endif /* HAVE_UIO_ZEROCOPY */
 531
 532         while (n > 0) {
 533                 nbytes = MIN(n, zfs_read_chunk_size -
 534                     P2PHASE(uio->uio_loffset, zfs_read_chunk_size));
 535
 536                 if (zp->z_is_mapped && !(ioflag & O_DIRECT)) {
 537                         error = mappedread(ip, nbytes, uio);
 538                 } else {
 539                         error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
 540                             uio, nbytes);
 541                 }
 542
 543                 if (error) {
 544                         /* convert checksum errors into IO errors */
 545                         if (error == ECKSUM)
 546                                 error = SET_ERROR(EIO);
 547                         break;
 548                 }
 549
 550                 n -= nbytes;
 551         }
 552 out:
 553         zfs_range_unlock(rl);
 554
 555         ZFS_EXIT(zsb);
 556         return (error);
 557 }
 558 EXPORT_SYMBOL(zfs_read);
 559
 560 /*
 561  * Write the bytes to a file.
 562  *
 563  *      IN:     ip      - inode of file to be written to.
 564  *              uio     - structure supplying write location, range info,
 565  *                        and data buffer.
 566  *              ioflag  - FAPPEND flag set if in append mode.
 567  *                        O_DIRECT flag; used to bypass page cache.
 568  *              cr      - credentials of caller.
 569  *
 570  *      OUT:    uio     - updated offset and range.
 571  *
 572  *      RETURN: 0 if success
 573  *              error code if failure
 574  *
 575  * Timestamps:
 576  *      ip - ctime|mtime updated if byte count > 0
 577  */
 578
 579 /* ARGSUSED */
 580 int
 581 zfs_write(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
 582 {
 583         znode_t         *zp = ITOZ(ip);
 584         rlim64_t        limit = uio->uio_limit;
 585         ssize_t         start_resid = uio->uio_resid;
 586         ssize_t         tx_bytes;
 587         uint64_t        end_size;
 588         dmu_tx_t        *tx;
 589         zfs_sb_t        *zsb = ZTOZSB(zp);
 590         zilog_t         *zilog;
 591         offset_t        woff;
 592         ssize_t         n, nbytes;
 593         rl_t            *rl;
 594         int             max_blksz = zsb->z_max_blksz;
 595         int             error = 0;
 596         arc_buf_t       *abuf;
 597         const iovec_t   *aiov = NULL;
 598         xuio_t          *xuio = NULL;
 599         int             write_eof;
 600         int             count = 0;
 601         sa_bulk_attr_t  bulk[4];
 602         uint64_t        mtime[2], ctime[2];
 603         uint32_t        uid;
 604 #ifdef HAVE_UIO_ZEROCOPY
 605         int             i_iov = 0;
 606         const iovec_t   *iovp = uio->uio_iov;
 607         ASSERTV(int     iovcnt = uio->uio_iovcnt);
 608 #endif
 609
 610         /*
 611          * Fasttrack empty write
 612          */
 613         n = start_resid;
 614         if (n == 0)
 615                 return (0);
 616
 617         if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T)
 618                 limit = MAXOFFSET_T;
 619
 620         ZFS_ENTER(zsb);
 621         ZFS_VERIFY_ZP(zp);
 622
 623         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL, &mtime, 16);
 624         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL, &ctime, 16);
 625         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zsb), NULL, &zp->z_size, 8);
 626         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
 627             &zp->z_pflags, 8);
 628
 629         /*
 630          * Callers might not be able to detect properly that we are read-only,
 631          * so check it explicitly here.
 632          */
 633         if (zfs_is_readonly(zsb)) {
 634                 ZFS_EXIT(zsb);
 635                 return (SET_ERROR(EROFS));
 636         }
 637
 638         /*
 639          * If immutable or not appending then return EPERM
 640          */
 641         if ((zp->z_pflags & (ZFS_IMMUTABLE | ZFS_READONLY)) ||
 642             ((zp->z_pflags & ZFS_APPENDONLY) && !(ioflag & FAPPEND) &&
 643             (uio->uio_loffset < zp->z_size))) {
 644                 ZFS_EXIT(zsb);
 645                 return (SET_ERROR(EPERM));
 646         }
 647
 648         zilog = zsb->z_log;
 649
 650         /*
 651          * Validate file offset
 652          */
 653         woff = ioflag & FAPPEND ? zp->z_size : uio->uio_loffset;
 654         if (woff < 0) {
 655                 ZFS_EXIT(zsb);
 656                 return (SET_ERROR(EINVAL));
 657         }
 658
 659         /*
 660          * Pre-fault the pages to ensure slow (eg NFS) pages
 661          * don't hold up txg.
 662          * Skip this if uio contains loaned arc_buf.
 663          */
 664 #ifdef HAVE_UIO_ZEROCOPY
 665         if ((uio->uio_extflg == UIO_XUIO) &&
 666             (((xuio_t *)uio)->xu_type == UIOTYPE_ZEROCOPY))
 667                 xuio = (xuio_t *)uio;
 668         else
 669 #endif
 670                 uio_prefaultpages(MIN(n, max_blksz), uio);
 671
 672         /*
 673          * If in append mode, set the io offset pointer to eof.
 674          */
 675         if (ioflag & FAPPEND) {
 676                 /*
 677                  * Obtain an appending range lock to guarantee file append
 678                  * semantics.  We reset the write offset once we have the lock.
 679                  */
 680                 rl = zfs_range_lock(&zp->z_range_lock, 0, n, RL_APPEND);
 681                 woff = rl->r_off;
 682                 if (rl->r_len == UINT64_MAX) {
 683                         /*
 684                          * We overlocked the file because this write will cause
 685                          * the file block size to increase.
 686                          * Note that zp_size cannot change with this lock held.
 687                          */
 688                         woff = zp->z_size;
 689                 }
 690                 uio->uio_loffset = woff;
 691         } else {
 692                 /*
 693                  * Note that if the file block size will change as a result of
 694                  * this write, then this range lock will lock the entire file
 695                  * so that we can re-write the block safely.
 696                  */
 697                 rl = zfs_range_lock(&zp->z_range_lock, woff, n, RL_WRITER);
 698         }
 699
 700         if (woff >= limit) {
 701                 zfs_range_unlock(rl);
 702                 ZFS_EXIT(zsb);
 703                 return (SET_ERROR(EFBIG));
 704         }
 705
 706         if ((woff + n) > limit || woff > (limit - n))
 707                 n = limit - woff;
 708
 709         /* Will this write extend the file length? */
 710         write_eof = (woff + n > zp->z_size);
 711
 712         end_size = MAX(zp->z_size, woff + n);
 713
 714         /*
 715          * Write the file in reasonable size chunks.  Each chunk is written
 716          * in a separate transaction; this keeps the intent log records small
 717          * and allows us to do more fine-grained space accounting.
 718          */
 719         while (n > 0) {
 720                 abuf = NULL;
 721                 woff = uio->uio_loffset;
 722                 if (zfs_owner_overquota(zsb, zp, B_FALSE) ||
 723                     zfs_owner_overquota(zsb, zp, B_TRUE)) {
 724                         if (abuf != NULL)
 725                                 dmu_return_arcbuf(abuf);
 726                         error = SET_ERROR(EDQUOT);
 727                         break;
 728                 }
 729
 730                 if (xuio && abuf == NULL) {
 731 #ifdef HAVE_UIO_ZEROCOPY
 732                         ASSERT(i_iov < iovcnt);
 733                         ASSERT3U(uio->uio_segflg, !=, UIO_BVEC);
 734                         aiov = &iovp[i_iov];
 735                         abuf = dmu_xuio_arcbuf(xuio, i_iov);
 736                         dmu_xuio_clear(xuio, i_iov);
 737                         ASSERT((aiov->iov_base == abuf->b_data) ||
 738                             ((char *)aiov->iov_base - (char *)abuf->b_data +
 739                             aiov->iov_len == arc_buf_size(abuf)));
 740                         i_iov++;
 741 #endif
 742                 } else if (abuf == NULL && n >= max_blksz &&
 743                     woff >= zp->z_size &&
 744                     P2PHASE(woff, max_blksz) == 0 &&
 745                     zp->z_blksz == max_blksz) {
 746                         /*
 747                          * This write covers a full block.  "Borrow" a buffer
 748                          * from the dmu so that we can fill it before we enter
 749                          * a transaction.  This avoids the possibility of
 750                          * holding up the transaction if the data copy hangs
 751                          * up on a pagefault (e.g., from an NFS server mapping).
 752                          */
 753                         size_t cbytes;
 754
 755                         abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
 756                             max_blksz);
 757                         ASSERT(abuf != NULL);
 758                         ASSERT(arc_buf_size(abuf) == max_blksz);
 759                         if ((error = uiocopy(abuf->b_data, max_blksz,
 760                             UIO_WRITE, uio, &cbytes))) {
 761                                 dmu_return_arcbuf(abuf);
 762                                 break;
 763                         }
 764                         ASSERT(cbytes == max_blksz);
 765                 }
 766
 767                 /*
 768                  * Start a transaction.
 769                  */
 770                 tx = dmu_tx_create(zsb->z_os);
 771                 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
 772                 dmu_tx_hold_write(tx, zp->z_id, woff, MIN(n, max_blksz));
 773                 zfs_sa_upgrade_txholds(tx, zp);
 774                 error = dmu_tx_assign(tx, TXG_WAIT);
 775                 if (error) {
 776                         dmu_tx_abort(tx);
 777                         if (abuf != NULL)
 778                                 dmu_return_arcbuf(abuf);
 779                         break;
 780                 }
 781
 782                 /*
 783                  * If zfs_range_lock() over-locked we grow the blocksize
 784                  * and then reduce the lock range.  This will only happen
 785                  * on the first iteration since zfs_range_reduce() will
 786                  * shrink down r_len to the appropriate size.
 787                  */
 788                 if (rl->r_len == UINT64_MAX) {
 789                         uint64_t new_blksz;
 790
 791                         if (zp->z_blksz > max_blksz) {
 792                                 /*
 793                                  * File's blocksize is already larger than the
 794                                  * "recordsize" property.  Only let it grow to
 795                                  * the next power of 2.
 796                                  */
 797                                 ASSERT(!ISP2(zp->z_blksz));
 798                                 new_blksz = MIN(end_size,
 799                                     1 << highbit64(zp->z_blksz));
 800                         } else {
 801                                 new_blksz = MIN(end_size, max_blksz);
 802                         }
 803                         zfs_grow_blocksize(zp, new_blksz, tx);
 804                         zfs_range_reduce(rl, woff, n);
 805                 }
 806
 807                 /*
 808                  * XXX - should we really limit each write to z_max_blksz?
 809                  * Perhaps we should use SPA_MAXBLOCKSIZE chunks?
 810                  */
 811                 nbytes = MIN(n, max_blksz - P2PHASE(woff, max_blksz));
 812
 813                 if (abuf == NULL) {
 814                         tx_bytes = uio->uio_resid;
 815                         error = dmu_write_uio_dbuf(sa_get_db(zp->z_sa_hdl),
 816                             uio, nbytes, tx);
 817                         tx_bytes -= uio->uio_resid;
 818                 } else {
 819                         tx_bytes = nbytes;
 820                         ASSERT(xuio == NULL || tx_bytes == aiov->iov_len);
 821                         /*
 822                          * If this is not a full block write, but we are
 823                          * extending the file past EOF and this data starts
 824                          * block-aligned, use assign_arcbuf().  Otherwise,
 825                          * write via dmu_write().
 826                          */
 827                         if (tx_bytes < max_blksz && (!write_eof ||
 828                             aiov->iov_base != abuf->b_data)) {
 829                                 ASSERT(xuio);
 830                                 dmu_write(zsb->z_os, zp->z_id, woff,
 831                                     aiov->iov_len, aiov->iov_base, tx);
 832                                 dmu_return_arcbuf(abuf);
 833                                 xuio_stat_wbuf_copied();
 834                         } else {
 835                                 ASSERT(xuio || tx_bytes == max_blksz);
 836                                 dmu_assign_arcbuf(sa_get_db(zp->z_sa_hdl),
 837                                     woff, abuf, tx);
 838                         }
 839                         ASSERT(tx_bytes <= uio->uio_resid);
 840                         uioskip(uio, tx_bytes);
 841                 }
 842
 843                 if (tx_bytes && zp->z_is_mapped && !(ioflag & O_DIRECT))
 844                         update_pages(ip, woff, tx_bytes, zsb->z_os, zp->z_id);
 845
 846                 /*
 847                  * If we made no progress, we're done.  If we made even
 848                  * partial progress, update the znode and ZIL accordingly.
 849                  */
 850                 if (tx_bytes == 0) {
 851                         (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zsb),
 852                             (void *)&zp->z_size, sizeof (uint64_t), tx);
 853                         dmu_tx_commit(tx);
 854                         ASSERT(error != 0);
 855                         break;
 856                 }
 857
 858                 /*
 859                  * Clear Set-UID/Set-GID bits on successful write if not
 860                  * privileged and at least one of the execute bits is set.
 861                  *
 862                  * It would be nice to to this after all writes have
 863                  * been done, but that would still expose the ISUID/ISGID
 864                  * to another app after the partial write is committed.
 865                  *
 866                  * Note: we don't call zfs_fuid_map_id() here because
 867                  * user 0 is not an ephemeral uid.
 868                  */
 869                 mutex_enter(&zp->z_acl_lock);
 870                 uid = KUID_TO_SUID(ip->i_uid);
 871                 if ((zp->z_mode & (S_IXUSR | (S_IXUSR >> 3) |
 872                     (S_IXUSR >> 6))) != 0 &&
 873                     (zp->z_mode & (S_ISUID | S_ISGID)) != 0 &&
 874                     secpolicy_vnode_setid_retain(cr,
 875                     ((zp->z_mode & S_ISUID) != 0 && uid == 0)) != 0) {
 876                         uint64_t newmode;
 877                         zp->z_mode &= ~(S_ISUID | S_ISGID);
 878                         ip->i_mode = newmode = zp->z_mode;
 879                         (void) sa_update(zp->z_sa_hdl, SA_ZPL_MODE(zsb),
 880                             (void *)&newmode, sizeof (uint64_t), tx);
 881                 }
 882                 mutex_exit(&zp->z_acl_lock);
 883
 884                 zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
 885
 886                 /*
 887                  * Update the file size (zp_size) if it has changed;
 888                  * account for possible concurrent updates.
 889                  */
 890                 while ((end_size = zp->z_size) < uio->uio_loffset) {
 891                         (void) atomic_cas_64(&zp->z_size, end_size,
 892                             uio->uio_loffset);
 893                         ASSERT(error == 0);
 894                 }
 895                 /*
 896                  * If we are replaying and eof is non zero then force
 897                  * the file size to the specified eof. Note, there's no
 898                  * concurrency during replay.
 899                  */
 900                 if (zsb->z_replay && zsb->z_replay_eof != 0)
 901                         zp->z_size = zsb->z_replay_eof;
 902
 903                 error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
 904
 905                 zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, ioflag,
 906                     NULL, NULL);
 907                 dmu_tx_commit(tx);
 908
 909                 if (error != 0)
 910                         break;
 911                 ASSERT(tx_bytes == nbytes);
 912                 n -= nbytes;
 913
 914                 if (!xuio && n > 0)
 915                         uio_prefaultpages(MIN(n, max_blksz), uio);
 916         }
 917
 918         zfs_inode_update(zp);
 919         zfs_range_unlock(rl);
 920
 921         /*
 922          * If we're in replay mode, or we made no progress, return error.
 923          * Otherwise, it's at least a partial write, so it's successful.
 924          */
 925         if (zsb->z_replay || uio->uio_resid == start_resid) {
 926                 ZFS_EXIT(zsb);
 927                 return (error);
 928         }
 929
 930         if (ioflag & (FSYNC | FDSYNC) ||
 931             zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
 932                 zil_commit(zilog, zp->z_id);
 933
 934         ZFS_EXIT(zsb);
 935         return (0);
 936 }
 937 EXPORT_SYMBOL(zfs_write);
 938
 939 /*
 940  * Drop a reference on the passed inode asynchronously. This ensures
 941  * that the caller will never drop the last reference on an inode in
 942  * the current context. Doing so while holding open a tx could result
 943  * in a deadlock if iput_final() re-enters the filesystem code.
 944  */
 945 void
 946 zfs_iput_async(struct inode *ip)
 947 {
 948         objset_t *os = ITOZSB(ip)->z_os;
 949
 950         ASSERT(atomic_read(&ip->i_count) > 0);
 951         ASSERT(os != NULL);
 952
 953         if (atomic_read(&ip->i_count) == 1)
 954                 VERIFY(taskq_dispatch(dsl_pool_iput_taskq(dmu_objset_pool(os)),
 955                     (task_func_t *)iput, ip, TQ_SLEEP) != TASKQID_INVALID);
 956         else
 957                 iput(ip);
 958 }
 959
 960 void
 961 zfs_get_done(zgd_t *zgd, int error)
 962 {
 963         znode_t *zp = zgd->zgd_private;
 964
 965         if (zgd->zgd_db)
 966                 dmu_buf_rele(zgd->zgd_db, zgd);
 967
 968         zfs_range_unlock(zgd->zgd_rl);
 969
 970         /*
 971          * Release the vnode asynchronously as we currently have the
 972          * txg stopped from syncing.
 973          */
 974         zfs_iput_async(ZTOI(zp));
 975
 976         if (error == 0 && zgd->zgd_bp)
 977                 zil_add_block(zgd->zgd_zilog, zgd->zgd_bp);
 978
 979         kmem_free(zgd, sizeof (zgd_t));
 980 }
 981
 982 #ifdef DEBUG
 983 static int zil_fault_io = 0;
 984 #endif
 985
 986 /*
 987  * Get data to generate a TX_WRITE intent log record.
 988  */
 989 int
 990 zfs_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
 991 {
 992         zfs_sb_t *zsb = arg;
 993         objset_t *os = zsb->z_os;
 994         znode_t *zp;
 995         uint64_t object = lr->lr_foid;
 996         uint64_t offset = lr->lr_offset;
 997         uint64_t size = lr->lr_length;
 998         blkptr_t *bp = &lr->lr_blkptr;
 999         dmu_buf_t *db;
1000         zgd_t *zgd;
1001         int error = 0;
1002
1003         ASSERT(zio != NULL);
1004         ASSERT(size != 0);
1005
1006         /*
1007          * Nothing to do if the file has been removed
1008          */
1009         if (zfs_zget(zsb, object, &zp) != 0)
1010                 return (SET_ERROR(ENOENT));
1011         if (zp->z_unlinked) {
1012                 /*
1013                  * Release the vnode asynchronously as we currently have the
1014                  * txg stopped from syncing.
1015                  */
1016                 zfs_iput_async(ZTOI(zp));
1017                 return (SET_ERROR(ENOENT));
1018         }
1019
1020         zgd = (zgd_t *)kmem_zalloc(sizeof (zgd_t), KM_SLEEP);
1021         zgd->zgd_zilog = zsb->z_log;
1022         zgd->zgd_private = zp;
1023
1024         /*
1025          * Write records come in two flavors: immediate and indirect.
1026          * For small writes it's cheaper to store the data with the
1027          * log record (immediate); for large writes it's cheaper to
1028          * sync the data and get a pointer to it (indirect) so that
1029          * we don't have to write the data twice.
1030          */
1031         if (buf != NULL) { /* immediate write */
1032                 zgd->zgd_rl = zfs_range_lock(&zp->z_range_lock, offset, size,
1033                     RL_READER);
1034                 /* test for truncation needs to be done while range locked */
1035                 if (offset >= zp->z_size) {
1036                         error = SET_ERROR(ENOENT);
1037                 } else {
1038                         error = dmu_read(os, object, offset, size, buf,
1039                             DMU_READ_NO_PREFETCH);
1040                 }
1041                 ASSERT(error == 0 || error == ENOENT);
1042         } else { /* indirect write */
1043                 /*
1044                  * Have to lock the whole block to ensure when it's
1045                  * written out and it's checksum is being calculated
1046                  * that no one can change the data. We need to re-check
1047                  * blocksize after we get the lock in case it's changed!
1048                  */
1049                 for (;;) {
1050                         uint64_t blkoff;
1051                         size = zp->z_blksz;
1052                         blkoff = ISP2(size) ? P2PHASE(offset, size) : offset;
1053                         offset -= blkoff;
1054                         zgd->zgd_rl = zfs_range_lock(&zp->z_range_lock, offset,
1055                             size, RL_READER);
1056                         if (zp->z_blksz == size)
1057                                 break;
1058                         offset += blkoff;
1059                         zfs_range_unlock(zgd->zgd_rl);
1060                 }
1061                 /* test for truncation needs to be done while range locked */
1062                 if (lr->lr_offset >= zp->z_size)
1063                         error = SET_ERROR(ENOENT);
1064 #ifdef DEBUG
1065                 if (zil_fault_io) {
1066                         error = SET_ERROR(EIO);
1067                         zil_fault_io = 0;
1068                 }
1069 #endif
1070                 if (error == 0)
1071                         error = dmu_buf_hold(os, object, offset, zgd, &db,
1072                             DMU_READ_NO_PREFETCH);
1073
1074                 if (error == 0) {
1075                         blkptr_t *obp = dmu_buf_get_blkptr(db);
1076                         if (obp) {
1077                                 ASSERT(BP_IS_HOLE(bp));
1078                                 *bp = *obp;
1079                         }
1080
1081                         zgd->zgd_db = db;
1082                         zgd->zgd_bp = bp;
1083
1084                         ASSERT(db->db_offset == offset);
1085                         ASSERT(db->db_size == size);
1086
1087                         error = dmu_sync(zio, lr->lr_common.lrc_txg,
1088                             zfs_get_done, zgd);
1089                         ASSERT(error || lr->lr_length <= size);
1090
1091                         /*
1092                          * On success, we need to wait for the write I/O
1093                          * initiated by dmu_sync() to complete before we can
1094                          * release this dbuf.  We will finish everything up
1095                          * in the zfs_get_done() callback.
1096                          */
1097                         if (error == 0)
1098                                 return (0);
1099
1100                         if (error == EALREADY) {
1101                                 lr->lr_common.lrc_txtype = TX_WRITE2;
1102                                 error = 0;
1103                         }
1104                 }
1105         }
1106
1107         zfs_get_done(zgd, error);
1108
1109         return (error);
1110 }
1111
1112 /*ARGSUSED*/
1113 int
1114 zfs_access(struct inode *ip, int mode, int flag, cred_t *cr)
1115 {
1116         znode_t *zp = ITOZ(ip);
1117         zfs_sb_t *zsb = ITOZSB(ip);
1118         int error;
1119
1120         ZFS_ENTER(zsb);
1121         ZFS_VERIFY_ZP(zp);
1122
1123         if (flag & V_ACE_MASK)
1124                 error = zfs_zaccess(zp, mode, flag, B_FALSE, cr);
1125         else
1126                 error = zfs_zaccess_rwx(zp, mode, flag, cr);
1127
1128         ZFS_EXIT(zsb);
1129         return (error);
1130 }
1131 EXPORT_SYMBOL(zfs_access);
1132
1133 /*
1134  * Lookup an entry in a directory, or an extended attribute directory.
1135  * If it exists, return a held inode reference for it.
1136  *
1137  *      IN:     dip     - inode of directory to search.
1138  *              nm      - name of entry to lookup.
1139  *              flags   - LOOKUP_XATTR set if looking for an attribute.
1140  *              cr      - credentials of caller.
1141  *              direntflags - directory lookup flags
1142  *              realpnp - returned pathname.
1143  *
1144  *      OUT:    ipp     - inode of located entry, NULL if not found.
1145  *
1146  *      RETURN: 0 on success, error code on failure.
1147  *
1148  * Timestamps:
1149  *      NA
1150  */
1151 /* ARGSUSED */
1152 int
1153 zfs_lookup(struct inode *dip, char *nm, struct inode **ipp, int flags,
1154     cred_t *cr, int *direntflags, pathname_t *realpnp)
1155 {
1156         znode_t *zdp = ITOZ(dip);
1157         zfs_sb_t *zsb = ITOZSB(dip);
1158         int error = 0;
1159
1160         /* fast path */
1161         if (!(flags & (LOOKUP_XATTR | FIGNORECASE))) {
1162
1163                 if (!S_ISDIR(dip->i_mode)) {
1164                         return (SET_ERROR(ENOTDIR));
1165                 } else if (zdp->z_sa_hdl == NULL) {
1166                         return (SET_ERROR(EIO));
1167                 }
1168
1169                 if (nm[0] == 0 || (nm[0] == '.' && nm[1] == '\0')) {
1170                         error = zfs_fastaccesschk_execute(zdp, cr);
1171                         if (!error) {
1172                                 *ipp = dip;
1173                                 igrab(*ipp);
1174                                 return (0);
1175                         }
1176                         return (error);
1177 #ifdef HAVE_DNLC
1178                 } else {
1179                         vnode_t *tvp = dnlc_lookup(dvp, nm);
1180
1181                         if (tvp) {
1182                                 error = zfs_fastaccesschk_execute(zdp, cr);
1183                                 if (error) {
1184                                         iput(tvp);
1185                                         return (error);
1186                                 }
1187                                 if (tvp == DNLC_NO_VNODE) {
1188                                         iput(tvp);
1189                                         return (SET_ERROR(ENOENT));
1190                                 } else {
1191                                         *vpp = tvp;
1192                                         return (specvp_check(vpp, cr));
1193                                 }
1194                         }
1195 #endif /* HAVE_DNLC */
1196                 }
1197         }
1198
1199         ZFS_ENTER(zsb);
1200         ZFS_VERIFY_ZP(zdp);
1201
1202         *ipp = NULL;
1203
1204         if (flags & LOOKUP_XATTR) {
1205                 /*
1206                  * We don't allow recursive attributes..
1207                  * Maybe someday we will.
1208                  */
1209                 if (zdp->z_pflags & ZFS_XATTR) {
1210                         ZFS_EXIT(zsb);
1211                         return (SET_ERROR(EINVAL));
1212                 }
1213
1214                 if ((error = zfs_get_xattrdir(zdp, ipp, cr, flags))) {
1215                         ZFS_EXIT(zsb);
1216                         return (error);
1217                 }
1218
1219                 /*
1220                  * Do we have permission to get into attribute directory?
1221                  */
1222
1223                 if ((error = zfs_zaccess(ITOZ(*ipp), ACE_EXECUTE, 0,
1224                     B_FALSE, cr))) {
1225                         iput(*ipp);
1226                         *ipp = NULL;
1227                 }
1228
1229                 ZFS_EXIT(zsb);
1230                 return (error);
1231         }
1232
1233         if (!S_ISDIR(dip->i_mode)) {
1234                 ZFS_EXIT(zsb);
1235                 return (SET_ERROR(ENOTDIR));
1236         }
1237
1238         /*
1239          * Check accessibility of directory.
1240          */
1241
1242         if ((error = zfs_zaccess(zdp, ACE_EXECUTE, 0, B_FALSE, cr))) {
1243                 ZFS_EXIT(zsb);
1244                 return (error);
1245         }
1246
1247         if (zsb->z_utf8 && u8_validate(nm, strlen(nm),
1248             NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
1249                 ZFS_EXIT(zsb);
1250                 return (SET_ERROR(EILSEQ));
1251         }
1252
1253         error = zfs_dirlook(zdp, nm, ipp, flags, direntflags, realpnp);
1254         if ((error == 0) && (*ipp))
1255                 zfs_inode_update(ITOZ(*ipp));
1256
1257         ZFS_EXIT(zsb);
1258         return (error);
1259 }
1260 EXPORT_SYMBOL(zfs_lookup);
1261
1262 /*
1263  * Attempt to create a new entry in a directory.  If the entry
1264  * already exists, truncate the file if permissible, else return
1265  * an error.  Return the ip of the created or trunc'd file.
1266  *
1267  *      IN:     dip     - inode of directory to put new file entry in.
1268  *              name    - name of new file entry.
1269  *              vap     - attributes of new file.
1270  *              excl    - flag indicating exclusive or non-exclusive mode.
1271  *              mode    - mode to open file with.
1272  *              cr      - credentials of caller.
1273  *              flag    - large file flag [UNUSED].
1274  *              vsecp   - ACL to be set
1275  *
1276  *      OUT:    ipp     - inode of created or trunc'd entry.
1277  *
1278  *      RETURN: 0 on success, error code on failure.
1279  *
1280  * Timestamps:
1281  *      dip - ctime|mtime updated if new entry created
1282  *       ip - ctime|mtime always, atime if new
1283  */
1284
1285 /* ARGSUSED */
1286 int
1287 zfs_create(struct inode *dip, char *name, vattr_t *vap, int excl,
1288     int mode, struct inode **ipp, cred_t *cr, int flag, vsecattr_t *vsecp)
1289 {
1290         znode_t         *zp, *dzp = ITOZ(dip);
1291         zfs_sb_t        *zsb = ITOZSB(dip);
1292         zilog_t         *zilog;
1293         objset_t        *os;
1294         zfs_dirlock_t   *dl;
1295         dmu_tx_t        *tx;
1296         int             error;
1297         uid_t           uid;
1298         gid_t           gid;
1299         zfs_acl_ids_t   acl_ids;
1300         boolean_t       fuid_dirtied;
1301         boolean_t       have_acl = B_FALSE;
1302         boolean_t       waited = B_FALSE;
1303
1304         /*
1305          * If we have an ephemeral id, ACL, or XVATTR then
1306          * make sure file system is at proper version
1307          */
1308
1309         gid = crgetgid(cr);
1310         uid = crgetuid(cr);
1311
1312         if (zsb->z_use_fuids == B_FALSE &&
1313             (vsecp || IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid)))
1314                 return (SET_ERROR(EINVAL));
1315
1316         if (name == NULL)
1317                 return (SET_ERROR(EINVAL));
1318
1319         ZFS_ENTER(zsb);
1320         ZFS_VERIFY_ZP(dzp);
1321         os = zsb->z_os;
1322         zilog = zsb->z_log;
1323
1324         if (zsb->z_utf8 && u8_validate(name, strlen(name),
1325             NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
1326                 ZFS_EXIT(zsb);
1327                 return (SET_ERROR(EILSEQ));
1328         }
1329
1330         if (vap->va_mask & ATTR_XVATTR) {
1331                 if ((error = secpolicy_xvattr((xvattr_t *)vap,
1332                     crgetuid(cr), cr, vap->va_mode)) != 0) {
1333                         ZFS_EXIT(zsb);
1334                         return (error);
1335                 }
1336         }
1337
1338 top:
1339         *ipp = NULL;
1340         if (*name == '\0') {
1341                 /*
1342                  * Null component name refers to the directory itself.
1343                  */
1344                 igrab(dip);
1345                 zp = dzp;
1346                 dl = NULL;
1347                 error = 0;
1348         } else {
1349                 /* possible igrab(zp) */
1350                 int zflg = 0;
1351
1352                 if (flag & FIGNORECASE)
1353                         zflg |= ZCILOOK;
1354
1355                 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
1356                     NULL, NULL);
1357                 if (error) {
1358                         if (have_acl)
1359                                 zfs_acl_ids_free(&acl_ids);
1360                         if (strcmp(name, "..") == 0)
1361                                 error = SET_ERROR(EISDIR);
1362                         ZFS_EXIT(zsb);
1363                         return (error);
1364                 }
1365         }
1366
1367         if (zp == NULL) {
1368                 uint64_t txtype;
1369
1370                 /*
1371                  * Create a new file object and update the directory
1372                  * to reference it.
1373                  */
1374                 if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
1375                         if (have_acl)
1376                                 zfs_acl_ids_free(&acl_ids);
1377                         goto out;
1378                 }
1379
1380                 /*
1381                  * We only support the creation of regular files in
1382                  * extended attribute directories.
1383                  */
1384
1385                 if ((dzp->z_pflags & ZFS_XATTR) && !S_ISREG(vap->va_mode)) {
1386                         if (have_acl)
1387                                 zfs_acl_ids_free(&acl_ids);
1388                         error = SET_ERROR(EINVAL);
1389                         goto out;
1390                 }
1391
1392                 if (!have_acl && (error = zfs_acl_ids_create(dzp, 0, vap,
1393                     cr, vsecp, &acl_ids)) != 0)
1394                         goto out;
1395                 have_acl = B_TRUE;
1396
1397                 if (zfs_acl_ids_overquota(zsb, &acl_ids)) {
1398                         zfs_acl_ids_free(&acl_ids);
1399                         error = SET_ERROR(EDQUOT);
1400                         goto out;
1401                 }
1402
1403                 tx = dmu_tx_create(os);
1404
1405                 dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
1406                     ZFS_SA_BASE_ATTR_SIZE);
1407
1408                 fuid_dirtied = zsb->z_fuid_dirty;
1409                 if (fuid_dirtied)
1410                         zfs_fuid_txhold(zsb, tx);
1411                 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
1412                 dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
1413                 if (!zsb->z_use_sa &&
1414                     acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
1415                         dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
1416                             0, acl_ids.z_aclp->z_acl_bytes);
1417                 }
1418                 error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
1419                 if (error) {
1420                         zfs_dirent_unlock(dl);
1421                         if (error == ERESTART) {
1422                                 waited = B_TRUE;
1423                                 dmu_tx_wait(tx);
1424                                 dmu_tx_abort(tx);
1425                                 goto top;
1426                         }
1427                         zfs_acl_ids_free(&acl_ids);
1428                         dmu_tx_abort(tx);
1429                         ZFS_EXIT(zsb);
1430                         return (error);
1431                 }
1432                 zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
1433
1434                 if (fuid_dirtied)
1435                         zfs_fuid_sync(zsb, tx);
1436
1437                 (void) zfs_link_create(dl, zp, tx, ZNEW);
1438                 txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap);
1439                 if (flag & FIGNORECASE)
1440                         txtype |= TX_CI;
1441                 zfs_log_create(zilog, tx, txtype, dzp, zp, name,
1442                     vsecp, acl_ids.z_fuidp, vap);
1443                 zfs_acl_ids_free(&acl_ids);
1444                 dmu_tx_commit(tx);
1445         } else {
1446                 int aflags = (flag & FAPPEND) ? V_APPEND : 0;
1447
1448                 if (have_acl)
1449                         zfs_acl_ids_free(&acl_ids);
1450                 have_acl = B_FALSE;
1451
1452                 /*
1453                  * A directory entry already exists for this name.
1454                  */
1455                 /*
1456                  * Can't truncate an existing file if in exclusive mode.
1457                  */
1458                 if (excl) {
1459                         error = SET_ERROR(EEXIST);
1460                         goto out;
1461                 }
1462                 /*
1463                  * Can't open a directory for writing.
1464                  */
1465                 if (S_ISDIR(ZTOI(zp)->i_mode)) {
1466                         error = SET_ERROR(EISDIR);
1467                         goto out;
1468                 }
1469                 /*
1470                  * Verify requested access to file.
1471                  */
1472                 if (mode && (error = zfs_zaccess_rwx(zp, mode, aflags, cr))) {
1473                         goto out;
1474                 }
1475
1476                 mutex_enter(&dzp->z_lock);
1477                 dzp->z_seq++;
1478                 mutex_exit(&dzp->z_lock);
1479
1480                 /*
1481                  * Truncate regular files if requested.
1482                  */
1483                 if (S_ISREG(ZTOI(zp)->i_mode) &&
1484                     (vap->va_mask & ATTR_SIZE) && (vap->va_size == 0)) {
1485                         /* we can't hold any locks when calling zfs_freesp() */
1486                         if (dl) {
1487                                 zfs_dirent_unlock(dl);
1488                                 dl = NULL;
1489                         }
1490                         error = zfs_freesp(zp, 0, 0, mode, TRUE);
1491                 }
1492         }
1493 out:
1494
1495         if (dl)
1496                 zfs_dirent_unlock(dl);
1497
1498         if (error) {
1499                 if (zp)
1500                         iput(ZTOI(zp));
1501         } else {
1502                 zfs_inode_update(dzp);
1503                 zfs_inode_update(zp);
1504                 *ipp = ZTOI(zp);
1505         }
1506
1507         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
1508                 zil_commit(zilog, 0);
1509
1510         ZFS_EXIT(zsb);
1511         return (error);
1512 }
1513 EXPORT_SYMBOL(zfs_create);
1514
1515 /* ARGSUSED */
1516 int
1517 zfs_tmpfile(struct inode *dip, vattr_t *vap, int excl,
1518     int mode, struct inode **ipp, cred_t *cr, int flag, vsecattr_t *vsecp)
1519 {
1520         znode_t         *zp = NULL, *dzp = ITOZ(dip);
1521         zfs_sb_t        *zsb = ITOZSB(dip);
1522         objset_t        *os;
1523         dmu_tx_t        *tx;
1524         int             error;
1525         uid_t           uid;
1526         gid_t           gid;
1527         zfs_acl_ids_t   acl_ids;
1528         boolean_t       fuid_dirtied;
1529         boolean_t       have_acl = B_FALSE;
1530         boolean_t       waited = B_FALSE;
1531
1532         /*
1533          * If we have an ephemeral id, ACL, or XVATTR then
1534          * make sure file system is at proper version
1535          */
1536
1537         gid = crgetgid(cr);
1538         uid = crgetuid(cr);
1539
1540         if (zsb->z_use_fuids == B_FALSE &&
1541             (vsecp || IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid)))
1542                 return (SET_ERROR(EINVAL));
1543
1544         ZFS_ENTER(zsb);
1545         ZFS_VERIFY_ZP(dzp);
1546         os = zsb->z_os;
1547
1548         if (vap->va_mask & ATTR_XVATTR) {
1549                 if ((error = secpolicy_xvattr((xvattr_t *)vap,
1550                     crgetuid(cr), cr, vap->va_mode)) != 0) {
1551                         ZFS_EXIT(zsb);
1552                         return (error);
1553                 }
1554         }
1555
1556 top:
1557         *ipp = NULL;
1558
1559         /*
1560          * Create a new file object and update the directory
1561          * to reference it.
1562          */
1563         if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
1564                 if (have_acl)
1565                         zfs_acl_ids_free(&acl_ids);
1566                 goto out;
1567         }
1568
1569         if (!have_acl && (error = zfs_acl_ids_create(dzp, 0, vap,
1570             cr, vsecp, &acl_ids)) != 0)
1571                 goto out;
1572         have_acl = B_TRUE;
1573
1574         if (zfs_acl_ids_overquota(zsb, &acl_ids)) {
1575                 zfs_acl_ids_free(&acl_ids);
1576                 error = SET_ERROR(EDQUOT);
1577                 goto out;
1578         }
1579
1580         tx = dmu_tx_create(os);
1581
1582         dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
1583             ZFS_SA_BASE_ATTR_SIZE);
1584         dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
1585
1586         fuid_dirtied = zsb->z_fuid_dirty;
1587         if (fuid_dirtied)
1588                 zfs_fuid_txhold(zsb, tx);
1589         if (!zsb->z_use_sa &&
1590             acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
1591                 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
1592                     0, acl_ids.z_aclp->z_acl_bytes);
1593         }
1594         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
1595         if (error) {
1596                 if (error == ERESTART) {
1597                         waited = B_TRUE;
1598                         dmu_tx_wait(tx);
1599                         dmu_tx_abort(tx);
1600                         goto top;
1601                 }
1602                 zfs_acl_ids_free(&acl_ids);
1603                 dmu_tx_abort(tx);
1604                 ZFS_EXIT(zsb);
1605                 return (error);
1606         }
1607         zfs_mknode(dzp, vap, tx, cr, IS_TMPFILE, &zp, &acl_ids);
1608
1609         if (fuid_dirtied)
1610                 zfs_fuid_sync(zsb, tx);
1611
1612         /* Add to unlinked set */
1613         zp->z_unlinked = 1;
1614         zfs_unlinked_add(zp, tx);
1615         zfs_acl_ids_free(&acl_ids);
1616         dmu_tx_commit(tx);
1617 out:
1618
1619         if (error) {
1620                 if (zp)
1621                         iput(ZTOI(zp));
1622         } else {
1623                 zfs_inode_update(dzp);
1624                 zfs_inode_update(zp);
1625                 *ipp = ZTOI(zp);
1626         }
1627
1628         ZFS_EXIT(zsb);
1629         return (error);
1630 }
1631
1632 /*
1633  * Remove an entry from a directory.
1634  *
1635  *      IN:     dip     - inode of directory to remove entry from.
1636  *              name    - name of entry to remove.
1637  *              cr      - credentials of caller.
1638  *
1639  *      RETURN: 0 if success
1640  *              error code if failure
1641  *
1642  * Timestamps:
1643  *      dip - ctime|mtime
1644  *       ip - ctime (if nlink > 0)
1645  */
1646
1647 uint64_t null_xattr = 0;
1648
1649 /*ARGSUSED*/
1650 int
1651 zfs_remove(struct inode *dip, char *name, cred_t *cr, int flags)
1652 {
1653         znode_t         *zp, *dzp = ITOZ(dip);
1654         znode_t         *xzp;
1655         struct inode    *ip;
1656         zfs_sb_t        *zsb = ITOZSB(dip);
1657         zilog_t         *zilog;
1658         uint64_t        acl_obj, xattr_obj;
1659         uint64_t        xattr_obj_unlinked = 0;
1660         uint64_t        obj = 0;
1661         uint64_t        links;
1662         zfs_dirlock_t   *dl;
1663         dmu_tx_t        *tx;
1664         boolean_t       may_delete_now, delete_now = FALSE;
1665         boolean_t       unlinked, toobig = FALSE;
1666         uint64_t        txtype;
1667         pathname_t      *realnmp = NULL;
1668         pathname_t      realnm;
1669         int             error;
1670         int             zflg = ZEXISTS;
1671         boolean_t       waited = B_FALSE;
1672
1673         if (name == NULL)
1674                 return (SET_ERROR(EINVAL));
1675
1676         ZFS_ENTER(zsb);
1677         ZFS_VERIFY_ZP(dzp);
1678         zilog = zsb->z_log;
1679
1680         if (flags & FIGNORECASE) {
1681                 zflg |= ZCILOOK;
1682                 pn_alloc(&realnm);
1683                 realnmp = &realnm;
1684         }
1685
1686 top:
1687         xattr_obj = 0;
1688         xzp = NULL;
1689         /*
1690          * Attempt to lock directory; fail if entry doesn't exist.
1691          */
1692         if ((error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
1693             NULL, realnmp))) {
1694                 if (realnmp)
1695                         pn_free(realnmp);
1696                 ZFS_EXIT(zsb);
1697                 return (error);
1698         }
1699
1700         ip = ZTOI(zp);
1701
1702         if ((error = zfs_zaccess_delete(dzp, zp, cr))) {
1703                 goto out;
1704         }
1705
1706         /*
1707          * Need to use rmdir for removing directories.
1708          */
1709         if (S_ISDIR(ip->i_mode)) {
1710                 error = SET_ERROR(EPERM);
1711                 goto out;
1712         }
1713
1714 #ifdef HAVE_DNLC
1715         if (realnmp)
1716                 dnlc_remove(dvp, realnmp->pn_buf);
1717         else
1718                 dnlc_remove(dvp, name);
1719 #endif /* HAVE_DNLC */
1720
1721         mutex_enter(&zp->z_lock);
1722         may_delete_now = atomic_read(&ip->i_count) == 1 && !(zp->z_is_mapped);
1723         mutex_exit(&zp->z_lock);
1724
1725         /*
1726          * We may delete the znode now, or we may put it in the unlinked set;
1727          * it depends on whether we're the last link, and on whether there are
1728          * other holds on the inode.  So we dmu_tx_hold() the right things to
1729          * allow for either case.
1730          */
1731         obj = zp->z_id;
1732         tx = dmu_tx_create(zsb->z_os);
1733         dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
1734         dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
1735         zfs_sa_upgrade_txholds(tx, zp);
1736         zfs_sa_upgrade_txholds(tx, dzp);
1737         if (may_delete_now) {
1738                 toobig = zp->z_size > zp->z_blksz * zfs_delete_blocks;
1739                 /* if the file is too big, only hold_free a token amount */
1740                 dmu_tx_hold_free(tx, zp->z_id, 0,
1741                     (toobig ? DMU_MAX_ACCESS : DMU_OBJECT_END));
1742         }
1743
1744         /* are there any extended attributes? */
1745         error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zsb),
1746             &xattr_obj, sizeof (xattr_obj));
1747         if (error == 0 && xattr_obj) {
1748                 error = zfs_zget(zsb, xattr_obj, &xzp);
1749                 ASSERT0(error);
1750                 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
1751                 dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
1752         }
1753
1754         mutex_enter(&zp->z_lock);
1755         if ((acl_obj = zfs_external_acl(zp)) != 0 && may_delete_now)
1756                 dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
1757         mutex_exit(&zp->z_lock);
1758
1759         /* charge as an update -- would be nice not to charge at all */
1760         dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
1761
1762         /*
1763          * Mark this transaction as typically resulting in a net free of space
1764          */
1765         dmu_tx_mark_netfree(tx);
1766
1767         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
1768         if (error) {
1769                 zfs_dirent_unlock(dl);
1770                 iput(ip);
1771                 if (xzp)
1772                         iput(ZTOI(xzp));
1773                 if (error == ERESTART) {
1774                         waited = B_TRUE;
1775                         dmu_tx_wait(tx);
1776                         dmu_tx_abort(tx);
1777                         goto top;
1778                 }
1779                 if (realnmp)
1780                         pn_free(realnmp);
1781                 dmu_tx_abort(tx);
1782                 ZFS_EXIT(zsb);
1783                 return (error);
1784         }
1785
1786         /*
1787          * Remove the directory entry.
1788          */
1789         error = zfs_link_destroy(dl, zp, tx, zflg, &unlinked);
1790
1791         if (error) {
1792                 dmu_tx_commit(tx);
1793                 goto out;
1794         }
1795
1796         if (unlinked) {
1797                 /*
1798                  * Hold z_lock so that we can make sure that the ACL obj
1799                  * hasn't changed.  Could have been deleted due to
1800                  * zfs_sa_upgrade().
1801                  */
1802                 mutex_enter(&zp->z_lock);
1803                 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zsb),
1804                     &xattr_obj_unlinked, sizeof (xattr_obj_unlinked));
1805                 delete_now = may_delete_now && !toobig &&
1806                     atomic_read(&ip->i_count) == 1 && !(zp->z_is_mapped) &&
1807                     xattr_obj == xattr_obj_unlinked && zfs_external_acl(zp) ==
1808                     acl_obj;
1809         }
1810
1811         if (delete_now) {
1812                 if (xattr_obj_unlinked) {
1813                         ASSERT3U(ZTOI(xzp)->i_nlink, ==, 2);
1814                         mutex_enter(&xzp->z_lock);
1815                         xzp->z_unlinked = 1;
1816                         clear_nlink(ZTOI(xzp));
1817                         links = 0;
1818                         error = sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zsb),
1819                             &links, sizeof (links), tx);
1820                         ASSERT3U(error,  ==,  0);
1821                         mutex_exit(&xzp->z_lock);
1822                         zfs_unlinked_add(xzp, tx);
1823
1824                         if (zp->z_is_sa)
1825                                 error = sa_remove(zp->z_sa_hdl,
1826                                     SA_ZPL_XATTR(zsb), tx);
1827                         else
1828                                 error = sa_update(zp->z_sa_hdl,
1829                                     SA_ZPL_XATTR(zsb), &null_xattr,
1830                                     sizeof (uint64_t), tx);
1831                         ASSERT0(error);
1832                 }
1833                 /*
1834                  * Add to the unlinked set because a new reference could be
1835                  * taken concurrently resulting in a deferred destruction.
1836                  */
1837                 zfs_unlinked_add(zp, tx);
1838                 mutex_exit(&zp->z_lock);
1839                 zfs_inode_update(zp);
1840                 iput(ip);
1841         } else if (unlinked) {
1842                 mutex_exit(&zp->z_lock);
1843                 zfs_unlinked_add(zp, tx);
1844         }
1845
1846         txtype = TX_REMOVE;
1847         if (flags & FIGNORECASE)
1848                 txtype |= TX_CI;
1849         zfs_log_remove(zilog, tx, txtype, dzp, name, obj);
1850
1851         dmu_tx_commit(tx);
1852 out:
1853         if (realnmp)
1854                 pn_free(realnmp);
1855
1856         zfs_dirent_unlock(dl);
1857         zfs_inode_update(dzp);
1858
1859         if (!delete_now) {
1860                 zfs_inode_update(zp);
1861                 zfs_iput_async(ip);
1862         }
1863
1864         if (xzp) {
1865                 zfs_inode_update(xzp);
1866                 zfs_iput_async(ZTOI(xzp));
1867         }
1868
1869         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
1870                 zil_commit(zilog, 0);
1871
1872         ZFS_EXIT(zsb);
1873         return (error);
1874 }
1875 EXPORT_SYMBOL(zfs_remove);
1876
1877 /*
1878  * Create a new directory and insert it into dip using the name
1879  * provided.  Return a pointer to the inserted directory.
1880  *
1881  *      IN:     dip     - inode of directory to add subdir to.
1882  *              dirname - name of new directory.
1883  *              vap     - attributes of new directory.
1884  *              cr      - credentials of caller.
1885  *              vsecp   - ACL to be set
1886  *
1887  *      OUT:    ipp     - inode of created directory.
1888  *
1889  *      RETURN: 0 if success
1890  *              error code if failure
1891  *
1892  * Timestamps:
1893  *      dip - ctime|mtime updated
1894  *      ipp - ctime|mtime|atime updated
1895  */
1896 /*ARGSUSED*/
1897 int
1898 zfs_mkdir(struct inode *dip, char *dirname, vattr_t *vap, struct inode **ipp,
1899     cred_t *cr, int flags, vsecattr_t *vsecp)
1900 {
1901         znode_t         *zp, *dzp = ITOZ(dip);
1902         zfs_sb_t        *zsb = ITOZSB(dip);
1903         zilog_t         *zilog;
1904         zfs_dirlock_t   *dl;
1905         uint64_t        txtype;
1906         dmu_tx_t        *tx;
1907         int             error;
1908         int             zf = ZNEW;
1909         uid_t           uid;
1910         gid_t           gid = crgetgid(cr);
1911         zfs_acl_ids_t   acl_ids;
1912         boolean_t       fuid_dirtied;
1913         boolean_t       waited = B_FALSE;
1914
1915         ASSERT(S_ISDIR(vap->va_mode));
1916
1917         /*
1918          * If we have an ephemeral id, ACL, or XVATTR then
1919          * make sure file system is at proper version
1920          */
1921
1922         uid = crgetuid(cr);
1923         if (zsb->z_use_fuids == B_FALSE &&
1924             (vsecp || IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid)))
1925                 return (SET_ERROR(EINVAL));
1926
1927         if (dirname == NULL)
1928                 return (SET_ERROR(EINVAL));
1929
1930         ZFS_ENTER(zsb);
1931         ZFS_VERIFY_ZP(dzp);
1932         zilog = zsb->z_log;
1933
1934         if (dzp->z_pflags & ZFS_XATTR) {
1935                 ZFS_EXIT(zsb);
1936                 return (SET_ERROR(EINVAL));
1937         }
1938
1939         if (zsb->z_utf8 && u8_validate(dirname,
1940             strlen(dirname), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
1941                 ZFS_EXIT(zsb);
1942                 return (SET_ERROR(EILSEQ));
1943         }
1944         if (flags & FIGNORECASE)
1945                 zf |= ZCILOOK;
1946
1947         if (vap->va_mask & ATTR_XVATTR) {
1948                 if ((error = secpolicy_xvattr((xvattr_t *)vap,
1949                     crgetuid(cr), cr, vap->va_mode)) != 0) {
1950                         ZFS_EXIT(zsb);
1951                         return (error);
1952                 }
1953         }
1954
1955         if ((error = zfs_acl_ids_create(dzp, 0, vap, cr,
1956             vsecp, &acl_ids)) != 0) {
1957                 ZFS_EXIT(zsb);
1958                 return (error);
1959         }
1960         /*
1961          * First make sure the new directory doesn't exist.
1962          *
1963          * Existence is checked first to make sure we don't return
1964          * EACCES instead of EEXIST which can cause some applications
1965          * to fail.
1966          */
1967 top:
1968         *ipp = NULL;
1969
1970         if ((error = zfs_dirent_lock(&dl, dzp, dirname, &zp, zf,
1971             NULL, NULL))) {
1972                 zfs_acl_ids_free(&acl_ids);
1973                 ZFS_EXIT(zsb);
1974                 return (error);
1975         }
1976
1977         if ((error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr))) {
1978                 zfs_acl_ids_free(&acl_ids);
1979                 zfs_dirent_unlock(dl);
1980                 ZFS_EXIT(zsb);
1981                 return (error);
1982         }
1983
1984         if (zfs_acl_ids_overquota(zsb, &acl_ids)) {
1985                 zfs_acl_ids_free(&acl_ids);
1986                 zfs_dirent_unlock(dl);
1987                 ZFS_EXIT(zsb);
1988                 return (SET_ERROR(EDQUOT));
1989         }
1990
1991         /*
1992          * Add a new entry to the directory.
1993          */
1994         tx = dmu_tx_create(zsb->z_os);
1995         dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname);
1996         dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
1997         fuid_dirtied = zsb->z_fuid_dirty;
1998         if (fuid_dirtied)
1999                 zfs_fuid_txhold(zsb, tx);
2000         if (!zsb->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
2001                 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
2002                     acl_ids.z_aclp->z_acl_bytes);
2003         }
2004
2005         dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
2006             ZFS_SA_BASE_ATTR_SIZE);
2007
2008         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
2009         if (error) {
2010                 zfs_dirent_unlock(dl);
2011                 if (error == ERESTART) {
2012                         waited = B_TRUE;
2013                         dmu_tx_wait(tx);
2014                         dmu_tx_abort(tx);
2015                         goto top;
2016                 }
2017                 zfs_acl_ids_free(&acl_ids);
2018                 dmu_tx_abort(tx);
2019                 ZFS_EXIT(zsb);
2020                 return (error);
2021         }
2022
2023         /*
2024          * Create new node.
2025          */
2026         zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
2027
2028         if (fuid_dirtied)
2029                 zfs_fuid_sync(zsb, tx);
2030
2031         /*
2032          * Now put new name in parent dir.
2033          */
2034         (void) zfs_link_create(dl, zp, tx, ZNEW);
2035
2036         *ipp = ZTOI(zp);
2037
2038         txtype = zfs_log_create_txtype(Z_DIR, vsecp, vap);
2039         if (flags & FIGNORECASE)
2040                 txtype |= TX_CI;
2041         zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, vsecp,
2042             acl_ids.z_fuidp, vap);
2043
2044         zfs_acl_ids_free(&acl_ids);
2045
2046         dmu_tx_commit(tx);
2047
2048         zfs_dirent_unlock(dl);
2049
2050         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
2051                 zil_commit(zilog, 0);
2052
2053         zfs_inode_update(dzp);
2054         zfs_inode_update(zp);
2055         ZFS_EXIT(zsb);
2056         return (0);
2057 }
2058 EXPORT_SYMBOL(zfs_mkdir);
2059
2060 /*
2061  * Remove a directory subdir entry.  If the current working
2062  * directory is the same as the subdir to be removed, the
2063  * remove will fail.
2064  *
2065  *      IN:     dip     - inode of directory to remove from.
2066  *              name    - name of directory to be removed.
2067  *              cwd     - inode of current working directory.
2068  *              cr      - credentials of caller.
2069  *              flags   - case flags
2070  *
2071  *      RETURN: 0 on success, error code on failure.
2072  *
2073  * Timestamps:
2074  *      dip - ctime|mtime updated
2075  */
2076 /*ARGSUSED*/
2077 int
2078 zfs_rmdir(struct inode *dip, char *name, struct inode *cwd, cred_t *cr,
2079     int flags)
2080 {
2081         znode_t         *dzp = ITOZ(dip);
2082         znode_t         *zp;
2083         struct inode    *ip;
2084         zfs_sb_t        *zsb = ITOZSB(dip);
2085         zilog_t         *zilog;
2086         zfs_dirlock_t   *dl;
2087         dmu_tx_t        *tx;
2088         int             error;
2089         int             zflg = ZEXISTS;
2090         boolean_t       waited = B_FALSE;
2091
2092         if (name == NULL)
2093                 return (SET_ERROR(EINVAL));
2094
2095         ZFS_ENTER(zsb);
2096         ZFS_VERIFY_ZP(dzp);
2097         zilog = zsb->z_log;
2098
2099         if (flags & FIGNORECASE)
2100                 zflg |= ZCILOOK;
2101 top:
2102         zp = NULL;
2103
2104         /*
2105          * Attempt to lock directory; fail if entry doesn't exist.
2106          */
2107         if ((error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
2108             NULL, NULL))) {
2109                 ZFS_EXIT(zsb);
2110                 return (error);
2111         }
2112
2113         ip = ZTOI(zp);
2114
2115         if ((error = zfs_zaccess_delete(dzp, zp, cr))) {
2116                 goto out;
2117         }
2118
2119         if (!S_ISDIR(ip->i_mode)) {
2120                 error = SET_ERROR(ENOTDIR);
2121                 goto out;
2122         }
2123
2124         if (ip == cwd) {
2125                 error = SET_ERROR(EINVAL);
2126                 goto out;
2127         }
2128
2129         /*
2130          * Grab a lock on the directory to make sure that no one is
2131          * trying to add (or lookup) entries while we are removing it.
2132          */
2133         rw_enter(&zp->z_name_lock, RW_WRITER);
2134
2135         /*
2136          * Grab a lock on the parent pointer to make sure we play well
2137          * with the treewalk and directory rename code.
2138          */
2139         rw_enter(&zp->z_parent_lock, RW_WRITER);
2140
2141         tx = dmu_tx_create(zsb->z_os);
2142         dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
2143         dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
2144         dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
2145         zfs_sa_upgrade_txholds(tx, zp);
2146         zfs_sa_upgrade_txholds(tx, dzp);
2147         dmu_tx_mark_netfree(tx);
2148         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
2149         if (error) {
2150                 rw_exit(&zp->z_parent_lock);
2151                 rw_exit(&zp->z_name_lock);
2152                 zfs_dirent_unlock(dl);
2153                 iput(ip);
2154                 if (error == ERESTART) {
2155                         waited = B_TRUE;
2156                         dmu_tx_wait(tx);
2157                         dmu_tx_abort(tx);
2158                         goto top;
2159                 }
2160                 dmu_tx_abort(tx);
2161                 ZFS_EXIT(zsb);
2162                 return (error);
2163         }
2164
2165         error = zfs_link_destroy(dl, zp, tx, zflg, NULL);
2166
2167         if (error == 0) {
2168                 uint64_t txtype = TX_RMDIR;
2169                 if (flags & FIGNORECASE)
2170                         txtype |= TX_CI;
2171                 zfs_log_remove(zilog, tx, txtype, dzp, name, ZFS_NO_OBJECT);
2172         }
2173
2174         dmu_tx_commit(tx);
2175
2176         rw_exit(&zp->z_parent_lock);
2177         rw_exit(&zp->z_name_lock);
2178 out:
2179         zfs_dirent_unlock(dl);
2180
2181         zfs_inode_update(dzp);
2182         zfs_inode_update(zp);
2183         iput(ip);
2184
2185         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
2186                 zil_commit(zilog, 0);
2187
2188         ZFS_EXIT(zsb);
2189         return (error);
2190 }
2191 EXPORT_SYMBOL(zfs_rmdir);
2192
2193 /*
2194  * Read as many directory entries as will fit into the provided
2195  * dirent buffer from the given directory cursor position.
2196  *
2197  *      IN:     ip      - inode of directory to read.
2198  *              dirent  - buffer for directory entries.
2199  *
2200  *      OUT:    dirent  - filler buffer of directory entries.
2201  *
2202  *      RETURN: 0 if success
2203  *              error code if failure
2204  *
2205  * Timestamps:
2206  *      ip - atime updated
2207  *
2208  * Note that the low 4 bits of the cookie returned by zap is always zero.
2209  * This allows us to use the low range for "special" directory entries:
2210  * We use 0 for '.', and 1 for '..'.  If this is the root of the filesystem,
2211  * we use the offset 2 for the '.zfs' directory.
2212  */
2213 /* ARGSUSED */
2214 int
2215 zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
2216 {
2217         znode_t         *zp = ITOZ(ip);
2218         zfs_sb_t        *zsb = ITOZSB(ip);
2219         objset_t        *os;
2220         zap_cursor_t    zc;
2221         zap_attribute_t zap;
2222         int             error;
2223         uint8_t         prefetch;
2224         uint8_t         type;
2225         int             done = 0;
2226         uint64_t        parent;
2227         uint64_t        offset; /* must be unsigned; checks for < 1 */
2228
2229         ZFS_ENTER(zsb);
2230         ZFS_VERIFY_ZP(zp);
2231
2232         if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zsb),
2233             &parent, sizeof (parent))) != 0)
2234                 goto out;
2235
2236         /*
2237          * Quit if directory has been removed (posix)
2238          */
2239         if (zp->z_unlinked)
2240                 goto out;
2241
2242         error = 0;
2243         os = zsb->z_os;
2244         offset = ctx->pos;
2245         prefetch = zp->z_zn_prefetch;
2246
2247         /*
2248          * Initialize the iterator cursor.
2249          */
2250         if (offset <= 3) {
2251                 /*
2252                  * Start iteration from the beginning of the directory.
2253                  */
2254                 zap_cursor_init(&zc, os, zp->z_id);
2255         } else {
2256                 /*
2257                  * The offset is a serialized cursor.
2258                  */
2259                 zap_cursor_init_serialized(&zc, os, zp->z_id, offset);
2260         }
2261
2262         /*
2263          * Transform to file-system independent format
2264          */
2265         while (!done) {
2266                 uint64_t objnum;
2267                 /*
2268                  * Special case `.', `..', and `.zfs'.
2269                  */
2270                 if (offset == 0) {
2271                         (void) strcpy(zap.za_name, ".");
2272                         zap.za_normalization_conflict = 0;
2273                         objnum = zp->z_id;
2274                         type = DT_DIR;
2275                 } else if (offset == 1) {
2276                         (void) strcpy(zap.za_name, "..");
2277                         zap.za_normalization_conflict = 0;
2278                         objnum = parent;
2279                         type = DT_DIR;
2280                 } else if (offset == 2 && zfs_show_ctldir(zp)) {
2281                         (void) strcpy(zap.za_name, ZFS_CTLDIR_NAME);
2282                         zap.za_normalization_conflict = 0;
2283                         objnum = ZFSCTL_INO_ROOT;
2284                         type = DT_DIR;
2285                 } else {
2286                         /*
2287                          * Grab next entry.
2288                          */
2289                         if ((error = zap_cursor_retrieve(&zc, &zap))) {
2290                                 if (error == ENOENT)
2291                                         break;
2292                                 else
2293                                         goto update;
2294                         }
2295
2296                         /*
2297                          * Allow multiple entries provided the first entry is
2298                          * the object id.  Non-zpl consumers may safely make
2299                          * use of the additional space.
2300                          *
2301                          * XXX: This should be a feature flag for compatibility
2302                          */
2303                         if (zap.za_integer_length != 8 ||
2304                             zap.za_num_integers == 0) {
2305                                 cmn_err(CE_WARN, "zap_readdir: bad directory "
2306                                     "entry, obj = %lld, offset = %lld, "
2307                                     "length = %d, num = %lld\n",
2308                                     (u_longlong_t)zp->z_id,
2309                                     (u_longlong_t)offset,
2310                                     zap.za_integer_length,
2311                                     (u_longlong_t)zap.za_num_integers);
2312                                 error = SET_ERROR(ENXIO);
2313                                 goto update;
2314                         }
2315
2316                         objnum = ZFS_DIRENT_OBJ(zap.za_first_integer);
2317                         type = ZFS_DIRENT_TYPE(zap.za_first_integer);
2318                 }
2319
2320                 done = !dir_emit(ctx, zap.za_name, strlen(zap.za_name),
2321                     objnum, type);
2322                 if (done)
2323                         break;
2324
2325                 /* Prefetch znode */
2326                 if (prefetch) {
2327                         dmu_prefetch(os, objnum, 0, 0, 0,
2328                             ZIO_PRIORITY_SYNC_READ);
2329                 }
2330
2331                 /*
2332                  * Move to the next entry, fill in the previous offset.
2333                  */
2334                 if (offset > 2 || (offset == 2 && !zfs_show_ctldir(zp))) {
2335                         zap_cursor_advance(&zc);
2336                         offset = zap_cursor_serialize(&zc);
2337                 } else {
2338                         offset += 1;
2339                 }
2340                 ctx->pos = offset;
2341         }
2342         zp->z_zn_prefetch = B_FALSE; /* a lookup will re-enable pre-fetching */
2343
2344 update:
2345         zap_cursor_fini(&zc);
2346         if (error == ENOENT)
2347                 error = 0;
2348 out:
2349         ZFS_EXIT(zsb);
2350
2351         return (error);
2352 }
2353 EXPORT_SYMBOL(zfs_readdir);
2354
2355 ulong_t zfs_fsync_sync_cnt = 4;
2356
2357 int
2358 zfs_fsync(struct inode *ip, int syncflag, cred_t *cr)
2359 {
2360         znode_t *zp = ITOZ(ip);
2361         zfs_sb_t *zsb = ITOZSB(ip);
2362
2363         (void) tsd_set(zfs_fsyncer_key, (void *)zfs_fsync_sync_cnt);
2364
2365         if (zsb->z_os->os_sync != ZFS_SYNC_DISABLED) {
2366                 ZFS_ENTER(zsb);
2367                 ZFS_VERIFY_ZP(zp);
2368                 zil_commit(zsb->z_log, zp->z_id);
2369                 ZFS_EXIT(zsb);
2370         }
2371         tsd_set(zfs_fsyncer_key, NULL);
2372
2373         return (0);
2374 }
2375 EXPORT_SYMBOL(zfs_fsync);
2376
2377
2378 /*
2379  * Get the requested file attributes and place them in the provided
2380  * vattr structure.
2381  *
2382  *      IN:     ip      - inode of file.
2383  *              vap     - va_mask identifies requested attributes.
2384  *                        If ATTR_XVATTR set, then optional attrs are requested
2385  *              flags   - ATTR_NOACLCHECK (CIFS server context)
2386  *              cr      - credentials of caller.
2387  *
2388  *      OUT:    vap     - attribute values.
2389  *
2390  *      RETURN: 0 (always succeeds)
2391  */
2392 /* ARGSUSED */
2393 int
2394 zfs_getattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
2395 {
2396         znode_t *zp = ITOZ(ip);
2397         zfs_sb_t *zsb = ITOZSB(ip);
2398         int     error = 0;
2399         uint64_t links;
2400         uint64_t atime[2], mtime[2], ctime[2];
2401         xvattr_t *xvap = (xvattr_t *)vap;       /* vap may be an xvattr_t * */
2402         xoptattr_t *xoap = NULL;
2403         boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
2404         sa_bulk_attr_t bulk[3];
2405         int count = 0;
2406
2407         ZFS_ENTER(zsb);
2408         ZFS_VERIFY_ZP(zp);
2409
2410         zfs_fuid_map_ids(zp, cr, &vap->va_uid, &vap->va_gid);
2411
2412         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL, &atime, 16);
2413         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL, &mtime, 16);
2414         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL, &ctime, 16);
2415
2416         if ((error = sa_bulk_lookup(zp->z_sa_hdl, bulk, count)) != 0) {
2417                 ZFS_EXIT(zsb);
2418                 return (error);
2419         }
2420
2421         /*
2422          * If ACL is trivial don't bother looking for ACE_READ_ATTRIBUTES.
2423          * Also, if we are the owner don't bother, since owner should
2424          * always be allowed to read basic attributes of file.
2425          */
2426         if (!(zp->z_pflags & ZFS_ACL_TRIVIAL) &&
2427             (vap->va_uid != crgetuid(cr))) {
2428                 if ((error = zfs_zaccess(zp, ACE_READ_ATTRIBUTES, 0,
2429                     skipaclchk, cr))) {
2430                         ZFS_EXIT(zsb);
2431                         return (error);
2432                 }
2433         }
2434
2435         /*
2436          * Return all attributes.  It's cheaper to provide the answer
2437          * than to determine whether we were asked the question.
2438          */
2439
2440         mutex_enter(&zp->z_lock);
2441         vap->va_type = vn_mode_to_vtype(zp->z_mode);
2442         vap->va_mode = zp->z_mode;
2443         vap->va_fsid = ZTOI(zp)->i_sb->s_dev;
2444         vap->va_nodeid = zp->z_id;
2445         if ((zp->z_id == zsb->z_root) && zfs_show_ctldir(zp))
2446                 links = ZTOI(zp)->i_nlink + 1;
2447         else
2448                 links = ZTOI(zp)->i_nlink;
2449         vap->va_nlink = MIN(links, ZFS_LINK_MAX);
2450         vap->va_size = i_size_read(ip);
2451         vap->va_rdev = ip->i_rdev;
2452         vap->va_seq = ip->i_generation;
2453
2454         /*
2455          * Add in any requested optional attributes and the create time.
2456          * Also set the corresponding bits in the returned attribute bitmap.
2457          */
2458         if ((xoap = xva_getxoptattr(xvap)) != NULL && zsb->z_use_fuids) {
2459                 if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) {
2460                         xoap->xoa_archive =
2461                             ((zp->z_pflags & ZFS_ARCHIVE) != 0);
2462                         XVA_SET_RTN(xvap, XAT_ARCHIVE);
2463                 }
2464
2465                 if (XVA_ISSET_REQ(xvap, XAT_READONLY)) {
2466                         xoap->xoa_readonly =
2467                             ((zp->z_pflags & ZFS_READONLY) != 0);
2468                         XVA_SET_RTN(xvap, XAT_READONLY);
2469                 }
2470
2471                 if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) {
2472                         xoap->xoa_system =
2473                             ((zp->z_pflags & ZFS_SYSTEM) != 0);
2474                         XVA_SET_RTN(xvap, XAT_SYSTEM);
2475                 }
2476
2477                 if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) {
2478                         xoap->xoa_hidden =
2479                             ((zp->z_pflags & ZFS_HIDDEN) != 0);
2480                         XVA_SET_RTN(xvap, XAT_HIDDEN);
2481                 }
2482
2483                 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
2484                         xoap->xoa_nounlink =
2485                             ((zp->z_pflags & ZFS_NOUNLINK) != 0);
2486                         XVA_SET_RTN(xvap, XAT_NOUNLINK);
2487                 }
2488
2489                 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
2490                         xoap->xoa_immutable =
2491                             ((zp->z_pflags & ZFS_IMMUTABLE) != 0);
2492                         XVA_SET_RTN(xvap, XAT_IMMUTABLE);
2493                 }
2494
2495                 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
2496                         xoap->xoa_appendonly =
2497                             ((zp->z_pflags & ZFS_APPENDONLY) != 0);
2498                         XVA_SET_RTN(xvap, XAT_APPENDONLY);
2499                 }
2500
2501                 if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
2502                         xoap->xoa_nodump =
2503                             ((zp->z_pflags & ZFS_NODUMP) != 0);
2504                         XVA_SET_RTN(xvap, XAT_NODUMP);
2505                 }
2506
2507                 if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) {
2508                         xoap->xoa_opaque =
2509                             ((zp->z_pflags & ZFS_OPAQUE) != 0);
2510                         XVA_SET_RTN(xvap, XAT_OPAQUE);
2511                 }
2512
2513                 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
2514                         xoap->xoa_av_quarantined =
2515                             ((zp->z_pflags & ZFS_AV_QUARANTINED) != 0);
2516                         XVA_SET_RTN(xvap, XAT_AV_QUARANTINED);
2517                 }
2518
2519                 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
2520                         xoap->xoa_av_modified =
2521                             ((zp->z_pflags & ZFS_AV_MODIFIED) != 0);
2522                         XVA_SET_RTN(xvap, XAT_AV_MODIFIED);
2523                 }
2524
2525                 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) &&
2526                     S_ISREG(ip->i_mode)) {
2527                         zfs_sa_get_scanstamp(zp, xvap);
2528                 }
2529
2530                 if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) {
2531                         uint64_t times[2];
2532
2533                         (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_CRTIME(zsb),
2534                             times, sizeof (times));
2535                         ZFS_TIME_DECODE(&xoap->xoa_createtime, times);
2536                         XVA_SET_RTN(xvap, XAT_CREATETIME);
2537                 }
2538
2539                 if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
2540                         xoap->xoa_reparse = ((zp->z_pflags & ZFS_REPARSE) != 0);
2541                         XVA_SET_RTN(xvap, XAT_REPARSE);
2542                 }
2543                 if (XVA_ISSET_REQ(xvap, XAT_GEN)) {
2544                         xoap->xoa_generation = ip->i_generation;
2545                         XVA_SET_RTN(xvap, XAT_GEN);
2546                 }
2547
2548                 if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) {
2549                         xoap->xoa_offline =
2550                             ((zp->z_pflags & ZFS_OFFLINE) != 0);
2551                         XVA_SET_RTN(xvap, XAT_OFFLINE);
2552                 }
2553
2554                 if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) {
2555                         xoap->xoa_sparse =
2556                             ((zp->z_pflags & ZFS_SPARSE) != 0);
2557                         XVA_SET_RTN(xvap, XAT_SPARSE);
2558                 }
2559         }
2560
2561         ZFS_TIME_DECODE(&vap->va_atime, atime);
2562         ZFS_TIME_DECODE(&vap->va_mtime, mtime);
2563         ZFS_TIME_DECODE(&vap->va_ctime, ctime);
2564
2565         mutex_exit(&zp->z_lock);
2566
2567         sa_object_size(zp->z_sa_hdl, &vap->va_blksize, &vap->va_nblocks);
2568
2569         if (zp->z_blksz == 0) {
2570                 /*
2571                  * Block size hasn't been set; suggest maximal I/O transfers.
2572                  */
2573                 vap->va_blksize = zsb->z_max_blksz;
2574         }
2575
2576         ZFS_EXIT(zsb);
2577         return (0);
2578 }
2579 EXPORT_SYMBOL(zfs_getattr);
2580
2581 /*
2582  * Get the basic file attributes and place them in the provided kstat
2583  * structure.  The inode is assumed to be the authoritative source
2584  * for most of the attributes.  However, the znode currently has the
2585  * authoritative atime, blksize, and block count.
2586  *
2587  *      IN:     ip      - inode of file.
2588  *
2589  *      OUT:    sp      - kstat values.
2590  *
2591  *      RETURN: 0 (always succeeds)
2592  */
2593 /* ARGSUSED */
2594 int
2595 zfs_getattr_fast(struct inode *ip, struct kstat *sp)
2596 {
2597         znode_t *zp = ITOZ(ip);
2598         zfs_sb_t *zsb = ITOZSB(ip);
2599         uint32_t blksize;
2600         u_longlong_t nblocks;
2601
2602         ZFS_ENTER(zsb);
2603         ZFS_VERIFY_ZP(zp);
2604
2605         mutex_enter(&zp->z_lock);
2606
2607         generic_fillattr(ip, sp);
2608
2609         sa_object_size(zp->z_sa_hdl, &blksize, &nblocks);
2610         sp->blksize = blksize;
2611         sp->blocks = nblocks;
2612
2613         if (unlikely(zp->z_blksz == 0)) {
2614                 /*
2615                  * Block size hasn't been set; suggest maximal I/O transfers.
2616                  */
2617                 sp->blksize = zsb->z_max_blksz;
2618         }
2619
2620         mutex_exit(&zp->z_lock);
2621
2622         /*
2623          * Required to prevent NFS client from detecting different inode
2624          * numbers of snapshot root dentry before and after snapshot mount.
2625          */
2626         if (zsb->z_issnap) {
2627                 if (ip->i_sb->s_root->d_inode == ip)
2628                         sp->ino = ZFSCTL_INO_SNAPDIRS -
2629                             dmu_objset_id(zsb->z_os);
2630         }
2631
2632         ZFS_EXIT(zsb);
2633
2634         return (0);
2635 }
2636 EXPORT_SYMBOL(zfs_getattr_fast);
2637
2638 /*
2639  * Set the file attributes to the values contained in the
2640  * vattr structure.
2641  *
2642  *      IN:     ip      - inode of file to be modified.
2643  *              vap     - new attribute values.
2644  *                        If ATTR_XVATTR set, then optional attrs are being set
2645  *              flags   - ATTR_UTIME set if non-default time values provided.
2646  *                      - ATTR_NOACLCHECK (CIFS context only).
2647  *              cr      - credentials of caller.
2648  *
2649  *      RETURN: 0 if success
2650  *              error code if failure
2651  *
2652  * Timestamps:
2653  *      ip - ctime updated, mtime updated if size changed.
2654  */
2655 /* ARGSUSED */
2656 int
2657 zfs_setattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
2658 {
2659         znode_t         *zp = ITOZ(ip);
2660         zfs_sb_t        *zsb = ITOZSB(ip);
2661         zilog_t         *zilog;
2662         dmu_tx_t        *tx;
2663         vattr_t         oldva;
2664         xvattr_t        *tmpxvattr;
2665         uint_t          mask = vap->va_mask;
2666         uint_t          saved_mask = 0;
2667         int             trim_mask = 0;
2668         uint64_t        new_mode;
2669         uint64_t        new_kuid = 0, new_kgid = 0, new_uid, new_gid;
2670         uint64_t        xattr_obj;
2671         uint64_t        mtime[2], ctime[2], atime[2];
2672         znode_t         *attrzp;
2673         int             need_policy = FALSE;
2674         int             err, err2;
2675         zfs_fuid_info_t *fuidp = NULL;
2676         xvattr_t *xvap = (xvattr_t *)vap;       /* vap may be an xvattr_t * */
2677         xoptattr_t      *xoap;
2678         zfs_acl_t       *aclp;
2679         boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
2680         boolean_t       fuid_dirtied = B_FALSE;
2681         sa_bulk_attr_t  *bulk, *xattr_bulk;
2682         int             count = 0, xattr_count = 0;
2683
2684         if (mask == 0)
2685                 return (0);
2686
2687         ZFS_ENTER(zsb);
2688         ZFS_VERIFY_ZP(zp);
2689
2690         zilog = zsb->z_log;
2691
2692         /*
2693          * Make sure that if we have ephemeral uid/gid or xvattr specified
2694          * that file system is at proper version level
2695          */
2696
2697         if (zsb->z_use_fuids == B_FALSE &&
2698             (((mask & ATTR_UID) && IS_EPHEMERAL(vap->va_uid)) ||
2699             ((mask & ATTR_GID) && IS_EPHEMERAL(vap->va_gid)) ||
2700             (mask & ATTR_XVATTR))) {
2701                 ZFS_EXIT(zsb);
2702                 return (SET_ERROR(EINVAL));
2703         }
2704
2705         if (mask & ATTR_SIZE && S_ISDIR(ip->i_mode)) {
2706                 ZFS_EXIT(zsb);
2707                 return (SET_ERROR(EISDIR));
2708         }
2709
2710         if (mask & ATTR_SIZE && !S_ISREG(ip->i_mode) && !S_ISFIFO(ip->i_mode)) {
2711                 ZFS_EXIT(zsb);
2712                 return (SET_ERROR(EINVAL));
2713         }
2714
2715         /*
2716          * If this is an xvattr_t, then get a pointer to the structure of
2717          * optional attributes.  If this is NULL, then we have a vattr_t.
2718          */
2719         xoap = xva_getxoptattr(xvap);
2720
2721         tmpxvattr = kmem_alloc(sizeof (xvattr_t), KM_SLEEP);
2722         xva_init(tmpxvattr);
2723
2724         bulk = kmem_alloc(sizeof (sa_bulk_attr_t) * 7, KM_SLEEP);
2725         xattr_bulk = kmem_alloc(sizeof (sa_bulk_attr_t) * 7, KM_SLEEP);
2726
2727         /*
2728          * Immutable files can only alter immutable bit and atime
2729          */
2730         if ((zp->z_pflags & ZFS_IMMUTABLE) &&
2731             ((mask & (ATTR_SIZE|ATTR_UID|ATTR_GID|ATTR_MTIME|ATTR_MODE)) ||
2732             ((mask & ATTR_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) {
2733                 err = EPERM;
2734                 goto out3;
2735         }
2736
2737         if ((mask & ATTR_SIZE) && (zp->z_pflags & ZFS_READONLY)) {
2738                 err = EPERM;
2739                 goto out3;
2740         }
2741
2742         /*
2743          * Verify timestamps doesn't overflow 32 bits.
2744          * ZFS can handle large timestamps, but 32bit syscalls can't
2745          * handle times greater than 2039.  This check should be removed
2746          * once large timestamps are fully supported.
2747          */
2748         if (mask & (ATTR_ATIME | ATTR_MTIME)) {
2749                 if (((mask & ATTR_ATIME) &&
2750                     TIMESPEC_OVERFLOW(&vap->va_atime)) ||
2751                     ((mask & ATTR_MTIME) &&
2752                     TIMESPEC_OVERFLOW(&vap->va_mtime))) {
2753                         err = EOVERFLOW;
2754                         goto out3;
2755                 }
2756         }
2757
2758 top:
2759         attrzp = NULL;
2760         aclp = NULL;
2761
2762         /* Can this be moved to before the top label? */
2763         if (zfs_is_readonly(zsb)) {
2764                 err = EROFS;
2765                 goto out3;
2766         }
2767
2768         /*
2769          * First validate permissions
2770          */
2771
2772         if (mask & ATTR_SIZE) {
2773                 err = zfs_zaccess(zp, ACE_WRITE_DATA, 0, skipaclchk, cr);
2774                 if (err)
2775                         goto out3;
2776
2777                 /*
2778                  * XXX - Note, we are not providing any open
2779                  * mode flags here (like FNDELAY), so we may
2780                  * block if there are locks present... this
2781                  * should be addressed in openat().
2782                  */
2783                 /* XXX - would it be OK to generate a log record here? */
2784                 err = zfs_freesp(zp, vap->va_size, 0, 0, FALSE);
2785                 if (err)
2786                         goto out3;
2787         }
2788
2789         if (mask & (ATTR_ATIME|ATTR_MTIME) ||
2790             ((mask & ATTR_XVATTR) && (XVA_ISSET_REQ(xvap, XAT_HIDDEN) ||
2791             XVA_ISSET_REQ(xvap, XAT_READONLY) ||
2792             XVA_ISSET_REQ(xvap, XAT_ARCHIVE) ||
2793             XVA_ISSET_REQ(xvap, XAT_OFFLINE) ||
2794             XVA_ISSET_REQ(xvap, XAT_SPARSE) ||
2795             XVA_ISSET_REQ(xvap, XAT_CREATETIME) ||
2796             XVA_ISSET_REQ(xvap, XAT_SYSTEM)))) {
2797                 need_policy = zfs_zaccess(zp, ACE_WRITE_ATTRIBUTES, 0,
2798                     skipaclchk, cr);
2799         }
2800
2801         if (mask & (ATTR_UID|ATTR_GID)) {
2802                 int     idmask = (mask & (ATTR_UID|ATTR_GID));
2803                 int     take_owner;
2804                 int     take_group;
2805
2806                 /*
2807                  * NOTE: even if a new mode is being set,
2808                  * we may clear S_ISUID/S_ISGID bits.
2809                  */
2810
2811                 if (!(mask & ATTR_MODE))
2812                         vap->va_mode = zp->z_mode;
2813
2814                 /*
2815                  * Take ownership or chgrp to group we are a member of
2816                  */
2817
2818                 take_owner = (mask & ATTR_UID) && (vap->va_uid == crgetuid(cr));
2819                 take_group = (mask & ATTR_GID) &&
2820                     zfs_groupmember(zsb, vap->va_gid, cr);
2821
2822                 /*
2823                  * If both ATTR_UID and ATTR_GID are set then take_owner and
2824                  * take_group must both be set in order to allow taking
2825                  * ownership.
2826                  *
2827                  * Otherwise, send the check through secpolicy_vnode_setattr()
2828                  *
2829                  */
2830
2831                 if (((idmask == (ATTR_UID|ATTR_GID)) &&
2832                     take_owner && take_group) ||
2833                     ((idmask == ATTR_UID) && take_owner) ||
2834                     ((idmask == ATTR_GID) && take_group)) {
2835                         if (zfs_zaccess(zp, ACE_WRITE_OWNER, 0,
2836                             skipaclchk, cr) == 0) {
2837                                 /*
2838                                  * Remove setuid/setgid for non-privileged users
2839                                  */
2840                                 (void) secpolicy_setid_clear(vap, cr);
2841                                 trim_mask = (mask & (ATTR_UID|ATTR_GID));
2842                         } else {
2843                                 need_policy =  TRUE;
2844                         }
2845                 } else {
2846                         need_policy =  TRUE;
2847                 }
2848         }
2849
2850         mutex_enter(&zp->z_lock);
2851         oldva.va_mode = zp->z_mode;
2852         zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid);
2853         if (mask & ATTR_XVATTR) {
2854                 /*
2855                  * Update xvattr mask to include only those attributes
2856                  * that are actually changing.
2857                  *
2858                  * the bits will be restored prior to actually setting
2859                  * the attributes so the caller thinks they were set.
2860                  */
2861                 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
2862                         if (xoap->xoa_appendonly !=
2863                             ((zp->z_pflags & ZFS_APPENDONLY) != 0)) {
2864                                 need_policy = TRUE;
2865                         } else {
2866                                 XVA_CLR_REQ(xvap, XAT_APPENDONLY);
2867                                 XVA_SET_REQ(tmpxvattr, XAT_APPENDONLY);
2868                         }
2869                 }
2870
2871                 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
2872                         if (xoap->xoa_nounlink !=
2873                             ((zp->z_pflags & ZFS_NOUNLINK) != 0)) {
2874                                 need_policy = TRUE;
2875                         } else {
2876                                 XVA_CLR_REQ(xvap, XAT_NOUNLINK);
2877                                 XVA_SET_REQ(tmpxvattr, XAT_NOUNLINK);
2878                         }
2879                 }
2880
2881                 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
2882                         if (xoap->xoa_immutable !=
2883                             ((zp->z_pflags & ZFS_IMMUTABLE) != 0)) {
2884                                 need_policy = TRUE;
2885                         } else {
2886                                 XVA_CLR_REQ(xvap, XAT_IMMUTABLE);
2887                                 XVA_SET_REQ(tmpxvattr, XAT_IMMUTABLE);
2888                         }
2889                 }
2890
2891                 if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
2892                         if (xoap->xoa_nodump !=
2893                             ((zp->z_pflags & ZFS_NODUMP) != 0)) {
2894                                 need_policy = TRUE;
2895                         } else {
2896                                 XVA_CLR_REQ(xvap, XAT_NODUMP);
2897                                 XVA_SET_REQ(tmpxvattr, XAT_NODUMP);
2898                         }
2899                 }
2900
2901                 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
2902                         if (xoap->xoa_av_modified !=
2903                             ((zp->z_pflags & ZFS_AV_MODIFIED) != 0)) {
2904                                 need_policy = TRUE;
2905                         } else {
2906                                 XVA_CLR_REQ(xvap, XAT_AV_MODIFIED);
2907                                 XVA_SET_REQ(tmpxvattr, XAT_AV_MODIFIED);
2908                         }
2909                 }
2910
2911                 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
2912                         if ((!S_ISREG(ip->i_mode) &&
2913                             xoap->xoa_av_quarantined) ||
2914                             xoap->xoa_av_quarantined !=
2915                             ((zp->z_pflags & ZFS_AV_QUARANTINED) != 0)) {
2916                                 need_policy = TRUE;
2917                         } else {
2918                                 XVA_CLR_REQ(xvap, XAT_AV_QUARANTINED);
2919                                 XVA_SET_REQ(tmpxvattr, XAT_AV_QUARANTINED);
2920                         }
2921                 }
2922
2923                 if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
2924                         mutex_exit(&zp->z_lock);
2925                         err = EPERM;
2926                         goto out3;
2927                 }
2928
2929                 if (need_policy == FALSE &&
2930                     (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) ||
2931                     XVA_ISSET_REQ(xvap, XAT_OPAQUE))) {
2932                         need_policy = TRUE;
2933                 }
2934         }
2935
2936         mutex_exit(&zp->z_lock);
2937
2938         if (mask & ATTR_MODE) {
2939                 if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) {
2940                         err = secpolicy_setid_setsticky_clear(ip, vap,
2941                             &oldva, cr);
2942                         if (err)
2943                                 goto out3;
2944
2945                         trim_mask |= ATTR_MODE;
2946                 } else {
2947                         need_policy = TRUE;
2948                 }
2949         }
2950
2951         if (need_policy) {
2952                 /*
2953                  * If trim_mask is set then take ownership
2954                  * has been granted or write_acl is present and user
2955                  * has the ability to modify mode.  In that case remove
2956                  * UID|GID and or MODE from mask so that
2957                  * secpolicy_vnode_setattr() doesn't revoke it.
2958                  */
2959
2960                 if (trim_mask) {
2961                         saved_mask = vap->va_mask;
2962                         vap->va_mask &= ~trim_mask;
2963                 }
2964                 err = secpolicy_vnode_setattr(cr, ip, vap, &oldva, flags,
2965                     (int (*)(void *, int, cred_t *))zfs_zaccess_unix, zp);
2966                 if (err)
2967                         goto out3;
2968
2969                 if (trim_mask)
2970                         vap->va_mask |= saved_mask;
2971         }
2972
2973         /*
2974          * secpolicy_vnode_setattr, or take ownership may have
2975          * changed va_mask
2976          */
2977         mask = vap->va_mask;
2978
2979         if ((mask & (ATTR_UID | ATTR_GID))) {
2980                 err = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zsb),
2981                     &xattr_obj, sizeof (xattr_obj));
2982
2983                 if (err == 0 && xattr_obj) {
2984                         err = zfs_zget(ZTOZSB(zp), xattr_obj, &attrzp);
2985                         if (err)
2986                                 goto out2;
2987                 }
2988                 if (mask & ATTR_UID) {
2989                         new_kuid = zfs_fuid_create(zsb,
2990                             (uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp);
2991                         if (new_kuid != KUID_TO_SUID(ZTOI(zp)->i_uid) &&
2992                             zfs_fuid_overquota(zsb, B_FALSE, new_kuid)) {
2993                                 if (attrzp)
2994                                         iput(ZTOI(attrzp));
2995                                 err = EDQUOT;
2996                                 goto out2;
2997                         }
2998                 }
2999
3000                 if (mask & ATTR_GID) {
3001                         new_kgid = zfs_fuid_create(zsb, (uint64_t)vap->va_gid,
3002                             cr, ZFS_GROUP, &fuidp);
3003                         if (new_kgid != KGID_TO_SGID(ZTOI(zp)->i_gid) &&
3004                             zfs_fuid_overquota(zsb, B_TRUE, new_kgid)) {
3005                                 if (attrzp)
3006                                         iput(ZTOI(attrzp));
3007                                 err = EDQUOT;
3008                                 goto out2;
3009                         }
3010                 }
3011         }
3012         tx = dmu_tx_create(zsb->z_os);
3013
3014         if (mask & ATTR_MODE) {
3015                 uint64_t pmode = zp->z_mode;
3016                 uint64_t acl_obj;
3017                 new_mode = (pmode & S_IFMT) | (vap->va_mode & ~S_IFMT);
3018
3019                 zfs_acl_chmod_setattr(zp, &aclp, new_mode);
3020
3021                 mutex_enter(&zp->z_lock);
3022                 if (!zp->z_is_sa && ((acl_obj = zfs_external_acl(zp)) != 0)) {
3023                         /*
3024                          * Are we upgrading ACL from old V0 format
3025                          * to V1 format?
3026                          */
3027                         if (zsb->z_version >= ZPL_VERSION_FUID &&
3028                             zfs_znode_acl_version(zp) ==
3029                             ZFS_ACL_VERSION_INITIAL) {
3030                                 dmu_tx_hold_free(tx, acl_obj, 0,
3031                                     DMU_OBJECT_END);
3032                                 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
3033                                     0, aclp->z_acl_bytes);
3034                         } else {
3035                                 dmu_tx_hold_write(tx, acl_obj, 0,
3036                                     aclp->z_acl_bytes);
3037                         }
3038                 } else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) {
3039                         dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
3040                             0, aclp->z_acl_bytes);
3041                 }
3042                 mutex_exit(&zp->z_lock);
3043                 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
3044         } else {
3045                 if ((mask & ATTR_XVATTR) &&
3046                     XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP))
3047                         dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
3048                 else
3049                         dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
3050         }
3051
3052         if (attrzp) {
3053                 dmu_tx_hold_sa(tx, attrzp->z_sa_hdl, B_FALSE);
3054         }
3055
3056         fuid_dirtied = zsb->z_fuid_dirty;
3057         if (fuid_dirtied)
3058                 zfs_fuid_txhold(zsb, tx);
3059
3060         zfs_sa_upgrade_txholds(tx, zp);
3061
3062         err = dmu_tx_assign(tx, TXG_WAIT);
3063         if (err)
3064                 goto out;
3065
3066         count = 0;
3067         /*
3068          * Set each attribute requested.
3069          * We group settings according to the locks they need to acquire.
3070          *
3071          * Note: you cannot set ctime directly, although it will be
3072          * updated as a side-effect of calling this function.
3073          */
3074
3075
3076         if (mask & (ATTR_UID|ATTR_GID|ATTR_MODE))
3077                 mutex_enter(&zp->z_acl_lock);
3078         mutex_enter(&zp->z_lock);
3079
3080         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
3081             &zp->z_pflags, sizeof (zp->z_pflags));
3082
3083         if (attrzp) {
3084                 if (mask & (ATTR_UID|ATTR_GID|ATTR_MODE))
3085                         mutex_enter(&attrzp->z_acl_lock);
3086                 mutex_enter(&attrzp->z_lock);
3087                 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
3088                     SA_ZPL_FLAGS(zsb), NULL, &attrzp->z_pflags,
3089                     sizeof (attrzp->z_pflags));
3090         }
3091
3092         if (mask & (ATTR_UID|ATTR_GID)) {
3093
3094                 if (mask & ATTR_UID) {
3095                         ZTOI(zp)->i_uid = SUID_TO_KUID(new_kuid);
3096                         new_uid = zfs_uid_read(ZTOI(zp));
3097                         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zsb), NULL,
3098                             &new_uid, sizeof (new_uid));
3099                         if (attrzp) {
3100                                 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
3101                                     SA_ZPL_UID(zsb), NULL, &new_uid,
3102                                     sizeof (new_uid));
3103                                 ZTOI(attrzp)->i_uid = SUID_TO_KUID(new_uid);
3104                         }
3105                 }
3106
3107                 if (mask & ATTR_GID) {
3108                         ZTOI(zp)->i_gid = SGID_TO_KGID(new_kgid);
3109                         new_gid = zfs_gid_read(ZTOI(zp));
3110                         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zsb),
3111                             NULL, &new_gid, sizeof (new_gid));
3112                         if (attrzp) {
3113                                 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
3114                                     SA_ZPL_GID(zsb), NULL, &new_gid,
3115                                     sizeof (new_gid));
3116                                 ZTOI(attrzp)->i_gid = SGID_TO_KGID(new_kgid);
3117                         }
3118                 }
3119                 if (!(mask & ATTR_MODE)) {
3120                         SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zsb),
3121                             NULL, &new_mode, sizeof (new_mode));
3122                         new_mode = zp->z_mode;
3123                 }
3124                 err = zfs_acl_chown_setattr(zp);
3125                 ASSERT(err == 0);
3126                 if (attrzp) {
3127                         err = zfs_acl_chown_setattr(attrzp);
3128                         ASSERT(err == 0);
3129                 }
3130         }
3131
3132         if (mask & ATTR_MODE) {
3133                 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zsb), NULL,
3134                     &new_mode, sizeof (new_mode));
3135                 zp->z_mode = ZTOI(zp)->i_mode = new_mode;
3136                 ASSERT3P(aclp, !=, NULL);
3137                 err = zfs_aclset_common(zp, aclp, cr, tx);
3138                 ASSERT0(err);
3139                 if (zp->z_acl_cached)
3140                         zfs_acl_free(zp->z_acl_cached);
3141                 zp->z_acl_cached = aclp;
3142                 aclp = NULL;
3143         }
3144
3145         if ((mask & ATTR_ATIME) || zp->z_atime_dirty) {
3146                 zp->z_atime_dirty = 0;
3147                 ZFS_TIME_ENCODE(&ip->i_atime, atime);
3148                 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL,
3149                     &atime, sizeof (atime));
3150         }
3151
3152         if (mask & ATTR_MTIME) {
3153                 ZFS_TIME_ENCODE(&vap->va_mtime, mtime);
3154                 ZTOI(zp)->i_mtime = timespec_trunc(vap->va_mtime,
3155                     ZTOI(zp)->i_sb->s_time_gran);
3156
3157                 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL,
3158                     mtime, sizeof (mtime));
3159         }
3160
3161         if (mask & ATTR_CTIME) {
3162                 ZFS_TIME_ENCODE(&vap->va_ctime, ctime);
3163                 ZTOI(zp)->i_ctime = timespec_trunc(vap->va_ctime,
3164                     ZTOI(zp)->i_sb->s_time_gran);
3165                 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
3166                     ctime, sizeof (ctime));
3167         }
3168
3169         if (attrzp && mask) {
3170                 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
3171                     SA_ZPL_CTIME(zsb), NULL, &ctime,
3172                     sizeof (ctime));
3173         }
3174
3175         /*
3176          * Do this after setting timestamps to prevent timestamp
3177          * update from toggling bit
3178          */
3179
3180         if (xoap && (mask & ATTR_XVATTR)) {
3181
3182                 /*
3183                  * restore trimmed off masks
3184                  * so that return masks can be set for caller.
3185                  */
3186
3187                 if (XVA_ISSET_REQ(tmpxvattr, XAT_APPENDONLY)) {
3188                         XVA_SET_REQ(xvap, XAT_APPENDONLY);
3189                 }
3190                 if (XVA_ISSET_REQ(tmpxvattr, XAT_NOUNLINK)) {
3191                         XVA_SET_REQ(xvap, XAT_NOUNLINK);
3192                 }
3193                 if (XVA_ISSET_REQ(tmpxvattr, XAT_IMMUTABLE)) {
3194                         XVA_SET_REQ(xvap, XAT_IMMUTABLE);
3195                 }
3196                 if (XVA_ISSET_REQ(tmpxvattr, XAT_NODUMP)) {
3197                         XVA_SET_REQ(xvap, XAT_NODUMP);
3198                 }
3199                 if (XVA_ISSET_REQ(tmpxvattr, XAT_AV_MODIFIED)) {
3200                         XVA_SET_REQ(xvap, XAT_AV_MODIFIED);
3201                 }
3202                 if (XVA_ISSET_REQ(tmpxvattr, XAT_AV_QUARANTINED)) {
3203                         XVA_SET_REQ(xvap, XAT_AV_QUARANTINED);
3204                 }
3205
3206                 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP))
3207                         ASSERT(S_ISREG(ip->i_mode));
3208
3209                 zfs_xvattr_set(zp, xvap, tx);
3210         }
3211
3212         if (fuid_dirtied)
3213                 zfs_fuid_sync(zsb, tx);
3214
3215         if (mask != 0)
3216                 zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp);
3217
3218         mutex_exit(&zp->z_lock);
3219         if (mask & (ATTR_UID|ATTR_GID|ATTR_MODE))
3220                 mutex_exit(&zp->z_acl_lock);
3221
3222         if (attrzp) {
3223                 if (mask & (ATTR_UID|ATTR_GID|ATTR_MODE))
3224                         mutex_exit(&attrzp->z_acl_lock);
3225                 mutex_exit(&attrzp->z_lock);
3226         }
3227 out:
3228         if (err == 0 && attrzp) {
3229                 err2 = sa_bulk_update(attrzp->z_sa_hdl, xattr_bulk,
3230                     xattr_count, tx);
3231                 ASSERT(err2 == 0);
3232         }
3233
3234         if (attrzp)
3235                 iput(ZTOI(attrzp));
3236         if (aclp)
3237                 zfs_acl_free(aclp);
3238
3239         if (fuidp) {
3240                 zfs_fuid_info_free(fuidp);
3241                 fuidp = NULL;
3242         }
3243
3244         if (err) {
3245                 dmu_tx_abort(tx);
3246                 if (err == ERESTART)
3247                         goto top;
3248         } else {
3249                 err2 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
3250                 dmu_tx_commit(tx);
3251                 zfs_inode_update(zp);
3252         }
3253
3254 out2:
3255         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
3256                 zil_commit(zilog, 0);
3257
3258 out3:
3259         kmem_free(xattr_bulk, sizeof (sa_bulk_attr_t) * 7);
3260         kmem_free(bulk, sizeof (sa_bulk_attr_t) * 7);
3261         kmem_free(tmpxvattr, sizeof (xvattr_t));
3262         ZFS_EXIT(zsb);
3263         return (err);
3264 }
3265 EXPORT_SYMBOL(zfs_setattr);
3266
3267 typedef struct zfs_zlock {
3268         krwlock_t       *zl_rwlock;     /* lock we acquired */
3269         znode_t         *zl_znode;      /* znode we held */
3270         struct zfs_zlock *zl_next;      /* next in list */
3271 } zfs_zlock_t;
3272
3273 /*
3274  * Drop locks and release vnodes that were held by zfs_rename_lock().
3275  */
3276 static void
3277 zfs_rename_unlock(zfs_zlock_t **zlpp)
3278 {
3279         zfs_zlock_t *zl;
3280
3281         while ((zl = *zlpp) != NULL) {
3282                 if (zl->zl_znode != NULL)
3283                         iput(ZTOI(zl->zl_znode));
3284                 rw_exit(zl->zl_rwlock);
3285                 *zlpp = zl->zl_next;
3286                 kmem_free(zl, sizeof (*zl));
3287         }
3288 }
3289
3290 /*
3291  * Search back through the directory tree, using the ".." entries.
3292  * Lock each directory in the chain to prevent concurrent renames.
3293  * Fail any attempt to move a directory into one of its own descendants.
3294  * XXX - z_parent_lock can overlap with map or grow locks
3295  */
3296 static int
3297 zfs_rename_lock(znode_t *szp, znode_t *tdzp, znode_t *sdzp, zfs_zlock_t **zlpp)
3298 {
3299         zfs_zlock_t     *zl;
3300         znode_t         *zp = tdzp;
3301         uint64_t        rootid = ZTOZSB(zp)->z_root;
3302         uint64_t        oidp = zp->z_id;
3303         krwlock_t       *rwlp = &szp->z_parent_lock;
3304         krw_t           rw = RW_WRITER;
3305
3306         /*
3307          * First pass write-locks szp and compares to zp->z_id.
3308          * Later passes read-lock zp and compare to zp->z_parent.
3309          */
3310         do {
3311                 if (!rw_tryenter(rwlp, rw)) {
3312                         /*
3313                          * Another thread is renaming in this path.
3314                          * Note that if we are a WRITER, we don't have any
3315                          * parent_locks held yet.
3316                          */
3317                         if (rw == RW_READER && zp->z_id > szp->z_id) {
3318                                 /*
3319                                  * Drop our locks and restart
3320                                  */
3321                                 zfs_rename_unlock(&zl);
3322                                 *zlpp = NULL;
3323                                 zp = tdzp;
3324                                 oidp = zp->z_id;
3325                                 rwlp = &szp->z_parent_lock;
3326                                 rw = RW_WRITER;
3327                                 continue;
3328                         } else {
3329                                 /*
3330                                  * Wait for other thread to drop its locks
3331                                  */
3332                                 rw_enter(rwlp, rw);
3333                         }
3334                 }
3335
3336                 zl = kmem_alloc(sizeof (*zl), KM_SLEEP);
3337                 zl->zl_rwlock = rwlp;
3338                 zl->zl_znode = NULL;
3339                 zl->zl_next = *zlpp;
3340                 *zlpp = zl;
3341
3342                 if (oidp == szp->z_id)          /* We're a descendant of szp */
3343                         return (SET_ERROR(EINVAL));
3344
3345                 if (oidp == rootid)             /* We've hit the top */
3346                         return (0);
3347
3348                 if (rw == RW_READER) {          /* i.e. not the first pass */
3349                         int error = zfs_zget(ZTOZSB(zp), oidp, &zp);
3350                         if (error)
3351                                 return (error);
3352                         zl->zl_znode = zp;
3353                 }
3354                 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(ZTOZSB(zp)),
3355                     &oidp, sizeof (oidp));
3356                 rwlp = &zp->z_parent_lock;
3357                 rw = RW_READER;
3358
3359         } while (zp->z_id != sdzp->z_id);
3360
3361         return (0);
3362 }
3363
3364 /*
3365  * Move an entry from the provided source directory to the target
3366  * directory.  Change the entry name as indicated.
3367  *
3368  *      IN:     sdip    - Source directory containing the "old entry".
3369  *              snm     - Old entry name.
3370  *              tdip    - Target directory to contain the "new entry".
3371  *              tnm     - New entry name.
3372  *              cr      - credentials of caller.
3373  *              flags   - case flags
3374  *
3375  *      RETURN: 0 on success, error code on failure.
3376  *
3377  * Timestamps:
3378  *      sdip,tdip - ctime|mtime updated
3379  */
3380 /*ARGSUSED*/
3381 int
3382 zfs_rename(struct inode *sdip, char *snm, struct inode *tdip, char *tnm,
3383     cred_t *cr, int flags)
3384 {
3385         znode_t         *tdzp, *szp, *tzp;
3386         znode_t         *sdzp = ITOZ(sdip);
3387         zfs_sb_t        *zsb = ITOZSB(sdip);
3388         zilog_t         *zilog;
3389         zfs_dirlock_t   *sdl, *tdl;
3390         dmu_tx_t        *tx;
3391         zfs_zlock_t     *zl;
3392         int             cmp, serr, terr;
3393         int             error = 0;
3394         int             zflg = 0;
3395         boolean_t       waited = B_FALSE;
3396
3397         if (snm == NULL || tnm == NULL)
3398                 return (SET_ERROR(EINVAL));
3399
3400         ZFS_ENTER(zsb);
3401         ZFS_VERIFY_ZP(sdzp);
3402         zilog = zsb->z_log;
3403
3404         tdzp = ITOZ(tdip);
3405         ZFS_VERIFY_ZP(tdzp);
3406
3407         /*
3408          * We check i_sb because snapshots and the ctldir must have different
3409          * super blocks.
3410          */
3411         if (tdip->i_sb != sdip->i_sb || zfsctl_is_node(tdip)) {
3412                 ZFS_EXIT(zsb);
3413                 return (SET_ERROR(EXDEV));
3414         }
3415
3416         if (zsb->z_utf8 && u8_validate(tnm,
3417             strlen(tnm), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
3418                 ZFS_EXIT(zsb);
3419                 return (SET_ERROR(EILSEQ));
3420         }
3421
3422         if (flags & FIGNORECASE)
3423                 zflg |= ZCILOOK;
3424
3425 top:
3426         szp = NULL;
3427         tzp = NULL;
3428         zl = NULL;
3429
3430         /*
3431          * This is to prevent the creation of links into attribute space
3432          * by renaming a linked file into/outof an attribute directory.
3433          * See the comment in zfs_link() for why this is considered bad.
3434          */
3435         if ((tdzp->z_pflags & ZFS_XATTR) != (sdzp->z_pflags & ZFS_XATTR)) {
3436                 ZFS_EXIT(zsb);
3437                 return (SET_ERROR(EINVAL));
3438         }
3439
3440         /*
3441          * Lock source and target directory entries.  To prevent deadlock,
3442          * a lock ordering must be defined.  We lock the directory with
3443          * the smallest object id first, or if it's a tie, the one with
3444          * the lexically first name.
3445          */
3446         if (sdzp->z_id < tdzp->z_id) {
3447                 cmp = -1;
3448         } else if (sdzp->z_id > tdzp->z_id) {
3449                 cmp = 1;
3450         } else {
3451                 /*
3452                  * First compare the two name arguments without
3453                  * considering any case folding.
3454                  */
3455                 int nofold = (zsb->z_norm & ~U8_TEXTPREP_TOUPPER);
3456
3457                 cmp = u8_strcmp(snm, tnm, 0, nofold, U8_UNICODE_LATEST, &error);
3458                 ASSERT(error == 0 || !zsb->z_utf8);
3459                 if (cmp == 0) {
3460                         /*
3461                          * POSIX: "If the old argument and the new argument
3462                          * both refer to links to the same existing file,
3463                          * the rename() function shall return successfully
3464                          * and perform no other action."
3465                          */
3466                         ZFS_EXIT(zsb);
3467                         return (0);
3468                 }
3469                 /*
3470                  * If the file system is case-folding, then we may
3471                  * have some more checking to do.  A case-folding file
3472                  * system is either supporting mixed case sensitivity
3473                  * access or is completely case-insensitive.  Note
3474                  * that the file system is always case preserving.
3475                  *
3476                  * In mixed sensitivity mode case sensitive behavior
3477                  * is the default.  FIGNORECASE must be used to
3478                  * explicitly request case insensitive behavior.
3479                  *
3480                  * If the source and target names provided differ only
3481                  * by case (e.g., a request to rename 'tim' to 'Tim'),
3482                  * we will treat this as a special case in the
3483                  * case-insensitive mode: as long as the source name
3484                  * is an exact match, we will allow this to proceed as
3485                  * a name-change request.
3486                  */
3487                 if ((zsb->z_case == ZFS_CASE_INSENSITIVE ||
3488                     (zsb->z_case == ZFS_CASE_MIXED &&
3489                     flags & FIGNORECASE)) &&
3490                     u8_strcmp(snm, tnm, 0, zsb->z_norm, U8_UNICODE_LATEST,
3491                     &error) == 0) {
3492                         /*
3493                          * case preserving rename request, require exact
3494                          * name matches
3495                          */
3496                         zflg |= ZCIEXACT;
3497                         zflg &= ~ZCILOOK;
3498                 }
3499         }
3500
3501         /*
3502          * If the source and destination directories are the same, we should
3503          * grab the z_name_lock of that directory only once.
3504          */
3505         if (sdzp == tdzp) {
3506                 zflg |= ZHAVELOCK;
3507                 rw_enter(&sdzp->z_name_lock, RW_READER);
3508         }
3509
3510         if (cmp < 0) {
3511                 serr = zfs_dirent_lock(&sdl, sdzp, snm, &szp,
3512                     ZEXISTS | zflg, NULL, NULL);
3513                 terr = zfs_dirent_lock(&tdl,
3514                     tdzp, tnm, &tzp, ZRENAMING | zflg, NULL, NULL);
3515         } else {
3516                 terr = zfs_dirent_lock(&tdl,
3517                     tdzp, tnm, &tzp, zflg, NULL, NULL);
3518                 serr = zfs_dirent_lock(&sdl,
3519                     sdzp, snm, &szp, ZEXISTS | ZRENAMING | zflg,
3520                     NULL, NULL);
3521         }
3522
3523         if (serr) {
3524                 /*
3525                  * Source entry invalid or not there.
3526                  */
3527                 if (!terr) {
3528                         zfs_dirent_unlock(tdl);
3529                         if (tzp)
3530                                 iput(ZTOI(tzp));
3531                 }
3532
3533                 if (sdzp == tdzp)
3534                         rw_exit(&sdzp->z_name_lock);
3535
3536                 if (strcmp(snm, "..") == 0)
3537                         serr = EINVAL;
3538                 ZFS_EXIT(zsb);
3539                 return (serr);
3540         }
3541         if (terr) {
3542                 zfs_dirent_unlock(sdl);
3543                 iput(ZTOI(szp));
3544
3545                 if (sdzp == tdzp)
3546                         rw_exit(&sdzp->z_name_lock);
3547
3548                 if (strcmp(tnm, "..") == 0)
3549                         terr = EINVAL;
3550                 ZFS_EXIT(zsb);
3551                 return (terr);
3552         }
3553
3554         /*
3555          * Must have write access at the source to remove the old entry
3556          * and write access at the target to create the new entry.
3557          * Note that if target and source are the same, this can be
3558          * done in a single check.
3559          */
3560
3561         if ((error = zfs_zaccess_rename(sdzp, szp, tdzp, tzp, cr)))
3562                 goto out;
3563
3564         if (S_ISDIR(ZTOI(szp)->i_mode)) {
3565                 /*
3566                  * Check to make sure rename is valid.
3567                  * Can't do a move like this: /usr/a/b to /usr/a/b/c/d
3568                  */
3569                 if ((error = zfs_rename_lock(szp, tdzp, sdzp, &zl)))
3570                         goto out;
3571         }
3572
3573         /*
3574          * Does target exist?
3575          */
3576         if (tzp) {
3577                 /*
3578                  * Source and target must be the same type.
3579                  */
3580                 if (S_ISDIR(ZTOI(szp)->i_mode)) {
3581                         if (!S_ISDIR(ZTOI(tzp)->i_mode)) {
3582                                 error = SET_ERROR(ENOTDIR);
3583                                 goto out;
3584                         }
3585                 } else {
3586                         if (S_ISDIR(ZTOI(tzp)->i_mode)) {
3587                                 error = SET_ERROR(EISDIR);
3588                                 goto out;
3589                         }
3590                 }
3591                 /*
3592                  * POSIX dictates that when the source and target
3593                  * entries refer to the same file object, rename
3594                  * must do nothing and exit without error.
3595                  */
3596                 if (szp->z_id == tzp->z_id) {
3597                         error = 0;
3598                         goto out;
3599                 }
3600         }
3601
3602         tx = dmu_tx_create(zsb->z_os);
3603         dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
3604         dmu_tx_hold_sa(tx, sdzp->z_sa_hdl, B_FALSE);
3605         dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm);
3606         dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm);
3607         if (sdzp != tdzp) {
3608                 dmu_tx_hold_sa(tx, tdzp->z_sa_hdl, B_FALSE);
3609                 zfs_sa_upgrade_txholds(tx, tdzp);
3610         }
3611         if (tzp) {
3612                 dmu_tx_hold_sa(tx, tzp->z_sa_hdl, B_FALSE);
3613                 zfs_sa_upgrade_txholds(tx, tzp);
3614         }
3615
3616         zfs_sa_upgrade_txholds(tx, szp);
3617         dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
3618         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
3619         if (error) {
3620                 if (zl != NULL)
3621                         zfs_rename_unlock(&zl);
3622                 zfs_dirent_unlock(sdl);
3623                 zfs_dirent_unlock(tdl);
3624
3625                 if (sdzp == tdzp)
3626                         rw_exit(&sdzp->z_name_lock);
3627
3628                 iput(ZTOI(szp));
3629                 if (tzp)
3630                         iput(ZTOI(tzp));
3631                 if (error == ERESTART) {
3632                         waited = B_TRUE;
3633                         dmu_tx_wait(tx);
3634                         dmu_tx_abort(tx);
3635                         goto top;
3636                 }
3637                 dmu_tx_abort(tx);
3638                 ZFS_EXIT(zsb);
3639                 return (error);
3640         }
3641
3642         if (tzp)        /* Attempt to remove the existing target */
3643                 error = zfs_link_destroy(tdl, tzp, tx, zflg, NULL);
3644
3645         if (error == 0) {
3646                 error = zfs_link_create(tdl, szp, tx, ZRENAMING);
3647                 if (error == 0) {
3648                         szp->z_pflags |= ZFS_AV_MODIFIED;
3649
3650                         error = sa_update(szp->z_sa_hdl, SA_ZPL_FLAGS(zsb),
3651                             (void *)&szp->z_pflags, sizeof (uint64_t), tx);
3652                         ASSERT0(error);
3653
3654                         error = zfs_link_destroy(sdl, szp, tx, ZRENAMING, NULL);
3655                         if (error == 0) {
3656                                 zfs_log_rename(zilog, tx, TX_RENAME |
3657                                     (flags & FIGNORECASE ? TX_CI : 0), sdzp,
3658                                     sdl->dl_name, tdzp, tdl->dl_name, szp);
3659                         } else {
3660                                 /*
3661                                  * At this point, we have successfully created
3662                                  * the target name, but have failed to remove
3663                                  * the source name.  Since the create was done
3664                                  * with the ZRENAMING flag, there are
3665                                  * complications; for one, the link count is
3666                                  * wrong.  The easiest way to deal with this
3667                                  * is to remove the newly created target, and
3668                                  * return the original error.  This must
3669                                  * succeed; fortunately, it is very unlikely to
3670                                  * fail, since we just created it.
3671                                  */
3672                                 VERIFY3U(zfs_link_destroy(tdl, szp, tx,
3673                                     ZRENAMING, NULL), ==, 0);
3674                         }
3675                 }
3676         }
3677
3678         dmu_tx_commit(tx);
3679 out:
3680         if (zl != NULL)
3681                 zfs_rename_unlock(&zl);
3682
3683         zfs_dirent_unlock(sdl);
3684         zfs_dirent_unlock(tdl);
3685
3686         zfs_inode_update(sdzp);
3687         if (sdzp == tdzp)
3688                 rw_exit(&sdzp->z_name_lock);
3689
3690         if (sdzp != tdzp)
3691                 zfs_inode_update(tdzp);
3692
3693         zfs_inode_update(szp);
3694         iput(ZTOI(szp));
3695         if (tzp) {
3696                 zfs_inode_update(tzp);
3697                 iput(ZTOI(tzp));
3698         }
3699
3700         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
3701                 zil_commit(zilog, 0);
3702
3703         ZFS_EXIT(zsb);
3704         return (error);
3705 }
3706 EXPORT_SYMBOL(zfs_rename);
3707
3708 /*
3709  * Insert the indicated symbolic reference entry into the directory.
3710  *
3711  *      IN:     dip     - Directory to contain new symbolic link.
3712  *              link    - Name for new symlink entry.
3713  *              vap     - Attributes of new entry.
3714  *              target  - Target path of new symlink.
3715  *
3716  *              cr      - credentials of caller.
3717  *              flags   - case flags
3718  *
3719  *      RETURN: 0 on success, error code on failure.
3720  *
3721  * Timestamps:
3722  *      dip - ctime|mtime updated
3723  */
3724 /*ARGSUSED*/
3725 int
3726 zfs_symlink(struct inode *dip, char *name, vattr_t *vap, char *link,
3727     struct inode **ipp, cred_t *cr, int flags)
3728 {
3729         znode_t         *zp, *dzp = ITOZ(dip);
3730         zfs_dirlock_t   *dl;
3731         dmu_tx_t        *tx;
3732         zfs_sb_t        *zsb = ITOZSB(dip);
3733         zilog_t         *zilog;
3734         uint64_t        len = strlen(link);
3735         int             error;
3736         int             zflg = ZNEW;
3737         zfs_acl_ids_t   acl_ids;
3738         boolean_t       fuid_dirtied;
3739         uint64_t        txtype = TX_SYMLINK;
3740         boolean_t       waited = B_FALSE;
3741
3742         ASSERT(S_ISLNK(vap->va_mode));
3743
3744         if (name == NULL)
3745                 return (SET_ERROR(EINVAL));
3746
3747         ZFS_ENTER(zsb);
3748         ZFS_VERIFY_ZP(dzp);
3749         zilog = zsb->z_log;
3750
3751         if (zsb->z_utf8 && u8_validate(name, strlen(name),
3752             NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
3753                 ZFS_EXIT(zsb);
3754                 return (SET_ERROR(EILSEQ));
3755         }
3756         if (flags & FIGNORECASE)
3757                 zflg |= ZCILOOK;
3758
3759         if (len > MAXPATHLEN) {
3760                 ZFS_EXIT(zsb);
3761                 return (SET_ERROR(ENAMETOOLONG));
3762         }
3763
3764         if ((error = zfs_acl_ids_create(dzp, 0,
3765             vap, cr, NULL, &acl_ids)) != 0) {
3766                 ZFS_EXIT(zsb);
3767                 return (error);
3768         }
3769 top:
3770         *ipp = NULL;
3771
3772         /*
3773          * Attempt to lock directory; fail if entry already exists.
3774          */
3775         error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, NULL, NULL);
3776         if (error) {
3777                 zfs_acl_ids_free(&acl_ids);
3778                 ZFS_EXIT(zsb);
3779                 return (error);
3780         }
3781
3782         if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
3783                 zfs_acl_ids_free(&acl_ids);
3784                 zfs_dirent_unlock(dl);
3785                 ZFS_EXIT(zsb);
3786                 return (error);
3787         }
3788
3789         if (zfs_acl_ids_overquota(zsb, &acl_ids)) {
3790                 zfs_acl_ids_free(&acl_ids);
3791                 zfs_dirent_unlock(dl);
3792                 ZFS_EXIT(zsb);
3793                 return (SET_ERROR(EDQUOT));
3794         }
3795         tx = dmu_tx_create(zsb->z_os);
3796         fuid_dirtied = zsb->z_fuid_dirty;
3797         dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len));
3798         dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
3799         dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
3800             ZFS_SA_BASE_ATTR_SIZE + len);
3801         dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
3802         if (!zsb->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
3803                 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
3804                     acl_ids.z_aclp->z_acl_bytes);
3805         }
3806         if (fuid_dirtied)
3807                 zfs_fuid_txhold(zsb, tx);
3808         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
3809         if (error) {
3810                 zfs_dirent_unlock(dl);
3811                 if (error == ERESTART) {
3812                         waited = B_TRUE;
3813                         dmu_tx_wait(tx);
3814                         dmu_tx_abort(tx);
3815                         goto top;
3816                 }
3817                 zfs_acl_ids_free(&acl_ids);
3818                 dmu_tx_abort(tx);
3819                 ZFS_EXIT(zsb);
3820                 return (error);
3821         }
3822
3823         /*
3824          * Create a new object for the symlink.
3825          * for version 4 ZPL datsets the symlink will be an SA attribute
3826          */
3827         zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
3828
3829         if (fuid_dirtied)
3830                 zfs_fuid_sync(zsb, tx);
3831
3832         mutex_enter(&zp->z_lock);
3833         if (zp->z_is_sa)
3834                 error = sa_update(zp->z_sa_hdl, SA_ZPL_SYMLINK(zsb),
3835                     link, len, tx);
3836         else
3837                 zfs_sa_symlink(zp, link, len, tx);
3838         mutex_exit(&zp->z_lock);
3839
3840         zp->z_size = len;
3841         (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zsb),
3842             &zp->z_size, sizeof (zp->z_size), tx);
3843         /*
3844          * Insert the new object into the directory.
3845          */
3846         (void) zfs_link_create(dl, zp, tx, ZNEW);
3847
3848         if (flags & FIGNORECASE)
3849                 txtype |= TX_CI;
3850         zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link);
3851
3852         zfs_inode_update(dzp);
3853         zfs_inode_update(zp);
3854
3855         zfs_acl_ids_free(&acl_ids);
3856
3857         dmu_tx_commit(tx);
3858
3859         zfs_dirent_unlock(dl);
3860
3861         *ipp = ZTOI(zp);
3862
3863         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
3864                 zil_commit(zilog, 0);
3865
3866         ZFS_EXIT(zsb);
3867         return (error);
3868 }
3869 EXPORT_SYMBOL(zfs_symlink);
3870
3871 /*
3872  * Return, in the buffer contained in the provided uio structure,
3873  * the symbolic path referred to by ip.
3874  *
3875  *      IN:     ip      - inode of symbolic link
3876  *              uio     - structure to contain the link path.
3877  *              cr      - credentials of caller.
3878  *
3879  *      RETURN: 0 if success
3880  *              error code if failure
3881  *
3882  * Timestamps:
3883  *      ip - atime updated
3884  */
3885 /* ARGSUSED */
3886 int
3887 zfs_readlink(struct inode *ip, uio_t *uio, cred_t *cr)
3888 {
3889         znode_t         *zp = ITOZ(ip);
3890         zfs_sb_t        *zsb = ITOZSB(ip);
3891         int             error;
3892
3893         ZFS_ENTER(zsb);
3894         ZFS_VERIFY_ZP(zp);
3895
3896         mutex_enter(&zp->z_lock);
3897         if (zp->z_is_sa)
3898                 error = sa_lookup_uio(zp->z_sa_hdl,
3899                     SA_ZPL_SYMLINK(zsb), uio);
3900         else
3901                 error = zfs_sa_readlink(zp, uio);
3902         mutex_exit(&zp->z_lock);
3903
3904         ZFS_EXIT(zsb);
3905         return (error);
3906 }
3907 EXPORT_SYMBOL(zfs_readlink);
3908
3909 /*
3910  * Insert a new entry into directory tdip referencing sip.
3911  *
3912  *      IN:     tdip    - Directory to contain new entry.
3913  *              sip     - inode of new entry.
3914  *              name    - name of new entry.
3915  *              cr      - credentials of caller.
3916  *
3917  *      RETURN: 0 if success
3918  *              error code if failure
3919  *
3920  * Timestamps:
3921  *      tdip - ctime|mtime updated
3922  *       sip - ctime updated
3923  */
3924 /* ARGSUSED */
3925 int
3926 zfs_link(struct inode *tdip, struct inode *sip, char *name, cred_t *cr,
3927     int flags)
3928 {
3929         znode_t         *dzp = ITOZ(tdip);
3930         znode_t         *tzp, *szp;
3931         zfs_sb_t        *zsb = ITOZSB(tdip);
3932         zilog_t         *zilog;
3933         zfs_dirlock_t   *dl;
3934         dmu_tx_t        *tx;
3935         int             error;
3936         int             zf = ZNEW;
3937         uint64_t        parent;
3938         uid_t           owner;
3939         boolean_t       waited = B_FALSE;
3940         boolean_t       is_tmpfile = 0;
3941         uint64_t        txg;
3942 #ifdef HAVE_TMPFILE
3943         is_tmpfile = (sip->i_nlink == 0 && (sip->i_state & I_LINKABLE));
3944 #endif
3945         ASSERT(S_ISDIR(tdip->i_mode));
3946
3947         if (name == NULL)
3948                 return (SET_ERROR(EINVAL));
3949
3950         ZFS_ENTER(zsb);
3951         ZFS_VERIFY_ZP(dzp);
3952         zilog = zsb->z_log;
3953
3954         /*
3955          * POSIX dictates that we return EPERM here.
3956          * Better choices include ENOTSUP or EISDIR.
3957          */
3958         if (S_ISDIR(sip->i_mode)) {
3959                 ZFS_EXIT(zsb);
3960                 return (SET_ERROR(EPERM));
3961         }
3962
3963         szp = ITOZ(sip);
3964         ZFS_VERIFY_ZP(szp);
3965
3966         /*
3967          * We check i_sb because snapshots and the ctldir must have different
3968          * super blocks.
3969          */
3970         if (sip->i_sb != tdip->i_sb || zfsctl_is_node(sip)) {
3971                 ZFS_EXIT(zsb);
3972                 return (SET_ERROR(EXDEV));
3973         }
3974
3975         /* Prevent links to .zfs/shares files */
3976
3977         if ((error = sa_lookup(szp->z_sa_hdl, SA_ZPL_PARENT(zsb),
3978             &parent, sizeof (uint64_t))) != 0) {
3979                 ZFS_EXIT(zsb);
3980                 return (error);
3981         }
3982         if (parent == zsb->z_shares_dir) {
3983                 ZFS_EXIT(zsb);
3984                 return (SET_ERROR(EPERM));
3985         }
3986
3987         if (zsb->z_utf8 && u8_validate(name,
3988             strlen(name), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
3989                 ZFS_EXIT(zsb);
3990                 return (SET_ERROR(EILSEQ));
3991         }
3992         if (flags & FIGNORECASE)
3993                 zf |= ZCILOOK;
3994
3995         /*
3996          * We do not support links between attributes and non-attributes
3997          * because of the potential security risk of creating links
3998          * into "normal" file space in order to circumvent restrictions
3999          * imposed in attribute space.
4000          */
4001         if ((szp->z_pflags & ZFS_XATTR) != (dzp->z_pflags & ZFS_XATTR)) {
4002                 ZFS_EXIT(zsb);
4003                 return (SET_ERROR(EINVAL));
4004         }
4005
4006         owner = zfs_fuid_map_id(zsb, KUID_TO_SUID(sip->i_uid), cr, ZFS_OWNER);
4007         if (owner != crgetuid(cr) && secpolicy_basic_link(cr) != 0) {
4008                 ZFS_EXIT(zsb);
4009                 return (SET_ERROR(EPERM));
4010         }
4011
4012         if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
4013                 ZFS_EXIT(zsb);
4014                 return (error);
4015         }
4016
4017 top:
4018         /*
4019          * Attempt to lock directory; fail if entry already exists.
4020          */
4021         error = zfs_dirent_lock(&dl, dzp, name, &tzp, zf, NULL, NULL);
4022         if (error) {
4023                 ZFS_EXIT(zsb);
4024                 return (error);
4025         }
4026
4027         tx = dmu_tx_create(zsb->z_os);
4028         dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
4029         dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
4030         if (is_tmpfile)
4031                 dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
4032
4033         zfs_sa_upgrade_txholds(tx, szp);
4034         zfs_sa_upgrade_txholds(tx, dzp);
4035         error = dmu_tx_assign(tx, waited ? TXG_WAITED : TXG_NOWAIT);
4036         if (error) {
4037                 zfs_dirent_unlock(dl);
4038                 if (error == ERESTART) {
4039                         waited = B_TRUE;
4040                         dmu_tx_wait(tx);
4041                         dmu_tx_abort(tx);
4042                         goto top;
4043                 }
4044                 dmu_tx_abort(tx);
4045                 ZFS_EXIT(zsb);
4046                 return (error);
4047         }
4048         /* unmark z_unlinked so zfs_link_create will not reject */
4049         if (is_tmpfile)
4050                 szp->z_unlinked = 0;
4051         error = zfs_link_create(dl, szp, tx, 0);
4052
4053         if (error == 0) {
4054                 uint64_t txtype = TX_LINK;
4055                 /*
4056                  * tmpfile is created to be in z_unlinkedobj, so remove it.
4057                  * Also, we don't log in ZIL, be cause all previous file
4058                  * operation on the tmpfile are ignored by ZIL. Instead we
4059                  * always wait for txg to sync to make sure all previous
4060                  * operation are sync safe.
4061                  */
4062                 if (is_tmpfile) {
4063                         VERIFY(zap_remove_int(zsb->z_os, zsb->z_unlinkedobj,
4064                             szp->z_id, tx) == 0);
4065                 } else {
4066                         if (flags & FIGNORECASE)
4067                                 txtype |= TX_CI;
4068                         zfs_log_link(zilog, tx, txtype, dzp, szp, name);
4069                 }
4070         } else if (is_tmpfile) {
4071                 /* restore z_unlinked since when linking failed */
4072                 szp->z_unlinked = 1;
4073         }
4074         txg = dmu_tx_get_txg(tx);
4075         dmu_tx_commit(tx);
4076
4077         zfs_dirent_unlock(dl);
4078
4079         if (!is_tmpfile && zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
4080                 zil_commit(zilog, 0);
4081
4082         if (is_tmpfile)
4083                 txg_wait_synced(dmu_objset_pool(zsb->z_os), txg);
4084
4085         zfs_inode_update(dzp);
4086         zfs_inode_update(szp);
4087         ZFS_EXIT(zsb);
4088         return (error);
4089 }
4090 EXPORT_SYMBOL(zfs_link);
4091
4092 static void
4093 zfs_putpage_commit_cb(void *arg)
4094 {
4095         struct page *pp = arg;
4096
4097         ClearPageError(pp);
4098         end_page_writeback(pp);
4099 }
4100
4101 /*
4102  * Push a page out to disk, once the page is on stable storage the
4103  * registered commit callback will be run as notification of completion.
4104  *
4105  *      IN:     ip      - page mapped for inode.
4106  *              pp      - page to push (page is locked)
4107  *              wbc     - writeback control data
4108  *
4109  *      RETURN: 0 if success
4110  *              error code if failure
4111  *
4112  * Timestamps:
4113  *      ip - ctime|mtime updated
4114  */
4115 /* ARGSUSED */
4116 int
4117 zfs_putpage(struct inode *ip, struct page *pp, struct writeback_control *wbc)
4118 {
4119         znode_t         *zp = ITOZ(ip);
4120         zfs_sb_t        *zsb = ITOZSB(ip);
4121         loff_t          offset;
4122         loff_t          pgoff;
4123         unsigned int    pglen;
4124         rl_t            *rl;
4125         dmu_tx_t        *tx;
4126         caddr_t         va;
4127         int             err = 0;
4128         uint64_t        mtime[2], ctime[2];
4129         sa_bulk_attr_t  bulk[3];
4130         int             cnt = 0;
4131         struct address_space *mapping;
4132
4133         ZFS_ENTER(zsb);
4134         ZFS_VERIFY_ZP(zp);
4135
4136         ASSERT(PageLocked(pp));
4137
4138         pgoff = page_offset(pp);        /* Page byte-offset in file */
4139         offset = i_size_read(ip);       /* File length in bytes */
4140         pglen = MIN(PAGE_SIZE,          /* Page length in bytes */
4141             P2ROUNDUP(offset, PAGE_SIZE)-pgoff);
4142
4143         /* Page is beyond end of file */
4144         if (pgoff >= offset) {
4145                 unlock_page(pp);
4146                 ZFS_EXIT(zsb);
4147                 return (0);
4148         }
4149
4150         /* Truncate page length to end of file */
4151         if (pgoff + pglen > offset)
4152                 pglen = offset - pgoff;
4153
4154 #if 0
4155         /*
4156          * FIXME: Allow mmap writes past its quota.  The correct fix
4157          * is to register a page_mkwrite() handler to count the page
4158          * against its quota when it is about to be dirtied.
4159          */
4160         if (zfs_owner_overquota(zsb, zp, B_FALSE) ||
4161             zfs_owner_overquota(zsb, zp, B_TRUE)) {
4162                 err = EDQUOT;
4163         }
4164 #endif
4165
4166         /*
4167          * The ordering here is critical and must adhere to the following
4168          * rules in order to avoid deadlocking in either zfs_read() or
4169          * zfs_free_range() due to a lock inversion.
4170          *
4171          * 1) The page must be unlocked prior to acquiring the range lock.
4172          *    This is critical because zfs_read() calls find_lock_page()
4173          *    which may block on the page lock while holding the range lock.
4174          *
4175          * 2) Before setting or clearing write back on a page the range lock
4176          *    must be held in order to prevent a lock inversion with the
4177          *    zfs_free_range() function.
4178          *
4179          * This presents a problem because upon entering this function the
4180          * page lock is already held.  To safely acquire the range lock the
4181          * page lock must be dropped.  This creates a window where another
4182          * process could truncate, invalidate, dirty, or write out the page.
4183          *
4184          * Therefore, after successfully reacquiring the range and page locks
4185          * the current page state is checked.  In the common case everything
4186          * will be as is expected and it can be written out.  However, if
4187          * the page state has changed it must be handled accordingly.
4188          */
4189         mapping = pp->mapping;
4190         redirty_page_for_writepage(wbc, pp);
4191         unlock_page(pp);
4192
4193         rl = zfs_range_lock(&zp->z_range_lock, pgoff, pglen, RL_WRITER);
4194         lock_page(pp);
4195
4196         /* Page mapping changed or it was no longer dirty, we're done */
4197         if (unlikely((mapping != pp->mapping) || !PageDirty(pp))) {
4198                 unlock_page(pp);
4199                 zfs_range_unlock(rl);
4200                 ZFS_EXIT(zsb);
4201                 return (0);
4202         }
4203
4204         /* Another process started write block if required */
4205         if (PageWriteback(pp)) {
4206                 unlock_page(pp);
4207                 zfs_range_unlock(rl);
4208
4209                 if (wbc->sync_mode != WB_SYNC_NONE)
4210                         wait_on_page_writeback(pp);
4211
4212                 ZFS_EXIT(zsb);
4213                 return (0);
4214         }
4215
4216         /* Clear the dirty flag the required locks are held */
4217         if (!clear_page_dirty_for_io(pp)) {
4218                 unlock_page(pp);
4219                 zfs_range_unlock(rl);
4220                 ZFS_EXIT(zsb);
4221                 return (0);
4222         }
4223
4224         /*
4225          * Counterpart for redirty_page_for_writepage() above.  This page
4226          * was in fact not skipped and should not be counted as if it were.
4227          */
4228         wbc->pages_skipped--;
4229         set_page_writeback(pp);
4230         unlock_page(pp);
4231
4232         tx = dmu_tx_create(zsb->z_os);
4233         dmu_tx_hold_write(tx, zp->z_id, pgoff, pglen);
4234         dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
4235         zfs_sa_upgrade_txholds(tx, zp);
4236
4237         err = dmu_tx_assign(tx, TXG_NOWAIT);
4238         if (err != 0) {
4239                 if (err == ERESTART)
4240                         dmu_tx_wait(tx);
4241
4242                 dmu_tx_abort(tx);
4243                 __set_page_dirty_nobuffers(pp);
4244                 ClearPageError(pp);
4245                 end_page_writeback(pp);
4246                 zfs_range_unlock(rl);
4247                 ZFS_EXIT(zsb);
4248                 return (err);
4249         }
4250
4251         va = kmap(pp);
4252         ASSERT3U(pglen, <=, PAGE_SIZE);
4253         dmu_write(zsb->z_os, zp->z_id, pgoff, pglen, va, tx);
4254         kunmap(pp);
4255
4256         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(zsb), NULL, &mtime, 16);
4257         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(zsb), NULL, &ctime, 16);
4258         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_FLAGS(zsb), NULL, &zp->z_pflags, 8);
4259
4260         /* Preserve the mtime and ctime provided by the inode */
4261         ZFS_TIME_ENCODE(&ip->i_mtime, mtime);
4262         ZFS_TIME_ENCODE(&ip->i_ctime, ctime);
4263         zp->z_atime_dirty = 0;
4264         zp->z_seq++;
4265
4266         err = sa_bulk_update(zp->z_sa_hdl, bulk, cnt, tx);
4267
4268         zfs_log_write(zsb->z_log, tx, TX_WRITE, zp, pgoff, pglen, 0,
4269             zfs_putpage_commit_cb, pp);
4270         dmu_tx_commit(tx);
4271
4272         zfs_range_unlock(rl);
4273
4274         if (wbc->sync_mode != WB_SYNC_NONE) {
4275                 /*
4276                  * Note that this is rarely called under writepages(), because
4277                  * writepages() normally handles the entire commit for
4278                  * performance reasons.
4279                  */
4280                 zil_commit(zsb->z_log, zp->z_id);
4281         }
4282
4283         ZFS_EXIT(zsb);
4284         return (err);
4285 }
4286
4287 /*
4288  * Update the system attributes when the inode has been dirtied.  For the
4289  * moment we only update the mode, atime, mtime, and ctime.
4290  */
4291 int
4292 zfs_dirty_inode(struct inode *ip, int flags)
4293 {
4294         znode_t         *zp = ITOZ(ip);
4295         zfs_sb_t        *zsb = ITOZSB(ip);
4296         dmu_tx_t        *tx;
4297         uint64_t        mode, atime[2], mtime[2], ctime[2];
4298         sa_bulk_attr_t  bulk[4];
4299         int             error = 0;
4300         int             cnt = 0;
4301
4302         if (zfs_is_readonly(zsb) || dmu_objset_is_snapshot(zsb->z_os))
4303                 return (0);
4304
4305         ZFS_ENTER(zsb);
4306         ZFS_VERIFY_ZP(zp);
4307
4308 #ifdef I_DIRTY_TIME
4309         /*
4310          * This is the lazytime semantic indroduced in Linux 4.0
4311          * This flag will only be called from update_time when lazytime is set.
4312          * (Note, I_DIRTY_SYNC will also set if not lazytime)
4313          * Fortunately mtime and ctime are managed within ZFS itself, so we
4314          * only need to dirty atime.
4315          */
4316         if (flags == I_DIRTY_TIME) {
4317                 zp->z_atime_dirty = 1;
4318                 goto out;
4319         }
4320 #endif
4321
4322         tx = dmu_tx_create(zsb->z_os);
4323
4324         dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
4325         zfs_sa_upgrade_txholds(tx, zp);
4326
4327         error = dmu_tx_assign(tx, TXG_WAIT);
4328         if (error) {
4329                 dmu_tx_abort(tx);
4330                 goto out;
4331         }
4332
4333         mutex_enter(&zp->z_lock);
4334         zp->z_atime_dirty = 0;
4335
4336         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MODE(zsb), NULL, &mode, 8);
4337         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_ATIME(zsb), NULL, &atime, 16);
4338         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(zsb), NULL, &mtime, 16);
4339         SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(zsb), NULL, &ctime, 16);
4340
4341         /* Preserve the mode, mtime and ctime provided by the inode */
4342         ZFS_TIME_ENCODE(&ip->i_atime, atime);
4343         ZFS_TIME_ENCODE(&ip->i_mtime, mtime);
4344         ZFS_TIME_ENCODE(&ip->i_ctime, ctime);
4345         mode = ip->i_mode;
4346
4347         zp->z_mode = mode;
4348
4349         error = sa_bulk_update(zp->z_sa_hdl, bulk, cnt, tx);
4350         mutex_exit(&zp->z_lock);
4351
4352         dmu_tx_commit(tx);
4353 out:
4354         ZFS_EXIT(zsb);
4355         return (error);
4356 }
4357 EXPORT_SYMBOL(zfs_dirty_inode);
4358
4359 /*ARGSUSED*/
4360 void
4361 zfs_inactive(struct inode *ip)
4362 {
4363         znode_t *zp = ITOZ(ip);
4364         zfs_sb_t *zsb = ITOZSB(ip);
4365         uint64_t atime[2];
4366         int error;
4367         int need_unlock = 0;
4368
4369         /* Only read lock if we haven't already write locked, e.g. rollback */
4370         if (!RW_WRITE_HELD(&zsb->z_teardown_inactive_lock)) {
4371                 need_unlock = 1;
4372                 rw_enter(&zsb->z_teardown_inactive_lock, RW_READER);
4373         }
4374         if (zp->z_sa_hdl == NULL) {
4375                 if (need_unlock)
4376                         rw_exit(&zsb->z_teardown_inactive_lock);
4377                 return;
4378         }
4379
4380         if (zp->z_atime_dirty && zp->z_unlinked == 0) {
4381                 dmu_tx_t *tx = dmu_tx_create(zsb->z_os);
4382
4383                 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
4384                 zfs_sa_upgrade_txholds(tx, zp);
4385                 error = dmu_tx_assign(tx, TXG_WAIT);
4386                 if (error) {
4387                         dmu_tx_abort(tx);
4388                 } else {
4389                         ZFS_TIME_ENCODE(&ip->i_atime, atime);
4390                         mutex_enter(&zp->z_lock);
4391                         (void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zsb),
4392                             (void *)&atime, sizeof (atime), tx);
4393                         zp->z_atime_dirty = 0;
4394                         mutex_exit(&zp->z_lock);
4395                         dmu_tx_commit(tx);
4396                 }
4397         }
4398
4399         zfs_zinactive(zp);
4400         if (need_unlock)
4401                 rw_exit(&zsb->z_teardown_inactive_lock);
4402 }
4403 EXPORT_SYMBOL(zfs_inactive);
4404
4405 /*
4406  * Bounds-check the seek operation.
4407  *
4408  *      IN:     ip      - inode seeking within
4409  *              ooff    - old file offset
4410  *              noffp   - pointer to new file offset
4411  *              ct      - caller context
4412  *
4413  *      RETURN: 0 if success
4414  *              EINVAL if new offset invalid
4415  */
4416 /* ARGSUSED */
4417 int
4418 zfs_seek(struct inode *ip, offset_t ooff, offset_t *noffp)
4419 {
4420         if (S_ISDIR(ip->i_mode))
4421                 return (0);
4422         return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);
4423 }
4424 EXPORT_SYMBOL(zfs_seek);
4425
4426 /*
4427  * Fill pages with data from the disk.
4428  */
4429 static int
4430 zfs_fillpage(struct inode *ip, struct page *pl[], int nr_pages)
4431 {
4432         znode_t *zp = ITOZ(ip);
4433         zfs_sb_t *zsb = ITOZSB(ip);
4434         objset_t *os;
4435         struct page *cur_pp;
4436         u_offset_t io_off, total;
4437         size_t io_len;
4438         loff_t i_size;
4439         unsigned page_idx;
4440         int err;
4441
4442         os = zsb->z_os;
4443         io_len = nr_pages << PAGE_SHIFT;
4444         i_size = i_size_read(ip);
4445         io_off = page_offset(pl[0]);
4446
4447         if (io_off + io_len > i_size)
4448                 io_len = i_size - io_off;
4449
4450         /*
4451          * Iterate over list of pages and read each page individually.
4452          */
4453         page_idx = 0;
4454         for (total = io_off + io_len; io_off < total; io_off += PAGESIZE) {
4455                 caddr_t va;
4456
4457                 cur_pp = pl[page_idx++];
4458                 va = kmap(cur_pp);
4459                 err = dmu_read(os, zp->z_id, io_off, PAGESIZE, va,
4460                     DMU_READ_PREFETCH);
4461                 kunmap(cur_pp);
4462                 if (err) {
4463                         /* convert checksum errors into IO errors */
4464                         if (err == ECKSUM)
4465                                 err = SET_ERROR(EIO);
4466                         return (err);
4467                 }
4468         }
4469
4470         return (0);
4471 }
4472
4473 /*
4474  * Uses zfs_fillpage to read data from the file and fill the pages.
4475  *
4476  *      IN:     ip       - inode of file to get data from.
4477  *              pl       - list of pages to read
4478  *              nr_pages - number of pages to read
4479  *
4480  *      RETURN: 0 on success, error code on failure.
4481  *
4482  * Timestamps:
4483  *      vp - atime updated
4484  */
4485 /* ARGSUSED */
4486 int
4487 zfs_getpage(struct inode *ip, struct page *pl[], int nr_pages)
4488 {
4489         znode_t  *zp  = ITOZ(ip);
4490         zfs_sb_t *zsb = ITOZSB(ip);
4491         int      err;
4492
4493         if (pl == NULL)
4494                 return (0);
4495
4496         ZFS_ENTER(zsb);
4497         ZFS_VERIFY_ZP(zp);
4498
4499         err = zfs_fillpage(ip, pl, nr_pages);
4500
4501         ZFS_EXIT(zsb);
4502         return (err);
4503 }
4504 EXPORT_SYMBOL(zfs_getpage);
4505
4506 /*
4507  * Check ZFS specific permissions to memory map a section of a file.
4508  *
4509  *      IN:     ip      - inode of the file to mmap
4510  *              off     - file offset
4511  *              addrp   - start address in memory region
4512  *              len     - length of memory region
4513  *              vm_flags- address flags
4514  *
4515  *      RETURN: 0 if success
4516  *              error code if failure
4517  */
4518 /*ARGSUSED*/
4519 int
4520 zfs_map(struct inode *ip, offset_t off, caddr_t *addrp, size_t len,
4521     unsigned long vm_flags)
4522 {
4523         znode_t  *zp = ITOZ(ip);
4524         zfs_sb_t *zsb = ITOZSB(ip);
4525
4526         ZFS_ENTER(zsb);
4527         ZFS_VERIFY_ZP(zp);
4528
4529         if ((vm_flags & VM_WRITE) && (zp->z_pflags &
4530             (ZFS_IMMUTABLE | ZFS_READONLY | ZFS_APPENDONLY))) {
4531                 ZFS_EXIT(zsb);
4532                 return (SET_ERROR(EPERM));
4533         }
4534
4535         if ((vm_flags & (VM_READ | VM_EXEC)) &&
4536             (zp->z_pflags & ZFS_AV_QUARANTINED)) {
4537                 ZFS_EXIT(zsb);
4538                 return (SET_ERROR(EACCES));
4539         }
4540
4541         if (off < 0 || len > MAXOFFSET_T - off) {
4542                 ZFS_EXIT(zsb);
4543                 return (SET_ERROR(ENXIO));
4544         }
4545
4546         ZFS_EXIT(zsb);
4547         return (0);
4548 }
4549 EXPORT_SYMBOL(zfs_map);
4550
4551 /*
4552  * convoff - converts the given data (start, whence) to the
4553  * given whence.
4554  */
4555 int
4556 convoff(struct inode *ip, flock64_t *lckdat, int  whence, offset_t offset)
4557 {
4558         vattr_t vap;
4559         int error;
4560
4561         if ((lckdat->l_whence == 2) || (whence == 2)) {
4562                 if ((error = zfs_getattr(ip, &vap, 0, CRED()) != 0))
4563                         return (error);
4564         }
4565
4566         switch (lckdat->l_whence) {
4567         case 1:
4568                 lckdat->l_start += offset;
4569                 break;
4570         case 2:
4571                 lckdat->l_start += vap.va_size;
4572                 /* FALLTHRU */
4573         case 0:
4574                 break;
4575         default:
4576                 return (SET_ERROR(EINVAL));
4577         }
4578
4579         if (lckdat->l_start < 0)
4580                 return (SET_ERROR(EINVAL));
4581
4582         switch (whence) {
4583         case 1:
4584                 lckdat->l_start -= offset;
4585                 break;
4586         case 2:
4587                 lckdat->l_start -= vap.va_size;
4588                 /* FALLTHRU */
4589         case 0:
4590                 break;
4591         default:
4592                 return (SET_ERROR(EINVAL));
4593         }
4594
4595         lckdat->l_whence = (short)whence;
4596         return (0);
4597 }
4598
4599 /*
4600  * Free or allocate space in a file.  Currently, this function only
4601  * supports the `F_FREESP' command.  However, this command is somewhat
4602  * misnamed, as its functionality includes the ability to allocate as
4603  * well as free space.
4604  *
4605  *      IN:     ip      - inode of file to free data in.
4606  *              cmd     - action to take (only F_FREESP supported).
4607  *              bfp     - section of file to free/alloc.
4608  *              flag    - current file open mode flags.
4609  *              offset  - current file offset.
4610  *              cr      - credentials of caller [UNUSED].
4611  *
4612  *      RETURN: 0 on success, error code on failure.
4613  *
4614  * Timestamps:
4615  *      ip - ctime|mtime updated
4616  */
4617 /* ARGSUSED */
4618 int
4619 zfs_space(struct inode *ip, int cmd, flock64_t *bfp, int flag,
4620     offset_t offset, cred_t *cr)
4621 {
4622         znode_t         *zp = ITOZ(ip);
4623         zfs_sb_t        *zsb = ITOZSB(ip);
4624         uint64_t        off, len;
4625         int             error;
4626
4627         ZFS_ENTER(zsb);
4628         ZFS_VERIFY_ZP(zp);
4629
4630         if (cmd != F_FREESP) {
4631                 ZFS_EXIT(zsb);
4632                 return (SET_ERROR(EINVAL));
4633         }
4634
4635         /*
4636          * Callers might not be able to detect properly that we are read-only,
4637          * so check it explicitly here.
4638          */
4639         if (zfs_is_readonly(zsb)) {
4640                 ZFS_EXIT(zsb);
4641                 return (SET_ERROR(EROFS));
4642         }
4643
4644         if ((error = convoff(ip, bfp, 0, offset))) {
4645                 ZFS_EXIT(zsb);
4646                 return (error);
4647         }
4648
4649         if (bfp->l_len < 0) {
4650                 ZFS_EXIT(zsb);
4651                 return (SET_ERROR(EINVAL));
4652         }
4653
4654         /*
4655          * Permissions aren't checked on Solaris because on this OS
4656          * zfs_space() can only be called with an opened file handle.
4657          * On Linux we can get here through truncate_range() which
4658          * operates directly on inodes, so we need to check access rights.
4659          */
4660         if ((error = zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr))) {
4661                 ZFS_EXIT(zsb);
4662                 return (error);
4663         }
4664
4665         off = bfp->l_start;
4666         len = bfp->l_len; /* 0 means from off to end of file */
4667
4668         error = zfs_freesp(zp, off, len, flag, TRUE);
4669
4670         ZFS_EXIT(zsb);
4671         return (error);
4672 }
4673 EXPORT_SYMBOL(zfs_space);
4674
4675 /*ARGSUSED*/
4676 int
4677 zfs_fid(struct inode *ip, fid_t *fidp)
4678 {
4679         znode_t         *zp = ITOZ(ip);
4680         zfs_sb_t        *zsb = ITOZSB(ip);
4681         uint32_t        gen;
4682         uint64_t        gen64;
4683         uint64_t        object = zp->z_id;
4684         zfid_short_t    *zfid;
4685         int             size, i, error;
4686
4687         ZFS_ENTER(zsb);
4688         ZFS_VERIFY_ZP(zp);
4689
4690         if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zsb),
4691             &gen64, sizeof (uint64_t))) != 0) {
4692                 ZFS_EXIT(zsb);
4693                 return (error);
4694         }
4695
4696         gen = (uint32_t)gen64;
4697
4698         size = (zsb->z_parent != zsb) ? LONG_FID_LEN : SHORT_FID_LEN;
4699         if (fidp->fid_len < size) {
4700                 fidp->fid_len = size;
4701                 ZFS_EXIT(zsb);
4702                 return (SET_ERROR(ENOSPC));
4703         }
4704
4705         zfid = (zfid_short_t *)fidp;
4706
4707         zfid->zf_len = size;
4708
4709         for (i = 0; i < sizeof (zfid->zf_object); i++)
4710                 zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
4711
4712         /* Must have a non-zero generation number to distinguish from .zfs */
4713         if (gen == 0)
4714                 gen = 1;
4715         for (i = 0; i < sizeof (zfid->zf_gen); i++)
4716                 zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));
4717
4718         if (size == LONG_FID_LEN) {
4719                 uint64_t        objsetid = dmu_objset_id(zsb->z_os);
4720                 zfid_long_t     *zlfid;
4721
4722                 zlfid = (zfid_long_t *)fidp;
4723
4724                 for (i = 0; i < sizeof (zlfid->zf_setid); i++)
4725                         zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i));
4726
4727                 /* XXX - this should be the generation number for the objset */
4728                 for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
4729                         zlfid->zf_setgen[i] = 0;
4730         }
4731
4732         ZFS_EXIT(zsb);
4733         return (0);
4734 }
4735 EXPORT_SYMBOL(zfs_fid);
4736
4737 /*ARGSUSED*/
4738 int
4739 zfs_getsecattr(struct inode *ip, vsecattr_t *vsecp, int flag, cred_t *cr)
4740 {
4741         znode_t *zp = ITOZ(ip);
4742         zfs_sb_t *zsb = ITOZSB(ip);
4743         int error;
4744         boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
4745
4746         ZFS_ENTER(zsb);
4747         ZFS_VERIFY_ZP(zp);
4748         error = zfs_getacl(zp, vsecp, skipaclchk, cr);
4749         ZFS_EXIT(zsb);
4750
4751         return (error);
4752 }
4753 EXPORT_SYMBOL(zfs_getsecattr);
4754
4755 /*ARGSUSED*/
4756 int
4757 zfs_setsecattr(struct inode *ip, vsecattr_t *vsecp, int flag, cred_t *cr)
4758 {
4759         znode_t *zp = ITOZ(ip);
4760         zfs_sb_t *zsb = ITOZSB(ip);
4761         int error;
4762         boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
4763         zilog_t *zilog = zsb->z_log;
4764
4765         ZFS_ENTER(zsb);
4766         ZFS_VERIFY_ZP(zp);
4767
4768         error = zfs_setacl(zp, vsecp, skipaclchk, cr);
4769
4770         if (zsb->z_os->os_sync == ZFS_SYNC_ALWAYS)
4771                 zil_commit(zilog, 0);
4772
4773         ZFS_EXIT(zsb);
4774         return (error);
4775 }
4776 EXPORT_SYMBOL(zfs_setsecattr);
4777
4778 #ifdef HAVE_UIO_ZEROCOPY
4779 /*
4780  * Tunable, both must be a power of 2.
4781  *
4782  * zcr_blksz_min: the smallest read we may consider to loan out an arcbuf
4783  * zcr_blksz_max: if set to less than the file block size, allow loaning out of
4784  *              an arcbuf for a partial block read
4785  */
4786 int zcr_blksz_min = (1 << 10);  /* 1K */
4787 int zcr_blksz_max = (1 << 17);  /* 128K */
4788
4789 /*ARGSUSED*/
4790 static int
4791 zfs_reqzcbuf(struct inode *ip, enum uio_rw ioflag, xuio_t *xuio, cred_t *cr)
4792 {
4793         znode_t *zp = ITOZ(ip);
4794         zfs_sb_t *zsb = ITOZSB(ip);
4795         int max_blksz = zsb->z_max_blksz;
4796         uio_t *uio = &xuio->xu_uio;
4797         ssize_t size = uio->uio_resid;
4798         offset_t offset = uio->uio_loffset;
4799         int blksz;
4800         int fullblk, i;
4801         arc_buf_t *abuf;
4802         ssize_t maxsize;
4803         int preamble, postamble;
4804
4805         if (xuio->xu_type != UIOTYPE_ZEROCOPY)
4806                 return (SET_ERROR(EINVAL));
4807
4808         ZFS_ENTER(zsb);
4809         ZFS_VERIFY_ZP(zp);
4810         switch (ioflag) {
4811         case UIO_WRITE:
4812                 /*
4813                  * Loan out an arc_buf for write if write size is bigger than
4814                  * max_blksz, and the file's block size is also max_blksz.
4815                  */
4816                 blksz = max_blksz;
4817                 if (size < blksz || zp->z_blksz != blksz) {
4818                         ZFS_EXIT(zsb);
4819                         return (SET_ERROR(EINVAL));
4820                 }
4821                 /*
4822                  * Caller requests buffers for write before knowing where the
4823                  * write offset might be (e.g. NFS TCP write).
4824                  */
4825                 if (offset == -1) {
4826                         preamble = 0;
4827                 } else {
4828                         preamble = P2PHASE(offset, blksz);
4829                         if (preamble) {
4830                                 preamble = blksz - preamble;
4831                                 size -= preamble;
4832                         }
4833                 }
4834
4835                 postamble = P2PHASE(size, blksz);
4836                 size -= postamble;
4837
4838                 fullblk = size / blksz;
4839                 (void) dmu_xuio_init(xuio,
4840                     (preamble != 0) + fullblk + (postamble != 0));
4841
4842                 /*
4843                  * Have to fix iov base/len for partial buffers.  They
4844                  * currently represent full arc_buf's.
4845                  */
4846                 if (preamble) {
4847                         /* data begins in the middle of the arc_buf */
4848                         abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
4849                             blksz);
4850                         ASSERT(abuf);
4851                         (void) dmu_xuio_add(xuio, abuf,
4852                             blksz - preamble, preamble);
4853                 }
4854
4855                 for (i = 0; i < fullblk; i++) {
4856                         abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
4857                             blksz);
4858                         ASSERT(abuf);
4859                         (void) dmu_xuio_add(xuio, abuf, 0, blksz);
4860                 }
4861
4862                 if (postamble) {
4863                         /* data ends in the middle of the arc_buf */
4864                         abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
4865                             blksz);
4866                         ASSERT(abuf);
4867                         (void) dmu_xuio_add(xuio, abuf, 0, postamble);
4868                 }
4869                 break;
4870         case UIO_READ:
4871                 /*
4872                  * Loan out an arc_buf for read if the read size is larger than
4873                  * the current file block size.  Block alignment is not
4874                  * considered.  Partial arc_buf will be loaned out for read.
4875                  */
4876                 blksz = zp->z_blksz;
4877                 if (blksz < zcr_blksz_min)
4878                         blksz = zcr_blksz_min;
4879                 if (blksz > zcr_blksz_max)
4880                         blksz = zcr_blksz_max;
4881                 /* avoid potential complexity of dealing with it */
4882                 if (blksz > max_blksz) {
4883                         ZFS_EXIT(zsb);
4884                         return (SET_ERROR(EINVAL));
4885                 }
4886
4887                 maxsize = zp->z_size - uio->uio_loffset;
4888                 if (size > maxsize)
4889                         size = maxsize;
4890
4891                 if (size < blksz) {
4892                         ZFS_EXIT(zsb);
4893                         return (SET_ERROR(EINVAL));
4894                 }
4895                 break;
4896         default:
4897                 ZFS_EXIT(zsb);
4898                 return (SET_ERROR(EINVAL));
4899         }
4900
4901         uio->uio_extflg = UIO_XUIO;
4902         XUIO_XUZC_RW(xuio) = ioflag;
4903         ZFS_EXIT(zsb);
4904         return (0);
4905 }
4906
4907 /*ARGSUSED*/
4908 static int
4909 zfs_retzcbuf(struct inode *ip, xuio_t *xuio, cred_t *cr)
4910 {
4911         int i;
4912         arc_buf_t *abuf;
4913         int ioflag = XUIO_XUZC_RW(xuio);
4914
4915         ASSERT(xuio->xu_type == UIOTYPE_ZEROCOPY);
4916
4917         i = dmu_xuio_cnt(xuio);
4918         while (i-- > 0) {
4919                 abuf = dmu_xuio_arcbuf(xuio, i);
4920                 /*
4921                  * if abuf == NULL, it must be a write buffer
4922                  * that has been returned in zfs_write().
4923                  */
4924                 if (abuf)
4925                         dmu_return_arcbuf(abuf);
4926                 ASSERT(abuf || ioflag == UIO_WRITE);
4927         }
4928
4929         dmu_xuio_fini(xuio);
4930         return (0);
4931 }
4932 #endif /* HAVE_UIO_ZEROCOPY */
4933
4934 #if defined(_KERNEL) && defined(HAVE_SPL)
4935 /* CSTYLED */
4936 module_param(zfs_delete_blocks, ulong, 0644);
4937 MODULE_PARM_DESC(zfs_delete_blocks, "Delete files larger than N blocks async");
4938 module_param(zfs_read_chunk_size, long, 0644);
4939 MODULE_PARM_DESC(zfs_read_chunk_size, "Bytes to read per chunk");
4940 #endif