source: src/linux/universal/linux-3.18/drivers/block/zram/zram_drv.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 6 weeks ago

update

File size: 27.5 KB
Line 
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#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/string.h>
33#include <linux/vmalloc.h>
34#include <linux/err.h>
35
36#include "zram_drv.h"
37
38/* Globals */
39static int zram_major;
40static struct zram *zram_devices;
41static const char *default_compressor = "lzo";
42
43/* Module params (documentation at end) */
44static unsigned int num_devices = 1;
45
46#define ZRAM_ATTR_RO(name)                                              \
47static ssize_t zram_attr_##name##_show(struct device *d,                \
48                                struct device_attribute *attr, char *b) \
49{                                                                       \
50        struct zram *zram = dev_to_zram(d);                             \
51        return scnprintf(b, PAGE_SIZE, "%llu\n",                        \
52                (u64)atomic64_read(&zram->stats.name));                 \
53}                                                                       \
54static struct device_attribute dev_attr_##name =                        \
55        __ATTR(name, S_IRUGO, zram_attr_##name##_show, NULL);
56
57static inline int init_done(struct zram *zram)
58{
59        return zram->meta != NULL;
60}
61
62static inline struct zram *dev_to_zram(struct device *dev)
63{
64        return (struct zram *)dev_to_disk(dev)->private_data;
65}
66
67static ssize_t disksize_show(struct device *dev,
68                struct device_attribute *attr, char *buf)
69{
70        struct zram *zram = dev_to_zram(dev);
71
72        return scnprintf(buf, PAGE_SIZE, "%llu\n", zram->disksize);
73}
74
75static ssize_t initstate_show(struct device *dev,
76                struct device_attribute *attr, char *buf)
77{
78        u32 val;
79        struct zram *zram = dev_to_zram(dev);
80
81        down_read(&zram->init_lock);
82        val = init_done(zram);
83        up_read(&zram->init_lock);
84
85        return scnprintf(buf, PAGE_SIZE, "%u\n", val);
86}
87
88static ssize_t orig_data_size_show(struct device *dev,
89                struct device_attribute *attr, char *buf)
90{
91        struct zram *zram = dev_to_zram(dev);
92
93        return scnprintf(buf, PAGE_SIZE, "%llu\n",
94                (u64)(atomic64_read(&zram->stats.pages_stored)) << PAGE_SHIFT);
95}
96
97static ssize_t mem_used_total_show(struct device *dev,
98                struct device_attribute *attr, char *buf)
99{
100        u64 val = 0;
101        struct zram *zram = dev_to_zram(dev);
102
103        down_read(&zram->init_lock);
104        if (init_done(zram)) {
105                struct zram_meta *meta = zram->meta;
106                val = zs_get_total_pages(meta->mem_pool);
107        }
108        up_read(&zram->init_lock);
109
110        return scnprintf(buf, PAGE_SIZE, "%llu\n", val << PAGE_SHIFT);
111}
112
113static ssize_t max_comp_streams_show(struct device *dev,
114                struct device_attribute *attr, char *buf)
115{
116        int val;
117        struct zram *zram = dev_to_zram(dev);
118
119        down_read(&zram->init_lock);
120        val = zram->max_comp_streams;
121        up_read(&zram->init_lock);
122
123        return scnprintf(buf, PAGE_SIZE, "%d\n", val);
124}
125
126static ssize_t mem_limit_show(struct device *dev,
127                struct device_attribute *attr, char *buf)
128{
129        u64 val;
130        struct zram *zram = dev_to_zram(dev);
131
132        down_read(&zram->init_lock);
133        val = zram->limit_pages;
134        up_read(&zram->init_lock);
135
136        return scnprintf(buf, PAGE_SIZE, "%llu\n", val << PAGE_SHIFT);
137}
138
139static ssize_t mem_limit_store(struct device *dev,
140                struct device_attribute *attr, const char *buf, size_t len)
141{
142        u64 limit;
143        char *tmp;
144        struct zram *zram = dev_to_zram(dev);
145
146        limit = memparse(buf, &tmp);
147        if (buf == tmp) /* no chars parsed, invalid input */
148                return -EINVAL;
149
150        down_write(&zram->init_lock);
151        zram->limit_pages = PAGE_ALIGN(limit) >> PAGE_SHIFT;
152        up_write(&zram->init_lock);
153
154        return len;
155}
156
157static ssize_t mem_used_max_show(struct device *dev,
158                struct device_attribute *attr, char *buf)
159{
160        u64 val = 0;
161        struct zram *zram = dev_to_zram(dev);
162
163        down_read(&zram->init_lock);
164        if (init_done(zram))
165                val = atomic_long_read(&zram->stats.max_used_pages);
166        up_read(&zram->init_lock);
167
168        return scnprintf(buf, PAGE_SIZE, "%llu\n", val << PAGE_SHIFT);
169}
170
171static ssize_t mem_used_max_store(struct device *dev,
172                struct device_attribute *attr, const char *buf, size_t len)
173{
174        int err;
175        unsigned long val;
176        struct zram *zram = dev_to_zram(dev);
177
178        err = kstrtoul(buf, 10, &val);
179        if (err || val != 0)
180                return -EINVAL;
181
182        down_read(&zram->init_lock);
183        if (init_done(zram)) {
184                struct zram_meta *meta = zram->meta;
185                atomic_long_set(&zram->stats.max_used_pages,
186                                zs_get_total_pages(meta->mem_pool));
187        }
188        up_read(&zram->init_lock);
189
190        return len;
191}
192
193static ssize_t max_comp_streams_store(struct device *dev,
194                struct device_attribute *attr, const char *buf, size_t len)
195{
196        int num;
197        struct zram *zram = dev_to_zram(dev);
198        int ret;
199
200        ret = kstrtoint(buf, 0, &num);
201        if (ret < 0)
202                return ret;
203        if (num < 1)
204                return -EINVAL;
205
206        down_write(&zram->init_lock);
207        if (init_done(zram)) {
208                if (!zcomp_set_max_streams(zram->comp, num)) {
209                        pr_info("Cannot change max compression streams\n");
210                        ret = -EINVAL;
211                        goto out;
212                }
213        }
214
215        zram->max_comp_streams = num;
216        ret = len;
217out:
218        up_write(&zram->init_lock);
219        return ret;
220}
221
222static ssize_t comp_algorithm_show(struct device *dev,
223                struct device_attribute *attr, char *buf)
224{
225        size_t sz;
226        struct zram *zram = dev_to_zram(dev);
227
228        down_read(&zram->init_lock);
229        sz = zcomp_available_show(zram->compressor, buf);
230        up_read(&zram->init_lock);
231
232        return sz;
233}
234
235static ssize_t comp_algorithm_store(struct device *dev,
236                struct device_attribute *attr, const char *buf, size_t len)
237{
238        struct zram *zram = dev_to_zram(dev);
239        down_write(&zram->init_lock);
240        if (init_done(zram)) {
241                up_write(&zram->init_lock);
242                pr_info("Can't change algorithm for initialized device\n");
243                return -EBUSY;
244        }
245        strlcpy(zram->compressor, buf, sizeof(zram->compressor));
246        up_write(&zram->init_lock);
247        return len;
248}
249
250/* flag operations needs meta->tb_lock */
251static int zram_test_flag(struct zram_meta *meta, u32 index,
252                        enum zram_pageflags flag)
253{
254        return meta->table[index].value & BIT(flag);
255}
256
257static void zram_set_flag(struct zram_meta *meta, u32 index,
258                        enum zram_pageflags flag)
259{
260        meta->table[index].value |= BIT(flag);
261}
262
263static void zram_clear_flag(struct zram_meta *meta, u32 index,
264                        enum zram_pageflags flag)
265{
266        meta->table[index].value &= ~BIT(flag);
267}
268
269static size_t zram_get_obj_size(struct zram_meta *meta, u32 index)
270{
271        return meta->table[index].value & (BIT(ZRAM_FLAG_SHIFT) - 1);
272}
273
274static void zram_set_obj_size(struct zram_meta *meta,
275                                        u32 index, size_t size)
276{
277        unsigned long flags = meta->table[index].value >> ZRAM_FLAG_SHIFT;
278
279        meta->table[index].value = (flags << ZRAM_FLAG_SHIFT) | size;
280}
281
282static inline int is_partial_io(struct bio_vec *bvec)
283{
284        return bvec->bv_len != PAGE_SIZE;
285}
286
287/*
288 * Check if request is within bounds and aligned on zram logical blocks.
289 */
290static inline int valid_io_request(struct zram *zram, struct bio *bio)
291{
292        u64 start, end, bound;
293
294        /* unaligned request */
295        if (unlikely(bio->bi_iter.bi_sector &
296                     (ZRAM_SECTOR_PER_LOGICAL_BLOCK - 1)))
297                return 0;
298        if (unlikely(bio->bi_iter.bi_size & (ZRAM_LOGICAL_BLOCK_SIZE - 1)))
299                return 0;
300
301        start = bio->bi_iter.bi_sector;
302        end = start + (bio->bi_iter.bi_size >> SECTOR_SHIFT);
303        bound = zram->disksize >> SECTOR_SHIFT;
304        /* out of range range */
305        if (unlikely(start >= bound || end > bound || start > end))
306                return 0;
307
308        /* I/O request is valid */
309        return 1;
310}
311
312static void zram_meta_free(struct zram_meta *meta)
313{
314        zs_destroy_pool(meta->mem_pool);
315        vfree(meta->table);
316        kfree(meta);
317}
318
319static struct zram_meta *zram_meta_alloc(u64 disksize)
320{
321        size_t num_pages;
322        struct zram_meta *meta = kmalloc(sizeof(*meta), GFP_KERNEL);
323        if (!meta)
324                goto out;
325
326        num_pages = disksize >> PAGE_SHIFT;
327        meta->table = vzalloc(num_pages * sizeof(*meta->table));
328        if (!meta->table) {
329                pr_err("Error allocating zram address table\n");
330                goto free_meta;
331        }
332
333        meta->mem_pool = zs_create_pool(GFP_NOIO | __GFP_HIGHMEM);
334        if (!meta->mem_pool) {
335                pr_err("Error creating memory pool\n");
336                goto free_table;
337        }
338
339        return meta;
340
341free_table:
342        vfree(meta->table);
343free_meta:
344        kfree(meta);
345        meta = NULL;
346out:
347        return meta;
348}
349
350static void update_position(u32 *index, int *offset, struct bio_vec *bvec)
351{
352        if (*offset + bvec->bv_len >= PAGE_SIZE)
353                (*index)++;
354        *offset = (*offset + bvec->bv_len) % PAGE_SIZE;
355}
356
357static int page_zero_filled(void *ptr)
358{
359        unsigned int pos;
360        unsigned long *page;
361
362        page = (unsigned long *)ptr;
363
364        for (pos = 0; pos != PAGE_SIZE / sizeof(*page); pos++) {
365                if (page[pos])
366                        return 0;
367        }
368
369        return 1;
370}
371
372static void handle_zero_page(struct bio_vec *bvec)
373{
374        struct page *page = bvec->bv_page;
375        void *user_mem;
376
377        user_mem = kmap_atomic(page);
378        if (is_partial_io(bvec))
379                memset(user_mem + bvec->bv_offset, 0, bvec->bv_len);
380        else
381                clear_page(user_mem);
382        kunmap_atomic(user_mem);
383
384        flush_dcache_page(page);
385}
386
387
388/*
389 * To protect concurrent access to the same index entry,
390 * caller should hold this table index entry's bit_spinlock to
391 * indicate this index entry is accessing.
392 */
393static void zram_free_page(struct zram *zram, size_t index)
394{
395        struct zram_meta *meta = zram->meta;
396        unsigned long handle = meta->table[index].handle;
397
398        if (unlikely(!handle)) {
399                /*
400                 * No memory is allocated for zero filled pages.
401                 * Simply clear zero page flag.
402                 */
403                if (zram_test_flag(meta, index, ZRAM_ZERO)) {
404                        zram_clear_flag(meta, index, ZRAM_ZERO);
405                        atomic64_dec(&zram->stats.zero_pages);
406                }
407                return;
408        }
409
410        zs_free(meta->mem_pool, handle);
411
412        atomic64_sub(zram_get_obj_size(meta, index),
413                        &zram->stats.compr_data_size);
414        atomic64_dec(&zram->stats.pages_stored);
415
416        meta->table[index].handle = 0;
417        zram_set_obj_size(meta, index, 0);
418}
419
420static int zram_decompress_page(struct zram *zram, char *mem, u32 index)
421{
422        int ret = 0;
423        unsigned char *cmem;
424        struct zram_meta *meta = zram->meta;
425        unsigned long handle;
426        size_t size;
427
428        bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
429        handle = meta->table[index].handle;
430        size = zram_get_obj_size(meta, index);
431
432        if (!handle || zram_test_flag(meta, index, ZRAM_ZERO)) {
433                bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
434                memset(mem, 0, PAGE_SIZE);
435                return 0;
436        }
437
438        cmem = zs_map_object(meta->mem_pool, handle, ZS_MM_RO);
439        if (size == PAGE_SIZE)
440                memcpy(mem, cmem, PAGE_SIZE);
441        else
442                ret = zcomp_decompress(zram->comp, cmem, size, mem);
443        zs_unmap_object(meta->mem_pool, handle);
444        bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
445
446        /* Should NEVER happen. Return bio error if it does. */
447        if (unlikely(ret)) {
448                pr_err("Decompression failed! err=%d, page=%u\n", ret, index);
449                return ret;
450        }
451
452        return 0;
453}
454
455static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
456                          u32 index, int offset, struct bio *bio)
457{
458        int ret;
459        struct page *page;
460        unsigned char *user_mem, *uncmem = NULL;
461        struct zram_meta *meta = zram->meta;
462        page = bvec->bv_page;
463
464        bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
465        if (unlikely(!meta->table[index].handle) ||
466                        zram_test_flag(meta, index, ZRAM_ZERO)) {
467                bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
468                handle_zero_page(bvec);
469                return 0;
470        }
471        bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
472
473        if (is_partial_io(bvec))
474                /* Use  a temporary buffer to decompress the page */
475                uncmem = kmalloc(PAGE_SIZE, GFP_NOIO);
476
477        user_mem = kmap_atomic(page);
478        if (!is_partial_io(bvec))
479                uncmem = user_mem;
480
481        if (!uncmem) {
482                pr_info("Unable to allocate temp memory\n");
483                ret = -ENOMEM;
484                goto out_cleanup;
485        }
486
487        ret = zram_decompress_page(zram, uncmem, index);
488        /* Should NEVER happen. Return bio error if it does. */
489        if (unlikely(ret))
490                goto out_cleanup;
491
492        if (is_partial_io(bvec))
493                memcpy(user_mem + bvec->bv_offset, uncmem + offset,
494                                bvec->bv_len);
495
496        flush_dcache_page(page);
497        ret = 0;
498out_cleanup:
499        kunmap_atomic(user_mem);
500        if (is_partial_io(bvec))
501                kfree(uncmem);
502        return ret;
503}
504
505static inline void update_used_max(struct zram *zram,
506                                        const unsigned long pages)
507{
508        int old_max, cur_max;
509
510        old_max = atomic_long_read(&zram->stats.max_used_pages);
511
512        do {
513                cur_max = old_max;
514                if (pages > cur_max)
515                        old_max = atomic_long_cmpxchg(
516                                &zram->stats.max_used_pages, cur_max, pages);
517        } while (old_max != cur_max);
518}
519
520static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
521                           int offset)
522{
523        int ret = 0;
524        size_t clen;
525        unsigned long handle;
526        struct page *page;
527        unsigned char *user_mem, *cmem, *src, *uncmem = NULL;
528        struct zram_meta *meta = zram->meta;
529        struct zcomp_strm *zstrm;
530        bool locked = false;
531        unsigned long alloced_pages;
532
533        page = bvec->bv_page;
534        if (is_partial_io(bvec)) {
535                /*
536                 * This is a partial IO. We need to read the full page
537                 * before to write the changes.
538                 */
539                uncmem = kmalloc(PAGE_SIZE, GFP_NOIO);
540                if (!uncmem) {
541                        ret = -ENOMEM;
542                        goto out;
543                }
544                ret = zram_decompress_page(zram, uncmem, index);
545                if (ret)
546                        goto out;
547        }
548
549        zstrm = zcomp_strm_find(zram->comp);
550        locked = true;
551        user_mem = kmap_atomic(page);
552
553        if (is_partial_io(bvec)) {
554                memcpy(uncmem + offset, user_mem + bvec->bv_offset,
555                       bvec->bv_len);
556                kunmap_atomic(user_mem);
557                user_mem = NULL;
558        } else {
559                uncmem = user_mem;
560        }
561
562        if (page_zero_filled(uncmem)) {
563                if (user_mem)
564                        kunmap_atomic(user_mem);
565                /* Free memory associated with this sector now. */
566                bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
567                zram_free_page(zram, index);
568                zram_set_flag(meta, index, ZRAM_ZERO);
569                bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
570
571                atomic64_inc(&zram->stats.zero_pages);
572                ret = 0;
573                goto out;
574        }
575
576        ret = zcomp_compress(zram->comp, zstrm, uncmem, &clen);
577        if (!is_partial_io(bvec)) {
578                kunmap_atomic(user_mem);
579                user_mem = NULL;
580                uncmem = NULL;
581        }
582
583        if (unlikely(ret)) {
584                pr_err("Compression failed! err=%d\n", ret);
585                goto out;
586        }
587        src = zstrm->buffer;
588        if (unlikely(clen > max_zpage_size)) {
589                clen = PAGE_SIZE;
590                if (is_partial_io(bvec))
591                        src = uncmem;
592        }
593
594        handle = zs_malloc(meta->mem_pool, clen);
595        if (!handle) {
596                pr_info("Error allocating memory for compressed page: %u, size=%zu\n",
597                        index, clen);
598                ret = -ENOMEM;
599                goto out;
600        }
601
602        alloced_pages = zs_get_total_pages(meta->mem_pool);
603        if (zram->limit_pages && alloced_pages > zram->limit_pages) {
604                zs_free(meta->mem_pool, handle);
605                ret = -ENOMEM;
606                goto out;
607        }
608
609        update_used_max(zram, alloced_pages);
610
611        cmem = zs_map_object(meta->mem_pool, handle, ZS_MM_WO);
612
613        if ((clen == PAGE_SIZE) && !is_partial_io(bvec)) {
614                src = kmap_atomic(page);
615                memcpy(cmem, src, PAGE_SIZE);
616                kunmap_atomic(src);
617        } else {
618                memcpy(cmem, src, clen);
619        }
620
621        zcomp_strm_release(zram->comp, zstrm);
622        locked = false;
623        zs_unmap_object(meta->mem_pool, handle);
624
625        /*
626         * Free memory associated with this sector
627         * before overwriting unused sectors.
628         */
629        bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
630        zram_free_page(zram, index);
631
632        meta->table[index].handle = handle;
633        zram_set_obj_size(meta, index, clen);
634        bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
635
636        /* Update stats */
637        atomic64_add(clen, &zram->stats.compr_data_size);
638        atomic64_inc(&zram->stats.pages_stored);
639out:
640        if (locked)
641                zcomp_strm_release(zram->comp, zstrm);
642        if (is_partial_io(bvec))
643                kfree(uncmem);
644        return ret;
645}
646
647static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
648                        int offset, struct bio *bio)
649{
650        int ret;
651        int rw = bio_data_dir(bio);
652
653        if (rw == READ) {
654                atomic64_inc(&zram->stats.num_reads);
655                ret = zram_bvec_read(zram, bvec, index, offset, bio);
656        } else {
657                atomic64_inc(&zram->stats.num_writes);
658                ret = zram_bvec_write(zram, bvec, index, offset);
659        }
660
661        if (unlikely(ret)) {
662                if (rw == READ)
663                        atomic64_inc(&zram->stats.failed_reads);
664                else
665                        atomic64_inc(&zram->stats.failed_writes);
666        }
667
668        return ret;
669}
670
671/*
672 * zram_bio_discard - handler on discard request
673 * @index: physical block index in PAGE_SIZE units
674 * @offset: byte offset within physical block
675 */
676static void zram_bio_discard(struct zram *zram, u32 index,
677                             int offset, struct bio *bio)
678{
679        size_t n = bio->bi_iter.bi_size;
680        struct zram_meta *meta = zram->meta;
681
682        /*
683         * zram manages data in physical block size units. Because logical block
684         * size isn't identical with physical block size on some arch, we
685         * could get a discard request pointing to a specific offset within a
686         * certain physical block.  Although we can handle this request by
687         * reading that physiclal block and decompressing and partially zeroing
688         * and re-compressing and then re-storing it, this isn't reasonable
689         * because our intent with a discard request is to save memory.  So
690         * skipping this logical block is appropriate here.
691         */
692        if (offset) {
693                if (n <= (PAGE_SIZE - offset))
694                        return;
695
696                n -= (PAGE_SIZE - offset);
697                index++;
698        }
699
700        while (n >= PAGE_SIZE) {
701                bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
702                zram_free_page(zram, index);
703                bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
704                atomic64_inc(&zram->stats.notify_free);
705                index++;
706                n -= PAGE_SIZE;
707        }
708}
709
710static void zram_reset_device(struct zram *zram, bool reset_capacity)
711{
712        size_t index;
713        struct zram_meta *meta;
714
715        down_write(&zram->init_lock);
716
717        zram->limit_pages = 0;
718
719        if (!init_done(zram)) {
720                up_write(&zram->init_lock);
721                return;
722        }
723
724        meta = zram->meta;
725        /* Free all pages that are still in this zram device */
726        for (index = 0; index < zram->disksize >> PAGE_SHIFT; index++) {
727                unsigned long handle = meta->table[index].handle;
728                if (!handle)
729                        continue;
730
731                zs_free(meta->mem_pool, handle);
732        }
733
734        zcomp_destroy(zram->comp);
735        zram->max_comp_streams = 1;
736
737        zram_meta_free(zram->meta);
738        zram->meta = NULL;
739        /* Reset stats */
740        memset(&zram->stats, 0, sizeof(zram->stats));
741
742        zram->disksize = 0;
743        if (reset_capacity)
744                set_capacity(zram->disk, 0);
745
746        up_write(&zram->init_lock);
747
748        /*
749         * Revalidate disk out of the init_lock to avoid lockdep splat.
750         * It's okay because disk's capacity is protected by init_lock
751         * so that revalidate_disk always sees up-to-date capacity.
752         */
753        if (reset_capacity)
754                revalidate_disk(zram->disk);
755}
756
757static ssize_t disksize_store(struct device *dev,
758                struct device_attribute *attr, const char *buf, size_t len)
759{
760        u64 disksize;
761        struct zcomp *comp;
762        struct zram_meta *meta;
763        struct zram *zram = dev_to_zram(dev);
764        int err;
765
766        disksize = memparse(buf, NULL);
767        if (!disksize)
768                return -EINVAL;
769
770        disksize = PAGE_ALIGN(disksize);
771        meta = zram_meta_alloc(disksize);
772        if (!meta)
773                return -ENOMEM;
774
775        comp = zcomp_create(zram->compressor, zram->max_comp_streams);
776        if (IS_ERR(comp)) {
777                pr_info("Cannot initialise %s compressing backend\n",
778                                zram->compressor);
779                err = PTR_ERR(comp);
780                goto out_free_meta;
781        }
782
783        down_write(&zram->init_lock);
784        if (init_done(zram)) {
785                pr_info("Cannot change disksize for initialized device\n");
786                err = -EBUSY;
787                goto out_destroy_comp;
788        }
789
790        zram->meta = meta;
791        zram->comp = comp;
792        zram->disksize = disksize;
793        set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
794        up_write(&zram->init_lock);
795
796        /*
797         * Revalidate disk out of the init_lock to avoid lockdep splat.
798         * It's okay because disk's capacity is protected by init_lock
799         * so that revalidate_disk always sees up-to-date capacity.
800         */
801        revalidate_disk(zram->disk);
802
803        return len;
804
805out_destroy_comp:
806        up_write(&zram->init_lock);
807        zcomp_destroy(comp);
808out_free_meta:
809        zram_meta_free(meta);
810        return err;
811}
812
813static ssize_t reset_store(struct device *dev,
814                struct device_attribute *attr, const char *buf, size_t len)
815{
816        int ret;
817        unsigned short do_reset;
818        struct zram *zram;
819        struct block_device *bdev;
820
821        zram = dev_to_zram(dev);
822        bdev = bdget_disk(zram->disk, 0);
823
824        if (!bdev)
825                return -ENOMEM;
826
827        /* Do not reset an active device! */
828        if (bdev->bd_holders) {
829                ret = -EBUSY;
830                goto out;
831        }
832
833        ret = kstrtou16(buf, 10, &do_reset);
834        if (ret)
835                goto out;
836
837        if (!do_reset) {
838                ret = -EINVAL;
839                goto out;
840        }
841
842        /* Make sure all pending I/O is finished */
843        fsync_bdev(bdev);
844        bdput(bdev);
845
846        zram_reset_device(zram, true);
847        return len;
848
849out:
850        bdput(bdev);
851        return ret;
852}
853
854static void __zram_make_request(struct zram *zram, struct bio *bio)
855{
856        int offset;
857        u32 index;
858        struct bio_vec bvec;
859        struct bvec_iter iter;
860
861        index = bio->bi_iter.bi_sector >> SECTORS_PER_PAGE_SHIFT;
862        offset = (bio->bi_iter.bi_sector &
863                  (SECTORS_PER_PAGE - 1)) << SECTOR_SHIFT;
864
865        if (unlikely(bio->bi_rw & REQ_DISCARD)) {
866                zram_bio_discard(zram, index, offset, bio);
867                bio_endio(bio, 0);
868                return;
869        }
870
871        bio_for_each_segment(bvec, bio, iter) {
872                int max_transfer_size = PAGE_SIZE - offset;
873
874                if (bvec.bv_len > max_transfer_size) {
875                        /*
876                         * zram_bvec_rw() can only make operation on a single
877                         * zram page. Split the bio vector.
878                         */
879                        struct bio_vec bv;
880
881                        bv.bv_page = bvec.bv_page;
882                        bv.bv_len = max_transfer_size;
883                        bv.bv_offset = bvec.bv_offset;
884
885                        if (zram_bvec_rw(zram, &bv, index, offset, bio) < 0)
886                                goto out;
887
888                        bv.bv_len = bvec.bv_len - max_transfer_size;
889                        bv.bv_offset += max_transfer_size;
890                        if (zram_bvec_rw(zram, &bv, index + 1, 0, bio) < 0)
891                                goto out;
892                } else
893                        if (zram_bvec_rw(zram, &bvec, index, offset, bio) < 0)
894                                goto out;
895
896                update_position(&index, &offset, &bvec);
897        }
898
899        set_bit(BIO_UPTODATE, &bio->bi_flags);
900        bio_endio(bio, 0);
901        return;
902
903out:
904        bio_io_error(bio);
905}
906
907/*
908 * Handler function for all zram I/O requests.
909 */
910static void zram_make_request(struct request_queue *queue, struct bio *bio)
911{
912        struct zram *zram = queue->queuedata;
913
914        down_read(&zram->init_lock);
915        if (unlikely(!init_done(zram)))
916                goto error;
917
918        if (!valid_io_request(zram, bio)) {
919                atomic64_inc(&zram->stats.invalid_io);
920                goto error;
921        }
922
923        __zram_make_request(zram, bio);
924        up_read(&zram->init_lock);
925
926        return;
927
928error:
929        up_read(&zram->init_lock);
930        bio_io_error(bio);
931}
932
933static void zram_slot_free_notify(struct block_device *bdev,
934                                unsigned long index)
935{
936        struct zram *zram;
937        struct zram_meta *meta;
938
939        zram = bdev->bd_disk->private_data;
940        meta = zram->meta;
941
942        bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
943        zram_free_page(zram, index);
944        bit_spin_unlock(ZRAM_ACCESS, &meta->table[index].value);
945        atomic64_inc(&zram->stats.notify_free);
946}
947
948static const struct block_device_operations zram_devops = {
949        .swap_slot_free_notify = zram_slot_free_notify,
950        .owner = THIS_MODULE
951};
952
953static DEVICE_ATTR(disksize, S_IRUGO | S_IWUSR,
954                disksize_show, disksize_store);
955static DEVICE_ATTR(initstate, S_IRUGO, initstate_show, NULL);
956static DEVICE_ATTR(reset, S_IWUSR, NULL, reset_store);
957static DEVICE_ATTR(orig_data_size, S_IRUGO, orig_data_size_show, NULL);
958static DEVICE_ATTR(mem_used_total, S_IRUGO, mem_used_total_show, NULL);
959static DEVICE_ATTR(mem_limit, S_IRUGO | S_IWUSR, mem_limit_show,
960                mem_limit_store);
961static DEVICE_ATTR(mem_used_max, S_IRUGO | S_IWUSR, mem_used_max_show,
962                mem_used_max_store);
963static DEVICE_ATTR(max_comp_streams, S_IRUGO | S_IWUSR,
964                max_comp_streams_show, max_comp_streams_store);
965static DEVICE_ATTR(comp_algorithm, S_IRUGO | S_IWUSR,
966                comp_algorithm_show, comp_algorithm_store);
967
968ZRAM_ATTR_RO(num_reads);
969ZRAM_ATTR_RO(num_writes);
970ZRAM_ATTR_RO(failed_reads);
971ZRAM_ATTR_RO(failed_writes);
972ZRAM_ATTR_RO(invalid_io);
973ZRAM_ATTR_RO(notify_free);
974ZRAM_ATTR_RO(zero_pages);
975ZRAM_ATTR_RO(compr_data_size);
976
977static struct attribute *zram_disk_attrs[] = {
978        &dev_attr_disksize.attr,
979        &dev_attr_initstate.attr,
980        &dev_attr_reset.attr,
981        &dev_attr_num_reads.attr,
982        &dev_attr_num_writes.attr,
983        &dev_attr_failed_reads.attr,
984        &dev_attr_failed_writes.attr,
985        &dev_attr_invalid_io.attr,
986        &dev_attr_notify_free.attr,
987        &dev_attr_zero_pages.attr,
988        &dev_attr_orig_data_size.attr,
989        &dev_attr_compr_data_size.attr,
990        &dev_attr_mem_used_total.attr,
991        &dev_attr_mem_limit.attr,
992        &dev_attr_mem_used_max.attr,
993        &dev_attr_max_comp_streams.attr,
994        &dev_attr_comp_algorithm.attr,
995        NULL,
996};
997
998static struct attribute_group zram_disk_attr_group = {
999        .attrs = zram_disk_attrs,
1000};
1001
1002static int create_device(struct zram *zram, int device_id)
1003{
1004        int ret = -ENOMEM;
1005
1006        init_rwsem(&zram->init_lock);
1007
1008        zram->queue = blk_alloc_queue(GFP_KERNEL);
1009        if (!zram->queue) {
1010                pr_err("Error allocating disk queue for device %d\n",
1011                        device_id);
1012                goto out;
1013        }
1014
1015        blk_queue_make_request(zram->queue, zram_make_request);
1016        zram->queue->queuedata = zram;
1017
1018         /* gendisk structure */
1019        zram->disk = alloc_disk(1);
1020        if (!zram->disk) {
1021                pr_warn("Error allocating disk structure for device %d\n",
1022                        device_id);
1023                goto out_free_queue;
1024        }
1025
1026        zram->disk->major = zram_major;
1027        zram->disk->first_minor = device_id;
1028        zram->disk->fops = &zram_devops;
1029        zram->disk->queue = zram->queue;
1030        zram->disk->private_data = zram;
1031        snprintf(zram->disk->disk_name, 16, "zram%d", device_id);
1032
1033        /* Actual capacity set using syfs (/sys/block/zram<id>/disksize */
1034        set_capacity(zram->disk, 0);
1035        /* zram devices sort of resembles non-rotational disks */
1036        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zram->disk->queue);
1037        queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, zram->disk->queue);
1038        /*
1039         * To ensure that we always get PAGE_SIZE aligned
1040         * and n*PAGE_SIZED sized I/O requests.
1041         */
1042        blk_queue_physical_block_size(zram->disk->queue, PAGE_SIZE);
1043        blk_queue_logical_block_size(zram->disk->queue,
1044                                        ZRAM_LOGICAL_BLOCK_SIZE);
1045        blk_queue_io_min(zram->disk->queue, PAGE_SIZE);
1046        blk_queue_io_opt(zram->disk->queue, PAGE_SIZE);
1047        zram->disk->queue->limits.discard_granularity = PAGE_SIZE;
1048        zram->disk->queue->limits.max_discard_sectors = UINT_MAX;
1049        /*
1050         * zram_bio_discard() will clear all logical blocks if logical block
1051         * size is identical with physical block size(PAGE_SIZE). But if it is
1052         * different, we will skip discarding some parts of logical blocks in
1053         * the part of the request range which isn't aligned to physical block
1054         * size.  So we can't ensure that all discarded logical blocks are
1055         * zeroed.
1056         */
1057        if (ZRAM_LOGICAL_BLOCK_SIZE == PAGE_SIZE)
1058                zram->disk->queue->limits.discard_zeroes_data = 1;
1059        else
1060                zram->disk->queue->limits.discard_zeroes_data = 0;
1061        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, zram->disk->queue);
1062
1063        add_disk(zram->disk);
1064
1065        ret = sysfs_create_group(&disk_to_dev(zram->disk)->kobj,
1066                                &zram_disk_attr_group);
1067        if (ret < 0) {
1068                pr_warn("Error creating sysfs group");
1069                goto out_free_disk;
1070        }
1071        strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor));
1072        zram->meta = NULL;
1073        zram->max_comp_streams = 1;
1074        return 0;
1075
1076out_free_disk:
1077        del_gendisk(zram->disk);
1078        put_disk(zram->disk);
1079out_free_queue:
1080        blk_cleanup_queue(zram->queue);
1081out:
1082        return ret;
1083}
1084
1085static void destroy_device(struct zram *zram)
1086{
1087        sysfs_remove_group(&disk_to_dev(zram->disk)->kobj,
1088                        &zram_disk_attr_group);
1089
1090        del_gendisk(zram->disk);
1091        put_disk(zram->disk);
1092
1093        blk_cleanup_queue(zram->queue);
1094}
1095
1096static int __init zram_init(void)
1097{
1098        int ret, dev_id;
1099
1100        if (num_devices > max_num_devices) {
1101                pr_warn("Invalid value for num_devices: %u\n",
1102                                num_devices);
1103                ret = -EINVAL;
1104                goto out;
1105        }
1106
1107        zram_major = register_blkdev(0, "zram");
1108        if (zram_major <= 0) {
1109                pr_warn("Unable to get major number\n");
1110                ret = -EBUSY;
1111                goto out;
1112        }
1113
1114        /* Allocate the device array and initialize each one */
1115        zram_devices = kzalloc(num_devices * sizeof(struct zram), GFP_KERNEL);
1116        if (!zram_devices) {
1117                ret = -ENOMEM;
1118                goto unregister;
1119        }
1120
1121        for (dev_id = 0; dev_id < num_devices; dev_id++) {
1122                ret = create_device(&zram_devices[dev_id], dev_id);
1123                if (ret)
1124                        goto free_devices;
1125        }
1126
1127        pr_info("Created %u device(s) ...\n", num_devices);
1128
1129        return 0;
1130
1131free_devices:
1132        while (dev_id)
1133                destroy_device(&zram_devices[--dev_id]);
1134        kfree(zram_devices);
1135unregister:
1136        unregister_blkdev(zram_major, "zram");
1137out:
1138        return ret;
1139}
1140
1141static void __exit zram_exit(void)
1142{
1143        int i;
1144        struct zram *zram;
1145
1146        for (i = 0; i < num_devices; i++) {
1147                zram = &zram_devices[i];
1148
1149                destroy_device(zram);
1150                /*
1151                 * Shouldn't access zram->disk after destroy_device
1152                 * because destroy_device already released zram->disk.
1153                 */
1154                zram_reset_device(zram, false);
1155        }
1156
1157        unregister_blkdev(zram_major, "zram");
1158
1159        kfree(zram_devices);
1160        pr_debug("Cleanup done!\n");
1161}
1162
1163module_init(zram_init);
1164module_exit(zram_exit);
1165
1166module_param(num_devices, uint, 0);
1167MODULE_PARM_DESC(num_devices, "Number of zram devices");
1168
1169MODULE_LICENSE("Dual BSD/GPL");
1170MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");
1171MODULE_DESCRIPTION("Compressed RAM Block Device");
Note: See TracBrowser for help on using the repository browser.