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