Print this page
4101 metaslab_debug should allow for fine-grained control
4102 space_maps should store more information about themselves
4103 space map object blocksize should be increased
4104 ::spa_space no longer works
4105 removing a mirrored log device results in a leaked object
4106 asynchronously load metaslab
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Adam Leventhal <ahl@delphix.com>
Reviewed by: Sebastien Roy <seb@delphix.com>
*** 29,38 ****
--- 29,39 ----
#include <sys/dmu_tx.h>
#include <sys/space_map.h>
#include <sys/metaslab_impl.h>
#include <sys/vdev_impl.h>
#include <sys/zio.h>
+ #include <sys/spa_impl.h>
/*
* Allow allocations to switch to gang blocks quickly. We do this to
* avoid having to load lots of space_maps in a given txg. There are,
* however, some cases where we want to avoid "fast" ganging and instead
*** 42,51 ****
--- 43,57 ----
*/
#define CAN_FASTGANG(flags) \
(!((flags) & (METASLAB_GANG_CHILD | METASLAB_GANG_HEADER | \
METASLAB_GANG_AVOID)))
+ #define METASLAB_WEIGHT_PRIMARY (1ULL << 63)
+ #define METASLAB_WEIGHT_SECONDARY (1ULL << 62)
+ #define METASLAB_ACTIVE_MASK \
+ (METASLAB_WEIGHT_PRIMARY | METASLAB_WEIGHT_SECONDARY)
+
uint64_t metaslab_aliquot = 512ULL << 10;
uint64_t metaslab_gang_bang = SPA_MAXBLOCKSIZE + 1; /* force gang blocks */
/*
* The in-core space map representation is more compact than its on-disk form.
*** 77,91 ****
* no metaslab group will be excluded based on this criterion.
*/
int zfs_mg_noalloc_threshold = 0;
/*
! * Metaslab debugging: when set, keeps all space maps in core to verify frees.
*/
! static int metaslab_debug = 0;
/*
* Minimum size which forces the dynamic allocator to change
* it's allocation strategy. Once the space map cannot satisfy
* an allocation of this size then it switches to using more
* aggressive strategy (i.e search by size rather than offset).
*/
--- 83,102 ----
* no metaslab group will be excluded based on this criterion.
*/
int zfs_mg_noalloc_threshold = 0;
/*
! * When set will load all metaslabs when pool is first opened.
*/
! int metaslab_debug_load = 0;
/*
+ * When set will prevent metaslabs from being unloaded.
+ */
+ int metaslab_debug_unload = 0;
+
+ /*
* Minimum size which forces the dynamic allocator to change
* it's allocation strategy. Once the space map cannot satisfy
* an allocation of this size then it switches to using more
* aggressive strategy (i.e search by size rather than offset).
*/
*** 104,134 ****
* segment which is greater than metaslab_min_alloc_size.
*/
uint64_t metaslab_min_alloc_size = DMU_MAX_ACCESS;
/*
! * Max number of space_maps to prefetch.
*/
! int metaslab_prefetch_limit = SPA_DVAS_PER_BP;
/*
! * Percentage bonus multiplier for metaslabs that are in the bonus area.
*/
! int metaslab_smo_bonus_pct = 150;
/*
* Should we be willing to write data to degraded vdevs?
*/
boolean_t zfs_write_to_degraded = B_FALSE;
/*
* ==========================================================================
* Metaslab classes
* ==========================================================================
*/
metaslab_class_t *
! metaslab_class_create(spa_t *spa, space_map_ops_t *ops)
{
metaslab_class_t *mc;
mc = kmem_zalloc(sizeof (metaslab_class_t), KM_SLEEP);
--- 115,163 ----
* segment which is greater than metaslab_min_alloc_size.
*/
uint64_t metaslab_min_alloc_size = DMU_MAX_ACCESS;
/*
! * Percentage of all cpus that can be used by the metaslab taskq.
*/
! int metaslab_load_pct = 50;
/*
! * Determines how many txgs a metaslab may remain loaded without having any
! * allocations from it. As long as a metaslab continues to be used we will
! * keep it loaded.
*/
! int metaslab_unload_delay = TXG_SIZE * 2;
/*
* Should we be willing to write data to degraded vdevs?
*/
boolean_t zfs_write_to_degraded = B_FALSE;
/*
+ * Max number of metaslabs per group to preload.
+ */
+ int metaslab_preload_limit = SPA_DVAS_PER_BP;
+
+ /*
+ * Enable/disable preloading of metaslab.
+ */
+ boolean_t metaslab_preload_enabled = B_TRUE;
+
+ /*
+ * Enable/disable additional weight factor for each metaslab.
+ */
+ boolean_t metaslab_weight_factor_enable = B_FALSE;
+
+
+ /*
* ==========================================================================
* Metaslab classes
* ==========================================================================
*/
metaslab_class_t *
! metaslab_class_create(spa_t *spa, metaslab_ops_t *ops)
{
metaslab_class_t *mc;
mc = kmem_zalloc(sizeof (metaslab_class_t), KM_SLEEP);
*** 228,240 ****
return (-1);
/*
* If the weights are identical, use the offset to force uniqueness.
*/
! if (m1->ms_map->sm_start < m2->ms_map->sm_start)
return (-1);
! if (m1->ms_map->sm_start > m2->ms_map->sm_start)
return (1);
ASSERT3P(m1, ==, m2);
return (0);
--- 257,269 ----
return (-1);
/*
* If the weights are identical, use the offset to force uniqueness.
*/
! if (m1->ms_start < m2->ms_start)
return (-1);
! if (m1->ms_start > m2->ms_start)
return (1);
ASSERT3P(m1, ==, m2);
return (0);
*** 298,307 ****
--- 327,339 ----
sizeof (metaslab_t), offsetof(struct metaslab, ms_group_node));
mg->mg_vd = vd;
mg->mg_class = mc;
mg->mg_activation_count = 0;
+ mg->mg_taskq = taskq_create("metaslab_group_tasksq", metaslab_load_pct,
+ minclsyspri, 10, INT_MAX, TASKQ_THREADS_CPU_PCT);
+
return (mg);
}
void
metaslab_group_destroy(metaslab_group_t *mg)
*** 366,375 ****
--- 398,409 ----
ASSERT(mg->mg_next == NULL);
ASSERT(mg->mg_activation_count < 0);
return;
}
+ taskq_wait(mg->mg_taskq);
+
mgprev = mg->mg_prev;
mgnext = mg->mg_next;
if (mg == mgnext) {
mc->mc_rotor = NULL;
*** 445,609 ****
mc != spa_normal_class(spa) || mc->mc_alloc_groups == 0);
}
/*
* ==========================================================================
! * Common allocator routines
* ==========================================================================
*/
static int
! metaslab_segsize_compare(const void *x1, const void *x2)
{
! const space_seg_t *s1 = x1;
! const space_seg_t *s2 = x2;
! uint64_t ss_size1 = s1->ss_end - s1->ss_start;
! uint64_t ss_size2 = s2->ss_end - s2->ss_start;
! if (ss_size1 < ss_size2)
return (-1);
! if (ss_size1 > ss_size2)
return (1);
! if (s1->ss_start < s2->ss_start)
return (-1);
! if (s1->ss_start > s2->ss_start)
return (1);
return (0);
}
/*
! * This is a helper function that can be used by the allocator to find
! * a suitable block to allocate. This will search the specified AVL
! * tree looking for a block that matches the specified criteria.
*/
! static uint64_t
! metaslab_block_picker(avl_tree_t *t, uint64_t *cursor, uint64_t size,
! uint64_t align)
{
! space_seg_t *ss, ssearch;
! avl_index_t where;
! ssearch.ss_start = *cursor;
! ssearch.ss_end = *cursor + size;
! ss = avl_find(t, &ssearch, &where);
! if (ss == NULL)
! ss = avl_nearest(t, where, AVL_AFTER);
!
! while (ss != NULL) {
! uint64_t offset = P2ROUNDUP(ss->ss_start, align);
!
! if (offset + size <= ss->ss_end) {
! *cursor = offset + size;
! return (offset);
! }
! ss = AVL_NEXT(t, ss);
! }
!
! /*
! * If we know we've searched the whole map (*cursor == 0), give up.
! * Otherwise, reset the cursor to the beginning and try again.
! */
! if (*cursor == 0)
! return (-1ULL);
!
! *cursor = 0;
! return (metaslab_block_picker(t, cursor, size, align));
}
static void
! metaslab_pp_load(space_map_t *sm)
{
! space_seg_t *ss;
! ASSERT(sm->sm_ppd == NULL);
! sm->sm_ppd = kmem_zalloc(64 * sizeof (uint64_t), KM_SLEEP);
! sm->sm_pp_root = kmem_alloc(sizeof (avl_tree_t), KM_SLEEP);
! avl_create(sm->sm_pp_root, metaslab_segsize_compare,
! sizeof (space_seg_t), offsetof(struct space_seg, ss_pp_node));
!
! for (ss = avl_first(&sm->sm_root); ss; ss = AVL_NEXT(&sm->sm_root, ss))
! avl_add(sm->sm_pp_root, ss);
}
static void
! metaslab_pp_unload(space_map_t *sm)
{
! void *cookie = NULL;
! kmem_free(sm->sm_ppd, 64 * sizeof (uint64_t));
! sm->sm_ppd = NULL;
!
! while (avl_destroy_nodes(sm->sm_pp_root, &cookie) != NULL) {
! /* tear down the tree */
! }
!
! avl_destroy(sm->sm_pp_root);
! kmem_free(sm->sm_pp_root, sizeof (avl_tree_t));
! sm->sm_pp_root = NULL;
}
- /* ARGSUSED */
static void
! metaslab_pp_claim(space_map_t *sm, uint64_t start, uint64_t size)
{
! /* No need to update cursor */
}
- /* ARGSUSED */
static void
! metaslab_pp_free(space_map_t *sm, uint64_t start, uint64_t size)
{
! /* No need to update cursor */
}
/*
* Return the maximum contiguous segment within the metaslab.
*/
uint64_t
! metaslab_pp_maxsize(space_map_t *sm)
{
! avl_tree_t *t = sm->sm_pp_root;
! space_seg_t *ss;
! if (t == NULL || (ss = avl_last(t)) == NULL)
return (0ULL);
! return (ss->ss_end - ss->ss_start);
}
/*
* ==========================================================================
* The first-fit block allocator
* ==========================================================================
*/
static uint64_t
! metaslab_ff_alloc(space_map_t *sm, uint64_t size)
{
! avl_tree_t *t = &sm->sm_root;
uint64_t align = size & -size;
! uint64_t *cursor = (uint64_t *)sm->sm_ppd + highbit(align) - 1;
return (metaslab_block_picker(t, cursor, size, align));
}
/* ARGSUSED */
! boolean_t
! metaslab_ff_fragmented(space_map_t *sm)
{
return (B_TRUE);
}
! static space_map_ops_t metaslab_ff_ops = {
! metaslab_pp_load,
! metaslab_pp_unload,
metaslab_ff_alloc,
- metaslab_pp_claim,
- metaslab_pp_free,
- metaslab_pp_maxsize,
metaslab_ff_fragmented
};
/*
* ==========================================================================
--- 479,715 ----
mc != spa_normal_class(spa) || mc->mc_alloc_groups == 0);
}
/*
* ==========================================================================
! * Range tree callbacks
* ==========================================================================
*/
+
+ /*
+ * Comparison function for the private size-ordered tree. Tree is sorted
+ * by size, larger sizes at the end of the tree.
+ */
static int
! metaslab_rangesize_compare(const void *x1, const void *x2)
{
! const range_seg_t *r1 = x1;
! const range_seg_t *r2 = x2;
! uint64_t rs_size1 = r1->rs_end - r1->rs_start;
! uint64_t rs_size2 = r2->rs_end - r2->rs_start;
! if (rs_size1 < rs_size2)
return (-1);
! if (rs_size1 > rs_size2)
return (1);
! if (r1->rs_start < r2->rs_start)
return (-1);
!
! if (r1->rs_start > r2->rs_start)
return (1);
return (0);
}
/*
! * Create any block allocator specific components. The current allocators
! * rely on using both a size-ordered range_tree_t and an array of uint64_t's.
*/
! static void
! metaslab_rt_create(range_tree_t *rt, void *arg)
{
! metaslab_t *msp = arg;
! ASSERT3P(rt->rt_arg, ==, msp);
! ASSERT(msp->ms_tree == NULL);
! avl_create(&msp->ms_size_tree, metaslab_rangesize_compare,
! sizeof (range_seg_t), offsetof(range_seg_t, rs_pp_node));
}
+ /*
+ * Destroy the block allocator specific components.
+ */
static void
! metaslab_rt_destroy(range_tree_t *rt, void *arg)
{
! metaslab_t *msp = arg;
! ASSERT3P(rt->rt_arg, ==, msp);
! ASSERT3P(msp->ms_tree, ==, rt);
! ASSERT0(avl_numnodes(&msp->ms_size_tree));
! avl_destroy(&msp->ms_size_tree);
}
static void
! metaslab_rt_add(range_tree_t *rt, range_seg_t *rs, void *arg)
{
! metaslab_t *msp = arg;
! ASSERT3P(rt->rt_arg, ==, msp);
! ASSERT3P(msp->ms_tree, ==, rt);
! VERIFY(!msp->ms_condensing);
! avl_add(&msp->ms_size_tree, rs);
}
static void
! metaslab_rt_remove(range_tree_t *rt, range_seg_t *rs, void *arg)
{
! metaslab_t *msp = arg;
!
! ASSERT3P(rt->rt_arg, ==, msp);
! ASSERT3P(msp->ms_tree, ==, rt);
! VERIFY(!msp->ms_condensing);
! avl_remove(&msp->ms_size_tree, rs);
}
static void
! metaslab_rt_vacate(range_tree_t *rt, void *arg)
{
! metaslab_t *msp = arg;
!
! ASSERT3P(rt->rt_arg, ==, msp);
! ASSERT3P(msp->ms_tree, ==, rt);
!
! /*
! * Normally one would walk the tree freeing nodes along the way.
! * Since the nodes are shared with the range trees we can avoid
! * walking all nodes and just reinitialize the avl tree. The nodes
! * will be freed by the range tree, so we don't want to free them here.
! */
! avl_create(&msp->ms_size_tree, metaslab_rangesize_compare,
! sizeof (range_seg_t), offsetof(range_seg_t, rs_pp_node));
}
+ static range_tree_ops_t metaslab_rt_ops = {
+ metaslab_rt_create,
+ metaslab_rt_destroy,
+ metaslab_rt_add,
+ metaslab_rt_remove,
+ metaslab_rt_vacate
+ };
+
/*
+ * ==========================================================================
+ * Metaslab block operations
+ * ==========================================================================
+ */
+
+ /*
* Return the maximum contiguous segment within the metaslab.
*/
uint64_t
! metaslab_block_maxsize(metaslab_t *msp)
{
! avl_tree_t *t = &msp->ms_size_tree;
! range_seg_t *rs;
! if (t == NULL || (rs = avl_last(t)) == NULL)
return (0ULL);
! return (rs->rs_end - rs->rs_start);
}
+ uint64_t
+ metaslab_block_alloc(metaslab_t *msp, uint64_t size)
+ {
+ uint64_t start;
+ range_tree_t *rt = msp->ms_tree;
+
+ VERIFY(!msp->ms_condensing);
+
+ start = msp->ms_ops->msop_alloc(msp, size);
+ if (start != -1ULL) {
+ vdev_t *vd = msp->ms_group->mg_vd;
+
+ VERIFY0(P2PHASE(start, 1ULL << vd->vdev_ashift));
+ VERIFY0(P2PHASE(size, 1ULL << vd->vdev_ashift));
+ VERIFY3U(range_tree_space(rt) - size, <=, msp->ms_size);
+ range_tree_remove(rt, start, size);
+ }
+ return (start);
+ }
+
/*
* ==========================================================================
+ * Common allocator routines
+ * ==========================================================================
+ */
+
+ /*
+ * This is a helper function that can be used by the allocator to find
+ * a suitable block to allocate. This will search the specified AVL
+ * tree looking for a block that matches the specified criteria.
+ */
+ static uint64_t
+ metaslab_block_picker(avl_tree_t *t, uint64_t *cursor, uint64_t size,
+ uint64_t align)
+ {
+ range_seg_t *rs, rsearch;
+ avl_index_t where;
+
+ rsearch.rs_start = *cursor;
+ rsearch.rs_end = *cursor + size;
+
+ rs = avl_find(t, &rsearch, &where);
+ if (rs == NULL)
+ rs = avl_nearest(t, where, AVL_AFTER);
+
+ while (rs != NULL) {
+ uint64_t offset = P2ROUNDUP(rs->rs_start, align);
+
+ if (offset + size <= rs->rs_end) {
+ *cursor = offset + size;
+ return (offset);
+ }
+ rs = AVL_NEXT(t, rs);
+ }
+
+ /*
+ * If we know we've searched the whole map (*cursor == 0), give up.
+ * Otherwise, reset the cursor to the beginning and try again.
+ */
+ if (*cursor == 0)
+ return (-1ULL);
+
+ *cursor = 0;
+ return (metaslab_block_picker(t, cursor, size, align));
+ }
+
+ /*
+ * ==========================================================================
* The first-fit block allocator
* ==========================================================================
*/
static uint64_t
! metaslab_ff_alloc(metaslab_t *msp, uint64_t size)
{
! /*
! * Find the largest power of 2 block size that evenly divides the
! * requested size. This is used to try to allocate blocks with similar
! * alignment from the same area of the metaslab (i.e. same cursor
! * bucket) but it does not guarantee that other allocations sizes
! * may exist in the same region.
! */
uint64_t align = size & -size;
! uint64_t *cursor = &msp->ms_lbas[highbit(align) - 1];
! avl_tree_t *t = &msp->ms_tree->rt_root;
return (metaslab_block_picker(t, cursor, size, align));
}
/* ARGSUSED */
! static boolean_t
! metaslab_ff_fragmented(metaslab_t *msp)
{
return (B_TRUE);
}
! static metaslab_ops_t metaslab_ff_ops = {
metaslab_ff_alloc,
metaslab_ff_fragmented
};
/*
* ==========================================================================
*** 612,631 ****
* adjusts to a best fit allocation method. Uses metaslab_df_alloc_threshold
* and metaslab_df_free_pct to determine when to switch the allocation scheme.
* ==========================================================================
*/
static uint64_t
! metaslab_df_alloc(space_map_t *sm, uint64_t size)
{
! avl_tree_t *t = &sm->sm_root;
uint64_t align = size & -size;
! uint64_t *cursor = (uint64_t *)sm->sm_ppd + highbit(align) - 1;
! uint64_t max_size = metaslab_pp_maxsize(sm);
! int free_pct = sm->sm_space * 100 / sm->sm_size;
! ASSERT(MUTEX_HELD(sm->sm_lock));
! ASSERT3U(avl_numnodes(&sm->sm_root), ==, avl_numnodes(sm->sm_pp_root));
if (max_size < size)
return (-1ULL);
/*
--- 718,745 ----
* adjusts to a best fit allocation method. Uses metaslab_df_alloc_threshold
* and metaslab_df_free_pct to determine when to switch the allocation scheme.
* ==========================================================================
*/
static uint64_t
! metaslab_df_alloc(metaslab_t *msp, uint64_t size)
{
! /*
! * Find the largest power of 2 block size that evenly divides the
! * requested size. This is used to try to allocate blocks with similar
! * alignment from the same area of the metaslab (i.e. same cursor
! * bucket) but it does not guarantee that other allocations sizes
! * may exist in the same region.
! */
uint64_t align = size & -size;
! uint64_t *cursor = &msp->ms_lbas[highbit(align) - 1];
! range_tree_t *rt = msp->ms_tree;
! avl_tree_t *t = &rt->rt_root;
! uint64_t max_size = metaslab_block_maxsize(msp);
! int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
! ASSERT(MUTEX_HELD(&msp->ms_lock));
! ASSERT3U(avl_numnodes(t), ==, avl_numnodes(&msp->ms_size_tree));
if (max_size < size)
return (-1ULL);
/*
*** 632,837 ****
* If we're running low on space switch to using the size
* sorted AVL tree (best-fit).
*/
if (max_size < metaslab_df_alloc_threshold ||
free_pct < metaslab_df_free_pct) {
! t = sm->sm_pp_root;
*cursor = 0;
}
return (metaslab_block_picker(t, cursor, size, 1ULL));
}
static boolean_t
! metaslab_df_fragmented(space_map_t *sm)
{
! uint64_t max_size = metaslab_pp_maxsize(sm);
! int free_pct = sm->sm_space * 100 / sm->sm_size;
if (max_size >= metaslab_df_alloc_threshold &&
free_pct >= metaslab_df_free_pct)
return (B_FALSE);
return (B_TRUE);
}
! static space_map_ops_t metaslab_df_ops = {
! metaslab_pp_load,
! metaslab_pp_unload,
metaslab_df_alloc,
- metaslab_pp_claim,
- metaslab_pp_free,
- metaslab_pp_maxsize,
metaslab_df_fragmented
};
/*
* ==========================================================================
! * Other experimental allocators
* ==========================================================================
*/
static uint64_t
! metaslab_cdf_alloc(space_map_t *sm, uint64_t size)
{
! avl_tree_t *t = &sm->sm_root;
! uint64_t *cursor = (uint64_t *)sm->sm_ppd;
! uint64_t *extent_end = (uint64_t *)sm->sm_ppd + 1;
! uint64_t max_size = metaslab_pp_maxsize(sm);
! uint64_t rsize = size;
uint64_t offset = 0;
! ASSERT(MUTEX_HELD(sm->sm_lock));
! ASSERT3U(avl_numnodes(&sm->sm_root), ==, avl_numnodes(sm->sm_pp_root));
! if (max_size < size)
! return (-1ULL);
! ASSERT3U(*extent_end, >=, *cursor);
! /*
! * If we're running low on space switch to using the size
! * sorted AVL tree (best-fit).
! */
! if ((*cursor + size) > *extent_end) {
! t = sm->sm_pp_root;
! *cursor = *extent_end = 0;
!
! if (max_size > 2 * SPA_MAXBLOCKSIZE)
! rsize = MIN(metaslab_min_alloc_size, max_size);
! offset = metaslab_block_picker(t, extent_end, rsize, 1ULL);
! if (offset != -1)
! *cursor = offset + size;
! } else {
! offset = metaslab_block_picker(t, cursor, rsize, 1ULL);
}
! ASSERT3U(*cursor, <=, *extent_end);
return (offset);
}
static boolean_t
! metaslab_cdf_fragmented(space_map_t *sm)
{
! uint64_t max_size = metaslab_pp_maxsize(sm);
!
! if (max_size > (metaslab_min_alloc_size * 10))
! return (B_FALSE);
! return (B_TRUE);
}
! static space_map_ops_t metaslab_cdf_ops = {
! metaslab_pp_load,
! metaslab_pp_unload,
! metaslab_cdf_alloc,
! metaslab_pp_claim,
! metaslab_pp_free,
! metaslab_pp_maxsize,
! metaslab_cdf_fragmented
};
uint64_t metaslab_ndf_clump_shift = 4;
static uint64_t
! metaslab_ndf_alloc(space_map_t *sm, uint64_t size)
{
! avl_tree_t *t = &sm->sm_root;
avl_index_t where;
! space_seg_t *ss, ssearch;
uint64_t hbit = highbit(size);
! uint64_t *cursor = (uint64_t *)sm->sm_ppd + hbit - 1;
! uint64_t max_size = metaslab_pp_maxsize(sm);
! ASSERT(MUTEX_HELD(sm->sm_lock));
! ASSERT3U(avl_numnodes(&sm->sm_root), ==, avl_numnodes(sm->sm_pp_root));
if (max_size < size)
return (-1ULL);
! ssearch.ss_start = *cursor;
! ssearch.ss_end = *cursor + size;
! ss = avl_find(t, &ssearch, &where);
! if (ss == NULL || (ss->ss_start + size > ss->ss_end)) {
! t = sm->sm_pp_root;
! ssearch.ss_start = 0;
! ssearch.ss_end = MIN(max_size,
1ULL << (hbit + metaslab_ndf_clump_shift));
! ss = avl_find(t, &ssearch, &where);
! if (ss == NULL)
! ss = avl_nearest(t, where, AVL_AFTER);
! ASSERT(ss != NULL);
}
! if (ss != NULL) {
! if (ss->ss_start + size <= ss->ss_end) {
! *cursor = ss->ss_start + size;
! return (ss->ss_start);
}
- }
return (-1ULL);
}
static boolean_t
! metaslab_ndf_fragmented(space_map_t *sm)
{
! uint64_t max_size = metaslab_pp_maxsize(sm);
!
! if (max_size > (metaslab_min_alloc_size << metaslab_ndf_clump_shift))
! return (B_FALSE);
! return (B_TRUE);
}
!
! static space_map_ops_t metaslab_ndf_ops = {
! metaslab_pp_load,
! metaslab_pp_unload,
metaslab_ndf_alloc,
- metaslab_pp_claim,
- metaslab_pp_free,
- metaslab_pp_maxsize,
metaslab_ndf_fragmented
};
! space_map_ops_t *zfs_metaslab_ops = &metaslab_df_ops;
/*
* ==========================================================================
* Metaslabs
* ==========================================================================
*/
metaslab_t *
! metaslab_init(metaslab_group_t *mg, space_map_obj_t *smo,
! uint64_t start, uint64_t size, uint64_t txg)
{
vdev_t *vd = mg->mg_vd;
metaslab_t *msp;
msp = kmem_zalloc(sizeof (metaslab_t), KM_SLEEP);
mutex_init(&msp->ms_lock, NULL, MUTEX_DEFAULT, NULL);
! msp->ms_smo_syncing = *smo;
/*
! * We create the main space map here, but we don't create the
! * allocmaps and freemaps until metaslab_sync_done(). This serves
* two purposes: it allows metaslab_sync_done() to detect the
* addition of new space; and for debugging, it ensures that we'd
* data fault on any attempt to use this metaslab before it's ready.
*/
! msp->ms_map = kmem_zalloc(sizeof (space_map_t), KM_SLEEP);
! space_map_create(msp->ms_map, start, size,
! vd->vdev_ashift, &msp->ms_lock);
!
metaslab_group_add(mg, msp);
! if (metaslab_debug && smo->smo_object != 0) {
! mutex_enter(&msp->ms_lock);
! VERIFY(space_map_load(msp->ms_map, mg->mg_class->mc_ops,
! SM_FREE, smo, spa_meta_objset(vd->vdev_spa)) == 0);
! mutex_exit(&msp->ms_lock);
! }
/*
* If we're opening an existing pool (txg == 0) or creating
* a new one (txg == TXG_INITIAL), all space is available now.
* If we're adding space to an existing pool, the new space
--- 746,998 ----
* If we're running low on space switch to using the size
* sorted AVL tree (best-fit).
*/
if (max_size < metaslab_df_alloc_threshold ||
free_pct < metaslab_df_free_pct) {
! t = &msp->ms_size_tree;
*cursor = 0;
}
return (metaslab_block_picker(t, cursor, size, 1ULL));
}
static boolean_t
! metaslab_df_fragmented(metaslab_t *msp)
{
! range_tree_t *rt = msp->ms_tree;
! uint64_t max_size = metaslab_block_maxsize(msp);
! int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
if (max_size >= metaslab_df_alloc_threshold &&
free_pct >= metaslab_df_free_pct)
return (B_FALSE);
return (B_TRUE);
}
! static metaslab_ops_t metaslab_df_ops = {
metaslab_df_alloc,
metaslab_df_fragmented
};
/*
* ==========================================================================
! * Cursor fit block allocator -
! * Select the largest region in the metaslab, set the cursor to the beginning
! * of the range and the cursor_end to the end of the range. As allocations
! * are made advance the cursor. Continue allocating from the cursor until
! * the range is exhausted and then find a new range.
* ==========================================================================
*/
static uint64_t
! metaslab_cf_alloc(metaslab_t *msp, uint64_t size)
{
! range_tree_t *rt = msp->ms_tree;
! avl_tree_t *t = &msp->ms_size_tree;
! uint64_t *cursor = &msp->ms_lbas[0];
! uint64_t *cursor_end = &msp->ms_lbas[1];
uint64_t offset = 0;
! ASSERT(MUTEX_HELD(&msp->ms_lock));
! ASSERT3U(avl_numnodes(t), ==, avl_numnodes(&rt->rt_root));
! ASSERT3U(*cursor_end, >=, *cursor);
! if ((*cursor + size) > *cursor_end) {
! range_seg_t *rs;
! rs = avl_last(&msp->ms_size_tree);
! if (rs == NULL || (rs->rs_end - rs->rs_start) < size)
! return (-1ULL);
! *cursor = rs->rs_start;
! *cursor_end = rs->rs_end;
}
!
! offset = *cursor;
! *cursor += size;
!
return (offset);
}
static boolean_t
! metaslab_cf_fragmented(metaslab_t *msp)
{
! return (metaslab_block_maxsize(msp) < metaslab_min_alloc_size);
}
! static metaslab_ops_t metaslab_cf_ops = {
! metaslab_cf_alloc,
! metaslab_cf_fragmented
};
+ /*
+ * ==========================================================================
+ * New dynamic fit allocator -
+ * Select a region that is large enough to allocate 2^metaslab_ndf_clump_shift
+ * contiguous blocks. If no region is found then just use the largest segment
+ * that remains.
+ * ==========================================================================
+ */
+
+ /*
+ * Determines desired number of contiguous blocks (2^metaslab_ndf_clump_shift)
+ * to request from the allocator.
+ */
uint64_t metaslab_ndf_clump_shift = 4;
static uint64_t
! metaslab_ndf_alloc(metaslab_t *msp, uint64_t size)
{
! avl_tree_t *t = &msp->ms_tree->rt_root;
avl_index_t where;
! range_seg_t *rs, rsearch;
uint64_t hbit = highbit(size);
! uint64_t *cursor = &msp->ms_lbas[hbit - 1];
! uint64_t max_size = metaslab_block_maxsize(msp);
! ASSERT(MUTEX_HELD(&msp->ms_lock));
! ASSERT3U(avl_numnodes(t), ==, avl_numnodes(&msp->ms_size_tree));
if (max_size < size)
return (-1ULL);
! rsearch.rs_start = *cursor;
! rsearch.rs_end = *cursor + size;
! rs = avl_find(t, &rsearch, &where);
! if (rs == NULL || (rs->rs_end - rs->rs_start) < size) {
! t = &msp->ms_size_tree;
! rsearch.rs_start = 0;
! rsearch.rs_end = MIN(max_size,
1ULL << (hbit + metaslab_ndf_clump_shift));
! rs = avl_find(t, &rsearch, &where);
! if (rs == NULL)
! rs = avl_nearest(t, where, AVL_AFTER);
! ASSERT(rs != NULL);
}
! if ((rs->rs_end - rs->rs_start) >= size) {
! *cursor = rs->rs_start + size;
! return (rs->rs_start);
}
return (-1ULL);
}
static boolean_t
! metaslab_ndf_fragmented(metaslab_t *msp)
{
! return (metaslab_block_maxsize(msp) <=
! (metaslab_min_alloc_size << metaslab_ndf_clump_shift));
}
! static metaslab_ops_t metaslab_ndf_ops = {
metaslab_ndf_alloc,
metaslab_ndf_fragmented
};
! metaslab_ops_t *zfs_metaslab_ops = &metaslab_df_ops;
/*
* ==========================================================================
* Metaslabs
* ==========================================================================
*/
+
+ /*
+ * Wait for any in-progress metaslab loads to complete.
+ */
+ void
+ metaslab_load_wait(metaslab_t *msp)
+ {
+ ASSERT(MUTEX_HELD(&msp->ms_lock));
+
+ while (msp->ms_loading) {
+ ASSERT(!msp->ms_loaded);
+ cv_wait(&msp->ms_load_cv, &msp->ms_lock);
+ }
+ }
+
+ int
+ metaslab_load(metaslab_t *msp)
+ {
+ int error = 0;
+
+ ASSERT(MUTEX_HELD(&msp->ms_lock));
+ ASSERT(!msp->ms_loaded);
+ ASSERT(!msp->ms_loading);
+
+ msp->ms_loading = B_TRUE;
+
+ /*
+ * If the space map has not been allocated yet, then treat
+ * all the space in the metaslab as free and add it to the
+ * ms_tree.
+ */
+ if (msp->ms_sm != NULL)
+ error = space_map_load(msp->ms_sm, msp->ms_tree, SM_FREE);
+ else
+ range_tree_add(msp->ms_tree, msp->ms_start, msp->ms_size);
+
+ msp->ms_loaded = (error == 0);
+ msp->ms_loading = B_FALSE;
+
+ if (msp->ms_loaded) {
+ for (int t = 0; t < TXG_DEFER_SIZE; t++) {
+ range_tree_walk(msp->ms_defertree[t],
+ range_tree_remove, msp->ms_tree);
+ }
+ }
+ cv_broadcast(&msp->ms_load_cv);
+ return (error);
+ }
+
+ void
+ metaslab_unload(metaslab_t *msp)
+ {
+ ASSERT(MUTEX_HELD(&msp->ms_lock));
+ range_tree_vacate(msp->ms_tree, NULL, NULL);
+ msp->ms_loaded = B_FALSE;
+ msp->ms_weight &= ~METASLAB_ACTIVE_MASK;
+ }
+
metaslab_t *
! metaslab_init(metaslab_group_t *mg, uint64_t id, uint64_t object, uint64_t txg)
{
vdev_t *vd = mg->mg_vd;
+ objset_t *mos = vd->vdev_spa->spa_meta_objset;
metaslab_t *msp;
msp = kmem_zalloc(sizeof (metaslab_t), KM_SLEEP);
mutex_init(&msp->ms_lock, NULL, MUTEX_DEFAULT, NULL);
+ cv_init(&msp->ms_load_cv, NULL, CV_DEFAULT, NULL);
+ msp->ms_id = id;
+ msp->ms_start = id << vd->vdev_ms_shift;
+ msp->ms_size = 1ULL << vd->vdev_ms_shift;
! /*
! * We only open space map objects that already exist. All others
! * will be opened when we finally allocate an object for it.
! */
! if (object != 0) {
! VERIFY0(space_map_open(&msp->ms_sm, mos, object, msp->ms_start,
! msp->ms_size, vd->vdev_ashift, &msp->ms_lock));
! ASSERT(msp->ms_sm != NULL);
! }
/*
! * We create the main range tree here, but we don't create the
! * alloctree and freetree until metaslab_sync_done(). This serves
* two purposes: it allows metaslab_sync_done() to detect the
* addition of new space; and for debugging, it ensures that we'd
* data fault on any attempt to use this metaslab before it's ready.
*/
! msp->ms_tree = range_tree_create(&metaslab_rt_ops, msp, &msp->ms_lock);
metaslab_group_add(mg, msp);
! msp->ms_ops = mg->mg_class->mc_ops;
/*
* If we're opening an existing pool (txg == 0) or creating
* a new one (txg == TXG_INITIAL), all space is available now.
* If we're adding space to an existing pool, the new space
*** 838,847 ****
--- 999,1019 ----
* does not become available until after this txg has synced.
*/
if (txg <= TXG_INITIAL)
metaslab_sync_done(msp, 0);
+ /*
+ * If metaslab_debug_load is set and we're initializing a metaslab
+ * that has an allocated space_map object then load the its space
+ * map so that can verify frees.
+ */
+ if (metaslab_debug_load && msp->ms_sm != NULL) {
+ mutex_enter(&msp->ms_lock);
+ VERIFY0(metaslab_load(msp));
+ mutex_exit(&msp->ms_lock);
+ }
+
if (txg != 0) {
vdev_dirty(vd, 0, NULL, txg);
vdev_dirty(vd, VDD_METASLAB, msp, txg);
}
*** 851,902 ****
void
metaslab_fini(metaslab_t *msp)
{
metaslab_group_t *mg = msp->ms_group;
- vdev_space_update(mg->mg_vd,
- -msp->ms_smo.smo_alloc, 0, -msp->ms_map->sm_size);
-
metaslab_group_remove(mg, msp);
mutex_enter(&msp->ms_lock);
! space_map_unload(msp->ms_map);
! space_map_destroy(msp->ms_map);
! kmem_free(msp->ms_map, sizeof (*msp->ms_map));
for (int t = 0; t < TXG_SIZE; t++) {
! space_map_destroy(msp->ms_allocmap[t]);
! space_map_destroy(msp->ms_freemap[t]);
! kmem_free(msp->ms_allocmap[t], sizeof (*msp->ms_allocmap[t]));
! kmem_free(msp->ms_freemap[t], sizeof (*msp->ms_freemap[t]));
}
for (int t = 0; t < TXG_DEFER_SIZE; t++) {
! space_map_destroy(msp->ms_defermap[t]);
! kmem_free(msp->ms_defermap[t], sizeof (*msp->ms_defermap[t]));
}
ASSERT0(msp->ms_deferspace);
mutex_exit(&msp->ms_lock);
mutex_destroy(&msp->ms_lock);
kmem_free(msp, sizeof (metaslab_t));
}
! #define METASLAB_WEIGHT_PRIMARY (1ULL << 63)
! #define METASLAB_WEIGHT_SECONDARY (1ULL << 62)
! #define METASLAB_ACTIVE_MASK \
! (METASLAB_WEIGHT_PRIMARY | METASLAB_WEIGHT_SECONDARY)
static uint64_t
metaslab_weight(metaslab_t *msp)
{
metaslab_group_t *mg = msp->ms_group;
- space_map_t *sm = msp->ms_map;
- space_map_obj_t *smo = &msp->ms_smo;
vdev_t *vd = mg->mg_vd;
uint64_t weight, space;
ASSERT(MUTEX_HELD(&msp->ms_lock));
--- 1023,1129 ----
void
metaslab_fini(metaslab_t *msp)
{
metaslab_group_t *mg = msp->ms_group;
metaslab_group_remove(mg, msp);
mutex_enter(&msp->ms_lock);
! VERIFY(msp->ms_group == NULL);
! vdev_space_update(mg->mg_vd, -space_map_allocated(msp->ms_sm),
! 0, -msp->ms_size);
! space_map_close(msp->ms_sm);
+ metaslab_unload(msp);
+ range_tree_destroy(msp->ms_tree);
+
for (int t = 0; t < TXG_SIZE; t++) {
! range_tree_destroy(msp->ms_alloctree[t]);
! range_tree_destroy(msp->ms_freetree[t]);
}
for (int t = 0; t < TXG_DEFER_SIZE; t++) {
! range_tree_destroy(msp->ms_defertree[t]);
}
ASSERT0(msp->ms_deferspace);
mutex_exit(&msp->ms_lock);
+ cv_destroy(&msp->ms_load_cv);
mutex_destroy(&msp->ms_lock);
kmem_free(msp, sizeof (metaslab_t));
}
! /*
! * Apply a weighting factor based on the histogram information for this
! * metaslab. The current weighting factor is somewhat arbitrary and requires
! * additional investigation. The implementation provides a measure of
! * "weighted" free space and gives a higher weighting for larger contiguous
! * regions. The weighting factor is determined by counting the number of
! * sm_shift sectors that exist in each region represented by the histogram.
! * That value is then multiplied by the power of 2 exponent and the sm_shift
! * value.
! *
! * For example, assume the 2^21 histogram bucket has 4 2MB regions and the
! * metaslab has an sm_shift value of 9 (512B):
! *
! * 1) calculate the number of sm_shift sectors in the region:
! * 2^21 / 2^9 = 2^12 = 4096 * 4 (number of regions) = 16384
! * 2) multiply by the power of 2 exponent and the sm_shift value:
! * 16384 * 21 * 9 = 3096576
! * This value will be added to the weighting of the metaslab.
! */
! static uint64_t
! metaslab_weight_factor(metaslab_t *msp)
! {
! uint64_t factor = 0;
! uint64_t sectors;
! int i;
+ /*
+ * A null space map means that the entire metaslab is free,
+ * calculate a weight factor that spans the entire size of the
+ * metaslab.
+ */
+ if (msp->ms_sm == NULL) {
+ vdev_t *vd = msp->ms_group->mg_vd;
+
+ i = highbit(msp->ms_size) - 1;
+ sectors = msp->ms_size >> vd->vdev_ashift;
+ return (sectors * i * vd->vdev_ashift);
+ }
+
+ if (msp->ms_sm->sm_dbuf->db_size != sizeof (space_map_phys_t))
+ return (0);
+
+ for (i = 0; i < SPACE_MAP_HISTOGRAM_SIZE(msp->ms_sm); i++) {
+ if (msp->ms_sm->sm_phys->smp_histogram[i] == 0)
+ continue;
+
+ /*
+ * Determine the number of sm_shift sectors in the region
+ * indicated by the histogram. For example, given an
+ * sm_shift value of 9 (512 bytes) and i = 4 then we know
+ * that we're looking at an 8K region in the histogram
+ * (i.e. 9 + 4 = 13, 2^13 = 8192). To figure out the
+ * number of sm_shift sectors (512 bytes in this example),
+ * we would take 8192 / 512 = 16. Since the histogram
+ * is offset by sm_shift we can simply use the value of
+ * of i to calculate this (i.e. 2^i = 16 where i = 4).
+ */
+ sectors = msp->ms_sm->sm_phys->smp_histogram[i] << i;
+ factor += (i + msp->ms_sm->sm_shift) * sectors;
+ }
+ return (factor * msp->ms_sm->sm_shift);
+ }
+
static uint64_t
metaslab_weight(metaslab_t *msp)
{
metaslab_group_t *mg = msp->ms_group;
vdev_t *vd = mg->mg_vd;
uint64_t weight, space;
ASSERT(MUTEX_HELD(&msp->ms_lock));
*** 903,921 ****
/*
* This vdev is in the process of being removed so there is nothing
* for us to do here.
*/
if (vd->vdev_removing) {
! ASSERT0(smo->smo_alloc);
ASSERT0(vd->vdev_ms_shift);
return (0);
}
/*
* The baseline weight is the metaslab's free space.
*/
! space = sm->sm_size - smo->smo_alloc;
weight = space;
/*
* Modern disks have uniform bit density and constant angular velocity.
* Therefore, the outer recording zones are faster (higher bandwidth)
--- 1130,1148 ----
/*
* This vdev is in the process of being removed so there is nothing
* for us to do here.
*/
if (vd->vdev_removing) {
! ASSERT0(space_map_allocated(msp->ms_sm));
ASSERT0(vd->vdev_ms_shift);
return (0);
}
/*
* The baseline weight is the metaslab's free space.
*/
! space = msp->ms_size - space_map_allocated(msp->ms_sm);
weight = space;
/*
* Modern disks have uniform bit density and constant angular velocity.
* Therefore, the outer recording zones are faster (higher bandwidth)
*** 923,1026 ****
* which is typically around 2:1. We account for this by assigning
* higher weight to lower metaslabs (multiplier ranging from 2x to 1x).
* In effect, this means that we'll select the metaslab with the most
* free bandwidth rather than simply the one with the most free space.
*/
! weight = 2 * weight -
! ((sm->sm_start >> vd->vdev_ms_shift) * weight) / vd->vdev_ms_count;
ASSERT(weight >= space && weight <= 2 * space);
! /*
! * For locality, assign higher weight to metaslabs which have
! * a lower offset than what we've already activated.
! */
! if (sm->sm_start <= mg->mg_bonus_area)
! weight *= (metaslab_smo_bonus_pct / 100);
! ASSERT(weight >= space &&
! weight <= 2 * (metaslab_smo_bonus_pct / 100) * space);
! if (sm->sm_loaded && !sm->sm_ops->smop_fragmented(sm)) {
/*
* If this metaslab is one we're actively using, adjust its
* weight to make it preferable to any inactive metaslab so
* we'll polish it off.
*/
weight |= (msp->ms_weight & METASLAB_ACTIVE_MASK);
}
return (weight);
}
- static void
- metaslab_prefetch(metaslab_group_t *mg)
- {
- spa_t *spa = mg->mg_vd->vdev_spa;
- metaslab_t *msp;
- avl_tree_t *t = &mg->mg_metaslab_tree;
- int m;
-
- mutex_enter(&mg->mg_lock);
-
- /*
- * Prefetch the next potential metaslabs
- */
- for (msp = avl_first(t), m = 0; msp; msp = AVL_NEXT(t, msp), m++) {
- space_map_t *sm = msp->ms_map;
- space_map_obj_t *smo = &msp->ms_smo;
-
- /* If we have reached our prefetch limit then we're done */
- if (m >= metaslab_prefetch_limit)
- break;
-
- if (!sm->sm_loaded && smo->smo_object != 0) {
- mutex_exit(&mg->mg_lock);
- dmu_prefetch(spa_meta_objset(spa), smo->smo_object,
- 0ULL, smo->smo_objsize);
- mutex_enter(&mg->mg_lock);
- }
- }
- mutex_exit(&mg->mg_lock);
- }
-
static int
metaslab_activate(metaslab_t *msp, uint64_t activation_weight)
{
- metaslab_group_t *mg = msp->ms_group;
- space_map_t *sm = msp->ms_map;
- space_map_ops_t *sm_ops = msp->ms_group->mg_class->mc_ops;
-
ASSERT(MUTEX_HELD(&msp->ms_lock));
if ((msp->ms_weight & METASLAB_ACTIVE_MASK) == 0) {
! space_map_load_wait(sm);
! if (!sm->sm_loaded) {
! space_map_obj_t *smo = &msp->ms_smo;
!
! int error = space_map_load(sm, sm_ops, SM_FREE, smo,
! spa_meta_objset(msp->ms_group->mg_vd->vdev_spa));
if (error) {
metaslab_group_sort(msp->ms_group, msp, 0);
return (error);
}
- for (int t = 0; t < TXG_DEFER_SIZE; t++)
- space_map_walk(msp->ms_defermap[t],
- space_map_claim, sm);
-
}
- /*
- * Track the bonus area as we activate new metaslabs.
- */
- if (sm->sm_start > mg->mg_bonus_area) {
- mutex_enter(&mg->mg_lock);
- mg->mg_bonus_area = sm->sm_start;
- mutex_exit(&mg->mg_lock);
- }
-
metaslab_group_sort(msp->ms_group, msp,
msp->ms_weight | activation_weight);
}
! ASSERT(sm->sm_loaded);
ASSERT(msp->ms_weight & METASLAB_ACTIVE_MASK);
return (0);
}
--- 1150,1197 ----
* which is typically around 2:1. We account for this by assigning
* higher weight to lower metaslabs (multiplier ranging from 2x to 1x).
* In effect, this means that we'll select the metaslab with the most
* free bandwidth rather than simply the one with the most free space.
*/
! weight = 2 * weight - (msp->ms_id * weight) / vd->vdev_ms_count;
ASSERT(weight >= space && weight <= 2 * space);
! msp->ms_factor = metaslab_weight_factor(msp);
! if (metaslab_weight_factor_enable)
! weight += msp->ms_factor;
! if (msp->ms_loaded && !msp->ms_ops->msop_fragmented(msp)) {
/*
* If this metaslab is one we're actively using, adjust its
* weight to make it preferable to any inactive metaslab so
* we'll polish it off.
*/
weight |= (msp->ms_weight & METASLAB_ACTIVE_MASK);
}
+
return (weight);
}
static int
metaslab_activate(metaslab_t *msp, uint64_t activation_weight)
{
ASSERT(MUTEX_HELD(&msp->ms_lock));
if ((msp->ms_weight & METASLAB_ACTIVE_MASK) == 0) {
! metaslab_load_wait(msp);
! if (!msp->ms_loaded) {
! int error = metaslab_load(msp);
if (error) {
metaslab_group_sort(msp->ms_group, msp, 0);
return (error);
}
}
metaslab_group_sort(msp->ms_group, msp,
msp->ms_weight | activation_weight);
}
! ASSERT(msp->ms_loaded);
ASSERT(msp->ms_weight & METASLAB_ACTIVE_MASK);
return (0);
}
*** 1030,1059 ****
/*
* If size < SPA_MINBLOCKSIZE, then we will not allocate from
* this metaslab again. In that case, it had better be empty,
* or we would be leaving space on the table.
*/
! ASSERT(size >= SPA_MINBLOCKSIZE || msp->ms_map->sm_space == 0);
metaslab_group_sort(msp->ms_group, msp, MIN(msp->ms_weight, size));
ASSERT((msp->ms_weight & METASLAB_ACTIVE_MASK) == 0);
}
/*
! * Determine if the in-core space map representation can be condensed on-disk.
! * We would like to use the following criteria to make our decision:
*
* 1. The size of the space map object should not dramatically increase as a
! * result of writing out our in-core free map.
*
* 2. The minimal on-disk space map representation is zfs_condense_pct/100
! * times the size than the in-core representation (i.e. zfs_condense_pct = 110
! * and in-core = 1MB, minimal = 1.1.MB).
*
* Checking the first condition is tricky since we don't want to walk
* the entire AVL tree calculating the estimated on-disk size. Instead we
! * use the size-ordered AVL tree in the space map and calculate the
! * size required for the largest segment in our in-core free map. If the
* size required to represent that segment on disk is larger than the space
* map object then we avoid condensing this map.
*
* To determine the second criterion we use a best-case estimate and assume
* each segment can be represented on-disk as a single 64-bit entry. We refer
--- 1201,1278 ----
/*
* If size < SPA_MINBLOCKSIZE, then we will not allocate from
* this metaslab again. In that case, it had better be empty,
* or we would be leaving space on the table.
*/
! ASSERT(size >= SPA_MINBLOCKSIZE || range_tree_space(msp->ms_tree) == 0);
metaslab_group_sort(msp->ms_group, msp, MIN(msp->ms_weight, size));
ASSERT((msp->ms_weight & METASLAB_ACTIVE_MASK) == 0);
}
+ static void
+ metaslab_preload(void *arg)
+ {
+ metaslab_t *msp = arg;
+ spa_t *spa = msp->ms_group->mg_vd->vdev_spa;
+
+ mutex_enter(&msp->ms_lock);
+ metaslab_load_wait(msp);
+ if (!msp->ms_loaded)
+ (void) metaslab_load(msp);
+
+ /*
+ * Set the ms_access_txg value so that we don't unload it right away.
+ */
+ msp->ms_access_txg = spa_syncing_txg(spa) + metaslab_unload_delay + 1;
+ mutex_exit(&msp->ms_lock);
+ }
+
+ static void
+ metaslab_group_preload(metaslab_group_t *mg)
+ {
+ spa_t *spa = mg->mg_vd->vdev_spa;
+ metaslab_t *msp;
+ avl_tree_t *t = &mg->mg_metaslab_tree;
+ int m = 0;
+
+ if (spa_shutting_down(spa) || !metaslab_preload_enabled) {
+ taskq_wait(mg->mg_taskq);
+ return;
+ }
+ mutex_enter(&mg->mg_lock);
+
+ /*
+ * Prefetch the next potential metaslabs
+ */
+ for (msp = avl_first(t); msp != NULL; msp = AVL_NEXT(t, msp)) {
+
+ /* If we have reached our preload limit then we're done */
+ if (++m > metaslab_preload_limit)
+ break;
+
+ VERIFY(taskq_dispatch(mg->mg_taskq, metaslab_preload,
+ msp, TQ_SLEEP) != NULL);
+ }
+ mutex_exit(&mg->mg_lock);
+ }
+
/*
! * Determine if the space map's on-disk footprint is past our tolerance
! * for inefficiency. We would like to use the following criteria to make
! * our decision:
*
* 1. The size of the space map object should not dramatically increase as a
! * result of writing out the free space range tree.
*
* 2. The minimal on-disk space map representation is zfs_condense_pct/100
! * times the size than the free space range tree representation
! * (i.e. zfs_condense_pct = 110 and in-core = 1MB, minimal = 1.1.MB).
*
* Checking the first condition is tricky since we don't want to walk
* the entire AVL tree calculating the estimated on-disk size. Instead we
! * use the size-ordered range tree in the metaslab and calculate the
! * size required to write out the largest segment in our free tree. If the
* size required to represent that segment on disk is larger than the space
* map object then we avoid condensing this map.
*
* To determine the second criterion we use a best-case estimate and assume
* each segment can be represented on-disk as a single 64-bit entry. We refer
*** 1060,1284 ****
* to this best-case estimate as the space map's minimal form.
*/
static boolean_t
metaslab_should_condense(metaslab_t *msp)
{
! space_map_t *sm = msp->ms_map;
! space_map_obj_t *smo = &msp->ms_smo_syncing;
! space_seg_t *ss;
uint64_t size, entries, segsz;
ASSERT(MUTEX_HELD(&msp->ms_lock));
! ASSERT(sm->sm_loaded);
/*
! * Use the sm_pp_root AVL tree, which is ordered by size, to obtain
! * the largest segment in the in-core free map. If the tree is
! * empty then we should condense the map.
*/
! ss = avl_last(sm->sm_pp_root);
! if (ss == NULL)
return (B_TRUE);
/*
* Calculate the number of 64-bit entries this segment would
* require when written to disk. If this single segment would be
* larger on-disk than the entire current on-disk structure, then
* clearly condensing will increase the on-disk structure size.
*/
! size = (ss->ss_end - ss->ss_start) >> sm->sm_shift;
entries = size / (MIN(size, SM_RUN_MAX));
segsz = entries * sizeof (uint64_t);
! return (segsz <= smo->smo_objsize &&
! smo->smo_objsize >= (zfs_condense_pct *
! sizeof (uint64_t) * avl_numnodes(&sm->sm_root)) / 100);
}
/*
* Condense the on-disk space map representation to its minimized form.
* The minimized form consists of a small number of allocations followed by
! * the in-core free map.
*/
static void
metaslab_condense(metaslab_t *msp, uint64_t txg, dmu_tx_t *tx)
{
spa_t *spa = msp->ms_group->mg_vd->vdev_spa;
! space_map_t *freemap = msp->ms_freemap[txg & TXG_MASK];
! space_map_t condense_map;
! space_map_t *sm = msp->ms_map;
! objset_t *mos = spa_meta_objset(spa);
! space_map_obj_t *smo = &msp->ms_smo_syncing;
ASSERT(MUTEX_HELD(&msp->ms_lock));
ASSERT3U(spa_sync_pass(spa), ==, 1);
! ASSERT(sm->sm_loaded);
spa_dbgmsg(spa, "condensing: txg %llu, msp[%llu] %p, "
! "smo size %llu, segments %lu", txg,
! (msp->ms_map->sm_start / msp->ms_map->sm_size), msp,
! smo->smo_objsize, avl_numnodes(&sm->sm_root));
/*
! * Create an map that is a 100% allocated map. We remove segments
* that have been freed in this txg, any deferred frees that exist,
* and any allocation in the future. Removing segments should be
! * a relatively inexpensive operation since we expect these maps to
! * a small number of nodes.
*/
! space_map_create(&condense_map, sm->sm_start, sm->sm_size,
! sm->sm_shift, sm->sm_lock);
! space_map_add(&condense_map, condense_map.sm_start,
! condense_map.sm_size);
/*
! * Remove what's been freed in this txg from the condense_map.
* Since we're in sync_pass 1, we know that all the frees from
! * this txg are in the freemap.
*/
! space_map_walk(freemap, space_map_remove, &condense_map);
! for (int t = 0; t < TXG_DEFER_SIZE; t++)
! space_map_walk(msp->ms_defermap[t],
! space_map_remove, &condense_map);
! for (int t = 1; t < TXG_CONCURRENT_STATES; t++)
! space_map_walk(msp->ms_allocmap[(txg + t) & TXG_MASK],
! space_map_remove, &condense_map);
/*
* We're about to drop the metaslab's lock thus allowing
* other consumers to change it's content. Set the
! * space_map's sm_condensing flag to ensure that
* allocations on this metaslab do not occur while we're
* in the middle of committing it to disk. This is only critical
! * for the ms_map as all other space_maps use per txg
* views of their content.
*/
! sm->sm_condensing = B_TRUE;
mutex_exit(&msp->ms_lock);
! space_map_truncate(smo, mos, tx);
mutex_enter(&msp->ms_lock);
/*
* While we would ideally like to create a space_map representation
* that consists only of allocation records, doing so can be
! * prohibitively expensive because the in-core free map can be
* large, and therefore computationally expensive to subtract
! * from the condense_map. Instead we sync out two maps, a cheap
! * allocation only map followed by the in-core free map. While not
* optimal, this is typically close to optimal, and much cheaper to
* compute.
*/
! space_map_sync(&condense_map, SM_ALLOC, smo, mos, tx);
! space_map_vacate(&condense_map, NULL, NULL);
! space_map_destroy(&condense_map);
! space_map_sync(sm, SM_FREE, smo, mos, tx);
! sm->sm_condensing = B_FALSE;
!
! spa_dbgmsg(spa, "condensed: txg %llu, msp[%llu] %p, "
! "smo size %llu", txg,
! (msp->ms_map->sm_start / msp->ms_map->sm_size), msp,
! smo->smo_objsize);
}
/*
* Write a metaslab to disk in the context of the specified transaction group.
*/
void
metaslab_sync(metaslab_t *msp, uint64_t txg)
{
! vdev_t *vd = msp->ms_group->mg_vd;
spa_t *spa = vd->vdev_spa;
objset_t *mos = spa_meta_objset(spa);
! space_map_t *allocmap = msp->ms_allocmap[txg & TXG_MASK];
! space_map_t **freemap = &msp->ms_freemap[txg & TXG_MASK];
! space_map_t **freed_map = &msp->ms_freemap[TXG_CLEAN(txg) & TXG_MASK];
! space_map_t *sm = msp->ms_map;
! space_map_obj_t *smo = &msp->ms_smo_syncing;
! dmu_buf_t *db;
dmu_tx_t *tx;
ASSERT(!vd->vdev_ishole);
/*
* This metaslab has just been added so there's no work to do now.
*/
! if (*freemap == NULL) {
! ASSERT3P(allocmap, ==, NULL);
return;
}
! ASSERT3P(allocmap, !=, NULL);
! ASSERT3P(*freemap, !=, NULL);
! ASSERT3P(*freed_map, !=, NULL);
! if (allocmap->sm_space == 0 && (*freemap)->sm_space == 0)
return;
/*
* The only state that can actually be changing concurrently with
! * metaslab_sync() is the metaslab's ms_map. No other thread can
! * be modifying this txg's allocmap, freemap, freed_map, or smo.
! * Therefore, we only hold ms_lock to satify space_map ASSERTs.
! * We drop it whenever we call into the DMU, because the DMU
! * can call down to us (e.g. via zio_free()) at any time.
*/
tx = dmu_tx_create_assigned(spa_get_dsl(spa), txg);
! if (smo->smo_object == 0) {
! ASSERT(smo->smo_objsize == 0);
! ASSERT(smo->smo_alloc == 0);
! smo->smo_object = dmu_object_alloc(mos,
! DMU_OT_SPACE_MAP, 1 << SPACE_MAP_BLOCKSHIFT,
! DMU_OT_SPACE_MAP_HEADER, sizeof (*smo), tx);
! ASSERT(smo->smo_object != 0);
! dmu_write(mos, vd->vdev_ms_array, sizeof (uint64_t) *
! (sm->sm_start >> vd->vdev_ms_shift),
! sizeof (uint64_t), &smo->smo_object, tx);
}
mutex_enter(&msp->ms_lock);
! if (sm->sm_loaded && spa_sync_pass(spa) == 1 &&
metaslab_should_condense(msp)) {
metaslab_condense(msp, txg, tx);
} else {
! space_map_sync(allocmap, SM_ALLOC, smo, mos, tx);
! space_map_sync(*freemap, SM_FREE, smo, mos, tx);
}
! space_map_vacate(allocmap, NULL, NULL);
/*
! * For sync pass 1, we avoid walking the entire space map and
! * instead will just swap the pointers for freemap and
! * freed_map. We can safely do this since the freed_map is
* guaranteed to be empty on the initial pass.
*/
if (spa_sync_pass(spa) == 1) {
! ASSERT0((*freed_map)->sm_space);
! ASSERT0(avl_numnodes(&(*freed_map)->sm_root));
! space_map_swap(freemap, freed_map);
} else {
! space_map_vacate(*freemap, space_map_add, *freed_map);
}
! ASSERT0(msp->ms_allocmap[txg & TXG_MASK]->sm_space);
! ASSERT0(msp->ms_freemap[txg & TXG_MASK]->sm_space);
mutex_exit(&msp->ms_lock);
! VERIFY0(dmu_bonus_hold(mos, smo->smo_object, FTAG, &db));
! dmu_buf_will_dirty(db, tx);
! ASSERT3U(db->db_size, >=, sizeof (*smo));
! bcopy(smo, db->db_data, sizeof (*smo));
! dmu_buf_rele(db, FTAG);
!
dmu_tx_commit(tx);
}
/*
* Called after a transaction group has completely synced to mark
--- 1279,1513 ----
* to this best-case estimate as the space map's minimal form.
*/
static boolean_t
metaslab_should_condense(metaslab_t *msp)
{
! space_map_t *sm = msp->ms_sm;
! range_seg_t *rs;
uint64_t size, entries, segsz;
ASSERT(MUTEX_HELD(&msp->ms_lock));
! ASSERT(msp->ms_loaded);
/*
! * Use the ms_size_tree range tree, which is ordered by size, to
! * obtain the largest segment in the free tree. If the tree is empty
! * then we should condense the map.
*/
! rs = avl_last(&msp->ms_size_tree);
! if (rs == NULL)
return (B_TRUE);
/*
* Calculate the number of 64-bit entries this segment would
* require when written to disk. If this single segment would be
* larger on-disk than the entire current on-disk structure, then
* clearly condensing will increase the on-disk structure size.
*/
! size = (rs->rs_end - rs->rs_start) >> sm->sm_shift;
entries = size / (MIN(size, SM_RUN_MAX));
segsz = entries * sizeof (uint64_t);
! return (segsz <= space_map_length(msp->ms_sm) &&
! space_map_length(msp->ms_sm) >= (zfs_condense_pct *
! sizeof (uint64_t) * avl_numnodes(&msp->ms_tree->rt_root)) / 100);
}
/*
* Condense the on-disk space map representation to its minimized form.
* The minimized form consists of a small number of allocations followed by
! * the entries of the free range tree.
*/
static void
metaslab_condense(metaslab_t *msp, uint64_t txg, dmu_tx_t *tx)
{
spa_t *spa = msp->ms_group->mg_vd->vdev_spa;
! range_tree_t *freetree = msp->ms_freetree[txg & TXG_MASK];
! range_tree_t *condense_tree;
! space_map_t *sm = msp->ms_sm;
ASSERT(MUTEX_HELD(&msp->ms_lock));
ASSERT3U(spa_sync_pass(spa), ==, 1);
! ASSERT(msp->ms_loaded);
spa_dbgmsg(spa, "condensing: txg %llu, msp[%llu] %p, "
! "smp size %llu, segments %lu", txg, msp->ms_id, msp,
! space_map_length(msp->ms_sm), avl_numnodes(&msp->ms_tree->rt_root));
/*
! * Create an range tree that is 100% allocated. We remove segments
* that have been freed in this txg, any deferred frees that exist,
* and any allocation in the future. Removing segments should be
! * a relatively inexpensive operation since we expect these trees to
! * have a small number of nodes.
*/
! condense_tree = range_tree_create(NULL, NULL, &msp->ms_lock);
! range_tree_add(condense_tree, msp->ms_start, msp->ms_size);
/*
! * Remove what's been freed in this txg from the condense_tree.
* Since we're in sync_pass 1, we know that all the frees from
! * this txg are in the freetree.
*/
! range_tree_walk(freetree, range_tree_remove, condense_tree);
! for (int t = 0; t < TXG_DEFER_SIZE; t++) {
! range_tree_walk(msp->ms_defertree[t],
! range_tree_remove, condense_tree);
! }
! for (int t = 1; t < TXG_CONCURRENT_STATES; t++) {
! range_tree_walk(msp->ms_alloctree[(txg + t) & TXG_MASK],
! range_tree_remove, condense_tree);
! }
/*
* We're about to drop the metaslab's lock thus allowing
* other consumers to change it's content. Set the
! * metaslab's ms_condensing flag to ensure that
* allocations on this metaslab do not occur while we're
* in the middle of committing it to disk. This is only critical
! * for the ms_tree as all other range trees use per txg
* views of their content.
*/
! msp->ms_condensing = B_TRUE;
mutex_exit(&msp->ms_lock);
! space_map_truncate(sm, tx);
mutex_enter(&msp->ms_lock);
/*
* While we would ideally like to create a space_map representation
* that consists only of allocation records, doing so can be
! * prohibitively expensive because the in-core free tree can be
* large, and therefore computationally expensive to subtract
! * from the condense_tree. Instead we sync out two trees, a cheap
! * allocation only tree followed by the in-core free tree. While not
* optimal, this is typically close to optimal, and much cheaper to
* compute.
*/
! space_map_write(sm, condense_tree, SM_ALLOC, tx);
! range_tree_vacate(condense_tree, NULL, NULL);
! range_tree_destroy(condense_tree);
! space_map_write(sm, msp->ms_tree, SM_FREE, tx);
! msp->ms_condensing = B_FALSE;
}
/*
* Write a metaslab to disk in the context of the specified transaction group.
*/
void
metaslab_sync(metaslab_t *msp, uint64_t txg)
{
! metaslab_group_t *mg = msp->ms_group;
! vdev_t *vd = mg->mg_vd;
spa_t *spa = vd->vdev_spa;
objset_t *mos = spa_meta_objset(spa);
! range_tree_t *alloctree = msp->ms_alloctree[txg & TXG_MASK];
! range_tree_t **freetree = &msp->ms_freetree[txg & TXG_MASK];
! range_tree_t **freed_tree =
! &msp->ms_freetree[TXG_CLEAN(txg) & TXG_MASK];
dmu_tx_t *tx;
+ uint64_t object = space_map_object(msp->ms_sm);
ASSERT(!vd->vdev_ishole);
/*
* This metaslab has just been added so there's no work to do now.
*/
! if (*freetree == NULL) {
! ASSERT3P(alloctree, ==, NULL);
return;
}
! ASSERT3P(alloctree, !=, NULL);
! ASSERT3P(*freetree, !=, NULL);
! ASSERT3P(*freed_tree, !=, NULL);
! if (range_tree_space(alloctree) == 0 &&
! range_tree_space(*freetree) == 0)
return;
/*
* The only state that can actually be changing concurrently with
! * metaslab_sync() is the metaslab's ms_tree. No other thread can
! * be modifying this txg's alloctree, freetree, freed_tree, or
! * space_map_phys_t. Therefore, we only hold ms_lock to satify
! * space_map ASSERTs. We drop it whenever we call into the DMU,
! * because the DMU can call down to us (e.g. via zio_free()) at
! * any time.
*/
tx = dmu_tx_create_assigned(spa_get_dsl(spa), txg);
! if (msp->ms_sm == NULL) {
! uint64_t new_object;
!
! new_object = space_map_alloc(mos, tx);
! VERIFY3U(new_object, !=, 0);
!
! VERIFY0(space_map_open(&msp->ms_sm, mos, new_object,
! msp->ms_start, msp->ms_size, vd->vdev_ashift,
! &msp->ms_lock));
! ASSERT(msp->ms_sm != NULL);
}
mutex_enter(&msp->ms_lock);
! if (msp->ms_loaded && spa_sync_pass(spa) == 1 &&
metaslab_should_condense(msp)) {
metaslab_condense(msp, txg, tx);
} else {
! space_map_write(msp->ms_sm, alloctree, SM_ALLOC, tx);
! space_map_write(msp->ms_sm, *freetree, SM_FREE, tx);
}
! range_tree_vacate(alloctree, NULL, NULL);
+ if (msp->ms_loaded) {
/*
! * When the space map is loaded, we have an accruate
! * histogram in the range tree. This gives us an opportunity
! * to bring the space map's histogram up-to-date so we clear
! * it first before updating it.
! */
! space_map_histogram_clear(msp->ms_sm);
! space_map_histogram_add(msp->ms_sm, msp->ms_tree, tx);
! } else {
! /*
! * Since the space map is not loaded we simply update the
! * exisiting histogram with what was freed in this txg. This
! * means that the on-disk histogram may not have an accurate
! * view of the free space but it's close enough to allow
! * us to make allocation decisions.
! */
! space_map_histogram_add(msp->ms_sm, *freetree, tx);
! }
!
! /*
! * For sync pass 1, we avoid traversing this txg's free range tree
! * and instead will just swap the pointers for freetree and
! * freed_tree. We can safely do this since the freed_tree is
* guaranteed to be empty on the initial pass.
*/
if (spa_sync_pass(spa) == 1) {
! range_tree_swap(freetree, freed_tree);
} else {
! range_tree_vacate(*freetree, range_tree_add, *freed_tree);
}
! ASSERT0(range_tree_space(msp->ms_alloctree[txg & TXG_MASK]));
! ASSERT0(range_tree_space(msp->ms_freetree[txg & TXG_MASK]));
mutex_exit(&msp->ms_lock);
! if (object != space_map_object(msp->ms_sm)) {
! object = space_map_object(msp->ms_sm);
! dmu_write(mos, vd->vdev_ms_array, sizeof (uint64_t) *
! msp->ms_id, sizeof (uint64_t), &object, tx);
! }
dmu_tx_commit(tx);
}
/*
* Called after a transaction group has completely synced to mark
*** 1285,1432 ****
* all of the metaslab's free space as usable.
*/
void
metaslab_sync_done(metaslab_t *msp, uint64_t txg)
{
- space_map_obj_t *smo = &msp->ms_smo;
- space_map_obj_t *smosync = &msp->ms_smo_syncing;
- space_map_t *sm = msp->ms_map;
- space_map_t **freed_map = &msp->ms_freemap[TXG_CLEAN(txg) & TXG_MASK];
- space_map_t **defer_map = &msp->ms_defermap[txg % TXG_DEFER_SIZE];
metaslab_group_t *mg = msp->ms_group;
vdev_t *vd = mg->mg_vd;
int64_t alloc_delta, defer_delta;
ASSERT(!vd->vdev_ishole);
mutex_enter(&msp->ms_lock);
/*
* If this metaslab is just becoming available, initialize its
! * allocmaps, freemaps, and defermap and add its capacity to the vdev.
*/
! if (*freed_map == NULL) {
! ASSERT(*defer_map == NULL);
for (int t = 0; t < TXG_SIZE; t++) {
! msp->ms_allocmap[t] = kmem_zalloc(sizeof (space_map_t),
! KM_SLEEP);
! space_map_create(msp->ms_allocmap[t], sm->sm_start,
! sm->sm_size, sm->sm_shift, sm->sm_lock);
! msp->ms_freemap[t] = kmem_zalloc(sizeof (space_map_t),
! KM_SLEEP);
! space_map_create(msp->ms_freemap[t], sm->sm_start,
! sm->sm_size, sm->sm_shift, sm->sm_lock);
}
for (int t = 0; t < TXG_DEFER_SIZE; t++) {
! msp->ms_defermap[t] = kmem_zalloc(sizeof (space_map_t),
! KM_SLEEP);
! space_map_create(msp->ms_defermap[t], sm->sm_start,
! sm->sm_size, sm->sm_shift, sm->sm_lock);
}
! freed_map = &msp->ms_freemap[TXG_CLEAN(txg) & TXG_MASK];
! defer_map = &msp->ms_defermap[txg % TXG_DEFER_SIZE];
!
! vdev_space_update(vd, 0, 0, sm->sm_size);
}
! alloc_delta = smosync->smo_alloc - smo->smo_alloc;
! defer_delta = (*freed_map)->sm_space - (*defer_map)->sm_space;
vdev_space_update(vd, alloc_delta + defer_delta, defer_delta, 0);
! ASSERT(msp->ms_allocmap[txg & TXG_MASK]->sm_space == 0);
! ASSERT(msp->ms_freemap[txg & TXG_MASK]->sm_space == 0);
/*
! * If there's a space_map_load() in progress, wait for it to complete
* so that we have a consistent view of the in-core space map.
*/
! space_map_load_wait(sm);
/*
! * Move the frees from the defer_map to this map (if it's loaded).
! * Swap the freed_map and the defer_map -- this is safe to do
! * because we've just emptied out the defer_map.
*/
! space_map_vacate(*defer_map, sm->sm_loaded ? space_map_free : NULL, sm);
! ASSERT0((*defer_map)->sm_space);
! ASSERT0(avl_numnodes(&(*defer_map)->sm_root));
! space_map_swap(freed_map, defer_map);
! *smo = *smosync;
msp->ms_deferspace += defer_delta;
ASSERT3S(msp->ms_deferspace, >=, 0);
! ASSERT3S(msp->ms_deferspace, <=, sm->sm_size);
if (msp->ms_deferspace != 0) {
/*
* Keep syncing this metaslab until all deferred frees
* are back in circulation.
*/
vdev_dirty(vd, VDD_METASLAB, msp, txg + 1);
}
! /*
! * If the map is loaded but no longer active, evict it as soon as all
! * future allocations have synced. (If we unloaded it now and then
! * loaded a moment later, the map wouldn't reflect those allocations.)
! */
! if (sm->sm_loaded && (msp->ms_weight & METASLAB_ACTIVE_MASK) == 0) {
! int evictable = 1;
! for (int t = 1; t < TXG_CONCURRENT_STATES; t++)
! if (msp->ms_allocmap[(txg + t) & TXG_MASK]->sm_space)
! evictable = 0;
!
! if (evictable && !metaslab_debug)
! space_map_unload(sm);
}
metaslab_group_sort(mg, msp, metaslab_weight(msp));
-
mutex_exit(&msp->ms_lock);
}
void
metaslab_sync_reassess(metaslab_group_t *mg)
{
- vdev_t *vd = mg->mg_vd;
int64_t failures = mg->mg_alloc_failures;
metaslab_group_alloc_update(mg);
-
- /*
- * Re-evaluate all metaslabs which have lower offsets than the
- * bonus area.
- */
- for (int m = 0; m < vd->vdev_ms_count; m++) {
- metaslab_t *msp = vd->vdev_ms[m];
-
- if (msp->ms_map->sm_start > mg->mg_bonus_area)
- break;
-
- mutex_enter(&msp->ms_lock);
- metaslab_group_sort(mg, msp, metaslab_weight(msp));
- mutex_exit(&msp->ms_lock);
- }
-
atomic_add_64(&mg->mg_alloc_failures, -failures);
/*
! * Prefetch the next potential metaslabs
*/
! metaslab_prefetch(mg);
}
static uint64_t
metaslab_distance(metaslab_t *msp, dva_t *dva)
{
uint64_t ms_shift = msp->ms_group->mg_vd->vdev_ms_shift;
uint64_t offset = DVA_GET_OFFSET(dva) >> ms_shift;
! uint64_t start = msp->ms_map->sm_start >> ms_shift;
if (msp->ms_group->mg_vd->vdev_id != DVA_GET_VDEV(dva))
return (1ULL << 63);
if (offset < start)
--- 1514,1635 ----
* all of the metaslab's free space as usable.
*/
void
metaslab_sync_done(metaslab_t *msp, uint64_t txg)
{
metaslab_group_t *mg = msp->ms_group;
vdev_t *vd = mg->mg_vd;
+ range_tree_t **freed_tree;
+ range_tree_t **defer_tree;
int64_t alloc_delta, defer_delta;
ASSERT(!vd->vdev_ishole);
mutex_enter(&msp->ms_lock);
/*
* If this metaslab is just becoming available, initialize its
! * alloctrees, freetrees, and defertree and add its capacity to
! * the vdev.
*/
! if (msp->ms_freetree[TXG_CLEAN(txg) & TXG_MASK] == NULL) {
for (int t = 0; t < TXG_SIZE; t++) {
! ASSERT(msp->ms_alloctree[t] == NULL);
! ASSERT(msp->ms_freetree[t] == NULL);
!
! msp->ms_alloctree[t] = range_tree_create(NULL, msp,
! &msp->ms_lock);
! msp->ms_freetree[t] = range_tree_create(NULL, msp,
! &msp->ms_lock);
}
for (int t = 0; t < TXG_DEFER_SIZE; t++) {
! ASSERT(msp->ms_defertree[t] == NULL);
!
! msp->ms_defertree[t] = range_tree_create(NULL, msp,
! &msp->ms_lock);
}
! vdev_space_update(vd, 0, 0, msp->ms_size);
}
! freed_tree = &msp->ms_freetree[TXG_CLEAN(txg) & TXG_MASK];
! defer_tree = &msp->ms_defertree[txg % TXG_DEFER_SIZE];
+ alloc_delta = space_map_alloc_delta(msp->ms_sm);
+ defer_delta = range_tree_space(*freed_tree) -
+ range_tree_space(*defer_tree);
+
vdev_space_update(vd, alloc_delta + defer_delta, defer_delta, 0);
! ASSERT0(range_tree_space(msp->ms_alloctree[txg & TXG_MASK]));
! ASSERT0(range_tree_space(msp->ms_freetree[txg & TXG_MASK]));
/*
! * If there's a metaslab_load() in progress, wait for it to complete
* so that we have a consistent view of the in-core space map.
*/
! metaslab_load_wait(msp);
/*
! * Move the frees from the defer_tree back to the free
! * range tree (if it's loaded). Swap the freed_tree and the
! * defer_tree -- this is safe to do because we've just emptied out
! * the defer_tree.
*/
! range_tree_vacate(*defer_tree,
! msp->ms_loaded ? range_tree_add : NULL, msp->ms_tree);
! range_tree_swap(freed_tree, defer_tree);
! space_map_update(msp->ms_sm);
msp->ms_deferspace += defer_delta;
ASSERT3S(msp->ms_deferspace, >=, 0);
! ASSERT3S(msp->ms_deferspace, <=, msp->ms_size);
if (msp->ms_deferspace != 0) {
/*
* Keep syncing this metaslab until all deferred frees
* are back in circulation.
*/
vdev_dirty(vd, VDD_METASLAB, msp, txg + 1);
}
! if (msp->ms_loaded && msp->ms_access_txg < txg) {
! for (int t = 1; t < TXG_CONCURRENT_STATES; t++) {
! VERIFY0(range_tree_space(
! msp->ms_alloctree[(txg + t) & TXG_MASK]));
! }
! if (!metaslab_debug_unload)
! metaslab_unload(msp);
}
metaslab_group_sort(mg, msp, metaslab_weight(msp));
mutex_exit(&msp->ms_lock);
+
}
void
metaslab_sync_reassess(metaslab_group_t *mg)
{
int64_t failures = mg->mg_alloc_failures;
metaslab_group_alloc_update(mg);
atomic_add_64(&mg->mg_alloc_failures, -failures);
/*
! * Preload the next potential metaslabs
*/
! metaslab_group_preload(mg);
}
static uint64_t
metaslab_distance(metaslab_t *msp, dva_t *dva)
{
uint64_t ms_shift = msp->ms_group->mg_vd->vdev_ms_shift;
uint64_t offset = DVA_GET_OFFSET(dva) >> ms_shift;
! uint64_t start = msp->ms_id;
if (msp->ms_group->mg_vd->vdev_id != DVA_GET_VDEV(dva))
return (1ULL << 63);
if (offset < start)
*** 1474,1492 ****
}
/*
* If the selected metaslab is condensing, skip it.
*/
! if (msp->ms_map->sm_condensing)
continue;
was_active = msp->ms_weight & METASLAB_ACTIVE_MASK;
if (activation_weight == METASLAB_WEIGHT_PRIMARY)
break;
target_distance = min_distance +
! (msp->ms_smo.smo_alloc ? 0 : min_distance >> 1);
for (i = 0; i < d; i++)
if (metaslab_distance(msp, &dva[i]) <
target_distance)
break;
--- 1677,1696 ----
}
/*
* If the selected metaslab is condensing, skip it.
*/
! if (msp->ms_condensing)
continue;
was_active = msp->ms_weight & METASLAB_ACTIVE_MASK;
if (activation_weight == METASLAB_WEIGHT_PRIMARY)
break;
target_distance = min_distance +
! (space_map_allocated(msp->ms_sm) != 0 ? 0 :
! min_distance >> 1);
for (i = 0; i < d; i++)
if (metaslab_distance(msp, &dva[i]) <
target_distance)
break;
*** 1509,1521 ****
*/
if (mg->mg_alloc_failures > zfs_mg_alloc_failures &&
CAN_FASTGANG(flags) && psize > SPA_GANGBLOCKSIZE &&
activation_weight == METASLAB_WEIGHT_PRIMARY) {
spa_dbgmsg(spa, "%s: skipping metaslab group: "
! "vdev %llu, txg %llu, mg %p, psize %llu, "
! "asize %llu, failures %llu", spa_name(spa),
! mg->mg_vd->vdev_id, txg, mg, psize, asize,
mg->mg_alloc_failures);
mutex_exit(&msp->ms_lock);
return (-1ULL);
}
--- 1713,1726 ----
*/
if (mg->mg_alloc_failures > zfs_mg_alloc_failures &&
CAN_FASTGANG(flags) && psize > SPA_GANGBLOCKSIZE &&
activation_weight == METASLAB_WEIGHT_PRIMARY) {
spa_dbgmsg(spa, "%s: skipping metaslab group: "
! "vdev %llu, txg %llu, mg %p, msp[%llu] %p, "
! "psize %llu, asize %llu, failures %llu",
! spa_name(spa), mg->mg_vd->vdev_id, txg, mg,
! msp->ms_id, msp, psize, asize,
mg->mg_alloc_failures);
mutex_exit(&msp->ms_lock);
return (-1ULL);
}
*** 1548,1576 ****
/*
* If this metaslab is currently condensing then pick again as
* we can't manipulate this metaslab until it's committed
* to disk.
*/
! if (msp->ms_map->sm_condensing) {
mutex_exit(&msp->ms_lock);
continue;
}
! if ((offset = space_map_alloc(msp->ms_map, asize)) != -1ULL)
break;
atomic_inc_64(&mg->mg_alloc_failures);
! metaslab_passivate(msp, space_map_maxsize(msp->ms_map));
!
mutex_exit(&msp->ms_lock);
}
! if (msp->ms_allocmap[txg & TXG_MASK]->sm_space == 0)
vdev_dirty(mg->mg_vd, VDD_METASLAB, msp, txg);
! space_map_add(msp->ms_allocmap[txg & TXG_MASK], offset, asize);
mutex_exit(&msp->ms_lock);
return (offset);
}
--- 1753,1781 ----
/*
* If this metaslab is currently condensing then pick again as
* we can't manipulate this metaslab until it's committed
* to disk.
*/
! if (msp->ms_condensing) {
mutex_exit(&msp->ms_lock);
continue;
}
! if ((offset = metaslab_block_alloc(msp, asize)) != -1ULL)
break;
atomic_inc_64(&mg->mg_alloc_failures);
! metaslab_passivate(msp, metaslab_block_maxsize(msp));
mutex_exit(&msp->ms_lock);
}
! if (range_tree_space(msp->ms_alloctree[txg & TXG_MASK]) == 0)
vdev_dirty(mg->mg_vd, VDD_METASLAB, msp, txg);
! range_tree_add(msp->ms_alloctree[txg & TXG_MASK], offset, asize);
! msp->ms_access_txg = txg + metaslab_unload_delay;
mutex_exit(&msp->ms_lock);
return (offset);
}
*** 1813,1829 ****
size = vdev_psize_to_asize(vd, SPA_GANGBLOCKSIZE);
mutex_enter(&msp->ms_lock);
if (now) {
! space_map_remove(msp->ms_allocmap[txg & TXG_MASK],
offset, size);
! space_map_free(msp->ms_map, offset, size);
} else {
! if (msp->ms_freemap[txg & TXG_MASK]->sm_space == 0)
vdev_dirty(vd, VDD_METASLAB, msp, txg);
! space_map_add(msp->ms_freemap[txg & TXG_MASK], offset, size);
}
mutex_exit(&msp->ms_lock);
}
--- 2018,2043 ----
size = vdev_psize_to_asize(vd, SPA_GANGBLOCKSIZE);
mutex_enter(&msp->ms_lock);
if (now) {
! range_tree_remove(msp->ms_alloctree[txg & TXG_MASK],
offset, size);
!
! VERIFY(!msp->ms_condensing);
! VERIFY3U(offset, >=, msp->ms_start);
! VERIFY3U(offset + size, <=, msp->ms_start + msp->ms_size);
! VERIFY3U(range_tree_space(msp->ms_tree) + size, <=,
! msp->ms_size);
! VERIFY0(P2PHASE(offset, 1ULL << vd->vdev_ashift));
! VERIFY0(P2PHASE(size, 1ULL << vd->vdev_ashift));
! range_tree_add(msp->ms_tree, offset, size);
} else {
! if (range_tree_space(msp->ms_freetree[txg & TXG_MASK]) == 0)
vdev_dirty(vd, VDD_METASLAB, msp, txg);
! range_tree_add(msp->ms_freetree[txg & TXG_MASK],
! offset, size);
}
mutex_exit(&msp->ms_lock);
}
*** 1854,1880 ****
if (DVA_GET_GANG(dva))
size = vdev_psize_to_asize(vd, SPA_GANGBLOCKSIZE);
mutex_enter(&msp->ms_lock);
! if ((txg != 0 && spa_writeable(spa)) || !msp->ms_map->sm_loaded)
error = metaslab_activate(msp, METASLAB_WEIGHT_SECONDARY);
! if (error == 0 && !space_map_contains(msp->ms_map, offset, size))
error = SET_ERROR(ENOENT);
if (error || txg == 0) { /* txg == 0 indicates dry run */
mutex_exit(&msp->ms_lock);
return (error);
}
! space_map_claim(msp->ms_map, offset, size);
if (spa_writeable(spa)) { /* don't dirty if we're zdb(1M) */
! if (msp->ms_allocmap[txg & TXG_MASK]->sm_space == 0)
vdev_dirty(vd, VDD_METASLAB, msp, txg);
! space_map_add(msp->ms_allocmap[txg & TXG_MASK], offset, size);
}
mutex_exit(&msp->ms_lock);
return (0);
--- 2068,2098 ----
if (DVA_GET_GANG(dva))
size = vdev_psize_to_asize(vd, SPA_GANGBLOCKSIZE);
mutex_enter(&msp->ms_lock);
! if ((txg != 0 && spa_writeable(spa)) || !msp->ms_loaded)
error = metaslab_activate(msp, METASLAB_WEIGHT_SECONDARY);
! if (error == 0 && !range_tree_contains(msp->ms_tree, offset, size))
error = SET_ERROR(ENOENT);
if (error || txg == 0) { /* txg == 0 indicates dry run */
mutex_exit(&msp->ms_lock);
return (error);
}
! VERIFY(!msp->ms_condensing);
! VERIFY0(P2PHASE(offset, 1ULL << vd->vdev_ashift));
! VERIFY0(P2PHASE(size, 1ULL << vd->vdev_ashift));
! VERIFY3U(range_tree_space(msp->ms_tree) - size, <=, msp->ms_size);
! range_tree_remove(msp->ms_tree, offset, size);
if (spa_writeable(spa)) { /* don't dirty if we're zdb(1M) */
! if (range_tree_space(msp->ms_alloctree[txg & TXG_MASK]) == 0)
vdev_dirty(vd, VDD_METASLAB, msp, txg);
! range_tree_add(msp->ms_alloctree[txg & TXG_MASK], offset, size);
}
mutex_exit(&msp->ms_lock);
return (0);
*** 1903,1913 ****
ASSERT(hintbp == NULL || ndvas <= BP_GET_NDVAS(hintbp));
for (int d = 0; d < ndvas; d++) {
error = metaslab_alloc_dva(spa, mc, psize, dva, d, hintdva,
txg, flags);
! if (error) {
for (d--; d >= 0; d--) {
metaslab_free_dva(spa, &dva[d], txg, B_TRUE);
bzero(&dva[d], sizeof (dva_t));
}
spa_config_exit(spa, SCL_ALLOC, FTAG);
--- 2121,2131 ----
ASSERT(hintbp == NULL || ndvas <= BP_GET_NDVAS(hintbp));
for (int d = 0; d < ndvas; d++) {
error = metaslab_alloc_dva(spa, mc, psize, dva, d, hintdva,
txg, flags);
! if (error != 0) {
for (d--; d >= 0; d--) {
metaslab_free_dva(spa, &dva[d], txg, B_TRUE);
bzero(&dva[d], sizeof (dva_t));
}
spa_config_exit(spa, SCL_ALLOC, FTAG);
*** 1970,2011 ****
ASSERT(error == 0 || txg == 0);
return (error);
}
- static void
- checkmap(space_map_t *sm, uint64_t off, uint64_t size)
- {
- space_seg_t *ss;
- avl_index_t where;
-
- mutex_enter(sm->sm_lock);
- ss = space_map_find(sm, off, size, &where);
- if (ss != NULL)
- panic("freeing free block; ss=%p", (void *)ss);
- mutex_exit(sm->sm_lock);
- }
-
void
metaslab_check_free(spa_t *spa, const blkptr_t *bp)
{
if ((zfs_flags & ZFS_DEBUG_ZIO_FREE) == 0)
return;
spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
for (int i = 0; i < BP_GET_NDVAS(bp); i++) {
! uint64_t vdid = DVA_GET_VDEV(&bp->blk_dva[i]);
! vdev_t *vd = vdev_lookup_top(spa, vdid);
! uint64_t off = DVA_GET_OFFSET(&bp->blk_dva[i]);
uint64_t size = DVA_GET_ASIZE(&bp->blk_dva[i]);
! metaslab_t *ms = vd->vdev_ms[off >> vd->vdev_ms_shift];
! if (ms->ms_map->sm_loaded)
! checkmap(ms->ms_map, off, size);
for (int j = 0; j < TXG_SIZE; j++)
! checkmap(ms->ms_freemap[j], off, size);
for (int j = 0; j < TXG_DEFER_SIZE; j++)
! checkmap(ms->ms_defermap[j], off, size);
}
spa_config_exit(spa, SCL_VDEV, FTAG);
}
--- 2188,2216 ----
ASSERT(error == 0 || txg == 0);
return (error);
}
void
metaslab_check_free(spa_t *spa, const blkptr_t *bp)
{
if ((zfs_flags & ZFS_DEBUG_ZIO_FREE) == 0)
return;
spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
for (int i = 0; i < BP_GET_NDVAS(bp); i++) {
! uint64_t vdev = DVA_GET_VDEV(&bp->blk_dva[i]);
! vdev_t *vd = vdev_lookup_top(spa, vdev);
! uint64_t offset = DVA_GET_OFFSET(&bp->blk_dva[i]);
uint64_t size = DVA_GET_ASIZE(&bp->blk_dva[i]);
! metaslab_t *msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
! if (msp->ms_loaded)
! range_tree_verify(msp->ms_tree, offset, size);
for (int j = 0; j < TXG_SIZE; j++)
! range_tree_verify(msp->ms_freetree[j], offset, size);
for (int j = 0; j < TXG_DEFER_SIZE; j++)
! range_tree_verify(msp->ms_defertree[j], offset, size);
}
spa_config_exit(spa, SCL_VDEV, FTAG);
}