drivers/lightnvm/rrpc.h

   1 /*
   2  * Copyright (C) 2015 IT University of Copenhagen
   3  * Initial release: Matias Bjorling <m@bjorling.me>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License version
   7  * 2 as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * Implementation of a Round-robin page-based Hybrid FTL for Open-channel SSDs.
  15  */
  16
  17 #ifndef RRPC_H_
  18 #define RRPC_H_
  19
  20 #include <linux/blkdev.h>
  21 #include <linux/blk-mq.h>
  22 #include <linux/bio.h>
  23 #include <linux/module.h>
  24 #include <linux/kthread.h>
  25 #include <linux/vmalloc.h>
  26
  27 #include <linux/lightnvm.h>
  28
  29 /* Run only GC if less than 1/X blocks are free */
  30 #define GC_LIMIT_INVERSE 10
  31 #define GC_TIME_SECS 100
  32
  33 #define RRPC_SECTOR (512)
  34 #define RRPC_EXPOSED_PAGE_SIZE (4096)
  35
  36 #define NR_PHY_IN_LOG (RRPC_EXPOSED_PAGE_SIZE / RRPC_SECTOR)
  37
  38 struct rrpc_inflight {
  39         struct list_head reqs;
  40         spinlock_t lock;
  41 };
  42
  43 struct rrpc_inflight_rq {
  44         struct list_head list;
  45         sector_t l_start;
  46         sector_t l_end;
  47 };
  48
  49 struct rrpc_rq {
  50         struct rrpc_inflight_rq inflight_rq;
  51         struct rrpc_addr *addr;
  52         unsigned long flags;
  53 };
  54
  55 struct rrpc_block {
  56         struct nvm_block *parent;
  57         struct rrpc_lun *rlun;
  58         struct list_head prio;
  59
  60 #define MAX_INVALID_PAGES_STORAGE 8
  61         /* Bitmap for invalid page intries */
  62         unsigned long invalid_pages[MAX_INVALID_PAGES_STORAGE];
  63         /* points to the next writable page within a block */
  64         unsigned int next_page;
  65         /* number of pages that are invalid, wrt host page size */
  66         unsigned int nr_invalid_pages;
  67
  68         spinlock_t lock;
  69         atomic_t data_cmnt_size; /* data pages committed to stable storage */
  70 };
  71
  72 struct rrpc_lun {
  73         struct rrpc *rrpc;
  74         struct nvm_lun *parent;
  75         struct rrpc_block *cur, *gc_cur;
  76         struct rrpc_block *blocks;      /* Reference to block allocation */
  77         struct list_head prio_list;             /* Blocks that may be GC'ed */
  78         struct work_struct ws_gc;
  79
  80         spinlock_t lock;
  81 };
  82
  83 struct rrpc {
  84         /* instance must be kept in top to resolve rrpc in unprep */
  85         struct nvm_tgt_instance instance;
  86
  87         struct nvm_dev *dev;
  88         struct gendisk *disk;
  89
  90         u64 poffset; /* physical page offset */
  91         int lun_offset;
  92
  93         int nr_luns;
  94         struct rrpc_lun *luns;
  95
  96         /* calculated values */
  97         unsigned long long nr_pages;
  98         unsigned long total_blocks;
  99
 100         /* Write strategy variables. Move these into each for structure for each
 101          * strategy
 102          */
 103         atomic_t next_lun; /* Whenever a page is written, this is updated
 104                             * to point to the next write lun
 105                             */
 106
 107         spinlock_t bio_lock;
 108         struct bio_list requeue_bios;
 109         struct work_struct ws_requeue;
 110
 111         /* Simple translation map of logical addresses to physical addresses.
 112          * The logical addresses is known by the host system, while the physical
 113          * addresses are used when writing to the disk block device.
 114          */
 115         struct rrpc_addr *trans_map;
 116         /* also store a reverse map for garbage collection */
 117         struct rrpc_rev_addr *rev_trans_map;
 118         spinlock_t rev_lock;
 119
 120         struct rrpc_inflight inflights;
 121
 122         mempool_t *addr_pool;
 123         mempool_t *page_pool;
 124         mempool_t *gcb_pool;
 125         mempool_t *rq_pool;
 126
 127         struct timer_list gc_timer;
 128         struct workqueue_struct *krqd_wq;
 129         struct workqueue_struct *kgc_wq;
 130 };
 131
 132 struct rrpc_block_gc {
 133         struct rrpc *rrpc;
 134         struct rrpc_block *rblk;
 135         struct work_struct ws_gc;
 136 };
 137
 138 /* Logical to physical mapping */
 139 struct rrpc_addr {
 140         u64 addr;
 141         struct rrpc_block *rblk;
 142 };
 143
 144 /* Physical to logical mapping */
 145 struct rrpc_rev_addr {
 146         u64 addr;
 147 };
 148
 149 static inline sector_t rrpc_get_laddr(struct bio *bio)
 150 {
 151         return bio->bi_iter.bi_sector / NR_PHY_IN_LOG;
 152 }
 153
 154 static inline unsigned int rrpc_get_pages(struct bio *bio)
 155 {
 156         return  bio->bi_iter.bi_size / RRPC_EXPOSED_PAGE_SIZE;
 157 }
 158
 159 static inline sector_t rrpc_get_sector(sector_t laddr)
 160 {
 161         return laddr * NR_PHY_IN_LOG;
 162 }
 163
 164 static inline int request_intersects(struct rrpc_inflight_rq *r,
 165                                 sector_t laddr_start, sector_t laddr_end)
 166 {
 167         return (laddr_end >= r->l_start && laddr_end <= r->l_end) &&
 168                 (laddr_start >= r->l_start && laddr_start <= r->l_end);
 169 }
 170
 171 static int __rrpc_lock_laddr(struct rrpc *rrpc, sector_t laddr,
 172                              unsigned pages, struct rrpc_inflight_rq *r)
 173 {
 174         sector_t laddr_end = laddr + pages - 1;
 175         struct rrpc_inflight_rq *rtmp;
 176
 177         spin_lock_irq(&rrpc->inflights.lock);
 178         list_for_each_entry(rtmp, &rrpc->inflights.reqs, list) {
 179                 if (unlikely(request_intersects(rtmp, laddr, laddr_end))) {
 180                         /* existing, overlapping request, come back later */
 181                         spin_unlock_irq(&rrpc->inflights.lock);
 182                         return 1;
 183                 }
 184         }
 185
 186         r->l_start = laddr;
 187         r->l_end = laddr_end;
 188
 189         list_add_tail(&r->list, &rrpc->inflights.reqs);
 190         spin_unlock_irq(&rrpc->inflights.lock);
 191         return 0;
 192 }
 193
 194 static inline int rrpc_lock_laddr(struct rrpc *rrpc, sector_t laddr,
 195                                  unsigned pages,
 196                                  struct rrpc_inflight_rq *r)
 197 {
 198         BUG_ON((laddr + pages) > rrpc->nr_pages);
 199
 200         return __rrpc_lock_laddr(rrpc, laddr, pages, r);
 201 }
 202
 203 static inline struct rrpc_inflight_rq *rrpc_get_inflight_rq(struct nvm_rq *rqd)
 204 {
 205         struct rrpc_rq *rrqd = nvm_rq_to_pdu(rqd);
 206
 207         return &rrqd->inflight_rq;
 208 }
 209
 210 static inline int rrpc_lock_rq(struct rrpc *rrpc, struct bio *bio,
 211                                                         struct nvm_rq *rqd)
 212 {
 213         sector_t laddr = rrpc_get_laddr(bio);
 214         unsigned int pages = rrpc_get_pages(bio);
 215         struct rrpc_inflight_rq *r = rrpc_get_inflight_rq(rqd);
 216
 217         return rrpc_lock_laddr(rrpc, laddr, pages, r);
 218 }
 219
 220 static inline void rrpc_unlock_laddr(struct rrpc *rrpc,
 221                                                 struct rrpc_inflight_rq *r)
 222 {
 223         unsigned long flags;
 224
 225         spin_lock_irqsave(&rrpc->inflights.lock, flags);
 226         list_del_init(&r->list);
 227         spin_unlock_irqrestore(&rrpc->inflights.lock, flags);
 228 }
 229
 230 static inline void rrpc_unlock_rq(struct rrpc *rrpc, struct nvm_rq *rqd)
 231 {
 232         struct rrpc_inflight_rq *r = rrpc_get_inflight_rq(rqd);
 233         uint8_t pages = rqd->nr_pages;
 234
 235         BUG_ON((r->l_start + pages) > rrpc->nr_pages);
 236
 237         rrpc_unlock_laddr(rrpc, r);
 238 }
 239
 240 #endif /* RRPC_H_ */