nvm page allocator for bcache
v5 cover nvm page allocator for bcache
This series implements nvm pages allocator for bcache. This idea is from one discussion about nvdimm use case in kernel together with Coly. Coly sent the following email about this idea to give some introduction on what we will do before:
https://lore.kernel.org/linux-bcache/[email protected]/
Here this series focus on the first step in above email, that is to say, this patch set implements a generic framework in bcache to allocate/release NV-memory pages, and provide allocated pages for each requestor after reboot. In order to do this, one simple buddy system is implemented to manage NV-memory pages.
This set includes one testing module which can be used for simple test cases. Next need to stroe bcache log or internal btree nodes into nvdimm based on these buddy apis to do more testing.
Qiaowei Ren (8):
bcache: add initial data structures for nvm pages
bcache: initialize the nvm pages allocator
bcache: initialization of the buddy
bcache: bch_nvm_alloc_pages() of the buddy
bcache: bch_nvm_free_pages() of the buddy
bcache: get allocated pages from specific owner
bcache: persist owner info when alloc/free pages.
bcache: testing module for nvm pages allocator
drivers/md/bcache/Kconfig | 12 + drivers/md/bcache/Makefile | 4 +- drivers/md/bcache/nvm-pages.c | 914 ++++++++++++++++++++++++++++++++ drivers/md/bcache/nvm-pages.h | 111 ++++ drivers/md/bcache/super.c | 3 + drivers/md/bcache/test-nvm.c | 202 +++++++ include/uapi/linux/bcache-nvm.h | 188 +++++++ 7 files changed, 1433 insertions(+), 1 deletion(-) create mode 100644 drivers/md/bcache/nvm-pages.c create mode 100644 drivers/md/bcache/nvm-pages.h create mode 100644 drivers/md/bcache/test-nvm.c create mode 100644 include/uapi/linux/bcache-nvm.h
Signature · 1 line
2.17.1
RFC PATCH v5 1/8 bcache: add initial data structures for nvm pages
This patch initializes the prototype data structures for nvm pages allocator,
- struct bch_nvm_pages_sb
This is the super block allocated on each nvdimm namespace. A nvdimm set may have multiple namespaces, bch_nvm_pages_sb->set_uuid is used to mark which nvdimm set this name space belongs to. Normally we will use the bcache's cache set UUID to initialize this uuid, to connect this nvdimm set to a specified bcache cache set.
- struct bch_owner_list_head
This is a table for all heads of all owner lists. A owner list records which page(s) allocated to which owner. After reboot from power failure, the ownwer may find all its requested and allocated pages from the owner list by a handler which is converted by a UUID.
- struct bch_nvm_pages_owner_head
This is a head of an owner list. Each owner only has one owner list, and a nvm page only belongs to an specific owner. uuid[] will be set to owner's uuid, for bcache it is the bcache's cache set uuid. label is not mandatory, it is a human-readable string for debug purpose. The pointer *recs references to separated nvm page which hold the table of struct bch_nvm_pgalloc_rec.
- struct bch_nvm_pgalloc_recs
This struct occupies a whole page, owner_uuid should match the uuid in struct bch_nvm_pages_owner_head. recs[] is the real table contains all allocated records.
- struct bch_nvm_pgalloc_rec
Each structure records a range of allocated nvm pages. pgoff is offset in unit of page size of this allocated nvm page range. The adjoint page ranges of same owner can be merged into a larger one, therefore pages_nr is NOT always power of 2.
--- include/uapi/linux/bcache-nvm.h | 195 ++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 include/uapi/linux/bcache-nvm.h
include/uapi/linux/bcache-nvm.h new file +195 -0
@@ -0,0 +1,195 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ + +#ifndef _UAPI_BCACHE_NVM_H +#define _UAPI_BCACHE_NVM_H + +/* +* Bcache on NVDIMM data structures +*/ + +/* +* - struct bch_nvm_pages_sb +* This is the super block allocated on each nvdimm namespace. A nvdimm +* set may have multiple namespaces, bch_nvm_pages_sb->set_uuid is used to mark +* which nvdimm set this name space belongs to. Normally we will use the +* bcache's cache set UUID to initialize this uuid, to connect this nvdimm +* set to a specified bcache cache set. +* +* - struct bch_owner_list_head +* This is a table for all heads of all owner lists. A owner list records +* which page(s) allocated to which owner. After reboot from power failure, +* the ownwer may find all its requested and allocated pages from the owner +* list by a handler which is converted by a UUID. +* +* - struct bch_nvm_pages_owner_head +* This is a head of an owner list. Each owner only has one owner list, +* and a nvm page only belongs to an specific owner. uuid[] will be set to +* owner's uuid, for bcache it is the bcache's cache set uuid. label is not +* mandatory, it is a human-readable string for debug purpose. The pointer +* recs references to separated nvm page which hold the table of struct +* bch_pgalloc_rec. +* +*- struct bch_nvm_pgalloc_recs +* This structure occupies a whole page, owner_uuid should match the uuid +* in struct bch_nvm_pages_owner_head. recs[] is the real table contains all +* allocated records. +* +* - struct bch_pgalloc_rec +* Each structure records a range of allocated nvm pages. pgoff is offset +* in unit of page size of this allocated nvm page range. The adjoint page +* ranges of same owner can be merged into a larger one, therefore pages_nr +* is NOT always power of 2. +* +* +* Memory layout on nvdimm namespace 0 +* +* 0 +---------------------------------+ +* | | +* 4KB +---------------------------------+ +* | bch_nvm_pages_sb | +* 8KB +---------------------------------+ <--- bch_nvm_pages_sb.bch_owner_list_head +* | bch_owner_list_head | +* | | +* 16KB +---------------------------------+ <--- bch_owner_list_head.heads[0].recs[0] +* | bch_nvm_pgalloc_recs | +* | (nvm pages internal usage) | +* 24KB +---------------------------------+ +* | | +* | | +* 16MB +---------------------------------+ +* | allocable nvm pages | +* | for buddy allocator | +* end +---------------------------------+ +* +* +* +* Memory layout on nvdimm namespace N +* (doesn't have owner list) +* +* 0 +---------------------------------+ +* | | +* 4KB +---------------------------------+ +* | bch_nvm_pages_sb | +* 8KB +---------------------------------+ +* | | +* | | +* | | +* | | +* | | +* | | +* 16MB +---------------------------------+ +* | allocable nvm pages | +* | for buddy allocator | +* end +---------------------------------+ +* +*/ + +#include <linux/types.h> + +/* In sectors */ +#define BCH_NVM_PAGES_SB_OFFSET 4096 +#define BCH_NVM_PAGES_OFFSET (16 << 20) + +#define BCH_NVM_PAGES_LABEL_SIZE 32 +#define BCH_NVM_PAGES_NAMESPACES_MAX 8 + +#define BCH_NVM_PAGES_OWNER_LIST_HEAD_OFFSET (8<<10) +#define BCH_NVM_PAGES_SYS_RECS_HEAD_OFFSET (16<<10) + +#define BCH_NVM_PAGES_SB_VERSION 0 +#define BCH_NVM_PAGES_SB_VERSION_MAX 0 + +static const char bch_nvm_pages_magic[] = { +0x17 ,0xbd ,0x53 ,0x7f ,0x1b ,0x23 ,0xd6 ,0x83 , +0x46 ,0xa4 ,0xf8 ,0x28 ,0x17 ,0xda ,0xec ,0xa9 }; +static const char bch_nvm_pages_pgalloc_magic[] = { +0x39 ,0x25 ,0x3f ,0xf7 ,0x27 ,0x17 ,0xd0 ,0xb9 , +0x10 ,0xe6 ,0xd2 ,0xda ,0x38 ,0x68 ,0x26 ,0xae }; + +struct bch_pgalloc_rec { +__u32 pgoff; +__u32 nr; +}; + +struct bch_nvm_pgalloc_recs { +union { +struct { +struct bch_nvm_pages_owner_head *owner; +struct bch_nvm_pgalloc_recs *next; +__u8 magic[16 ]; +__u8 owner_uuid[16 ]; +__u32 size; +__u32 used; +__u64 _pad[4 ]; +struct bch_pgalloc_rec recs[]; + }; +__u8 pad[8192 ]; +}; +}; +#define BCH_MAX_RECS \ + ((sizeof(struct bch_nvm_pgalloc_recs) - \ + offsetof(struct bch_nvm_pgalloc_recs, recs)) / \ + sizeof(struct bch_pgalloc_rec)) + +struct bch_nvm_pages_owner_head { +__u8 uuid[16 ]; +char label[BCH_NVM_PAGES_LABEL_SIZE ]; +/* Per-namespace own lists */ +struct bch_nvm_pgalloc_recs *recs[BCH_NVM_PAGES_NAMESPACES_MAX ]; +}; + +/* heads[0] is always for nvm_pages internal usage */ +struct bch_owner_list_head { +union { +struct { +__u32 size; +__u32 used; +__u64 _pad[4 ]; +struct bch_nvm_pages_owner_head heads[]; + }; +__u8 pad[8192 ]; +}; +}; +#define BCH_MAX_OWNER_LIST \ + ((sizeof(struct bch_owner_list_head) - \ + offsetof(struct bch_owner_list_head, heads)) / \ + sizeof(struct bch_nvm_pages_owner_head)) + +/* The on-media bit order is local CPU order */ +struct bch_nvm_pages_sb { +__u64 csum; +__u64 ns_start; +__u64 sb_offset; +__u64 version; +__u8 magic[16 ]; +__u8 uuid[16 ]; +__u32 page_size; +__u32 total_namespaces_nr; +__u32 this_namespace_nr; +union { +__u8 set_uuid[16 ]; +__u64 set_magic; + }; + +__u64 flags; +__u64 seq; + +__u64 feature_compat; +__u64 feature_incompat; +__u64 feature_ro_compat; + +/* For allocable nvm pages from buddy systems */ +__u64 pages_offset; +__u64 pages_total; + +__u64 pad[8 ]; + +/* Only on the first name space */ +struct bch_owner_list_head *owner_list_head; + +/* Just for csum_set() */ +__u32 keys; +__u64 d[0 ]; +}; + +#endif /* _UAPI_BCACHE_NVM_H */
Signature · 1 line
2.17.1
RFC PATCH v5 2/8 bcache: initialize the nvm pages allocator
In reply to Qiaowei RenThis patch define the prototype data structures in memory and initializes the nvm pages allocator.
The nv address space which is managed by this allocatior can consist of many nvm namespaces, and some namespaces can compose into one nvm set, like cache set. For this initial implementation, only one set can be supported.
The users of this nvm pages allocator need to call regiseter_namespace() to register the nvdimm device (like /dev/pmemX) into this allocator as the instance of struct nvm_namespace.
--- drivers/md/bcache/Kconfig | 6 + drivers/md/bcache/Makefile | 2 +- drivers/md/bcache/nvm-pages.c | 406 ++++++++++++++++++++++++++++++++ drivers/md/bcache/nvm-pages.h | 92 ++++++++ drivers/md/bcache/super.c | 3 + include/uapi/linux/bcache-nvm.h | 7 - 6 files changed, 508 insertions(+), 8 deletions(-) create mode 100644 drivers/md/bcache/nvm-pages.c create mode 100644 drivers/md/bcache/nvm-pages.h
drivers/md/bcache/Kconfig +6 -0
@@ -35,3 +35,9 @@ config BCACHE_ASYNC_REGISTRATION device path into this file will returns immediately and the real registration work is handled in kernel work queue in asynchronous way. + +config BCACHE_NVM_PAGES + bool "NVDIMM support for bcache (EXPERIMENTAL)" + depends on BCACHE + help + nvm pages allocator for bcache.
drivers/md/bcache/Makefile +1 -1
@@ -4,4 +4,4 @@ obj-$(CONFIG_BCACHE) += bcache.o bcache-y := alloc.o bset.o btree.o closure.o debug.o extents.o\ io.o journal.o movinggc.o request.o stats.o super.o sysfs.o trace.o\ - util.o writeback.o features.o + util.o writeback.o features.o nvm-pages.o
drivers/md/bcache/nvm-pages.c new file +406 -0
406 lines not on this page · raw message
drivers/md/bcache/nvm-pages.h new file +92 -0
92 lines not on this page · raw message
drivers/md/bcache/super.c +3 -0
@@ -14,6 +14,7 @@#include "request.h" #include "writeback.h" #include "features.h" +#include "nvm-pages.h" #include <linux/blkdev.h> #include <linux/debugfs.h>
@@ -2815,6 +2816,7 @@ static void bcache_exit(void) {bch_debug_exit ();bch_request_exit (); +bch_nvm_exit ();if (bcache_kobj)kobject_put (bcache_kobj);if (bcache_wq)
@@ -2894,6 +2896,7 @@ static int __init bcache_init(void)bch_debug_init ();closure_debug_init (); +bch_nvm_init (); bcache_is_reboot = false;
include/uapi/linux/bcache-nvm.h +0 -7
@@ -99,13 +99,6 @@#define BCH_NVM_PAGES_SB_VERSION 0#define BCH_NVM_PAGES_SB_VERSION_MAX 0 -static const char bch_nvm_pages_magic[] = { -0x17 ,0xbd ,0x53 ,0x7f ,0x1b ,0x23 ,0xd6 ,0x83 , -0x46 ,0xa4 ,0xf8 ,0x28 ,0x17 ,0xda ,0xec ,0xa9 }; -static const char bch_nvm_pages_pgalloc_magic[] = { -0x39 ,0x25 ,0x3f ,0xf7 ,0x27 ,0x17 ,0xd0 ,0xb9 , -0x10 ,0xe6 ,0xd2 ,0xda ,0x38 ,0x68 ,0x26 ,0xae }; -struct bch_pgalloc_rec {__u32 pgoff;__u32 nr;
Signature · 1 line
2.17.1
RFC PATCH v5 3/8 bcache: initialization of the buddy
In reply to Qiaowei RenThis nvm pages allocator will implement the simple buddy to manage the nvm address space. This patch initializes this buddy for new namespace.
the unit of alloc/free of the buddy is page. DAX device has their struct page(in dram or PMEM).
struct { /* ZONE_DEVICE pages */
/** @pgmap: Points to the hosting device page map. */ struct dev_pagemap *pgmap;
void *zone_device_data;
/*
* ZONE_DEVICE private pages are counted as being
* mapped so the next 3 words hold the mapping, index,
* and private fields from the source anonymous or
* page cache page while the page is migrated to device
* private memory.
* ZONE_DEVICE MEMORY_DEVICE_FS_DAX pages also
* use the mapping, index, and private fields when
* pmem backed DAX files are mapped.
*/
};
ZONE_DEVICE pages only use pgmap. Other 4 words[16/32 bytes] don't use. So the second/third word will be used as 'struct list_head ' which list in buddy. The fourth word(that is normal struct page::index) store pgoff which the page-offset in the dax device. And the fifth word (that is normal struct page::private) store order of buddy. page_type will be used to store buddy flags.
--- drivers/md/bcache/nvm-pages.c | 83 ++++++++++++++++++++++++++++++++++- drivers/md/bcache/nvm-pages.h | 5 +++ 2 files changed, 86 insertions(+), 2 deletions(-)
drivers/md/bcache/nvm-pages.c +81 -2
@@ -93,6 +93,7 @@ static void release_nvm_namespaces(struct bch_nvm_set *nvm_set)int i;for (i =0 ; i < nvm_set->total_namespaces_nr; i++) { +kvfree (nvm_set->nss[i]->pages_bitmap);blkdev_put (nvm_set->nss[i]->bdev,FMODE_READ |FMODE_WRITE |FMODE_EXEC );kfree (nvm_set->nss[i]); }
@@ -112,6 +113,17 @@ static void *nvm_pgoff_to_vaddr(struct bch_nvm_namespace *ns, pgoff_t pgoff)return ns->kaddr + (pgoff <<PAGE_SHIFT ); } +static struct page *nvm_vaddr_to_page (struct bch_nvm_namespace *ns,void *addr) +{ +return virt_to_page (addr); +} + +static inline void remove_owner_space (struct bch_nvm_namespace *ns, +pgoff_t pgoff,u32 nr) +{ +bitmap_set (ns->pages_bitmap, pgoff, nr); +} +static int init_owner_info (struct bch_nvm_namespace *ns) {struct bch_owner_list_head *owner_list_head;
@@ -129,6 +141,8 @@ static int init_owner_info(struct bch_nvm_namespace *ns) only_set->owner_list_size = owner_list_head->size; only_set->owner_list_used = owner_list_head->used; +remove_owner_space (ns,0 , ns->pages_offset/ns->page_size); +for (i =0 ; i < owner_list_head->used; i++) { owner_head = &owner_list_head->heads[i]; owner_list = alloc_owner_list(owner_head->uuid, owner_head->label,
@@ -173,6 +187,8 @@ static int init_owner_info(struct bch_nvm_namespace *ns) extent->kaddr =nvm_pgoff_to_vaddr (extents->ns, rec->pgoff); extent->nr = rec->nr;list_add_tail (&extent->list, &extents->extent_head); +/*remove already alloced space*/ +remove_owner_space (extents->ns, rec->pgoff, rec->nr); extents->ns->free -= rec->nr; }
@@ -199,6 +215,54 @@ static int init_owner_info(struct bch_nvm_namespace *ns)return 0 ; } +static void init_nvm_free_space (struct bch_nvm_namespace *ns) +{ +unsigned int start, end, i; +struct page *page; +long long pages; +pgoff_t pgoff_start; + +bitmap_for_each_clear_region (ns->pages_bitmap, start, end,0 , ns->pages_total) { + pgoff_start = start; + pages = end - start; + +while (pages) { +for (i =BCH_MAX_ORDER -1 ; i >=0 ; i--) { +if ((pgoff_start % (1 << i) ==0 ) && (pages >= (1 << i))) +break ; + } + + page =nvm_vaddr_to_page (ns,nvm_pgoff_to_vaddr (ns, pgoff_start)); + page->index = pgoff_start; +set_page_private (page, i); +__SetPageBuddy (page); +list_add ((struct list_head *)&page->zone_device_data, &ns->free_area[i]); + + pgoff_start +=1 << i; + pages -=1 << i; + } + } + +bitmap_for_each_set_region (ns->pages_bitmap, start, end,0 , ns->pages_total) { + pages = end - start; + pgoff_start = start; + +while (pages) { +for (i =BCH_MAX_ORDER -1 ; i >=0 ; i--) { +if ((pgoff_start % (1 << i) ==0 ) && (pages >= (1 << i))) +break ; + } + + page =nvm_vaddr_to_page (ns,nvm_pgoff_to_vaddr (ns, pgoff_start)); + page->index = pgoff_start; +set_page_private (page, i); + + pgoff_start +=1 << i; + pages -=1 << i; + } + } +} +static bool attach_nvm_set (struct bch_nvm_namespace *ns) {bool rc = true;
@@ -263,7 +327,7 @@ static int read_nvdimm_meta_super(struct block_device *bdev,struct bch_nvm_namespace *bch_register_namespace (const char *dev_path) {struct bch_nvm_namespace *ns; -int err; +int i, err;pgoff_t pgoff;char buf[BDEVNAME_SIZE ];struct block_device *bdev;
@@ -359,6 +423,16 @@ struct bch_nvm_namespace *bch_register_namespace(const char *dev_path) ns->bdev = bdev; ns->nvm_set = only_set; + ns->pages_bitmap =kvcalloc (BITS_TO_LONGS (ns->pages_total), +sizeof (unsigned long ),GFP_KERNEL ); +if (!ns->pages_bitmap) { + err = -ENOMEM ; + goto free_ns; + } + +for (i =0 ; i <BCH_MAX_ORDER ; i++) +INIT_LIST_HEAD (&ns->free_area[i]); +mutex_init (&ns->lock);if (ns->sb.this_namespace_nr ==0 ) {
@@ -366,12 +440,17 @@ struct bch_nvm_namespace *bch_register_namespace(const char *dev_path) err =init_owner_info (ns);if (err <0 ) {pr_info ("init_owner_info met error %d\n" , err); - goto free_ns; + goto free_bitmap; } +/* init buddy allocator */ +init_nvm_free_space (ns); }kfree (path);return ns; + +free_bitmap: +kvfree (ns->pages_bitmap); free_ns:kfree (ns); bdput:
drivers/md/bcache/nvm-pages.h +5 -0
@@ -34,6 +34,7 @@ struct bch_owner_list {struct bch_nvm_alloced_recs **alloced_recs; }; +#define BCH_MAX_ORDER 20struct bch_nvm_namespace {struct bch_nvm_pages_sb sb;void *kaddr;
@@ -45,6 +46,10 @@ struct bch_nvm_namespace {u64 pages_total;pfn_t start_pfn; +unsigned long *pages_bitmap; +struct list_head free_area[BCH_MAX_ORDER ]; + +struct dax_device *dax_dev;struct block_device *bdev;struct bch_nvm_set *nvm_set;
Signature · 1 line
2.17.1
RFC PATCH v5 4/8 bcache: bch_nvm_alloc_pages() of the buddy
In reply to Qiaowei RenThis patch implements the bch_nvm_alloc_pages() of the buddy.
--- drivers/md/bcache/nvm-pages.c | 155 ++++++++++++++++++++++++++++++++++ drivers/md/bcache/nvm-pages.h | 6 ++ 2 files changed, 161 insertions(+)
drivers/md/bcache/nvm-pages.c +155 -0
@@ -124,6 +124,161 @@ static inline void remove_owner_space(struct bch_nvm_namespace *ns,bitmap_set (ns->pages_bitmap, pgoff, nr); } +/* If not found, it will create if create == true */ +static struct bch_owner_list *find_owner_list (const char *owner_uuid,bool create) +{ +struct bch_owner_list *owner_list; +int i; + +for (i =0 ; i < only_set->owner_list_used; i++) { +if (!memcmp (owner_uuid, only_set->owner_lists[i]->owner_uuid,16 )) +return only_set->owner_lists[i]; + } + +if (create) { + owner_list =alloc_owner_list (owner_uuid,NULL , only_set->total_namespaces_nr); + only_set->owner_lists[only_set->owner_list_used++] = owner_list; +return owner_list; + }else +return NULL ; +} + +static struct bch_nvm_alloced_recs *find_nvm_alloced_recs (struct bch_owner_list *owner_list, +struct bch_nvm_namespace *ns,bool create) +{ +int position = ns->sb.this_namespace_nr; + +if (create && !owner_list->alloced_recs[position]) { +struct bch_nvm_alloced_recs *alloced_recs = +kzalloc (sizeof (*alloced_recs),GFP_KERNEL |__GFP_NOFAIL); + + alloced_recs->ns = ns; +INIT_LIST_HEAD (&alloced_recs->extent_head); + owner_list->alloced_recs[position] = alloced_recs; +return alloced_recs; + }else +return owner_list->alloced_recs[position]; +} + +static inline void *extent_end_addr (struct bch_extent *extent) +{ +return extent->kaddr + ((u64)(extent->nr) <<PAGE_SHIFT ); +} + +static void add_extent (struct bch_nvm_alloced_recs *alloced_recs,void *addr,int order) +{ +struct list_head *list = alloced_recs->extent_head.next; +struct bch_extent *extent, *tmp; +void *end_addr = addr + (((u64 )1 << order) <<PAGE_SHIFT ); + +while (list != &alloced_recs->extent_head) { + extent = container_of(list, struct bch_extent, list); +if (end_addr == extent->kaddr) { + extent->kaddr = addr; + extent->nr +=1 << order; + +if (list->prev != &alloced_recs->extent_head) { + tmp = container_of(list->prev, struct bch_extent, list); +if (extent_end_addr (tmp) == addr) { + tmp->nr += extent->nr; + alloced_recs->nr--; +list_del (list); +kfree (extent); + } + } +break ; + }else if (extent_end_addr (extent) == addr) { + extent->nr +=1 << order; + +if (list->next != &alloced_recs->extent_head) { + tmp = container_of(list->next, struct bch_extent, list); +if (extent_end_addr (extent) == tmp->kaddr) { + extent->nr += tmp->nr; + alloced_recs->nr--; +list_del (list->next); +kfree (tmp); + } + } +break ; + }else if (end_addr < extent->kaddr) { + tmp =kzalloc (sizeof (*tmp),GFP_KERNEL |__GFP_NOFAIL); + tmp->kaddr = addr; + tmp->nr =1 << order; +list_add_tail (&tmp->list, &extent->list); + alloced_recs->nr++; +break ; + } + list = list->next; + } + +if (list == &alloced_recs->extent_head) { +struct bch_extent *e =kzalloc (sizeof (*e),GFP_KERNEL ); + + e->kaddr = addr; + e->nr =1 << order; +list_add (&e->list, &alloced_recs->extent_head); + alloced_recs->nr++; + } +} + +void *bch_nvm_alloc_pages (int order,const char *owner_uuid) +{ +void *kaddr =NULL ; +struct bch_owner_list *owner_list; +struct bch_nvm_alloced_recs *alloced_recs; +int i, j; + +mutex_lock (&only_set->lock); + owner_list =find_owner_list (owner_uuid, true); + +for (j =0 ; j < only_set->total_namespaces_nr; j++) { +struct bch_nvm_namespace *ns = only_set->nss[j]; + +if (!ns || (ns->free < (1 << order))) +continue ; + +for (i = order; i <BCH_MAX_ORDER ; i++) { +struct list_head *list; +struct page *page, *buddy_page; + +if (list_empty (&ns->free_area[i])) +continue ; + + list = ns->free_area[i].next; + page = container_of((void *)list, struct page, zone_device_data); + +list_del (list); + +while (i != order) { + buddy_page =nvm_vaddr_to_page (ns, +nvm_pgoff_to_vaddr (ns, page->index + (1 << (i -1 )))); +set_page_private (buddy_page, i -1 ); + buddy_page->index = page->index + (1 << (i -1 )); +__SetPageBuddy (buddy_page); +list_add ((struct list_head *)&buddy_page->zone_device_data, + &ns->free_area[i -1 ]); + i--; + } + +set_page_private (page, order); +__ClearPageBuddy (page); + ns->free -=1 << order; + kaddr =nvm_pgoff_to_vaddr (ns, page->index); +break ; + } + +if (i !=BCH_MAX_ORDER ) { + alloced_recs =find_nvm_alloced_recs (owner_list, ns, true); +add_extent (alloced_recs, kaddr, order); +break ; + } + } + +mutex_unlock (&only_set->lock); +return kaddr; +} +EXPORT_SYMBOL_GPL (bch_nvm_alloc_pages); +static int init_owner_info (struct bch_nvm_namespace *ns) {struct bch_owner_list_head *owner_list_head;
drivers/md/bcache/nvm-pages.h +6 -0
@@ -79,6 +79,7 @@ extern struct bch_nvm_set *only_set;struct bch_nvm_namespace *bch_register_namespace (const char *dev_path);int bch_nvm_init (void );void bch_nvm_exit (void ); +void *bch_nvm_alloc_pages (int order,const char *owner_uuid);#else
@@ -92,6 +93,11 @@ static inline int bch_nvm_init(void) }static inline void bch_nvm_exit (void ) { } +static inline void *bch_nvm_alloc_pages (int order,const char *owner_uuid) +{ +return NULL ; +} +#endif /* CONFIG_BCACHE_NVM_PAGES */ #endif /* _BCACHE_NVM_PAGES_H */
Signature · 1 line
2.17.1
RFC PATCH v5 5/8 bcache: bch_nvm_free_pages() of the buddy
In reply to Qiaowei RenThis patch implements the bch_nvm_free_pages() of the buddy.
--- drivers/md/bcache/nvm-pages.c | 157 ++++++++++++++++++++++++++++++++-- drivers/md/bcache/nvm-pages.h | 4 +- 2 files changed, 154 insertions(+), 7 deletions(-)
drivers/md/bcache/nvm-pages.c +151 -6
@@ -221,6 +221,153 @@ static void add_extent(struct bch_nvm_alloced_recs *alloced_recs, void *addr, in } } +static inline void *nvm_end_addr (struct bch_nvm_namespace *ns) +{ +return ns->kaddr + (ns->pages_total <<PAGE_SHIFT ); +} + +static inline bool in_nvm_range (struct bch_nvm_namespace *ns, +void *start_addr,void *end_addr) +{ +return (start_addr >= ns->kaddr) && (end_addr <=nvm_end_addr (ns)); +} + +static struct bch_nvm_namespace *find_nvm_by_addr (void *addr,int order) +{ +int i; +struct bch_nvm_namespace *ns; + +for (i =0 ; i < only_set->total_namespaces_nr; i++) { + ns = only_set->nss[i]; +if (ns &&in_nvm_range (ns, addr, addr + (1 << order))) +return ns; + } +return NULL ; +} + +static int remove_extent (struct bch_nvm_alloced_recs *alloced_recs,void *addr,int order) +{ +struct list_head *list = alloced_recs->extent_head.next; +struct bch_extent *extent, *tmp; +void *end_addr = addr + (((u64 )1 << order) <<PAGE_SHIFT ); + +while (list != &alloced_recs->extent_head) { + extent = container_of(list, struct bch_extent, list); + +if (addr < extent->kaddr) +return -ENOENT ; + +if (addr >extent_end_addr (extent)) { + list = list->next; +continue ; + } + +if (addr == extent->kaddr) { +if (extent->nr == (1 << order)) { +list_del (list); +kfree (extent); + alloced_recs->nr--; + }else { + extent->kaddr = end_addr; + extent->nr -=1 << order; + } + }else { +if (extent_end_addr (extent) > end_addr) { + tmp =kzalloc (sizeof (*tmp),GFP_KERNEL |__GFP_NOFAIL); + + tmp->kaddr = end_addr; + tmp->nr = (extent_end_addr (extent) - end_addr) >>PAGE_SHIFT ; +list_add (&tmp->list, list); + alloced_recs->nr++; + } + extent->nr = (addr - extent->kaddr) >>PAGE_SHIFT ; + } +break ; + } +return (list == &alloced_recs->extent_head) ? -ENOENT :0 ; +} + +static void __free_space (struct bch_nvm_namespace *ns,void *addr,int order) +{ +unsigned int add_pages = (1 << order); +pgoff_t pgoff; +struct page *page; + + page =nvm_vaddr_to_page (ns, addr); +WARN_ON ((!page) || (page->private != order)); + pgoff = page->index; + +while (order <BCH_MAX_ORDER -1 ) { +struct page *buddy_page; + +pgoff_t buddy_pgoff = pgoff ^ (1 << order); +pgoff_t parent_pgoff = pgoff & ~(1 << order); + +if ((parent_pgoff + (1 << (order +1 )) > ns->pages_total)) +break ; + + buddy_page =nvm_vaddr_to_page (ns,nvm_pgoff_to_vaddr (ns, buddy_pgoff)); +WARN_ON (!buddy_page); + +if (PageBuddy (buddy_page) && (buddy_page->private == order)) { +list_del ((struct list_head *)&buddy_page->zone_device_data); +__ClearPageBuddy (buddy_page); + pgoff = parent_pgoff; + order++; +continue ; + } +break ; + } + + page =nvm_vaddr_to_page (ns,nvm_pgoff_to_vaddr (ns, pgoff)); +WARN_ON (!page); +list_add ((struct list_head *)&page->zone_device_data, &ns->free_area[order]); + page->index = pgoff; +set_page_private (page, order); +__SetPageBuddy (page); + ns->free += add_pages; +} + +void bch_nvm_free_pages (void *addr,int order,const char *owner_uuid) +{ +struct bch_nvm_namespace *ns; +struct bch_owner_list *owner_list; +struct bch_nvm_alloced_recs *alloced_recs; +int r; + +mutex_lock (&only_set->lock); + + ns =find_nvm_by_addr (addr, order); +if (!ns) { +pr_info ("can't find nvm_dev by kaddr %p\n" , addr); + goto unlock; + } + + owner_list =find_owner_list (owner_uuid, false); +if (!owner_list) { +pr_info ("can't found owner(uuid=%s)\n" , owner_uuid); + goto unlock; + } + + alloced_recs =find_nvm_alloced_recs (owner_list, ns, false); +if (!alloced_recs) { +pr_info ("can't find alloced_recs(uuid=%s)\n" , ns->uuid); + goto unlock; + } + + r =remove_extent (alloced_recs, addr, order); +if (r <0 ) { +pr_info ("can't find extent\n" ); + goto unlock; + } + +__free_space (ns, addr, order); + +unlock: +mutex_unlock (&only_set->lock); +} +EXPORT_SYMBOL_GPL (bch_nvm_free_pages); +void *bch_nvm_alloc_pages (int order,const char *owner_uuid) {void *kaddr =NULL ;
@@ -306,11 +453,9 @@ static int init_owner_info(struct bch_nvm_namespace *ns)mutex_unlock (&only_set->lock);return -ENOMEM ; } -for (j =0 ; j < only_set->total_namespaces_nr; j++) {if (!only_set->nss[j] || !owner_head->recs[j])continue ; - nvm_pgalloc_recs = (struct bch_nvm_pgalloc_recs *) ((long )owner_head->recs[j] + ns->kaddr);if (memcmp (nvm_pgalloc_recs->magic, bch_nvm_pages_pgalloc_magic,16 )) {
@@ -374,7 +519,7 @@ static void init_nvm_free_space(struct bch_nvm_namespace *ns) {unsigned int start, end, i;struct page *page; -long long pages; +u64 pages;pgoff_t pgoff_start;bitmap_for_each_clear_region (ns->pages_bitmap, start, end,0 , ns->pages_total) {
@@ -390,8 +535,8 @@ static void init_nvm_free_space(struct bch_nvm_namespace *ns) page =nvm_vaddr_to_page (ns,nvm_pgoff_to_vaddr (ns, pgoff_start)); page->index = pgoff_start;set_page_private (page, i); -__SetPageBuddy (page); -list_add ((struct list_head *)&page->zone_device_data, &ns->free_area[i]); +/* in order to update ns->free */ +__free_space (ns,nvm_pgoff_to_vaddr (ns, pgoff_start), i); pgoff_start +=1 << i; pages -=1 << i;
@@ -574,7 +719,7 @@ struct bch_nvm_namespace *bch_register_namespace(const char *dev_path) ns->page_size = ns->sb.page_size; ns->pages_offset = ns->sb.pages_offset; ns->pages_total = ns->sb.pages_total; - ns->free =0 ; + ns->free =0 ;/* increased by __free_space() */ ns->bdev = bdev; ns->nvm_set = only_set;
drivers/md/bcache/nvm-pages.h +3 -1
@@ -80,7 +80,7 @@ struct bch_nvm_namespace *bch_register_namespace(const char *dev_path);int bch_nvm_init (void );void bch_nvm_exit (void );void *bch_nvm_alloc_pages (int order,const char *owner_uuid); - +void bch_nvm_free_pages (void *addr,int order,const char *owner_uuid);#else static inline struct bch_nvm_namespace *bch_register_namespace (const char *dev_path)
@@ -98,6 +98,8 @@ static inline void *bch_nvm_alloc_pages(int order, const char *owner_uuid)return NULL ; } +static inline void bch_nvm_free_pages (void *addr,int order,const char *owner_uuid) { } +#endif /* CONFIG_BCACHE_NVM_PAGES */ #endif /* _BCACHE_NVM_PAGES_H */
Signature · 1 line
2.17.1
RFC PATCH v5 6/8 bcache: get allocated pages from specific owner
In reply to Qiaowei RenThis patch implements bch_get_allocated_pages() of the buddy to be used to get allocated pages from specific owner.
--- drivers/md/bcache/nvm-pages.c | 38 +++++++++++++++++++++++++++++++++++ drivers/md/bcache/nvm-pages.h | 6 ++++++ 2 files changed, 44 insertions(+)
drivers/md/bcache/nvm-pages.c +38 -0
@@ -426,6 +426,44 @@ void *bch_nvm_alloc_pages(int order, const char *owner_uuid) }EXPORT_SYMBOL_GPL (bch_nvm_alloc_pages); +struct bch_extent *bch_get_allocated_pages (const char *owner_uuid) +{ +struct bch_owner_list *owner_list =find_owner_list (owner_uuid, false); +struct bch_nvm_alloced_recs *alloced_recs; +struct bch_extent *head =NULL , *e, *tmp; +int i; + +if (!owner_list) +return NULL ; + +for (i =0 ; i < only_set->total_namespaces_nr; i++) { +struct list_head *l; + + alloced_recs = owner_list->alloced_recs[i]; + +if (!alloced_recs || alloced_recs->nr ==0 ) +continue ; + + l = alloced_recs->extent_head.next; +while (l != &alloced_recs->extent_head) { + e = container_of(l, struct bch_extent, list); + tmp =kzalloc (sizeof (*tmp),GFP_KERNEL |__GFP_NOFAIL); + + tmp->kaddr = e->kaddr; + tmp->nr = e->nr; + +if (head) +list_add_tail (&tmp->list, &head->list); +else + head = tmp; + + l = l->next; + } + } +return head; +} +EXPORT_SYMBOL_GPL (bch_get_allocated_pages); +static int init_owner_info (struct bch_nvm_namespace *ns) {struct bch_owner_list_head *owner_list_head;
drivers/md/bcache/nvm-pages.h +6 -0
@@ -81,6 +81,7 @@ int bch_nvm_init(void);void bch_nvm_exit (void );void *bch_nvm_alloc_pages (int order,const char *owner_uuid);void bch_nvm_free_pages (void *addr,int order,const char *owner_uuid); +struct bch_extent *bch_get_allocated_pages (const char *owner_uuid);#else static inline struct bch_nvm_namespace *bch_register_namespace (const char *dev_path)
@@ -100,6 +101,11 @@ static inline void *bch_nvm_alloc_pages(int order, const char *owner_uuid)static inline void bch_nvm_free_pages (void *addr,int order,const char *owner_uuid) { } +static inline struct bch_extent *bch_get_allocated_pages (const char *owner_uuid) +{ +return NULL ; +} +#endif /* CONFIG_BCACHE_NVM_PAGES */ #endif /* _BCACHE_NVM_PAGES_H */
Signature · 1 line
2.17.1
RFC PATCH v5 7/8 bcache: persist owner info when alloc/free pages.
In reply to Qiaowei RenThis patch implement persist owner info on nvdimm device when alloc/free pages.
--- drivers/md/bcache/nvm-pages.c | 93 ++++++++++++++++++++++++++++++++++- 1 file changed, 92 insertions(+), 1 deletion(-)
drivers/md/bcache/nvm-pages.c +92 -1
@@ -245,6 +245,18 @@ static struct bch_nvm_namespace *find_nvm_by_addr(void *addr, int order)return NULL ; } +static void init_pgalloc_recs (struct bch_nvm_pgalloc_recs *recs,const char *owner_uuid) +{ +memset (recs,0 ,sizeof (struct bch_nvm_pgalloc_recs )); +memcpy (recs->magic, bch_nvm_pages_pgalloc_magic,16 ); +memcpy (recs->owner_uuid, owner_uuid,16 ); +} + +static pgoff_t vaddr_to_nvm_pgoff (struct bch_nvm_namespace *ns,void *kaddr) +{ +return (kaddr - ns->kaddr) /PAGE_SIZE ; +} +static int remove_extent (struct bch_nvm_alloced_recs *alloced_recs,void *addr,int order) {struct list_head *list = alloced_recs->extent_head.next;
@@ -287,6 +299,83 @@ static int remove_extent(struct bch_nvm_alloced_recs *alloced_recs, void *addr,return (list == &alloced_recs->extent_head) ? -ENOENT :0 ; } +#define BCH_RECS_LEN (sizeof(struct bch_nvm_pgalloc_recs)) + +static void write_owner_info (void ) +{ +struct bch_owner_list *owner_list; +struct bch_nvm_pgalloc_recs *recs; +struct bch_extent *extent; +struct bch_nvm_namespace *ns = only_set->nss[0 ]; +struct bch_owner_list_head *owner_list_head; +struct bch_nvm_pages_owner_head *owner_head; +bool update_owner = false; +u64 recs_pos =BCH_NVM_PAGES_SYS_RECS_HEAD_OFFSET ; +struct list_head *list; +int i, j; + + owner_list_head =kzalloc (sizeof (*owner_list_head),GFP_KERNEL ); + recs =kmalloc (sizeof (*recs),GFP_KERNEL ); +if (!owner_list_head || !recs) { +pr_info ("can't alloc memory\n" ); + goto free_resouce; + } + +// in-memory owner maybe not contain alloced-pages. +for (i =0 ; i < only_set->owner_list_used; i++) { + owner_head = &owner_list_head->heads[owner_list_head->size]; + owner_list = only_set->owner_lists[i]; + +for (j =0 ; j < only_set->total_namespaces_nr; j++) { +struct bch_nvm_alloced_recs *extents = owner_list->alloced_recs[j]; + +if (!extents || !extents->nr) +continue ; + +init_pgalloc_recs (recs, owner_list->owner_uuid); + +BUG_ON (recs_pos >=BCH_NVM_PAGES_OFFSET ); + owner_head->recs[j] = (struct bch_nvm_pgalloc_recs *)(uintptr_t )recs_pos; + +for (list = extents->extent_head.next; + list != &extents->extent_head; + list = list->next) { + extent = container_of(list, struct bch_extent, list); + +if (recs->size ==BCH_MAX_RECS ) { +BUG_ON (recs_pos >=BCH_NVM_PAGES_OFFSET ); + recs->next = (struct bch_nvm_pgalloc_recs *) + (uintptr_t )(recs_pos +BCH_RECS_LEN ); +memcpy_flushcache (ns->kaddr + recs_pos, recs,BCH_RECS_LEN ); +init_pgalloc_recs (recs, owner_list->owner_uuid); + recs_pos +=BCH_RECS_LEN ; + } + + recs->recs[recs->size].pgoff = +vaddr_to_nvm_pgoff (only_set->nss[j], extent->kaddr); + recs->recs[recs->size].nr = extent->nr; + recs->size++; + } + + update_owner = true; +memcpy_flushcache (ns->kaddr + recs_pos, recs,BCH_RECS_LEN ); + recs_pos +=sizeof (struct bch_nvm_pgalloc_recs ); + } + +if (update_owner) { +memcpy (owner_head->uuid, owner_list->owner_uuid,16 ); + owner_list_head->size++; + update_owner = false; + } + } + +memcpy_flushcache (ns->kaddr +BCH_NVM_PAGES_OWNER_LIST_HEAD_OFFSET , + (void *)owner_list_head,sizeof (struct bch_owner_list_head )); +free_resouce: +kfree (owner_list_head); +kfree (recs); +} +static void __free_space (struct bch_nvm_namespace *ns,void *addr,int order) {unsigned int add_pages = (1 << order);
@@ -362,6 +451,7 @@ void bch_nvm_free_pages(void *addr, int order, const char *owner_uuid) }__free_space (ns, addr, order); +write_owner_info (); unlock:mutex_unlock (&only_set->lock);
@@ -420,7 +510,8 @@ void *bch_nvm_alloc_pages(int order, const char *owner_uuid)break ; } } - +if (kaddr) +write_owner_info ();mutex_unlock (&only_set->lock);return kaddr; }
Signature · 1 line
2.17.1
RFC PATCH v5 8/8 bcache: testing module for nvm pages allocator
In reply to Qiaowei RenThis patch creates the testing module for nvm pages allocator. Before this module is loaded, the super block needs to be writen into nvdimm device (like /dev/pmemX).
--- drivers/md/bcache/Kconfig | 6 ++ drivers/md/bcache/Makefile | 2 + drivers/md/bcache/test-nvm.c | 202 +++++++++++++++++++++++++++++++++++ 3 files changed, 210 insertions(+) create mode 100644 drivers/md/bcache/test-nvm.c
drivers/md/bcache/Kconfig +6 -0
@@ -41,3 +41,9 @@ config BCACHE_NVM_PAGES depends on BCACHE help nvm pages allocator for bcache. + +config BCACHE_NVM_PAGES_TEST + tristate "Testing for NVM pages" + depends on BCACHE_NVM_PAGES + help + Testing module for NVM pages allocator.
drivers/md/bcache/Makefile +2 -0
@@ -5,3 +5,5 @@ obj-$(CONFIG_BCACHE) += bcache.o bcache-y := alloc.o bset.o btree.o closure.o debug.o extents.o\ io.o journal.o movinggc.o request.o stats.o super.o sysfs.o trace.o\ util.o writeback.o features.o nvm-pages.o + +obj-$(CONFIG_BCACHE_NVM_PAGES_TEST) += test-nvm.o
drivers/md/bcache/test-nvm.c new file +202 -0
202 lines not on this page · raw message
Signature · 1 line
2.17.1