Lines Matching refs:vd
191 vdev_default_asize(vdev_t *vd, uint64_t psize)
193 uint64_t asize = P2ROUNDUP(psize, 1ULL << vd->vdev_top->vdev_ashift);
196 for (int c = 0; c < vd->vdev_children; c++) {
197 csize = vdev_psize_to_asize(vd->vdev_child[c], psize);
211 vdev_get_min_asize(vdev_t *vd)
213 vdev_t *pvd = vd->vdev_parent;
220 return (vd->vdev_asize);
226 if (vd == vd->vdev_top)
227 return (P2ALIGN(vd->vdev_asize, 1ULL << vd->vdev_ms_shift));
240 vdev_set_min_asize(vdev_t *vd)
242 vd->vdev_min_asize = vdev_get_min_asize(vd);
244 for (int c = 0; c < vd->vdev_children; c++)
245 vdev_set_min_asize(vd->vdev_child[c]);
264 vdev_lookup_by_guid(vdev_t *vd, uint64_t guid)
268 if (vd->vdev_guid == guid)
269 return (vd);
271 for (int c = 0; c < vd->vdev_children; c++)
272 if ((mvd = vdev_lookup_by_guid(vd->vdev_child[c], guid)) !=
280 vdev_count_leaves_impl(vdev_t *vd)
284 if (vd->vdev_ops->vdev_op_leaf)
287 for (int c = 0; c < vd->vdev_children; c++)
288 n += vdev_count_leaves_impl(vd->vdev_child[c]);
410 vdev_t *vd;
412 vd = kmem_zalloc(sizeof (vdev_t), KM_SLEEP);
416 spa->spa_root_vdev = vd;
421 if (spa->spa_root_vdev == vd) {
436 vd->vdev_spa = spa;
437 vd->vdev_id = id;
438 vd->vdev_guid = guid;
439 vd->vdev_guid_sum = guid;
440 vd->vdev_ops = ops;
441 vd->vdev_state = VDEV_STATE_CLOSED;
442 vd->vdev_ishole = (ops == &vdev_hole_ops);
444 mutex_init(&vd->vdev_dtl_lock, NULL, MUTEX_DEFAULT, NULL);
445 mutex_init(&vd->vdev_stat_lock, NULL, MUTEX_DEFAULT, NULL);
446 mutex_init(&vd->vdev_probe_lock, NULL, MUTEX_DEFAULT, NULL);
447 mutex_init(&vd->vdev_queue_lock, NULL, MUTEX_DEFAULT, NULL);
449 vd->vdev_dtl[t] = range_tree_create(NULL, NULL,
450 &vd->vdev_dtl_lock);
452 txg_list_create(&vd->vdev_ms_list,
454 txg_list_create(&vd->vdev_dtl_list,
456 vd->vdev_stat.vs_timestamp = gethrtime();
457 vdev_queue_init(vd);
458 vdev_cache_init(vd);
460 return (vd);
475 vdev_t *vd;
562 vd = vdev_alloc_common(spa, id, guid, ops);
564 vd->vdev_islog = islog;
565 vd->vdev_nparity = nparity;
567 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &vd->vdev_path) == 0)
568 vd->vdev_path = spa_strdup(vd->vdev_path);
569 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &vd->vdev_devid) == 0)
570 vd->vdev_devid = spa_strdup(vd->vdev_devid);
572 &vd->vdev_physpath) == 0)
573 vd->vdev_physpath = spa_strdup(vd->vdev_physpath);
574 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_FRU, &vd->vdev_fru) == 0)
575 vd->vdev_fru = spa_strdup(vd->vdev_fru);
582 &vd->vdev_wholedisk) != 0)
583 vd->vdev_wholedisk = -1ULL;
590 &vd->vdev_not_present);
595 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &vd->vdev_ashift);
601 &vd->vdev_crtxg);
609 &vd->vdev_ms_array);
611 &vd->vdev_ms_shift);
613 &vd->vdev_asize);
615 &vd->vdev_removing);
617 &vd->vdev_top_zap);
619 vd->vdev_top_zap);
627 vd->vdev_mg = metaslab_group_create(islog ?
628 spa_log_class(spa) : spa_normal_class(spa), vd);
631 if (vd->vdev_ops->vdev_op_leaf &&
634 ZPOOL_CONFIG_VDEV_LEAF_ZAP, &vd->vdev_leaf_zap);
636 ASSERT0(vd->vdev_leaf_zap);
643 if (vd->vdev_ops->vdev_op_leaf &&
648 &vd->vdev_dtl_object);
650 &vd->vdev_unspare);
658 spa_spare_add(vd);
662 &vd->vdev_offline);
665 &vd->vdev_resilver_txg);
675 &vd->vdev_faulted);
677 &vd->vdev_degraded);
679 &vd->vdev_removed);
681 if (vd->vdev_faulted || vd->vdev_degraded) {
684 vd->vdev_label_aux =
689 vd->vdev_label_aux = VDEV_AUX_EXTERNAL;
697 vdev_add_child(parent, vd);
699 *vdp = vd;
705 vdev_free(vdev_t *vd)
707 spa_t *spa = vd->vdev_spa;
713 vdev_close(vd);
715 ASSERT(!list_link_active(&vd->vdev_config_dirty_node));
716 ASSERT(!list_link_active(&vd->vdev_state_dirty_node));
721 for (int c = 0; c < vd->vdev_children; c++)
722 vdev_free(vd->vdev_child[c]);
724 ASSERT(vd->vdev_child == NULL);
725 ASSERT(vd->vdev_guid_sum == vd->vdev_guid);
730 if (vd->vdev_mg != NULL) {
731 vdev_metaslab_fini(vd);
732 metaslab_group_destroy(vd->vdev_mg);
735 ASSERT0(vd->vdev_stat.vs_space);
736 ASSERT0(vd->vdev_stat.vs_dspace);
737 ASSERT0(vd->vdev_stat.vs_alloc);
742 vdev_remove_child(vd->vdev_parent, vd);
744 ASSERT(vd->vdev_parent == NULL);
749 vdev_queue_fini(vd);
750 vdev_cache_fini(vd);
752 if (vd->vdev_path)
753 spa_strfree(vd->vdev_path);
754 if (vd->vdev_devid)
755 spa_strfree(vd->vdev_devid);
756 if (vd->vdev_physpath)
757 spa_strfree(vd->vdev_physpath);
758 if (vd->vdev_fru)
759 spa_strfree(vd->vdev_fru);
761 if (vd->vdev_isspare)
762 spa_spare_remove(vd);
763 if (vd->vdev_isl2cache)
764 spa_l2cache_remove(vd);
766 txg_list_destroy(&vd->vdev_ms_list);
767 txg_list_destroy(&vd->vdev_dtl_list);
769 mutex_enter(&vd->vdev_dtl_lock);
770 space_map_close(vd->vdev_dtl_sm);
772 range_tree_vacate(vd->vdev_dtl[t], NULL, NULL);
773 range_tree_destroy(vd->vdev_dtl[t]);
775 mutex_exit(&vd->vdev_dtl_lock);
777 mutex_destroy(&vd->vdev_queue_lock);
778 mutex_destroy(&vd->vdev_dtl_lock);
779 mutex_destroy(&vd->vdev_stat_lock);
780 mutex_destroy(&vd->vdev_probe_lock);
782 if (vd == spa->spa_root_vdev)
785 kmem_free(vd, sizeof (vdev_t));
796 vdev_t *vd;
833 while ((vd = txg_list_remove(&svd->vdev_dtl_list, t)) != NULL)
834 (void) txg_list_add(&tvd->vdev_dtl_list, vd, t);
857 vdev_top_update(vdev_t *tvd, vdev_t *vd)
859 if (vd == NULL)
862 vd->vdev_top = tvd;
864 for (int c = 0; c < vd->vdev_children; c++)
865 vdev_top_update(tvd, vd->vdev_child[c]);
949 vdev_metaslab_init(vdev_t *vd, uint64_t txg)
951 spa_t *spa = vd->vdev_spa;
954 uint64_t oldc = vd->vdev_ms_count;
955 uint64_t newc = vd->vdev_asize >> vd->vdev_ms_shift;
964 if (vd->vdev_ms_shift == 0)
967 ASSERT(!vd->vdev_ishole);
975 vd->vdev_deflate_ratio = (1 << 17) /
976 (vdev_psize_to_asize(vd, 1 << 17) >> SPA_MINBLOCKSHIFT);
983 bcopy(vd->vdev_ms, mspp, oldc * sizeof (*mspp));
984 kmem_free(vd->vdev_ms, oldc * sizeof (*mspp));
987 vd->vdev_ms = mspp;
988 vd->vdev_ms_count = newc;
994 error = dmu_read(mos, vd->vdev_ms_array,
1001 error = metaslab_init(vd->vdev_mg, m, object, txg,
1002 &(vd->vdev_ms[m]));
1015 if (oldc == 0 && !vd->vdev_removing)
1016 metaslab_group_activate(vd->vdev_mg);
1025 vdev_metaslab_fini(vdev_t *vd)
1028 uint64_t count = vd->vdev_ms_count;
1030 if (vd->vdev_ms != NULL) {
1031 metaslab_group_passivate(vd->vdev_mg);
1033 metaslab_t *msp = vd->vdev_ms[m];
1038 kmem_free(vd->vdev_ms, count * sizeof (metaslab_t *));
1039 vd->vdev_ms = NULL;
1053 vdev_t *vd = zio->io_vd;
1056 ASSERT(vd->vdev_probe_zio != NULL);
1062 zio_nowait(zio_write_phys(vd->vdev_probe_zio, vd,
1076 vd->vdev_cant_read |= !vps->vps_readable;
1077 vd->vdev_cant_write |= !vps->vps_writeable;
1079 if (vdev_readable(vd) &&
1080 (vdev_writeable(vd) || !spa_writeable(spa))) {
1085 spa, vd, NULL, 0, 0);
1089 mutex_enter(&vd->vdev_probe_lock);
1090 ASSERT(vd->vdev_probe_zio == zio);
1091 vd->vdev_probe_zio = NULL;
1092 mutex_exit(&vd->vdev_probe_lock);
1096 if (!vdev_accessible(vd, pio))
1111 vdev_probe(vdev_t *vd, zio_t *zio)
1113 spa_t *spa = vd->vdev_spa;
1117 ASSERT(vd->vdev_ops->vdev_op_leaf);
1130 mutex_enter(&vd->vdev_probe_lock);
1132 if ((pio = vd->vdev_probe_zio) == NULL) {
1157 vd->vdev_cant_read = B_FALSE;
1158 vd->vdev_cant_write = B_FALSE;
1161 vd->vdev_probe_zio = pio = zio_null(NULL, spa, vd,
1170 vd->vdev_probe_wanted = B_TRUE;
1178 mutex_exit(&vd->vdev_probe_lock);
1186 zio_nowait(zio_read_phys(pio, vd,
1187 vdev_label_offset(vd->vdev_psize, l,
1204 vdev_t *vd = arg;
1206 vd->vdev_open_thread = curthread;
1207 vd->vdev_open_error = vdev_open(vd);
1208 vd->vdev_open_thread = NULL;
1212 vdev_uses_zvols(vdev_t *vd)
1214 if (vd->vdev_path && strncmp(vd->vdev_path, ZVOL_DIR,
1217 for (int c = 0; c < vd->vdev_children; c++)
1218 if (vdev_uses_zvols(vd->vdev_child[c]))
1224 vdev_open_children(vdev_t *vd)
1227 int children = vd->vdev_children;
1234 if (B_TRUE || vdev_uses_zvols(vd)) {
1236 vd->vdev_child[c]->vdev_open_error =
1237 vdev_open(vd->vdev_child[c]);
1244 VERIFY(taskq_dispatch(tq, vdev_open_child, vd->vdev_child[c],
1254 vdev_open(vdev_t *vd)
1256 spa_t *spa = vd->vdev_spa;
1264 ASSERT(vd->vdev_open_thread == curthread ||
1266 ASSERT(vd->vdev_state == VDEV_STATE_CLOSED ||
1267 vd->vdev_state == VDEV_STATE_CANT_OPEN ||
1268 vd->vdev_state == VDEV_STATE_OFFLINE);
1270 vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
1271 vd
1272 vd->vdev_cant_write = B_FALSE;
1273 vd->vdev_notrim = B_FALSE;
1274 vd->vdev_min_asize = vdev_get_min_asize(vd);
1280 if (!vd->vdev_removed && vd->vdev_faulted) {
1281 ASSERT(vd->vdev_children == 0);
1282 ASSERT(vd->vdev_label_aux == VDEV_AUX_ERR_EXCEEDED ||
1283 vd->vdev_label_aux == VDEV_AUX_EXTERNAL);
1284 vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
1285 vd->vdev_label_aux);
1287 } else if (vd->vdev_offline) {
1288 ASSERT(vd->vdev_children == 0);
1289 vdev_set_state(vd, B_TRUE, VDEV_STATE_OFFLINE, VDEV_AUX_NONE);
1293 error = vd->vdev_ops->vdev_op_open(vd, &osize, &max_osize,
1300 vd->vdev_reopening = B_FALSE;
1302 error = zio_handle_device_injection(vd, NULL, ENXIO);
1305 if (vd->vdev_removed &&
1306 vd->vdev_stat.vs_aux != VDEV_AUX_OPEN_FAILED)
1307 vd->vdev_removed = B_FALSE;
1309 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1310 vd->vdev_stat.vs_aux);
1314 vd->vdev_removed = B_FALSE;
1320 if (vd->vdev_faulted) {
1321 ASSERT(vd->vdev_children == 0);
1322 ASSERT(vd->vdev_label_aux == VDEV_AUX_ERR_EXCEEDED ||
1323 vd->vdev_label_aux == VDEV_AUX_EXTERNAL);
1324 vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
1325 vd->vdev_label_aux);
1329 if (vd->vdev_degraded) {
1330 ASSERT(vd->vdev_children == 0);
1331 vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED,
1334 vdev_set_state(vd, B_TRUE, VDEV_STATE_HEALTHY, 0);
1340 if (vd->vdev_ishole || vd->vdev_ops == &vdev_missing_ops)
1343 if (zfs_trim_enabled && !vd->vdev_notrim && vd->vdev_ops->vdev_op_leaf)
1344 trim_map_create(vd);
1346 for (int c = 0; c < vd->vdev_children; c++) {
1347 if (vd->vdev_child[c]->vdev_state != VDEV_STATE_HEALTHY) {
1348 vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED,
1357 if (vd->vdev_children == 0) {
1359 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1368 if (vd->vdev_parent != NULL && osize < SPA_MINDEVSIZE -
1370 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1379 vd->vdev_psize = psize;
1384 if (asize < vd->vdev_min_asize) {
1385 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1390 vd->vdev_physical_ashift =
1391 MAX(physical_ashift, vd->vdev_physical_ashift);
1392 vd->vdev_logical_ashift = MAX(logical_ashift, vd->vdev_logical_ashift);
1393 vd->vdev_ashift = MAX(vd->vdev_logical_ashift, vd->vdev_ashift);
1395 if (vd->vdev_logical_ashift > SPA_MAXASHIFT) {
1396 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1401 if (vd->vdev_asize == 0) {
1406 vd->vdev_asize = asize;
1407 vd->vdev_max_asize = max_asize;
1412 if (vd->vdev_ashift > vd->vdev_top->vdev_ashift &&
1413 vd->vdev_ops->vdev_op_leaf) {
1414 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1418 vd->vdev_max_asize = max_asize;
1426 if (vd->vdev_state == VDEV_STATE_HEALTHY && asize > vd->vdev_asize &&
1427 (vd->vdev_expanding || spa->spa_autoexpand))
1428 vd->vdev_asize = asize;
1430 vdev_set_min_asize(vd);
1436 if (vd->vdev_ops->vdev_op_leaf &&
1437 (error = zio_wait(vdev_probe(vd, NULL))) != 0) {
1438 vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
1446 if (vd->vdev_top == vd && vd->vdev_ashift != 0 &&
1447 !vd->vdev_islog && vd->vdev_aux == NULL) {
1448 if (vd->vdev_ashift > spa->spa_max_ashift)
1449 spa->spa_max_ashift = vd->vdev_ashift;
1450 if (vd->vdev_ashift < spa->spa_min_ashift)
1451 spa->spa_min_ashift = vd->vdev_ashift;
1459 if (vd->vdev_ops->vdev_op_leaf && !spa->spa_scrub_reopen &&
1460 vdev_resilver_needed(vd, NULL, NULL))
1482 vdev_validate(vdev_t *vd, boolean_t strict)
1484 spa_t *spa = vd->vdev_spa;
1489 for (int c = 0; c < vd->vdev_children; c++)
1490 if (vdev_validate(vd->vdev_child[c], strict) != 0)
1498 if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
1504 if ((label = vdev_label_read_config(vd, txg)) == NULL) {
1505 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1516 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1525 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1552 ((vd->vdev_guid != guid && vd->vdev_guid != aux_guid) &&
1553 (vd->vdev_guid != top_guid || vd != vd->vdev_top))) {
1554 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1562 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1584 if (vd->vdev_not_present)
1585 vd->vdev_not_present = 0;
1595 vdev_close(vdev_t *vd)
1597 spa_t *spa = vd->vdev_spa;
1598 vdev_t *pvd = vd->vdev_parent;
1607 vd->vdev_reopening = (pvd->vdev_reopening && !vd->vdev_offline);
1609 vd->vdev_ops->vdev_op_close(vd);
1611 vdev_cache_purge(vd);
1613 if (vd->vdev_ops->vdev_op_leaf)
1614 trim_map_destroy(vd);
1621 vd->vdev_prevstate = vd->vdev_state;
1623 if (vd->vdev_offline)
1624 vd->vdev_state = VDEV_STATE_OFFLINE;
1626 vd->vdev_state = VDEV_STATE_CLOSED;
1627 vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
1631 vdev_hold(vdev_t *vd)
1633 spa_t *spa = vd->vdev_spa;
1639 for (int c = 0; c < vd->vdev_children; c++)
1640 vdev_hold(vd->vdev_child[c]);
1642 if (vd->vdev_ops->vdev_op_leaf)
1643 vd->vdev_ops->vdev_op_hold(vd);
1647 vdev_rele(vdev_t *vd)
1649 spa_t *spa = vd->vdev_spa;
1652 for (int c = 0; c < vd->vdev_children; c++)
1653 vdev_rele(vd->vdev_child[c]);
1655 if (vd->vdev_ops->vdev_op_leaf)
1656 vd->vdev_ops->vdev_op_rele(vd);
1666 vdev_reopen(vdev_t *vd)
1668 spa_t *spa = vd->vdev_spa;
1673 vd->vdev_reopening = !vd->vdev_offline;
1674 vdev_close(vd);
1675 (void) vdev_open(vd);
1682 if (vd->vdev_aux) {
1683 (void) vdev_validate_aux(vd);
1684 if (vdev_readable(vd) && vdev_writeable(vd) &&
1685 vd->vdev_aux == &spa->spa_l2cache &&
1686 !l2arc_vdev_present(vd))
1687 l2arc_add_vdev(spa, vd);
1689 (void) vdev_validate(vd, B_TRUE);
1695 vdev_propagate_state(vd);
1699 vdev_create(vdev_t *vd, uint64_t txg, boolean_t isreplacing)
1708 error = vdev_open(vd);
1710 if (error || vd->vdev_state != VDEV_STATE_HEALTHY) {
1711 vdev_close(vd);
1718 if ((error = vdev_dtl_load(vd)) != 0 ||
1719 (error = vdev_label_init(vd, txg, isreplacing ?
1721 vdev_close(vd);
1729 vdev_metaslab_set_size(vdev_t *vd)
1734 vd->vdev_ms_shift = highbit64(vd->vdev_asize / metaslabs_per_vdev);
1735 vd->vdev_ms_shift = MAX(vd->vdev_ms_shift, SPA_MAXBLOCKSHIFT);
1745 vdev_ashift_optimize(vdev_t *vd)
1747 if (vd == vd->vdev_top) {
1748 if (vd->vdev_ashift < vd->vdev_physical_ashift) {
1749 vd->vdev_ashift = MIN(
1750 MAX(zfs_max_auto_ashift, vd->vdev_ashift),
1751 MAX(zfs_min_auto_ashift, vd->vdev_physical_ashift));
1760 vd->vdev_ashift = MAX(zfs_min_auto_ashift,
1761 vd->vdev_ashift);
1767 vdev_dirty(vdev_t *vd, int flags, void *arg, uint64_t txg)
1769 ASSERT(vd == vd->vdev_top);
1770 ASSERT(!vd->vdev_ishole);
1772 ASSERT(spa_writeable(vd->vdev_spa));
1775 (void) txg_list_add(&vd->vdev_ms_list, arg, txg);
1778 (void) txg_list_add(&vd->vdev_dtl_list, arg, txg);
1780 (void) txg_list_add(&vd->vdev_spa->spa_vdev_txg_list, vd, txg);
1784 vdev_dirty_leaves(vdev_t *vd, int flags, uint64_t txg)
1786 for (int c = 0; c < vd->vdev_children; c++)
1787 vdev_dirty_leaves(vd->vdev_child[c], flags, txg);
1789 if (vd->vdev_ops->vdev_op_leaf)
1790 vdev_dirty(vd->vdev_top, flags, vd, txg);
1832 vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size)
1834 range_tree_t *rt = vd->vdev_dtl[t];
1837 ASSERT(vd != vd->vdev_spa->spa_root_vdev);
1838 ASSERT(spa_writeable(vd->vdev_spa));
1847 vdev_dtl_contains(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size)
1849 range_tree_t *rt = vd->vdev_dtl[t];
1853 ASSERT(vd != vd->vdev_spa->spa_root_vdev);
1864 vdev_dtl_empty(vdev_t *vd, vdev_dtl_type_t t)
1866 range_tree_t *rt = vd->vdev_dtl[t];
1880 vdev_dtl_min(vdev_t *vd)
1884 ASSERT(MUTEX_HELD(&vd->vdev_dtl_lock));
1885 ASSERT3U(range_tree_space(vd->vdev_dtl[DTL_MISSING]), !=, 0);
1886 ASSERT0(vd->vdev_children);
1888 rs = avl_first(&vd->vdev_dtl[DTL_MISSING]->rt_root);
1896 vdev_dtl_max(vdev_t *vd)
1900 ASSERT(MUTEX_HELD(&vd->vdev_dtl_lock));
1901 ASSERT3U(range_tree_space(vd->vdev_dtl[DTL_MISSING]), !=, 0);
1902 ASSERT0(vd->vdev_children);
1904 rs = avl_last(&vd->vdev_dtl[DTL_MISSING]->rt_root);
1917 vdev_dtl_should_excise(vdev_t *vd)
1919 spa_t *spa = vd->vdev_spa;
1923 ASSERT0(vd->vdev_children);
1925 if (vd->vdev_resilver_txg == 0 ||
1926 range_tree_space(vd->vdev_dtl[DTL_MISSING]) == 0)
1936 if (vdev_dtl_max(vd) <= scn->scn_phys.scn_max_txg) {
1937 ASSERT3U(scn->scn_phys.scn_min_txg, <=, vdev_dtl_min(vd));
1938 ASSERT3U(scn->scn_phys.scn_min_txg, <, vd->vdev_resilver_txg);
1939 ASSERT3U(vd->vdev_resilver_txg, <=, scn->scn_phys.scn_max_txg);
1949 vdev_dtl_reassess(vdev_t *vd, uint64_t txg, uint64_t scrub_txg, int scrub_done)
1951 spa_t *spa = vd->vdev_spa;
1957 for (int c = 0; c < vd->vdev_children; c++)
1958 vdev_dtl_reassess(vd->vdev_child[c], txg,
1961 if (vd == spa->spa_root_vdev || vd->vdev_ishole || vd->vdev_aux)
1964 if (vd->vdev_ops->vdev_op_leaf) {
1967 mutex_enter(&vd->vdev_dtl_lock);
1978 vdev_dtl_should_excise(vd)) {
1998 vd->vdev_dtl[DTL_MISSING], 1);
2001 vd->vdev_dtl[DTL_SCRUB], 2);
2003 vd->vdev_dtl[DTL_MISSING], 1);
2006 range_tree_vacate(vd->vdev_dtl[DTL_PARTIAL], NULL, NULL);
2007 range_tree_walk(vd->vdev_dtl[DTL_MISSING],
2008 range_tree_add, vd->vdev_dtl[DTL_PARTIAL]);
2010 range_tree_vacate(vd->vdev_dtl[DTL_SCRUB], NULL, NULL);
2011 range_tree_vacate(vd->vdev_dtl[DTL_OUTAGE], NULL, NULL);
2012 if (!vdev_readable(vd))
2013 range_tree_add(vd->vdev_dtl[DTL_OUTAGE], 0, -1ULL);
2015 range_tree_walk(vd->vdev_dtl[DTL_MISSING],
2016 range_tree_add, vd->vdev_dtl[DTL_OUTAGE]);
2023 if (vd->vdev_resilver_txg != 0 &&
2024 range_tree_space(vd->vdev_dtl[DTL_MISSING]) == 0 &&
2025 range_tree_space(vd->vdev_dtl[DTL_OUTAGE]) == 0) {
2026 vd->vdev_resilver_txg = 0;
2027 vdev_config_dirty(vd->vdev_top);
2030 mutex_exit(&vd->vdev_dtl_lock);
2033 vdev_dirty(vd->vdev_top, VDD_DTL, vd, txg);
2037 mutex_enter(&vd->vdev_dtl_lock);
2045 else if (vd->vdev_nparity != 0)
2046 minref = vd->vdev_nparity + 1; /* RAID-Z */
2048 minref = vd->vdev_children; /* any kind of mirror */
2050 for (int c = 0; c < vd->vdev_children; c++) {
2051 vdev_t *cvd = vd->vdev_child[c];
2056 space_reftree_generate_map(&reftree, vd->vdev_dtl[t], minref);
2059 mutex_exit(&vd->vdev_dtl_lock);
2063 vdev_dtl_load(vdev_t *vd)
2065 spa_t *spa = vd->vdev_spa;
2069 if (vd->vdev_ops->vdev_op_leaf && vd->vdev_dtl_object != 0) {
2070 ASSERT(!vd->vdev_ishole);
2072 error = space_map_open(&vd->vdev_dtl_sm, mos,
2073 vd->vdev_dtl_object, 0, -1ULL, 0, &vd->vdev_dtl_lock);
2076 ASSERT(vd->vdev_dtl_sm != NULL);
2078 mutex_enter(&vd->vdev_dtl_lock);
2084 space_map_update(vd->vdev_dtl_sm);
2086 error = space_map_load(vd->vdev_dtl_sm,
2087 vd->vdev_dtl[DTL_MISSING], SM_ALLOC);
2088 mutex_exit(&vd->vdev_dtl_lock);
2093 for (int c = 0; c < vd->vdev_children; c++) {
2094 error = vdev_dtl_load(vd->vdev_child[c]);
2103 vdev_destroy_unlink_zap(vdev_t *vd, uint64_t zapobj, dmu_tx_t *tx)
2105 spa_t *spa = vd->vdev_spa;
2113 vdev_create_link_zap(vdev_t *vd, dmu_tx_t *tx)
2115 spa_t *spa = vd->vdev_spa;
2127 vdev_construct_zaps(vdev_t *vd, dmu_tx_t *tx)
2129 if (vd->vdev_ops != &vdev_hole_ops &&
2130 vd->vdev_ops != &vdev_missing_ops &&
2131 vd->vdev_ops != &vdev_root_ops &&
2132 !vd->vdev_top->vdev_removing) {
2133 if (vd->vdev_ops->vdev_op_leaf && vd->vdev_leaf_zap == 0) {
2134 vd->vdev_leaf_zap = vdev_create_link_zap(vd, tx);
2136 if (vd == vd->vdev_top && vd->vdev_top_zap == 0) {
2137 vd->vdev_top_zap = vdev_create_link_zap(vd, tx);
2140 for (uint64_t i = 0; i < vd->vdev_children; i++) {
2141 vdev_construct_zaps(vd->vdev_child[i], tx);
2146 vdev_dtl_sync(vdev_t *vd, uint64_t txg)
2148 spa_t *spa = vd->vdev_spa;
2149 range_tree_t *rt = vd->vdev_dtl[DTL_MISSING];
2154 uint64_t object = space_map_object(vd->vdev_dtl_sm);
2156 ASSERT(!vd->vdev_ishole);
2157 ASSERT(vd->vdev_ops->vdev_op_leaf);
2161 if (vd->vdev_detached || vd->vdev_top->vdev_removing) {
2162 mutex_enter(&vd->vdev_dtl_lock);
2163 space_map_free(vd->vdev_dtl_sm, tx);
2164 space_map_close(vd->vdev_dtl_sm);
2165 vd->vdev_dtl_sm = NULL;
2166 mutex_exit(&vd->vdev_dtl_lock);
2173 if (vd->vdev_leaf_zap != 0 && (vd->vdev_detached ||
2174 vd->vdev_top->vdev_islog)) {
2175 vdev_destroy_unlink_zap(vd, vd->vdev_leaf_zap, tx);
2176 vd->vdev_leaf_zap = 0;
2183 if (vd->vdev_dtl_sm == NULL) {
2189 VERIFY0(space_map_open(&vd->vdev_dtl_sm, mos, new_object,
2190 0, -1ULL, 0, &vd->vdev_dtl_lock));
2191 ASSERT(vd->vdev_dtl_sm != NULL);
2201 mutex_enter(&vd->vdev_dtl_lock);
2203 mutex_exit(&vd->vdev_dtl_lock);
2205 space_map_truncate(vd->vdev_dtl_sm, tx);
2206 space_map_write(vd->vdev_dtl_sm, rtsync, SM_ALLOC, tx);
2218 if (object != space_map_object(vd->vdev_dtl_sm)) {
2221 space_map_object(vd->vdev_dtl_sm));
2222 vdev_config_dirty(vd->vdev_top);
2227 mutex_enter(&vd->vdev_dtl_lock);
2228 space_map_update(vd->vdev_dtl_sm);
2229 mutex_exit(&vd->vdev_dtl_lock);
2237 vdev_dtl_required(vdev_t *vd)
2239 spa_t *spa = vd->vdev_spa;
2240 vdev_t *tvd = vd->vdev_top;
2241 uint8_t cant_read = vd->vdev_cant_read;
2246 if (vd == spa->spa_root_vdev || vd == tvd)
2254 vd->vdev_cant_read = B_TRUE;
2257 vd->vdev_cant_read = cant_read;
2261 required = !!zio_handle_device_injection(vd, NULL, ECHILD);
2270 vdev_resilver_needed(vdev_t *vd, uint64_t *minp, uint64_t *maxp)
2276 if (vd->vdev_children == 0) {
2277 mutex_enter(&vd->vdev_dtl_lock);
2278 if (range_tree_space(vd->vdev_dtl[DTL_MISSING]) != 0 &&
2279 vdev_writeable(vd)) {
2281 thismin = vdev_dtl_min(vd);
2282 thismax = vdev_dtl_max(vd);
2285 mutex_exit(&vd->vdev_dtl_lock);
2287 for (int c = 0; c < vd->vdev_children; c++) {
2288 vdev_t *cvd = vd->vdev_child[c];
2307 vdev_load(vdev_t *vd)
2312 for (int c = 0; c < vd->vdev_children; c++)
2313 vdev_load(vd->vdev_child[c]);
2318 if (vd == vd->vdev_top && !vd->vdev_ishole &&
2319 (vd->vdev_ashift == 0 || vd->vdev_asize == 0 ||
2320 vdev_metaslab_init(vd, 0) != 0))
2321 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
2327 if (vd->vdev_ops->vdev_op_leaf && vdev_dtl_load(vd) != 0)
2328 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
2340 vdev_validate_aux(vdev_t *vd)
2346 if (!vdev_readable(vd))
2349 if ((label = vdev_label_read_config(vd, -1ULL)) == NULL) {
2350 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
2358 guid != vd->vdev_guid ||
2360 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
2375 vdev_remove(vdev_t *vd, uint64_t txg)
2377 spa_t *spa = vd->vdev_spa;
2382 ASSERT(vd == vd->vdev_top);
2385 if (vd->vdev_ms != NULL) {
2386 metaslab_group_t *mg = vd->vdev_mg;
2391 for (int m = 0; m < vd->vdev_ms_count; m++) {
2392 metaslab_t *msp = vd->vdev_ms[m];
2421 if (vd->vdev_ms_array) {
2422 (void) dmu_object_free(mos, vd->vdev_ms_array, tx);
2423 vd->vdev_ms_array = 0;
2426 if (vd->vdev_islog && vd->vdev_top_zap != 0) {
2427 vdev_destroy_unlink_zap(vd, vd->vdev_top_zap, tx);
2428 vd->vdev_top_zap = 0;
2434 vdev_sync_done(vdev_t *vd, uint64_t txg)
2437 boolean_t reassess = !txg_list_empty(&vd->vdev_ms_list, TXG_CLEAN(txg));
2439 ASSERT(!vd->vdev_ishole);
2441 while (msp = txg_list_remove(&vd->vdev_ms_list, TXG_CLEAN(txg)))
2445 vd->vdev_mg);
2449 vdev_sync(vdev_t *vd, uint64_t txg)
2451 spa_t *spa = vd->vdev_spa;
2456 ASSERT(!vd->vdev_ishole);
2458 if (vd->vdev_ms_array == 0 && vd->vdev_ms_shift != 0) {
2459 ASSERT(vd == vd->vdev_top);
2461 vd->vdev_ms_array = dmu_object_alloc(spa->spa_meta_objset,
2463 ASSERT(vd->vdev_ms_array != 0);
2464 vdev_config_dirty(vd);
2471 if (vd->vdev_stat.vs_alloc == 0 && vd->vdev_removing)
2472 vdev_remove(vd, txg);
2474 while ((msp = txg_list_remove(&vd->vdev_ms_list, txg)) != NULL) {
2476 (void) txg_list_add(&vd->vdev_ms_list, msp, TXG_CLEAN(txg));
2479 while ((lvd = txg_list_remove(&vd->vdev_dtl_list, txg)) != NULL)
2482 (void) txg_list_add(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg));
2486 vdev_psize_to_asize(vdev_t *vd, uint64_t psize)
2488 return (vd->vdev_ops->vdev_op_asize(vd, psize));
2498 vdev_t *vd, *tvd;
2502 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
2505 if (!vd->vdev_ops->vdev_op_leaf)
2508 tvd = vd->vdev_top;
2515 vd->vdev_label_aux = aux;
2520 vd->vdev_delayed_close = B_FALSE;
2521 vd->vdev_faulted = 1ULL;
2522 vd->vdev_degraded = 0ULL;
2523 vdev_set_state(vd, B_FALSE, VDEV_STATE_FAULTED, aux);
2529 if (!tvd->vdev_islog && vd->vdev_aux == NULL && vdev_dtl_required(vd)) {
2530 vd->vdev_degraded = 1ULL;
2531 vd->vdev_faulted = 0ULL;
2539 if (vdev_readable(vd))
2540 vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, aux);
2543 return (spa_vdev_state_exit(spa, vd, 0));
2554 vdev_t *vd;
2558 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
2561 if (!vd->vdev_ops->vdev_op_leaf)
2567 if (vd->vdev_faulted || vd->vdev_degraded)
2570 vd->vdev_degraded = 1ULL;
2571 if (!vdev_is_dead(vd))
2572 vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED,
2575 return (spa_vdev_state_exit(spa, vd, 0));
2589 vdev_t *vd, *tvd, *pvd, *rvd = spa->spa_root_vdev;
2594 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
2597 if (!vd->vdev_ops->vdev_op_leaf)
2601 (vd->vdev_offline == B_TRUE || vd->vdev_tmpoffline == B_TRUE) ?
2604 tvd = vd->vdev_top;
2605 vd->vdev_offline = B_FALSE;
2606 vd->vdev_tmpoffline = B_FALSE;
2607 vd->vdev_checkremove = !!(flags & ZFS_ONLINE_CHECKREMOVE);
2608 vd->vdev_forcefault = !!(flags & ZFS_ONLINE_FORCEFAULT);
2611 if (!vd->vdev_aux) {
2612 for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
2617 vd->vdev_checkremove = vd->vdev_forcefault = B_FALSE;
2619 if (!vd->vdev_aux) {
2620 for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
2625 *newstate = vd->vdev_state;
2627 !vdev_is_dead(vd) && vd->vdev_parent &&
2628 vd->vdev_parent->vdev_ops == &vdev_spare_ops &&
2629 vd->vdev_parent->vdev_child[0] == vd)
2630 vd->vdev_unspare = B_TRUE;
2635 if (vd->vdev_aux)
2636 return (spa_vdev_state_exit(spa, vd, ENOTSUP));
2641 spa_event_notify(spa, vd, ESC_ZFS_VDEV_ONLINE);
2643 return (spa_vdev_state_exit(spa, vd, 0));
2649 vdev_t *vd, *tvd;
2657 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
2660 if (!vd->vdev_ops->vdev_op_leaf)
2663 tvd = vd->vdev_top;
2670 if (!vd->vdev_offline) {
2676 if (!tvd->vdev_islog && vd->vdev_aux == NULL &&
2677 vdev_dtl_required(vd))
2691 (void) spa_vdev_state_exit(spa, vd, 0);
2704 vd, error));
2705 (void) spa_vdev_state_exit(spa, vd, 0);
2717 vd->vdev_offline = B_TRUE;
2720 if (!tvd->vdev_islog && vd->vdev_aux == NULL &&
2722 vd->vdev_offline = B_FALSE;
2735 vd->vdev_tmpoffline = !!(flags & ZFS_OFFLINE_TEMPORARY);
2737 return (spa_vdev_state_exit(spa, vd, 0));
2755 * children. If 'vd' is NULL, then the user wants to clear all vdevs.
2758 vdev_clear(spa_t *spa, vdev_t *vd)
2764 if (vd == NULL)
2765 vd = rvd;
2767 vd->vdev_stat.vs_read_errors = 0;
2768 vd->vdev_stat.vs_write_errors = 0;
2769 vd->vdev_stat.vs_checksum_errors = 0;
2771 for (int c = 0; c < vd->vdev_children; c++)
2772 vdev_clear(spa, vd->vdev_child[c]);
2774 if (vd == rvd) {
2788 if (vd->vdev_faulted || vd->vdev_degraded ||
2789 !vdev_readable(vd) || !vdev_writeable(vd)) {
2796 vd->vdev_forcefault = B_TRUE;
2798 vd->vdev_faulted = vd->vdev_degraded = 0ULL;
2799 vd->vdev_cant_read = B_FALSE;
2800 vd->vdev_cant_write = B_FALSE;
2802 vdev_reopen(vd == rvd ? rvd : vd->vdev_top);
2804 vd->vdev_forcefault = B_FALSE;
2806 if (vd != rvd && vdev_writeable(vd->vdev_top))
2807 vdev_state_dirty(vd->vdev_top);
2809 if (vd->vdev_aux == NULL && !vdev_is_dead(vd))
2812 spa_event_notify(spa, vd, ESC_ZFS_VDEV_CLEAR);
2820 if (!vdev_is_dead(vd) && vd->vdev_parent != NULL &&
2821 vd->vdev_parent->vdev_ops == &vdev_spare_ops &&
2822 vd->vdev_parent->vdev_child[0] == vd)
2823 vd->vdev_unspare = B_TRUE;
2827 vdev_is_dead(vdev_t *vd)
2836 return (vd->vdev_state < VDEV_STATE_DEGRADED || vd->vdev_ishole ||
2837 vd->vdev_ops == &vdev_missing_ops);
2841 vdev_readable(vdev_t *vd)
2843 return (!vdev_is_dead(vd) && !vd->vdev_cant_read);
2847 vdev_writeable(vdev_t *vd)
2849 return (!vdev_is_dead(vd) && !vd->vdev_cant_write);
2853 vdev_allocatable(vdev_t *vd)
2855 uint64_t state = vd->vdev_state;
2866 !vd->vdev_cant_write && !vd->vdev_ishole &&
2867 vd->vdev_mg->mg_initialized);
2871 vdev_accessible(vdev_t *vd, zio_t *zio)
2873 ASSERT(zio->io_vd == vd);
2875 if (vdev_is_dead(vd) || vd->vdev_remove_wanted)
2879 return (!vd->vdev_cant_read);
2882 return (!vd->vdev_cant_write);
2891 vdev_get_stats(vdev_t *vd, vdev_stat_t *vs)
2893 spa_t *spa = vd->vdev_spa;
2895 vdev_t *tvd = vd->vdev_top;
2899 mutex_enter(&vd->vdev_stat_lock);
2900 bcopy(&vd->vdev_stat, vs, sizeof (*vs));
2902 vs->vs_state = vd->vdev_state;
2903 vs->vs_rsize = vdev_get_min_asize(vd);
2904 if (vd->vdev_ops->vdev_op_leaf)
2911 if (vd->vdev_aux == NULL && tvd != NULL && vd->vdev_max_asize != 0) {
2912 vs->vs_esize = P2ALIGN(vd->vdev_max_asize - vd->vdev_asize,
2915 vs->vs_configured_ashift = vd->vdev_top != NULL
2916 ? vd->vdev_top->vdev_ashift : vd->vdev_ashift;
2917 vs->vs_logical_ashift = vd->vdev_logical_ashift;
2918 vs->vs_physical_ashift = vd->vdev_physical_ashift;
2919 if (vd->vdev_aux == NULL && vd == vd->vdev_top && !vd->vdev_ishole) {
2920 vs->vs_fragmentation = vd->vdev_mg->mg_fragmentation;
2927 if (vd == rvd) {
2939 mutex_exit(&vd->vdev_stat_lock);
2943 vdev_clear_stats(vdev_t *vd)
2945 mutex_enter(&vd->vdev_stat_lock);
2946 vd->vdev_stat.vs_space = 0;
2947 vd->vdev_stat.vs_dspace = 0;
2948 vd->vdev_stat.vs_alloc = 0;
2949 mutex_exit(&vd->vdev_stat_lock);
2953 vdev_scan_stat_init(vdev_t *vd)
2955 vdev_stat_t *vs = &vd->vdev_stat;
2957 for (int c = 0; c < vd->vdev_children; c++)
2958 vdev_scan_stat_init(vd->vdev_child[c]);
2960 mutex_enter(&vd->vdev_stat_lock);
2962 mutex_exit(&vd->vdev_stat_lock);
2970 vdev_t *vd = zio->io_vd ? zio->io_vd : rvd;
2973 vdev_stat_t *vs = &vd->vdev_stat;
2998 if (vd == rvd)
3001 ASSERT(vd == zio->io_vd);
3006 mutex_enter(&vd->vdev_stat_lock);
3015 if (vd->vdev_ops->vdev_op_leaf)
3027 mutex_exit(&vd->vdev_stat_lock);
3052 mutex_enter(&vd
3053 if (type == ZIO_TYPE_READ && !vdev_is_dead(vd)) {
3059 if (type == ZIO_TYPE_WRITE && !vdev_is_dead(vd))
3061 mutex_exit(&vd->vdev_stat_lock);
3082 if (vd->vdev_ops->vdev_op_leaf) {
3087 vdev_dtl_dirty(vd, DTL_SCRUB, txg, 1);
3094 if (vdev_dtl_contains(vd, DTL_MISSING, txg, 1))
3096 for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
3098 vdev_dirty(vd->vdev_top, VDD_DTL, vd, commit_txg);
3100 if (vd != rvd)
3101 vdev_dtl_dirty(vd, DTL_MISSING, txg, 1);
3110 vdev_space_update(vdev_t *vd, int64_t alloc_delta, int64_t defer_delta,
3114 spa_t *spa = vd->vdev_spa;
3116 metaslab_group_t *mg = vd->vdev_mg;
3119 ASSERT(vd == vd->vdev_top);
3128 ASSERT(vd->vdev_deflate_ratio != 0 || vd->vdev_isl2cache);
3130 vd->vdev_deflate_ratio;
3132 mutex_enter(&vd->vdev_stat_lock);
3133 vd->vdev_stat.vs_alloc += alloc_delta;
3134 vd->vdev_stat.vs_space += space_delta;
3135 vd->vdev_stat.vs_dspace += dspace_delta;
3136 mutex_exit(&vd->vdev_stat_lock);
3147 ASSERT(rvd == vd->vdev_parent);
3148 ASSERT(vd->vdev_ms_count != 0);
3161 vdev_config_dirty(vdev_t *vd)
3163 spa_t *spa = vd->vdev_spa;
3173 if (vd->vdev_aux != NULL) {
3174 spa_aux_vdev_t *sav = vd->vdev_aux;
3179 if (sav->sav_vdevs[c] == vd)
3206 aux[c] = vdev_config_generate(spa, vd, B_TRUE, 0);
3221 if (vd == rvd) {
3225 ASSERT(vd == vd->vdev_top);
3227 if (!list_link_active(&vd->vdev_config_dirty_node) &&
3228 !vd->vdev_ishole)
3229 list_insert_head(&spa->spa_config_dirty_list, vd);
3234 vdev_config_clean(vdev_t *vd)
3236 spa_t *spa = vd->vdev_spa;
3242 ASSERT(list_link_active(&vd->vdev_config_dirty_node));
3243 list_remove(&spa->spa_config_dirty_list, vd);
3253 vdev_state_dirty(vdev_t *vd)
3255 spa_t *spa = vd->vdev_spa;
3258 ASSERT(vd == vd->vdev_top);
3270 if (!list_link_active(&vd->vdev_state_dirty_node) && !vd->vdev_ishole)
3271 list_insert_head(&spa->spa_state_dirty_list, vd);
3275 vdev_state_clean(vdev_t *vd)
3277 spa_t *spa = vd->vdev_spa;
3283 ASSERT(list_link_active(&vd->vdev_state_dirty_node));
3284 list_remove(&spa->spa_state_dirty_list, vd);
3291 vdev_propagate_state(vdev_t *vd)
3293 spa_t *spa = vd->vdev_spa;
3299 if (vd->vdev_children > 0) {
3300 for (int c = 0; c < vd->vdev_children; c++) {
3301 child = vd->vdev_child[c];
3316 if (child->vdev_islog && vd == rvd)
3328 vd->vdev_ops->vdev_op_state_change(vd, faulted, degraded);
3336 if (corrupted && vd == rvd &&
3342 if (vd->vdev_parent)
3343 vdev_propagate_state(vd->vdev_parent);
3355 vdev_set_state(vdev_t *vd, boolean_t isopen, vdev_state_t state, vdev_aux_t aux)
3358 spa_t *spa = vd->vdev_spa;
3360 if (state == vd->vdev_state) {
3361 vd->vdev_stat.vs_aux = aux;
3365 save_state = vd->vdev_state;
3367 vd->vdev_state = state;
3368 vd->vdev_stat.vs_aux = aux;
3380 if (!vd->vdev_delayed_close && vdev_is_dead(vd) &&
3381 vd->vdev_ops->vdev_op_leaf)
3382 vd->vdev_ops->vdev_op_close(vd);
3384 if (vd->vdev_removed &&
3386 (aux == VDEV_AUX_OPEN_FAILED || vd->vdev_checkremove)) {
3396 vd->vdev_state = VDEV_STATE_REMOVED;
3397 vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
3399 vd->vdev_removed = B_TRUE;
3409 vd->vdev_ops->vdev_op_leaf)
3410 vd->vdev_not_present = 1;
3427 if ((vd->vdev_prevstate != state || vd->vdev_forcefault) &&
3428 !vd->vdev_not_present && !vd->vdev_checkremove &&
3429 vd != spa->spa_root_vdev) {
3455 zfs_ereport_post(class, spa, vd, NULL, save_state, 0);
3459 vd->vdev_removed = B_FALSE;
3461 vd->vdev_removed = B_FALSE;
3471 if (vd->vdev_ops->vdev_op_leaf)
3472 zfs_post_state_change(spa, vd);
3474 if (!isopen && vd->vdev_parent)
3475 vdev_propagate_state(vd->vdev_parent);
3486 vdev_is_bootable(vdev_t *vd)
3489 if (!vd->vdev_ops->vdev_op_leaf) {
3490 char *vdev_type = vd->vdev_ops->vdev_op_type;
3493 vd->vdev_children > 1) {
3500 for (int c = 0; c < vd->vdev_children; c++) {
3501 if (!vdev_is_bootable(vd->vdev_child[c]))
3543 vdev_log_state_valid(vdev_t *vd)
3545 if (vd->vdev_ops->vdev_op_leaf && !vd->vdev_faulted &&
3546 !vd->vdev_removed)
3549 for (int c = 0; c < vd->vdev_children; c++)
3550 if (vdev_log_state_valid(vd->vdev_child[c]))
3560 vdev_expand(vdev_t *vd, uint64_t txg)
3562 ASSERT(vd->vdev_top == vd);
3563 ASSERT(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);
3565 if ((vd->vdev_asize >> vd->vdev_ms_shift) > vd->vdev_ms_count) {
3566 VERIFY(vdev_metaslab_init(vd, txg) == 0);
3567 vdev_config_dirty(vd);
3575 vdev_split(vdev_t *vd)
3577 vdev_t *cvd, *pvd = vd->vdev_parent;
3579 vdev_remove_child(pvd, vd);
3591 vdev_deadman(vdev_t *vd)
3593 for (int c = 0; c < vd->vdev_children; c++) {
3594 vdev_t *cvd = vd->vdev_child[c];
3599 if (vd->vdev_ops->vdev_op_leaf) {
3600 vdev_queue_t *vq = &vd->vdev_queue;
3604 spa_t *spa = vd->vdev_spa;
3629 (long long unsigned int) vd->vdev_guid,
3630 vd->vdev_path);
Indexes created Tue Aug 04 00:24:20 UTC 2026