Lines Matching defs:msp
711 metaslab_t *msp = vd->vdev_ms[m];
713 if (msp->ms_sm == NULL)
718 msp->ms_sm->sm_phys->smp_histogram[i];
728 metaslab_group_histogram_add(metaslab_group_t *mg, metaslab_t *msp)
733 ASSERT(MUTEX_HELD(&msp->ms_lock));
734 if (msp->ms_sm == NULL)
740 msp->ms_sm->sm_phys->smp_histogram[i];
742 msp->ms_sm->sm_phys->smp_histogram[i];
748 metaslab_group_histogram_remove(metaslab_group_t *mg, metaslab_t *msp)
753 ASSERT(MUTEX_HELD(&msp->ms_lock));
754 if (msp->ms_sm == NULL)
760 msp->ms_sm->sm_phys->smp_histogram[i]);
762 msp->ms_sm->sm_phys->smp_histogram[i]);
765 msp->ms_sm->sm_phys->smp_histogram[i];
767 msp->ms_sm->sm_phys->smp_histogram[i];
773 metaslab_group_add(metaslab_group_t *mg, metaslab_t *msp)
775 ASSERT(msp->ms_group == NULL);
777 msp->ms_group = mg;
778 msp->ms_weight = 0;
779 avl_add(&mg->mg_metaslab_tree, msp);
782 mutex_enter(&msp->ms_lock);
783 metaslab_group_histogram_add(mg, msp);
784 mutex_exit(&msp->ms_lock);
788 metaslab_group_remove(metaslab_group_t *mg, metaslab_t *msp)
790 mutex_enter(&msp->ms_lock);
791 metaslab_group_histogram_remove(mg, msp);
792 mutex_exit(&msp->ms_lock);
795 ASSERT(msp->ms_group == mg);
796 avl_remove(&mg->mg_metaslab_tree, msp);
797 msp->ms_group = NULL;
802 metaslab_group_sort(metaslab_group_t *mg, metaslab_t *msp, uint64_t weight)
809 ASSERT(MUTEX_HELD(&msp->ms_lock));
812 ASSERT(msp->ms_group == mg);
813 avl_remove(&mg->mg_metaslab_tree, msp);
814 msp->ms_weight = weight;
815 avl_add(&mg->mg_metaslab_tree, msp);
834 metaslab_t *msp = vd->vdev_ms[m];
836 if (msp->ms_fragmentation == ZFS_FRAG_INVALID)
840 fragmentation += msp->ms_fragmentation;
921 metaslab_t *msp = arg;
923 ASSERT3P(rt->rt_arg, ==, msp);
924 ASSERT(msp->ms_tree == NULL);
926 avl_create(&msp->ms_size_tree, metaslab_rangesize_compare,
936 metaslab_t *msp = arg;
938 ASSERT3P(rt->rt_arg, ==, msp);
939 ASSERT3P(msp->ms_tree, ==, rt);
940 ASSERT0(avl_numnodes(&msp->ms_size_tree));
942 avl_destroy(&msp->ms_size_tree);
948 metaslab_t *msp = arg;
950 ASSERT3P(rt->rt_arg, ==, msp);
951 ASSERT3P(msp->ms_tree, ==, rt);
952 VERIFY(!msp->ms_condensing);
953 avl_add(&msp->ms_size_tree, rs);
959 metaslab_t *msp = arg;
961 ASSERT3P(rt->rt_arg, ==, msp);
962 ASSERT3P(msp->ms_tree, ==, rt);
963 VERIFY(!msp->ms_condensing);
964 avl_remove(&msp->ms_size_tree, rs);
970 metaslab_t *msp = arg;
972 ASSERT3P(rt->rt_arg, ==, msp);
973 ASSERT3P(msp->ms_tree, ==, rt);
981 avl_create(&msp->ms_size_tree, metaslab_rangesize_compare,
1003 metaslab_block_maxsize(metaslab_t *msp)
1005 avl_tree_t *t = &msp->ms_size_tree;
1015 metaslab_block_alloc(metaslab_t *msp, uint64_t size)
1018 range_tree_t *rt = msp->ms_tree;
1020 VERIFY(!msp->ms_condensing);
1022 start = msp->ms_ops->msop_alloc(msp, size);
1024 vdev_t *vd = msp->ms_group->mg_vd;
1028 VERIFY3U(range_tree_space(rt) - size, <=, msp->ms_size);
1086 metaslab_ff_alloc(metaslab_t *msp, uint64_t size)
1096 uint64_t *cursor = &msp->ms_lbas[highbit64(align) - 1];
1097 avl_tree_t *t = &msp->ms_tree->rt_root;
1115 metaslab_df_alloc(metaslab_t *msp, uint64_t size)
1125 uint64_t *cursor = &msp->ms_lbas[highbit64(align) - 1];
1126 range_tree_t *rt = msp->ms_tree;
1128 uint64_t max_size = metaslab_block_maxsize(msp);
1129 int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
1131 ASSERT(MUTEX_HELD(&msp->ms_lock));
1132 ASSERT3U(avl_numnodes(t), ==, avl_numnodes(&msp->ms_size_tree));
1143 t = &msp->ms_size_tree;
1164 metaslab_cf_alloc(metaslab_t *msp, uint64_t size)
1166 range_tree_t *rt = msp->ms_tree;
1167 avl_tree_t *t = &msp->ms_size_tree;
1168 uint64_t *cursor = &msp->ms_lbas[0];
1169 uint64_t *cursor_end = &msp->ms_lbas[1];
1172 ASSERT(MUTEX_HELD(&msp->ms_lock));
1180 rs = avl_last(&msp->ms_size_tree);
1214 metaslab_ndf_alloc(metaslab_t *msp, uint64_t size)
1216 avl_tree_t *t = &msp->ms_tree->rt_root;
1220 uint64_t *cursor = &msp->ms_lbas[hbit - 1];
1221 uint64_t max_size = metaslab_block_maxsize(msp);
1223 ASSERT(MUTEX_HELD(&msp->ms_lock));
1224 ASSERT3U(avl_numnodes(t), ==, avl_numnodes(&msp->ms_size_tree));
1234 t = &msp->ms_size_tree;
1268 metaslab_load_wait(metaslab_t *msp)
1270 ASSERT(MUTEX_HELD(&msp->ms_lock));
1272 while (msp->ms_loading) {
1273 ASSERT(!msp->ms_loaded);
1274 cv_wait(&msp->ms_load_cv, &msp->ms_lock);
1279 metaslab_load(metaslab_t *msp)
1283 ASSERT(MUTEX_HELD(&msp->ms_lock));
1284 ASSERT(!msp->ms_loaded);
1285 ASSERT(!msp->ms_loading);
1287 msp->ms_loading = B_TRUE;
1294 if (msp->ms_sm != NULL)
1295 error = space_map_load(msp->ms_sm, msp->ms_tree, SM_FREE);
1297 range_tree_add(msp->ms_tree, msp->ms_start, msp->ms_size);
1299 msp->ms_loaded = (error == 0);
1300 msp->ms_loading = B_FALSE;
1302 if (msp->ms_loaded) {
1304 range_tree_walk(msp->ms_defertree[t],
1305 range_tree_remove, msp->ms_tree);
1308 cv_broadcast(&msp->ms_load_cv);
1313 metaslab_unload(metaslab_t *msp)
1315 ASSERT(MUTEX_HELD(&msp->ms_lock));
1316 range_tree_vacate(msp->ms_tree, NULL, NULL);
1317 msp->ms_loaded = B_FALSE;
1318 msp->ms_weight &= ~METASLAB_ACTIVE_MASK;
1323 metaslab_t **msp)
1391 *msp = ms;
1397 metaslab_fini(metaslab_t *msp)
1399 metaslab_group_t *mg = msp->ms_group;
1401 metaslab_group_remove(mg, msp);
1403 mutex_enter(&msp->ms_lock);
1405 VERIFY(msp->ms_group == NULL);
1406 vdev_space_update(mg->mg_vd, -space_map_allocated(msp->ms_sm),
1407 0, -msp->ms_size);
1408 space_map_close(msp->ms_sm);
1410 metaslab_unload(msp);
1411 range_tree_destroy(msp->ms_tree);
1414 range_tree_destroy(msp->ms_alloctree[t]);
1415 range_tree_destroy(msp->ms_freetree[t]);
1419 range_tree_destroy(msp->ms_defertree[t]);
1422 ASSERT0(msp->ms_deferspace);
1424 mutex_exit(&msp->ms_lock);
1425 cv_destroy(&msp->ms_load_cv);
1426 mutex_destroy(&msp->ms_lock);
1428 kmem_free(msp, sizeof (metaslab_t));
1478 metaslab_fragmentation(metaslab_t *msp)
1480 spa_t *spa = msp->ms_group->mg_vd->vdev_spa;
1493 if (msp->ms_sm == NULL)
1500 if (msp->ms_sm->sm_dbuf->db_size != sizeof (space_map_phys_t)) {
1502 vdev_t *vd = msp->ms_group->mg_vd;
1505 msp->ms_condense_wanted = B_TRUE;
1506 vdev_dirty(vd, VDD_METASLAB, msp, txg + 1);
1508 "msp %p, vd %p", txg, msp, vd);
1515 uint8_t shift = msp->ms_sm->sm_shift;
1519 if (msp->ms_sm->sm_phys->smp_histogram[i] == 0)
1522 space = msp->ms_sm->sm_phys->smp_histogram[i] << (i + shift);
1541 metaslab_weight(metaslab_t *msp)
1543 metaslab_group_t *mg = msp->ms_group;
1547 ASSERT(MUTEX_HELD(&msp->ms_lock));
1554 ASSERT0(space_map_allocated(msp->ms_sm));
1562 space = msp->ms_size - space_map_allocated(msp->ms_sm);
1564 msp->ms_fragmentation = metaslab_fragmentation(msp);
1566 msp->ms_fragmentation != ZFS_FRAG_INVALID) {
1574 space = (space * (100 - (msp->ms_fragmentation - 1))) / 100;
1598 weight = 2 * weight - (msp->ms_id * weight) / vd->vdev_ms_count;
1608 if (msp->ms_loaded && msp->ms_fragmentation != ZFS_FRAG_INVALID &&
1609 msp->ms_fragmentation <= zfs_metaslab_fragmentation_threshold) {
1610 weight |= (msp->ms_weight & METASLAB_ACTIVE_MASK);
1617 metaslab_activate(metaslab_t *msp, uint64_t activation_weight)
1619 ASSERT(MUTEX_HELD(&msp->ms_lock));
1621 if ((msp->ms_weight & METASLAB_ACTIVE_MASK) == 0) {
1622 metaslab_load_wait(msp);
1623 if (!msp->ms_loaded) {
1624 int error = metaslab_load(msp);
1626 metaslab_group_sort(msp->ms_group, msp, 0);
1631 metaslab_group_sort(msp->ms_group, msp,
1632 msp->ms_weight | activation_weight);
1634 ASSERT(msp->ms_loaded);
1635 ASSERT(msp->ms_weight & METASLAB_ACTIVE_MASK);
1641 metaslab_passivate(metaslab_t *msp, uint64_t size)
1648 ASSERT(size >= SPA_MINBLOCKSIZE || range_tree_space(msp->ms_tree) == 0);
1649 metaslab_group_sort(msp->ms_group, msp, MIN(msp->ms_weight, size));
1650 ASSERT((msp->ms_weight & METASLAB_ACTIVE_MASK) == 0);
1656 metaslab_t *msp = arg;
1657 spa_t *spa = msp->ms_group->mg_vd->vdev_spa;
1659 ASSERT(!MUTEX_HELD(&msp->ms_group->mg_lock));
1661 mutex_enter(&msp->ms_lock);
1662 metaslab_load_wait(msp);
1663 if (!msp->ms_loaded)
1664 (void) metaslab_load(msp);
1669 msp->ms_access_txg = spa_syncing_txg(spa) + metaslab_unload_delay + 1;
1670 mutex_exit(&msp->ms_lock);
1677 metaslab_t *msp;
1690 msp = avl_first(t);
1691 while (msp != NULL) {
1692 metaslab_t *msp_next = AVL_NEXT(t, msp);
1700 if (++m > metaslab_preload_limit && !msp->ms_condense_wanted) {
1701 msp = msp_next;
1719 msp, TQ_SLEEP) != 0);
1721 msp = msp_next;
1758 metaslab_should_condense(metaslab_t *msp)
1760 space_map_t *sm = msp->ms_sm;
1764 uint64_t vdev_blocksize = 1 << msp->ms_group->mg_vd->vdev_ashift;
1766 ASSERT(MUTEX_HELD(&msp->ms_lock));
1767 ASSERT(msp->ms_loaded);
1775 rs = avl_last(&msp->ms_size_tree);
1776 if (rs == NULL || msp->ms_condense_wanted)
1789 optimal_size = sizeof (uint64_t) * avl_numnodes(&msp->ms_tree->rt_root);
1790 object_size = space_map_length(msp->ms_sm);
1806 metaslab_condense(metaslab_t *msp, uint64_t txg, dmu_tx_t *tx)
1808 spa_t *spa = msp->ms_group->mg_vd->vdev_spa;
1809 range_tree_t *freetree = msp->ms_freetree[txg & TXG_MASK];
1811 space_map_t *sm = msp->ms_sm;
1813 ASSERT(MUTEX_HELD(&msp->ms_lock));
1815 ASSERT(msp->ms_loaded);
1818 spa_dbgmsg(spa, "condensing: txg %llu, msp[%llu] %p, "
1820 msp->ms_id, msp, space_map_length(msp->ms_sm),
1821 avl_numnodes(&msp->ms_tree->rt_root),
1822 msp->ms_condense_wanted ? "TRUE" : "FALSE");
1824 msp->ms_condense_wanted = B_FALSE;
1833 condense_tree = range_tree_create(NULL, NULL, &msp->ms_lock);
1834 range_tree_add(condense_tree, msp->ms_start, msp->ms_size);
1844 range_tree_walk(msp->ms_defertree[t],
1849 range_tree_walk(msp->ms_alloctree[(txg + t) & TXG_MASK],
1862 msp->ms_condensing = B_TRUE;
1864 mutex_exit(&msp->ms_lock);
1866 mutex_enter(&msp->ms_lock);
1882 space_map_write(sm, msp->ms_tree, SM_FREE, tx);
1883 msp->ms_condensing = B_FALSE;
1890 metaslab_sync(metaslab_t *msp, uint64_t txg)
1892 metaslab_group_t *mg = msp->ms_group;
1896 range_tree_t *alloctree = msp->ms_alloctree[txg & TXG_MASK];
1897 range_tree_t **freetree = &msp->ms_freetree[txg & TXG_MASK];
1899 &msp->ms_freetree[TXG_CLEAN(txg) & TXG_MASK];
1901 uint64_t object = space_map_object(msp->ms_sm);
1924 !msp->ms_condense_wanted)
1939 if (msp->ms_sm == NULL) {
1945 VERIFY0(space_map_open(&msp->ms_sm, mos, new_object,
1946 msp->ms_start, msp->ms_size, vd->vdev_ashift,
1947 &msp->ms_lock));
1948 ASSERT(msp->ms_sm != NULL);
1951 mutex_enter(&msp->ms_lock);
1960 metaslab_group_histogram_remove(mg, msp);
1962 if (msp->ms_loaded && spa_sync_pass(spa) == 1 &&
1963 metaslab_should_condense(msp)) {
1964 metaslab_condense(msp, txg, tx);
1966 space_map_write(msp->ms_sm, alloctree, SM_ALLOC, tx);
1967 space_map_write(msp->ms_sm, *freetree, SM_FREE, tx);
1970 if (msp->ms_loaded) {
1977 space_map_histogram_clear(msp->ms_sm);
1978 space_map_histogram_add(msp->ms_sm, msp->ms_tree, tx);
1987 space_map_histogram_add(msp->ms_sm, *freetree, tx);
1989 metaslab_group_histogram_add(mg, msp);
2006 ASSERT0(range_tree_space(msp->ms_alloctree[txg & TXG_MASK]));
2007 ASSERT0(range_tree_space(msp->ms_freetree[txg & TXG_MASK]));
2009 mutex_exit(&msp->ms_lock);
2011 if (object != space_map_object(msp->ms_sm)) {
2012 object = space_map_object(msp->ms_sm);
2014 msp->ms_id, sizeof (uint64_t), &object, tx);
2024 metaslab_sync_done(metaslab_t *msp, uint64_t txg)
2026 metaslab_group_t *mg = msp->ms_group;
2034 mutex_enter(&msp->ms_lock);
2041 if (msp->ms_freetree[TXG_CLEAN(txg) & TXG_MASK] == NULL) {
2043 ASSERT(msp->ms_alloctree[t] == NULL);
2044 ASSERT(msp->ms_freetree[t] == NULL);
2046 msp->ms_alloctree[t] = range_tree_create(NULL, msp,
2047 &msp->ms_lock);
2048 msp->ms_freetree[t] = range_tree_create(NULL, msp,
2049 &msp->ms_lock);
2053 ASSERT(msp->ms_defertree[t] == NULL);
2055 msp->ms_defertree[t] = range_tree_create(NULL, msp,
2056 &msp->ms_lock);
2059 vdev_space_update(vd, 0, 0, msp->ms_size);
2062 freed_tree = &msp->ms_freetree[TXG_CLEAN(txg) & TXG_MASK];
2063 defer_tree = &msp->ms_defertree[txg % TXG_DEFER_SIZE];
2065 alloc_delta = space_map_alloc_delta(msp->ms_sm);
2071 ASSERT0(range_tree_space(msp->ms_alloctree[txg & TXG_MASK]));
2072 ASSERT0(range_tree_space(msp->ms_freetree[txg & TXG_MASK]));
2078 metaslab_load_wait(msp);
2087 msp->ms_loaded ? range_tree_add : NULL, msp->ms_tree);
2090 space_map_update(msp->ms_sm);
2092 msp->ms_deferspace += defer_delta;
2093 ASSERT3S(msp->ms_deferspace, >=, 0);
2094 ASSERT3S(msp->ms_deferspace, <=, msp->ms_size);
2095 if (msp->ms_deferspace != 0) {
2100 vdev_dirty(vd, VDD_METASLAB, msp, txg + 1);
2103 if (msp->ms_loaded && msp->ms_access_txg < txg) {
2106 msp->ms_alloctree[(txg + t) & TXG_MASK]));
2110 metaslab_unload(msp);
2113 metaslab_group_sort(mg, msp, metaslab_weight(msp));
2114 mutex_exit(&msp->ms_lock);
2130 metaslab_distance(metaslab_t *msp, dva_t *dva)
2132 uint64_t ms_shift = msp->ms_group->mg_vd->vdev_ms_shift;
2134 uint64_t start = msp->ms_id;
2136 if (msp->ms_group->mg_vd->vdev_id != DVA_GET_VDEV(dva))
2151 metaslab_t *msp = NULL;
2170 for (msp = avl_first(t); msp; msp = AVL_NEXT(t, msp)) {
2171 if (msp->ms_weight < asize) {
2174 "msp %p, psize %llu, asize %llu, "
2177 mg, msp, psize, asize, msp->ms_weight);
2185 if (msp->ms_condensing)
2188 was_active = msp->ms_weight & METASLAB_ACTIVE_MASK;
2193 (space_map_allocated(msp->ms_sm) != 0 ? 0 :
2197 if (metaslab_distance(msp, &dva[i]) <
2204 if (msp == NULL)
2207 mutex_enter(&msp->ms_lock);
2215 if (msp->ms_weight < asize || (was_active &&
2216 !(msp->ms_weight & METASLAB_ACTIVE_MASK) &&
2218 mutex_exit(&msp->ms_lock);
2222 if ((msp->ms_weight & METASLAB_WEIGHT_SECONDARY) &&
2224 metaslab_passivate(msp,
2225 msp->ms_weight & ~METASLAB_ACTIVE_MASK);
2226 mutex_exit(&msp->ms_lock);
2230 if (metaslab_activate(msp, activation_weight) != 0) {
2231 mutex_exit(&msp->ms_lock);
2240 if (msp->ms_condensing) {
2241 mutex_exit(&msp->ms_lock);
2245 if ((offset = metaslab_block_alloc(msp, asize)) != -1ULL)
2248 metaslab_passivate(msp, metaslab_block_maxsize(msp));
2249 mutex_exit(&msp->ms_lock);
2252 if (range_tree_space(msp->ms_alloctree[txg & TXG_MASK]) == 0)
2253 vdev_dirty(mg->mg_vd, VDD_METASLAB, msp, txg);
2255 range_tree_add(msp->ms_alloctree[txg & TXG_MASK], offset, asize);
2256 msp->ms_access_txg = txg + metaslab_unload_delay;
2258 mutex_exit(&msp->ms_lock);
2480 metaslab_t *msp;
2495 msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
2500 mutex_enter(&msp->ms_lock);
2503 range_tree_remove(msp->ms_alloctree[txg & TXG_MASK],
2506 VERIFY(!msp->ms_condensing);
2507 VERIFY3U(offset, >=, msp->ms_start);
2508 VERIFY3U(offset + size, <=, msp->ms_start + msp->ms_size);
2509 VERIFY3U(range_tree_space(msp->ms_tree) + size, <=,
2510 msp->ms_size);
2513 range_tree_add(msp->ms_tree, offset, size);
2515 if (range_tree_space(msp->ms_freetree[txg & TXG_MASK]) == 0)
2516 vdev_dirty(vd, VDD_METASLAB, msp, txg);
2517 range_tree_add(msp->ms_freetree[txg & TXG_MASK],
2521 mutex_exit(&msp->ms_lock);
2537 metaslab_t *msp;
2546 msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
2551 mutex_enter(&msp->ms_lock);
2553 if ((txg != 0 && spa_writeable(spa)) || !msp->ms_loaded)
2554 error = metaslab_activate(msp, METASLAB_WEIGHT_SECONDARY);
2556 if (error == 0 && !range_tree_contains(msp->ms_tree, offset, size))
2560 mutex_exit(&msp->ms_lock);
2564 VERIFY(!msp->ms_condensing);
2567 VERIFY3U(range_tree_space(msp->ms_tree) - size, <=, msp->ms_size);
2568 range_tree_remove(msp->ms_tree, offset, size);
2571 if (range_tree_space(msp->ms_alloctree[txg & TXG_MASK]) == 0)
2572 vdev_dirty(vd, VDD_METASLAB, msp, txg);
2573 range_tree_add(msp->ms_alloctree[txg & TXG_MASK], offset, size);
2576 mutex_exit(&msp->ms_lock);
2685 metaslab_t *msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
2687 if (msp->ms_loaded)
2688 range_tree_verify(msp->ms_tree, offset, size);
2691 range_tree_verify(msp->ms_freetree[j], offset, size);
2693 range_tree_verify(msp->ms_defertree[j], offset, size);