drivers/block/zram/zram_drv.c

   1 /*
   2  * Compressed RAM block device
   3  *
   4  * Copyright (C) 2008, 2009, 2010  Nitin Gupta
   5  *               2012, 2013 Minchan Kim
   6  *
   7  * This code is released using a dual license strategy: BSD/GPL
   8  * You can choose the licence that better fits your requirements.
   9  *
  10  * Released under the terms of 3-clause BSD License
  11  * Released under the terms of GNU General Public License Version 2.0
  12  *
  13  */
  14
  15 #define KMSG_COMPONENT "zram"
  16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/bio.h>
  21 #include <linux/bitops.h>
  22 #include <linux/blkdev.h>
  23 #include <linux/buffer_head.h>
  24 #include <linux/device.h>
  25 #include <linux/genhd.h>
  26 #include <linux/highmem.h>
  27 #include <linux/slab.h>
  28 #include <linux/string.h>
  29 #include <linux/vmalloc.h>
  30 #include <linux/err.h>
  31 #include <linux/idr.h>
  32 #include <linux/sysfs.h>
  33
  34 #include "zram_drv.h"
  35
  36 static DEFINE_IDR(zram_index_idr);
  37 /* idr index must be protected */
  38 static DEFINE_MUTEX(zram_index_mutex);
  39
  40 static int zram_major;
  41 static const char *default_compressor = "lzo";
  42
  43 /* Module params (documentation at end) */
  44 static unsigned int num_devices = 1;
  45
  46 static inline void deprecated_attr_warn(const char *name)
  47 {
  48         pr_warn_once("%d (%s) Attribute %s (and others) will be removed. %s\n",
  49                         task_pid_nr(current),
  50                         current->comm,
  51                         name,
  52                         "See zram documentation.");
  53 }
  54
  55 #define ZRAM_ATTR_RO(name)                                              \
  56 static ssize_t name##_show(struct device *d,                            \
  57                                 struct device_attribute *attr, char *b) \
  58 {                                                                       \
  59         struct zram *zram = dev_to_zram(d);                             \
  60                                                                         \
  61         deprecated_attr_warn(__stringify(name));                        \
  62         return scnprintf(b, PAGE_SIZE, "%llu\n",                        \
  63                 (u64)atomic64_read(&zram->stats.name));                 \
  64 }                                                                       \
  65 static DEVICE_ATTR_RO(name);
  66
  67 static inline bool init_done(struct zram *zram)
  68 {
  69         return zram->disksize;
  70 }
  71
  72 static inline struct zram *dev_to_zram(struct device *dev)
  73 {
  74         return (struct zram *)dev_to_disk(dev)->private_data;
  75 }
  76
  77 /* flag operations require table entry bit_spin_lock() being held */
  78 static int zram_test_flag(struct zram_meta *meta, u32 index,
  79                         enum zram_pageflags flag)
  80 {
  81         return meta->table[index].value & BIT(flag);
  82 }
  83
  84 static void zram_set_flag(struct zram_meta *meta, u32 index,
  85                         enum zram_pageflags flag)
  86 {
  87         meta->table[index].value |= BIT(flag);
  88 }
  89
  90 static void zram_clear_flag(struct zram_meta *meta, u32 index,
  91                         enum zram_pageflags flag)
  92 {
  93         meta->table[index].value &= ~BIT(flag);
  94 }
  95
  96 static size_t zram_get_obj_size(struct zram_meta *meta, u32 index)
  97 {
  98         return meta->table[index].value & (BIT(ZRAM_FLAG_SHIFT) - 1);
  99 }
 100
 101 static void zram_set_obj_size(struct zram_meta *meta,
 102                                         u32 index, size_t size)
 103 {
 104         unsigned long flags = meta->table[index].value >> ZRAM_FLAG_SHIFT;
 105
 106         meta->table[index].value = (flags << ZRAM_FLAG_SHIFT) | size;
 107 }
 108
 109 static inline int is_partial_io(struct bio_vec *bvec)
 110 {
 111         return bvec->bv_len != PAGE_SIZE;
 112 }
 113
 114 /*
 115  * Check if request is within bounds and aligned on zram logical blocks.
 116  */
 117 static inline int valid_io_request(struct zram *zram,
 118                 sector_t start, unsigned int size)
 119 {
 120         u64 end, bound;
 121
 122         /* unaligned request */
 123         if (unlikely(start & (ZRAM_SECTOR_PER_LOGICAL_BLOCK - 1)))
 124                 return 0;
 125         if (unlikely(size & (ZRAM_LOGICAL_BLOCK_SIZE - 1)))
 126                 return 0;
 127
 128         end = start + (size >> SECTOR_SHIFT);
 129         bound = zram->disksize >> SECTOR_SHIFT;
 130         /* out of range range */
 131         if (unlikely(start >= bound || end > bound || start > end))
 132                 return 0;
 133
 134         /* I/O request is valid */
 135         return 1;
 136 }
 137
 138 static void update_position(u32 *index, int *offset, struct bio_vec *bvec)
 139 {
 140         if (*offset + bvec->bv_len >= PAGE_SIZE)
 141                 (*index)++;
 142         *offset = (*offset + bvec->bv_len) % PAGE_SIZE;
 143 }
 144
 145 static inline void update_used_max(struct zram *zram,
 146                                         const unsigned long pages)
 147 {
 148         unsigned long old_max, cur_max;
 149
 150         old_max = atomic_long_read(&zram->stats.max_used_pages);
 151
 152         do {
 153                 cur_max = old_max;
 154                 if (pages > cur_max)
 155                         old_max = atomic_long_cmpxchg(
 156                                 &zram->stats.max_used_pages, cur_max, pages);
 157         } while (old_max != cur_max);
 158 }
 159
 160 static int page_zero_filled(void *ptr)
 161 {
 162         unsigned int pos;
 163         unsigned long *page;
 164
 165         page = (unsigned long *)ptr;
 166
 167         for (pos = 0; pos != PAGE_SIZE / sizeof(*page); pos++) {
 168                 if (page[pos])
 169                         return 0;
 170         }
 171
 172         return 1;
 173 }
 174
 175 static void handle_zero_page(struct bio_vec *bvec)
 176 {
 177         struct page *page = bvec->bv_page;
 178         void *user_mem;
 179
 180         user_mem = kmap_atomic(page);
 181         if (is_partial_io(bvec))
 182                 memset(user_mem + bvec->bv_offset, 0, bvec->bv_len);
 183         else
 184                 clear_page(user_mem);
 185         kunmap_atomic(user_mem);
 186
 187         flush_dcache_page(page);
 188 }
 189
 190 static ssize_t initstate_show(struct device *dev,
 191                 struct device_attribute *attr, char *buf)
 192 {
 193         u32 val;
 194         struct zram *zram = dev_to_zram(dev);
 195
 196         down_read(&zram->init_lock);
 197         val = init_done(zram);
 198         up_read(&zram->init_lock);
 199
 200         return scnprintf(buf, PAGE_SIZE, "%u\n", val);
 201 }
 202
 203 static ssize_t disksize_show(struct device *dev,
 204                 struct device_attribute *attr, char *buf)
 205 {
 206         struct zram *zram = dev_to_zram(dev);
 207
 208         return scnprintf(buf, PAGE_SIZE, "%llu\n", zram->disksize);
 209 }
 210
 211 static ssize_t orig_data_size_show(struct device *dev,
 212                 struct device_attribute *attr, char *buf)
 213 {
 214         struct zram *zram = dev_to_zram(dev);
 215
 216         deprecated_attr_warn("orig_data_size");
 217         return scnprintf(buf, PAGE_SIZE, "%llu\n",
 218                 (u64)(atomic64_read(&zram->stats.pages_stored)) << PAGE_SHIFT);
 219 }
 220
 221 static ssize_t mem_used_total_show(struct device *dev,
 222                 struct device_attribute *attr, char *buf)
 223 {
 224         u64 val = 0;
 225         struct zram *zram = dev_to_zram(dev);
 226
 227         deprecated_attr_warn("mem_used_total");
 228         down_read(&zram->init_lock);
 229         if (init_done(zram)) {
 230                 struct zram_meta *meta = zram->meta;
 231                 val = zs_get_total_pages(meta->mem_pool);
 232         }
 233         up_read(&zram->init_lock);
 234
 235         return scnprintf(buf, PAGE_SIZE, "%llu\n", val << PAGE_SHIFT);
 236 }
 237
 238 static ssize_t mem_limit_show(struct device *dev,
 239                 struct device_attribute *attr, char *buf)
 240 {
 241         u64 val;
 242         struct zram *zram = dev_to_zram(dev);
 243
 244         deprecated_attr_warn("mem_limit");
 245         down_read(&zram->init_lock);
 246         val = zram->limit_pages;
 247         up_read(&zram->init_lock);
 248
 249         return scnprintf(buf, PAGE_SIZE, "%llu\n", val << PAGE_SHIFT);
 250 }
 251
 252 static ssize_t mem_limit_store(struct device *dev,
 253                 struct device_attribute *attr, const char *buf, size_t len)
 254 {
 255         u64 limit;
 256         char *tmp;
 257         struct zram *zram = dev_to_zram(dev);
 258
 259         limit = memparse(buf, &tmp);
 260         if (buf == tmp) /* no chars parsed, invalid input */
 261                 return -EINVAL;
 262
 263         down_write(&zram->init_lock);
 264         zram->limit_pages = PAGE_ALIGN(limit) >> PAGE_SHIFT;
 265         up_write(&zram->init_lock);
 266
 267         return len;
 268 }
 269
 270 static ssize_t mem_used_max_show(struct device *dev,
 271                 struct device_attribute *attr, char *buf)
 272 {
 273         u64 val = 0;
 274         struct zram *zram = dev_to_zram(dev);
 275
 276         deprecated_attr_warn("mem_used_max");
 277         down_read(&zram->init_lock);
 278         if (init_done(zram))
 279                 val = atomic_long_read(&zram->stats.max_used_pages);
 280         up_read(&zram->init_lock);
 281
 282         return scnprintf(buf, PAGE_SIZE, "%llu\n", val << PAGE_SHIFT);
 283 }
 284
 285 static ssize_t mem_used_max_store(struct device *dev,
 286                 struct device_attribute *attr, const char *buf, size_t len)
 287 {
 288         int err;
 289         unsigned long val;
 290         struct zram *zram = dev_to_zram(dev);
 291
 292         err = kstrtoul(buf, 10, &val);
 293         if (err || val != 0)
 294                 return -EINVAL;
 295
 296         down_read(&zram->init_lock);
 297         if (init_done(zram)) {
 298                 struct zram_meta *meta = zram->meta;
 299                 atomic_long_set(&zram->stats.max_used_pages,
 300                                 zs_get_total_pages(meta->mem_pool));
 301         }
 302         up_read(&zram->init_lock);
 303
 304         return len;
 305 }
 306
 307 static ssize_t max_comp_streams_show(struct device *dev,
 308                 struct device_attribute *attr, char *buf)
 309 {
 310         int val;
 311         struct zram *zram = dev_to_zram(dev);
 312
 313         down_read(&zram->init_lock);
 314         val = zram->max_comp_streams;
 315         up_read(&zram->init_lock);
 316
 317         return scnprintf(buf, PAGE_SIZE, "%d\n", val);
 318 }
 319
 320 static ssize_t max_comp_streams_store(struct device *dev,
 321                 struct device_attribute *attr, const char *buf, size_t len)
 322 {
 323         int num;
 324         struct zram *zram = dev_to_zram(dev);
 325         int ret;
 326
 327         ret = kstrtoint(buf, 0, &num);
 328         if (ret < 0)
 329                 return ret;
 330         if (num < 1)
 331                 return -EINVAL;
 332
 333         down_write(&zram->init_lock);
 334         if (init_done(zram)) {
 335                 if (!zcomp_set_max_streams(zram->comp, num)) {
 336                         pr_info("Cannot change max compression streams\n");
 337                         ret = -EINVAL;
 338                         goto out;
 339                 }
 340         }
 341
 342         zram->max_comp_streams = num;
 343         ret = len;
 344 out:
 345         up_write(&zram->init_lock);
 346         return ret;
 347 }
 348
 349 static ssize_t comp_algorithm_show(struct device *dev,
 350                 struct device_attribute *attr, char *buf)
 351 {
 352         size_t sz;
 353         struct zram *zram = dev_to_zram(dev);
 354
 355         down_read(&zram->init_lock);
 356         sz = zcomp_available_show(zram->compressor, buf);
 357         up_read(&zram->init_lock);
 358
 359         return sz;
 360 }
 361
 362 static ssize_t comp_algorithm_store(struct device *dev,
 363                 struct device_attribute *attr, const char *buf, size_t len)
 364 {
 365         struct zram *zram = dev_to_zram(dev);
 366         down_write(&zram->init_lock);
 367         if (init_done(zram)) {
 368                 up_write(&zram->init_lock);
 369                 pr_info("Can't change algorithm for initialized device\n");
 370                 return -EBUSY;
 371         }
 372         strlcpy(zram->compressor, buf, sizeof(zram->compressor));
 373         up_write(&zram->init_lock);
 374         return len;
 375 }
 376
 377 static ssize_t compact_store(struct device *dev,
 378                 struct device_attribute *attr, const char *buf, size_t len)
 379 {
 380         unsigned long nr_migrated;
 381         struct zram *zram = dev_to_zram(dev);
 382         struct zram_meta *meta;
 383
 384         down_read(&zram->init_lock);
 385         if (!init_done(zram)) {
 386                 up_read(&zram->init_lock);
 387                 return -EINVAL;
 388         }
 389
 390         meta = zram->meta;
 391         nr_migrated = zs_compact(meta->mem_pool);
 392         atomic64_add(nr_migrated, &zram->stats.num_migrated);
 393         up_read(&zram->init_lock);
 394
 395         return len;
 396 }
 397
 398 static ssize_t io_stat_show(struct device *dev,
 399                 struct device_attribute *attr, char *buf)
 400 {
 401         struct zram *zram = dev_to_zram(dev);
 402         ssize_t ret;
 403
 404         down_read(&zram->init_lock);
 405         ret = scnprintf(buf, PAGE_SIZE,
 406                         "%8llu %8llu %8llu %8llu\n",
 407                         (u64)atomic64_read(&zram->stats.failed_reads),
 408                         (u64)atomic64_read(&zram->stats.failed_writes),
 409                         (u64)atomic64_read(&zram->stats.invalid_io),
 410                         (u64)atomic64_read(&zram->stats.notify_free));
 411         up_read(&zram->init_lock);
 412
 413         return ret;
 414 }
 415
 416 static ssize_t mm_stat_show(struct device *dev,
 417                 struct device_attribute *attr, char *buf)
 418 {
 419         struct zram *zram = dev_to_zram(dev);
 420         u64 orig_size, mem_used = 0;
 421         long max_used;
 422         ssize_t ret;
 423
 424         down_read(&zram->init_lock);
 425         if (init_done(zram))
 426                 mem_used = zs_get_total_pages(zram->meta->mem_pool);
 427
 428         orig_size = atomic64_read(&zram->stats.pages_stored);
 429         max_used = atomic_long_read(&zram->stats.max_used_pages);
 430
 431         ret = scnprintf(buf, PAGE_SIZE,
 432                         "%8llu %8llu %8llu %8lu %8ld %8llu %8llu\n",
 433                         orig_size << PAGE_SHIFT,
 434                         (u64)atomic64_read(&zram->stats.compr_data_size),
 435                         mem_used << PAGE_SHIFT,
 436                         zram->limit_pages << PAGE_SHIFT,
 437                         max_used << PAGE_SHIFT,
 438                         (u64)atomic64_read(&zram->stats.zero_pages),
 439                         (u64)atomic64_read(&zram->stats.num_migrated));
 440         up_read(&zram->init_lock);
 441
 442         return ret;
 443 }
 444
 445 static DEVICE_ATTR_RO(io_stat);
 446 static DEVICE_ATTR_RO(mm_stat);
 447 ZRAM_ATTR_RO(num_reads);
 448 ZRAM_ATTR_RO(num_writes);
 449 ZRAM_ATTR_RO(failed_reads);
 450 ZRAM_ATTR_RO(failed_writes);
 451 ZRAM_ATTR_RO(invalid_io);
 452 ZRAM_ATTR_RO(notify_free);
 453 ZRAM_ATTR_RO(zero_pages);
 454 ZRAM_ATTR_RO(compr_data_size);
 455
 456 static inline bool zram_meta_get(struct zram *zram)
 457 {
 458         if (atomic_inc_not_zero(&zram->refcount))
 459                 return true;
 460         return false;
 461 }
 462
 463 static inline void zram_meta_put(struct zram *zram)
 464 {
 465         atomic_dec(&zram->refcount);
 466 }
 467
 468 static void zram_meta_free(struct zram_meta *meta, u64 disksize)
 469 {
 470         size_t num_pages = disksize >> PAGE_SHIFT;
 471         size_t index;
 472
 473         /* Free all pages that are still in this zram device */
 474         for (index = 0; index < num_pages; index++) {
 475                 unsigned long handle = meta->table[index].handle;
 476
 477                 if (!handle)
 478                         continue;
 479
 480                 zs_free(meta->mem_pool, handle);
 481         }
 482
 483         zs_destroy_pool(meta->mem_pool);
 484         vfree(meta->table);
 485         kfree(meta);
 486 }
 487
 488 static struct zram_meta *zram_meta_alloc(int device_id, u64 disksize)
 489 {
 490         size_t num_pages;
 491         char pool_name[8];
 492         struct zram_meta *meta = kmalloc(sizeof(*meta), GFP_KERNEL);
 493
 494         if (!meta)
 495                 return NULL;
 496
 497         num_pages = disksize >> PAGE_SHIFT;
 498         meta->table = vzalloc(num_pages * sizeof(*meta->table));
 499         if (!meta->table) {
 500                 pr_err("Error allocating zram address table\n");
 501                 goto out_error;
 502         }
 503
 504         snprintf(pool_name, sizeof(pool_name), "zram%d", device_id);
 505         meta->mem_pool = zs_create_pool(pool_name, GFP_NOIO | __GFP_HIGHMEM);
 506         if (!meta->mem_pool) {
 507                 pr_err("Error creating memory pool\n");
 508                 goto out_error;
 509         }
 510
 511         return meta;
 512
 513 out_error:
 514         vfree(meta->table);
 515         kfree(meta);
 516         return NULL;
 517 }
 518
 519 /*
 520  * To protect concurrent access to the same index entry,
 521  * caller should hold this table index entry's bit_spinlock to
 522  * indicate this index entry is accessing.
 523  */
 524 static void zram_free_page(struct zram *zram, size_t index)
 525 {
 526         struct zram_meta *meta = zram->meta;
 527         unsigned long handle = meta->table[index].handle;
 528
 529         if (unlikely(!handle)) {
 530                 /*
 531                  * No memory is allocated for zero filled pages.
 532                  * Simply clear zero page flag.
 533                  */
 534                 if (zram_test_flag(meta, index, ZRAM_ZERO)) {
 535                         zram_clear_flag(meta, index, ZRAM_ZERO);
 536                         atomic64_dec(&zram->stats.zero_pages);
 537                 }
 538                 return;
 539         }
 540
 541         zs_free(meta->mem_pool, handle);
 542
 543         atomic64_sub(zram_get_obj_size(meta, index),
 544                         &zram->stats.compr_data_size);
 545         atomic64_dec(&zram->stats.pages_stored);
 546
 547         meta->table[index].handle = 0;
 548         zram_set_obj_size(meta, index, 0);
 549 }
 550
 551 static int zram_decompress_page(struct zram *zram, char *mem, u32 index)
 552 {
 553         int ret = 0;
 554         unsigned char *cmem;
 555         struct zram_meta *meta = zram->meta;
 556         unsigned long handle;
 557         size_t size;
 558
 559         bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
 560         handle = meta->table[index].handle;
 561         size = zram_get_obj_size(meta, index);
 562
 563         if (!handle || zram_test_flag(meta, index, ZRAM_ZERO)) {
 564                 bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 565                 clear_page(mem);
 566                 return 0;
 567         }
 568
 569         cmem = zs_map_object(meta->mem_pool, handle, ZS_MM_RO);
 570         if (size == PAGE_SIZE)
 571                 copy_page(mem, cmem);
 572         else
 573                 ret = zcomp_decompress(zram->comp, cmem, size, mem);
 574         zs_unmap_object(meta->mem_pool, handle);
 575         bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 576
 577         /* Should NEVER happen. Return bio error if it does. */
 578         if (unlikely(ret)) {
 579                 pr_err("Decompression failed! err=%d, page=%u\n", ret, index);
 580                 return ret;
 581         }
 582
 583         return 0;
 584 }
 585
 586 static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
 587                           u32 index, int offset)
 588 {
 589         int ret;
 590         struct page *page;
 591         unsigned char *user_mem, *uncmem = NULL;
 592         struct zram_meta *meta = zram->meta;
 593         page = bvec->bv_page;
 594
 595         bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
 596         if (unlikely(!meta->table[index].handle) ||
 597                         zram_test_flag(meta, index, ZRAM_ZERO)) {
 598                 bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 599                 handle_zero_page(bvec);
 600                 return 0;
 601         }
 602         bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 603
 604         if (is_partial_io(bvec))
 605                 /* Use  a temporary buffer to decompress the page */
 606                 uncmem = kmalloc(PAGE_SIZE, GFP_NOIO);
 607
 608         user_mem = kmap_atomic(page);
 609         if (!is_partial_io(bvec))
 610                 uncmem = user_mem;
 611
 612         if (!uncmem) {
 613                 pr_info("Unable to allocate temp memory\n");
 614                 ret = -ENOMEM;
 615                 goto out_cleanup;
 616         }
 617
 618         ret = zram_decompress_page(zram, uncmem, index);
 619         /* Should NEVER happen. Return bio error if it does. */
 620         if (unlikely(ret))
 621                 goto out_cleanup;
 622
 623         if (is_partial_io(bvec))
 624                 memcpy(user_mem + bvec->bv_offset, uncmem + offset,
 625                                 bvec->bv_len);
 626
 627         flush_dcache_page(page);
 628         ret = 0;
 629 out_cleanup:
 630         kunmap_atomic(user_mem);
 631         if (is_partial_io(bvec))
 632                 kfree(uncmem);
 633         return ret;
 634 }
 635
 636 static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
 637                            int offset)
 638 {
 639         int ret = 0;
 640         size_t clen;
 641         unsigned long handle;
 642         struct page *page;
 643         unsigned char *user_mem, *cmem, *src, *uncmem = NULL;
 644         struct zram_meta *meta = zram->meta;
 645         struct zcomp_strm *zstrm;
 646         bool locked = false;
 647         unsigned long alloced_pages;
 648
 649         page = bvec->bv_page;
 650         if (is_partial_io(bvec)) {
 651                 /*
 652                  * This is a partial IO. We need to read the full page
 653                  * before to write the changes.
 654                  */
 655                 uncmem = kmalloc(PAGE_SIZE, GFP_NOIO);
 656                 if (!uncmem) {
 657                         ret = -ENOMEM;
 658                         goto out;
 659                 }
 660                 ret = zram_decompress_page(zram, uncmem, index);
 661                 if (ret)
 662                         goto out;
 663         }
 664
 665         zstrm = zcomp_strm_find(zram->comp);
 666         locked = true;
 667         user_mem = kmap_atomic(page);
 668
 669         if (is_partial_io(bvec)) {
 670                 memcpy(uncmem + offset, user_mem + bvec->bv_offset,
 671                        bvec->bv_len);
 672                 kunmap_atomic(user_mem);
 673                 user_mem = NULL;
 674         } else {
 675                 uncmem = user_mem;
 676         }
 677
 678         if (page_zero_filled(uncmem)) {
 679                 if (user_mem)
 680                         kunmap_atomic(user_mem);
 681                 /* Free memory associated with this sector now. */
 682                 bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
 683                 zram_free_page(zram, index);
 684                 zram_set_flag(meta, index, ZRAM_ZERO);
 685                 bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 686
 687                 atomic64_inc(&zram->stats.zero_pages);
 688                 ret = 0;
 689                 goto out;
 690         }
 691
 692         ret = zcomp_compress(zram->comp, zstrm, uncmem, &clen);
 693         if (!is_partial_io(bvec)) {
 694                 kunmap_atomic(user_mem);
 695                 user_mem = NULL;
 696                 uncmem = NULL;
 697         }
 698
 699         if (unlikely(ret)) {
 700                 pr_err("Compression failed! err=%d\n", ret);
 701                 goto out;
 702         }
 703         src = zstrm->buffer;
 704         if (unlikely(clen > max_zpage_size)) {
 705                 clen = PAGE_SIZE;
 706                 if (is_partial_io(bvec))
 707                         src = uncmem;
 708         }
 709
 710         handle = zs_malloc(meta->mem_pool, clen);
 711         if (!handle) {
 712                 pr_info("Error allocating memory for compressed page: %u, size=%zu\n",
 713                         index, clen);
 714                 ret = -ENOMEM;
 715                 goto out;
 716         }
 717
 718         alloced_pages = zs_get_total_pages(meta->mem_pool);
 719         if (zram->limit_pages && alloced_pages > zram->limit_pages) {
 720                 zs_free(meta->mem_pool, handle);
 721                 ret = -ENOMEM;
 722                 goto out;
 723         }
 724
 725         update_used_max(zram, alloced_pages);
 726
 727         cmem = zs_map_object(meta->mem_pool, handle, ZS_MM_WO);
 728
 729         if ((clen == PAGE_SIZE) && !is_partial_io(bvec)) {
 730                 src = kmap_atomic(page);
 731                 copy_page(cmem, src);
 732                 kunmap_atomic(src);
 733         } else {
 734                 memcpy(cmem, src, clen);
 735         }
 736
 737         zcomp_strm_release(zram->comp, zstrm);
 738         locked = false;
 739         zs_unmap_object(meta->mem_pool, handle);
 740
 741         /*
 742          * Free memory associated with this sector
 743          * before overwriting unused sectors.
 744          */
 745         bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
 746         zram_free_page(zram, index);
 747
 748         meta->table[index].handle = handle;
 749         zram_set_obj_size(meta, index, clen);
 750         bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 751
 752         /* Update stats */
 753         atomic64_add(clen, &zram->stats.compr_data_size);
 754         atomic64_inc(&zram->stats.pages_stored);
 755 out:
 756         if (locked)
 757                 zcomp_strm_release(zram->comp, zstrm);
 758         if (is_partial_io(bvec))
 759                 kfree(uncmem);
 760         return ret;
 761 }
 762
 763 /*
 764  * zram_bio_discard - handler on discard request
 765  * @index: physical block index in PAGE_SIZE units
 766  * @offset: byte offset within physical block
 767  */
 768 static void zram_bio_discard(struct zram *zram, u32 index,
 769                              int offset, struct bio *bio)
 770 {
 771         size_t n = bio->bi_iter.bi_size;
 772         struct zram_meta *meta = zram->meta;
 773
 774         /*
 775          * zram manages data in physical block size units. Because logical block
 776          * size isn't identical with physical block size on some arch, we
 777          * could get a discard request pointing to a specific offset within a
 778          * certain physical block.  Although we can handle this request by
 779          * reading that physiclal block and decompressing and partially zeroing
 780          * and re-compressing and then re-storing it, this isn't reasonable
 781          * because our intent with a discard request is to save memory.  So
 782          * skipping this logical block is appropriate here.
 783          */
 784         if (offset) {
 785                 if (n <= (PAGE_SIZE - offset))
 786                         return;
 787
 788                 n -= (PAGE_SIZE - offset);
 789                 index++;
 790         }
 791
 792         while (n >= PAGE_SIZE) {
 793                 bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
 794                 zram_free_page(zram, index);
 795                 bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 796                 atomic64_inc(&zram->stats.notify_free);
 797                 index++;
 798                 n -= PAGE_SIZE;
 799         }
 800 }
 801
 802 static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
 803                         int offset, int rw)
 804 {
 805         unsigned long start_time = jiffies;
 806         int ret;
 807
 808         generic_start_io_acct(rw, bvec->bv_len >> SECTOR_SHIFT,
 809                         &zram->disk->part0);
 810
 811         if (rw == READ) {
 812                 atomic64_inc(&zram->stats.num_reads);
 813                 ret = zram_bvec_read(zram, bvec, index, offset);
 814         } else {
 815                 atomic64_inc(&zram->stats.num_writes);
 816                 ret = zram_bvec_write(zram, bvec, index, offset);
 817         }
 818
 819         generic_end_io_acct(rw, &zram->disk->part0, start_time);
 820
 821         if (unlikely(ret)) {
 822                 if (rw == READ)
 823                         atomic64_inc(&zram->stats.failed_reads);
 824                 else
 825                         atomic64_inc(&zram->stats.failed_writes);
 826         }
 827
 828         return ret;
 829 }
 830
 831 static void __zram_make_request(struct zram *zram, struct bio *bio)
 832 {
 833         int offset, rw;
 834         u32 index;
 835         struct bio_vec bvec;
 836         struct bvec_iter iter;
 837
 838         index = bio->bi_iter.bi_sector >> SECTORS_PER_PAGE_SHIFT;
 839         offset = (bio->bi_iter.bi_sector &
 840                   (SECTORS_PER_PAGE - 1)) << SECTOR_SHIFT;
 841
 842         if (unlikely(bio->bi_rw & REQ_DISCARD)) {
 843                 zram_bio_discard(zram, index, offset, bio);
 844                 bio_endio(bio, 0);
 845                 return;
 846         }
 847
 848         rw = bio_data_dir(bio);
 849         bio_for_each_segment(bvec, bio, iter) {
 850                 int max_transfer_size = PAGE_SIZE - offset;
 851
 852                 if (bvec.bv_len > max_transfer_size) {
 853                         /*
 854                          * zram_bvec_rw() can only make operation on a single
 855                          * zram page. Split the bio vector.
 856                          */
 857                         struct bio_vec bv;
 858
 859                         bv.bv_page = bvec.bv_page;
 860                         bv.bv_len = max_transfer_size;
 861                         bv.bv_offset = bvec.bv_offset;
 862
 863                         if (zram_bvec_rw(zram, &bv, index, offset, rw) < 0)
 864                                 goto out;
 865
 866                         bv.bv_len = bvec.bv_len - max_transfer_size;
 867                         bv.bv_offset += max_transfer_size;
 868                         if (zram_bvec_rw(zram, &bv, index + 1, 0, rw) < 0)
 869                                 goto out;
 870                 } else
 871                         if (zram_bvec_rw(zram, &bvec, index, offset, rw) < 0)
 872                                 goto out;
 873
 874                 update_position(&index, &offset, &bvec);
 875         }
 876
 877         set_bit(BIO_UPTODATE, &bio->bi_flags);
 878         bio_endio(bio, 0);
 879         return;
 880
 881 out:
 882         bio_io_error(bio);
 883 }
 884
 885 /*
 886  * Handler function for all zram I/O requests.
 887  */
 888 static void zram_make_request(struct request_queue *queue, struct bio *bio)
 889 {
 890         struct zram *zram = queue->queuedata;
 891
 892         if (unlikely(!zram_meta_get(zram)))
 893                 goto error;
 894
 895         if (!valid_io_request(zram, bio->bi_iter.bi_sector,
 896                                         bio->bi_iter.bi_size)) {
 897                 atomic64_inc(&zram->stats.invalid_io);
 898                 goto put_zram;
 899         }
 900
 901         __zram_make_request(zram, bio);
 902         zram_meta_put(zram);
 903         return;
 904 put_zram:
 905         zram_meta_put(zram);
 906 error:
 907         bio_io_error(bio);
 908 }
 909
 910 static void zram_slot_free_notify(struct block_device *bdev,
 911                                 unsigned long index)
 912 {
 913         struct zram *zram;
 914         struct zram_meta *meta;
 915
 916         zram = bdev->bd_disk->private_data;
 917         meta = zram->meta;
 918
 919         bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
 920         zram_free_page(zram, index);
 921         bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
 922         atomic64_inc(&zram->stats.notify_free);
 923 }
 924
 925 static int zram_rw_page(struct block_device *bdev, sector_t sector,
 926                        struct page *page, int rw)
 927 {
 928         int offset, err = -EIO;
 929         u32 index;
 930         struct zram *zram;
 931         struct bio_vec bv;
 932
 933         zram = bdev->bd_disk->private_data;
 934         if (unlikely(!zram_meta_get(zram)))
 935                 goto out;
 936
 937         if (!valid_io_request(zram, sector, PAGE_SIZE)) {
 938                 atomic64_inc(&zram->stats.invalid_io);
 939                 err = -EINVAL;
 940                 goto put_zram;
 941         }
 942
 943         index = sector >> SECTORS_PER_PAGE_SHIFT;
 944         offset = sector & (SECTORS_PER_PAGE - 1) << SECTOR_SHIFT;
 945
 946         bv.bv_page = page;
 947         bv.bv_len = PAGE_SIZE;
 948         bv.bv_offset = 0;
 949
 950         err = zram_bvec_rw(zram, &bv, index, offset, rw);
 951 put_zram:
 952         zram_meta_put(zram);
 953 out:
 954         /*
 955          * If I/O fails, just return error(ie, non-zero) without
 956          * calling page_endio.
 957          * It causes resubmit the I/O with bio request by upper functions
 958          * of rw_page(e.g., swap_readpage, __swap_writepage) and
 959          * bio->bi_end_io does things to handle the error
 960          * (e.g., SetPageError, set_page_dirty and extra works).
 961          */
 962         if (err == 0)
 963                 page_endio(page, rw, 0);
 964         return err;
 965 }
 966
 967 static void zram_reset_device(struct zram *zram)
 968 {
 969         struct zram_meta *meta;
 970         struct zcomp *comp;
 971         u64 disksize;
 972
 973         down_write(&zram->init_lock);
 974
 975         zram->limit_pages = 0;
 976
 977         if (!init_done(zram)) {
 978                 up_write(&zram->init_lock);
 979                 return;
 980         }
 981
 982         meta = zram->meta;
 983         comp = zram->comp;
 984         disksize = zram->disksize;
 985         /*
 986          * Refcount will go down to 0 eventually and r/w handler
 987          * cannot handle further I/O so it will bail out by
 988          * check zram_meta_get.
 989          */
 990         zram_meta_put(zram);
 991         /*
 992          * We want to free zram_meta in process context to avoid
 993          * deadlock between reclaim path and any other locks.
 994          */
 995         wait_event(zram->io_done, atomic_read(&zram->refcount) == 0);
 996
 997         /* Reset stats */
 998         memset(&zram->stats, 0, sizeof(zram->stats));
 999         zram->disksize = 0;
1000         zram->max_comp_streams = 1;
1001
1002         set_capacity(zram->disk, 0);
1003         part_stat_set_all(&zram->disk->part0, 0);
1004
1005         up_write(&zram->init_lock);
1006         /* I/O operation under all of CPU are done so let's free */
1007         zram_meta_free(meta, disksize);
1008         zcomp_destroy(comp);
1009 }
1010
1011 static ssize_t disksize_store(struct device *dev,
1012                 struct device_attribute *attr, const char *buf, size_t len)
1013 {
1014         u64 disksize;
1015         struct zcomp *comp;
1016         struct zram_meta *meta;
1017         struct zram *zram = dev_to_zram(dev);
1018         int err;
1019
1020         disksize = memparse(buf, NULL);
1021         if (!disksize)
1022                 return -EINVAL;
1023
1024         disksize = PAGE_ALIGN(disksize);
1025         meta = zram_meta_alloc(zram->disk->first_minor, disksize);
1026         if (!meta)
1027                 return -ENOMEM;
1028
1029         comp = zcomp_create(zram->compressor, zram->max_comp_streams);
1030         if (IS_ERR(comp)) {
1031                 pr_info("Cannot initialise %s compressing backend\n",
1032                                 zram->compressor);
1033                 err = PTR_ERR(comp);
1034                 goto out_free_meta;
1035         }
1036
1037         down_write(&zram->init_lock);
1038         if (init_done(zram)) {
1039                 pr_info("Cannot change disksize for initialized device\n");
1040                 err = -EBUSY;
1041                 goto out_destroy_comp;
1042         }
1043
1044         init_waitqueue_head(&zram->io_done);
1045         atomic_set(&zram->refcount, 1);
1046         zram->meta = meta;
1047         zram->comp = comp;
1048         zram->disksize = disksize;
1049         set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
1050         up_write(&zram->init_lock);
1051
1052         /*
1053          * Revalidate disk out of the init_lock to avoid lockdep splat.
1054          * It's okay because disk's capacity is protected by init_lock
1055          * so that revalidate_disk always sees up-to-date capacity.
1056          */
1057         revalidate_disk(zram->disk);
1058
1059         return len;
1060
1061 out_destroy_comp:
1062         up_write(&zram->init_lock);
1063         zcomp_destroy(comp);
1064 out_free_meta:
1065         zram_meta_free(meta, disksize);
1066         return err;
1067 }
1068
1069 static ssize_t reset_store(struct device *dev,
1070                 struct device_attribute *attr, const char *buf, size_t len)
1071 {
1072         int ret;
1073         unsigned short do_reset;
1074         struct zram *zram;
1075         struct block_device *bdev;
1076
1077         ret = kstrtou16(buf, 10, &do_reset);
1078         if (ret)
1079                 return ret;
1080
1081         if (!do_reset)
1082                 return -EINVAL;
1083
1084         zram = dev_to_zram(dev);
1085         bdev = bdget_disk(zram->disk, 0);
1086         if (!bdev)
1087                 return -ENOMEM;
1088
1089         mutex_lock(&bdev->bd_mutex);
1090         /* Do not reset an active device or claimed device */
1091         if (bdev->bd_openers || zram->claim) {
1092                 mutex_unlock(&bdev->bd_mutex);
1093                 bdput(bdev);
1094                 return -EBUSY;
1095         }
1096
1097         /* From now on, anyone can't open /dev/zram[0-9] */
1098         zram->claim = true;
1099         mutex_unlock(&bdev->bd_mutex);
1100
1101         /* Make sure all the pending I/O are finished */
1102         fsync_bdev(bdev);
1103         zram_reset_device(zram);
1104         revalidate_disk(zram->disk);
1105         bdput(bdev);
1106
1107         mutex_lock(&bdev->bd_mutex);
1108         zram->claim = false;
1109         mutex_unlock(&bdev->bd_mutex);
1110
1111         return len;
1112 }
1113
1114 static int zram_open(struct block_device *bdev, fmode_t mode)
1115 {
1116         int ret = 0;
1117         struct zram *zram;
1118
1119         WARN_ON(!mutex_is_locked(&bdev->bd_mutex));
1120
1121         zram = bdev->bd_disk->private_data;
1122         /* zram was claimed to reset so open request fails */
1123         if (zram->claim)
1124                 ret = -EBUSY;
1125
1126         return ret;
1127 }
1128
1129 static const struct block_device_operations zram_devops = {
1130         .open = zram_open,
1131         .swap_slot_free_notify = zram_slot_free_notify,
1132         .rw_page = zram_rw_page,
1133         .owner = THIS_MODULE
1134 };
1135
1136 static DEVICE_ATTR_WO(compact);
1137 static DEVICE_ATTR_RW(disksize);
1138 static DEVICE_ATTR_RO(initstate);
1139 static DEVICE_ATTR_WO(reset);
1140 static DEVICE_ATTR_RO(orig_data_size);
1141 static DEVICE_ATTR_RO(mem_used_total);
1142 static DEVICE_ATTR_RW(mem_limit);
1143 static DEVICE_ATTR_RW(mem_used_max);
1144 static DEVICE_ATTR_RW(max_comp_streams);
1145 static DEVICE_ATTR_RW(comp_algorithm);
1146
1147 static struct attribute *zram_disk_attrs[] = {
1148         &dev_attr_disksize.attr,
1149         &dev_attr_initstate.attr,
1150         &dev_attr_reset.attr,
1151         &dev_attr_num_reads.attr,
1152         &dev_attr_num_writes.attr,
1153         &dev_attr_failed_reads.attr,
1154         &dev_attr_failed_writes.attr,
1155         &dev_attr_compact.attr,
1156         &dev_attr_invalid_io.attr,
1157         &dev_attr_notify_free.attr,
1158         &dev_attr_zero_pages.attr,
1159         &dev_attr_orig_data_size.attr,
1160         &dev_attr_compr_data_size.attr,
1161         &dev_attr_mem_used_total.attr,
1162         &dev_attr_mem_limit.attr,
1163         &dev_attr_mem_used_max.attr,
1164         &dev_attr_max_comp_streams.attr,
1165         &dev_attr_comp_algorithm.attr,
1166         &dev_attr_io_stat.attr,
1167         &dev_attr_mm_stat.attr,
1168         NULL,
1169 };
1170
1171 static struct attribute_group zram_disk_attr_group = {
1172         .attrs = zram_disk_attrs,
1173 };
1174
1175 /*
1176  * Allocate and initialize new zram device. the function returns
1177  * '>= 0' device_id upon success, and negative value otherwise.
1178  */
1179 static int zram_add(void)
1180 {
1181         struct zram *zram;
1182         struct request_queue *queue;
1183         int ret, device_id;
1184
1185         zram = kzalloc(sizeof(struct zram), GFP_KERNEL);
1186         if (!zram)
1187                 return -ENOMEM;
1188
1189         ret = idr_alloc(&zram_index_idr, zram, 0, 0, GFP_KERNEL);
1190         if (ret < 0)
1191                 goto out_free_dev;
1192         device_id = ret;
1193
1194         init_rwsem(&zram->init_lock);
1195
1196         queue = blk_alloc_queue(GFP_KERNEL);
1197         if (!queue) {
1198                 pr_err("Error allocating disk queue for device %d\n",
1199                         device_id);
1200                 ret = -ENOMEM;
1201                 goto out_free_idr;
1202         }
1203
1204         blk_queue_make_request(queue, zram_make_request);
1205
1206         /* gendisk structure */
1207         zram->disk = alloc_disk(1);
1208         if (!zram->disk) {
1209                 pr_warn("Error allocating disk structure for device %d\n",
1210                         device_id);
1211                 ret = -ENOMEM;
1212                 goto out_free_queue;
1213         }
1214
1215         zram->disk->major = zram_major;
1216         zram->disk->first_minor = device_id;
1217         zram->disk->fops = &zram_devops;
1218         zram->disk->queue = queue;
1219         zram->disk->queue->queuedata = zram;
1220         zram->disk->private_data = zram;
1221         snprintf(zram->disk->disk_name, 16, "zram%d", device_id);
1222
1223         /* Actual capacity set using syfs (/sys/block/zram<id>/disksize */
1224         set_capacity(zram->disk, 0);
1225         /* zram devices sort of resembles non-rotational disks */
1226         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zram->disk->queue);
1227         queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, zram->disk->queue);
1228         /*
1229          * To ensure that we always get PAGE_SIZE aligned
1230          * and n*PAGE_SIZED sized I/O requests.
1231          */
1232         blk_queue_physical_block_size(zram->disk->queue, PAGE_SIZE);
1233         blk_queue_logical_block_size(zram->disk->queue,
1234                                         ZRAM_LOGICAL_BLOCK_SIZE);
1235         blk_queue_io_min(zram->disk->queue, PAGE_SIZE);
1236         blk_queue_io_opt(zram->disk->queue, PAGE_SIZE);
1237         zram->disk->queue->limits.discard_granularity = PAGE_SIZE;
1238         zram->disk->queue->limits.max_discard_sectors = UINT_MAX;
1239         /*
1240          * zram_bio_discard() will clear all logical blocks if logical block
1241          * size is identical with physical block size(PAGE_SIZE). But if it is
1242          * different, we will skip discarding some parts of logical blocks in
1243          * the part of the request range which isn't aligned to physical block
1244          * size.  So we can't ensure that all discarded logical blocks are
1245          * zeroed.
1246          */
1247         if (ZRAM_LOGICAL_BLOCK_SIZE == PAGE_SIZE)
1248                 zram->disk->queue->limits.discard_zeroes_data = 1;
1249         else
1250                 zram->disk->queue->limits.discard_zeroes_data = 0;
1251         queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, zram->disk->queue);
1252
1253         add_disk(zram->disk);
1254
1255         ret = sysfs_create_group(&disk_to_dev(zram->disk)->kobj,
1256                                 &zram_disk_attr_group);
1257         if (ret < 0) {
1258                 pr_warn("Error creating sysfs group");
1259                 goto out_free_disk;
1260         }
1261         strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor));
1262         zram->meta = NULL;
1263         zram->max_comp_streams = 1;
1264
1265         pr_info("Added device: %s\n", zram->disk->disk_name);
1266         return device_id;
1267
1268 out_free_disk:
1269         del_gendisk(zram->disk);
1270         put_disk(zram->disk);
1271 out_free_queue:
1272         blk_cleanup_queue(queue);
1273 out_free_idr:
1274         idr_remove(&zram_index_idr, device_id);
1275 out_free_dev:
1276         kfree(zram);
1277         return ret;
1278 }
1279
1280 static int zram_remove(struct zram *zram)
1281 {
1282         struct block_device *bdev;
1283
1284         bdev = bdget_disk(zram->disk, 0);
1285         if (!bdev)
1286                 return -ENOMEM;
1287
1288         mutex_lock(&bdev->bd_mutex);
1289         if (bdev->bd_openers || zram->claim) {
1290                 mutex_unlock(&bdev->bd_mutex);
1291                 bdput(bdev);
1292                 return -EBUSY;
1293         }
1294
1295         zram->claim = true;
1296         mutex_unlock(&bdev->bd_mutex);
1297
1298         /*
1299          * Remove sysfs first, so no one will perform a disksize
1300          * store while we destroy the devices. This also helps during
1301          * hot_remove -- zram_reset_device() is the last holder of
1302          * ->init_lock, no later/concurrent disksize_store() or any
1303          * other sysfs handlers are possible.
1304          */
1305         sysfs_remove_group(&disk_to_dev(zram->disk)->kobj,
1306                         &zram_disk_attr_group);
1307
1308         /* Make sure all the pending I/O are finished */
1309         fsync_bdev(bdev);
1310         zram_reset_device(zram);
1311         bdput(bdev);
1312
1313         pr_info("Removed device: %s\n", zram->disk->disk_name);
1314
1315         idr_remove(&zram_index_idr, zram->disk->first_minor);
1316         blk_cleanup_queue(zram->disk->queue);
1317         del_gendisk(zram->disk);
1318         put_disk(zram->disk);
1319         kfree(zram);
1320         return 0;
1321 }
1322
1323 /* zram-control sysfs attributes */
1324 static ssize_t hot_add_show(struct class *class,
1325                         struct class_attribute *attr,
1326                         char *buf)
1327 {
1328         int ret;
1329
1330         mutex_lock(&zram_index_mutex);
1331         ret = zram_add();
1332         mutex_unlock(&zram_index_mutex);
1333
1334         if (ret < 0)
1335                 return ret;
1336         return scnprintf(buf, PAGE_SIZE, "%d\n", ret);
1337 }
1338
1339 static ssize_t hot_remove_store(struct class *class,
1340                         struct class_attribute *attr,
1341                         const char *buf,
1342                         size_t count)
1343 {
1344         struct zram *zram;
1345         int ret, dev_id;
1346
1347         /* dev_id is gendisk->first_minor, which is `int' */
1348         ret = kstrtoint(buf, 10, &dev_id);
1349         if (ret)
1350                 return ret;
1351         if (dev_id < 0)
1352                 return -EINVAL;
1353
1354         mutex_lock(&zram_index_mutex);
1355
1356         zram = idr_find(&zram_index_idr, dev_id);
1357         if (zram)
1358                 ret = zram_remove(zram);
1359         else
1360                 ret = -ENODEV;
1361
1362         mutex_unlock(&zram_index_mutex);
1363         return ret ? ret : count;
1364 }
1365
1366 static struct class_attribute zram_control_class_attrs[] = {
1367         __ATTR_RO(hot_add),
1368         __ATTR_WO(hot_remove),
1369         __ATTR_NULL,
1370 };
1371
1372 static struct class zram_control_class = {
1373         .name           = "zram-control",
1374         .owner          = THIS_MODULE,
1375         .class_attrs    = zram_control_class_attrs,
1376 };
1377
1378 static int zram_remove_cb(int id, void *ptr, void *data)
1379 {
1380         zram_remove(ptr);
1381         return 0;
1382 }
1383
1384 static void destroy_devices(void)
1385 {
1386         class_unregister(&zram_control_class);
1387         idr_for_each(&zram_index_idr, &zram_remove_cb, NULL);
1388         idr_destroy(&zram_index_idr);
1389         unregister_blkdev(zram_major, "zram");
1390 }
1391
1392 static int __init zram_init(void)
1393 {
1394         int ret;
1395
1396         ret = class_register(&zram_control_class);
1397         if (ret) {
1398                 pr_warn("Unable to register zram-control class\n");
1399                 return ret;
1400         }
1401
1402         zram_major = register_blkdev(0, "zram");
1403         if (zram_major <= 0) {
1404                 pr_warn("Unable to get major number\n");
1405                 class_unregister(&zram_control_class);
1406                 return -EBUSY;
1407         }
1408
1409         while (num_devices != 0) {
1410                 mutex_lock(&zram_index_mutex);
1411                 ret = zram_add();
1412                 mutex_unlock(&zram_index_mutex);
1413                 if (ret < 0)
1414                         goto out_error;
1415                 num_devices--;
1416         }
1417
1418         return 0;
1419
1420 out_error:
1421         destroy_devices();
1422         return ret;
1423 }
1424
1425 static void __exit zram_exit(void)
1426 {
1427         destroy_devices();
1428 }
1429
1430 module_init(zram_init);
1431 module_exit(zram_exit);
1432
1433 module_param(num_devices, uint, 0);
1434 MODULE_PARM_DESC(num_devices, "Number of pre-created zram devices");
1435
1436 MODULE_LICENSE("Dual BSD/GPL");
1437 MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");
1438 MODULE_DESCRIPTION("Compressed RAM Block Device");