1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
5736b9155Smarks * Common Development and Distribution License (the "License").
6736b9155Smarks * You may not use this file except in compliance with the License.
7fa9e4066Sahrens *
8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens * See the License for the specific language governing permissions
11fa9e4066Sahrens * and limitations under the License.
12fa9e4066Sahrens *
13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens *
19fa9e4066Sahrens * CDDL HEADER END
20fa9e4066Sahrens */
211c17160aSKevin Crowe
22fa9e4066Sahrens /*
23d39ee142SMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24ade42b55SSebastien Roy * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
25c3d26abcSMatthew Ahrens * Copyright (c) 2014 Integros [integros.com]
26aaa9aa59SJerry Jelinek * Copyright 2020 Joyent, Inc.
27f37b3cbbSMatt Barden * Copyright 2020 Tintri by DDN, Inc. All rights reserved.
2870561057SGordon Ross * Copyright 2015-2023 RackTop Systems, Inc.
29fa9e4066Sahrens */
30fa9e4066Sahrens
3175c76197Speteh /* Portions Copyright 2007 Jeremy Teo */
3255da60b9SMark J Musante /* Portions Copyright 2010 Robert Milkowski */
3375c76197Speteh
34fa9e4066Sahrens #include <sys/types.h>
35fa9e4066Sahrens #include <sys/param.h>
36fa9e4066Sahrens #include <sys/time.h>
37fa9e4066Sahrens #include <sys/systm.h>
38fa9e4066Sahrens #include <sys/sysmacros.h>
39fa9e4066Sahrens #include <sys/resource.h>
40fa9e4066Sahrens #include <sys/vfs.h>
41aa59c4cbSrsb #include <sys/vfs_opreg.h>
42fa9e4066Sahrens #include <sys/vnode.h>
43fa9e4066Sahrens #include <sys/file.h>
44fa9e4066Sahrens #include <sys/stat.h>
45fa9e4066Sahrens #include <sys/kmem.h>
46fa9e4066Sahrens #include <sys/taskq.h>
47fa9e4066Sahrens #include <sys/uio.h>
48fa9e4066Sahrens #include <sys/vmsystm.h>
49fa9e4066Sahrens #include <sys/atomic.h>
5044eda4d7Smaybee #include <sys/vm.h>
51fa9e4066Sahrens #include <vm/seg_vn.h>
52fa9e4066Sahrens #include <vm/pvn.h>
53fa9e4066Sahrens #include <vm/as.h>
540fab61baSJonathan W Adams #include <vm/kpm.h>
550fab61baSJonathan W Adams #include <vm/seg_kpm.h>
56fa9e4066Sahrens #include <sys/mman.h>
57fa9e4066Sahrens #include <sys/pathname.h>
58fa9e4066Sahrens #include <sys/cmn_err.h>
59fa9e4066Sahrens #include <sys/errno.h>
60fa9e4066Sahrens #include <sys/unistd.h>
61fa9e4066Sahrens #include <sys/zfs_dir.h>
62fa9e4066Sahrens #include <sys/zfs_acl.h>
63fa9e4066Sahrens #include <sys/zfs_ioctl.h>
64fa9e4066Sahrens #include <sys/fs/zfs.h>
65fa9e4066Sahrens #include <sys/dmu.h>
6655da60b9SMark J Musante #include <sys/dmu_objset.h>
67fa9e4066Sahrens #include <sys/spa.h>
68fa9e4066Sahrens #include <sys/txg.h>
69fa9e4066Sahrens #include <sys/dbuf.h>
70fa9e4066Sahrens #include <sys/zap.h>
710a586ceaSMark Shellenbaum #include <sys/sa.h>
72fa9e4066Sahrens #include <sys/dirent.h>
73fa9e4066Sahrens #include <sys/policy.h>
74fa9e4066Sahrens #include <sys/sunddi.h>
75fa9e4066Sahrens #include <sys/filio.h>
76c1ce5987SMark Shellenbaum #include <sys/sid.h>
77fa9e4066Sahrens #include "fs/fs_subr.h"
78fa9e4066Sahrens #include <sys/zfs_ctldir.h>
79da6c28aaSamw #include <sys/zfs_fuid.h>
800a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
81033f9833Sek110237 #include <sys/dnlc.h>
82104e2ed7Sperrin #include <sys/zfs_rlock.h>
83da6c28aaSamw #include <sys/extdirent.h>
84da6c28aaSamw #include <sys/kidmap.h>
8567dbe2beSCasper H.S. Dik #include <sys/cred.h>
86b38f0970Sck153898 #include <sys/attr.h>
871271e4b1SPrakash Surya #include <sys/zil.h>
88f67950b2SNasf-Fan #include <sys/sa_impl.h>
89f67950b2SNasf-Fan #include <sys/zfs_project.h>
90fa9e4066Sahrens
91fa9e4066Sahrens /*
92fa9e4066Sahrens * Programming rules.
93fa9e4066Sahrens *
94fa9e4066Sahrens * Each vnode op performs some logical unit of work. To do this, the ZPL must
95fa9e4066Sahrens * properly lock its in-core state, create a DMU transaction, do the work,
96fa9e4066Sahrens * record this work in the intent log (ZIL), commit the DMU transaction,
97da6c28aaSamw * and wait for the intent log to commit if it is a synchronous operation.
98da6c28aaSamw * Moreover, the vnode ops must work in both normal and log replay context.
99fa9e4066Sahrens * The ordering of events is important to avoid deadlocks and references
100fa9e4066Sahrens * to freed memory. The example below illustrates the following Big Rules:
101fa9e4066Sahrens *
102fa9e4066Sahrens * (1) A check must be made in each zfs thread for a mounted file system.
1033cb34c60Sahrens * This is done avoiding races using ZFS_ENTER(zfsvfs).
1043cb34c60Sahrens * A ZFS_EXIT(zfsvfs) is needed before all returns. Any znodes
1053cb34c60Sahrens * must be checked with ZFS_VERIFY_ZP(zp). Both of these macros
1063cb34c60Sahrens * can return EIO from the calling function.
107fa9e4066Sahrens *
108fa9e4066Sahrens * (2) VN_RELE() should always be the last thing except for zil_commit()
109b19a79ecSperrin * (if necessary) and ZFS_EXIT(). This is for 3 reasons:
110fa9e4066Sahrens * First, if it's the last reference, the vnode/znode
111fa9e4066Sahrens * can be freed, so the zp may point to freed memory. Second, the last
112fa9e4066Sahrens * reference will call zfs_zinactive(), which may induce a lot of work --
113104e2ed7Sperrin * pushing cached pages (which acquires range locks) and syncing out
114fa9e4066Sahrens * cached atime changes. Third, zfs_zinactive() may require a new tx,
115fa9e4066Sahrens * which could deadlock the system if you were already holding one.
1169d3574bfSNeil Perrin * If you must call VN_RELE() within a tx then use VN_RELE_ASYNC().
117fa9e4066Sahrens *
1187885c754Sperrin * (3) All range locks must be grabbed before calling dmu_tx_assign(),
1197885c754Sperrin * as they can span dmu_tx_assign() calls.
1207885c754Sperrin *
121e722410cSMatthew Ahrens * (4) If ZPL locks are held, pass TXG_NOWAIT as the second argument to
122e722410cSMatthew Ahrens * dmu_tx_assign(). This is critical because we don't want to block
123e722410cSMatthew Ahrens * while holding locks.
124e722410cSMatthew Ahrens *
125e722410cSMatthew Ahrens * If no ZPL locks are held (aside from ZFS_ENTER()), use TXG_WAIT. This
126e722410cSMatthew Ahrens * reduces lock contention and CPU usage when we must wait (note that if
127e722410cSMatthew Ahrens * throughput is constrained by the storage, nearly every transaction
128e722410cSMatthew Ahrens * must wait).
129e722410cSMatthew Ahrens *
130fa9e4066Sahrens * Note, in particular, that if a lock is sometimes acquired before
131e722410cSMatthew Ahrens * the tx assigns, and sometimes after (e.g. z_lock), then failing
132e722410cSMatthew Ahrens * to use a non-blocking assign can deadlock the system. The scenario:
133fa9e4066Sahrens *
134fa9e4066Sahrens * Thread A has grabbed a lock before calling dmu_tx_assign().
135fa9e4066Sahrens * Thread B is in an already-assigned tx, and blocks for this lock.
136fa9e4066Sahrens * Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()
137fa9e4066Sahrens * forever, because the previous txg can't quiesce until B's tx commits.
138fa9e4066Sahrens *
139fa9e4066Sahrens * If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT,
14069962b56SMatthew Ahrens * then drop all locks, call dmu_tx_wait(), and try again. On subsequent
141f864f99eSPrakash Surya * calls to dmu_tx_assign(), pass TXG_NOTHROTTLE in addition to TXG_NOWAIT,
14269962b56SMatthew Ahrens * to indicate that this operation has already called dmu_tx_wait().
14369962b56SMatthew Ahrens * This will ensure that we don't retry forever, waiting a short bit
14469962b56SMatthew Ahrens * each time.
145fa9e4066Sahrens *
1467885c754Sperrin * (5) If the operation succeeded, generate the intent log entry for it
147fa9e4066Sahrens * before dropping locks. This ensures that the ordering of events
148fa9e4066Sahrens * in the intent log matches the order in which they actually occurred.
1491209a471SNeil Perrin * During ZIL replay the zfs_log_* functions will update the sequence
1501209a471SNeil Perrin * number to indicate the zil transaction has replayed.
151fa9e4066Sahrens *
1527885c754Sperrin * (6) At the end of each vnode op, the DMU tx must always commit,
153fa9e4066Sahrens * regardless of whether there were any errors.
154fa9e4066Sahrens *
1555002558fSNeil Perrin * (7) After dropping all locks, invoke zil_commit(zilog, foid)
156fa9e4066Sahrens * to ensure that synchronous semantics are provided when necessary.
157fa9e4066Sahrens *
158fa9e4066Sahrens * In general, this is how things should be ordered in each vnode op:
159fa9e4066Sahrens *
160fa9e4066Sahrens * ZFS_ENTER(zfsvfs); // exit if unmounted
161fa9e4066Sahrens * top:
162fa9e4066Sahrens * zfs_dirent_lock(&dl, ...) // lock directory entry (may VN_HOLD())
163fa9e4066Sahrens * rw_enter(...); // grab any other locks you need
164fa9e4066Sahrens * tx = dmu_tx_create(...); // get DMU tx
165fa9e4066Sahrens * dmu_tx_hold_*(); // hold each object you might modify
166f864f99eSPrakash Surya * error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
167fa9e4066Sahrens * if (error) {
168fa9e4066Sahrens * rw_exit(...); // drop locks
169fa9e4066Sahrens * zfs_dirent_unlock(dl); // unlock directory entry
170fa9e4066Sahrens * VN_RELE(...); // release held vnodes
1711209a471SNeil Perrin * if (error == ERESTART) {
17269962b56SMatthew Ahrens * waited = B_TRUE;
1738a2f1b91Sahrens * dmu_tx_wait(tx);
1748a2f1b91Sahrens * dmu_tx_abort(tx);
175fa9e4066Sahrens * goto top;
176fa9e4066Sahrens * }
1778a2f1b91Sahrens * dmu_tx_abort(tx); // abort DMU tx
178fa9e4066Sahrens * ZFS_EXIT(zfsvfs); // finished in zfs
179fa9e4066Sahrens * return (error); // really out of space
180fa9e4066Sahrens * }
181fa9e4066Sahrens * error = do_real_work(); // do whatever this VOP does
182fa9e4066Sahrens * if (error == 0)
183b19a79ecSperrin * zfs_log_*(...); // on success, make ZIL entry
184fa9e4066Sahrens * dmu_tx_commit(tx); // commit DMU tx -- error or not
185fa9e4066Sahrens * rw_exit(...); // drop locks
186fa9e4066Sahrens * zfs_dirent_unlock(dl); // unlock directory entry
187fa9e4066Sahrens * VN_RELE(...); // release held vnodes
1885002558fSNeil Perrin * zil_commit(zilog, foid); // synchronous when necessary
189fa9e4066Sahrens * ZFS_EXIT(zfsvfs); // finished in zfs
190fa9e4066Sahrens * return (error); // done, report error
191fa9e4066Sahrens */
1923cb34c60Sahrens
193fa9e4066Sahrens /* ARGSUSED */
194fa9e4066Sahrens static int
zfs_open(vnode_t ** vpp,int flag,cred_t * cr,caller_context_t * ct)195da6c28aaSamw zfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
196fa9e4066Sahrens {
19767bd71c6Sperrin znode_t *zp = VTOZ(*vpp);
198b614fdaaSMark Shellenbaum zfsvfs_t *zfsvfs = zp->z_zfsvfs;
199b614fdaaSMark Shellenbaum
200b614fdaaSMark Shellenbaum ZFS_ENTER(zfsvfs);
201b614fdaaSMark Shellenbaum ZFS_VERIFY_ZP(zp);
20267bd71c6Sperrin
2030a586ceaSMark Shellenbaum if ((flag & FWRITE) && (zp->z_pflags & ZFS_APPENDONLY) &&
204da6c28aaSamw ((flag & FAPPEND) == 0)) {
205b614fdaaSMark Shellenbaum ZFS_EXIT(zfsvfs);
206be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
207da6c28aaSamw }
208da6c28aaSamw
209da6c28aaSamw if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
210da6c28aaSamw ZTOV(zp)->v_type == VREG &&
2110a586ceaSMark Shellenbaum !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) {
212b614fdaaSMark Shellenbaum if (fs_vscan(*vpp, cr, 0) != 0) {
213b614fdaaSMark Shellenbaum ZFS_EXIT(zfsvfs);
214be6fd75aSMatthew Ahrens return (SET_ERROR(EACCES));
215b614fdaaSMark Shellenbaum }
216b614fdaaSMark Shellenbaum }
217da6c28aaSamw
21867bd71c6Sperrin /* Keep a count of the synchronous opens in the znode */
21967bd71c6Sperrin if (flag & (FSYNC | FDSYNC))
22067bd71c6Sperrin atomic_inc_32(&zp->z_sync_cnt);
221da6c28aaSamw
222b614fdaaSMark Shellenbaum ZFS_EXIT(zfsvfs);
223fa9e4066Sahrens return (0);
224fa9e4066Sahrens }
225fa9e4066Sahrens
226fa9e4066Sahrens /* ARGSUSED */
227fa9e4066Sahrens static int
zfs_close(vnode_t * vp,int flag,int count,offset_t offset,cred_t * cr,caller_context_t * ct)228da6c28aaSamw zfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
229da6c28aaSamw caller_context_t *ct)
230fa9e4066Sahrens {
23167bd71c6Sperrin znode_t *zp = VTOZ(vp);
232b614fdaaSMark Shellenbaum zfsvfs_t *zfsvfs = zp->z_zfsvfs;
233b614fdaaSMark Shellenbaum
234ee8143cbSChris Kirby /*
235ee8143cbSChris Kirby * Clean up any locks held by this process on the vp.
236ee8143cbSChris Kirby */
237ee8143cbSChris Kirby cleanlocks(vp, ddi_get_pid(), 0);
238ee8143cbSChris Kirby cleanshares(vp, ddi_get_pid());
239ee8143cbSChris Kirby
240b614fdaaSMark Shellenbaum ZFS_ENTER(zfsvfs);
241b614fdaaSMark Shellenbaum ZFS_VERIFY_ZP(zp);
24267bd71c6Sperrin
24367bd71c6Sperrin /* Decrement the synchronous opens in the znode */
244ecb72030Sperrin if ((flag & (FSYNC | FDSYNC)) && (count == 1))
24567bd71c6Sperrin atomic_dec_32(&zp->z_sync_cnt);
24667bd71c6Sperrin
247da6c28aaSamw if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
248da6c28aaSamw ZTOV(zp)->v_type == VREG &&
2490a586ceaSMark Shellenbaum !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0)
250da6c28aaSamw VERIFY(fs_vscan(vp, cr, 1) == 0);
251da6c28aaSamw
252b614fdaaSMark Shellenbaum ZFS_EXIT(zfsvfs);
253fa9e4066Sahrens return (0);
254fa9e4066Sahrens }
255fa9e4066Sahrens
256fa9e4066Sahrens /*
257fa9e4066Sahrens * Lseek support for finding holes (cmd == _FIO_SEEK_HOLE) and
258fa9e4066Sahrens * data (cmd == _FIO_SEEK_DATA). "off" is an in/out parameter.
259fa9e4066Sahrens */
260fa9e4066Sahrens static int
zfs_holey(vnode_t * vp,int cmd,offset_t * off)261fa9e4066Sahrens zfs_holey(vnode_t *vp, int cmd, offset_t *off)
262fa9e4066Sahrens {
263fa9e4066Sahrens znode_t *zp = VTOZ(vp);
264fa9e4066Sahrens uint64_t noff = (uint64_t)*off; /* new offset */
265fa9e4066Sahrens uint64_t file_sz;
266fa9e4066Sahrens int error;
267fa9e4066Sahrens boolean_t hole;
268fa9e4066Sahrens
2690a586ceaSMark Shellenbaum file_sz = zp->z_size;
270fa9e4066Sahrens if (noff >= file_sz) {
271be6fd75aSMatthew Ahrens return (SET_ERROR(ENXIO));
272fa9e4066Sahrens }
273fa9e4066Sahrens
274fa9e4066Sahrens if (cmd == _FIO_SEEK_HOLE)
275fa9e4066Sahrens hole = B_TRUE;
276fa9e4066Sahrens else
277fa9e4066Sahrens hole = B_FALSE;
278fa9e4066Sahrens
279fa9e4066Sahrens error = dmu_offset_next(zp->z_zfsvfs->z_os, zp->z_id, hole, &noff);
280fa9e4066Sahrens
2810fbc0cd0SMatthew Ahrens if (error == ESRCH)
282be6fd75aSMatthew Ahrens return (SET_ERROR(ENXIO));
2830fbc0cd0SMatthew Ahrens
2840fbc0cd0SMatthew Ahrens /*
2850fbc0cd0SMatthew Ahrens * We could find a hole that begins after the logical end-of-file,
2860fbc0cd0SMatthew Ahrens * because dmu_offset_next() only works on whole blocks. If the
2870fbc0cd0SMatthew Ahrens * EOF falls mid-block, then indicate that the "virtual hole"
2880fbc0cd0SMatthew Ahrens * at the end of the file begins at the logical EOF, rather than
2890fbc0cd0SMatthew Ahrens * at the end of the last block.
2900fbc0cd0SMatthew Ahrens */
2910fbc0cd0SMatthew Ahrens if (noff > file_sz) {
2920fbc0cd0SMatthew Ahrens ASSERT(hole);
2930fbc0cd0SMatthew Ahrens noff = file_sz;
294fa9e4066Sahrens }
295fa9e4066Sahrens
296fa9e4066Sahrens if (noff < *off)
297fa9e4066Sahrens return (error);
298fa9e4066Sahrens *off = noff;
299fa9e4066Sahrens return (error);
300fa9e4066Sahrens }
301fa9e4066Sahrens
302f67950b2SNasf-Fan static int
zfs_ioctl_getxattr(vnode_t * vp,intptr_t data,int flag,cred_t * cr,caller_context_t * ct)303f67950b2SNasf-Fan zfs_ioctl_getxattr(vnode_t *vp, intptr_t data, int flag, cred_t *cr,
304f67950b2SNasf-Fan caller_context_t *ct)
305f67950b2SNasf-Fan {
306f67950b2SNasf-Fan zfsxattr_t fsx = { 0 };
307f67950b2SNasf-Fan znode_t *zp = VTOZ(vp);
308f67950b2SNasf-Fan
309f67950b2SNasf-Fan if (zp->z_pflags & ZFS_PROJINHERIT)
310f67950b2SNasf-Fan fsx.fsx_xflags = ZFS_PROJINHERIT_FL;
311f67950b2SNasf-Fan if (zp->z_pflags & ZFS_PROJID)
312f67950b2SNasf-Fan fsx.fsx_projid = zp->z_projid;
313f67950b2SNasf-Fan if (ddi_copyout(&fsx, (void *)data, sizeof (fsx), flag))
314f67950b2SNasf-Fan return (SET_ERROR(EFAULT));
315f67950b2SNasf-Fan
316f67950b2SNasf-Fan return (0);
317f67950b2SNasf-Fan }
318f67950b2SNasf-Fan
319f67950b2SNasf-Fan static int zfs_setattr(vnode_t *, vattr_t *, int, cred_t *, caller_context_t *);
320f67950b2SNasf-Fan
321f67950b2SNasf-Fan static int
zfs_ioctl_setxattr(vnode_t * vp,intptr_t data,int flags,cred_t * cr,caller_context_t * ct)322f67950b2SNasf-Fan zfs_ioctl_setxattr(vnode_t *vp, intptr_t data, int flags, cred_t *cr,
323f67950b2SNasf-Fan caller_context_t *ct)
324f67950b2SNasf-Fan {
325f67950b2SNasf-Fan znode_t *zp = VTOZ(vp);
326f67950b2SNasf-Fan zfsxattr_t fsx;
327f67950b2SNasf-Fan xvattr_t xva;
328f67950b2SNasf-Fan xoptattr_t *xoap;
329f67950b2SNasf-Fan int err;
330f67950b2SNasf-Fan
331f67950b2SNasf-Fan if (ddi_copyin((void *)data, &fsx, sizeof (fsx), flags))
332f67950b2SNasf-Fan return (SET_ERROR(EFAULT));
333f67950b2SNasf-Fan
334f67950b2SNasf-Fan if (!zpl_is_valid_projid(fsx.fsx_projid))
335f67950b2SNasf-Fan return (SET_ERROR(EINVAL));
336f67950b2SNasf-Fan
337f67950b2SNasf-Fan if (fsx.fsx_xflags & ~ZFS_PROJINHERIT_FL)
338f67950b2SNasf-Fan return (SET_ERROR(EOPNOTSUPP));
339f67950b2SNasf-Fan
340f67950b2SNasf-Fan xva_init(&xva);
341f67950b2SNasf-Fan xoap = xva_getxoptattr(&xva);
342f67950b2SNasf-Fan
343f67950b2SNasf-Fan XVA_SET_REQ(&xva, XAT_PROJINHERIT);
344f67950b2SNasf-Fan if (fsx.fsx_xflags & ZFS_PROJINHERIT_FL)
345f67950b2SNasf-Fan xoap->xoa_projinherit = B_TRUE;
346f67950b2SNasf-Fan
347f67950b2SNasf-Fan XVA_SET_REQ(&xva, XAT_PROJID);
348f67950b2SNasf-Fan xoap->xoa_projid = fsx.fsx_projid;
349f67950b2SNasf-Fan
350f67950b2SNasf-Fan return (zfs_setattr(vp, (vattr_t *)&xva, flags, cr, ct));
351f67950b2SNasf-Fan }
352f67950b2SNasf-Fan
353fa9e4066Sahrens /* ARGSUSED */
354fa9e4066Sahrens static int
zfs_ioctl(vnode_t * vp,int com,intptr_t data,int flag,cred_t * cred,int * rvalp,caller_context_t * ct)355fa9e4066Sahrens zfs_ioctl(vnode_t *vp, int com, intptr_t data, int flag, cred_t *cred,
356da6c28aaSamw int *rvalp, caller_context_t *ct)
357fa9e4066Sahrens {
358fa9e4066Sahrens offset_t off;
3592bcf0248SMax Grossman offset_t ndata;
3602bcf0248SMax Grossman dmu_object_info_t doi;
361fa9e4066Sahrens int error;
362fa9e4066Sahrens zfsvfs_t *zfsvfs;
363f18faf3fSek110237 znode_t *zp;
364fa9e4066Sahrens
365fa9e4066Sahrens switch (com) {
366fa9e4066Sahrens case _FIOFFS:
3672bcf0248SMax Grossman {
368fa9e4066Sahrens return (zfs_sync(vp->v_vfsp, 0, cred));
369fa9e4066Sahrens
370ea8dc4b6Seschrock /*
371ea8dc4b6Seschrock * The following two ioctls are used by bfu. Faking out,
372ea8dc4b6Seschrock * necessary to avoid bfu errors.
373ea8dc4b6Seschrock */
3742bcf0248SMax Grossman }
375ea8dc4b6Seschrock case _FIOGDIO:
376ea8dc4b6Seschrock case _FIOSDIO:
3772bcf0248SMax Grossman {
378ea8dc4b6Seschrock return (0);
3792bcf0248SMax Grossman }
380ea8dc4b6Seschrock
381aaa9aa59SJerry Jelinek case _FIODIRECTIO:
382aaa9aa59SJerry Jelinek {
383aaa9aa59SJerry Jelinek /*
384aaa9aa59SJerry Jelinek * ZFS inherently provides the basic semantics for directio.
385aaa9aa59SJerry Jelinek * This is the summary from the ZFS on Linux support for
386aaa9aa59SJerry Jelinek * O_DIRECT, which is the common form of directio, and required
387aaa9aa59SJerry Jelinek * no changes to ZFS.
388aaa9aa59SJerry Jelinek *
389aaa9aa59SJerry Jelinek * 1. Minimize cache effects of the I/O.
390aaa9aa59SJerry Jelinek *
391aaa9aa59SJerry Jelinek * By design the ARC is already scan-resistant, which helps
392aaa9aa59SJerry Jelinek * mitigate the need for special O_DIRECT handling.
393aaa9aa59SJerry Jelinek *
394aaa9aa59SJerry Jelinek * 2. O_DIRECT _MAY_ impose restrictions on IO alignment and
395aaa9aa59SJerry Jelinek * length.
396aaa9aa59SJerry Jelinek *
397aaa9aa59SJerry Jelinek * No additional alignment or length restrictions are
398aaa9aa59SJerry Jelinek * imposed by ZFS.
399aaa9aa59SJerry Jelinek *
400aaa9aa59SJerry Jelinek * 3. O_DIRECT _MAY_ perform unbuffered IO operations directly
401aaa9aa59SJerry Jelinek * between user memory and block device.
402aaa9aa59SJerry Jelinek *
403aaa9aa59SJerry Jelinek * No unbuffered IO operations are currently supported. In
404aaa9aa59SJerry Jelinek * order to support features such as compression, encryption,
405aaa9aa59SJerry Jelinek * and checksumming a copy must be made to transform the
406aaa9aa59SJerry Jelinek * data.
407aaa9aa59SJerry Jelinek *
408aaa9aa59SJerry Jelinek * 4. O_DIRECT _MAY_ imply O_DSYNC (XFS).
409aaa9aa59SJerry Jelinek *
410aaa9aa59SJerry Jelinek * O_DIRECT does not imply O_DSYNC for ZFS.
411aaa9aa59SJerry Jelinek *
412aaa9aa59SJerry Jelinek * 5. O_DIRECT _MAY_ disable file locking that serializes IO
413aaa9aa59SJerry Jelinek * operations.
414aaa9aa59SJerry Jelinek *
415aaa9aa59SJerry Jelinek * All I/O in ZFS is locked for correctness and this locking
416aaa9aa59SJerry Jelinek * is not disabled by O_DIRECT.
417aaa9aa59SJerry Jelinek */
418aaa9aa59SJerry Jelinek return (0);
419aaa9aa59SJerry Jelinek }
420aaa9aa59SJerry Jelinek
421fa9e4066Sahrens case _FIO_SEEK_DATA:
422fa9e4066Sahrens case _FIO_SEEK_HOLE:
4232bcf0248SMax Grossman {
424fa9e4066Sahrens if (ddi_copyin((void *)data, &off, sizeof (off), flag))
425be6fd75aSMatthew Ahrens return (SET_ERROR(EFAULT));
426fa9e4066Sahrens
427f18faf3fSek110237 zp = VTOZ(vp);
428f18faf3fSek110237 zfsvfs = zp->z_zfsvfs;
4293cb34c60Sahrens ZFS_ENTER(zfsvfs);
4303cb34c60Sahrens ZFS_VERIFY_ZP(zp);
431fa9e4066Sahrens
432fa9e4066Sahrens /* offset parameter is in/out */
433fa9e4066Sahrens error = zfs_holey(vp, com, &off);
434fa9e4066Sahrens ZFS_EXIT(zfsvfs);
435fa9e4066Sahrens if (error)
436fa9e4066Sahrens return (error);
437fa9e4066Sahrens if (ddi_copyout(&off, (void *)data, sizeof (off), flag))
438be6fd75aSMatthew Ahrens return (SET_ERROR(EFAULT));
439fa9e4066Sahrens return (0);
440fa9e4066Sahrens }
4412bcf0248SMax Grossman case _FIO_COUNT_FILLED:
4422bcf0248SMax Grossman {
4432bcf0248SMax Grossman /*
4442bcf0248SMax Grossman * _FIO_COUNT_FILLED adds a new ioctl command which
4452bcf0248SMax Grossman * exposes the number of filled blocks in a
4462bcf0248SMax Grossman * ZFS object.
4472bcf0248SMax Grossman */
4482bcf0248SMax Grossman zp = VTOZ(vp);
4492bcf0248SMax Grossman zfsvfs = zp->z_zfsvfs;
4502bcf0248SMax Grossman ZFS_ENTER(zfsvfs);
4512bcf0248SMax Grossman ZFS_VERIFY_ZP(zp);
4522bcf0248SMax Grossman
4532bcf0248SMax Grossman /*
4542bcf0248SMax Grossman * Wait for all dirty blocks for this object
4552bcf0248SMax Grossman * to get synced out to disk, and the DMU info
4562bcf0248SMax Grossman * updated.
4572bcf0248SMax Grossman */
4582bcf0248SMax Grossman error = dmu_object_wait_synced(zfsvfs->z_os, zp->z_id);
4592bcf0248SMax Grossman if (error) {
4602bcf0248SMax Grossman ZFS_EXIT(zfsvfs);
4612bcf0248SMax Grossman return (error);
4622bcf0248SMax Grossman }
4632bcf0248SMax Grossman
4642bcf0248SMax Grossman /*
4652bcf0248SMax Grossman * Retrieve fill count from DMU object.
4662bcf0248SMax Grossman */
4672bcf0248SMax Grossman error = dmu_object_info(zfsvfs->z_os, zp->z_id, &doi);
4682bcf0248SMax Grossman if (error) {
4692bcf0248SMax Grossman ZFS_EXIT(zfsvfs);
4702bcf0248SMax Grossman return (error);
4712bcf0248SMax Grossman }
4722bcf0248SMax Grossman
4732bcf0248SMax Grossman ndata = doi.doi_fill_count;
4742bcf0248SMax Grossman
4752bcf0248SMax Grossman ZFS_EXIT(zfsvfs);
4762bcf0248SMax Grossman if (ddi_copyout(&ndata, (void *)data, sizeof (ndata), flag))
4772bcf0248SMax Grossman return (SET_ERROR(EFAULT));
4782bcf0248SMax Grossman return (0);
4792bcf0248SMax Grossman }
480f67950b2SNasf-Fan case ZFS_IOC_FSGETXATTR:
481f67950b2SNasf-Fan return (zfs_ioctl_getxattr(vp, data, flag, cred, ct));
482f67950b2SNasf-Fan case ZFS_IOC_FSSETXATTR:
483f67950b2SNasf-Fan return (zfs_ioctl_setxattr(vp, data, flag, cred, ct));
4842bcf0248SMax Grossman }
485be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTTY));
486fa9e4066Sahrens }
487fa9e4066Sahrens
488fa9e4066Sahrens /*
4890fab61baSJonathan W Adams * Utility functions to map and unmap a single physical page. These
4900fab61baSJonathan W Adams * are used to manage the mappable copies of ZFS file data, and therefore
4910fab61baSJonathan W Adams * do not update ref/mod bits.
4920fab61baSJonathan W Adams */
4930fab61baSJonathan W Adams caddr_t
zfs_map_page(page_t * pp,enum seg_rw rw)4940fab61baSJonathan W Adams zfs_map_page(page_t *pp, enum seg_rw rw)
4950fab61baSJonathan W Adams {
4960fab61baSJonathan W Adams if (kpm_enable)
4970fab61baSJonathan W Adams return (hat_kpm_mapin(pp, 0));
4980fab61baSJonathan W Adams ASSERT(rw == S_READ || rw == S_WRITE);
4990fab61baSJonathan W Adams return (ppmapin(pp, PROT_READ | ((rw == S_WRITE) ? PROT_WRITE : 0),
5000fab61baSJonathan W Adams (caddr_t)-1));
5010fab61baSJonathan W Adams }
5020fab61baSJonathan W Adams
5030fab61baSJonathan W Adams void
zfs_unmap_page(page_t * pp,caddr_t addr)5040fab61baSJonathan W Adams zfs_unmap_page(page_t *pp, caddr_t addr)
5050fab61baSJonathan W Adams {
5060fab61baSJonathan W Adams if (kpm_enable) {
5070fab61baSJonathan W Adams hat_kpm_mapout(pp, 0, addr);
5080fab61baSJonathan W Adams } else {
5090fab61baSJonathan W Adams ppmapout(addr);
5100fab61baSJonathan W Adams }
5110fab61baSJonathan W Adams }
5120fab61baSJonathan W Adams
5130fab61baSJonathan W Adams /*
514fa9e4066Sahrens * When a file is memory mapped, we must keep the IO data synchronized
515fa9e4066Sahrens * between the DMU cache and the memory mapped pages. What this means:
516fa9e4066Sahrens *
517fa9e4066Sahrens * On Write: If we find a memory mapped page, we write to *both*
518fa9e4066Sahrens * the page and the dmu buffer.
519fa9e4066Sahrens */
520ac05c741SMark Maybee static void
update_pages(vnode_t * vp,int64_t start,int len,objset_t * os,uint64_t oid)521ac05c741SMark Maybee update_pages(vnode_t *vp, int64_t start, int len, objset_t *os, uint64_t oid)
522fa9e4066Sahrens {
523ac05c741SMark Maybee int64_t off;
524fa9e4066Sahrens
525fa9e4066Sahrens off = start & PAGEOFFSET;
526fa9e4066Sahrens for (start &= PAGEMASK; len > 0; start += PAGESIZE) {
527fa9e4066Sahrens page_t *pp;
528ac05c741SMark Maybee uint64_t nbytes = MIN(PAGESIZE - off, len);
529fa9e4066Sahrens
530fa9e4066Sahrens if (pp = page_lookup(vp, start, SE_SHARED)) {
531fa9e4066Sahrens caddr_t va;
532fa9e4066Sahrens
5330fab61baSJonathan W Adams va = zfs_map_page(pp, S_WRITE);
5347bfdf011SNeil Perrin (void) dmu_read(os, oid, start+off, nbytes, va+off,
5357bfdf011SNeil Perrin DMU_READ_PREFETCH);
5360fab61baSJonathan W Adams zfs_unmap_page(pp, va);
537fa9e4066Sahrens page_unlock(pp);
538fa9e4066Sahrens }
539ac05c741SMark Maybee len -= nbytes;
540fa9e4066Sahrens off = 0;
541fa9e4066Sahrens }
542fa9e4066Sahrens }
543fa9e4066Sahrens
544fa9e4066Sahrens /*
545fa9e4066Sahrens * When a file is memory mapped, we must keep the IO data synchronized
546fa9e4066Sahrens * between the DMU cache and the memory mapped pages. What this means:
547fa9e4066Sahrens *
548fa9e4066Sahrens * On Read: We "read" preferentially from memory mapped pages,
549fa9e4066Sahrens * else we default from the dmu buffer.
550fa9e4066Sahrens *
551fa9e4066Sahrens * NOTE: We will always "break up" the IO into PAGESIZE uiomoves when
552fa9e4066Sahrens * the file is memory mapped.
553fa9e4066Sahrens */
554fa9e4066Sahrens static int
mappedread(vnode_t * vp,int nbytes,uio_t * uio)555feb08c6bSbillm mappedread(vnode_t *vp, int nbytes, uio_t *uio)
556fa9e4066Sahrens {
557feb08c6bSbillm znode_t *zp = VTOZ(vp);
558feb08c6bSbillm int64_t start, off;
559fa9e4066Sahrens int len = nbytes;
560fa9e4066Sahrens int error = 0;
561fa9e4066Sahrens
562fa9e4066Sahrens start = uio->uio_loffset;
563fa9e4066Sahrens off = start & PAGEOFFSET;
564fa9e4066Sahrens for (start &= PAGEMASK; len > 0; start += PAGESIZE) {
565fa9e4066Sahrens page_t *pp;
566feb08c6bSbillm uint64_t bytes = MIN(PAGESIZE - off, len);
567fa9e4066Sahrens
568fa9e4066Sahrens if (pp = page_lookup(vp, start, SE_SHARED)) {
569fa9e4066Sahrens caddr_t va;
570fa9e4066Sahrens
5710fab61baSJonathan W Adams va = zfs_map_page(pp, S_READ);
572fa9e4066Sahrens error = uiomove(va + off, bytes, UIO_READ, uio);
5730fab61baSJonathan W Adams zfs_unmap_page(pp, va);
574fa9e4066Sahrens page_unlock(pp);
575fa9e4066Sahrens } else {
576f8554bb9SMatthew Ahrens error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
577f8554bb9SMatthew Ahrens uio, bytes);
578fa9e4066Sahrens }
579fa9e4066Sahrens len -= bytes;
580fa9e4066Sahrens off = 0;
581fa9e4066Sahrens if (error)
582fa9e4066Sahrens break;
583fa9e4066Sahrens }
584fa9e4066Sahrens return (error);
585fa9e4066Sahrens }
586fa9e4066Sahrens
587feb08c6bSbillm offset_t zfs_read_chunk_size = 1024 * 1024; /* Tunable */
588fa9e4066Sahrens
589fa9e4066Sahrens /*
590fa9e4066Sahrens * Read bytes from specified file into supplied buffer.
591fa9e4066Sahrens *
592fa9e4066Sahrens * IN: vp - vnode of file to be read from.
593fa9e4066Sahrens * uio - structure supplying read location, range info,
594fa9e4066Sahrens * and return buffer.
595fa9e4066Sahrens * ioflag - SYNC flags; used to provide FRSYNC semantics.
596fa9e4066Sahrens * cr - credentials of caller.
597da6c28aaSamw * ct - caller context
598fa9e4066Sahrens *
599fa9e4066Sahrens * OUT: uio - updated offset and range, buffer filled.
600fa9e4066Sahrens *
601f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
602fa9e4066Sahrens *
603fa9e4066Sahrens * Side Effects:
604fa9e4066Sahrens * vp - atime updated if byte count > 0
605fa9e4066Sahrens */
606fa9e4066Sahrens /* ARGSUSED */
607fa9e4066Sahrens static int
zfs_read(vnode_t * vp,uio_t * uio,int ioflag,cred_t * cr,caller_context_t * ct)608fa9e4066Sahrens zfs_read(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr, caller_context_t *ct)
609fa9e4066Sahrens {
610fa9e4066Sahrens znode_t *zp = VTOZ(vp);
611fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
612feb08c6bSbillm ssize_t n, nbytes;
613d5285caeSGeorge Wilson int error = 0;
614da7753c4SGeorge Wilson boolean_t frsync = B_FALSE;
615c242f9a0Schunli zhang - Sun Microsystems - Irvine United States xuio_t *xuio = NULL;
616fa9e4066Sahrens
6173cb34c60Sahrens ZFS_ENTER(zfsvfs);
6183cb34c60Sahrens ZFS_VERIFY_ZP(zp);
619fa9e4066Sahrens
6200a586ceaSMark Shellenbaum if (zp->z_pflags & ZFS_AV_QUARANTINED) {
6210616c50eSmarks ZFS_EXIT(zfsvfs);
622be6fd75aSMatthew Ahrens return (SET_ERROR(EACCES));
6230616c50eSmarks }
6240616c50eSmarks
625fa9e4066Sahrens /*
626fa9e4066Sahrens * Validate file offset
627fa9e4066Sahrens */
628fa9e4066Sahrens if (uio->uio_loffset < (offset_t)0) {
629fa9e4066Sahrens ZFS_EXIT(zfsvfs);
630be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
631fa9e4066Sahrens }
632fa9e4066Sahrens
633fa9e4066Sahrens /*
634fa9e4066Sahrens * Fasttrack empty reads
635fa9e4066Sahrens */
636fa9e4066Sahrens if (uio->uio_resid == 0) {
637fa9e4066Sahrens ZFS_EXIT(zfsvfs);
638fa9e4066Sahrens return (0);
639fa9e4066Sahrens }
640fa9e4066Sahrens
641fa9e4066Sahrens /*
642104e2ed7Sperrin * Check for mandatory locks
643fa9e4066Sahrens */
6440a586ceaSMark Shellenbaum if (MANDMODE(zp->z_mode)) {
645fa9e4066Sahrens if (error = chklock(vp, FREAD,
646fa9e4066Sahrens uio->uio_loffset, uio->uio_resid, uio->uio_fmode, ct)) {
647fa9e4066Sahrens ZFS_EXIT(zfsvfs);
648fa9e4066Sahrens return (error);
649fa9e4066Sahrens }
650fa9e4066Sahrens }
651fa9e4066Sahrens
652da7753c4SGeorge Wilson #ifdef FRSYNC
653fa9e4066Sahrens /*
654fa9e4066Sahrens * If we're in FRSYNC mode, sync out this znode before reading it.
655da7753c4SGeorge Wilson * Only do this for non-snapshots.
656da7753c4SGeorge Wilson *
657da7753c4SGeorge Wilson * Some platforms do not support FRSYNC and instead map it
658da7753c4SGeorge Wilson * to FSYNC, which results in unnecessary calls to zil_commit. We
659da7753c4SGeorge Wilson * only honor FRSYNC requests on platforms which support it.
660fa9e4066Sahrens */
661da7753c4SGeorge Wilson frsync = !!(ioflag & FRSYNC);
662da7753c4SGeorge Wilson #endif
663da7753c4SGeorge Wilson
664da7753c4SGeorge Wilson if (zfsvfs->z_log &&
665da7753c4SGeorge Wilson (frsync || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS))
6665002558fSNeil Perrin zil_commit(zfsvfs->z_log, zp->z_id);
667fa9e4066Sahrens
668fa9e4066Sahrens /*
669104e2ed7Sperrin * Lock the range against changes.
670fa9e4066Sahrens */
67179315247SMatthew Ahrens locked_range_t *lr = rangelock_enter(&zp->z_rangelock,
67279315247SMatthew Ahrens uio->uio_loffset, uio->uio_resid, RL_READER);
673104e2ed7Sperrin
674fa9e4066Sahrens /*
675fa9e4066Sahrens * If we are reading past end-of-file we can skip
676fa9e4066Sahrens * to the end; but we might still need to set atime.
677fa9e4066Sahrens */
6780a586ceaSMark Shellenbaum if (uio->uio_loffset >= zp->z_size) {
679fa9e4066Sahrens error = 0;
680fa9e4066Sahrens goto out;
681fa9e4066Sahrens }
682fa9e4066Sahrens
6830a586ceaSMark Shellenbaum ASSERT(uio->uio_loffset < zp->z_size);
6840a586ceaSMark Shellenbaum n = MIN(uio->uio_resid, zp->z_size - uio->uio_loffset);
685fa9e4066Sahrens
686c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if ((uio->uio_extflg == UIO_XUIO) &&
687c242f9a0Schunli zhang - Sun Microsystems - Irvine United States (((xuio_t *)uio)->xu_type == UIOTYPE_ZEROCOPY)) {
688c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int nblk;
689c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int blksz = zp->z_blksz;
690c242f9a0Schunli zhang - Sun Microsystems - Irvine United States uint64_t offset = uio->uio_loffset;
691c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
692c242f9a0Schunli zhang - Sun Microsystems - Irvine United States xuio = (xuio_t *)uio;
693c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if ((ISP2(blksz))) {
694c242f9a0Schunli zhang - Sun Microsystems - Irvine United States nblk = (P2ROUNDUP(offset + n, blksz) - P2ALIGN(offset,
695c242f9a0Schunli zhang - Sun Microsystems - Irvine United States blksz)) / blksz;
696c242f9a0Schunli zhang - Sun Microsystems - Irvine United States } else {
697c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(offset + n <= blksz);
698c242f9a0Schunli zhang - Sun Microsystems - Irvine United States nblk = 1;
699c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
700570de38fSSurya Prakki (void) dmu_xuio_init(xuio, nblk);
701c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
702c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (vn_has_cached_data(vp)) {
703c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
704c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * For simplicity, we always allocate a full buffer
705c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * even if we only expect to read a portion of a block.
706c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
707c242f9a0Schunli zhang - Sun Microsystems - Irvine United States while (--nblk >= 0) {
708570de38fSSurya Prakki (void) dmu_xuio_add(xuio,
7090a586ceaSMark Shellenbaum dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
7100a586ceaSMark Shellenbaum blksz), 0, blksz);
711c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
712c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
713c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
714c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
715feb08c6bSbillm while (n > 0) {
716feb08c6bSbillm nbytes = MIN(n, zfs_read_chunk_size -
717feb08c6bSbillm P2PHASE(uio->uio_loffset, zfs_read_chunk_size));
718feb08c6bSbillm
719f8554bb9SMatthew Ahrens if (vn_has_cached_data(vp)) {
720feb08c6bSbillm error = mappedread(vp, nbytes, uio);
721f8554bb9SMatthew Ahrens } else {
722f8554bb9SMatthew Ahrens error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
723f8554bb9SMatthew Ahrens uio, nbytes);
724f8554bb9SMatthew Ahrens }
725b87f3af3Sperrin if (error) {
726b87f3af3Sperrin /* convert checksum errors into IO errors */
727b87f3af3Sperrin if (error == ECKSUM)
728be6fd75aSMatthew Ahrens error = SET_ERROR(EIO);
729fa9e4066Sahrens break;
730b87f3af3Sperrin }
731feb08c6bSbillm
732feb08c6bSbillm n -= nbytes;
733fa9e4066Sahrens }
734fa9e4066Sahrens out:
73579315247SMatthew Ahrens rangelock_exit(lr);
736fa9e4066Sahrens
737fa9e4066Sahrens ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
738fa9e4066Sahrens ZFS_EXIT(zfsvfs);
739fa9e4066Sahrens return (error);
740fa9e4066Sahrens }
741fa9e4066Sahrens
742163bcb88SPawel Jakub Dawidek static void
zfs_write_clear_setid_bits_if_necessary(zfsvfs_t * zfsvfs,znode_t * zp,cred_t * cr,boolean_t * did_check,dmu_tx_t * tx)743163bcb88SPawel Jakub Dawidek zfs_write_clear_setid_bits_if_necessary(zfsvfs_t *zfsvfs, znode_t *zp,
744163bcb88SPawel Jakub Dawidek cred_t *cr, boolean_t *did_check, dmu_tx_t *tx)
745163bcb88SPawel Jakub Dawidek {
746163bcb88SPawel Jakub Dawidek ASSERT(did_check != NULL);
747163bcb88SPawel Jakub Dawidek ASSERT(tx != NULL);
748163bcb88SPawel Jakub Dawidek
749163bcb88SPawel Jakub Dawidek if (*did_check)
750163bcb88SPawel Jakub Dawidek return;
751163bcb88SPawel Jakub Dawidek
752163bcb88SPawel Jakub Dawidek zilog_t *zilog = zfsvfs->z_log;
753163bcb88SPawel Jakub Dawidek
754163bcb88SPawel Jakub Dawidek /*
755163bcb88SPawel Jakub Dawidek * Clear Set-UID/Set-GID bits on successful write if not
756163bcb88SPawel Jakub Dawidek * privileged and at least one of the execute bits is set.
757163bcb88SPawel Jakub Dawidek *
758163bcb88SPawel Jakub Dawidek * It would be nice to do this after all writes have
759163bcb88SPawel Jakub Dawidek * been done, but that would still expose the ISUID/ISGID
760163bcb88SPawel Jakub Dawidek * to another app after the partial write is committed.
761163bcb88SPawel Jakub Dawidek *
762163bcb88SPawel Jakub Dawidek * Note: we don't call zfs_fuid_map_id() here because
763163bcb88SPawel Jakub Dawidek * user 0 is not an ephemeral uid.
764163bcb88SPawel Jakub Dawidek */
76506799660SGordon Ross rw_enter(&zp->z_acl_lock, RW_READER);
766163bcb88SPawel Jakub Dawidek if ((zp->z_mode & (S_IXUSR | (S_IXUSR >> 3) | (S_IXUSR >> 6))) != 0 &&
767163bcb88SPawel Jakub Dawidek (zp->z_mode & (S_ISUID | S_ISGID)) != 0 &&
768163bcb88SPawel Jakub Dawidek secpolicy_vnode_setid_retain(cr,
769163bcb88SPawel Jakub Dawidek ((zp->z_mode & S_ISUID) != 0 && zp->z_uid == 0)) != 0) {
77006799660SGordon Ross /*
77106799660SGordon Ross * We need to clear the SUID|SGID bits, but
77206799660SGordon Ross * become RW_WRITER before updating z_mode.
77306799660SGordon Ross */
77406799660SGordon Ross rw_exit(&zp->z_acl_lock);
77506799660SGordon Ross rw_enter(&zp->z_acl_lock, RW_WRITER);
77606799660SGordon Ross
77706799660SGordon Ross /*
77806799660SGordon Ross * If another writer did this, skip it.
77906799660SGordon Ross */
78006799660SGordon Ross if ((zp->z_mode & (S_ISUID | S_ISGID)) != 0) {
781163bcb88SPawel Jakub Dawidek uint64_t newmode;
782163bcb88SPawel Jakub Dawidek vattr_t va;
783163bcb88SPawel Jakub Dawidek
784163bcb88SPawel Jakub Dawidek zp->z_mode &= ~(S_ISUID | S_ISGID);
785163bcb88SPawel Jakub Dawidek newmode = zp->z_mode;
786163bcb88SPawel Jakub Dawidek (void) sa_update(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs),
787163bcb88SPawel Jakub Dawidek (void *)&newmode, sizeof (uint64_t), tx);
788163bcb88SPawel Jakub Dawidek
789163bcb88SPawel Jakub Dawidek /*
79006799660SGordon Ross * Make sure SUID/SGID bits will be removed
79106799660SGordon Ross * when we replay the log.
792163bcb88SPawel Jakub Dawidek */
793163bcb88SPawel Jakub Dawidek bzero(&va, sizeof (va));
794163bcb88SPawel Jakub Dawidek va.va_mask = AT_MODE;
795163bcb88SPawel Jakub Dawidek va.va_nodeid = zp->z_id;
796163bcb88SPawel Jakub Dawidek va.va_mode = newmode;
79706799660SGordon Ross zfs_log_setattr(zilog, tx, TX_SETATTR,
79806799660SGordon Ross zp, &va, AT_MODE, NULL);
799163bcb88SPawel Jakub Dawidek }
80006799660SGordon Ross }
80106799660SGordon Ross rw_exit(&zp->z_acl_lock);
802163bcb88SPawel Jakub Dawidek
803163bcb88SPawel Jakub Dawidek *did_check = B_TRUE;
804163bcb88SPawel Jakub Dawidek }
805163bcb88SPawel Jakub Dawidek
806fa9e4066Sahrens /*
807fa9e4066Sahrens * Write the bytes to a file.
808fa9e4066Sahrens *
809fa9e4066Sahrens * IN: vp - vnode of file to be written to.
810fa9e4066Sahrens * uio - structure supplying write location, range info,
811fa9e4066Sahrens * and data buffer.
812f7170741SWill Andrews * ioflag - FAPPEND, FSYNC, and/or FDSYNC. FAPPEND is
813f7170741SWill Andrews * set if in append mode.
814fa9e4066Sahrens * cr - credentials of caller.
815da6c28aaSamw * ct - caller context (NFS/CIFS fem monitor only)
816fa9e4066Sahrens *
817fa9e4066Sahrens * OUT: uio - updated offset and range.
818fa9e4066Sahrens *
819f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
820fa9e4066Sahrens *
821fa9e4066Sahrens * Timestamps:
822fa9e4066Sahrens * vp - ctime|mtime updated if byte count > 0
823fa9e4066Sahrens */
8240a586ceaSMark Shellenbaum
825fa9e4066Sahrens /* ARGSUSED */
826fa9e4066Sahrens static int
zfs_write(vnode_t * vp,uio_t * uio,int ioflag,cred_t * cr,caller_context_t * ct)827fa9e4066Sahrens zfs_write(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr, caller_context_t *ct)
828fa9e4066Sahrens {
829fa9e4066Sahrens znode_t *zp = VTOZ(vp);
830fa9e4066Sahrens rlim64_t limit = uio->uio_llimit;
831fa9e4066Sahrens ssize_t start_resid = uio->uio_resid;
832fa9e4066Sahrens ssize_t tx_bytes;
833fa9e4066Sahrens uint64_t end_size;
834fa9e4066Sahrens dmu_tx_t *tx;
835fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
836f18faf3fSek110237 zilog_t *zilog;
837fa9e4066Sahrens offset_t woff;
838fa9e4066Sahrens ssize_t n, nbytes;
839fa9e4066Sahrens int max_blksz = zfsvfs->z_max_blksz;
840d5285caeSGeorge Wilson int error = 0;
841b0ef4256SJerry Jelinek int prev_error;
8422fdbea25SAleksandr Guzovskiy arc_buf_t *abuf;
843d5285caeSGeorge Wilson iovec_t *aiov = NULL;
844c242f9a0Schunli zhang - Sun Microsystems - Irvine United States xuio_t *xuio = NULL;
845c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int i_iov = 0;
846c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int iovcnt = uio->uio_iovcnt;
847c242f9a0Schunli zhang - Sun Microsystems - Irvine United States iovec_t *iovp = uio->uio_iov;
848c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int write_eof;
8490a586ceaSMark Shellenbaum int count = 0;
8500a586ceaSMark Shellenbaum sa_bulk_attr_t bulk[4];
8510a586ceaSMark Shellenbaum uint64_t mtime[2], ctime[2];
852163bcb88SPawel Jakub Dawidek boolean_t did_clear_setid_bits = B_FALSE;
853fa9e4066Sahrens
854fa9e4066Sahrens /*
855fa9e4066Sahrens * Fasttrack empty write
856fa9e4066Sahrens */
857104e2ed7Sperrin n = start_resid;
858fa9e4066Sahrens if (n == 0)
859fa9e4066Sahrens return (0);
860fa9e4066Sahrens
861104e2ed7Sperrin if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T)
862104e2ed7Sperrin limit = MAXOFFSET_T;
863104e2ed7Sperrin
8643cb34c60Sahrens ZFS_ENTER(zfsvfs);
8653cb34c60Sahrens ZFS_VERIFY_ZP(zp);
866c09193bfSmarks
8670a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
8680a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);
8690a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
8700a586ceaSMark Shellenbaum &zp->z_size, 8);
8710a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
8720a586ceaSMark Shellenbaum &zp->z_pflags, 8);
8730a586ceaSMark Shellenbaum
874c09193bfSmarks /*
8752144b121SMarcel Telka * In a case vp->v_vfsp != zp->z_zfsvfs->z_vfs (e.g. snapshots) our
8762144b121SMarcel Telka * callers might not be able to detect properly that we are read-only,
8772144b121SMarcel Telka * so check it explicitly here.
8782144b121SMarcel Telka */
8792144b121SMarcel Telka if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) {
8802144b121SMarcel Telka ZFS_EXIT(zfsvfs);
8812144b121SMarcel Telka return (SET_ERROR(EROFS));
8822144b121SMarcel Telka }
8832144b121SMarcel Telka
8842144b121SMarcel Telka /*
8852889ec41SGordon Ross * If immutable or not appending then return EPERM.
8862889ec41SGordon Ross * Intentionally allow ZFS_READONLY through here.
8872889ec41SGordon Ross * See zfs_zaccess_common()
888c09193bfSmarks */
8892889ec41SGordon Ross if ((zp->z_pflags & ZFS_IMMUTABLE) ||
8900a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_APPENDONLY) && !(ioflag & FAPPEND) &&
8910a586ceaSMark Shellenbaum (uio->uio_loffset < zp->z_size))) {
892c09193bfSmarks ZFS_EXIT(zfsvfs);
893be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
894c09193bfSmarks }
895c09193bfSmarks
896f18faf3fSek110237 zilog = zfsvfs->z_log;
897fa9e4066Sahrens
898fa9e4066Sahrens /*
89941865f27SWilliam Gorrell * Validate file offset
90041865f27SWilliam Gorrell */
9010a586ceaSMark Shellenbaum woff = ioflag & FAPPEND ? zp->z_size : uio->uio_loffset;
90241865f27SWilliam Gorrell if (woff < 0) {
90341865f27SWilliam Gorrell ZFS_EXIT(zfsvfs);
904be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
90541865f27SWilliam Gorrell }
90641865f27SWilliam Gorrell
90741865f27SWilliam Gorrell /*
90879315247SMatthew Ahrens * Check for mandatory locks before calling rangelock_enter()
90941865f27SWilliam Gorrell * in order to prevent a deadlock with locks set via fcntl().
91041865f27SWilliam Gorrell */
9110a586ceaSMark Shellenbaum if (MANDMODE((mode_t)zp->z_mode) &&
91241865f27SWilliam Gorrell (error = chklock(vp, FWRITE, woff, n, uio->uio_fmode, ct)) != 0) {
91341865f27SWilliam Gorrell ZFS_EXIT(zfsvfs);
91441865f27SWilliam Gorrell return (error);
91541865f27SWilliam Gorrell }
91641865f27SWilliam Gorrell
91741865f27SWilliam Gorrell /*
918c5c6ffa0Smaybee * Pre-fault the pages to ensure slow (eg NFS) pages
919104e2ed7Sperrin * don't hold up txg.
920c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * Skip this if uio contains loaned arc_buf.
921fa9e4066Sahrens */
922c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if ((uio->uio_extflg == UIO_XUIO) &&
923c242f9a0Schunli zhang - Sun Microsystems - Irvine United States (((xuio_t *)uio)->xu_type == UIOTYPE_ZEROCOPY))
924c242f9a0Schunli zhang - Sun Microsystems - Irvine United States xuio = (xuio_t *)uio;
925c242f9a0Schunli zhang - Sun Microsystems - Irvine United States else
926ff866947SSanjeev Bagewadi uio_prefaultpages(MIN(n, max_blksz), uio);
927fa9e4066Sahrens
928fa9e4066Sahrens /*
929fa9e4066Sahrens * If in append mode, set the io offset pointer to eof.
930fa9e4066Sahrens */
93179315247SMatthew Ahrens locked_range_t *lr;
932104e2ed7Sperrin if (ioflag & FAPPEND) {
933104e2ed7Sperrin /*
93441865f27SWilliam Gorrell * Obtain an appending range lock to guarantee file append
93541865f27SWilliam Gorrell * semantics. We reset the write offset once we have the lock.
936104e2ed7Sperrin */
93779315247SMatthew Ahrens lr = rangelock_enter(&zp->z_rangelock, 0, n, RL_APPEND);
93879315247SMatthew Ahrens woff = lr->lr_offset;
93979315247SMatthew Ahrens if (lr->lr_length == UINT64_MAX) {
940fa9e4066Sahrens /*
94141865f27SWilliam Gorrell * We overlocked the file because this write will cause
94241865f27SWilliam Gorrell * the file block size to increase.
94341865f27SWilliam Gorrell * Note that zp_size cannot change with this lock held.
944fa9e4066Sahrens */
9450a586ceaSMark Shellenbaum woff = zp->z_size;
946fa9e4066Sahrens }
94741865f27SWilliam Gorrell uio->uio_loffset = woff;
94841865f27SWilliam Gorrell } else {
949fa9e4066Sahrens /*
95041865f27SWilliam Gorrell * Note that if the file block size will change as a result of
95141865f27SWilliam Gorrell * this write, then this range lock will lock the entire file
95241865f27SWilliam Gorrell * so that we can re-write the block safely.
953fa9e4066Sahrens */
95479315247SMatthew Ahrens lr = rangelock_enter(&zp->z_rangelock, woff, n, RL_WRITER);
955fa9e4066Sahrens }
956fa9e4066Sahrens
957fa9e4066Sahrens if (woff >= limit) {
95879315247SMatthew Ahrens rangelock_exit(lr);
959feb08c6bSbillm ZFS_EXIT(zfsvfs);
960be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG));
961fa9e4066Sahrens }
962fa9e4066Sahrens
963fa9e4066Sahrens if ((woff + n) > limit || woff > (limit - n))
964fa9e4066Sahrens n = limit - woff;
965fa9e4066Sahrens
966c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /* Will this write extend the file length? */
9670a586ceaSMark Shellenbaum write_eof = (woff + n > zp->z_size);
968c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
9690a586ceaSMark Shellenbaum end_size = MAX(zp->z_size, woff + n);
970feb08c6bSbillm
971feb08c6bSbillm /*
972feb08c6bSbillm * Write the file in reasonable size chunks. Each chunk is written
973feb08c6bSbillm * in a separate transaction; this keeps the intent log records small
974feb08c6bSbillm * and allows us to do more fine-grained space accounting.
975feb08c6bSbillm */
976feb08c6bSbillm while (n > 0) {
9772fdbea25SAleksandr Guzovskiy woff = uio->uio_loffset;
978f67950b2SNasf-Fan
979f67950b2SNasf-Fan if (zfs_id_overblockquota(zfsvfs, DMU_USERUSED_OBJECT,
980f67950b2SNasf-Fan zp->z_uid) ||
981f67950b2SNasf-Fan zfs_id_overblockquota(zfsvfs, DMU_GROUPUSED_OBJECT,
982f67950b2SNasf-Fan zp->z_gid) ||
983f67950b2SNasf-Fan (zp->z_projid != ZFS_DEFAULT_PROJID &&
984f67950b2SNasf-Fan zfs_id_overblockquota(zfsvfs, DMU_PROJECTUSED_OBJECT,
985f67950b2SNasf-Fan zp->z_projid))) {
986be6fd75aSMatthew Ahrens error = SET_ERROR(EDQUOT);
98714843421SMatthew Ahrens break;
98814843421SMatthew Ahrens }
9892fdbea25SAleksandr Guzovskiy
990f67950b2SNasf-Fan arc_buf_t *abuf = NULL;
991f67950b2SNasf-Fan if (xuio) {
992c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(i_iov < iovcnt);
993c242f9a0Schunli zhang - Sun Microsystems - Irvine United States aiov = &iovp[i_iov];
994c242f9a0Schunli zhang - Sun Microsystems - Irvine United States abuf = dmu_xuio_arcbuf(xuio, i_iov);
995c242f9a0Schunli zhang - Sun Microsystems - Irvine United States dmu_xuio_clear(xuio, i_iov);
996c242f9a0Schunli zhang - Sun Microsystems - Irvine United States DTRACE_PROBE3(zfs_cp_write, int, i_iov,
997c242f9a0Schunli zhang - Sun Microsystems - Irvine United States iovec_t *, aiov, arc_buf_t *, abuf);
998c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT((aiov->iov_base == abuf->b_data) ||
999c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ((char *)aiov->iov_base - (char *)abuf->b_data +
1000c242f9a0Schunli zhang - Sun Microsystems - Irvine United States aiov->iov_len == arc_buf_size(abuf)));
1001c242f9a0Schunli zhang - Sun Microsystems - Irvine United States i_iov++;
1002f67950b2SNasf-Fan } else if (n >= max_blksz && woff >= zp->z_size &&
10032fdbea25SAleksandr Guzovskiy P2PHASE(woff, max_blksz) == 0 &&
10042fdbea25SAleksandr Guzovskiy zp->z_blksz == max_blksz) {
1005c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
1006c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * This write covers a full block. "Borrow" a buffer
1007c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * from the dmu so that we can fill it before we enter
1008c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * a transaction. This avoids the possibility of
1009c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * holding up the transaction if the data copy hangs
1010c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * up on a pagefault (e.g., from an NFS server mapping).
1011c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
10122fdbea25SAleksandr Guzovskiy size_t cbytes;
10132fdbea25SAleksandr Guzovskiy
10140a586ceaSMark Shellenbaum abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
10150a586ceaSMark Shellenbaum max_blksz);
10162fdbea25SAleksandr Guzovskiy ASSERT(abuf != NULL);
10172fdbea25SAleksandr Guzovskiy ASSERT(arc_buf_size(abuf) == max_blksz);
10182fdbea25SAleksandr Guzovskiy if (error = uiocopy(abuf->b_data, max_blksz,
10192fdbea25SAleksandr Guzovskiy UIO_WRITE, uio, &cbytes)) {
10202fdbea25SAleksandr Guzovskiy dmu_return_arcbuf(abuf);
10212fdbea25SAleksandr Guzovskiy break;
10222fdbea25SAleksandr Guzovskiy }
10232fdbea25SAleksandr Guzovskiy ASSERT(cbytes == max_blksz);
10242fdbea25SAleksandr Guzovskiy }
10252fdbea25SAleksandr Guzovskiy
10262fdbea25SAleksandr Guzovskiy /*
10272fdbea25SAleksandr Guzovskiy * Start a transaction.
10282fdbea25SAleksandr Guzovskiy */
1029fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
10300a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
1031fa9e4066Sahrens dmu_tx_hold_write(tx, zp->z_id, woff, MIN(n, max_blksz));
10320a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
1033e722410cSMatthew Ahrens error = dmu_tx_assign(tx, TXG_WAIT);
1034fa9e4066Sahrens if (error) {
10358a2f1b91Sahrens dmu_tx_abort(tx);
10362fdbea25SAleksandr Guzovskiy if (abuf != NULL)
10372fdbea25SAleksandr Guzovskiy dmu_return_arcbuf(abuf);
1038feb08c6bSbillm break;
1039fa9e4066Sahrens }
1040fa9e4066Sahrens
1041fa9e4066Sahrens /*
1042163bcb88SPawel Jakub Dawidek * NB: We must call zfs_write_clear_setid_bits_if_necessary
1043163bcb88SPawel Jakub Dawidek * before committing the transaction!
1044163bcb88SPawel Jakub Dawidek */
1045163bcb88SPawel Jakub Dawidek
1046163bcb88SPawel Jakub Dawidek /*
104779315247SMatthew Ahrens * If rangelock_enter() over-locked we grow the blocksize
1048feb08c6bSbillm * and then reduce the lock range. This will only happen
104979315247SMatthew Ahrens * on the first iteration since rangelock_reduce() will
105079315247SMatthew Ahrens * shrink down lr_length to the appropriate size.
1051fa9e4066Sahrens */
105279315247SMatthew Ahrens if (lr->lr_length == UINT64_MAX) {
1053104e2ed7Sperrin uint64_t new_blksz;
1054104e2ed7Sperrin
1055fa9e4066Sahrens if (zp->z_blksz > max_blksz) {
1056b5152584SMatthew Ahrens /*
1057b5152584SMatthew Ahrens * File's blocksize is already larger than the
1058b5152584SMatthew Ahrens * "recordsize" property. Only let it grow to
1059b5152584SMatthew Ahrens * the next power of 2.
1060b5152584SMatthew Ahrens */
1061fa9e4066Sahrens ASSERT(!ISP2(zp->z_blksz));
1062b5152584SMatthew Ahrens new_blksz = MIN(end_size,
1063b5152584SMatthew Ahrens 1 << highbit64(zp->z_blksz));
1064fa9e4066Sahrens } else {
1065fa9e4066Sahrens new_blksz = MIN(end_size, max_blksz);
1066fa9e4066Sahrens }
1067104e2ed7Sperrin zfs_grow_blocksize(zp, new_blksz, tx);
106879315247SMatthew Ahrens rangelock_reduce(lr, woff, n);
1069fa9e4066Sahrens }
1070fa9e4066Sahrens
1071fa9e4066Sahrens /*
1072fa9e4066Sahrens * XXX - should we really limit each write to z_max_blksz?
1073fa9e4066Sahrens * Perhaps we should use SPA_MAXBLOCKSIZE chunks?
1074fa9e4066Sahrens */
1075fa9e4066Sahrens nbytes = MIN(n, max_blksz - P2PHASE(woff, max_blksz));
1076fa9e4066Sahrens
10772fdbea25SAleksandr Guzovskiy if (abuf == NULL) {
1078fa9e4066Sahrens tx_bytes = uio->uio_resid;
107994d1a210STim Haley error = dmu_write_uio_dbuf(sa_get_db(zp->z_sa_hdl),
108094d1a210STim Haley uio, nbytes, tx);
1081fa9e4066Sahrens tx_bytes -= uio->uio_resid;
10822fdbea25SAleksandr Guzovskiy } else {
10832fdbea25SAleksandr Guzovskiy tx_bytes = nbytes;
1084c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(xuio == NULL || tx_bytes == aiov->iov_len);
1085c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
1086c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * If this is not a full block write, but we are
1087c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * extending the file past EOF and this data starts
1088c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * block-aligned, use assign_arcbuf(). Otherwise,
1089c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * write via dmu_write().
1090c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
1091c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (tx_bytes < max_blksz && (!write_eof ||
1092c242f9a0Schunli zhang - Sun Microsystems - Irvine United States aiov->iov_base != abuf->b_data)) {
1093c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(xuio);
1094c242f9a0Schunli zhang - Sun Microsystems - Irvine United States dmu_write(zfsvfs->z_os, zp->z_id, woff,
1095c242f9a0Schunli zhang - Sun Microsystems - Irvine United States aiov->iov_len, aiov->iov_base, tx);
1096c242f9a0Schunli zhang - Sun Microsystems - Irvine United States dmu_return_arcbuf(abuf);
1097c242f9a0Schunli zhang - Sun Microsystems - Irvine United States xuio_stat_wbuf_copied();
1098c242f9a0Schunli zhang - Sun Microsystems - Irvine United States } else {
1099c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(xuio || tx_bytes == max_blksz);
1100eb633035STom Caputi dmu_assign_arcbuf_by_dbuf(
1101eb633035STom Caputi sa_get_db(zp->z_sa_hdl), woff, abuf, tx);
1102c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
11032fdbea25SAleksandr Guzovskiy ASSERT(tx_bytes <= uio->uio_resid);
11042fdbea25SAleksandr Guzovskiy uioskip(uio, tx_bytes);
11052fdbea25SAleksandr Guzovskiy }
11062fdbea25SAleksandr Guzovskiy if (tx_bytes && vn_has_cached_data(vp)) {
1107ac05c741SMark Maybee update_pages(vp, woff,
1108ac05c741SMark Maybee tx_bytes, zfsvfs->z_os, zp->z_id);
11092fdbea25SAleksandr Guzovskiy }
1110fa9e4066Sahrens
1111feb08c6bSbillm /*
1112feb08c6bSbillm * If we made no progress, we're done. If we made even
1113feb08c6bSbillm * partial progress, update the znode and ZIL accordingly.
1114feb08c6bSbillm */
1115feb08c6bSbillm if (tx_bytes == 0) {
11160a586ceaSMark Shellenbaum (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
11170a586ceaSMark Shellenbaum (void *)&zp->z_size, sizeof (uint64_t), tx);
1118af2c4821Smaybee dmu_tx_commit(tx);
1119feb08c6bSbillm ASSERT(error != 0);
1120fa9e4066Sahrens break;
1121fa9e4066Sahrens }
1122fa9e4066Sahrens
1123163bcb88SPawel Jakub Dawidek zfs_write_clear_setid_bits_if_necessary(zfsvfs, zp, cr,
1124163bcb88SPawel Jakub Dawidek &did_clear_setid_bits, tx);
1125169cdae2Smarks
11260a586ceaSMark Shellenbaum zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime,
11270a586ceaSMark Shellenbaum B_TRUE);
1128feb08c6bSbillm
1129feb08c6bSbillm /*
1130feb08c6bSbillm * Update the file size (zp_size) if it has changed;
1131feb08c6bSbillm * account for possible concurrent updates.
1132feb08c6bSbillm */
11330a586ceaSMark Shellenbaum while ((end_size = zp->z_size) < uio->uio_loffset) {
11340a586ceaSMark Shellenbaum (void) atomic_cas_64(&zp->z_size, end_size,
1135feb08c6bSbillm uio->uio_loffset);
11360a586ceaSMark Shellenbaum }
1137c0e50c98SNeil Perrin /*
1138c0e50c98SNeil Perrin * If we are replaying and eof is non zero then force
1139c0e50c98SNeil Perrin * the file size to the specified eof. Note, there's no
1140c0e50c98SNeil Perrin * concurrency during replay.
1141c0e50c98SNeil Perrin */
1142c0e50c98SNeil Perrin if (zfsvfs->z_replay && zfsvfs->z_replay_eof != 0)
1143c0e50c98SNeil Perrin zp->z_size = zfsvfs->z_replay_eof;
1144c0e50c98SNeil Perrin
1145b0ef4256SJerry Jelinek /*
1146b0ef4256SJerry Jelinek * Keep track of a possible pre-existing error from a partial
1147b0ef4256SJerry Jelinek * write via dmu_write_uio_dbuf above.
1148b0ef4256SJerry Jelinek */
1149b0ef4256SJerry Jelinek prev_error = error;
11500a586ceaSMark Shellenbaum error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
11510a586ceaSMark Shellenbaum
1152163bcb88SPawel Jakub Dawidek /*
1153163bcb88SPawel Jakub Dawidek * NB: During replay, the TX_SETATTR record logged by
1154163bcb88SPawel Jakub Dawidek * zfs_write_clear_setid_bits_if_necessary must precede
1155163bcb88SPawel Jakub Dawidek * any of the TX_WRITE records logged here.
1156163bcb88SPawel Jakub Dawidek */
1157feb08c6bSbillm zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, ioflag);
1158feb08c6bSbillm dmu_tx_commit(tx);
1159feb08c6bSbillm
1160b0ef4256SJerry Jelinek if (prev_error != 0 || error != 0)
1161fa9e4066Sahrens break;
1162feb08c6bSbillm ASSERT(tx_bytes == nbytes);
1163feb08c6bSbillm n -= nbytes;
1164ff866947SSanjeev Bagewadi
1165ff866947SSanjeev Bagewadi if (!xuio && n > 0)
1166ff866947SSanjeev Bagewadi uio_prefaultpages(MIN(n, max_blksz), uio);
1167fa9e4066Sahrens }
1168fa9e4066Sahrens
116979315247SMatthew Ahrens rangelock_exit(lr);
1170fa9e4066Sahrens
1171fa9e4066Sahrens /*
1172fa9e4066Sahrens * If we're in replay mode, or we made no progress, return error.
1173fa9e4066Sahrens * Otherwise, it's at least a partial write, so it's successful.
1174fa9e4066Sahrens */
11751209a471SNeil Perrin if (zfsvfs->z_replay || uio->uio_resid == start_resid) {
1176fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1177fa9e4066Sahrens return (error);
1178fa9e4066Sahrens }
1179fa9e4066Sahrens
118055da60b9SMark J Musante if (ioflag & (FSYNC | FDSYNC) ||
118155da60b9SMark J Musante zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
11825002558fSNeil Perrin zil_commit(zilog, zp->z_id);
1183fa9e4066Sahrens
1184fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1185fa9e4066Sahrens return (0);
1186fa9e4066Sahrens }
1187fa9e4066Sahrens
1188cab3a55eSPrakash Surya /* ARGSUSED */
1189c5c6ffa0Smaybee void
zfs_get_done(zgd_t * zgd,int error)1190b24ab676SJeff Bonwick zfs_get_done(zgd_t *zgd, int error)
1191c5c6ffa0Smaybee {
1192b24ab676SJeff Bonwick znode_t *zp = zgd->zgd_private;
1193b24ab676SJeff Bonwick objset_t *os = zp->z_zfsvfs->z_os;
1194c5c6ffa0Smaybee
1195b24ab676SJeff Bonwick if (zgd->zgd_db)
1196b24ab676SJeff Bonwick dmu_buf_rele(zgd->zgd_db, zgd);
1197b24ab676SJeff Bonwick
119879315247SMatthew Ahrens rangelock_exit(zgd->zgd_lr);
1199b24ab676SJeff Bonwick
12009d3574bfSNeil Perrin /*
12019d3574bfSNeil Perrin * Release the vnode asynchronously as we currently have the
12029d3574bfSNeil Perrin * txg stopped from syncing.
12039d3574bfSNeil Perrin */
1204b24ab676SJeff Bonwick VN_RELE_ASYNC(ZTOV(zp), dsl_pool_vnrele_taskq(dmu_objset_pool(os)));
1205b24ab676SJeff Bonwick
120667bd71c6Sperrin kmem_free(zgd, sizeof (zgd_t));
1207c5c6ffa0Smaybee }
1208c5c6ffa0Smaybee
1209c87b8fc5SMark J Musante #ifdef DEBUG
1210c87b8fc5SMark J Musante static int zil_fault_io = 0;
1211c87b8fc5SMark J Musante #endif
1212c87b8fc5SMark J Musante
1213fa9e4066Sahrens /*
1214fa9e4066Sahrens * Get data to generate a TX_WRITE intent log record.
1215fa9e4066Sahrens */
1216fa9e4066Sahrens int
zfs_get_data(void * arg,lr_write_t * lr,char * buf,struct lwb * lwb,zio_t * zio)12171271e4b1SPrakash Surya zfs_get_data(void *arg, lr_write_t *lr, char *buf, struct lwb *lwb, zio_t *zio)
1218fa9e4066Sahrens {
1219fa9e4066Sahrens zfsvfs_t *zfsvfs = arg;
1220fa9e4066Sahrens objset_t *os = zfsvfs->z_os;
1221fa9e4066Sahrens znode_t *zp;
1222b24ab676SJeff Bonwick uint64_t object = lr->lr_foid;
1223b24ab676SJeff Bonwick uint64_t offset = lr->lr_offset;
1224b24ab676SJeff Bonwick uint64_t size = lr->lr_length;
1225c5c6ffa0Smaybee dmu_buf_t *db;
122667bd71c6Sperrin zgd_t *zgd;
1227fa9e4066Sahrens int error = 0;
1228fa9e4066Sahrens
12291271e4b1SPrakash Surya ASSERT3P(lwb, !=, NULL);
12301271e4b1SPrakash Surya ASSERT3P(zio, !=, NULL);
12311271e4b1SPrakash Surya ASSERT3U(size, !=, 0);
1232fa9e4066Sahrens
1233fa9e4066Sahrens /*
1234104e2ed7Sperrin * Nothing to do if the file has been removed
1235fa9e4066Sahrens */
1236b24ab676SJeff Bonwick if (zfs_zget(zfsvfs, object, &zp) != 0)
1237be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
1238893a6d32Sahrens if (zp->z_unlinked) {
12399d3574bfSNeil Perrin /*
12409d3574bfSNeil Perrin * Release the vnode asynchronously as we currently have the
12419d3574bfSNeil Perrin * txg stopped from syncing.
12429d3574bfSNeil Perrin */
12439d3574bfSNeil Perrin VN_RELE_ASYNC(ZTOV(zp),
12449d3574bfSNeil Perrin dsl_pool_vnrele_taskq(dmu_objset_pool(os)));
1245be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
1246fa9e4066Sahrens }
1247fa9e4066Sahrens
1248b24ab676SJeff Bonwick zgd = (zgd_t *)kmem_zalloc(sizeof (zgd_t), KM_SLEEP);
12491271e4b1SPrakash Surya zgd->zgd_lwb = lwb;
1250b24ab676SJeff Bonwick zgd->zgd_private = zp;
1251b24ab676SJeff Bonwick
1252fa9e4066Sahrens /*
1253fa9e4066Sahrens * Write records come in two flavors: immediate and indirect.
1254fa9e4066Sahrens * For small writes it's cheaper to store the data with the
1255fa9e4066Sahrens * log record (immediate); for large writes it's cheaper to
1256fa9e4066Sahrens * sync the data and get a pointer to it (indirect) so that
1257fa9e4066Sahrens * we don't have to write the data twice.
1258fa9e4066Sahrens */
1259104e2ed7Sperrin if (buf != NULL) { /* immediate write */
126079315247SMatthew Ahrens zgd->zgd_lr = rangelock_enter(&zp->z_rangelock,
126179315247SMatthew Ahrens offset, size, RL_READER);
1262104e2ed7Sperrin /* test for truncation needs to be done while range locked */
12630a586ceaSMark Shellenbaum if (offset >= zp->z_size) {
1264be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT);
1265b24ab676SJeff Bonwick } else {
1266b24ab676SJeff Bonwick error = dmu_read(os, object, offset, size, buf,
1267b24ab676SJeff Bonwick DMU_READ_NO_PREFETCH);
1268104e2ed7Sperrin }
1269b24ab676SJeff Bonwick ASSERT(error == 0 || error == ENOENT);
1270104e2ed7Sperrin } else { /* indirect write */
1271fa9e4066Sahrens /*
1272104e2ed7Sperrin * Have to lock the whole block to ensure when it's
127342b14111SLOLi * written out and its checksum is being calculated
1274104e2ed7Sperrin * that no one can change the data. We need to re-check
1275104e2ed7Sperrin * blocksize after we get the lock in case it's changed!
1276fa9e4066Sahrens */
1277104e2ed7Sperrin for (;;) {
1278b24ab676SJeff Bonwick uint64_t blkoff;
1279b24ab676SJeff Bonwick size = zp->z_blksz;
1280dfe73b3dSJeff Bonwick blkoff = ISP2(size) ? P2PHASE(offset, size) : offset;
1281b24ab676SJeff Bonwick offset -= blkoff;
128279315247SMatthew Ahrens zgd->zgd_lr = rangelock_enter(&zp->z_rangelock,
128379315247SMatthew Ahrens offset, size, RL_READER);
1284b24ab676SJeff Bonwick if (zp->z_blksz == size)
1285104e2ed7Sperrin break;
1286b24ab676SJeff Bonwick offset += blkoff;
128779315247SMatthew Ahrens rangelock_exit(zgd->zgd_lr);
1288104e2ed7Sperrin }
1289104e2ed7Sperrin /* test for truncation needs to be done while range locked */
12900a586ceaSMark Shellenbaum if (lr->lr_offset >= zp->z_size)
1291be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT);
1292c87b8fc5SMark J Musante #ifdef DEBUG
1293c87b8fc5SMark J Musante if (zil_fault_io) {
1294be6fd75aSMatthew Ahrens error = SET_ERROR(EIO);
1295c87b8fc5SMark J Musante zil_fault_io = 0;
1296c87b8fc5SMark J Musante }
1297c87b8fc5SMark J Musante #endif
1298b24ab676SJeff Bonwick if (error == 0)
129947cb52daSJeff Bonwick error = dmu_buf_hold(os, object, offset, zgd, &db,
130047cb52daSJeff Bonwick DMU_READ_NO_PREFETCH);
1301c87b8fc5SMark J Musante
1302975c32a0SNeil Perrin if (error == 0) {
1303b7edcb94SMatthew Ahrens blkptr_t *bp = &lr->lr_blkptr;
130480901aeaSGeorge Wilson
1305b24ab676SJeff Bonwick zgd->zgd_db = db;
1306b24ab676SJeff Bonwick zgd->zgd_bp = bp;
1307b24ab676SJeff Bonwick
1308b24ab676SJeff Bonwick ASSERT(db->db_offset == offset);
1309b24ab676SJeff Bonwick ASSERT(db->db_size == size);
1310b24ab676SJeff Bonwick
1311b24ab676SJeff Bonwick error = dmu_sync(zio, lr->lr_common.lrc_txg,
1312b24ab676SJeff Bonwick zfs_get_done, zgd);
13130c94e1afSAndriy Gapon ASSERT(error || lr->lr_length <= size);
1314975c32a0SNeil Perrin
1315c5c6ffa0Smaybee /*
1316b24ab676SJeff Bonwick * On success, we need to wait for the write I/O
1317b24ab676SJeff Bonwick * initiated by dmu_sync() to complete before we can
1318b24ab676SJeff Bonwick * release this dbuf. We will finish everything up
1319b24ab676SJeff Bonwick * in the zfs_get_done() callback.
1320c5c6ffa0Smaybee */
1321b24ab676SJeff Bonwick if (error == 0)
1322c5c6ffa0Smaybee return (0);
1323b24ab676SJeff Bonwick
1324b24ab676SJeff Bonwick if (error == EALREADY) {
1325975c32a0SNeil Perrin lr->lr_common.lrc_txtype = TX_WRITE2;
13265cabbc6bSPrashanth Sreenivasa /*
13275cabbc6bSPrashanth Sreenivasa * TX_WRITE2 relies on the data previously
13285cabbc6bSPrashanth Sreenivasa * written by the TX_WRITE that caused
13295cabbc6bSPrashanth Sreenivasa * EALREADY. We zero out the BP because
1330cab3a55eSPrakash Surya * it is the old, currently-on-disk BP.
13315cabbc6bSPrashanth Sreenivasa */
13325cabbc6bSPrashanth Sreenivasa zgd->zgd_bp = NULL;
13335cabbc6bSPrashanth Sreenivasa BP_ZERO(bp);
1334975c32a0SNeil Perrin error = 0;
1335975c32a0SNeil Perrin }
1336fa9e4066Sahrens }
1337b24ab676SJeff Bonwick }
1338b24ab676SJeff Bonwick
1339b24ab676SJeff Bonwick zfs_get_done(zgd, error);
1340b24ab676SJeff Bonwick
1341fa9e4066Sahrens return (error);
1342fa9e4066Sahrens }
1343fa9e4066Sahrens
1344fa9e4066Sahrens /*ARGSUSED*/
1345fa9e4066Sahrens static int
zfs_access(vnode_t * vp,int mode,int flag,cred_t * cr,caller_context_t * ct)1346da6c28aaSamw zfs_access(vnode_t *vp, int mode, int flag, cred_t *cr,
1347da6c28aaSamw caller_context_t *ct)
1348fa9e4066Sahrens {
1349fa9e4066Sahrens znode_t *zp = VTOZ(vp);
1350fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
1351fa9e4066Sahrens int error;
1352fa9e4066Sahrens
13533cb34c60Sahrens ZFS_ENTER(zfsvfs);
13543cb34c60Sahrens ZFS_VERIFY_ZP(zp);
1355da6c28aaSamw
1356da6c28aaSamw if (flag & V_ACE_MASK)
1357da6c28aaSamw error = zfs_zaccess(zp, mode, flag, B_FALSE, cr);
1358da6c28aaSamw else
1359da6c28aaSamw error = zfs_zaccess_rwx(zp, mode, flag, cr);
1360da6c28aaSamw
1361fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1362fa9e4066Sahrens return (error);
1363fa9e4066Sahrens }
1364fa9e4066Sahrens
1365fa9e4066Sahrens /*
1366d47621a4STim Haley * If vnode is for a device return a specfs vnode instead.
1367d47621a4STim Haley */
1368d47621a4STim Haley static int
specvp_check(vnode_t ** vpp,cred_t * cr)1369d47621a4STim Haley specvp_check(vnode_t **vpp, cred_t *cr)
1370d47621a4STim Haley {
1371d47621a4STim Haley int error = 0;
1372d47621a4STim Haley
1373d47621a4STim Haley if (IS_DEVVP(*vpp)) {
1374d47621a4STim Haley struct vnode *svp;
1375d47621a4STim Haley
1376d47621a4STim Haley svp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr);
1377d47621a4STim Haley VN_RELE(*vpp);
1378d47621a4STim Haley if (svp == NULL)
1379be6fd75aSMatthew Ahrens error = SET_ERROR(ENOSYS);
1380d47621a4STim Haley *vpp = svp;
1381d47621a4STim Haley }
1382d47621a4STim Haley return (error);
1383d47621a4STim Haley }
1384d47621a4STim Haley
1385d47621a4STim Haley
1386d47621a4STim Haley /*
1387fa9e4066Sahrens * Lookup an entry in a directory, or an extended attribute directory.
1388fa9e4066Sahrens * If it exists, return a held vnode reference for it.
1389fa9e4066Sahrens *
1390fa9e4066Sahrens * IN: dvp - vnode of directory to search.
1391fa9e4066Sahrens * nm - name of entry to lookup.
1392fa9e4066Sahrens * pnp - full pathname to lookup [UNUSED].
1393fa9e4066Sahrens * flags - LOOKUP_XATTR set if looking for an attribute.
1394fa9e4066Sahrens * rdir - root directory vnode [UNUSED].
1395fa9e4066Sahrens * cr - credentials of caller.
1396da6c28aaSamw * ct - caller context
1397da6c28aaSamw * direntflags - directory lookup flags
1398da6c28aaSamw * realpnp - returned pathname.
1399fa9e4066Sahrens *
1400fa9e4066Sahrens * OUT: vpp - vnode of located entry, NULL if not found.
1401fa9e4066Sahrens *
1402f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
1403fa9e4066Sahrens *
1404fa9e4066Sahrens * Timestamps:
1405fa9e4066Sahrens * NA
1406fa9e4066Sahrens */
1407fa9e4066Sahrens /* ARGSUSED */
1408fa9e4066Sahrens static int
zfs_lookup(vnode_t * dvp,char * nm,vnode_t ** vpp,struct pathname * pnp,int flags,vnode_t * rdir,cred_t * cr,caller_context_t * ct,int * direntflags,pathname_t * realpnp)1409fa9e4066Sahrens zfs_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, struct pathname *pnp,
1410da6c28aaSamw int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
1411da6c28aaSamw int *direntflags, pathname_t *realpnp)
1412fa9e4066Sahrens {
1413fa9e4066Sahrens znode_t *zdp = VTOZ(dvp);
1414fa9e4066Sahrens zfsvfs_t *zfsvfs = zdp->z_zfsvfs;
1415d47621a4STim Haley int error = 0;
1416680069d3SMatt Barden boolean_t skipaclchk = ((flags & LOOKUP_NOACLCHECK) != 0);
1417f37b3cbbSMatt Barden
1418f37b3cbbSMatt Barden /*
1419680069d3SMatt Barden * LOOKUP_NOACLCHECK is specified to skip EXECUTE checks for
1420f37b3cbbSMatt Barden * consumers (like SMB) that bypass traverse checking.
1421f37b3cbbSMatt Barden * Turn it off here so it can't accidentally be used
1422f37b3cbbSMatt Barden * for other checks.
1423f37b3cbbSMatt Barden */
1424680069d3SMatt Barden flags &= ~LOOKUP_NOACLCHECK;
1425d47621a4STim Haley
14261c17160aSKevin Crowe /*
14271c17160aSKevin Crowe * Fast path lookup, however we must skip DNLC lookup
14281c17160aSKevin Crowe * for case folding or normalizing lookups because the
14291c17160aSKevin Crowe * DNLC code only stores the passed in name. This means
14301c17160aSKevin Crowe * creating 'a' and removing 'A' on a case insensitive
14311c17160aSKevin Crowe * file system would work, but DNLC still thinks 'a'
14321c17160aSKevin Crowe * exists and won't let you create it again on the next
14331c17160aSKevin Crowe * pass through fast path.
14341c17160aSKevin Crowe */
1435d47621a4STim Haley if (!(flags & (LOOKUP_XATTR | FIGNORECASE))) {
1436d47621a4STim Haley
1437d47621a4STim Haley if (dvp->v_type != VDIR) {
1438be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTDIR));
14390a586ceaSMark Shellenbaum } else if (zdp->z_sa_hdl == NULL) {
1440be6fd75aSMatthew Ahrens return (SET_ERROR(EIO));
1441d47621a4STim Haley }
1442d47621a4STim Haley
1443d47621a4STim Haley if (nm[0] == 0 || (nm[0] == '.' && nm[1] == '\0')) {
1444f37b3cbbSMatt Barden error = zfs_fastaccesschk_execute(zdp, cr, skipaclchk);
1445d47621a4STim Haley if (!error) {
1446d47621a4STim Haley *vpp = dvp;
1447d47621a4STim Haley VN_HOLD(*vpp);
1448d47621a4STim Haley return (0);
1449d47621a4STim Haley }
1450d47621a4STim Haley return (error);
14511c17160aSKevin Crowe } else if (!zdp->z_zfsvfs->z_norm &&
14521c17160aSKevin Crowe (zdp->z_zfsvfs->z_case == ZFS_CASE_SENSITIVE)) {
14531c17160aSKevin Crowe
1454d47621a4STim Haley vnode_t *tvp = dnlc_lookup(dvp, nm);
1455d47621a4STim Haley
1456d47621a4STim Haley if (tvp) {
1457f37b3cbbSMatt Barden error = zfs_fastaccesschk_execute(zdp, cr,
1458f37b3cbbSMatt Barden skipaclchk);
1459d47621a4STim Haley if (error) {
1460d47621a4STim Haley VN_RELE(tvp);
1461d47621a4STim Haley return (error);
1462d47621a4STim Haley }
1463d47621a4STim Haley if (tvp == DNLC_NO_VNODE) {
1464d47621a4STim Haley VN_RELE(tvp);
1465be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
1466d47621a4STim Haley } else {
1467d47621a4STim Haley *vpp = tvp;
1468d47621a4STim Haley return (specvp_check(vpp, cr));
1469d47621a4STim Haley }
1470d47621a4STim Haley }
1471d47621a4STim Haley }
1472d47621a4STim Haley }
1473d47621a4STim Haley
1474d47621a4STim Haley DTRACE_PROBE2(zfs__fastpath__lookup__miss, vnode_t *, dvp, char *, nm);
1475fa9e4066Sahrens
14763cb34c60Sahrens ZFS_ENTER(zfsvfs);
14773cb34c60Sahrens ZFS_VERIFY_ZP(zdp);
1478fa9e4066Sahrens
1479fa9e4066Sahrens *vpp = NULL;
1480fa9e4066Sahrens
1481fa9e4066Sahrens if (flags & LOOKUP_XATTR) {
1482fa9e4066Sahrens /*
14837b55fa8eSck153898 * If the xattr property is off, refuse the lookup request.
14847b55fa8eSck153898 */
14857b55fa8eSck153898 if (!(zfsvfs->z_vfs->vfs_flag & VFS_XATTR)) {
14867b55fa8eSck153898 ZFS_EXIT(zfsvfs);
1487be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
14887b55fa8eSck153898 }
14897b55fa8eSck153898
14907b55fa8eSck153898 /*
1491fa9e4066Sahrens * We don't allow recursive attributes..
1492fa9e4066Sahrens * Maybe someday we will.
1493fa9e4066Sahrens */
14940a586ceaSMark Shellenbaum if (zdp->z_pflags & ZFS_XATTR) {
1495fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1496be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
1497fa9e4066Sahrens }
1498fa9e4066Sahrens
14993f063a9dSck153898 if (error = zfs_get_xattrdir(VTOZ(dvp), vpp, cr, flags)) {
1500fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1501fa9e4066Sahrens return (error);
1502fa9e4066Sahrens }
1503fa9e4066Sahrens
1504fa9e4066Sahrens /*
1505fa9e4066Sahrens * Do we have permission to get into attribute directory?
1506fa9e4066Sahrens */
1507fa9e4066Sahrens
1508da6c28aaSamw if (error = zfs_zaccess(VTOZ(*vpp), ACE_EXECUTE, 0,
1509f37b3cbbSMatt Barden skipaclchk, cr)) {
1510fa9e4066Sahrens VN_RELE(*vpp);
1511da6c28aaSamw *vpp = NULL;
1512fa9e4066Sahrens }
1513fa9e4066Sahrens
1514fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1515fa9e4066Sahrens return (error);
1516fa9e4066Sahrens }
1517fa9e4066Sahrens
15180f2dc02eSek110237 if (dvp->v_type != VDIR) {
15190f2dc02eSek110237 ZFS_EXIT(zfsvfs);
1520be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTDIR));
15210f2dc02eSek110237 }
1522736b9155Smarks
1523fa9e4066Sahrens /*
1524fa9e4066Sahrens * Check accessibility of directory.
1525fa9e4066Sahrens */
1526fa9e4066Sahrens
1527f37b3cbbSMatt Barden if (error = zfs_zaccess(zdp, ACE_EXECUTE, 0, skipaclchk, cr)) {
1528fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1529fa9e4066Sahrens return (error);
1530fa9e4066Sahrens }
1531fa9e4066Sahrens
1532de8267e0Stimh if (zfsvfs->z_utf8 && u8_validate(nm, strlen(nm),
1533da6c28aaSamw NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
1534da6c28aaSamw ZFS_EXIT(zfsvfs);
1535be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ));
1536da6c28aaSamw }
1537fa9e4066Sahrens
1538da6c28aaSamw error = zfs_dirlook(zdp, nm, vpp, flags, direntflags, realpnp);
1539d47621a4STim Haley if (error == 0)
1540d47621a4STim Haley error = specvp_check(vpp, cr);
1541fa9e4066Sahrens
1542fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1543fa9e4066Sahrens return (error);
1544fa9e4066Sahrens }
1545fa9e4066Sahrens
1546fa9e4066Sahrens /*
1547fa9e4066Sahrens * Attempt to create a new entry in a directory. If the entry
1548fa9e4066Sahrens * already exists, truncate the file if permissible, else return
1549fa9e4066Sahrens * an error. Return the vp of the created or trunc'd file.
1550fa9e4066Sahrens *
1551fa9e4066Sahrens * IN: dvp - vnode of directory to put new file entry in.
1552fa9e4066Sahrens * name - name of new file entry.
1553fa9e4066Sahrens * vap - attributes of new file.
1554fa9e4066Sahrens * excl - flag indicating exclusive or non-exclusive mode.
1555fa9e4066Sahrens * mode - mode to open file with.
1556fa9e4066Sahrens * cr - credentials of caller.
1557fa9e4066Sahrens * flag - large file flag [UNUSED].
1558da6c28aaSamw * ct - caller context
1559da6c28aaSamw * vsecp - ACL to be set
1560fa9e4066Sahrens *
1561fa9e4066Sahrens * OUT: vpp - vnode of created or trunc'd entry.
1562fa9e4066Sahrens *
1563f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
1564fa9e4066Sahrens *
1565fa9e4066Sahrens * Timestamps:
1566fa9e4066Sahrens * dvp - ctime|mtime updated if new entry created
1567fa9e4066Sahrens * vp - ctime|mtime always, atime if new
1568fa9e4066Sahrens */
1569da6c28aaSamw
1570fa9e4066Sahrens /* ARGSUSED */
1571fa9e4066Sahrens static int
zfs_create(vnode_t * dvp,char * name,vattr_t * vap,vcexcl_t excl,int mode,vnode_t ** vpp,cred_t * cr,int flag,caller_context_t * ct,vsecattr_t * vsecp)1572fa9e4066Sahrens zfs_create(vnode_t *dvp, char *name, vattr_t *vap, vcexcl_t excl,
1573da6c28aaSamw int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct,
1574da6c28aaSamw vsecattr_t *vsecp)
1575fa9e4066Sahrens {
1576fa9e4066Sahrens znode_t *zp, *dzp = VTOZ(dvp);
1577fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
1578f18faf3fSek110237 zilog_t *zilog;
1579f18faf3fSek110237 objset_t *os;
1580fa9e4066Sahrens zfs_dirlock_t *dl;
1581fa9e4066Sahrens dmu_tx_t *tx;
1582fa9e4066Sahrens int error;
1583c1ce5987SMark Shellenbaum ksid_t *ksid;
1584c1ce5987SMark Shellenbaum uid_t uid;
1585c1ce5987SMark Shellenbaum gid_t gid = crgetgid(cr);
158689459e17SMark Shellenbaum zfs_acl_ids_t acl_ids;
158789459e17SMark Shellenbaum boolean_t fuid_dirtied;
1588c8c24165SMark Shellenbaum boolean_t have_acl = B_FALSE;
158969962b56SMatthew Ahrens boolean_t waited = B_FALSE;
1590da6c28aaSamw
1591da6c28aaSamw /*
1592da6c28aaSamw * If we have an ephemeral id, ACL, or XVATTR then
1593da6c28aaSamw * make sure file system is at proper version
1594da6c28aaSamw */
1595da6c28aaSamw
1596c1ce5987SMark Shellenbaum ksid = crgetsid(cr, KSID_OWNER);
1597c1ce5987SMark Shellenbaum if (ksid)
1598c1ce5987SMark Shellenbaum uid = ksid_getid(ksid);
1599c1ce5987SMark Shellenbaum else
1600c1ce5987SMark Shellenbaum uid = crgetuid(cr);
1601c1ce5987SMark Shellenbaum
1602da6c28aaSamw if (zfsvfs->z_use_fuids == B_FALSE &&
1603da6c28aaSamw (vsecp || (vap->va_mask & AT_XVATTR) ||
1604c1ce5987SMark Shellenbaum IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid)))
1605be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
1606fa9e4066Sahrens
16073cb34c60Sahrens ZFS_ENTER(zfsvfs);
16083cb34c60Sahrens ZFS_VERIFY_ZP(dzp);
1609f18faf3fSek110237 os = zfsvfs->z_os;
1610f18faf3fSek110237 zilog = zfsvfs->z_log;
1611fa9e4066Sahrens
1612de8267e0Stimh if (zfsvfs->z_utf8 && u8_validate(name, strlen(name),
1613da6c28aaSamw NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
1614da6c28aaSamw ZFS_EXIT(zfsvfs);
1615be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ));
1616da6c28aaSamw }
1617da6c28aaSamw
1618da6c28aaSamw if (vap->va_mask & AT_XVATTR) {
1619da6c28aaSamw if ((error = secpolicy_xvattr((xvattr_t *)vap,
1620da6c28aaSamw crgetuid(cr), cr, vap->va_type)) != 0) {
1621da6c28aaSamw ZFS_EXIT(zfsvfs);
1622da6c28aaSamw return (error);
1623da6c28aaSamw }
1624da6c28aaSamw }
1625fa9e4066Sahrens top:
1626fa9e4066Sahrens *vpp = NULL;
1627fa9e4066Sahrens
1628fa9e4066Sahrens if ((vap->va_mode & VSVTX) && secpolicy_vnode_stky_modify(cr))
1629fa9e4066Sahrens vap->va_mode &= ~VSVTX;
1630fa9e4066Sahrens
1631fa9e4066Sahrens if (*name == '\0') {
1632fa9e4066Sahrens /*
1633fa9e4066Sahrens * Null component name refers to the directory itself.
1634fa9e4066Sahrens */
1635fa9e4066Sahrens VN_HOLD(dvp);
1636fa9e4066Sahrens zp = dzp;
1637fa9e4066Sahrens dl = NULL;
1638fa9e4066Sahrens error = 0;
1639fa9e4066Sahrens } else {
1640fa9e4066Sahrens /* possible VN_HOLD(zp) */
1641da6c28aaSamw int zflg = 0;
1642da6c28aaSamw
1643da6c28aaSamw if (flag & FIGNORECASE)
1644da6c28aaSamw zflg |= ZCILOOK;
1645da6c28aaSamw
1646da6c28aaSamw error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
1647da6c28aaSamw NULL, NULL);
1648da6c28aaSamw if (error) {
16490b2a8171SMark Shellenbaum if (have_acl)
16500b2a8171SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
1651fa9e4066Sahrens if (strcmp(name, "..") == 0)
1652be6fd75aSMatthew Ahrens error = SET_ERROR(EISDIR);
1653fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1654fa9e4066Sahrens return (error);
1655fa9e4066Sahrens }
1656fa9e4066Sahrens }
16570a586ceaSMark Shellenbaum
1658fa9e4066Sahrens if (zp == NULL) {
1659da6c28aaSamw uint64_t txtype;
1660f67950b2SNasf-Fan uint64_t projid = ZFS_DEFAULT_PROJID;
1661da6c28aaSamw
1662fa9e4066Sahrens /*
1663fa9e4066Sahrens * Create a new file object and update the directory
1664fa9e4066Sahrens * to reference it.
1665fa9e4066Sahrens */
1666da6c28aaSamw if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) {
16670b2a8171SMark Shellenbaum if (have_acl)
16680b2a8171SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
1669fa9e4066Sahrens goto out;
1670fa9e4066Sahrens }
1671fa9e4066Sahrens
1672fa9e4066Sahrens /*
1673fa9e4066Sahrens * We only support the creation of regular files in
1674fa9e4066Sahrens * extended attribute directories.
1675fa9e4066Sahrens */
16760a586ceaSMark Shellenbaum
16770a586ceaSMark Shellenbaum if ((dzp->z_pflags & ZFS_XATTR) &&
1678fa9e4066Sahrens (vap->va_type != VREG)) {
16790b2a8171SMark Shellenbaum if (have_acl)
16800b2a8171SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
1681be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL);
1682fa9e4066Sahrens goto out;
1683fa9e4066Sahrens }
1684fa9e4066Sahrens
1685c8c24165SMark Shellenbaum if (!have_acl && (error = zfs_acl_ids_create(dzp, 0, vap,
1686c8c24165SMark Shellenbaum cr, vsecp, &acl_ids)) != 0)
168789459e17SMark Shellenbaum goto out;
1688c8c24165SMark Shellenbaum have_acl = B_TRUE;
1689c8c24165SMark Shellenbaum
1690f67950b2SNasf-Fan if (vap->va_type == VREG || vap->va_type == VDIR)
1691f67950b2SNasf-Fan projid = zfs_inherit_projid(dzp);
1692f67950b2SNasf-Fan if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, projid)) {
16934929fd5eSTim Haley zfs_acl_ids_free(&acl_ids);
1694be6fd75aSMatthew Ahrens error = SET_ERROR(EDQUOT);
169514843421SMatthew Ahrens goto out;
169614843421SMatthew Ahrens }
169789459e17SMark Shellenbaum
1698fa9e4066Sahrens tx = dmu_tx_create(os);
16990a586ceaSMark Shellenbaum
17000a586ceaSMark Shellenbaum dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
17010a586ceaSMark Shellenbaum ZFS_SA_BASE_ATTR_SIZE);
17020a586ceaSMark Shellenbaum
170389459e17SMark Shellenbaum fuid_dirtied = zfsvfs->z_fuid_dirty;
170414843421SMatthew Ahrens if (fuid_dirtied)
170514843421SMatthew Ahrens zfs_fuid_txhold(zfsvfs, tx);
1706ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
17070a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
17080a586ceaSMark Shellenbaum if (!zfsvfs->z_use_sa &&
17090a586ceaSMark Shellenbaum acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
1710fa9e4066Sahrens dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
17110a586ceaSMark Shellenbaum 0, acl_ids.z_aclp->z_acl_bytes);
1712da6c28aaSamw }
1713f864f99eSPrakash Surya error = dmu_tx_assign(tx,
1714f864f99eSPrakash Surya (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
1715fa9e4066Sahrens if (error) {
1716fa9e4066Sahrens zfs_dirent_unlock(dl);
17171209a471SNeil Perrin if (error == ERESTART) {
171869962b56SMatthew Ahrens waited = B_TRUE;
17198a2f1b91Sahrens dmu_tx_wait(tx);
17208a2f1b91Sahrens dmu_tx_abort(tx);
1721fa9e4066Sahrens goto top;
1722fa9e4066Sahrens }
1723c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
17248a2f1b91Sahrens dmu_tx_abort(tx);
1725fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1726fa9e4066Sahrens return (error);
1727fa9e4066Sahrens }
17280a586ceaSMark Shellenbaum zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
172989459e17SMark Shellenbaum
173089459e17SMark Shellenbaum if (fuid_dirtied)
173189459e17SMark Shellenbaum zfs_fuid_sync(zfsvfs, tx);
173289459e17SMark Shellenbaum
1733fa9e4066Sahrens (void) zfs_link_create(dl, zp, tx, ZNEW);
1734da6c28aaSamw txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap);
1735da6c28aaSamw if (flag & FIGNORECASE)
1736da6c28aaSamw txtype |= TX_CI;
1737da6c28aaSamw zfs_log_create(zilog, tx, txtype, dzp, zp, name,
173889459e17SMark Shellenbaum vsecp, acl_ids.z_fuidp, vap);
173989459e17SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
1740fa9e4066Sahrens dmu_tx_commit(tx);
1741fa9e4066Sahrens } else {
1742da6c28aaSamw int aflags = (flag & FAPPEND) ? V_APPEND : 0;
1743da6c28aaSamw
17440b2a8171SMark Shellenbaum if (have_acl)
17450b2a8171SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
17460b2a8171SMark Shellenbaum have_acl = B_FALSE;
17470b2a8171SMark Shellenbaum
1748fa9e4066Sahrens /*
1749fa9e4066Sahrens * A directory entry already exists for this name.
1750fa9e4066Sahrens */
1751fa9e4066Sahrens /*
1752fa9e4066Sahrens * Can't truncate an existing file if in exclusive mode.
1753fa9e4066Sahrens */
1754fa9e4066Sahrens if (excl == EXCL) {
1755be6fd75aSMatthew Ahrens error = SET_ERROR(EEXIST);
1756fa9e4066Sahrens goto out;
1757fa9e4066Sahrens }
1758fa9e4066Sahrens /*
1759fa9e4066Sahrens * Can't open a directory for writing.
1760fa9e4066Sahrens */
1761fa9e4066Sahrens if ((ZTOV(zp)->v_type == VDIR) && (mode & S_IWRITE)) {
1762be6fd75aSMatthew Ahrens error = SET_ERROR(EISDIR);
1763fa9e4066Sahrens goto out;
1764fa9e4066Sahrens }
1765fa9e4066Sahrens /*
1766fa9e4066Sahrens * Verify requested access to file.
1767fa9e4066Sahrens */
1768da6c28aaSamw if (mode && (error = zfs_zaccess_rwx(zp, mode, aflags, cr))) {
1769fa9e4066Sahrens goto out;
1770fa9e4066Sahrens }
1771fa9e4066Sahrens
1772fa9e4066Sahrens mutex_enter(&dzp->z_lock);
1773fa9e4066Sahrens dzp->z_seq++;
1774fa9e4066Sahrens mutex_exit(&dzp->z_lock);
1775fa9e4066Sahrens
1776fa9e4066Sahrens /*
17775730cc9aSmaybee * Truncate regular files if requested.
1778fa9e4066Sahrens */
17795730cc9aSmaybee if ((ZTOV(zp)->v_type == VREG) &&
17805730cc9aSmaybee (vap->va_mask & AT_SIZE) && (vap->va_size == 0)) {
1781cdb0ab79Smaybee /* we can't hold any locks when calling zfs_freesp() */
17825730cc9aSmaybee zfs_dirent_unlock(dl);
1783cdb0ab79Smaybee dl = NULL;
1784cdb0ab79Smaybee error = zfs_freesp(zp, 0, 0, mode, TRUE);
1785df2381bfSpraks if (error == 0) {
1786da6c28aaSamw vnevent_create(ZTOV(zp), ct);
1787df2381bfSpraks }
1788fa9e4066Sahrens }
1789fa9e4066Sahrens }
1790fa9e4066Sahrens out:
1791fa9e4066Sahrens
1792fa9e4066Sahrens if (dl)
1793fa9e4066Sahrens zfs_dirent_unlock(dl);
1794fa9e4066Sahrens
1795fa9e4066Sahrens if (error) {
1796fa9e4066Sahrens if (zp)
1797fa9e4066Sahrens VN_RELE(ZTOV(zp));
1798fa9e4066Sahrens } else {
1799fa9e4066Sahrens *vpp = ZTOV(zp);
1800d47621a4STim Haley error = specvp_check(vpp, cr);
1801fa9e4066Sahrens }
1802fa9e4066Sahrens
180355da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
18045002558fSNeil Perrin zil_commit(zilog, 0);
180555da60b9SMark J Musante
1806fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1807fa9e4066Sahrens return (error);
1808fa9e4066Sahrens }
1809fa9e4066Sahrens
1810fa9e4066Sahrens /*
1811fa9e4066Sahrens * Remove an entry from a directory.
1812fa9e4066Sahrens *
1813fa9e4066Sahrens * IN: dvp - vnode of directory to remove entry from.
1814fa9e4066Sahrens * name - name of entry to remove.
1815fa9e4066Sahrens * cr - credentials of caller.
1816da6c28aaSamw * ct - caller context
1817da6c28aaSamw * flags - case flags
1818fa9e4066Sahrens *
1819f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
1820fa9e4066Sahrens *
1821fa9e4066Sahrens * Timestamps:
1822fa9e4066Sahrens * dvp - ctime|mtime
1823fa9e4066Sahrens * vp - ctime (if nlink > 0)
1824fa9e4066Sahrens */
18250a586ceaSMark Shellenbaum
18260a586ceaSMark Shellenbaum uint64_t null_xattr = 0;
18270a586ceaSMark Shellenbaum
1828da6c28aaSamw /*ARGSUSED*/
1829fa9e4066Sahrens static int
zfs_remove(vnode_t * dvp,char * name,cred_t * cr,caller_context_t * ct,int flags)1830da6c28aaSamw zfs_remove(vnode_t *dvp, char *name, cred_t *cr, caller_context_t *ct,
1831da6c28aaSamw int flags)
1832fa9e4066Sahrens {
1833fa9e4066Sahrens znode_t *zp, *dzp = VTOZ(dvp);
18340b2a8171SMark Shellenbaum znode_t *xzp;
1835fa9e4066Sahrens vnode_t *vp;
1836fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
1837f18faf3fSek110237 zilog_t *zilog;
18380b2a8171SMark Shellenbaum uint64_t acl_obj, xattr_obj;
18390a586ceaSMark Shellenbaum uint64_t xattr_obj_unlinked = 0;
184051bd2f97SNeil Perrin uint64_t obj = 0;
1841fa9e4066Sahrens zfs_dirlock_t *dl;
1842fa9e4066Sahrens dmu_tx_t *tx;
1843893a6d32Sahrens boolean_t may_delete_now, delete_now = FALSE;
1844cdb0ab79Smaybee boolean_t unlinked, toobig = FALSE;
1845da6c28aaSamw uint64_t txtype;
1846da6c28aaSamw pathname_t *realnmp = NULL;
1847da6c28aaSamw pathname_t realnm;
1848fa9e4066Sahrens int error;
1849da6c28aaSamw int zflg = ZEXISTS;
185069962b56SMatthew Ahrens boolean_t waited = B_FALSE;
1851fa9e4066Sahrens
18523cb34c60Sahrens ZFS_ENTER(zfsvfs);
18533cb34c60Sahrens ZFS_VERIFY_ZP(dzp);
1854f18faf3fSek110237 zilog = zfsvfs->z_log;
1855fa9e4066Sahrens
1856da6c28aaSamw if (flags & FIGNORECASE) {
1857da6c28aaSamw zflg |= ZCILOOK;
1858da6c28aaSamw pn_alloc(&realnm);
1859da6c28aaSamw realnmp = &realnm;
1860da6c28aaSamw }
1861da6c28aaSamw
1862fa9e4066Sahrens top:
18630b2a8171SMark Shellenbaum xattr_obj = 0;
18640b2a8171SMark Shellenbaum xzp = NULL;
1865fa9e4066Sahrens /*
1866fa9e4066Sahrens * Attempt to lock directory; fail if entry doesn't exist.
1867fa9e4066Sahrens */
1868da6c28aaSamw if (error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
1869da6c28aaSamw NULL, realnmp)) {
1870da6c28aaSamw if (realnmp)
1871da6c28aaSamw pn_free(realnmp);
1872fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1873fa9e4066Sahrens return (error);
1874fa9e4066Sahrens }
1875fa9e4066Sahrens
1876fa9e4066Sahrens vp = ZTOV(zp);
1877fa9e4066Sahrens
1878fa9e4066Sahrens if (error = zfs_zaccess_delete(dzp, zp, cr)) {
1879fa9e4066Sahrens goto out;
1880fa9e4066Sahrens }
1881fa9e4066Sahrens
1882fa9e4066Sahrens /*
1883fa9e4066Sahrens * Need to use rmdir for removing directories.
1884fa9e4066Sahrens */
1885fa9e4066Sahrens if (vp->v_type == VDIR) {
1886be6fd75aSMatthew Ahrens error = SET_ERROR(EPERM);
1887fa9e4066Sahrens goto out;
1888fa9e4066Sahrens }
1889fa9e4066Sahrens
1890da6c28aaSamw vnevent_remove(vp, dvp, name, ct);
1891fa9e4066Sahrens
1892da6c28aaSamw if (realnmp)
1893ab04eb8eStimh dnlc_remove(dvp, realnmp->pn_buf);
1894da6c28aaSamw else
1895033f9833Sek110237 dnlc_remove(dvp, name);
1896033f9833Sek110237
1897fa9e4066Sahrens mutex_enter(&vp->v_lock);
1898fa9e4066Sahrens may_delete_now = vp->v_count == 1 && !vn_has_cached_data(vp);
1899fa9e4066Sahrens mutex_exit(&vp->v_lock);
1900fa9e4066Sahrens
1901fa9e4066Sahrens /*
1902893a6d32Sahrens * We may delete the znode now, or we may put it in the unlinked set;
1903fa9e4066Sahrens * it depends on whether we're the last link, and on whether there are
1904fa9e4066Sahrens * other holds on the vnode. So we dmu_tx_hold() the right things to
1905fa9e4066Sahrens * allow for either case.
1906fa9e4066Sahrens */
190751bd2f97SNeil Perrin obj = zp->z_id;
1908fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
1909ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
19100a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
19110a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
19120a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, dzp);
1913cdb0ab79Smaybee if (may_delete_now) {
1914cdb0ab79Smaybee toobig =
19150a586ceaSMark Shellenbaum zp->z_size > zp->z_blksz * DMU_MAX_DELETEBLKCNT;
1916cdb0ab79Smaybee /* if the file is too big, only hold_free a token amount */
1917cdb0ab79Smaybee dmu_tx_hold_free(tx, zp->z_id, 0,
1918cdb0ab79Smaybee (toobig ? DMU_MAX_ACCESS : DMU_OBJECT_END));
1919cdb0ab79Smaybee }
1920fa9e4066Sahrens
1921fa9e4066Sahrens /* are there any extended attributes? */
19220a586ceaSMark Shellenbaum error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
19230a586ceaSMark Shellenbaum &xattr_obj, sizeof (xattr_obj));
19240b2a8171SMark Shellenbaum if (error == 0 && xattr_obj) {
19250a586ceaSMark Shellenbaum error = zfs_zget(zfsvfs, xattr_obj, &xzp);
1926fb09f5aaSMadhav Suresh ASSERT0(error);
19270a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
19280a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
1929fa9e4066Sahrens }
1930fa9e4066Sahrens
19311412a1a2SMark Shellenbaum mutex_enter(&zp->z_lock);
19321412a1a2SMark Shellenbaum if ((acl_obj = zfs_external_acl(zp)) != 0 && may_delete_now)
1933fa9e4066Sahrens dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
19341412a1a2SMark Shellenbaum mutex_exit(&zp->z_lock);
1935fa9e4066Sahrens
1936fa9e4066Sahrens /* charge as an update -- would be nice not to charge at all */
1937893a6d32Sahrens dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
1938fa9e4066Sahrens
19394bb73804SMatthew Ahrens /*
19406575bca0SSimon Klinkert * Mark this transaction as typically resulting in a net free of space
19414bb73804SMatthew Ahrens */
19424bb73804SMatthew Ahrens dmu_tx_mark_netfree(tx);
19434bb73804SMatthew Ahrens
1944f864f99eSPrakash Surya error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
1945fa9e4066Sahrens if (error) {
1946fa9e4066Sahrens zfs_dirent_unlock(dl);
1947fa9e4066Sahrens VN_RELE(vp);
19480b2a8171SMark Shellenbaum if (xzp)
19490b2a8171SMark Shellenbaum VN_RELE(ZTOV(xzp));
19501209a471SNeil Perrin if (error == ERESTART) {
195169962b56SMatthew Ahrens waited = B_TRUE;
19528a2f1b91Sahrens dmu_tx_wait(tx);
19538a2f1b91Sahrens dmu_tx_abort(tx);
1954fa9e4066Sahrens goto top;
1955fa9e4066Sahrens }
1956da6c28aaSamw if (realnmp)
1957da6c28aaSamw pn_free(realnmp);
19588a2f1b91Sahrens dmu_tx_abort(tx);
1959fa9e4066Sahrens ZFS_EXIT(zfsvfs);
1960fa9e4066Sahrens return (error);
1961fa9e4066Sahrens }
1962fa9e4066Sahrens
1963fa9e4066Sahrens /*
1964fa9e4066Sahrens * Remove the directory entry.
1965fa9e4066Sahrens */
1966da6c28aaSamw error = zfs_link_destroy(dl, zp, tx, zflg, &unlinked);
1967fa9e4066Sahrens
1968fa9e4066Sahrens if (error) {
1969fa9e4066Sahrens dmu_tx_commit(tx);
1970fa9e4066Sahrens goto out;
1971fa9e4066Sahrens }
1972fa9e4066Sahrens
1973893a6d32Sahrens if (unlinked) {
19741412a1a2SMark Shellenbaum /*
19751412a1a2SMark Shellenbaum * Hold z_lock so that we can make sure that the ACL obj
19761412a1a2SMark Shellenbaum * hasn't changed. Could have been deleted due to
19771412a1a2SMark Shellenbaum * zfs_sa_upgrade().
19781412a1a2SMark Shellenbaum */
19791412a1a2SMark Shellenbaum mutex_enter(&zp->z_lock);
1980fa9e4066Sahrens mutex_enter(&vp->v_lock);
19810a586ceaSMark Shellenbaum (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
19820a586ceaSMark Shellenbaum &xattr_obj_unlinked, sizeof (xattr_obj_unlinked));
1983cdb0ab79Smaybee delete_now = may_delete_now && !toobig &&
1984fa9e4066Sahrens vp->v_count == 1 && !vn_has_cached_data(vp) &&
19851412a1a2SMark Shellenbaum xattr_obj == xattr_obj_unlinked && zfs_external_acl(zp) ==
19860a586ceaSMark Shellenbaum acl_obj;
1987fa9e4066Sahrens mutex_exit(&vp->v_lock);
1988fa9e4066Sahrens }
1989fa9e4066Sahrens
1990fa9e4066Sahrens if (delete_now) {
19910a586ceaSMark Shellenbaum if (xattr_obj_unlinked) {
19920a586ceaSMark Shellenbaum ASSERT3U(xzp->z_links, ==, 2);
1993fa9e4066Sahrens mutex_enter(&xzp->z_lock);
1994893a6d32Sahrens xzp->z_unlinked = 1;
19950a586ceaSMark Shellenbaum xzp->z_links = 0;
19960a586ceaSMark Shellenbaum error = sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zfsvfs),
19970a586ceaSMark Shellenbaum &xzp->z_links, sizeof (xzp->z_links), tx);
19980a586ceaSMark Shellenbaum ASSERT3U(error, ==, 0);
1999fa9e4066Sahrens mutex_exit(&xzp->z_lock);
2000893a6d32Sahrens zfs_unlinked_add(xzp, tx);
20011412a1a2SMark Shellenbaum
20020a586ceaSMark Shellenbaum if (zp->z_is_sa)
20030a586ceaSMark Shellenbaum error = sa_remove(zp->z_sa_hdl,
20040a586ceaSMark Shellenbaum SA_ZPL_XATTR(zfsvfs), tx);
20050a586ceaSMark Shellenbaum else
20060a586ceaSMark Shellenbaum error = sa_update(zp->z_sa_hdl,
20070a586ceaSMark Shellenbaum SA_ZPL_XATTR(zfsvfs), &null_xattr,
20080a586ceaSMark Shellenbaum sizeof (uint64_t), tx);
2009fb09f5aaSMadhav Suresh ASSERT0(error);
2010fa9e4066Sahrens }
2011fa9e4066Sahrens mutex_enter(&vp->v_lock);
2012ade42b55SSebastien Roy VN_RELE_LOCKED(vp);
2013fb09f5aaSMadhav Suresh ASSERT0(vp->v_count);
2014fa9e4066Sahrens mutex_exit(&vp->v_lock);
2015fa9e4066Sahrens mutex_exit(&zp->z_lock);
2016fa9e4066Sahrens zfs_znode_delete(zp, tx);
2017893a6d32Sahrens } else if (unlinked) {
20181412a1a2SMark Shellenbaum mutex_exit(&zp->z_lock);
2019893a6d32Sahrens zfs_unlinked_add(zp, tx);
2020fa9e4066Sahrens }
2021fa9e4066Sahrens
2022da6c28aaSamw txtype = TX_REMOVE;
2023da6c28aaSamw if (flags & FIGNORECASE)
2024da6c28aaSamw txtype |= TX_CI;
2025d8849d7dSChunwei Chen zfs_log_remove(zilog, tx, txtype, dzp, name, obj, unlinked);
2026fa9e4066Sahrens
2027fa9e4066Sahrens dmu_tx_commit(tx);
2028fa9e4066Sahrens out:
2029da6c28aaSamw if (realnmp)
2030da6c28aaSamw pn_free(realnmp);
2031da6c28aaSamw
2032fa9e4066Sahrens zfs_dirent_unlock(dl);
2033fa9e4066Sahrens
203406e0070dSMark Shellenbaum if (!delete_now)
2035fa9e4066Sahrens VN_RELE(vp);
203606e0070dSMark Shellenbaum if (xzp)
2037fa9e4066Sahrens VN_RELE(ZTOV(xzp));
2038fa9e4066Sahrens
203955da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
20405002558fSNeil Perrin zil_commit(zilog, 0);
204155da60b9SMark J Musante
2042fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2043fa9e4066Sahrens return (error);
2044fa9e4066Sahrens }
2045fa9e4066Sahrens
2046fa9e4066Sahrens /*
2047fa9e4066Sahrens * Create a new directory and insert it into dvp using the name
2048fa9e4066Sahrens * provided. Return a pointer to the inserted directory.
2049fa9e4066Sahrens *
2050fa9e4066Sahrens * IN: dvp - vnode of directory to add subdir to.
2051fa9e4066Sahrens * dirname - name of new directory.
2052fa9e4066Sahrens * vap - attributes of new directory.
2053fa9e4066Sahrens * cr - credentials of caller.
2054da6c28aaSamw * ct - caller context
2055f7170741SWill Andrews * flags - case flags
2056da6c28aaSamw * vsecp - ACL to be set
2057fa9e4066Sahrens *
2058fa9e4066Sahrens * OUT: vpp - vnode of created directory.
2059fa9e4066Sahrens *
2060f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
2061fa9e4066Sahrens *
2062fa9e4066Sahrens * Timestamps:
2063fa9e4066Sahrens * dvp - ctime|mtime updated
2064fa9e4066Sahrens * vp - ctime|mtime|atime updated
2065fa9e4066Sahrens */
2066da6c28aaSamw /*ARGSUSED*/
2067fa9e4066Sahrens static int
zfs_mkdir(vnode_t * dvp,char * dirname,vattr_t * vap,vnode_t ** vpp,cred_t * cr,caller_context_t * ct,int flags,vsecattr_t * vsecp)2068da6c28aaSamw zfs_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t **vpp, cred_t *cr,
2069da6c28aaSamw caller_context_t *ct, int flags, vsecattr_t *vsecp)
2070fa9e4066Sahrens {
2071fa9e4066Sahrens znode_t *zp, *dzp = VTOZ(dvp);
2072fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
2073f18faf3fSek110237 zilog_t *zilog;
2074fa9e4066Sahrens zfs_dirlock_t *dl;
2075da6c28aaSamw uint64_t txtype;
2076fa9e4066Sahrens dmu_tx_t *tx;
2077fa9e4066Sahrens int error;
2078da6c28aaSamw int zf = ZNEW;
2079c1ce5987SMark Shellenbaum ksid_t *ksid;
2080c1ce5987SMark Shellenbaum uid_t uid;
2081c1ce5987SMark Shellenbaum gid_t gid = crgetgid(cr);
208289459e17SMark Shellenbaum zfs_acl_ids_t acl_ids;
208389459e17SMark Shellenbaum boolean_t fuid_dirtied;
208469962b56SMatthew Ahrens boolean_t waited = B_FALSE;
2085fa9e4066Sahrens
2086fa9e4066Sahrens ASSERT(vap->va_type == VDIR);
2087fa9e4066Sahrens
2088da6c28aaSamw /*
2089da6c28aaSamw * If we have an ephemeral id, ACL, or XVATTR then
2090da6c28aaSamw * make sure file system is at proper version
2091da6c28aaSamw */
2092da6c28aaSamw
2093c1ce5987SMark Shellenbaum ksid = crgetsid(cr, KSID_OWNER);
2094c1ce5987SMark Shellenbaum if (ksid)
2095c1ce5987SMark Shellenbaum uid = ksid_getid(ksid);
2096c1ce5987SMark Shellenbaum else
2097c1ce5987SMark Shellenbaum uid = crgetuid(cr);
2098da6c28aaSamw if (zfsvfs->z_use_fuids == B_FALSE &&
2099c1ce5987SMark Shellenbaum (vsecp || (vap->va_mask & AT_XVATTR) ||
2100756962ecSMark Shellenbaum IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid)))
2101be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
2102da6c28aaSamw
21033cb34c60Sahrens ZFS_ENTER(zfsvfs);
21043cb34c60Sahrens ZFS_VERIFY_ZP(dzp);
2105f18faf3fSek110237 zilog = zfsvfs->z_log;
2106fa9e4066Sahrens
21070a586ceaSMark Shellenbaum if (dzp->z_pflags & ZFS_XATTR) {
2108fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2109be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
2110fa9e4066Sahrens }
2111fa9e4066Sahrens
2112de8267e0Stimh if (zfsvfs->z_utf8 && u8_validate(dirname,
2113da6c28aaSamw strlen(dirname), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
2114da6c28aaSamw ZFS_EXIT(zfsvfs);
2115be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ));
2116da6c28aaSamw }
2117da6c28aaSamw if (flags & FIGNORECASE)
2118da6c28aaSamw zf |= ZCILOOK;
2119da6c28aaSamw
2120c8c24165SMark Shellenbaum if (vap->va_mask & AT_XVATTR) {
2121da6c28aaSamw if ((error = secpolicy_xvattr((xvattr_t *)vap,
2122da6c28aaSamw crgetuid(cr), cr, vap->va_type)) != 0) {
2123fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2124fa9e4066Sahrens return (error);
2125fa9e4066Sahrens }
2126c8c24165SMark Shellenbaum }
2127fa9e4066Sahrens
2128c8c24165SMark Shellenbaum if ((error = zfs_acl_ids_create(dzp, 0, vap, cr,
2129c8c24165SMark Shellenbaum vsecp, &acl_ids)) != 0) {
2130c8c24165SMark Shellenbaum ZFS_EXIT(zfsvfs);
2131c8c24165SMark Shellenbaum return (error);
2132c8c24165SMark Shellenbaum }
2133da6c28aaSamw /*
2134da6c28aaSamw * First make sure the new directory doesn't exist.
2135c8c24165SMark Shellenbaum *
2136c8c24165SMark Shellenbaum * Existence is checked first to make sure we don't return
2137c8c24165SMark Shellenbaum * EACCES instead of EEXIST which can cause some applications
2138c8c24165SMark Shellenbaum * to fail.
2139da6c28aaSamw */
2140da6c28aaSamw top:
2141da6c28aaSamw *vpp = NULL;
2142da6c28aaSamw
2143da6c28aaSamw if (error = zfs_dirent_lock(&dl, dzp, dirname, &zp, zf,
2144da6c28aaSamw NULL, NULL)) {
2145c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
2146da6c28aaSamw ZFS_EXIT(zfsvfs);
2147da6c28aaSamw return (error);
2148da6c28aaSamw }
2149da6c28aaSamw
2150da6c28aaSamw if (error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr)) {
2151c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
2152d2443e76Smarks zfs_dirent_unlock(dl);
2153d2443e76Smarks ZFS_EXIT(zfsvfs);
2154d2443e76Smarks return (error);
2155d2443e76Smarks }
2156d2443e76Smarks
2157f67950b2SNasf-Fan if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, zfs_inherit_projid(dzp))) {
21584929fd5eSTim Haley zfs_acl_ids_free(&acl_ids);
215914843421SMatthew Ahrens zfs_dirent_unlock(dl);
216014843421SMatthew Ahrens ZFS_EXIT(zfsvfs);
2161be6fd75aSMatthew Ahrens return (SET_ERROR(EDQUOT));
216214843421SMatthew Ahrens }
216389459e17SMark Shellenbaum
2164fa9e4066Sahrens /*
2165fa9e4066Sahrens * Add a new entry to the directory.
2166fa9e4066Sahrens */
2167fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
2168ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname);
2169ea8dc4b6Seschrock dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
217089459e17SMark Shellenbaum fuid_dirtied = zfsvfs->z_fuid_dirty;
217114843421SMatthew Ahrens if (fuid_dirtied)
217214843421SMatthew Ahrens zfs_fuid_txhold(zfsvfs, tx);
21730a586ceaSMark Shellenbaum if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
21740a586ceaSMark Shellenbaum dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
21750a586ceaSMark Shellenbaum acl_ids.z_aclp->z_acl_bytes);
21760a586ceaSMark Shellenbaum }
21770a586ceaSMark Shellenbaum
21780a586ceaSMark Shellenbaum dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
21790a586ceaSMark Shellenbaum ZFS_SA_BASE_ATTR_SIZE);
21800a586ceaSMark Shellenbaum
2181f864f99eSPrakash Surya error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
2182fa9e4066Sahrens if (error) {
2183fa9e4066Sahrens zfs_dirent_unlock(dl);
21841209a471SNeil Perrin if (error == ERESTART) {
218569962b56SMatthew Ahrens waited = B_TRUE;
21868a2f1b91Sahrens dmu_tx_wait(tx);
21878a2f1b91Sahrens dmu_tx_abort(tx);
2188fa9e4066Sahrens goto top;
2189fa9e4066Sahrens }
2190c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
21918a2f1b91Sahrens dmu_tx_abort(tx);
2192fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2193fa9e4066Sahrens return (error);
2194fa9e4066Sahrens }
2195fa9e4066Sahrens
2196fa9e4066Sahrens /*
2197fa9e4066Sahrens * Create new node.
2198fa9e4066Sahrens */
21990a586ceaSMark Shellenbaum zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
2200da6c28aaSamw
220189459e17SMark Shellenbaum if (fuid_dirtied)
220289459e17SMark Shellenbaum zfs_fuid_sync(zfsvfs, tx);
22030a586ceaSMark Shellenbaum
2204fa9e4066Sahrens /*
2205fa9e4066Sahrens * Now put new name in parent dir.
2206fa9e4066Sahrens */
2207fa9e4066Sahrens (void) zfs_link_create(dl, zp, tx, ZNEW);
2208fa9e4066Sahrens
2209fa9e4066Sahrens *vpp = ZTOV(zp);
2210fa9e4066Sahrens
2211da6c28aaSamw txtype = zfs_log_create_txtype(Z_DIR, vsecp, vap);
2212da6c28aaSamw if (flags & FIGNORECASE)
2213da6c28aaSamw txtype |= TX_CI;
221489459e17SMark Shellenbaum zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, vsecp,
221589459e17SMark Shellenbaum acl_ids.z_fuidp, vap);
2216da6c28aaSamw
221789459e17SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
22180a586ceaSMark Shellenbaum
2219fa9e4066Sahrens dmu_tx_commit(tx);
2220fa9e4066Sahrens
2221fa9e4066Sahrens zfs_dirent_unlock(dl);
2222fa9e4066Sahrens
222355da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
22245002558fSNeil Perrin zil_commit(zilog, 0);
222555da60b9SMark J Musante
2226fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2227fa9e4066Sahrens return (0);
2228fa9e4066Sahrens }
2229fa9e4066Sahrens
2230fa9e4066Sahrens /*
2231fa9e4066Sahrens * Remove a directory subdir entry. If the current working
2232fa9e4066Sahrens * directory is the same as the subdir to be removed, the
2233fa9e4066Sahrens * remove will fail.
2234fa9e4066Sahrens *
2235fa9e4066Sahrens * IN: dvp - vnode of directory to remove from.
2236fa9e4066Sahrens * name - name of directory to be removed.
2237fa9e4066Sahrens * cwd - vnode of current working directory.
2238fa9e4066Sahrens * cr - credentials of caller.
2239da6c28aaSamw * ct - caller context
2240da6c28aaSamw * flags - case flags
2241fa9e4066Sahrens *
2242f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
2243fa9e4066Sahrens *
2244fa9e4066Sahrens * Timestamps:
2245fa9e4066Sahrens * dvp - ctime|mtime updated
2246fa9e4066Sahrens */
2247da6c28aaSamw /*ARGSUSED*/
2248fa9e4066Sahrens static int
zfs_rmdir(vnode_t * dvp,char * name,vnode_t * cwd,cred_t * cr,caller_context_t * ct,int flags)2249da6c28aaSamw zfs_rmdir(vnode_t *dvp, char *name, vnode_t *cwd, cred_t *cr,
2250da6c28aaSamw caller_context_t *ct, int flags)
2251fa9e4066Sahrens {
2252fa9e4066Sahrens znode_t *dzp = VTOZ(dvp);
2253fa9e4066Sahrens znode_t *zp;
2254fa9e4066Sahrens vnode_t *vp;
2255fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
2256f18faf3fSek110237 zilog_t *zilog;
2257fa9e4066Sahrens zfs_dirlock_t *dl;
2258fa9e4066Sahrens dmu_tx_t *tx;
2259fa9e4066Sahrens int error;
2260da6c28aaSamw int zflg = ZEXISTS;
226169962b56SMatthew Ahrens boolean_t waited = B_FALSE;
2262fa9e4066Sahrens
22633cb34c60Sahrens ZFS_ENTER(zfsvfs);
22643cb34c60Sahrens ZFS_VERIFY_ZP(dzp);
2265f18faf3fSek110237 zilog = zfsvfs->z_log;
2266fa9e4066Sahrens
2267da6c28aaSamw if (flags & FIGNORECASE)
2268da6c28aaSamw zflg |= ZCILOOK;
2269fa9e4066Sahrens top:
2270fa9e4066Sahrens zp = NULL;
2271fa9e4066Sahrens
2272fa9e4066Sahrens /*
2273fa9e4066Sahrens * Attempt to lock directory; fail if entry doesn't exist.
2274fa9e4066Sahrens */
2275da6c28aaSamw if (error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
2276da6c28aaSamw NULL, NULL)) {
2277fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2278fa9e4066Sahrens return (error);
2279fa9e4066Sahrens }
2280fa9e4066Sahrens
2281fa9e4066Sahrens vp = ZTOV(zp);
2282fa9e4066Sahrens
2283fa9e4066Sahrens if (error = zfs_zaccess_delete(dzp, zp, cr)) {
2284fa9e4066Sahrens goto out;
2285fa9e4066Sahrens }
2286fa9e4066Sahrens
2287fa9e4066Sahrens if (vp->v_type != VDIR) {
2288be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTDIR);
2289fa9e4066Sahrens goto out;
2290fa9e4066Sahrens }
2291fa9e4066Sahrens
2292fa9e4066Sahrens if (vp == cwd) {
2293be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL);
2294fa9e4066Sahrens goto out;
2295fa9e4066Sahrens }
2296fa9e4066Sahrens
2297da6c28aaSamw vnevent_rmdir(vp, dvp, name, ct);
2298fa9e4066Sahrens
2299fa9e4066Sahrens /*
2300af2c4821Smaybee * Grab a lock on the directory to make sure that noone is
2301af2c4821Smaybee * trying to add (or lookup) entries while we are removing it.
2302af2c4821Smaybee */
2303af2c4821Smaybee rw_enter(&zp->z_name_lock, RW_WRITER);
2304af2c4821Smaybee
2305af2c4821Smaybee /*
2306af2c4821Smaybee * Grab a lock on the parent pointer to make sure we play well
2307fa9e4066Sahrens * with the treewalk and directory rename code.
2308fa9e4066Sahrens */
2309fa9e4066Sahrens rw_enter(&zp->z_parent_lock, RW_WRITER);
2310fa9e4066Sahrens
2311fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
2312ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
23130a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
2314893a6d32Sahrens dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
23150a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
23160a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, dzp);
231799189164SSimon Klinkert dmu_tx_mark_netfree(tx);
2318f864f99eSPrakash Surya error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
2319fa9e4066Sahrens if (error) {
2320fa9e4066Sahrens rw_exit(&zp->z_parent_lock);
2321af2c4821Smaybee rw_exit(&zp->z_name_lock);
2322fa9e4066Sahrens zfs_dirent_unlock(dl);
2323fa9e4066Sahrens VN_RELE(vp);
23241209a471SNeil Perrin if (error == ERESTART) {
232569962b56SMatthew Ahrens waited = B_TRUE;
23268a2f1b91Sahrens dmu_tx_wait(tx);
23278a2f1b91Sahrens dmu_tx_abort(tx);
2328fa9e4066Sahrens goto top;
2329fa9e4066Sahrens }
23308a2f1b91Sahrens dmu_tx_abort(tx);
2331fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2332fa9e4066Sahrens return (error);
2333fa9e4066Sahrens }
2334fa9e4066Sahrens
2335da6c28aaSamw error = zfs_link_destroy(dl, zp, tx, zflg, NULL);
2336fa9e4066Sahrens
2337da6c28aaSamw if (error == 0) {
2338da6c28aaSamw uint64_t txtype = TX_RMDIR;
2339da6c28aaSamw if (flags & FIGNORECASE)
2340da6c28aaSamw txtype |= TX_CI;
2341d8849d7dSChunwei Chen zfs_log_remove(zilog, tx, txtype, dzp, name, ZFS_NO_OBJECT,
2342d8849d7dSChunwei Chen B_FALSE);
2343da6c28aaSamw }
2344fa9e4066Sahrens
2345fa9e4066Sahrens dmu_tx_commit(tx);
2346fa9e4066Sahrens
2347fa9e4066Sahrens rw_exit(&zp->z_parent_lock);
2348af2c4821Smaybee rw_exit(&zp->z_name_lock);
2349fa9e4066Sahrens out:
2350fa9e4066Sahrens zfs_dirent_unlock(dl);
2351fa9e4066Sahrens
2352fa9e4066Sahrens VN_RELE(vp);
2353fa9e4066Sahrens
235455da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
23555002558fSNeil Perrin zil_commit(zilog, 0);
235655da60b9SMark J Musante
2357fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2358fa9e4066Sahrens return (error);
2359fa9e4066Sahrens }
2360fa9e4066Sahrens
2361fa9e4066Sahrens /*
2362fa9e4066Sahrens * Read as many directory entries as will fit into the provided
2363fa9e4066Sahrens * buffer from the given directory cursor position (specified in
2364f7170741SWill Andrews * the uio structure).
2365fa9e4066Sahrens *
2366fa9e4066Sahrens * IN: vp - vnode of directory to read.
2367fa9e4066Sahrens * uio - structure supplying read location, range info,
2368fa9e4066Sahrens * and return buffer.
2369fa9e4066Sahrens * cr - credentials of caller.
2370da6c28aaSamw * ct - caller context
2371da6c28aaSamw * flags - case flags
2372fa9e4066Sahrens *
2373fa9e4066Sahrens * OUT: uio - updated offset and range, buffer filled.
2374fa9e4066Sahrens * eofp - set to true if end-of-file detected.
2375fa9e4066Sahrens *
2376f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
2377fa9e4066Sahrens *
2378fa9e4066Sahrens * Timestamps:
2379fa9e4066Sahrens * vp - atime updated
2380fa9e4066Sahrens *
2381fa9e4066Sahrens * Note that the low 4 bits of the cookie returned by zap is always zero.
2382fa9e4066Sahrens * This allows us to use the low range for "special" directory entries:
2383fa9e4066Sahrens * We use 0 for '.', and 1 for '..'. If this is the root of the filesystem,
2384fa9e4066Sahrens * we use the offset 2 for the '.zfs' directory.
2385fa9e4066Sahrens */
2386fa9e4066Sahrens /* ARGSUSED */
2387fa9e4066Sahrens static int
zfs_readdir(vnode_t * vp,uio_t * uio,cred_t * cr,int * eofp,caller_context_t * ct,int flags)2388da6c28aaSamw zfs_readdir(vnode_t *vp, uio_t *uio, cred_t *cr, int *eofp,
2389da6c28aaSamw caller_context_t *ct, int flags)
2390fa9e4066Sahrens {
2391fa9e4066Sahrens znode_t *zp = VTOZ(vp);
2392fa9e4066Sahrens iovec_t *iovp;
2393da6c28aaSamw edirent_t *eodp;
2394fa9e4066Sahrens dirent64_t *odp;
2395fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
23967f6e3e7dSperrin objset_t *os;
2397fa9e4066Sahrens caddr_t outbuf;
2398fa9e4066Sahrens size_t bufsize;
2399fa9e4066Sahrens zap_cursor_t zc;
2400fa9e4066Sahrens zap_attribute_t zap;
2401fa9e4066Sahrens uint_t bytes_wanted;
2402fa9e4066Sahrens uint64_t offset; /* must be unsigned; checks for < 1 */
24030a586ceaSMark Shellenbaum uint64_t parent;
2404fa9e4066Sahrens int local_eof;
24057f6e3e7dSperrin int outcount;
24067f6e3e7dSperrin int error;
24077f6e3e7dSperrin uint8_t prefetch;
2408b38f0970Sck153898 boolean_t check_sysattrs;
2409fa9e4066Sahrens
24103cb34c60Sahrens ZFS_ENTER(zfsvfs);
24113cb34c60Sahrens ZFS_VERIFY_ZP(zp);
2412fa9e4066Sahrens
24130a586ceaSMark Shellenbaum if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
24140a586ceaSMark Shellenbaum &parent, sizeof (parent))) != 0) {
24150a586ceaSMark Shellenbaum ZFS_EXIT(zfsvfs);
24160a586ceaSMark Shellenbaum return (error);
24170a586ceaSMark Shellenbaum }
24180a586ceaSMark Shellenbaum
2419fa9e4066Sahrens /*
2420fa9e4066Sahrens * If we are not given an eof variable,
2421fa9e4066Sahrens * use a local one.
2422fa9e4066Sahrens */
2423fa9e4066Sahrens if (eofp == NULL)
2424fa9e4066Sahrens eofp = &local_eof;
2425fa9e4066Sahrens
2426fa9e4066Sahrens /*
2427fa9e4066Sahrens * Check for valid iov_len.
2428fa9e4066Sahrens */
2429fa9e4066Sahrens if (uio->uio_iov->iov_len <= 0) {
2430fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2431be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
2432fa9e4066Sahrens }
2433fa9e4066Sahrens
2434fa9e4066Sahrens /*
2435fa9e4066Sahrens * Quit if directory has been removed (posix)
2436fa9e4066Sahrens */
2437893a6d32Sahrens if ((*eofp = zp->z_unlinked) != 0) {
2438fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2439fa9e4066Sahrens return (0);
2440fa9e4066Sahrens }
2441fa9e4066Sahrens
24427f6e3e7dSperrin error = 0;
24437f6e3e7dSperrin os = zfsvfs->z_os;
24447f6e3e7dSperrin offset = uio->uio_loffset;
24457f6e3e7dSperrin prefetch = zp->z_zn_prefetch;
24467f6e3e7dSperrin
2447fa9e4066Sahrens /*
2448fa9e4066Sahrens * Initialize the iterator cursor.
2449fa9e4066Sahrens */
2450fa9e4066Sahrens if (offset <= 3) {
2451fa9e4066Sahrens /*
2452fa9e4066Sahrens * Start iteration from the beginning of the directory.
2453fa9e4066Sahrens */
24547f6e3e7dSperrin zap_cursor_init(&zc, os, zp->z_id);
2455fa9e4066Sahrens } else {
2456fa9e4066Sahrens /*
2457fa9e4066Sahrens * The offset is a serialized cursor.
2458fa9e4066Sahrens */
24597f6e3e7dSperrin zap_cursor_init_serialized(&zc, os, zp->z_id, offset);
2460fa9e4066Sahrens }
2461fa9e4066Sahrens
2462fa9e4066Sahrens /*
2463fa9e4066Sahrens * Get space to change directory entries into fs independent format.
2464fa9e4066Sahrens */
2465fa9e4066Sahrens iovp = uio->uio_iov;
2466fa9e4066Sahrens bytes_wanted = iovp->iov_len;
2467fa9e4066Sahrens if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) {
2468fa9e4066Sahrens bufsize = bytes_wanted;
2469fa9e4066Sahrens outbuf = kmem_alloc(bufsize, KM_SLEEP);
2470fa9e4066Sahrens odp = (struct dirent64 *)outbuf;
2471fa9e4066Sahrens } else {
2472fa9e4066Sahrens bufsize = bytes_wanted;
2473d5285caeSGeorge Wilson outbuf = NULL;
2474fa9e4066Sahrens odp = (struct dirent64 *)iovp->iov_base;
2475fa9e4066Sahrens }
2476da6c28aaSamw eodp = (struct edirent *)odp;
2477fa9e4066Sahrens
2478fa9e4066Sahrens /*
24799660e5cbSJanice Chang * If this VFS supports the system attribute view interface; and
24809660e5cbSJanice Chang * we're looking at an extended attribute directory; and we care
24819660e5cbSJanice Chang * about normalization conflicts on this vfs; then we must check
24829660e5cbSJanice Chang * for normalization conflicts with the sysattr name space.
2483b38f0970Sck153898 */
24849660e5cbSJanice Chang check_sysattrs = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) &&
2485b38f0970Sck153898 (vp->v_flag & V_XATTRDIR) && zfsvfs->z_norm &&
2486b38f0970Sck153898 (flags & V_RDDIR_ENTFLAGS);
2487b38f0970Sck153898
2488b38f0970Sck153898 /*
2489fa9e4066Sahrens * Transform to file-system independent format
2490fa9e4066Sahrens */
2491fa9e4066Sahrens outcount = 0;
2492fa9e4066Sahrens while (outcount < bytes_wanted) {
2493b1b8ab34Slling ino64_t objnum;
2494b1b8ab34Slling ushort_t reclen;
249597f85387STim Haley off64_t *next = NULL;
2496b1b8ab34Slling
2497fa9e4066Sahrens /*
2498fa9e4066Sahrens * Special case `.', `..', and `.zfs'.
2499fa9e4066Sahrens */
2500fa9e4066Sahrens if (offset == 0) {
2501fa9e4066Sahrens (void) strcpy(zap.za_name, ".");
2502da6c28aaSamw zap.za_normalization_conflict = 0;
2503b1b8ab34Slling objnum = zp->z_id;
2504fa9e4066Sahrens } else if (offset == 1) {
2505fa9e4066Sahrens (void) strcpy(zap.za_name, "..");
2506da6c28aaSamw zap.za_normalization_conflict = 0;
25070a586ceaSMark Shellenbaum objnum = parent;
2508fa9e4066Sahrens } else if (offset == 2 && zfs_show_ctldir(zp)) {
2509fa9e4066Sahrens (void) strcpy(zap.za_name, ZFS_CTLDIR_NAME);
2510da6c28aaSamw zap.za_normalization_conflict = 0;
2511b1b8ab34Slling objnum = ZFSCTL_INO_ROOT;
2512fa9e4066Sahrens } else {
2513fa9e4066Sahrens /*
2514fa9e4066Sahrens * Grab next entry.
2515fa9e4066Sahrens */
2516fa9e4066Sahrens if (error = zap_cursor_retrieve(&zc, &zap)) {
2517fa9e4066Sahrens if ((*eofp = (error == ENOENT)) != 0)
2518fa9e4066Sahrens break;
2519fa9e4066Sahrens else
2520fa9e4066Sahrens goto update;
2521fa9e4066Sahrens }
2522fa9e4066Sahrens
2523fa9e4066Sahrens if (zap.za_integer_length != 8 ||
2524fa9e4066Sahrens zap.za_num_integers != 1) {
2525fa9e4066Sahrens cmn_err(CE_WARN, "zap_readdir: bad directory "
2526fa9e4066Sahrens "entry, obj = %lld, offset = %lld\n",
2527fa9e4066Sahrens (u_longlong_t)zp->z_id,
2528fa9e4066Sahrens (u_longlong_t)offset);
2529be6fd75aSMatthew Ahrens error = SET_ERROR(ENXIO);
2530fa9e4066Sahrens goto update;
2531fa9e4066Sahrens }
2532b1b8ab34Slling
2533b1b8ab34Slling objnum = ZFS_DIRENT_OBJ(zap.za_first_integer);
2534b1b8ab34Slling /*
2535b1b8ab34Slling * MacOS X can extract the object type here such as:
2536b1b8ab34Slling * uint8_t type = ZFS_DIRENT_TYPE(zap.za_first_integer);
2537b1b8ab34Slling */
2538b38f0970Sck153898
2539b38f0970Sck153898 if (check_sysattrs && !zap.za_normalization_conflict) {
2540b38f0970Sck153898 zap.za_normalization_conflict =
2541b38f0970Sck153898 xattr_sysattr_casechk(zap.za_name);
2542b38f0970Sck153898 }
2543fa9e4066Sahrens }
2544da6c28aaSamw
2545e802abbdSTim Haley if (flags & V_RDDIR_ACCFILTER) {
2546e802abbdSTim Haley /*
2547e802abbdSTim Haley * If we have no access at all, don't include
2548e802abbdSTim Haley * this entry in the returned information
2549e802abbdSTim Haley */
2550e802abbdSTim Haley znode_t *ezp;
2551e802abbdSTim Haley if (zfs_zget(zp->z_zfsvfs, objnum, &ezp) != 0)
2552e802abbdSTim Haley goto skip_entry;
2553e802abbdSTim Haley if (!zfs_has_access(ezp, cr)) {
2554e802abbdSTim Haley VN_RELE(ZTOV(ezp));
2555e802abbdSTim Haley goto skip_entry;
2556e802abbdSTim Haley }
2557e802abbdSTim Haley VN_RELE(ZTOV(ezp));
2558e802abbdSTim Haley }
2559e802abbdSTim Haley
2560da6c28aaSamw if (flags & V_RDDIR_ENTFLAGS)
2561da6c28aaSamw reclen = EDIRENT_RECLEN(strlen(zap.za_name));
2562da6c28aaSamw else
2563b1b8ab34Slling reclen = DIRENT64_RECLEN(strlen(zap.za_name));
2564fa9e4066Sahrens
2565fa9e4066Sahrens /*
2566fa9e4066Sahrens * Will this entry fit in the buffer?
2567fa9e4066Sahrens */
2568b1b8ab34Slling if (outcount + reclen > bufsize) {
2569fa9e4066Sahrens /*
2570fa9e4066Sahrens * Did we manage to fit anything in the buffer?
2571fa9e4066Sahrens */
2572fa9e4066Sahrens if (!outcount) {
2573be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL);
2574fa9e4066Sahrens goto update;
2575fa9e4066Sahrens }
2576fa9e4066Sahrens break;
2577fa9e4066Sahrens }
2578da6c28aaSamw if (flags & V_RDDIR_ENTFLAGS) {
2579fa9e4066Sahrens /*
2580da6c28aaSamw * Add extended flag entry:
2581da6c28aaSamw */
2582da6c28aaSamw eodp->ed_ino = objnum;
2583da6c28aaSamw eodp->ed_reclen = reclen;
2584da6c28aaSamw /* NOTE: ed_off is the offset for the *next* entry */
2585da6c28aaSamw next = &(eodp->ed_off);
2586da6c28aaSamw eodp->ed_eflags = zap.za_normalization_conflict ?
2587da6c28aaSamw ED_CASE_CONFLICT : 0;
2588da6c28aaSamw (void) strncpy(eodp->ed_name, zap.za_name,
2589da6c28aaSamw EDIRENT_NAMELEN(reclen));
2590da6c28aaSamw eodp = (edirent_t *)((intptr_t)eodp + reclen);
2591da6c28aaSamw } else {
2592da6c28aaSamw /*
2593da6c28aaSamw * Add normal entry:
2594fa9e4066Sahrens */
2595b1b8ab34Slling odp->d_ino = objnum;
2596b1b8ab34Slling odp->d_reclen = reclen;
2597fa9e4066Sahrens /* NOTE: d_off is the offset for the *next* entry */
2598fa9e4066Sahrens next = &(odp->d_off);
2599fa9e4066Sahrens (void) strncpy(odp->d_name, zap.za_name,
2600b1b8ab34Slling DIRENT64_NAMELEN(reclen));
2601b1b8ab34Slling odp = (dirent64_t *)((intptr_t)odp + reclen);
2602da6c28aaSamw }
2603da6c28aaSamw outcount += reclen;
2604fa9e4066Sahrens
2605fa9e4066Sahrens ASSERT(outcount <= bufsize);
2606fa9e4066Sahrens
2607fa9e4066Sahrens /* Prefetch znode */
26087f6e3e7dSperrin if (prefetch)
2609a2cdcdd2SPaul Dagnelie dmu_prefetch(os, objnum, 0, 0, 0,
2610a2cdcdd2SPaul Dagnelie ZIO_PRIORITY_SYNC_READ);
2611fa9e4066Sahrens
2612e802abbdSTim Haley skip_entry:
2613fa9e4066Sahrens /*
2614fa9e4066Sahrens * Move to the next entry, fill in the previous offset.
2615fa9e4066Sahrens */
2616fa9e4066Sahrens if (offset > 2 || (offset == 2 && !zfs_show_ctldir(zp))) {
2617fa9e4066Sahrens zap_cursor_advance(&zc);
2618fa9e4066Sahrens offset = zap_cursor_serialize(&zc);
2619fa9e4066Sahrens } else {
2620fa9e4066Sahrens offset += 1;
2621fa9e4066Sahrens }
262297f85387STim Haley if (next)
2623fa9e4066Sahrens *next = offset;
2624fa9e4066Sahrens }
26257f6e3e7dSperrin zp->z_zn_prefetch = B_FALSE; /* a lookup will re-enable pre-fetching */
2626fa9e4066Sahrens
2627fa9e4066Sahrens if (uio->uio_segflg == UIO_SYSSPACE && uio->uio_iovcnt == 1) {
2628fa9e4066Sahrens iovp->iov_base += outcount;
2629fa9e4066Sahrens iovp->iov_len -= outcount;
2630fa9e4066Sahrens uio->uio_resid -= outcount;
2631fa9e4066Sahrens } else if (error = uiomove(outbuf, (long)outcount, UIO_READ, uio)) {
2632fa9e4066Sahrens /*
2633fa9e4066Sahrens * Reset the pointer.
2634fa9e4066Sahrens */
2635fa9e4066Sahrens offset = uio->uio_loffset;
2636fa9e4066Sahrens }
2637fa9e4066Sahrens
2638fa9e4066Sahrens update:
263987e5029aSahrens zap_cursor_fini(&zc);
2640fa9e4066Sahrens if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
2641fa9e4066Sahrens kmem_free(outbuf, bufsize);
2642fa9e4066Sahrens
2643fa9e4066Sahrens if (error == ENOENT)
2644fa9e4066Sahrens error = 0;
2645fa9e4066Sahrens
2646fa9e4066Sahrens ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
2647fa9e4066Sahrens
2648fa9e4066Sahrens uio->uio_loffset = offset;
2649fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2650fa9e4066Sahrens return (error);
2651fa9e4066Sahrens }
2652fa9e4066Sahrens
2653ec533521Sfr157268 ulong_t zfs_fsync_sync_cnt = 4;
2654ec533521Sfr157268
2655fa9e4066Sahrens static int
zfs_fsync(vnode_t * vp,int syncflag,cred_t * cr,caller_context_t * ct)2656da6c28aaSamw zfs_fsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct)
2657fa9e4066Sahrens {
2658fa9e4066Sahrens znode_t *zp = VTOZ(vp);
2659fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
2660fa9e4066Sahrens
2661b468a217Seschrock /*
2662b468a217Seschrock * Regardless of whether this is required for standards conformance,
2663b468a217Seschrock * this is the logical behavior when fsync() is called on a file with
2664b468a217Seschrock * dirty pages. We use B_ASYNC since the ZIL transactions are already
2665b468a217Seschrock * going to be pushed out as part of the zil_commit().
2666b468a217Seschrock */
2667b468a217Seschrock if (vn_has_cached_data(vp) && !(syncflag & FNODSYNC) &&
2668b468a217Seschrock (vp->v_type == VREG) && !(IS_SWAPVP(vp)))
2669da6c28aaSamw (void) VOP_PUTPAGE(vp, (offset_t)0, (size_t)0, B_ASYNC, cr, ct);
2670b468a217Seschrock
2671ec533521Sfr157268 (void) tsd_set(zfs_fsyncer_key, (void *)zfs_fsync_sync_cnt);
2672ec533521Sfr157268
267355da60b9SMark J Musante if (zfsvfs->z_os->os_sync != ZFS_SYNC_DISABLED) {
26743cb34c60Sahrens ZFS_ENTER(zfsvfs);
26753cb34c60Sahrens ZFS_VERIFY_ZP(zp);
26765002558fSNeil Perrin zil_commit(zfsvfs->z_log, zp->z_id);
2677fa9e4066Sahrens ZFS_EXIT(zfsvfs);
267855da60b9SMark J Musante }
2679fa9e4066Sahrens return (0);
2680fa9e4066Sahrens }
2681fa9e4066Sahrens
2682da6c28aaSamw
2683fa9e4066Sahrens /*
2684fa9e4066Sahrens * Get the requested file attributes and place them in the provided
2685fa9e4066Sahrens * vattr structure.
2686fa9e4066Sahrens *
2687fa9e4066Sahrens * IN: vp - vnode of file.
2688fa9e4066Sahrens * vap - va_mask identifies requested attributes.
2689da6c28aaSamw * If AT_XVATTR set, then optional attrs are requested
2690da6c28aaSamw * flags - ATTR_NOACLCHECK (CIFS server context)
2691fa9e4066Sahrens * cr - credentials of caller.
2692da6c28aaSamw * ct - caller context
2693fa9e4066Sahrens *
2694fa9e4066Sahrens * OUT: vap - attribute values.
2695fa9e4066Sahrens *
2696f7170741SWill Andrews * RETURN: 0 (always succeeds).
2697fa9e4066Sahrens */
2698fa9e4066Sahrens /* ARGSUSED */
2699fa9e4066Sahrens static int
zfs_getattr(vnode_t * vp,vattr_t * vap,int flags,cred_t * cr,caller_context_t * ct)2700da6c28aaSamw zfs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
2701da6c28aaSamw caller_context_t *ct)
2702fa9e4066Sahrens {
2703fa9e4066Sahrens znode_t *zp = VTOZ(vp);
2704fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
2705da6c28aaSamw int error = 0;
2706ecd6cf80Smarks uint64_t links;
27070a586ceaSMark Shellenbaum uint64_t mtime[2], ctime[2];
2708da6c28aaSamw xvattr_t *xvap = (xvattr_t *)vap; /* vap may be an xvattr_t * */
2709da6c28aaSamw xoptattr_t *xoap = NULL;
2710da6c28aaSamw boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
27110a586ceaSMark Shellenbaum sa_bulk_attr_t bulk[2];
27120a586ceaSMark Shellenbaum int count = 0;
2713fa9e4066Sahrens
27143cb34c60Sahrens ZFS_ENTER(zfsvfs);
27153cb34c60Sahrens ZFS_VERIFY_ZP(zp);
27160a586ceaSMark Shellenbaum
2717f1696b23SMark Shellenbaum zfs_fuid_map_ids(zp, cr, &vap->va_uid, &vap->va_gid);
2718f1696b23SMark Shellenbaum
27190a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
27200a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);
27210a586ceaSMark Shellenbaum
27220a586ceaSMark Shellenbaum if ((error = sa_bulk_lookup(zp->z_sa_hdl, bulk, count)) != 0) {
27230a586ceaSMark Shellenbaum ZFS_EXIT(zfsvfs);
27240a586ceaSMark Shellenbaum return (error);
27250a586ceaSMark Shellenbaum }
2726fa9e4066Sahrens
2727da6c28aaSamw /*
2728da6c28aaSamw * If ACL is trivial don't bother looking for ACE_READ_ATTRIBUTES.
2729da6c28aaSamw * Also, if we are the owner don't bother, since owner should
2730da6c28aaSamw * always be allowed to read basic attributes of file.
2731da6c28aaSamw */
2732f1696b23SMark Shellenbaum if (!(zp->z_pflags & ZFS_ACL_TRIVIAL) &&
2733f1696b23SMark Shellenbaum (vap->va_uid != crgetuid(cr))) {
2734da6c28aaSamw if (error = zfs_zaccess(zp, ACE_READ_ATTRIBUTES, 0,
2735da6c28aaSamw skipaclchk, cr)) {
2736da6c28aaSamw ZFS_EXIT(zfsvfs);
2737da6c28aaSamw return (error);
2738da6c28aaSamw }
2739da6c28aaSamw }
2740da6c28aaSamw
2741fa9e4066Sahrens /*
2742fa9e4066Sahrens * Return all attributes. It's cheaper to provide the answer
2743fa9e4066Sahrens * than to determine whether we were asked the question.
2744fa9e4066Sahrens */
2745fa9e4066Sahrens
274634f345efSRay Hassan mutex_enter(&zp->z_lock);
2747fa9e4066Sahrens vap->va_type = vp->v_type;
27480a586ceaSMark Shellenbaum vap->va_mode = zp->z_mode & MODEMASK;
2749fa9e4066Sahrens vap->va_fsid = zp->z_zfsvfs->z_vfs->vfs_dev;
2750fa9e4066Sahrens vap->va_nodeid = zp->z_id;
2751ecd6cf80Smarks if ((vp->v_flag & VROOT) && zfs_show_ctldir(zp))
27520a586ceaSMark Shellenbaum links = zp->z_links + 1;
2753ecd6cf80Smarks else
27540a586ceaSMark Shellenbaum links = zp->z_links;
2755ecd6cf80Smarks vap->va_nlink = MIN(links, UINT32_MAX); /* nlink_t limit! */
27560a586ceaSMark Shellenbaum vap->va_size = zp->z_size;
275772fc53bcSmarks vap->va_rdev = vp->v_rdev;
2758fa9e4066Sahrens vap->va_seq = zp->z_seq;
2759fa9e4066Sahrens
2760da6c28aaSamw /*
2761da6c28aaSamw * Add in any requested optional attributes and the create time.
2762da6c28aaSamw * Also set the corresponding bits in the returned attribute bitmap.
2763da6c28aaSamw */
2764da6c28aaSamw if ((xoap = xva_getxoptattr(xvap)) != NULL && zfsvfs->z_use_fuids) {
2765da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) {
2766da6c28aaSamw xoap->xoa_archive =
27670a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_ARCHIVE) != 0);
2768da6c28aaSamw XVA_SET_RTN(xvap, XAT_ARCHIVE);
2769da6c28aaSamw }
2770da6c28aaSamw
2771da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_READONLY)) {
2772da6c28aaSamw xoap->xoa_readonly =
27730a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_READONLY) != 0);
2774da6c28aaSamw XVA_SET_RTN(xvap, XAT_READONLY);
2775da6c28aaSamw }
2776da6c28aaSamw
2777da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) {
2778da6c28aaSamw xoap->xoa_system =
27790a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_SYSTEM) != 0);
2780da6c28aaSamw XVA_SET_RTN(xvap, XAT_SYSTEM);
2781da6c28aaSamw }
2782da6c28aaSamw
2783da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) {
2784da6c28aaSamw xoap->xoa_hidden =
27850a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_HIDDEN) != 0);
2786da6c28aaSamw XVA_SET_RTN(xvap, XAT_HIDDEN);
2787da6c28aaSamw }
2788da6c28aaSamw
2789da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
2790da6c28aaSamw xoap->xoa_nounlink =
27910a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_NOUNLINK) != 0);
2792da6c28aaSamw XVA_SET_RTN(xvap, XAT_NOUNLINK);
2793da6c28aaSamw }
2794da6c28aaSamw
2795da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
2796da6c28aaSamw xoap->xoa_immutable =
27970a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_IMMUTABLE) != 0);
2798da6c28aaSamw XVA_SET_RTN(xvap, XAT_IMMUTABLE);
2799da6c28aaSamw }
2800da6c28aaSamw
2801da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
2802da6c28aaSamw xoap->xoa_appendonly =
28030a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_APPENDONLY) != 0);
2804da6c28aaSamw XVA_SET_RTN(xvap, XAT_APPENDONLY);
2805da6c28aaSamw }
2806da6c28aaSamw
2807da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
2808da6c28aaSamw xoap->xoa_nodump =
28090a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_NODUMP) != 0);
2810da6c28aaSamw XVA_SET_RTN(xvap, XAT_NODUMP);
2811da6c28aaSamw }
2812da6c28aaSamw
2813da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) {
2814da6c28aaSamw xoap->xoa_opaque =
28150a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_OPAQUE) != 0);
2816da6c28aaSamw XVA_SET_RTN(xvap, XAT_OPAQUE);
2817da6c28aaSamw }
2818da6c28aaSamw
2819da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
2820da6c28aaSamw xoap->xoa_av_quarantined =
28210a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_AV_QUARANTINED) != 0);
2822da6c28aaSamw XVA_SET_RTN(xvap, XAT_AV_QUARANTINED);
2823da6c28aaSamw }
2824da6c28aaSamw
2825da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
2826da6c28aaSamw xoap->xoa_av_modified =
28270a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_AV_MODIFIED) != 0);
2828da6c28aaSamw XVA_SET_RTN(xvap, XAT_AV_MODIFIED);
2829da6c28aaSamw }
2830da6c28aaSamw
2831da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) &&
28320a586ceaSMark Shellenbaum vp->v_type == VREG) {
28330a586ceaSMark Shellenbaum zfs_sa_get_scanstamp(zp, xvap);
2834da6c28aaSamw }
2835da6c28aaSamw
2836da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) {
28370a586ceaSMark Shellenbaum uint64_t times[2];
28380a586ceaSMark Shellenbaum
28390a586ceaSMark Shellenbaum (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs),
28400a586ceaSMark Shellenbaum times, sizeof (times));
28410a586ceaSMark Shellenbaum ZFS_TIME_DECODE(&xoap->xoa_createtime, times);
2842da6c28aaSamw XVA_SET_RTN(xvap, XAT_CREATETIME);
2843da6c28aaSamw }
28447a286c47SDai Ngo
28457a286c47SDai Ngo if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
28460a586ceaSMark Shellenbaum xoap->xoa_reparse = ((zp->z_pflags & ZFS_REPARSE) != 0);
28477a286c47SDai Ngo XVA_SET_RTN(xvap, XAT_REPARSE);
28487a286c47SDai Ngo }
284999d5e173STim Haley if (XVA_ISSET_REQ(xvap, XAT_GEN)) {
285099d5e173STim Haley xoap->xoa_generation = zp->z_gen;
285199d5e173STim Haley XVA_SET_RTN(xvap, XAT_GEN);
285299d5e173STim Haley }
2853fd9ee8b5Sjoyce mcintosh
2854fd9ee8b5Sjoyce mcintosh if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) {
2855fd9ee8b5Sjoyce mcintosh xoap->xoa_offline =
2856fd9ee8b5Sjoyce mcintosh ((zp->z_pflags & ZFS_OFFLINE) != 0);
2857fd9ee8b5Sjoyce mcintosh XVA_SET_RTN(xvap, XAT_OFFLINE);
2858fd9ee8b5Sjoyce mcintosh }
2859fd9ee8b5Sjoyce mcintosh
2860fd9ee8b5Sjoyce mcintosh if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) {
2861fd9ee8b5Sjoyce mcintosh xoap->xoa_sparse =
2862fd9ee8b5Sjoyce mcintosh ((zp->z_pflags & ZFS_SPARSE) != 0);
2863fd9ee8b5Sjoyce mcintosh XVA_SET_RTN(xvap, XAT_SPARSE);
2864fd9ee8b5Sjoyce mcintosh }
2865f67950b2SNasf-Fan
2866f67950b2SNasf-Fan if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT)) {
2867f67950b2SNasf-Fan xoap->xoa_projinherit =
2868f67950b2SNasf-Fan ((zp->z_pflags & ZFS_PROJINHERIT) != 0);
2869f67950b2SNasf-Fan XVA_SET_RTN(xvap, XAT_PROJINHERIT);
2870f67950b2SNasf-Fan }
2871f67950b2SNasf-Fan
2872f67950b2SNasf-Fan if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
2873f67950b2SNasf-Fan xoap->xoa_projid = zp->z_projid;
2874f67950b2SNasf-Fan XVA_SET_RTN(xvap, XAT_PROJID);
2875f67950b2SNasf-Fan }
2876da6c28aaSamw }
2877da6c28aaSamw
28780a586ceaSMark Shellenbaum ZFS_TIME_DECODE(&vap->va_atime, zp->z_atime);
28790a586ceaSMark Shellenbaum ZFS_TIME_DECODE(&vap->va_mtime, mtime);
28800a586ceaSMark Shellenbaum ZFS_TIME_DECODE(&vap->va_ctime, ctime);
2881fa9e4066Sahrens
2882fa9e4066Sahrens mutex_exit(&zp->z_lock);
2883fa9e4066Sahrens
28840a586ceaSMark Shellenbaum sa_object_size(zp->z_sa_hdl, &vap->va_blksize, &vap->va_nblocks);
2885fa9e4066Sahrens
2886fa9e4066Sahrens if (zp->z_blksz == 0) {
2887fa9e4066Sahrens /*
2888fa9e4066Sahrens * Block size hasn't been set; suggest maximal I/O transfers.
2889fa9e4066Sahrens */
2890fa9e4066Sahrens vap->va_blksize = zfsvfs->z_max_blksz;
2891fa9e4066Sahrens }
2892fa9e4066Sahrens
2893fa9e4066Sahrens ZFS_EXIT(zfsvfs);
2894fa9e4066Sahrens return (0);
2895fa9e4066Sahrens }
2896fa9e4066Sahrens
2897fa9e4066Sahrens /*
2898f67950b2SNasf-Fan * For the operation of changing file's user/group/project, we need to
2899f67950b2SNasf-Fan * handle not only the main object that is assigned to the file directly,
2900f67950b2SNasf-Fan * but also the ones that are used by the file via hidden xattr directory.
2901f67950b2SNasf-Fan *
2902f67950b2SNasf-Fan * Because the xattr directory may contain many EA entries, it may be
2903f67950b2SNasf-Fan * impossible to change all of them in the same transaction as changing the
2904f67950b2SNasf-Fan * main object's user/group/project attributes. If so, we have to change them
2905f67950b2SNasf-Fan * via other multiple independent transactions one by one. It may be not a good
2906f67950b2SNasf-Fan * solution, but we have no better idea yet.
2907f67950b2SNasf-Fan */
2908f67950b2SNasf-Fan static int
zfs_setattr_dir(znode_t * dzp)2909f67950b2SNasf-Fan zfs_setattr_dir(znode_t *dzp)
2910f67950b2SNasf-Fan {
2911f67950b2SNasf-Fan zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
2912f67950b2SNasf-Fan objset_t *os = zfsvfs->z_os;
2913f67950b2SNasf-Fan zap_cursor_t zc;
2914f67950b2SNasf-Fan zap_attribute_t zap;
2915f67950b2SNasf-Fan zfs_dirlock_t *dl;
2916f67950b2SNasf-Fan znode_t *zp = NULL;
2917f67950b2SNasf-Fan dmu_tx_t *tx = NULL;
2918f67950b2SNasf-Fan sa_bulk_attr_t bulk[4];
29195a120e27STim Chase int count;
2920f67950b2SNasf-Fan int err;
2921f67950b2SNasf-Fan
2922f67950b2SNasf-Fan zap_cursor_init(&zc, os, dzp->z_id);
2923f67950b2SNasf-Fan while ((err = zap_cursor_retrieve(&zc, &zap)) == 0) {
29245a120e27STim Chase count = 0;
2925f67950b2SNasf-Fan if (zap.za_integer_length != 8 || zap.za_num_integers != 1) {
2926f67950b2SNasf-Fan err = ENXIO;
2927f67950b2SNasf-Fan break;
2928f67950b2SNasf-Fan }
2929f67950b2SNasf-Fan
2930f67950b2SNasf-Fan err = zfs_dirent_lock(&dl, dzp, (char *)zap.za_name, &zp,
2931f67950b2SNasf-Fan ZEXISTS, NULL, NULL);
2932f67950b2SNasf-Fan if (err == ENOENT)
2933f67950b2SNasf-Fan goto next;
2934f67950b2SNasf-Fan if (err)
2935f67950b2SNasf-Fan break;
2936f67950b2SNasf-Fan
2937f67950b2SNasf-Fan if (zp->z_uid == dzp->z_uid &&
2938f67950b2SNasf-Fan zp->z_gid == dzp->z_gid &&
2939f67950b2SNasf-Fan zp->z_projid == dzp->z_projid)
2940f67950b2SNasf-Fan goto next;
2941f67950b2SNasf-Fan
2942f67950b2SNasf-Fan tx = dmu_tx_create(os);
2943f67950b2SNasf-Fan if (!(zp->z_pflags & ZFS_PROJID))
2944f67950b2SNasf-Fan dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
2945f67950b2SNasf-Fan else
2946f67950b2SNasf-Fan dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
2947f67950b2SNasf-Fan
2948f67950b2SNasf-Fan err = dmu_tx_assign(tx, TXG_WAIT);
2949f67950b2SNasf-Fan if (err)
2950f67950b2SNasf-Fan break;
2951f67950b2SNasf-Fan
2952f67950b2SNasf-Fan mutex_enter(&dzp->z_lock);
2953f67950b2SNasf-Fan
2954f67950b2SNasf-Fan if (zp->z_uid != dzp->z_uid) {
2955f67950b2SNasf-Fan zp->z_uid = dzp->z_uid;
2956f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
2957f67950b2SNasf-Fan &dzp->z_uid, sizeof (dzp->z_uid));
2958f67950b2SNasf-Fan }
2959f67950b2SNasf-Fan
2960f67950b2SNasf-Fan if (zp->z_gid != dzp->z_gid) {
2961f67950b2SNasf-Fan zp->z_gid = dzp->z_gid;
2962f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL,
2963f67950b2SNasf-Fan &dzp->z_gid, sizeof (dzp->z_gid));
2964f67950b2SNasf-Fan }
2965f67950b2SNasf-Fan
2966f67950b2SNasf-Fan if (zp->z_projid != dzp->z_projid) {
2967f67950b2SNasf-Fan if (!(zp->z_pflags & ZFS_PROJID)) {
2968f67950b2SNasf-Fan zp->z_pflags |= ZFS_PROJID;
2969f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count,
2970f67950b2SNasf-Fan SA_ZPL_FLAGS(zfsvfs), NULL, &zp->z_pflags,
2971f67950b2SNasf-Fan sizeof (zp->z_pflags));
2972f67950b2SNasf-Fan }
2973f67950b2SNasf-Fan
2974f67950b2SNasf-Fan zp->z_projid = dzp->z_projid;
2975f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PROJID(zfsvfs),
2976f67950b2SNasf-Fan NULL, &zp->z_projid, sizeof (zp->z_projid));
2977f67950b2SNasf-Fan }
2978f67950b2SNasf-Fan
2979f67950b2SNasf-Fan mutex_exit(&dzp->z_lock);
2980f67950b2SNasf-Fan
2981f67950b2SNasf-Fan if (likely(count > 0)) {
2982f67950b2SNasf-Fan err = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
2983f67950b2SNasf-Fan dmu_tx_commit(tx);
2984f67950b2SNasf-Fan } else {
2985f67950b2SNasf-Fan dmu_tx_abort(tx);
2986f67950b2SNasf-Fan }
2987f67950b2SNasf-Fan tx = NULL;
2988f67950b2SNasf-Fan if (err != 0 && err != ENOENT)
2989f67950b2SNasf-Fan break;
2990f67950b2SNasf-Fan
2991f67950b2SNasf-Fan next:
2992f67950b2SNasf-Fan if (zp) {
2993f67950b2SNasf-Fan VN_RELE(ZTOV(zp));
2994f67950b2SNasf-Fan zp = NULL;
2995f67950b2SNasf-Fan zfs_dirent_unlock(dl);
2996f67950b2SNasf-Fan }
2997f67950b2SNasf-Fan zap_cursor_advance(&zc);
2998f67950b2SNasf-Fan }
2999f67950b2SNasf-Fan
3000f67950b2SNasf-Fan if (tx)
3001f67950b2SNasf-Fan dmu_tx_abort(tx);
3002f67950b2SNasf-Fan if (zp) {
3003f67950b2SNasf-Fan VN_RELE(ZTOV(zp));
3004f67950b2SNasf-Fan zfs_dirent_unlock(dl);
3005f67950b2SNasf-Fan }
3006f67950b2SNasf-Fan zap_cursor_fini(&zc);
3007f67950b2SNasf-Fan
3008f67950b2SNasf-Fan return (err == ENOENT ? 0 : err);
3009f67950b2SNasf-Fan }
3010f67950b2SNasf-Fan
3011f67950b2SNasf-Fan /*
3012fa9e4066Sahrens * Set the file attributes to the values contained in the
3013fa9e4066Sahrens * vattr structure.
3014fa9e4066Sahrens *
3015fa9e4066Sahrens * IN: vp - vnode of file to be modified.
3016fa9e4066Sahrens * vap - new attribute values.
3017da6c28aaSamw * If AT_XVATTR set, then optional attrs are being set
3018fa9e4066Sahrens * flags - ATTR_UTIME set if non-default time values provided.
3019da6c28aaSamw * - ATTR_NOACLCHECK (CIFS context only).
3020fa9e4066Sahrens * cr - credentials of caller.
3021da6c28aaSamw * ct - caller context
3022fa9e4066Sahrens *
3023f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
3024fa9e4066Sahrens *
3025fa9e4066Sahrens * Timestamps:
3026fa9e4066Sahrens * vp - ctime updated, mtime updated if size changed.
3027fa9e4066Sahrens */
3028fa9e4066Sahrens /* ARGSUSED */
3029fa9e4066Sahrens static int
zfs_setattr(vnode_t * vp,vattr_t * vap,int flags,cred_t * cr,caller_context_t * ct)3030fa9e4066Sahrens zfs_setattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
3031fa9e4066Sahrens caller_context_t *ct)
3032fa9e4066Sahrens {
3033f18faf3fSek110237 znode_t *zp = VTOZ(vp);
3034fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
3035f67950b2SNasf-Fan objset_t *os = zfsvfs->z_os;
3036f18faf3fSek110237 zilog_t *zilog;
3037fa9e4066Sahrens dmu_tx_t *tx;
3038fa9e4066Sahrens vattr_t oldva;
3039ae4caef8SMark Shellenbaum xvattr_t tmpxvattr;
30405730cc9aSmaybee uint_t mask = vap->va_mask;
3041d5285caeSGeorge Wilson uint_t saved_mask = 0;
3042f92daba9Smarks int trim_mask = 0;
3043fa9e4066Sahrens uint64_t new_mode;
304489459e17SMark Shellenbaum uint64_t new_uid, new_gid;
30450b2a8171SMark Shellenbaum uint64_t xattr_obj;
30460a586ceaSMark Shellenbaum uint64_t mtime[2], ctime[2];
3047f67950b2SNasf-Fan uint64_t projid = ZFS_INVALID_PROJID;
3048d2443e76Smarks znode_t *attrzp;
3049fa9e4066Sahrens int need_policy = FALSE;
3050f67950b2SNasf-Fan int err, err2 = 0;
3051da6c28aaSamw zfs_fuid_info_t *fuidp = NULL;
3052da6c28aaSamw xvattr_t *xvap = (xvattr_t *)vap; /* vap may be an xvattr_t * */
3053da6c28aaSamw xoptattr_t *xoap;
30540b2a8171SMark Shellenbaum zfs_acl_t *aclp;
3055da6c28aaSamw boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
305689459e17SMark Shellenbaum boolean_t fuid_dirtied = B_FALSE;
3057f67950b2SNasf-Fan boolean_t handle_eadir = B_FALSE;
305806799660SGordon Ross boolean_t zp_acl_entered = B_FALSE;
305906799660SGordon Ross boolean_t attr_acl_entered = B_FALSE;
3060f67950b2SNasf-Fan sa_bulk_attr_t bulk[8], xattr_bulk[8];
30610a586ceaSMark Shellenbaum int count = 0, xattr_count = 0;
3062fa9e4066Sahrens
3063fa9e4066Sahrens if (mask == 0)
3064fa9e4066Sahrens return (0);
3065fa9e4066Sahrens
3066fa9e4066Sahrens if (mask & AT_NOSET)
3067be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
3068fa9e4066Sahrens
30693cb34c60Sahrens ZFS_ENTER(zfsvfs);
30703cb34c60Sahrens ZFS_VERIFY_ZP(zp);
3071da6c28aaSamw
3072f67950b2SNasf-Fan /*
3073f67950b2SNasf-Fan * If this is a xvattr_t, then get a pointer to the structure of
3074f67950b2SNasf-Fan * optional attributes. If this is NULL, then we have a vattr_t.
3075f67950b2SNasf-Fan */
3076f67950b2SNasf-Fan xoap = xva_getxoptattr(xvap);
3077f67950b2SNasf-Fan if (xoap != NULL && (mask & AT_XVATTR)) {
3078f67950b2SNasf-Fan if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
3079f67950b2SNasf-Fan if (!dmu_objset_projectquota_enabled(os) ||
3080f67950b2SNasf-Fan (vp->v_type != VREG && vp->v_type != VDIR)) {
3081f67950b2SNasf-Fan ZFS_EXIT(zfsvfs);
3082f67950b2SNasf-Fan return (SET_ERROR(ENOTSUP));
3083f67950b2SNasf-Fan }
3084f67950b2SNasf-Fan
3085f67950b2SNasf-Fan projid = xoap->xoa_projid;
3086f67950b2SNasf-Fan if (unlikely(projid == ZFS_INVALID_PROJID)) {
3087f67950b2SNasf-Fan ZFS_EXIT(zfsvfs);
3088f67950b2SNasf-Fan return (SET_ERROR(EINVAL));
3089f67950b2SNasf-Fan }
3090f67950b2SNasf-Fan
3091f67950b2SNasf-Fan if (projid == zp->z_projid && zp->z_pflags & ZFS_PROJID)
3092f67950b2SNasf-Fan projid = ZFS_INVALID_PROJID;
3093f67950b2SNasf-Fan else
3094f67950b2SNasf-Fan need_policy = TRUE;
3095f67950b2SNasf-Fan }
3096f67950b2SNasf-Fan
3097f67950b2SNasf-Fan if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT) &&
3098f67950b2SNasf-Fan (!dmu_objset_projectquota_enabled(os) ||
3099f67950b2SNasf-Fan (vp->v_type != VREG && vp->v_type != VDIR))) {
3100f67950b2SNasf-Fan ZFS_EXIT(zfsvfs);
3101f67950b2SNasf-Fan return (SET_ERROR(ENOTSUP));
3102f67950b2SNasf-Fan }
3103f67950b2SNasf-Fan }
3104f67950b2SNasf-Fan
3105da6c28aaSamw zilog = zfsvfs->z_log;
3106da6c28aaSamw
3107da6c28aaSamw /*
3108da6c28aaSamw * Make sure that if we have ephemeral uid/gid or xvattr specified
3109da6c28aaSamw * that file system is at proper version level
3110da6c28aaSamw */
3111da6c28aaSamw
3112da6c28aaSamw if (zfsvfs->z_use_fuids == B_FALSE &&
3113da6c28aaSamw (((mask & AT_UID) && IS_EPHEMERAL(vap->va_uid)) ||
3114da6c28aaSamw ((mask & AT_GID) && IS_EPHEMERAL(vap->va_gid)) ||
311502dcba3bStimh (mask & AT_XVATTR))) {
311602dcba3bStimh ZFS_EXIT(zfsvfs);
3117be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
311802dcba3bStimh }
3119da6c28aaSamw
312002dcba3bStimh if (mask & AT_SIZE && vp->v_type == VDIR) {
312102dcba3bStimh ZFS_EXIT(zfsvfs);
3122be6fd75aSMatthew Ahrens return (SET_ERROR(EISDIR));
312302dcba3bStimh }
3124fa9e4066Sahrens
312502dcba3bStimh if (mask & AT_SIZE && vp->v_type != VREG && vp->v_type != VFIFO) {
312602dcba3bStimh ZFS_EXIT(zfsvfs);
3127be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
312802dcba3bStimh }
312984c5a155Smarks
3130ae4caef8SMark Shellenbaum xva_init(&tmpxvattr);
3131ae4caef8SMark Shellenbaum
3132da6c28aaSamw /*
3133da6c28aaSamw * Immutable files can only alter immutable bit and atime
3134da6c28aaSamw */
31350a586ceaSMark Shellenbaum if ((zp->z_pflags & ZFS_IMMUTABLE) &&
3136da6c28aaSamw ((mask & (AT_SIZE|AT_UID|AT_GID|AT_MTIME|AT_MODE)) ||
313702dcba3bStimh ((mask & AT_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) {
313802dcba3bStimh ZFS_EXIT(zfsvfs);
3139be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
314002dcba3bStimh }
3141da6c28aaSamw
31422889ec41SGordon Ross /*
31432889ec41SGordon Ross * Note: ZFS_READONLY is handled in zfs_zaccess_common.
31442889ec41SGordon Ross */
3145fa9e4066Sahrens
314693129341Smarks /*
314793129341Smarks * Verify timestamps doesn't overflow 32 bits.
314893129341Smarks * ZFS can handle large timestamps, but 32bit syscalls can't
314993129341Smarks * handle times greater than 2039. This check should be removed
315093129341Smarks * once large timestamps are fully supported.
315193129341Smarks */
315293129341Smarks if (mask & (AT_ATIME | AT_MTIME)) {
315393129341Smarks if (((mask & AT_ATIME) && TIMESPEC_OVERFLOW(&vap->va_atime)) ||
315493129341Smarks ((mask & AT_MTIME) && TIMESPEC_OVERFLOW(&vap->va_mtime))) {
315593129341Smarks ZFS_EXIT(zfsvfs);
3156be6fd75aSMatthew Ahrens return (SET_ERROR(EOVERFLOW));
315793129341Smarks }
315893129341Smarks }
315993129341Smarks
3160fa9e4066Sahrens top:
3161d2443e76Smarks attrzp = NULL;
31620b2a8171SMark Shellenbaum aclp = NULL;
3163fa9e4066Sahrens
3164d47621a4STim Haley /* Can this be moved to before the top label? */
3165fa9e4066Sahrens if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) {
3166fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3167be6fd75aSMatthew Ahrens return (SET_ERROR(EROFS));
3168fa9e4066Sahrens }
3169fa9e4066Sahrens
3170fa9e4066Sahrens /*
3171fa9e4066Sahrens * First validate permissions
3172fa9e4066Sahrens */
3173fa9e4066Sahrens
3174fa9e4066Sahrens if (mask & AT_SIZE) {
3175da6c28aaSamw err = zfs_zaccess(zp, ACE_WRITE_DATA, 0, skipaclchk, cr);
3176fa9e4066Sahrens if (err) {
3177fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3178fa9e4066Sahrens return (err);
3179fa9e4066Sahrens }
31805730cc9aSmaybee /*
31815730cc9aSmaybee * XXX - Note, we are not providing any open
31825730cc9aSmaybee * mode flags here (like FNDELAY), so we may
31835730cc9aSmaybee * block if there are locks present... this
31845730cc9aSmaybee * should be addressed in openat().
31855730cc9aSmaybee */
3186cdb0ab79Smaybee /* XXX - would it be OK to generate a log record here? */
31875730cc9aSmaybee err = zfs_freesp(zp, vap->va_size, 0, 0, FALSE);
31885730cc9aSmaybee if (err) {
31895730cc9aSmaybee ZFS_EXIT(zfsvfs);
31905730cc9aSmaybee return (err);
31915730cc9aSmaybee }
319272102e74SBryan Cantrill
319372102e74SBryan Cantrill if (vap->va_size == 0)
319472102e74SBryan Cantrill vnevent_truncate(ZTOV(zp), ct);
3195fa9e4066Sahrens }
3196fa9e4066Sahrens
3197da6c28aaSamw if (mask & (AT_ATIME|AT_MTIME) ||
3198da6c28aaSamw ((mask & AT_XVATTR) && (XVA_ISSET_REQ(xvap, XAT_HIDDEN) ||
3199da6c28aaSamw XVA_ISSET_REQ(xvap, XAT_READONLY) ||
3200da6c28aaSamw XVA_ISSET_REQ(xvap, XAT_ARCHIVE) ||
3201fd9ee8b5Sjoyce mcintosh XVA_ISSET_REQ(xvap, XAT_OFFLINE) ||
3202fd9ee8b5Sjoyce mcintosh XVA_ISSET_REQ(xvap, XAT_SPARSE) ||
3203da6c28aaSamw XVA_ISSET_REQ(xvap, XAT_CREATETIME) ||
32040a586ceaSMark Shellenbaum XVA_ISSET_REQ(xvap, XAT_SYSTEM)))) {
3205da6c28aaSamw need_policy = zfs_zaccess(zp, ACE_WRITE_ATTRIBUTES, 0,
3206da6c28aaSamw skipaclchk, cr);
32070a586ceaSMark Shellenbaum }
3208fa9e4066Sahrens
3209fa9e4066Sahrens if (mask & (AT_UID|AT_GID)) {
3210fa9e4066Sahrens int idmask = (mask & (AT_UID|AT_GID));
3211fa9e4066Sahrens int take_owner;
3212fa9e4066Sahrens int take_group;
3213fa9e4066Sahrens
3214fa9e4066Sahrens /*
3215a933bc41Smarks * NOTE: even if a new mode is being set,
3216a933bc41Smarks * we may clear S_ISUID/S_ISGID bits.
3217a933bc41Smarks */
3218a933bc41Smarks
3219a933bc41Smarks if (!(mask & AT_MODE))
32200a586ceaSMark Shellenbaum vap->va_mode = zp->z_mode;
3221a933bc41Smarks
3222a933bc41Smarks /*
3223fa9e4066Sahrens * Take ownership or chgrp to group we are a member of
3224fa9e4066Sahrens */
3225fa9e4066Sahrens
3226fa9e4066Sahrens take_owner = (mask & AT_UID) && (vap->va_uid == crgetuid(cr));
3227da6c28aaSamw take_group = (mask & AT_GID) &&
3228da6c28aaSamw zfs_groupmember(zfsvfs, vap->va_gid, cr);
3229fa9e4066Sahrens
3230fa9e4066Sahrens /*
3231fa9e4066Sahrens * If both AT_UID and AT_GID are set then take_owner and
3232fa9e4066Sahrens * take_group must both be set in order to allow taking
3233fa9e4066Sahrens * ownership.
3234fa9e4066Sahrens *
3235fa9e4066Sahrens * Otherwise, send the check through secpolicy_vnode_setattr()
3236fa9e4066Sahrens *
3237fa9e4066Sahrens */
3238fa9e4066Sahrens
3239fa9e4066Sahrens if (((idmask == (AT_UID|AT_GID)) && take_owner && take_group) ||
3240fa9e4066Sahrens ((idmask == AT_UID) && take_owner) ||
3241fa9e4066Sahrens ((idmask == AT_GID) && take_group)) {
3242da6c28aaSamw if (zfs_zaccess(zp, ACE_WRITE_OWNER, 0,
3243da6c28aaSamw skipaclchk, cr) == 0) {
3244fa9e4066Sahrens /*
3245fa9e4066Sahrens * Remove setuid/setgid for non-privileged users
3246fa9e4066Sahrens */
324713f9f30eSmarks secpolicy_setid_clear(vap, cr);
3248f92daba9Smarks trim_mask = (mask & (AT_UID|AT_GID));
3249fa9e4066Sahrens } else {
3250fa9e4066Sahrens need_policy = TRUE;
3251fa9e4066Sahrens }
3252fa9e4066Sahrens } else {
3253fa9e4066Sahrens need_policy = TRUE;
3254fa9e4066Sahrens }
3255fa9e4066Sahrens }
3256fa9e4066Sahrens
3257fa9e4066Sahrens mutex_enter(&zp->z_lock);
32580a586ceaSMark Shellenbaum oldva.va_mode = zp->z_mode;
3259f1696b23SMark Shellenbaum zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid);
3260da6c28aaSamw if (mask & AT_XVATTR) {
3261ae4caef8SMark Shellenbaum /*
3262ae4caef8SMark Shellenbaum * Update xvattr mask to include only those attributes
3263ae4caef8SMark Shellenbaum * that are actually changing.
3264ae4caef8SMark Shellenbaum *
3265ae4caef8SMark Shellenbaum * the bits will be restored prior to actually setting
3266ae4caef8SMark Shellenbaum * the attributes so the caller thinks they were set.
3267ae4caef8SMark Shellenbaum */
3268ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
3269ae4caef8SMark Shellenbaum if (xoap->xoa_appendonly !=
32700a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_APPENDONLY) != 0)) {
3271ae4caef8SMark Shellenbaum need_policy = TRUE;
3272ae4caef8SMark Shellenbaum } else {
3273ae4caef8SMark Shellenbaum XVA_CLR_REQ(xvap, XAT_APPENDONLY);
3274ae4caef8SMark Shellenbaum XVA_SET_REQ(&tmpxvattr, XAT_APPENDONLY);
3275ae4caef8SMark Shellenbaum }
3276ae4caef8SMark Shellenbaum }
3277ae4caef8SMark Shellenbaum
3278f67950b2SNasf-Fan if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT)) {
3279f67950b2SNasf-Fan if (xoap->xoa_projinherit !=
3280f67950b2SNasf-Fan ((zp->z_pflags & ZFS_PROJINHERIT) != 0)) {
3281f67950b2SNasf-Fan need_policy = TRUE;
3282f67950b2SNasf-Fan } else {
3283f67950b2SNasf-Fan XVA_CLR_REQ(xvap, XAT_PROJINHERIT);
3284f67950b2SNasf-Fan XVA_SET_REQ(&tmpxvattr, XAT_PROJINHERIT);
3285f67950b2SNasf-Fan }
3286f67950b2SNasf-Fan }
3287f67950b2SNasf-Fan
3288ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
3289ae4caef8SMark Shellenbaum if (xoap->xoa_nounlink !=
32900a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_NOUNLINK) != 0)) {
3291ae4caef8SMark Shellenbaum need_policy = TRUE;
3292ae4caef8SMark Shellenbaum } else {
3293ae4caef8SMark Shellenbaum XVA_CLR_REQ(xvap, XAT_NOUNLINK);
3294ae4caef8SMark Shellenbaum XVA_SET_REQ(&tmpxvattr, XAT_NOUNLINK);
3295ae4caef8SMark Shellenbaum }
3296ae4caef8SMark Shellenbaum }
3297ae4caef8SMark Shellenbaum
3298ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
3299ae4caef8SMark Shellenbaum if (xoap->xoa_immutable !=
33000a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_IMMUTABLE) != 0)) {
3301ae4caef8SMark Shellenbaum need_policy = TRUE;
3302ae4caef8SMark Shellenbaum } else {
3303ae4caef8SMark Shellenbaum XVA_CLR_REQ(xvap, XAT_IMMUTABLE);
3304ae4caef8SMark Shellenbaum XVA_SET_REQ(&tmpxvattr, XAT_IMMUTABLE);
3305ae4caef8SMark Shellenbaum }
3306ae4caef8SMark Shellenbaum }
3307ae4caef8SMark Shellenbaum
3308ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
3309ae4caef8SMark Shellenbaum if (xoap->xoa_nodump !=
33100a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_NODUMP) != 0)) {
3311ae4caef8SMark Shellenbaum need_policy = TRUE;
3312ae4caef8SMark Shellenbaum } else {
3313ae4caef8SMark Shellenbaum XVA_CLR_REQ(xvap, XAT_NODUMP);
3314ae4caef8SMark Shellenbaum XVA_SET_REQ(&tmpxvattr, XAT_NODUMP);
3315ae4caef8SMark Shellenbaum }
3316ae4caef8SMark Shellenbaum }
3317ae4caef8SMark Shellenbaum
3318ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
3319ae4caef8SMark Shellenbaum if (xoap->xoa_av_modified !=
33200a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_AV_MODIFIED) != 0)) {
3321ae4caef8SMark Shellenbaum need_policy = TRUE;
3322ae4caef8SMark Shellenbaum } else {
3323ae4caef8SMark Shellenbaum XVA_CLR_REQ(xvap, XAT_AV_MODIFIED);
3324ae4caef8SMark Shellenbaum XVA_SET_REQ(&tmpxvattr, XAT_AV_MODIFIED);
3325ae4caef8SMark Shellenbaum }
3326ae4caef8SMark Shellenbaum }
3327ae4caef8SMark Shellenbaum
3328ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
3329ae4caef8SMark Shellenbaum if ((vp->v_type != VREG &&
3330ae4caef8SMark Shellenbaum xoap->xoa_av_quarantined) ||
3331da6c28aaSamw xoap->xoa_av_quarantined !=
33320a586ceaSMark Shellenbaum ((zp->z_pflags & ZFS_AV_QUARANTINED) != 0)) {
3333ae4caef8SMark Shellenbaum need_policy = TRUE;
3334ae4caef8SMark Shellenbaum } else {
3335ae4caef8SMark Shellenbaum XVA_CLR_REQ(xvap, XAT_AV_QUARANTINED);
3336ae4caef8SMark Shellenbaum XVA_SET_REQ(&tmpxvattr, XAT_AV_QUARANTINED);
3337ae4caef8SMark Shellenbaum }
3338ae4caef8SMark Shellenbaum }
3339ae4caef8SMark Shellenbaum
33407a286c47SDai Ngo if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
33417a286c47SDai Ngo mutex_exit(&zp->z_lock);
33427a286c47SDai Ngo ZFS_EXIT(zfsvfs);
3343be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
33447a286c47SDai Ngo }
33457a286c47SDai Ngo
3346ae4caef8SMark Shellenbaum if (need_policy == FALSE &&
3347ae4caef8SMark Shellenbaum (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) ||
3348ae4caef8SMark Shellenbaum XVA_ISSET_REQ(xvap, XAT_OPAQUE))) {
3349da6c28aaSamw need_policy = TRUE;
3350da6c28aaSamw }
3351da6c28aaSamw }
3352da6c28aaSamw
3353fa9e4066Sahrens mutex_exit(&zp->z_lock);
335413f9f30eSmarks
3355f92daba9Smarks if (mask & AT_MODE) {
3356da6c28aaSamw if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) {
3357f92daba9Smarks err = secpolicy_setid_setsticky_clear(vp, vap,
3358f92daba9Smarks &oldva, cr);
3359f92daba9Smarks if (err) {
3360f92daba9Smarks ZFS_EXIT(zfsvfs);
3361f92daba9Smarks return (err);
3362f92daba9Smarks }
3363f92daba9Smarks trim_mask |= AT_MODE;
3364f92daba9Smarks } else {
3365f92daba9Smarks need_policy = TRUE;
3366f92daba9Smarks }
3367f92daba9Smarks }
3368f92daba9Smarks
3369f92daba9Smarks if (need_policy) {
337013f9f30eSmarks /*
337113f9f30eSmarks * If trim_mask is set then take ownership
3372f92daba9Smarks * has been granted or write_acl is present and user
3373f92daba9Smarks * has the ability to modify mode. In that case remove
3374f92daba9Smarks * UID|GID and or MODE from mask so that
337513f9f30eSmarks * secpolicy_vnode_setattr() doesn't revoke it.
337670561057SGordon Ross * If acl_implicit (implicit owner rights) is false,
337770561057SGordon Ross * tell secpolicy about that via the flags.
337813f9f30eSmarks */
337913f9f30eSmarks
338070561057SGordon Ross if (zfsvfs->z_acl_implicit == B_FALSE)
338170561057SGordon Ross flags |= ATTR_NOIMPLICIT;
3382f92daba9Smarks if (trim_mask) {
3383f92daba9Smarks saved_mask = vap->va_mask;
3384f92daba9Smarks vap->va_mask &= ~trim_mask;
3385f92daba9Smarks }
3386fa9e4066Sahrens err = secpolicy_vnode_setattr(cr, vp, vap, &oldva, flags,
3387da6c28aaSamw (int (*)(void *, int, cred_t *))zfs_zaccess_unix, zp);
3388fa9e4066Sahrens if (err) {
3389fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3390fa9e4066Sahrens return (err);
3391fa9e4066Sahrens }
339213f9f30eSmarks
339313f9f30eSmarks if (trim_mask)
3394f92daba9Smarks vap->va_mask |= saved_mask;
3395fa9e4066Sahrens }
3396fa9e4066Sahrens
3397fa9e4066Sahrens /*
3398fa9e4066Sahrens * secpolicy_vnode_setattr, or take ownership may have
3399fa9e4066Sahrens * changed va_mask
3400fa9e4066Sahrens */
3401fa9e4066Sahrens mask = vap->va_mask;
3402fa9e4066Sahrens
3403f67950b2SNasf-Fan if ((mask & (AT_UID | AT_GID)) || projid != ZFS_INVALID_PROJID) {
3404f67950b2SNasf-Fan handle_eadir = B_TRUE;
34050b2a8171SMark Shellenbaum err = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
34060b2a8171SMark Shellenbaum &xattr_obj, sizeof (xattr_obj));
3407fa9e4066Sahrens
34080b2a8171SMark Shellenbaum if (err == 0 && xattr_obj) {
34090a586ceaSMark Shellenbaum err = zfs_zget(zp->z_zfsvfs, xattr_obj, &attrzp);
341014843421SMatthew Ahrens if (err)
34110a586ceaSMark Shellenbaum goto out2;
3412d2443e76Smarks }
341389459e17SMark Shellenbaum if (mask & AT_UID) {
341489459e17SMark Shellenbaum new_uid = zfs_fuid_create(zfsvfs,
341589459e17SMark Shellenbaum (uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp);
3416f1696b23SMark Shellenbaum if (new_uid != zp->z_uid &&
3417f67950b2SNasf-Fan zfs_id_overquota(zfsvfs, DMU_USERUSED_OBJECT,
3418f67950b2SNasf-Fan new_uid)) {
34190b2a8171SMark Shellenbaum if (attrzp)
34200b2a8171SMark Shellenbaum VN_RELE(ZTOV(attrzp));
3421be6fd75aSMatthew Ahrens err = SET_ERROR(EDQUOT);
34220a586ceaSMark Shellenbaum goto out2;
342389459e17SMark Shellenbaum }
342414843421SMatthew Ahrens }
342514843421SMatthew Ahrens
342689459e17SMark Shellenbaum if (mask & AT_GID) {
342789459e17SMark Shellenbaum new_gid = zfs_fuid_create(zfsvfs, (uint64_t)vap->va_gid,
342889459e17SMark Shellenbaum cr, ZFS_GROUP, &fuidp);
34290a586ceaSMark Shellenbaum if (new_gid != zp->z_gid &&
3430f67950b2SNasf-Fan zfs_id_overquota(zfsvfs, DMU_GROUPUSED_OBJECT,
3431f67950b2SNasf-Fan new_gid)) {
34320b2a8171SMark Shellenbaum if (attrzp)
34330b2a8171SMark Shellenbaum VN_RELE(ZTOV(attrzp));
3434be6fd75aSMatthew Ahrens err = SET_ERROR(EDQUOT);
34350a586ceaSMark Shellenbaum goto out2;
34360a586ceaSMark Shellenbaum }
34370a586ceaSMark Shellenbaum }
3438f67950b2SNasf-Fan
3439f67950b2SNasf-Fan if (projid != ZFS_INVALID_PROJID &&
3440f67950b2SNasf-Fan zfs_id_overquota(zfsvfs, DMU_PROJECTUSED_OBJECT, projid)) {
3441f67950b2SNasf-Fan if (attrzp)
3442f67950b2SNasf-Fan VN_RELE(ZTOV(attrzp));
3443f67950b2SNasf-Fan err = EDQUOT;
3444f67950b2SNasf-Fan goto out2;
34450a586ceaSMark Shellenbaum }
3446f67950b2SNasf-Fan }
3447f67950b2SNasf-Fan tx = dmu_tx_create(os);
34480a586ceaSMark Shellenbaum
34490a586ceaSMark Shellenbaum if (mask & AT_MODE) {
34500a586ceaSMark Shellenbaum uint64_t pmode = zp->z_mode;
34511412a1a2SMark Shellenbaum uint64_t acl_obj;
34520a586ceaSMark Shellenbaum new_mode = (pmode & S_IFMT) | (vap->va_mode & ~S_IFMT);
34530a586ceaSMark Shellenbaum
345471dbfc28SPaul B. Henson if (zp->z_zfsvfs->z_acl_mode == ZFS_ACL_RESTRICTED &&
345571dbfc28SPaul B. Henson !(zp->z_pflags & ZFS_ACL_TRIVIAL)) {
3456be6fd75aSMatthew Ahrens err = SET_ERROR(EPERM);
345771dbfc28SPaul B. Henson goto out;
345871dbfc28SPaul B. Henson }
345971dbfc28SPaul B. Henson
3460a3c49ce1SAlbert Lee if (err = zfs_acl_chmod_setattr(zp, &aclp, new_mode))
3461a3c49ce1SAlbert Lee goto out;
34620a586ceaSMark Shellenbaum
34631412a1a2SMark Shellenbaum mutex_enter(&zp->z_lock);
34641412a1a2SMark Shellenbaum if (!zp->z_is_sa && ((acl_obj = zfs_external_acl(zp)) != 0)) {
34650a586ceaSMark Shellenbaum /*
34660a586ceaSMark Shellenbaum * Are we upgrading ACL from old V0 format
34670a586ceaSMark Shellenbaum * to V1 format?
34680a586ceaSMark Shellenbaum */
34692bd6c4deSMark Shellenbaum if (zfsvfs->z_version >= ZPL_VERSION_FUID &&
34701412a1a2SMark Shellenbaum zfs_znode_acl_version(zp) ==
34710a586ceaSMark Shellenbaum ZFS_ACL_VERSION_INITIAL) {
34721412a1a2SMark Shellenbaum dmu_tx_hold_free(tx, acl_obj, 0,
34730a586ceaSMark Shellenbaum DMU_OBJECT_END);
34740a586ceaSMark Shellenbaum dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
34750a586ceaSMark Shellenbaum 0, aclp->z_acl_bytes);
347689459e17SMark Shellenbaum } else {
34771412a1a2SMark Shellenbaum dmu_tx_hold_write(tx, acl_obj, 0,
34780a586ceaSMark Shellenbaum aclp->z_acl_bytes);
347989459e17SMark Shellenbaum }
34800a586ceaSMark Shellenbaum } else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) {
34810a586ceaSMark Shellenbaum dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
34820a586ceaSMark Shellenbaum 0, aclp->z_acl_bytes);
348389459e17SMark Shellenbaum }
34841412a1a2SMark Shellenbaum mutex_exit(&zp->z_lock);
34850a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
34860a586ceaSMark Shellenbaum } else {
3487f67950b2SNasf-Fan if (((mask & AT_XVATTR) &&
3488f67950b2SNasf-Fan XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) ||
3489f67950b2SNasf-Fan (projid != ZFS_INVALID_PROJID &&
3490f67950b2SNasf-Fan !(zp->z_pflags & ZFS_PROJID)))
34910a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
34920a586ceaSMark Shellenbaum else
34930a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
349489459e17SMark Shellenbaum }
3495d2443e76Smarks
34960a586ceaSMark Shellenbaum if (attrzp) {
34970a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, attrzp->z_sa_hdl, B_FALSE);
34980a586ceaSMark Shellenbaum }
34990a586ceaSMark Shellenbaum
35000a586ceaSMark Shellenbaum fuid_dirtied = zfsvfs->z_fuid_dirty;
35010a586ceaSMark Shellenbaum if (fuid_dirtied)
35020a586ceaSMark Shellenbaum zfs_fuid_txhold(zfsvfs, tx);
35030a586ceaSMark Shellenbaum
35040a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
35050a586ceaSMark Shellenbaum
3506e722410cSMatthew Ahrens err = dmu_tx_assign(tx, TXG_WAIT);
3507e722410cSMatthew Ahrens if (err)
350814843421SMatthew Ahrens goto out;
3509fa9e4066Sahrens
35100a586ceaSMark Shellenbaum count = 0;
3511fa9e4066Sahrens /*
3512fa9e4066Sahrens * Set each attribute requested.
3513fa9e4066Sahrens * We group settings according to the locks they need to acquire.
3514fa9e4066Sahrens *
3515fa9e4066Sahrens * Note: you cannot set ctime directly, although it will be
3516fa9e4066Sahrens * updated as a side-effect of calling this function.
3517fa9e4066Sahrens */
3518fa9e4066Sahrens
3519f67950b2SNasf-Fan if (projid != ZFS_INVALID_PROJID && !(zp->z_pflags & ZFS_PROJID)) {
3520f67950b2SNasf-Fan /*
3521f67950b2SNasf-Fan * For the existing object that is upgraded from old system,
3522f67950b2SNasf-Fan * its on-disk layout has no slot for the project ID attribute.
3523f67950b2SNasf-Fan * But quota accounting logic needs to access related slots by
3524f67950b2SNasf-Fan * offset directly. So we need to adjust old objects' layout
3525f67950b2SNasf-Fan * to make the project ID to some unified and fixed offset.
3526f67950b2SNasf-Fan */
3527f67950b2SNasf-Fan if (attrzp)
3528f67950b2SNasf-Fan err = sa_add_projid(attrzp->z_sa_hdl, tx, projid);
3529f67950b2SNasf-Fan if (err == 0)
3530f67950b2SNasf-Fan err = sa_add_projid(zp->z_sa_hdl, tx, projid);
3531f67950b2SNasf-Fan
3532f67950b2SNasf-Fan if (unlikely(err == EEXIST))
3533f67950b2SNasf-Fan err = 0;
3534f67950b2SNasf-Fan else if (err != 0)
3535f67950b2SNasf-Fan goto out;
3536f67950b2SNasf-Fan else
3537f67950b2SNasf-Fan projid = ZFS_INVALID_PROJID;
3538f67950b2SNasf-Fan }
35391412a1a2SMark Shellenbaum
354006799660SGordon Ross if (mask & (AT_UID|AT_GID|AT_MODE)) {
354106799660SGordon Ross rw_enter(&zp->z_acl_lock, RW_WRITER);
354206799660SGordon Ross zp_acl_entered = B_TRUE;
354306799660SGordon Ross }
3544fa9e4066Sahrens mutex_enter(&zp->z_lock);
3545fa9e4066Sahrens
3546db9986c7SMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
3547db9986c7SMark Shellenbaum &zp->z_pflags, sizeof (zp->z_pflags));
3548db9986c7SMark Shellenbaum
3549db9986c7SMark Shellenbaum if (attrzp) {
355006799660SGordon Ross if (mask & (AT_UID|AT_GID|AT_MODE)) {
355106799660SGordon Ross rw_enter(&attrzp->z_acl_lock, RW_WRITER);
355206799660SGordon Ross attr_acl_entered = B_TRUE;
355306799660SGordon Ross }
35540a586ceaSMark Shellenbaum mutex_enter(&attrzp->z_lock);
3555db9986c7SMark Shellenbaum SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
3556db9986c7SMark Shellenbaum SA_ZPL_FLAGS(zfsvfs), NULL, &attrzp->z_pflags,
3557db9986c7SMark Shellenbaum sizeof (attrzp->z_pflags));
3558f67950b2SNasf-Fan if (projid != ZFS_INVALID_PROJID) {
3559f67950b2SNasf-Fan attrzp->z_projid = projid;
3560f67950b2SNasf-Fan SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
3561f67950b2SNasf-Fan SA_ZPL_PROJID(zfsvfs), NULL, &attrzp->z_projid,
3562f67950b2SNasf-Fan sizeof (attrzp->z_projid));
3563f67950b2SNasf-Fan }
3564db9986c7SMark Shellenbaum }
35650a586ceaSMark Shellenbaum
356627dd1e87SMark Shellenbaum if (mask & (AT_UID|AT_GID)) {
356727dd1e87SMark Shellenbaum
35680a586ceaSMark Shellenbaum if (mask & AT_UID) {
35690a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
35700a586ceaSMark Shellenbaum &new_uid, sizeof (new_uid));
3571f1696b23SMark Shellenbaum zp->z_uid = new_uid;
35720a586ceaSMark Shellenbaum if (attrzp) {
35730a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
35740a586ceaSMark Shellenbaum SA_ZPL_UID(zfsvfs), NULL, &new_uid,
35750a586ceaSMark Shellenbaum sizeof (new_uid));
3576f1696b23SMark Shellenbaum attrzp->z_uid = new_uid;
35770a586ceaSMark Shellenbaum }
35780a586ceaSMark Shellenbaum }
35790a586ceaSMark Shellenbaum
35800a586ceaSMark Shellenbaum if (mask & AT_GID) {
358127dd1e87SMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs),
358227dd1e87SMark Shellenbaum NULL, &new_gid, sizeof (new_gid));
3583f1696b23SMark Shellenbaum zp->z_gid = new_gid;
35840a586ceaSMark Shellenbaum if (attrzp) {
35850a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
35860a586ceaSMark Shellenbaum SA_ZPL_GID(zfsvfs), NULL, &new_gid,
35870a586ceaSMark Shellenbaum sizeof (new_gid));
3588f1696b23SMark Shellenbaum attrzp->z_gid = new_gid;
35890a586ceaSMark Shellenbaum }
35900a586ceaSMark Shellenbaum }
359127dd1e87SMark Shellenbaum if (!(mask & AT_MODE)) {
359227dd1e87SMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs),
359327dd1e87SMark Shellenbaum NULL, &new_mode, sizeof (new_mode));
359427dd1e87SMark Shellenbaum new_mode = zp->z_mode;
359527dd1e87SMark Shellenbaum }
359627dd1e87SMark Shellenbaum err = zfs_acl_chown_setattr(zp);
359727dd1e87SMark Shellenbaum ASSERT(err == 0);
359827dd1e87SMark Shellenbaum if (attrzp) {
359927dd1e87SMark Shellenbaum err = zfs_acl_chown_setattr(attrzp);
360027dd1e87SMark Shellenbaum ASSERT(err == 0);
360127dd1e87SMark Shellenbaum }
360227dd1e87SMark Shellenbaum }
36030a586ceaSMark Shellenbaum
3604fa9e4066Sahrens if (mask & AT_MODE) {
36050a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
36060a586ceaSMark Shellenbaum &new_mode, sizeof (new_mode));
36070a586ceaSMark Shellenbaum zp->z_mode = new_mode;
360827dd1e87SMark Shellenbaum ASSERT3U((uintptr_t)aclp, !=, NULL);
360989459e17SMark Shellenbaum err = zfs_aclset_common(zp, aclp, cr, tx);
3610fb09f5aaSMadhav Suresh ASSERT0(err);
36110b2a8171SMark Shellenbaum if (zp->z_acl_cached)
36120b2a8171SMark Shellenbaum zfs_acl_free(zp->z_acl_cached);
36134929fd5eSTim Haley zp->z_acl_cached = aclp;
36144929fd5eSTim Haley aclp = NULL;
3615fa9e4066Sahrens }
3616fa9e4066Sahrens
3617fa9e4066Sahrens
36180a586ceaSMark Shellenbaum if (mask & AT_ATIME) {
36190a586ceaSMark Shellenbaum ZFS_TIME_ENCODE(&vap->va_atime, zp->z_atime);
36200a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL,
36210a586ceaSMark Shellenbaum &zp->z_atime, sizeof (zp->z_atime));
36220a586ceaSMark Shellenbaum }
3623fa9e4066Sahrens
36240a586ceaSMark Shellenbaum if (mask & AT_MTIME) {
36250a586ceaSMark Shellenbaum ZFS_TIME_ENCODE(&vap->va_mtime, mtime);
36260a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
36270a586ceaSMark Shellenbaum mtime, sizeof (mtime));
36280a586ceaSMark Shellenbaum }
3629fa9e4066Sahrens
3630cdb0ab79Smaybee /* XXX - shouldn't this be done *before* the ATIME/MTIME checks? */
36310a586ceaSMark Shellenbaum if (mask & AT_SIZE && !(mask & AT_MTIME)) {
36320a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs),
36330a586ceaSMark Shellenbaum NULL, mtime, sizeof (mtime));
36340a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
36350a586ceaSMark Shellenbaum &ctime, sizeof (ctime));
36360a586ceaSMark Shellenbaum zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime,
36370a586ceaSMark Shellenbaum B_TRUE);
36380a586ceaSMark Shellenbaum } else if (mask != 0) {
36390a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
36400a586ceaSMark Shellenbaum &ctime, sizeof (ctime));
36410a586ceaSMark Shellenbaum zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime,
36420a586ceaSMark Shellenbaum B_TRUE);
36430a586ceaSMark Shellenbaum if (attrzp) {
36440a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
36450a586ceaSMark Shellenbaum SA_ZPL_CTIME(zfsvfs), NULL,
36460a586ceaSMark Shellenbaum &ctime, sizeof (ctime));
36470a586ceaSMark Shellenbaum zfs_tstamp_update_setup(attrzp, STATE_CHANGED,
36480a586ceaSMark Shellenbaum mtime, ctime, B_TRUE);
36490a586ceaSMark Shellenbaum }
36500a586ceaSMark Shellenbaum }
3651f67950b2SNasf-Fan
3652f67950b2SNasf-Fan if (projid != ZFS_INVALID_PROJID) {
3653f67950b2SNasf-Fan zp->z_projid = projid;
3654f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count,
3655f67950b2SNasf-Fan SA_ZPL_PROJID(zfsvfs), NULL, &zp->z_projid,
3656f67950b2SNasf-Fan sizeof (zp->z_projid));
3657f67950b2SNasf-Fan }
3658f67950b2SNasf-Fan
3659da6c28aaSamw /*
3660da6c28aaSamw * Do this after setting timestamps to prevent timestamp
3661da6c28aaSamw * update from toggling bit
3662da6c28aaSamw */
3663da6c28aaSamw
3664da6c28aaSamw if (xoap && (mask & AT_XVATTR)) {
3665ae4caef8SMark Shellenbaum
3666ae4caef8SMark Shellenbaum /*
3667ae4caef8SMark Shellenbaum * restore trimmed off masks
3668ae4caef8SMark Shellenbaum * so that return masks can be set for caller.
3669ae4caef8SMark Shellenbaum */
3670ae4caef8SMark Shellenbaum
3671ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(&tmpxvattr, XAT_APPENDONLY)) {
3672ae4caef8SMark Shellenbaum XVA_SET_REQ(xvap, XAT_APPENDONLY);
3673ae4caef8SMark Shellenbaum }
3674ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(&tmpxvattr, XAT_NOUNLINK)) {
3675ae4caef8SMark Shellenbaum XVA_SET_REQ(xvap, XAT_NOUNLINK);
3676ae4caef8SMark Shellenbaum }
3677ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(&tmpxvattr, XAT_IMMUTABLE)) {
3678ae4caef8SMark Shellenbaum XVA_SET_REQ(xvap, XAT_IMMUTABLE);
3679ae4caef8SMark Shellenbaum }
3680ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(&tmpxvattr, XAT_NODUMP)) {
3681ae4caef8SMark Shellenbaum XVA_SET_REQ(xvap, XAT_NODUMP);
3682ae4caef8SMark Shellenbaum }
3683ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_MODIFIED)) {
3684ae4caef8SMark Shellenbaum XVA_SET_REQ(xvap, XAT_AV_MODIFIED);
3685ae4caef8SMark Shellenbaum }
3686ae4caef8SMark Shellenbaum if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_QUARANTINED)) {
3687ae4caef8SMark Shellenbaum XVA_SET_REQ(xvap, XAT_AV_QUARANTINED);
3688ae4caef8SMark Shellenbaum }
3689f67950b2SNasf-Fan if (XVA_ISSET_REQ(&tmpxvattr, XAT_PROJINHERIT)) {
3690f67950b2SNasf-Fan XVA_SET_REQ(xvap, XAT_PROJINHERIT);
3691f67950b2SNasf-Fan }
3692ae4caef8SMark Shellenbaum
36930a586ceaSMark Shellenbaum if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP))
3694da6c28aaSamw ASSERT(vp->v_type == VREG);
3695da6c28aaSamw
36960a586ceaSMark Shellenbaum zfs_xvattr_set(zp, xvap, tx);
3697da6c28aaSamw }
3698fa9e4066Sahrens
369989459e17SMark Shellenbaum if (fuid_dirtied)
370089459e17SMark Shellenbaum zfs_fuid_sync(zfsvfs, tx);
370189459e17SMark Shellenbaum
37025730cc9aSmaybee if (mask != 0)
3703da6c28aaSamw zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp);
3704fa9e4066Sahrens
37051412a1a2SMark Shellenbaum if (attrzp) {
370606799660SGordon Ross if (attr_acl_entered)
370706799660SGordon Ross rw_exit(&attrzp->z_acl_lock);
37081412a1a2SMark Shellenbaum mutex_exit(&attrzp->z_lock);
37091412a1a2SMark Shellenbaum }
371006799660SGordon Ross
371106799660SGordon Ross mutex_exit(&zp->z_lock);
371206799660SGordon Ross if (zp_acl_entered)
371306799660SGordon Ross rw_exit(&zp->z_acl_lock);
371414843421SMatthew Ahrens out:
3715f67950b2SNasf-Fan if (err == 0 && xattr_count > 0) {
37160a586ceaSMark Shellenbaum err2 = sa_bulk_update(attrzp->z_sa_hdl, xattr_bulk,
37170a586ceaSMark Shellenbaum xattr_count, tx);
37180a586ceaSMark Shellenbaum ASSERT(err2 == 0);
37190a586ceaSMark Shellenbaum }
37200a586ceaSMark Shellenbaum
37214929fd5eSTim Haley if (aclp)
37224929fd5eSTim Haley zfs_acl_free(aclp);
37234929fd5eSTim Haley
372414843421SMatthew Ahrens if (fuidp) {
372514843421SMatthew Ahrens zfs_fuid_info_free(fuidp);
372614843421SMatthew Ahrens fuidp = NULL;
372714843421SMatthew Ahrens }
372814843421SMatthew Ahrens
37290a586ceaSMark Shellenbaum if (err) {
373014843421SMatthew Ahrens dmu_tx_abort(tx);
3731f67950b2SNasf-Fan if (attrzp)
3732f67950b2SNasf-Fan VN_RELE(ZTOV(attrzp));
373314843421SMatthew Ahrens if (err == ERESTART)
373414843421SMatthew Ahrens goto top;
37350a586ceaSMark Shellenbaum } else {
3736f67950b2SNasf-Fan if (count > 0)
37370a586ceaSMark Shellenbaum err2 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
37380a586ceaSMark Shellenbaum dmu_tx_commit(tx);
3739f67950b2SNasf-Fan if (attrzp) {
3740f67950b2SNasf-Fan if (err2 == 0 && handle_eadir)
3741f67950b2SNasf-Fan err2 = zfs_setattr_dir(attrzp);
3742f67950b2SNasf-Fan VN_RELE(ZTOV(attrzp));
3743f67950b2SNasf-Fan }
37440a586ceaSMark Shellenbaum }
3745fa9e4066Sahrens
37460a586ceaSMark Shellenbaum out2:
3747f67950b2SNasf-Fan if (os->os_sync == ZFS_SYNC_ALWAYS)
37485002558fSNeil Perrin zil_commit(zilog, 0);
374955da60b9SMark J Musante
3750fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3751fa9e4066Sahrens return (err);
3752fa9e4066Sahrens }
3753fa9e4066Sahrens
3754fa9e4066Sahrens typedef struct zfs_zlock {
3755fa9e4066Sahrens krwlock_t *zl_rwlock; /* lock we acquired */
3756fa9e4066Sahrens znode_t *zl_znode; /* znode we held */
3757fa9e4066Sahrens struct zfs_zlock *zl_next; /* next in list */
3758fa9e4066Sahrens } zfs_zlock_t;
3759fa9e4066Sahrens
3760ff008e00Smaybee /*
3761ff008e00Smaybee * Drop locks and release vnodes that were held by zfs_rename_lock().
3762ff008e00Smaybee */
3763ff008e00Smaybee static void
zfs_rename_unlock(zfs_zlock_t ** zlpp)3764ff008e00Smaybee zfs_rename_unlock(zfs_zlock_t **zlpp)
3765ff008e00Smaybee {
3766ff008e00Smaybee zfs_zlock_t *zl;
3767ff008e00Smaybee
3768ff008e00Smaybee while ((zl = *zlpp) != NULL) {
3769ff008e00Smaybee if (zl->zl_znode != NULL)
3770ff008e00Smaybee VN_RELE(ZTOV(zl->zl_znode));
3771ff008e00Smaybee rw_exit(zl->zl_rwlock);
3772ff008e00Smaybee *zlpp = zl->zl_next;
3773ff008e00Smaybee kmem_free(zl, sizeof (*zl));
3774ff008e00Smaybee }
3775ff008e00Smaybee }
3776ff008e00Smaybee
3777ff008e00Smaybee /*
3778ff008e00Smaybee * Search back through the directory tree, using the ".." entries.
3779ff008e00Smaybee * Lock each directory in the chain to prevent concurrent renames.
3780ff008e00Smaybee * Fail any attempt to move a directory into one of its own descendants.
3781ff008e00Smaybee * XXX - z_parent_lock can overlap with map or grow locks
3782ff008e00Smaybee */
3783fa9e4066Sahrens static int
zfs_rename_lock(znode_t * szp,znode_t * tdzp,znode_t * sdzp,zfs_zlock_t ** zlpp)3784fa9e4066Sahrens zfs_rename_lock(znode_t *szp, znode_t *tdzp, znode_t *sdzp, zfs_zlock_t **zlpp)
3785fa9e4066Sahrens {
3786fa9e4066Sahrens zfs_zlock_t *zl;
3787fa9e4066Sahrens znode_t *zp = tdzp;
3788fa9e4066Sahrens uint64_t rootid = zp->z_zfsvfs->z_root;
37890a586ceaSMark Shellenbaum uint64_t oidp = zp->z_id;
3790fa9e4066Sahrens krwlock_t *rwlp = &szp->z_parent_lock;
3791fa9e4066Sahrens krw_t rw = RW_WRITER;
3792fa9e4066Sahrens
3793fa9e4066Sahrens /*
3794fa9e4066Sahrens * First pass write-locks szp and compares to zp->z_id.
3795fa9e4066Sahrens * Later passes read-lock zp and compare to zp->z_parent.
3796fa9e4066Sahrens */
3797fa9e4066Sahrens do {
3798ff008e00Smaybee if (!rw_tryenter(rwlp, rw)) {
3799ff008e00Smaybee /*
3800ff008e00Smaybee * Another thread is renaming in this path.
3801ff008e00Smaybee * Note that if we are a WRITER, we don't have any
3802ff008e00Smaybee * parent_locks held yet.
3803ff008e00Smaybee */
3804ff008e00Smaybee if (rw == RW_READER && zp->z_id > szp->z_id) {
3805ff008e00Smaybee /*
3806ff008e00Smaybee * Drop our locks and restart
3807ff008e00Smaybee */
3808ff008e00Smaybee zfs_rename_unlock(&zl);
3809ff008e00Smaybee *zlpp = NULL;
3810ff008e00Smaybee zp = tdzp;
38110a586ceaSMark Shellenbaum oidp = zp->z_id;
3812ff008e00Smaybee rwlp = &szp->z_parent_lock;
3813ff008e00Smaybee rw = RW_WRITER;
3814ff008e00Smaybee continue;
3815ff008e00Smaybee } else {
3816ff008e00Smaybee /*
3817ff008e00Smaybee * Wait for other thread to drop its locks
3818ff008e00Smaybee */
3819ff008e00Smaybee rw_enter(rwlp, rw);
3820ff008e00Smaybee }
3821ff008e00Smaybee }
3822ff008e00Smaybee
3823fa9e4066Sahrens zl = kmem_alloc(sizeof (*zl), KM_SLEEP);
3824fa9e4066Sahrens zl->zl_rwlock = rwlp;
3825fa9e4066Sahrens zl->zl_znode = NULL;
3826fa9e4066Sahrens zl->zl_next = *zlpp;
3827fa9e4066Sahrens *zlpp = zl;
3828fa9e4066Sahrens
38290a586ceaSMark Shellenbaum if (oidp == szp->z_id) /* We're a descendant of szp */
3830be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
3831fa9e4066Sahrens
38320a586ceaSMark Shellenbaum if (oidp == rootid) /* We've hit the top */
3833fa9e4066Sahrens return (0);
3834fa9e4066Sahrens
3835fa9e4066Sahrens if (rw == RW_READER) { /* i.e. not the first pass */
38360a586ceaSMark Shellenbaum int error = zfs_zget(zp->z_zfsvfs, oidp, &zp);
3837fa9e4066Sahrens if (error)
3838fa9e4066Sahrens return (error);
3839fa9e4066Sahrens zl->zl_znode = zp;
3840fa9e4066Sahrens }
38410a586ceaSMark Shellenbaum (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zp->z_zfsvfs),
38420a586ceaSMark Shellenbaum &oidp, sizeof (oidp));
3843fa9e4066Sahrens rwlp = &zp->z_parent_lock;
3844fa9e4066Sahrens rw = RW_READER;
3845fa9e4066Sahrens
3846fa9e4066Sahrens } while (zp->z_id != sdzp->z_id);
3847fa9e4066Sahrens
3848fa9e4066Sahrens return (0);
3849fa9e4066Sahrens }
3850fa9e4066Sahrens
3851fa9e4066Sahrens /*
3852fa9e4066Sahrens * Move an entry from the provided source directory to the target
3853fa9e4066Sahrens * directory. Change the entry name as indicated.
3854fa9e4066Sahrens *
3855fa9e4066Sahrens * IN: sdvp - Source directory containing the "old entry".
3856fa9e4066Sahrens * snm - Old entry name.
3857fa9e4066Sahrens * tdvp - Target directory to contain the "new entry".
3858fa9e4066Sahrens * tnm - New entry name.
3859fa9e4066Sahrens * cr - credentials of caller.
3860da6c28aaSamw * ct - caller context
3861da6c28aaSamw * flags - case flags
3862fa9e4066Sahrens *
3863f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
3864fa9e4066Sahrens *
3865fa9e4066Sahrens * Timestamps:
3866fa9e4066Sahrens * sdvp,tdvp - ctime|mtime updated
3867fa9e4066Sahrens */
3868da6c28aaSamw /*ARGSUSED*/
3869fa9e4066Sahrens static int
zfs_rename(vnode_t * sdvp,char * snm,vnode_t * tdvp,char * tnm,cred_t * cr,caller_context_t * ct,int flags)3870da6c28aaSamw zfs_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, cred_t *cr,
3871da6c28aaSamw caller_context_t *ct, int flags)
3872fa9e4066Sahrens {
3873fa9e4066Sahrens znode_t *tdzp, *szp, *tzp;
3874fa9e4066Sahrens znode_t *sdzp = VTOZ(sdvp);
3875fa9e4066Sahrens zfsvfs_t *zfsvfs = sdzp->z_zfsvfs;
3876f18faf3fSek110237 zilog_t *zilog;
3877fa9e4066Sahrens vnode_t *realvp;
3878fa9e4066Sahrens zfs_dirlock_t *sdl, *tdl;
3879fa9e4066Sahrens dmu_tx_t *tx;
3880fa9e4066Sahrens zfs_zlock_t *zl;
3881da6c28aaSamw int cmp, serr, terr;
388254207fd2SJerry Jelinek int error = 0, rm_err = 0;
3883da6c28aaSamw int zflg = 0;
388469962b56SMatthew Ahrens boolean_t waited = B_FALSE;
3885fa9e4066Sahrens
38863cb34c60Sahrens ZFS_ENTER(zfsvfs);
38873cb34c60Sahrens ZFS_VERIFY_ZP(sdzp);
3888f18faf3fSek110237 zilog = zfsvfs->z_log;
3889fa9e4066Sahrens
3890fa9e4066Sahrens /*
3891fa9e4066Sahrens * Make sure we have the real vp for the target directory.
3892fa9e4066Sahrens */
3893da6c28aaSamw if (VOP_REALVP(tdvp, &realvp, ct) == 0)
3894fa9e4066Sahrens tdvp = realvp;
3895fa9e4066Sahrens
389618e64978SMarcel Telka tdzp = VTOZ(tdvp);
389718e64978SMarcel Telka ZFS_VERIFY_ZP(tdzp);
389818e64978SMarcel Telka
389918e64978SMarcel Telka /*
390018e64978SMarcel Telka * We check z_zfsvfs rather than v_vfsp here, because snapshots and the
390118e64978SMarcel Telka * ctldir appear to have the same v_vfsp.
390218e64978SMarcel Telka */
390318e64978SMarcel Telka if (tdzp->z_zfsvfs != zfsvfs || zfsctl_is_node(tdvp)) {
3904fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3905be6fd75aSMatthew Ahrens return (SET_ERROR(EXDEV));
3906fa9e4066Sahrens }
3907fa9e4066Sahrens
3908de8267e0Stimh if (zfsvfs->z_utf8 && u8_validate(tnm,
3909da6c28aaSamw strlen(tnm), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
3910da6c28aaSamw ZFS_EXIT(zfsvfs);
3911be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ));
3912da6c28aaSamw }
3913da6c28aaSamw
3914da6c28aaSamw if (flags & FIGNORECASE)
3915da6c28aaSamw zflg |= ZCILOOK;
3916da6c28aaSamw
3917fa9e4066Sahrens top:
3918fa9e4066Sahrens szp = NULL;
3919fa9e4066Sahrens tzp = NULL;
3920fa9e4066Sahrens zl = NULL;
3921fa9e4066Sahrens
3922fa9e4066Sahrens /*
3923fa9e4066Sahrens * This is to prevent the creation of links into attribute space
3924fa9e4066Sahrens * by renaming a linked file into/outof an attribute directory.
3925fa9e4066Sahrens * See the comment in zfs_link() for why this is considered bad.
3926fa9e4066Sahrens */
39270a586ceaSMark Shellenbaum if ((tdzp->z_pflags & ZFS_XATTR) != (sdzp->z_pflags & ZFS_XATTR)) {
3928fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3929be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
3930fa9e4066Sahrens }
3931fa9e4066Sahrens
3932fa9e4066Sahrens /*
3933fa9e4066Sahrens * Lock source and target directory entries. To prevent deadlock,
3934fa9e4066Sahrens * a lock ordering must be defined. We lock the directory with
3935fa9e4066Sahrens * the smallest object id first, or if it's a tie, the one with
3936fa9e4066Sahrens * the lexically first name.
3937fa9e4066Sahrens */
3938fa9e4066Sahrens if (sdzp->z_id < tdzp->z_id) {
3939fa9e4066Sahrens cmp = -1;
3940fa9e4066Sahrens } else if (sdzp->z_id > tdzp->z_id) {
3941fa9e4066Sahrens cmp = 1;
3942fa9e4066Sahrens } else {
3943da6c28aaSamw /*
3944da6c28aaSamw * First compare the two name arguments without
3945da6c28aaSamw * considering any case folding.
3946da6c28aaSamw */
3947da6c28aaSamw int nofold = (zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER);
3948da6c28aaSamw
3949da6c28aaSamw cmp = u8_strcmp(snm, tnm, 0, nofold, U8_UNICODE_LATEST, &error);
3950de8267e0Stimh ASSERT(error == 0 || !zfsvfs->z_utf8);
3951fa9e4066Sahrens if (cmp == 0) {
3952fa9e4066Sahrens /*
3953fa9e4066Sahrens * POSIX: "If the old argument and the new argument
3954fa9e4066Sahrens * both refer to links to the same existing file,
3955fa9e4066Sahrens * the rename() function shall return successfully
3956fa9e4066Sahrens * and perform no other action."
3957fa9e4066Sahrens */
3958fa9e4066Sahrens ZFS_EXIT(zfsvfs);
3959fa9e4066Sahrens return (0);
3960fa9e4066Sahrens }
3961da6c28aaSamw /*
3962da6c28aaSamw * If the file system is case-folding, then we may
3963da6c28aaSamw * have some more checking to do. A case-folding file
3964da6c28aaSamw * system is either supporting mixed case sensitivity
3965da6c28aaSamw * access or is completely case-insensitive. Note
3966da6c28aaSamw * that the file system is always case preserving.
3967da6c28aaSamw *
3968da6c28aaSamw * In mixed sensitivity mode case sensitive behavior
3969da6c28aaSamw * is the default. FIGNORECASE must be used to
3970da6c28aaSamw * explicitly request case insensitive behavior.
3971da6c28aaSamw *
3972da6c28aaSamw * If the source and target names provided differ only
3973da6c28aaSamw * by case (e.g., a request to rename 'tim' to 'Tim'),
3974da6c28aaSamw * we will treat this as a special case in the
3975da6c28aaSamw * case-insensitive mode: as long as the source name
3976da6c28aaSamw * is an exact match, we will allow this to proceed as
3977da6c28aaSamw * a name-change request.
3978da6c28aaSamw */
3979de8267e0Stimh if ((zfsvfs->z_case == ZFS_CASE_INSENSITIVE ||
3980de8267e0Stimh (zfsvfs->z_case == ZFS_CASE_MIXED &&
3981de8267e0Stimh flags & FIGNORECASE)) &&
3982da6c28aaSamw u8_strcmp(snm, tnm, 0, zfsvfs->z_norm, U8_UNICODE_LATEST,
3983da6c28aaSamw &error) == 0) {
3984da6c28aaSamw /*
3985da6c28aaSamw * case preserving rename request, require exact
3986da6c28aaSamw * name matches
3987da6c28aaSamw */
3988da6c28aaSamw zflg |= ZCIEXACT;
3989da6c28aaSamw zflg &= ~ZCILOOK;
3990fa9e4066Sahrens }
3991da6c28aaSamw }
3992da6c28aaSamw
3993afefc7e4SSanjeev Bagewadi /*
3994afefc7e4SSanjeev Bagewadi * If the source and destination directories are the same, we should
3995afefc7e4SSanjeev Bagewadi * grab the z_name_lock of that directory only once.
3996afefc7e4SSanjeev Bagewadi */
3997afefc7e4SSanjeev Bagewadi if (sdzp == tdzp) {
3998afefc7e4SSanjeev Bagewadi zflg |= ZHAVELOCK;
3999afefc7e4SSanjeev Bagewadi rw_enter(&sdzp->z_name_lock, RW_READER);
4000afefc7e4SSanjeev Bagewadi }
4001afefc7e4SSanjeev Bagewadi
4002fa9e4066Sahrens if (cmp < 0) {
4003da6c28aaSamw serr = zfs_dirent_lock(&sdl, sdzp, snm, &szp,
4004da6c28aaSamw ZEXISTS | zflg, NULL, NULL);
4005da6c28aaSamw terr = zfs_dirent_lock(&tdl,
4006da6c28aaSamw tdzp, tnm, &tzp, ZRENAMING | zflg, NULL, NULL);
4007fa9e4066Sahrens } else {
4008da6c28aaSamw terr = zfs_dirent_lock(&tdl,
4009da6c28aaSamw tdzp, tnm, &tzp, zflg, NULL, NULL);
4010da6c28aaSamw serr = zfs_dirent_lock(&sdl,
4011da6c28aaSamw sdzp, snm, &szp, ZEXISTS | ZRENAMING | zflg,
4012da6c28aaSamw NULL, NULL);
4013fa9e4066Sahrens }
4014fa9e4066Sahrens
4015fa9e4066Sahrens if (serr) {
4016fa9e4066Sahrens /*
4017fa9e4066Sahrens * Source entry invalid or not there.
4018fa9e4066Sahrens */
4019fa9e4066Sahrens if (!terr) {
4020fa9e4066Sahrens zfs_dirent_unlock(tdl);
4021fa9e4066Sahrens if (tzp)
4022fa9e4066Sahrens VN_RELE(ZTOV(tzp));
4023fa9e4066Sahrens }
4024afefc7e4SSanjeev Bagewadi
4025afefc7e4SSanjeev Bagewadi if (sdzp == tdzp)
4026afefc7e4SSanjeev Bagewadi rw_exit(&sdzp->z_name_lock);
4027afefc7e4SSanjeev Bagewadi
4028fa9e4066Sahrens if (strcmp(snm, "..") == 0)
4029be6fd75aSMatthew Ahrens serr = SET_ERROR(EINVAL);
4030fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4031fa9e4066Sahrens return (serr);
4032fa9e4066Sahrens }
4033fa9e4066Sahrens if (terr) {
4034fa9e4066Sahrens zfs_dirent_unlock(sdl);
4035fa9e4066Sahrens VN_RELE(ZTOV(szp));
4036afefc7e4SSanjeev Bagewadi
4037afefc7e4SSanjeev Bagewadi if (sdzp == tdzp)
4038afefc7e4SSanjeev Bagewadi rw_exit(&sdzp->z_name_lock);
4039afefc7e4SSanjeev Bagewadi
4040fa9e4066Sahrens if (strcmp(tnm, "..") == 0)
4041be6fd75aSMatthew Ahrens terr = SET_ERROR(EINVAL);
4042fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4043fa9e4066Sahrens return (terr);
4044fa9e4066Sahrens }
4045fa9e4066Sahrens
4046fa9e4066Sahrens /*
4047f67950b2SNasf-Fan * If we are using project inheritance, it means if the directory has
4048f67950b2SNasf-Fan * ZFS_PROJINHERIT set, then its descendant directories will inherit
4049f67950b2SNasf-Fan * not only the project ID, but also the ZFS_PROJINHERIT flag. Under
4050f67950b2SNasf-Fan * such case, we only allow renames into our tree when the project
4051f67950b2SNasf-Fan * IDs are the same.
4052f67950b2SNasf-Fan */
4053f67950b2SNasf-Fan if (tdzp->z_pflags & ZFS_PROJINHERIT &&
4054f67950b2SNasf-Fan tdzp->z_projid != szp->z_projid) {
4055f67950b2SNasf-Fan error = SET_ERROR(EXDEV);
4056f67950b2SNasf-Fan goto out;
4057f67950b2SNasf-Fan }
4058f67950b2SNasf-Fan
4059f67950b2SNasf-Fan /*
4060fa9e4066Sahrens * Must have write access at the source to remove the old entry
4061fa9e4066Sahrens * and write access at the target to create the new entry.
4062fa9e4066Sahrens * Note that if target and source are the same, this can be
4063fa9e4066Sahrens * done in a single check.
4064fa9e4066Sahrens */
4065fa9e4066Sahrens
4066fa9e4066Sahrens if (error = zfs_zaccess_rename(sdzp, szp, tdzp, tzp, cr))
4067fa9e4066Sahrens goto out;
4068fa9e4066Sahrens
4069fa9e4066Sahrens if (ZTOV(szp)->v_type == VDIR) {
4070fa9e4066Sahrens /*
4071fa9e4066Sahrens * Check to make sure rename is valid.
4072fa9e4066Sahrens * Can't do a move like this: /usr/a/b to /usr/a/b/c/d
4073fa9e4066Sahrens */
4074fa9e4066Sahrens if (error = zfs_rename_lock(szp, tdzp, sdzp, &zl))
4075fa9e4066Sahrens goto out;
4076fa9e4066Sahrens }
4077fa9e4066Sahrens
4078fa9e4066Sahrens /*
4079fa9e4066Sahrens * Does target exist?
4080fa9e4066Sahrens */
4081fa9e4066Sahrens if (tzp) {
4082fa9e4066Sahrens /*
4083fa9e4066Sahrens * Source and target must be the same type.
4084fa9e4066Sahrens */
4085fa9e4066Sahrens if (ZTOV(szp)->v_type == VDIR) {
4086fa9e4066Sahrens if (ZTOV(tzp)->v_type != VDIR) {
4087be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTDIR);
4088fa9e4066Sahrens goto out;
4089fa9e4066Sahrens }
4090fa9e4066Sahrens } else {
4091fa9e4066Sahrens if (ZTOV(tzp)->v_type == VDIR) {
4092be6fd75aSMatthew Ahrens error = SET_ERROR(EISDIR);
4093fa9e4066Sahrens goto out;
4094fa9e4066Sahrens }
4095fa9e4066Sahrens }
4096fa9e4066Sahrens /*
4097fa9e4066Sahrens * POSIX dictates that when the source and target
4098fa9e4066Sahrens * entries refer to the same file object, rename
4099fa9e4066Sahrens * must do nothing and exit without error.
4100fa9e4066Sahrens */
4101fa9e4066Sahrens if (szp->z_id == tzp->z_id) {
4102fa9e4066Sahrens error = 0;
4103fa9e4066Sahrens goto out;
4104fa9e4066Sahrens }
4105fa9e4066Sahrens }
4106fa9e4066Sahrens
410754207fd2SJerry Jelinek vnevent_pre_rename_src(ZTOV(szp), sdvp, snm, ct);
4108fa9e4066Sahrens if (tzp)
410954207fd2SJerry Jelinek vnevent_pre_rename_dest(ZTOV(tzp), tdvp, tnm, ct);
4110df2381bfSpraks
4111df2381bfSpraks /*
4112df2381bfSpraks * notify the target directory if it is not the same
4113df2381bfSpraks * as source directory.
4114df2381bfSpraks */
4115df2381bfSpraks if (tdvp != sdvp) {
411654207fd2SJerry Jelinek vnevent_pre_rename_dest_dir(tdvp, ZTOV(szp), tnm, ct);
4117df2381bfSpraks }
4118fa9e4066Sahrens
4119fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
41200a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
41210a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, sdzp->z_sa_hdl, B_FALSE);
4122ea8dc4b6Seschrock dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm);
4123ea8dc4b6Seschrock dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm);
41240a586ceaSMark Shellenbaum if (sdzp != tdzp) {
41250a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, tdzp->z_sa_hdl, B_FALSE);
41260a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, tdzp);
41270a586ceaSMark Shellenbaum }
41280a586ceaSMark Shellenbaum if (tzp) {
41290a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, tzp->z_sa_hdl, B_FALSE);
41300a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, tzp);
41310a586ceaSMark Shellenbaum }
41320a586ceaSMark Shellenbaum
41330a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, szp);
4134893a6d32Sahrens dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
4135f864f99eSPrakash Surya error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
4136fa9e4066Sahrens if (error) {
4137fa9e4066Sahrens if (zl != NULL)
4138fa9e4066Sahrens zfs_rename_unlock(&zl);
4139fa9e4066Sahrens zfs_dirent_unlock(sdl);
4140fa9e4066Sahrens zfs_dirent_unlock(tdl);
4141afefc7e4SSanjeev Bagewadi
4142afefc7e4SSanjeev Bagewadi if (sdzp == tdzp)
4143afefc7e4SSanjeev Bagewadi rw_exit(&sdzp->z_name_lock);
4144afefc7e4SSanjeev Bagewadi
4145fa9e4066Sahrens VN_RELE(ZTOV(szp));
4146fa9e4066Sahrens if (tzp)
4147fa9e4066Sahrens VN_RELE(ZTOV(tzp));
41481209a471SNeil Perrin if (error == ERESTART) {
414969962b56SMatthew Ahrens waited = B_TRUE;
41508a2f1b91Sahrens dmu_tx_wait(tx);
41518a2f1b91Sahrens dmu_tx_abort(tx);
4152fa9e4066Sahrens goto top;
4153fa9e4066Sahrens }
41548a2f1b91Sahrens dmu_tx_abort(tx);
4155fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4156fa9e4066Sahrens return (error);
4157fa9e4066Sahrens }
4158fa9e4066Sahrens
4159fa9e4066Sahrens if (tzp) /* Attempt to remove the existing target */
416054207fd2SJerry Jelinek error = rm_err = zfs_link_destroy(tdl, tzp, tx, zflg, NULL);
4161fa9e4066Sahrens
4162fa9e4066Sahrens if (error == 0) {
4163fa9e4066Sahrens error = zfs_link_create(tdl, szp, tx, ZRENAMING);
4164fa9e4066Sahrens if (error == 0) {
41650a586ceaSMark Shellenbaum szp->z_pflags |= ZFS_AV_MODIFIED;
4166f67950b2SNasf-Fan if (tdzp->z_pflags & ZFS_PROJINHERIT)
4167f67950b2SNasf-Fan szp->z_pflags |= ZFS_PROJINHERIT;
41680a586ceaSMark Shellenbaum
41690a586ceaSMark Shellenbaum error = sa_update(szp->z_sa_hdl, SA_ZPL_FLAGS(zfsvfs),
41700a586ceaSMark Shellenbaum (void *)&szp->z_pflags, sizeof (uint64_t), tx);
4171fb09f5aaSMadhav Suresh ASSERT0(error);
4172da6c28aaSamw
4173fa9e4066Sahrens error = zfs_link_destroy(sdl, szp, tx, ZRENAMING, NULL);
41746ed5e6abSSam Falkner if (error == 0) {
41756ed5e6abSSam Falkner zfs_log_rename(zilog, tx, TX_RENAME |
417691de656bSNeil Perrin (flags & FIGNORECASE ? TX_CI : 0), sdzp,
417791de656bSNeil Perrin sdl->dl_name, tdzp, tdl->dl_name, szp);
4178da6c28aaSamw
41796ed5e6abSSam Falkner /*
41806ed5e6abSSam Falkner * Update path information for the target vnode
41816ed5e6abSSam Falkner */
41826ed5e6abSSam Falkner vn_renamepath(tdvp, ZTOV(szp), tnm,
41836ed5e6abSSam Falkner strlen(tnm));
41846ed5e6abSSam Falkner } else {
41856ed5e6abSSam Falkner /*
41866ed5e6abSSam Falkner * At this point, we have successfully created
41876ed5e6abSSam Falkner * the target name, but have failed to remove
41886ed5e6abSSam Falkner * the source name. Since the create was done
41896ed5e6abSSam Falkner * with the ZRENAMING flag, there are
41906ed5e6abSSam Falkner * complications; for one, the link count is
41916ed5e6abSSam Falkner * wrong. The easiest way to deal with this
41926ed5e6abSSam Falkner * is to remove the newly created target, and
41936ed5e6abSSam Falkner * return the original error. This must
41946ed5e6abSSam Falkner * succeed; fortunately, it is very unlikely to
41956ed5e6abSSam Falkner * fail, since we just created it.
41966ed5e6abSSam Falkner */
41976ed5e6abSSam Falkner VERIFY3U(zfs_link_destroy(tdl, szp, tx,
41986ed5e6abSSam Falkner ZRENAMING, NULL), ==, 0);
41996ed5e6abSSam Falkner }
4200fa9e4066Sahrens }
4201fa9e4066Sahrens }
4202fa9e4066Sahrens
4203fa9e4066Sahrens dmu_tx_commit(tx);
420454207fd2SJerry Jelinek
420554207fd2SJerry Jelinek if (tzp && rm_err == 0)
420654207fd2SJerry Jelinek vnevent_rename_dest(ZTOV(tzp), tdvp, tnm, ct);
420754207fd2SJerry Jelinek
420854207fd2SJerry Jelinek if (error == 0) {
420954207fd2SJerry Jelinek vnevent_rename_src(ZTOV(szp), sdvp, snm, ct);
421054207fd2SJerry Jelinek /* notify the target dir if it is not the same as source dir */
421154207fd2SJerry Jelinek if (tdvp != sdvp)
421254207fd2SJerry Jelinek vnevent_rename_dest_dir(tdvp, ct);
421354207fd2SJerry Jelinek }
4214fa9e4066Sahrens out:
4215fa9e4066Sahrens if (zl != NULL)
4216fa9e4066Sahrens zfs_rename_unlock(&zl);
4217fa9e4066Sahrens
4218fa9e4066Sahrens zfs_dirent_unlock(sdl);
4219fa9e4066Sahrens zfs_dirent_unlock(tdl);
4220fa9e4066Sahrens
4221afefc7e4SSanjeev Bagewadi if (sdzp == tdzp)
4222afefc7e4SSanjeev Bagewadi rw_exit(&sdzp->z_name_lock);
4223afefc7e4SSanjeev Bagewadi
4224afefc7e4SSanjeev Bagewadi
4225fa9e4066Sahrens VN_RELE(ZTOV(szp));
4226fa9e4066Sahrens if (tzp)
4227fa9e4066Sahrens VN_RELE(ZTOV(tzp));
4228fa9e4066Sahrens
422955da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
42305002558fSNeil Perrin zil_commit(zilog, 0);
423155da60b9SMark J Musante
4232fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4233fa9e4066Sahrens return (error);
4234fa9e4066Sahrens }
4235fa9e4066Sahrens
4236fa9e4066Sahrens /*
4237fa9e4066Sahrens * Insert the indicated symbolic reference entry into the directory.
4238fa9e4066Sahrens *
4239fa9e4066Sahrens * IN: dvp - Directory to contain new symbolic link.
4240fa9e4066Sahrens * link - Name for new symlink entry.
4241fa9e4066Sahrens * vap - Attributes of new entry.
4242fa9e4066Sahrens * cr - credentials of caller.
4243da6c28aaSamw * ct - caller context
4244da6c28aaSamw * flags - case flags
4245fa9e4066Sahrens *
4246f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
4247fa9e4066Sahrens *
4248fa9e4066Sahrens * Timestamps:
4249fa9e4066Sahrens * dvp - ctime|mtime updated
4250fa9e4066Sahrens */
4251da6c28aaSamw /*ARGSUSED*/
4252fa9e4066Sahrens static int
zfs_symlink(vnode_t * dvp,char * name,vattr_t * vap,char * link,cred_t * cr,caller_context_t * ct,int flags)4253da6c28aaSamw zfs_symlink(vnode_t *dvp, char *name, vattr_t *vap, char *link, cred_t *cr,
4254da6c28aaSamw caller_context_t *ct, int flags)
4255fa9e4066Sahrens {
4256fa9e4066Sahrens znode_t *zp, *dzp = VTOZ(dvp);
4257fa9e4066Sahrens zfs_dirlock_t *dl;
4258fa9e4066Sahrens dmu_tx_t *tx;
4259fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
4260f18faf3fSek110237 zilog_t *zilog;
42610a586ceaSMark Shellenbaum uint64_t len = strlen(link);
4262fa9e4066Sahrens int error;
4263da6c28aaSamw int zflg = ZNEW;
426489459e17SMark Shellenbaum zfs_acl_ids_t acl_ids;
426589459e17SMark Shellenbaum boolean_t fuid_dirtied;
42660a586ceaSMark Shellenbaum uint64_t txtype = TX_SYMLINK;
426769962b56SMatthew Ahrens boolean_t waited = B_FALSE;
4268fa9e4066Sahrens
4269fa9e4066Sahrens ASSERT(vap->va_type == VLNK);
4270fa9e4066Sahrens
42713cb34c60Sahrens ZFS_ENTER(zfsvfs);
42723cb34c60Sahrens ZFS_VERIFY_ZP(dzp);
4273f18faf3fSek110237 zilog = zfsvfs->z_log;
4274da6c28aaSamw
4275de8267e0Stimh if (zfsvfs->z_utf8 && u8_validate(name, strlen(name),
4276da6c28aaSamw NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
4277da6c28aaSamw ZFS_EXIT(zfsvfs);
4278be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ));
4279da6c28aaSamw }
4280da6c28aaSamw if (flags & FIGNORECASE)
4281da6c28aaSamw zflg |= ZCILOOK;
4282fa9e4066Sahrens
4283fa9e4066Sahrens if (len > MAXPATHLEN) {
4284fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4285be6fd75aSMatthew Ahrens return (SET_ERROR(ENAMETOOLONG));
4286fa9e4066Sahrens }
4287fa9e4066Sahrens
4288c8c24165SMark Shellenbaum if ((error = zfs_acl_ids_create(dzp, 0,
4289c8c24165SMark Shellenbaum vap, cr, NULL, &acl_ids)) != 0) {
4290c8c24165SMark Shellenbaum ZFS_EXIT(zfsvfs);
4291c8c24165SMark Shellenbaum return (error);
4292c8c24165SMark Shellenbaum }
4293c8c24165SMark Shellenbaum top:
4294fa9e4066Sahrens /*
4295fa9e4066Sahrens * Attempt to lock directory; fail if entry already exists.
4296fa9e4066Sahrens */
4297da6c28aaSamw error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, NULL, NULL);
4298da6c28aaSamw if (error) {
4299c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
4300fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4301fa9e4066Sahrens return (error);
4302fa9e4066Sahrens }
4303fa9e4066Sahrens
4304c8c24165SMark Shellenbaum if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) {
4305c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
43068e303ae0SMark Shellenbaum zfs_dirent_unlock(dl);
4307c8c24165SMark Shellenbaum ZFS_EXIT(zfsvfs);
4308c8c24165SMark Shellenbaum return (error);
4309c8c24165SMark Shellenbaum }
4310c8c24165SMark Shellenbaum
4311f67950b2SNasf-Fan if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, ZFS_DEFAULT_PROJID)) {
431214843421SMatthew Ahrens zfs_acl_ids_free(&acl_ids);
431314843421SMatthew Ahrens zfs_dirent_unlock(dl);
431414843421SMatthew Ahrens ZFS_EXIT(zfsvfs);
4315be6fd75aSMatthew Ahrens return (SET_ERROR(EDQUOT));
431614843421SMatthew Ahrens }
4317fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
431889459e17SMark Shellenbaum fuid_dirtied = zfsvfs->z_fuid_dirty;
4319fa9e4066Sahrens dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len));
4320ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
43210a586ceaSMark Shellenbaum dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
43220a586ceaSMark Shellenbaum ZFS_SA_BASE_ATTR_SIZE + len);
43230a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
43240a586ceaSMark Shellenbaum if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
43250a586ceaSMark Shellenbaum dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
43260a586ceaSMark Shellenbaum acl_ids.z_aclp->z_acl_bytes);
43270a586ceaSMark Shellenbaum }
432814843421SMatthew Ahrens if (fuid_dirtied)
432914843421SMatthew Ahrens zfs_fuid_txhold(zfsvfs, tx);
4330f864f99eSPrakash Surya error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
4331fa9e4066Sahrens if (error) {
4332fa9e4066Sahrens zfs_dirent_unlock(dl);
43331209a471SNeil Perrin if (error == ERESTART) {
433469962b56SMatthew Ahrens waited = B_TRUE;
43358a2f1b91Sahrens dmu_tx_wait(tx);
43368a2f1b91Sahrens dmu_tx_abort(tx);
4337fa9e4066Sahrens goto top;
4338fa9e4066Sahrens }
4339c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
43408a2f1b91Sahrens dmu_tx_abort(tx);
4341fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4342fa9e4066Sahrens return (error);
4343fa9e4066Sahrens }
4344fa9e4066Sahrens
4345fa9e4066Sahrens /*
4346fa9e4066Sahrens * Create a new object for the symlink.
43470a586ceaSMark Shellenbaum * for version 4 ZPL datsets the symlink will be an SA attribute
4348fa9e4066Sahrens */
43490a586ceaSMark Shellenbaum zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
435089459e17SMark Shellenbaum
435189459e17SMark Shellenbaum if (fuid_dirtied)
435289459e17SMark Shellenbaum zfs_fuid_sync(zfsvfs, tx);
4353fa9e4066Sahrens
43541412a1a2SMark Shellenbaum mutex_enter(&zp->z_lock);
43550a586ceaSMark Shellenbaum if (zp->z_is_sa)
43560a586ceaSMark Shellenbaum error = sa_update(zp->z_sa_hdl, SA_ZPL_SYMLINK(zfsvfs),
43570a586ceaSMark Shellenbaum link, len, tx);
43580a586ceaSMark Shellenbaum else
43590a586ceaSMark Shellenbaum zfs_sa_symlink(zp, link, len, tx);
43601412a1a2SMark Shellenbaum mutex_exit(&zp->z_lock);
4361fa9e4066Sahrens
43620a586ceaSMark Shellenbaum zp->z_size = len;
43630a586ceaSMark Shellenbaum (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
43640a586ceaSMark Shellenbaum &zp->z_size, sizeof (zp->z_size), tx);
4365fa9e4066Sahrens /*
4366fa9e4066Sahrens * Insert the new object into the directory.
4367fa9e4066Sahrens */
4368fa9e4066Sahrens (void) zfs_link_create(dl, zp, tx, ZNEW);
43690a586ceaSMark Shellenbaum
4370da6c28aaSamw if (flags & FIGNORECASE)
4371da6c28aaSamw txtype |= TX_CI;
4372da6c28aaSamw zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link);
437389459e17SMark Shellenbaum
437489459e17SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
4375fa9e4066Sahrens
4376fa9e4066Sahrens dmu_tx_commit(tx);
4377fa9e4066Sahrens
4378fa9e4066Sahrens zfs_dirent_unlock(dl);
4379fa9e4066Sahrens
4380fa9e4066Sahrens VN_RELE(ZTOV(zp));
4381fa9e4066Sahrens
438255da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
43835002558fSNeil Perrin zil_commit(zilog, 0);
438455da60b9SMark J Musante
4385fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4386fa9e4066Sahrens return (error);
4387fa9e4066Sahrens }
4388fa9e4066Sahrens
4389fa9e4066Sahrens /*
4390fa9e4066Sahrens * Return, in the buffer contained in the provided uio structure,
4391fa9e4066Sahrens * the symbolic path referred to by vp.
4392fa9e4066Sahrens *
4393fa9e4066Sahrens * IN: vp - vnode of symbolic link.
4394f7170741SWill Andrews * uio - structure to contain the link path.
4395fa9e4066Sahrens * cr - credentials of caller.
4396da6c28aaSamw * ct - caller context
4397fa9e4066Sahrens *
4398f7170741SWill Andrews * OUT: uio - structure containing the link path.
4399fa9e4066Sahrens *
4400f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
4401fa9e4066Sahrens *
4402fa9e4066Sahrens * Timestamps:
4403fa9e4066Sahrens * vp - atime updated
4404fa9e4066Sahrens */
4405fa9e4066Sahrens /* ARGSUSED */
4406fa9e4066Sahrens static int
zfs_readlink(vnode_t * vp,uio_t * uio,cred_t * cr,caller_context_t * ct)4407da6c28aaSamw zfs_readlink(vnode_t *vp, uio_t *uio, cred_t *cr, caller_context_t *ct)
4408fa9e4066Sahrens {
4409fa9e4066Sahrens znode_t *zp = VTOZ(vp);
4410fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
4411fa9e4066Sahrens int error;
4412fa9e4066Sahrens
44133cb34c60Sahrens ZFS_ENTER(zfsvfs);
44143cb34c60Sahrens ZFS_VERIFY_ZP(zp);
4415fa9e4066Sahrens
44161412a1a2SMark Shellenbaum mutex_enter(&zp->z_lock);
44170a586ceaSMark Shellenbaum if (zp->z_is_sa)
44180a586ceaSMark Shellenbaum error = sa_lookup_uio(zp->z_sa_hdl,
44190a586ceaSMark Shellenbaum SA_ZPL_SYMLINK(zfsvfs), uio);
44200a586ceaSMark Shellenbaum else
44210a586ceaSMark Shellenbaum error = zfs_sa_readlink(zp, uio);
44221412a1a2SMark Shellenbaum mutex_exit(&zp->z_lock);
4423fa9e4066Sahrens
4424fa9e4066Sahrens ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
44250a586ceaSMark Shellenbaum
4426fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4427fa9e4066Sahrens return (error);
4428fa9e4066Sahrens }
4429fa9e4066Sahrens
4430fa9e4066Sahrens /*
4431fa9e4066Sahrens * Insert a new entry into directory tdvp referencing svp.
4432fa9e4066Sahrens *
4433fa9e4066Sahrens * IN: tdvp - Directory to contain new entry.
4434fa9e4066Sahrens * svp - vnode of new entry.
4435fa9e4066Sahrens * name - name of new entry.
4436fa9e4066Sahrens * cr - credentials of caller.
4437da6c28aaSamw * ct - caller context
4438fa9e4066Sahrens *
4439f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
4440fa9e4066Sahrens *
4441fa9e4066Sahrens * Timestamps:
4442fa9e4066Sahrens * tdvp - ctime|mtime updated
4443fa9e4066Sahrens * svp - ctime updated
4444fa9e4066Sahrens */
4445fa9e4066Sahrens /* ARGSUSED */
4446fa9e4066Sahrens static int
zfs_link(vnode_t * tdvp,vnode_t * svp,char * name,cred_t * cr,caller_context_t * ct,int flags)4447da6c28aaSamw zfs_link(vnode_t *tdvp, vnode_t *svp, char *name, cred_t *cr,
4448da6c28aaSamw caller_context_t *ct, int flags)
4449fa9e4066Sahrens {
4450fa9e4066Sahrens znode_t *dzp = VTOZ(tdvp);
4451fa9e4066Sahrens znode_t *tzp, *szp;
4452fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
4453f18faf3fSek110237 zilog_t *zilog;
4454fa9e4066Sahrens zfs_dirlock_t *dl;
4455fa9e4066Sahrens dmu_tx_t *tx;
4456fa9e4066Sahrens vnode_t *realvp;
4457fa9e4066Sahrens int error;
4458da6c28aaSamw int zf = ZNEW;
4459d39ee142SMark Shellenbaum uint64_t parent;
4460f1696b23SMark Shellenbaum uid_t owner;
446169962b56SMatthew Ahrens boolean_t waited = B_FALSE;
4462fa9e4066Sahrens
4463fa9e4066Sahrens ASSERT(tdvp->v_type == VDIR);
4464fa9e4066Sahrens
44653cb34c60Sahrens ZFS_ENTER(zfsvfs);
44663cb34c60Sahrens ZFS_VERIFY_ZP(dzp);
4467f18faf3fSek110237 zilog = zfsvfs->z_log;
4468fa9e4066Sahrens
4469da6c28aaSamw if (VOP_REALVP(svp, &realvp, ct) == 0)
4470fa9e4066Sahrens svp = realvp;
4471fa9e4066Sahrens
4472d39ee142SMark Shellenbaum /*
4473d39ee142SMark Shellenbaum * POSIX dictates that we return EPERM here.
4474d39ee142SMark Shellenbaum * Better choices include ENOTSUP or EISDIR.
4475d39ee142SMark Shellenbaum */
4476d39ee142SMark Shellenbaum if (svp->v_type == VDIR) {
4477d39ee142SMark Shellenbaum ZFS_EXIT(zfsvfs);
4478be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
4479d39ee142SMark Shellenbaum }
4480d39ee142SMark Shellenbaum
448118e64978SMarcel Telka szp = VTOZ(svp);
448218e64978SMarcel Telka ZFS_VERIFY_ZP(szp);
448318e64978SMarcel Telka
448418e64978SMarcel Telka /*
4485f67950b2SNasf-Fan * If we are using project inheritance, it means if the directory has
4486f67950b2SNasf-Fan * ZFS_PROJINHERIT set, then its descendant directories will inherit
4487f67950b2SNasf-Fan * not only the project ID, but also the ZFS_PROJINHERIT flag. Under
4488f67950b2SNasf-Fan * such case, we only allow hard link creation in our tree when the
4489f67950b2SNasf-Fan * project IDs are the same.
4490f67950b2SNasf-Fan */
4491f67950b2SNasf-Fan if (dzp->z_pflags & ZFS_PROJINHERIT && dzp->z_projid != szp->z_projid) {
4492f67950b2SNasf-Fan ZFS_EXIT(zfsvfs);
4493f67950b2SNasf-Fan return (SET_ERROR(EXDEV));
4494f67950b2SNasf-Fan }
4495f67950b2SNasf-Fan
4496f67950b2SNasf-Fan /*
449718e64978SMarcel Telka * We check z_zfsvfs rather than v_vfsp here, because snapshots and the
449818e64978SMarcel Telka * ctldir appear to have the same v_vfsp.
449918e64978SMarcel Telka */
450018e64978SMarcel Telka if (szp->z_zfsvfs != zfsvfs || zfsctl_is_node(svp)) {
4501fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4502be6fd75aSMatthew Ahrens return (SET_ERROR(EXDEV));
4503fa9e4066Sahrens }
4504d39ee142SMark Shellenbaum
4505d39ee142SMark Shellenbaum /* Prevent links to .zfs/shares files */
4506d39ee142SMark Shellenbaum
4507d39ee142SMark Shellenbaum if ((error = sa_lookup(szp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
4508d39ee142SMark Shellenbaum &parent, sizeof (uint64_t))) != 0) {
4509d39ee142SMark Shellenbaum ZFS_EXIT(zfsvfs);
4510d39ee142SMark Shellenbaum return (error);
4511d39ee142SMark Shellenbaum }
4512d39ee142SMark Shellenbaum if (parent == zfsvfs->z_shares_dir) {
4513d39ee142SMark Shellenbaum ZFS_EXIT(zfsvfs);
4514be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
4515d39ee142SMark Shellenbaum }
4516d39ee142SMark Shellenbaum
4517de8267e0Stimh if (zfsvfs->z_utf8 && u8_validate(name,
4518da6c28aaSamw strlen(name), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
4519da6c28aaSamw ZFS_EXIT(zfsvfs);
4520be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ));
4521da6c28aaSamw }
4522da6c28aaSamw if (flags & FIGNORECASE)
4523da6c28aaSamw zf |= ZCILOOK;
4524da6c28aaSamw
4525fa9e4066Sahrens /*
4526fa9e4066Sahrens * We do not support links between attributes and non-attributes
4527fa9e4066Sahrens * because of the potential security risk of creating links
4528fa9e4066Sahrens * into "normal" file space in order to circumvent restrictions
4529fa9e4066Sahrens * imposed in attribute space.
4530fa9e4066Sahrens */
45310a586ceaSMark Shellenbaum if ((szp->z_pflags & ZFS_XATTR) != (dzp->z_pflags & ZFS_XATTR)) {
4532fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4533be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
4534fa9e4066Sahrens }
4535fa9e4066Sahrens
4536fa9e4066Sahrens
4537f1696b23SMark Shellenbaum owner = zfs_fuid_map_id(zfsvfs, szp->z_uid, cr, ZFS_OWNER);
4538f1696b23SMark Shellenbaum if (owner != crgetuid(cr) && secpolicy_basic_link(cr) != 0) {
4539fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4540be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
4541fa9e4066Sahrens }
4542fa9e4066Sahrens
4543da6c28aaSamw if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) {
4544fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4545fa9e4066Sahrens return (error);
4546fa9e4066Sahrens }
4547fa9e4066Sahrens
4548d39ee142SMark Shellenbaum top:
4549fa9e4066Sahrens /*
4550fa9e4066Sahrens * Attempt to lock directory; fail if entry already exists.
4551fa9e4066Sahrens */
4552da6c28aaSamw error = zfs_dirent_lock(&dl, dzp, name, &tzp, zf, NULL, NULL);
4553da6c28aaSamw if (error) {
4554fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4555fa9e4066Sahrens return (error);
4556fa9e4066Sahrens }
4557fa9e4066Sahrens
4558fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
45590a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
4560ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
45610a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, szp);
45620a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, dzp);
4563f864f99eSPrakash Surya error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) | TXG_NOWAIT);
4564fa9e4066Sahrens if (error) {
4565fa9e4066Sahrens zfs_dirent_unlock(dl);
45661209a471SNeil Perrin if (error == ERESTART) {
456769962b56SMatthew Ahrens waited = B_TRUE;
45688a2f1b91Sahrens dmu_tx_wait(tx);
45698a2f1b91Sahrens dmu_tx_abort(tx);
4570fa9e4066Sahrens goto top;
4571fa9e4066Sahrens }
45728a2f1b91Sahrens dmu_tx_abort(tx);
4573fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4574fa9e4066Sahrens return (error);
4575fa9e4066Sahrens }
4576fa9e4066Sahrens
4577fa9e4066Sahrens error = zfs_link_create(dl, szp, tx, 0);
4578fa9e4066Sahrens
4579da6c28aaSamw if (error == 0) {
4580da6c28aaSamw uint64_t txtype = TX_LINK;
4581da6c28aaSamw if (flags & FIGNORECASE)
4582da6c28aaSamw txtype |= TX_CI;
4583da6c28aaSamw zfs_log_link(zilog, tx, txtype, dzp, szp, name);
4584da6c28aaSamw }
4585fa9e4066Sahrens
4586fa9e4066Sahrens dmu_tx_commit(tx);
4587fa9e4066Sahrens
4588fa9e4066Sahrens zfs_dirent_unlock(dl);
4589fa9e4066Sahrens
4590df2381bfSpraks if (error == 0) {
4591da6c28aaSamw vnevent_link(svp, ct);
4592df2381bfSpraks }
4593df2381bfSpraks
459455da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
45955002558fSNeil Perrin zil_commit(zilog, 0);
459655da60b9SMark J Musante
4597fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4598fa9e4066Sahrens return (error);
4599fa9e4066Sahrens }
4600fa9e4066Sahrens
4601fa9e4066Sahrens /*
4602fa9e4066Sahrens * zfs_null_putapage() is used when the file system has been force
4603fa9e4066Sahrens * unmounted. It just drops the pages.
4604fa9e4066Sahrens */
4605fa9e4066Sahrens /* ARGSUSED */
4606fa9e4066Sahrens static int
zfs_null_putapage(vnode_t * vp,page_t * pp,u_offset_t * offp,size_t * lenp,int flags,cred_t * cr)4607fa9e4066Sahrens zfs_null_putapage(vnode_t *vp, page_t *pp, u_offset_t *offp,
4608fa9e4066Sahrens size_t *lenp, int flags, cred_t *cr)
4609fa9e4066Sahrens {
4610fa9e4066Sahrens pvn_write_done(pp, B_INVAL|B_FORCE|B_ERROR);
4611fa9e4066Sahrens return (0);
4612fa9e4066Sahrens }
4613fa9e4066Sahrens
461444eda4d7Smaybee /*
461544eda4d7Smaybee * Push a page out to disk, klustering if possible.
461644eda4d7Smaybee *
461744eda4d7Smaybee * IN: vp - file to push page to.
461844eda4d7Smaybee * pp - page to push.
461944eda4d7Smaybee * flags - additional flags.
462044eda4d7Smaybee * cr - credentials of caller.
462144eda4d7Smaybee *
462244eda4d7Smaybee * OUT: offp - start of range pushed.
462344eda4d7Smaybee * lenp - len of range pushed.
462444eda4d7Smaybee *
4625f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
462644eda4d7Smaybee *
462744eda4d7Smaybee * NOTE: callers must have locked the page to be pushed. On
462844eda4d7Smaybee * exit, the page (and all other pages in the kluster) must be
462944eda4d7Smaybee * unlocked.
463044eda4d7Smaybee */
4631fa9e4066Sahrens /* ARGSUSED */
4632fa9e4066Sahrens static int
zfs_putapage(vnode_t * vp,page_t * pp,u_offset_t * offp,size_t * lenp,int flags,cred_t * cr)4633fa9e4066Sahrens zfs_putapage(vnode_t *vp, page_t *pp, u_offset_t *offp,
4634fa9e4066Sahrens size_t *lenp, int flags, cred_t *cr)
4635fa9e4066Sahrens {
4636fa9e4066Sahrens znode_t *zp = VTOZ(vp);
4637fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
4638fa9e4066Sahrens dmu_tx_t *tx;
463944eda4d7Smaybee u_offset_t off, koff;
464044eda4d7Smaybee size_t len, klen;
4641fa9e4066Sahrens int err;
4642fa9e4066Sahrens
4643fa9e4066Sahrens off = pp->p_offset;
464444eda4d7Smaybee len = PAGESIZE;
464544eda4d7Smaybee /*
464644eda4d7Smaybee * If our blocksize is bigger than the page size, try to kluster
46471209a471SNeil Perrin * multiple pages so that we write a full block (thus avoiding
464844eda4d7Smaybee * a read-modify-write).
464944eda4d7Smaybee */
46500a586ceaSMark Shellenbaum if (off < zp->z_size && zp->z_blksz > PAGESIZE) {
465144eda4d7Smaybee klen = P2ROUNDUP((ulong_t)zp->z_blksz, PAGESIZE);
4652ac05c741SMark Maybee koff = ISP2(klen) ? P2ALIGN(off, (u_offset_t)klen) : 0;
46530a586ceaSMark Shellenbaum ASSERT(koff <= zp->z_size);
46540a586ceaSMark Shellenbaum if (koff + klen > zp->z_size)
46550a586ceaSMark Shellenbaum klen = P2ROUNDUP(zp->z_size - koff, (uint64_t)PAGESIZE);
465644eda4d7Smaybee pp = pvn_write_kluster(vp, pp, &off, &len, koff, klen, flags);
465744eda4d7Smaybee }
465844eda4d7Smaybee ASSERT3U(btop(len), ==, btopr(len));
4659ac05c741SMark Maybee
4660dd6ef538Smaybee /*
4661dd6ef538Smaybee * Can't push pages past end-of-file.
4662dd6ef538Smaybee */
46630a586ceaSMark Shellenbaum if (off >= zp->z_size) {
4664f4d2e9e6Smaybee /* ignore all pages */
466544eda4d7Smaybee err = 0;
466644eda4d7Smaybee goto out;
46670a586ceaSMark Shellenbaum } else if (off + len > zp->z_size) {
46680a586ceaSMark Shellenbaum int npages = btopr(zp->z_size - off);
466944eda4d7Smaybee page_t *trunc;
467044eda4d7Smaybee
467144eda4d7Smaybee page_list_break(&pp, &trunc, npages);
4672f4d2e9e6Smaybee /* ignore pages past end of file */
467344eda4d7Smaybee if (trunc)
4674f4d2e9e6Smaybee pvn_write_done(trunc, flags);
46750a586ceaSMark Shellenbaum len = zp->z_size - off;
4676dd6ef538Smaybee }
467714843421SMatthew Ahrens
4678f67950b2SNasf-Fan if (zfs_id_overblockquota(zfsvfs, DMU_USERUSED_OBJECT, zp->z_uid) ||
4679f67950b2SNasf-Fan zfs_id_overblockquota(zfsvfs, DMU_GROUPUSED_OBJECT, zp->z_gid)) {
4680be6fd75aSMatthew Ahrens err = SET_ERROR(EDQUOT);
468114843421SMatthew Ahrens goto out;
468214843421SMatthew Ahrens }
4683fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
4684fa9e4066Sahrens dmu_tx_hold_write(tx, zp->z_id, off, len);
46850a586ceaSMark Shellenbaum
46860a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
46870a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
4688e722410cSMatthew Ahrens err = dmu_tx_assign(tx, TXG_WAIT);
4689fa9e4066Sahrens if (err != 0) {
46908a2f1b91Sahrens dmu_tx_abort(tx);
4691fa9e4066Sahrens goto out;
4692fa9e4066Sahrens }
4693fa9e4066Sahrens
469444eda4d7Smaybee if (zp->z_blksz <= PAGESIZE) {
46950fab61baSJonathan W Adams caddr_t va = zfs_map_page(pp, S_READ);
469644eda4d7Smaybee ASSERT3U(len, <=, PAGESIZE);
4697fa9e4066Sahrens dmu_write(zfsvfs->z_os, zp->z_id, off, len, va, tx);
46980fab61baSJonathan W Adams zfs_unmap_page(pp, va);
469944eda4d7Smaybee } else {
470044eda4d7Smaybee err = dmu_write_pages(zfsvfs->z_os, zp->z_id, off, len, pp, tx);
470144eda4d7Smaybee }
4702fa9e4066Sahrens
470344eda4d7Smaybee if (err == 0) {
47040a586ceaSMark Shellenbaum uint64_t mtime[2], ctime[2];
4705db9986c7SMark Shellenbaum sa_bulk_attr_t bulk[3];
47060a586ceaSMark Shellenbaum int count = 0;
47070a586ceaSMark Shellenbaum
47080a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
47090a586ceaSMark Shellenbaum &mtime, 16);
47100a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
47110a586ceaSMark Shellenbaum &ctime, 16);
4712db9986c7SMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
4713db9986c7SMark Shellenbaum &zp->z_pflags, 8);
47140a586ceaSMark Shellenbaum zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime,
47150a586ceaSMark Shellenbaum B_TRUE);
471680e10fd0SAndriy Gapon err = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
471780e10fd0SAndriy Gapon ASSERT0(err);
4718ac05c741SMark Maybee zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, off, len, 0);
471944eda4d7Smaybee }
472068857716SLin Ling dmu_tx_commit(tx);
4721fa9e4066Sahrens
472244eda4d7Smaybee out:
4723f4d2e9e6Smaybee pvn_write_done(pp, (err ? B_ERROR : 0) | flags);
4724fa9e4066Sahrens if (offp)
4725fa9e4066Sahrens *offp = off;
4726fa9e4066Sahrens if (lenp)
4727fa9e4066Sahrens *lenp = len;
4728fa9e4066Sahrens
4729fa9e4066Sahrens return (err);
4730fa9e4066Sahrens }
4731fa9e4066Sahrens
4732fa9e4066Sahrens /*
4733fa9e4066Sahrens * Copy the portion of the file indicated from pages into the file.
4734fa9e4066Sahrens * The pages are stored in a page list attached to the files vnode.
4735fa9e4066Sahrens *
4736fa9e4066Sahrens * IN: vp - vnode of file to push page data to.
4737fa9e4066Sahrens * off - position in file to put data.
4738fa9e4066Sahrens * len - amount of data to write.
4739fa9e4066Sahrens * flags - flags to control the operation.
4740fa9e4066Sahrens * cr - credentials of caller.
4741da6c28aaSamw * ct - caller context.
4742fa9e4066Sahrens *
4743f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
4744fa9e4066Sahrens *
4745fa9e4066Sahrens * Timestamps:
4746fa9e4066Sahrens * vp - ctime|mtime updated
4747fa9e4066Sahrens */
4748da6c28aaSamw /*ARGSUSED*/
4749fa9e4066Sahrens static int
zfs_putpage(vnode_t * vp,offset_t off,size_t len,int flags,cred_t * cr,caller_context_t * ct)4750da6c28aaSamw zfs_putpage(vnode_t *vp, offset_t off, size_t len, int flags, cred_t *cr,
4751da6c28aaSamw caller_context_t *ct)
4752fa9e4066Sahrens {
4753fa9e4066Sahrens znode_t *zp = VTOZ(vp);
4754fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
4755fa9e4066Sahrens page_t *pp;
4756fa9e4066Sahrens size_t io_len;
4757fa9e4066Sahrens u_offset_t io_off;
4758ac05c741SMark Maybee uint_t blksz;
475979315247SMatthew Ahrens locked_range_t *lr;
4760fa9e4066Sahrens int error = 0;
4761fa9e4066Sahrens
47623cb34c60Sahrens ZFS_ENTER(zfsvfs);
47633cb34c60Sahrens ZFS_VERIFY_ZP(zp);
4764fa9e4066Sahrens
4765fa9e4066Sahrens /*
4766c4fc6b21SGarrett D'Amore * There's nothing to do if no data is cached.
4767c4fc6b21SGarrett D'Amore */
4768c4fc6b21SGarrett D'Amore if (!vn_has_cached_data(vp)) {
4769c4fc6b21SGarrett D'Amore ZFS_EXIT(zfsvfs);
4770c4fc6b21SGarrett D'Amore return (0);
4771c4fc6b21SGarrett D'Amore }
4772c4fc6b21SGarrett D'Amore
4773c4fc6b21SGarrett D'Amore /*
4774ac05c741SMark Maybee * Align this request to the file block size in case we kluster.
4775ac05c741SMark Maybee * XXX - this can result in pretty aggresive locking, which can
4776ac05c741SMark Maybee * impact simultanious read/write access. One option might be
4777ac05c741SMark Maybee * to break up long requests (len == 0) into block-by-block
4778ac05c741SMark Maybee * operations to get narrower locking.
4779fa9e4066Sahrens */
4780ac05c741SMark Maybee blksz = zp->z_blksz;
4781ac05c741SMark Maybee if (ISP2(blksz))
4782ac05c741SMark Maybee io_off = P2ALIGN_TYPED(off, blksz, u_offset_t);
4783ac05c741SMark Maybee else
4784ac05c741SMark Maybee io_off = 0;
4785ac05c741SMark Maybee if (len > 0 && ISP2(blksz))
47865a6f5619SMark Maybee io_len = P2ROUNDUP_TYPED(len + (off - io_off), blksz, size_t);
4787ac05c741SMark Maybee else
4788ac05c741SMark Maybee io_len = 0;
4789ac05c741SMark Maybee
4790ac05c741SMark Maybee if (io_len == 0) {
4791ac05c741SMark Maybee /*
4792ac05c741SMark Maybee * Search the entire vp list for pages >= io_off.
4793ac05c741SMark Maybee */
479479315247SMatthew Ahrens lr = rangelock_enter(&zp->z_rangelock,
479579315247SMatthew Ahrens io_off, UINT64_MAX, RL_WRITER);
4796ac05c741SMark Maybee error = pvn_vplist_dirty(vp, io_off, zfs_putapage, flags, cr);
4797fe9cf88cSperrin goto out;
4798fa9e4066Sahrens }
479979315247SMatthew Ahrens lr = rangelock_enter(&zp->z_rangelock, io_off, io_len, RL_WRITER);
4800fa9e4066Sahrens
48010a586ceaSMark Shellenbaum if (off > zp->z_size) {
4802fa9e4066Sahrens /* past end of file */
480379315247SMatthew Ahrens rangelock_exit(lr);
4804fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4805fa9e4066Sahrens return (0);
4806fa9e4066Sahrens }
4807fa9e4066Sahrens
48080a586ceaSMark Shellenbaum len = MIN(io_len, P2ROUNDUP(zp->z_size, PAGESIZE) - io_off);
4809fa9e4066Sahrens
4810ac05c741SMark Maybee for (off = io_off; io_off < off + len; io_off += io_len) {
4811fa9e4066Sahrens if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
4812fa9e4066Sahrens pp = page_lookup(vp, io_off,
4813ecb72030Sperrin (flags & (B_INVAL | B_FREE)) ? SE_EXCL : SE_SHARED);
4814fa9e4066Sahrens } else {
4815fa9e4066Sahrens pp = page_lookup_nowait(vp, io_off,
4816fa9e4066Sahrens (flags & B_FREE) ? SE_EXCL : SE_SHARED);
4817fa9e4066Sahrens }
4818fa9e4066Sahrens
4819fa9e4066Sahrens if (pp != NULL && pvn_getdirty(pp, flags)) {
4820fa9e4066Sahrens int err;
4821fa9e4066Sahrens
4822fa9e4066Sahrens /*
4823fa9e4066Sahrens * Found a dirty page to push
4824fa9e4066Sahrens */
4825104e2ed7Sperrin err = zfs_putapage(vp, pp, &io_off, &io_len, flags, cr);
4826104e2ed7Sperrin if (err)
4827fa9e4066Sahrens error = err;
4828fa9e4066Sahrens } else {
4829fa9e4066Sahrens io_len = PAGESIZE;
4830fa9e4066Sahrens }
4831fa9e4066Sahrens }
4832fe9cf88cSperrin out:
483379315247SMatthew Ahrens rangelock_exit(lr);
483455da60b9SMark J Musante if ((flags & B_ASYNC) == 0 || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
48355002558fSNeil Perrin zil_commit(zfsvfs->z_log, zp->z_id);
4836fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4837fa9e4066Sahrens return (error);
4838fa9e4066Sahrens }
4839fa9e4066Sahrens
4840da6c28aaSamw /*ARGSUSED*/
4841fa9e4066Sahrens void
zfs_inactive(vnode_t * vp,cred_t * cr,caller_context_t * ct)4842da6c28aaSamw zfs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
4843fa9e4066Sahrens {
4844fa9e4066Sahrens znode_t *zp = VTOZ(vp);
4845fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
4846fa9e4066Sahrens int error;
4847fa9e4066Sahrens
4848f18faf3fSek110237 rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_READER);
48490a586ceaSMark Shellenbaum if (zp->z_sa_hdl == NULL) {
48504ccbb6e7Sahrens /*
4851874395d5Smaybee * The fs has been unmounted, or we did a
4852874395d5Smaybee * suspend/resume and this file no longer exists.
48534ccbb6e7Sahrens */
4854fa9e4066Sahrens if (vn_has_cached_data(vp)) {
4855fa9e4066Sahrens (void) pvn_vplist_dirty(vp, 0, zfs_null_putapage,
4856fa9e4066Sahrens B_INVAL, cr);
4857fa9e4066Sahrens }
4858fa9e4066Sahrens
4859ea8dc4b6Seschrock mutex_enter(&zp->z_lock);
4860cd2adeceSChris Kirby mutex_enter(&vp->v_lock);
4861cd2adeceSChris Kirby ASSERT(vp->v_count == 1);
4862ade42b55SSebastien Roy VN_RELE_LOCKED(vp);
4863cd2adeceSChris Kirby mutex_exit(&vp->v_lock);
4864ea8dc4b6Seschrock mutex_exit(&zp->z_lock);
4865f18faf3fSek110237 rw_exit(&zfsvfs->z_teardown_inactive_lock);
4866874395d5Smaybee zfs_znode_free(zp);
4867fa9e4066Sahrens return;
4868fa9e4066Sahrens }
4869fa9e4066Sahrens
4870fa9e4066Sahrens /*
4871fa9e4066Sahrens * Attempt to push any data in the page cache. If this fails
4872fa9e4066Sahrens * we will get kicked out later in zfs_zinactive().
4873fa9e4066Sahrens */
48748afd4dd6Sperrin if (vn_has_cached_data(vp)) {
48758afd4dd6Sperrin (void) pvn_vplist_dirty(vp, 0, zfs_putapage, B_INVAL|B_ASYNC,
48768afd4dd6Sperrin cr);
48778afd4dd6Sperrin }
4878fa9e4066Sahrens
4879893a6d32Sahrens if (zp->z_atime_dirty && zp->z_unlinked == 0) {
4880fa9e4066Sahrens dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);
4881fa9e4066Sahrens
48820a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
48830a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
4884fa9e4066Sahrens error = dmu_tx_assign(tx, TXG_WAIT);
4885fa9e4066Sahrens if (error) {
4886fa9e4066Sahrens dmu_tx_abort(tx);
4887fa9e4066Sahrens } else {
4888fa9e4066Sahrens mutex_enter(&zp->z_lock);
48890a586ceaSMark Shellenbaum (void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zfsvfs),
48900a586ceaSMark Shellenbaum (void *)&zp->z_atime, sizeof (zp->z_atime), tx);
4891fa9e4066Sahrens zp->z_atime_dirty = 0;
4892fa9e4066Sahrens mutex_exit(&zp->z_lock);
4893fa9e4066Sahrens dmu_tx_commit(tx);
4894fa9e4066Sahrens }
4895fa9e4066Sahrens }
4896fa9e4066Sahrens
4897fa9e4066Sahrens zfs_zinactive(zp);
4898f18faf3fSek110237 rw_exit(&zfsvfs->z_teardown_inactive_lock);
4899fa9e4066Sahrens }
4900fa9e4066Sahrens
4901fa9e4066Sahrens /*
4902fa9e4066Sahrens * Bounds-check the seek operation.
4903fa9e4066Sahrens *
4904fa9e4066Sahrens * IN: vp - vnode seeking within
4905fa9e4066Sahrens * ooff - old file offset
4906fa9e4066Sahrens * noffp - pointer to new file offset
4907da6c28aaSamw * ct - caller context
4908fa9e4066Sahrens *
4909f7170741SWill Andrews * RETURN: 0 on success, EINVAL if new offset invalid.
4910fa9e4066Sahrens */
4911fa9e4066Sahrens /* ARGSUSED */
4912fa9e4066Sahrens static int
zfs_seek(vnode_t * vp,offset_t ooff,offset_t * noffp,caller_context_t * ct)4913da6c28aaSamw zfs_seek(vnode_t *vp, offset_t ooff, offset_t *noffp,
4914da6c28aaSamw caller_context_t *ct)
4915fa9e4066Sahrens {
4916fa9e4066Sahrens if (vp->v_type == VDIR)
4917fa9e4066Sahrens return (0);
4918e4af2f17SToomas Soome return ((*noffp < 0) ? EINVAL : 0);
4919fa9e4066Sahrens }
4920fa9e4066Sahrens
4921fa9e4066Sahrens /*
4922fa9e4066Sahrens * Pre-filter the generic locking function to trap attempts to place
4923fa9e4066Sahrens * a mandatory lock on a memory mapped file.
4924fa9e4066Sahrens */
4925fa9e4066Sahrens static int
zfs_frlock(vnode_t * vp,int cmd,flock64_t * bfp,int flag,offset_t offset,flk_callback_t * flk_cbp,cred_t * cr,caller_context_t * ct)4926fa9e4066Sahrens zfs_frlock(vnode_t *vp, int cmd, flock64_t *bfp, int flag, offset_t offset,
4927da6c28aaSamw flk_callback_t *flk_cbp, cred_t *cr, caller_context_t *ct)
4928fa9e4066Sahrens {
4929fa9e4066Sahrens znode_t *zp = VTOZ(vp);
4930fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
4931fa9e4066Sahrens
49323cb34c60Sahrens ZFS_ENTER(zfsvfs);
49333cb34c60Sahrens ZFS_VERIFY_ZP(zp);
4934fa9e4066Sahrens
4935fa9e4066Sahrens /*
4936ea8dc4b6Seschrock * We are following the UFS semantics with respect to mapcnt
4937ea8dc4b6Seschrock * here: If we see that the file is mapped already, then we will
4938ea8dc4b6Seschrock * return an error, but we don't worry about races between this
4939ea8dc4b6Seschrock * function and zfs_map().
4940fa9e4066Sahrens */
49410a586ceaSMark Shellenbaum if (zp->z_mapcnt > 0 && MANDMODE(zp->z_mode)) {
4942fa9e4066Sahrens ZFS_EXIT(zfsvfs);
4943be6fd75aSMatthew Ahrens return (SET_ERROR(EAGAIN));
4944fa9e4066Sahrens }
4945fa9e4066Sahrens ZFS_EXIT(zfsvfs);
494604ce3d0bSMark Shellenbaum return (fs_frlock(vp, cmd, bfp, flag, offset, flk_cbp, cr, ct));
4947fa9e4066Sahrens }
4948fa9e4066Sahrens
4949fa9e4066Sahrens /*
4950fa9e4066Sahrens * If we can't find a page in the cache, we will create a new page
4951fa9e4066Sahrens * and fill it with file data. For efficiency, we may try to fill
4952ac05c741SMark Maybee * multiple pages at once (klustering) to fill up the supplied page
4953ed886187SMark Maybee * list. Note that the pages to be filled are held with an exclusive
4954ed886187SMark Maybee * lock to prevent access by other threads while they are being filled.
4955fa9e4066Sahrens */
4956fa9e4066Sahrens static int
zfs_fillpage(vnode_t * vp,u_offset_t off,struct seg * seg,caddr_t addr,page_t * pl[],size_t plsz,enum seg_rw rw)4957fa9e4066Sahrens zfs_fillpage(vnode_t *vp, u_offset_t off, struct seg *seg,
4958fa9e4066Sahrens caddr_t addr, page_t *pl[], size_t plsz, enum seg_rw rw)
4959fa9e4066Sahrens {
4960fa9e4066Sahrens znode_t *zp = VTOZ(vp);
4961fa9e4066Sahrens page_t *pp, *cur_pp;
4962fa9e4066Sahrens objset_t *os = zp->z_zfsvfs->z_os;
4963fa9e4066Sahrens u_offset_t io_off, total;
4964fa9e4066Sahrens size_t io_len;
4965fa9e4066Sahrens int err;
4966fa9e4066Sahrens
496744eda4d7Smaybee if (plsz == PAGESIZE || zp->z_blksz <= PAGESIZE) {
4968ac05c741SMark Maybee /*
4969ac05c741SMark Maybee * We only have a single page, don't bother klustering
4970ac05c741SMark Maybee */
4971fa9e4066Sahrens io_off = off;
4972fa9e4066Sahrens io_len = PAGESIZE;
4973ed886187SMark Maybee pp = page_create_va(vp, io_off, io_len,
4974ed886187SMark Maybee PG_EXCL | PG_WAIT, seg, addr);
4975fa9e4066Sahrens } else {
4976fa9e4066Sahrens /*
4977ac05c741SMark Maybee * Try to find enough pages to fill the page list
4978fa9e4066Sahrens */
4979fa9e4066Sahrens pp = pvn_read_kluster(vp, off, seg, addr, &io_off,
4980ac05c741SMark Maybee &io_len, off, plsz, 0);
4981fa9e4066Sahrens }
4982fa9e4066Sahrens if (pp == NULL) {
4983fa9e4066Sahrens /*
4984ac05c741SMark Maybee * The page already exists, nothing to do here.
4985fa9e4066Sahrens */
4986fa9e4066Sahrens *pl = NULL;
4987fa9e4066Sahrens return (0);
4988fa9e4066Sahrens }
4989fa9e4066Sahrens
4990fa9e4066Sahrens /*
4991fa9e4066Sahrens * Fill the pages in the kluster.
4992fa9e4066Sahrens */
4993fa9e4066Sahrens cur_pp = pp;
4994fa9e4066Sahrens for (total = io_off + io_len; io_off < total; io_off += PAGESIZE) {
4995ac05c741SMark Maybee caddr_t va;
4996ac05c741SMark Maybee
499744eda4d7Smaybee ASSERT3U(io_off, ==, cur_pp->p_offset);
49980fab61baSJonathan W Adams va = zfs_map_page(cur_pp, S_WRITE);
49997bfdf011SNeil Perrin err = dmu_read(os, zp->z_id, io_off, PAGESIZE, va,
50007bfdf011SNeil Perrin DMU_READ_PREFETCH);
50010fab61baSJonathan W Adams zfs_unmap_page(cur_pp, va);
5002fa9e4066Sahrens if (err) {
5003fa9e4066Sahrens /* On error, toss the entire kluster */
5004fa9e4066Sahrens pvn_read_done(pp, B_ERROR);
5005b87f3af3Sperrin /* convert checksum errors into IO errors */
5006b87f3af3Sperrin if (err == ECKSUM)
5007be6fd75aSMatthew Ahrens err = SET_ERROR(EIO);
5008fa9e4066Sahrens return (err);
5009fa9e4066Sahrens }
5010fa9e4066Sahrens cur_pp = cur_pp->p_next;
5011fa9e4066Sahrens }
5012ac05c741SMark Maybee
5013fa9e4066Sahrens /*
5014ac05c741SMark Maybee * Fill in the page list array from the kluster starting
5015ac05c741SMark Maybee * from the desired offset `off'.
5016fa9e4066Sahrens * NOTE: the page list will always be null terminated.
5017fa9e4066Sahrens */
5018fa9e4066Sahrens pvn_plist_init(pp, pl, plsz, off, io_len, rw);
5019ac05c741SMark Maybee ASSERT(pl == NULL || (*pl)->p_offset == off);
5020fa9e4066Sahrens
5021fa9e4066Sahrens return (0);
5022fa9e4066Sahrens }
5023fa9e4066Sahrens
5024fa9e4066Sahrens /*
5025fa9e4066Sahrens * Return pointers to the pages for the file region [off, off + len]
5026fa9e4066Sahrens * in the pl array. If plsz is greater than len, this function may
5027ac05c741SMark Maybee * also return page pointers from after the specified region
5028ac05c741SMark Maybee * (i.e. the region [off, off + plsz]). These additional pages are
5029ac05c741SMark Maybee * only returned if they are already in the cache, or were created as
5030ac05c741SMark Maybee * part of a klustered read.
5031fa9e4066Sahrens *
5032fa9e4066Sahrens * IN: vp - vnode of file to get data from.
5033fa9e4066Sahrens * off - position in file to get data from.
5034fa9e4066Sahrens * len - amount of data to retrieve.
5035fa9e4066Sahrens * plsz - length of provided page list.
5036fa9e4066Sahrens * seg - segment to obtain pages for.
5037fa9e4066Sahrens * addr - virtual address of fault.
5038fa9e4066Sahrens * rw - mode of created pages.
5039fa9e4066Sahrens * cr - credentials of caller.
5040da6c28aaSamw * ct - caller context.
5041fa9e4066Sahrens *
5042fa9e4066Sahrens * OUT: protp - protection mode of created pages.
5043fa9e4066Sahrens * pl - list of pages created.
5044fa9e4066Sahrens *
5045f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
5046fa9e4066Sahrens *
5047fa9e4066Sahrens * Timestamps:
5048fa9e4066Sahrens * vp - atime updated
5049fa9e4066Sahrens */
5050fa9e4066Sahrens /* ARGSUSED */
5051fa9e4066Sahrens static int
zfs_getpage(vnode_t * vp,offset_t off,size_t len,uint_t * protp,page_t * pl[],size_t plsz,struct seg * seg,caddr_t addr,enum seg_rw rw,cred_t * cr,caller_context_t * ct)5052fa9e4066Sahrens zfs_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
5053fa9e4066Sahrens page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr,
5054da6c28aaSamw enum seg_rw rw, cred_t *cr, caller_context_t *ct)
5055fa9e4066Sahrens {
5056fa9e4066Sahrens znode_t *zp = VTOZ(vp);
5057fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5058ac05c741SMark Maybee page_t **pl0 = pl;
5059ac05c741SMark Maybee int err = 0;
5060ac05c741SMark Maybee
5061ac05c741SMark Maybee /* we do our own caching, faultahead is unnecessary */
5062ac05c741SMark Maybee if (pl == NULL)
5063ac05c741SMark Maybee return (0);
5064ac05c741SMark Maybee else if (len > plsz)
5065ac05c741SMark Maybee len = plsz;
506627bd165aSMark Maybee else
506727bd165aSMark Maybee len = P2ROUNDUP(len, PAGESIZE);
5068ac05c741SMark Maybee ASSERT(plsz >= len);
5069fa9e4066Sahrens
50703cb34c60Sahrens ZFS_ENTER(zfsvfs);
50713cb34c60Sahrens ZFS_VERIFY_ZP(zp);
5072fa9e4066Sahrens
5073fa9e4066Sahrens if (protp)
5074fa9e4066Sahrens *protp = PROT_ALL;
5075fa9e4066Sahrens
5076fa9e4066Sahrens /*
5077ed886187SMark Maybee * Loop through the requested range [off, off + len) looking
5078fa9e4066Sahrens * for pages. If we don't find a page, we will need to create
5079fa9e4066Sahrens * a new page and fill it with data from the file.
5080fa9e4066Sahrens */
5081fa9e4066Sahrens while (len > 0) {
5082ac05c741SMark Maybee if (*pl = page_lookup(vp, off, SE_SHARED))
5083ac05c741SMark Maybee *(pl+1) = NULL;
5084ac05c741SMark Maybee else if (err = zfs_fillpage(vp, off, seg, addr, pl, plsz, rw))
5085fe2f476aSperrin goto out;
5086fa9e4066Sahrens while (*pl) {
5087ac05c741SMark Maybee ASSERT3U((*pl)->p_offset, ==, off);
5088fa9e4066Sahrens off += PAGESIZE;
5089fa9e4066Sahrens addr += PAGESIZE;
509027bd165aSMark Maybee if (len > 0) {
509127bd165aSMark Maybee ASSERT3U(len, >=, PAGESIZE);
5092fa9e4066Sahrens len -= PAGESIZE;
509327bd165aSMark Maybee }
5094ac05c741SMark Maybee ASSERT3U(plsz, >=, PAGESIZE);
5095ac05c741SMark Maybee plsz -= PAGESIZE;
5096ac05c741SMark Maybee pl++;
5097104e2ed7Sperrin }
5098104e2ed7Sperrin }
5099fa9e4066Sahrens
5100fa9e4066Sahrens /*
5101fa9e4066Sahrens * Fill out the page array with any pages already in the cache.
5102fa9e4066Sahrens */
5103ac05c741SMark Maybee while (plsz > 0 &&
5104ac05c741SMark Maybee (*pl++ = page_lookup_nowait(vp, off, SE_SHARED))) {
5105fa9e4066Sahrens off += PAGESIZE;
5106fa9e4066Sahrens plsz -= PAGESIZE;
5107fa9e4066Sahrens }
5108fa9e4066Sahrens out:
5109fe2f476aSperrin if (err) {
5110fe2f476aSperrin /*
5111fe2f476aSperrin * Release any pages we have previously locked.
5112fe2f476aSperrin */
5113fe2f476aSperrin while (pl > pl0)
5114fe2f476aSperrin page_unlock(*--pl);
5115ac05c741SMark Maybee } else {
5116ac05c741SMark Maybee ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
5117fe2f476aSperrin }
5118fe2f476aSperrin
5119fa9e4066Sahrens *pl = NULL;
5120fa9e4066Sahrens
5121fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5122fa9e4066Sahrens return (err);
5123fa9e4066Sahrens }
5124fa9e4066Sahrens
5125ea8dc4b6Seschrock /*
5126ea8dc4b6Seschrock * Request a memory map for a section of a file. This code interacts
5127ea8dc4b6Seschrock * with common code and the VM system as follows:
5128ea8dc4b6Seschrock *
5129f7170741SWill Andrews * - common code calls mmap(), which ends up in smmap_common()
5130f7170741SWill Andrews * - this calls VOP_MAP(), which takes you into (say) zfs
5131f7170741SWill Andrews * - zfs_map() calls as_map(), passing segvn_create() as the callback
5132f7170741SWill Andrews * - segvn_create() creates the new segment and calls VOP_ADDMAP()
5133f7170741SWill Andrews * - zfs_addmap() updates z_mapcnt
5134ea8dc4b6Seschrock */
5135da6c28aaSamw /*ARGSUSED*/
5136fa9e4066Sahrens static int
zfs_map(vnode_t * vp,offset_t off,struct as * as,caddr_t * addrp,size_t len,uchar_t prot,uchar_t maxprot,uint_t flags,cred_t * cr,caller_context_t * ct)5137fa9e4066Sahrens zfs_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
5138da6c28aaSamw size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
5139da6c28aaSamw caller_context_t *ct)
5140fa9e4066Sahrens {
5141fa9e4066Sahrens znode_t *zp = VTOZ(vp);
5142fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5143fa9e4066Sahrens segvn_crargs_t vn_a;
5144fa9e4066Sahrens int error;
5145fa9e4066Sahrens
51463cb34c60Sahrens ZFS_ENTER(zfsvfs);
51473cb34c60Sahrens ZFS_VERIFY_ZP(zp);
5148fa9e4066Sahrens
51492889ec41SGordon Ross /*
51502889ec41SGordon Ross * Note: ZFS_READONLY is handled in zfs_zaccess_common.
51512889ec41SGordon Ross */
51522889ec41SGordon Ross
51530a586ceaSMark Shellenbaum if ((prot & PROT_WRITE) && (zp->z_pflags &
51542889ec41SGordon Ross (ZFS_IMMUTABLE | ZFS_APPENDONLY))) {
51550616c50eSmarks ZFS_EXIT(zfsvfs);
5156be6fd75aSMatthew Ahrens return (SET_ERROR(EPERM));
51570616c50eSmarks }
51580616c50eSmarks
51590616c50eSmarks if ((prot & (PROT_READ | PROT_EXEC)) &&
51600a586ceaSMark Shellenbaum (zp->z_pflags & ZFS_AV_QUARANTINED)) {
51610616c50eSmarks ZFS_EXIT(zfsvfs);
5162be6fd75aSMatthew Ahrens return (SET_ERROR(EACCES));
51630616c50eSmarks }
51640616c50eSmarks
5165fa9e4066Sahrens if (vp->v_flag & VNOMAP) {
5166fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5167be6fd75aSMatthew Ahrens return (SET_ERROR(ENOSYS));
5168fa9e4066Sahrens }
5169fa9e4066Sahrens
5170fa9e4066Sahrens if (off < 0 || len > MAXOFFSET_T - off) {
5171fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5172be6fd75aSMatthew Ahrens return (SET_ERROR(ENXIO));
5173fa9e4066Sahrens }
5174fa9e4066Sahrens
5175fa9e4066Sahrens if (vp->v_type != VREG) {
5176fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5177be6fd75aSMatthew Ahrens return (SET_ERROR(ENODEV));
5178fa9e4066Sahrens }
5179fa9e4066Sahrens
5180fa9e4066Sahrens /*
5181fa9e4066Sahrens * If file is locked, disallow mapping.
5182fa9e4066Sahrens */
51830a586ceaSMark Shellenbaum if (MANDMODE(zp->z_mode) && vn_has_flocks(vp)) {
5184fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5185be6fd75aSMatthew Ahrens return (SET_ERROR(EAGAIN));
5186fa9e4066Sahrens }
5187fa9e4066Sahrens
5188fa9e4066Sahrens as_rangelock(as);
518960946fe0Smec error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
519060946fe0Smec if (error != 0) {
5191fa9e4066Sahrens as_rangeunlock(as);
5192fa9e4066Sahrens ZFS_EXIT(zfsvfs);
519360946fe0Smec return (error);
5194fa9e4066Sahrens }
5195fa9e4066Sahrens
5196fa9e4066Sahrens vn_a.vp = vp;
5197fa9e4066Sahrens vn_a.offset = (u_offset_t)off;
5198fa9e4066Sahrens vn_a.type = flags & MAP_TYPE;
5199fa9e4066Sahrens vn_a.prot = prot;
5200fa9e4066Sahrens vn_a.maxprot = maxprot;
5201fa9e4066Sahrens vn_a.cred = cr;
5202fa9e4066Sahrens vn_a.amp = NULL;
5203fa9e4066Sahrens vn_a.flags = flags & ~MAP_TYPE;
52044944b02eSkchow vn_a.szc = 0;
52054944b02eSkchow vn_a.lgrp_mem_policy_flags = 0;
5206fa9e4066Sahrens
5207fa9e4066Sahrens error = as_map(as, *addrp, len, segvn_create, &vn_a);
5208fa9e4066Sahrens
5209fa9e4066Sahrens as_rangeunlock(as);
5210fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5211fa9e4066Sahrens return (error);
5212fa9e4066Sahrens }
5213fa9e4066Sahrens
5214fa9e4066Sahrens /* ARGSUSED */
5215fa9e4066Sahrens static int
zfs_addmap(vnode_t * vp,offset_t off,struct as * as,caddr_t addr,size_t len,uchar_t prot,uchar_t maxprot,uint_t flags,cred_t * cr,caller_context_t * ct)5216fa9e4066Sahrens zfs_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
5217da6c28aaSamw size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
5218da6c28aaSamw caller_context_t *ct)
5219fa9e4066Sahrens {
5220ea8dc4b6Seschrock uint64_t pages = btopr(len);
5221ea8dc4b6Seschrock
5222ea8dc4b6Seschrock atomic_add_64(&VTOZ(vp)->z_mapcnt, pages);
5223fa9e4066Sahrens return (0);
5224fa9e4066Sahrens }
5225fa9e4066Sahrens
5226fa9e4066Sahrens /* ARGSUSED */
5227fa9e4066Sahrens static int
zfs_delmap(vnode_t * vp,offset_t off,struct as * as,caddr_t addr,size_t len,uint_t prot,uint_t maxprot,uint_t flags,cred_t * cr,caller_context_t * ct)5228fa9e4066Sahrens zfs_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
5229da6c28aaSamw size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
5230da6c28aaSamw caller_context_t *ct)
5231fa9e4066Sahrens {
5232ea8dc4b6Seschrock uint64_t pages = btopr(len);
5233ea8dc4b6Seschrock
5234ea8dc4b6Seschrock ASSERT3U(VTOZ(vp)->z_mapcnt, >=, pages);
5235ea8dc4b6Seschrock atomic_add_64(&VTOZ(vp)->z_mapcnt, -pages);
5236b468a217Seschrock
5237fa9e4066Sahrens return (0);
5238fa9e4066Sahrens }
5239fa9e4066Sahrens
5240fa9e4066Sahrens /*
5241fa9e4066Sahrens * Free or allocate space in a file. Currently, this function only
5242fa9e4066Sahrens * supports the `F_FREESP' command. However, this command is somewhat
5243fa9e4066Sahrens * misnamed, as its functionality includes the ability to allocate as
5244fa9e4066Sahrens * well as free space.
5245fa9e4066Sahrens *
5246fa9e4066Sahrens * IN: vp - vnode of file to free data in.
5247fa9e4066Sahrens * cmd - action to take (only F_FREESP supported).
5248fa9e4066Sahrens * bfp - section of file to free/alloc.
5249fa9e4066Sahrens * flag - current file open mode flags.
5250fa9e4066Sahrens * offset - current file offset.
5251fa9e4066Sahrens * cr - credentials of caller [UNUSED].
5252da6c28aaSamw * ct - caller context.
5253fa9e4066Sahrens *
5254f7170741SWill Andrews * RETURN: 0 on success, error code on failure.
5255fa9e4066Sahrens *
5256fa9e4066Sahrens * Timestamps:
5257fa9e4066Sahrens * vp - ctime|mtime updated
5258fa9e4066Sahrens */
5259fa9e4066Sahrens /* ARGSUSED */
5260fa9e4066Sahrens static int
zfs_space(vnode_t * vp,int cmd,flock64_t * bfp,int flag,offset_t offset,cred_t * cr,caller_context_t * ct)5261fa9e4066Sahrens zfs_space(vnode_t *vp, int cmd, flock64_t *bfp, int flag,
5262fa9e4066Sahrens offset_t offset, cred_t *cr, caller_context_t *ct)
5263fa9e4066Sahrens {
5264fa9e4066Sahrens znode_t *zp = VTOZ(vp);
5265fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5266fa9e4066Sahrens uint64_t off, len;
5267fa9e4066Sahrens int error;
5268fa9e4066Sahrens
52693cb34c60Sahrens ZFS_ENTER(zfsvfs);
52703cb34c60Sahrens ZFS_VERIFY_ZP(zp);
5271fa9e4066Sahrens
5272fa9e4066Sahrens if (cmd != F_FREESP) {
5273fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5274be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5275fa9e4066Sahrens }
5276fa9e4066Sahrens
52772144b121SMarcel Telka /*
52782144b121SMarcel Telka * In a case vp->v_vfsp != zp->z_zfsvfs->z_vfs (e.g. snapshots) our
52792144b121SMarcel Telka * callers might not be able to detect properly that we are read-only,
52802144b121SMarcel Telka * so check it explicitly here.
52812144b121SMarcel Telka */
52822144b121SMarcel Telka if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) {
52832144b121SMarcel Telka ZFS_EXIT(zfsvfs);
52842144b121SMarcel Telka return (SET_ERROR(EROFS));
52852144b121SMarcel Telka }
52862144b121SMarcel Telka
5287fa9e4066Sahrens if (error = convoff(vp, bfp, 0, offset)) {
5288fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5289fa9e4066Sahrens return (error);
5290fa9e4066Sahrens }
5291fa9e4066Sahrens
5292fa9e4066Sahrens if (bfp->l_len < 0) {
5293fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5294be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5295fa9e4066Sahrens }
5296fa9e4066Sahrens
5297fa9e4066Sahrens off = bfp->l_start;
5298104e2ed7Sperrin len = bfp->l_len; /* 0 means from off to end of file */
5299104e2ed7Sperrin
53005730cc9aSmaybee error = zfs_freesp(zp, off, len, flag, TRUE);
5301fa9e4066Sahrens
530272102e74SBryan Cantrill if (error == 0 && off == 0 && len == 0)
530372102e74SBryan Cantrill vnevent_truncate(ZTOV(zp), ct);
530472102e74SBryan Cantrill
5305fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5306fa9e4066Sahrens return (error);
5307fa9e4066Sahrens }
5308fa9e4066Sahrens
5309da6c28aaSamw /*ARGSUSED*/
5310fa9e4066Sahrens static int
zfs_fid(vnode_t * vp,fid_t * fidp,caller_context_t * ct)5311da6c28aaSamw zfs_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
5312fa9e4066Sahrens {
5313fa9e4066Sahrens znode_t *zp = VTOZ(vp);
5314fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5315f18faf3fSek110237 uint32_t gen;
53160a586ceaSMark Shellenbaum uint64_t gen64;
5317fa9e4066Sahrens uint64_t object = zp->z_id;
5318fa9e4066Sahrens zfid_short_t *zfid;
53190a586ceaSMark Shellenbaum int size, i, error;
5320fa9e4066Sahrens
53213cb34c60Sahrens ZFS_ENTER(zfsvfs);
53223cb34c60Sahrens ZFS_VERIFY_ZP(zp);
53230a586ceaSMark Shellenbaum
53240a586ceaSMark Shellenbaum if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs),
5325f3e6fb2fSMark Shellenbaum &gen64, sizeof (uint64_t))) != 0) {
5326f3e6fb2fSMark Shellenbaum ZFS_EXIT(zfsvfs);
53270a586ceaSMark Shellenbaum return (error);
5328f3e6fb2fSMark Shellenbaum }
53290a586ceaSMark Shellenbaum
53300a586ceaSMark Shellenbaum gen = (uint32_t)gen64;
5331fa9e4066Sahrens
5332fa9e4066Sahrens size = (zfsvfs->z_parent != zfsvfs) ? LONG_FID_LEN : SHORT_FID_LEN;
5333fa9e4066Sahrens if (fidp->fid_len < size) {
5334fa9e4066Sahrens fidp->fid_len = size;
53350f2dc02eSek110237 ZFS_EXIT(zfsvfs);
5336be6fd75aSMatthew Ahrens return (SET_ERROR(ENOSPC));
5337fa9e4066Sahrens }
5338fa9e4066Sahrens
5339fa9e4066Sahrens zfid = (zfid_short_t *)fidp;
5340fa9e4066Sahrens
5341fa9e4066Sahrens zfid->zf_len = size;
5342fa9e4066Sahrens
5343fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_object); i++)
5344fa9e4066Sahrens zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
5345fa9e4066Sahrens
5346fa9e4066Sahrens /* Must have a non-zero generation number to distinguish from .zfs */
5347fa9e4066Sahrens if (gen == 0)
5348fa9e4066Sahrens gen = 1;
5349fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_gen); i++)
5350fa9e4066Sahrens zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));
5351fa9e4066Sahrens
5352fa9e4066Sahrens if (size == LONG_FID_LEN) {
5353fa9e4066Sahrens uint64_t objsetid = dmu_objset_id(zfsvfs->z_os);
5354fa9e4066Sahrens zfid_long_t *zlfid;
5355fa9e4066Sahrens
5356fa9e4066Sahrens zlfid = (zfid_long_t *)fidp;
5357fa9e4066Sahrens
5358fa9e4066Sahrens for (i = 0; i < sizeof (zlfid->zf_setid); i++)
5359fa9e4066Sahrens zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i));
5360fa9e4066Sahrens
5361fa9e4066Sahrens /* XXX - this should be the generation number for the objset */
5362fa9e4066Sahrens for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
5363fa9e4066Sahrens zlfid->zf_setgen[i] = 0;
5364fa9e4066Sahrens }
5365fa9e4066Sahrens
5366fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5367fa9e4066Sahrens return (0);
5368fa9e4066Sahrens }
5369fa9e4066Sahrens
5370fa9e4066Sahrens static int
zfs_pathconf(vnode_t * vp,int cmd,ulong_t * valp,cred_t * cr,caller_context_t * ct)5371da6c28aaSamw zfs_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
5372da6c28aaSamw caller_context_t *ct)
5373fa9e4066Sahrens {
5374fa9e4066Sahrens znode_t *zp, *xzp;
5375fa9e4066Sahrens zfsvfs_t *zfsvfs;
5376fa9e4066Sahrens zfs_dirlock_t *dl;
5377fa9e4066Sahrens int error;
5378fa9e4066Sahrens
5379fa9e4066Sahrens switch (cmd) {
5380fa9e4066Sahrens case _PC_LINK_MAX:
5381fa9e4066Sahrens *valp = ULONG_MAX;
5382fa9e4066Sahrens return (0);
5383fa9e4066Sahrens
5384fa9e4066Sahrens case _PC_FILESIZEBITS:
5385fa9e4066Sahrens *valp = 64;
5386fa9e4066Sahrens return (0);
5387fa9e4066Sahrens
5388fa9e4066Sahrens case _PC_XATTR_EXISTS:
5389fa9e4066Sahrens zp = VTOZ(vp);
5390fa9e4066Sahrens zfsvfs = zp->z_zfsvfs;
53913cb34c60Sahrens ZFS_ENTER(zfsvfs);
53923cb34c60Sahrens ZFS_VERIFY_ZP(zp);
5393fa9e4066Sahrens *valp = 0;
5394fa9e4066Sahrens error = zfs_dirent_lock(&dl, zp, "", &xzp,
5395da6c28aaSamw ZXATTR | ZEXISTS | ZSHARED, NULL, NULL);
5396fa9e4066Sahrens if (error == 0) {
5397fa9e4066Sahrens zfs_dirent_unlock(dl);
5398fa9e4066Sahrens if (!zfs_dirempty(xzp))
5399fa9e4066Sahrens *valp = 1;
5400fa9e4066Sahrens VN_RELE(ZTOV(xzp));
5401fa9e4066Sahrens } else if (error == ENOENT) {
5402fa9e4066Sahrens /*
5403fa9e4066Sahrens * If there aren't extended attributes, it's the
5404fa9e4066Sahrens * same as having zero of them.
5405fa9e4066Sahrens */
5406fa9e4066Sahrens error = 0;
5407fa9e4066Sahrens }
5408fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5409fa9e4066Sahrens return (error);
5410fa9e4066Sahrens
5411da6c28aaSamw case _PC_SATTR_ENABLED:
5412da6c28aaSamw case _PC_SATTR_EXISTS:
54139660e5cbSJanice Chang *valp = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) &&
5414da6c28aaSamw (vp->v_type == VREG || vp->v_type == VDIR);
5415da6c28aaSamw return (0);
5416da6c28aaSamw
5417e802abbdSTim Haley case _PC_ACCESS_FILTERING:
5418e802abbdSTim Haley *valp = vfs_has_feature(vp->v_vfsp, VFSFT_ACCESS_FILTER) &&
5419e802abbdSTim Haley vp->v_type == VDIR;
5420e802abbdSTim Haley return (0);
5421e802abbdSTim Haley
5422fa9e4066Sahrens case _PC_ACL_ENABLED:
5423fa9e4066Sahrens *valp = _ACL_ACE_ENABLED;
5424fa9e4066Sahrens return (0);
5425fa9e4066Sahrens
5426fa9e4066Sahrens case _PC_MIN_HOLE_SIZE:
5427fa9e4066Sahrens *valp = (ulong_t)SPA_MINBLOCKSIZE;
5428fa9e4066Sahrens return (0);
5429fa9e4066Sahrens
54303b862e9aSRoger A. Faulkner case _PC_TIMESTAMP_RESOLUTION:
54313b862e9aSRoger A. Faulkner /* nanosecond timestamp resolution */
54323b862e9aSRoger A. Faulkner *valp = 1L;
54333b862e9aSRoger A. Faulkner return (0);
54343b862e9aSRoger A. Faulkner
5435fa9e4066Sahrens default:
5436da6c28aaSamw return (fs_pathconf(vp, cmd, valp, cr, ct));
5437fa9e4066Sahrens }
5438fa9e4066Sahrens }
5439fa9e4066Sahrens
5440fa9e4066Sahrens /*ARGSUSED*/
5441fa9e4066Sahrens static int
zfs_getsecattr(vnode_t * vp,vsecattr_t * vsecp,int flag,cred_t * cr,caller_context_t * ct)5442da6c28aaSamw zfs_getsecattr(vnode_t *vp, vsecattr_t *vsecp, int flag, cred_t *cr,
5443da6c28aaSamw caller_context_t *ct)
5444fa9e4066Sahrens {
5445fa9e4066Sahrens znode_t *zp = VTOZ(vp);
5446fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5447fa9e4066Sahrens int error;
5448da6c28aaSamw boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
5449fa9e4066Sahrens
54503cb34c60Sahrens ZFS_ENTER(zfsvfs);
54513cb34c60Sahrens ZFS_VERIFY_ZP(zp);
5452da6c28aaSamw error = zfs_getacl(zp, vsecp, skipaclchk, cr);
5453fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5454fa9e4066Sahrens
5455fa9e4066Sahrens return (error);
5456fa9e4066Sahrens }
5457fa9e4066Sahrens
5458fa9e4066Sahrens /*ARGSUSED*/
5459fa9e4066Sahrens static int
zfs_setsecattr(vnode_t * vp,vsecattr_t * vsecp,int flag,cred_t * cr,caller_context_t * ct)5460da6c28aaSamw zfs_setsecattr(vnode_t *vp, vsecattr_t *vsecp, int flag, cred_t *cr,
5461da6c28aaSamw caller_context_t *ct)
5462fa9e4066Sahrens {
5463fa9e4066Sahrens znode_t *zp = VTOZ(vp);
5464fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5465fa9e4066Sahrens int error;
5466da6c28aaSamw boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
546755da60b9SMark J Musante zilog_t *zilog = zfsvfs->z_log;
5468fa9e4066Sahrens
54693cb34c60Sahrens ZFS_ENTER(zfsvfs);
54703cb34c60Sahrens ZFS_VERIFY_ZP(zp);
547155da60b9SMark J Musante
5472da6c28aaSamw error = zfs_setacl(zp, vsecp, skipaclchk, cr);
547355da60b9SMark J Musante
547455da60b9SMark J Musante if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
54755002558fSNeil Perrin zil_commit(zilog, 0);
547655da60b9SMark J Musante
5477fa9e4066Sahrens ZFS_EXIT(zfsvfs);
5478fa9e4066Sahrens return (error);
5479fa9e4066Sahrens }
5480fa9e4066Sahrens
5481fa9e4066Sahrens /*
5482f7170741SWill Andrews * The smallest read we may consider to loan out an arcbuf.
5483f7170741SWill Andrews * This must be a power of 2.
5484c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
5485c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int zcr_blksz_min = (1 << 10); /* 1K */
5486f7170741SWill Andrews /*
5487f7170741SWill Andrews * If set to less than the file block size, allow loaning out of an
5488f7170741SWill Andrews * arcbuf for a partial block read. This must be a power of 2.
5489f7170741SWill Andrews */
5490c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int zcr_blksz_max = (1 << 17); /* 128K */
5491c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5492c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*ARGSUSED*/
5493c242f9a0Schunli zhang - Sun Microsystems - Irvine United States static int
zfs_reqzcbuf(vnode_t * vp,enum uio_rw ioflag,xuio_t * xuio,cred_t * cr,caller_context_t * ct)5494c242f9a0Schunli zhang - Sun Microsystems - Irvine United States zfs_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *xuio, cred_t *cr,
5495c242f9a0Schunli zhang - Sun Microsystems - Irvine United States caller_context_t *ct)
5496c242f9a0Schunli zhang - Sun Microsystems - Irvine United States {
5497c242f9a0Schunli zhang - Sun Microsystems - Irvine United States znode_t *zp = VTOZ(vp);
5498c242f9a0Schunli zhang - Sun Microsystems - Irvine United States zfsvfs_t *zfsvfs = zp->z_zfsvfs;
5499c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int max_blksz = zfsvfs->z_max_blksz;
5500c242f9a0Schunli zhang - Sun Microsystems - Irvine United States uio_t *uio = &xuio->xu_uio;
5501c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ssize_t size = uio->uio_resid;
5502c242f9a0Schunli zhang - Sun Microsystems - Irvine United States offset_t offset = uio->uio_loffset;
5503c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int blksz;
5504c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int fullblk, i;
5505c242f9a0Schunli zhang - Sun Microsystems - Irvine United States arc_buf_t *abuf;
5506c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ssize_t maxsize;
5507c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int preamble, postamble;
5508c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5509c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (xuio->xu_type != UIOTYPE_ZEROCOPY)
5510be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5511c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5512c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_ENTER(zfsvfs);
5513c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_VERIFY_ZP(zp);
5514c242f9a0Schunli zhang - Sun Microsystems - Irvine United States switch (ioflag) {
5515c242f9a0Schunli zhang - Sun Microsystems - Irvine United States case UIO_WRITE:
5516c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
5517c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * Loan out an arc_buf for write if write size is bigger than
5518c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * max_blksz, and the file's block size is also max_blksz.
5519c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
5520c242f9a0Schunli zhang - Sun Microsystems - Irvine United States blksz = max_blksz;
5521c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (size < blksz || zp->z_blksz != blksz) {
5522c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_EXIT(zfsvfs);
5523be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5524c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5525c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
5526c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * Caller requests buffers for write before knowing where the
5527c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * write offset might be (e.g. NFS TCP write).
5528c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
5529c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (offset == -1) {
5530c242f9a0Schunli zhang - Sun Microsystems - Irvine United States preamble = 0;
5531c242f9a0Schunli zhang - Sun Microsystems - Irvine United States } else {
5532c242f9a0Schunli zhang - Sun Microsystems - Irvine United States preamble = P2PHASE(offset, blksz);
5533c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (preamble) {
5534c242f9a0Schunli zhang - Sun Microsystems - Irvine United States preamble = blksz - preamble;
5535c242f9a0Schunli zhang - Sun Microsystems - Irvine United States size -= preamble;
5536c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5537c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5538c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5539c242f9a0Schunli zhang - Sun Microsystems - Irvine United States postamble = P2PHASE(size, blksz);
5540c242f9a0Schunli zhang - Sun Microsystems - Irvine United States size -= postamble;
5541c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5542c242f9a0Schunli zhang - Sun Microsystems - Irvine United States fullblk = size / blksz;
5543570de38fSSurya Prakki (void) dmu_xuio_init(xuio,
5544c242f9a0Schunli zhang - Sun Microsystems - Irvine United States (preamble != 0) + fullblk + (postamble != 0));
5545c242f9a0Schunli zhang - Sun Microsystems - Irvine United States DTRACE_PROBE3(zfs_reqzcbuf_align, int, preamble,
5546c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int, postamble, int,
5547c242f9a0Schunli zhang - Sun Microsystems - Irvine United States (preamble != 0) + fullblk + (postamble != 0));
5548c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5549c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
5550c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * Have to fix iov base/len for partial buffers. They
5551c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * currently represent full arc_buf's.
5552c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
5553c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (preamble) {
5554c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /* data begins in the middle of the arc_buf */
55550a586ceaSMark Shellenbaum abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
55560a586ceaSMark Shellenbaum blksz);
5557c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(abuf);
5558570de38fSSurya Prakki (void) dmu_xuio_add(xuio, abuf,
5559570de38fSSurya Prakki blksz - preamble, preamble);
5560c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5561c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5562c242f9a0Schunli zhang - Sun Microsystems - Irvine United States for (i = 0; i < fullblk; i++) {
55630a586ceaSMark Shellenbaum abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
55640a586ceaSMark Shellenbaum blksz);
5565c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(abuf);
5566570de38fSSurya Prakki (void) dmu_xuio_add(xuio, abuf, 0, blksz);
5567c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5568c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5569c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (postamble) {
5570c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /* data ends in the middle of the arc_buf */
55710a586ceaSMark Shellenbaum abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
55720a586ceaSMark Shellenbaum blksz);
5573c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(abuf);
5574570de38fSSurya Prakki (void) dmu_xuio_add(xuio, abuf, 0, postamble);
5575c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5576c242f9a0Schunli zhang - Sun Microsystems - Irvine United States break;
5577c242f9a0Schunli zhang - Sun Microsystems - Irvine United States case UIO_READ:
5578c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
5579c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * Loan out an arc_buf for read if the read size is larger than
5580c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * the current file block size. Block alignment is not
5581c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * considered. Partial arc_buf will be loaned out for read.
5582c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
5583c242f9a0Schunli zhang - Sun Microsystems - Irvine United States blksz = zp->z_blksz;
5584c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (blksz < zcr_blksz_min)
5585c242f9a0Schunli zhang - Sun Microsystems - Irvine United States blksz = zcr_blksz_min;
5586c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (blksz > zcr_blksz_max)
5587c242f9a0Schunli zhang - Sun Microsystems - Irvine United States blksz = zcr_blksz_max;
5588c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /* avoid potential complexity of dealing with it */
5589c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (blksz > max_blksz) {
5590c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_EXIT(zfsvfs);
5591be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5592c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5593c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
55940a586ceaSMark Shellenbaum maxsize = zp->z_size - uio->uio_loffset;
5595c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (size > maxsize)
5596c242f9a0Schunli zhang - Sun Microsystems - Irvine United States size = maxsize;
5597c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5598c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (size < blksz || vn_has_cached_data(vp)) {
5599c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_EXIT(zfsvfs);
5600be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5601c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5602c242f9a0Schunli zhang - Sun Microsystems - Irvine United States break;
5603c242f9a0Schunli zhang - Sun Microsystems - Irvine United States default:
5604c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_EXIT(zfsvfs);
5605be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5606c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5607c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5608*9b6c7373SGordon Ross /*
5609*9b6c7373SGordon Ross * Note: Setting UIO_XUIO in uio_extflg tells the caller to
5610*9b6c7373SGordon Ross * return any loaned buffers by calling VOP_RETZCBUF, so
5611*9b6c7373SGordon Ross * after we do this we MUST expect a zfs_retzcbuf call.
5612*9b6c7373SGordon Ross * Note that for UIO_READ, XUIO_XUZC_PRIV is not set
5613*9b6c7373SGordon Ross * until zfs_read calls dmu_xuio_init.
5614*9b6c7373SGordon Ross */
5615c242f9a0Schunli zhang - Sun Microsystems - Irvine United States uio->uio_extflg = UIO_XUIO;
5616c242f9a0Schunli zhang - Sun Microsystems - Irvine United States XUIO_XUZC_RW(xuio) = ioflag;
5617c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ZFS_EXIT(zfsvfs);
5618c242f9a0Schunli zhang - Sun Microsystems - Irvine United States return (0);
5619c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5620c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5621c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*ARGSUSED*/
5622c242f9a0Schunli zhang - Sun Microsystems - Irvine United States static int
zfs_retzcbuf(vnode_t * vp,xuio_t * xuio,cred_t * cr,caller_context_t * ct)5623c242f9a0Schunli zhang - Sun Microsystems - Irvine United States zfs_retzcbuf(vnode_t *vp, xuio_t *xuio, cred_t *cr, caller_context_t *ct)
5624c242f9a0Schunli zhang - Sun Microsystems - Irvine United States {
5625c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int i;
5626c242f9a0Schunli zhang - Sun Microsystems - Irvine United States arc_buf_t *abuf;
5627c242f9a0Schunli zhang - Sun Microsystems - Irvine United States int ioflag = XUIO_XUZC_RW(xuio);
5628c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5629c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(xuio->xu_type == UIOTYPE_ZEROCOPY);
5630c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5631*9b6c7373SGordon Ross /* In case zfs_read never calls dmu_xuio_init */
5632*9b6c7373SGordon Ross if (XUIO_XUZC_PRIV(xuio) == NULL)
5633*9b6c7373SGordon Ross return (0);
5634*9b6c7373SGordon Ross
5635c242f9a0Schunli zhang - Sun Microsystems - Irvine United States i = dmu_xuio_cnt(xuio);
5636c242f9a0Schunli zhang - Sun Microsystems - Irvine United States while (i-- > 0) {
5637c242f9a0Schunli zhang - Sun Microsystems - Irvine United States abuf = dmu_xuio_arcbuf(xuio, i);
5638c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
5639c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * if abuf == NULL, it must be a write buffer
5640c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * that has been returned in zfs_write().
5641c242f9a0Schunli zhang - Sun Microsystems - Irvine United States */
5642c242f9a0Schunli zhang - Sun Microsystems - Irvine United States if (abuf)
5643c242f9a0Schunli zhang - Sun Microsystems - Irvine United States dmu_return_arcbuf(abuf);
5644c242f9a0Schunli zhang - Sun Microsystems - Irvine United States ASSERT(abuf || ioflag == UIO_WRITE);
5645c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5646c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5647c242f9a0Schunli zhang - Sun Microsystems - Irvine United States dmu_xuio_fini(xuio);
5648c242f9a0Schunli zhang - Sun Microsystems - Irvine United States return (0);
5649c242f9a0Schunli zhang - Sun Microsystems - Irvine United States }
5650c242f9a0Schunli zhang - Sun Microsystems - Irvine United States
5651c242f9a0Schunli zhang - Sun Microsystems - Irvine United States /*
5652fa9e4066Sahrens * Predeclare these here so that the compiler assumes that
5653fa9e4066Sahrens * this is an "old style" function declaration that does
5654fa9e4066Sahrens * not include arguments => we won't get type mismatch errors
5655fa9e4066Sahrens * in the initializations that follow.
5656fa9e4066Sahrens */
5657fa9e4066Sahrens static int zfs_inval();
5658fa9e4066Sahrens static int zfs_isdir();
5659fa9e4066Sahrens
5660fa9e4066Sahrens static int
zfs_inval()5661fa9e4066Sahrens zfs_inval()
5662fa9e4066Sahrens {
5663be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL));
5664fa9e4066Sahrens }
5665fa9e4066Sahrens
5666fa9e4066Sahrens static int
zfs_isdir()5667fa9e4066Sahrens zfs_isdir()
5668fa9e4066Sahrens {
5669be6fd75aSMatthew Ahrens return (SET_ERROR(EISDIR));
5670fa9e4066Sahrens }
5671fa9e4066Sahrens /*
5672fa9e4066Sahrens * Directory vnode operations template
5673fa9e4066Sahrens */
5674fa9e4066Sahrens const fs_operation_def_t zfs_dvnodeops_template[] = {
5675aa59c4cbSrsb VOPNAME_OPEN, { .vop_open = zfs_open },
5676aa59c4cbSrsb VOPNAME_CLOSE, { .vop_close = zfs_close },
5677aa59c4cbSrsb VOPNAME_READ, { .error = zfs_isdir },
5678aa59c4cbSrsb VOPNAME_WRITE, { .error = zfs_isdir },
5679aa59c4cbSrsb VOPNAME_IOCTL, { .vop_ioctl = zfs_ioctl },
5680aa59c4cbSrsb VOPNAME_GETATTR, { .vop_getattr = zfs_getattr },
5681aa59c4cbSrsb VOPNAME_SETATTR, { .vop_setattr = zfs_setattr },
5682aa59c4cbSrsb VOPNAME_ACCESS, { .vop_access = zfs_access },
5683aa59c4cbSrsb VOPNAME_LOOKUP, { .vop_lookup = zfs_lookup },
5684aa59c4cbSrsb VOPNAME_CREATE, { .vop_create = zfs_create },
5685aa59c4cbSrsb VOPNAME_REMOVE, { .vop_remove = zfs_remove },
5686aa59c4cbSrsb VOPNAME_LINK, { .vop_link = zfs_link },
5687aa59c4cbSrsb VOPNAME_RENAME, { .vop_rename = zfs_rename },
5688aa59c4cbSrsb VOPNAME_MKDIR, { .vop_mkdir = zfs_mkdir },
5689aa59c4cbSrsb VOPNAME_RMDIR, { .vop_rmdir = zfs_rmdir },
5690aa59c4cbSrsb VOPNAME_READDIR, { .vop_readdir = zfs_readdir },
5691aa59c4cbSrsb VOPNAME_SYMLINK, { .vop_symlink = zfs_symlink },
5692aa59c4cbSrsb VOPNAME_FSYNC, { .vop_fsync = zfs_fsync },
5693aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive },
5694aa59c4cbSrsb VOPNAME_FID, { .vop_fid = zfs_fid },
5695aa59c4cbSrsb VOPNAME_SEEK, { .vop_seek = zfs_seek },
5696aa59c4cbSrsb VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf },
5697aa59c4cbSrsb VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr },
5698aa59c4cbSrsb VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr },
5699df2381bfSpraks VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
5700fa9e4066Sahrens NULL, NULL
5701fa9e4066Sahrens };
5702fa9e4066Sahrens
5703fa9e4066Sahrens /*
5704fa9e4066Sahrens * Regular file vnode operations template
5705fa9e4066Sahrens */
5706fa9e4066Sahrens const fs_operation_def_t zfs_fvnodeops_template[] = {
5707aa59c4cbSrsb VOPNAME_OPEN, { .vop_open = zfs_open },
5708aa59c4cbSrsb VOPNAME_CLOSE, { .vop_close = zfs_close },
5709aa59c4cbSrsb VOPNAME_READ, { .vop_read = zfs_read },
5710aa59c4cbSrsb VOPNAME_WRITE, { .vop_write = zfs_write },
5711aa59c4cbSrsb VOPNAME_IOCTL, { .vop_ioctl = zfs_ioctl },
5712aa59c4cbSrsb VOPNAME_GETATTR, { .vop_getattr = zfs_getattr },
5713aa59c4cbSrsb VOPNAME_SETATTR, { .vop_setattr = zfs_setattr },
5714aa59c4cbSrsb VOPNAME_ACCESS, { .vop_access = zfs_access },
5715aa59c4cbSrsb VOPNAME_LOOKUP, { .vop_lookup = zfs_lookup },
5716aa59c4cbSrsb VOPNAME_RENAME, { .vop_rename = zfs_rename },
5717aa59c4cbSrsb VOPNAME_FSYNC, { .vop_fsync = zfs_fsync },
5718aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive },
5719aa59c4cbSrsb VOPNAME_FID, { .vop_fid = zfs_fid },
5720aa59c4cbSrsb VOPNAME_SEEK, { .vop_seek = zfs_seek },
5721aa59c4cbSrsb VOPNAME_FRLOCK, { .vop_frlock = zfs_frlock },
5722aa59c4cbSrsb VOPNAME_SPACE, { .vop_space = zfs_space },
5723aa59c4cbSrsb VOPNAME_GETPAGE, { .vop_getpage = zfs_getpage },
5724aa59c4cbSrsb VOPNAME_PUTPAGE, { .vop_putpage = zfs_putpage },
5725aa59c4cbSrsb VOPNAME_MAP, { .vop_map = zfs_map },
5726aa59c4cbSrsb VOPNAME_ADDMAP, { .vop_addmap = zfs_addmap },
5727aa59c4cbSrsb VOPNAME_DELMAP, { .vop_delmap = zfs_delmap },
5728aa59c4cbSrsb VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf },
5729aa59c4cbSrsb VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr },
5730aa59c4cbSrsb VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr },
5731aa59c4cbSrsb VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
5732c242f9a0Schunli zhang - Sun Microsystems - Irvine United States VOPNAME_REQZCBUF, { .vop_reqzcbuf = zfs_reqzcbuf },
5733c242f9a0Schunli zhang - Sun Microsystems - Irvine United States VOPNAME_RETZCBUF, { .vop_retzcbuf = zfs_retzcbuf },
5734fa9e4066Sahrens NULL, NULL
5735fa9e4066Sahrens };
5736fa9e4066Sahrens
5737fa9e4066Sahrens /*
5738fa9e4066Sahrens * Symbolic link vnode operations template
5739fa9e4066Sahrens */
5740fa9e4066Sahrens const fs_operation_def_t zfs_symvnodeops_template[] = {
5741aa59c4cbSrsb VOPNAME_GETATTR, { .vop_getattr = zfs_getattr },
5742aa59c4cbSrsb VOPNAME_SETATTR, { .vop_setattr = zfs_setattr },
5743aa59c4cbSrsb VOPNAME_ACCESS, { .vop_access = zfs_access },
5744aa59c4cbSrsb VOPNAME_RENAME, { .vop_rename = zfs_rename },
5745aa59c4cbSrsb VOPNAME_READLINK, { .vop_readlink = zfs_readlink },
5746aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive },
5747aa59c4cbSrsb VOPNAME_FID, { .vop_fid = zfs_fid },
5748aa59c4cbSrsb VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf },
5749aa59c4cbSrsb VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
5750fa9e4066Sahrens NULL, NULL
5751fa9e4066Sahrens };
5752fa9e4066Sahrens
5753fa9e4066Sahrens /*
5754743a77edSAlan Wright * special share hidden files vnode operations template
5755743a77edSAlan Wright */
5756743a77edSAlan Wright const fs_operation_def_t zfs_sharevnodeops_template[] = {
5757743a77edSAlan Wright VOPNAME_GETATTR, { .vop_getattr = zfs_getattr },
5758743a77edSAlan Wright VOPNAME_ACCESS, { .vop_access = zfs_access },
5759743a77edSAlan Wright VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive },
5760743a77edSAlan Wright VOPNAME_FID, { .vop_fid = zfs_fid },
5761743a77edSAlan Wright VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf },
5762743a77edSAlan Wright VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr },
5763743a77edSAlan Wright VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr },
5764743a77edSAlan Wright VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
5765743a77edSAlan Wright NULL, NULL
5766743a77edSAlan Wright };
5767743a77edSAlan Wright
5768743a77edSAlan Wright /*
5769fa9e4066Sahrens * Extended attribute directory vnode operations template
5770f7170741SWill Andrews *
5771fa9e4066Sahrens * This template is identical to the directory vnodes
5772fa9e4066Sahrens * operation template except for restricted operations:
5773fa9e4066Sahrens * VOP_MKDIR()
5774fa9e4066Sahrens * VOP_SYMLINK()
5775f7170741SWill Andrews *
5776fa9e4066Sahrens * Note that there are other restrictions embedded in:
5777fa9e4066Sahrens * zfs_create() - restrict type to VREG
5778fa9e4066Sahrens * zfs_link() - no links into/out of attribute space
5779fa9e4066Sahrens * zfs_rename() - no moves into/out of attribute space
5780fa9e4066Sahrens */
5781fa9e4066Sahrens const fs_operation_def_t zfs_xdvnodeops_template[] = {
5782aa59c4cbSrsb VOPNAME_OPEN, { .vop_open = zfs_open },
5783aa59c4cbSrsb VOPNAME_CLOSE, { .vop_close = zfs_close },
5784aa59c4cbSrsb VOPNAME_IOCTL, { .vop_ioctl = zfs_ioctl },
5785aa59c4cbSrsb VOPNAME_GETATTR, { .vop_getattr = zfs_getattr },
5786aa59c4cbSrsb VOPNAME_SETATTR, { .vop_setattr = zfs_setattr },
5787aa59c4cbSrsb VOPNAME_ACCESS, { .vop_access = zfs_access },
5788aa59c4cbSrsb VOPNAME_LOOKUP, { .vop_lookup = zfs_lookup },
5789aa59c4cbSrsb VOPNAME_CREATE, { .vop_create = zfs_create },
5790aa59c4cbSrsb VOPNAME_REMOVE, { .vop_remove = zfs_remove },
5791aa59c4cbSrsb VOPNAME_LINK, { .vop_link = zfs_link },
5792aa59c4cbSrsb VOPNAME_RENAME, { .vop_rename = zfs_rename },
5793aa59c4cbSrsb VOPNAME_MKDIR, { .error = zfs_inval },
5794aa59c4cbSrsb VOPNAME_RMDIR, { .vop_rmdir = zfs_rmdir },
5795aa59c4cbSrsb VOPNAME_READDIR, { .vop_readdir = zfs_readdir },
5796aa59c4cbSrsb VOPNAME_SYMLINK, { .error = zfs_inval },
5797aa59c4cbSrsb VOPNAME_FSYNC, { .vop_fsync = zfs_fsync },
5798aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive },
5799aa59c4cbSrsb VOPNAME_FID, { .vop_fid = zfs_fid },
5800aa59c4cbSrsb VOPNAME_SEEK, { .vop_seek = zfs_seek },
5801aa59c4cbSrsb VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf },
5802aa59c4cbSrsb VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr },
5803aa59c4cbSrsb VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr },
5804aa59c4cbSrsb VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
5805fa9e4066Sahrens NULL, NULL
5806fa9e4066Sahrens };
5807fa9e4066Sahrens
5808fa9e4066Sahrens /*
5809fa9e4066Sahrens * Error vnode operations template
5810fa9e4066Sahrens */
5811fa9e4066Sahrens const fs_operation_def_t zfs_evnodeops_template[] = {
5812aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive },
5813aa59c4cbSrsb VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf },
5814fa9e4066Sahrens NULL, NULL
5815fa9e4066Sahrens };
5816