Lines Matching defs:zram
15 #define KMSG_COMPONENT "zram"
62 static void zram_free_page(struct zram *zram, size_t index);
63 static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
66 static inline bool init_done(struct zram *zram)
68 return zram->disksize;
71 static inline struct zram *dev_to_zram(struct device *dev)
73 return (struct zram *)dev_to_disk(dev)->private_data;
76 static inline void zram_set_element(struct zram *zram, u32 index,
79 zram->table[index].element = element;
82 static unsigned long zram_get_element(struct zram *zram, u32 index)
84 return zram->table[index].element;
87 static inline bool zram_allocated(struct zram *zram, u32 index)
89 return zram_get_obj_size(zram, index) ||
90 zram_test_flag(zram, index, ZRAM_SAME) ||
91 zram_test_flag(zram, index, ZRAM_WB);
107 * Check if request is within bounds and aligned on zram logical blocks.
109 static inline bool valid_io_request(struct zram *zram,
121 bound = zram->disksize >> SECTOR_SHIFT;
136 static inline void update_used_max(struct zram *zram,
141 old_max = atomic_long_read(&zram->stats.max_used_pages);
147 &zram->stats.max_used_pages, cur_max, pages);
184 struct zram *zram = dev_to_zram(dev);
186 down_read(&zram->init_lock);
187 val = init_done(zram);
188 up_read(&zram->init_lock);
196 struct zram *zram = dev_to_zram(dev);
198 return scnprintf(buf, PAGE_SIZE, "%llu\n", zram->disksize);
206 struct zram *zram = dev_to_zram(dev);
212 down_write(&zram->init_lock);
213 zram->limit_pages = PAGE_ALIGN(limit) >> PAGE_SHIFT;
214 up_write(&zram->init_lock);
224 struct zram *zram = dev_to_zram(dev);
230 down_read(&zram->init_lock);
231 if (init_done(zram)) {
232 atomic_long_set(&zram->stats.max_used_pages,
233 zs_get_total_pages(zram->mem_pool));
235 up_read(&zram->init_lock);
243 struct zram *zram = dev_to_zram(dev);
244 unsigned long nr_pages = zram->disksize >> PAGE_SHIFT;
250 down_read(&zram->init_lock);
251 if (!init_done(zram)) {
252 up_read(&zram->init_lock);
261 zram_slot_lock(zram, index);
262 if (zram_allocated(zram, index) &&
263 !zram_test_flag(zram, index, ZRAM_UNDER_WB))
264 zram_set_flag(zram, index, ZRAM_IDLE);
265 zram_slot_unlock(zram, index);
268 up_read(&zram->init_lock);
277 struct zram *zram = dev_to_zram(dev);
284 down_read(&zram->init_lock);
285 spin_lock(&zram->wb_limit_lock);
286 zram->wb_limit_enable = val;
287 spin_unlock(&zram->wb_limit_lock);
288 up_read(&zram->init_lock);
298 struct zram *zram = dev_to_zram(dev);
300 down_read(&zram->init_lock);
301 spin_lock(&zram->wb_limit_lock);
302 val = zram->wb_limit_enable;
303 spin_unlock(&zram->wb_limit_lock);
304 up_read(&zram->init_lock);
312 struct zram *zram = dev_to_zram(dev);
319 down_read(&zram->init_lock);
320 spin_lock(&zram->wb_limit_lock);
321 zram->bd_wb_limit = val;
322 spin_unlock(&zram->wb_limit_lock);
323 up_read(&zram->init_lock);
333 struct zram *zram = dev_to_zram(dev);
335 down_read(&zram->init_lock);
336 spin_lock(&zram->wb_limit_lock);
337 val = zram->bd_wb_limit;
338 spin_unlock(&zram->wb_limit_lock);
339 up_read(&zram->init_lock);
344 static void reset_bdev(struct zram *zram)
348 if (!zram->backing_dev)
351 bdev = zram->bdev;
352 if (zram->old_block_size)
353 set_blocksize(bdev, zram->old_block_size);
356 filp_close(zram->backing_dev, NULL);
357 zram->backing_dev = NULL;
358 zram->old_block_size = 0;
359 zram->bdev = NULL;
360 zram->disk->fops = &zram_devops;
361 kvfree(zram->bitmap);
362 zram->bitmap = NULL;
369 struct zram *zram = dev_to_zram(dev);
373 down_read(&zram->init_lock);
374 file = zram->backing_dev;
377 up_read(&zram->init_lock);
391 up_read(&zram->init_lock);
407 struct zram *zram = dev_to_zram(dev);
413 down_write(&zram->init_lock);
414 if (init_done(zram)) {
443 FMODE_READ | FMODE_WRITE | FMODE_EXCL, zram);
463 reset_bdev(zram);
465 zram->old_block_size = old_block_size;
466 zram->bdev = bdev;
467 zram->backing_dev = backing_dev;
468 zram->bitmap = bitmap;
469 zram->nr_pages = nr_pages;
471 * With writeback feature, zram does asynchronous IO so it's no longer
480 zram->disk->fops = &zram_wb_devops;
481 up_write(&zram->init_lock);
497 up_write(&zram->init_lock);
504 static unsigned long alloc_block_bdev(struct zram *zram)
508 /* skip 0 bit to confuse zram.handle = 0 */
509 blk_idx = find_next_zero_bit(zram->bitmap, zram->nr_pages, blk_idx);
510 if (blk_idx == zram->nr_pages)
513 if (test_and_set_bit(blk_idx, zram->bitmap))
516 atomic64_inc(&zram->stats.bd_count);
520 static void free_block_bdev(struct zram *zram, unsigned long blk_idx)
524 was_set = test_and_clear_bit(blk_idx, zram->bitmap);
526 atomic64_dec(&zram->stats.bd_count);
541 static int read_from_bdev_async(struct zram *zram, struct bio_vec *bvec,
551 bio_set_dev(bio, zram->bdev);
575 struct zram *zram = dev_to_zram(dev);
576 unsigned long nr_pages = zram->disksize >> PAGE_SHIFT;
592 down_read(&zram->init_lock);
593 if (!init_done(zram)) {
598 if (!zram->backing_dev) {
616 spin_lock(&zram->wb_limit_lock);
617 if (zram->wb_limit_enable && !zram->bd_wb_limit) {
618 spin_unlock(&zram->wb_limit_lock);
622 spin_unlock(&zram->wb_limit_lock);
625 blk_idx = alloc_block_bdev(zram);
632 zram_slot_lock(zram, index);
633 if (!zram_allocated(zram, index))
636 if (zram_test_flag(zram, index, ZRAM_WB) ||
637 zram_test_flag(zram, index, ZRAM_SAME) ||
638 zram_test_flag(zram, index, ZRAM_UNDER_WB))
642 !zram_test_flag(zram, index, ZRAM_IDLE))
645 !zram_test_flag(zram, index, ZRAM_HUGE))
651 zram_set_flag(zram, index, ZRAM_UNDER_WB);
653 zram_set_flag(zram, index, ZRAM_IDLE);
654 zram_slot_unlock(zram, index);
655 if (zram_bvec_read(zram, &bvec, index, 0, NULL)) {
656 zram_slot_lock(zram, index);
657 zram_clear_flag(zram, index, ZRAM_UNDER_WB);
658 zram_clear_flag(zram, index, ZRAM_IDLE);
659 zram_slot_unlock(zram, index);
664 bio_set_dev(&bio, zram->bdev);
676 zram_slot_lock(zram, index);
677 zram_clear_flag(zram, index, ZRAM_UNDER_WB);
678 zram_clear_flag(zram, index, ZRAM_IDLE);
679 zram_slot_unlock(zram, index);
688 atomic64_inc(&zram->stats.bd_writes);
698 zram_slot_lock(zram, index);
699 if (!zram_allocated(zram, index) ||
700 !zram_test_flag(zram, index, ZRAM_IDLE)) {
701 zram_clear_flag(zram, index, ZRAM_UNDER_WB);
702 zram_clear_flag(zram, index, ZRAM_IDLE);
706 zram_free_page(zram, index);
707 zram_clear_flag(zram, index, ZRAM_UNDER_WB);
708 zram_set_flag(zram, index, ZRAM_WB);
709 zram_set_element(zram, index, blk_idx);
711 atomic64_inc(&zram->stats.pages_stored);
712 spin_lock(&zram->wb_limit_lock);
713 if (zram->wb_limit_enable && zram->bd_wb_limit > 0)
714 zram->bd_wb_limit -= 1UL << (PAGE_SHIFT - 12);
715 spin_unlock(&zram->wb_limit_lock);
717 zram_slot_unlock(zram, index);
721 free_block_bdev(zram, blk_idx);
724 up_read(&zram->init_lock);
731 struct zram *zram;
741 struct zram *zram = zw->zram;
745 read_from_bdev_async(zram, &zw->bvec, entry, bio);
753 static int read_from_bdev_sync(struct zram *zram, struct bio_vec *bvec,
759 work.zram = zram;
771 static int read_from_bdev_sync(struct zram *zram, struct bio_vec *bvec,
779 static int read_from_bdev(struct zram *zram, struct bio_vec *bvec,
782 atomic64_inc(&zram->stats.bd_reads);
784 return read_from_bdev_sync(zram, bvec, entry, parent);
786 return read_from_bdev_async(zram, bvec, entry, parent);
789 static inline void reset_bdev(struct zram *zram) {};
790 static int read_from_bdev(struct zram *zram, struct bio_vec *bvec,
796 static void free_block_bdev(struct zram *zram, unsigned long blk_idx) {};
805 zram_debugfs_root = debugfs_create_dir("zram", NULL);
813 static void zram_accessed(struct zram *zram, u32 index)
815 zram_clear_flag(zram, index, ZRAM_IDLE);
816 zram->table[index].ac_time = ktime_get_boottime();
824 struct zram *zram = file->private_data;
825 unsigned long nr_pages = zram->disksize >> PAGE_SHIFT;
832 down_read(&zram->init_lock);
833 if (!init_done(zram)) {
834 up_read(&zram->init_lock);
842 zram_slot_lock(zram, index);
843 if (!zram_allocated(zram, index))
846 ts = ktime_to_timespec64(zram->table[index].ac_time);
851 zram_test_flag(zram, index, ZRAM_SAME) ? 's' : '.',
852 zram_test_flag(zram, index, ZRAM_WB) ? 'w' : '.',
853 zram_test_flag(zram, index, ZRAM_HUGE) ? 'h' : '.',
854 zram_test_flag(zram, index, ZRAM_IDLE) ? 'i' : '.');
857 zram_slot_unlock(zram, index);
863 zram_slot_unlock(zram, index);
867 up_read(&zram->init_lock);
881 static void zram_debugfs_register(struct zram *zram)
886 zram->debugfs_dir = debugfs_create_dir(zram->disk->disk_name,
888 debugfs_create_file("block_state", 0400, zram->debugfs_dir,
889 zram, &proc_zram_block_state_op);
892 static void zram_debugfs_unregister(struct zram *zram)
894 debugfs_remove_recursive(zram->debugfs_dir);
899 static void zram_accessed(struct zram *zram, u32 index)
901 zram_clear_flag(zram, index, ZRAM_IDLE);
903 static void zram_debugfs_register(struct zram *zram) {};
904 static void zram_debugfs_unregister(struct zram *zram) {};
932 struct zram *zram = dev_to_zram(dev);
934 down_read(&zram->init_lock);
935 sz = zcomp_available_show(zram->compressor, buf);
936 up_read(&zram->init_lock);
944 struct zram *zram = dev_to_zram(dev);
945 char compressor[ARRAY_SIZE(zram->compressor)];
957 down_write(&zram->init_lock);
958 if (init_done(zram)) {
959 up_write(&zram->init_lock);
964 strcpy(zram->compressor, compressor);
965 up_write(&zram->init_lock);
972 struct zram *zram = dev_to_zram(dev);
974 down_read(&zram->init_lock);
975 if (!init_done(zram)) {
976 up_read(&zram->init_lock);
980 zs_compact(zram->mem_pool);
981 up_read(&zram->init_lock);
989 struct zram *zram = dev_to_zram(dev);
992 down_read(&zram->init_lock);
995 (u64)atomic64_read(&zram->stats.failed_reads),
996 (u64)atomic64_read(&zram->stats.failed_writes),
997 (u64)atomic64_read(&zram->stats.invalid_io),
998 (u64)atomic64_read(&zram->stats.notify_free));
999 up_read(&zram->init_lock);
1007 struct zram *zram = dev_to_zram(dev);
1015 down_read(&zram->init_lock);
1016 if (init_done(zram)) {
1017 mem_used = zs_get_total_pages(zram->mem_pool);
1018 zs_pool_stats(zram->mem_pool, &pool_stats);
1021 orig_size = atomic64_read(&zram->stats.pages_stored);
1022 max_used = atomic_long_read(&zram->stats.max_used_pages);
1027 (u64)atomic64_read(&zram->stats.compr_data_size),
1029 zram->limit_pages << PAGE_SHIFT,
1031 (u64)atomic64_read(&zram->stats.same_pages),
1033 (u64)atomic64_read(&zram->stats.huge_pages));
1034 up_read(&zram->init_lock);
1044 struct zram *zram = dev_to_zram(dev);
1047 down_read(&zram->init_lock);
1050 FOUR_K((u64)atomic64_read(&zram->stats.bd_count)),
1051 FOUR_K((u64)atomic64_read(&zram->stats.bd_reads)),
1052 FOUR_K((u64)atomic64_read(&zram->stats.bd_writes)));
1053 up_read(&zram->init_lock);
1063 struct zram *zram = dev_to_zram(dev);
1066 down_read(&zram->init_lock);
1070 (u64)atomic64_read(&zram->stats.writestall),
1071 (u64)atomic64_read(&zram->stats.miss_free));
1072 up_read(&zram->init_lock);
1087 struct zram *zram = dev_to_zram(dev);
1089 down_read(&zram->init_lock);
1090 if (zram->zgrp_ctrl == ZGRP_NONE)
1092 else if (zram->zgrp_ctrl == ZGRP_TRACK)
1095 else if (zram->zgrp_ctrl == ZGRP_WRITE)
1098 up_read(&zram->init_lock);
1106 struct zram *zram = dev_to_zram(dev);
1114 group_debug(zram, op, index, gid);
1120 down_write(&zram->init_lock);
1121 if (init_done(zram)) {
1127 zram->zgrp_ctrl = ZGRP_NONE;
1129 zram->zgrp_ctrl = ZGRP_TRACK;
1132 zram->zgrp_ctrl = ZGRP_WRITE;
1137 up_write(&zram->init_lock);
1143 static void zram_meta_free(struct zram *zram, u64 disksize)
1148 /* Free all pages that are still in this zram device */
1150 zram_free_page(zram, index);
1152 zs_destroy_pool(zram->mem_pool);
1153 vfree(zram->table);
1155 zram_group_deinit(zram);
1159 static bool zram_meta_alloc(struct zram *zram, u64 disksize)
1164 zram->table = vzalloc(array_size(num_pages, sizeof(*zram->table)));
1165 if (!zram->table)
1168 zram->mem_pool = zs_create_pool(zram->disk->disk_name);
1169 if (!zram->mem_pool) {
1170 vfree(zram->table);
1175 huge_class_size = zs_huge_class_size(zram->mem_pool);
1177 zram_group_init(zram, num_pages);
1188 static void zram_free_page(struct zram *zram, size_t index)
1193 zram_group_untrack_obj(zram, index);
1197 zram->table[index].ac_time = 0;
1199 if (zram_test_flag(zram, index, ZRAM_IDLE))
1200 zram_clear_flag(zram, index, ZRAM_IDLE);
1202 if (zram_test_flag(zram, index, ZRAM_HUGE)) {
1203 zram_clear_flag(zram, index, ZRAM_HUGE);
1204 atomic64_dec(&zram->stats.huge_pages);
1207 if (zram_test_flag(zram, index, ZRAM_WB)) {
1208 zram_clear_flag(zram, index, ZRAM_WB);
1209 free_block_bdev(zram, zram_get_element(zram, index));
1217 if (zram_test_flag(zram, index, ZRAM_SAME)) {
1218 zram_clear_flag(zram, index, ZRAM_SAME);
1219 atomic64_dec(&zram->stats.same_pages);
1223 handle = zram_get_handle(zram, index);
1227 zs_free(zram->mem_pool, handle);
1229 atomic64_sub(zram_get_obj_size(zram, index),
1230 &zram->stats.compr_data_size);
1232 atomic64_dec(&zram->stats.pages_stored);
1233 zram_set_handle(zram, index, 0);
1234 zram_set_obj_size(zram, index, 0);
1235 WARN_ON_ONCE(zram->table[index].flags &
1239 static int __zram_bvec_read(struct zram *zram, struct page *page, u32 index,
1248 zram_slot_lock(zram, index);
1249 if (zram_test_flag(zram, index, ZRAM_WB)) {
1252 zram_slot_unlock(zram, index);
1257 return read_from_bdev(zram, &bvec,
1258 zram_get_element(zram, index),
1263 ret = zram_group_fault_obj(zram, index);
1265 zram_slot_unlock(zram, index);
1270 if (zram_test_flag(zram, index, ZRAM_GWB)) {
1271 zram_slot_unlock(zram, index);
1275 handle = zram_get_handle(zram, index);
1276 if (!handle || zram_test_flag(zram, index, ZRAM_SAME)) {
1280 value = handle ? zram_get_element(zram, index) : 0;
1284 zram_slot_unlock(zram, index);
1288 size = zram_get_obj_size(zram, index);
1291 zstrm = zcomp_stream_get(zram->comp);
1293 src = zs_map_object(zram->mem_pool, handle, ZS_MM_RO);
1303 zcomp_stream_put(zram->comp);
1305 zs_unmap_object(zram->mem_pool, handle);
1306 zram_slot_unlock(zram, index);
1315 static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
1329 ret = __zram_bvec_read(zram, page, index, bio, is_partial_io(bvec));
1348 static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
1366 atomic64_inc(&zram->stats.same_pages);
1372 zstrm = zcomp_stream_get(zram->comp);
1378 zcomp_stream_put(zram->comp);
1380 zs_free(zram->mem_pool, handle);
1400 handle = zs_malloc(zram->mem_pool, comp_len,
1406 zcomp_stream_put(zram->comp);
1407 atomic64_inc(&zram->stats.writestall);
1408 handle = zs_malloc(zram->mem_pool, comp_len,
1416 alloced_pages = zs_get_total_pages(zram->mem_pool);
1417 update_used_max(zram, alloced_pages);
1419 if (zram->limit_pages && alloced_pages > zram->limit_pages) {
1420 zcomp_stream_put(zram->comp);
1421 zs_free(zram->mem_pool, handle);
1425 dst = zs_map_object(zram->mem_pool, handle, ZS_MM_WO);
1434 zcomp_stream_put(zram->comp);
1435 zs_unmap_object(zram->mem_pool, handle);
1436 atomic64_add(comp_len, &zram->stats.compr_data_size);
1442 zram_slot_lock(zram, index);
1443 zram_free_page(zram, index);
1446 zram_set_flag(zram, index, ZRAM_HUGE);
1447 atomic64_inc(&zram->stats.huge_pages);
1451 zram_set_flag(zram, index, flags);
1452 zram_set_element(zram, index, element);
1454 zram_set_handle(zram, index, handle);
1455 zram_set_obj_size(zram, index, comp_len);
1458 zram_group_track_obj(zram, index, page->mem_cgroup);
1460 zram_slot_unlock(zram, index);
1463 atomic64_inc(&zram->stats.pages_stored);
1467 static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
1486 ret = __zram_bvec_read(zram, page, index, bio, true);
1501 ret = __zram_bvec_write(zram, &vec, index, bio);
1513 static void zram_bio_discard(struct zram *zram, u32 index,
1519 * zram manages data in physical block size units. Because logical block
1537 zram_slot_lock(zram, index);
1538 zram_free_page(zram, index);
1539 zram_slot_unlock(zram, index);
1540 atomic64_inc(&zram->stats.notify_free);
1551 static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
1557 atomic64_inc(&zram->stats.num_reads);
1558 ret = zram_bvec_read(zram, bvec, index, offset, bio);
1561 atomic64_inc(&zram->stats.num_writes);
1562 ret = zram_bvec_write(zram, bvec, index, offset, bio);
1565 zram_slot_lock(zram, index);
1566 zram_accessed(zram, index);
1567 zram_slot_unlock(zram, index);
1571 atomic64_inc(&zram->stats.failed_reads);
1573 atomic64_inc(&zram->stats.failed_writes);
1579 static void __zram_make_request(struct zram *zram, struct bio *bio)
1594 zram_bio_discard(zram, index, offset, bio);
1609 if (zram_bvec_rw(zram, &bv, index, offset,
1626 * Handler function for all zram I/O requests.
1630 struct zram *zram = bio->bi_disk->private_data;
1632 if (!valid_io_request(zram, bio->bi_iter.bi_sector,
1634 atomic64_inc(&zram->stats.invalid_io);
1638 __zram_make_request(zram, bio);
1649 struct zram *zram;
1651 zram = bdev->bd_disk->private_data;
1653 atomic64_inc(&zram->stats.notify_free);
1654 if (!zram_slot_trylock(zram, index)) {
1655 atomic64_inc(&zram->stats.miss_free);
1659 zram_free_page(zram, index);
1660 zram_slot_unlock(zram, index);
1668 struct zram *zram;
1674 zram = bdev->bd_disk->private_data;
1676 if (!valid_io_request(zram, sector, PAGE_SIZE)) {
1677 atomic64_inc(&zram->stats.invalid_io);
1690 ret = zram_bvec_rw(zram, &bv, index, offset, op, NULL);
1717 static void zram_reset_device(struct zram *zram)
1722 down_write(&zram->init_lock);
1724 zram->limit_pages = 0;
1726 if (!init_done(zram)) {
1727 up_write(&zram->init_lock);
1731 comp = zram->comp;
1732 disksize = zram->disksize;
1733 zram->disksize = 0;
1735 set_capacity(zram->disk, 0);
1736 part_stat_set_all(&zram->disk->part0, 0);
1738 up_write(&zram->init_lock);
1740 zram_meta_free(zram, disksize);
1741 memset(&zram->stats, 0, sizeof(zram->stats));
1743 reset_bdev(zram);
1751 struct zram *zram = dev_to_zram(dev);
1758 down_write(&zram->init_lock);
1759 if (init_done(zram)) {
1766 if (!zram_meta_alloc(zram, disksize)) {
1771 comp = zcomp_create(zram->compressor);
1774 zram->compressor);
1779 zram->comp = comp;
1780 zram->disksize = disksize;
1781 set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
1783 revalidate_disk_size(zram->disk, true);
1784 up_write(&zram->init_lock);
1789 zram_meta_free(zram, disksize);
1791 up_write(&zram->init_lock);
1800 struct zram *zram;
1810 zram = dev_to_zram(dev);
1811 bdev = bdget_disk(zram->disk, 0);
1817 if (bdev->bd_openers || zram->claim) {
1823 /* From now on, anyone can't open /dev/zram[0-9] */
1824 zram->claim = true;
1829 zram_reset_device(zram);
1830 revalidate_disk_size(zram->disk, true);
1834 zram->claim = false;
1843 struct zram *zram;
1847 zram = bdev->bd_disk->private_data;
1848 /* zram was claimed to reset so open request fails */
1849 if (zram->claim)
1927 * Allocate and initialize new zram device. the function returns
1932 struct zram *zram;
1936 zram = kzalloc(sizeof(struct zram), GFP_KERNEL);
1937 if (!zram)
1940 ret = idr_alloc(&zram_index_idr, zram, 0, 0, GFP_KERNEL);
1945 init_rwsem(&zram->init_lock);
1947 spin_lock_init(&zram->wb_limit_lock);
1958 zram->disk = alloc_disk(1);
1959 if (!zram->disk) {
1966 zram->disk->major = zram_major;
1967 zram->disk->first_minor = device_id;
1968 zram->disk->fops = &zram_devops;
1969 zram->disk->queue = queue;
1970 zram->disk->private_data = zram;
1971 snprintf(zram->disk->disk_name, 16, "zram%d", device_id);
1973 /* Actual capacity set using syfs (/sys/block/zram<id>/disksize */
1974 set_capacity(zram->disk, 0);
1975 /* zram devices sort of resembles non-rotational disks */
1976 blk_queue_flag_set(QUEUE_FLAG_NONROT, zram->disk->queue);
1977 blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, zram->disk->queue);
1983 blk_queue_physical_block_size(zram->disk->queue, PAGE_SIZE);
1984 blk_queue_logical_block_size(zram->disk->queue,
1986 blk_queue_io_min(zram->disk->queue, PAGE_SIZE);
1987 blk_queue_io_opt(zram->disk->queue, PAGE_SIZE);
1988 zram->disk->queue->limits.discard_granularity = PAGE_SIZE;
1989 blk_queue_max_discard_sectors(zram->disk->queue, UINT_MAX);
1990 blk_queue_flag_set(QUEUE_FLAG_DISCARD, zram->disk->queue);
2001 blk_queue_max_write_zeroes_sectors(zram->disk->queue, UINT_MAX);
2003 blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, zram->disk->queue);
2004 device_add_disk(NULL, zram->disk, zram_disk_attr_groups);
2006 strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor));
2008 zram_debugfs_register(zram);
2009 pr_info("Added device: %s\n", zram->disk->disk_name);
2017 kfree(zram);
2021 static int zram_remove(struct zram *zram)
2025 bdev = bdget_disk(zram->disk, 0);
2030 if (bdev->bd_openers || zram->claim) {
2036 zram->claim = true;
2039 zram_debugfs_unregister(zram);
2043 zram_reset_device(zram);
2046 pr_info("Removed device: %s\n", zram->disk->disk_name);
2048 del_gendisk(zram->disk);
2049 blk_cleanup_queue(zram->disk->queue);
2050 put_disk(zram->disk);
2051 kfree(zram);
2055 /* zram-control sysfs attributes */
2060 * creates a new un-initialized zram device and returns back this device's
2085 struct zram *zram;
2097 zram = idr_find(&zram_index_idr, dev_id);
2098 if (zram) {
2099 ret = zram_remove(zram);
2119 .name = "zram-control",
2136 unregister_blkdev(zram_major, "zram");
2144 ret = cpuhp_setup_state_multi(CPUHP_ZCOMP_PREPARE, "block/zram:prepare",
2151 pr_err("Unable to register zram-control class\n");
2157 zram_major = register_blkdev(0, "zram");
2190 MODULE_PARM_DESC(num_devices, "Number of pre-created zram devices");