1 /* 2 * Copyright (C) 2010-2011 Red Hat, Inc. 3 * 4 * This file is released under the GPL. 5 */ 6 7 #ifndef DM_THIN_METADATA_H 8 #define DM_THIN_METADATA_H 9 10 #include "persistent-data/dm-block-manager.h" 11 #include "persistent-data/dm-space-map.h" 12 #include "persistent-data/dm-space-map-metadata.h" 13 14 #define THIN_METADATA_BLOCK_SIZE DM_SM_METADATA_BLOCK_SIZE 15 16 /* 17 * The metadata device is currently limited in size. 18 */ 19 #define THIN_METADATA_MAX_SECTORS DM_SM_METADATA_MAX_SECTORS 20 21 /* 22 * A metadata device larger than 16GB triggers a warning. 23 */ 24 #define THIN_METADATA_MAX_SECTORS_WARNING (16 * (1024 * 1024 * 1024 >> SECTOR_SHIFT)) 25 26 /*----------------------------------------------------------------*/ 27 28 /* 29 * Thin metadata superblock flags. 30 */ 31 #define THIN_METADATA_NEEDS_CHECK_FLAG (1 << 0) 32 33 struct dm_pool_metadata; 34 struct dm_thin_device; 35 36 /* 37 * Device identifier 38 */ 39 typedef uint64_t dm_thin_id; 40 41 /* 42 * Reopens or creates a new, empty metadata volume. 43 */ 44 struct dm_pool_metadata *dm_pool_metadata_open(struct block_device *bdev, 45 sector_t data_block_size, 46 bool format_device); 47 48 int dm_pool_metadata_close(struct dm_pool_metadata *pmd); 49 50 /* 51 * Compat feature flags. Any incompat flags beyond the ones 52 * specified below will prevent use of the thin metadata. 53 */ 54 #define THIN_FEATURE_COMPAT_SUPP 0UL 55 #define THIN_FEATURE_COMPAT_RO_SUPP 0UL 56 #define THIN_FEATURE_INCOMPAT_SUPP 0UL 57 58 /* 59 * Device creation/deletion. 60 */ 61 int dm_pool_create_thin(struct dm_pool_metadata *pmd, dm_thin_id dev); 62 63 /* 64 * An internal snapshot. 65 * 66 * You can only snapshot a quiesced origin i.e. one that is either 67 * suspended or not instanced at all. 68 */ 69 int dm_pool_create_snap(struct dm_pool_metadata *pmd, dm_thin_id dev, 70 dm_thin_id origin); 71 72 /* 73 * Deletes a virtual device from the metadata. It _is_ safe to call this 74 * when that device is open. Operations on that device will just start 75 * failing. You still need to call close() on the device. 76 */ 77 int dm_pool_delete_thin_device(struct dm_pool_metadata *pmd, 78 dm_thin_id dev); 79 80 /* 81 * Commits _all_ metadata changes: device creation, deletion, mapping 82 * updates. 83 */ 84 int dm_pool_commit_metadata(struct dm_pool_metadata *pmd); 85 86 /* 87 * Discards all uncommitted changes. Rereads the superblock, rolling back 88 * to the last good transaction. Thin devices remain open. 89 * dm_thin_aborted_changes() tells you if they had uncommitted changes. 90 * 91 * If this call fails it's only useful to call dm_pool_metadata_close(). 92 * All other methods will fail with -EINVAL. 93 */ 94 int dm_pool_abort_metadata(struct dm_pool_metadata *pmd); 95 96 /* 97 * Set/get userspace transaction id. 98 */ 99 int dm_pool_set_metadata_transaction_id(struct dm_pool_metadata *pmd, 100 uint64_t current_id, 101 uint64_t new_id); 102 103 int dm_pool_get_metadata_transaction_id(struct dm_pool_metadata *pmd, 104 uint64_t *result); 105 106 /* 107 * Hold/get root for userspace transaction. 108 * 109 * The metadata snapshot is a copy of the current superblock (minus the 110 * space maps). Userland can access the data structures for READ 111 * operations only. A small performance hit is incurred by providing this 112 * copy of the metadata to userland due to extra copy-on-write operations 113 * on the metadata nodes. Release this as soon as you finish with it. 114 */ 115 int dm_pool_reserve_metadata_snap(struct dm_pool_metadata *pmd); 116 int dm_pool_release_metadata_snap(struct dm_pool_metadata *pmd); 117 118 int dm_pool_get_metadata_snap(struct dm_pool_metadata *pmd, 119 dm_block_t *result); 120 121 /* 122 * Actions on a single virtual device. 123 */ 124 125 /* 126 * Opening the same device more than once will fail with -EBUSY. 127 */ 128 int dm_pool_open_thin_device(struct dm_pool_metadata *pmd, dm_thin_id dev, 129 struct dm_thin_device **td); 130 131 int dm_pool_close_thin_device(struct dm_thin_device *td); 132 133 dm_thin_id dm_thin_dev_id(struct dm_thin_device *td); 134 135 struct dm_thin_lookup_result { 136 dm_block_t block; 137 bool shared:1; 138 }; 139 140 /* 141 * Returns: 142 * -EWOULDBLOCK iff @can_block is set and would block. 143 * -ENODATA iff that mapping is not present. 144 * 0 success 145 */ 146 int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block, 147 int can_block, struct dm_thin_lookup_result *result); 148 149 /* 150 * Obtain an unused block. 151 */ 152 int dm_pool_alloc_data_block(struct dm_pool_metadata *pmd, dm_block_t *result); 153 154 /* 155 * Insert or remove block. 156 */ 157 int dm_thin_insert_block(struct dm_thin_device *td, dm_block_t block, 158 dm_block_t data_block); 159 160 int dm_thin_remove_block(struct dm_thin_device *td, dm_block_t block); 161 162 /* 163 * Queries. 164 */ 165 bool dm_thin_changed_this_transaction(struct dm_thin_device *td); 166 167 bool dm_pool_changed_this_transaction(struct dm_pool_metadata *pmd); 168 169 bool dm_thin_aborted_changes(struct dm_thin_device *td); 170 171 int dm_thin_get_highest_mapped_block(struct dm_thin_device *td, 172 dm_block_t *highest_mapped); 173 174 int dm_thin_get_mapped_count(struct dm_thin_device *td, dm_block_t *result); 175 176 int dm_pool_get_free_block_count(struct dm_pool_metadata *pmd, 177 dm_block_t *result); 178 179 int dm_pool_get_free_metadata_block_count(struct dm_pool_metadata *pmd, 180 dm_block_t *result); 181 182 int dm_pool_get_metadata_dev_size(struct dm_pool_metadata *pmd, 183 dm_block_t *result); 184 185 int dm_pool_get_data_block_size(struct dm_pool_metadata *pmd, sector_t *result); 186 187 int dm_pool_get_data_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result); 188 189 int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *result); 190 191 /* 192 * Returns -ENOSPC if the new size is too small and already allocated 193 * blocks would be lost. 194 */ 195 int dm_pool_resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_size); 196 int dm_pool_resize_metadata_dev(struct dm_pool_metadata *pmd, dm_block_t new_size); 197 198 /* 199 * Flicks the underlying block manager into read only mode, so you know 200 * that nothing is changing. 201 */ 202 void dm_pool_metadata_read_only(struct dm_pool_metadata *pmd); 203 void dm_pool_metadata_read_write(struct dm_pool_metadata *pmd); 204 205 int dm_pool_register_metadata_threshold(struct dm_pool_metadata *pmd, 206 dm_block_t threshold, 207 dm_sm_threshold_fn fn, 208 void *context); 209 210 /* 211 * Updates the superblock immediately. 212 */ 213 int dm_pool_metadata_set_needs_check(struct dm_pool_metadata *pmd); 214 bool dm_pool_metadata_needs_check(struct dm_pool_metadata *pmd); 215 216 /*----------------------------------------------------------------*/ 217 218 #endif 219