tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

zram: drop wb_limit_lock

We don't need wb_limit_lock. Writeback limit setters take an exclusive
write zram init_lock, while wb_limit modifications happen only from a
single task and under zram read init_lock. No concurrent wb_limit
modifications are possible (we permit only one post-processing task at a
time). Add lockdep assertions to wb_limit mutators.

While at it, fixup coding styles.

Link: https://lkml.kernel.org/r/20251122074029.3948921-5-senozhatsky@chromium.org
Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org>
Reviewed-by: Brian Geffon <bgeffon@google.com>
Cc: Minchan Kim <minchan@google.com>
Cc: Richard Chang <richardycc@google.com>
Cc: Yuwen Chen <ywen.chen@foxmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

Sergey Senozhatsky and committed by
Andrew Morton a4f506c5 7c929664

+5 -18
+5 -17
drivers/block/zram/zram_drv.c
··· 532 532 return ret; 533 533 534 534 down_write(&zram->init_lock); 535 - spin_lock(&zram->wb_limit_lock); 536 535 zram->wb_limit_enable = val; 537 - spin_unlock(&zram->wb_limit_lock); 538 536 up_write(&zram->init_lock); 539 537 ret = len; 540 538 ··· 547 549 struct zram *zram = dev_to_zram(dev); 548 550 549 551 down_read(&zram->init_lock); 550 - spin_lock(&zram->wb_limit_lock); 551 552 val = zram->wb_limit_enable; 552 - spin_unlock(&zram->wb_limit_lock); 553 553 up_read(&zram->init_lock); 554 554 555 555 return sysfs_emit(buf, "%d\n", val); ··· 565 569 return ret; 566 570 567 571 down_write(&zram->init_lock); 568 - spin_lock(&zram->wb_limit_lock); 569 572 zram->bd_wb_limit = val; 570 - spin_unlock(&zram->wb_limit_lock); 571 573 up_write(&zram->init_lock); 572 574 ret = len; 573 575 ··· 573 579 } 574 580 575 581 static ssize_t writeback_limit_show(struct device *dev, 576 - struct device_attribute *attr, char *buf) 582 + struct device_attribute *attr, char *buf) 577 583 { 578 584 u64 val; 579 585 struct zram *zram = dev_to_zram(dev); 580 586 581 587 down_read(&zram->init_lock); 582 - spin_lock(&zram->wb_limit_lock); 583 588 val = zram->bd_wb_limit; 584 - spin_unlock(&zram->wb_limit_lock); 585 589 up_read(&zram->init_lock); 586 590 587 591 return sysfs_emit(buf, "%llu\n", val); ··· 861 869 862 870 static void zram_account_writeback_rollback(struct zram *zram) 863 871 { 864 - spin_lock(&zram->wb_limit_lock); 872 + lockdep_assert_held_read(&zram->init_lock); 873 + 865 874 if (zram->wb_limit_enable) 866 875 zram->bd_wb_limit += 1UL << (PAGE_SHIFT - 12); 867 - spin_unlock(&zram->wb_limit_lock); 868 876 } 869 877 870 878 static void zram_account_writeback_submit(struct zram *zram) 871 879 { 872 - spin_lock(&zram->wb_limit_lock); 880 + lockdep_assert_held_read(&zram->init_lock); 881 + 873 882 if (zram->wb_limit_enable && zram->bd_wb_limit > 0) 874 883 zram->bd_wb_limit -= 1UL << (PAGE_SHIFT - 12); 875 - spin_unlock(&zram->wb_limit_lock); 876 884 } 877 885 878 886 static int zram_writeback_complete(struct zram *zram, struct zram_wb_req *req) ··· 997 1005 u32 index = 0; 998 1006 999 1007 while ((pps = select_pp_slot(ctl))) { 1000 - spin_lock(&zram->wb_limit_lock); 1001 1008 if (zram->wb_limit_enable && !zram->bd_wb_limit) { 1002 - spin_unlock(&zram->wb_limit_lock); 1003 1009 ret = -EIO; 1004 1010 break; 1005 1011 } 1006 - spin_unlock(&zram->wb_limit_lock); 1007 1012 1008 1013 while (!req) { 1009 1014 req = zram_select_idle_req(wb_ctl); ··· 2951 2962 init_rwsem(&zram->init_lock); 2952 2963 #ifdef CONFIG_ZRAM_WRITEBACK 2953 2964 zram->wb_batch_size = 32; 2954 - spin_lock_init(&zram->wb_limit_lock); 2955 2965 #endif 2956 2966 2957 2967 /* gendisk structure */
-1
drivers/block/zram/zram_drv.h
··· 127 127 bool claim; /* Protected by disk->open_mutex */ 128 128 #ifdef CONFIG_ZRAM_WRITEBACK 129 129 struct file *backing_dev; 130 - spinlock_t wb_limit_lock; 131 130 bool wb_limit_enable; 132 131 u32 wb_batch_size; 133 132 u64 bd_wb_limit;