zram: switch to guard() for init_lock · tjh.dev/kernel@0d38260

+77 -134

1 changed file

expand all

drivers

block

zram

zram_drv.c

+77 -134

drivers/block/zram/zram_drv.c

··· 360 360 return true; 361 361 } 362 362 363 - static ssize_t initstate_show(struct device *dev, 364 - struct device_attribute *attr, char *buf) 363 + static ssize_t initstate_show(struct device *dev, struct device_attribute *attr, 364 + char *buf) 365 365 { 366 366 u32 val; 367 367 struct zram *zram = dev_to_zram(dev); 368 368 369 - down_read(&zram->init_lock); 369 + guard(rwsem_read)(&zram->init_lock); 370 370 val = init_done(zram); 371 - up_read(&zram->init_lock); 372 371 373 372 return sysfs_emit(buf, "%u\n", val); 374 373 } ··· 381 382 } 382 383 383 384 static ssize_t mem_limit_store(struct device *dev, 384 - struct device_attribute *attr, const char *buf, size_t len) 385 + struct device_attribute *attr, const char *buf, 386 + size_t len) 385 387 { 386 388 u64 limit; 387 389 char *tmp; ··· 392 392 if (buf == tmp) /* no chars parsed, invalid input */ 393 393 return -EINVAL; 394 394 395 - down_write(&zram->init_lock); 395 + guard(rwsem_write)(&zram->init_lock); 396 396 zram->limit_pages = PAGE_ALIGN(limit) >> PAGE_SHIFT; 397 - up_write(&zram->init_lock); 398 397 399 398 return len; 400 399 } 401 400 402 401 static ssize_t mem_used_max_store(struct device *dev, 403 - struct device_attribute *attr, const char *buf, size_t len) 402 + struct device_attribute *attr, 403 + const char *buf, size_t len) 404 404 { 405 405 int err; 406 406 unsigned long val; ··· 410 410 if (err || val != 0) 411 411 return -EINVAL; 412 412 413 - down_read(&zram->init_lock); 413 + guard(rwsem_read)(&zram->init_lock); 414 414 if (init_done(zram)) { 415 415 atomic_long_set(&zram->stats.max_used_pages, 416 416 zs_get_total_pages(zram->mem_pool)); 417 417 } 418 - up_read(&zram->init_lock); 419 418 420 419 return len; 421 420 } ··· 457 458 } 458 459 } 459 460 460 - static ssize_t idle_store(struct device *dev, 461 - struct device_attribute *attr, const char *buf, size_t len) 461 + static ssize_t idle_store(struct device *dev, struct device_attribute *attr, 462 + const char *buf, size_t len) 462 463 { 463 464 struct zram *zram = dev_to_zram(dev); 464 465 ktime_t cutoff_time = 0; 465 - ssize_t rv = -EINVAL; 466 466 467 467 if (!sysfs_streq(buf, "all")) { 468 468 /* ··· 474 476 cutoff_time = ktime_sub(ktime_get_boottime(), 475 477 ns_to_ktime(age_sec * NSEC_PER_SEC)); 476 478 else 477 - goto out; 479 + return -EINVAL; 478 480 } 479 481 480 - down_read(&zram->init_lock); 482 + guard(rwsem_read)(&zram->init_lock); 481 483 if (!init_done(zram)) 482 - goto out_unlock; 484 + return -EINVAL; 483 485 484 486 /* 485 487 * A cutoff_time of 0 marks everything as idle, this is the 486 488 * "all" behavior. 487 489 */ 488 490 mark_idle(zram, cutoff_time); 489 - rv = len; 490 - 491 - out_unlock: 492 - up_read(&zram->init_lock); 493 - out: 494 - return rv; 491 + return len; 495 492 } 496 493 497 494 #ifdef CONFIG_ZRAM_WRITEBACK ··· 539 546 struct zram *zram = dev_to_zram(dev); 540 547 ssize_t ret; 541 548 542 - down_read(&zram->init_lock); 549 + guard(rwsem_read)(&zram->init_lock); 543 550 ret = sysfs_emit(buf, 544 551 "%8llu %8llu %8llu\n", 545 552 FOUR_K((u64)atomic64_read(&zram->stats.bd_count)), 546 553 FOUR_K((u64)atomic64_read(&zram->stats.bd_reads)), 547 554 FOUR_K((u64)atomic64_read(&zram->stats.bd_writes))); 548 - up_read(&zram->init_lock); 549 555 550 556 return ret; 551 557 } ··· 559 567 if (kstrtobool(buf, &val)) 560 568 return -EINVAL; 561 569 562 - down_write(&zram->init_lock); 570 + guard(rwsem_write)(&zram->init_lock); 563 571 if (init_done(zram)) { 564 - up_write(&zram->init_lock); 565 572 return -EBUSY; 566 573 } 567 574 568 575 zram->wb_compressed = val; 569 - up_write(&zram->init_lock); 570 576 571 577 return len; 572 578 } ··· 576 586 bool val; 577 587 struct zram *zram = dev_to_zram(dev); 578 588 579 - down_read(&zram->init_lock); 589 + guard(rwsem_read)(&zram->init_lock); 580 590 val = zram->wb_compressed; 581 - up_read(&zram->init_lock); 582 591 583 592 return sysfs_emit(buf, "%d\n", val); 584 593 } ··· 588 599 { 589 600 struct zram *zram = dev_to_zram(dev); 590 601 u64 val; 591 - ssize_t ret = -EINVAL; 592 602 593 603 if (kstrtoull(buf, 10, &val)) 594 - return ret; 604 + return -EINVAL; 595 605 596 - down_write(&zram->init_lock); 606 + guard(rwsem_write)(&zram->init_lock); 597 607 zram->wb_limit_enable = val; 598 - up_write(&zram->init_lock); 599 - ret = len; 600 608 601 - return ret; 609 + return len; 602 610 } 603 611 604 612 static ssize_t writeback_limit_enable_show(struct device *dev, ··· 605 619 bool val; 606 620 struct zram *zram = dev_to_zram(dev); 607 621 608 - down_read(&zram->init_lock); 622 + guard(rwsem_read)(&zram->init_lock); 609 623 val = zram->wb_limit_enable; 610 - up_read(&zram->init_lock); 611 624 612 625 return sysfs_emit(buf, "%d\n", val); 613 626 } ··· 617 632 { 618 633 struct zram *zram = dev_to_zram(dev); 619 634 u64 val; 620 - ssize_t ret = -EINVAL; 621 635 622 636 if (kstrtoull(buf, 10, &val)) 623 - return ret; 637 + return -EINVAL; 624 638 625 639 /* 626 640 * When the page size is greater than 4KB, if bd_wb_limit is set to ··· 631 647 */ 632 648 val = rounddown(val, PAGE_SIZE / 4096); 633 649 634 - down_write(&zram->init_lock); 650 + guard(rwsem_write)(&zram->init_lock); 635 651 zram->bd_wb_limit = val; 636 - up_write(&zram->init_lock); 637 - ret = len; 638 652 639 - return ret; 653 + return len; 640 654 } 641 655 642 656 static ssize_t writeback_limit_show(struct device *dev, ··· 643 661 u64 val; 644 662 struct zram *zram = dev_to_zram(dev); 645 663 646 - down_read(&zram->init_lock); 664 + guard(rwsem_read)(&zram->init_lock); 647 665 val = zram->bd_wb_limit; 648 - up_read(&zram->init_lock); 649 666 650 667 return sysfs_emit(buf, "%llu\n", val); 651 668 } ··· 662 681 if (!val) 663 682 return -EINVAL; 664 683 665 - down_write(&zram->init_lock); 684 + guard(rwsem_write)(&zram->init_lock); 666 685 zram->wb_batch_size = val; 667 - up_write(&zram->init_lock); 668 686 669 687 return len; 670 688 } ··· 675 695 u32 val; 676 696 struct zram *zram = dev_to_zram(dev); 677 697 678 - down_read(&zram->init_lock); 698 + guard(rwsem_read)(&zram->init_lock); 679 699 val = zram->wb_batch_size; 680 - up_read(&zram->init_lock); 681 700 682 701 return sysfs_emit(buf, "%u\n", val); 683 702 } ··· 696 717 } 697 718 698 719 static ssize_t backing_dev_show(struct device *dev, 699 - struct device_attribute *attr, char *buf) 720 + struct device_attribute *attr, char *buf) 700 721 { 701 722 struct file *file; 702 723 struct zram *zram = dev_to_zram(dev); 703 724 char *p; 704 725 ssize_t ret; 705 726 706 - down_read(&zram->init_lock); 727 + guard(rwsem_read)(&zram->init_lock); 707 728 file = zram->backing_dev; 708 729 if (!file) { 709 730 memcpy(buf, "none\n", 5); 710 - up_read(&zram->init_lock); 711 731 return 5; 712 732 } 713 733 714 734 p = file_path(file, buf, PAGE_SIZE - 1); 715 - if (IS_ERR(p)) { 716 - ret = PTR_ERR(p); 717 - goto out; 718 - } 735 + if (IS_ERR(p)) 736 + return PTR_ERR(p); 719 737 720 738 ret = strlen(p); 721 739 memmove(buf, p, ret); 722 740 buf[ret++] = '\n'; 723 - out: 724 - up_read(&zram->init_lock); 725 741 return ret; 726 742 } 727 743 728 744 static ssize_t backing_dev_store(struct device *dev, 729 - struct device_attribute *attr, const char *buf, size_t len) 745 + struct device_attribute *attr, const char *buf, 746 + size_t len) 730 747 { 731 748 char *file_name; 732 749 size_t sz; ··· 737 762 if (!file_name) 738 763 return -ENOMEM; 739 764 740 - down_write(&zram->init_lock); 765 + guard(rwsem_write)(&zram->init_lock); 741 766 if (init_done(zram)) { 742 767 pr_info("Can't setup backing device for initialized device\n"); 743 768 err = -EBUSY; ··· 785 810 zram->backing_dev = backing_dev; 786 811 zram->bitmap = bitmap; 787 812 zram->nr_pages = nr_pages; 788 - up_write(&zram->init_lock); 789 813 790 814 pr_info("setup backing device %s\n", file_name); 791 815 kfree(file_name); ··· 795 821 796 822 if (backing_dev) 797 823 filp_close(backing_dev, NULL); 798 - 799 - up_write(&zram->init_lock); 800 824 801 825 kfree(file_name); 802 826 ··· 1263 1291 ssize_t ret = len; 1264 1292 int err, mode = 0; 1265 1293 1266 - down_read(&zram->init_lock); 1267 - if (!init_done(zram)) { 1268 - up_read(&zram->init_lock); 1294 + guard(rwsem_read)(&zram->init_lock); 1295 + if (!init_done(zram)) 1269 1296 return -EINVAL; 1270 - } 1271 1297 1272 1298 /* Do not permit concurrent post-processing actions. */ 1273 - if (atomic_xchg(&zram->pp_in_progress, 1)) { 1274 - up_read(&zram->init_lock); 1299 + if (atomic_xchg(&zram->pp_in_progress, 1)) 1275 1300 return -EAGAIN; 1276 - } 1277 1301 1278 1302 if (!zram->backing_dev) { 1279 1303 ret = -ENODEV; 1280 - goto release_init_lock; 1304 + goto out; 1281 1305 } 1282 1306 1283 1307 pp_ctl = init_pp_ctl(); 1284 1308 if (!pp_ctl) { 1285 1309 ret = -ENOMEM; 1286 - goto release_init_lock; 1310 + goto out; 1287 1311 } 1288 1312 1289 1313 wb_ctl = init_wb_ctl(zram); 1290 1314 if (!wb_ctl) { 1291 1315 ret = -ENOMEM; 1292 - goto release_init_lock; 1316 + goto out; 1293 1317 } 1294 1318 1295 1319 args = skip_spaces(buf); ··· 1309 1341 err = parse_mode(param, &mode); 1310 1342 if (err) { 1311 1343 ret = err; 1312 - goto release_init_lock; 1344 + goto out; 1313 1345 } 1314 1346 1315 1347 scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); ··· 1320 1352 err = parse_mode(val, &mode); 1321 1353 if (err) { 1322 1354 ret = err; 1323 - goto release_init_lock; 1355 + goto out; 1324 1356 } 1325 1357 1326 1358 scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); ··· 1331 1363 err = parse_page_index(val, nr_pages, &lo, &hi); 1332 1364 if (err) { 1333 1365 ret = err; 1334 - goto release_init_lock; 1366 + goto out; 1335 1367 } 1336 1368 1337 1369 scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); ··· 1342 1374 err = parse_page_indexes(val, nr_pages, &lo, &hi); 1343 1375 if (err) { 1344 1376 ret = err; 1345 - goto release_init_lock; 1377 + goto out; 1346 1378 } 1347 1379 1348 1380 scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); ··· 1354 1386 if (err) 1355 1387 ret = err; 1356 1388 1357 - release_init_lock: 1389 + out: 1358 1390 release_pp_ctl(zram, pp_ctl); 1359 1391 release_wb_ctl(wb_ctl); 1360 1392 atomic_set(&zram->pp_in_progress, 0); 1361 - up_read(&zram->init_lock); 1362 1393 1363 1394 return ret; 1364 1395 } ··· 1575 1608 if (!kbuf) 1576 1609 return -ENOMEM; 1577 1610 1578 - down_read(&zram->init_lock); 1611 + guard(rwsem_read)(&zram->init_lock); 1579 1612 if (!init_done(zram)) { 1580 - up_read(&zram->init_lock); 1581 1613 kvfree(kbuf); 1582 1614 return -EINVAL; 1583 1615 } ··· 1612 1646 *ppos += 1; 1613 1647 } 1614 1648 1615 - up_read(&zram->init_lock); 1616 1649 if (copy_to_user(buf, kbuf, written)) 1617 1650 written = -EFAULT; 1618 1651 kvfree(kbuf); ··· 1678 1713 return -EINVAL; 1679 1714 } 1680 1715 1681 - down_write(&zram->init_lock); 1716 + guard(rwsem_write)(&zram->init_lock); 1682 1717 if (init_done(zram)) { 1683 - up_write(&zram->init_lock); 1684 1718 kfree(compressor); 1685 1719 pr_info("Can't change algorithm for initialized device\n"); 1686 1720 return -EBUSY; 1687 1721 } 1688 1722 1689 1723 comp_algorithm_set(zram, prio, compressor); 1690 - up_write(&zram->init_lock); 1691 1724 return 0; 1692 1725 } 1693 1726 ··· 1806 1843 struct zram *zram = dev_to_zram(dev); 1807 1844 ssize_t sz; 1808 1845 1809 - down_read(&zram->init_lock); 1846 + guard(rwsem_read)(&zram->init_lock); 1810 1847 sz = zcomp_available_show(zram->comp_algs[ZRAM_PRIMARY_COMP], buf, 0); 1811 - up_read(&zram->init_lock); 1812 1848 return sz; 1813 1849 } 1814 1850 ··· 1832 1870 ssize_t sz = 0; 1833 1871 u32 prio; 1834 1872 1835 - down_read(&zram->init_lock); 1873 + guard(rwsem_read)(&zram->init_lock); 1836 1874 for (prio = ZRAM_SECONDARY_COMP; prio < ZRAM_MAX_COMPS; prio++) { 1837 1875 if (!zram->comp_algs[prio]) 1838 1876 continue; ··· 1840 1878 sz += sysfs_emit_at(buf, sz, "#%d: ", prio); 1841 1879 sz += zcomp_available_show(zram->comp_algs[prio], buf, sz); 1842 1880 } 1843 - up_read(&zram->init_lock); 1844 1881 return sz; 1845 1882 } 1846 1883 ··· 1885 1924 } 1886 1925 #endif 1887 1926 1888 - static ssize_t compact_store(struct device *dev, 1889 - struct device_attribute *attr, const char *buf, size_t len) 1927 + static ssize_t compact_store(struct device *dev, struct device_attribute *attr, 1928 + const char *buf, size_t len) 1890 1929 { 1891 1930 struct zram *zram = dev_to_zram(dev); 1892 1931 1893 - down_read(&zram->init_lock); 1894 - if (!init_done(zram)) { 1895 - up_read(&zram->init_lock); 1932 + guard(rwsem_read)(&zram->init_lock); 1933 + if (!init_done(zram)) 1896 1934 return -EINVAL; 1897 - } 1898 1935 1899 1936 zs_compact(zram->mem_pool); 1900 - up_read(&zram->init_lock); 1901 1937 1902 1938 return len; 1903 1939 } 1904 1940 1905 - static ssize_t io_stat_show(struct device *dev, 1906 - struct device_attribute *attr, char *buf) 1941 + static ssize_t io_stat_show(struct device *dev, struct device_attribute *attr, 1942 + char *buf) 1907 1943 { 1908 1944 struct zram *zram = dev_to_zram(dev); 1909 1945 ssize_t ret; 1910 1946 1911 - down_read(&zram->init_lock); 1947 + guard(rwsem_read)(&zram->init_lock); 1912 1948 ret = sysfs_emit(buf, 1913 1949 "%8llu %8llu 0 %8llu\n", 1914 1950 (u64)atomic64_read(&zram->stats.failed_reads), 1915 1951 (u64)atomic64_read(&zram->stats.failed_writes), 1916 1952 (u64)atomic64_read(&zram->stats.notify_free)); 1917 - up_read(&zram->init_lock); 1918 1953 1919 1954 return ret; 1920 1955 } 1921 1956 1922 - static ssize_t mm_stat_show(struct device *dev, 1923 - struct device_attribute *attr, char *buf) 1957 + static ssize_t mm_stat_show(struct device *dev, struct device_attribute *attr, 1958 + char *buf) 1924 1959 { 1925 1960 struct zram *zram = dev_to_zram(dev); 1926 1961 struct zs_pool_stats pool_stats; ··· 1926 1969 1927 1970 memset(&pool_stats, 0x00, sizeof(struct zs_pool_stats)); 1928 1971 1929 - down_read(&zram->init_lock); 1972 + guard(rwsem_read)(&zram->init_lock); 1930 1973 if (init_done(zram)) { 1931 1974 mem_used = zs_get_total_pages(zram->mem_pool); 1932 1975 zs_pool_stats(zram->mem_pool, &pool_stats); ··· 1946 1989 atomic_long_read(&pool_stats.pages_compacted), 1947 1990 (u64)atomic64_read(&zram->stats.huge_pages), 1948 1991 (u64)atomic64_read(&zram->stats.huge_pages_since)); 1949 - up_read(&zram->init_lock); 1950 1992 1951 1993 return ret; 1952 1994 } ··· 1957 2001 struct zram *zram = dev_to_zram(dev); 1958 2002 ssize_t ret; 1959 2003 1960 - down_read(&zram->init_lock); 2004 + guard(rwsem_read)(&zram->init_lock); 1961 2005 ret = sysfs_emit(buf, 1962 2006 "version: %d\n0 %8llu\n", 1963 2007 version, 1964 2008 (u64)atomic64_read(&zram->stats.miss_free)); 1965 - up_read(&zram->init_lock); 1966 2009 1967 2010 return ret; 1968 2011 } ··· 2624 2669 if (threshold >= huge_class_size) 2625 2670 return -EINVAL; 2626 2671 2627 - down_read(&zram->init_lock); 2628 - if (!init_done(zram)) { 2629 - ret = -EINVAL; 2630 - goto release_init_lock; 2631 - } 2672 + guard(rwsem_read)(&zram->init_lock); 2673 + if (!init_done(zram)) 2674 + return -EINVAL; 2632 2675 2633 2676 /* Do not permit concurrent post-processing actions. */ 2634 - if (atomic_xchg(&zram->pp_in_progress, 1)) { 2635 - up_read(&zram->init_lock); 2677 + if (atomic_xchg(&zram->pp_in_progress, 1)) 2636 2678 return -EAGAIN; 2637 - } 2638 2679 2639 2680 if (algo) { 2640 2681 bool found = false; ··· 2648 2697 2649 2698 if (!found) { 2650 2699 ret = -EINVAL; 2651 - goto release_init_lock; 2700 + goto out; 2652 2701 } 2653 2702 } 2654 2703 2655 2704 prio_max = min(prio_max, (u32)zram->num_active_comps); 2656 2705 if (prio >= prio_max) { 2657 2706 ret = -EINVAL; 2658 - goto release_init_lock; 2707 + goto out; 2659 2708 } 2660 2709 2661 2710 page = alloc_page(GFP_KERNEL); 2662 2711 if (!page) { 2663 2712 ret = -ENOMEM; 2664 - goto release_init_lock; 2713 + goto out; 2665 2714 } 2666 2715 2667 2716 ctl = init_pp_ctl(); 2668 2717 if (!ctl) { 2669 2718 ret = -ENOMEM; 2670 - goto release_init_lock; 2719 + goto out; 2671 2720 } 2672 2721 2673 2722 scan_slots_for_recompress(zram, mode, prio_max, ctl); ··· 2698 2747 cond_resched(); 2699 2748 } 2700 2749 2701 - release_init_lock: 2750 + out: 2702 2751 if (page) 2703 2752 __free_page(page); 2704 2753 release_pp_ctl(zram, ctl); 2705 2754 atomic_set(&zram->pp_in_progress, 0); 2706 - up_read(&zram->init_lock); 2707 2755 return ret; 2708 2756 } 2709 2757 #endif ··· 2881 2931 2882 2932 static void zram_reset_device(struct zram *zram) 2883 2933 { 2884 - down_write(&zram->init_lock); 2934 + guard(rwsem_write)(&zram->init_lock); 2885 2935 2886 2936 zram->limit_pages = 0; 2887 2937 ··· 2897 2947 reset_bdev(zram); 2898 2948 2899 2949 comp_algorithm_set(zram, ZRAM_PRIMARY_COMP, default_compressor); 2900 - up_write(&zram->init_lock); 2901 2950 } 2902 2951 2903 - static ssize_t disksize_store(struct device *dev, 2904 - struct device_attribute *attr, const char *buf, size_t len) 2952 + static ssize_t disksize_store(struct device *dev, struct device_attribute *attr, 2953 + const char *buf, size_t len) 2905 2954 { 2906 2955 u64 disksize; 2907 2956 struct zcomp *comp; ··· 2912 2963 if (!disksize) 2913 2964 return -EINVAL; 2914 2965 2915 - down_write(&zram->init_lock); 2966 + guard(rwsem_write)(&zram->init_lock); 2916 2967 if (init_done(zram)) { 2917 2968 pr_info("Cannot change disksize for initialized device\n"); 2918 - err = -EBUSY; 2919 - goto out_unlock; 2969 + return -EBUSY; 2920 2970 } 2921 2971 2922 2972 disksize = PAGE_ALIGN(disksize); 2923 - if (!zram_meta_alloc(zram, disksize)) { 2924 - err = -ENOMEM; 2925 - goto out_unlock; 2926 - } 2973 + if (!zram_meta_alloc(zram, disksize)) 2974 + return -ENOMEM; 2927 2975 2928 2976 for (prio = ZRAM_PRIMARY_COMP; prio < ZRAM_MAX_COMPS; prio++) { 2929 2977 if (!zram->comp_algs[prio]) ··· 2940 2994 } 2941 2995 zram->disksize = disksize; 2942 2996 set_capacity_and_notify(zram->disk, zram->disksize >> SECTOR_SHIFT); 2943 - up_write(&zram->init_lock); 2944 2997 2945 2998 return len; 2946 2999 2947 3000 out_free_comps: 2948 3001 zram_destroy_comps(zram); 2949 3002 zram_meta_free(zram, disksize); 2950 - out_unlock: 2951 - up_write(&zram->init_lock); 2952 3003 return err; 2953 3004 } 2954 3005

Configure Feed

Configure Feed