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