Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ae1519ec authored by Matias Bjørling's avatar Matias Bjørling Committed by Jens Axboe
Browse files

rrpc: Round-robin sector target with cost-based gc 



This target allows an Open-Channel SSD to be exposed asas a block
device.

It implements a round-robin approach for sector allocation,
together with a greedy cost-based garbage collector.

Signed-off-by: default avatarMatias Bjørling <m@bjorling.me>
Signed-off-by: default avatarJens Axboe <axboe@fb.com>
parent 48add0f5

drivers/lightnvm/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -32,4 +32,11 @@ config NVM_GENNVM 
	functionality to device, while keeping data placement and garbage

	collection decisions on the host.



config NVM_RRPC

	tristate "Round-robin Hybrid Open-Channel SSD target"

	---help---

	Allows an open-channel SSD to be exposed as a block device to the

	host. The target is implemented using a linear mapping table and

	cost-based garbage collection. It is optimized for 4K IO sizes.



endif # NVM

drivers/lightnvm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -4,3 +4,4 @@ 


obj-$(CONFIG_NVM)		:= core.o

obj-$(CONFIG_NVM_GENNVM) 	+= gennvm.o

obj-$(CONFIG_NVM_RRPC)		+= rrpc.o

drivers/lightnvm/rrpc.c

0 → 100644
+1324 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/lightnvm/rrpc.h

0 → 100644
+239 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2015 IT University of Copenhagen

 * Initial release: Matias Bjorling <m@bjorling.me>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License version

 * 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * Implementation of a Round-robin page-based Hybrid FTL for Open-channel SSDs.

 */



#ifndef RRPC_H_

#define RRPC_H_



#include <linux/blkdev.h>

#include <linux/blk-mq.h>

#include <linux/bio.h>

#include <linux/module.h>

#include <linux/kthread.h>

#include <linux/vmalloc.h>



#include <linux/lightnvm.h>



/* Run only GC if less than 1/X blocks are free */

#define GC_LIMIT_INVERSE 10

#define GC_TIME_SECS 100



#define RRPC_SECTOR (512)

#define RRPC_EXPOSED_PAGE_SIZE (4096)



#define NR_PHY_IN_LOG (RRPC_EXPOSED_PAGE_SIZE / RRPC_SECTOR)



struct rrpc_inflight {

	struct list_head reqs;

	spinlock_t lock;

};



struct rrpc_inflight_rq {

	struct list_head list;

	sector_t l_start;

	sector_t l_end;

};



struct rrpc_rq {

	struct rrpc_inflight_rq inflight_rq;

	struct rrpc_addr *addr;

	unsigned long flags;

};



struct rrpc_block {

	struct nvm_block *parent;

	struct list_head prio;



#define MAX_INVALID_PAGES_STORAGE 8

	/* Bitmap for invalid page intries */

	unsigned long invalid_pages[MAX_INVALID_PAGES_STORAGE];

	/* points to the next writable page within a block */

	unsigned int next_page;

	/* number of pages that are invalid, wrt host page size */

	unsigned int nr_invalid_pages;



	spinlock_t lock;

	atomic_t data_cmnt_size; /* data pages committed to stable storage */

};



struct rrpc_lun {

	struct rrpc *rrpc;

	struct nvm_lun *parent;

	struct rrpc_block *cur, *gc_cur;

	struct rrpc_block *blocks;	/* Reference to block allocation */

	struct list_head prio_list;		/* Blocks that may be GC'ed */

	struct work_struct ws_gc;



	spinlock_t lock;

};



struct rrpc {

	/* instance must be kept in top to resolve rrpc in unprep */

	struct nvm_tgt_instance instance;



	struct nvm_dev *dev;

	struct gendisk *disk;



	sector_t poffset; /* physical page offset */

	int lun_offset;



	int nr_luns;

	struct rrpc_lun *luns;



	/* calculated values */

	unsigned long long nr_pages;

	unsigned long total_blocks;



	/* Write strategy variables. Move these into each for structure for each

	 * strategy

	 */

	atomic_t next_lun; /* Whenever a page is written, this is updated

			    * to point to the next write lun

			    */



	spinlock_t bio_lock;

	struct bio_list requeue_bios;

	struct work_struct ws_requeue;



	/* Simple translation map of logical addresses to physical addresses.

	 * The logical addresses is known by the host system, while the physical

	 * addresses are used when writing to the disk block device.

	 */

	struct rrpc_addr *trans_map;

	/* also store a reverse map for garbage collection */

	struct rrpc_rev_addr *rev_trans_map;

	spinlock_t rev_lock;



	struct rrpc_inflight inflights;



	mempool_t *addr_pool;

	mempool_t *page_pool;

	mempool_t *gcb_pool;

	mempool_t *rq_pool;



	struct timer_list gc_timer;

	struct workqueue_struct *krqd_wq;

	struct workqueue_struct *kgc_wq;

};



struct rrpc_block_gc {

	struct rrpc *rrpc;

	struct rrpc_block *rblk;

	struct work_struct ws_gc;

};



/* Logical to physical mapping */

struct rrpc_addr {

	sector_t addr;

	struct rrpc_block *rblk;

};



/* Physical to logical mapping */

struct rrpc_rev_addr {

	sector_t addr;

};



static inline sector_t rrpc_get_laddr(struct bio *bio)

{

	return bio->bi_iter.bi_sector / NR_PHY_IN_LOG;

}



static inline unsigned int rrpc_get_pages(struct bio *bio)

{

	return  bio->bi_iter.bi_size / RRPC_EXPOSED_PAGE_SIZE;

}



static inline sector_t rrpc_get_sector(sector_t laddr)

{

	return laddr * NR_PHY_IN_LOG;

}



static inline int request_intersects(struct rrpc_inflight_rq *r,

				sector_t laddr_start, sector_t laddr_end)

{

	return (laddr_end >= r->l_start && laddr_end <= r->l_end) &&

		(laddr_start >= r->l_start && laddr_start <= r->l_end);

}



static int __rrpc_lock_laddr(struct rrpc *rrpc, sector_t laddr,

			     unsigned pages, struct rrpc_inflight_rq *r)

{

	sector_t laddr_end = laddr + pages - 1;

	struct rrpc_inflight_rq *rtmp;



	spin_lock_irq(&rrpc->inflights.lock);

	list_for_each_entry(rtmp, &rrpc->inflights.reqs, list) {

		if (unlikely(request_intersects(rtmp, laddr, laddr_end))) {

			/* existing, overlapping request, come back later */

			spin_unlock_irq(&rrpc->inflights.lock);

			return 1;

		}

	}



	r->l_start = laddr;

	r->l_end = laddr_end;



	list_add_tail(&r->list, &rrpc->inflights.reqs);

	spin_unlock_irq(&rrpc->inflights.lock);

	return 0;

}



static inline int rrpc_lock_laddr(struct rrpc *rrpc, sector_t laddr,

				 unsigned pages,

				 struct rrpc_inflight_rq *r)

{

	BUG_ON((laddr + pages) > rrpc->nr_pages);



	return __rrpc_lock_laddr(rrpc, laddr, pages, r);

}



static inline struct rrpc_inflight_rq *rrpc_get_inflight_rq(struct nvm_rq *rqd)

{

	struct rrpc_rq *rrqd = nvm_rq_to_pdu(rqd);



	return &rrqd->inflight_rq;

}



static inline int rrpc_lock_rq(struct rrpc *rrpc, struct bio *bio,

							struct nvm_rq *rqd)

{

	sector_t laddr = rrpc_get_laddr(bio);

	unsigned int pages = rrpc_get_pages(bio);

	struct rrpc_inflight_rq *r = rrpc_get_inflight_rq(rqd);



	return rrpc_lock_laddr(rrpc, laddr, pages, r);

}



static inline void rrpc_unlock_laddr(struct rrpc *rrpc,

						struct rrpc_inflight_rq *r)

{

	unsigned long flags;



	spin_lock_irqsave(&rrpc->inflights.lock, flags);

	list_del_init(&r->list);

	spin_unlock_irqrestore(&rrpc->inflights.lock, flags);

}



static inline void rrpc_unlock_rq(struct rrpc *rrpc, struct nvm_rq *rqd)

{

	struct rrpc_inflight_rq *r = rrpc_get_inflight_rq(rqd);

	uint8_t pages = rqd->nr_pages;



	BUG_ON((r->l_start + pages) > rrpc->nr_pages);



	rrpc_unlock_laddr(rrpc, r);

}



#endif /* RRPC_H_ */