block: remove support for bio remapping from ->make_request
[linux-3.10.git] / drivers / staging / zram / zram_drv.c
1 /*
2  * Compressed RAM block device
3  *
4  * Copyright (C) 2008, 2009, 2010  Nitin Gupta
5  *
6  * This code is released using a dual license strategy: BSD/GPL
7  * You can choose the licence that better fits your requirements.
8  *
9  * Released under the terms of 3-clause BSD License
10  * Released under the terms of GNU General Public License Version 2.0
11  *
12  * Project home: http://compcache.googlecode.com
13  */
14
15 #define KMSG_COMPONENT "zram"
16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
17
18 #ifdef CONFIG_ZRAM_DEBUG
19 #define DEBUG
20 #endif
21
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/bio.h>
25 #include <linux/bitops.h>
26 #include <linux/blkdev.h>
27 #include <linux/buffer_head.h>
28 #include <linux/device.h>
29 #include <linux/genhd.h>
30 #include <linux/highmem.h>
31 #include <linux/slab.h>
32 #include <linux/lzo.h>
33 #include <linux/string.h>
34 #include <linux/vmalloc.h>
35
36 #include "zram_drv.h"
37
38 /* Globals */
39 static int zram_major;
40 struct zram *devices;
41
42 /* Module params (documentation at end) */
43 unsigned int num_devices;
44
45 static void zram_stat_inc(u32 *v)
46 {
47         *v = *v + 1;
48 }
49
50 static void zram_stat_dec(u32 *v)
51 {
52         *v = *v - 1;
53 }
54
55 static void zram_stat64_add(struct zram *zram, u64 *v, u64 inc)
56 {
57         spin_lock(&zram->stat64_lock);
58         *v = *v + inc;
59         spin_unlock(&zram->stat64_lock);
60 }
61
62 static void zram_stat64_sub(struct zram *zram, u64 *v, u64 dec)
63 {
64         spin_lock(&zram->stat64_lock);
65         *v = *v - dec;
66         spin_unlock(&zram->stat64_lock);
67 }
68
69 static void zram_stat64_inc(struct zram *zram, u64 *v)
70 {
71         zram_stat64_add(zram, v, 1);
72 }
73
74 static int zram_test_flag(struct zram *zram, u32 index,
75                         enum zram_pageflags flag)
76 {
77         return zram->table[index].flags & BIT(flag);
78 }
79
80 static void zram_set_flag(struct zram *zram, u32 index,
81                         enum zram_pageflags flag)
82 {
83         zram->table[index].flags |= BIT(flag);
84 }
85
86 static void zram_clear_flag(struct zram *zram, u32 index,
87                         enum zram_pageflags flag)
88 {
89         zram->table[index].flags &= ~BIT(flag);
90 }
91
92 static int page_zero_filled(void *ptr)
93 {
94         unsigned int pos;
95         unsigned long *page;
96
97         page = (unsigned long *)ptr;
98
99         for (pos = 0; pos != PAGE_SIZE / sizeof(*page); pos++) {
100                 if (page[pos])
101                         return 0;
102         }
103
104         return 1;
105 }
106
107 static void zram_set_disksize(struct zram *zram, size_t totalram_bytes)
108 {
109         if (!zram->disksize) {
110                 pr_info(
111                 "disk size not provided. You can use disksize_kb module "
112                 "param to specify size.\nUsing default: (%u%% of RAM).\n",
113                 default_disksize_perc_ram
114                 );
115                 zram->disksize = default_disksize_perc_ram *
116                                         (totalram_bytes / 100);
117         }
118
119         if (zram->disksize > 2 * (totalram_bytes)) {
120                 pr_info(
121                 "There is little point creating a zram of greater than "
122                 "twice the size of memory since we expect a 2:1 compression "
123                 "ratio. Note that zram uses about 0.1%% of the size of "
124                 "the disk when not in use so a huge zram is "
125                 "wasteful.\n"
126                 "\tMemory Size: %zu kB\n"
127                 "\tSize you selected: %llu kB\n"
128                 "Continuing anyway ...\n",
129                 totalram_bytes >> 10, zram->disksize
130                 );
131         }
132
133         zram->disksize &= PAGE_MASK;
134 }
135
136 static void zram_free_page(struct zram *zram, size_t index)
137 {
138         u32 clen;
139         void *obj;
140
141         struct page *page = zram->table[index].page;
142         u32 offset = zram->table[index].offset;
143
144         if (unlikely(!page)) {
145                 /*
146                  * No memory is allocated for zero filled pages.
147                  * Simply clear zero page flag.
148                  */
149                 if (zram_test_flag(zram, index, ZRAM_ZERO)) {
150                         zram_clear_flag(zram, index, ZRAM_ZERO);
151                         zram_stat_dec(&zram->stats.pages_zero);
152                 }
153                 return;
154         }
155
156         if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
157                 clen = PAGE_SIZE;
158                 __free_page(page);
159                 zram_clear_flag(zram, index, ZRAM_UNCOMPRESSED);
160                 zram_stat_dec(&zram->stats.pages_expand);
161                 goto out;
162         }
163
164         obj = kmap_atomic(page, KM_USER0) + offset;
165         clen = xv_get_object_size(obj) - sizeof(struct zobj_header);
166         kunmap_atomic(obj, KM_USER0);
167
168         xv_free(zram->mem_pool, page, offset);
169         if (clen <= PAGE_SIZE / 2)
170                 zram_stat_dec(&zram->stats.good_compress);
171
172 out:
173         zram_stat64_sub(zram, &zram->stats.compr_size, clen);
174         zram_stat_dec(&zram->stats.pages_stored);
175
176         zram->table[index].page = NULL;
177         zram->table[index].offset = 0;
178 }
179
180 static void handle_zero_page(struct bio_vec *bvec)
181 {
182         struct page *page = bvec->bv_page;
183         void *user_mem;
184
185         user_mem = kmap_atomic(page, KM_USER0);
186         memset(user_mem + bvec->bv_offset, 0, bvec->bv_len);
187         kunmap_atomic(user_mem, KM_USER0);
188
189         flush_dcache_page(page);
190 }
191
192 static void handle_uncompressed_page(struct zram *zram, struct bio_vec *bvec,
193                                      u32 index, int offset)
194 {
195         struct page *page = bvec->bv_page;
196         unsigned char *user_mem, *cmem;
197
198         user_mem = kmap_atomic(page, KM_USER0);
199         cmem = kmap_atomic(zram->table[index].page, KM_USER1);
200
201         memcpy(user_mem + bvec->bv_offset, cmem + offset, bvec->bv_len);
202         kunmap_atomic(cmem, KM_USER1);
203         kunmap_atomic(user_mem, KM_USER0);
204
205         flush_dcache_page(page);
206 }
207
208 static inline int is_partial_io(struct bio_vec *bvec)
209 {
210         return bvec->bv_len != PAGE_SIZE;
211 }
212
213 static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
214                           u32 index, int offset, struct bio *bio)
215 {
216         int ret;
217         size_t clen;
218         struct page *page;
219         struct zobj_header *zheader;
220         unsigned char *user_mem, *cmem, *uncmem = NULL;
221
222         page = bvec->bv_page;
223
224         if (zram_test_flag(zram, index, ZRAM_ZERO)) {
225                 handle_zero_page(bvec);
226                 return 0;
227         }
228
229         /* Requested page is not present in compressed area */
230         if (unlikely(!zram->table[index].page)) {
231                 pr_debug("Read before write: sector=%lu, size=%u",
232                          (ulong)(bio->bi_sector), bio->bi_size);
233                 handle_zero_page(bvec);
234                 return 0;
235         }
236
237         /* Page is stored uncompressed since it's incompressible */
238         if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
239                 handle_uncompressed_page(zram, bvec, index, offset);
240                 return 0;
241         }
242
243         if (is_partial_io(bvec)) {
244                 /* Use  a temporary buffer to decompress the page */
245                 uncmem = kmalloc(PAGE_SIZE, GFP_KERNEL);
246                 if (!uncmem) {
247                         pr_info("Error allocating temp memory!\n");
248                         return -ENOMEM;
249                 }
250         }
251
252         user_mem = kmap_atomic(page, KM_USER0);
253         if (!is_partial_io(bvec))
254                 uncmem = user_mem;
255         clen = PAGE_SIZE;
256
257         cmem = kmap_atomic(zram->table[index].page, KM_USER1) +
258                 zram->table[index].offset;
259
260         ret = lzo1x_decompress_safe(cmem + sizeof(*zheader),
261                                     xv_get_object_size(cmem) - sizeof(*zheader),
262                                     uncmem, &clen);
263
264         if (is_partial_io(bvec)) {
265                 memcpy(user_mem + bvec->bv_offset, uncmem + offset,
266                        bvec->bv_len);
267                 kfree(uncmem);
268         }
269
270         kunmap_atomic(cmem, KM_USER1);
271         kunmap_atomic(user_mem, KM_USER0);
272
273         /* Should NEVER happen. Return bio error if it does. */
274         if (unlikely(ret != LZO_E_OK)) {
275                 pr_err("Decompression failed! err=%d, page=%u\n", ret, index);
276                 zram_stat64_inc(zram, &zram->stats.failed_reads);
277                 return ret;
278         }
279
280         flush_dcache_page(page);
281
282         return 0;
283 }
284
285 static int zram_read_before_write(struct zram *zram, char *mem, u32 index)
286 {
287         int ret;
288         size_t clen = PAGE_SIZE;
289         struct zobj_header *zheader;
290         unsigned char *cmem;
291
292         if (zram_test_flag(zram, index, ZRAM_ZERO) ||
293             !zram->table[index].page) {
294                 memset(mem, 0, PAGE_SIZE);
295                 return 0;
296         }
297
298         cmem = kmap_atomic(zram->table[index].page, KM_USER0) +
299                 zram->table[index].offset;
300
301         /* Page is stored uncompressed since it's incompressible */
302         if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
303                 memcpy(mem, cmem, PAGE_SIZE);
304                 kunmap_atomic(cmem, KM_USER0);
305                 return 0;
306         }
307
308         ret = lzo1x_decompress_safe(cmem + sizeof(*zheader),
309                                     xv_get_object_size(cmem) - sizeof(*zheader),
310                                     mem, &clen);
311         kunmap_atomic(cmem, KM_USER0);
312
313         /* Should NEVER happen. Return bio error if it does. */
314         if (unlikely(ret != LZO_E_OK)) {
315                 pr_err("Decompression failed! err=%d, page=%u\n", ret, index);
316                 zram_stat64_inc(zram, &zram->stats.failed_reads);
317                 return ret;
318         }
319
320         return 0;
321 }
322
323 static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
324                            int offset)
325 {
326         int ret;
327         u32 store_offset;
328         size_t clen;
329         struct zobj_header *zheader;
330         struct page *page, *page_store;
331         unsigned char *user_mem, *cmem, *src, *uncmem = NULL;
332
333         page = bvec->bv_page;
334         src = zram->compress_buffer;
335
336         if (is_partial_io(bvec)) {
337                 /*
338                  * This is a partial IO. We need to read the full page
339                  * before to write the changes.
340                  */
341                 uncmem = kmalloc(PAGE_SIZE, GFP_KERNEL);
342                 if (!uncmem) {
343                         pr_info("Error allocating temp memory!\n");
344                         ret = -ENOMEM;
345                         goto out;
346                 }
347                 ret = zram_read_before_write(zram, uncmem, index);
348                 if (ret) {
349                         kfree(uncmem);
350                         goto out;
351                 }
352         }
353
354         /*
355          * System overwrites unused sectors. Free memory associated
356          * with this sector now.
357          */
358         if (zram->table[index].page ||
359             zram_test_flag(zram, index, ZRAM_ZERO))
360                 zram_free_page(zram, index);
361
362         user_mem = kmap_atomic(page, KM_USER0);
363
364         if (is_partial_io(bvec))
365                 memcpy(uncmem + offset, user_mem + bvec->bv_offset,
366                        bvec->bv_len);
367         else
368                 uncmem = user_mem;
369
370         if (page_zero_filled(uncmem)) {
371                 kunmap_atomic(user_mem, KM_USER0);
372                 if (is_partial_io(bvec))
373                         kfree(uncmem);
374                 zram_stat_inc(&zram->stats.pages_zero);
375                 zram_set_flag(zram, index, ZRAM_ZERO);
376                 ret = 0;
377                 goto out;
378         }
379
380         ret = lzo1x_1_compress(uncmem, PAGE_SIZE, src, &clen,
381                                zram->compress_workmem);
382
383         kunmap_atomic(user_mem, KM_USER0);
384         if (is_partial_io(bvec))
385                         kfree(uncmem);
386
387         if (unlikely(ret != LZO_E_OK)) {
388                 pr_err("Compression failed! err=%d\n", ret);
389                 goto out;
390         }
391
392         /*
393          * Page is incompressible. Store it as-is (uncompressed)
394          * since we do not want to return too many disk write
395          * errors which has side effect of hanging the system.
396          */
397         if (unlikely(clen > max_zpage_size)) {
398                 clen = PAGE_SIZE;
399                 page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
400                 if (unlikely(!page_store)) {
401                         pr_info("Error allocating memory for "
402                                 "incompressible page: %u\n", index);
403                         ret = -ENOMEM;
404                         goto out;
405                 }
406
407                 store_offset = 0;
408                 zram_set_flag(zram, index, ZRAM_UNCOMPRESSED);
409                 zram_stat_inc(&zram->stats.pages_expand);
410                 zram->table[index].page = page_store;
411                 src = kmap_atomic(page, KM_USER0);
412                 goto memstore;
413         }
414
415         if (xv_malloc(zram->mem_pool, clen + sizeof(*zheader),
416                       &zram->table[index].page, &store_offset,
417                       GFP_NOIO | __GFP_HIGHMEM)) {
418                 pr_info("Error allocating memory for compressed "
419                         "page: %u, size=%zu\n", index, clen);
420                 ret = -ENOMEM;
421                 goto out;
422         }
423
424 memstore:
425         zram->table[index].offset = store_offset;
426
427         cmem = kmap_atomic(zram->table[index].page, KM_USER1) +
428                 zram->table[index].offset;
429
430 #if 0
431         /* Back-reference needed for memory defragmentation */
432         if (!zram_test_flag(zram, index, ZRAM_UNCOMPRESSED)) {
433                 zheader = (struct zobj_header *)cmem;
434                 zheader->table_idx = index;
435                 cmem += sizeof(*zheader);
436         }
437 #endif
438
439         memcpy(cmem, src, clen);
440
441         kunmap_atomic(cmem, KM_USER1);
442         if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED)))
443                 kunmap_atomic(src, KM_USER0);
444
445         /* Update stats */
446         zram_stat64_add(zram, &zram->stats.compr_size, clen);
447         zram_stat_inc(&zram->stats.pages_stored);
448         if (clen <= PAGE_SIZE / 2)
449                 zram_stat_inc(&zram->stats.good_compress);
450
451         return 0;
452
453 out:
454         if (ret)
455                 zram_stat64_inc(zram, &zram->stats.failed_writes);
456         return ret;
457 }
458
459 static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
460                         int offset, struct bio *bio, int rw)
461 {
462         int ret;
463
464         if (rw == READ) {
465                 down_read(&zram->lock);
466                 ret = zram_bvec_read(zram, bvec, index, offset, bio);
467                 up_read(&zram->lock);
468         } else {
469                 down_write(&zram->lock);
470                 ret = zram_bvec_write(zram, bvec, index, offset);
471                 up_write(&zram->lock);
472         }
473
474         return ret;
475 }
476
477 static void update_position(u32 *index, int *offset, struct bio_vec *bvec)
478 {
479         if (*offset + bvec->bv_len >= PAGE_SIZE)
480                 (*index)++;
481         *offset = (*offset + bvec->bv_len) % PAGE_SIZE;
482 }
483
484 static void __zram_make_request(struct zram *zram, struct bio *bio, int rw)
485 {
486         int i, offset;
487         u32 index;
488         struct bio_vec *bvec;
489
490         switch (rw) {
491         case READ:
492                 zram_stat64_inc(zram, &zram->stats.num_reads);
493                 break;
494         case WRITE:
495                 zram_stat64_inc(zram, &zram->stats.num_writes);
496                 break;
497         }
498
499         index = bio->bi_sector >> SECTORS_PER_PAGE_SHIFT;
500         offset = (bio->bi_sector & (SECTORS_PER_PAGE - 1)) << SECTOR_SHIFT;
501
502         bio_for_each_segment(bvec, bio, i) {
503                 int max_transfer_size = PAGE_SIZE - offset;
504
505                 if (bvec->bv_len > max_transfer_size) {
506                         /*
507                          * zram_bvec_rw() can only make operation on a single
508                          * zram page. Split the bio vector.
509                          */
510                         struct bio_vec bv;
511
512                         bv.bv_page = bvec->bv_page;
513                         bv.bv_len = max_transfer_size;
514                         bv.bv_offset = bvec->bv_offset;
515
516                         if (zram_bvec_rw(zram, &bv, index, offset, bio, rw) < 0)
517                                 goto out;
518
519                         bv.bv_len = bvec->bv_len - max_transfer_size;
520                         bv.bv_offset += max_transfer_size;
521                         if (zram_bvec_rw(zram, &bv, index+1, 0, bio, rw) < 0)
522                                 goto out;
523                 } else
524                         if (zram_bvec_rw(zram, bvec, index, offset, bio, rw)
525                             < 0)
526                                 goto out;
527
528                 update_position(&index, &offset, bvec);
529         }
530
531         set_bit(BIO_UPTODATE, &bio->bi_flags);
532         bio_endio(bio, 0);
533         return;
534
535 out:
536         bio_io_error(bio);
537 }
538
539 /*
540  * Check if request is within bounds and aligned on zram logical blocks.
541  */
542 static inline int valid_io_request(struct zram *zram, struct bio *bio)
543 {
544         if (unlikely(
545                 (bio->bi_sector >= (zram->disksize >> SECTOR_SHIFT)) ||
546                 (bio->bi_sector & (ZRAM_SECTOR_PER_LOGICAL_BLOCK - 1)) ||
547                 (bio->bi_size & (ZRAM_LOGICAL_BLOCK_SIZE - 1)))) {
548
549                 return 0;
550         }
551
552         /* I/O request is valid */
553         return 1;
554 }
555
556 /*
557  * Handler function for all zram I/O requests.
558  */
559 static void zram_make_request(struct request_queue *queue, struct bio *bio)
560 {
561         struct zram *zram = queue->queuedata;
562
563         if (!valid_io_request(zram, bio)) {
564                 zram_stat64_inc(zram, &zram->stats.invalid_io);
565                 bio_io_error(bio);
566                 return;
567         }
568
569         if (unlikely(!zram->init_done) && zram_init_device(zram)) {
570                 bio_io_error(bio);
571                 return;
572         }
573
574         __zram_make_request(zram, bio, bio_data_dir(bio));
575 }
576
577 void zram_reset_device(struct zram *zram)
578 {
579         size_t index;
580
581         mutex_lock(&zram->init_lock);
582         zram->init_done = 0;
583
584         /* Free various per-device buffers */
585         kfree(zram->compress_workmem);
586         free_pages((unsigned long)zram->compress_buffer, 1);
587
588         zram->compress_workmem = NULL;
589         zram->compress_buffer = NULL;
590
591         /* Free all pages that are still in this zram device */
592         for (index = 0; index < zram->disksize >> PAGE_SHIFT; index++) {
593                 struct page *page;
594                 u16 offset;
595
596                 page = zram->table[index].page;
597                 offset = zram->table[index].offset;
598
599                 if (!page)
600                         continue;
601
602                 if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED)))
603                         __free_page(page);
604                 else
605                         xv_free(zram->mem_pool, page, offset);
606         }
607
608         vfree(zram->table);
609         zram->table = NULL;
610
611         xv_destroy_pool(zram->mem_pool);
612         zram->mem_pool = NULL;
613
614         /* Reset stats */
615         memset(&zram->stats, 0, sizeof(zram->stats));
616
617         zram->disksize = 0;
618         mutex_unlock(&zram->init_lock);
619 }
620
621 int zram_init_device(struct zram *zram)
622 {
623         int ret;
624         size_t num_pages;
625
626         mutex_lock(&zram->init_lock);
627
628         if (zram->init_done) {
629                 mutex_unlock(&zram->init_lock);
630                 return 0;
631         }
632
633         zram_set_disksize(zram, totalram_pages << PAGE_SHIFT);
634
635         zram->compress_workmem = kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
636         if (!zram->compress_workmem) {
637                 pr_err("Error allocating compressor working memory!\n");
638                 ret = -ENOMEM;
639                 goto fail;
640         }
641
642         zram->compress_buffer = (void *)__get_free_pages(__GFP_ZERO, 1);
643         if (!zram->compress_buffer) {
644                 pr_err("Error allocating compressor buffer space\n");
645                 ret = -ENOMEM;
646                 goto fail;
647         }
648
649         num_pages = zram->disksize >> PAGE_SHIFT;
650         zram->table = vzalloc(num_pages * sizeof(*zram->table));
651         if (!zram->table) {
652                 pr_err("Error allocating zram address table\n");
653                 /* To prevent accessing table entries during cleanup */
654                 zram->disksize = 0;
655                 ret = -ENOMEM;
656                 goto fail;
657         }
658
659         set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
660
661         /* zram devices sort of resembles non-rotational disks */
662         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zram->disk->queue);
663
664         zram->mem_pool = xv_create_pool();
665         if (!zram->mem_pool) {
666                 pr_err("Error creating memory pool\n");
667                 ret = -ENOMEM;
668                 goto fail;
669         }
670
671         zram->init_done = 1;
672         mutex_unlock(&zram->init_lock);
673
674         pr_debug("Initialization done!\n");
675         return 0;
676
677 fail:
678         mutex_unlock(&zram->init_lock);
679         zram_reset_device(zram);
680
681         pr_err("Initialization failed: err=%d\n", ret);
682         return ret;
683 }
684
685 void zram_slot_free_notify(struct block_device *bdev, unsigned long index)
686 {
687         struct zram *zram;
688
689         zram = bdev->bd_disk->private_data;
690         zram_free_page(zram, index);
691         zram_stat64_inc(zram, &zram->stats.notify_free);
692 }
693
694 static const struct block_device_operations zram_devops = {
695         .swap_slot_free_notify = zram_slot_free_notify,
696         .owner = THIS_MODULE
697 };
698
699 static int create_device(struct zram *zram, int device_id)
700 {
701         int ret = 0;
702
703         init_rwsem(&zram->lock);
704         mutex_init(&zram->init_lock);
705         spin_lock_init(&zram->stat64_lock);
706
707         zram->queue = blk_alloc_queue(GFP_KERNEL);
708         if (!zram->queue) {
709                 pr_err("Error allocating disk queue for device %d\n",
710                         device_id);
711                 ret = -ENOMEM;
712                 goto out;
713         }
714
715         blk_queue_make_request(zram->queue, zram_make_request);
716         zram->queue->queuedata = zram;
717
718          /* gendisk structure */
719         zram->disk = alloc_disk(1);
720         if (!zram->disk) {
721                 blk_cleanup_queue(zram->queue);
722                 pr_warning("Error allocating disk structure for device %d\n",
723                         device_id);
724                 ret = -ENOMEM;
725                 goto out;
726         }
727
728         zram->disk->major = zram_major;
729         zram->disk->first_minor = device_id;
730         zram->disk->fops = &zram_devops;
731         zram->disk->queue = zram->queue;
732         zram->disk->private_data = zram;
733         snprintf(zram->disk->disk_name, 16, "zram%d", device_id);
734
735         /* Actual capacity set using syfs (/sys/block/zram<id>/disksize */
736         set_capacity(zram->disk, 0);
737
738         /*
739          * To ensure that we always get PAGE_SIZE aligned
740          * and n*PAGE_SIZED sized I/O requests.
741          */
742         blk_queue_physical_block_size(zram->disk->queue, PAGE_SIZE);
743         blk_queue_logical_block_size(zram->disk->queue,
744                                         ZRAM_LOGICAL_BLOCK_SIZE);
745         blk_queue_io_min(zram->disk->queue, PAGE_SIZE);
746         blk_queue_io_opt(zram->disk->queue, PAGE_SIZE);
747
748         add_disk(zram->disk);
749
750         ret = sysfs_create_group(&disk_to_dev(zram->disk)->kobj,
751                                 &zram_disk_attr_group);
752         if (ret < 0) {
753                 pr_warning("Error creating sysfs group");
754                 goto out;
755         }
756
757         zram->init_done = 0;
758
759 out:
760         return ret;
761 }
762
763 static void destroy_device(struct zram *zram)
764 {
765         sysfs_remove_group(&disk_to_dev(zram->disk)->kobj,
766                         &zram_disk_attr_group);
767
768         if (zram->disk) {
769                 del_gendisk(zram->disk);
770                 put_disk(zram->disk);
771         }
772
773         if (zram->queue)
774                 blk_cleanup_queue(zram->queue);
775 }
776
777 static int __init zram_init(void)
778 {
779         int ret, dev_id;
780
781         if (num_devices > max_num_devices) {
782                 pr_warning("Invalid value for num_devices: %u\n",
783                                 num_devices);
784                 ret = -EINVAL;
785                 goto out;
786         }
787
788         zram_major = register_blkdev(0, "zram");
789         if (zram_major <= 0) {
790                 pr_warning("Unable to get major number\n");
791                 ret = -EBUSY;
792                 goto out;
793         }
794
795         if (!num_devices) {
796                 pr_info("num_devices not specified. Using default: 1\n");
797                 num_devices = 1;
798         }
799
800         /* Allocate the device array and initialize each one */
801         pr_info("Creating %u devices ...\n", num_devices);
802         devices = kzalloc(num_devices * sizeof(struct zram), GFP_KERNEL);
803         if (!devices) {
804                 ret = -ENOMEM;
805                 goto unregister;
806         }
807
808         for (dev_id = 0; dev_id < num_devices; dev_id++) {
809                 ret = create_device(&devices[dev_id], dev_id);
810                 if (ret)
811                         goto free_devices;
812         }
813
814         return 0;
815
816 free_devices:
817         while (dev_id)
818                 destroy_device(&devices[--dev_id]);
819         kfree(devices);
820 unregister:
821         unregister_blkdev(zram_major, "zram");
822 out:
823         return ret;
824 }
825
826 static void __exit zram_exit(void)
827 {
828         int i;
829         struct zram *zram;
830
831         for (i = 0; i < num_devices; i++) {
832                 zram = &devices[i];
833
834                 destroy_device(zram);
835                 if (zram->init_done)
836                         zram_reset_device(zram);
837         }
838
839         unregister_blkdev(zram_major, "zram");
840
841         kfree(devices);
842         pr_debug("Cleanup done!\n");
843 }
844
845 module_param(num_devices, uint, 0);
846 MODULE_PARM_DESC(num_devices, "Number of zram devices");
847
848 module_init(zram_init);
849 module_exit(zram_exit);
850
851 MODULE_LICENSE("Dual BSD/GPL");
852 MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");
853 MODULE_DESCRIPTION("Compressed RAM Block Device");