Deleted Added
sdiff udiff text old ( 209097 ) new ( 209962 )
full compact
zfs_vnops.c (209097) zfs_vnops.c (209962)
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 5 unchanged lines hidden (view full) ---

14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 5 unchanged lines hidden (view full) ---

14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26/* Portions Copyright 2007 Jeremy Teo */
27
28#include <sys/types.h>
29#include <sys/param.h>
30#include <sys/time.h>

--- 20 unchanged lines hidden (view full) ---

51#include <sys/spa.h>
52#include <sys/txg.h>
53#include <sys/dbuf.h>
54#include <sys/zap.h>
55#include <sys/dirent.h>
56#include <sys/policy.h>
57#include <sys/sunddi.h>
58#include <sys/filio.h>
23 * Use is subject to license terms.
24 */
25
26/* Portions Copyright 2007 Jeremy Teo */
27
28#include <sys/types.h>
29#include <sys/param.h>
30#include <sys/time.h>

--- 20 unchanged lines hidden (view full) ---

51#include <sys/spa.h>
52#include <sys/txg.h>
53#include <sys/dbuf.h>
54#include <sys/zap.h>
55#include <sys/dirent.h>
56#include <sys/policy.h>
57#include <sys/sunddi.h>
58#include <sys/filio.h>
59#include <sys/sid.h>
59#include <sys/zfs_ctldir.h>
60#include <sys/zfs_fuid.h>
61#include <sys/dnlc.h>
62#include <sys/zfs_rlock.h>
63#include <sys/extdirent.h>
64#include <sys/kidmap.h>
65#include <sys/bio.h>
66#include <sys/buf.h>

--- 26 unchanged lines hidden (view full) ---

93 * pushing cached pages (which acquires range locks) and syncing out
94 * cached atime changes. Third, zfs_zinactive() may require a new tx,
95 * which could deadlock the system if you were already holding one.
96 * If you must call VN_RELE() within a tx then use VN_RELE_ASYNC().
97 *
98 * (3) All range locks must be grabbed before calling dmu_tx_assign(),
99 * as they can span dmu_tx_assign() calls.
100 *
60#include <sys/zfs_ctldir.h>
61#include <sys/zfs_fuid.h>
62#include <sys/dnlc.h>
63#include <sys/zfs_rlock.h>
64#include <sys/extdirent.h>
65#include <sys/kidmap.h>
66#include <sys/bio.h>
67#include <sys/buf.h>

--- 26 unchanged lines hidden (view full) ---

94 * pushing cached pages (which acquires range locks) and syncing out
95 * cached atime changes. Third, zfs_zinactive() may require a new tx,
96 * which could deadlock the system if you were already holding one.
97 * If you must call VN_RELE() within a tx then use VN_RELE_ASYNC().
98 *
99 * (3) All range locks must be grabbed before calling dmu_tx_assign(),
100 * as they can span dmu_tx_assign() calls.
101 *
101 * (4) Always pass zfsvfs->z_assign as the second argument to dmu_tx_assign().
102 * In normal operation, this will be TXG_NOWAIT. During ZIL replay,
103 * it will be a specific txg. Either way, dmu_tx_assign() never blocks.
102 * (4) Always pass TXG_NOWAIT as the second argument to dmu_tx_assign().
104 * This is critical because we don't want to block while holding locks.
105 * Note, in particular, that if a lock is sometimes acquired before
106 * the tx assigns, and sometimes after (e.g. z_lock), then failing to
107 * use a non-blocking assign can deadlock the system. The scenario:
108 *
109 * Thread A has grabbed a lock before calling dmu_tx_assign().
110 * Thread B is in an already-assigned tx, and blocks for this lock.
111 * Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()
112 * forever, because the previous txg can't quiesce until B's tx commits.
113 *
114 * If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT,
115 * then drop all locks, call dmu_tx_wait(), and try again.
116 *
117 * (5) If the operation succeeded, generate the intent log entry for it
118 * before dropping locks. This ensures that the ordering of events
119 * in the intent log matches the order in which they actually occurred.
103 * This is critical because we don't want to block while holding locks.
104 * Note, in particular, that if a lock is sometimes acquired before
105 * the tx assigns, and sometimes after (e.g. z_lock), then failing to
106 * use a non-blocking assign can deadlock the system. The scenario:
107 *
108 * Thread A has grabbed a lock before calling dmu_tx_assign().
109 * Thread B is in an already-assigned tx, and blocks for this lock.
110 * Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()
111 * forever, because the previous txg can't quiesce until B's tx commits.
112 *
113 * If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT,
114 * then drop all locks, call dmu_tx_wait(), and try again.
115 *
116 * (5) If the operation succeeded, generate the intent log entry for it
117 * before dropping locks. This ensures that the ordering of events
118 * in the intent log matches the order in which they actually occurred.
119 * During ZIL replay the zfs_log_* functions will update the sequence
120 * number to indicate the zil transaction has replayed.
120 *
121 * (6) At the end of each vnode op, the DMU tx must always commit,
122 * regardless of whether there were any errors.
123 *
124 * (7) After dropping all locks, invoke zil_commit(zilog, seq, foid)
125 * to ensure that synchronous semantics are provided when necessary.
126 *
127 * In general, this is how things should be ordered in each vnode op:
128 *
129 * ZFS_ENTER(zfsvfs); // exit if unmounted
130 * top:
131 * zfs_dirent_lock(&dl, ...) // lock directory entry (may VN_HOLD())
132 * rw_enter(...); // grab any other locks you need
133 * tx = dmu_tx_create(...); // get DMU tx
134 * dmu_tx_hold_*(); // hold each object you might modify
121 *
122 * (6) At the end of each vnode op, the DMU tx must always commit,
123 * regardless of whether there were any errors.
124 *
125 * (7) After dropping all locks, invoke zil_commit(zilog, seq, foid)
126 * to ensure that synchronous semantics are provided when necessary.
127 *
128 * In general, this is how things should be ordered in each vnode op:
129 *
130 * ZFS_ENTER(zfsvfs); // exit if unmounted
131 * top:
132 * zfs_dirent_lock(&dl, ...) // lock directory entry (may VN_HOLD())
133 * rw_enter(...); // grab any other locks you need
134 * tx = dmu_tx_create(...); // get DMU tx
135 * dmu_tx_hold_*(); // hold each object you might modify
135 * error = dmu_tx_assign(tx, zfsvfs->z_assign); // try to assign
136 * error = dmu_tx_assign(tx, TXG_NOWAIT); // try to assign
136 * if (error) {
137 * rw_exit(...); // drop locks
138 * zfs_dirent_unlock(dl); // unlock directory entry
139 * VN_RELE(...); // release held vnodes
137 * if (error) {
138 * rw_exit(...); // drop locks
139 * zfs_dirent_unlock(dl); // unlock directory entry
140 * VN_RELE(...); // release held vnodes
140 * if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
141 * if (error == ERESTART) {
141 * dmu_tx_wait(tx);
142 * dmu_tx_abort(tx);
143 * goto top;
144 * }
145 * dmu_tx_abort(tx); // abort DMU tx
146 * ZFS_EXIT(zfsvfs); // finished in zfs
147 * return (error); // really out of space
148 * }

--- 9 unchanged lines hidden (view full) ---

158 * return (error); // done, report error
159 */
160
161/* ARGSUSED */
162static int
163zfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
164{
165 znode_t *zp = VTOZ(*vpp);
142 * dmu_tx_wait(tx);
143 * dmu_tx_abort(tx);
144 * goto top;
145 * }
146 * dmu_tx_abort(tx); // abort DMU tx
147 * ZFS_EXIT(zfsvfs); // finished in zfs
148 * return (error); // really out of space
149 * }

--- 9 unchanged lines hidden (view full) ---

159 * return (error); // done, report error
160 */
161
162/* ARGSUSED */
163static int
164zfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
165{
166 znode_t *zp = VTOZ(*vpp);
167 zfsvfs_t *zfsvfs = zp->z_zfsvfs;
166
168
169 ZFS_ENTER(zfsvfs);
170 ZFS_VERIFY_ZP(zp);
171
167 if ((flag & FWRITE) && (zp->z_phys->zp_flags & ZFS_APPENDONLY) &&
168 ((flag & FAPPEND) == 0)) {
172 if ((flag & FWRITE) && (zp->z_phys->zp_flags & ZFS_APPENDONLY) &&
173 ((flag & FAPPEND) == 0)) {
174 ZFS_EXIT(zfsvfs);
169 return (EPERM);
170 }
171
172 if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
173 ZTOV(zp)->v_type == VREG &&
174 !(zp->z_phys->zp_flags & ZFS_AV_QUARANTINED) &&
175 return (EPERM);
176 }
177
178 if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
179 ZTOV(zp)->v_type == VREG &&
180 !(zp->z_phys->zp_flags & ZFS_AV_QUARANTINED) &&
175 zp->z_phys->zp_size > 0)
176 if (fs_vscan(*vpp, cr, 0) != 0)
181 zp->z_phys->zp_size > 0) {
182 if (fs_vscan(*vpp, cr, 0) != 0) {
183 ZFS_EXIT(zfsvfs);
177 return (EACCES);
184 return (EACCES);
185 }
186 }
178
179 /* Keep a count of the synchronous opens in the znode */
180 if (flag & (FSYNC | FDSYNC))
181 atomic_inc_32(&zp->z_sync_cnt);
182
187
188 /* Keep a count of the synchronous opens in the znode */
189 if (flag & (FSYNC | FDSYNC))
190 atomic_inc_32(&zp->z_sync_cnt);
191
192 ZFS_EXIT(zfsvfs);
183 return (0);
184}
185
186/* ARGSUSED */
187static int
188zfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
189 caller_context_t *ct)
190{
191 znode_t *zp = VTOZ(vp);
193 return (0);
194}
195
196/* ARGSUSED */
197static int
198zfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
199 caller_context_t *ct)
200{
201 znode_t *zp = VTOZ(vp);
202 zfsvfs_t *zfsvfs = zp->z_zfsvfs;
192
203
204 ZFS_ENTER(zfsvfs);
205 ZFS_VERIFY_ZP(zp);
206
193 /* Decrement the synchronous opens in the znode */
194 if ((flag & (FSYNC | FDSYNC)) && (count == 1))
195 atomic_dec_32(&zp->z_sync_cnt);
196
197 /*
198 * Clean up any locks held by this process on the vp.
199 */
200 cleanlocks(vp, ddi_get_pid(), 0);
201 cleanshares(vp, ddi_get_pid());
202
203 if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
204 ZTOV(zp)->v_type == VREG &&
205 !(zp->z_phys->zp_flags & ZFS_AV_QUARANTINED) &&
206 zp->z_phys->zp_size > 0)
207 VERIFY(fs_vscan(vp, cr, 1) == 0);
208
207 /* Decrement the synchronous opens in the znode */
208 if ((flag & (FSYNC | FDSYNC)) && (count == 1))
209 atomic_dec_32(&zp->z_sync_cnt);
210
211 /*
212 * Clean up any locks held by this process on the vp.
213 */
214 cleanlocks(vp, ddi_get_pid(), 0);
215 cleanshares(vp, ddi_get_pid());
216
217 if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
218 ZTOV(zp)->v_type == VREG &&
219 !(zp->z_phys->zp_flags & ZFS_AV_QUARANTINED) &&
220 zp->z_phys->zp_size > 0)
221 VERIFY(fs_vscan(vp, cr, 1) == 0);
222
223 ZFS_EXIT(zfsvfs);
209 return (0);
210}
211
212/*
213 * Lseek support for finding holes (cmd == _FIO_SEEK_HOLE) and
214 * data (cmd == _FIO_SEEK_DATA). "off" is an in/out parameter.
215 */
216static int

--- 74 unchanged lines hidden (view full) ---

291 return (error);
292 if (ddi_copyout(&off, (void *)data, sizeof (off), flag))
293 return (EFAULT);
294 return (0);
295 }
296 return (ENOTTY);
297}
298
224 return (0);
225}
226
227/*
228 * Lseek support for finding holes (cmd == _FIO_SEEK_HOLE) and
229 * data (cmd == _FIO_SEEK_DATA). "off" is an in/out parameter.
230 */
231static int

--- 74 unchanged lines hidden (view full) ---

306 return (error);
307 if (ddi_copyout(&off, (void *)data, sizeof (off), flag))
308 return (EFAULT);
309 return (0);
310 }
311 return (ENOTTY);
312}
313
314static vm_page_t
315page_lookup(vnode_t *vp, int64_t start, int64_t off, int64_t nbytes)
316{
317 vm_object_t obj;
318 vm_page_t pp;
319
320 obj = vp->v_object;
321 VM_OBJECT_LOCK_ASSERT(obj, MA_OWNED);
322
323 for (;;) {
324 if ((pp = vm_page_lookup(obj, OFF_TO_IDX(start))) != NULL &&
325 vm_page_is_valid(pp, (vm_offset_t)off, nbytes)) {
326 if (vm_page_sleep_if_busy(pp, FALSE, "zfsmwb"))
327 continue;
328 vm_page_busy(pp);
329 vm_page_lock_queues();
330 vm_page_undirty(pp);
331 vm_page_unlock_queues();
332 } else {
333 if (__predict_false(obj->cache != NULL)) {
334 vm_page_cache_free(obj, OFF_TO_IDX(start),
335 OFF_TO_IDX(start) + 1);
336 }
337 pp = NULL;
338 }
339 break;
340 }
341 return (pp);
342}
343
344static void
345page_unlock(vm_page_t pp)
346{
347
348 vm_page_wakeup(pp);
349}
350
351static caddr_t
352zfs_map_page(vm_page_t pp, struct sf_buf **sfp)
353{
354
355 sched_pin();
356 *sfp = sf_buf_alloc(pp, SFB_CPUPRIVATE);
357 return ((caddr_t)sf_buf_kva(*sfp));
358}
359
360static void
361zfs_unmap_page(struct sf_buf *sf)
362{
363
364 sf_buf_free(sf);
365 sched_unpin();
366}
367
368
299/*
300 * When a file is memory mapped, we must keep the IO data synchronized
301 * between the DMU cache and the memory mapped pages. What this means:
302 *
303 * On Write: If we find a memory mapped page, we write to *both*
304 * the page and the dmu buffer.
369/*
370 * When a file is memory mapped, we must keep the IO data synchronized
371 * between the DMU cache and the memory mapped pages. What this means:
372 *
373 * On Write: If we find a memory mapped page, we write to *both*
374 * the page and the dmu buffer.
305 *
306 * NOTE: We will always "break up" the IO into PAGESIZE uiomoves when
307 * the file is memory mapped.
308 */
375 */
309static int
310mappedwrite(vnode_t *vp, int nbytes, uio_t *uio, dmu_tx_t *tx)
376
377static void
378update_pages(vnode_t *vp, int64_t start, int len, objset_t *os, uint64_t oid,
379 int segflg, dmu_tx_t *tx)
311{
380{
312 znode_t *zp = VTOZ(vp);
313 objset_t *os = zp->z_zfsvfs->z_os;
314 vm_object_t obj;
381 vm_object_t obj;
315 vm_page_t m;
316 struct sf_buf *sf;
382 struct sf_buf *sf;
317 int64_t start, off;
318 int len = nbytes;
319 int error = 0;
320 uint64_t dirbytes;
383 int64_t off;
321
322 ASSERT(vp->v_mount != NULL);
323 obj = vp->v_object;
324 ASSERT(obj != NULL);
325
384
385 ASSERT(vp->v_mount != NULL);
386 obj = vp->v_object;
387 ASSERT(obj != NULL);
388
326 start = uio->uio_loffset;
327 off = start & PAGEOFFSET;
389 off = start & PAGEOFFSET;
328 dirbytes = 0;
329 VM_OBJECT_LOCK(obj);
330 for (start &= PAGEMASK; len > 0; start += PAGESIZE) {
390 VM_OBJECT_LOCK(obj);
391 for (start &= PAGEMASK; len > 0; start += PAGESIZE) {
331 uint64_t bytes = MIN(PAGESIZE - off, len);
332 uint64_t fsize;
392 vm_page_t pp;
393 uint64_t nbytes = MIN(PAGESIZE - off, len);
333
394
334again:
335 if ((m = vm_page_lookup(obj, OFF_TO_IDX(start))) != NULL &&
336 vm_page_is_valid(m, (vm_offset_t)off, bytes)) {
337 uint64_t woff;
395 if ((pp = page_lookup(vp, start, off, nbytes)) != NULL) {
338 caddr_t va;
339
396 caddr_t va;
397
340 if (vm_page_sleep_if_busy(m, FALSE, "zfsmwb"))
341 goto again;
342 fsize = obj->un_pager.vnp.vnp_size;
343 vm_page_busy(m);
344 vm_page_lock_queues();
345 vm_page_undirty(m);
346 vm_page_unlock_queues();
347 VM_OBJECT_UNLOCK(obj);
398 VM_OBJECT_UNLOCK(obj);
348 if (dirbytes > 0) {
349 error = dmu_write_uio(os, zp->z_id, uio,
350 dirbytes, tx);
351 dirbytes = 0;
399 va = zfs_map_page(pp, &sf);
400 if (segflg == UIO_NOCOPY) {
401 (void) dmu_write(os, oid, start+off, nbytes,
402 va+off, tx);
403 } else {
404 (void) dmu_read(os, oid, start+off, nbytes,
405 va+off, DMU_READ_PREFETCH);;
352 }
406 }
353 if (error == 0) {
354 sched_pin();
355 sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
356 va = (caddr_t)sf_buf_kva(sf);
357 woff = uio->uio_loffset - off;
358 error = uiomove(va + off, bytes, UIO_WRITE, uio);
359 /*
360 * The uiomove() above could have been partially
361 * successful, that's why we call dmu_write()
362 * below unconditionally. The page was marked
363 * non-dirty above and we would lose the changes
364 * without doing so. If the uiomove() failed
365 * entirely, well, we just write what we got
366 * before one more time.
367 */
368 dmu_write(os, zp->z_id, woff,
369 MIN(PAGESIZE, fsize - woff), va, tx);
370 sf_buf_free(sf);
371 sched_unpin();
372 }
407 zfs_unmap_page(sf);
373 VM_OBJECT_LOCK(obj);
408 VM_OBJECT_LOCK(obj);
374 vm_page_wakeup(m);
375 } else {
376 if (__predict_false(obj->cache != NULL)) {
377 vm_page_cache_free(obj, OFF_TO_IDX(start),
378 OFF_TO_IDX(start) + 1);
379 }
380 dirbytes += bytes;
409 page_unlock(pp);
410
381 }
411 }
382 len -= bytes;
412 len -= nbytes;
383 off = 0;
413 off = 0;
384 if (error)
385 break;
386 }
387 VM_OBJECT_UNLOCK(obj);
414 }
415 VM_OBJECT_UNLOCK(obj);
388 if (error == 0 && dirbytes > 0)
389 error = dmu_write_uio(os, zp->z_id, uio, dirbytes, tx);
390 return (error);
391}
392
393/*
394 * When a file is memory mapped, we must keep the IO data synchronized
395 * between the DMU cache and the memory mapped pages. What this means:
396 *
397 * On Read: We "read" preferentially from memory mapped pages,
398 * else we default from the dmu buffer.

--- 65 unchanged lines hidden (view full) ---

464 dirbytes);
465 dirbytes = 0;
466 }
467 if (error == 0) {
468 sched_pin();
469 sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
470 va = (caddr_t)sf_buf_kva(sf);
471 error = dmu_read(os, zp->z_id, start + off,
416}
417
418/*
419 * When a file is memory mapped, we must keep the IO data synchronized
420 * between the DMU cache and the memory mapped pages. What this means:
421 *
422 * On Read: We "read" preferentially from memory mapped pages,
423 * else we default from the dmu buffer.

--- 65 unchanged lines hidden (view full) ---

489 dirbytes);
490 dirbytes = 0;
491 }
492 if (error == 0) {
493 sched_pin();
494 sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
495 va = (caddr_t)sf_buf_kva(sf);
496 error = dmu_read(os, zp->z_id, start + off,
472 bytes, (void *)(va + off));
497 bytes, (void *)(va + off),
498 DMU_READ_PREFETCH);
473 sf_buf_free(sf);
474 sched_unpin();
475 }
476 VM_OBJECT_LOCK(obj);
477 vm_page_wakeup(m);
478 if (error == 0)
479 uio->uio_resid -= bytes;
480 } else {

--- 204 unchanged lines hidden (view full) ---

685 zfsvfs_t *zfsvfs = zp->z_zfsvfs;
686 zilog_t *zilog;
687 offset_t woff;
688 ssize_t n, nbytes;
689 rl_t *rl;
690 int max_blksz = zfsvfs->z_max_blksz;
691 uint64_t pflags;
692 int error;
499 sf_buf_free(sf);
500 sched_unpin();
501 }
502 VM_OBJECT_LOCK(obj);
503 vm_page_wakeup(m);
504 if (error == 0)
505 uio->uio_resid -= bytes;
506 } else {

--- 204 unchanged lines hidden (view full) ---

711 zfsvfs_t *zfsvfs = zp->z_zfsvfs;
712 zilog_t *zilog;
713 offset_t woff;
714 ssize_t n, nbytes;
715 rl_t *rl;
716 int max_blksz = zfsvfs->z_max_blksz;
717 uint64_t pflags;
718 int error;
719 arc_buf_t *abuf;
693
694 /*
695 * Fasttrack empty write
696 */
697 n = start_resid;
698 if (n == 0)
699 return (0);
700

--- 80 unchanged lines hidden (view full) ---

781 end_size = MAX(zp->z_phys->zp_size, woff + n);
782
783 /*
784 * Write the file in reasonable size chunks. Each chunk is written
785 * in a separate transaction; this keeps the intent log records small
786 * and allows us to do more fine-grained space accounting.
787 */
788 while (n > 0) {
720
721 /*
722 * Fasttrack empty write
723 */
724 n = start_resid;
725 if (n == 0)
726 return (0);
727

--- 80 unchanged lines hidden (view full) ---

808 end_size = MAX(zp->z_phys->zp_size, woff + n);
809
810 /*
811 * Write the file in reasonable size chunks. Each chunk is written
812 * in a separate transaction; this keeps the intent log records small
813 * and allows us to do more fine-grained space accounting.
814 */
815 while (n > 0) {
816 abuf = NULL;
817 woff = uio->uio_loffset;
818
819again:
820 if (zfs_usergroup_overquota(zfsvfs,
821 B_FALSE, zp->z_phys->zp_uid) ||
822 zfs_usergroup_overquota(zfsvfs,
823 B_TRUE, zp->z_phys->zp_gid)) {
824 if (abuf != NULL)
825 dmu_return_arcbuf(abuf);
826 error = EDQUOT;
827 break;
828 }
829
789 /*
830 /*
831 * If dmu_assign_arcbuf() is expected to execute with minimum
832 * overhead loan an arc buffer and copy user data to it before
833 * we enter a txg. This avoids holding a txg forever while we
834 * pagefault on a hanging NFS server mapping.
835 */
836 if (abuf == NULL && n >= max_blksz &&
837 woff >= zp->z_phys->zp_size &&
838 P2PHASE(woff, max_blksz) == 0 &&
839 zp->z_blksz == max_blksz) {
840 size_t cbytes;
841
842 abuf = dmu_request_arcbuf(zp->z_dbuf, max_blksz);
843 ASSERT(abuf != NULL);
844 ASSERT(arc_buf_size(abuf) == max_blksz);
845 if (error = uiocopy(abuf->b_data, max_blksz,
846 UIO_WRITE, uio, &cbytes)) {
847 dmu_return_arcbuf(abuf);
848 break;
849 }
850 ASSERT(cbytes == max_blksz);
851 }
852
853 /*
790 * Start a transaction.
791 */
854 * Start a transaction.
855 */
792 woff = uio->uio_loffset;
793 tx = dmu_tx_create(zfsvfs->z_os);
794 dmu_tx_hold_bonus(tx, zp->z_id);
795 dmu_tx_hold_write(tx, zp->z_id, woff, MIN(n, max_blksz));
856 tx = dmu_tx_create(zfsvfs->z_os);
857 dmu_tx_hold_bonus(tx, zp->z_id);
858 dmu_tx_hold_write(tx, zp->z_id, woff, MIN(n, max_blksz));
796 error = dmu_tx_assign(tx, zfsvfs->z_assign);
859 error = dmu_tx_assign(tx, TXG_NOWAIT);
797 if (error) {
860 if (error) {
798 if (error == ERESTART &&
799 zfsvfs->z_assign == TXG_NOWAIT) {
861 if (error == ERESTART) {
800 dmu_tx_wait(tx);
801 dmu_tx_abort(tx);
862 dmu_tx_wait(tx);
863 dmu_tx_abort(tx);
802 continue;
864 goto again;
803 }
804 dmu_tx_abort(tx);
865 }
866 dmu_tx_abort(tx);
867 if (abuf != NULL)
868 dmu_return_arcbuf(abuf);
805 break;
806 }
807
808 /*
809 * If zfs_range_lock() over-locked we grow the blocksize
810 * and then reduce the lock range. This will only happen
811 * on the first iteration since zfs_range_reduce() will
812 * shrink down r_len to the appropriate size.

--- 15 unchanged lines hidden (view full) ---

828 * XXX - should we really limit each write to z_max_blksz?
829 * Perhaps we should use SPA_MAXBLOCKSIZE chunks?
830 */
831 nbytes = MIN(n, max_blksz - P2PHASE(woff, max_blksz));
832
833 if (woff + nbytes > zp->z_phys->zp_size)
834 vnode_pager_setsize(vp, woff + nbytes);
835
869 break;
870 }
871
872 /*
873 * If zfs_range_lock() over-locked we grow the blocksize
874 * and then reduce the lock range. This will only happen
875 * on the first iteration since zfs_range_reduce() will
876 * shrink down r_len to the appropriate size.

--- 15 unchanged lines hidden (view full) ---

892 * XXX - should we really limit each write to z_max_blksz?
893 * Perhaps we should use SPA_MAXBLOCKSIZE chunks?
894 */
895 nbytes = MIN(n, max_blksz - P2PHASE(woff, max_blksz));
896
897 if (woff + nbytes > zp->z_phys->zp_size)
898 vnode_pager_setsize(vp, woff + nbytes);
899
836 rw_enter(&zp->z_map_lock, RW_READER);
837
838 tx_bytes = uio->uio_resid;
839 if (vn_has_cached_data(vp)) {
840 rw_exit(&zp->z_map_lock);
841 error = mappedwrite(vp, nbytes, uio, tx);
900 if (abuf == NULL) {
901 tx_bytes = uio->uio_resid;
902 error = dmu_write_uio(zfsvfs->z_os, zp->z_id, uio,
903 nbytes, tx);
904 tx_bytes -= uio->uio_resid;
842 } else {
905 } else {
843 error = dmu_write_uio(zfsvfs->z_os, zp->z_id,
844 uio, nbytes, tx);
845 rw_exit(&zp->z_map_lock);
906 tx_bytes = nbytes;
907 ASSERT(tx_bytes == max_blksz);
908 dmu_assign_arcbuf(zp->z_dbuf, woff, abuf, tx);
909 ASSERT(tx_bytes <= uio->uio_resid);
910 uioskip(uio, tx_bytes);
846 }
911 }
847 tx_bytes -= uio->uio_resid;
848
849 /*
912
913 /*
914 * XXXPJD: There are some cases (triggered by fsx) where
915 * vn_has_cached_data(vp) returns false when it should
916 * return true. This should be investigated.
917 */
918#if 0
919 if (tx_bytes && vn_has_cached_data(vp))
920#else
921 if (tx_bytes && vp->v_object != NULL)
922#endif
923 {
924 update_pages(vp, woff, tx_bytes, zfsvfs->z_os,
925 zp->z_id, uio->uio_segflg, tx);
926 }
927
928 /*
850 * If we made no progress, we're done. If we made even
851 * partial progress, update the znode and ZIL accordingly.
852 */
853 if (tx_bytes == 0) {
854 dmu_tx_commit(tx);
855 ASSERT(error != 0);
856 break;
857 }

--- 43 unchanged lines hidden (view full) ---

901 }
902
903 zfs_range_unlock(rl);
904
905 /*
906 * If we're in replay mode, or we made no progress, return error.
907 * Otherwise, it's at least a partial write, so it's successful.
908 */
929 * If we made no progress, we're done. If we made even
930 * partial progress, update the znode and ZIL accordingly.
931 */
932 if (tx_bytes == 0) {
933 dmu_tx_commit(tx);
934 ASSERT(error != 0);
935 break;
936 }

--- 43 unchanged lines hidden (view full) ---

980 }
981
982 zfs_range_unlock(rl);
983
984 /*
985 * If we're in replay mode, or we made no progress, return error.
986 * Otherwise, it's at least a partial write, so it's successful.
987 */
909 if (zfsvfs->z_assign >= TXG_INITIAL || uio->uio_resid == start_resid) {
988 if (zfsvfs->z_replay || uio->uio_resid == start_resid) {
910 ZFS_EXIT(zfsvfs);
911 return (error);
912 }
913
914 if (ioflag & (FSYNC | FDSYNC))
915 zil_commit(zilog, zp->z_last_itx, zp->z_id);
916
917 ZFS_EXIT(zfsvfs);

--- 65 unchanged lines hidden (view full) ---

983 */
984 if (buf != NULL) { /* immediate write */
985 rl = zfs_range_lock(zp, off, dlen, RL_READER);
986 /* test for truncation needs to be done while range locked */
987 if (off >= zp->z_phys->zp_size) {
988 error = ENOENT;
989 goto out;
990 }
989 ZFS_EXIT(zfsvfs);
990 return (error);
991 }
992
993 if (ioflag & (FSYNC | FDSYNC))
994 zil_commit(zilog, zp->z_last_itx, zp->z_id);
995
996 ZFS_EXIT(zfsvfs);

--- 65 unchanged lines hidden (view full) ---

1062 */
1063 if (buf != NULL) { /* immediate write */
1064 rl = zfs_range_lock(zp, off, dlen, RL_READER);
1065 /* test for truncation needs to be done while range locked */
1066 if (off >= zp->z_phys->zp_size) {
1067 error = ENOENT;
1068 goto out;
1069 }
991 VERIFY(0 == dmu_read(os, lr->lr_foid, off, dlen, buf));
1070 VERIFY(0 == dmu_read(os, lr->lr_foid, off, dlen, buf,
1071 DMU_READ_NO_PREFETCH));
992 } else { /* indirect write */
993 uint64_t boff; /* block starting offset */
994
995 /*
996 * Have to lock the whole block to ensure when it's
997 * written out and it's checksum is being calculated
998 * that no one can change the data. We need to re-check
999 * blocksize after we get the lock in case it's changed!

--- 22 unchanged lines hidden (view full) ---

1022 zgd->zgd_bp = &lr->lr_blkptr;
1023 VERIFY(0 == dmu_buf_hold(os, lr->lr_foid, boff, zgd, &db));
1024 ASSERT(boff == db->db_offset);
1025 lr->lr_blkoff = off - boff;
1026 error = dmu_sync(zio, db, &lr->lr_blkptr,
1027 lr->lr_common.lrc_txg, zfs_get_done, zgd);
1028 ASSERT((error && error != EINPROGRESS) ||
1029 lr->lr_length <= zp->z_blksz);
1072 } else { /* indirect write */
1073 uint64_t boff; /* block starting offset */
1074
1075 /*
1076 * Have to lock the whole block to ensure when it's
1077 * written out and it's checksum is being calculated
1078 * that no one can change the data. We need to re-check
1079 * blocksize after we get the lock in case it's changed!

--- 22 unchanged lines hidden (view full) ---

1102 zgd->zgd_bp = &lr->lr_blkptr;
1103 VERIFY(0 == dmu_buf_hold(os, lr->lr_foid, boff, zgd, &db));
1104 ASSERT(boff == db->db_offset);
1105 lr->lr_blkoff = off - boff;
1106 error = dmu_sync(zio, db, &lr->lr_blkptr,
1107 lr->lr_common.lrc_txg, zfs_get_done, zgd);
1108 ASSERT((error && error != EINPROGRESS) ||
1109 lr->lr_length <= zp->z_blksz);
1030 if (error == 0)
1110 if (error == 0) {
1111 /*
1112 * dmu_sync() can compress a block of zeros to a null
1113 * blkptr but the block size still needs to be passed
1114 * through to replay.
1115 */
1116 BP_SET_LSIZE(&lr->lr_blkptr, db->db_size);
1031 zil_add_block(zfsvfs->z_log, &lr->lr_blkptr);
1117 zil_add_block(zfsvfs->z_log, &lr->lr_blkptr);
1118 }
1119
1032 /*
1033 * If we get EINPROGRESS, then we need to wait for a
1034 * write IO initiated by dmu_sync() to complete before
1035 * we can release this dbuf. We will finish everything
1036 * up in the zfs_get_done() callback.
1037 */
1120 /*
1121 * If we get EINPROGRESS, then we need to wait for a
1122 * write IO initiated by dmu_sync() to complete before
1123 * we can release this dbuf. We will finish everything
1124 * up in the zfs_get_done() callback.
1125 */
1038 if (error == EINPROGRESS)
1126 if (error == EINPROGRESS) {
1039 return (0);
1127 return (0);
1128 } else if (error == EALREADY) {
1129 lr->lr_common.lrc_txtype = TX_WRITE2;
1130 error = 0;
1131 }
1040 dmu_buf_rele(db, zgd);
1041 kmem_free(zgd, sizeof (zgd_t));
1042 }
1043out:
1044 zfs_range_unlock(rl);
1045 /*
1046 * Release the vnode asynchronously as we currently have the
1047 * txg stopped from syncing.

--- 226 unchanged lines hidden (view full) ---

1274{
1275 znode_t *zp, *dzp = VTOZ(dvp);
1276 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
1277 zilog_t *zilog;
1278 objset_t *os;
1279 zfs_dirlock_t *dl;
1280 dmu_tx_t *tx;
1281 int error;
1132 dmu_buf_rele(db, zgd);
1133 kmem_free(zgd, sizeof (zgd_t));
1134 }
1135out:
1136 zfs_range_unlock(rl);
1137 /*
1138 * Release the vnode asynchronously as we currently have the
1139 * txg stopped from syncing.

--- 226 unchanged lines hidden (view full) ---

1366{
1367 znode_t *zp, *dzp = VTOZ(dvp);
1368 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
1369 zilog_t *zilog;
1370 objset_t *os;
1371 zfs_dirlock_t *dl;
1372 dmu_tx_t *tx;
1373 int error;
1282 zfs_acl_t *aclp = NULL;
1283 zfs_fuid_info_t *fuidp = NULL;
1374 ksid_t *ksid;
1375 uid_t uid;
1376 gid_t gid = crgetgid(cr);
1377 zfs_acl_ids_t acl_ids;
1378 boolean_t fuid_dirtied;
1284 void *vsecp = NULL;
1285 int flag = 0;
1286
1287 /*
1288 * If we have an ephemeral id, ACL, or XVATTR then
1289 * make sure file system is at proper version
1290 */
1291
1379 void *vsecp = NULL;
1380 int flag = 0;
1381
1382 /*
1383 * If we have an ephemeral id, ACL, or XVATTR then
1384 * make sure file system is at proper version
1385 */
1386
1387 ksid = crgetsid(cr, KSID_OWNER);
1388 if (ksid)
1389 uid = ksid_getid(ksid);
1390 else
1391 uid = crgetuid(cr);
1292 if (zfsvfs->z_use_fuids == B_FALSE &&
1293 (vsecp || (vap->va_mask & AT_XVATTR) ||
1294 IS_EPHEMERAL(crgetuid(cr)) || IS_EPHEMERAL(crgetgid(cr))))
1295 return (EINVAL);
1296
1297 ZFS_ENTER(zfsvfs);
1298 ZFS_VERIFY_ZP(dzp);
1299 os = zfsvfs->z_os;

--- 34 unchanged lines hidden (view full) ---

1334 zflg |= ZCILOOK;
1335
1336 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
1337 NULL, NULL);
1338 if (error) {
1339 if (strcmp(name, "..") == 0)
1340 error = EISDIR;
1341 ZFS_EXIT(zfsvfs);
1392 if (zfsvfs->z_use_fuids == B_FALSE &&
1393 (vsecp || (vap->va_mask & AT_XVATTR) ||
1394 IS_EPHEMERAL(crgetuid(cr)) || IS_EPHEMERAL(crgetgid(cr))))
1395 return (EINVAL);
1396
1397 ZFS_ENTER(zfsvfs);
1398 ZFS_VERIFY_ZP(dzp);
1399 os = zfsvfs->z_os;

--- 34 unchanged lines hidden (view full) ---

1434 zflg |= ZCILOOK;
1435
1436 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
1437 NULL, NULL);
1438 if (error) {
1439 if (strcmp(name, "..") == 0)
1440 error = EISDIR;
1441 ZFS_EXIT(zfsvfs);
1342 if (aclp)
1343 zfs_acl_free(aclp);
1344 return (error);
1345 }
1346 }
1442 return (error);
1443 }
1444 }
1347 if (vsecp && aclp == NULL) {
1348 error = zfs_vsec_2_aclp(zfsvfs, vap->va_type, vsecp, &aclp);
1349 if (error) {
1350 ZFS_EXIT(zfsvfs);
1351 if (dl)
1352 zfs_dirent_unlock(dl);
1353 return (error);
1354 }
1355 }
1356
1357 if (zp == NULL) {
1358 uint64_t txtype;
1359
1360 /*
1361 * Create a new file object and update the directory
1362 * to reference it.
1363 */
1364 if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) {

--- 5 unchanged lines hidden (view full) ---

1370 * extended attribute directories.
1371 */
1372 if ((dzp->z_phys->zp_flags & ZFS_XATTR) &&
1373 (vap->va_type != VREG)) {
1374 error = EINVAL;
1375 goto out;
1376 }
1377
1445 if (zp == NULL) {
1446 uint64_t txtype;
1447
1448 /*
1449 * Create a new file object and update the directory
1450 * to reference it.
1451 */
1452 if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) {

--- 5 unchanged lines hidden (view full) ---

1458 * extended attribute directories.
1459 */
1460 if ((dzp->z_phys->zp_flags & ZFS_XATTR) &&
1461 (vap->va_type != VREG)) {
1462 error = EINVAL;
1463 goto out;
1464 }
1465
1466
1467 if ((error = zfs_acl_ids_create(dzp, 0, vap, cr, vsecp,
1468 &acl_ids)) != 0)
1469 goto out;
1470 if (zfs_acl_ids_overquota(zfsvfs, &acl_ids)) {
1471 error = EDQUOT;
1472 goto out;
1473 }
1474
1378 tx = dmu_tx_create(os);
1379 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1475 tx = dmu_tx_create(os);
1476 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1380 if ((aclp && aclp->z_has_fuids) || IS_EPHEMERAL(crgetuid(cr)) ||
1381 IS_EPHEMERAL(crgetgid(cr))) {
1382 if (zfsvfs->z_fuid_obj == 0) {
1383 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1384 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
1385 FUID_SIZE_ESTIMATE(zfsvfs));
1386 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ,
1387 FALSE, NULL);
1388 } else {
1389 dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj);
1390 dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0,
1391 FUID_SIZE_ESTIMATE(zfsvfs));
1392 }
1393 }
1477 fuid_dirtied = zfsvfs->z_fuid_dirty;
1478 if (fuid_dirtied)
1479 zfs_fuid_txhold(zfsvfs, tx);
1394 dmu_tx_hold_bonus(tx, dzp->z_id);
1395 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
1480 dmu_tx_hold_bonus(tx, dzp->z_id);
1481 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
1396 if ((dzp->z_phys->zp_flags & ZFS_INHERIT_ACE) || aclp) {
1482 if (acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
1397 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
1398 0, SPA_MAXBLOCKSIZE);
1399 }
1483 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
1484 0, SPA_MAXBLOCKSIZE);
1485 }
1400 error = dmu_tx_assign(tx, zfsvfs->z_assign);
1486 error = dmu_tx_assign(tx, TXG_NOWAIT);
1401 if (error) {
1487 if (error) {
1488 zfs_acl_ids_free(&acl_ids);
1402 zfs_dirent_unlock(dl);
1489 zfs_dirent_unlock(dl);
1403 if (error == ERESTART &&
1404 zfsvfs->z_assign == TXG_NOWAIT) {
1490 if (error == ERESTART) {
1405 dmu_tx_wait(tx);
1406 dmu_tx_abort(tx);
1407 goto top;
1408 }
1409 dmu_tx_abort(tx);
1410 ZFS_EXIT(zfsvfs);
1491 dmu_tx_wait(tx);
1492 dmu_tx_abort(tx);
1493 goto top;
1494 }
1495 dmu_tx_abort(tx);
1496 ZFS_EXIT(zfsvfs);
1411 if (aclp)
1412 zfs_acl_free(aclp);
1413 return (error);
1414 }
1497 return (error);
1498 }
1415 zfs_mknode(dzp, vap, tx, cr, 0, &zp, 0, aclp, &fuidp);
1499 zfs_mknode(dzp, vap, tx, cr, 0, &zp, 0, &acl_ids);
1500
1501 if (fuid_dirtied)
1502 zfs_fuid_sync(zfsvfs, tx);
1503
1416 (void) zfs_link_create(dl, zp, tx, ZNEW);
1504 (void) zfs_link_create(dl, zp, tx, ZNEW);
1505
1417 txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap);
1418 if (flag & FIGNORECASE)
1419 txtype |= TX_CI;
1420 zfs_log_create(zilog, tx, txtype, dzp, zp, name,
1506 txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap);
1507 if (flag & FIGNORECASE)
1508 txtype |= TX_CI;
1509 zfs_log_create(zilog, tx, txtype, dzp, zp, name,
1421 vsecp, fuidp, vap);
1422 if (fuidp)
1423 zfs_fuid_info_free(fuidp);
1510 vsecp, acl_ids.z_fuidp, vap);
1511 zfs_acl_ids_free(&acl_ids);
1424 dmu_tx_commit(tx);
1425 } else {
1426 int aflags = (flag & FAPPEND) ? V_APPEND : 0;
1427
1428 /*
1429 * A directory entry already exists for this name.
1430 */
1431 /*

--- 53 unchanged lines hidden (view full) ---

1485 svp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr);
1486 VN_RELE(*vpp);
1487 if (svp == NULL) {
1488 error = ENOSYS;
1489 }
1490 *vpp = svp;
1491 }
1492 }
1512 dmu_tx_commit(tx);
1513 } else {
1514 int aflags = (flag & FAPPEND) ? V_APPEND : 0;
1515
1516 /*
1517 * A directory entry already exists for this name.
1518 */
1519 /*

--- 53 unchanged lines hidden (view full) ---

1573 svp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr);
1574 VN_RELE(*vpp);
1575 if (svp == NULL) {
1576 error = ENOSYS;
1577 }
1578 *vpp = svp;
1579 }
1580 }
1493 if (aclp)
1494 zfs_acl_free(aclp);
1495
1496 ZFS_EXIT(zfsvfs);
1497 return (error);
1498}
1499
1500/*
1501 * Remove an entry from a directory.
1502 *

--- 102 unchanged lines hidden (view full) ---

1605 /* are there any additional acls */
1606 if ((acl_obj = zp->z_phys->zp_acl.z_acl_extern_obj) != 0 &&
1607 may_delete_now)
1608 dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
1609
1610 /* charge as an update -- would be nice not to charge at all */
1611 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
1612
1581
1582 ZFS_EXIT(zfsvfs);
1583 return (error);
1584}
1585
1586/*
1587 * Remove an entry from a directory.
1588 *

--- 102 unchanged lines hidden (view full) ---

1691 /* are there any additional acls */
1692 if ((acl_obj = zp->z_phys->zp_acl.z_acl_extern_obj) != 0 &&
1693 may_delete_now)
1694 dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
1695
1696 /* charge as an update -- would be nice not to charge at all */
1697 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
1698
1613 error = dmu_tx_assign(tx, zfsvfs->z_assign);
1699 error = dmu_tx_assign(tx, TXG_NOWAIT);
1614 if (error) {
1615 zfs_dirent_unlock(dl);
1616 VN_RELE(vp);
1700 if (error) {
1701 zfs_dirent_unlock(dl);
1702 VN_RELE(vp);
1617 if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
1703 if (error == ERESTART) {
1618 dmu_tx_wait(tx);
1619 dmu_tx_abort(tx);
1620 goto top;
1621 }
1622 if (realnmp)
1623 pn_free(realnmp);
1624 dmu_tx_abort(tx);
1625 ZFS_EXIT(zfsvfs);

--- 93 unchanged lines hidden (view full) ---

1719{
1720 znode_t *zp, *dzp = VTOZ(dvp);
1721 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
1722 zilog_t *zilog;
1723 zfs_dirlock_t *dl;
1724 uint64_t txtype;
1725 dmu_tx_t *tx;
1726 int error;
1704 dmu_tx_wait(tx);
1705 dmu_tx_abort(tx);
1706 goto top;
1707 }
1708 if (realnmp)
1709 pn_free(realnmp);
1710 dmu_tx_abort(tx);
1711 ZFS_EXIT(zfsvfs);

--- 93 unchanged lines hidden (view full) ---

1805{
1806 znode_t *zp, *dzp = VTOZ(dvp);
1807 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
1808 zilog_t *zilog;
1809 zfs_dirlock_t *dl;
1810 uint64_t txtype;
1811 dmu_tx_t *tx;
1812 int error;
1727 zfs_acl_t *aclp = NULL;
1728 zfs_fuid_info_t *fuidp = NULL;
1729 int zf = ZNEW;
1813 int zf = ZNEW;
1814 ksid_t *ksid;
1815 uid_t uid;
1816 gid_t gid = crgetgid(cr);
1817 zfs_acl_ids_t acl_ids;
1818 boolean_t fuid_dirtied;
1730
1731 ASSERT(vap->va_type == VDIR);
1732
1733 /*
1734 * If we have an ephemeral id, ACL, or XVATTR then
1735 * make sure file system is at proper version
1736 */
1737
1819
1820 ASSERT(vap->va_type == VDIR);
1821
1822 /*
1823 * If we have an ephemeral id, ACL, or XVATTR then
1824 * make sure file system is at proper version
1825 */
1826
1827 ksid = crgetsid(cr, KSID_OWNER);
1828 if (ksid)
1829 uid = ksid_getid(ksid);
1830 else
1831 uid = crgetuid(cr);
1738 if (zfsvfs->z_use_fuids == B_FALSE &&
1739 (vsecp || (vap->va_mask & AT_XVATTR) || IS_EPHEMERAL(crgetuid(cr))||
1740 IS_EPHEMERAL(crgetgid(cr))))
1741 return (EINVAL);
1742
1743 ZFS_ENTER(zfsvfs);
1744 ZFS_VERIFY_ZP(dzp);
1745 zilog = zfsvfs->z_log;

--- 31 unchanged lines hidden (view full) ---

1777 }
1778
1779 if (error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr)) {
1780 zfs_dirent_unlock(dl);
1781 ZFS_EXIT(zfsvfs);
1782 return (error);
1783 }
1784
1832 if (zfsvfs->z_use_fuids == B_FALSE &&
1833 (vsecp || (vap->va_mask & AT_XVATTR) || IS_EPHEMERAL(crgetuid(cr))||
1834 IS_EPHEMERAL(crgetgid(cr))))
1835 return (EINVAL);
1836
1837 ZFS_ENTER(zfsvfs);
1838 ZFS_VERIFY_ZP(dzp);
1839 zilog = zfsvfs->z_log;

--- 31 unchanged lines hidden (view full) ---

1871 }
1872
1873 if (error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr)) {
1874 zfs_dirent_unlock(dl);
1875 ZFS_EXIT(zfsvfs);
1876 return (error);
1877 }
1878
1785 if (vsecp && aclp == NULL) {
1786 error = zfs_vsec_2_aclp(zfsvfs, vap->va_type, vsecp, &aclp);
1787 if (error) {
1788 zfs_dirent_unlock(dl);
1789 ZFS_EXIT(zfsvfs);
1790 return (error);
1791 }
1879 if ((error = zfs_acl_ids_create(dzp, 0, vap, cr, vsecp,
1880 &acl_ids)) != 0) {
1881 zfs_dirent_unlock(dl);
1882 ZFS_EXIT(zfsvfs);
1883 return (error);
1792 }
1884 }
1885 if (zfs_acl_ids_overquota(zfsvfs, &acl_ids)) {
1886 zfs_dirent_unlock(dl);
1887 ZFS_EXIT(zfsvfs);
1888 return (EDQUOT);
1889 }
1890
1793 /*
1794 * Add a new entry to the directory.
1795 */
1796 tx = dmu_tx_create(zfsvfs->z_os);
1797 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname);
1798 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
1891 /*
1892 * Add a new entry to the directory.
1893 */
1894 tx = dmu_tx_create(zfsvfs->z_os);
1895 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname);
1896 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
1799 if ((aclp && aclp->z_has_fuids) || IS_EPHEMERAL(crgetuid(cr)) ||
1800 IS_EPHEMERAL(crgetgid(cr))) {
1801 if (zfsvfs->z_fuid_obj == 0) {
1802 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1803 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
1804 FUID_SIZE_ESTIMATE(zfsvfs));
1805 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, FALSE, NULL);
1806 } else {
1807 dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj);
1808 dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0,
1809 FUID_SIZE_ESTIMATE(zfsvfs));
1810 }
1811 }
1812 if ((dzp->z_phys->zp_flags & ZFS_INHERIT_ACE) || aclp)
1897 fuid_dirtied = zfsvfs->z_fuid_dirty;
1898 if (fuid_dirtied)
1899 zfs_fuid_txhold(zfsvfs, tx);
1900 if (acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE)
1813 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
1814 0, SPA_MAXBLOCKSIZE);
1901 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
1902 0, SPA_MAXBLOCKSIZE);
1815 error = dmu_tx_assign(tx, zfsvfs->z_assign);
1903 error = dmu_tx_assign(tx, TXG_NOWAIT);
1816 if (error) {
1904 if (error) {
1905 zfs_acl_ids_free(&acl_ids);
1817 zfs_dirent_unlock(dl);
1906 zfs_dirent_unlock(dl);
1818 if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
1907 if (error == ERESTART) {
1819 dmu_tx_wait(tx);
1820 dmu_tx_abort(tx);
1821 goto top;
1822 }
1823 dmu_tx_abort(tx);
1824 ZFS_EXIT(zfsvfs);
1908 dmu_tx_wait(tx);
1909 dmu_tx_abort(tx);
1910 goto top;
1911 }
1912 dmu_tx_abort(tx);
1913 ZFS_EXIT(zfsvfs);
1825 if (aclp)
1826 zfs_acl_free(aclp);
1827 return (error);
1828 }
1829
1830 /*
1831 * Create new node.
1832 */
1914 return (error);
1915 }
1916
1917 /*
1918 * Create new node.
1919 */
1833 zfs_mknode(dzp, vap, tx, cr, 0, &zp, 0, aclp, &fuidp);
1920 zfs_mknode(dzp, vap, tx, cr, 0, &zp, 0, &acl_ids);
1834
1921
1835 if (aclp)
1836 zfs_acl_free(aclp);
1837
1922 if (fuid_dirtied)
1923 zfs_fuid_sync(zfsvfs, tx);
1838 /*
1839 * Now put new name in parent dir.
1840 */
1841 (void) zfs_link_create(dl, zp, tx, ZNEW);
1842
1843 *vpp = ZTOV(zp);
1844
1845 txtype = zfs_log_create_txtype(Z_DIR, vsecp, vap);
1846 if (flags & FIGNORECASE)
1847 txtype |= TX_CI;
1924 /*
1925 * Now put new name in parent dir.
1926 */
1927 (void) zfs_link_create(dl, zp, tx, ZNEW);
1928
1929 *vpp = ZTOV(zp);
1930
1931 txtype = zfs_log_create_txtype(Z_DIR, vsecp, vap);
1932 if (flags & FIGNORECASE)
1933 txtype |= TX_CI;
1848 zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, vsecp, fuidp, vap);
1934 zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, vsecp,
1935 acl_ids.z_fuidp, vap);
1849
1936
1850 if (fuidp)
1851 zfs_fuid_info_free(fuidp);
1937 zfs_acl_ids_free(&acl_ids);
1852 dmu_tx_commit(tx);
1853
1854 zfs_dirent_unlock(dl);
1855
1856 ZFS_EXIT(zfsvfs);
1857 return (0);
1858}
1859

--- 77 unchanged lines hidden (view full) ---

1937 * with the treewalk and directory rename code.
1938 */
1939 rw_enter(&zp->z_parent_lock, RW_WRITER);
1940
1941 tx = dmu_tx_create(zfsvfs->z_os);
1942 dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
1943 dmu_tx_hold_bonus(tx, zp->z_id);
1944 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
1938 dmu_tx_commit(tx);
1939
1940 zfs_dirent_unlock(dl);
1941
1942 ZFS_EXIT(zfsvfs);
1943 return (0);
1944}
1945

--- 77 unchanged lines hidden (view full) ---

2023 * with the treewalk and directory rename code.
2024 */
2025 rw_enter(&zp->z_parent_lock, RW_WRITER);
2026
2027 tx = dmu_tx_create(zfsvfs->z_os);
2028 dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
2029 dmu_tx_hold_bonus(tx, zp->z_id);
2030 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
1945 error = dmu_tx_assign(tx, zfsvfs->z_assign);
2031 error = dmu_tx_assign(tx, TXG_NOWAIT);
1946 if (error) {
1947 rw_exit(&zp->z_parent_lock);
1948 rw_exit(&zp->z_name_lock);
1949 zfs_dirent_unlock(dl);
1950 VN_RELE(vp);
2032 if (error) {
2033 rw_exit(&zp->z_parent_lock);
2034 rw_exit(&zp->z_name_lock);
2035 zfs_dirent_unlock(dl);
2036 VN_RELE(vp);
1951 if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
2037 if (error == ERESTART) {
1952 dmu_tx_wait(tx);
1953 dmu_tx_abort(tx);
1954 goto top;
1955 }
1956 dmu_tx_abort(tx);
1957 ZFS_EXIT(zfsvfs);
1958 return (error);
1959 }

--- 569 unchanged lines hidden (view full) ---

2529 caller_context_t *ct)
2530{
2531 znode_t *zp = VTOZ(vp);
2532 znode_phys_t *pzp;
2533 zfsvfs_t *zfsvfs = zp->z_zfsvfs;
2534 zilog_t *zilog;
2535 dmu_tx_t *tx;
2536 vattr_t oldva;
2038 dmu_tx_wait(tx);
2039 dmu_tx_abort(tx);
2040 goto top;
2041 }
2042 dmu_tx_abort(tx);
2043 ZFS_EXIT(zfsvfs);
2044 return (error);
2045 }

--- 569 unchanged lines hidden (view full) ---

2615 caller_context_t *ct)
2616{
2617 znode_t *zp = VTOZ(vp);
2618 znode_phys_t *pzp;
2619 zfsvfs_t *zfsvfs = zp->z_zfsvfs;
2620 zilog_t *zilog;
2621 dmu_tx_t *tx;
2622 vattr_t oldva;
2623 xvattr_t tmpxvattr;
2537 uint_t mask = vap->va_mask;
2538 uint_t saved_mask;
2539 uint64_t saved_mode;
2540 int trim_mask = 0;
2541 uint64_t new_mode;
2624 uint_t mask = vap->va_mask;
2625 uint_t saved_mask;
2626 uint64_t saved_mode;
2627 int trim_mask = 0;
2628 uint64_t new_mode;
2629 uint64_t new_uid, new_gid;
2542 znode_t *attrzp;
2543 int need_policy = FALSE;
2544 int err;
2545 zfs_fuid_info_t *fuidp = NULL;
2546 xvattr_t *xvap = (xvattr_t *)vap; /* vap may be an xvattr_t * */
2547 xoptattr_t *xoap;
2548 zfs_acl_t *aclp = NULL;
2549 boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
2630 znode_t *attrzp;
2631 int need_policy = FALSE;
2632 int err;
2633 zfs_fuid_info_t *fuidp = NULL;
2634 xvattr_t *xvap = (xvattr_t *)vap; /* vap may be an xvattr_t * */
2635 xoptattr_t *xoap;
2636 zfs_acl_t *aclp = NULL;
2637 boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
2638 boolean_t fuid_dirtied = B_FALSE;
2550
2551 if (mask == 0)
2552 return (0);
2553
2554 if (mask & AT_NOSET)
2555 return (EINVAL);
2556
2557 ZFS_ENTER(zfsvfs);

--- 26 unchanged lines hidden (view full) ---

2584 }
2585
2586 /*
2587 * If this is an xvattr_t, then get a pointer to the structure of
2588 * optional attributes. If this is NULL, then we have a vattr_t.
2589 */
2590 xoap = xva_getxoptattr(xvap);
2591
2639
2640 if (mask == 0)
2641 return (0);
2642
2643 if (mask & AT_NOSET)
2644 return (EINVAL);
2645
2646 ZFS_ENTER(zfsvfs);

--- 26 unchanged lines hidden (view full) ---

2673 }
2674
2675 /*
2676 * If this is an xvattr_t, then get a pointer to the structure of
2677 * optional attributes. If this is NULL, then we have a vattr_t.
2678 */
2679 xoap = xva_getxoptattr(xvap);
2680
2681 xva_init(&tmpxvattr);
2682
2592 /*
2593 * Immutable files can only alter immutable bit and atime
2594 */
2595 if ((pzp->zp_flags & ZFS_IMMUTABLE) &&
2596 ((mask & (AT_SIZE|AT_UID|AT_GID|AT_MTIME|AT_MODE)) ||
2597 ((mask & AT_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) {
2598 ZFS_EXIT(zfsvfs);
2599 return (EPERM);

--- 106 unchanged lines hidden (view full) ---

2706 need_policy = TRUE;
2707 }
2708 }
2709
2710 mutex_enter(&zp->z_lock);
2711 oldva.va_mode = pzp->zp_mode;
2712 zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid);
2713 if (mask & AT_XVATTR) {
2683 /*
2684 * Immutable files can only alter immutable bit and atime
2685 */
2686 if ((pzp->zp_flags & ZFS_IMMUTABLE) &&
2687 ((mask & (AT_SIZE|AT_UID|AT_GID|AT_MTIME|AT_MODE)) ||
2688 ((mask & AT_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) {
2689 ZFS_EXIT(zfsvfs);
2690 return (EPERM);

--- 106 unchanged lines hidden (view full) ---

2797 need_policy = TRUE;
2798 }
2799 }
2800
2801 mutex_enter(&zp->z_lock);
2802 oldva.va_mode = pzp->zp_mode;
2803 zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid);
2804 if (mask & AT_XVATTR) {
2714 if ((need_policy == FALSE) &&
2715 (XVA_ISSET_REQ(xvap, XAT_APPENDONLY) &&
2716 xoap->xoa_appendonly !=
2717 ((pzp->zp_flags & ZFS_APPENDONLY) != 0)) ||
2718 (XVA_ISSET_REQ(xvap, XAT_NOUNLINK) &&
2719 xoap->xoa_nounlink !=
2720 ((pzp->zp_flags & ZFS_NOUNLINK) != 0)) ||
2721 (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE) &&
2722 xoap->xoa_immutable !=
2723 ((pzp->zp_flags & ZFS_IMMUTABLE) != 0)) ||
2724 (XVA_ISSET_REQ(xvap, XAT_NODUMP) &&
2725 xoap->xoa_nodump !=
2726 ((pzp->zp_flags & ZFS_NODUMP) != 0)) ||
2727 (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED) &&
2728 xoap->xoa_av_modified !=
2729 ((pzp->zp_flags & ZFS_AV_MODIFIED) != 0)) ||
2730 ((XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED) &&
2731 ((vp->v_type != VREG && xoap->xoa_av_quarantined) ||
2732 xoap->xoa_av_quarantined !=
2733 ((pzp->zp_flags & ZFS_AV_QUARANTINED) != 0)))) ||
2734 (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) ||
2735 (XVA_ISSET_REQ(xvap, XAT_OPAQUE))) {
2805 /*
2806 * Update xvattr mask to include only those attributes
2807 * that are actually changing.
2808 *
2809 * the bits will be restored prior to actually setting
2810 * the attributes so the caller thinks they were set.
2811 */
2812 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
2813 if (xoap->xoa_appendonly !=
2814 ((pzp->zp_flags & ZFS_APPENDONLY) != 0)) {
2815 need_policy = TRUE;
2816 } else {
2817 XVA_CLR_REQ(xvap, XAT_APPENDONLY);
2818 XVA_SET_REQ(&tmpxvattr, XAT_APPENDONLY);
2819 }
2820 }
2821
2822 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
2823 if (xoap->xoa_nounlink !=
2824 ((pzp->zp_flags & ZFS_NOUNLINK) != 0)) {
2825 need_policy = TRUE;
2826 } else {
2827 XVA_CLR_REQ(xvap, XAT_NOUNLINK);
2828 XVA_SET_REQ(&tmpxvattr, XAT_NOUNLINK);
2829 }
2830 }
2831
2832 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
2833 if (xoap->xoa_immutable !=
2834 ((pzp->zp_flags & ZFS_IMMUTABLE) != 0)) {
2835 need_policy = TRUE;
2836 } else {
2837 XVA_CLR_REQ(xvap, XAT_IMMUTABLE);
2838 XVA_SET_REQ(&tmpxvattr, XAT_IMMUTABLE);
2839 }
2840 }
2841
2842 if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
2843 if (xoap->xoa_nodump !=
2844 ((pzp->zp_flags & ZFS_NODUMP) != 0)) {
2845 need_policy = TRUE;
2846 } else {
2847 XVA_CLR_REQ(xvap, XAT_NODUMP);
2848 XVA_SET_REQ(&tmpxvattr, XAT_NODUMP);
2849 }
2850 }
2851
2852 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
2853 if (xoap->xoa_av_modified !=
2854 ((pzp->zp_flags & ZFS_AV_MODIFIED) != 0)) {
2855 need_policy = TRUE;
2856 } else {
2857 XVA_CLR_REQ(xvap, XAT_AV_MODIFIED);
2858 XVA_SET_REQ(&tmpxvattr, XAT_AV_MODIFIED);
2859 }
2860 }
2861
2862 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
2863 if ((vp->v_type != VREG &&
2864 xoap->xoa_av_quarantined) ||
2865 xoap->xoa_av_quarantined !=
2866 ((pzp->zp_flags & ZFS_AV_QUARANTINED) != 0)) {
2867 need_policy = TRUE;
2868 } else {
2869 XVA_CLR_REQ(xvap, XAT_AV_QUARANTINED);
2870 XVA_SET_REQ(&tmpxvattr, XAT_AV_QUARANTINED);
2871 }
2872 }
2873
2874 if (need_policy == FALSE &&
2875 (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) ||
2876 XVA_ISSET_REQ(xvap, XAT_OPAQUE))) {
2736 need_policy = TRUE;
2737 }
2738 }
2739
2740 mutex_exit(&zp->z_lock);
2741
2742 if (mask & AT_MODE) {
2743 if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) {

--- 51 unchanged lines hidden (view full) ---

2795 /*
2796 * secpolicy_vnode_setattr, or take ownership may have
2797 * changed va_mask
2798 */
2799 mask = vap->va_mask;
2800
2801 tx = dmu_tx_create(zfsvfs->z_os);
2802 dmu_tx_hold_bonus(tx, zp->z_id);
2877 need_policy = TRUE;
2878 }
2879 }
2880
2881 mutex_exit(&zp->z_lock);
2882
2883 if (mask & AT_MODE) {
2884 if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) {

--- 51 unchanged lines hidden (view full) ---

2936 /*
2937 * secpolicy_vnode_setattr, or take ownership may have
2938 * changed va_mask
2939 */
2940 mask = vap->va_mask;
2941
2942 tx = dmu_tx_create(zfsvfs->z_os);
2943 dmu_tx_hold_bonus(tx, zp->z_id);
2803 if (((mask & AT_UID) && IS_EPHEMERAL(vap->va_uid)) ||
2804 ((mask & AT_GID) && IS_EPHEMERAL(vap->va_gid))) {
2805 if (zfsvfs->z_fuid_obj == 0) {
2806 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
2807 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
2808 FUID_SIZE_ESTIMATE(zfsvfs));
2809 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, FALSE, NULL);
2810 } else {
2811 dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj);
2812 dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0,
2813 FUID_SIZE_ESTIMATE(zfsvfs));
2814 }
2815 }
2816
2817 if (mask & AT_MODE) {
2818 uint64_t pmode = pzp->zp_mode;
2819
2820 new_mode = (pmode & S_IFMT) | (vap->va_mode & ~S_IFMT);
2821
2944
2945 if (mask & AT_MODE) {
2946 uint64_t pmode = pzp->zp_mode;
2947
2948 new_mode = (pmode & S_IFMT) | (vap->va_mode & ~S_IFMT);
2949
2822 if (err = zfs_acl_chmod_setattr(zp, &aclp, new_mode)) {
2823 dmu_tx_abort(tx);
2824 ZFS_EXIT(zfsvfs);
2825 return (err);
2826 }
2950 if (err = zfs_acl_chmod_setattr(zp, &aclp, new_mode))
2951 goto out;
2827 if (pzp->zp_acl.z_acl_extern_obj) {
2828 /* Are we upgrading ACL from old V0 format to new V1 */
2829 if (zfsvfs->z_version <= ZPL_VERSION_FUID &&
2830 pzp->zp_acl.z_acl_version ==
2831 ZFS_ACL_VERSION_INITIAL) {
2832 dmu_tx_hold_free(tx,
2833 pzp->zp_acl.z_acl_extern_obj, 0,
2834 DMU_OBJECT_END);

--- 5 unchanged lines hidden (view full) ---

2840 aclp->z_acl_bytes);
2841 }
2842 } else if (aclp->z_acl_bytes > ZFS_ACE_SPACE) {
2843 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
2844 0, aclp->z_acl_bytes);
2845 }
2846 }
2847
2952 if (pzp->zp_acl.z_acl_extern_obj) {
2953 /* Are we upgrading ACL from old V0 format to new V1 */
2954 if (zfsvfs->z_version <= ZPL_VERSION_FUID &&
2955 pzp->zp_acl.z_acl_version ==
2956 ZFS_ACL_VERSION_INITIAL) {
2957 dmu_tx_hold_free(tx,
2958 pzp->zp_acl.z_acl_extern_obj, 0,
2959 DMU_OBJECT_END);

--- 5 unchanged lines hidden (view full) ---

2965 aclp->z_acl_bytes);
2966 }
2967 } else if (aclp->z_acl_bytes > ZFS_ACE_SPACE) {
2968 dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
2969 0, aclp->z_acl_bytes);
2970 }
2971 }
2972
2848 if ((mask & (AT_UID | AT_GID)) && pzp->zp_xattr != 0) {
2849 err = zfs_zget(zp->z_zfsvfs, pzp->zp_xattr, &attrzp);
2850 if (err) {
2851 dmu_tx_abort(tx);
2852 ZFS_EXIT(zfsvfs);
2853 if (aclp)
2854 zfs_acl_free(aclp);
2855 return (err);
2973 if (mask & (AT_UID | AT_GID)) {
2974 if (pzp->zp_xattr) {
2975 err = zfs_zget(zp->z_zfsvfs, pzp->zp_xattr, &attrzp);
2976 if (err)
2977 goto out;
2978 dmu_tx_hold_bonus(tx, attrzp->z_id);
2856 }
2979 }
2857 dmu_tx_hold_bonus(tx, attrzp->z_id);
2858 }
2980 if (mask & AT_UID) {
2981 new_uid = zfs_fuid_create(zfsvfs,
2982 (uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp);
2983 if (new_uid != pzp->zp_uid &&
2984 zfs_usergroup_overquota(zfsvfs, B_FALSE, new_uid)) {
2985 err = EDQUOT;
2986 goto out;
2987 }
2988 }
2859
2989
2860 err = dmu_tx_assign(tx, zfsvfs->z_assign);
2861 if (err) {
2862 if (attrzp)
2863 VN_RELE(ZTOV(attrzp));
2864
2865 if (aclp) {
2866 zfs_acl_free(aclp);
2867 aclp = NULL;
2990 if (mask & AT_GID) {
2991 new_gid = zfs_fuid_create(zfsvfs, (uint64_t)vap->va_gid,
2992 cr, ZFS_GROUP, &fuidp);
2993 if (new_gid != pzp->zp_gid &&
2994 zfs_usergroup_overquota(zfsvfs, B_TRUE, new_gid)) {
2995 err = EDQUOT;
2996 goto out;
2997 }
2868 }
2998 }
2999 fuid_dirtied = zfsvfs->z_fuid_dirty;
3000 if (fuid_dirtied) {
3001 if (zfsvfs->z_fuid_obj == 0) {
3002 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
3003 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
3004 FUID_SIZE_ESTIMATE(zfsvfs));
3005 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ,
3006 FALSE, NULL);
3007 } else {
3008 dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj);
3009 dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0,
3010 FUID_SIZE_ESTIMATE(zfsvfs));
3011 }
3012 }
3013 }
2869
3014
2870 if (err == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
3015 err = dmu_tx_assign(tx, TXG_NOWAIT);
3016 if (err) {
3017 if (err == ERESTART)
2871 dmu_tx_wait(tx);
3018 dmu_tx_wait(tx);
2872 dmu_tx_abort(tx);
2873 goto top;
2874 }
2875 dmu_tx_abort(tx);
2876 ZFS_EXIT(zfsvfs);
2877 return (err);
3019 goto out;
2878 }
2879
2880 dmu_buf_will_dirty(zp->z_dbuf, tx);
2881
2882 /*
2883 * Set each attribute requested.
2884 * We group settings according to the locks they need to acquire.
2885 *
2886 * Note: you cannot set ctime directly, although it will be
2887 * updated as a side-effect of calling this function.
2888 */
2889
2890 mutex_enter(&zp->z_lock);
2891
2892 if (mask & AT_MODE) {
2893 mutex_enter(&zp->z_acl_lock);
2894 zp->z_phys->zp_mode = new_mode;
3020 }
3021
3022 dmu_buf_will_dirty(zp->z_dbuf, tx);
3023
3024 /*
3025 * Set each attribute requested.
3026 * We group settings according to the locks they need to acquire.
3027 *
3028 * Note: you cannot set ctime directly, although it will be
3029 * updated as a side-effect of calling this function.
3030 */
3031
3032 mutex_enter(&zp->z_lock);
3033
3034 if (mask & AT_MODE) {
3035 mutex_enter(&zp->z_acl_lock);
3036 zp->z_phys->zp_mode = new_mode;
2895 err = zfs_aclset_common(zp, aclp, cr, &fuidp, tx);
3037 err = zfs_aclset_common(zp, aclp, cr, tx);
2896 ASSERT3U(err, ==, 0);
2897 mutex_exit(&zp->z_acl_lock);
2898 }
2899
2900 if (attrzp)
2901 mutex_enter(&attrzp->z_lock);
2902
2903 if (mask & AT_UID) {
3038 ASSERT3U(err, ==, 0);
3039 mutex_exit(&zp->z_acl_lock);
3040 }
3041
3042 if (attrzp)
3043 mutex_enter(&attrzp->z_lock);
3044
3045 if (mask & AT_UID) {
2904 pzp->zp_uid = zfs_fuid_create(zfsvfs,
2905 vap->va_uid, cr, ZFS_OWNER, tx, &fuidp);
2906 if (attrzp) {
2907 attrzp->z_phys->zp_uid = zfs_fuid_create(zfsvfs,
2908 vap->va_uid, cr, ZFS_OWNER, tx, &fuidp);
2909 }
3046 pzp->zp_uid = new_uid;
3047 if (attrzp)
3048 attrzp->z_phys->zp_uid = new_uid;
2910 }
2911
2912 if (mask & AT_GID) {
3049 }
3050
3051 if (mask & AT_GID) {
2913 pzp->zp_gid = zfs_fuid_create(zfsvfs, vap->va_gid,
2914 cr, ZFS_GROUP, tx, &fuidp);
3052 pzp->zp_gid = new_gid;
2915 if (attrzp)
3053 if (attrzp)
2916 attrzp->z_phys->zp_gid = zfs_fuid_create(zfsvfs,
2917 vap->va_gid, cr, ZFS_GROUP, tx, &fuidp);
3054 attrzp->z_phys->zp_gid = new_gid;
2918 }
2919
3055 }
3056
2920 if (aclp)
2921 zfs_acl_free(aclp);
2922
2923 if (attrzp)
2924 mutex_exit(&attrzp->z_lock);
2925
2926 if (mask & AT_ATIME)
2927 ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime);
2928
2929 if (mask & AT_MTIME)
2930 ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime);

--- 4 unchanged lines hidden (view full) ---

2935 else if (mask != 0)
2936 zfs_time_stamper_locked(zp, STATE_CHANGED, tx);
2937 /*
2938 * Do this after setting timestamps to prevent timestamp
2939 * update from toggling bit
2940 */
2941
2942 if (xoap && (mask & AT_XVATTR)) {
3057 if (attrzp)
3058 mutex_exit(&attrzp->z_lock);
3059
3060 if (mask & AT_ATIME)
3061 ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime);
3062
3063 if (mask & AT_MTIME)
3064 ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime);

--- 4 unchanged lines hidden (view full) ---

3069 else if (mask != 0)
3070 zfs_time_stamper_locked(zp, STATE_CHANGED, tx);
3071 /*
3072 * Do this after setting timestamps to prevent timestamp
3073 * update from toggling bit
3074 */
3075
3076 if (xoap && (mask & AT_XVATTR)) {
3077
3078 /*
3079 * restore trimmed off masks
3080 * so that return masks can be set for caller.
3081 */
3082
3083 if (XVA_ISSET_REQ(&tmpxvattr, XAT_APPENDONLY)) {
3084 XVA_SET_REQ(xvap, XAT_APPENDONLY);
3085 }
3086 if (XVA_ISSET_REQ(&tmpxvattr, XAT_NOUNLINK)) {
3087 XVA_SET_REQ(xvap, XAT_NOUNLINK);
3088 }
3089 if (XVA_ISSET_REQ(&tmpxvattr, XAT_IMMUTABLE)) {
3090 XVA_SET_REQ(xvap, XAT_IMMUTABLE);
3091 }
3092 if (XVA_ISSET_REQ(&tmpxvattr, XAT_NODUMP)) {
3093 XVA_SET_REQ(xvap, XAT_NODUMP);
3094 }
3095 if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_MODIFIED)) {
3096 XVA_SET_REQ(xvap, XAT_AV_MODIFIED);
3097 }
3098 if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_QUARANTINED)) {
3099 XVA_SET_REQ(xvap, XAT_AV_QUARANTINED);
3100 }
3101
2943 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) {
2944 size_t len;
2945 dmu_object_info_t doi;
2946
2947 ASSERT(vp->v_type == VREG);
2948
2949 /* Grow the bonus buffer if necessary. */
2950 dmu_object_info_from_db(zp->z_dbuf, &doi);
2951 len = sizeof (xoap->xoa_av_scanstamp) +
2952 sizeof (znode_phys_t);
2953 if (len > doi.doi_bonus_size)
2954 VERIFY(dmu_set_bonus(zp->z_dbuf, len, tx) == 0);
2955 }
2956 zfs_xvattr_set(zp, xvap);
2957 }
2958
3102 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) {
3103 size_t len;
3104 dmu_object_info_t doi;
3105
3106 ASSERT(vp->v_type == VREG);
3107
3108 /* Grow the bonus buffer if necessary. */
3109 dmu_object_info_from_db(zp->z_dbuf, &doi);
3110 len = sizeof (xoap->xoa_av_scanstamp) +
3111 sizeof (znode_phys_t);
3112 if (len > doi.doi_bonus_size)
3113 VERIFY(dmu_set_bonus(zp->z_dbuf, len, tx) == 0);
3114 }
3115 zfs_xvattr_set(zp, xvap);
3116 }
3117
3118 if (fuid_dirtied)
3119 zfs_fuid_sync(zfsvfs, tx);
3120
2959 if (mask != 0)
2960 zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp);
2961
3121 if (mask != 0)
3122 zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp);
3123
2962 if (fuidp)
2963 zfs_fuid_info_free(fuidp);
2964 mutex_exit(&zp->z_lock);
2965
3124 mutex_exit(&zp->z_lock);
3125
3126out:
2966 if (attrzp)
2967 VN_RELE(ZTOV(attrzp));
2968
3127 if (attrzp)
3128 VN_RELE(ZTOV(attrzp));
3129
2969 dmu_tx_commit(tx);
3130 if (aclp) {
3131 zfs_acl_free(aclp);
3132 aclp = NULL;
3133 }
2970
3134
3135 if (fuidp) {
3136 zfs_fuid_info_free(fuidp);
3137 fuidp = NULL;
3138 }
3139
3140 if (err)
3141 dmu_tx_abort(tx);
3142 else
3143 dmu_tx_commit(tx);
3144
3145 if (err == ERESTART)
3146 goto top;
3147
2971 ZFS_EXIT(zfsvfs);
2972 return (err);
2973}
2974
2975typedef struct zfs_zlock {
2976 krwlock_t *zl_rwlock; /* lock we acquired */
2977 znode_t *zl_znode; /* znode we held */
2978 struct zfs_zlock *zl_next; /* next in list */

--- 345 unchanged lines hidden (view full) ---

3324 dmu_tx_hold_bonus(tx, sdzp->z_id); /* nlink changes */
3325 dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm);
3326 dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm);
3327 if (sdzp != tdzp)
3328 dmu_tx_hold_bonus(tx, tdzp->z_id); /* nlink changes */
3329 if (tzp)
3330 dmu_tx_hold_bonus(tx, tzp->z_id); /* parent changes */
3331 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
3148 ZFS_EXIT(zfsvfs);
3149 return (err);
3150}
3151
3152typedef struct zfs_zlock {
3153 krwlock_t *zl_rwlock; /* lock we acquired */
3154 znode_t *zl_znode; /* znode we held */
3155 struct zfs_zlock *zl_next; /* next in list */

--- 345 unchanged lines hidden (view full) ---

3501 dmu_tx_hold_bonus(tx, sdzp->z_id); /* nlink changes */
3502 dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm);
3503 dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm);
3504 if (sdzp != tdzp)
3505 dmu_tx_hold_bonus(tx, tdzp->z_id); /* nlink changes */
3506 if (tzp)
3507 dmu_tx_hold_bonus(tx, tzp->z_id); /* parent changes */
3508 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
3332 error = dmu_tx_assign(tx, zfsvfs->z_assign);
3509 error = dmu_tx_assign(tx, TXG_NOWAIT);
3333 if (error) {
3334 if (zl != NULL)
3335 zfs_rename_unlock(&zl);
3336 zfs_dirent_unlock(sdl);
3337 zfs_dirent_unlock(tdl);
3338
3339 if (sdzp == tdzp)
3340 rw_exit(&sdzp->z_name_lock);
3341
3342 VN_RELE(ZTOV(szp));
3343 if (tzp)
3344 VN_RELE(ZTOV(tzp));
3510 if (error) {
3511 if (zl != NULL)
3512 zfs_rename_unlock(&zl);
3513 zfs_dirent_unlock(sdl);
3514 zfs_dirent_unlock(tdl);
3515
3516 if (sdzp == tdzp)
3517 rw_exit(&sdzp->z_name_lock);
3518
3519 VN_RELE(ZTOV(szp));
3520 if (tzp)
3521 VN_RELE(ZTOV(tzp));
3345 if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
3522 if (error == ERESTART) {
3346 dmu_tx_wait(tx);
3347 dmu_tx_abort(tx);
3348 goto top;
3349 }
3350 dmu_tx_abort(tx);
3351 ZFS_EXIT(zfsvfs);
3352 return (error);
3353 }

--- 69 unchanged lines hidden (view full) ---

3423 znode_t *zp, *dzp = VTOZ(dvp);
3424 zfs_dirlock_t *dl;
3425 dmu_tx_t *tx;
3426 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
3427 zilog_t *zilog;
3428 int len = strlen(link);
3429 int error;
3430 int zflg = ZNEW;
3523 dmu_tx_wait(tx);
3524 dmu_tx_abort(tx);
3525 goto top;
3526 }
3527 dmu_tx_abort(tx);
3528 ZFS_EXIT(zfsvfs);
3529 return (error);
3530 }

--- 69 unchanged lines hidden (view full) ---

3600 znode_t *zp, *dzp = VTOZ(dvp);
3601 zfs_dirlock_t *dl;
3602 dmu_tx_t *tx;
3603 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
3604 zilog_t *zilog;
3605 int len = strlen(link);
3606 int error;
3607 int zflg = ZNEW;
3431 zfs_fuid_info_t *fuidp = NULL;
3608 zfs_acl_ids_t acl_ids;
3609 boolean_t fuid_dirtied;
3432 int flags = 0;
3433
3434 ASSERT(vap->va_type == VLNK);
3435
3436 ZFS_ENTER(zfsvfs);
3437 ZFS_VERIFY_ZP(dzp);
3438 zilog = zfsvfs->z_log;
3439

--- 19 unchanged lines hidden (view full) ---

3459 * Attempt to lock directory; fail if entry already exists.
3460 */
3461 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, NULL, NULL);
3462 if (error) {
3463 ZFS_EXIT(zfsvfs);
3464 return (error);
3465 }
3466
3610 int flags = 0;
3611
3612 ASSERT(vap->va_type == VLNK);
3613
3614 ZFS_ENTER(zfsvfs);
3615 ZFS_VERIFY_ZP(dzp);
3616 zilog = zfsvfs->z_log;
3617

--- 19 unchanged lines hidden (view full) ---

3637 * Attempt to lock directory; fail if entry already exists.
3638 */
3639 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, NULL, NULL);
3640 if (error) {
3641 ZFS_EXIT(zfsvfs);
3642 return (error);
3643 }
3644
3645 VERIFY(0 == zfs_acl_ids_create(dzp, 0, vap, cr, NULL, &acl_ids));
3646 if (zfs_acl_ids_overquota(zfsvfs, &acl_ids)) {
3647 zfs_acl_ids_free(&acl_ids);
3648 zfs_dirent_unlock(dl);
3649 ZFS_EXIT(zfsvfs);
3650 return (EDQUOT);
3651 }
3467 tx = dmu_tx_create(zfsvfs->z_os);
3652 tx = dmu_tx_create(zfsvfs->z_os);
3653 fuid_dirtied = zfsvfs->z_fuid_dirty;
3468 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len));
3469 dmu_tx_hold_bonus(tx, dzp->z_id);
3470 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
3654 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len));
3655 dmu_tx_hold_bonus(tx, dzp->z_id);
3656 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
3471 if (dzp->z_phys->zp_flags & ZFS_INHERIT_ACE)
3657 if (acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE)
3472 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, SPA_MAXBLOCKSIZE);
3658 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, SPA_MAXBLOCKSIZE);
3473 if (IS_EPHEMERAL(crgetuid(cr)) || IS_EPHEMERAL(crgetgid(cr))) {
3474 if (zfsvfs->z_fuid_obj == 0) {
3475 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
3476 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
3477 FUID_SIZE_ESTIMATE(zfsvfs));
3478 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, FALSE, NULL);
3479 } else {
3480 dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj);
3481 dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0,
3482 FUID_SIZE_ESTIMATE(zfsvfs));
3483 }
3484 }
3485 error = dmu_tx_assign(tx, zfsvfs->z_assign);
3659 if (fuid_dirtied)
3660 zfs_fuid_txhold(zfsvfs, tx);
3661 error = dmu_tx_assign(tx, TXG_NOWAIT);
3486 if (error) {
3662 if (error) {
3663 zfs_acl_ids_free(&acl_ids);
3487 zfs_dirent_unlock(dl);
3664 zfs_dirent_unlock(dl);
3488 if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
3665 if (error == ERESTART) {
3489 dmu_tx_wait(tx);
3490 dmu_tx_abort(tx);
3491 goto top;
3492 }
3493 dmu_tx_abort(tx);
3494 ZFS_EXIT(zfsvfs);
3495 return (error);
3496 }
3497
3498 dmu_buf_will_dirty(dzp->z_dbuf, tx);
3499
3500 /*
3501 * Create a new object for the symlink.
3502 * Put the link content into bonus buffer if it will fit;
3503 * otherwise, store it just like any other file data.
3504 */
3505 if (sizeof (znode_phys_t) + len <= dmu_bonus_max()) {
3666 dmu_tx_wait(tx);
3667 dmu_tx_abort(tx);
3668 goto top;
3669 }
3670 dmu_tx_abort(tx);
3671 ZFS_EXIT(zfsvfs);
3672 return (error);
3673 }
3674
3675 dmu_buf_will_dirty(dzp->z_dbuf, tx);
3676
3677 /*
3678 * Create a new object for the symlink.
3679 * Put the link content into bonus buffer if it will fit;
3680 * otherwise, store it just like any other file data.
3681 */
3682 if (sizeof (znode_phys_t) + len <= dmu_bonus_max()) {
3506 zfs_mknode(dzp, vap, tx, cr, 0, &zp, len, NULL, &fuidp);
3683 zfs_mknode(dzp, vap, tx, cr, 0, &zp, len, &acl_ids);
3507 if (len != 0)
3508 bcopy(link, zp->z_phys + 1, len);
3509 } else {
3510 dmu_buf_t *dbp;
3511
3684 if (len != 0)
3685 bcopy(link, zp->z_phys + 1, len);
3686 } else {
3687 dmu_buf_t *dbp;
3688
3512 zfs_mknode(dzp, vap, tx, cr, 0, &zp, 0, NULL, &fuidp);
3689 zfs_mknode(dzp, vap, tx, cr, 0, &zp, 0, &acl_ids);
3690
3691 if (fuid_dirtied)
3692 zfs_fuid_sync(zfsvfs, tx);
3513 /*
3514 * Nothing can access the znode yet so no locking needed
3515 * for growing the znode's blocksize.
3516 */
3517 zfs_grow_blocksize(zp, len, tx);
3518
3519 VERIFY(0 == dmu_buf_hold(zfsvfs->z_os,
3520 zp->z_id, 0, FTAG, &dbp));

--- 4 unchanged lines hidden (view full) ---

3525 dmu_buf_rele(dbp, FTAG);
3526 }
3527 zp->z_phys->zp_size = len;
3528
3529 /*
3530 * Insert the new object into the directory.
3531 */
3532 (void) zfs_link_create(dl, zp, tx, ZNEW);
3693 /*
3694 * Nothing can access the znode yet so no locking needed
3695 * for growing the znode's blocksize.
3696 */
3697 zfs_grow_blocksize(zp, len, tx);
3698
3699 VERIFY(0 == dmu_buf_hold(zfsvfs->z_os,
3700 zp->z_id, 0, FTAG, &dbp));

--- 4 unchanged lines hidden (view full) ---

3705 dmu_buf_rele(dbp, FTAG);
3706 }
3707 zp->z_phys->zp_size = len;
3708
3709 /*
3710 * Insert the new object into the directory.
3711 */
3712 (void) zfs_link_create(dl, zp, tx, ZNEW);
3533out:
3534 if (error == 0) {
3535 uint64_t txtype = TX_SYMLINK;
3536 if (flags & FIGNORECASE)
3537 txtype |= TX_CI;
3538 zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link);
3539 *vpp = ZTOV(zp);
3540 }
3713 if (error == 0) {
3714 uint64_t txtype = TX_SYMLINK;
3715 if (flags & FIGNORECASE)
3716 txtype |= TX_CI;
3717 zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link);
3718 *vpp = ZTOV(zp);
3719 }
3541 if (fuidp)
3542 zfs_fuid_info_free(fuidp);
3543
3720
3721 zfs_acl_ids_free(&acl_ids);
3722
3544 dmu_tx_commit(tx);
3545
3546 zfs_dirent_unlock(dl);
3547
3548 ZFS_EXIT(zfsvfs);
3549 return (error);
3550}
3551

--- 144 unchanged lines hidden (view full) ---

3696 if (error) {
3697 ZFS_EXIT(zfsvfs);
3698 return (error);
3699 }
3700
3701 tx = dmu_tx_create(zfsvfs->z_os);
3702 dmu_tx_hold_bonus(tx, szp->z_id);
3703 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
3723 dmu_tx_commit(tx);
3724
3725 zfs_dirent_unlock(dl);
3726
3727 ZFS_EXIT(zfsvfs);
3728 return (error);
3729}
3730

--- 144 unchanged lines hidden (view full) ---

3875 if (error) {
3876 ZFS_EXIT(zfsvfs);
3877 return (error);
3878 }
3879
3880 tx = dmu_tx_create(zfsvfs->z_os);
3881 dmu_tx_hold_bonus(tx, szp->z_id);
3882 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
3704 error = dmu_tx_assign(tx, zfsvfs->z_assign);
3883 error = dmu_tx_assign(tx, TXG_NOWAIT);
3705 if (error) {
3706 zfs_dirent_unlock(dl);
3884 if (error) {
3885 zfs_dirent_unlock(dl);
3707 if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {
3886 if (error == ERESTART) {
3708 dmu_tx_wait(tx);
3709 dmu_tx_abort(tx);
3710 goto top;
3711 }
3712 dmu_tx_abort(tx);
3713 ZFS_EXIT(zfsvfs);
3714 return (error);
3715 }

--- 1273 unchanged lines hidden (view full) ---

4989 } */ *ap;
4990{
4991
4992 return (EOPNOTSUPP);
4993}
4994
4995struct vop_vector zfs_vnodeops;
4996struct vop_vector zfs_fifoops;
3887 dmu_tx_wait(tx);
3888 dmu_tx_abort(tx);
3889 goto top;
3890 }
3891 dmu_tx_abort(tx);
3892 ZFS_EXIT(zfsvfs);
3893 return (error);
3894 }

--- 1273 unchanged lines hidden (view full) ---

5168 } */ *ap;
5169{
5170
5171 return (EOPNOTSUPP);
5172}
5173
5174struct vop_vector zfs_vnodeops;
5175struct vop_vector zfs_fifoops;
5176struct vop_vector zfs_shareops;
4997
4998struct vop_vector zfs_vnodeops = {
4999 .vop_default = &default_vnodeops,
5000 .vop_inactive = zfs_freebsd_inactive,
5001 .vop_reclaim = zfs_freebsd_reclaim,
5002 .vop_access = zfs_freebsd_access,
5003#ifdef FREEBSD_NAMECACHE
5004 .vop_lookup = vfs_cache_lookup,

--- 42 unchanged lines hidden (view full) ---

5047 .vop_setattr = zfs_freebsd_setattr,
5048 .vop_write = VOP_PANIC,
5049 .vop_pathconf = zfs_freebsd_fifo_pathconf,
5050 .vop_fid = zfs_freebsd_fid,
5051 .vop_getacl = zfs_freebsd_getacl,
5052 .vop_setacl = zfs_freebsd_setacl,
5053 .vop_aclcheck = zfs_freebsd_aclcheck,
5054};
5177
5178struct vop_vector zfs_vnodeops = {
5179 .vop_default = &default_vnodeops,
5180 .vop_inactive = zfs_freebsd_inactive,
5181 .vop_reclaim = zfs_freebsd_reclaim,
5182 .vop_access = zfs_freebsd_access,
5183#ifdef FREEBSD_NAMECACHE
5184 .vop_lookup = vfs_cache_lookup,

--- 42 unchanged lines hidden (view full) ---

5227 .vop_setattr = zfs_freebsd_setattr,
5228 .vop_write = VOP_PANIC,
5229 .vop_pathconf = zfs_freebsd_fifo_pathconf,
5230 .vop_fid = zfs_freebsd_fid,
5231 .vop_getacl = zfs_freebsd_getacl,
5232 .vop_setacl = zfs_freebsd_setacl,
5233 .vop_aclcheck = zfs_freebsd_aclcheck,
5234};
5235
5236/*
5237 * special share hidden files vnode operations template
5238 */
5239struct vop_vector zfs_shareops = {
5240 .vop_default = &default_vnodeops,
5241 .vop_access = zfs_freebsd_access,
5242 .vop_inactive = zfs_freebsd_inactive,
5243 .vop_reclaim = zfs_freebsd_reclaim,
5244 .vop_fid = zfs_freebsd_fid,
5245 .vop_pathconf = zfs_freebsd_pathconf,
5246};