leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

zram: remove double compression logic

Browse Source 
The 2nd trial allocation under per-cpu presumption has been used to
prevent regression of allocation failure.  However, it makes trouble for
maintenance without significant benefit.  The slowpath branch is executed
extremely rarely: getting there is problematic.  Therefore, we delete this
branch.

Since b09ab054b6 ("zram: support BDI_CAP_STABLE_WRITES"), zram has used
QUEUE_FLAG_STABLE_WRITES to prevent buffer change between 1st and 2nd
memory allocations.  Since we remove second trial memory allocation logic,
we could remove the STABLE_WRITES flag because there is no change buffer
to be modified under us.

Link: https://lkml.kernel.org/r/20220505094443.11728-1-avromanov@sberdevices.ru
Signed-off-by: Alexey Romanov <avromanov@sberdevices.ru>
Signed-off-by: Dmitry Rokosov <ddrokosov@sberdevices.ru>
Acked-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Sergey Senozhatsky <senozhatsky@chromium.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
Alexey Romanov 2022-05-12 20:23:07 -07:00 committed by Andrew Morton
parent f67bed134a
commit e7be8d1dd9
2 changed files with 10 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
drivers/block/zram/zram_drv.c
View File

@ -1144,15 +1144,14 @@ static ssize_t bd_stat_show(struct device *dev,
static ssize_t debug_stat_show(struct device *dev, static ssize_t debug_stat_show(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
int version = 1; int version = 2;
struct zram *zram = dev_to_zram(dev); struct zram *zram = dev_to_zram(dev);
ssize_t ret; ssize_t ret;
down_read(&zram->init_lock); down_read(&zram->init_lock);
ret = scnprintf(buf, PAGE_SIZE, ret = scnprintf(buf, PAGE_SIZE,
"version: %d\n%8llu %8llu\n", "version: %d\n%8llu\n",
version, version,
(u64)atomic64_read(&zram->stats.writestall),
(u64)atomic64_read(&zram->stats.miss_free)); (u64)atomic64_read(&zram->stats.miss_free));
up_read(&zram->init_lock); up_read(&zram->init_lock);
@ -1368,7 +1367,6 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
} }
kunmap_atomic(mem); kunmap_atomic(mem);
compress_again:
zstrm = zcomp_stream_get(zram->comp); zstrm = zcomp_stream_get(zram->comp);
src = kmap_atomic(page); src = kmap_atomic(page);
ret = zcomp_compress(zstrm, src, &comp_len); ret = zcomp_compress(zstrm, src, &comp_len);
@ -1377,39 +1375,20 @@ compress_again:
if (unlikely(ret)) { if (unlikely(ret)) {
zcomp_stream_put(zram->comp); zcomp_stream_put(zram->comp);
pr_err("Compression failed! err=%d\n", ret); pr_err("Compression failed! err=%d\n", ret);
zs_free(zram->mem_pool, handle);
return ret; return ret;
} }
if (comp_len >= huge_class_size) if (comp_len >= huge_class_size)
comp_len = PAGE_SIZE; comp_len = PAGE_SIZE;
/*
* handle allocation has 2 paths:
* a) fast path is executed with preemption disabled (for
* per-cpu streams) and has __GFP_DIRECT_RECLAIM bit clear,
* since we can't sleep;
* b) slow path enables preemption and attempts to allocate
* the page with __GFP_DIRECT_RECLAIM bit set. we have to
* put per-cpu compression stream and, thus, to re-do
* the compression once handle is allocated.
*
* if we have a 'non-null' handle here then we are coming
* from the slow path and handle has already been allocated.
*/
if (!handle)
handle = zs_malloc(zram->mem_pool, comp_len, handle = zs_malloc(zram->mem_pool, comp_len,
__GFP_KSWAPD_RECLAIM | __GFP_KSWAPD_RECLAIM |
__GFP_NOWARN | __GFP_NOWARN |
__GFP_HIGHMEM | __GFP_HIGHMEM |
__GFP_MOVABLE); __GFP_MOVABLE);
if (!handle) {
if (unlikely(!handle)) {
zcomp_stream_put(zram->comp); zcomp_stream_put(zram->comp);
atomic64_inc(&zram->stats.writestall);
handle = zs_malloc(zram->mem_pool, comp_len,
GFP_NOIO | __GFP_HIGHMEM |
__GFP_MOVABLE);
if (handle)
goto compress_again;
return -ENOMEM; return -ENOMEM;
} }
@ -1967,7 +1946,6 @@ static int zram_add(void)
if (ZRAM_LOGICAL_BLOCK_SIZE == PAGE_SIZE) if (ZRAM_LOGICAL_BLOCK_SIZE == PAGE_SIZE)
blk_queue_max_write_zeroes_sectors(zram->disk->queue, UINT_MAX); blk_queue_max_write_zeroes_sectors(zram->disk->queue, UINT_MAX);
blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, zram->disk->queue);
ret = device_add_disk(NULL, zram->disk, zram_disk_groups); ret = device_add_disk(NULL, zram->disk, zram_disk_groups);
if (ret) if (ret)
goto out_cleanup_disk; goto out_cleanup_disk;

1
drivers/block/zram/zram_drv.h
View File

@ -81,7 +81,6 @@ struct zram_stats {
atomic64_t huge_pages_since; /* no. of huge pages since zram set up */ atomic64_t huge_pages_since; /* no. of huge pages since zram set up */
atomic64_t pages_stored; /* no. of pages currently stored */ atomic64_t pages_stored; /* no. of pages currently stored */
atomic_long_t max_used_pages; /* no. of maximum pages stored */ atomic_long_t max_used_pages; /* no. of maximum pages stored */
atomic64_t writestall; /* no. of write slow paths */
atomic64_t miss_free; /* no. of missed free */ atomic64_t miss_free; /* no. of missed free */
#ifdef CONFIG_ZRAM_WRITEBACK #ifdef CONFIG_ZRAM_WRITEBACK
atomic64_t bd_count; /* no. of pages in backing device */ atomic64_t bd_count; /* no. of pages in backing device */