Rename zone_{pblk,lblk}* to {pblk,lblk}*
This commit is contained in:
parent
4499785fbb
commit
a5cc0f2e81
|
|
@ -64,13 +64,13 @@ struct dm_compress
|
|||
u8* lz4_cbuf;
|
||||
|
||||
/* Currently cached zone pblk alloc info (if any) */
|
||||
u32 zone_pblk_alloc_idx;
|
||||
bool zone_pblk_alloc_dirty;
|
||||
void* zone_pblk_alloc;
|
||||
u32 pblk_alloc_idx;
|
||||
bool pblk_alloc_dirty;
|
||||
void* pblk_alloc;
|
||||
|
||||
/* Currently cached zone lblk alloc info (if any) */
|
||||
u32 zone_lblk_alloc_idx;
|
||||
void* zone_lblk_alloc;
|
||||
u32 lblk_alloc_idx;
|
||||
void* lblk_alloc;
|
||||
|
||||
/* Currently cached lblk data (if any) */
|
||||
u64 lblk_num;
|
||||
|
|
@ -196,33 +196,33 @@ blkdev_pblk_write(struct block_device* dev, u64 pblk, u32 count, void *data)
|
|||
**************************************/
|
||||
|
||||
static int
|
||||
zone_pblk_alloc_write(struct dm_compress* dc)
|
||||
pblk_alloc_write(struct dm_compress* dc)
|
||||
{
|
||||
int ret;
|
||||
u64 pblk;
|
||||
u32 count;
|
||||
|
||||
BUG_ON(dc->zone_pblk_alloc_idx == ZONE_NONE);
|
||||
pblk = pblk_alloc_off(&dc->params, dc->zone_pblk_alloc_idx);
|
||||
BUG_ON(dc->pblk_alloc_idx == ZONE_NONE);
|
||||
pblk = pblk_alloc_off(&dc->params, dc->pblk_alloc_idx);
|
||||
count = pblk_alloc_len(&dc->params);
|
||||
|
||||
ret = blkdev_pblk_write(dc->dev->bdev, pblk, count, dc->zone_pblk_alloc);
|
||||
ret = blkdev_pblk_write(dc->dev->bdev, pblk, count, dc->pblk_alloc);
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
dc->zone_pblk_alloc_dirty = false;
|
||||
dc->pblk_alloc_dirty = false;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
zone_pblk_alloc_flush(struct dm_compress* dc)
|
||||
pblk_alloc_flush(struct dm_compress* dc)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (dc->zone_pblk_alloc_dirty) {
|
||||
ret = zone_pblk_alloc_write(dc);
|
||||
if (dc->pblk_alloc_dirty) {
|
||||
ret = pblk_alloc_write(dc);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -233,16 +233,16 @@ zone_pblk_alloc_flush(struct dm_compress* dc)
|
|||
|
||||
/* Read zone physical block alloc bitmap */
|
||||
static int
|
||||
zone_pblk_alloc_read(struct dm_compress* dc, u32 idx)
|
||||
pblk_alloc_read(struct dm_compress* dc, u32 idx)
|
||||
{
|
||||
int ret;
|
||||
u64 pblk;
|
||||
u32 count;
|
||||
|
||||
if (dc->zone_pblk_alloc_idx == idx) {
|
||||
if (dc->pblk_alloc_idx == idx) {
|
||||
return 0;
|
||||
}
|
||||
ret = zone_pblk_alloc_flush(dc);
|
||||
ret = pblk_alloc_flush(dc);
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -250,12 +250,12 @@ zone_pblk_alloc_read(struct dm_compress* dc, u32 idx)
|
|||
pblk = pblk_alloc_off(&dc->params, idx);
|
||||
count = pblk_alloc_len(&dc->params);
|
||||
|
||||
ret = blkdev_pblk_read(dc->dev->bdev, pblk, count, dc->zone_pblk_alloc);
|
||||
ret = blkdev_pblk_read(dc->dev->bdev, pblk, count, dc->pblk_alloc);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
dc->zone_pblk_alloc_idx = idx;
|
||||
dc->pblk_alloc_idx = idx;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -265,7 +265,7 @@ zone_pblk_alloc_read(struct dm_compress* dc, u32 idx)
|
|||
* XXX: get rid of this function and use pblk_alloc directly in lblk_write().
|
||||
*/
|
||||
static u64
|
||||
zone_pblk_alloc_get(struct dm_compress* dc, u32 zone_hint)
|
||||
pblk_alloc_get(struct dm_compress* dc, u32 zone_hint)
|
||||
{
|
||||
u32 zone_pblk_count = pblk_alloc_len(&dc->params) * PBLK_SIZE_BITS;
|
||||
u32 zone;
|
||||
|
|
@ -274,13 +274,13 @@ zone_pblk_alloc_get(struct dm_compress* dc, u32 zone_hint)
|
|||
zone = zone_hint;
|
||||
/* XXX: check both forward and backward */
|
||||
do {
|
||||
if (zone_pblk_alloc_read(dc, zone) != 0) {
|
||||
printk(KERN_ERR " zone_pblk_alloc_read failed\n");
|
||||
if (pblk_alloc_read(dc, zone) != 0) {
|
||||
printk(KERN_ERR " pblk_alloc_read failed\n");
|
||||
return 0;
|
||||
}
|
||||
idx = cbd_bitmap_alloc(dc->zone_pblk_alloc, zone_pblk_count);
|
||||
idx = cbd_bitmap_alloc(dc->pblk_alloc, zone_pblk_count);
|
||||
if (idx != zone_pblk_count) {
|
||||
dc->zone_pblk_alloc_dirty = true;
|
||||
dc->pblk_alloc_dirty = true;
|
||||
return zone_data_off(&dc->params, zone) + idx;
|
||||
}
|
||||
++zone;
|
||||
|
|
@ -299,7 +299,7 @@ zone_pblk_alloc_get(struct dm_compress* dc, u32 zone_hint)
|
|||
* XXX: get rid of this function and use pblk_free directly in lblk_write().
|
||||
*/
|
||||
static int
|
||||
zone_pblk_alloc_put(struct dm_compress* dc, u64 pblk)
|
||||
pblk_alloc_put(struct dm_compress* dc, u64 pblk)
|
||||
{
|
||||
u32 zone_pblk_count = pblk_alloc_len(&dc->params) * PBLK_SIZE_BITS;
|
||||
u32 zone;
|
||||
|
|
@ -324,12 +324,12 @@ zone_pblk_alloc_put(struct dm_compress* dc, u64 pblk)
|
|||
printk(KERN_ERR "%s: pblk index out of bounds\n", __func__);
|
||||
return -EINVAL;
|
||||
}
|
||||
ret = zone_pblk_alloc_read(dc, zone);
|
||||
ret = pblk_alloc_read(dc, zone);
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
cbd_bitmap_free(dc->zone_pblk_alloc, idx);
|
||||
dc->zone_pblk_alloc_dirty = true;
|
||||
cbd_bitmap_free(dc->pblk_alloc, idx);
|
||||
dc->pblk_alloc_dirty = true;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -339,22 +339,22 @@ zone_pblk_alloc_put(struct dm_compress* dc, u64 pblk)
|
|||
**************************************/
|
||||
|
||||
static int
|
||||
zone_lblk_alloc_write(struct dm_compress* dc)
|
||||
lblk_alloc_write(struct dm_compress* dc)
|
||||
{
|
||||
int ret;
|
||||
u64 pblk;
|
||||
u32 count;
|
||||
|
||||
if (!dc->zone_lblk_alloc) {
|
||||
printk(KERN_ERR "%s: zone_lblk_alloc is NULL\n", __func__);
|
||||
if (!dc->lblk_alloc) {
|
||||
printk(KERN_ERR "%s: lblk_alloc is NULL\n", __func__);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
BUG_ON(dc->zone_lblk_alloc_idx == ZONE_NONE);
|
||||
pblk = lblk_alloc_off(&dc->params, dc->zone_lblk_alloc_idx);
|
||||
BUG_ON(dc->lblk_alloc_idx == ZONE_NONE);
|
||||
pblk = lblk_alloc_off(&dc->params, dc->lblk_alloc_idx);
|
||||
count = lblk_alloc_len(&dc->params);
|
||||
|
||||
ret = blkdev_pblk_write(dc->dev->bdev, pblk, count, dc->zone_lblk_alloc);
|
||||
ret = blkdev_pblk_write(dc->dev->bdev, pblk, count, dc->lblk_alloc);
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -367,21 +367,21 @@ zone_lblk_alloc_write(struct dm_compress* dc)
|
|||
* pages for lblk_alloc_elem buffer instead of the entire lblk_alloc.
|
||||
*/
|
||||
static int
|
||||
zone_lblk_alloc_read(struct dm_compress* dc, u32 idx)
|
||||
lblk_alloc_read(struct dm_compress* dc, u32 idx)
|
||||
{
|
||||
int ret;
|
||||
u64 pblk;
|
||||
u32 count;
|
||||
|
||||
if (dc->zone_lblk_alloc_idx == idx) {
|
||||
if (dc->lblk_alloc_idx == idx) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
pblk = lblk_alloc_off(&dc->params, idx);
|
||||
count = lblk_alloc_len(&dc->params);
|
||||
ret = blkdev_pblk_read(dc->dev->bdev, pblk, count, dc->zone_lblk_alloc);
|
||||
ret = blkdev_pblk_read(dc->dev->bdev, pblk, count, dc->lblk_alloc);
|
||||
if (ret == 0) {
|
||||
dc->zone_lblk_alloc_idx = idx;
|
||||
dc->lblk_alloc_idx = idx;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
@ -450,17 +450,17 @@ lblk_write(struct dm_compress* dc)
|
|||
|
||||
zone = dc->lblk_num / dc->params.lblk_per_zone;
|
||||
zone_lblk = dc->lblk_num - (zone * dc->params.lblk_per_zone);
|
||||
elem_buf = dc->zone_lblk_alloc + zone_lblk * lblk_alloc_elem_len(&dc->params);
|
||||
elem_buf = dc->lblk_alloc + zone_lblk * lblk_alloc_elem_len(&dc->params);
|
||||
|
||||
/*
|
||||
* We must have dc->zone_lblk_alloc and dc->lblk_alloc_elem cached by
|
||||
* We must have dc->lblk_alloc and dc->lblk_alloc_elem cached by
|
||||
* the previous lblk_read().
|
||||
*/
|
||||
if (dc->zone_lblk_alloc_idx != zone) {
|
||||
printk(KERN_ERR "*** lblk_alloc not cached: %lu vs %lu\n", (unsigned long)dc->zone_lblk_alloc_idx, (unsigned long)zone);
|
||||
if (dc->lblk_alloc_idx != zone) {
|
||||
printk(KERN_ERR "*** lblk_alloc not cached: %lu vs %lu\n", (unsigned long)dc->lblk_alloc_idx, (unsigned long)zone);
|
||||
return -EIO;
|
||||
}
|
||||
BUG_ON(dc->zone_lblk_alloc_idx != zone);
|
||||
BUG_ON(dc->lblk_alloc_idx != zone);
|
||||
|
||||
d_len = PBLK_SIZE * lblk_per_pblk(&dc->params);
|
||||
#ifdef CBD_DETECT_ZERO_BLOCKS
|
||||
|
|
@ -489,9 +489,9 @@ lblk_write(struct dm_compress* dc)
|
|||
if (c_len > PBLK_SIZE * n) {
|
||||
pblk = dc->lblk_alloc_elem->pblk[n];
|
||||
if (!pblk) {
|
||||
pblk = zone_pblk_alloc_get(dc, zone);
|
||||
pblk = pblk_alloc_get(dc, zone);
|
||||
if (pblk == 0) {
|
||||
printk(KERN_ERR " zone_pblk_alloc_get failed\n");
|
||||
printk(KERN_ERR " pblk_alloc_get failed\n");
|
||||
return -ENOSPC;
|
||||
}
|
||||
dc->lblk_alloc_elem->pblk[n] = pblk;
|
||||
|
|
@ -503,9 +503,9 @@ lblk_write(struct dm_compress* dc)
|
|||
pblk = dc->lblk_alloc_elem->pblk[n];
|
||||
if (pblk) {
|
||||
dc->lblk_alloc_elem->pblk[n] = 0;
|
||||
ret = zone_pblk_alloc_put(dc, pblk);
|
||||
ret = pblk_alloc_put(dc, pblk);
|
||||
if (ret != 0) {
|
||||
printk(KERN_ERR " zone_pblk_alloc_put failed\n");
|
||||
printk(KERN_ERR " pblk_alloc_put failed\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
|
@ -513,14 +513,14 @@ lblk_write(struct dm_compress* dc)
|
|||
}
|
||||
|
||||
lblk_alloc_elem_put(&dc->params, elem_buf, dc->lblk_alloc_elem);
|
||||
ret = zone_lblk_alloc_write(dc);
|
||||
ret = lblk_alloc_write(dc);
|
||||
if (ret != 0) {
|
||||
printk(KERN_ERR " zone_lblk_alloc_write failed\n");
|
||||
printk(KERN_ERR " lblk_alloc_write failed\n");
|
||||
return ret;
|
||||
}
|
||||
ret = zone_pblk_alloc_flush(dc);
|
||||
ret = pblk_alloc_flush(dc);
|
||||
if (ret != 0) {
|
||||
printk(KERN_ERR " zone_pblk_alloc_flush failed\n");
|
||||
printk(KERN_ERR " pblk_alloc_flush failed\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -564,11 +564,11 @@ lblk_read(struct dm_compress* dc, u64 idx)
|
|||
|
||||
zone = idx / dc->params.lblk_per_zone;
|
||||
zone_lblk = idx - (zone * dc->params.lblk_per_zone);
|
||||
elem_buf = dc->zone_lblk_alloc + zone_lblk * lblk_alloc_elem_len(&dc->params);
|
||||
elem_buf = dc->lblk_alloc + zone_lblk * lblk_alloc_elem_len(&dc->params);
|
||||
|
||||
ret = zone_lblk_alloc_read(dc, zone);
|
||||
ret = lblk_alloc_read(dc, zone);
|
||||
if (ret != 0) {
|
||||
printk(KERN_ERR " zone_lblk_alloc_read failed\n");
|
||||
printk(KERN_ERR " lblk_alloc_read failed\n");
|
||||
return ret;
|
||||
}
|
||||
lblk_alloc_elem_get(&dc->params, elem_buf, dc->lblk_alloc_elem);
|
||||
|
|
@ -671,11 +671,11 @@ compress_free_buffers(struct dm_compress* dc)
|
|||
kfree(dc->lblk_alloc_elem);
|
||||
dc->lblk_alloc_elem = NULL;
|
||||
|
||||
compress_free_pages(dc->zone_lblk_alloc, PBLK_SIZE * lblk_alloc_len(&dc->params));
|
||||
dc->zone_lblk_alloc = NULL;
|
||||
compress_free_pages(dc->lblk_alloc, PBLK_SIZE * lblk_alloc_len(&dc->params));
|
||||
dc->lblk_alloc = NULL;
|
||||
|
||||
compress_free_pages(dc->zone_pblk_alloc, PBLK_SIZE * pblk_alloc_len(&dc->params));
|
||||
dc->zone_pblk_alloc = NULL;
|
||||
compress_free_pages(dc->pblk_alloc, PBLK_SIZE * pblk_alloc_len(&dc->params));
|
||||
dc->pblk_alloc = NULL;
|
||||
|
||||
compress_free_pages(dc->lz4_cbuf, PBLK_SIZE * lblk_per_pblk(&dc->params));
|
||||
dc->lz4_cbuf = NULL;
|
||||
|
|
@ -702,17 +702,17 @@ compress_alloc_buffers(struct dm_compress* dc)
|
|||
printk(KERN_ERR "%s: Failed to alloc lz4_cmem\n", __func__);
|
||||
goto out_nomem;
|
||||
}
|
||||
dc->zone_pblk_alloc_idx = ZONE_NONE;
|
||||
dc->zone_pblk_alloc_dirty = false;
|
||||
dc->zone_pblk_alloc = compress_alloc_pages(PBLK_SIZE * pblk_alloc_len(&dc->params));
|
||||
if (!dc->zone_pblk_alloc) {
|
||||
printk(KERN_ERR "%s: Failed to alloc zone_pblk_alloc\n", __func__);
|
||||
dc->pblk_alloc_idx = ZONE_NONE;
|
||||
dc->pblk_alloc_dirty = false;
|
||||
dc->pblk_alloc = compress_alloc_pages(PBLK_SIZE * pblk_alloc_len(&dc->params));
|
||||
if (!dc->pblk_alloc) {
|
||||
printk(KERN_ERR "%s: Failed to alloc pblk_alloc\n", __func__);
|
||||
goto out_nomem;
|
||||
}
|
||||
dc->zone_lblk_alloc_idx = ZONE_NONE;
|
||||
dc->zone_lblk_alloc = compress_alloc_pages(PBLK_SIZE * lblk_alloc_len(&dc->params));
|
||||
if (!dc->zone_lblk_alloc) {
|
||||
printk(KERN_ERR "%s: Failed to alloc zone_lblk_alloc\n", __func__);
|
||||
dc->lblk_alloc_idx = ZONE_NONE;
|
||||
dc->lblk_alloc = compress_alloc_pages(PBLK_SIZE * lblk_alloc_len(&dc->params));
|
||||
if (!dc->lblk_alloc) {
|
||||
printk(KERN_ERR "%s: Failed to alloc lblk_alloc\n", __func__);
|
||||
goto out_nomem;
|
||||
}
|
||||
dc->lblk_num = LBLK_NONE;
|
||||
|
|
|
|||
Loading…
Reference in New Issue