]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/md/persistent-data/dm-transaction-manager.h
2 * Copyright (C) 2011 Red Hat, Inc.
4 * This file is released under the GPL.
7 #ifndef _LINUX_DM_TRANSACTION_MANAGER_H
8 #define _LINUX_DM_TRANSACTION_MANAGER_H
10 #include "dm-block-manager.h"
12 struct dm_transaction_manager
;
15 /*----------------------------------------------------------------*/
18 * This manages the scope of a transaction. It also enforces immutability
19 * of the on-disk data structures by limiting access to writeable blocks.
21 * Clients should not fiddle with the block manager directly.
24 void dm_tm_destroy(struct dm_transaction_manager
*tm
);
27 * The non-blocking version of a transaction manager is intended for use in
28 * fast path code that needs to do lookups e.g. a dm mapping function.
29 * You create the non-blocking variant from a normal tm. The interface is
30 * the same, except that most functions will just return -EWOULDBLOCK.
31 * Methods that return void yet may block should not be called on a clone
32 * viz. dm_tm_inc, dm_tm_dec. Call dm_tm_destroy() as you would with a normal
33 * tm when you've finished with it. You may not destroy the original prior
36 struct dm_transaction_manager
*dm_tm_create_non_blocking_clone(struct dm_transaction_manager
*real
);
39 * We use a 2-phase commit here.
41 * i) Make all changes for the transaction *except* for the superblock.
42 * Then call dm_tm_pre_commit() to flush them to disk.
44 * ii) Lock your superblock. Update. Then call dm_tm_commit() which will
45 * unlock the superblock and flush it. No other blocks should be updated
46 * during this period. Care should be taken to never unlock a partially
47 * updated superblock; perform any operations that could fail *before* you
48 * take the superblock lock.
50 int dm_tm_pre_commit(struct dm_transaction_manager
*tm
);
51 int dm_tm_commit(struct dm_transaction_manager
*tm
, struct dm_block
*superblock
);
54 * These methods are the only way to get hold of a writeable block.
58 * dm_tm_new_block() is pretty self-explanatory. Make sure you do actually
59 * write to the whole of @data before you unlock, otherwise you could get
60 * a data leak. (The other option is for tm_new_block() to zero new blocks
61 * before handing them out, which will be redundant in most, if not all,
63 * Zeroes the new block and returns with write lock held.
65 int dm_tm_new_block(struct dm_transaction_manager
*tm
,
66 struct dm_block_validator
*v
,
67 struct dm_block
**result
);
70 * dm_tm_shadow_block() allocates a new block and copies the data from @orig
71 * to it. It then decrements the reference count on original block. Use
72 * this to update the contents of a block in a data structure, don't
73 * confuse this with a clone - you shouldn't access the orig block after
74 * this operation. Because the tm knows the scope of the transaction it
75 * can optimise requests for a shadow of a shadow to a no-op. Don't forget
76 * to unlock when you've finished with the shadow.
78 * The @inc_children flag is used to tell the caller whether it needs to
79 * adjust reference counts for children. (Data in the block may refer to
82 * Shadowing implicitly drops a reference on @orig so you must not have
83 * it locked when you call this.
85 int dm_tm_shadow_block(struct dm_transaction_manager
*tm
, dm_block_t orig
,
86 struct dm_block_validator
*v
,
87 struct dm_block
**result
, int *inc_children
);
90 * Read access. You can lock any block you want. If there's a write lock
91 * on it outstanding then it'll block.
93 int dm_tm_read_lock(struct dm_transaction_manager
*tm
, dm_block_t b
,
94 struct dm_block_validator
*v
,
95 struct dm_block
**result
);
97 int dm_tm_unlock(struct dm_transaction_manager
*tm
, struct dm_block
*b
);
100 * Functions for altering the reference count of a block directly.
102 void dm_tm_inc(struct dm_transaction_manager
*tm
, dm_block_t b
);
104 void dm_tm_dec(struct dm_transaction_manager
*tm
, dm_block_t b
);
106 int dm_tm_ref(struct dm_transaction_manager
*tm
, dm_block_t b
,
109 struct dm_block_manager
*dm_tm_get_bm(struct dm_transaction_manager
*tm
);
112 * A little utility that ties the knot by producing a transaction manager
113 * that has a space map managed by the transaction manager...
115 * Returns a tm that has an open transaction to write the new disk sm.
116 * Caller should store the new sm root and commit.
118 * The superblock location is passed so the metadata space map knows it
121 int dm_tm_create_with_sm(struct dm_block_manager
*bm
, dm_block_t sb_location
,
122 struct dm_transaction_manager
**tm
,
123 struct dm_space_map
**sm
);
125 int dm_tm_open_with_sm(struct dm_block_manager
*bm
, dm_block_t sb_location
,
126 void *sm_root
, size_t root_len
,
127 struct dm_transaction_manager
**tm
,
128 struct dm_space_map
**sm
);
130 #endif /* _LINUX_DM_TRANSACTION_MANAGER_H */