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