1 /* 2 * Copyright (C) 2011 Red Hat, Inc. 3 * 4 * This file is released under the GPL. 5 */ 6 7 #ifndef _LINUX_DM_BLOCK_MANAGER_H 8 #define _LINUX_DM_BLOCK_MANAGER_H 9 10 #include <linux/types.h> 11 #include <linux/blkdev.h> 12 13 /*----------------------------------------------------------------*/ 14 15 /* 16 * Block number. 17 */ 18 typedef uint64_t dm_block_t; 19 struct dm_block; 20 21 dm_block_t dm_block_location(struct dm_block *b); 22 void *dm_block_data(struct dm_block *b); 23 24 /*----------------------------------------------------------------*/ 25 26 /* 27 * @name should be a unique identifier for the block manager, no longer 28 * than 32 chars. 29 * 30 * @max_held_per_thread should be the maximum number of locks, read or 31 * write, that an individual thread holds at any one time. 32 */ 33 struct dm_block_manager; 34 struct dm_block_manager *dm_block_manager_create( 35 struct block_device *bdev, unsigned int block_size, 36 unsigned int max_held_per_thread); 37 void dm_block_manager_destroy(struct dm_block_manager *bm); 38 void dm_block_manager_reset(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