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.
239 lines
7.2 KiB
239 lines
7.2 KiB
/* SPDX-License-Identifier: GPL-2.0-only */ |
|
/* |
|
* Block Translation Table library |
|
* Copyright (c) 2014-2015, Intel Corporation. |
|
*/ |
|
|
|
#ifndef _LINUX_BTT_H |
|
#define _LINUX_BTT_H |
|
|
|
#include <linux/types.h> |
|
|
|
#define BTT_SIG_LEN 16 |
|
#define BTT_SIG "BTT_ARENA_INFO\0" |
|
#define MAP_ENT_SIZE 4 |
|
#define MAP_TRIM_SHIFT 31 |
|
#define MAP_TRIM_MASK (1 << MAP_TRIM_SHIFT) |
|
#define MAP_ERR_SHIFT 30 |
|
#define MAP_ERR_MASK (1 << MAP_ERR_SHIFT) |
|
#define MAP_LBA_MASK (~((1 << MAP_TRIM_SHIFT) | (1 << MAP_ERR_SHIFT))) |
|
#define MAP_ENT_NORMAL 0xC0000000 |
|
#define LOG_GRP_SIZE sizeof(struct log_group) |
|
#define LOG_ENT_SIZE sizeof(struct log_entry) |
|
#define ARENA_MIN_SIZE (1UL << 24) /* 16 MB */ |
|
#define ARENA_MAX_SIZE (1ULL << 39) /* 512 GB */ |
|
#define RTT_VALID (1UL << 31) |
|
#define RTT_INVALID 0 |
|
#define BTT_PG_SIZE 4096 |
|
#define BTT_DEFAULT_NFREE ND_MAX_LANES |
|
#define LOG_SEQ_INIT 1 |
|
|
|
#define IB_FLAG_ERROR 0x00000001 |
|
#define IB_FLAG_ERROR_MASK 0x00000001 |
|
|
|
#define ent_lba(ent) (ent & MAP_LBA_MASK) |
|
#define ent_e_flag(ent) (!!(ent & MAP_ERR_MASK)) |
|
#define ent_z_flag(ent) (!!(ent & MAP_TRIM_MASK)) |
|
#define set_e_flag(ent) (ent |= MAP_ERR_MASK) |
|
/* 'normal' is both e and z flags set */ |
|
#define ent_normal(ent) (ent_e_flag(ent) && ent_z_flag(ent)) |
|
|
|
enum btt_init_state { |
|
INIT_UNCHECKED = 0, |
|
INIT_NOTFOUND, |
|
INIT_READY |
|
}; |
|
|
|
/* |
|
* A log group represents one log 'lane', and consists of four log entries. |
|
* Two of the four entries are valid entries, and the remaining two are |
|
* padding. Due to an old bug in the padding location, we need to perform a |
|
* test to determine the padding scheme being used, and use that scheme |
|
* thereafter. |
|
* |
|
* In kernels prior to 4.15, 'log group' would have actual log entries at |
|
* indices (0, 2) and padding at indices (1, 3), where as the correct/updated |
|
* format has log entries at indices (0, 1) and padding at indices (2, 3). |
|
* |
|
* Old (pre 4.15) format: |
|
* +-----------------+-----------------+ |
|
* | ent[0] | ent[1] | |
|
* | 16B | 16B | |
|
* | lba/old/new/seq | pad | |
|
* +-----------------------------------+ |
|
* | ent[2] | ent[3] | |
|
* | 16B | 16B | |
|
* | lba/old/new/seq | pad | |
|
* +-----------------+-----------------+ |
|
* |
|
* New format: |
|
* +-----------------+-----------------+ |
|
* | ent[0] | ent[1] | |
|
* | 16B | 16B | |
|
* | lba/old/new/seq | lba/old/new/seq | |
|
* +-----------------------------------+ |
|
* | ent[2] | ent[3] | |
|
* | 16B | 16B | |
|
* | pad | pad | |
|
* +-----------------+-----------------+ |
|
* |
|
* We detect during start-up which format is in use, and set |
|
* arena->log_index[(0, 1)] with the detected format. |
|
*/ |
|
|
|
struct log_entry { |
|
__le32 lba; |
|
__le32 old_map; |
|
__le32 new_map; |
|
__le32 seq; |
|
}; |
|
|
|
struct log_group { |
|
struct log_entry ent[4]; |
|
}; |
|
|
|
struct btt_sb { |
|
u8 signature[BTT_SIG_LEN]; |
|
u8 uuid[16]; |
|
u8 parent_uuid[16]; |
|
__le32 flags; |
|
__le16 version_major; |
|
__le16 version_minor; |
|
__le32 external_lbasize; |
|
__le32 external_nlba; |
|
__le32 internal_lbasize; |
|
__le32 internal_nlba; |
|
__le32 nfree; |
|
__le32 infosize; |
|
__le64 nextoff; |
|
__le64 dataoff; |
|
__le64 mapoff; |
|
__le64 logoff; |
|
__le64 info2off; |
|
u8 padding[3968]; |
|
__le64 checksum; |
|
}; |
|
|
|
struct free_entry { |
|
u32 block; |
|
u8 sub; |
|
u8 seq; |
|
u8 has_err; |
|
}; |
|
|
|
struct aligned_lock { |
|
union { |
|
spinlock_t lock; |
|
u8 cacheline_padding[L1_CACHE_BYTES]; |
|
}; |
|
}; |
|
|
|
/** |
|
* struct arena_info - handle for an arena |
|
* @size: Size in bytes this arena occupies on the raw device. |
|
* This includes arena metadata. |
|
* @external_lba_start: The first external LBA in this arena. |
|
* @internal_nlba: Number of internal blocks available in the arena |
|
* including nfree reserved blocks |
|
* @internal_lbasize: Internal and external lba sizes may be different as |
|
* we can round up 'odd' external lbasizes such as 520B |
|
* to be aligned. |
|
* @external_nlba: Number of blocks contributed by the arena to the number |
|
* reported to upper layers. (internal_nlba - nfree) |
|
* @external_lbasize: LBA size as exposed to upper layers. |
|
* @nfree: A reserve number of 'free' blocks that is used to |
|
* handle incoming writes. |
|
* @version_major: Metadata layout version major. |
|
* @version_minor: Metadata layout version minor. |
|
* @sector_size: The Linux sector size - 512 or 4096 |
|
* @nextoff: Offset in bytes to the start of the next arena. |
|
* @infooff: Offset in bytes to the info block of this arena. |
|
* @dataoff: Offset in bytes to the data area of this arena. |
|
* @mapoff: Offset in bytes to the map area of this arena. |
|
* @logoff: Offset in bytes to the log area of this arena. |
|
* @info2off: Offset in bytes to the backup info block of this arena. |
|
* @freelist: Pointer to in-memory list of free blocks |
|
* @rtt: Pointer to in-memory "Read Tracking Table" |
|
* @map_locks: Spinlocks protecting concurrent map writes |
|
* @nd_btt: Pointer to parent nd_btt structure. |
|
* @list: List head for list of arenas |
|
* @debugfs_dir: Debugfs dentry |
|
* @flags: Arena flags - may signify error states. |
|
* @err_lock: Mutex for synchronizing error clearing. |
|
* @log_index: Indices of the valid log entries in a log_group |
|
* |
|
* arena_info is a per-arena handle. Once an arena is narrowed down for an |
|
* IO, this struct is passed around for the duration of the IO. |
|
*/ |
|
struct arena_info { |
|
u64 size; /* Total bytes for this arena */ |
|
u64 external_lba_start; |
|
u32 internal_nlba; |
|
u32 internal_lbasize; |
|
u32 external_nlba; |
|
u32 external_lbasize; |
|
u32 nfree; |
|
u16 version_major; |
|
u16 version_minor; |
|
u32 sector_size; |
|
/* Byte offsets to the different on-media structures */ |
|
u64 nextoff; |
|
u64 infooff; |
|
u64 dataoff; |
|
u64 mapoff; |
|
u64 logoff; |
|
u64 info2off; |
|
/* Pointers to other in-memory structures for this arena */ |
|
struct free_entry *freelist; |
|
u32 *rtt; |
|
struct aligned_lock *map_locks; |
|
struct nd_btt *nd_btt; |
|
struct list_head list; |
|
struct dentry *debugfs_dir; |
|
/* Arena flags */ |
|
u32 flags; |
|
struct mutex err_lock; |
|
int log_index[2]; |
|
}; |
|
|
|
struct badblocks; |
|
|
|
/** |
|
* struct btt - handle for a BTT instance |
|
* @btt_disk: Pointer to the gendisk for BTT device |
|
* @arena_list: Head of the list of arenas |
|
* @debugfs_dir: Debugfs dentry |
|
* @nd_btt: Parent nd_btt struct |
|
* @nlba: Number of logical blocks exposed to the upper layers |
|
* after removing the amount of space needed by metadata |
|
* @rawsize: Total size in bytes of the available backing device |
|
* @lbasize: LBA size as requested and presented to upper layers. |
|
* This is sector_size + size of any metadata. |
|
* @sector_size: The Linux sector size - 512 or 4096 |
|
* @lanes: Per-lane spinlocks |
|
* @init_lock: Mutex used for the BTT initialization |
|
* @init_state: Flag describing the initialization state for the BTT |
|
* @num_arenas: Number of arenas in the BTT instance |
|
* @phys_bb: Pointer to the namespace's badblocks structure |
|
*/ |
|
struct btt { |
|
struct gendisk *btt_disk; |
|
struct list_head arena_list; |
|
struct dentry *debugfs_dir; |
|
struct nd_btt *nd_btt; |
|
u64 nlba; |
|
unsigned long long rawsize; |
|
u32 lbasize; |
|
u32 sector_size; |
|
struct nd_region *nd_region; |
|
struct mutex init_lock; |
|
int init_state; |
|
int num_arenas; |
|
struct badblocks *phys_bb; |
|
}; |
|
|
|
bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super); |
|
int nd_btt_version(struct nd_btt *nd_btt, struct nd_namespace_common *ndns, |
|
struct btt_sb *btt_sb); |
|
|
|
#endif
|
|
|