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