module/zfs/zfs_vnops.c

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