Commit beb6602c authored by Minchan Kim's avatar Minchan Kim Committed by Linus Torvalds

zram: remove zram_meta structure

It's redundant now.  Instead, remove it and use zram structure directly.

Link: http://lkml.kernel.org/r/1492052365-16169-5-git-send-email-minchan@kernel.orgSigned-off-by: default avatarMinchan Kim <minchan@kernel.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Johannes Thumshirn <jthumshirn@suse.de>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 86c49814
......@@ -58,46 +58,46 @@ static inline struct zram *dev_to_zram(struct device *dev)
}
/* flag operations require table entry bit_spin_lock() being held */
static int zram_test_flag(struct zram_meta *meta, u32 index,
static int zram_test_flag(struct zram *zram, u32 index,
enum zram_pageflags flag)
{
return meta->table[index].value & BIT(flag);
return zram->table[index].value & BIT(flag);
}
static void zram_set_flag(struct zram_meta *meta, u32 index,
static void zram_set_flag(struct zram *zram, u32 index,
enum zram_pageflags flag)
{
meta->table[index].value |= BIT(flag);
zram->table[index].value |= BIT(flag);
}
static void zram_clear_flag(struct zram_meta *meta, u32 index,
static void zram_clear_flag(struct zram *zram, u32 index,
enum zram_pageflags flag)
{
meta->table[index].value &= ~BIT(flag);
zram->table[index].value &= ~BIT(flag);
}
static inline void zram_set_element(struct zram_meta *meta, u32 index,
static inline void zram_set_element(struct zram *zram, u32 index,
unsigned long element)
{
meta->table[index].element = element;
zram->table[index].element = element;
}
static inline void zram_clear_element(struct zram_meta *meta, u32 index)
static inline void zram_clear_element(struct zram *zram, u32 index)
{
meta->table[index].element = 0;
zram->table[index].element = 0;
}
static size_t zram_get_obj_size(struct zram_meta *meta, u32 index)
static size_t zram_get_obj_size(struct zram *zram, u32 index)
{
return meta->table[index].value & (BIT(ZRAM_FLAG_SHIFT) - 1);
return zram->table[index].value & (BIT(ZRAM_FLAG_SHIFT) - 1);
}
static void zram_set_obj_size(struct zram_meta *meta,
static void zram_set_obj_size(struct zram *zram,
u32 index, size_t size)
{
unsigned long flags = meta->table[index].value >> ZRAM_FLAG_SHIFT;
unsigned long flags = zram->table[index].value >> ZRAM_FLAG_SHIFT;
meta->table[index].value = (flags << ZRAM_FLAG_SHIFT) | size;
zram->table[index].value = (flags << ZRAM_FLAG_SHIFT) | size;
}
#if PAGE_SIZE != 4096
......@@ -250,9 +250,8 @@ static ssize_t mem_used_max_store(struct device *dev,
down_read(&zram->init_lock);
if (init_done(zram)) {
struct zram_meta *meta = zram->meta;
atomic_long_set(&zram->stats.max_used_pages,
zs_get_total_pages(meta->mem_pool));
zs_get_total_pages(zram->mem_pool));
}
up_read(&zram->init_lock);
......@@ -325,7 +324,6 @@ static ssize_t compact_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
struct zram *zram = dev_to_zram(dev);
struct zram_meta *meta;
down_read(&zram->init_lock);
if (!init_done(zram)) {
......@@ -333,8 +331,7 @@ static ssize_t compact_store(struct device *dev,
return -EINVAL;
}
meta = zram->meta;
zs_compact(meta->mem_pool);
zs_compact(zram->mem_pool);
up_read(&zram->init_lock);
return len;
......@@ -371,8 +368,8 @@ static ssize_t mm_stat_show(struct device *dev,
down_read(&zram->init_lock);
if (init_done(zram)) {
mem_used = zs_get_total_pages(zram->meta->mem_pool);
zs_pool_stats(zram->meta->mem_pool, &pool_stats);
mem_used = zs_get_total_pages(zram->mem_pool);
zs_pool_stats(zram->mem_pool, &pool_stats);
}
orig_size = atomic64_read(&zram->stats.pages_stored);
......@@ -415,32 +412,26 @@ static DEVICE_ATTR_RO(debug_stat);
static void zram_slot_lock(struct zram *zram, u32 index)
{
struct zram_meta *meta = zram->meta;
bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
bit_spin_lock(ZRAM_ACCESS, &zram->table[index].value);
}
static void zram_slot_unlock(struct zram *zram, u32 index)
{
struct zram_meta *meta = zram->meta;
bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
bit_spin_unlock(ZRAM_ACCESS, &zram->table[index].value);
}
static bool zram_same_page_read(struct zram *zram, u32 index,
struct page *page,
unsigned int offset, unsigned int len)
{
struct zram_meta *meta = zram->meta;
zram_slot_lock(zram, index);
if (unlikely(!meta->table[index].handle) ||
zram_test_flag(meta, index, ZRAM_SAME)) {
if (unlikely(!zram->table[index].handle) ||
zram_test_flag(zram, index, ZRAM_SAME)) {
void *mem;
zram_slot_unlock(zram, index);
mem = kmap_atomic(page);
zram_fill_page(mem + offset, len, meta->table[index].element);
zram_fill_page(mem + offset, len, zram->table[index].element);
kunmap_atomic(mem);
return true;
}
......@@ -456,14 +447,12 @@ static bool zram_same_page_write(struct zram *zram, u32 index,
void *mem = kmap_atomic(page);
if (page_same_filled(mem, &element)) {
struct zram_meta *meta = zram->meta;
kunmap_atomic(mem);
/* Free memory associated with this sector now. */
zram_slot_lock(zram, index);
zram_free_page(zram, index);
zram_set_flag(meta, index, ZRAM_SAME);
zram_set_element(meta, index, element);
zram_set_flag(zram, index, ZRAM_SAME);
zram_set_element(zram, index, element);
zram_slot_unlock(zram, index);
atomic64_inc(&zram->stats.same_pages);
......@@ -474,56 +463,44 @@ static bool zram_same_page_write(struct zram *zram, u32 index,
return false;
}
static void zram_meta_free(struct zram_meta *meta, u64 disksize)
static void zram_meta_free(struct zram *zram, u64 disksize)
{
size_t num_pages = disksize >> PAGE_SHIFT;
size_t index;
/* Free all pages that are still in this zram device */
for (index = 0; index < num_pages; index++) {
unsigned long handle = meta->table[index].handle;
unsigned long handle = zram->table[index].handle;
/*
* No memory is allocated for same element filled pages.
* Simply clear same page flag.
*/
if (!handle || zram_test_flag(meta, index, ZRAM_SAME))
if (!handle || zram_test_flag(zram, index, ZRAM_SAME))
continue;
zs_free(meta->mem_pool, handle);
zs_free(zram->mem_pool, handle);
}
zs_destroy_pool(meta->mem_pool);
vfree(meta->table);
kfree(meta);
zs_destroy_pool(zram->mem_pool);
vfree(zram->table);
}
static struct zram_meta *zram_meta_alloc(char *pool_name, u64 disksize)
static bool zram_meta_alloc(struct zram *zram, u64 disksize)
{
size_t num_pages;
struct zram_meta *meta = kmalloc(sizeof(*meta), GFP_KERNEL);
if (!meta)
return NULL;
num_pages = disksize >> PAGE_SHIFT;
meta->table = vzalloc(num_pages * sizeof(*meta->table));
if (!meta->table) {
pr_err("Error allocating zram address table\n");
goto out_error;
}
zram->table = vzalloc(num_pages * sizeof(*zram->table));
if (!zram->table)
return false;
meta->mem_pool = zs_create_pool(pool_name);
if (!meta->mem_pool) {
pr_err("Error creating memory pool\n");
goto out_error;
zram->mem_pool = zs_create_pool(zram->disk->disk_name);
if (!zram->mem_pool) {
vfree(zram->table);
return false;
}
return meta;
out_error:
vfree(meta->table);
kfree(meta);
return NULL;
return true;
}
/*
......@@ -533,16 +510,15 @@ static struct zram_meta *zram_meta_alloc(char *pool_name, u64 disksize)
*/
static void zram_free_page(struct zram *zram, size_t index)
{
struct zram_meta *meta = zram->meta;
unsigned long handle = meta->table[index].handle;
unsigned long handle = zram->table[index].handle;
/*
* No memory is allocated for same element filled pages.
* Simply clear same page flag.
*/
if (zram_test_flag(meta, index, ZRAM_SAME)) {
zram_clear_flag(meta, index, ZRAM_SAME);
zram_clear_element(meta, index);
if (zram_test_flag(zram, index, ZRAM_SAME)) {
zram_clear_flag(zram, index, ZRAM_SAME);
zram_clear_element(zram, index);
atomic64_dec(&zram->stats.same_pages);
return;
}
......@@ -550,14 +526,14 @@ static void zram_free_page(struct zram *zram, size_t index)
if (!handle)
return;
zs_free(meta->mem_pool, handle);
zs_free(zram->mem_pool, handle);
atomic64_sub(zram_get_obj_size(meta, index),
atomic64_sub(zram_get_obj_size(zram, index),
&zram->stats.compr_data_size);
atomic64_dec(&zram->stats.pages_stored);
meta->table[index].handle = 0;
zram_set_obj_size(meta, index, 0);
zram->table[index].handle = 0;
zram_set_obj_size(zram, index, 0);
}
static int zram_decompress_page(struct zram *zram, struct page *page, u32 index)
......@@ -566,16 +542,15 @@ static int zram_decompress_page(struct zram *zram, struct page *page, u32 index)
unsigned long handle;
unsigned int size;
void *src, *dst;
struct zram_meta *meta = zram->meta;
if (zram_same_page_read(zram, index, page, 0, PAGE_SIZE))
return 0;
zram_slot_lock(zram, index);
handle = meta->table[index].handle;
size = zram_get_obj_size(meta, index);
handle = zram->table[index].handle;
size = zram_get_obj_size(zram, index);
src = zs_map_object(meta->mem_pool, handle, ZS_MM_RO);
src = zs_map_object(zram->mem_pool, handle, ZS_MM_RO);
if (size == PAGE_SIZE) {
dst = kmap_atomic(page);
memcpy(dst, src, PAGE_SIZE);
......@@ -589,7 +564,7 @@ static int zram_decompress_page(struct zram *zram, struct page *page, u32 index)
kunmap_atomic(dst);
zcomp_stream_put(zram->comp);
}
zs_unmap_object(meta->mem_pool, handle);
zs_unmap_object(zram->mem_pool, handle);
zram_slot_unlock(zram, index);
/* Should NEVER happen. Return bio error if it does. */
......@@ -641,7 +616,6 @@ static int zram_compress(struct zram *zram, struct zcomp_strm **zstrm,
void *src;
unsigned long alloced_pages;
unsigned long handle = 0;
struct zram_meta *meta = zram->meta;
compress_again:
src = kmap_atomic(page);
......@@ -651,7 +625,7 @@ static int zram_compress(struct zram *zram, struct zcomp_strm **zstrm,
if (unlikely(ret)) {
pr_err("Compression failed! err=%d\n", ret);
if (handle)
zs_free(meta->mem_pool, handle);
zs_free(zram->mem_pool, handle);
return ret;
}
......@@ -672,7 +646,7 @@ static int zram_compress(struct zram *zram, struct zcomp_strm **zstrm,
* from the slow path and handle has already been allocated.
*/
if (!handle)
handle = zs_malloc(meta->mem_pool, comp_len,
handle = zs_malloc(zram->mem_pool, comp_len,
__GFP_KSWAPD_RECLAIM |
__GFP_NOWARN |
__GFP_HIGHMEM |
......@@ -680,7 +654,7 @@ static int zram_compress(struct zram *zram, struct zcomp_strm **zstrm,
if (!handle) {
zcomp_stream_put(zram->comp);
atomic64_inc(&zram->stats.writestall);
handle = zs_malloc(meta->mem_pool, comp_len,
handle = zs_malloc(zram->mem_pool, comp_len,
GFP_NOIO | __GFP_HIGHMEM |
__GFP_MOVABLE);
*zstrm = zcomp_stream_get(zram->comp);
......@@ -689,11 +663,11 @@ static int zram_compress(struct zram *zram, struct zcomp_strm **zstrm,
return -ENOMEM;
}
alloced_pages = zs_get_total_pages(meta->mem_pool);
alloced_pages = zs_get_total_pages(zram->mem_pool);
update_used_max(zram, alloced_pages);
if (zram->limit_pages && alloced_pages > zram->limit_pages) {
zs_free(meta->mem_pool, handle);
zs_free(zram->mem_pool, handle);
return -ENOMEM;
}
......@@ -709,7 +683,6 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index)
unsigned int comp_len;
void *src, *dst;
struct zcomp_strm *zstrm;
struct zram_meta *meta = zram->meta;
struct page *page = bvec->bv_page;
if (zram_same_page_write(zram, index, page))
......@@ -722,8 +695,7 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index)
return ret;
}
dst = zs_map_object(meta->mem_pool, handle, ZS_MM_WO);
dst = zs_map_object(zram->mem_pool, handle, ZS_MM_WO);
src = zstrm->buffer;
if (comp_len == PAGE_SIZE)
......@@ -733,7 +705,7 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index)
kunmap_atomic(src);
zcomp_stream_put(zram->comp);
zs_unmap_object(meta->mem_pool, handle);
zs_unmap_object(zram->mem_pool, handle);
/*
* Free memory associated with this sector
......@@ -741,8 +713,8 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index)
*/
zram_slot_lock(zram, index);
zram_free_page(zram, index);
meta->table[index].handle = handle;
zram_set_obj_size(meta, index, comp_len);
zram->table[index].handle = handle;
zram_set_obj_size(zram, index, comp_len);
zram_slot_unlock(zram, index);
/* Update stats */
......@@ -932,10 +904,8 @@ static void zram_slot_free_notify(struct block_device *bdev,
unsigned long index)
{
struct zram *zram;
struct zram_meta *meta;
zram = bdev->bd_disk->private_data;
meta = zram->meta;
zram_slot_lock(zram, index);
zram_free_page(zram, index);
......@@ -983,7 +953,6 @@ static int zram_rw_page(struct block_device *bdev, sector_t sector,
static void zram_reset_device(struct zram *zram)
{
struct zram_meta *meta;
struct zcomp *comp;
u64 disksize;
......@@ -996,7 +965,6 @@ static void zram_reset_device(struct zram *zram)
return;
}
meta = zram->meta;
comp = zram->comp;
disksize = zram->disksize;
......@@ -1009,7 +977,7 @@ static void zram_reset_device(struct zram *zram)
up_write(&zram->init_lock);
/* I/O operation under all of CPU are done so let's free */
zram_meta_free(meta, disksize);
zram_meta_free(zram, disksize);
zcomp_destroy(comp);
}
......@@ -1018,7 +986,6 @@ static ssize_t disksize_store(struct device *dev,
{
u64 disksize;
struct zcomp *comp;
struct zram_meta *meta;
struct zram *zram = dev_to_zram(dev);
int err;
......@@ -1026,10 +993,18 @@ static ssize_t disksize_store(struct device *dev,
if (!disksize)
return -EINVAL;
down_write(&zram->init_lock);
if (init_done(zram)) {
pr_info("Cannot change disksize for initialized device\n");
err = -EBUSY;
goto out_unlock;
}
disksize = PAGE_ALIGN(disksize);
meta = zram_meta_alloc(zram->disk->disk_name, disksize);
if (!meta)
return -ENOMEM;
if (!zram_meta_alloc(zram, disksize)) {
err = -ENOMEM;
goto out_unlock;
}
comp = zcomp_create(zram->compressor);
if (IS_ERR(comp)) {
......@@ -1039,14 +1014,6 @@ static ssize_t disksize_store(struct device *dev,
goto out_free_meta;
}
down_write(&zram->init_lock);
if (init_done(zram)) {
pr_info("Cannot change disksize for initialized device\n");
err = -EBUSY;
goto out_destroy_comp;
}
zram->meta = meta;
zram->comp = comp;
zram->disksize = disksize;
set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
......@@ -1055,11 +1022,10 @@ static ssize_t disksize_store(struct device *dev,
return len;
out_destroy_comp:
up_write(&zram->init_lock);
zcomp_destroy(comp);
out_free_meta:
zram_meta_free(meta, disksize);
zram_meta_free(zram, disksize);
out_unlock:
up_write(&zram->init_lock);
return err;
}
......@@ -1245,7 +1211,6 @@ static int zram_add(void)
goto out_free_disk;
}
strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor));
zram->meta = NULL;
pr_info("Added device: %s\n", zram->disk->disk_name);
return device_id;
......
......@@ -92,13 +92,9 @@ struct zram_stats {
atomic64_t writestall; /* no. of write slow paths */
};
struct zram_meta {
struct zram {
struct zram_table_entry *table;
struct zs_pool *mem_pool;
};
struct zram {
struct zram_meta *meta;
struct zcomp *comp;
struct gendisk *disk;
/* Prevent concurrent execution of device init */
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment