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: rename init_lock to dev_lock

init_lock has completely outgrown its initial purpose and is no longer
used only to "prevent concurrent execution of device init" as the stale
comment suggests. The scope of this lock is much bigger now.

These days this lock (rw_semaphore) controls how a task owns the
corresponding zram device: either in shared mode or in exclusive mode.

All zram device attribute writes should own the device in exclusive mode,
which synchronizes these tasks and prevents, for example, concurrent
execution of recompression and writeback.

All zram device attribute reads should own the device in shared mode.

Rename the lock to dev_lock to better reflect its current purpose.

Link: https://lkml.kernel.org/r/20260115080807.3957860-1-senozhatsky@chromium.org
Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org>
Reviewed-by: Andrew Morton <akpm@linux-foundation.org>
Cc: Brian Geffon <bgeffon@google.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Minchan Kim <minchan@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

Sergey Senozhatsky and committed by
Andrew Morton 6efc548d c0f609f7

+32 -32
+30 -30
drivers/block/zram/zram_drv.c
··· 365 365 u32 val; 366 366 struct zram *zram = dev_to_zram(dev); 367 367 368 - guard(rwsem_read)(&zram->init_lock); 368 + guard(rwsem_read)(&zram->dev_lock); 369 369 val = init_done(zram); 370 370 371 371 return sysfs_emit(buf, "%u\n", val); ··· 391 391 if (buf == tmp) /* no chars parsed, invalid input */ 392 392 return -EINVAL; 393 393 394 - guard(rwsem_write)(&zram->init_lock); 394 + guard(rwsem_write)(&zram->dev_lock); 395 395 zram->limit_pages = PAGE_ALIGN(limit) >> PAGE_SHIFT; 396 396 397 397 return len; ··· 409 409 if (err || val != 0) 410 410 return -EINVAL; 411 411 412 - guard(rwsem_read)(&zram->init_lock); 412 + guard(rwsem_read)(&zram->dev_lock); 413 413 if (init_done(zram)) { 414 414 atomic_long_set(&zram->stats.max_used_pages, 415 415 zs_get_total_pages(zram->mem_pool)); ··· 477 477 return -EINVAL; 478 478 } 479 479 480 - guard(rwsem_read)(&zram->init_lock); 480 + guard(rwsem_read)(&zram->dev_lock); 481 481 if (!init_done(zram)) 482 482 return -EINVAL; 483 483 ··· 539 539 struct zram *zram = dev_to_zram(dev); 540 540 ssize_t ret; 541 541 542 - guard(rwsem_read)(&zram->init_lock); 542 + guard(rwsem_read)(&zram->dev_lock); 543 543 ret = sysfs_emit(buf, 544 544 "%8llu %8llu %8llu\n", 545 545 FOUR_K((u64)atomic64_read(&zram->stats.bd_count)), ··· 559 559 if (kstrtobool(buf, &val)) 560 560 return -EINVAL; 561 561 562 - guard(rwsem_write)(&zram->init_lock); 562 + guard(rwsem_write)(&zram->dev_lock); 563 563 if (init_done(zram)) { 564 564 return -EBUSY; 565 565 } ··· 576 576 bool val; 577 577 struct zram *zram = dev_to_zram(dev); 578 578 579 - guard(rwsem_read)(&zram->init_lock); 579 + guard(rwsem_read)(&zram->dev_lock); 580 580 val = zram->wb_compressed; 581 581 582 582 return sysfs_emit(buf, "%d\n", val); ··· 592 592 if (kstrtoull(buf, 10, &val)) 593 593 return -EINVAL; 594 594 595 - guard(rwsem_write)(&zram->init_lock); 595 + guard(rwsem_write)(&zram->dev_lock); 596 596 zram->wb_limit_enable = val; 597 597 598 598 return len; ··· 605 605 bool val; 606 606 struct zram *zram = dev_to_zram(dev); 607 607 608 - guard(rwsem_read)(&zram->init_lock); 608 + guard(rwsem_read)(&zram->dev_lock); 609 609 val = zram->wb_limit_enable; 610 610 611 611 return sysfs_emit(buf, "%d\n", val); ··· 631 631 */ 632 632 val = rounddown(val, PAGE_SIZE / 4096); 633 633 634 - guard(rwsem_write)(&zram->init_lock); 634 + guard(rwsem_write)(&zram->dev_lock); 635 635 zram->bd_wb_limit = val; 636 636 637 637 return len; ··· 643 643 u64 val; 644 644 struct zram *zram = dev_to_zram(dev); 645 645 646 - guard(rwsem_read)(&zram->init_lock); 646 + guard(rwsem_read)(&zram->dev_lock); 647 647 val = zram->bd_wb_limit; 648 648 649 649 return sysfs_emit(buf, "%llu\n", val); ··· 662 662 if (!val) 663 663 return -EINVAL; 664 664 665 - guard(rwsem_write)(&zram->init_lock); 665 + guard(rwsem_write)(&zram->dev_lock); 666 666 zram->wb_batch_size = val; 667 667 668 668 return len; ··· 675 675 u32 val; 676 676 struct zram *zram = dev_to_zram(dev); 677 677 678 - guard(rwsem_read)(&zram->init_lock); 678 + guard(rwsem_read)(&zram->dev_lock); 679 679 val = zram->wb_batch_size; 680 680 681 681 return sysfs_emit(buf, "%u\n", val); ··· 703 703 char *p; 704 704 ssize_t ret; 705 705 706 - guard(rwsem_read)(&zram->init_lock); 706 + guard(rwsem_read)(&zram->dev_lock); 707 707 file = zram->backing_dev; 708 708 if (!file) { 709 709 memcpy(buf, "none\n", 5); ··· 737 737 if (!file_name) 738 738 return -ENOMEM; 739 739 740 - guard(rwsem_write)(&zram->init_lock); 740 + guard(rwsem_write)(&zram->dev_lock); 741 741 if (init_done(zram)) { 742 742 pr_info("Can't setup backing device for initialized device\n"); 743 743 err = -EBUSY; ··· 901 901 902 902 static void zram_account_writeback_rollback(struct zram *zram) 903 903 { 904 - lockdep_assert_held_write(&zram->init_lock); 904 + lockdep_assert_held_write(&zram->dev_lock); 905 905 906 906 if (zram->wb_limit_enable) 907 907 zram->bd_wb_limit += 1UL << (PAGE_SHIFT - 12); ··· 909 909 910 910 static void zram_account_writeback_submit(struct zram *zram) 911 911 { 912 - lockdep_assert_held_write(&zram->init_lock); 912 + lockdep_assert_held_write(&zram->dev_lock); 913 913 914 914 if (zram->wb_limit_enable && zram->bd_wb_limit > 0) 915 915 zram->bd_wb_limit -= 1UL << (PAGE_SHIFT - 12); ··· 1263 1263 ssize_t ret = len; 1264 1264 int err, mode = 0; 1265 1265 1266 - guard(rwsem_write)(&zram->init_lock); 1266 + guard(rwsem_write)(&zram->dev_lock); 1267 1267 if (!init_done(zram)) 1268 1268 return -EINVAL; 1269 1269 ··· 1565 1565 if (!kbuf) 1566 1566 return -ENOMEM; 1567 1567 1568 - guard(rwsem_read)(&zram->init_lock); 1568 + guard(rwsem_read)(&zram->dev_lock); 1569 1569 if (!init_done(zram)) { 1570 1570 kvfree(kbuf); 1571 1571 return -EINVAL; ··· 1666 1666 return -EINVAL; 1667 1667 } 1668 1668 1669 - guard(rwsem_write)(&zram->init_lock); 1669 + guard(rwsem_write)(&zram->dev_lock); 1670 1670 if (init_done(zram)) { 1671 1671 kfree(compressor); 1672 1672 pr_info("Can't change algorithm for initialized device\n"); ··· 1794 1794 struct zram *zram = dev_to_zram(dev); 1795 1795 ssize_t sz; 1796 1796 1797 - guard(rwsem_read)(&zram->init_lock); 1797 + guard(rwsem_read)(&zram->dev_lock); 1798 1798 sz = zcomp_available_show(zram->comp_algs[ZRAM_PRIMARY_COMP], buf, 0); 1799 1799 return sz; 1800 1800 } ··· 1820 1820 ssize_t sz = 0; 1821 1821 u32 prio; 1822 1822 1823 - guard(rwsem_read)(&zram->init_lock); 1823 + guard(rwsem_read)(&zram->dev_lock); 1824 1824 for (prio = ZRAM_SECONDARY_COMP; prio < ZRAM_MAX_COMPS; prio++) { 1825 1825 if (!zram->comp_algs[prio]) 1826 1826 continue; ··· 1878 1878 { 1879 1879 struct zram *zram = dev_to_zram(dev); 1880 1880 1881 - guard(rwsem_read)(&zram->init_lock); 1881 + guard(rwsem_read)(&zram->dev_lock); 1882 1882 if (!init_done(zram)) 1883 1883 return -EINVAL; 1884 1884 ··· 1893 1893 struct zram *zram = dev_to_zram(dev); 1894 1894 ssize_t ret; 1895 1895 1896 - guard(rwsem_read)(&zram->init_lock); 1896 + guard(rwsem_read)(&zram->dev_lock); 1897 1897 ret = sysfs_emit(buf, 1898 1898 "%8llu %8llu 0 %8llu\n", 1899 1899 (u64)atomic64_read(&zram->stats.failed_reads), ··· 1914 1914 1915 1915 memset(&pool_stats, 0x00, sizeof(struct zs_pool_stats)); 1916 1916 1917 - guard(rwsem_read)(&zram->init_lock); 1917 + guard(rwsem_read)(&zram->dev_lock); 1918 1918 if (init_done(zram)) { 1919 1919 mem_used = zs_get_total_pages(zram->mem_pool); 1920 1920 zs_pool_stats(zram->mem_pool, &pool_stats); ··· 1945 1945 struct zram *zram = dev_to_zram(dev); 1946 1946 ssize_t ret; 1947 1947 1948 - guard(rwsem_read)(&zram->init_lock); 1948 + guard(rwsem_read)(&zram->dev_lock); 1949 1949 ret = sysfs_emit(buf, 1950 1950 "version: %d\n0 %8llu\n", 1951 1951 version, ··· 2611 2611 if (threshold >= huge_class_size) 2612 2612 return -EINVAL; 2613 2613 2614 - guard(rwsem_write)(&zram->init_lock); 2614 + guard(rwsem_write)(&zram->dev_lock); 2615 2615 if (!init_done(zram)) 2616 2616 return -EINVAL; 2617 2617 ··· 2863 2863 2864 2864 static void zram_reset_device(struct zram *zram) 2865 2865 { 2866 - guard(rwsem_write)(&zram->init_lock); 2866 + guard(rwsem_write)(&zram->dev_lock); 2867 2867 2868 2868 zram->limit_pages = 0; 2869 2869 ··· 2893 2893 if (!disksize) 2894 2894 return -EINVAL; 2895 2895 2896 - guard(rwsem_write)(&zram->init_lock); 2896 + guard(rwsem_write)(&zram->dev_lock); 2897 2897 if (init_done(zram)) { 2898 2898 pr_info("Cannot change disksize for initialized device\n"); 2899 2899 return -EBUSY; ··· 3088 3088 goto out_free_dev; 3089 3089 device_id = ret; 3090 3090 3091 - init_rwsem(&zram->init_lock); 3091 + init_rwsem(&zram->dev_lock); 3092 3092 #ifdef CONFIG_ZRAM_WRITEBACK 3093 3093 zram->wb_batch_size = 32; 3094 3094 zram->wb_compressed = false;
+2 -2
drivers/block/zram/zram_drv.h
··· 111 111 struct zcomp *comps[ZRAM_MAX_COMPS]; 112 112 struct zcomp_params params[ZRAM_MAX_COMPS]; 113 113 struct gendisk *disk; 114 - /* Prevent concurrent execution of device init */ 115 - struct rw_semaphore init_lock; 114 + /* Locks the device either in exclusive or in shared mode */ 115 + struct rw_semaphore dev_lock; 116 116 /* 117 117 * the number of pages zram can consume for storing compressed data 118 118 */