tdm
/
cbd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename [pl]blk_alloc to [pl]bat

This commit is contained in:
Tom Marshall 2019-10-11 08:28:37 -07:00
parent b80d80215b
commit 8ff29f0262
3 changed files with 148 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
dm-compress/dm-compress.c
View File

@ -58,17 +58,17 @@ struct zone_cache {
u8* lz4_wrkmem;
u8* lz4_cbuf;
/* Currently cached zone pblk alloc info (if any) */
u32 pblk_alloc_idx;
bool pblk_alloc_dirty;
void* pblk_alloc;
/* Currently cached zone pbat (if any) */
bool pbat_data_cached;
bool pbat_data_dirty;
void* pbat_buf;
/* Currently cached zone lblk alloc info (if any) */
u64 lblk_alloc_pblk;
u32 lblk_alloc_len;
void* lblk_alloc;
u64 lblk_alloc_elem_lblk;
struct lblk_alloc_elem* lblk_alloc_elem;
u64 lbat_data_pblk;
u32 lbat_data_len;
void* lbat_buf;
u64 lbat_elem_lblk;
struct lbat_elem* lbat_elem;
/* Currently cached lblk data (if any) */
u64 lblk_num;
@ -265,35 +265,35 @@ blkdev_pblk_write(struct dm_compress* dc, u64 pblk, u32 count, void *data)
**************************************/
static int
pblk_alloc_write(struct dm_compress* dc, struct zone_cache* zc)
pbat_write(struct dm_compress* dc, struct zone_cache* zc)
{
u64 pblk;
u32 count;
void* pg;
BUG_ON(zc->pblk_alloc_idx == ZONE_NONE);
pblk = pblk_alloc_off(&dc->params, zc->pblk_alloc_idx);
count = pblk_alloc_len(&dc->params);
BUG_ON(!zc->pbat_data_cached);
pblk = pbat_off(&dc->params, zc->zone);
count = pbat_len(&dc->params);
pg = compress_alloc_pages(PBLK_SIZE);
if (!pg) {
return -ENOMEM;
}
memcpy(pg, zc->pblk_alloc, count * PBLK_SIZE);
memcpy(pg, zc->pbat_buf, count * PBLK_SIZE);
blkdev_pblk_write(dc, pblk, count, pg);
zc->pblk_alloc_dirty = false;
zc->pbat_data_dirty = false;
return 0;
}
static int
pblk_alloc_flush(struct dm_compress* dc, struct zone_cache* zc)
pbat_flush(struct dm_compress* dc, struct zone_cache* zc)
{
int ret = 0;
if (zc->pblk_alloc_dirty) {
ret = pblk_alloc_write(dc, zc);
if (zc->pbat_data_dirty) {
ret = pbat_write(dc, zc);
}
return ret;
@ -301,64 +301,60 @@ pblk_alloc_flush(struct dm_compress* dc, struct zone_cache* zc)
/* Read zone physical block alloc bitmap */
static int
pblk_alloc_read(struct dm_compress* dc, struct zone_cache* zc)
pbat_read(struct dm_compress* dc, struct zone_cache* zc)
{
int ret;
u64 pblk;
u32 count;
if (zc->pblk_alloc_idx == zc->zone) {
if (zc->pbat_data_cached) {
return 0;
}
ret = pblk_alloc_flush(dc, zc);
ret = pbat_flush(dc, zc);
if (ret) {
return ret;
}
pblk = pblk_alloc_off(&dc->params, zc->zone);
count = pblk_alloc_len(&dc->params);
pblk = pbat_off(&dc->params, zc->zone);
count = pbat_len(&dc->params);
ret = blkdev_pblk_read(dc, pblk, count, zc->pblk_alloc);
ret = blkdev_pblk_read(dc, pblk, count, zc->pbat_buf);
if (ret) {
return ret;
}
zc->pblk_alloc_idx = zc->zone;
zc->pbat_data_cached = true;
return 0;
}
static u64
__pblk_alloc_get(struct dm_compress* dc, struct zone_cache* zc)
__pbat_alloc(struct dm_compress* dc, struct zone_cache* zc)
{
u32 pblk_count = pblk_alloc_len(&dc->params) * PBLK_SIZE_BITS;
u32 pblk_count = pbat_len(&dc->params) * PBLK_SIZE_BITS;
u32 idx;
if (pblk_alloc_read(dc, zc) != 0) {
printk(KERN_ERR "%s: pblk_alloc_read failed\n", __func__);
if (pbat_read(dc, zc) != 0) {
printk(KERN_ERR "%s: pbat_read failed\n", __func__);
return PBLK_NONE;
}
idx = cbd_bitmap_alloc(zc->pblk_alloc, pblk_count);
idx = cbd_bitmap_alloc(zc->pbat_buf, pblk_count);
if (idx == pblk_count) {
return PBLK_NONE;
}
zc->pblk_alloc_dirty = true;
zc->pbat_data_dirty = true;
return idx;
}
/*
* Get (allocate) one pblk from the currently cached zone pblk alloc bitmap.
* XXX: get rid of this function and use pblk_alloc directly in lblk_write().
*/
static u64
pblk_alloc_get(struct dm_compress* dc, struct zone_cache* zc_hint)
pbat_alloc(struct dm_compress* dc, struct zone_cache* zc_hint)
{
u64 pblk;
u32 zone_off;
struct zone_cache* zc;
pblk = __pblk_alloc_get(dc, zc_hint);
pblk = __pbat_alloc(dc, zc_hint);
if (pblk != PBLK_NONE) {
return zone_data_off(&dc->params, zc_hint->zone) + pblk;
}
@ -368,7 +364,7 @@ pblk_alloc_get(struct dm_compress* dc, struct zone_cache* zc_hint)
if (zone_off <= zc_hint->zone) {
zc = zone_cache_get(dc, zc_hint->zone - zone_off);
if (zc) {
pblk = __pblk_alloc_get(dc, zc);
pblk = __pbat_alloc(dc, zc);
if (zone_cache_put(dc, zc) != 0) {
return PBLK_NONE;
}
@ -380,7 +376,7 @@ pblk_alloc_get(struct dm_compress* dc, struct zone_cache* zc_hint)
if (zc_hint->zone + zone_off < dc->params.nr_zones) {
zc = zone_cache_get(dc, zc_hint->zone + zone_off);
if (zc) {
pblk = __pblk_alloc_get(dc, zc);
pblk = __pbat_alloc(dc, zc);
if (zone_cache_put(dc, zc) != 0) {
return PBLK_NONE;
}
@ -396,13 +392,13 @@ pblk_alloc_get(struct dm_compress* dc, struct zone_cache* zc_hint)
}
/*
* Put (free) one pblk into the currently cached zone pblk alloc bitmap.
* XXX: get rid of this function and use pblk_free directly in lblk_write().
* XXX: When fine grained locking is in place, we won't need the zc param
* or the put_zone flag.
*/
static int
pblk_alloc_put(struct dm_compress* dc, struct zone_cache* zc, u64 pblk)
pbat_free(struct dm_compress* dc, struct zone_cache* zc, u64 pblk)
{
u32 zone_pblk_count = pblk_alloc_len(&dc->params) * PBLK_SIZE_BITS;
u32 zone_pblk_count = pbat_len(&dc->params) * PBLK_SIZE_BITS;
bool put_zone = false;
u32 zone;
u32 idx;
@ -432,12 +428,12 @@ pblk_alloc_put(struct dm_compress* dc, struct zone_cache* zc, u64 pblk)
put_zone = true;
}
ret = pblk_alloc_read(dc, zc);
ret = pbat_read(dc, zc);
if (ret) {
goto out_put;
}
cbd_bitmap_free(zc->pblk_alloc, idx);
zc->pblk_alloc_dirty = true;
cbd_bitmap_free(zc->pbat_buf, idx);
zc->pbat_data_dirty = true;
out_put:
if (put_zone) {
@ -452,7 +448,7 @@ out_put:
**************************************/
static int
lblk_alloc_elem_write(struct dm_compress* dc, struct zone_cache* zc)
lbat_elem_write(struct dm_compress* dc, struct zone_cache* zc)
{
u32 zone;
u32 zone_lblk;
@ -464,32 +460,32 @@ lblk_alloc_elem_write(struct dm_compress* dc, struct zone_cache* zc)
u8* buf;
void* pg;
BUG_ON(zc->lblk_alloc_elem_lblk == LBLK_NONE);
BUG_ON(zc->lblk_alloc_pblk == PBLK_NONE);
BUG_ON(zc->lblk_alloc_len == 0);
BUG_ON(zc->lbat_elem_lblk == LBLK_NONE);
BUG_ON(zc->lbat_data_pblk == PBLK_NONE);
BUG_ON(zc->lbat_data_len == 0);
zone = zc->lblk_alloc_elem_lblk / dc->params.lblk_per_zone;
zone_lblk = zc->lblk_alloc_elem_lblk - (zc->zone * dc->params.lblk_per_zone);
elem_off = lblk_alloc_elem_len(&dc->params) * zone_lblk;
elem_end = elem_off + lblk_alloc_elem_len(&dc->params);
zone = zc->lbat_elem_lblk / dc->params.lblk_per_zone;
zone_lblk = zc->lbat_elem_lblk - (zc->zone * dc->params.lblk_per_zone);
elem_off = lbat_elem_len(&dc->params) * zone_lblk;
elem_end = elem_off + lbat_elem_len(&dc->params);
rel_pblk = elem_off / PBLK_SIZE;
count = zc->lblk_alloc_len;
pblk = zc->lblk_alloc_pblk;
buf = zc->lblk_alloc + (elem_off - rel_pblk * PBLK_SIZE);
lblk_alloc_elem_put(&dc->params, buf, zc->lblk_alloc_elem);
count = zc->lbat_data_len;
pblk = zc->lbat_data_pblk;
buf = zc->lbat_buf + (elem_off - rel_pblk * PBLK_SIZE);
lbat_elem_put(&dc->params, buf, zc->lbat_elem);
pg = compress_alloc_pages(count * PBLK_SIZE);
if (!pg) {
return -ENOMEM;
}
memcpy(pg, zc->lblk_alloc, count * PBLK_SIZE);
memcpy(pg, zc->lbat_buf, count * PBLK_SIZE);
blkdev_pblk_write(dc, pblk, count, pg);
return 0;
}
static int
lblk_alloc_elem_read(struct dm_compress* dc, struct zone_cache* zc, u64 lblk)
lbat_elem_read(struct dm_compress* dc, struct zone_cache* zc, u64 lblk)
{
int ret;
u32 zone;
@ -501,28 +497,28 @@ lblk_alloc_elem_read(struct dm_compress* dc, struct zone_cache* zc, u64 lblk)
u64 pblk;
u8* buf;
if (zc->lblk_alloc_elem_lblk == lblk) {
if (zc->lbat_elem_lblk == lblk) {
return 0;
}
zone = lblk / dc->params.lblk_per_zone;
zone_lblk = lblk - (zone * dc->params.lblk_per_zone);
elem_off = lblk_alloc_elem_len(&dc->params) * zone_lblk;
elem_end = elem_off + lblk_alloc_elem_len(&dc->params);
elem_off = lbat_elem_len(&dc->params) * zone_lblk;
elem_end = elem_off + lbat_elem_len(&dc->params);
rel_pblk = elem_off / PBLK_SIZE;
count = 1 + (elem_end - 1) / PBLK_SIZE - (elem_off / PBLK_SIZE);
pblk = lblk_alloc_off(&dc->params, zone) + rel_pblk;
if (zc->lblk_alloc_pblk != pblk || zc->lblk_alloc_len < count) {
ret = blkdev_pblk_read(dc, pblk, count, zc->lblk_alloc);
pblk = lbat_off(&dc->params, zone) + rel_pblk;
if (zc->lbat_data_pblk != pblk || zc->lbat_data_len < count) {
ret = blkdev_pblk_read(dc, pblk, count, zc->lbat_buf);
if (ret != 0) {
return ret;
}
zc->lblk_alloc_pblk = pblk;
zc->lblk_alloc_len = count;
zc->lbat_data_pblk = pblk;
zc->lbat_data_len = count;
}
buf = zc->lblk_alloc + (elem_off - rel_pblk * PBLK_SIZE);
lblk_alloc_elem_get(&dc->params, buf, zc->lblk_alloc_elem);
zc->lblk_alloc_elem_lblk = lblk;
buf = zc->lbat_buf + (elem_off - rel_pblk * PBLK_SIZE);
lbat_elem_get(&dc->params, buf, zc->lbat_elem);
zc->lbat_elem_lblk = lblk;
return 0;
}
@ -600,7 +596,6 @@ lblk_write(struct dm_compress* dc, struct zone_cache* zc)
int ret;
u32 zone;
u32 zone_lblk;
u8* elem_buf;
size_t d_len;
size_t c_len;
u8* c_buf;
@ -609,16 +604,15 @@ lblk_write(struct dm_compress* dc, struct zone_cache* zc)
zone = zc->zone;
zone_lblk = zc->lblk_num - (zone * dc->params.lblk_per_zone);
elem_buf = zc->lblk_alloc + zone_lblk * lblk_alloc_elem_len(&dc->params);
/* We must have a cached lblk elem */
BUG_ON(zc->lblk_alloc_elem_lblk == LBLK_NONE);
BUG_ON(zc->lbat_elem_lblk == LBLK_NONE);
d_len = PBLK_SIZE * lblk_per_pblk(&dc->params);
if (lblk_is_zeros(&dc->params, zc)) {
c_len = 0;
c_buf = NULL;
zc->lblk_alloc_elem->len = 0;
zc->lbat_elem->len = 0;
}
else {
c_len = lblk_compress(&dc->params, zc);
@ -628,26 +622,26 @@ lblk_write(struct dm_compress* dc, struct zone_cache* zc)
memset(zc->lz4_cbuf + c_len, 0, c_blkrem);
}
c_buf = zc->lz4_cbuf;
zc->lblk_alloc_elem->len = c_len;
zc->lbat_elem->len = c_len;
}
else {
c_len = d_len;
c_buf = zc->lblk;
zc->lblk_alloc_elem->len = CBD_UNCOMPRESSED;
zc->lbat_elem->len = CBD_UNCOMPRESSED;
}
}
for (n = 0; n < lblk_per_pblk(&dc->params); ++n) {
if (c_len > PBLK_SIZE * n) {
void* pg;
pblk = zc->lblk_alloc_elem->pblk[n];
pblk = zc->lbat_elem->pblk[n];
if (!pblk) {
pblk = pblk_alloc_get(dc, zc);
pblk = pbat_alloc(dc, zc);
if (pblk == 0) {
printk(KERN_ERR " pblk_alloc_get failed\n");
printk(KERN_ERR " pbat_alloc failed\n");
return -ENOSPC;
}
zc->lblk_alloc_elem->pblk[n] = pblk;
zc->lbat_elem->pblk[n] = pblk;
}
pg = compress_alloc_pages(PBLK_SIZE);
if (!pg) {
@ -658,26 +652,26 @@ lblk_write(struct dm_compress* dc, struct zone_cache* zc)
c_buf += PBLK_SIZE;
}
else {
pblk = zc->lblk_alloc_elem->pblk[n];
pblk = zc->lbat_elem->pblk[n];
if (pblk) {
zc->lblk_alloc_elem->pblk[n] = 0;
ret = pblk_alloc_put(dc, zc, pblk);
zc->lbat_elem->pblk[n] = 0;
ret = pbat_free(dc, zc, pblk);
if (ret != 0) {
printk(KERN_ERR " pblk_alloc_put failed\n");
printk(KERN_ERR " pbat_free failed\n");
return ret;
}
}
}
}
ret = lblk_alloc_elem_write(dc, zc);
ret = lbat_elem_write(dc, zc);
if (ret != 0) {
printk(KERN_ERR " lblk_alloc_elem_write failed\n");
printk(KERN_ERR " lbat_elem_write failed\n");
return ret;
}
ret = pblk_alloc_flush(dc, zc);
ret = pbat_flush(dc, zc);
if (ret != 0) {
printk(KERN_ERR " pblk_alloc_flush failed\n");
printk(KERN_ERR " pbat_flush failed\n");
return ret;
}
@ -707,7 +701,6 @@ lblk_read(struct dm_compress* dc, struct zone_cache* zc, u64 idx)
int ret;
u32 zone;
u32 zone_lblk;
u8* elem_buf;
u32 c_len;
u64 pblk;
@ -721,15 +714,14 @@ lblk_read(struct dm_compress* dc, struct zone_cache* zc, u64 idx)
zone = idx / dc->params.lblk_per_zone;
zone_lblk = idx - (zone * dc->params.lblk_per_zone);
elem_buf = zc->lblk_alloc + zone_lblk * lblk_alloc_elem_len(&dc->params);
ret = lblk_alloc_elem_read(dc, zc, idx);
ret = lbat_elem_read(dc, zc, idx);
if (ret != 0) {
printk(KERN_ERR " lblk_alloc_elem_read failed\n");
printk(KERN_ERR " lbat_elem_read failed\n");
return ret;
}
c_len = zc->lblk_alloc_elem->len;
c_len = zc->lbat_elem->len;
if (c_len == 0) {
memset(zc->lblk, 0, PBLK_SIZE * lblk_per_pblk(&dc->params));
}
@ -745,7 +737,7 @@ lblk_read(struct dm_compress* dc, struct zone_cache* zc, u64 idx)
}
p = zc->lz4_cbuf;
for (n = 0; n * PBLK_SIZE < c_len; ++n, p += PBLK_SIZE) {
pblk = zc->lblk_alloc_elem->pblk[n];
pblk = zc->lbat_elem->pblk[n];
BUG_ON(pblk == 0);
ret = blkdev_pblk_read(dc, pblk, 1, p);
if (ret != 0) {
@ -776,11 +768,11 @@ static void
zone_cache_reset(struct zone_cache* zc, u32 zone)
{
zc->zone = zone;
zc->pblk_alloc_idx = ZONE_NONE;
zc->pblk_alloc_dirty = false;
zc->lblk_alloc_pblk = PBLK_NONE;
zc->lblk_alloc_len = 0;
zc->lblk_alloc_elem_lblk = LBLK_NONE;
zc->pbat_data_cached = false;
zc->pbat_data_dirty = false;
zc->lbat_data_pblk = PBLK_NONE;
zc->lbat_data_len = 0;
zc->lbat_elem_lblk = LBLK_NONE;
zc->lblk_num = LBLK_NONE;
zc->lblk_dirty = false;
}
@ -794,7 +786,7 @@ zone_cache_flush(struct dm_compress* dc, struct zone_cache* zc)
if (ret) {
return ret;
}
ret = pblk_alloc_flush(dc, zc);
ret = pbat_flush(dc, zc);
if (ret) {
return ret;
}
@ -860,14 +852,14 @@ zone_cache_dtr(struct dm_compress* dc, struct zone_cache* zc)
compress_free_pages(zc->lblk, PBLK_SIZE * lblk_per_pblk(&dc->params));
zc->lblk = NULL;
kfree(zc->lblk_alloc_elem);
zc->lblk_alloc_elem = NULL;
kfree(zc->lbat_elem);
zc->lbat_elem = NULL;
compress_free_pages(zc->lblk_alloc, PBLK_SIZE * 2);
zc->lblk_alloc = NULL;
compress_free_pages(zc->lbat_buf, PBLK_SIZE * 2);
zc->lbat_buf = NULL;
compress_free_pages(zc->pblk_alloc, PBLK_SIZE * pblk_alloc_len(&dc->params));
zc->pblk_alloc = NULL;
compress_free_pages(zc->pbat_buf, PBLK_SIZE * pbat_len(&dc->params));
zc->pbat_buf = NULL;
compress_free_pages(zc->lz4_cbuf, PBLK_SIZE * lblk_per_pblk(&dc->params));
zc->lz4_cbuf = NULL;
@ -892,24 +884,24 @@ zone_cache_ctr(struct dm_compress* dc, struct zone_cache* zc)
printk(KERN_ERR "%s: Failed to alloc lz4_cmem\n", __func__);
goto out_nomem;
}
zc->pblk_alloc_idx = ZONE_NONE;
zc->pblk_alloc_dirty = false;
zc->pblk_alloc = compress_alloc_pages(PBLK_SIZE * pblk_alloc_len(&dc->params));
if (!zc->pblk_alloc) {
printk(KERN_ERR "%s: Failed to alloc pblk_alloc\n", __func__);
zc->pbat_data_cached = false;
zc->pbat_data_dirty = false;
zc->pbat_buf = compress_alloc_pages(PBLK_SIZE * pbat_len(&dc->params));
if (!zc->pbat_buf) {
printk(KERN_ERR "%s: Failed to alloc pbat_buf\n", __func__);
goto out_nomem;
}
zc->lblk_alloc_pblk = PBLK_NONE;
zc->lblk_alloc_len = 0;
zc->lblk_alloc = compress_alloc_pages(PBLK_SIZE * 2);
if (!zc->lblk_alloc) {
printk(KERN_ERR "%s: Failed to alloc lblk_alloc\n", __func__);
zc->lbat_data_pblk = PBLK_NONE;
zc->lbat_data_len = 0;
zc->lbat_buf = compress_alloc_pages(PBLK_SIZE * 2);
if (!zc->lbat_buf) {
printk(KERN_ERR "%s: Failed to alloc lbat_buf\n", __func__);
goto out_nomem;
}
zc->lblk_alloc_elem_lblk = LBLK_NONE;
zc->lblk_alloc_elem = kmalloc(offsetof(struct lblk_alloc_elem, pblk[lblk_per_pblk(&dc->params)]), GFP_KERNEL);
if (!zc->lblk_alloc_elem) {
printk(KERN_ERR "%s: Failed to alloc lblk_alloc_elem\n", __func__);
zc->lbat_elem_lblk = LBLK_NONE;
zc->lbat_elem = kmalloc(offsetof(struct lbat_elem, pblk[lblk_per_pblk(&dc->params)]), GFP_KERNEL);
if (!zc->lbat_elem) {
printk(KERN_ERR "%s: Failed to alloc lbat_elem\n", __func__);
goto out_nomem;
}
zc->lblk_num = LBLK_NONE;

36
include/linux/dm-compress.h
View File

@ -48,7 +48,7 @@ struct cbd_header {
struct cbd_params params;
};
struct lblk_alloc_elem
struct lbat_elem
{
u32 len; /* Compressed length */
u64 pblk[1]; /* Vector of physical blocks */
@ -160,13 +160,13 @@ lblk_per_pblk(const struct cbd_params* params)
}
static inline u32
pblk_alloc_len(const struct cbd_params* params)
pbat_len(const struct cbd_params* params)
{
return 1;
}
static inline u32
lblk_alloc_elem_len(const struct cbd_params* params)
lbat_elem_len(const struct cbd_params* params)
{
u32 elem_len_bytes = (params->lblk_shift + PBLK_SHIFT > 16) ? 4 : 2;
u32 elem_pblk_bytes = (params->nr_pblk <= 0xffff ? 2 :
@ -175,22 +175,22 @@ lblk_alloc_elem_len(const struct cbd_params* params)
}
static inline u32
lblk_alloc_len(const struct cbd_params* params)
lbat_len(const struct cbd_params* params)
{
return DIV_ROUND_UP(params->lblk_per_zone * lblk_alloc_elem_len(params), PBLK_SIZE);
return DIV_ROUND_UP(params->lblk_per_zone * lbat_elem_len(params), PBLK_SIZE);
}
static inline u32
zone_metadata_len(const struct cbd_params* params)
{
return pblk_alloc_len(params) +
lblk_alloc_len(params);
return pbat_len(params) +
lbat_len(params);
}
static inline u32
zone_data_len(const struct cbd_params* params)
{
return pblk_alloc_len(params) * PBLK_SIZE * BITS_PER_BYTE;
return pbat_len(params) * PBLK_SIZE * BITS_PER_BYTE;
}
static inline u32
@ -207,24 +207,24 @@ zone_off(const struct cbd_params* params, u32 idx)
}
static inline u64
pblk_alloc_off(const struct cbd_params* params, u32 idx)
pbat_off(const struct cbd_params* params, u32 idx)
{
return zone_off(params, idx) + 0;
}
static inline u64
lblk_alloc_off(const struct cbd_params* params, u32 idx)
lbat_off(const struct cbd_params* params, u32 idx)
{
return zone_off(params, idx) +
pblk_alloc_len(params);
pbat_len(params);
}
static inline u64
zone_data_off(const struct cbd_params* params, u32 idx)
{
return zone_off(params, idx) +
pblk_alloc_len(params) +
lblk_alloc_len(params);
pbat_len(params) +
lbat_len(params);
}
static inline void
@ -257,7 +257,7 @@ cbd_header_put(u8* buf, const struct cbd_header* header)
/*
* XXX:
* nr_bits = pblk_alloc_len(params) * PBLK_SIZE;
* nr_bits = pbat_len(params) * PBLK_SIZE;
* bit = find_next_zero_bit_le(buf, nr_bits);
* if (bit < nr_bits) {
* set_bit_le(bit, buf);
@ -297,8 +297,8 @@ cbd_bitmap_free(u8* buf, u32 idx)
}
static inline void
lblk_alloc_elem_get(const struct cbd_params* params,
const u8* buf, struct lblk_alloc_elem* elem)
lbat_elem_get(const struct cbd_params* params,
const u8* buf, struct lbat_elem* elem)
{
u32 n;
@ -326,8 +326,8 @@ lblk_alloc_elem_get(const struct cbd_params* params,
}
static inline void
lblk_alloc_elem_put(const struct cbd_params* params,
u8* buf, const struct lblk_alloc_elem* elem)
lbat_elem_put(const struct cbd_params* params,
u8* buf, const struct lbat_elem* elem)
{
u32 n;

34
libcbd/check.c
View File

@ -4,8 +4,8 @@
struct zone_metadata
{
u8* pblk_alloc;
u8* lblk_alloc;
u8* pbat;
u8* lbat;
};
static void
@ -63,15 +63,15 @@ check_one_lblk(const struct cbd_params* params,
const struct zone_metadata* zm,
u8** pblk_used)
{
struct lblk_alloc_elem* elem;
struct lbat_elem* elem;
u8* elem_buf;
u32 n;
u64 pblk;
u32 rel_pblk;
elem = calloc(1, offsetof(struct lblk_alloc_elem, pblk[lblk_per_pblk(params)]));
elem_buf = zm->lblk_alloc + lblk * lblk_alloc_elem_len(params);
lblk_alloc_elem_get(params, elem_buf, elem);
elem = calloc(1, offsetof(struct lbat_elem, pblk[lblk_per_pblk(params)]));
elem_buf = zm->lbat + lblk * lbat_elem_len(params);
lbat_elem_get(params, elem_buf, elem);
printf(" lblk[%u]: len=%u\n", lblk, elem->len);
for (n = 0; n < lblk_per_pblk(params); ++n) {
pblk = elem->pblk[n];
@ -130,7 +130,7 @@ check_zone_metadata(const struct cbd_params* params,
pblk_used = calloc(params->nr_zones, sizeof(void*));
for (zone = 0; zone < params->nr_zones; ++zone) {
pblk_used[zone] = calloc(1, pblk_alloc_len(params));
pblk_used[zone] = calloc(1, pbat_len(params));
}
for (zone = 0; zone < params->nr_zones; ++zone) {
@ -164,23 +164,23 @@ cbd_check(const char* dev,
zmvec = calloc(header.params.nr_zones, sizeof(struct zone_metadata));
for (zone = 0; zone < header.params.nr_zones; ++zone) {
zmvec[zone].pblk_alloc = calloc(1, PBLK_SIZE);
zmvec[zone].pbat = calloc(1, PBLK_SIZE);
pblk_read(devfd,
pblk_alloc_off(&header.params, zone),
pblk_alloc_len(&header.params),
zmvec[zone].pblk_alloc);
zmvec[zone].lblk_alloc = calloc(lblk_alloc_len(&header.params), PBLK_SIZE);
pbat_off(&header.params, zone),
pbat_len(&header.params),
zmvec[zone].pbat);
zmvec[zone].lbat = calloc(lbat_len(&header.params), PBLK_SIZE);
pblk_read(devfd,
lblk_alloc_off(&header.params, zone),
lblk_alloc_len(&header.params),
zmvec[zone].lblk_alloc);
lbat_off(&header.params, zone),
lbat_len(&header.params),
zmvec[zone].lbat);
}
check_zone_metadata(&header.params, zmvec);
for (zone = 0; zone < header.params.nr_zones; ++zone) {
free(zmvec[zone].lblk_alloc);
free(zmvec[zone].pblk_alloc);
free(zmvec[zone].lbat);
free(zmvec[zone].pbat);
}
free(zmvec);