Branch data Line data Source code
1 : : /*
2 : : * Ram backed block device driver.
3 : : *
4 : : * Copyright (C) 2007 Nick Piggin
5 : : * Copyright (C) 2007 Novell Inc.
6 : : *
7 : : * Parts derived from drivers/block/rd.c, and drivers/block/loop.c, copyright
8 : : * of their respective owners.
9 : : */
10 : :
11 : : #include <linux/init.h>
12 : : #include <linux/module.h>
13 : : #include <linux/moduleparam.h>
14 : : #include <linux/major.h>
15 : : #include <linux/blkdev.h>
16 : : #include <linux/bio.h>
17 : : #include <linux/highmem.h>
18 : : #include <linux/mutex.h>
19 : : #include <linux/radix-tree.h>
20 : : #include <linux/fs.h>
21 : : #include <linux/slab.h>
22 : :
23 : : #include <asm/uaccess.h>
24 : :
25 : : #define SECTOR_SHIFT 9
26 : : #define PAGE_SECTORS_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)
27 : : #define PAGE_SECTORS (1 << PAGE_SECTORS_SHIFT)
28 : :
29 : : /*
30 : : * Each block ramdisk device has a radix_tree brd_pages of pages that stores
31 : : * the pages containing the block device's contents. A brd page's ->index is
32 : : * its offset in PAGE_SIZE units. This is similar to, but in no way connected
33 : : * with, the kernel's pagecache or buffer cache (which sit above our block
34 : : * device).
35 : : */
36 : : struct brd_device {
37 : : int brd_number;
38 : :
39 : : struct request_queue *brd_queue;
40 : : struct gendisk *brd_disk;
41 : : struct list_head brd_list;
42 : :
43 : : /*
44 : : * Backing store of pages and lock to protect it. This is the contents
45 : : * of the block device.
46 : : */
47 : : spinlock_t brd_lock;
48 : : struct radix_tree_root brd_pages;
49 : : };
50 : :
51 : : /*
52 : : * Look up and return a brd's page for a given sector.
53 : : */
54 : : static DEFINE_MUTEX(brd_mutex);
55 : 0 : static struct page *brd_lookup_page(struct brd_device *brd, sector_t sector)
56 : : {
57 : : pgoff_t idx;
58 : : struct page *page;
59 : :
60 : : /*
61 : : * The page lifetime is protected by the fact that we have opened the
62 : : * device node -- brd pages will never be deleted under us, so we
63 : : * don't need any further locking or refcounting.
64 : : *
65 : : * This is strictly true for the radix-tree nodes as well (ie. we
66 : : * don't actually need the rcu_read_lock()), however that is not a
67 : : * documented feature of the radix-tree API so it is better to be
68 : : * safe here (we don't have total exclusion from radix tree updates
69 : : * here, only deletes).
70 : : */
71 : : rcu_read_lock();
72 : 0 : idx = sector >> PAGE_SECTORS_SHIFT; /* sector to page index */
73 : 0 : page = radix_tree_lookup(&brd->brd_pages, idx);
74 : : rcu_read_unlock();
75 : :
76 [ # # ][ # # ]: 0 : BUG_ON(page && page->index != idx);
77 : :
78 : 0 : return page;
79 : : }
80 : :
81 : : /*
82 : : * Look up and return a brd's page for a given sector.
83 : : * If one does not exist, allocate an empty page, and insert that. Then
84 : : * return it.
85 : : */
86 : 0 : static struct page *brd_insert_page(struct brd_device *brd, sector_t sector)
87 : : {
88 : : pgoff_t idx;
89 : : struct page *page;
90 : : gfp_t gfp_flags;
91 : :
92 : 0 : page = brd_lookup_page(brd, sector);
93 [ # # ]: 0 : if (page)
94 : : return page;
95 : :
96 : : /*
97 : : * Must use NOIO because we don't want to recurse back into the
98 : : * block or filesystem layers from page reclaim.
99 : : *
100 : : * Cannot support XIP and highmem, because our ->direct_access
101 : : * routine for XIP must return memory that is always addressable.
102 : : * If XIP was reworked to use pfns and kmap throughout, this
103 : : * restriction might be able to be lifted.
104 : : */
105 : : gfp_flags = GFP_NOIO | __GFP_ZERO;
106 : : #ifndef CONFIG_BLK_DEV_XIP
107 : : gfp_flags |= __GFP_HIGHMEM;
108 : : #endif
109 : : page = alloc_page(gfp_flags);
110 [ # # ]: 0 : if (!page)
111 : : return NULL;
112 : :
113 [ # # ]: 0 : if (radix_tree_preload(GFP_NOIO)) {
114 : 0 : __free_page(page);
115 : 0 : return NULL;
116 : : }
117 : :
118 : : spin_lock(&brd->brd_lock);
119 : 0 : idx = sector >> PAGE_SECTORS_SHIFT;
120 : 0 : page->index = idx;
121 [ # # ]: 0 : if (radix_tree_insert(&brd->brd_pages, idx, page)) {
122 : 0 : __free_page(page);
123 : 0 : page = radix_tree_lookup(&brd->brd_pages, idx);
124 [ # # ]: 0 : BUG_ON(!page);
125 [ # # ]: 0 : BUG_ON(page->index != idx);
126 : : }
127 : : spin_unlock(&brd->brd_lock);
128 : :
129 : : radix_tree_preload_end();
130 : :
131 : 0 : return page;
132 : : }
133 : :
134 : : static void brd_free_page(struct brd_device *brd, sector_t sector)
135 : : {
136 : : struct page *page;
137 : : pgoff_t idx;
138 : :
139 : : spin_lock(&brd->brd_lock);
140 : : idx = sector >> PAGE_SECTORS_SHIFT;
141 : : page = radix_tree_delete(&brd->brd_pages, idx);
142 : : spin_unlock(&brd->brd_lock);
143 : : if (page)
144 : : __free_page(page);
145 : : }
146 : :
147 : 0 : static void brd_zero_page(struct brd_device *brd, sector_t sector)
148 : : {
149 : : struct page *page;
150 : :
151 : 0 : page = brd_lookup_page(brd, sector);
152 [ # # ]: 0 : if (page)
153 : : clear_highpage(page);
154 : 0 : }
155 : :
156 : : /*
157 : : * Free all backing store pages and radix tree. This must only be called when
158 : : * there are no other users of the device.
159 : : */
160 : : #define FREE_BATCH 16
161 : 0 : static void brd_free_pages(struct brd_device *brd)
162 : : {
163 : : unsigned long pos = 0;
164 : : struct page *pages[FREE_BATCH];
165 : : int nr_pages;
166 : :
167 : : do {
168 : : int i;
169 : :
170 : 0 : nr_pages = radix_tree_gang_lookup(&brd->brd_pages,
171 : : (void **)pages, pos, FREE_BATCH);
172 : :
173 [ # # ]: 0 : for (i = 0; i < nr_pages; i++) {
174 : : void *ret;
175 : :
176 [ # # ]: 0 : BUG_ON(pages[i]->index < pos);
177 : : pos = pages[i]->index;
178 : 0 : ret = radix_tree_delete(&brd->brd_pages, pos);
179 [ # # ][ # # ]: 0 : BUG_ON(!ret || ret != pages[i]);
180 : 0 : __free_page(pages[i]);
181 : : }
182 : :
183 : 0 : pos++;
184 : :
185 : : /*
186 : : * This assumes radix_tree_gang_lookup always returns as
187 : : * many pages as possible. If the radix-tree code changes,
188 : : * so will this have to.
189 : : */
190 [ # # ]: 0 : } while (nr_pages == FREE_BATCH);
191 : 0 : }
192 : :
193 : : /*
194 : : * copy_to_brd_setup must be called before copy_to_brd. It may sleep.
195 : : */
196 : 0 : static int copy_to_brd_setup(struct brd_device *brd, sector_t sector, size_t n)
197 : : {
198 : 0 : unsigned int offset = (sector & (PAGE_SECTORS-1)) << SECTOR_SHIFT;
199 : : size_t copy;
200 : :
201 : 0 : copy = min_t(size_t, n, PAGE_SIZE - offset);
202 [ # # ]: 0 : if (!brd_insert_page(brd, sector))
203 : : return -ENOMEM;
204 [ # # ]: 0 : if (copy < n) {
205 : 0 : sector += copy >> SECTOR_SHIFT;
206 [ # # ]: 0 : if (!brd_insert_page(brd, sector))
207 : : return -ENOMEM;
208 : : }
209 : : return 0;
210 : : }
211 : :
212 : : static void discard_from_brd(struct brd_device *brd,
213 : : sector_t sector, size_t n)
214 : : {
215 [ # # ]: 0 : while (n >= PAGE_SIZE) {
216 : : /*
217 : : * Don't want to actually discard pages here because
218 : : * re-allocating the pages can result in writeback
219 : : * deadlocks under heavy load.
220 : : */
221 : : if (0)
222 : : brd_free_page(brd, sector);
223 : : else
224 : 0 : brd_zero_page(brd, sector);
225 : 0 : sector += PAGE_SIZE >> SECTOR_SHIFT;
226 : 0 : n -= PAGE_SIZE;
227 : : }
228 : : }
229 : :
230 : : /*
231 : : * Copy n bytes from src to the brd starting at sector. Does not sleep.
232 : : */
233 : 0 : static void copy_to_brd(struct brd_device *brd, const void *src,
234 : : sector_t sector, size_t n)
235 : : {
236 : : struct page *page;
237 : : void *dst;
238 : 0 : unsigned int offset = (sector & (PAGE_SECTORS-1)) << SECTOR_SHIFT;
239 : : size_t copy;
240 : :
241 : 0 : copy = min_t(size_t, n, PAGE_SIZE - offset);
242 : 0 : page = brd_lookup_page(brd, sector);
243 [ # # ]: 0 : BUG_ON(!page);
244 : :
245 : 0 : dst = kmap_atomic(page);
246 : 0 : memcpy(dst + offset, src, copy);
247 : 0 : kunmap_atomic(dst);
248 : :
249 [ # # ]: 0 : if (copy < n) {
250 : 0 : src += copy;
251 : 0 : sector += copy >> SECTOR_SHIFT;
252 : 0 : copy = n - copy;
253 : 0 : page = brd_lookup_page(brd, sector);
254 [ # # ]: 0 : BUG_ON(!page);
255 : :
256 : 0 : dst = kmap_atomic(page);
257 : 0 : memcpy(dst, src, copy);
258 : 0 : kunmap_atomic(dst);
259 : : }
260 : 0 : }
261 : :
262 : : /*
263 : : * Copy n bytes to dst from the brd starting at sector. Does not sleep.
264 : : */
265 : 0 : static void copy_from_brd(void *dst, struct brd_device *brd,
266 : : sector_t sector, size_t n)
267 : : {
268 : : struct page *page;
269 : : void *src;
270 : 0 : unsigned int offset = (sector & (PAGE_SECTORS-1)) << SECTOR_SHIFT;
271 : : size_t copy;
272 : :
273 : 0 : copy = min_t(size_t, n, PAGE_SIZE - offset);
274 : 0 : page = brd_lookup_page(brd, sector);
275 [ # # ]: 0 : if (page) {
276 : 0 : src = kmap_atomic(page);
277 : 0 : memcpy(dst, src + offset, copy);
278 : 0 : kunmap_atomic(src);
279 : : } else
280 [ # # ]: 0 : memset(dst, 0, copy);
281 : :
282 [ # # ]: 0 : if (copy < n) {
283 : 0 : dst += copy;
284 : 0 : sector += copy >> SECTOR_SHIFT;
285 : 0 : copy = n - copy;
286 : 0 : page = brd_lookup_page(brd, sector);
287 [ # # ]: 0 : if (page) {
288 : 0 : src = kmap_atomic(page);
289 : 0 : memcpy(dst, src, copy);
290 : 0 : kunmap_atomic(src);
291 : : } else
292 [ # # ]: 0 : memset(dst, 0, copy);
293 : : }
294 : 0 : }
295 : :
296 : : /*
297 : : * Process a single bvec of a bio.
298 : : */
299 : 0 : static int brd_do_bvec(struct brd_device *brd, struct page *page,
300 : : unsigned int len, unsigned int off, int rw,
301 : : sector_t sector)
302 : : {
303 : : void *mem;
304 : : int err = 0;
305 : :
306 [ # # ]: 0 : if (rw != READ) {
307 : 0 : err = copy_to_brd_setup(brd, sector, len);
308 [ # # ]: 0 : if (err)
309 : : goto out;
310 : : }
311 : :
312 : 0 : mem = kmap_atomic(page);
313 [ # # ]: 0 : if (rw == READ) {
314 : 0 : copy_from_brd(mem + off, brd, sector, len);
315 : 0 : flush_dcache_page(page);
316 : : } else {
317 : 0 : flush_dcache_page(page);
318 : 0 : copy_to_brd(brd, mem + off, sector, len);
319 : : }
320 : 0 : kunmap_atomic(mem);
321 : :
322 : : out:
323 : 0 : return err;
324 : : }
325 : :
326 : 0 : static void brd_make_request(struct request_queue *q, struct bio *bio)
327 : : {
328 : 0 : struct block_device *bdev = bio->bi_bdev;
329 : 0 : struct brd_device *brd = bdev->bd_disk->private_data;
330 : : int rw;
331 : : struct bio_vec *bvec;
332 : : sector_t sector;
333 : : int i;
334 : : int err = -EIO;
335 : :
336 : 0 : sector = bio->bi_sector;
337 [ # # ]: 0 : if (bio_end_sector(bio) > get_capacity(bdev->bd_disk))
338 : : goto out;
339 : :
340 [ # # ]: 0 : if (unlikely(bio->bi_rw & REQ_DISCARD)) {
341 : : err = 0;
342 : : discard_from_brd(brd, sector, bio->bi_size);
343 : : goto out;
344 : : }
345 : :
346 : 0 : rw = bio_rw(bio);
347 [ # # ]: 0 : if (rw == READA)
348 : : rw = READ;
349 : :
350 [ # # ]: 0 : bio_for_each_segment(bvec, bio, i) {
351 : 0 : unsigned int len = bvec->bv_len;
352 : 0 : err = brd_do_bvec(brd, bvec->bv_page, len,
353 : : bvec->bv_offset, rw, sector);
354 [ # # ]: 0 : if (err)
355 : : break;
356 : 0 : sector += len >> SECTOR_SHIFT;
357 : : }
358 : :
359 : : out:
360 : 0 : bio_endio(bio, err);
361 : 0 : }
362 : :
363 : : #ifdef CONFIG_BLK_DEV_XIP
364 : : static int brd_direct_access(struct block_device *bdev, sector_t sector,
365 : : void **kaddr, unsigned long *pfn)
366 : : {
367 : : struct brd_device *brd = bdev->bd_disk->private_data;
368 : : struct page *page;
369 : :
370 : : if (!brd)
371 : : return -ENODEV;
372 : : if (sector & (PAGE_SECTORS-1))
373 : : return -EINVAL;
374 : : if (sector + PAGE_SECTORS > get_capacity(bdev->bd_disk))
375 : : return -ERANGE;
376 : : page = brd_insert_page(brd, sector);
377 : : if (!page)
378 : : return -ENOMEM;
379 : : *kaddr = page_address(page);
380 : : *pfn = page_to_pfn(page);
381 : :
382 : : return 0;
383 : : }
384 : : #endif
385 : :
386 : 0 : static int brd_ioctl(struct block_device *bdev, fmode_t mode,
387 : : unsigned int cmd, unsigned long arg)
388 : : {
389 : : int error;
390 : 0 : struct brd_device *brd = bdev->bd_disk->private_data;
391 : :
392 [ # # ]: 0 : if (cmd != BLKFLSBUF)
393 : : return -ENOTTY;
394 : :
395 : : /*
396 : : * ram device BLKFLSBUF has special semantics, we want to actually
397 : : * release and destroy the ramdisk data.
398 : : */
399 : 0 : mutex_lock(&brd_mutex);
400 : 0 : mutex_lock(&bdev->bd_mutex);
401 : : error = -EBUSY;
402 [ # # ]: 0 : if (bdev->bd_openers <= 1) {
403 : : /*
404 : : * Kill the cache first, so it isn't written back to the
405 : : * device.
406 : : *
407 : : * Another thread might instantiate more buffercache here,
408 : : * but there is not much we can do to close that race.
409 : : */
410 : 0 : kill_bdev(bdev);
411 : 0 : brd_free_pages(brd);
412 : : error = 0;
413 : : }
414 : 0 : mutex_unlock(&bdev->bd_mutex);
415 : 0 : mutex_unlock(&brd_mutex);
416 : :
417 : 0 : return error;
418 : : }
419 : :
420 : : static const struct block_device_operations brd_fops = {
421 : : .owner = THIS_MODULE,
422 : : .ioctl = brd_ioctl,
423 : : #ifdef CONFIG_BLK_DEV_XIP
424 : : .direct_access = brd_direct_access,
425 : : #endif
426 : : };
427 : :
428 : : /*
429 : : * And now the modules code and kernel interface.
430 : : */
431 : : static int rd_nr;
432 : : int rd_size = CONFIG_BLK_DEV_RAM_SIZE;
433 : : static int max_part;
434 : : static int part_shift;
435 : : module_param(rd_nr, int, S_IRUGO);
436 : : MODULE_PARM_DESC(rd_nr, "Maximum number of brd devices");
437 : : module_param(rd_size, int, S_IRUGO);
438 : : MODULE_PARM_DESC(rd_size, "Size of each RAM disk in kbytes.");
439 : : module_param(max_part, int, S_IRUGO);
440 : : MODULE_PARM_DESC(max_part, "Maximum number of partitions per RAM disk");
441 : : MODULE_LICENSE("GPL");
442 : : MODULE_ALIAS_BLOCKDEV_MAJOR(RAMDISK_MAJOR);
443 : : MODULE_ALIAS("rd");
444 : :
445 : : #ifndef MODULE
446 : : /* Legacy boot options - nonmodular */
447 : 0 : static int __init ramdisk_size(char *str)
448 : : {
449 : 0 : rd_size = simple_strtol(str, NULL, 0);
450 : 0 : return 1;
451 : : }
452 : : __setup("ramdisk_size=", ramdisk_size);
453 : : #endif
454 : :
455 : : /*
456 : : * The device scheme is derived from loop.c. Keep them in synch where possible
457 : : * (should share code eventually).
458 : : */
459 : : static LIST_HEAD(brd_devices);
460 : : static DEFINE_MUTEX(brd_devices_mutex);
461 : :
462 : 0 : static struct brd_device *brd_alloc(int i)
463 : : {
464 : : struct brd_device *brd;
465 : : struct gendisk *disk;
466 : :
467 : : brd = kzalloc(sizeof(*brd), GFP_KERNEL);
468 [ # # ]: 0 : if (!brd)
469 : : goto out;
470 : 0 : brd->brd_number = i;
471 : 0 : spin_lock_init(&brd->brd_lock);
472 : 0 : INIT_RADIX_TREE(&brd->brd_pages, GFP_ATOMIC);
473 : :
474 : 0 : brd->brd_queue = blk_alloc_queue(GFP_KERNEL);
475 [ # # ]: 0 : if (!brd->brd_queue)
476 : : goto out_free_dev;
477 : 0 : blk_queue_make_request(brd->brd_queue, brd_make_request);
478 : 0 : blk_queue_max_hw_sectors(brd->brd_queue, 1024);
479 : 0 : blk_queue_bounce_limit(brd->brd_queue, BLK_BOUNCE_ANY);
480 : :
481 : 0 : brd->brd_queue->limits.discard_granularity = PAGE_SIZE;
482 : 0 : brd->brd_queue->limits.max_discard_sectors = UINT_MAX;
483 : 0 : brd->brd_queue->limits.discard_zeroes_data = 1;
484 : 0 : queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, brd->brd_queue);
485 : :
486 : 0 : disk = brd->brd_disk = alloc_disk(1 << part_shift);
487 [ # # ]: 0 : if (!disk)
488 : : goto out_free_queue;
489 : 0 : disk->major = RAMDISK_MAJOR;
490 : 0 : disk->first_minor = i << part_shift;
491 : 0 : disk->fops = &brd_fops;
492 : 0 : disk->private_data = brd;
493 : 0 : disk->queue = brd->brd_queue;
494 : 0 : disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
495 : 0 : sprintf(disk->disk_name, "ram%d", i);
496 : 0 : set_capacity(disk, rd_size * 2);
497 : :
498 : 0 : return brd;
499 : :
500 : : out_free_queue:
501 : 0 : blk_cleanup_queue(brd->brd_queue);
502 : : out_free_dev:
503 : 0 : kfree(brd);
504 : : out:
505 : : return NULL;
506 : : }
507 : :
508 : 0 : static void brd_free(struct brd_device *brd)
509 : : {
510 : 0 : put_disk(brd->brd_disk);
511 : 0 : blk_cleanup_queue(brd->brd_queue);
512 : 0 : brd_free_pages(brd);
513 : 0 : kfree(brd);
514 : 0 : }
515 : :
516 : 0 : static struct brd_device *brd_init_one(int i)
517 : : {
518 : : struct brd_device *brd;
519 : :
520 [ # # ]: 0 : list_for_each_entry(brd, &brd_devices, brd_list) {
521 [ # # ]: 0 : if (brd->brd_number == i)
522 : : goto out;
523 : : }
524 : :
525 : 0 : brd = brd_alloc(i);
526 [ # # ]: 0 : if (brd) {
527 : 0 : add_disk(brd->brd_disk);
528 : 0 : list_add_tail(&brd->brd_list, &brd_devices);
529 : : }
530 : : out:
531 : 0 : return brd;
532 : : }
533 : :
534 : 0 : static void brd_del_one(struct brd_device *brd)
535 : : {
536 : : list_del(&brd->brd_list);
537 : 0 : del_gendisk(brd->brd_disk);
538 : 0 : brd_free(brd);
539 : 0 : }
540 : :
541 : 0 : static struct kobject *brd_probe(dev_t dev, int *part, void *data)
542 : : {
543 : : struct brd_device *brd;
544 : : struct kobject *kobj;
545 : :
546 : 0 : mutex_lock(&brd_devices_mutex);
547 : 0 : brd = brd_init_one(MINOR(dev) >> part_shift);
548 [ # # ]: 0 : kobj = brd ? get_disk(brd->brd_disk) : NULL;
549 : 0 : mutex_unlock(&brd_devices_mutex);
550 : :
551 : 0 : *part = 0;
552 : 0 : return kobj;
553 : : }
554 : :
555 : 0 : static int __init brd_init(void)
556 : : {
557 : : int i, nr;
558 : : unsigned long range;
559 : : struct brd_device *brd, *next;
560 : :
561 : : /*
562 : : * brd module now has a feature to instantiate underlying device
563 : : * structure on-demand, provided that there is an access dev node.
564 : : * However, this will not work well with user space tool that doesn't
565 : : * know about such "feature". In order to not break any existing
566 : : * tool, we do the following:
567 : : *
568 : : * (1) if rd_nr is specified, create that many upfront, and this
569 : : * also becomes a hard limit.
570 : : * (2) if rd_nr is not specified, create CONFIG_BLK_DEV_RAM_COUNT
571 : : * (default 16) rd device on module load, user can further
572 : : * extend brd device by create dev node themselves and have
573 : : * kernel automatically instantiate actual device on-demand.
574 : : */
575 : :
576 : 0 : part_shift = 0;
577 [ # # ]: 0 : if (max_part > 0) {
578 : 0 : part_shift = fls(max_part);
579 : :
580 : : /*
581 : : * Adjust max_part according to part_shift as it is exported
582 : : * to user space so that user can decide correct minor number
583 : : * if [s]he want to create more devices.
584 : : *
585 : : * Note that -1 is required because partition 0 is reserved
586 : : * for the whole disk.
587 : : */
588 : 0 : max_part = (1UL << part_shift) - 1;
589 : : }
590 : :
591 [ # # ]: 0 : if ((1UL << part_shift) > DISK_MAX_PARTS)
592 : : return -EINVAL;
593 : :
594 [ # # ]: 0 : if (rd_nr > 1UL << (MINORBITS - part_shift))
595 : : return -EINVAL;
596 : :
597 [ # # ]: 0 : if (rd_nr) {
598 : : nr = rd_nr;
599 : 0 : range = rd_nr << part_shift;
600 : : } else {
601 : : nr = CONFIG_BLK_DEV_RAM_COUNT;
602 : : range = 1UL << MINORBITS;
603 : : }
604 : :
605 [ # # ]: 0 : if (register_blkdev(RAMDISK_MAJOR, "ramdisk"))
606 : : return -EIO;
607 : :
608 [ # # ]: 0 : for (i = 0; i < nr; i++) {
609 : 0 : brd = brd_alloc(i);
610 [ # # ]: 0 : if (!brd)
611 : : goto out_free;
612 : 0 : list_add_tail(&brd->brd_list, &brd_devices);
613 : : }
614 : :
615 : : /* point of no return */
616 : :
617 [ # # ]: 0 : list_for_each_entry(brd, &brd_devices, brd_list)
618 : 0 : add_disk(brd->brd_disk);
619 : :
620 : 0 : blk_register_region(MKDEV(RAMDISK_MAJOR, 0), range,
621 : : THIS_MODULE, brd_probe, NULL, NULL);
622 : :
623 : 0 : printk(KERN_INFO "brd: module loaded\n");
624 : 0 : return 0;
625 : :
626 : : out_free:
627 [ # # ]: 0 : list_for_each_entry_safe(brd, next, &brd_devices, brd_list) {
628 : : list_del(&brd->brd_list);
629 : 0 : brd_free(brd);
630 : : }
631 : 0 : unregister_blkdev(RAMDISK_MAJOR, "ramdisk");
632 : :
633 : 0 : return -ENOMEM;
634 : : }
635 : :
636 : 0 : static void __exit brd_exit(void)
637 : : {
638 : : unsigned long range;
639 : : struct brd_device *brd, *next;
640 : :
641 [ # # ]: 0 : range = rd_nr ? rd_nr << part_shift : 1UL << MINORBITS;
642 : :
643 [ # # ]: 0 : list_for_each_entry_safe(brd, next, &brd_devices, brd_list)
644 : 0 : brd_del_one(brd);
645 : :
646 : 0 : blk_unregister_region(MKDEV(RAMDISK_MAJOR, 0), range);
647 : 0 : unregister_blkdev(RAMDISK_MAJOR, "ramdisk");
648 : 0 : }
649 : :
650 : : module_init(brd_init);
651 : : module_exit(brd_exit);
652 : :
|
