drivers/md/persistent-data/dm-space-map-checker.c

   1 /*
   2  * Copyright (C) 2011 Red Hat, Inc.
   3  *
   4  * This file is released under the GPL.
   5  */
   6
   7 #include "dm-space-map-checker.h"
   8
   9 #include <linux/device-mapper.h>
  10 #include <linux/export.h>
  11
  12 #ifdef CONFIG_DM_DEBUG_SPACE_MAPS
  13
  14 #define DM_MSG_PREFIX "space map checker"
  15
  16 /*----------------------------------------------------------------*/
  17
  18 struct count_array {
  19         dm_block_t nr;
  20         dm_block_t nr_free;
  21
  22         uint32_t *counts;
  23 };
  24
  25 static int ca_get_count(struct count_array *ca, dm_block_t b, uint32_t *count)
  26 {
  27         if (b >= ca->nr)
  28                 return -EINVAL;
  29
  30         *count = ca->counts[b];
  31         return 0;
  32 }
  33
  34 static int ca_count_more_than_one(struct count_array *ca, dm_block_t b, int *r)
  35 {
  36         if (b >= ca->nr)
  37                 return -EINVAL;
  38
  39         *r = ca->counts[b] > 1;
  40         return 0;
  41 }
  42
  43 static int ca_set_count(struct count_array *ca, dm_block_t b, uint32_t count)
  44 {
  45         uint32_t old_count;
  46
  47         if (b >= ca->nr)
  48                 return -EINVAL;
  49
  50         old_count = ca->counts[b];
  51
  52         if (!count && old_count)
  53                 ca->nr_free++;
  54
  55         else if (count && !old_count)
  56                 ca->nr_free--;
  57
  58         ca->counts[b] = count;
  59         return 0;
  60 }
  61
  62 static int ca_inc_block(struct count_array *ca, dm_block_t b)
  63 {
  64         if (b >= ca->nr)
  65                 return -EINVAL;
  66
  67         ca_set_count(ca, b, ca->counts[b] + 1);
  68         return 0;
  69 }
  70
  71 static int ca_dec_block(struct count_array *ca, dm_block_t b)
  72 {
  73         if (b >= ca->nr)
  74                 return -EINVAL;
  75
  76         BUG_ON(ca->counts[b] == 0);
  77         ca_set_count(ca, b, ca->counts[b] - 1);
  78         return 0;
  79 }
  80
  81 static int ca_create(struct count_array *ca, struct dm_space_map *sm)
  82 {
  83         int r;
  84         dm_block_t nr_blocks;
  85
  86         r = dm_sm_get_nr_blocks(sm, &nr_blocks);
  87         if (r)
  88                 return r;
  89
  90         ca->nr = nr_blocks;
  91         ca->nr_free = nr_blocks;
  92         ca->counts = kzalloc(sizeof(*ca->counts) * nr_blocks, GFP_KERNEL);
  93         if (!ca->counts)
  94                 return -ENOMEM;
  95
  96         return 0;
  97 }
  98
  99 static int ca_load(struct count_array *ca, struct dm_space_map *sm)
 100 {
 101         int r;
 102         uint32_t count;
 103         dm_block_t nr_blocks, i;
 104
 105         r = dm_sm_get_nr_blocks(sm, &nr_blocks);
 106         if (r)
 107                 return r;
 108
 109         BUG_ON(ca->nr != nr_blocks);
 110
 111         DMWARN("Loading debug space map from disk.  This may take some time");
 112         for (i = 0; i < nr_blocks; i++) {
 113                 r = dm_sm_get_count(sm, i, &count);
 114                 if (r) {
 115                         DMERR("load failed");
 116                         return r;
 117                 }
 118
 119                 ca_set_count(ca, i, count);
 120         }
 121         DMWARN("Load complete");
 122
 123         return 0;
 124 }
 125
 126 static int ca_extend(struct count_array *ca, dm_block_t extra_blocks)
 127 {
 128         dm_block_t nr_blocks = ca->nr + extra_blocks;
 129         uint32_t *counts = kzalloc(sizeof(*counts) * nr_blocks, GFP_KERNEL);
 130         if (!counts)
 131                 return -ENOMEM;
 132
 133         memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
 134         kfree(ca->counts);
 135         ca->nr = nr_blocks;
 136         ca->nr_free += extra_blocks;
 137         ca->counts = counts;
 138         return 0;
 139 }
 140
 141 static int ca_commit(struct count_array *old, struct count_array *new)
 142 {
 143         if (old->nr != new->nr) {
 144                 BUG_ON(old->nr > new->nr);
 145                 ca_extend(old, new->nr - old->nr);
 146         }
 147
 148         BUG_ON(old->nr != new->nr);
 149         old->nr_free = new->nr_free;
 150         memcpy(old->counts, new->counts, sizeof(*old->counts) * old->nr);
 151         return 0;
 152 }
 153
 154 static void ca_destroy(struct count_array *ca)
 155 {
 156         kfree(ca->counts);
 157 }
 158
 159 /*----------------------------------------------------------------*/
 160
 161 struct sm_checker {
 162         struct dm_space_map sm;
 163
 164         struct count_array old_counts;
 165         struct count_array counts;
 166
 167         struct dm_space_map *real_sm;
 168 };
 169
 170 static void sm_checker_destroy(struct dm_space_map *sm)
 171 {
 172         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 173
 174         dm_sm_destroy(smc->real_sm);
 175         ca_destroy(&smc->old_counts);
 176         ca_destroy(&smc->counts);
 177         kfree(smc);
 178 }
 179
 180 static int sm_checker_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count)
 181 {
 182         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 183         int r = dm_sm_get_nr_blocks(smc->real_sm, count);
 184         if (!r)
 185                 BUG_ON(smc->old_counts.nr != *count);
 186         return r;
 187 }
 188
 189 static int sm_checker_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
 190 {
 191         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 192         int r = dm_sm_get_nr_free(smc->real_sm, count);
 193         if (!r) {
 194                 /*
 195                  * Slow, but we know it's correct.
 196                  */
 197                 dm_block_t b, n = 0;
 198                 for (b = 0; b < smc->old_counts.nr; b++)
 199                         if (smc->old_counts.counts[b] == 0 &&
 200                             smc->counts.counts[b] == 0)
 201                                 n++;
 202
 203                 if (n != *count)
 204                         DMERR("free block counts differ, checker %u, sm-disk:%u",
 205                               (unsigned) n, (unsigned) *count);
 206         }
 207         return r;
 208 }
 209
 210 static int sm_checker_new_block(struct dm_space_map *sm, dm_block_t *b)
 211 {
 212         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 213         int r = dm_sm_new_block(smc->real_sm, b);
 214
 215         if (!r) {
 216                 BUG_ON(*b >= smc->old_counts.nr);
 217                 BUG_ON(smc->old_counts.counts[*b] != 0);
 218                 BUG_ON(*b >= smc->counts.nr);
 219                 BUG_ON(smc->counts.counts[*b] != 0);
 220                 ca_set_count(&smc->counts, *b, 1);
 221         }
 222
 223         return r;
 224 }
 225
 226 static int sm_checker_inc_block(struct dm_space_map *sm, dm_block_t b)
 227 {
 228         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 229         int r = dm_sm_inc_block(smc->real_sm, b);
 230         int r2 = ca_inc_block(&smc->counts, b);
 231         BUG_ON(r != r2);
 232         return r;
 233 }
 234
 235 static int sm_checker_dec_block(struct dm_space_map *sm, dm_block_t b)
 236 {
 237         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 238         int r = dm_sm_dec_block(smc->real_sm, b);
 239         int r2 = ca_dec_block(&smc->counts, b);
 240         BUG_ON(r != r2);
 241         return r;
 242 }
 243
 244 static int sm_checker_get_count(struct dm_space_map *sm, dm_block_t b, uint32_t *result)
 245 {
 246         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 247         uint32_t result2 = 0;
 248         int r = dm_sm_get_count(smc->real_sm, b, result);
 249         int r2 = ca_get_count(&smc->counts, b, &result2);
 250
 251         BUG_ON(r != r2);
 252         if (!r)
 253                 BUG_ON(*result != result2);
 254         return r;
 255 }
 256
 257 static int sm_checker_count_more_than_one(struct dm_space_map *sm, dm_block_t b, int *result)
 258 {
 259         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 260         int result2 = 0;
 261         int r = dm_sm_count_is_more_than_one(smc->real_sm, b, result);
 262         int r2 = ca_count_more_than_one(&smc->counts, b, &result2);
 263
 264         BUG_ON(r != r2);
 265         if (!r)
 266                 BUG_ON(!(*result) && result2);
 267         return r;
 268 }
 269
 270 static int sm_checker_set_count(struct dm_space_map *sm, dm_block_t b, uint32_t count)
 271 {
 272         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 273         uint32_t old_rc;
 274         int r = dm_sm_set_count(smc->real_sm, b, count);
 275         int r2;
 276
 277         BUG_ON(b >= smc->counts.nr);
 278         old_rc = smc->counts.counts[b];
 279         r2 = ca_set_count(&smc->counts, b, count);
 280         BUG_ON(r != r2);
 281
 282         return r;
 283 }
 284
 285 static int sm_checker_commit(struct dm_space_map *sm)
 286 {
 287         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 288         int r;
 289
 290         r = dm_sm_commit(smc->real_sm);
 291         if (r)
 292                 return r;
 293
 294         r = ca_commit(&smc->old_counts, &smc->counts);
 295         if (r)
 296                 return r;
 297
 298         return 0;
 299 }
 300
 301 static int sm_checker_extend(struct dm_space_map *sm, dm_block_t extra_blocks)
 302 {
 303         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 304         int r = dm_sm_extend(smc->real_sm, extra_blocks);
 305         if (r)
 306                 return r;
 307
 308         return ca_extend(&smc->counts, extra_blocks);
 309 }
 310
 311 static int sm_checker_root_size(struct dm_space_map *sm, size_t *result)
 312 {
 313         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 314         return dm_sm_root_size(smc->real_sm, result);
 315 }
 316
 317 static int sm_checker_copy_root(struct dm_space_map *sm, void *copy_to_here_le, size_t len)
 318 {
 319         struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
 320         return dm_sm_copy_root(smc->real_sm, copy_to_here_le, len);
 321 }
 322
 323 /*----------------------------------------------------------------*/
 324
 325 static struct dm_space_map ops_ = {
 326         .destroy = sm_checker_destroy,
 327         .get_nr_blocks = sm_checker_get_nr_blocks,
 328         .get_nr_free = sm_checker_get_nr_free,
 329         .inc_block = sm_checker_inc_block,
 330         .dec_block = sm_checker_dec_block,
 331         .new_block = sm_checker_new_block,
 332         .get_count = sm_checker_get_count,
 333         .count_is_more_than_one = sm_checker_count_more_than_one,
 334         .set_count = sm_checker_set_count,
 335         .commit = sm_checker_commit,
 336         .extend = sm_checker_extend,
 337         .root_size = sm_checker_root_size,
 338         .copy_root = sm_checker_copy_root
 339 };
 340
 341 struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
 342 {
 343         int r;
 344         struct sm_checker *smc;
 345
 346         if (!sm)
 347                 return NULL;
 348
 349         smc = kmalloc(sizeof(*smc), GFP_KERNEL);
 350         if (!smc)
 351                 return NULL;
 352
 353         memcpy(&smc->sm, &ops_, sizeof(smc->sm));
 354         r = ca_create(&smc->old_counts, sm);
 355         if (r) {
 356                 kfree(smc);
 357                 return NULL;
 358         }
 359
 360         r = ca_create(&smc->counts, sm);
 361         if (r) {
 362                 ca_destroy(&smc->old_counts);
 363                 kfree(smc);
 364                 return NULL;
 365         }
 366
 367         smc->real_sm = sm;
 368
 369         r = ca_load(&smc->counts, sm);
 370         if (r) {
 371                 ca_destroy(&smc->counts);
 372                 ca_destroy(&smc->old_counts);
 373                 kfree(smc);
 374                 return NULL;
 375         }
 376
 377         r = ca_commit(&smc->old_counts, &smc->counts);
 378         if (r) {
 379                 ca_destroy(&smc->counts);
 380                 ca_destroy(&smc->old_counts);
 381                 kfree(smc);
 382                 return NULL;
 383         }
 384
 385         return &smc->sm;
 386 }
 387 EXPORT_SYMBOL_GPL(dm_sm_checker_create);
 388
 389 struct dm_space_map *dm_sm_checker_create_fresh(struct dm_space_map *sm)
 390 {
 391         int r;
 392         struct sm_checker *smc;
 393
 394         if (!sm)
 395                 return NULL;
 396
 397         smc = kmalloc(sizeof(*smc), GFP_KERNEL);
 398         if (!smc)
 399                 return NULL;
 400
 401         memcpy(&smc->sm, &ops_, sizeof(smc->sm));
 402         r = ca_create(&smc->old_counts, sm);
 403         if (r) {
 404                 kfree(smc);
 405                 return NULL;
 406         }
 407
 408         r = ca_create(&smc->counts, sm);
 409         if (r) {
 410                 ca_destroy(&smc->old_counts);
 411                 kfree(smc);
 412                 return NULL;
 413         }
 414
 415         smc->real_sm = sm;
 416         return &smc->sm;
 417 }
 418 EXPORT_SYMBOL_GPL(dm_sm_checker_create_fresh);
 419
 420 /*----------------------------------------------------------------*/
 421
 422 #else
 423
 424 struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
 425 {
 426         return sm;
 427 }
 428 EXPORT_SYMBOL_GPL(dm_sm_checker_create);
 429
 430 struct dm_space_map *dm_sm_checker_create_fresh(struct dm_space_map *sm)
 431 {
 432         return sm;
 433 }
 434 EXPORT_SYMBOL_GPL(dm_sm_checker_create_fresh);
 435
 436 /*----------------------------------------------------------------*/
 437
 438 #endif