drivers/nvdimm/btt.h

   1 /*
   2  * Block Translation Table library
   3  * Copyright (c) 2014-2015, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #ifndef _LINUX_BTT_H
  16 #define _LINUX_BTT_H
  17
  18 #include <linux/badblocks.h>
  19 #include <linux/types.h>
  20
  21 #define BTT_SIG_LEN 16
  22 #define BTT_SIG "BTT_ARENA_INFO\0"
  23 #define MAP_ENT_SIZE 4
  24 #define MAP_TRIM_SHIFT 31
  25 #define MAP_TRIM_MASK (1 << MAP_TRIM_SHIFT)
  26 #define MAP_ERR_SHIFT 30
  27 #define MAP_ERR_MASK (1 << MAP_ERR_SHIFT)
  28 #define MAP_LBA_MASK (~((1 << MAP_TRIM_SHIFT) | (1 << MAP_ERR_SHIFT)))
  29 #define MAP_ENT_NORMAL 0xC0000000
  30 #define LOG_ENT_SIZE sizeof(struct log_entry)
  31 #define ARENA_MIN_SIZE (1UL << 24)      /* 16 MB */
  32 #define ARENA_MAX_SIZE (1ULL << 39)     /* 512 GB */
  33 #define RTT_VALID (1UL << 31)
  34 #define RTT_INVALID 0
  35 #define BTT_PG_SIZE 4096
  36 #define BTT_DEFAULT_NFREE ND_MAX_LANES
  37 #define LOG_SEQ_INIT 1
  38
  39 #define IB_FLAG_ERROR 0x00000001
  40 #define IB_FLAG_ERROR_MASK 0x00000001
  41
  42 #define ent_lba(ent) (ent & MAP_LBA_MASK)
  43 #define ent_e_flag(ent) (!!(ent & MAP_ERR_MASK))
  44 #define ent_z_flag(ent) (!!(ent & MAP_TRIM_MASK))
  45 #define set_e_flag(ent) (ent |= MAP_ERR_MASK)
  46
  47 enum btt_init_state {
  48         INIT_UNCHECKED = 0,
  49         INIT_NOTFOUND,
  50         INIT_READY
  51 };
  52
  53 struct log_entry {
  54         __le32 lba;
  55         __le32 old_map;
  56         __le32 new_map;
  57         __le32 seq;
  58         __le64 padding[2];
  59 };
  60
  61 struct btt_sb {
  62         u8 signature[BTT_SIG_LEN];
  63         u8 uuid[16];
  64         u8 parent_uuid[16];
  65         __le32 flags;
  66         __le16 version_major;
  67         __le16 version_minor;
  68         __le32 external_lbasize;
  69         __le32 external_nlba;
  70         __le32 internal_lbasize;
  71         __le32 internal_nlba;
  72         __le32 nfree;
  73         __le32 infosize;
  74         __le64 nextoff;
  75         __le64 dataoff;
  76         __le64 mapoff;
  77         __le64 logoff;
  78         __le64 info2off;
  79         u8 padding[3968];
  80         __le64 checksum;
  81 };
  82
  83 struct free_entry {
  84         u32 block;
  85         u8 sub;
  86         u8 seq;
  87         u8 has_err;
  88 };
  89
  90 struct aligned_lock {
  91         union {
  92                 spinlock_t lock;
  93                 u8 cacheline_padding[L1_CACHE_BYTES];
  94         };
  95 };
  96
  97 /**
  98  * struct arena_info - handle for an arena
  99  * @size:               Size in bytes this arena occupies on the raw device.
 100  *                      This includes arena metadata.
 101  * @external_lba_start: The first external LBA in this arena.
 102  * @internal_nlba:      Number of internal blocks available in the arena
 103  *                      including nfree reserved blocks
 104  * @internal_lbasize:   Internal and external lba sizes may be different as
 105  *                      we can round up 'odd' external lbasizes such as 520B
 106  *                      to be aligned.
 107  * @external_nlba:      Number of blocks contributed by the arena to the number
 108  *                      reported to upper layers. (internal_nlba - nfree)
 109  * @external_lbasize:   LBA size as exposed to upper layers.
 110  * @nfree:              A reserve number of 'free' blocks that is used to
 111  *                      handle incoming writes.
 112  * @version_major:      Metadata layout version major.
 113  * @version_minor:      Metadata layout version minor.
 114  * @sector_size:        The Linux sector size - 512 or 4096
 115  * @nextoff:            Offset in bytes to the start of the next arena.
 116  * @infooff:            Offset in bytes to the info block of this arena.
 117  * @dataoff:            Offset in bytes to the data area of this arena.
 118  * @mapoff:             Offset in bytes to the map area of this arena.
 119  * @logoff:             Offset in bytes to the log area of this arena.
 120  * @info2off:           Offset in bytes to the backup info block of this arena.
 121  * @freelist:           Pointer to in-memory list of free blocks
 122  * @rtt:                Pointer to in-memory "Read Tracking Table"
 123  * @map_locks:          Spinlocks protecting concurrent map writes
 124  * @nd_btt:             Pointer to parent nd_btt structure.
 125  * @list:               List head for list of arenas
 126  * @debugfs_dir:        Debugfs dentry
 127  * @flags:              Arena flags - may signify error states.
 128  *
 129  * arena_info is a per-arena handle. Once an arena is narrowed down for an
 130  * IO, this struct is passed around for the duration of the IO.
 131  */
 132 struct arena_info {
 133         u64 size;                       /* Total bytes for this arena */
 134         u64 external_lba_start;
 135         u32 internal_nlba;
 136         u32 internal_lbasize;
 137         u32 external_nlba;
 138         u32 external_lbasize;
 139         u32 nfree;
 140         u16 version_major;
 141         u16 version_minor;
 142         u32 sector_size;
 143         /* Byte offsets to the different on-media structures */
 144         u64 nextoff;
 145         u64 infooff;
 146         u64 dataoff;
 147         u64 mapoff;
 148         u64 logoff;
 149         u64 info2off;
 150         /* Pointers to other in-memory structures for this arena */
 151         struct free_entry *freelist;
 152         u32 *rtt;
 153         struct aligned_lock *map_locks;
 154         struct nd_btt *nd_btt;
 155         struct list_head list;
 156         struct dentry *debugfs_dir;
 157         /* Arena flags */
 158         u32 flags;
 159         struct mutex err_lock;
 160 };
 161
 162 /**
 163  * struct btt - handle for a BTT instance
 164  * @btt_disk:           Pointer to the gendisk for BTT device
 165  * @btt_queue:          Pointer to the request queue for the BTT device
 166  * @arena_list:         Head of the list of arenas
 167  * @debugfs_dir:        Debugfs dentry
 168  * @nd_btt:             Parent nd_btt struct
 169  * @nlba:               Number of logical blocks exposed to the upper layers
 170  *                      after removing the amount of space needed by metadata
 171  * @rawsize:            Total size in bytes of the available backing device
 172  * @lbasize:            LBA size as requested and presented to upper layers.
 173  *                      This is sector_size + size of any metadata.
 174  * @sector_size:        The Linux sector size - 512 or 4096
 175  * @lanes:              Per-lane spinlocks
 176  * @init_lock:          Mutex used for the BTT initialization
 177  * @init_state:         Flag describing the initialization state for the BTT
 178  * @num_arenas:         Number of arenas in the BTT instance
 179  */
 180 struct btt {
 181         struct gendisk *btt_disk;
 182         struct request_queue *btt_queue;
 183         struct list_head arena_list;
 184         struct dentry *debugfs_dir;
 185         struct nd_btt *nd_btt;
 186         u64 nlba;
 187         unsigned long long rawsize;
 188         u32 lbasize;
 189         u32 sector_size;
 190         struct nd_region *nd_region;
 191         struct mutex init_lock;
 192         int init_state;
 193         int num_arenas;
 194         struct badblocks *phys_bb;
 195 };
 196
 197 bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super);
 198 int nd_btt_version(struct nd_btt *nd_btt, struct nd_namespace_common *ndns,
 199                 struct btt_sb *btt_sb);
 200
 201 #endif