dsl_dir.c revision 263390
1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net>. 24 * All rights reserved. 25 * Copyright (c) 2013 by Delphix. All rights reserved. 26 */ 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/dmu_impl.h> 37#include <sys/spa.h> 38#include <sys/metaslab.h> 39#include <sys/zap.h> 40#include <sys/zio.h> 41#include <sys/arc.h> 42#include <sys/sunddi.h> 43#include <sys/zvol.h> 44#ifdef _KERNEL 45#include <sys/zfs_vfsops.h> 46#endif 47#include "zfs_namecheck.h" 48 49static uint64_t dsl_dir_space_towrite(dsl_dir_t *dd); 50 51/* ARGSUSED */ 52static void 53dsl_dir_evict(dmu_buf_t *db, void *arg) 54{ 55 dsl_dir_t *dd = arg; 56 dsl_pool_t *dp = dd->dd_pool; 57 int t; 58 59 for (t = 0; t < TXG_SIZE; t++) { 60 ASSERT(!txg_list_member(&dp->dp_dirty_dirs, dd, t)); 61 ASSERT(dd->dd_tempreserved[t] == 0); 62 ASSERT(dd->dd_space_towrite[t] == 0); 63 } 64 65 if (dd->dd_parent) 66 dsl_dir_rele(dd->dd_parent, dd); 67 68 spa_close(dd->dd_pool->dp_spa, dd); 69 70 /* 71 * The props callback list should have been cleaned up by 72 * objset_evict(). 73 */ 74 list_destroy(&dd->dd_prop_cbs); 75 mutex_destroy(&dd->dd_lock); 76 kmem_free(dd, sizeof (dsl_dir_t)); 77} 78 79int 80dsl_dir_hold_obj(dsl_pool_t *dp, uint64_t ddobj, 81 const char *tail, void *tag, dsl_dir_t **ddp) 82{ 83 dmu_buf_t *dbuf; 84 dsl_dir_t *dd; 85 int err; 86 87 ASSERT(dsl_pool_config_held(dp)); 88 89 err = dmu_bonus_hold(dp->dp_meta_objset, ddobj, tag, &dbuf); 90 if (err != 0) 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_bonus_type, ==, DMU_OT_DSL_DIR); 98 ASSERT3U(doi.doi_bonus_size, >=, sizeof (dsl_dir_phys_t)); 99 } 100#endif 101 if (dd == NULL) { 102 dsl_dir_t *winner; 103 104 dd = kmem_zalloc(sizeof (dsl_dir_t), KM_SLEEP); 105 dd->dd_object = ddobj; 106 dd->dd_dbuf = dbuf; 107 dd->dd_pool = dp; 108 dd->dd_phys = dbuf->db_data; 109 mutex_init(&dd->dd_lock, NULL, MUTEX_DEFAULT, NULL); 110 111 list_create(&dd->dd_prop_cbs, sizeof (dsl_prop_cb_record_t), 112 offsetof(dsl_prop_cb_record_t, cbr_node)); 113 114 dsl_dir_snap_cmtime_update(dd); 115 116 if (dd->dd_phys->dd_parent_obj) { 117 err = dsl_dir_hold_obj(dp, dd->dd_phys->dd_parent_obj, 118 NULL, dd, &dd->dd_parent); 119 if (err != 0) 120 goto errout; 121 if (tail) { 122#ifdef ZFS_DEBUG 123 uint64_t foundobj; 124 125 err = zap_lookup(dp->dp_meta_objset, 126 dd->dd_parent->dd_phys->dd_child_dir_zapobj, 127 tail, sizeof (foundobj), 1, &foundobj); 128 ASSERT(err || foundobj == ddobj); 129#endif 130 (void) strcpy(dd->dd_myname, tail); 131 } else { 132 err = zap_value_search(dp->dp_meta_objset, 133 dd->dd_parent->dd_phys->dd_child_dir_zapobj, 134 ddobj, 0, dd->dd_myname); 135 } 136 if (err != 0) 137 goto errout; 138 } else { 139 (void) strcpy(dd->dd_myname, spa_name(dp->dp_spa)); 140 } 141 142 if (dsl_dir_is_clone(dd)) { 143 dmu_buf_t *origin_bonus; 144 dsl_dataset_phys_t *origin_phys; 145 146 /* 147 * We can't open the origin dataset, because 148 * that would require opening this dsl_dir. 149 * Just look at its phys directly instead. 150 */ 151 err = dmu_bonus_hold(dp->dp_meta_objset, 152 dd->dd_phys->dd_origin_obj, FTAG, &origin_bonus); 153 if (err != 0) 154 goto errout; 155 origin_phys = origin_bonus->db_data; 156 dd->dd_origin_txg = 157 origin_phys->ds_creation_txg; 158 dmu_buf_rele(origin_bonus, FTAG); 159 } 160 161 winner = dmu_buf_set_user_ie(dbuf, dd, &dd->dd_phys, 162 dsl_dir_evict); 163 if (winner) { 164 if (dd->dd_parent) 165 dsl_dir_rele(dd->dd_parent, dd); 166 mutex_destroy(&dd->dd_lock); 167 kmem_free(dd, sizeof (dsl_dir_t)); 168 dd = winner; 169 } else { 170 spa_open_ref(dp->dp_spa, dd); 171 } 172 } 173 174 /* 175 * The dsl_dir_t has both open-to-close and instantiate-to-evict 176 * holds on the spa. We need the open-to-close holds because 177 * otherwise the spa_refcnt wouldn't change when we open a 178 * dir which the spa also has open, so we could incorrectly 179 * think it was OK to unload/export/destroy the pool. We need 180 * the instantiate-to-evict hold because the dsl_dir_t has a 181 * pointer to the dd_pool, which has a pointer to the spa_t. 182 */ 183 spa_open_ref(dp->dp_spa, tag); 184 ASSERT3P(dd->dd_pool, ==, dp); 185 ASSERT3U(dd->dd_object, ==, ddobj); 186 ASSERT3P(dd->dd_dbuf, ==, dbuf); 187 *ddp = dd; 188 return (0); 189 190errout: 191 if (dd->dd_parent) 192 dsl_dir_rele(dd->dd_parent, dd); 193 mutex_destroy(&dd->dd_lock); 194 kmem_free(dd, sizeof (dsl_dir_t)); 195 dmu_buf_rele(dbuf, tag); 196 return (err); 197} 198 199void 200dsl_dir_rele(dsl_dir_t *dd, void *tag) 201{ 202 dprintf_dd(dd, "%s\n", ""); 203 spa_close(dd->dd_pool->dp_spa, tag); 204 dmu_buf_rele(dd->dd_dbuf, tag); 205} 206 207/* buf must be long enough (MAXNAMELEN + strlen(MOS_DIR_NAME) + 1 should do) */ 208void 209dsl_dir_name(dsl_dir_t *dd, char *buf) 210{ 211 if (dd->dd_parent) { 212 dsl_dir_name(dd->dd_parent, buf); 213 (void) strcat(buf, "/"); 214 } else { 215 buf[0] = '\0'; 216 } 217 if (!MUTEX_HELD(&dd->dd_lock)) { 218 /* 219 * recursive mutex so that we can use 220 * dprintf_dd() with dd_lock held 221 */ 222 mutex_enter(&dd->dd_lock); 223 (void) strcat(buf, dd->dd_myname); 224 mutex_exit(&dd->dd_lock); 225 } else { 226 (void) strcat(buf, dd->dd_myname); 227 } 228} 229 230/* Calculate name length, avoiding all the strcat calls of dsl_dir_name */ 231int 232dsl_dir_namelen(dsl_dir_t *dd) 233{ 234 int result = 0; 235 236 if (dd->dd_parent) { 237 /* parent's name + 1 for the "/" */ 238 result = dsl_dir_namelen(dd->dd_parent) + 1; 239 } 240 241 if (!MUTEX_HELD(&dd->dd_lock)) { 242 /* see dsl_dir_name */ 243 mutex_enter(&dd->dd_lock); 244 result += strlen(dd->dd_myname); 245 mutex_exit(&dd->dd_lock); 246 } else { 247 result += strlen(dd->dd_myname); 248 } 249 250 return (result); 251} 252 253static int 254getcomponent(const char *path, char *component, const char **nextp) 255{ 256 char *p; 257 258 if ((path == NULL) || (path[0] == '\0')) 259 return (SET_ERROR(ENOENT)); 260 /* This would be a good place to reserve some namespace... */ 261 p = strpbrk(path, "/@"); 262 if (p && (p[1] == '/' || p[1] == '@')) { 263 /* two separators in a row */ 264 return (SET_ERROR(EINVAL)); 265 } 266 if (p == NULL || p == path) { 267 /* 268 * if the first thing is an @ or /, it had better be an 269 * @ and it had better not have any more ats or slashes, 270 * and it had better have something after the @. 271 */ 272 if (p != NULL && 273 (p[0] != '@' || strpbrk(path+1, "/@") || p[1] == '\0')) 274 return (SET_ERROR(EINVAL)); 275 if (strlen(path) >= MAXNAMELEN) 276 return (SET_ERROR(ENAMETOOLONG)); 277 (void) strcpy(component, path); 278 p = NULL; 279 } else if (p[0] == '/') { 280 if (p - path >= MAXNAMELEN) 281 return (SET_ERROR(ENAMETOOLONG)); 282 (void) strncpy(component, path, p - path); 283 component[p - path] = '\0'; 284 p++; 285 } else if (p[0] == '@') { 286 /* 287 * if the next separator is an @, there better not be 288 * any more slashes. 289 */ 290 if (strchr(path, '/')) 291 return (SET_ERROR(EINVAL)); 292 if (p - path >= MAXNAMELEN) 293 return (SET_ERROR(ENAMETOOLONG)); 294 (void) strncpy(component, path, p - path); 295 component[p - path] = '\0'; 296 } else { 297 panic("invalid p=%p", (void *)p); 298 } 299 *nextp = p; 300 return (0); 301} 302 303/* 304 * Return the dsl_dir_t, and possibly the last component which couldn't 305 * be found in *tail. The name must be in the specified dsl_pool_t. This 306 * thread must hold the dp_config_rwlock for the pool. Returns NULL if the 307 * path is bogus, or if tail==NULL and we couldn't parse the whole name. 308 * (*tail)[0] == '@' means that the last component is a snapshot. 309 */ 310int 311dsl_dir_hold(dsl_pool_t *dp, const char *name, void *tag, 312 dsl_dir_t **ddp, const char **tailp) 313{ 314 char buf[MAXNAMELEN]; 315 const char *spaname, *next, *nextnext = NULL; 316 int err; 317 dsl_dir_t *dd; 318 uint64_t ddobj; 319 320 err = getcomponent(name, buf, &next); 321 if (err != 0) 322 return (err); 323 324 /* Make sure the name is in the specified pool. */ 325 spaname = spa_name(dp->dp_spa); 326 if (strcmp(buf, spaname) != 0) 327 return (SET_ERROR(EINVAL)); 328 329 ASSERT(dsl_pool_config_held(dp)); 330 331 err = dsl_dir_hold_obj(dp, dp->dp_root_dir_obj, NULL, tag, &dd); 332 if (err != 0) { 333 return (err); 334 } 335 336 while (next != NULL) { 337 dsl_dir_t *child_ds; 338 err = getcomponent(next, buf, &nextnext); 339 if (err != 0) 340 break; 341 ASSERT(next[0] != '\0'); 342 if (next[0] == '@') 343 break; 344 dprintf("looking up %s in obj%lld\n", 345 buf, dd->dd_phys->dd_child_dir_zapobj); 346 347 err = zap_lookup(dp->dp_meta_objset, 348 dd->dd_phys->dd_child_dir_zapobj, 349 buf, sizeof (ddobj), 1, &ddobj); 350 if (err != 0) { 351 if (err == ENOENT) 352 err = 0; 353 break; 354 } 355 356 err = dsl_dir_hold_obj(dp, ddobj, buf, tag, &child_ds); 357 if (err != 0) 358 break; 359 dsl_dir_rele(dd, tag); 360 dd = child_ds; 361 next = nextnext; 362 } 363 364 if (err != 0) { 365 dsl_dir_rele(dd, tag); 366 return (err); 367 } 368 369 /* 370 * It's an error if there's more than one component left, or 371 * tailp==NULL and there's any component left. 372 */ 373 if (next != NULL && 374 (tailp == NULL || (nextnext && nextnext[0] != '\0'))) { 375 /* bad path name */ 376 dsl_dir_rele(dd, tag); 377 dprintf("next=%p (%s) tail=%p\n", next, next?next:"", tailp); 378 err = SET_ERROR(ENOENT); 379 } 380 if (tailp != NULL) 381 *tailp = next; 382 *ddp = dd; 383 return (err); 384} 385 386uint64_t 387dsl_dir_create_sync(dsl_pool_t *dp, dsl_dir_t *pds, const char *name, 388 dmu_tx_t *tx) 389{ 390 objset_t *mos = dp->dp_meta_objset; 391 uint64_t ddobj; 392 dsl_dir_phys_t *ddphys; 393 dmu_buf_t *dbuf; 394 395 ddobj = dmu_object_alloc(mos, DMU_OT_DSL_DIR, 0, 396 DMU_OT_DSL_DIR, sizeof (dsl_dir_phys_t), tx); 397 if (pds) { 398 VERIFY(0 == zap_add(mos, pds->dd_phys->dd_child_dir_zapobj, 399 name, sizeof (uint64_t), 1, &ddobj, tx)); 400 } else { 401 /* it's the root dir */ 402 VERIFY(0 == zap_add(mos, DMU_POOL_DIRECTORY_OBJECT, 403 DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1, &ddobj, tx)); 404 } 405 VERIFY(0 == dmu_bonus_hold(mos, ddobj, FTAG, &dbuf)); 406 dmu_buf_will_dirty(dbuf, tx); 407 ddphys = dbuf->db_data; 408 409 ddphys->dd_creation_time = gethrestime_sec(); 410 if (pds) 411 ddphys->dd_parent_obj = pds->dd_object; 412 ddphys->dd_props_zapobj = zap_create(mos, 413 DMU_OT_DSL_PROPS, DMU_OT_NONE, 0, tx); 414 ddphys->dd_child_dir_zapobj = zap_create(mos, 415 DMU_OT_DSL_DIR_CHILD_MAP, DMU_OT_NONE, 0, tx); 416 if (spa_version(dp->dp_spa) >= SPA_VERSION_USED_BREAKDOWN) 417 ddphys->dd_flags |= DD_FLAG_USED_BREAKDOWN; 418 dmu_buf_rele(dbuf, FTAG); 419 420 return (ddobj); 421} 422 423boolean_t 424dsl_dir_is_clone(dsl_dir_t *dd) 425{ 426 return (dd->dd_phys->dd_origin_obj && 427 (dd->dd_pool->dp_origin_snap == NULL || 428 dd->dd_phys->dd_origin_obj != 429 dd->dd_pool->dp_origin_snap->ds_object)); 430} 431 432void 433dsl_dir_stats(dsl_dir_t *dd, nvlist_t *nv) 434{ 435 mutex_enter(&dd->dd_lock); 436 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED, 437 dd->dd_phys->dd_used_bytes); 438 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_QUOTA, dd->dd_phys->dd_quota); 439 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_RESERVATION, 440 dd->dd_phys->dd_reserved); 441 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO, 442 dd->dd_phys->dd_compressed_bytes == 0 ? 100 : 443 (dd->dd_phys->dd_uncompressed_bytes * 100 / 444 dd->dd_phys->dd_compressed_bytes)); 445 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_LOGICALUSED, 446 dd->dd_phys->dd_uncompressed_bytes); 447 if (dd->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN) { 448 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDSNAP, 449 dd->dd_phys->dd_used_breakdown[DD_USED_SNAP]); 450 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDDS, 451 dd->dd_phys->dd_used_breakdown[DD_USED_HEAD]); 452 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDREFRESERV, 453 dd->dd_phys->dd_used_breakdown[DD_USED_REFRSRV]); 454 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USEDCHILD, 455 dd->dd_phys->dd_used_breakdown[DD_USED_CHILD] + 456 dd->dd_phys->dd_used_breakdown[DD_USED_CHILD_RSRV]); 457 } 458 mutex_exit(&dd->dd_lock); 459 460 if (dsl_dir_is_clone(dd)) { 461 dsl_dataset_t *ds; 462 char buf[MAXNAMELEN]; 463 464 VERIFY0(dsl_dataset_hold_obj(dd->dd_pool, 465 dd->dd_phys->dd_origin_obj, FTAG, &ds)); 466 dsl_dataset_name(ds, buf); 467 dsl_dataset_rele(ds, FTAG); 468 dsl_prop_nvlist_add_string(nv, ZFS_PROP_ORIGIN, buf); 469 } 470} 471 472void 473dsl_dir_dirty(dsl_dir_t *dd, dmu_tx_t *tx) 474{ 475 dsl_pool_t *dp = dd->dd_pool; 476 477 ASSERT(dd->dd_phys); 478 479 if (txg_list_add(&dp->dp_dirty_dirs, dd, tx->tx_txg)) { 480 /* up the hold count until we can be written out */ 481 dmu_buf_add_ref(dd->dd_dbuf, dd); 482 } 483} 484 485static int64_t 486parent_delta(dsl_dir_t *dd, uint64_t used, int64_t delta) 487{ 488 uint64_t old_accounted = MAX(used, dd->dd_phys->dd_reserved); 489 uint64_t new_accounted = MAX(used + delta, dd->dd_phys->dd_reserved); 490 return (new_accounted - old_accounted); 491} 492 493void 494dsl_dir_sync(dsl_dir_t *dd, dmu_tx_t *tx) 495{ 496 ASSERT(dmu_tx_is_syncing(tx)); 497 498 mutex_enter(&dd->dd_lock); 499 ASSERT0(dd->dd_tempreserved[tx->tx_txg&TXG_MASK]); 500 dprintf_dd(dd, "txg=%llu towrite=%lluK\n", tx->tx_txg, 501 dd->dd_space_towrite[tx->tx_txg&TXG_MASK] / 1024); 502 dd->dd_space_towrite[tx->tx_txg&TXG_MASK] = 0; 503 mutex_exit(&dd->dd_lock); 504 505 /* release the hold from dsl_dir_dirty */ 506 dmu_buf_rele(dd->dd_dbuf, dd); 507} 508 509static uint64_t 510dsl_dir_space_towrite(dsl_dir_t *dd) 511{ 512 uint64_t space = 0; 513 int i; 514 515 ASSERT(MUTEX_HELD(&dd->dd_lock)); 516 517 for (i = 0; i < TXG_SIZE; i++) { 518 space += dd->dd_space_towrite[i&TXG_MASK]; 519 ASSERT3U(dd->dd_space_towrite[i&TXG_MASK], >=, 0); 520 } 521 return (space); 522} 523 524/* 525 * How much space would dd have available if ancestor had delta applied 526 * to it? If ondiskonly is set, we're only interested in what's 527 * on-disk, not estimated pending changes. 528 */ 529uint64_t 530dsl_dir_space_available(dsl_dir_t *dd, 531 dsl_dir_t *ancestor, int64_t delta, int ondiskonly) 532{ 533 uint64_t parentspace, myspace, quota, used; 534 535 /* 536 * If there are no restrictions otherwise, assume we have 537 * unlimited space available. 538 */ 539 quota = UINT64_MAX; 540 parentspace = UINT64_MAX; 541 542 if (dd->dd_parent != NULL) { 543 parentspace = dsl_dir_space_available(dd->dd_parent, 544 ancestor, delta, ondiskonly); 545 } 546 547 mutex_enter(&dd->dd_lock); 548 if (dd->dd_phys->dd_quota != 0) 549 quota = dd->dd_phys->dd_quota; 550 used = dd->dd_phys->dd_used_bytes; 551 if (!ondiskonly) 552 used += dsl_dir_space_towrite(dd); 553 554 if (dd->dd_parent == NULL) { 555 uint64_t poolsize = dsl_pool_adjustedsize(dd->dd_pool, FALSE); 556 quota = MIN(quota, poolsize); 557 } 558 559 if (dd->dd_phys->dd_reserved > used && parentspace != UINT64_MAX) { 560 /* 561 * We have some space reserved, in addition to what our 562 * parent gave us. 563 */ 564 parentspace += dd->dd_phys->dd_reserved - used; 565 } 566 567 if (dd == ancestor) { 568 ASSERT(delta <= 0); 569 ASSERT(used >= -delta); 570 used += delta; 571 if (parentspace != UINT64_MAX) 572 parentspace -= delta; 573 } 574 575 if (used > quota) { 576 /* over quota */ 577 myspace = 0; 578 } else { 579 /* 580 * the lesser of the space provided by our parent and 581 * the space left in our quota 582 */ 583 myspace = MIN(parentspace, quota - used); 584 } 585 586 mutex_exit(&dd->dd_lock); 587 588 return (myspace); 589} 590 591struct tempreserve { 592 list_node_t tr_node; 593 dsl_dir_t *tr_ds; 594 uint64_t tr_size; 595}; 596 597static int 598dsl_dir_tempreserve_impl(dsl_dir_t *dd, uint64_t asize, boolean_t netfree, 599 boolean_t ignorequota, boolean_t checkrefquota, list_t *tr_list, 600 dmu_tx_t *tx, boolean_t first) 601{ 602 uint64_t txg = tx->tx_txg; 603 uint64_t est_inflight, used_on_disk, quota, parent_rsrv; 604 uint64_t deferred = 0; 605 struct tempreserve *tr; 606 int retval = EDQUOT; 607 int txgidx = txg & TXG_MASK; 608 int i; 609 uint64_t ref_rsrv = 0; 610 611 ASSERT3U(txg, !=, 0); 612 ASSERT3S(asize, >, 0); 613 614 mutex_enter(&dd->dd_lock); 615 616 /* 617 * Check against the dsl_dir's quota. We don't add in the delta 618 * when checking for over-quota because they get one free hit. 619 */ 620 est_inflight = dsl_dir_space_towrite(dd); 621 for (i = 0; i < TXG_SIZE; i++) 622 est_inflight += dd->dd_tempreserved[i]; 623 used_on_disk = dd->dd_phys->dd_used_bytes; 624 625 /* 626 * On the first iteration, fetch the dataset's used-on-disk and 627 * refreservation values. Also, if checkrefquota is set, test if 628 * allocating this space would exceed the dataset's refquota. 629 */ 630 if (first && tx->tx_objset) { 631 int error; 632 dsl_dataset_t *ds = tx->tx_objset->os_dsl_dataset; 633 634 error = dsl_dataset_check_quota(ds, checkrefquota, 635 asize, est_inflight, &used_on_disk, &ref_rsrv); 636 if (error) { 637 mutex_exit(&dd->dd_lock); 638 return (error); 639 } 640 } 641 642 /* 643 * If this transaction will result in a net free of space, 644 * we want to let it through. 645 */ 646 if (ignorequota || netfree || dd->dd_phys->dd_quota == 0) 647 quota = UINT64_MAX; 648 else 649 quota = dd->dd_phys->dd_quota; 650 651 /* 652 * Adjust the quota against the actual pool size at the root 653 * minus any outstanding deferred frees. 654 * To ensure that it's possible to remove files from a full 655 * pool without inducing transient overcommits, we throttle 656 * netfree transactions against a quota that is slightly larger, 657 * but still within the pool's allocation slop. In cases where 658 * we're very close to full, this will allow a steady trickle of 659 * removes to get through. 660 */ 661 if (dd->dd_parent == NULL) { 662 spa_t *spa = dd->dd_pool->dp_spa; 663 uint64_t poolsize = dsl_pool_adjustedsize(dd->dd_pool, netfree); 664 deferred = metaslab_class_get_deferred(spa_normal_class(spa)); 665 if (poolsize - deferred < quota) { 666 quota = poolsize - deferred; 667 retval = ENOSPC; 668 } 669 } 670 671 /* 672 * If they are requesting more space, and our current estimate 673 * is over quota, they get to try again unless the actual 674 * on-disk is over quota and there are no pending changes (which 675 * may free up space for us). 676 */ 677 if (used_on_disk + est_inflight >= quota) { 678 if (est_inflight > 0 || used_on_disk < quota || 679 (retval == ENOSPC && used_on_disk < quota + deferred)) 680 retval = ERESTART; 681 dprintf_dd(dd, "failing: used=%lluK inflight = %lluK " 682 "quota=%lluK tr=%lluK err=%d\n", 683 used_on_disk>>10, est_inflight>>10, 684 quota>>10, asize>>10, retval); 685 mutex_exit(&dd->dd_lock); 686 return (SET_ERROR(retval)); 687 } 688 689 /* We need to up our estimated delta before dropping dd_lock */ 690 dd->dd_tempreserved[txgidx] += asize; 691 692 parent_rsrv = parent_delta(dd, used_on_disk + est_inflight, 693 asize - ref_rsrv); 694 mutex_exit(&dd->dd_lock); 695 696 tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP); 697 tr->tr_ds = dd; 698 tr->tr_size = asize; 699 list_insert_tail(tr_list, tr); 700 701 /* see if it's OK with our parent */ 702 if (dd->dd_parent && parent_rsrv) { 703 boolean_t ismos = (dd->dd_phys->dd_head_dataset_obj == 0); 704 705 return (dsl_dir_tempreserve_impl(dd->dd_parent, 706 parent_rsrv, netfree, ismos, TRUE, tr_list, tx, FALSE)); 707 } else { 708 return (0); 709 } 710} 711 712/* 713 * Reserve space in this dsl_dir, to be used in this tx's txg. 714 * After the space has been dirtied (and dsl_dir_willuse_space() 715 * has been called), the reservation should be canceled, using 716 * dsl_dir_tempreserve_clear(). 717 */ 718int 719dsl_dir_tempreserve_space(dsl_dir_t *dd, uint64_t lsize, uint64_t asize, 720 uint64_t fsize, uint64_t usize, void **tr_cookiep, dmu_tx_t *tx) 721{ 722 int err; 723 list_t *tr_list; 724 725 if (asize == 0) { 726 *tr_cookiep = NULL; 727 return (0); 728 } 729 730 tr_list = kmem_alloc(sizeof (list_t), KM_SLEEP); 731 list_create(tr_list, sizeof (struct tempreserve), 732 offsetof(struct tempreserve, tr_node)); 733 ASSERT3S(asize, >, 0); 734 ASSERT3S(fsize, >=, 0); 735 736 err = arc_tempreserve_space(lsize, tx->tx_txg); 737 if (err == 0) { 738 struct tempreserve *tr; 739 740 tr = kmem_zalloc(sizeof (struct tempreserve), KM_SLEEP); 741 tr->tr_size = lsize; 742 list_insert_tail(tr_list, tr); 743 } else { 744 if (err == EAGAIN) { 745 /* 746 * If arc_memory_throttle() detected that pageout 747 * is running and we are low on memory, we delay new 748 * non-pageout transactions to give pageout an 749 * advantage. 750 * 751 * It is unfortunate to be delaying while the caller's 752 * locks are held. 753 */ 754 txg_delay(dd->dd_pool, tx->tx_txg, 755 MSEC2NSEC(10), MSEC2NSEC(10)); 756 err = SET_ERROR(ERESTART); 757 } 758 } 759 760 if (err == 0) { 761 err = dsl_dir_tempreserve_impl(dd, asize, fsize >= asize, 762 FALSE, asize > usize, tr_list, tx, TRUE); 763 } 764 765 if (err != 0) 766 dsl_dir_tempreserve_clear(tr_list, tx); 767 else 768 *tr_cookiep = tr_list; 769 770 return (err); 771} 772 773/* 774 * Clear a temporary reservation that we previously made with 775 * dsl_dir_tempreserve_space(). 776 */ 777void 778dsl_dir_tempreserve_clear(void *tr_cookie, dmu_tx_t *tx) 779{ 780 int txgidx = tx->tx_txg & TXG_MASK; 781 list_t *tr_list = tr_cookie; 782 struct tempreserve *tr; 783 784 ASSERT3U(tx->tx_txg, !=, 0); 785 786 if (tr_cookie == NULL) 787 return; 788 789 while ((tr = list_head(tr_list)) != NULL) { 790 if (tr->tr_ds) { 791 mutex_enter(&tr->tr_ds->dd_lock); 792 ASSERT3U(tr->tr_ds->dd_tempreserved[txgidx], >=, 793 tr->tr_size); 794 tr->tr_ds->dd_tempreserved[txgidx] -= tr->tr_size; 795 mutex_exit(&tr->tr_ds->dd_lock); 796 } else { 797 arc_tempreserve_clear(tr->tr_size); 798 } 799 list_remove(tr_list, tr); 800 kmem_free(tr, sizeof (struct tempreserve)); 801 } 802 803 kmem_free(tr_list, sizeof (list_t)); 804} 805 806/* 807 * This should be called from open context when we think we're going to write 808 * or free space, for example when dirtying data. Be conservative; it's okay 809 * to write less space or free more, but we don't want to write more or free 810 * less than the amount specified. 811 */ 812void 813dsl_dir_willuse_space(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx) 814{ 815 int64_t parent_space; 816 uint64_t est_used; 817 818 mutex_enter(&dd->dd_lock); 819 if (space > 0) 820 dd->dd_space_towrite[tx->tx_txg & TXG_MASK] += space; 821 822 est_used = dsl_dir_space_towrite(dd) + dd->dd_phys->dd_used_bytes; 823 parent_space = parent_delta(dd, est_used, space); 824 mutex_exit(&dd->dd_lock); 825 826 /* Make sure that we clean up dd_space_to* */ 827 dsl_dir_dirty(dd, tx); 828 829 /* XXX this is potentially expensive and unnecessary... */ 830 if (parent_space && dd->dd_parent) 831 dsl_dir_willuse_space(dd->dd_parent, parent_space, tx); 832} 833 834/* call from syncing context when we actually write/free space for this dd */ 835void 836dsl_dir_diduse_space(dsl_dir_t *dd, dd_used_t type, 837 int64_t used, int64_t compressed, int64_t uncompressed, dmu_tx_t *tx) 838{ 839 int64_t accounted_delta; 840 841 /* 842 * dsl_dataset_set_refreservation_sync_impl() calls this with 843 * dd_lock held, so that it can atomically update 844 * ds->ds_reserved and the dsl_dir accounting, so that 845 * dsl_dataset_check_quota() can see dataset and dir accounting 846 * consistently. 847 */ 848 boolean_t needlock = !MUTEX_HELD(&dd->dd_lock); 849 850 ASSERT(dmu_tx_is_syncing(tx)); 851 ASSERT(type < DD_USED_NUM); 852 853 dmu_buf_will_dirty(dd->dd_dbuf, tx); 854 855 if (needlock) 856 mutex_enter(&dd->dd_lock); 857 accounted_delta = parent_delta(dd, dd->dd_phys->dd_used_bytes, used); 858 ASSERT(used >= 0 || dd->dd_phys->dd_used_bytes >= -used); 859 ASSERT(compressed >= 0 || 860 dd->dd_phys->dd_compressed_bytes >= -compressed); 861 ASSERT(uncompressed >= 0 || 862 dd->dd_phys->dd_uncompressed_bytes >= -uncompressed); 863 dd->dd_phys->dd_used_bytes += used; 864 dd->dd_phys->dd_uncompressed_bytes += uncompressed; 865 dd->dd_phys->dd_compressed_bytes += compressed; 866 867 if (dd->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN) { 868 ASSERT(used > 0 || 869 dd->dd_phys->dd_used_breakdown[type] >= -used); 870 dd->dd_phys->dd_used_breakdown[type] += used; 871#ifdef DEBUG 872 dd_used_t t; 873 uint64_t u = 0; 874 for (t = 0; t < DD_USED_NUM; t++) 875 u += dd->dd_phys->dd_used_breakdown[t]; 876 ASSERT3U(u, ==, dd->dd_phys->dd_used_bytes); 877#endif 878 } 879 if (needlock) 880 mutex_exit(&dd->dd_lock); 881 882 if (dd->dd_parent != NULL) { 883 dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD, 884 accounted_delta, compressed, uncompressed, tx); 885 dsl_dir_transfer_space(dd->dd_parent, 886 used - accounted_delta, 887 DD_USED_CHILD_RSRV, DD_USED_CHILD, tx); 888 } 889} 890 891void 892dsl_dir_transfer_space(dsl_dir_t *dd, int64_t delta, 893 dd_used_t oldtype, dd_used_t newtype, dmu_tx_t *tx) 894{ 895 ASSERT(dmu_tx_is_syncing(tx)); 896 ASSERT(oldtype < DD_USED_NUM); 897 ASSERT(newtype < DD_USED_NUM); 898 899 if (delta == 0 || !(dd->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN)) 900 return; 901 902 dmu_buf_will_dirty(dd->dd_dbuf, tx); 903 mutex_enter(&dd->dd_lock); 904 ASSERT(delta > 0 ? 905 dd->dd_phys->dd_used_breakdown[oldtype] >= delta : 906 dd->dd_phys->dd_used_breakdown[newtype] >= -delta); 907 ASSERT(dd->dd_phys->dd_used_bytes >= ABS(delta)); 908 dd->dd_phys->dd_used_breakdown[oldtype] -= delta; 909 dd->dd_phys->dd_used_breakdown[newtype] += delta; 910 mutex_exit(&dd->dd_lock); 911} 912 913typedef struct dsl_dir_set_qr_arg { 914 const char *ddsqra_name; 915 zprop_source_t ddsqra_source; 916 uint64_t ddsqra_value; 917} dsl_dir_set_qr_arg_t; 918 919static int 920dsl_dir_set_quota_check(void *arg, dmu_tx_t *tx) 921{ 922 dsl_dir_set_qr_arg_t *ddsqra = arg; 923 dsl_pool_t *dp = dmu_tx_pool(tx); 924 dsl_dataset_t *ds; 925 int error; 926 uint64_t towrite, newval; 927 928 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds); 929 if (error != 0) 930 return (error); 931 932 error = dsl_prop_predict(ds->ds_dir, "quota", 933 ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval); 934 if (error != 0) { 935 dsl_dataset_rele(ds, FTAG); 936 return (error); 937 } 938 939 if (newval == 0) { 940 dsl_dataset_rele(ds, FTAG); 941 return (0); 942 } 943 944 mutex_enter(&ds->ds_dir->dd_lock); 945 /* 946 * If we are doing the preliminary check in open context, and 947 * there are pending changes, then don't fail it, since the 948 * pending changes could under-estimate the amount of space to be 949 * freed up. 950 */ 951 towrite = dsl_dir_space_towrite(ds->ds_dir); 952 if ((dmu_tx_is_syncing(tx) || towrite == 0) && 953 (newval < ds->ds_dir->dd_phys->dd_reserved || 954 newval < ds->ds_dir->dd_phys->dd_used_bytes + towrite)) { 955 error = SET_ERROR(ENOSPC); 956 } 957 mutex_exit(&ds->ds_dir->dd_lock); 958 dsl_dataset_rele(ds, FTAG); 959 return (error); 960} 961 962static void 963dsl_dir_set_quota_sync(void *arg, dmu_tx_t *tx) 964{ 965 dsl_dir_set_qr_arg_t *ddsqra = arg; 966 dsl_pool_t *dp = dmu_tx_pool(tx); 967 dsl_dataset_t *ds; 968 uint64_t newval; 969 970 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds)); 971 972 if (spa_version(dp->dp_spa) >= SPA_VERSION_RECVD_PROPS) { 973 dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_QUOTA), 974 ddsqra->ddsqra_source, sizeof (ddsqra->ddsqra_value), 1, 975 &ddsqra->ddsqra_value, tx); 976 977 VERIFY0(dsl_prop_get_int_ds(ds, 978 zfs_prop_to_name(ZFS_PROP_QUOTA), &newval)); 979 } else { 980 newval = ddsqra->ddsqra_value; 981 spa_history_log_internal_ds(ds, "set", tx, "%s=%lld", 982 zfs_prop_to_name(ZFS_PROP_QUOTA), (longlong_t)newval); 983 } 984 985 dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx); 986 mutex_enter(&ds->ds_dir->dd_lock); 987 ds->ds_dir->dd_phys->dd_quota = newval; 988 mutex_exit(&ds->ds_dir->dd_lock); 989 dsl_dataset_rele(ds, FTAG); 990} 991 992int 993dsl_dir_set_quota(const char *ddname, zprop_source_t source, uint64_t quota) 994{ 995 dsl_dir_set_qr_arg_t ddsqra; 996 997 ddsqra.ddsqra_name = ddname; 998 ddsqra.ddsqra_source = source; 999 ddsqra.ddsqra_value = quota; 1000 1001 return (dsl_sync_task(ddname, dsl_dir_set_quota_check, 1002 dsl_dir_set_quota_sync, &ddsqra, 0)); 1003} 1004 1005int 1006dsl_dir_set_reservation_check(void *arg, dmu_tx_t *tx) 1007{ 1008 dsl_dir_set_qr_arg_t *ddsqra = arg; 1009 dsl_pool_t *dp = dmu_tx_pool(tx); 1010 dsl_dataset_t *ds; 1011 dsl_dir_t *dd; 1012 uint64_t newval, used, avail; 1013 int error; 1014 1015 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds); 1016 if (error != 0) 1017 return (error); 1018 dd = ds->ds_dir; 1019 1020 /* 1021 * If we are doing the preliminary check in open context, the 1022 * space estimates may be inaccurate. 1023 */ 1024 if (!dmu_tx_is_syncing(tx)) { 1025 dsl_dataset_rele(ds, FTAG); 1026 return (0); 1027 } 1028 1029 error = dsl_prop_predict(ds->ds_dir, 1030 zfs_prop_to_name(ZFS_PROP_RESERVATION), 1031 ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval); 1032 if (error != 0) { 1033 dsl_dataset_rele(ds, FTAG); 1034 return (error); 1035 } 1036 1037 mutex_enter(&dd->dd_lock); 1038 used = dd->dd_phys->dd_used_bytes; 1039 mutex_exit(&dd->dd_lock); 1040 1041 if (dd->dd_parent) { 1042 avail = dsl_dir_space_available(dd->dd_parent, 1043 NULL, 0, FALSE); 1044 } else { 1045 avail = dsl_pool_adjustedsize(dd->dd_pool, B_FALSE) - used; 1046 } 1047 1048 if (MAX(used, newval) > MAX(used, dd->dd_phys->dd_reserved)) { 1049 uint64_t delta = MAX(used, newval) - 1050 MAX(used, dd->dd_phys->dd_reserved); 1051 1052 if (delta > avail || 1053 (dd->dd_phys->dd_quota > 0 && 1054 newval > dd->dd_phys->dd_quota)) 1055 error = SET_ERROR(ENOSPC); 1056 } 1057 1058 dsl_dataset_rele(ds, FTAG); 1059 return (error); 1060} 1061 1062void 1063dsl_dir_set_reservation_sync_impl(dsl_dir_t *dd, uint64_t value, dmu_tx_t *tx) 1064{ 1065 uint64_t used; 1066 int64_t delta; 1067 1068 dmu_buf_will_dirty(dd->dd_dbuf, tx); 1069 1070 mutex_enter(&dd->dd_lock); 1071 used = dd->dd_phys->dd_used_bytes; 1072 delta = MAX(used, value) - MAX(used, dd->dd_phys->dd_reserved); 1073 dd->dd_phys->dd_reserved = value; 1074 1075 if (dd->dd_parent != NULL) { 1076 /* Roll up this additional usage into our ancestors */ 1077 dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD_RSRV, 1078 delta, 0, 0, tx); 1079 } 1080 mutex_exit(&dd->dd_lock); 1081} 1082 1083static void 1084dsl_dir_set_reservation_sync(void *arg, dmu_tx_t *tx) 1085{ 1086 dsl_dir_set_qr_arg_t *ddsqra = arg; 1087 dsl_pool_t *dp = dmu_tx_pool(tx); 1088 dsl_dataset_t *ds; 1089 uint64_t newval; 1090 1091 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds)); 1092 1093 if (spa_version(dp->dp_spa) >= SPA_VERSION_RECVD_PROPS) { 1094 dsl_prop_set_sync_impl(ds, 1095 zfs_prop_to_name(ZFS_PROP_RESERVATION), 1096 ddsqra->ddsqra_source, sizeof (ddsqra->ddsqra_value), 1, 1097 &ddsqra->ddsqra_value, tx); 1098 1099 VERIFY0(dsl_prop_get_int_ds(ds, 1100 zfs_prop_to_name(ZFS_PROP_RESERVATION), &newval)); 1101 } else { 1102 newval = ddsqra->ddsqra_value; 1103 spa_history_log_internal_ds(ds, "set", tx, "%s=%lld", 1104 zfs_prop_to_name(ZFS_PROP_RESERVATION), 1105 (longlong_t)newval); 1106 } 1107 1108 dsl_dir_set_reservation_sync_impl(ds->ds_dir, newval, tx); 1109 dsl_dataset_rele(ds, FTAG); 1110} 1111 1112int 1113dsl_dir_set_reservation(const char *ddname, zprop_source_t source, 1114 uint64_t reservation) 1115{ 1116 dsl_dir_set_qr_arg_t ddsqra; 1117 1118 ddsqra.ddsqra_name = ddname; 1119 ddsqra.ddsqra_source = source; 1120 ddsqra.ddsqra_value = reservation; 1121 1122 return (dsl_sync_task(ddname, dsl_dir_set_reservation_check, 1123 dsl_dir_set_reservation_sync, &ddsqra, 0)); 1124} 1125 1126static dsl_dir_t * 1127closest_common_ancestor(dsl_dir_t *ds1, dsl_dir_t *ds2) 1128{ 1129 for (; ds1; ds1 = ds1->dd_parent) { 1130 dsl_dir_t *dd; 1131 for (dd = ds2; dd; dd = dd->dd_parent) { 1132 if (ds1 == dd) 1133 return (dd); 1134 } 1135 } 1136 return (NULL); 1137} 1138 1139/* 1140 * If delta is applied to dd, how much of that delta would be applied to 1141 * ancestor? Syncing context only. 1142 */ 1143static int64_t 1144would_change(dsl_dir_t *dd, int64_t delta, dsl_dir_t *ancestor) 1145{ 1146 if (dd == ancestor) 1147 return (delta); 1148 1149 mutex_enter(&dd->dd_lock); 1150 delta = parent_delta(dd, dd->dd_phys->dd_used_bytes, delta); 1151 mutex_exit(&dd->dd_lock); 1152 return (would_change(dd->dd_parent, delta, ancestor)); 1153} 1154 1155typedef struct dsl_dir_rename_arg { 1156 const char *ddra_oldname; 1157 const char *ddra_newname; 1158} dsl_dir_rename_arg_t; 1159 1160/* ARGSUSED */ 1161static int 1162dsl_valid_rename(dsl_pool_t *dp, dsl_dataset_t *ds, void *arg) 1163{ 1164 int *deltap = arg; 1165 char namebuf[MAXNAMELEN]; 1166 1167 dsl_dataset_name(ds, namebuf); 1168 1169 if (strlen(namebuf) + *deltap >= MAXNAMELEN) 1170 return (SET_ERROR(ENAMETOOLONG)); 1171 return (0); 1172} 1173 1174static int 1175dsl_dir_rename_check(void *arg, dmu_tx_t *tx) 1176{ 1177 dsl_dir_rename_arg_t *ddra = arg; 1178 dsl_pool_t *dp = dmu_tx_pool(tx); 1179 dsl_dir_t *dd, *newparent; 1180 const char *mynewname; 1181 int error; 1182 int delta = strlen(ddra->ddra_newname) - strlen(ddra->ddra_oldname); 1183 1184 /* target dir should exist */ 1185 error = dsl_dir_hold(dp, ddra->ddra_oldname, FTAG, &dd, NULL); 1186 if (error != 0) 1187 return (error); 1188 1189 /* new parent should exist */ 1190 error = dsl_dir_hold(dp, ddra->ddra_newname, FTAG, 1191 &newparent, &mynewname); 1192 if (error != 0) { 1193 dsl_dir_rele(dd, FTAG); 1194 return (error); 1195 } 1196 1197 /* can't rename to different pool */ 1198 if (dd->dd_pool != newparent->dd_pool) { 1199 dsl_dir_rele(newparent, FTAG); 1200 dsl_dir_rele(dd, FTAG); 1201 return (SET_ERROR(ENXIO)); 1202 } 1203 1204 /* new name should not already exist */ 1205 if (mynewname == NULL) { 1206 dsl_dir_rele(newparent, FTAG); 1207 dsl_dir_rele(dd, FTAG); 1208 return (SET_ERROR(EEXIST)); 1209 } 1210 1211 /* if the name length is growing, validate child name lengths */ 1212 if (delta > 0) { 1213 error = dmu_objset_find_dp(dp, dd->dd_object, dsl_valid_rename, 1214 &delta, DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS); 1215 if (error != 0) { 1216 dsl_dir_rele(newparent, FTAG); 1217 dsl_dir_rele(dd, FTAG); 1218 return (error); 1219 } 1220 } 1221 1222 if (newparent != dd->dd_parent) { 1223 /* is there enough space? */ 1224 uint64_t myspace = 1225 MAX(dd->dd_phys->dd_used_bytes, dd->dd_phys->dd_reserved); 1226 1227 /* no rename into our descendant */ 1228 if (closest_common_ancestor(dd, newparent) == dd) { 1229 dsl_dir_rele(newparent, FTAG); 1230 dsl_dir_rele(dd, FTAG); 1231 return (SET_ERROR(EINVAL)); 1232 } 1233 1234 error = dsl_dir_transfer_possible(dd->dd_parent, 1235 newparent, myspace); 1236 if (error != 0) { 1237 dsl_dir_rele(newparent, FTAG); 1238 dsl_dir_rele(dd, FTAG); 1239 return (error); 1240 } 1241 } 1242 1243 dsl_dir_rele(newparent, FTAG); 1244 dsl_dir_rele(dd, FTAG); 1245 return (0); 1246} 1247 1248static void 1249dsl_dir_rename_sync(void *arg, dmu_tx_t *tx) 1250{ 1251 dsl_dir_rename_arg_t *ddra = arg; 1252 dsl_pool_t *dp = dmu_tx_pool(tx); 1253 dsl_dir_t *dd, *newparent; 1254 const char *mynewname; 1255 int error; 1256 objset_t *mos = dp->dp_meta_objset; 1257 1258 VERIFY0(dsl_dir_hold(dp, ddra->ddra_oldname, FTAG, &dd, NULL)); 1259 VERIFY0(dsl_dir_hold(dp, ddra->ddra_newname, FTAG, &newparent, 1260 &mynewname)); 1261 1262 /* Log this before we change the name. */ 1263 spa_history_log_internal_dd(dd, "rename", tx, 1264 "-> %s", ddra->ddra_newname); 1265 1266 if (newparent != dd->dd_parent) { 1267 dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD, 1268 -dd->dd_phys->dd_used_bytes, 1269 -dd->dd_phys->dd_compressed_bytes, 1270 -dd->dd_phys->dd_uncompressed_bytes, tx); 1271 dsl_dir_diduse_space(newparent, DD_USED_CHILD, 1272 dd->dd_phys->dd_used_bytes, 1273 dd->dd_phys->dd_compressed_bytes, 1274 dd->dd_phys->dd_uncompressed_bytes, tx); 1275 1276 if (dd->dd_phys->dd_reserved > dd->dd_phys->dd_used_bytes) { 1277 uint64_t unused_rsrv = dd->dd_phys->dd_reserved - 1278 dd->dd_phys->dd_used_bytes; 1279 1280 dsl_dir_diduse_space(dd->dd_parent, DD_USED_CHILD_RSRV, 1281 -unused_rsrv, 0, 0, tx); 1282 dsl_dir_diduse_space(newparent, DD_USED_CHILD_RSRV, 1283 unused_rsrv, 0, 0, tx); 1284 } 1285 } 1286 1287 dmu_buf_will_dirty(dd->dd_dbuf, tx); 1288 1289 /* remove from old parent zapobj */ 1290 error = zap_remove(mos, dd->dd_parent->dd_phys->dd_child_dir_zapobj, 1291 dd->dd_myname, tx); 1292 ASSERT0(error); 1293 1294 (void) strcpy(dd->dd_myname, mynewname); 1295 dsl_dir_rele(dd->dd_parent, dd); 1296 dd->dd_phys->dd_parent_obj = newparent->dd_object; 1297 VERIFY0(dsl_dir_hold_obj(dp, 1298 newparent->dd_object, NULL, dd, &dd->dd_parent)); 1299 1300 /* add to new parent zapobj */ 1301 VERIFY0(zap_add(mos, newparent->dd_phys->dd_child_dir_zapobj, 1302 dd->dd_myname, 8, 1, &dd->dd_object, tx)); 1303 1304#ifdef __FreeBSD__ 1305#ifdef _KERNEL 1306 zfsvfs_update_fromname(ddra->ddra_oldname, ddra->ddra_newname); 1307 zvol_rename_minors(ddra->ddra_oldname, ddra->ddra_newname); 1308#endif 1309#endif 1310 1311 dsl_prop_notify_all(dd); 1312 1313 dsl_dir_rele(newparent, FTAG); 1314 dsl_dir_rele(dd, FTAG); 1315} 1316 1317int 1318dsl_dir_rename(const char *oldname, const char *newname) 1319{ 1320 dsl_dir_rename_arg_t ddra; 1321 1322 ddra.ddra_oldname = oldname; 1323 ddra.ddra_newname = newname; 1324 1325 return (dsl_sync_task(oldname, 1326 dsl_dir_rename_check, dsl_dir_rename_sync, &ddra, 3)); 1327} 1328 1329int 1330dsl_dir_transfer_possible(dsl_dir_t *sdd, dsl_dir_t *tdd, uint64_t space) 1331{ 1332 dsl_dir_t *ancestor; 1333 int64_t adelta; 1334 uint64_t avail; 1335 1336 ancestor = closest_common_ancestor(sdd, tdd); 1337 adelta = would_change(sdd, -space, ancestor); 1338 avail = dsl_dir_space_available(tdd, ancestor, adelta, FALSE); 1339 if (avail < space) 1340 return (SET_ERROR(ENOSPC)); 1341 1342 return (0); 1343} 1344 1345timestruc_t 1346dsl_dir_snap_cmtime(dsl_dir_t *dd) 1347{ 1348 timestruc_t t; 1349 1350 mutex_enter(&dd->dd_lock); 1351 t = dd->dd_snap_cmtime; 1352 mutex_exit(&dd->dd_lock); 1353 1354 return (t); 1355} 1356 1357void 1358dsl_dir_snap_cmtime_update(dsl_dir_t *dd) 1359{ 1360 timestruc_t t; 1361 1362 gethrestime(&t); 1363 mutex_enter(&dd->dd_lock); 1364 dd->dd_snap_cmtime = t; 1365 mutex_exit(&dd->dd_lock); 1366} 1367 1368void 1369dsl_dir_zapify(dsl_dir_t *dd, dmu_tx_t *tx) 1370{ 1371 objset_t *mos = dd->dd_pool->dp_meta_objset; 1372 dmu_object_zapify(mos, dd->dd_object, DMU_OT_DSL_DIR, tx); 1373} 1374