Fix problem with terminating on unaligned sizes

Three separate little issues:

- Don't round up the number of blocks needed. That means we end
  up with potential partial blocks, which we can never do IO to.

- Fix an axmap bug where we only check against the specific bit
  in the mask, but we really want to check for "this bit or any
  higher bit". This makes axmap_next_free() behave more like it
  should, instead of failing way too often.

- For the almost-full case, we can return a next available bit
  that is just outside the allowed range. Punt to first-free for
  that case.

Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/filesetup.c b/filesetup.c
index 5aadf126311b9322668c3e835b673126949fa4d5..ac1804bdf42daca3204d8385da0e0c7a9a1f4320 100644 (file)
--- a/filesetup.c
+++ b/filesetup.c
@@ -958,8 +958,8 @@ int init_random_map(struct thread_data *td)
        for_each_file(td, f, i) {
                uint64_t file_size = min(f->real_file_size, f->io_size);
 
-               blocks = (file_size + td->o.rw_min_bs - 1) /
-                               (unsigned long long) td->o.rw_min_bs;
+               blocks = file_size / (unsigned long long) td->o.rw_min_bs;
+
                if (td->o.random_generator == FIO_RAND_GEN_LFSR) {
                        unsigned long seed;
 

diff --git a/lib/axmap.c b/lib/axmap.c
index 533a155c7243ea5195b19baae6d023cbc23335b2..eeb32d42a6085e096bdde44fc39f057d9853b8da 100644 (file)
--- a/lib/axmap.c
+++ b/lib/axmap.c
@@ -374,9 +374,9 @@ static int axmap_next_free_fn(struct axmap_level *al, unsigned long offset,
                               unsigned int bit, void *__data)
 {
        struct axmap_next_free_data *data = __data;
-       uint64_t mask = ~((1UL << ((data->bit & BLOCKS_PER_UNIT_MASK) + 1)) - 1);
+       uint64_t mask = ~bit_masks[(data->bit + 1) & BLOCKS_PER_UNIT_MASK];
 
-       if (!(mask & al->map[offset]))
+       if (!(mask & ~al->map[offset]))
                return 0;
 
        if (al->map[offset] != -1UL) {
@@ -395,6 +395,7 @@ static int axmap_next_free_fn(struct axmap_level *al, unsigned long offset,
 uint64_t axmap_next_free(struct axmap *axmap, uint64_t bit_nr)
 {
        struct axmap_next_free_data data = { .level = -1U, .bit = bit_nr, };
+       uint64_t ret;
 
        if (firstfree_valid(axmap) && bit_nr < axmap->first_free)
                return axmap->first_free;
@@ -404,5 +405,14 @@ uint64_t axmap_next_free(struct axmap *axmap, uint64_t bit_nr)
 
        assert(data.level != -1U);
 
-       return axmap_find_first_free(axmap, data.level, data.offset);
+       /*
+        * In the rare case that the map is unaligned, we might end up
+        * finding an offset that's beyond the valid end. For that case,
+        * find the first free one, the map is practically full.
+        */
+       ret = axmap_find_first_free(axmap, data.level, data.offset);
+       if (ret != -1ULL)
+               return ret;
+
+       return axmap_first_free(axmap);
 }