forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
242 lines
7.0 KiB
242 lines
7.0 KiB
/* |
|
* Copyright (C) 2010-2011 Red Hat, Inc. |
|
* |
|
* This file is released under the GPL. |
|
*/ |
|
|
|
#ifndef DM_THIN_METADATA_H |
|
#define DM_THIN_METADATA_H |
|
|
|
#include "persistent-data/dm-block-manager.h" |
|
#include "persistent-data/dm-space-map.h" |
|
#include "persistent-data/dm-space-map-metadata.h" |
|
|
|
#define THIN_METADATA_BLOCK_SIZE DM_SM_METADATA_BLOCK_SIZE |
|
|
|
/* |
|
* The metadata device is currently limited in size. |
|
*/ |
|
#define THIN_METADATA_MAX_SECTORS DM_SM_METADATA_MAX_SECTORS |
|
|
|
/* |
|
* A metadata device larger than 16GB triggers a warning. |
|
*/ |
|
#define THIN_METADATA_MAX_SECTORS_WARNING (16 * (1024 * 1024 * 1024 >> SECTOR_SHIFT)) |
|
|
|
/*----------------------------------------------------------------*/ |
|
|
|
/* |
|
* Thin metadata superblock flags. |
|
*/ |
|
#define THIN_METADATA_NEEDS_CHECK_FLAG (1 << 0) |
|
|
|
struct dm_pool_metadata; |
|
struct dm_thin_device; |
|
|
|
/* |
|
* Device identifier |
|
*/ |
|
typedef uint64_t dm_thin_id; |
|
|
|
/* |
|
* Reopens or creates a new, empty metadata volume. |
|
*/ |
|
struct dm_pool_metadata *dm_pool_metadata_open(struct block_device *bdev, |
|
sector_t data_block_size, |
|
bool format_device); |
|
|
|
int dm_pool_metadata_close(struct dm_pool_metadata *pmd); |
|
|
|
/* |
|
* Compat feature flags. Any incompat flags beyond the ones |
|
* specified below will prevent use of the thin metadata. |
|
*/ |
|
#define THIN_FEATURE_COMPAT_SUPP 0UL |
|
#define THIN_FEATURE_COMPAT_RO_SUPP 0UL |
|
#define THIN_FEATURE_INCOMPAT_SUPP 0UL |
|
|
|
/* |
|
* Device creation/deletion. |
|
*/ |
|
int dm_pool_create_thin(struct dm_pool_metadata *pmd, dm_thin_id dev); |
|
|
|
/* |
|
* An internal snapshot. |
|
* |
|
* You can only snapshot a quiesced origin i.e. one that is either |
|
* suspended or not instanced at all. |
|
*/ |
|
int dm_pool_create_snap(struct dm_pool_metadata *pmd, dm_thin_id dev, |
|
dm_thin_id origin); |
|
|
|
/* |
|
* Deletes a virtual device from the metadata. It _is_ safe to call this |
|
* when that device is open. Operations on that device will just start |
|
* failing. You still need to call close() on the device. |
|
*/ |
|
int dm_pool_delete_thin_device(struct dm_pool_metadata *pmd, |
|
dm_thin_id dev); |
|
|
|
/* |
|
* Commits _all_ metadata changes: device creation, deletion, mapping |
|
* updates. |
|
*/ |
|
int dm_pool_commit_metadata(struct dm_pool_metadata *pmd); |
|
|
|
/* |
|
* Discards all uncommitted changes. Rereads the superblock, rolling back |
|
* to the last good transaction. Thin devices remain open. |
|
* dm_thin_aborted_changes() tells you if they had uncommitted changes. |
|
* |
|
* If this call fails it's only useful to call dm_pool_metadata_close(). |
|
* All other methods will fail with -EINVAL. |
|
*/ |
|
int dm_pool_abort_metadata(struct dm_pool_metadata *pmd); |
|
|
|
/* |
|
* Set/get userspace transaction id. |
|
*/ |
|
int dm_pool_set_metadata_transaction_id(struct dm_pool_metadata *pmd, |
|
uint64_t current_id, |
|
uint64_t new_id); |
|
|
|
int dm_pool_get_metadata_transaction_id(struct dm_pool_metadata *pmd, |
|
uint64_t *result); |
|
|
|
/* |
|
* Hold/get root for userspace transaction. |
|
* |
|
* The metadata snapshot is a copy of the current superblock (minus the |
|
* space maps). Userland can access the data structures for READ |
|
* operations only. A small performance hit is incurred by providing this |
|
* copy of the metadata to userland due to extra copy-on-write operations |
|
* on the metadata nodes. Release this as soon as you finish with it. |
|
*/ |
|
int dm_pool_reserve_metadata_snap(struct dm_pool_metadata *pmd); |
|
int dm_pool_release_metadata_snap(struct dm_pool_metadata *pmd); |
|
|
|
int dm_pool_get_metadata_snap(struct dm_pool_metadata *pmd, |
|
dm_block_t *result); |
|
|
|
/* |
|
* Actions on a single virtual device. |
|
*/ |
|
|
|
/* |
|
* Opening the same device more than once will fail with -EBUSY. |
|
*/ |
|
int dm_pool_open_thin_device(struct dm_pool_metadata *pmd, dm_thin_id dev, |
|
struct dm_thin_device **td); |
|
|
|
int dm_pool_close_thin_device(struct dm_thin_device *td); |
|
|
|
dm_thin_id dm_thin_dev_id(struct dm_thin_device *td); |
|
|
|
struct dm_thin_lookup_result { |
|
dm_block_t block; |
|
bool shared:1; |
|
}; |
|
|
|
/* |
|
* Returns: |
|
* -EWOULDBLOCK iff @can_issue_io is set and would issue IO |
|
* -ENODATA iff that mapping is not present. |
|
* 0 success |
|
*/ |
|
int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block, |
|
int can_issue_io, struct dm_thin_lookup_result *result); |
|
|
|
/* |
|
* Retrieve the next run of contiguously mapped blocks. Useful for working |
|
* out where to break up IO. Returns 0 on success, < 0 on error. |
|
*/ |
|
int dm_thin_find_mapped_range(struct dm_thin_device *td, |
|
dm_block_t begin, dm_block_t end, |
|
dm_block_t *thin_begin, dm_block_t *thin_end, |
|
dm_block_t *pool_begin, bool *maybe_shared); |
|
|
|
/* |
|
* Obtain an unused block. |
|
*/ |
|
int dm_pool_alloc_data_block(struct dm_pool_metadata *pmd, dm_block_t *result); |
|
|
|
/* |
|
* Insert or remove block. |
|
*/ |
|
int dm_thin_insert_block(struct dm_thin_device *td, dm_block_t block, |
|
dm_block_t data_block); |
|
|
|
int dm_thin_remove_block(struct dm_thin_device *td, dm_block_t block); |
|
int dm_thin_remove_range(struct dm_thin_device *td, |
|
dm_block_t begin, dm_block_t end); |
|
|
|
/* |
|
* Queries. |
|
*/ |
|
bool dm_thin_changed_this_transaction(struct dm_thin_device *td); |
|
|
|
bool dm_pool_changed_this_transaction(struct dm_pool_metadata *pmd); |
|
|
|
bool dm_thin_aborted_changes(struct dm_thin_device *td); |
|
|
|
int dm_thin_get_highest_mapped_block(struct dm_thin_device *td, |
|
dm_block_t *highest_mapped); |
|
|
|
int dm_thin_get_mapped_count(struct dm_thin_device *td, dm_block_t *result); |
|
|
|
int dm_pool_get_free_block_count(struct dm_pool_metadata *pmd, |
|
dm_block_t *result); |
|
|
|
int dm_pool_get_free_metadata_block_count(struct dm_pool_metadata *pmd, |
|
dm_block_t *result); |
|
|
|
int dm_pool_get_metadata_dev_size(struct dm_pool_metadata *pmd, |
|
dm_block_t *result); |
|
|
|
int dm_pool_get_data_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result); |
|
|
|
int dm_pool_block_is_shared(struct dm_pool_metadata *pmd, dm_block_t b, bool *result); |
|
|
|
int dm_pool_inc_data_range(struct dm_pool_metadata *pmd, dm_block_t b, dm_block_t e); |
|
int dm_pool_dec_data_range(struct dm_pool_metadata *pmd, dm_block_t b, dm_block_t e); |
|
|
|
/* |
|
* Returns -ENOSPC if the new size is too small and already allocated |
|
* blocks would be lost. |
|
*/ |
|
int dm_pool_resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_size); |
|
int dm_pool_resize_metadata_dev(struct dm_pool_metadata *pmd, dm_block_t new_size); |
|
|
|
/* |
|
* Flicks the underlying block manager into read only mode, so you know |
|
* that nothing is changing. |
|
*/ |
|
void dm_pool_metadata_read_only(struct dm_pool_metadata *pmd); |
|
void dm_pool_metadata_read_write(struct dm_pool_metadata *pmd); |
|
|
|
int dm_pool_register_metadata_threshold(struct dm_pool_metadata *pmd, |
|
dm_block_t threshold, |
|
dm_sm_threshold_fn fn, |
|
void *context); |
|
|
|
/* |
|
* Updates the superblock immediately. |
|
*/ |
|
int dm_pool_metadata_set_needs_check(struct dm_pool_metadata *pmd); |
|
bool dm_pool_metadata_needs_check(struct dm_pool_metadata *pmd); |
|
|
|
/* |
|
* Issue any prefetches that may be useful. |
|
*/ |
|
void dm_pool_issue_prefetches(struct dm_pool_metadata *pmd); |
|
|
|
/* Pre-commit callback */ |
|
typedef int (*dm_pool_pre_commit_fn)(void *context); |
|
|
|
void dm_pool_register_pre_commit_callback(struct dm_pool_metadata *pmd, |
|
dm_pool_pre_commit_fn fn, |
|
void *context); |
|
|
|
/*----------------------------------------------------------------*/ |
|
|
|
#endif
|
|
|