Home | History | Annotate | Download | only in zfs
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 /*
     22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
     23  * Use is subject to license terms.
     24  */
     25 
     26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
     27 
     28 #include <sys/dmu.h>
     29 #include <sys/dmu_objset.h>
     30 #include <sys/dmu_tx.h>
     31 #include <sys/dsl_dataset.h>
     32 #include <sys/dsl_dir.h>
     33 #include <sys/dsl_prop.h>
     34 #include <sys/dsl_synctask.h>
     35 #include <sys/dsl_deleg.h>
     36 #include <sys/spa.h>
     37 #include <sys/zap.h>
     38 #include <sys/zio.h>
     39 #include <sys/arc.h>
     40 #include <sys/sunddi.h>
     41 #include "zfs_namecheck.h"
     42 
     43 static uint64_t dsl_dir_space_towrite(dsl_dir_t *dd);
     44 static void dsl_dir_set_reservation_sync(void *arg1, void *arg2,
     45     cred_t *cr, dmu_tx_t *tx);
     46 
     47 
     48 /* ARGSUSED */
     49 static void
     50 dsl_dir_evict(dmu_buf_t *db, void *arg)
     51 {
     52 	dsl_dir_t *dd = arg;
     53 	dsl_pool_t *dp = dd->dd_pool;
     54 	int t;
     55 
     56 	for (t = 0; t < TXG_SIZE; t++) {
     57 		ASSERT(!txg_list_member(&dp->dp_dirty_dirs, dd, t));
     58 		ASSERT(dd->dd_tempreserved[t] == 0);
     59 		ASSERT(dd->dd_space_towrite[t] == 0);
     60 	}
     61 
     62 	ASSERT3U(dd->dd_used_bytes, ==, dd->dd_phys->dd_used_bytes);
     63 
     64 	if (dd->dd_parent)
     65 		dsl_dir_close(dd->dd_parent, dd);
     66 
     67 	spa_close(dd->dd_pool->dp_spa, dd);
     68 
     69 	/*
     70 	 * The props callback list should be empty since they hold the
     71 	 * dir open.
     72 	 */
     73 	list_destroy(&dd->dd_prop_cbs);
     74 	mutex_destroy(&dd->dd_lock);
     75 	kmem_free(dd, sizeof (dsl_dir_t));
     76 }
     77 
     78 int
     79 dsl_dir_open_obj(dsl_pool_t *dp, uint64_t ddobj,
     80     const char *tail, void *tag, dsl_dir_t **ddp)
     81 {
     82 	dmu_buf_t *dbuf;
     83 	dsl_dir_t *dd;
     84 	int err;
     85 
     86 	ASSERT(RW_LOCK_HELD(&dp->dp_config_rwlock) ||
     87 	    dsl_pool_sync_context(dp));
     88 
     89 	err = dmu_bonus_hold(dp->dp_meta_objset, ddobj, tag, &dbuf);
     90 	if (err)
     91 		return (err);
     92 	dd = dmu_buf_get_user(dbuf);
     93 #ifdef ZFS_DEBUG
     94 	{
     95 		dmu_object_info_t doi;
     96 		dmu_object_info_from_db(dbuf, &doi);
     97 		ASSERT3U(doi.doi_type, ==, DMU_OT_DSL_DIR);
     98 	}
     99 #endif
    100 	/* XXX assert bonus buffer size is correct */
    101 	if (dd == NULL) {
    102 		dsl_dir_t *winner;
    103 		int err;
    104 
    105 		dd = kmem_zalloc(sizeof (dsl_dir_t), KM_SLEEP);
    106 		dd->dd_object = ddobj;
    107 		dd->dd_dbuf = dbuf;
    108 		dd->dd_pool = dp;
    109 		dd->dd_phys = dbuf->db_data;
    110 		dd->dd_used_bytes = dd->dd_phys->dd_used_bytes;
    111 		mutex_init(&dd->dd_lock, NULL, MUTEX_DEFAULT, NULL);
    112 
    113 		list_create(&dd->dd_prop_cbs, sizeof (dsl_prop_cb_record_t),
    114 		    offsetof(dsl_prop_cb_record_t, cbr_node));
    115 
    116 		if (dd->dd_phys->dd_parent_obj) {
    117 			err = dsl_dir_open_obj(dp, dd->dd_phys->dd_parent_obj,
    118 			    NULL, dd, &dd->dd_parent);
    119 			if (err) {
    120 				mutex_destroy(&dd->dd_lock);
    121 				kmem_free(dd, sizeof (dsl_dir_t));
    122 				dmu_buf_rele(dbuf, tag);
    123 				return (err);
    124 			}
    125 			if (tail) {
    126 #ifdef ZFS_DEBUG
    127 				uint64_t foundobj;
    128 
    129 				err = zap_lookup(dp->dp_meta_objset,
    130 				    dd->dd_parent->dd_phys->dd_child_dir_zapobj,
    131 				    tail, sizeof (foundobj), 1, &foundobj);
    132 				ASSERT(err || foundobj == ddobj);
    133 #endif
    134 				(void) strcpy(dd->dd_myname, tail);
    135 			} else {
    136 				err = zap_value_search(dp->dp_meta_objset,
    137 				    dd->dd_parent->dd_phys->dd_child_dir_zapobj,
    138 				    ddobj, 0, dd->dd_myname);
    139 			}
    140 			if (err) {
    141 				dsl_dir_close(dd->dd_parent, dd);
    142 				mutex_destroy(&dd->dd_lock);
    143 				kmem_free(dd, sizeof (dsl_dir_t));
    144 				dmu_buf_rele(dbuf, tag);
    145 				return (err);
    146 			}
    147 		} else {
    148 			(void) strcpy(dd->dd_myname, spa_name(dp->dp_spa));
    149 		}
    150 
    151 		winner = dmu_buf_set_user_ie(dbuf, dd, &dd->dd_phys,
    152 		    dsl_dir_evict);
    153 		if (winner) {
    154 			if (dd->dd_parent)
    155 				dsl_dir_close(dd->dd_parent, dd);
    156 			mutex_destroy(&dd->dd_lock);
    157 			kmem_free(dd, sizeof (dsl_dir_t));
    158 			dd = winner;
    159 		} else {
    160 			spa_open_ref(dp->dp_spa, dd);
    161 		}
    162 	}
    163 
    164 	/*
    165 	 * The dsl_dir_t has both open-to-close and instantiate-to-evict
    166 	 * holds on the spa.  We need the open-to-close holds because
    167 	 * otherwise the spa_refcnt wouldn't change when we open a
    168 	 * dir which the spa also has open, so we could incorrectly
    169 	 * think it was OK to unload/export/destroy the pool.  We need
    170 	 * the instantiate-to-evict hold because the dsl_dir_t has a
    171 	 * pointer to the dd_pool, which has a pointer to the spa_t.
    172 	 */
    173 	spa_open_ref(dp->dp_spa, tag);
    174 	ASSERT3P(dd->dd_pool, ==, dp);
    175 	ASSERT3U(dd->dd_object, ==, ddobj);
    176 	ASSERT3P(dd->dd_dbuf, ==, dbuf);
    177 	*ddp = dd;
    178 	return (0);
    179 }
    180 
    181 void
    182 dsl_dir_close(dsl_dir_t *dd, void *tag)
    183 {
    184 	dprintf_dd(dd, "%s\n", "");
    185 	spa_close(dd->dd_pool->dp_spa, tag);
    186 	dmu_buf_rele(dd->dd_dbuf, tag);
    187 }
    188 
    189 /* buf must be long enough (MAXNAMELEN + strlen(MOS_DIR_NAME) + 1 should do) */
    190 void
    191 dsl_dir_name(dsl_dir_t *dd, char *buf)
    192 {
    193 	if (dd->dd_parent) {
    194 		dsl_dir_name(dd->dd_parent, buf);
    195 		(void) strcat(buf, "/");
    196 	} else {
    197 		buf[0] = '\0';
    198 	}
    199 	if (!MUTEX_HELD(&dd->dd_lock)) {
    200 		/*
    201 		 * recursive mutex so that we can use
    202 		 * dprintf_dd() with dd_lock held
    203 		 */
    204 		mutex_enter(&dd->dd_lock);
    205 		(void) strcat(buf, dd->dd_myname);
    206 		mutex_exit(&dd->dd_lock);
    207 	} else {
    208 		(void) strcat(buf, dd->dd_myname);
    209 	}
    210 }
    211 
    212 /* Calculate name legnth, avoiding all the strcat calls of dsl_dir_name */
    213 int
    214 dsl_dir_namelen(dsl_dir_t *dd)
    215 {
    216 	int result = 0;
    217 
    218 	if (dd->dd_parent) {
    219 		/* parent's name + 1 for the "/" */
    220 		result = dsl_dir_namelen(dd->dd_parent) + 1;
    221 	}
    222 
    223 	if (!MUTEX_HELD(&dd->dd_lock)) {
    224 		/* see dsl_dir_name */
    225 		mutex_enter(&dd->dd_lock);
    226 		result += strlen(dd->dd_myname);
    227 		mutex_exit(&dd->dd_lock);
    228 	} else {
    229 		result += strlen(dd->dd_myname);
    230 	}
    231 
    232 	return (result);
    233 }
    234 
    235 int
    236 dsl_dir_is_private(dsl_dir_t *dd)
    237 {
    238 	int rv = FALSE;
    239 
    240 	if (dd->dd_parent && dsl_dir_is_private(dd->dd_parent))
    241 		rv = TRUE;
    242 	if (dataset_name_hidden(dd->dd_myname))
    243 		rv = TRUE;
    244 	return (rv);
    245 }
    246 
    247 
    248 static int
    249 getcomponent(const char *path, char *component, const char **nextp)
    250 {
    251 	char *p;
    252 	if (path == NULL)
    253 		return (ENOENT);
    254 	/* This would be a good place to reserve some namespace... */
    255 	p = strpbrk(path, "/@");
    256 	if (p && (p[1] == '/' || p[1] == '@')) {
    257 		/* two separators in a row */
    258 		return (EINVAL);
    259 	}
    260 	if (p == NULL || p == path) {
    261 		/*
    262 		 * if the first thing is an @ or /, it had better be an
    263 		 * @ and it had better not have any more ats or slashes,
    264 		 * and it had better have something after the @.
    265 		 */
    266 		if (p != NULL &&
    267 		    (p[0] != '@' || strpbrk(path+1, "/@") || p[1] == '\0'))
    268 			return (EINVAL);
    269 		if (strlen(path) >= MAXNAMELEN)
    270 			return (ENAMETOOLONG);
    271 		(void) strcpy(component, path);
    272 		p = NULL;
    273 	} else if (p[0] == '/') {
    274 		if (p-path >= MAXNAMELEN)
    275 			return (ENAMETOOLONG);
    276 		(void) strncpy(component, path, p - path);
    277 		component[p-path] = '\0';
    278 		p++;
    279 	} else if (p[0] == '@') {
    280 		/*
    281 		 * if the next separator is an @, there better not be
    282 		 * any more slashes.
    283 		 */
    284 		if (strchr(path, '/'))
    285 			return (EINVAL);
    286 		if (p-path >= MAXNAMELEN)
    287 			return (ENAMETOOLONG);
    288 		(void) strncpy(component, path, p - path);
    289 		component[p-path] = '\0';
    290 	} else {
    291 		ASSERT(!"invalid p");
    292 	}
    293 	*nextp = p;
    294 	return (0);
    295 }
    296 
    297 /*
    298  * same as dsl_open_dir, ignore the first component of name and use the
    299  * spa instead
    300  */
    301 int
    302 dsl_dir_open_spa(spa_t *spa, const char *name, void *tag,
    303     dsl_dir_t **ddp, const char **tailp)
    304 {
    305 	char buf[MAXNAMELEN];
    306 	const char *next, *nextnext = NULL;
    307 	int err;
    308 	dsl_dir_t *dd;
    309 	dsl_pool_t *dp;
    310 	uint64_t ddobj;
    311 	int openedspa = FALSE;
    312 
    313 	dprintf("%s\n", name);
    314 
    315 	err = getcomponent(name, buf, &next);
    316 	if (err)
    317 		return (err);
    318 	if (spa == NULL) {
    319 		err = spa_open(buf, &spa, FTAG);
    320 		if (err) {
    321 			dprintf("spa_open(%s) failed\n", buf);
    322 			return (err);
    323 		}
    324 		openedspa = TRUE;
    325 
    326 		/* XXX this assertion belongs in spa_open */
    327 		ASSERT(!dsl_pool_sync_context(spa_get_dsl(spa)));
    328 	}
    329 
    330 	dp = spa_get_dsl(spa);
    331 
    332 	rw_enter(&dp->dp_config_rwlock, RW_READER);
    333 	err = dsl_dir_open_obj(dp, dp->dp_root_dir_obj, NULL, tag, &dd);
    334 	if (err) {
    335 		rw_exit(&dp->dp_config_rwlock);
    336 		if (openedspa)
    337 			spa_close(spa, FTAG);
    338 		return (err);
    339 	}
    340 
    341 	while (next != NULL) {
    342 		dsl_dir_t *child_ds;
    343 		err = getcomponent(next, buf, &nextnext);
    344 		if (err)
    345 			break;
    346 		ASSERT(next[0] != '\0');
    347 		if (next[0] == '@')
    348 			break;
    349 		dprintf("looking up %s in obj%lld\n",
    350 		    buf, dd->dd_phys->dd_child_dir_zapobj);
    351 
    352 		err = zap_lookup(dp->dp_meta_objset,
    353 		    dd->dd_phys->dd_child_dir_zapobj,
    354 		    buf, sizeof (ddobj), 1, &ddobj);
    355 		if (err) {
    356 			if (err == ENOENT)
    357 				err = 0;
    358 			break;
    359 		}
    360 
    361 		err = dsl_dir_open_obj(dp, ddobj, buf, tag, &child_ds);
    362 		if (err)
    363 			break;
    364 		dsl_dir_close(dd, tag);
    365 		dd = child_ds;
    366 		next = nextnext;
    367 	}
    368 	rw_exit(&dp->dp_config_rwlock);
    369 
    370 	if (err) {
    371 		dsl_dir_close(dd, tag);
    372 		if (openedspa)
    373 			spa_close(spa, FTAG);
    374 		return (err);
    375 	}
    376 
    377 	/*
    378 	 * It's an error if there's more than one component left, or
    379 	 * tailp==NULL and there's any component left.
    380 	 */
    381 	if (next != NULL &&
    382 	    (tailp == NULL || (nextnext && nextnext[0] != '\0'))) {
    383 		/* bad path name */
    384 		dsl_dir_close(dd, tag);
    385 		dprintf("next=%p (%s) tail=%p\n", next, next?next:"", tailp);
    386 		err = ENOENT;
    387 	}
    388 	if (tailp)
    389 		*tailp = next;
    390 	if (openedspa)
    391 		spa_close(spa, FTAG);
    392 	*ddp = dd;
    393 	return (err);
    394 }
    395 
    396 /*
    397  * Return the dsl_dir_t, and possibly the last component which couldn't
    398  * be found in *tail.  Return NULL if the path is bogus, or if
    399  * tail==NULL and we couldn't parse the whole name.  (*tail)[0] == '@'
    400  * means that the last component is a snapshot.
    401  */
    402 int
    403 dsl_dir_open(const char *name, void *tag, dsl_dir_t **ddp, const char **tailp)
    404 {
    405 	return (dsl_dir_open_spa(NULL, name, tag, ddp, tailp));
    406 }
    407 
    408 uint64_t
    409 dsl_dir_create_sync(dsl_dir_t *pds, const char *name, dmu_tx_t *tx)
    410 {
    411 	objset_t *mos = pds->dd_pool->dp_meta_objset;
    412 	uint64_t ddobj;
    413 	dsl_dir_phys_t *dsphys;
    414 	dmu_buf_t *dbuf;
    415 
    416 	ddobj = dmu_object_alloc(mos, DMU_OT_DSL_DIR, 0,
    417 	    DMU_OT_DSL_DIR, sizeof (dsl_dir_phys_t), tx);
    418 	VERIFY(0 == zap_add(mos, pds->dd_phys->dd_child_dir_zapobj,
    419 	    name, sizeof (uint64_t), 1, &ddobj, tx));
    420 	VERIFY(0 == dmu_bonus_hold(mos, ddobj, FTAG, &dbuf));
    421 	dmu_buf_will_dirty(dbuf, tx);
    422 	dsphys = dbuf->db_data;
    423 
    424 	dsphys->dd_creation_time = gethrestime_sec();
    425 	dsphys->dd_parent_obj = pds->dd_object;
    426 	dsphys->dd_props_zapobj = zap_create(mos,
    427 	    DMU_OT_DSL_PROPS, DMU_OT_NONE, 0, tx);
    428 	dsphys->dd_child_dir_zapobj = zap_create(mos,
    429 	    DMU_OT_DSL_DIR_CHILD_MAP, DMU_OT_NONE, 0, tx);
    430 	dmu_buf_rele(dbuf, FTAG);
    431 
    432 	return (ddobj);
    433 }
    434 
    435 /* ARGSUSED */
    436 int
    437 dsl_dir_destroy_check(void *arg1, void *arg2, dmu_tx_t *tx)
    438 {
    439 	dsl_dir_t *dd = arg1;
    440 	dsl_pool_t *dp = dd->dd_pool;
    441 	objset_t *mos = dp->dp_meta_objset;
    442 	int err;
    443 	uint64_t count;
    444 
    445 	/*
    446 	 * There should be exactly two holds, both from
    447 	 * dsl_dataset_destroy: one on the dd directory, and one on its
    448 	 * head ds.  Otherwise, someone is trying to lookup something
    449 	 * inside this dir while we want to destroy it.  The
    450 	 * config_rwlock ensures that nobody else opens it after we
    451 	 * check.
    452 	 */
    453 	if (dmu_buf_refcount(dd->dd_dbuf) > 2)
    454 		return (EBUSY);
    455 
    456 	err = zap_count(mos, dd->dd_phys->dd_child_dir_zapobj, &count);
    457 	if (err)
    458 		return (err);
    459 	if (count != 0)
    460 		return (EEXIST);
    461 
    462 	return (0);
    463 }
    464 
    465 void
    466 dsl_dir_destroy_sync(void *arg1, void *tag, cred_t *cr, dmu_tx_t *tx)
    467 {
    468 	dsl_dir_t *dd = arg1;
    469 	objset_t *mos = dd->dd_pool->dp_meta_objset;
    470 	uint64_t val, obj;
    471 
    472 	ASSERT(RW_WRITE_HELD(&dd->dd_pool->dp_config_rwlock));
    473 	ASSERT(dd->dd_phys->dd_head_dataset_obj == 0);
    474 
    475 	/* Remove our reservation. */
    476 	val = 0;
    477 	dsl_dir_set_reservation_sync(dd, &val, cr, tx);
    478 	ASSERT3U(dd->dd_used_bytes, ==, 0);
    479 	ASSERT3U(dd->dd_phys->dd_reserved, ==, 0);
    480 
    481 	VERIFY(0 == zap_destroy(mos, dd->dd_phys->dd_child_dir_zapobj, tx));
    482 	VERIFY(0 == zap_destroy(mos, dd->dd_phys->dd_props_zapobj, tx));
    483 	VERIFY(0 == dsl_deleg_destroy(mos, dd->dd_phys->dd_deleg_zapobj, tx));
    484 	VERIFY(0 == zap_remove(mos,
    485 	    dd->dd_parent->dd_phys->dd_child_dir_zapobj, dd->dd_myname, tx));
    486 
    487 	obj = dd->dd_object;
    488 	dsl_dir_close(dd, tag);
    489 	VERIFY(0 == dmu_object_free(mos, obj, tx));
    490 }
    491 
    492 void
    493 dsl_dir_create_root(objset_t *mos, uint64_t *ddobjp, dmu_tx_t *tx)
    494 {
    495 	dsl_dir_phys_t *dsp;
    496 	dmu_buf_t *dbuf;
    497 	int error;
    498 
    499 	*ddobjp = dmu_object_alloc(mos, DMU_OT_DSL_DIR, 0,
    500 	    DMU_OT_DSL_DIR, sizeof (dsl_dir_phys_t), tx);
    501 
    502 	error = zap_add(mos, DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ROOT_DATASET,
    503 	    sizeof (uint64_t), 1, ddobjp, tx);
    504 	ASSERT3U(error, ==, 0);
    505 
    506 	VERIFY(0 == dmu_bonus_hold(mos, *ddobjp, FTAG, &dbuf));
    507 	dmu_buf_will_dirty(dbuf, tx);
    508 	dsp = dbuf->db_data;
    509 
    510 	dsp->dd_creation_time = gethrestime_sec();
    511 	dsp->dd_props_zapobj = zap_create(mos,
    512 	    DMU_OT_DSL_PROPS, DMU_OT_NONE, 0, tx);
    513 	dsp->dd_child_dir_zapobj = zap_create(mos,
    514 	    DMU_OT_DSL_DIR_CHILD_MAP, DMU_OT_NONE, 0, tx);
    515 
    516 	dmu_buf_rele(dbuf, FTAG);
    517 }
    518 
    519 void
    520 dsl_dir_stats(dsl_dir_t *dd, nvlist_t *nv)
    521 {
    522 	mutex_enter(&dd->dd_lock);
    523 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED, dd->dd_used_bytes);
    524 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_QUOTA, dd->dd_phys->dd_quota);
    525 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_RESERVATION,
    526 	    dd->dd_phys->dd_reserved);
    527 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO,
    528 	    dd->dd_phys->dd_compressed_bytes == 0 ? 100 :
    529 	    (dd->dd_phys->dd_uncompressed_bytes * 100 /
    530 	    dd->dd_phys->dd_compressed_bytes));
    531 	mutex_exit(&dd->dd_lock);
    532 
    533 	rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
    534 	if (dd->dd_phys->dd_origin_obj) {
    535 		dsl_dataset_t *ds;
    536 		char buf[MAXNAMELEN];
    537 
    538 		VERIFY(0 == dsl_dataset_hold_obj(dd->dd_pool,
    539 		    dd->dd_phys->dd_origin_obj, FTAG, &ds));
    540 		dsl_dataset_name(ds, buf);
    541 		dsl_dataset_rele(ds, FTAG);
    542 		dsl_prop_nvlist_add_string(nv, ZFS_PROP_ORIGIN, buf);
    543 	}
    544 	rw_exit(&dd->dd_pool->dp_config_rwlock);
    545 }
    546 
    547 void
    548 dsl_dir_dirty(dsl_dir_t *dd, dmu_tx_t *tx)
    549 {
    550 	dsl_pool_t *dp = dd->dd_pool;
    551 
    552 	ASSERT(dd->dd_phys);
    553 
    554 	if (txg_list_add(&dp->dp_dirty_dirs, dd, tx->tx_txg) == 0) {
    555 		/* up the hold count until we can be written out */
    556 		dmu_buf_add_ref(dd->dd_dbuf, dd);
    557 	}
    558 }
    559 
    560 static int64_t
    561 parent_delta(dsl_dir_t *dd, uint64_t used, int64_t delta)
    562 {
    563 	uint64_t old_accounted = MAX(used, dd->dd_phys->dd_reserved);
    564 	uint64_t new_accounted = MAX(used + delta, dd->dd_phys->dd_reserved);
    565 	return (new_accounted - old_accounted);
    566 }
    567 
    568 void
    569 dsl_dir_sync(dsl_dir_t *dd, dmu_tx_t *tx)
    570 {
    571 	ASSERT(dmu_tx_is_syncing(tx));
    572 
    573 	dmu_buf_will_dirty(dd->dd_dbuf, tx);
    574 
    575 	mutex_enter(&dd->dd_lock);
    576 	ASSERT3U(dd->dd_tempreserved[tx->tx_txg&TXG_MASK], ==, 0);
    577 	dprintf_dd(dd, "txg=%llu towrite=%lluK\n", tx->tx_txg,
    578 	    dd->dd_space_towrite[tx->tx_txg&TXG_MASK] / 1024);
    579 	dd->dd_space_towrite[tx->tx_txg&TXG_MASK] = 0;
    580 	dd->dd_phys->dd_used_bytes = dd->dd_used_bytes;
    581 	mutex_exit(&dd->dd_lock);
    582 
    583 	/* release the hold from dsl_dir_dirty */
    584 	dmu_buf_rele(dd->dd_dbuf, dd);
    585 }
    586 
    587 static uint64_t
    588 dsl_dir_space_towrite(dsl_dir_t *dd)
    589 {
    590 	uint64_t space = 0;
    591 	int i;
    592 
    593 	ASSERT(MUTEX_HELD(&dd->dd_lock));
    594 
    595 	for (i = 0; i < TXG_SIZE; i++) {
    596 		space += dd->dd_space_towrite[i&TXG_MASK];
    597 		ASSERT3U(dd->dd_space_towrite[i&TXG_MASK], >=, 0);
    598 	}
    599 	return (space);
    600 }
    601 
    602 /*
    603  * How much space would dd have available if ancestor had delta applied
    604  * to it?  If ondiskonly is set, we're only interested in what's
    605  * on-disk, not estimated pending changes.
    606  */
    607 uint64_t
    608 dsl_dir_space_available(dsl_dir_t *dd,
    609     dsl_dir_t *ancestor, int64_t delta, int ondiskonly)
    610 {
    611 	uint64_t parentspace, myspace, quota, used;
    612 
    613 	/*
    614 	 * If there are no restrictions otherwise, assume we have
    615 	 * unlimited space available.
    616 	 */
    617 	quota = UINT64_MAX;
    618 	parentspace = UINT64_MAX;
    619 
    620 	if (dd->dd_parent != NULL) {
    621 		parentspace = dsl_dir_space_available(dd->dd_parent,
    622 		    ancestor, delta, ondiskonly);
    623 	}
    624 
    625 	mutex_enter(&dd->dd_lock);
    626 	if (dd->dd_phys->dd_quota != 0)
    627 		quota = dd->dd_phys->dd_quota;
    628 	used = dd->dd_used_bytes;
    629 	if (!ondiskonly)
    630 		used += dsl_dir_space_towrite(dd);
    631 	if (dd == ancestor)
    632 		used += delta;
    633 
    634 	if (dd->dd_parent == NULL) {
    635 		uint64_t poolsize = dsl_pool_adjustedsize(dd->dd_pool, FALSE);
    636 		quota = MIN(quota, poolsize);
    637 	}
    638 
    639 	if (dd->dd_phys->dd_reserved > used && parentspace != UINT64_MAX) {
    640 		/*
    641 		 * We have some space reserved, in addition to what our
    642 		 * parent gave us.
    643 		 */
    644 		parentspace += dd->dd_phys->dd_reserved - used;
    645 	}
    646 
    647 	if (used > quota) {
    648 		/* over quota */
    649 		myspace = 0;
    650 
    651 		/*
    652 		 * While it's OK to be a little over quota, if
    653 		 * we think we are using more space than there
    654 		 * is in the pool (which is already 1.6% more than
    655 		 * dsl_pool_adjustedsize()), something is very
    656 		 * wrong.
    657 		 */
    658 		ASSERT3U(used, <=, spa_get_space(dd->dd_pool->dp_spa));
    659 	} else {
    660 		/*
    661 		 * the lesser of the space provided by our parent and
    662 		 * the space left in our quota
    663 		 */
    664 		myspace = MIN(parentspace, quota - used);
    665 	}
    666 
    667 	mutex_exit(&dd->dd_lock);
    668 
    669 	return (myspace);
    670 }
    671 
    672 struct tempreserve {
    673 	list_node_t tr_node;
    674 	dsl_pool_t *tr_dp;
    675 	dsl_dir_t *tr_ds;
    676 	uint64_t tr_size;
    677 };
    678 
    679 static int
    680 dsl_dir_tempreserve_impl(dsl_dir_t *dd, uint64_t asize, boolean_t netfree,
    681     boolean_t ignorequota, boolean_t checkrefquota, list_t *tr_list,
    682     dmu_tx_t *tx, boolean_t first)
    683 {
    684 	uint64_t txg = tx->tx_txg;
    685 	uint64_t est_inflight, used_on_disk, quota, parent_rsrv;
    686 	struct tempreserve *tr;
    687 	int enospc = EDQUOT;
    688 	int txgidx = txg & TXG_MASK;
    689 	int i;
    690 	uint64_t ref_rsrv = 0;
    691 
    692 	ASSERT3U(txg, !=, 0);
    693 	ASSERT3S(asize, >, 0);
    694 
    695 	mutex_enter(&dd->dd_lock);
    696 
    697 	/*
    698 	 * Check against the dsl_dir's quota.  We don't add in the delta
    699 	 * when checking for over-quota because they get one free hit.
    700 	 */
    701 	est_inflight = dsl_dir_space_towrite(dd);
    702 	for (i = 0; i < TXG_SIZE; i++)
    703 		est_inflight += dd->dd_tempreserved[i];
    704 	used_on_disk = dd->dd_used_bytes;
    705 
    706 	/*
    707 	 * On the first iteration, fetch the dataset's used-on-disk and
    708 	 * refreservation values. Also, if checkrefquota is set, test if
    709 	 * allocating this space would exceed the dataset's refquota.
    710 	 */
    711 	if (first && tx->tx_objset) {
    712 		int error;
    713 		dsl_dataset_t *ds = tx->tx_objset->os->os_dsl_dataset;
    714 
    715 		error = dsl_dataset_check_quota(ds, checkrefquota,
    716 		    asize, est_inflight, &used_on_disk, &ref_rsrv);
    717 		if (error) {
    718 			mutex_exit(&dd->dd_lock);
    719 			return (error);
    720 		}
    721 	}
    722 
    723 	/*
    724 	 * If this transaction will result in a net free of space,
    725 	 * we want to let it through.
    726 	 */
    727 	if (ignorequota || netfree || dd->dd_phys->dd_quota == 0)
    728 		quota = UINT64_MAX;
    729 	else
    730 		quota = dd->dd_phys->dd_quota;
    731 
    732 	/*
    733 	 * Adjust the quota against the actual pool size at the root.
    734 	 * To ensure that it's possible to remove files from a full
    735 	 * pool without inducing transient overcommits, we throttle
    736 	 * netfree transactions against a quota that is slightly larger,
    737 	 * but still within the pool's allocation slop.  In cases where
    738 	 * we're very close to full, this will allow a steady trickle of
    739 	 * removes to get through.
    740 	 */
    741 	if (dd->dd_parent == NULL) {
    742 		uint64_t poolsize = dsl_pool_adjustedsize(dd->dd_pool, netfree);
    743 		if (poolsize < quota) {
    744 			quota = poolsize;
    745 			enospc = ENOSPC;
    746 		}
    747 	}
    748 
    749 	/*
    750 	 * If they are requesting more space, and our current estimate
    751 	 * is over quota, they get to try again unless the actual
    752 	 * on-disk is over quota and there are no pending changes (which
    753 	 * may free up space for us).
    754 	 */
    755 	if (used_on_disk + est_inflight > quota) {
    756 		if (est_inflight > 0 || used_on_disk < quota)
    757 			enospc = ERESTART;
    758 		dprintf_dd(dd, "failing: used=%lluK inflight = %lluK "
    759 		    "quota=%lluK tr=%lluK err=%d\n",
    760 		    used_on_disk>>10, est_inflight>>10,
    761 		    quota>>10, asize>>10, enospc);
    762 		mutex_exit(&dd->dd_lock);
    763 		return (enospc);
    764 	}
    765 
    766 	/* We need to up our estimated delta before dropping dd_lock */
    767 	dd->dd_tempreserved[txgidx] += asize;
    768 
    769 	parent_rsrv = parent_delta(dd, used_on_disk + est_inflight,
    770 	    asize - ref_rsrv);
    771 	mutex_exit(&dd->dd_lock);
    772 
    773 	tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP);
    774 	tr->tr_ds = dd;
    775 	tr->tr_size = asize;
    776 	list_insert_tail(tr_list, tr);
    777 
    778 	/* see if it's OK with our parent */
    779 	if (dd->dd_parent && parent_rsrv) {
    780 		boolean_t ismos = (dd->dd_phys->dd_head_dataset_obj == 0);
    781 
    782 		return (dsl_dir_tempreserve_impl(dd->dd_parent,
    783 		    parent_rsrv, netfree, ismos, TRUE, tr_list, tx, FALSE));
    784 	} else {
    785 		return (0);
    786 	}
    787 }
    788 
    789 /*
    790  * Reserve space in this dsl_dir, to be used in this tx's txg.
    791  * After the space has been dirtied (and dsl_dir_willuse_space()
    792  * has been called), the reservation should be canceled, using
    793  * dsl_dir_tempreserve_clear().
    794  */
    795 int
    796 dsl_dir_tempreserve_space(dsl_dir_t *dd, uint64_t lsize, uint64_t asize,
    797     uint64_t fsize, uint64_t usize, void **tr_cookiep, dmu_tx_t *tx)
    798 {
    799 	int err;
    800 	list_t *tr_list;
    801 
    802 	if (asize == 0) {
    803 		*tr_cookiep = NULL;
    804 		return (0);
    805 	}
    806 
    807 	tr_list = kmem_alloc(sizeof (list_t), KM_SLEEP);
    808 	list_create(tr_list, sizeof (struct tempreserve),
    809 	    offsetof(struct tempreserve, tr_node));
    810 	ASSERT3S(asize, >, 0);
    811 	ASSERT3S(fsize, >=, 0);
    812 
    813 	err = arc_tempreserve_space(lsize, tx->tx_txg);
    814 	if (err == 0) {
    815 		struct tempreserve *tr;
    816 
    817 		tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP);
    818 		tr->tr_size = lsize;
    819 		list_insert_tail(tr_list, tr);
    820 
    821 		err = dsl_pool_tempreserve_space(dd->dd_pool, asize, tx);
    822 	} else {
    823 		if (err == EAGAIN) {
    824 			txg_delay(dd->dd_pool, tx->tx_txg, 1);
    825 			err = ERESTART;
    826 		}
    827 		dsl_pool_memory_pressure(dd->dd_pool);
    828 	}
    829 
    830 	if (err == 0) {
    831 		struct tempreserve *tr;
    832 
    833 		tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP);
    834 		tr->tr_dp = dd->dd_pool;
    835 		tr->tr_size = asize;
    836 		list_insert_tail(tr_list, tr);
    837 
    838 		err = dsl_dir_tempreserve_impl(dd, asize, fsize >= asize,
    839 		    FALSE, asize > usize, tr_list, tx, TRUE);
    840 	}
    841 
    842 	if (err)
    843 		dsl_dir_tempreserve_clear(tr_list, tx);
    844 	else
    845 		*tr_cookiep = tr_list;
    846 
    847 	return (err);
    848 }
    849 
    850 /*
    851  * Clear a temporary reservation that we previously made with
    852  * dsl_dir_tempreserve_space().
    853  */
    854 void
    855 dsl_dir_tempreserve_clear(void *tr_cookie, dmu_tx_t *tx)
    856 {
    857 	int txgidx = tx->tx_txg & TXG_MASK;
    858 	list_t *tr_list = tr_cookie;
    859 	struct tempreserve *tr;
    860 
    861 	ASSERT3U(tx->tx_txg, !=, 0);
    862 
    863 	if (tr_cookie == NULL)
    864 		return;
    865 
    866 	while (tr = list_head(tr_list)) {
    867 		if (tr->tr_dp) {
    868 			dsl_pool_tempreserve_clear(tr->tr_dp, tr->tr_size, tx);
    869 		} else if (tr->tr_ds) {
    870 			mutex_enter(&tr->tr_ds->dd_lock);
    871 			ASSERT3U(tr->tr_ds->dd_tempreserved[txgidx], >=,
    872 			    tr->tr_size);
    873 			tr->tr_ds->dd_tempreserved[txgidx] -= tr->tr_size;
    874 			mutex_exit(&tr->tr_ds->dd_lock);
    875 		} else {
    876 			arc_tempreserve_clear(tr->tr_size);
    877 		}
    878 		list_remove(tr_list, tr);
    879 		kmem_free(tr, sizeof (struct tempreserve));
    880 	}
    881 
    882 	kmem_free(tr_list, sizeof (list_t));
    883 }
    884 
    885 static void
    886 dsl_dir_willuse_space_impl(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx)
    887 {
    888 	int64_t parent_space;
    889 	uint64_t est_used;
    890 
    891 	mutex_enter(&dd->dd_lock);
    892 	if (space > 0)
    893 		dd->dd_space_towrite[tx->tx_txg & TXG_MASK] += space;
    894 
    895 	est_used = dsl_dir_space_towrite(dd) + dd->dd_used_bytes;
    896 	parent_space = parent_delta(dd, est_used, space);
    897 	mutex_exit(&dd->dd_lock);
    898 
    899 	/* Make sure that we clean up dd_space_to* */
    900 	dsl_dir_dirty(dd, tx);
    901 
    902 	/* XXX this is potentially expensive and unnecessary... */
    903 	if (parent_space && dd->dd_parent)
    904 		dsl_dir_willuse_space_impl(dd->dd_parent, parent_space, tx);
    905 }
    906 
    907 /*
    908  * Call in open context when we think we're going to write/free space,
    909  * eg. when dirtying data.  Be conservative (ie. OK to write less than
    910  * this or free more than this, but don't write more or free less).
    911  */
    912 void
    913 dsl_dir_willuse_space(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx)
    914 {
    915 	dsl_pool_willuse_space(dd->dd_pool, space, tx);
    916 	dsl_dir_willuse_space_impl(dd, space, tx);
    917 }
    918 
    919 /* call from syncing context when we actually write/free space for this dd */
    920 void
    921 dsl_dir_diduse_space(dsl_dir_t *dd,
    922     int64_t used, int64_t compressed, int64_t uncompressed, dmu_tx_t *tx)
    923 {
    924 	int64_t accounted_delta;
    925 
    926 	ASSERT(dmu_tx_is_syncing(tx));
    927 
    928 	dsl_dir_dirty(dd, tx);
    929 
    930 	mutex_enter(&dd->dd_lock);
    931 	accounted_delta = parent_delta(dd, dd->dd_used_bytes, used);
    932 	ASSERT(used >= 0 || dd->dd_used_bytes >= -used);
    933 	ASSERT(compressed >= 0 ||
    934 	    dd->dd_phys->dd_compressed_bytes >= -compressed);
    935 	ASSERT(uncompressed >= 0 ||
    936 	    dd->dd_phys->dd_uncompressed_bytes >= -uncompressed);
    937 	dd->dd_used_bytes += used;
    938 	dd->dd_phys->dd_uncompressed_bytes += uncompressed;
    939 	dd->dd_phys->dd_compressed_bytes += compressed;
    940 	mutex_exit(&dd->dd_lock);
    941 
    942 	if (dd->dd_parent != NULL) {
    943 		dsl_dir_diduse_space(dd->dd_parent,
    944 		    accounted_delta, compressed, uncompressed, tx);
    945 	}
    946 }
    947 
    948 static int
    949 dsl_dir_set_quota_check(void *arg1, void *arg2, dmu_tx_t *tx)
    950 {
    951 	dsl_dir_t *dd = arg1;
    952 	uint64_t *quotap = arg2;
    953 	uint64_t new_quota = *quotap;
    954 	int err = 0;
    955 	uint64_t towrite;
    956 
    957 	if (new_quota == 0)
    958 		return (0);
    959 
    960 	mutex_enter(&dd->dd_lock);
    961 	/*
    962 	 * If we are doing the preliminary check in open context, and
    963 	 * there are pending changes, then don't fail it, since the
    964 	 * pending changes could under-estimate the amount of space to be
    965 	 * freed up.
    966 	 */
    967 	towrite = dsl_dir_space_towrite(dd);
    968 	if ((dmu_tx_is_syncing(tx) || towrite == 0) &&
    969 	    (new_q