drivers/md/persistent-data/dm-transaction-manager.c

   1 /*
   2  * Copyright (C) 2011 Red Hat, Inc.
   3  *
   4  * This file is released under the GPL.
   5  */
   6 #include "dm-transaction-manager.h"
   7 #include "dm-space-map.h"
   8 #include "dm-space-map-disk.h"
   9 #include "dm-space-map-metadata.h"
  10 #include "dm-persistent-data-internal.h"
  11
  12 #include <linux/export.h>
  13 #include <linux/slab.h>
  14 #include <linux/device-mapper.h>
  15
  16 #define DM_MSG_PREFIX "transaction manager"
  17
  18 /*----------------------------------------------------------------*/
  19
  20 struct shadow_info {
  21         struct hlist_node hlist;
  22         dm_block_t where;
  23 };
  24
  25 /*
  26  * It would be nice if we scaled with the size of transaction.
  27  */
  28 #define HASH_SIZE 256
  29 #define HASH_MASK (HASH_SIZE - 1)
  30
  31 struct dm_transaction_manager {
  32         int is_clone;
  33         struct dm_transaction_manager *real;
  34
  35         struct dm_block_manager *bm;
  36         struct dm_space_map *sm;
  37
  38         spinlock_t lock;
  39         struct hlist_head buckets[HASH_SIZE];
  40 };
  41
  42 /*----------------------------------------------------------------*/
  43
  44 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
  45 {
  46         int r = 0;
  47         unsigned bucket = dm_hash_block(b, HASH_MASK);
  48         struct shadow_info *si;
  49         struct hlist_node *n;
  50
  51         spin_lock(&tm->lock);
  52         hlist_for_each_entry(si, n, tm->buckets + bucket, hlist)
  53                 if (si->where == b) {
  54                         r = 1;
  55                         break;
  56                 }
  57         spin_unlock(&tm->lock);
  58
  59         return r;
  60 }
  61
  62 /*
  63  * This can silently fail if there's no memory.  We're ok with this since
  64  * creating redundant shadows causes no harm.
  65  */
  66 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
  67 {
  68         unsigned bucket;
  69         struct shadow_info *si;
  70
  71         si = kmalloc(sizeof(*si), GFP_NOIO);
  72         if (si) {
  73                 si->where = b;
  74                 bucket = dm_hash_block(b, HASH_MASK);
  75                 spin_lock(&tm->lock);
  76                 hlist_add_head(&si->hlist, tm->buckets + bucket);
  77                 spin_unlock(&tm->lock);
  78         }
  79 }
  80
  81 static void wipe_shadow_table(struct dm_transaction_manager *tm)
  82 {
  83         struct shadow_info *si;
  84         struct hlist_node *n, *tmp;
  85         struct hlist_head *bucket;
  86         int i;
  87
  88         spin_lock(&tm->lock);
  89         for (i = 0; i < HASH_SIZE; i++) {
  90                 bucket = tm->buckets + i;
  91                 hlist_for_each_entry_safe(si, n, tmp, bucket, hlist)
  92                         kfree(si);
  93
  94                 INIT_HLIST_HEAD(bucket);
  95         }
  96
  97         spin_unlock(&tm->lock);
  98 }
  99
 100 /*----------------------------------------------------------------*/
 101
 102 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
 103                                                    struct dm_space_map *sm)
 104 {
 105         int i;
 106         struct dm_transaction_manager *tm;
 107
 108         tm = kmalloc(sizeof(*tm), GFP_KERNEL);
 109         if (!tm)
 110                 return ERR_PTR(-ENOMEM);
 111
 112         tm->is_clone = 0;
 113         tm->real = NULL;
 114         tm->bm = bm;
 115         tm->sm = sm;
 116
 117         spin_lock_init(&tm->lock);
 118         for (i = 0; i < HASH_SIZE; i++)
 119                 INIT_HLIST_HEAD(tm->buckets + i);
 120
 121         return tm;
 122 }
 123
 124 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
 125 {
 126         struct dm_transaction_manager *tm;
 127
 128         tm = kmalloc(sizeof(*tm), GFP_KERNEL);
 129         if (tm) {
 130                 tm->is_clone = 1;
 131                 tm->real = real;
 132         }
 133
 134         return tm;
 135 }
 136 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
 137
 138 void dm_tm_destroy(struct dm_transaction_manager *tm)
 139 {
 140         if (!tm->is_clone)
 141                 wipe_shadow_table(tm);
 142
 143         kfree(tm);
 144 }
 145 EXPORT_SYMBOL_GPL(dm_tm_destroy);
 146
 147 int dm_tm_pre_commit(struct dm_transaction_manager *tm)
 148 {
 149         int r;
 150
 151         if (tm->is_clone)
 152                 return -EWOULDBLOCK;
 153
 154         r = dm_sm_commit(tm->sm);
 155         if (r < 0)
 156                 return r;
 157
 158         return 0;
 159 }
 160 EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
 161
 162 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
 163 {
 164         if (tm->is_clone)
 165                 return -EWOULDBLOCK;
 166
 167         wipe_shadow_table(tm);
 168
 169         return dm_bm_flush_and_unlock(tm->bm, root);
 170 }
 171 EXPORT_SYMBOL_GPL(dm_tm_commit);
 172
 173 int dm_tm_new_block(struct dm_transaction_manager *tm,
 174                     struct dm_block_validator *v,
 175                     struct dm_block **result)
 176 {
 177         int r;
 178         dm_block_t new_block;
 179
 180         if (tm->is_clone)
 181                 return -EWOULDBLOCK;
 182
 183         r = dm_sm_new_block(tm->sm, &new_block);
 184         if (r < 0)
 185                 return r;
 186
 187         r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
 188         if (r < 0) {
 189                 dm_sm_dec_block(tm->sm, new_block);
 190                 return r;
 191         }
 192
 193         /*
 194          * New blocks count as shadows in that they don't need to be
 195          * shadowed again.
 196          */
 197         insert_shadow(tm, new_block);
 198
 199         return 0;
 200 }
 201
 202 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
 203                           struct dm_block_validator *v,
 204                           struct dm_block **result)
 205 {
 206         int r;
 207         dm_block_t new;
 208         struct dm_block *orig_block;
 209
 210         r = dm_sm_new_block(tm->sm, &new);
 211         if (r < 0)
 212                 return r;
 213
 214         r = dm_sm_dec_block(tm->sm, orig);
 215         if (r < 0)
 216                 return r;
 217
 218         r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
 219         if (r < 0)
 220                 return r;
 221
 222         r = dm_bm_unlock_move(orig_block, new);
 223         if (r < 0) {
 224                 dm_bm_unlock(orig_block);
 225                 return r;
 226         }
 227
 228         return dm_bm_write_lock(tm->bm, new, v, result);
 229 }
 230
 231 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
 232                        struct dm_block_validator *v, struct dm_block **result,
 233                        int *inc_children)
 234 {
 235         int r;
 236
 237         if (tm->is_clone)
 238                 return -EWOULDBLOCK;
 239
 240         r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
 241         if (r < 0)
 242                 return r;
 243
 244         if (is_shadow(tm, orig) && !*inc_children)
 245                 return dm_bm_write_lock(tm->bm, orig, v, result);
 246
 247         r = __shadow_block(tm, orig, v, result);
 248         if (r < 0)
 249                 return r;
 250         insert_shadow(tm, dm_block_location(*result));
 251
 252         return r;
 253 }
 254 EXPORT_SYMBOL_GPL(dm_tm_shadow_block);
 255
 256 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
 257                     struct dm_block_validator *v,
 258                     struct dm_block **blk)
 259 {
 260         if (tm->is_clone)
 261                 return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
 262
 263         return dm_bm_read_lock(tm->bm, b, v, blk);
 264 }
 265 EXPORT_SYMBOL_GPL(dm_tm_read_lock);
 266
 267 int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
 268 {
 269         return dm_bm_unlock(b);
 270 }
 271 EXPORT_SYMBOL_GPL(dm_tm_unlock);
 272
 273 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
 274 {
 275         /*
 276          * The non-blocking clone doesn't support this.
 277          */
 278         BUG_ON(tm->is_clone);
 279
 280         dm_sm_inc_block(tm->sm, b);
 281 }
 282 EXPORT_SYMBOL_GPL(dm_tm_inc);
 283
 284 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
 285 {
 286         /*
 287          * The non-blocking clone doesn't support this.
 288          */
 289         BUG_ON(tm->is_clone);
 290
 291         dm_sm_dec_block(tm->sm, b);
 292 }
 293 EXPORT_SYMBOL_GPL(dm_tm_dec);
 294
 295 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
 296               uint32_t *result)
 297 {
 298         if (tm->is_clone)
 299                 return -EWOULDBLOCK;
 300
 301         return dm_sm_get_count(tm->sm, b, result);
 302 }
 303
 304 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
 305 {
 306         return tm->bm;
 307 }
 308
 309 /*----------------------------------------------------------------*/
 310
 311 static int dm_tm_create_internal(struct dm_block_manager *bm,
 312                                  dm_block_t sb_location,
 313                                  struct dm_block_validator *sb_validator,
 314                                  size_t root_offset, size_t root_max_len,
 315                                  struct dm_transaction_manager **tm,
 316                                  struct dm_space_map **sm,
 317                                  struct dm_block **sblock,
 318                                  int create)
 319 {
 320         int r;
 321
 322         *sm = dm_sm_metadata_init();
 323         if (IS_ERR(*sm))
 324                 return PTR_ERR(*sm);
 325
 326         *tm = dm_tm_create(bm, *sm);
 327         if (IS_ERR(*tm)) {
 328                 dm_sm_destroy(*sm);
 329                 return PTR_ERR(*tm);
 330         }
 331
 332         if (create) {
 333                 r = dm_bm_write_lock_zero(dm_tm_get_bm(*tm), sb_location,
 334                                           sb_validator, sblock);
 335                 if (r < 0) {
 336                         DMERR("couldn't lock superblock");
 337                         goto bad1;
 338                 }
 339
 340                 r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm),
 341                                           sb_location);
 342                 if (r) {
 343                         DMERR("couldn't create metadata space map");
 344                         goto bad2;
 345                 }
 346
 347         } else {
 348                 r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
 349                                      sb_validator, sblock);
 350                 if (r < 0) {
 351                         DMERR("couldn't lock superblock");
 352                         goto bad1;
 353                 }
 354
 355                 r = dm_sm_metadata_open(*sm, *tm,
 356                                         dm_block_data(*sblock) + root_offset,
 357                                         root_max_len);
 358                 if (r) {
 359                         DMERR("couldn't open metadata space map");
 360                         goto bad2;
 361                 }
 362         }
 363
 364         return 0;
 365
 366 bad2:
 367         dm_tm_unlock(*tm, *sblock);
 368 bad1:
 369         dm_tm_destroy(*tm);
 370         return r;
 371 }
 372
 373 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
 374                          struct dm_block_validator *sb_validator,
 375                          struct dm_transaction_manager **tm,
 376                          struct dm_space_map **sm, struct dm_block **sblock)
 377 {
 378         return dm_tm_create_internal(bm, sb_location, sb_validator,
 379                                      0, 0, tm, sm, sblock, 1);
 380 }
 381 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
 382
 383 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
 384                        struct dm_block_validator *sb_validator,
 385                        size_t root_offset, size_t root_max_len,
 386                        struct dm_transaction_manager **tm,
 387                        struct dm_space_map **sm, struct dm_block **sblock)
 388 {
 389         return dm_tm_create_internal(bm, sb_location, sb_validator, root_offset,
 390                                      root_max_len, tm, sm, sblock, 0);
 391 }
 392 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
 393
 394 /*----------------------------------------------------------------*/