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/cred.h> 29 #include <sys/zfs_context.h> 30 #include <sys/dmu_objset.h> 31 #include <sys/dsl_dir.h> 32 #include <sys/dsl_dataset.h> 33 #include <sys/dsl_prop.h> 34 #include <sys/dsl_pool.h> 35 #include <sys/dsl_synctask.h> 36 #include <sys/dsl_deleg.h> 37 #include <sys/dnode.h> 38 #include <sys/dbuf.h> 39 #include <sys/zvol.h> 40 #include <sys/dmu_tx.h> 41 #include <sys/zio_checksum.h> 42 #include <sys/zap.h> 43 #include <sys/zil.h> 44 #include <sys/dmu_impl.h> 45 #include <sys/zfs_ioctl.h> 46 47 spa_t * 48 dmu_objset_spa(objset_t *os) 49 { 50 return (os->os->os_spa); 51 } 52 53 zilog_t * 54 dmu_objset_zil(objset_t *os) 55 { 56 return (os->os->os_zil); 57 } 58 59 dsl_pool_t * 60 dmu_objset_pool(objset_t *os) 61 { 62 dsl_dataset_t *ds; 63 64 if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir) 65 return (ds->ds_dir->dd_pool); 66 else 67 return (spa_get_dsl(os->os->os_spa)); 68 } 69 70 dsl_dataset_t * 71 dmu_objset_ds(objset_t *os) 72 { 73 return (os->os->os_dsl_dataset); 74 } 75 76 dmu_objset_type_t 77 dmu_objset_type(objset_t *os) 78 { 79 return (os->os->os_phys->os_type); 80 } 81 82 void 83 dmu_objset_name(objset_t *os, char *buf) 84 { 85 dsl_dataset_name(os->os->os_dsl_dataset, buf); 86 } 87 88 uint64_t 89 dmu_objset_id(objset_t *os) 90 { 91 dsl_dataset_t *ds = os->os->os_dsl_dataset; 92 93 return (ds ? ds->ds_object : 0); 94 } 95 96 static void 97 checksum_changed_cb(void *arg, uint64_t newval) 98 { 99 objset_impl_t *osi = arg; 100 101 /* 102 * Inheritance should have been done by now. 103 */ 104 ASSERT(newval != ZIO_CHECKSUM_INHERIT); 105 106 osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE); 107 } 108 109 static void 110 compression_changed_cb(void *arg, uint64_t newval) 111 { 112 objset_impl_t *osi = arg; 113 114 /* 115 * Inheritance and range checking should have been done by now. 116 */ 117 ASSERT(newval != ZIO_COMPRESS_INHERIT); 118 119 osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE); 120 } 121 122 static void 123 copies_changed_cb(void *arg, uint64_t newval) 124 { 125 objset_impl_t *osi = arg; 126 127 /* 128 * Inheritance and range checking should have been done by now. 129 */ 130 ASSERT(newval > 0); 131 ASSERT(newval <= spa_max_replication(osi->os_spa)); 132 133 osi->os_copies = newval; 134 } 135 136 void 137 dmu_objset_byteswap(void *buf, size_t size) 138 { 139 objset_phys_t *osp = buf; 140 141 ASSERT(size == sizeof (objset_phys_t)); 142 dnode_byteswap(&osp->os_meta_dnode); 143 byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t)); 144 osp->os_type = BSWAP_64(osp->os_type); 145 } 146 147 int 148 dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 149 objset_impl_t **osip) 150 { 151 objset_impl_t *osi; 152 int i, err, checksum; 153 154 ASSERT(ds == NULL || MUTEX_HELD(&ds->ds_opening_lock)); 155 156 osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP); 157 osi->os.os = osi; 158 osi->os_dsl_dataset = ds; 159 osi->os_spa = spa; 160 osi->os_rootbp = bp; 161 if (!BP_IS_HOLE(osi->os_rootbp)) { 162 uint32_t aflags = ARC_WAIT; 163 zbookmark_t zb; 164 zb.zb_objset = ds ? ds->ds_object : 0; 165 zb.zb_object = 0; 166 zb.zb_level = -1; 167 zb.zb_blkid = 0; 168 169 dprintf_bp(osi->os_rootbp, "reading %s", ""); 170 err = arc_read(NULL, spa, osi->os_rootbp, 171 dmu_ot[DMU_OT_OBJSET].ot_byteswap, 172 arc_getbuf_func, &osi->os_phys_buf, 173 ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb); 174 if (err) { 175 kmem_free(osi, sizeof (objset_impl_t)); 176 return (err); 177 } 178 osi->os_phys = osi->os_phys_buf->b_data; 179 if (ds == NULL || dsl_dataset_is_snapshot(ds) == 0) 180 arc_release(osi->os_phys_buf, &osi->os_phys_buf); 181 } else { 182 osi->os_phys_buf = arc_buf_alloc(spa, sizeof (objset_phys_t), 183 &osi->os_phys_buf, ARC_BUFC_METADATA); 184 osi->os_phys = osi->os_phys_buf->b_data; 185 bzero(osi->os_phys, sizeof (objset_phys_t)); 186 } 187 188 /* 189 * Note: the changed_cb will be called once before the register 190 * func returns, thus changing the checksum/compression from the 191 * default (fletcher2/off). Snapshots don't need to know, and 192 * registering would complicate clone promotion. 193 */ 194 if (ds && ds->ds_phys->ds_num_children == 0) { 195 err = dsl_prop_register(ds, "checksum", 196 checksum_changed_cb, osi); 197 if (err == 0) 198 err = dsl_prop_register(ds, "compression", 199 compression_changed_cb, osi); 200 if (err == 0) 201 err = dsl_prop_register(ds, "copies", 202 copies_changed_cb, osi); 203 if (err) { 204 VERIFY(arc_buf_remove_ref(osi->os_phys_buf, 205 &osi->os_phys_buf) == 1); 206 kmem_free(osi, sizeof (objset_impl_t)); 207 return (err); 208 } 209 } else if (ds == NULL) { 210 /* It's the meta-objset. */ 211 osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4; 212 osi->os_compress = ZIO_COMPRESS_LZJB; 213 osi->os_copies = spa_max_replication(spa); 214 } 215 216 osi->os_zil = zil_alloc(&osi->os, &osi->os_phys->os_zil_header); 217 218 /* 219 * Metadata always gets compressed and checksummed. 220 * If the data checksum is multi-bit correctable, and it's not 221 * a ZBT-style checksum, then it's suitable for metadata as well. 222 * Otherwise, the metadata checksum defaults to fletcher4. 223 */ 224 checksum = osi->os_checksum; 225 226 if (zio_checksum_table[checksum].ci_correctable && 227 !zio_checksum_table[checksum].ci_zbt) 228 osi->os_md_checksum = checksum; 229 else 230 osi->os_md_checksum = ZIO_CHECKSUM_FLETCHER_4; 231 osi->os_md_compress = ZIO_COMPRESS_LZJB; 232 233 for (i = 0; i < TXG_SIZE; i++) { 234 list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t), 235 offsetof(dnode_t, dn_dirty_link[i])); 236 list_create(&osi->os_free_dnodes[i], sizeof (dnode_t), 237 offsetof(dnode_t, dn_dirty_link[i])); 238 } 239 list_create(&osi->os_dnodes, sizeof (dnode_t), 240 offsetof(dnode_t, dn_link)); 241 list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t), 242 offsetof(dmu_buf_impl_t, db_link)); 243 244 mutex_init(&osi->os_lock, NULL, MUTEX_DEFAULT, NULL); 245 mutex_init(&osi->os_obj_lock, NULL, MUTEX_DEFAULT, NULL); 246 mutex_init(&osi->os_user_ptr_lock, NULL, MUTEX_DEFAULT, NULL); 247 248 osi->os_meta_dnode = dnode_special_open(osi, 249 &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT); 250 251 /* 252 * We should be the only thread trying to do this because we 253 * have ds_opening_lock 254 */ 255 if (ds) { 256 VERIFY(NULL == dsl_dataset_set_user_ptr(ds, osi, 257 dmu_objset_evict)); 258 } 259 260 *osip = osi; 261 return (0); 262 } 263 264 static int 265 dmu_objset_open_ds_os(dsl_dataset_t *ds, objset_t *os, dmu_objset_type_t type) 266 { 267 objset_impl_t *osi; 268 int err; 269 270 mutex_enter(&ds->ds_opening_lock); 271 osi = dsl_dataset_get_user_ptr(ds); 272 if (osi == NULL) { 273 err = dmu_objset_open_impl(dsl_dataset_get_spa(ds), 274 ds, &ds->ds_phys->ds_bp, &osi); 275 if (err) 276 return (err); 277 } 278 mutex_exit(&ds->ds_opening_lock); 279 280 os->os = osi; 281 os->os_mode = DS_MODE_NONE; 282 283 if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) 284 return (EINVAL); 285 return (0); 286 } 287 288 int 289 dmu_objset_open_ds(dsl_dataset_t *ds, dmu_objset_type_t type, objset_t **osp) 290 { 291 objset_t *os; 292 int err; 293 294 os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 295 err = dmu_objset_open_ds_os(ds, os, type); 296 if (err) 297 kmem_free(os, sizeof (objset_t)); 298 else 299 *osp = os; 300 return (err); 301 } 302 303 /* called from zpl */ 304 int 305 dmu_objset_open(const char *name, dmu_objset_type_t type, int mode, 306 objset_t **osp) 307 { 308 objset_t *os; 309 dsl_dataset_t *ds; 310 int err; 311 312 ASSERT(mode != DS_MODE_NONE); 313 314 os = kmem_alloc(sizeof (objset_t), KM_SLEEP); 315 err = dsl_dataset_open(name, mode, os, &ds); 316 if (err) { 317 kmem_free(os, sizeof (objset_t)); 318 return (err); 319 } 320 321 err = dmu_objset_open_ds_os(ds, os, type); 322 os->os_mode = mode; 323 if (err) { 324 kmem_free(os, sizeof (objset_t)); 325 dsl_dataset_close(ds, mode, os); 326 } else { 327 *osp = os; 328 } 329 return (err); 330 } 331 332 void 333 dmu_objset_close(objset_t *os) 334 { 335 if (os->os_mode != DS_MODE_NONE) 336 dsl_dataset_close(os->os->os_dsl_dataset, os->os_mode, os); 337 kmem_free(os, sizeof (objset_t)); 338 } 339 340 int 341 dmu_objset_evict_dbufs(objset_t *os) 342 { 343 objset_impl_t *osi = os->os; 344 dnode_t *dn; 345 346 mutex_enter(&osi->os_lock); 347 348 /* process the mdn last, since the other dnodes have holds on it */ 349 list_remove(&osi->os_dnodes, osi->os_meta_dnode); 350 list_insert_tail(&osi->os_dnodes, osi->os_meta_dnode); 351 352 /* 353 * Find the first dnode with holds. We have to do this dance 354 * because dnode_add_ref() only works if you already have a 355 * hold. If there are no holds then it has no dbufs so OK to 356 * skip. 357 */ 358 for (dn = list_head(&osi->os_dnodes); 359 dn && !dnode_add_ref(dn, FTAG); 360 dn = list_next(&osi->os_dnodes, dn)) 361 continue; 362 363 while (dn) { 364 dnode_t *next_dn = dn; 365 366 do { 367 next_dn = list_next(&osi->os_dnodes, next_dn); 368 } while (next_dn && !dnode_add_ref(next_dn, FTAG)); 369 370 mutex_exit(&osi->os_lock); 371 dnode_evict_dbufs(dn); 372 dnode_rele(dn, FTAG); 373 mutex_enter(&osi->os_lock); 374 dn = next_dn; 375 } 376 mutex_exit(&osi->os_lock); 377 return (list_head(&osi->os_dnodes) != osi->os_meta_dnode); 378 } 379 380 void 381 dmu_objset_evict(dsl_dataset_t *ds, void *arg) 382 { 383 objset_impl_t *osi = arg; 384 objset_t os; 385 int i; 386 387 for (i = 0; i < TXG_SIZE; i++) { 388 ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL); 389 ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL); 390 } 391 392 if (ds && ds->ds_phys->ds_num_children == 0) { 393 VERIFY(0 == dsl_prop_unregister(ds, "checksum", 394 checksum_changed_cb, osi)); 395 VERIFY(0 == dsl_prop_unregister(ds, "compression", 396 compression_changed_cb, osi)); 397 VERIFY(0 == dsl_prop_unregister(ds, "copies", 398 copies_changed_cb, osi)); 399 } 400 401 /* 402 * We should need only a single pass over the dnode list, since 403 * nothing can be added to the list at this point. 404 */ 405 os.os = osi; 406 (void) dmu_objset_evict_dbufs(&os); 407 408 ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode); 409 ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode); 410 ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL); 411 412 dnode_special_close(osi->os_meta_dnode); 413 zil_free(osi->os_zil); 414 415 VERIFY(arc_buf_remove_ref(osi->os_phys_buf, &osi->os_phys_buf) == 1); 416 mutex_destroy(&osi->os_lock); 417 mutex_destroy(&osi->os_obj_lock); 418 mutex_destroy(&osi->os_user_ptr_lock); 419 kmem_free(osi, sizeof (objset_impl_t)); 420 } 421 422 /* called from dsl for meta-objset */ 423 objset_impl_t * 424 dmu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, 425 dmu_objset_type_t type, dmu_tx_t *tx) 426 { 427 objset_impl_t *osi; 428 dnode_t *mdn; 429 430 ASSERT(dmu_tx_is_syncing(tx)); 431 if (ds) 432 mutex_enter(&ds->ds_opening_lock); 433 VERIFY(0 == dmu_objset_open_impl(spa, ds, bp, &osi)); 434 if (ds) 435 mutex_exit(&ds->ds_opening_lock); 436 mdn = osi->os_meta_dnode; 437 438 dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT, 439 DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx); 440 441 /* 442 * We don't want to have to increase the meta-dnode's nlevels 443 * later, because then we could do it in quescing context while 444 * we are also accessing it in open context. 445 * 446 * This precaution is not necessary for the MOS (ds == NULL), 447 * because the MOS is only updated in syncing context. 448 * This is most fortunate: the MOS is the only objset that 449 * needs to be synced multiple times as spa_sync() iterates 450 * to convergence, so minimizing its dn_nlevels matters. 451 */ 452 if (ds != NULL) { 453 int levels = 1; 454 455 /* 456 * Determine the number of levels necessary for the meta-dnode 457 * to contain DN_MAX_OBJECT dnodes. 458 */ 459 while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift + 460 (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) < 461 DN_MAX_OBJECT * sizeof (dnode_phys_t)) 462 levels++; 463 464 mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] = 465 mdn->dn_nlevels = levels; 466 } 467 468 ASSERT(type != DMU_OST_NONE); 469 ASSERT(type != DMU_OST_ANY); 470 ASSERT(type < DMU_OST_NUMTYPES); 471 osi->os_phys->os_type = type; 472 473 dsl_dataset_dirty(ds, tx); 474 475 return (osi); 476 } 477 478 struct oscarg { 479 void (*userfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx); 480 void *userarg; 481 dsl_dataset_t *clone_parent; 482 const char *lastname; 483 dmu_objset_type_t type; 484 uint64_t flags; 485 }; 486 487 /*ARGSUSED*/ 488 static int 489 dmu_objset_create_check(void *arg1, void *arg2, dmu_tx_t *tx) 490 { 491 dsl_dir_t *dd = arg1; 492 struct oscarg *oa = arg2; 493 objset_t *mos = dd->dd_pool->dp_meta_objset; 494 int err; 495 uint64_t ddobj; 496 497 err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 498 oa->lastname, sizeof (uint64_t), 1, &ddobj); 499 if (err != ENOENT) 500 return (err ? err : EEXIST); 501 502 if (oa->clone_parent != NULL) { 503 /* 504 * You can't clone across pools. 505 */ 506 if (oa->clone_parent->ds_dir->dd_pool != dd->dd_pool) 507 return (EXDEV); 508 509 /* 510 * You can only clone snapshots, not the head datasets. 511 */ 512 if (oa->clone_parent->ds_phys->ds_num_children == 0) 513 return (EINVAL); 514 } 515 516 return (0); 517 } 518 519 static void 520 dmu_objset_create_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 521 { 522 dsl_dir_t *dd = arg1; 523 struct oscarg *oa = arg2; 524 dsl_dataset_t *ds; 525 blkptr_t *bp; 526 uint64_t dsobj; 527 528 ASSERT(dmu_tx_is_syncing(tx)); 529 530 dsobj = dsl_dataset_create_sync(dd, oa->lastname, 531 oa->clone_parent, oa->flags, cr, tx); 532 533 VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL, 534 DS_MODE_STANDARD | DS_MODE_READONLY, FTAG, &ds)); 535 bp = dsl_dataset_get_blkptr(ds); 536 if (BP_IS_HOLE(bp)) { 537 objset_impl_t *osi; 538 539 /* This is an empty dmu_objset; not a clone. */ 540 osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds), 541 ds, bp, oa->type, tx); 542 543 if (oa->userfunc) 544 oa->userfunc(&osi->os, oa->userarg, cr, tx); 545 } 546 547 spa_history_internal_log(LOG_DS_CREATE, dd->dd_pool->dp_spa, 548 tx, cr, "dataset = %llu", dsobj); 549 550 dsl_dataset_close(ds, DS_MODE_STANDARD | DS_MODE_READONLY, FTAG); 551 } 552 553 int 554 dmu_objset_create(const char *name, dmu_objset_type_t type, 555 objset_t *clone_parent, uint64_t flags, 556 void (*func)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx), void *arg) 557 { 558 dsl_dir_t *pdd; 559 const char *tail; 560 int err = 0; 561 struct oscarg oa = { 0 }; 562 563 ASSERT(strchr(name, '@') == NULL); 564 err = dsl_dir_open(name, FTAG, &pdd, &tail); 565 if (err) 566 return (err); 567 if (tail == NULL) { 568 dsl_dir_close(pdd, FTAG); 569 return (EEXIST); 570 } 571 572 dprintf("name=%s\n", name); 573 574 oa.userfunc = func; 575 oa.userarg = arg; 576 oa.lastname = tail; 577 oa.type = type; 578 oa.flags = flags; 579 580 if (clone_parent != NULL) { 581 /* 582 * You can't clone to a different type. 583 */ 584 if (clone_parent->os->os_phys->os_type != type) { 585 dsl_dir_close(pdd, FTAG); 586 return (EINVAL); 587 } 588 oa.clone_parent = clone_parent->os->os_dsl_dataset; 589 } 590 err = dsl_sync_task_do(pdd->dd_pool, dmu_objset_create_check, 591 dmu_objset_create_sync, pdd, &oa, 5); 592 dsl_dir_close(pdd, FTAG); 593 return (err); 594 } 595 596 int 597 dmu_objset_destroy(const char *name) 598 { 599 objset_t *os; 600 int error; 601 602 /* 603 * If it looks like we'll be able to destroy it, and there's 604 * an unplayed replay log sitting around, destroy the log. 605 * It would be nicer to do this in dsl_dataset_destroy_sync(), 606 * but the replay log objset is modified in open context. 607 */ 608 error = dmu_objset_open(name, DMU_OST_ANY, 609 DS_MODE_EXCLUSIVE|DS_MODE_READONLY, &os); 610 if (error == 0) { 611 dsl_dataset_t *ds = os->os->os_dsl_dataset; 612 zil_destroy(dmu_objset_zil(os), B_FALSE); 613 614 /* 615 * dsl_dataset_destroy() closes the ds. 616 * os is just used as the tag after it's freed. 617 */ 618 kmem_free(os, sizeof (objset_t)); 619 error = dsl_dataset_destroy(ds, os); 620 } 621 622 return (error); 623 } 624 625 /* 626 * This will close the objset. 627 */ 628 int 629 dmu_objset_rollback(objset_t *os) 630 { 631 int err; 632 dsl_dataset_t *ds; 633 634 ds = os->os->os_dsl_dataset; 635 636 if (!dsl_dataset_tryupgrade(ds, DS_MODE_STANDARD, DS_MODE_EXCLUSIVE)) { 637 dmu_objset_close(os); 638 return (EBUSY); 639 } 640 641 err = dsl_dataset_rollback(ds, os->os->os_phys->os_type); 642 643 /* 644 * NB: we close the objset manually because the rollback 645 * actually implicitly called dmu_objset_evict(), thus freeing 646 * the objset_impl_t. 647 */ 648 dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, os); 649 kmem_free(os, sizeof (objset_t)); 650 return (err); 651 } 652 653 struct snaparg { 654 dsl_sync_task_group_t *dstg; 655 char *snapname; 656 char failed[MAXPATHLEN]; 657 boolean_t checkperms; 658 list_t objsets; 659 }; 660 661 struct osnode { 662 list_node_t node; 663 objset_t *os; 664 }; 665 666 static int 667 dmu_objset_snapshot_one(char *name, void *arg) 668 { 669 struct snaparg *sn = arg; 670 objset_t *os; 671 dmu_objset_stats_t stat; 672 int err; 673 674 (void) strcpy(sn->failed, name); 675 676 /* 677 * Check permissions only when requested. This only applies when 678 * doing a recursive snapshot. The permission checks for the starting 679 * dataset have already been performed in zfs_secpolicy_snapshot() 680 */ 681 if (sn->checkperms == B_TRUE && 682 (err = zfs_secpolicy_snapshot_perms(name, CRED()))) 683 return (err); 684 685 err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_STANDARD, &os); 686 if (err != 0) 687 return (err); 688 689 /* 690 * If the objset is in an inconsistent state, return busy. 691 */ 692 dmu_objset_fast_stat(os, &stat); 693 if (stat.dds_inconsistent) { 694 dmu_objset_close(os); 695 return (EBUSY); 696 } 697 698 /* 699 * NB: we need to wait for all in-flight changes to get to disk, 700 * so that we snapshot those changes. zil_suspend does this as 701 * a side effect. 702 */ 703 err = zil_suspend(dmu_objset_zil(os)); 704 if (err == 0) { 705 struct osnode *osn; 706 dsl_sync_task_create(sn->dstg, dsl_dataset_snapshot_check, 707 dsl_dataset_snapshot_sync, os->os->os_dsl_dataset, 708 sn->snapname, 3); 709 osn = kmem_alloc(sizeof (struct osnode), KM_SLEEP); 710 osn->os = os; 711 list_insert_tail(&sn->objsets, osn); 712 } else { 713 dmu_objset_close(os); 714 } 715 716 return (err); 717 } 718 719 int 720 dmu_objset_snapshot(char *fsname, char *snapname, boolean_t recursive) 721 { 722 dsl_sync_task_t *dst; 723 struct osnode *osn; 724 struct snaparg sn = { 0 }; 725 spa_t *spa; 726 int err; 727 728 (void) strcpy(sn.failed, fsname); 729 730 err = spa_open(fsname, &spa, FTAG); 731 if (err) 732 return (err); 733 734 sn.dstg = dsl_sync_task_group_create(spa_get_dsl(spa)); 735 sn.snapname = snapname; 736 list_create(&sn.objsets, sizeof (struct osnode), 737 offsetof(struct osnode, node)); 738 739 if (recursive) { 740 sn.checkperms = B_TRUE; 741 err = dmu_objset_find(fsname, 742 dmu_objset_snapshot_one, &sn, DS_FIND_CHILDREN); 743 } else { 744 sn.checkperms = B_FALSE; 745 err = dmu_objset_snapshot_one(fsname, &sn); 746 } 747 748 if (err) 749 goto out; 750 751 err = dsl_sync_task_group_wait(sn.dstg); 752 753 for (dst = list_head(&sn.dstg->dstg_tasks); dst; 754 dst = list_next(&sn.dstg->dstg_tasks, dst)) { 755 dsl_dataset_t *ds = dst->dst_arg1; 756 if (dst->dst_err) 757 dsl_dataset_name(ds, sn.failed); 758 } 759 760 out: 761 while (osn = list_head(&sn.objsets)) { 762 list_remove(&sn.objsets, osn); 763 zil_resume(dmu_objset_zil(osn->os)); 764 dmu_objset_close(osn->os); 765 kmem_free(osn, sizeof (struct osnode)); 766 } 767 list_destroy(&sn.objsets); 768 769 if (err) 770 (void) strcpy(fsname, sn.failed); 771 dsl_sync_task_group_destroy(sn.dstg); 772 spa_close(spa, FTAG); 773 return (err); 774 } 775 776 static void 777 dmu_objset_sync_dnodes(list_t *list, dmu_tx_t *tx) 778 { 779 dnode_t *dn; 780 781 while (dn = list_head(list)) { 782 ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT); 783 ASSERT(dn->dn_dbuf->db_data_pending); 784 /* 785 * Initialize dn_zio outside dnode_sync() 786 * to accomodate meta-dnode 787 */ 788 dn->dn_zio = dn->dn_dbuf->db_data_pending->dr_zio; 789 ASSERT(dn->dn_zio); 790 791 ASSERT3U(dn->dn_nlevels, <=, DN_MAX_LEVELS); 792 list_remove(list, dn); 793 dnode_sync(dn, tx); 794 } 795 } 796 797 /* ARGSUSED */ 798 static void 799 ready(zio_t *zio, arc_buf_t *abuf, void *arg) 800 { 801 objset_impl_t *os = arg; 802 blkptr_t *bp = os->os_rootbp; 803 dnode_phys_t *dnp = &os->os_phys->os_meta_dnode; 804 int i; 805 806 ASSERT(bp == zio->io_bp); 807 808 /* 809 * Update rootbp fill count. 810 */ 811 bp->blk_fill = 1; /* count the meta-dnode */ 812 for (i = 0; i < dnp->dn_nblkptr; i++) 813 bp->blk_fill += dnp->dn_blkptr[i].blk_fill; 814 815 BP_SET_TYPE(bp, DMU_OT_OBJSET); 816 BP_SET_LEVEL(bp, 0); 817 818 /* We must do this after we've set the bp's type and level */ 819 if (!DVA_EQUAL(BP_IDENTITY(bp), 820 BP_IDENTITY(&zio->io_bp_orig))) { 821 if (zio->io_bp_orig.blk_birth == os->os_synctx->tx_txg) 822 dsl_dataset_block_kill(os->os_dsl_dataset, 823 &zio->io_bp_orig, NULL, os->os_synctx); 824 dsl_dataset_block_born(os->os_dsl_dataset, bp, os->os_synctx); 825 } 826 } 827 828 /* ARGSUSED */ 829 static void 830 killer(zio_t *zio, arc_buf_t *abuf, void *arg) 831 { 832 objset_impl_t *os = arg; 833 834 ASSERT3U(zio->io_error, ==, 0); 835 arc_release(os->os_phys_buf, &os->os_phys_buf); 836 } 837 838 /* called from dsl */ 839 void 840 dmu_objset_sync(objset_impl_t *os, zio_t *pio, dmu_tx_t *tx) 841 { 842 int txgoff; 843 zbookmark_t zb; 844 zio_t *zio; 845 list_t *list; 846 dbuf_dirty_record_t *dr; 847 848 dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg); 849 850 ASSERT(dmu_tx_is_syncing(tx)); 851 /* XXX the write_done callback should really give us the tx... */ 852 os->os_synctx = tx; 853 854 if (os->os_dsl_dataset == NULL) { 855 /* 856 * This is the MOS. If we have upgraded, 857 * spa_max_replication() could change, so reset 858 * os_copies here. 859 */ 860 os->os_copies = spa_max_replication(os->os_spa); 861 } 862 863 /* 864 * Create the root block IO 865 */ 866 zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0; 867 zb.zb_object = 0; 868 zb.zb_level = -1; 869 zb.zb_blkid = 0; 870 if (BP_IS_OLDER(os->os_rootbp, tx->tx_txg)) { 871 dsl_dataset_block_kill(os->os_dsl_dataset, 872 os->os_rootbp, pio, tx); 873 } 874 zio = arc_write(pio, os->os_spa, os->os_md_checksum, 875 os->os_md_compress, 876 dmu_get_replication_level(os, &zb, DMU_OT_OBJSET), 877 tx->tx_txg, os->os_rootbp, os->os_phys_buf, ready, killer, os, 878 ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_MUSTSUCCEED | ZIO_FLAG_METADATA, 879 &zb); 880 881 /* 882 * Sync meta-dnode - the parent IO for the sync is the root block 883 */ 884 os->os_meta_dnode->dn_zio = zio; 885 dnode_sync(os->os_meta_dnode, tx); 886 887 txgoff = tx->tx_txg & TXG_MASK; 888 889 dmu_objset_sync_dnodes(&os->os_free_dnodes[txgoff], tx); 890 dmu_objset_sync_dnodes(&os->os_dirty_dnodes[txgoff], tx); 891 892 list = &os->os_meta_dnode->dn_dirty_records[txgoff]; 893 while (dr = list_head(list)) { 894 ASSERT(dr->dr_dbuf->db_level == 0); 895 list_remove(list, dr); 896 if (dr->dr_zio) 897 zio_nowait(dr->dr_zio); 898 } 899 /* 900 * Free intent log blocks up to this tx. 901 */ 902 zil_sync(os->os_zil, tx); 903 zio_nowait(zio); 904 } 905 906 void 907 dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp, 908 uint64_t *usedobjsp, uint64_t *availobjsp) 909 { 910 dsl_dataset_space(os->os->os_dsl_dataset, refdbytesp, availbytesp, 911 usedobjsp, availobjsp); 912 } 913 914 uint64_t 915 dmu_objset_fsid_guid(objset_t *os) 916 { 917 return (dsl_dataset_fsid_guid(os->os->os_dsl_dataset)); 918 } 919 920 void 921 dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat) 922 { 923 stat->dds_type = os->os->os_phys->os_type; 924 if (os->os->os_dsl_dataset) 925 dsl_dataset_fast_stat(os->os->os_dsl_dataset, stat); 926 } 927 928 void 929 dmu_objset_stats(objset_t *os, nvlist_t *nv) 930 { 931 ASSERT(os->os->os_dsl_dataset || 932 os->os->os_phys->os_type == DMU_OST_META); 933 934 if (os->os->os_dsl_dataset != NULL) 935 dsl_dataset_stats(os->os->os_dsl_dataset, nv); 936 937 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_TYPE, 938 os->os->os_phys->os_type); 939 } 940 941 int 942 dmu_objset_is_snapshot(objset_t *os) 943 { 944 if (os->os->os_dsl_dataset != NULL) 945 return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset)); 946 else 947 return (B_FALSE); 948 } 949 950 int 951 dmu_snapshot_realname(objset_t *os, char *name, char *real, int maxlen, 952 boolean_t *conflict) 953 { 954 dsl_dataset_t *ds = os->os->os_dsl_dataset; 955 uint64_t ignored; 956 957 if (ds->ds_phys->ds_snapnames_zapobj == 0) 958 return (ENOENT); 959 960 return (zap_lookup_norm(ds->ds_dir->dd_pool->dp_meta_objset, 961 ds->ds_phys->ds_snapnames_zapobj, name, 8, 1, &ignored, MT_FIRST, 962 real, maxlen, conflict)); 963 } 964 965 int 966 dmu_snapshot_list_next(objset_t *os, int namelen, char *name, 967 uint64_t *idp, uint64_t *offp, boolean_t *case_conflict) 968 { 969 dsl_dataset_t *ds = os->os->os_dsl_dataset; 970 zap_cursor_t cursor; 971 zap_attribute_t attr; 972 973 if (ds->ds_phys->ds_snapnames_zapobj == 0) 974 return (ENOENT); 975 976 zap_cursor_init_serialized(&cursor, 977 ds->ds_dir->dd_pool->dp_meta_objset, 978 ds->ds_phys->ds_snapnames_zapobj, *offp); 979 980 if (zap_cursor_retrieve(&cursor, &attr) != 0) { 981 zap_cursor_fini(&cursor); 982 return (ENOENT); 983 } 984 985 if (strlen(attr.za_name) + 1 > namelen) { 986 zap_cursor_fini(&cursor); 987 return (ENAMETOOLONG); 988 } 989 990 (void) strcpy(name, attr.za_name); 991 if (idp) 992 *idp = attr.za_first_integer; 993 if (case_conflict) 994 *case_conflict = attr.za_normalization_conflict; 995 zap_cursor_advance(&cursor); 996 *offp = zap_cursor_serialize(&cursor); 997 zap_cursor_fini(&cursor); 998 999 return (0); 1000 } 1001 1002 int 1003 dmu_dir_list_next(objset_t *os, int namelen, char *name, 1004 uint64_t *idp, uint64_t *offp) 1005 { 1006 dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir; 1007 zap_cursor_t cursor; 1008 zap_attribute_t attr; 1009 1010 /* there is no next dir on a snapshot! */ 1011 if (os->os->os_dsl_dataset->ds_object != 1012 dd->dd_phys->dd_head_dataset_obj) 1013 return (ENOENT); 1014 1015 zap_cursor_init_serialized(&cursor, 1016 dd->dd_pool->dp_meta_objset, 1017 dd->dd_phys->dd_child_dir_zapobj, *offp); 1018 1019 if (zap_cursor_retrieve(&cursor, &attr) != 0) { 1020 zap_cursor_fini(&cursor); 1021 return (ENOENT); 1022 } 1023 1024 if (strlen(attr.za_name) + 1 > namelen) { 1025 zap_cursor_fini(&cursor); 1026 return (ENAMETOOLONG); 1027 } 1028 1029 (void) strcpy(name, attr.za_name); 1030 if (idp) 1031 *idp = attr.za_first_integer; 1032 zap_cursor_advance(&cursor); 1033 *offp = zap_cursor_serialize(&cursor); 1034 zap_cursor_fini(&cursor); 1035 1036 return (0); 1037 } 1038 1039 /* 1040 * Find all objsets under name, and for each, call 'func(child_name, arg)'. 1041 */ 1042 int 1043 dmu_objset_find(char *name, int func(char *, void *), void *arg, int flags) 1044 { 1045 dsl_dir_t *dd; 1046 objset_t *os; 1047 uint64_t snapobj; 1048 zap_cursor_t zc; 1049 zap_attribute_t *attr; 1050 char *child; 1051 int do_self, err; 1052 1053 err = dsl_dir_open(name, FTAG, &dd, NULL); 1054 if (err) 1055 return (err); 1056 1057 /* NB: the $MOS dir doesn't have a head dataset */ 1058 do_self = (dd->dd_phys->dd_head_dataset_obj != 0); 1059 attr = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); 1060 1061 /* 1062 * Iterate over all children. 1063 */ 1064 if (flags & DS_FIND_CHILDREN) { 1065 for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, 1066 dd->dd_phys->dd_child_dir_zapobj); 1067 zap_cursor_retrieve(&zc, attr) == 0; 1068 (void) zap_cursor_advance(&zc)) { 1069 ASSERT(attr->za_integer_length == sizeof (uint64_t)); 1070 ASSERT(attr->za_num_integers == 1); 1071 1072 /* 1073 * No separating '/' because parent's name ends in /. 1074 */ 1075 child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1076 /* XXX could probably just use name here */ 1077 dsl_dir_name(dd, child); 1078 (void) strcat(child, "/"); 1079 (void) strcat(child, attr->za_name); 1080 err = dmu_objset_find(child, func, arg, flags); 1081 kmem_free(child, MAXPATHLEN); 1082 if (err) 1083 break; 1084 } 1085 zap_cursor_fini(&zc); 1086 1087 if (err) { 1088 dsl_dir_close(dd, FTAG); 1089 kmem_free(attr, sizeof (zap_attribute_t)); 1090 return (err); 1091 } 1092 } 1093 1094 /* 1095 * Iterate over all snapshots. 1096 */ 1097 if ((flags & DS_FIND_SNAPSHOTS) && 1098 dmu_objset_open(name, DMU_OST_ANY, 1099 DS_MODE_STANDARD | DS_MODE_READONLY, &os) == 0) { 1100 1101 snapobj = os->os->os_dsl_dataset->ds_phys->ds_snapnames_zapobj; 1102 dmu_objset_close(os); 1103 1104 for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, snapobj); 1105 zap_cursor_retrieve(&zc, attr) == 0; 1106 (void) zap_cursor_advance(&zc)) { 1107 ASSERT(attr->za_integer_length == sizeof (uint64_t)); 1108 ASSERT(attr->za_num_integers == 1); 1109 1110 child = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1111 /* XXX could probably just use name here */ 1112 dsl_dir_name(dd, child); 1113 (void) strcat(child, "@"); 1114 (void) strcat(child, attr->za_name); 1115 err = func(child, arg); 1116 kmem_free(child, MAXPATHLEN); 1117 if (err) 1118 break; 1119 } 1120 zap_cursor_fini(&zc); 1121 } 1122 1123 dsl_dir_close(dd, FTAG); 1124 kmem_free(attr, sizeof (zap_attribute_t)); 1125 1126 if (err) 1127 return (err); 1128 1129 /* 1130 * Apply to self if appropriate. 1131 */ 1132 if (do_self) 1133 err = func(name, arg); 1134 return (err); 1135 } 1136 1137 void 1138 dmu_objset_set_user(objset_t *os, void *user_ptr) 1139 { 1140 ASSERT(MUTEX_HELD(&os->os->os_user_ptr_lock)); 1141 os->os->os_user_ptr = user_ptr; 1142 } 1143 1144 void * 1145 dmu_objset_get_user(objset_t *os) 1146 { 1147 ASSERT(MUTEX_HELD(&os->os->os_user_ptr_lock)); 1148 return (os->os->os_user_ptr); 1149 } 1150