22c22
< * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
---
> * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
26,27d25
< #pragma ident "%Z%%M% %I% %E% SMI"
<
28a27
> #include <sys/dmu_objset.h>
33a33
> #include <sys/dsl_deleg.h>
37a38
> #include <sys/sunddi.h>
40,41c41,43
< static uint64_t dsl_dir_estimated_space(dsl_dir_t *dd);
< static void dsl_dir_set_reservation_sync(void *arg1, void *arg2, dmu_tx_t *tx);
---
> static uint64_t dsl_dir_space_towrite(dsl_dir_t *dd);
> static void dsl_dir_set_reservation_sync(void *arg1, void *arg2,
> cred_t *cr, dmu_tx_t *tx);
58,59d59
< ASSERT3U(dd->dd_used_bytes, ==, dd->dd_phys->dd_used_bytes);
<
93a94
> ASSERT3U(doi.doi_bonus_size, >=, sizeof (dsl_dir_phys_t));
96d96
< /* XXX assert bonus buffer size is correct */
106d105
< dd->dd_used_bytes = dd->dd_phys->dd_used_bytes;
115,120c114,115
< if (err) {
< mutex_destroy(&dd->dd_lock);
< kmem_free(dd, sizeof (dsl_dir_t));
< dmu_buf_rele(dbuf, tag);
< return (err);
< }
---
> if (err)
> goto errout;
126,127c121
< dd->dd_parent->dd_phys->
< dd_child_dir_zapobj,
---
> dd->dd_parent->dd_phys->dd_child_dir_zapobj,
134,136c128,129
< dd->dd_parent->dd_phys->
< dd_child_dir_zapobj,
< ddobj, dd->dd_myname);
---
> dd->dd_parent->dd_phys->dd_child_dir_zapobj,
> ddobj, 0, dd->dd_myname);
138,144c131,132
< if (err) {
< dsl_dir_close(dd->dd_parent, dd);
< mutex_destroy(&dd->dd_lock);
< kmem_free(dd, sizeof (dsl_dir_t));
< dmu_buf_rele(dbuf, tag);
< return (err);
< }
---
> if (err)
> goto errout;
176a165,173
>
> errout:
> if (dd->dd_parent)
> dsl_dir_close(dd->dd_parent, dd);
> mutex_destroy(&dd->dd_lock);
> kmem_free(dd, sizeof (dsl_dir_t));
> dmu_buf_rele(dbuf, tag);
> return (err);
>
407c404,405
< dsl_dir_create_sync(dsl_dir_t *pds, const char *name, dmu_tx_t *tx)
---
> dsl_dir_create_sync(dsl_pool_t *dp, dsl_dir_t *pds, const char *name,
> dmu_tx_t *tx)
409c407
< objset_t *mos = pds->dd_pool->dp_meta_objset;
---
> objset_t *mos = dp->dp_meta_objset;
416,417c414,421
< VERIFY(0 == zap_add(mos, pds->dd_phys->dd_child_dir_zapobj,
< name, sizeof (uint64_t), 1, &ddobj, tx));
---
> if (pds) {
> VERIFY(0 == zap_add(mos, pds->dd_phys->dd_child_dir_zapobj,
> name, sizeof (uint64_t), 1, &ddobj, tx));
> } else {
> /* it's the root dir */
> VERIFY(0 == zap_add(mos, DMU_POOL_DIRECTORY_OBJECT,
> DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1, &ddobj, tx));
> }
423c427,428
< dsphys->dd_parent_obj = pds->dd_object;
---
> if (pds)
> dsphys->dd_parent_obj = pds->dd_object;
427a433,434
> if (spa_version(dp->dp_spa) >= SPA_VERSION_USED_BREAKDOWN)
> dsphys->dd_flags |= DD_FLAG_USED_BREAKDOWN;
464c471
< dsl_dir_destroy_sync(void *arg1, void *tag, dmu_tx_t *tx)
---
> dsl_dir_destroy_sync(void *arg1, void *tag, cred_t *cr, dmu_tx_t *tx)
468a476
> dd_used_t t;
475,476c483,484
< dsl_dir_set_reservation_sync(dd, &val, tx);
< ASSERT3U(dd->dd_used_bytes, ==, 0);
---
> dsl_dir_set_reservation_sync(dd, &val, cr, tx);
> ASSERT3U(dd->dd_phys->dd_used_bytes, ==, 0);
477a486,487
> for (t = 0; t < DD_USED_NUM; t++)
> ASSERT3U(dd->dd_phys->dd_used_breakdown[t], ==, 0);
480a491
> VERIFY(0 == dsl_deleg_destroy(mos, dd->dd_phys->dd_deleg_zapobj, tx));
489,490c500,501
< void
< dsl_dir_create_root(objset_t *mos, uint64_t *ddobjp, dmu_tx_t *tx)
---
> boolean_t
> dsl_dir_is_clone(dsl_dir_t *dd)
492,513c503,506
< dsl_dir_phys_t *dsp;
< dmu_buf_t *dbuf;
< int error;
<
< *ddobjp = dmu_object_alloc(mos, DMU_OT_DSL_DIR, 0,
< DMU_OT_DSL_DIR, sizeof (dsl_dir_phys_t), tx);
<
< error = zap_add(mos, DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ROOT_DATASET,
< sizeof (uint64_t), 1, ddobjp, tx);
< ASSERT3U(error, ==, 0);
<
< VERIFY(0 == dmu_bonus_hold(mos, *ddobjp, FTAG, &dbuf));
< dmu_buf_will_dirty(dbuf, tx);
< dsp = dbuf->db_data;
<
< dsp->dd_creation_time = gethrestime_sec();
< dsp->dd_props_zapobj = zap_create(mos,
< DMU_OT_DSL_PROPS, DMU_OT_NONE, 0, tx);
< dsp->dd_child_dir_zapobj = zap_create(mos,
< DMU_OT_DSL_DIR_CHILD_MAP, DMU_OT_NONE, 0, tx);
<
< dmu_buf_rele(dbuf, FTAG);
---
> return (dd->dd_phys->dd_origin_obj &&
> (dd->dd_pool->dp_origin_snap == NULL ||
> dd->dd_phys->dd_origin_obj !=
> dd->dd_pool->dp_origin_snap->ds_object));
519,521d511
< dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_AVAILABLE,
< dsl_dir_space_available(dd, NULL, 0, TRUE));
<
523,525c513,515
< dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED, dd->dd_used_bytes);
< dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_QUOTA,
< dd->dd_phys->dd_quota);
---
> dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,
> dd->dd_phys->dd_used_bytes);
> dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_QUOTA, dd->dd_phys->dd_quota);
531a522,532
> if (dd->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN) {
> dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDSNAP,
> dd->dd_phys->dd_used_breakdown[DD_USED_SNAP]);
> dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDDS,
> dd->dd_phys->dd_used_breakdown[DD_USED_HEAD]);
> dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDREFRESERV,
> dd->dd_phys->dd_used_breakdown[DD_USED_REFRSRV]);
> dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDCHILD,
> dd->dd_phys->dd_used_breakdown[DD_USED_CHILD] +
> dd->dd_phys->dd_used_breakdown[DD_USED_CHILD_RSRV]);
> }
534c535,536
< if (dd->dd_phys->dd_clone_parent_obj) {
---
> rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
> if (dsl_dir_is_clone(dd)) {
538,541c540,541
< rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
< VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool,
< dd->dd_phys->dd_clone_parent_obj,
< NULL, DS_MODE_NONE, FTAG, &ds));
---
> VERIFY(0 == dsl_dataset_hold_obj(dd->dd_pool,
> dd->dd_phys->dd_origin_obj, FTAG, &ds));
543,545c543
< dsl_dataset_close(ds, DS_MODE_NONE, FTAG);
< rw_exit(&dd->dd_pool->dp_config_rwlock);
<
---
> dsl_dataset_rele(ds, FTAG);
547a546
> rw_exit(&dd->dd_pool->dp_config_rwlock);
583d581
< dd->dd_phys->dd_used_bytes = dd->dd_used_bytes;
591c589
< dsl_dir_estimated_space(dsl_dir_t *dd)
---
> dsl_dir_space_towrite(dsl_dir_t *dd)
593c591
< int64_t space;
---
> uint64_t space = 0;
598,599d595
< space = dd->dd_phys->dd_used_bytes;
< ASSERT(space >= 0);
633,639c629,631
< if (ondiskonly) {
< used = dd->dd_used_bytes;
< } else {
< used = dsl_dir_estimated_space(dd);
< }
< if (dd == ancestor)
< used += delta;
---
> used = dd->dd_phys->dd_used_bytes;
> if (!ondiskonly)
> used += dsl_dir_space_towrite(dd);
653a646,653
> if (dd == ancestor) {
> ASSERT(delta <= 0);
> ASSERT(used >= -delta);
> used += delta;
> if (parentspace != UINT64_MAX)
> parentspace -= delta;
> }
>
680a681
> dsl_pool_t *tr_dp;
685,690d685
< /*
< * Reserve space in this dsl_dir, to be used in this tx's txg.
< * After the space has been dirtied (and thus
< * dsl_dir_willuse_space() has been called), the reservation should
< * be canceled, using dsl_dir_tempreserve_clear().
< */
692,693c687,689
< dsl_dir_tempreserve_impl(dsl_dir_t *dd,
< uint64_t asize, boolean_t netfree, list_t *tr_list, dmu_tx_t *tx)
---
> dsl_dir_tempreserve_impl(dsl_dir_t *dd, uint64_t asize, boolean_t netfree,
> boolean_t ignorequota, boolean_t checkrefquota, list_t *tr_list,
> dmu_tx_t *tx, boolean_t first)
696,697c692,694
< uint64_t est_used, quota, parent_rsrv;
< int edquot = EDQUOT;
---
> uint64_t est_inflight, used_on_disk, quota, parent_rsrv;
> struct tempreserve *tr;
> int enospc = EDQUOT;
700c697
< struct tempreserve *tr;
---
> uint64_t ref_rsrv = 0;
703c700
< ASSERT3S(asize, >=, 0);
---
> ASSERT3S(asize, >, 0);
705a703
>
710c708
< est_used = dsl_dir_estimated_space(dd);
---
> est_inflight = dsl_dir_space_towrite(dd);
712c710,711
< est_used += dd->dd_tempreserved[i];
---
> est_inflight += dd->dd_tempreserved[i];
> used_on_disk = dd->dd_phys->dd_used_bytes;
714c713,720
< quota = UINT64_MAX;
---
> /*
> * On the first iteration, fetch the dataset's used-on-disk and
> * refreservation values. Also, if checkrefquota is set, test if
> * allocating this space would exceed the dataset's refquota.
> */
> if (first && tx->tx_objset) {
> int error;
> dsl_dataset_t *ds = tx->tx_objset->os->os_dsl_dataset;
716c722,736
< if (dd->dd_phys->dd_quota)
---
> error = dsl_dataset_check_quota(ds, checkrefquota,
> asize, est_inflight, &used_on_disk, &ref_rsrv);
> if (error) {
> mutex_exit(&dd->dd_lock);
> return (error);
> }
> }
>
> /*
> * If this transaction will result in a net free of space,
> * we want to let it through.
> */
> if (ignorequota || netfree || dd->dd_phys->dd_quota == 0)
> quota = UINT64_MAX;
> else
720,724c740,742
< * If this transaction will result in a net free of space, we want
< * to let it through, but we have to be careful: the space that it
< * frees won't become available until *after* this txg syncs.
< * Therefore, to ensure that it's possible to remove files from
< * a full pool without inducing transient overcommits, we throttle
---
> * Adjust the quota against the actual pool size at the root.
> * To ensure that it's possible to remove files from a full
> * pool without inducing transient overcommits, we throttle
734c752
< edquot = ENOSPC;
---
> enospc = ENOSPC;
736,737d753
< } else if (netfree) {
< quota = UINT64_MAX;
742c758
< * is over quota. They get to try again unless the actual
---
> * is over quota, they get to try again unless the actual
746,752c762,765
< if (asize > 0 && est_used > quota) {
< if (dd->dd_space_towrite[txg & TXG_MASK] != 0 ||
< dd->dd_space_towrite[(txg-1) & TXG_MASK] != 0 ||
< dd->dd_space_towrite[(txg-2) & TXG_MASK] != 0 ||
< dd->dd_used_bytes < quota)
< edquot = ERESTART;
< dprintf_dd(dd, "failing: used=%lluK est_used = %lluK "
---
> if (used_on_disk + est_inflight > quota) {
> if (est_inflight > 0 || used_on_disk < quota)
> enospc = ERESTART;
> dprintf_dd(dd, "failing: used=%lluK inflight = %lluK "
754,755c767,768
< dd->dd_used_bytes>>10, est_used>>10,
< quota>>10, asize>>10, edquot);
---
> used_on_disk>>10, est_inflight>>10,
> quota>>10, asize>>10, enospc);
757c770
< return (edquot);
---
> return (enospc);
763c776,777
< parent_rsrv = parent_delta(dd, est_used, asize);
---
> parent_rsrv = parent_delta(dd, used_on_disk + est_inflight,
> asize - ref_rsrv);
766c780
< tr = kmem_alloc(sizeof (struct tempreserve), KM_SLEEP);
---
> tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP);
772a787,788
> boolean_t ismos = (dd->dd_phys->dd_head_dataset_obj == 0);
>
774c790
< parent_rsrv, netfree, tr_list, tx));
---
> parent_rsrv, netfree, ismos, TRUE, tr_list, tx, FALSE));
782,784c798,800
< * After the space has been dirtied (and thus
< * dsl_dir_willuse_space() has been called), the reservation should
< * be canceled, using dsl_dir_tempreserve_clear().
---
> * After the space has been dirtied (and dsl_dir_willuse_space()
> * has been called), the reservation should be canceled, using
> * dsl_dir_tempreserve_clear().
787,788c803,804
< dsl_dir_tempreserve_space(dsl_dir_t *dd, uint64_t lsize,
< uint64_t asize, uint64_t fsize, void **tr_cookiep, dmu_tx_t *tx)
---
> dsl_dir_tempreserve_space(dsl_dir_t *dd, uint64_t lsize, uint64_t asize,
> uint64_t fsize, uint64_t usize, void **tr_cookiep, dmu_tx_t *tx)
790c806
< int err = 0;
---
> int err;
792a809,813
> if (asize == 0) {
> *tr_cookiep = NULL;
> return (0);
> }
>
796c817
< ASSERT3S(asize, >=, 0);
---
> ASSERT3S(asize, >, 0);
799,801c820
< err = dsl_dir_tempreserve_impl(dd, asize, fsize >= asize,
< tr_list, tx);
<
---
> err = arc_tempreserve_space(lsize, tx->tx_txg);
805,810c824,832
< err = arc_tempreserve_space(lsize);
< if (err == 0) {
< tr = kmem_alloc(sizeof (struct tempreserve), KM_SLEEP);
< tr->tr_ds = NULL;
< tr->tr_size = lsize;
< list_insert_tail(tr_list, tr);
---
> tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP);
> tr->tr_size = lsize;
> list_insert_tail(tr_list, tr);
>
> err = dsl_pool_tempreserve_space(dd->dd_pool, asize, tx);
> } else {
> if (err == EAGAIN) {
> txg_delay(dd->dd_pool, tx->tx_txg, 1);
> err = ERESTART;
811a834
> dsl_pool_memory_pressure(dd->dd_pool);
813a837,848
> if (err == 0) {
> struct tempreserve *tr;
>
> tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP);
> tr->tr_dp = dd->dd_pool;
> tr->tr_size = asize;
> list_insert_tail(tr_list, tr);
>
> err = dsl_dir_tempreserve_impl(dd, asize, fsize >= asize,
> FALSE, asize > usize, tr_list, tx, TRUE);
> }
>
817a853
>
833a870,872
> if (tr_cookie == NULL)
> return;
>
835,837c874,876
< if (tr->tr_ds == NULL) {
< arc_tempreserve_clear(tr->tr_size);
< } else {
---
> if (tr->tr_dp) {
> dsl_pool_tempreserve_clear(tr->tr_dp, tr->tr_size, tx);
> } else if (tr->tr_ds) {
842a882,883
> } else {
> arc_tempreserve_clear(tr->tr_size);
851,857c892,893
< /*
< * Call in open context when we think we're going to write/free space,
< * eg. when dirtying data. Be conservative (ie. OK to write less than
< * this or free more than this, but don't write more or free less).
< */
< void
< dsl_dir_willuse_space(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx)
---
> static void
> dsl_dir_willuse_space_impl(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx)
866c902
< est_used = dsl_dir_estimated_space(dd);
---
> est_used = dsl_dir_space_towrite(dd) + dd->dd_phys->dd_used_bytes;
875c911
< dsl_dir_willuse_space(dd->dd_parent, parent_space, tx);
---
> dsl_dir_willuse_space_impl(dd->dd_parent, parent_space, tx);
877a914,925
> /*
> * Call in open context when we think we're going to write/free space,
> * eg. when dirtying data. Be conservative (ie. OK to write less than
> * this or free more than this, but don't write more or free less).
> */
> void
> dsl_dir_willuse_space(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx)
> {
> dsl_pool_willuse_space(dd->dd_pool, space, tx);
> dsl_dir_willuse_space_impl(dd, space, tx);
> }
>
880c928
< dsl_dir_diduse_space(dsl_dir_t *dd,
---
> dsl_dir_diduse_space(dsl_dir_t *dd, dd_used_t type,
883a932
> boolean_t needlock = !MUTEX_HELD(&dd->dd_lock);
885a935
> ASSERT(type < DD_USED_NUM);
889,891c939,942
< mutex_enter(&dd->dd_lock);
< accounted_delta = parent_delta(dd, dd->dd_used_bytes, used);
< ASSERT(used >= 0 || dd->dd_used_bytes >= -used);
---
> if (needlock)
> mutex_enter(&dd->dd_lock);
> accounted_delta = parent_delta(dd, dd->dd_phys->dd_used_bytes, used);
> ASSERT(used >= 0 || dd->dd_phys->dd_used_bytes >= -used);
896c947
< dd->dd_used_bytes += used;
---
> dd->dd_phys->dd_used_bytes += used;
899d949
< mutex_exit(&dd->dd_lock);
900a951,965
> if (dd->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN) {
> ASSERT(used > 0 ||
> dd->dd_phys->dd_used_breakdown[type] >= -used);
> dd->dd_phys->dd_used_breakdown[type] += used;
> #ifdef DEBUG
> dd_used_t t;
> uint64_t u = 0;
> for (t = 0; t < DD_USED_NUM; t++)
> u += dd->dd_phys->dd_used_breakdown[t];
> ASSERT3U(u, ==, dd->dd_phys->dd_used_bytes);
> #endif
> }
> if (needlock)
> mutex_exit(&dd->dd_lock);
>
902c967
< dsl_dir_diduse_space(dd->dd_parent,
---
> dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD,
903a969,971
> dsl_dir_transfer_space(dd->dd_parent,
> used - accounted_delta,
> DD_USED_CHILD_RSRV, DD_USED_CHILD, tx);
907c975,1000
< /* ARGSUSED */
---
> void
> dsl_dir_transfer_space(dsl_dir_t *dd, int64_t delta,
> dd_used_t oldtype, dd_used_t newtype, dmu_tx_t *tx)
> {
> boolean_t needlock = !MUTEX_HELD(&dd->dd_lock);
>
> ASSERT(dmu_tx_is_syncing(tx));
> ASSERT(oldtype < DD_USED_NUM);
> ASSERT(newtype < DD_USED_NUM);
>
> if (delta == 0 || !(dd->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN))
> return;
>
> dsl_dir_dirty(dd, tx);
> if (needlock)
> mutex_enter(&dd->dd_lock);
> ASSERT(delta > 0 ?
> dd->dd_phys->dd_used_breakdown[oldtype] >= delta :
> dd->dd_phys->dd_used_breakdown[newtype] >= -delta);
> ASSERT(dd->dd_phys->dd_used_bytes >= ABS(delta));
> dd->dd_phys->dd_used_breakdown[oldtype] -= delta;
> dd->dd_phys->dd_used_breakdown[newtype] += delta;
> if (needlock)
> mutex_exit(&dd->dd_lock);
> }
>
924c1017
< * pending changes could under-estimat the amount of space to be
---
> * pending changes could under-estimate the amount of space to be
927,928c1020
< towrite = dd->dd_space_towrite[0] + dd->dd_space_towrite[1] +
< dd->dd_space_towrite[2] + dd->dd_space_towrite[3];
---
> towrite = dsl_dir_space_towrite(dd);
931c1023
< new_quota < dsl_dir_estimated_space(dd))) {
---
> new_quota < dd->dd_phys->dd_used_bytes + towrite)) {
937a1030
> /* ARGSUSED */
939c1032
< dsl_dir_set_quota_sync(void *arg1, void *arg2, dmu_tx_t *tx)
---
> dsl_dir_set_quota_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
949a1043,1046
>
> spa_history_internal_log(LOG_DS_QUOTA, dd->dd_pool->dp_spa,
> tx, cr, "%lld dataset = %llu ",
> (longlong_t)new_quota, dd->dd_phys->dd_head_dataset_obj);
961,965d1057
< /*
< * If someone removes a file, then tries to set the quota, we
< * want to make sure the file freeing takes effect.
< */
< txg_wait_open(dd->dd_pool, 0);
967,968c1059,1068
< err = dsl_sync_task_do(dd->dd_pool, dsl_dir_set_quota_check,
< dsl_dir_set_quota_sync, dd, &quota, 0);
---
> if (quota != dd->dd_phys->dd_quota) {
> /*
> * If someone removes a file, then tries to set the quota, we
> * want to make sure the file freeing takes effect.
> */
> txg_wait_open(dd->dd_pool, 0);
>
> err = dsl_sync_task_do(dd->dd_pool, dsl_dir_set_quota_check,
> dsl_dir_set_quota_sync, dd, &quota, 0);
> }
973,974c1073
< /* ARGSUSED */
< static int
---
> int
994c1093
< used = dd->dd_used_bytes;
---
> used = dd->dd_phys->dd_used_bytes;
1013a1113
> /* ARGSUSED */
1015c1115
< dsl_dir_set_reservation_sync(void *arg1, void *arg2, dmu_tx_t *tx)
---
> dsl_dir_set_reservation_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
1022a1123,1124
> dmu_buf_will_dirty(dd->dd_dbuf, tx);
>
1024c1126
< used = dd->dd_used_bytes;
---
> used = dd->dd_phys->dd_used_bytes;
1027,1029d1128
< mutex_exit(&dd->dd_lock);
<
< dmu_buf_will_dirty(dd->dd_dbuf, tx);
1034c1133,1134
< dsl_dir_diduse_space(dd->dd_parent, delta, 0, 0, tx);
---
> dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD_RSRV,
> delta, 0, 0, tx);
1035a1136,1140
> mutex_exit(&dd->dd_lock);
>
> spa_history_internal_log(LOG_DS_RESERVATION, dd->dd_pool->dp_spa,
> tx, cr, "%lld dataset = %llu",
> (longlong_t)new_reservation, dd->dd_phys->dd_head_dataset_obj);
1077c1182
< delta = parent_delta(dd, dd->dd_used_bytes, delta);
---
> delta = parent_delta(dd, dd->dd_phys->dd_used_bytes, delta);
1087c1192
< /* ARGSUSED */
---
> /*ARGSUSED*/
1113c1218
< MAX(dd->dd_used_bytes, dd->dd_phys->dd_reserved);
---
> MAX(dd->dd_phys->dd_used_bytes, dd->dd_phys->dd_reserved);
1128c1233
< dsl_dir_rename_sync(void *arg1, void *arg2, dmu_tx_t *tx)
---
> dsl_dir_rename_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
1139,1142c1244,1245
< uint64_t myspace =
< MAX(dd->dd_used_bytes, dd->dd_phys->dd_reserved);
<
< dsl_dir_diduse_space(dd->dd_parent, -myspace,
---
> dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD,
> -dd->dd_phys->dd_used_bytes,
1145c1248,1249
< dsl_dir_diduse_space(ra->newparent, myspace,
---
> dsl_dir_diduse_space(ra->newparent, DD_USED_CHILD,
> dd->dd_phys->dd_used_bytes,
1147a1252,1261
>
> if (dd->dd_phys->dd_reserved > dd->dd_phys->dd_used_bytes) {
> uint64_t unused_rsrv = dd->dd_phys->dd_reserved -
> dd->dd_phys->dd_used_bytes;
>
> dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD_RSRV,
> -unused_rsrv, 0, 0, tx);
> dsl_dir_diduse_space(ra->newparent, DD_USED_CHILD_RSRV,
> unused_rsrv, 0, 0, tx);
> }
1166a1281,1283
>
> spa_history_internal_log(LOG_DS_RENAME, dd->dd_pool->dp_spa,
> tx, cr, "dataset = %llu", dd->dd_phys->dd_head_dataset_obj);
1192d1308
<