| 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_issue_io is set and would issue IO |
| 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_issue_io, 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_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result); |
| 186 | |
| 187 | int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *result); |
| 188 | |
| 189 | /* |
| 190 | * Returns -ENOSPC if the new size is too small and already allocated |
| 191 | * blocks would be lost. |
| 192 | */ |
| 193 | int dm_pool_resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_size); |
| 194 | int dm_pool_resize_metadata_dev(struct dm_pool_metadata *pmd, dm_block_t new_size); |
| 195 | |
| 196 | /* |
| 197 | * Flicks the underlying block manager into read only mode, so you know |
| 198 | * that nothing is changing. |
| 199 | */ |
| 200 | void dm_pool_metadata_read_only(struct dm_pool_metadata *pmd); |
| 201 | void dm_pool_metadata_read_write(struct dm_pool_metadata *pmd); |
| 202 | |
| 203 | int dm_pool_register_metadata_threshold(struct dm_pool_metadata *pmd, |
| 204 | dm_block_t threshold, |
| 205 | dm_sm_threshold_fn fn, |
| 206 | void *context); |
| 207 | |
| 208 | /* |
| 209 | * Updates the superblock immediately. |
| 210 | */ |
| 211 | int dm_pool_metadata_set_needs_check(struct dm_pool_metadata *pmd); |
| 212 | bool dm_pool_metadata_needs_check(struct dm_pool_metadata *pmd); |
| 213 | |
| 214 | /* |
| 215 | * Issue any prefetches that may be useful. |
| 216 | */ |
| 217 | void dm_pool_issue_prefetches(struct dm_pool_metadata *pmd); |
| 218 | |
| 219 | /*----------------------------------------------------------------*/ |
| 220 | |
| 221 | #endif |