1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
2 | /* |
3 | * Copyright (C) 2011 Red Hat, Inc. |
4 | * |
5 | * This file is released under the GPL. |
6 | */ |
7 | |
8 | #ifndef _LINUX_DM_BLOCK_MANAGER_H |
9 | #define _LINUX_DM_BLOCK_MANAGER_H |
10 | |
11 | #include <linux/types.h> |
12 | #include <linux/blkdev.h> |
13 | |
14 | /*----------------------------------------------------------------*/ |
15 | |
16 | /* |
17 | * Block number. |
18 | */ |
19 | typedef uint64_t dm_block_t; |
20 | struct dm_block; |
21 | |
22 | dm_block_t dm_block_location(struct dm_block *b); |
23 | void *dm_block_data(struct dm_block *b); |
24 | |
25 | /*----------------------------------------------------------------*/ |
26 | |
27 | /* |
28 | * @name should be a unique identifier for the block manager, no longer |
29 | * than 32 chars. |
30 | * |
31 | * @max_held_per_thread should be the maximum number of locks, read or |
32 | * write, that an individual thread holds at any one time. |
33 | */ |
34 | struct dm_block_manager; |
35 | struct dm_block_manager *dm_block_manager_create( |
36 | struct block_device *bdev, unsigned int block_size, |
37 | unsigned int max_held_per_thread); |
38 | void dm_block_manager_destroy(struct dm_block_manager *bm); |
39 | void dm_block_manager_reset(struct dm_block_manager *bm); |
40 | |
41 | unsigned int dm_bm_block_size(struct dm_block_manager *bm); |
42 | dm_block_t dm_bm_nr_blocks(struct dm_block_manager *bm); |
43 | |
44 | /*----------------------------------------------------------------*/ |
45 | |
46 | /* |
47 | * The validator allows the caller to verify newly-read data and modify |
48 | * the data just before writing, e.g. to calculate checksums. It's |
49 | * important to be consistent with your use of validators. The only time |
50 | * you can change validators is if you call dm_bm_write_lock_zero. |
51 | */ |
52 | struct dm_block_validator { |
53 | const char *name; |
54 | void (*prepare_for_write)(struct dm_block_validator *v, struct dm_block *b, size_t block_size); |
55 | |
56 | /* |
57 | * Return 0 if the checksum is valid or < 0 on error. |
58 | */ |
59 | int (*check)(struct dm_block_validator *v, struct dm_block *b, size_t block_size); |
60 | }; |
61 | |
62 | /*----------------------------------------------------------------*/ |
63 | |
64 | /* |
65 | * You can have multiple concurrent readers or a single writer holding a |
66 | * block lock. |
67 | */ |
68 | |
69 | /* |
70 | * dm_bm_lock() locks a block and returns through @result a pointer to |
71 | * memory that holds a copy of that block. If you have write-locked the |
72 | * block then any changes you make to memory pointed to by @result will be |
73 | * written back to the disk sometime after dm_bm_unlock is called. |
74 | */ |
75 | int dm_bm_read_lock(struct dm_block_manager *bm, dm_block_t b, |
76 | struct dm_block_validator *v, |
77 | struct dm_block **result); |
78 | |
79 | int dm_bm_write_lock(struct dm_block_manager *bm, dm_block_t b, |
80 | struct dm_block_validator *v, |
81 | struct dm_block **result); |
82 | |
83 | /* |
84 | * The *_try_lock variants return -EWOULDBLOCK if the block isn't |
85 | * available immediately. |
86 | */ |
87 | int dm_bm_read_try_lock(struct dm_block_manager *bm, dm_block_t b, |
88 | struct dm_block_validator *v, |
89 | struct dm_block **result); |
90 | |
91 | /* |
92 | * Use dm_bm_write_lock_zero() when you know you're going to |
93 | * overwrite the block completely. It saves a disk read. |
94 | */ |
95 | int dm_bm_write_lock_zero(struct dm_block_manager *bm, dm_block_t b, |
96 | struct dm_block_validator *v, |
97 | struct dm_block **result); |
98 | |
99 | void dm_bm_unlock(struct dm_block *b); |
100 | |
101 | /* |
102 | * It's a common idiom to have a superblock that should be committed last. |
103 | * |
104 | * @superblock should be write-locked on entry. It will be unlocked during |
105 | * this function. All dirty blocks are guaranteed to be written and flushed |
106 | * before the superblock. |
107 | * |
108 | * This method always blocks. |
109 | */ |
110 | int dm_bm_flush(struct dm_block_manager *bm); |
111 | |
112 | /* |
113 | * Request data is prefetched into the cache. |
114 | */ |
115 | void dm_bm_prefetch(struct dm_block_manager *bm, dm_block_t b); |
116 | |
117 | /* |
118 | * Switches the bm to a read only mode. Once read-only mode |
119 | * has been entered the following functions will return -EPERM. |
120 | * |
121 | * dm_bm_write_lock |
122 | * dm_bm_write_lock_zero |
123 | * dm_bm_flush_and_unlock |
124 | * |
125 | * Additionally you should not use dm_bm_unlock_move, however no error will |
126 | * be returned if you do. |
127 | */ |
128 | bool dm_bm_is_read_only(struct dm_block_manager *bm); |
129 | void dm_bm_set_read_only(struct dm_block_manager *bm); |
130 | void dm_bm_set_read_write(struct dm_block_manager *bm); |
131 | |
132 | u32 dm_bm_checksum(const void *data, size_t len, u32 init_xor); |
133 | |
134 | /*----------------------------------------------------------------*/ |
135 | |
136 | #endif /* _LINUX_DM_BLOCK_MANAGER_H */ |
137 | |