blob: 7c5fa4dd9722200160c44de44d3f346b2bd6657a [file] [log] [blame]
Matias Bjørlingae1519e2015-10-28 19:54:57 +01001/*
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
38struct rrpc_inflight {
39 struct list_head reqs;
40 spinlock_t lock;
41};
42
43struct rrpc_inflight_rq {
44 struct list_head list;
45 sector_t l_start;
46 sector_t l_end;
47};
48
49struct rrpc_rq {
50 struct rrpc_inflight_rq inflight_rq;
51 struct rrpc_addr *addr;
52 unsigned long flags;
53};
54
55struct rrpc_block {
56 struct nvm_block *parent;
Javier Gonzálezd7a64d22016-01-12 07:49:31 +010057 struct rrpc_lun *rlun;
Matias Bjørlingae1519e2015-10-28 19:54:57 +010058 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
72struct 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
83struct 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
Matias Bjørlingb7ceb7d2015-11-02 17:12:27 +010090 u64 poffset; /* physical page offset */
Matias Bjørlingae1519e2015-10-28 19:54:57 +010091 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
132struct 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 */
139struct rrpc_addr {
Matias Bjørlingb7ceb7d2015-11-02 17:12:27 +0100140 u64 addr;
Matias Bjørlingae1519e2015-10-28 19:54:57 +0100141 struct rrpc_block *rblk;
142};
143
144/* Physical to logical mapping */
145struct rrpc_rev_addr {
Matias Bjørlingb7ceb7d2015-11-02 17:12:27 +0100146 u64 addr;
Matias Bjørlingae1519e2015-10-28 19:54:57 +0100147};
148
149static inline sector_t rrpc_get_laddr(struct bio *bio)
150{
151 return bio->bi_iter.bi_sector / NR_PHY_IN_LOG;
152}
153
154static inline unsigned int rrpc_get_pages(struct bio *bio)
155{
156 return bio->bi_iter.bi_size / RRPC_EXPOSED_PAGE_SIZE;
157}
158
159static inline sector_t rrpc_get_sector(sector_t laddr)
160{
161 return laddr * NR_PHY_IN_LOG;
162}
163
164static 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
171static 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
194static 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
203static 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
210static 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
220static 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
230static 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_ */