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