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 
40 unsigned int dm_bm_block_size(struct dm_block_manager *bm);
41 dm_block_t dm_bm_nr_blocks(struct dm_block_manager *bm);
42 
43 /*----------------------------------------------------------------*/
44 
45 /*
46  * The validator allows the caller to verify newly-read data and modify
47  * the data just before writing, e.g. to calculate checksums.  It's
48  * important to be consistent with your use of validators.  The only time
49  * you can change validators is if you call dm_bm_write_lock_zero.
50  */
51 struct dm_block_validator {
52 	const char *name;
53 	void (*prepare_for_write)(struct dm_block_validator *v, struct dm_block *b, size_t block_size);
54 
55 	/*
56 	 * Return 0 if the checksum is valid or < 0 on error.
57 	 */
58 	int (*check)(struct dm_block_validator *v, struct dm_block *b, size_t block_size);
59 };
60 
61 /*----------------------------------------------------------------*/
62 
63 /*
64  * You can have multiple concurrent readers or a single writer holding a
65  * block lock.
66  */
67 
68 /*
69  * dm_bm_lock() locks a block and returns through @result a pointer to
70  * memory that holds a copy of that block.  If you have write-locked the
71  * block then any changes you make to memory pointed to by @result will be
72  * written back to the disk sometime after dm_bm_unlock is called.
73  */
74 int dm_bm_read_lock(struct dm_block_manager *bm, dm_block_t b,
75 		    struct dm_block_validator *v,
76 		    struct dm_block **result);
77 
78 int dm_bm_write_lock(struct dm_block_manager *bm, dm_block_t b,
79 		     struct dm_block_validator *v,
80 		     struct dm_block **result);
81 
82 /*
83  * The *_try_lock variants return -EWOULDBLOCK if the block isn't
84  * available immediately.
85  */
86 int dm_bm_read_try_lock(struct dm_block_manager *bm, dm_block_t b,
87 			struct dm_block_validator *v,
88 			struct dm_block **result);
89 
90 /*
91  * Use dm_bm_write_lock_zero() when you know you're going to
92  * overwrite the block completely.  It saves a disk read.
93  */
94 int dm_bm_write_lock_zero(struct dm_block_manager *bm, dm_block_t b,
95 			  struct dm_block_validator *v,
96 			  struct dm_block **result);
97 
98 void dm_bm_unlock(struct dm_block *b);
99 
100 /*
101  * It's a common idiom to have a superblock that should be committed last.
102  *
103  * @superblock should be write-locked on entry. It will be unlocked during
104  * this function.  All dirty blocks are guaranteed to be written and flushed
105  * before the superblock.
106  *
107  * This method always blocks.
108  */
109 int dm_bm_flush(struct dm_block_manager *bm);
110 
111 /*
112  * Request data is prefetched into the cache.
113  */
114 void dm_bm_prefetch(struct dm_block_manager *bm, dm_block_t b);
115 
116 /*
117  * Switches the bm to a read only mode.  Once read-only mode
118  * has been entered the following functions will return -EPERM.
119  *
120  *   dm_bm_write_lock
121  *   dm_bm_write_lock_zero
122  *   dm_bm_flush_and_unlock
123  *
124  * Additionally you should not use dm_bm_unlock_move, however no error will
125  * be returned if you do.
126  */
127 bool dm_bm_is_read_only(struct dm_block_manager *bm);
128 void dm_bm_set_read_only(struct dm_block_manager *bm);
129 void dm_bm_set_read_write(struct dm_block_manager *bm);
130 
131 u32 dm_bm_checksum(const void *data, size_t len, u32 init_xor);
132 
133 /*----------------------------------------------------------------*/
134 
135 #endif	/* _LINUX_DM_BLOCK_MANAGER_H */
136