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