109c434b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
29db5579bSNick Piggin /*
39db5579bSNick Piggin * Ram backed block device driver.
49db5579bSNick Piggin *
59db5579bSNick Piggin * Copyright (C) 2007 Nick Piggin
69db5579bSNick Piggin * Copyright (C) 2007 Novell Inc.
79db5579bSNick Piggin *
89db5579bSNick Piggin * Parts derived from drivers/block/rd.c, and drivers/block/loop.c, copyright
99db5579bSNick Piggin * of their respective owners.
109db5579bSNick Piggin */
119db5579bSNick Piggin
129db5579bSNick Piggin #include <linux/init.h>
13287f3ca5SBart Van Assche #include <linux/initrd.h>
149db5579bSNick Piggin #include <linux/module.h>
159db5579bSNick Piggin #include <linux/moduleparam.h>
169db5579bSNick Piggin #include <linux/major.h>
179db5579bSNick Piggin #include <linux/blkdev.h>
189db5579bSNick Piggin #include <linux/bio.h>
199db5579bSNick Piggin #include <linux/highmem.h>
202a48fc0aSArnd Bergmann #include <linux/mutex.h>
214ee60ec1SMatthew Wilcox (Oracle) #include <linux/pagemap.h>
22786bb024SPankaj Raghav #include <linux/xarray.h>
23ff01bb48SAl Viro #include <linux/fs.h>
245a0e3ad6STejun Heo #include <linux/slab.h>
2523c47d2aSMinchan Kim #include <linux/backing-dev.h>
26f4be591fSCalvin Owens #include <linux/debugfs.h>
279db5579bSNick Piggin
287c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
299db5579bSNick Piggin
309db5579bSNick Piggin /*
31786bb024SPankaj Raghav * Each block ramdisk device has a xarray brd_pages of pages that stores
329db5579bSNick Piggin * the pages containing the block device's contents. A brd page's ->index is
339db5579bSNick Piggin * its offset in PAGE_SIZE units. This is similar to, but in no way connected
349db5579bSNick Piggin * with, the kernel's pagecache or buffer cache (which sit above our block
359db5579bSNick Piggin * device).
369db5579bSNick Piggin */
379db5579bSNick Piggin struct brd_device {
389db5579bSNick Piggin int brd_number;
399db5579bSNick Piggin struct gendisk *brd_disk;
409db5579bSNick Piggin struct list_head brd_list;
419db5579bSNick Piggin
429db5579bSNick Piggin /*
43786bb024SPankaj Raghav * Backing store of pages. This is the contents of the block device.
449db5579bSNick Piggin */
45786bb024SPankaj Raghav struct xarray brd_pages;
46f4be591fSCalvin Owens u64 brd_nr_pages;
479db5579bSNick Piggin };
489db5579bSNick Piggin
499db5579bSNick Piggin /*
509db5579bSNick Piggin * Look up and return a brd's page for a given sector.
519db5579bSNick Piggin */
brd_lookup_page(struct brd_device * brd,sector_t sector)529db5579bSNick Piggin static struct page *brd_lookup_page(struct brd_device *brd, sector_t sector)
539db5579bSNick Piggin {
549db5579bSNick Piggin pgoff_t idx;
559db5579bSNick Piggin struct page *page;
569db5579bSNick Piggin
579db5579bSNick Piggin idx = sector >> PAGE_SECTORS_SHIFT; /* sector to page index */
58786bb024SPankaj Raghav page = xa_load(&brd->brd_pages, idx);
599db5579bSNick Piggin
609db5579bSNick Piggin BUG_ON(page && page->index != idx);
619db5579bSNick Piggin
629db5579bSNick Piggin return page;
639db5579bSNick Piggin }
649db5579bSNick Piggin
659db5579bSNick Piggin /*
66db0ccc44SJens Axboe * Insert a new page for a given sector, if one does not already exist.
679db5579bSNick Piggin */
brd_insert_page(struct brd_device * brd,sector_t sector,gfp_t gfp)686ded703cSJens Axboe static int brd_insert_page(struct brd_device *brd, sector_t sector, gfp_t gfp)
699db5579bSNick Piggin {
709db5579bSNick Piggin pgoff_t idx;
71786bb024SPankaj Raghav struct page *page, *cur;
726ded703cSJens Axboe int ret = 0;
739db5579bSNick Piggin
749db5579bSNick Piggin page = brd_lookup_page(brd, sector);
759db5579bSNick Piggin if (page)
76db0ccc44SJens Axboe return 0;
779db5579bSNick Piggin
786ded703cSJens Axboe page = alloc_page(gfp | __GFP_ZERO | __GFP_HIGHMEM);
799db5579bSNick Piggin if (!page)
80db0ccc44SJens Axboe return -ENOMEM;
819db5579bSNick Piggin
82786bb024SPankaj Raghav xa_lock(&brd->brd_pages);
839db5579bSNick Piggin
849db5579bSNick Piggin idx = sector >> PAGE_SECTORS_SHIFT;
85dfd20b2bSBrian Behlendorf page->index = idx;
86786bb024SPankaj Raghav
87786bb024SPankaj Raghav cur = __xa_cmpxchg(&brd->brd_pages, idx, NULL, page, gfp);
88786bb024SPankaj Raghav
89786bb024SPankaj Raghav if (unlikely(cur)) {
909db5579bSNick Piggin __free_page(page);
91786bb024SPankaj Raghav ret = xa_err(cur);
92786bb024SPankaj Raghav if (!ret && (cur->index != idx))
936ded703cSJens Axboe ret = -EIO;
94f4be591fSCalvin Owens } else {
95f4be591fSCalvin Owens brd->brd_nr_pages++;
96dfd20b2bSBrian Behlendorf }
979db5579bSNick Piggin
98786bb024SPankaj Raghav xa_unlock(&brd->brd_pages);
99786bb024SPankaj Raghav
1006ded703cSJens Axboe return ret;
1019db5579bSNick Piggin }
1029db5579bSNick Piggin
1039db5579bSNick Piggin /*
104786bb024SPankaj Raghav * Free all backing store pages and xarray. This must only be called when
1059db5579bSNick Piggin * there are no other users of the device.
1069db5579bSNick Piggin */
brd_free_pages(struct brd_device * brd)1079db5579bSNick Piggin static void brd_free_pages(struct brd_device *brd)
1089db5579bSNick Piggin {
109786bb024SPankaj Raghav struct page *page;
110786bb024SPankaj Raghav pgoff_t idx;
1119db5579bSNick Piggin
112786bb024SPankaj Raghav xa_for_each(&brd->brd_pages, idx, page) {
113786bb024SPankaj Raghav __free_page(page);
114*6dd4423fSPankaj Raghav cond_resched();
1159db5579bSNick Piggin }
1169db5579bSNick Piggin
117786bb024SPankaj Raghav xa_destroy(&brd->brd_pages);
1189db5579bSNick Piggin }
1199db5579bSNick Piggin
1209db5579bSNick Piggin /*
1219db5579bSNick Piggin * copy_to_brd_setup must be called before copy_to_brd. It may sleep.
1229db5579bSNick Piggin */
copy_to_brd_setup(struct brd_device * brd,sector_t sector,size_t n,gfp_t gfp)1236ded703cSJens Axboe static int copy_to_brd_setup(struct brd_device *brd, sector_t sector, size_t n,
1246ded703cSJens Axboe gfp_t gfp)
1259db5579bSNick Piggin {
1269db5579bSNick Piggin unsigned int offset = (sector & (PAGE_SECTORS-1)) << SECTOR_SHIFT;
1279db5579bSNick Piggin size_t copy;
128db0ccc44SJens Axboe int ret;
1299db5579bSNick Piggin
1309db5579bSNick Piggin copy = min_t(size_t, n, PAGE_SIZE - offset);
1316ded703cSJens Axboe ret = brd_insert_page(brd, sector, gfp);
132db0ccc44SJens Axboe if (ret)
133db0ccc44SJens Axboe return ret;
1349db5579bSNick Piggin if (copy < n) {
1359db5579bSNick Piggin sector += copy >> SECTOR_SHIFT;
1366ded703cSJens Axboe ret = brd_insert_page(brd, sector, gfp);
1379db5579bSNick Piggin }
138db0ccc44SJens Axboe return ret;
1399db5579bSNick Piggin }
1409db5579bSNick Piggin
1419db5579bSNick Piggin /*
1429db5579bSNick Piggin * Copy n bytes from src to the brd starting at sector. Does not sleep.
1439db5579bSNick Piggin */
copy_to_brd(struct brd_device * brd,const void * src,sector_t sector,size_t n)1449db5579bSNick Piggin static void copy_to_brd(struct brd_device *brd, const void *src,
1459db5579bSNick Piggin sector_t sector, size_t n)
1469db5579bSNick Piggin {
1479db5579bSNick Piggin struct page *page;
1489db5579bSNick Piggin void *dst;
1499db5579bSNick Piggin unsigned int offset = (sector & (PAGE_SECTORS-1)) << SECTOR_SHIFT;
1509db5579bSNick Piggin size_t copy;
1519db5579bSNick Piggin
1529db5579bSNick Piggin copy = min_t(size_t, n, PAGE_SIZE - offset);
1539db5579bSNick Piggin page = brd_lookup_page(brd, sector);
1549db5579bSNick Piggin BUG_ON(!page);
1559db5579bSNick Piggin
156cfd8005cSCong Wang dst = kmap_atomic(page);
1579db5579bSNick Piggin memcpy(dst + offset, src, copy);
158cfd8005cSCong Wang kunmap_atomic(dst);
1599db5579bSNick Piggin
1609db5579bSNick Piggin if (copy < n) {
1619db5579bSNick Piggin src += copy;
1629db5579bSNick Piggin sector += copy >> SECTOR_SHIFT;
1639db5579bSNick Piggin copy = n - copy;
1649db5579bSNick Piggin page = brd_lookup_page(brd, sector);
1659db5579bSNick Piggin BUG_ON(!page);
1669db5579bSNick Piggin
167cfd8005cSCong Wang dst = kmap_atomic(page);
1689db5579bSNick Piggin memcpy(dst, src, copy);
169cfd8005cSCong Wang kunmap_atomic(dst);
1709db5579bSNick Piggin }
1719db5579bSNick Piggin }
1729db5579bSNick Piggin
1739db5579bSNick Piggin /*
1749db5579bSNick Piggin * Copy n bytes to dst from the brd starting at sector. Does not sleep.
1759db5579bSNick Piggin */
copy_from_brd(void * dst,struct brd_device * brd,sector_t sector,size_t n)1769db5579bSNick Piggin static void copy_from_brd(void *dst, struct brd_device *brd,
1779db5579bSNick Piggin sector_t sector, size_t n)
1789db5579bSNick Piggin {
1799db5579bSNick Piggin struct page *page;
1809db5579bSNick Piggin void *src;
1819db5579bSNick Piggin unsigned int offset = (sector & (PAGE_SECTORS-1)) << SECTOR_SHIFT;
1829db5579bSNick Piggin size_t copy;
1839db5579bSNick Piggin
1849db5579bSNick Piggin copy = min_t(size_t, n, PAGE_SIZE - offset);
1859db5579bSNick Piggin page = brd_lookup_page(brd, sector);
1869db5579bSNick Piggin if (page) {
187cfd8005cSCong Wang src = kmap_atomic(page);
1889db5579bSNick Piggin memcpy(dst, src + offset, copy);
189cfd8005cSCong Wang kunmap_atomic(src);
1909db5579bSNick Piggin } else
1919db5579bSNick Piggin memset(dst, 0, copy);
1929db5579bSNick Piggin
1939db5579bSNick Piggin if (copy < n) {
1949db5579bSNick Piggin dst += copy;
1959db5579bSNick Piggin sector += copy >> SECTOR_SHIFT;
1969db5579bSNick Piggin copy = n - copy;
1979db5579bSNick Piggin page = brd_lookup_page(brd, sector);
1989db5579bSNick Piggin if (page) {
199cfd8005cSCong Wang src = kmap_atomic(page);
2009db5579bSNick Piggin memcpy(dst, src, copy);
201cfd8005cSCong Wang kunmap_atomic(src);
2029db5579bSNick Piggin } else
2039db5579bSNick Piggin memset(dst, 0, copy);
2049db5579bSNick Piggin }
2059db5579bSNick Piggin }
2069db5579bSNick Piggin
2079db5579bSNick Piggin /*
2089db5579bSNick Piggin * Process a single bvec of a bio.
2099db5579bSNick Piggin */
brd_do_bvec(struct brd_device * brd,struct page * page,unsigned int len,unsigned int off,blk_opf_t opf,sector_t sector)2109db5579bSNick Piggin static int brd_do_bvec(struct brd_device *brd, struct page *page,
2116ded703cSJens Axboe unsigned int len, unsigned int off, blk_opf_t opf,
2129db5579bSNick Piggin sector_t sector)
2139db5579bSNick Piggin {
2149db5579bSNick Piggin void *mem;
2159db5579bSNick Piggin int err = 0;
2169db5579bSNick Piggin
2176ded703cSJens Axboe if (op_is_write(opf)) {
2186ded703cSJens Axboe /*
2196ded703cSJens Axboe * Must use NOIO because we don't want to recurse back into the
2206ded703cSJens Axboe * block or filesystem layers from page reclaim.
2216ded703cSJens Axboe */
2226ded703cSJens Axboe gfp_t gfp = opf & REQ_NOWAIT ? GFP_NOWAIT : GFP_NOIO;
2236ded703cSJens Axboe
2246ded703cSJens Axboe err = copy_to_brd_setup(brd, sector, len, gfp);
2259db5579bSNick Piggin if (err)
2269db5579bSNick Piggin goto out;
2279db5579bSNick Piggin }
2289db5579bSNick Piggin
229cfd8005cSCong Wang mem = kmap_atomic(page);
2306ded703cSJens Axboe if (!op_is_write(opf)) {
2319db5579bSNick Piggin copy_from_brd(mem + off, brd, sector, len);
2329db5579bSNick Piggin flush_dcache_page(page);
233c2572f2bSNick Piggin } else {
234c2572f2bSNick Piggin flush_dcache_page(page);
2359db5579bSNick Piggin copy_to_brd(brd, mem + off, sector, len);
236c2572f2bSNick Piggin }
237cfd8005cSCong Wang kunmap_atomic(mem);
2389db5579bSNick Piggin
2399db5579bSNick Piggin out:
2409db5579bSNick Piggin return err;
2419db5579bSNick Piggin }
2429db5579bSNick Piggin
brd_submit_bio(struct bio * bio)2433e08773cSChristoph Hellwig static void brd_submit_bio(struct bio *bio)
2449db5579bSNick Piggin {
245309dca30SChristoph Hellwig struct brd_device *brd = bio->bi_bdev->bd_disk->private_data;
24674cb8994SChristoph Hellwig sector_t sector = bio->bi_iter.bi_sector;
2477988613bSKent Overstreet struct bio_vec bvec;
2487988613bSKent Overstreet struct bvec_iter iter;
2499db5579bSNick Piggin
2507988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) {
2517988613bSKent Overstreet unsigned int len = bvec.bv_len;
2524246a0b6SChristoph Hellwig int err;
2534246a0b6SChristoph Hellwig
254f1acbf21SMing Lei /* Don't support un-aligned buffer */
255f1acbf21SMing Lei WARN_ON_ONCE((bvec.bv_offset & (SECTOR_SIZE - 1)) ||
256f1acbf21SMing Lei (len & (SECTOR_SIZE - 1)));
257f1acbf21SMing Lei
258c11f0c0bSJens Axboe err = brd_do_bvec(brd, bvec.bv_page, len, bvec.bv_offset,
2596ded703cSJens Axboe bio->bi_opf, sector);
2603e08773cSChristoph Hellwig if (err) {
2616ded703cSJens Axboe if (err == -ENOMEM && bio->bi_opf & REQ_NOWAIT) {
2626ded703cSJens Axboe bio_wouldblock_error(bio);
2636ded703cSJens Axboe return;
2646ded703cSJens Axboe }
2653e08773cSChristoph Hellwig bio_io_error(bio);
2663e08773cSChristoph Hellwig return;
2673e08773cSChristoph Hellwig }
2689db5579bSNick Piggin sector += len >> SECTOR_SHIFT;
2699db5579bSNick Piggin }
2709db5579bSNick Piggin
2714246a0b6SChristoph Hellwig bio_endio(bio);
2729db5579bSNick Piggin }
2739db5579bSNick Piggin
27483d5cde4SAlexey Dobriyan static const struct block_device_operations brd_fops = {
2759db5579bSNick Piggin .owner = THIS_MODULE,
276c62b37d9SChristoph Hellwig .submit_bio = brd_submit_bio,
2779db5579bSNick Piggin };
2789db5579bSNick Piggin
2799db5579bSNick Piggin /*
2809db5579bSNick Piggin * And now the modules code and kernel interface.
2819db5579bSNick Piggin */
282937af5ecSBoaz Harrosh static int rd_nr = CONFIG_BLK_DEV_RAM_COUNT;
2835657a819SJoe Perches module_param(rd_nr, int, 0444);
2849db5579bSNick Piggin MODULE_PARM_DESC(rd_nr, "Maximum number of brd devices");
285937af5ecSBoaz Harrosh
286366f4aeaSJan Kara unsigned long rd_size = CONFIG_BLK_DEV_RAM_SIZE;
2875657a819SJoe Perches module_param(rd_size, ulong, 0444);
2889db5579bSNick Piggin MODULE_PARM_DESC(rd_size, "Size of each RAM disk in kbytes.");
289937af5ecSBoaz Harrosh
290937af5ecSBoaz Harrosh static int max_part = 1;
2915657a819SJoe Perches module_param(max_part, int, 0444);
292937af5ecSBoaz Harrosh MODULE_PARM_DESC(max_part, "Num Minors to reserve between devices");
293937af5ecSBoaz Harrosh
2949db5579bSNick Piggin MODULE_LICENSE("GPL");
2959db5579bSNick Piggin MODULE_ALIAS_BLOCKDEV_MAJOR(RAMDISK_MAJOR);
296efedf51cSNick Piggin MODULE_ALIAS("rd");
2979db5579bSNick Piggin
2989db5579bSNick Piggin #ifndef MODULE
2999db5579bSNick Piggin /* Legacy boot options - nonmodular */
ramdisk_size(char * str)3009db5579bSNick Piggin static int __init ramdisk_size(char *str)
3019db5579bSNick Piggin {
3029db5579bSNick Piggin rd_size = simple_strtol(str, NULL, 0);
3039db5579bSNick Piggin return 1;
3049db5579bSNick Piggin }
3051adbee50SRobert P. J. Day __setup("ramdisk_size=", ramdisk_size);
3069db5579bSNick Piggin #endif
3079db5579bSNick Piggin
3089db5579bSNick Piggin /*
3099db5579bSNick Piggin * The device scheme is derived from loop.c. Keep them in synch where possible
3109db5579bSNick Piggin * (should share code eventually).
3119db5579bSNick Piggin */
3129db5579bSNick Piggin static LIST_HEAD(brd_devices);
313f4be591fSCalvin Owens static struct dentry *brd_debugfs_dir;
3149db5579bSNick Piggin
brd_alloc(int i)3157f9b348cSChristoph Hellwig static int brd_alloc(int i)
3169db5579bSNick Piggin {
3179db5579bSNick Piggin struct brd_device *brd;
3189db5579bSNick Piggin struct gendisk *disk;
319f4be591fSCalvin Owens char buf[DISK_NAME_LEN];
320e1528830SLuis Chamberlain int err = -ENOMEM;
3219db5579bSNick Piggin
32200358933STetsuo Handa list_for_each_entry(brd, &brd_devices, brd_list)
32300358933STetsuo Handa if (brd->brd_number == i)
324f7bf3586STetsuo Handa return -EEXIST;
3259db5579bSNick Piggin brd = kzalloc(sizeof(*brd), GFP_KERNEL);
32600358933STetsuo Handa if (!brd)
3277f9b348cSChristoph Hellwig return -ENOMEM;
3289db5579bSNick Piggin brd->brd_number = i;
329f7bf3586STetsuo Handa list_add_tail(&brd->brd_list, &brd_devices);
330f7bf3586STetsuo Handa
331786bb024SPankaj Raghav xa_init(&brd->brd_pages);
3329db5579bSNick Piggin
333f4be591fSCalvin Owens snprintf(buf, DISK_NAME_LEN, "ram%d", i);
334f4be591fSCalvin Owens if (!IS_ERR_OR_NULL(brd_debugfs_dir))
335f4be591fSCalvin Owens debugfs_create_u64(buf, 0444, brd_debugfs_dir,
336f4be591fSCalvin Owens &brd->brd_nr_pages);
337f4be591fSCalvin Owens
3387f9b348cSChristoph Hellwig disk = brd->brd_disk = blk_alloc_disk(NUMA_NO_NODE);
3399db5579bSNick Piggin if (!disk)
3407f9b348cSChristoph Hellwig goto out_free_dev;
3417f9b348cSChristoph Hellwig
3429db5579bSNick Piggin disk->major = RAMDISK_MAJOR;
343937af5ecSBoaz Harrosh disk->first_minor = i * max_part;
3447f9b348cSChristoph Hellwig disk->minors = max_part;
3459db5579bSNick Piggin disk->fops = &brd_fops;
3469db5579bSNick Piggin disk->private_data = brd;
347e55e1b48SWolfram Sang strscpy(disk->disk_name, buf, DISK_NAME_LEN);
3489db5579bSNick Piggin set_capacity(disk, rd_size * 2);
3499db5579bSNick Piggin
3507f9b348cSChristoph Hellwig /*
3517f9b348cSChristoph Hellwig * This is so fdisk will align partitions on 4k, because of
3527f9b348cSChristoph Hellwig * direct_access API needing 4k alignment, returning a PFN
3537f9b348cSChristoph Hellwig * (This is only a problem on very small devices <= 4M,
3547f9b348cSChristoph Hellwig * otherwise fdisk will align on 1M. Regardless this call
3557f9b348cSChristoph Hellwig * is harmless)
3567f9b348cSChristoph Hellwig */
3577f9b348cSChristoph Hellwig blk_queue_physical_block_size(disk->queue, PAGE_SIZE);
3587f9b348cSChristoph Hellwig
359316ba573SSeongJae Park /* Tell the block layer that this is not a rotational device */
3607f9b348cSChristoph Hellwig blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
3613222d8c2SChristoph Hellwig blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, disk->queue);
36267205f80SJens Axboe blk_queue_flag_set(QUEUE_FLAG_NOWAIT, disk->queue);
363e1528830SLuis Chamberlain err = add_disk(disk);
364e1528830SLuis Chamberlain if (err)
365e1528830SLuis Chamberlain goto out_cleanup_disk;
366316ba573SSeongJae Park
3677f9b348cSChristoph Hellwig return 0;
3689db5579bSNick Piggin
369e1528830SLuis Chamberlain out_cleanup_disk:
3708b9ab626SChristoph Hellwig put_disk(disk);
3719db5579bSNick Piggin out_free_dev:
372f7bf3586STetsuo Handa list_del(&brd->brd_list);
3739db5579bSNick Piggin kfree(brd);
374e1528830SLuis Chamberlain return err;
3759db5579bSNick Piggin }
3769db5579bSNick Piggin
brd_probe(dev_t dev)3777cc178a6SChristoph Hellwig static void brd_probe(dev_t dev)
3789db5579bSNick Piggin {
379f7bf3586STetsuo Handa brd_alloc(MINOR(dev) / max_part);
3809db5579bSNick Piggin }
3819db5579bSNick Piggin
brd_cleanup(void)38200358933STetsuo Handa static void brd_cleanup(void)
3839db5579bSNick Piggin {
38400358933STetsuo Handa struct brd_device *brd, *next;
38500358933STetsuo Handa
38600358933STetsuo Handa debugfs_remove_recursive(brd_debugfs_dir);
38700358933STetsuo Handa
38800358933STetsuo Handa list_for_each_entry_safe(brd, next, &brd_devices, brd_list) {
3899db5579bSNick Piggin del_gendisk(brd->brd_disk);
3908b9ab626SChristoph Hellwig put_disk(brd->brd_disk);
3917f9b348cSChristoph Hellwig brd_free_pages(brd);
392f7bf3586STetsuo Handa list_del(&brd->brd_list);
3937f9b348cSChristoph Hellwig kfree(brd);
3949db5579bSNick Piggin }
39500358933STetsuo Handa }
3969db5579bSNick Piggin
brd_check_and_reset_par(void)397c8ab4225SZhiqiang Liu static inline void brd_check_and_reset_par(void)
398c8ab4225SZhiqiang Liu {
399c8ab4225SZhiqiang Liu if (unlikely(!max_part))
400c8ab4225SZhiqiang Liu max_part = 1;
401c8ab4225SZhiqiang Liu
402c8ab4225SZhiqiang Liu /*
403c8ab4225SZhiqiang Liu * make sure 'max_part' can be divided exactly by (1U << MINORBITS),
404c8ab4225SZhiqiang Liu * otherwise, it is possiable to get same dev_t when adding partitions.
405c8ab4225SZhiqiang Liu */
406c8ab4225SZhiqiang Liu if ((1U << MINORBITS) % max_part != 0)
407c8ab4225SZhiqiang Liu max_part = 1UL << fls(max_part);
408c8ab4225SZhiqiang Liu
409c8ab4225SZhiqiang Liu if (max_part > DISK_MAX_PARTS) {
410c8ab4225SZhiqiang Liu pr_info("brd: max_part can't be larger than %d, reset max_part = %d.\n",
411c8ab4225SZhiqiang Liu DISK_MAX_PARTS, DISK_MAX_PARTS);
412c8ab4225SZhiqiang Liu max_part = DISK_MAX_PARTS;
413c8ab4225SZhiqiang Liu }
414c8ab4225SZhiqiang Liu }
415c8ab4225SZhiqiang Liu
brd_init(void)4169db5579bSNick Piggin static int __init brd_init(void)
4179db5579bSNick Piggin {
4187f9b348cSChristoph Hellwig int err, i;
4199db5579bSNick Piggin
42000358933STetsuo Handa brd_check_and_reset_par();
42100358933STetsuo Handa
42200358933STetsuo Handa brd_debugfs_dir = debugfs_create_dir("ramdisk_pages", NULL);
42300358933STetsuo Handa
42400358933STetsuo Handa for (i = 0; i < rd_nr; i++) {
42500358933STetsuo Handa err = brd_alloc(i);
42600358933STetsuo Handa if (err)
42700358933STetsuo Handa goto out_free;
42800358933STetsuo Handa }
42900358933STetsuo Handa
4309db5579bSNick Piggin /*
4319db5579bSNick Piggin * brd module now has a feature to instantiate underlying device
4329db5579bSNick Piggin * structure on-demand, provided that there is an access dev node.
4339db5579bSNick Piggin *
434937af5ecSBoaz Harrosh * (1) if rd_nr is specified, create that many upfront. else
435937af5ecSBoaz Harrosh * it defaults to CONFIG_BLK_DEV_RAM_COUNT
436937af5ecSBoaz Harrosh * (2) User can further extend brd devices by create dev node themselves
437937af5ecSBoaz Harrosh * and have kernel automatically instantiate actual device
438937af5ecSBoaz Harrosh * on-demand. Example:
439937af5ecSBoaz Harrosh * mknod /path/devnod_name b 1 X # 1 is the rd major
440937af5ecSBoaz Harrosh * fdisk -l /path/devnod_name
441937af5ecSBoaz Harrosh * If (X / max_part) was not already created it will be created
442937af5ecSBoaz Harrosh * dynamically.
4439db5579bSNick Piggin */
444d7853d1fSLaurent Vivier
44500358933STetsuo Handa if (__register_blkdev(RAMDISK_MAJOR, "ramdisk", brd_probe)) {
44600358933STetsuo Handa err = -EIO;
4479db5579bSNick Piggin goto out_free;
4489db5579bSNick Piggin }
4499db5579bSNick Piggin
450937af5ecSBoaz Harrosh pr_info("brd: module loaded\n");
4519db5579bSNick Piggin return 0;
4529db5579bSNick Piggin
4539db5579bSNick Piggin out_free:
45400358933STetsuo Handa brd_cleanup();
4559db5579bSNick Piggin
456937af5ecSBoaz Harrosh pr_info("brd: module NOT loaded !!!\n");
4577f9b348cSChristoph Hellwig return err;
4589db5579bSNick Piggin }
4599db5579bSNick Piggin
brd_exit(void)4609db5579bSNick Piggin static void __exit brd_exit(void)
4619db5579bSNick Piggin {
4629db5579bSNick Piggin
463f7bf3586STetsuo Handa unregister_blkdev(RAMDISK_MAJOR, "ramdisk");
46400358933STetsuo Handa brd_cleanup();
4659db5579bSNick Piggin
466937af5ecSBoaz Harrosh pr_info("brd: module unloaded\n");
4679db5579bSNick Piggin }
4689db5579bSNick Piggin
4699db5579bSNick Piggin module_init(brd_init);
4709db5579bSNick Piggin module_exit(brd_exit);
4719db5579bSNick Piggin
472