Archive-Team
/
zfs
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 103 Wiki Activity

Tricky semantics of ms_max_size in metaslab_should_allocate() 

metaslab_should_allocate() is used in two places:
[1] When trying to select a metaslab to allocate from
[2] When trying to allocate from a metaslab

In [2] we always expect the metaslab to be loaded, and after
the refactoring of the log spacemap changes, whenever we load
a metaslab we set ms_max_size to the biggest range in the
ms_allocatable tree. Thus, when it is used in [2], if that
field is 0, it means that the metaslab doesn't have any
segments that can be used for allocations now (though it may
have some free space but that space can be in the freeing,
freed, or deferred trees).

In [1] a metaslab can be loaded or unloaded at which point 0
can either mean the metaslab doesn't have any space or the
metaslab is just not loaded thus we go ahead and try to make
an estimation based on its weight.

The issue here is when we call the above function for [2] and
the metaslab doesn't have any allocatable space, we still go
ahead and check its ms_weight which may be out of date because
we haven't ran metaslab_sync_done() yet. At that point we are
allowing an allocation to be attempted even though we know
there is no range that is allocatable.

This patch fixes this issue by explicitly checking if the
metaslab is loaded and if it is, the ms_max_size is used.

Reviewed-by: Matt Ahrens <mahrens@delphix.com>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Serapheim Dimitropoulos <serapheim@delphix.com>
Closes #9045
This commit is contained in:
Serapheim Dimitropoulos 2019-07-19 11:19:50 -07:00 committed by Brian Behlendorf
parent 43a8536260
commit 7f31908913
1 changed files with 10 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
module/zfs/metaslab.c
View File

@ -2511,18 +2511,21 @@ metaslab_segment_weight(metaslab_t *msp)
/* /*
* Determine if we should attempt to allocate from this metaslab. If the * Determine if we should attempt to allocate from this metaslab. If the
* metaslab has a maximum size then we can quickly determine if the desired * metaslab is loaded, then we can determine if the desired allocation
* allocation size can be satisfied. Otherwise, if we're using segment-based * can be satisfied by looking at the size of the maximum free segment
* weighting then we can determine the maximum allocation that this metaslab * on that metaslab. Otherwise, we make our decision based on the metaslab's
* can accommodate based on the index encoded in the weight. If we're using * weight. For segment-based weighting we can determine the maximum
* space-based weights then rely on the entire weight (excluding the weight * allocation based on the index encoded in its value. For space-based
* type bit). * weights we rely on the entire weight (excluding the weight-type bit).
*/ */
boolean_t boolean_t
metaslab_should_allocate(metaslab_t *msp, uint64_t asize) metaslab_should_allocate(metaslab_t *msp, uint64_t asize)
{ {
if (msp->ms_max_size != 0) if (msp->ms_loaded) {
return (msp->ms_max_size >= asize); return (msp->ms_max_size >= asize);
} else {
ASSERT0(msp->ms_max_size);
}
boolean_t should_allocate; boolean_t should_allocate;
if (!WEIGHT_IS_SPACEBASED(msp->ms_weight)) { if (!WEIGHT_IS_SPACEBASED(msp->ms_weight)) {