1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/blkdev.h>
20#include <linux/module.h>
21#include <linux/errno.h>
22#include <linux/slab.h>
23#include <linux/init.h>
24#include <linux/timer.h>
25#include <linux/sched.h>
26#include <linux/list.h>
27#include <linux/file.h>
28#include <linux/mount.h>
29#include <linux/buffer_head.h>
30#include "md.h"
31#include "bitmap.h"
32
33
34
35#define DEBUG 0
36
37#if DEBUG
38
39
40
41#define INJECT_FAULTS_1 0
42#define INJECT_FAULTS_2 0
43#define INJECT_FAULTS_3 0
44#define INJECT_FAULTS_4 0
45#define INJECT_FAULTS_5 0
46#define INJECT_FAULTS_6 0
47
48
49#define INJECT_FATAL_FAULT_1 0
50#define INJECT_FATAL_FAULT_2 0
51#define INJECT_FATAL_FAULT_3 0
52#endif
53
54
55#define DPRINTK(x...) do { } while(0)
56
57#ifndef PRINTK
58# if DEBUG > 0
59# define PRINTK(x...) printk(KERN_DEBUG x)
60# else
61# define PRINTK(x...)
62# endif
63#endif
64
65static inline char * bmname(struct bitmap *bitmap)
66{
67 return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";
68}
69
70
71
72
73
74static unsigned char *bitmap_alloc_page(struct bitmap *bitmap)
75{
76 unsigned char *page;
77
78#ifdef INJECT_FAULTS_1
79 page = NULL;
80#else
81 page = kmalloc(PAGE_SIZE, GFP_NOIO);
82#endif
83 if (!page)
84 printk("%s: bitmap_alloc_page FAILED\n", bmname(bitmap));
85 else
86 PRINTK("%s: bitmap_alloc_page: allocated page at %p\n",
87 bmname(bitmap), page);
88 return page;
89}
90
91
92
93
94static void bitmap_free_page(struct bitmap *bitmap, unsigned char *page)
95{
96 PRINTK("%s: bitmap_free_page: free page %p\n", bmname(bitmap), page);
97 kfree(page);
98}
99
100
101
102
103
104
105
106
107
108
109
110static int bitmap_checkpage(struct bitmap *bitmap, unsigned long page, int create)
111__releases(bitmap->lock)
112__acquires(bitmap->lock)
113{
114 unsigned char *mappage;
115
116 if (page >= bitmap->pages) {
117
118
119
120
121 return -EINVAL;
122 }
123
124
125 if (bitmap->bp[page].hijacked)
126 return 0;
127
128 if (bitmap->bp[page].map)
129 return 0;
130
131 if (!create)
132 return -ENOENT;
133
134 spin_unlock_irq(&bitmap->lock);
135
136
137
138 if ((mappage = bitmap_alloc_page(bitmap)) == NULL) {
139 PRINTK("%s: bitmap map page allocation failed, hijacking\n",
140 bmname(bitmap));
141
142
143 spin_lock_irq(&bitmap->lock);
144 if (!bitmap->bp[page].map)
145 bitmap->bp[page].hijacked = 1;
146 goto out;
147 }
148
149
150
151 spin_lock_irq(&bitmap->lock);
152
153
154
155 if (bitmap->bp[page].map || bitmap->bp[page].hijacked) {
156
157 bitmap_free_page(bitmap, mappage);
158 return 0;
159 }
160
161
162
163 memset(mappage, 0, PAGE_SIZE);
164 bitmap->bp[page].map = mappage;
165 bitmap->missing_pages--;
166out:
167 return 0;
168}
169
170
171
172
173
174static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page)
175{
176 char *ptr;
177
178 if (bitmap->bp[page].count)
179 return;
180
181
182
183 if (bitmap->bp[page].hijacked) {
184 bitmap->bp[page].hijacked = 0;
185 bitmap->bp[page].map = NULL;
186 return;
187 }
188
189
190
191#if 0
192
193
194
195 return;
196#else
197 ptr = bitmap->bp[page].map;
198 bitmap->bp[page].map = NULL;
199 bitmap->missing_pages++;
200 bitmap_free_page(bitmap, ptr);
201 return;
202#endif
203}
204
205
206
207
208
209
210
211
212
213
214
215static struct page *read_sb_page(mddev_t *mddev, long offset,
216 struct page *page,
217 unsigned long index, int size)
218{
219
220
221 mdk_rdev_t *rdev;
222 sector_t target;
223
224 if (!page)
225 page = alloc_page(GFP_KERNEL);
226 if (!page)
227 return ERR_PTR(-ENOMEM);
228
229 list_for_each_entry(rdev, &mddev->disks, same_set) {
230 if (! test_bit(In_sync, &rdev->flags)
231 || test_bit(Faulty, &rdev->flags))
232 continue;
233
234 target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
235
236 if (sync_page_io(rdev->bdev, target,
237 roundup(size, bdev_logical_block_size(rdev->bdev)),
238 page, READ)) {
239 page->index = index;
240 attach_page_buffers(page, NULL);
241
242 return page;
243 }
244 }
245 return ERR_PTR(-EIO);
246
247}
248
249static mdk_rdev_t *next_active_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
250{
251
252
253
254
255
256
257
258
259 struct list_head *pos;
260 rcu_read_lock();
261 if (rdev == NULL)
262
263 pos = &mddev->disks;
264 else {
265
266 rdev_dec_pending(rdev, mddev);
267 pos = &rdev->same_set;
268 }
269 list_for_each_continue_rcu(pos, &mddev->disks) {
270 rdev = list_entry(pos, mdk_rdev_t, same_set);
271 if (rdev->raid_disk >= 0 &&
272 !test_bit(Faulty, &rdev->flags)) {
273
274 atomic_inc(&rdev->nr_pending);
275 rcu_read_unlock();
276 return rdev;
277 }
278 }
279 rcu_read_unlock();
280 return NULL;
281}
282
283static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
284{
285 mdk_rdev_t *rdev = NULL;
286 mddev_t *mddev = bitmap->mddev;
287
288 while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
289 int size = PAGE_SIZE;
290 if (page->index == bitmap->file_pages-1)
291 size = roundup(bitmap->last_page_size,
292 bdev_logical_block_size(rdev->bdev));
293
294
295
296 if (bitmap->offset < 0) {
297
298 if (bitmap->offset
299 + (long)(page->index * (PAGE_SIZE/512))
300 + size/512 > 0)
301
302 goto bad_alignment;
303 if (rdev->data_offset + mddev->dev_sectors
304 > rdev->sb_start + bitmap->offset)
305
306 goto bad_alignment;
307 } else if (rdev->sb_start < rdev->data_offset) {
308
309 if (rdev->sb_start
310 + bitmap->offset
311 + page->index*(PAGE_SIZE/512) + size/512
312 > rdev->data_offset)
313
314 goto bad_alignment;
315 } else {
316
317 }
318 md_super_write(mddev, rdev,
319 rdev->sb_start + bitmap->offset
320 + page->index * (PAGE_SIZE/512),
321 size,
322 page);
323 }
324
325 if (wait)
326 md_super_wait(mddev);
327 return 0;
328
329 bad_alignment:
330 return -EINVAL;
331}
332
333static void bitmap_file_kick(struct bitmap *bitmap);
334
335
336
337static void write_page(struct bitmap *bitmap, struct page *page, int wait)
338{
339 struct buffer_head *bh;
340
341 if (bitmap->file == NULL) {
342 switch (write_sb_page(bitmap, page, wait)) {
343 case -EINVAL:
344 bitmap->flags |= BITMAP_WRITE_ERROR;
345 }
346 } else {
347
348 bh = page_buffers(page);
349
350 while (bh && bh->b_blocknr) {
351 atomic_inc(&bitmap->pending_writes);
352 set_buffer_locked(bh);
353 set_buffer_mapped(bh);
354 submit_bh(WRITE, bh);
355 bh = bh->b_this_page;
356 }
357
358 if (wait) {
359 wait_event(bitmap->write_wait,
360 atomic_read(&bitmap->pending_writes)==0);
361 }
362 }
363 if (bitmap->flags & BITMAP_WRITE_ERROR)
364 bitmap_file_kick(bitmap);
365}
366
367static void end_bitmap_write(struct buffer_head *bh, int uptodate)
368{
369 struct bitmap *bitmap = bh->b_private;
370 unsigned long flags;
371
372 if (!uptodate) {
373 spin_lock_irqsave(&bitmap->lock, flags);
374 bitmap->flags |= BITMAP_WRITE_ERROR;
375 spin_unlock_irqrestore(&bitmap->lock, flags);
376 }
377 if (atomic_dec_and_test(&bitmap->pending_writes))
378 wake_up(&bitmap->write_wait);
379}
380
381
382static void
383__clear_page_buffers(struct page *page)
384{
385 ClearPagePrivate(page);
386 set_page_private(page, 0);
387 page_cache_release(page);
388}
389static void free_buffers(struct page *page)
390{
391 struct buffer_head *bh = page_buffers(page);
392
393 while (bh) {
394 struct buffer_head *next = bh->b_this_page;
395 free_buffer_head(bh);
396 bh = next;
397 }
398 __clear_page_buffers(page);
399 put_page(page);
400}
401
402
403
404
405
406
407
408
409static struct page *read_page(struct file *file, unsigned long index,
410 struct bitmap *bitmap,
411 unsigned long count)
412{
413 struct page *page = NULL;
414 struct inode *inode = file->f_path.dentry->d_inode;
415 struct buffer_head *bh;
416 sector_t block;
417
418 PRINTK("read bitmap file (%dB @ %Lu)\n", (int)PAGE_SIZE,
419 (unsigned long long)index << PAGE_SHIFT);
420
421 page = alloc_page(GFP_KERNEL);
422 if (!page)
423 page = ERR_PTR(-ENOMEM);
424 if (IS_ERR(page))
425 goto out;
426
427 bh = alloc_page_buffers(page, 1<<inode->i_blkbits, 0);
428 if (!bh) {
429 put_page(page);
430 page = ERR_PTR(-ENOMEM);
431 goto out;
432 }
433 attach_page_buffers(page, bh);
434 block = index << (PAGE_SHIFT - inode->i_blkbits);
435 while (bh) {
436 if (count == 0)
437 bh->b_blocknr = 0;
438 else {
439 bh->b_blocknr = bmap(inode, block);
440 if (bh->b_blocknr == 0) {
441
442 free_buffers(page);
443 page = ERR_PTR(-EINVAL);
444 goto out;
445 }
446 bh->b_bdev = inode->i_sb->s_bdev;
447 if (count < (1<<inode->i_blkbits))
448 count = 0;
449 else
450 count -= (1<<inode->i_blkbits);
451
452 bh->b_end_io = end_bitmap_write;
453 bh->b_private = bitmap;
454 atomic_inc(&bitmap->pending_writes);
455 set_buffer_locked(bh);
456 set_buffer_mapped(bh);
457 submit_bh(READ, bh);
458 }
459 block++;
460 bh = bh->b_this_page;
461 }
462 page->index = index;
463
464 wait_event(bitmap->write_wait,
465 atomic_read(&bitmap->pending_writes)==0);
466 if (bitmap->flags & BITMAP_WRITE_ERROR) {
467 free_buffers(page);
468 page = ERR_PTR(-EIO);
469 }
470out:
471 if (IS_ERR(page))
472 printk(KERN_ALERT "md: bitmap read error: (%dB @ %Lu): %ld\n",
473 (int)PAGE_SIZE,
474 (unsigned long long)index << PAGE_SHIFT,
475 PTR_ERR(page));
476 return page;
477}
478
479
480
481
482
483
484void bitmap_update_sb(struct bitmap *bitmap)
485{
486 bitmap_super_t *sb;
487 unsigned long flags;
488
489 if (!bitmap || !bitmap->mddev)
490 return;
491 spin_lock_irqsave(&bitmap->lock, flags);
492 if (!bitmap->sb_page) {
493 spin_unlock_irqrestore(&bitmap->lock, flags);
494 return;
495 }
496 spin_unlock_irqrestore(&bitmap->lock, flags);
497 sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
498 sb->events = cpu_to_le64(bitmap->mddev->events);
499 if (bitmap->mddev->events < bitmap->events_cleared) {
500
501 bitmap->events_cleared = bitmap->mddev->events;
502 sb->events_cleared = cpu_to_le64(bitmap->events_cleared);
503 }
504 kunmap_atomic(sb, KM_USER0);
505 write_page(bitmap, bitmap->sb_page, 1);
506}
507
508
509void bitmap_print_sb(struct bitmap *bitmap)
510{
511 bitmap_super_t *sb;
512
513 if (!bitmap || !bitmap->sb_page)
514 return;
515 sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
516 printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
517 printk(KERN_DEBUG " magic: %08x\n", le32_to_cpu(sb->magic));
518 printk(KERN_DEBUG " version: %d\n", le32_to_cpu(sb->version));
519 printk(KERN_DEBUG " uuid: %08x.%08x.%08x.%08x\n",
520 *(__u32 *)(sb->uuid+0),
521 *(__u32 *)(sb->uuid+4),
522 *(__u32 *)(sb->uuid+8),
523 *(__u32 *)(sb->uuid+12));
524 printk(KERN_DEBUG " events: %llu\n",
525 (unsigned long long) le64_to_cpu(sb->events));
526 printk(KERN_DEBUG "events cleared: %llu\n",
527 (unsigned long long) le64_to_cpu(sb->events_cleared));
528 printk(KERN_DEBUG " state: %08x\n", le32_to_cpu(sb->state));
529 printk(KERN_DEBUG " chunksize: %d B\n", le32_to_cpu(sb->chunksize));
530 printk(KERN_DEBUG " daemon sleep: %ds\n", le32_to_cpu(sb->daemon_sleep));
531 printk(KERN_DEBUG " sync size: %llu KB\n",
532 (unsigned long long)le64_to_cpu(sb->sync_size)/2);
533 printk(KERN_DEBUG "max write behind: %d\n", le32_to_cpu(sb->write_behind));
534 kunmap_atomic(sb, KM_USER0);
535}
536
537
538static int bitmap_read_sb(struct bitmap *bitmap)
539{
540 char *reason = NULL;
541 bitmap_super_t *sb;
542 unsigned long chunksize, daemon_sleep, write_behind;
543 unsigned long long events;
544 int err = -EINVAL;
545
546
547 if (bitmap->file) {
548 loff_t isize = i_size_read(bitmap->file->f_mapping->host);
549 int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;
550
551 bitmap->sb_page = read_page(bitmap->file, 0, bitmap, bytes);
552 } else {
553 bitmap->sb_page = read_sb_page(bitmap->mddev, bitmap->offset,
554 NULL,
555 0, sizeof(bitmap_super_t));
556 }
557 if (IS_ERR(bitmap->sb_page)) {
558 err = PTR_ERR(bitmap->sb_page);
559 bitmap->sb_page = NULL;
560 return err;
561 }
562
563 sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
564
565 chunksize = le32_to_cpu(sb->chunksize);
566 daemon_sleep = le32_to_cpu(sb->daemon_sleep);
567 write_behind = le32_to_cpu(sb->write_behind);
568
569
570 if (sb->magic != cpu_to_le32(BITMAP_MAGIC))
571 reason = "bad magic";
572 else if (le32_to_cpu(sb->version) < BITMAP_MAJOR_LO ||
573 le32_to_cpu(sb->version) > BITMAP_MAJOR_HI)
574 reason = "unrecognized superblock version";
575 else if (chunksize < 512)
576 reason = "bitmap chunksize too small";
577 else if ((1 << ffz(~chunksize)) != chunksize)
578 reason = "bitmap chunksize not a power of 2";
579 else if (daemon_sleep < 1 || daemon_sleep > MAX_SCHEDULE_TIMEOUT / HZ)
580 reason = "daemon sleep period out of range";
581 else if (write_behind > COUNTER_MAX)
582 reason = "write-behind limit out of range (0 - 16383)";
583 if (reason) {
584 printk(KERN_INFO "%s: invalid bitmap file superblock: %s\n",
585 bmname(bitmap), reason);
586 goto out;
587 }
588
589
590 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
591
592 if (!bitmap->mddev->persistent)
593 goto success;
594
595
596
597
598
599 if (memcmp(sb->uuid, bitmap->mddev->uuid, 16)) {
600 printk(KERN_INFO "%s: bitmap superblock UUID mismatch\n",
601 bmname(bitmap));
602 goto out;
603 }
604 events = le64_to_cpu(sb->events);
605 if (events < bitmap->mddev->events) {
606 printk(KERN_INFO "%s: bitmap file is out of date (%llu < %llu) "
607 "-- forcing full recovery\n", bmname(bitmap), events,
608 (unsigned long long) bitmap->mddev->events);
609 sb->state |= cpu_to_le32(BITMAP_STALE);
610 }
611success:
612
613 bitmap->chunksize = chunksize;
614 bitmap->daemon_sleep = daemon_sleep;
615 bitmap->daemon_lastrun = jiffies;
616 bitmap->max_write_behind = write_behind;
617 bitmap->flags |= le32_to_cpu(sb->state);
618 if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)
619 bitmap->flags |= BITMAP_HOSTENDIAN;
620 bitmap->events_cleared = le64_to_cpu(sb->events_cleared);
621 if (sb->state & cpu_to_le32(BITMAP_STALE))
622 bitmap->events_cleared = bitmap->mddev->events;
623 err = 0;
624out:
625 kunmap_atomic(sb, KM_USER0);
626 if (err)
627 bitmap_print_sb(bitmap);
628 return err;
629}
630
631enum bitmap_mask_op {
632 MASK_SET,
633 MASK_UNSET
634};
635
636
637static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
638 enum bitmap_mask_op op)
639{
640 bitmap_super_t *sb;
641 unsigned long flags;
642 int old;
643
644 spin_lock_irqsave(&bitmap->lock, flags);
645 if (!bitmap->sb_page) {
646 spin_unlock_irqrestore(&bitmap->lock, flags);
647 return 0;
648 }
649 spin_unlock_irqrestore(&bitmap->lock, flags);
650 sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
651 old = le32_to_cpu(sb->state) & bits;
652 switch (op) {
653 case MASK_SET: sb->state |= cpu_to_le32(bits);
654 break;
655 case MASK_UNSET: sb->state &= cpu_to_le32(~bits);
656 break;
657 default: BUG();
658 }
659 kunmap_atomic(sb, KM_USER0);
660 return old;
661}
662
663
664
665
666
667
668static inline unsigned long file_page_index(unsigned long chunk)
669{
670 return CHUNK_BIT_OFFSET(chunk) >> PAGE_BIT_SHIFT;
671}
672
673
674static inline unsigned long file_page_offset(unsigned long chunk)
675{
676 return CHUNK_BIT_OFFSET(chunk) & (PAGE_BITS - 1);
677}
678
679
680
681
682
683
684
685
686static inline struct page *filemap_get_page(struct bitmap *bitmap,
687 unsigned long chunk)
688{
689 if (file_page_index(chunk) >= bitmap->file_pages) return NULL;
690 return bitmap->filemap[file_page_index(chunk) - file_page_index(0)];
691}
692
693
694static void bitmap_file_unmap(struct bitmap *bitmap)
695{
696 struct page **map, *sb_page;
697 unsigned long *attr;
698 int pages;
699 unsigned long flags;
700
701 spin_lock_irqsave(&bitmap->lock, flags);
702 map = bitmap->filemap;
703 bitmap->filemap = NULL;
704 attr = bitmap->filemap_attr;
705 bitmap->filemap_attr = NULL;
706 pages = bitmap->file_pages;
707 bitmap->file_pages = 0;
708 sb_page = bitmap->sb_page;
709 bitmap->sb_page = NULL;
710 spin_unlock_irqrestore(&bitmap->lock, flags);
711
712 while (pages--)
713 if (map[pages]->index != 0)
714 free_buffers(map[pages]);
715 kfree(map);
716 kfree(attr);
717
718 if (sb_page)
719 free_buffers(sb_page);
720}
721
722static void bitmap_file_put(struct bitmap *bitmap)
723{
724 struct file *file;
725 unsigned long flags;
726
727 spin_lock_irqsave(&bitmap->lock, flags);
728 file = bitmap->file;
729 bitmap->file = NULL;
730 spin_unlock_irqrestore(&bitmap->lock, flags);
731
732 if (file)
733 wait_event(bitmap->write_wait,
734 atomic_read(&bitmap->pending_writes)==0);
735 bitmap_file_unmap(bitmap);
736
737 if (file) {
738 struct inode *inode = file->f_path.dentry->d_inode;
739 invalidate_mapping_pages(inode->i_mapping, 0, -1);
740 fput(file);
741 }
742}
743
744
745
746
747
748
749
750static void bitmap_file_kick(struct bitmap *bitmap)
751{
752 char *path, *ptr = NULL;
753
754 if (bitmap_mask_state(bitmap, BITMAP_STALE, MASK_SET) == 0) {
755 bitmap_update_sb(bitmap);
756
757 if (bitmap->file) {
758 path = kmalloc(PAGE_SIZE, GFP_KERNEL);
759 if (path)
760 ptr = d_path(&bitmap->file->f_path, path,
761 PAGE_SIZE);
762
763
764 printk(KERN_ALERT
765 "%s: kicking failed bitmap file %s from array!\n",
766 bmname(bitmap), IS_ERR(ptr) ? "" : ptr);
767
768 kfree(path);
769 } else
770 printk(KERN_ALERT
771 "%s: disabling internal bitmap due to errors\n",
772 bmname(bitmap));
773 }
774
775 bitmap_file_put(bitmap);
776
777 return;
778}
779
780enum bitmap_page_attr {
781 BITMAP_PAGE_DIRTY = 0,
782 BITMAP_PAGE_CLEAN = 1,
783 BITMAP_PAGE_NEEDWRITE=2,
784};
785
786static inline void set_page_attr(struct bitmap *bitmap, struct page *page,
787 enum bitmap_page_attr attr)
788{
789 __set_bit((page->index<<2) + attr, bitmap->filemap_attr);
790}
791
792static inline void clear_page_attr(struct bitmap *bitmap, struct page *page,
793 enum bitmap_page_attr attr)
794{
795 __clear_bit((page->index<<2) + attr, bitmap->filemap_attr);
796}
797
798static inline unsigned long test_page_attr(struct bitmap *bitmap, struct page *page,
799 enum bitmap_page_attr attr)
800{
801 return test_bit((page->index<<2) + attr, bitmap->filemap_attr);
802}
803
804
805
806
807
808
809
810
811static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
812{
813 unsigned long bit;
814 struct page *page;
815 void *kaddr;
816 unsigned long chunk = block >> CHUNK_BLOCK_SHIFT(bitmap);
817
818 if (!bitmap->filemap) {
819 return;
820 }
821
822 page = filemap_get_page(bitmap, chunk);
823 if (!page) return;
824 bit = file_page_offset(chunk);
825
826
827 kaddr = kmap_atomic(page, KM_USER0);
828 if (bitmap->flags & BITMAP_HOSTENDIAN)
829 set_bit(bit, kaddr);
830 else
831 ext2_set_bit(bit, kaddr);
832 kunmap_atomic(kaddr, KM_USER0);
833 PRINTK("set file bit %lu page %lu\n", bit, page->index);
834
835
836 set_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
837
838}
839
840
841
842
843void bitmap_unplug(struct bitmap *bitmap)
844{
845 unsigned long i, flags;
846 int dirty, need_write;
847 struct page *page;
848 int wait = 0;
849
850 if (!bitmap)
851 return;
852
853
854
855 for (i = 0; i < bitmap->file_pages; i++) {
856 spin_lock_irqsave(&bitmap->lock, flags);
857 if (!bitmap->filemap) {
858 spin_unlock_irqrestore(&bitmap->lock, flags);
859 return;
860 }
861 page = bitmap->filemap[i];
862 dirty = test_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
863 need_write = test_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);
864 clear_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
865 clear_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);
866 if (dirty)
867 wait = 1;
868 spin_unlock_irqrestore(&bitmap->lock, flags);
869
870 if (dirty | need_write)
871 write_page(bitmap, page, 0);
872 }
873 if (wait) {
874 if (bitmap->file)
875 wait_event(bitmap->write_wait,
876 atomic_read(&bitmap->pending_writes)==0);
877 else
878 md_super_wait(bitmap->mddev);
879 }
880 if (bitmap->flags & BITMAP_WRITE_ERROR)
881 bitmap_file_kick(bitmap);
882}
883
884static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed);
885
886
887
888
889
890
891
892
893
894
895
896static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
897{
898 unsigned long i, chunks, index, oldindex, bit;
899 struct page *page = NULL, *oldpage = NULL;
900 unsigned long num_pages, bit_cnt = 0;
901 struct file *file;
902 unsigned long bytes, offset;
903 int outofdate;
904 int ret = -ENOSPC;
905 void *paddr;
906
907 chunks = bitmap->chunks;
908 file = bitmap->file;
909
910 BUG_ON(!file && !bitmap->offset);
911
912#ifdef INJECT_FAULTS_3
913 outofdate = 1;
914#else
915 outofdate = bitmap->flags & BITMAP_STALE;
916#endif
917 if (outofdate)
918 printk(KERN_INFO "%s: bitmap file is out of date, doing full "
919 "recovery\n", bmname(bitmap));
920
921 bytes = (chunks + 7) / 8;
922
923 num_pages = (bytes + sizeof(bitmap_super_t) + PAGE_SIZE - 1) / PAGE_SIZE;
924
925 if (file && i_size_read(file->f_mapping->host) < bytes + sizeof(bitmap_super_t)) {
926 printk(KERN_INFO "%s: bitmap file too short %lu < %lu\n",
927 bmname(bitmap),
928 (unsigned long) i_size_read(file->f_mapping->host),
929 bytes + sizeof(bitmap_super_t));
930 goto err;
931 }
932
933 ret = -ENOMEM;
934
935 bitmap->filemap = kmalloc(sizeof(struct page *) * num_pages, GFP_KERNEL);
936 if (!bitmap->filemap)
937 goto err;
938
939
940 bitmap->filemap_attr = kzalloc(
941 roundup( DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
942 GFP_KERNEL);
943 if (!bitmap->filemap_attr)
944 goto err;
945
946 oldindex = ~0L;
947
948 for (i = 0; i < chunks; i++) {
949 int b;
950 index = file_page_index(i);
951 bit = file_page_offset(i);
952 if (index != oldindex) {
953 int count;
954
955 if (index == num_pages-1)
956 count = bytes + sizeof(bitmap_super_t)
957 - index * PAGE_SIZE;
958 else
959 count = PAGE_SIZE;
960 if (index == 0) {
961
962
963
964
965
966 page = bitmap->sb_page;
967 offset = sizeof(bitmap_super_t);
968 if (!file)
969 read_sb_page(bitmap->mddev,
970 bitmap->offset,
971 page,
972 index, count);
973 } else if (file) {
974 page = read_page(file, index, bitmap, count);
975 offset = 0;
976 } else {
977 page = read_sb_page(bitmap->mddev, bitmap->offset,
978 NULL,
979 index, count);
980 offset = 0;
981 }
982 if (IS_ERR(page)) {
983 ret = PTR_ERR(page);
984 goto err;
985 }
986
987 oldindex = index;
988 oldpage = page;
989
990 bitmap->filemap[bitmap->file_pages++] = page;
991 bitmap->last_page_size = count;
992
993 if (outofdate) {
994
995
996
997
998 paddr = kmap_atomic(page, KM_USER0);
999 memset(paddr + offset, 0xff,
1000 PAGE_SIZE - offset);
1001 kunmap_atomic(paddr, KM_USER0);
1002 write_page(bitmap, page, 1);
1003
1004 ret = -EIO;
1005 if (bitmap->flags & BITMAP_WRITE_ERROR)
1006 goto err;
1007 }
1008 }
1009 paddr = kmap_atomic(page, KM_USER0);
1010 if (bitmap->flags & BITMAP_HOSTENDIAN)
1011 b = test_bit(bit, paddr);
1012 else
1013 b = ext2_test_bit(bit, paddr);
1014 kunmap_atomic(paddr, KM_USER0);
1015 if (b) {
1016
1017 int needed = ((sector_t)(i+1) << (CHUNK_BLOCK_SHIFT(bitmap))
1018 >= start);
1019 bitmap_set_memory_bits(bitmap,
1020 (sector_t)i << CHUNK_BLOCK_SHIFT(bitmap),
1021 needed);
1022 bit_cnt++;
1023 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1024 }
1025 }
1026
1027
1028 ret = 0;
1029 bitmap_mask_state(bitmap, BITMAP_STALE, MASK_UNSET);
1030
1031 if (bit_cnt) {
1032 set_bit(MD_RECOVERY_NEEDED, &bitmap->mddev->recovery);
1033 md_wakeup_thread(bitmap->mddev->thread);
1034 }
1035
1036 printk(KERN_INFO "%s: bitmap initialized from disk: "
1037 "read %lu/%lu pages, set %lu bits\n",
1038 bmname(bitmap), bitmap->file_pages, num_pages, bit_cnt);
1039
1040 return 0;
1041
1042 err:
1043 printk(KERN_INFO "%s: bitmap initialisation failed: %d\n",
1044 bmname(bitmap), ret);
1045 return ret;
1046}
1047
1048void bitmap_write_all(struct bitmap *bitmap)
1049{
1050
1051
1052
1053 int i;
1054
1055 for (i=0; i < bitmap->file_pages; i++)
1056 set_page_attr(bitmap, bitmap->filemap[i],
1057 BITMAP_PAGE_NEEDWRITE);
1058}
1059
1060
1061static void bitmap_count_page(struct bitmap *bitmap, sector_t offset, int inc)
1062{
1063 sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);
1064 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1065 bitmap->bp[page].count += inc;
1066
1067
1068
1069
1070 bitmap_checkfree(bitmap, page);
1071}
1072static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
1073 sector_t offset, int *blocks,
1074 int create);
1075
1076
1077
1078
1079
1080
1081void bitmap_daemon_work(struct bitmap *bitmap)
1082{
1083 unsigned long j;
1084 unsigned long flags;
1085 struct page *page = NULL, *lastpage = NULL;
1086 int blocks;
1087 void *paddr;
1088
1089 if (bitmap == NULL)
1090 return;
1091 if (time_before(jiffies, bitmap->daemon_lastrun + bitmap->daemon_sleep*HZ))
1092 goto done;
1093
1094 bitmap->daemon_lastrun = jiffies;
1095 if (bitmap->allclean) {
1096 bitmap->mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
1097 return;
1098 }
1099 bitmap->allclean = 1;
1100
1101 spin_lock_irqsave(&bitmap->lock, flags);
1102 for (j = 0; j < bitmap->chunks; j++) {
1103 bitmap_counter_t *bmc;
1104 if (!bitmap->filemap)
1105
1106 break;
1107
1108 page = filemap_get_page(bitmap, j);
1109
1110 if (page != lastpage) {
1111
1112 if (!test_page_attr(bitmap, page, BITMAP_PAGE_CLEAN)) {
1113 int need_write = test_page_attr(bitmap, page,
1114 BITMAP_PAGE_NEEDWRITE);
1115 if (need_write)
1116 clear_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);
1117
1118 spin_unlock_irqrestore(&bitmap->lock, flags);
1119 if (need_write) {
1120 write_page(bitmap, page, 0);
1121 bitmap->allclean = 0;
1122 }
1123 spin_lock_irqsave(&bitmap->lock, flags);
1124 j |= (PAGE_BITS - 1);
1125 continue;
1126 }
1127
1128
1129 if (lastpage != NULL) {
1130 if (test_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE)) {
1131 clear_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1132 spin_unlock_irqrestore(&bitmap->lock, flags);
1133 write_page(bitmap, lastpage, 0);
1134 } else {
1135 set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1136 spin_unlock_irqrestore(&bitmap->lock, flags);
1137 }
1138 } else
1139 spin_unlock_irqrestore(&bitmap->lock, flags);
1140 lastpage = page;
1141
1142
1143
1144
1145 if (bitmap->need_sync) {
1146 bitmap_super_t *sb;
1147 bitmap->need_sync = 0;
1148 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
1149 sb->events_cleared =
1150 cpu_to_le64(bitmap->events_cleared);
1151 kunmap_atomic(sb, KM_USER0);
1152 write_page(bitmap, bitmap->sb_page, 1);
1153 }
1154 spin_lock_irqsave(&bitmap->lock, flags);
1155 clear_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1156 }
1157 bmc = bitmap_get_counter(bitmap,
1158 (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),
1159 &blocks, 0);
1160 if (bmc) {
1161
1162
1163
1164 if (*bmc)
1165 bitmap->allclean = 0;
1166
1167 if (*bmc == 2) {
1168 *bmc=1;
1169 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1170 } else if (*bmc == 1) {
1171
1172 *bmc = 0;
1173 bitmap_count_page(bitmap,
1174 (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),
1175 -1);
1176
1177
1178 paddr = kmap_atomic(page, KM_USER0);
1179 if (bitmap->flags & BITMAP_HOSTENDIAN)
1180 clear_bit(file_page_offset(j), paddr);
1181 else
1182 ext2_clear_bit(file_page_offset(j), paddr);
1183 kunmap_atomic(paddr, KM_USER0);
1184 }
1185 } else
1186 j |= PAGE_COUNTER_MASK;
1187 }
1188 spin_unlock_irqrestore(&bitmap->lock, flags);
1189
1190
1191 if (lastpage != NULL) {
1192 spin_lock_irqsave(&bitmap->lock, flags);
1193 if (test_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE)) {
1194 clear_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1195 spin_unlock_irqrestore(&bitmap->lock, flags);
1196 write_page(bitmap, lastpage, 0);
1197 } else {
1198 set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1199 spin_unlock_irqrestore(&bitmap->lock, flags);
1200 }
1201 }
1202
1203 done:
1204 if (bitmap->allclean == 0)
1205 bitmap->mddev->thread->timeout = bitmap->daemon_sleep * HZ;
1206}
1207
1208static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
1209 sector_t offset, int *blocks,
1210 int create)
1211__releases(bitmap->lock)
1212__acquires(bitmap->lock)
1213{
1214
1215
1216
1217
1218 sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);
1219 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1220 unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
1221 sector_t csize;
1222
1223 if (bitmap_checkpage(bitmap, page, create) < 0) {
1224 csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap));
1225 *blocks = csize - (offset & (csize- 1));
1226 return NULL;
1227 }
1228
1229
1230 if (bitmap->bp[page].hijacked) {
1231
1232
1233 int hi = (pageoff > PAGE_COUNTER_MASK);
1234 csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap) +
1235 PAGE_COUNTER_SHIFT - 1);
1236 *blocks = csize - (offset & (csize- 1));
1237 return &((bitmap_counter_t *)
1238 &bitmap->bp[page].map)[hi];
1239 } else {
1240 csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap));
1241 *blocks = csize - (offset & (csize- 1));
1242 return (bitmap_counter_t *)
1243 &(bitmap->bp[page].map[pageoff]);
1244 }
1245}
1246
1247int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int behind)
1248{
1249 if (!bitmap) return 0;
1250
1251 if (behind) {
1252 atomic_inc(&bitmap->behind_writes);
1253 PRINTK(KERN_DEBUG "inc write-behind count %d/%d\n",
1254 atomic_read(&bitmap->behind_writes), bitmap->max_write_behind);
1255 }
1256
1257 while (sectors) {
1258 int blocks;
1259 bitmap_counter_t *bmc;
1260
1261 spin_lock_irq(&bitmap->lock);
1262 bmc = bitmap_get_counter(bitmap, offset, &blocks, 1);
1263 if (!bmc) {
1264 spin_unlock_irq(&bitmap->lock);
1265 return 0;
1266 }
1267
1268 if (unlikely((*bmc & COUNTER_MAX) == COUNTER_MAX)) {
1269 DEFINE_WAIT(__wait);
1270
1271
1272
1273
1274 prepare_to_wait(&bitmap->overflow_wait, &__wait,
1275 TASK_UNINTERRUPTIBLE);
1276 spin_unlock_irq(&bitmap->lock);
1277 blk_unplug(bitmap->mddev->queue);
1278 schedule();
1279 finish_wait(&bitmap->overflow_wait, &__wait);
1280 continue;
1281 }
1282
1283 switch(*bmc) {
1284 case 0:
1285 bitmap_file_set_bit(bitmap, offset);
1286 bitmap_count_page(bitmap,offset, 1);
1287 blk_plug_device_unlocked(bitmap->mddev->queue);
1288
1289 case 1:
1290 *bmc = 2;
1291 }
1292
1293 (*bmc)++;
1294
1295 spin_unlock_irq(&bitmap->lock);
1296
1297 offset += blocks;
1298 if (sectors > blocks)
1299 sectors -= blocks;
1300 else sectors = 0;
1301 }
1302 bitmap->allclean = 0;
1303 return 0;
1304}
1305
1306void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
1307 int success, int behind)
1308{
1309 if (!bitmap) return;
1310 if (behind) {
1311 atomic_dec(&bitmap->behind_writes);
1312 PRINTK(KERN_DEBUG "dec write-behind count %d/%d\n",
1313 atomic_read(&bitmap->behind_writes), bitmap->max_write_behind);
1314 }
1315 if (bitmap->mddev->degraded)
1316
1317 success = 0;
1318
1319 while (sectors) {
1320 int blocks;
1321 unsigned long flags;
1322 bitmap_counter_t *bmc;
1323
1324 spin_lock_irqsave(&bitmap->lock, flags);
1325 bmc = bitmap_get_counter(bitmap, offset, &blocks, 0);
1326 if (!bmc) {
1327 spin_unlock_irqrestore(&bitmap->lock, flags);
1328 return;
1329 }
1330
1331 if (success &&
1332 bitmap->events_cleared < bitmap->mddev->events) {
1333 bitmap->events_cleared = bitmap->mddev->events;
1334 bitmap->need_sync = 1;
1335 }
1336
1337 if (!success && ! (*bmc & NEEDED_MASK))
1338 *bmc |= NEEDED_MASK;
1339
1340 if ((*bmc & COUNTER_MAX) == COUNTER_MAX)
1341 wake_up(&bitmap->overflow_wait);
1342
1343 (*bmc)--;
1344 if (*bmc <= 2) {
1345 set_page_attr(bitmap,
1346 filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap)),
1347 BITMAP_PAGE_CLEAN);
1348 }
1349 spin_unlock_irqrestore(&bitmap->lock, flags);
1350 offset += blocks;
1351 if (sectors > blocks)
1352 sectors -= blocks;
1353 else sectors = 0;
1354 }
1355}
1356
1357static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks,
1358 int degraded)
1359{
1360 bitmap_counter_t *bmc;
1361 int rv;
1362 if (bitmap == NULL) {
1363 *blocks = 1024;
1364 return 1;
1365 }
1366 spin_lock_irq(&bitmap->lock);
1367 bmc = bitmap_get_counter(bitmap, offset, blocks, 0);
1368 rv = 0;
1369 if (bmc) {
1370
1371 if (RESYNC(*bmc))
1372 rv = 1;
1373 else if (NEEDED(*bmc)) {
1374 rv = 1;
1375 if (!degraded) {
1376 *bmc |= RESYNC_MASK;
1377 *bmc &= ~NEEDED_MASK;
1378 }
1379 }
1380 }
1381 spin_unlock_irq(&bitmap->lock);
1382 bitmap->allclean = 0;
1383 return rv;
1384}
1385
1386int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks,
1387 int degraded)
1388{
1389
1390
1391
1392
1393
1394
1395
1396 int rv = 0;
1397 int blocks1;
1398
1399 *blocks = 0;
1400 while (*blocks < (PAGE_SIZE>>9)) {
1401 rv |= __bitmap_start_sync(bitmap, offset,
1402 &blocks1, degraded);
1403 offset += blocks1;
1404 *blocks += blocks1;
1405 }
1406 return rv;
1407}
1408
1409void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted)
1410{
1411 bitmap_counter_t *bmc;
1412 unsigned long flags;
1413
1414
1415 if (bitmap == NULL) {
1416 *blocks = 1024;
1417 return;
1418 }
1419 spin_lock_irqsave(&bitmap->lock, flags);
1420 bmc = bitmap_get_counter(bitmap, offset, blocks, 0);
1421 if (bmc == NULL)
1422 goto unlock;
1423
1424
1425
1426
1427 if (RESYNC(*bmc)) {
1428 *bmc &= ~RESYNC_MASK;
1429
1430 if (!NEEDED(*bmc) && aborted)
1431 *bmc |= NEEDED_MASK;
1432 else {
1433 if (*bmc <= 2) {
1434 set_page_attr(bitmap,
1435 filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap)),
1436 BITMAP_PAGE_CLEAN);
1437 }
1438 }
1439 }
1440 unlock:
1441 spin_unlock_irqrestore(&bitmap->lock, flags);
1442 bitmap->allclean = 0;
1443}
1444
1445void bitmap_close_sync(struct bitmap *bitmap)
1446{
1447
1448
1449
1450
1451 sector_t sector = 0;
1452 int blocks;
1453 if (!bitmap)
1454 return;
1455 while (sector < bitmap->mddev->resync_max_sectors) {
1456 bitmap_end_sync(bitmap, sector, &blocks, 0);
1457 sector += blocks;
1458 }
1459}
1460
1461void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
1462{
1463 sector_t s = 0;
1464 int blocks;
1465
1466 if (!bitmap)
1467 return;
1468 if (sector == 0) {
1469 bitmap->last_end_sync = jiffies;
1470 return;
1471 }
1472 if (time_before(jiffies, (bitmap->last_end_sync
1473 + bitmap->daemon_sleep * HZ)))
1474 return;
1475 wait_event(bitmap->mddev->recovery_wait,
1476 atomic_read(&bitmap->mddev->recovery_active) == 0);
1477
1478 bitmap->mddev->curr_resync_completed = bitmap->mddev->curr_resync;
1479 set_bit(MD_CHANGE_CLEAN, &bitmap->mddev->flags);
1480 sector &= ~((1ULL << CHUNK_BLOCK_SHIFT(bitmap)) - 1);
1481 s = 0;
1482 while (s < sector && s < bitmap->mddev->resync_max_sectors) {
1483 bitmap_end_sync(bitmap, s, &blocks, 0);
1484 s += blocks;
1485 }
1486 bitmap->last_end_sync = jiffies;
1487 sysfs_notify(&bitmap->mddev->kobj, NULL, "sync_completed");
1488}
1489
1490static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)
1491{
1492
1493
1494
1495
1496
1497 int secs;
1498 bitmap_counter_t *bmc;
1499 spin_lock_irq(&bitmap->lock);
1500 bmc = bitmap_get_counter(bitmap, offset, &secs, 1);
1501 if (!bmc) {
1502 spin_unlock_irq(&bitmap->lock);
1503 return;
1504 }
1505 if (! *bmc) {
1506 struct page *page;
1507 *bmc = 1 | (needed?NEEDED_MASK:0);
1508 bitmap_count_page(bitmap, offset, 1);
1509 page = filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap));
1510 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1511 }
1512 spin_unlock_irq(&bitmap->lock);
1513 bitmap->allclean = 0;
1514}
1515
1516
1517void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e)
1518{
1519 unsigned long chunk;
1520
1521 for (chunk = s; chunk <= e; chunk++) {
1522 sector_t sec = (sector_t)chunk << CHUNK_BLOCK_SHIFT(bitmap);
1523 bitmap_set_memory_bits(bitmap, sec, 1);
1524 bitmap_file_set_bit(bitmap, sec);
1525 }
1526}
1527
1528
1529
1530
1531void bitmap_flush(mddev_t *mddev)
1532{
1533 struct bitmap *bitmap = mddev->bitmap;
1534 int sleep;
1535
1536 if (!bitmap)
1537 return;
1538
1539
1540
1541
1542 sleep = bitmap->daemon_sleep;
1543 bitmap->daemon_sleep = 0;
1544 bitmap_daemon_work(bitmap);
1545 bitmap_daemon_work(bitmap);
1546 bitmap_daemon_work(bitmap);
1547 bitmap->daemon_sleep = sleep;
1548 bitmap_update_sb(bitmap);
1549}
1550
1551
1552
1553
1554static void bitmap_free(struct bitmap *bitmap)
1555{
1556 unsigned long k, pages;
1557 struct bitmap_page *bp;
1558
1559 if (!bitmap)
1560 return;
1561
1562
1563 bitmap_file_put(bitmap);
1564
1565 bp = bitmap->bp;
1566 pages = bitmap->pages;
1567
1568
1569
1570 if (bp)
1571 for (k = 0; k < pages; k++)
1572 if (bp[k].map && !bp[k].hijacked)
1573 kfree(bp[k].map);
1574 kfree(bp);
1575 kfree(bitmap);
1576}
1577void bitmap_destroy(mddev_t *mddev)
1578{
1579 struct bitmap *bitmap = mddev->bitmap;
1580
1581 if (!bitmap)
1582 return;
1583
1584 mddev->bitmap = NULL;
1585 if (mddev->thread)
1586 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
1587
1588 bitmap_free(bitmap);
1589}
1590
1591
1592
1593
1594
1595int bitmap_create(mddev_t *mddev)
1596{
1597 struct bitmap *bitmap;
1598 sector_t blocks = mddev->resync_max_sectors;
1599 unsigned long chunks;
1600 unsigned long pages;
1601 struct file *file = mddev->bitmap_file;
1602 int err;
1603 sector_t start;
1604
1605 BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
1606
1607 if (!file && !mddev->bitmap_offset)
1608 return 0;
1609
1610 BUG_ON(file && mddev->bitmap_offset);
1611
1612 bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
1613 if (!bitmap)
1614 return -ENOMEM;
1615
1616 spin_lock_init(&bitmap->lock);
1617 atomic_set(&bitmap->pending_writes, 0);
1618 init_waitqueue_head(&bitmap->write_wait);
1619 init_waitqueue_head(&bitmap->overflow_wait);
1620
1621 bitmap->mddev = mddev;
1622
1623 bitmap->file = file;
1624 bitmap->offset = mddev->bitmap_offset;
1625 if (file) {
1626 get_file(file);
1627
1628
1629
1630
1631 vfs_fsync(file, file->f_dentry, 1);
1632 }
1633
1634 err = bitmap_read_sb(bitmap);
1635 if (err)
1636 goto error;
1637
1638 bitmap->chunkshift = ffz(~bitmap->chunksize);
1639
1640
1641 chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
1642 CHUNK_BLOCK_SHIFT(bitmap);
1643 pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
1644
1645 BUG_ON(!pages);
1646
1647 bitmap->chunks = chunks;
1648 bitmap->pages = pages;
1649 bitmap->missing_pages = pages;
1650 bitmap->counter_bits = COUNTER_BITS;
1651
1652 bitmap->syncchunk = ~0UL;
1653
1654#ifdef INJECT_FATAL_FAULT_1
1655 bitmap->bp = NULL;
1656#else
1657 bitmap->bp = kzalloc(pages * sizeof(*bitmap->bp), GFP_KERNEL);
1658#endif
1659 err = -ENOMEM;
1660 if (!bitmap->bp)
1661 goto error;
1662
1663
1664
1665 start = 0;
1666 if (mddev->degraded == 0
1667 || bitmap->events_cleared == mddev->events)
1668
1669 start = mddev->recovery_cp;
1670 err = bitmap_init_from_disk(bitmap, start);
1671
1672 if (err)
1673 goto error;
1674
1675 printk(KERN_INFO "created bitmap (%lu pages) for device %s\n",
1676 pages, bmname(bitmap));
1677
1678 mddev->bitmap = bitmap;
1679
1680 mddev->thread->timeout = bitmap->daemon_sleep * HZ;
1681
1682 bitmap_update_sb(bitmap);
1683
1684 return (bitmap->flags & BITMAP_WRITE_ERROR) ? -EIO : 0;
1685
1686 error:
1687 bitmap_free(bitmap);
1688 return err;
1689}
1690
1691
1692EXPORT_SYMBOL(bitmap_startwrite);
1693EXPORT_SYMBOL(bitmap_endwrite);
1694EXPORT_SYMBOL(bitmap_start_sync);
1695EXPORT_SYMBOL(bitmap_end_sync);
1696EXPORT_SYMBOL(bitmap_unplug);
1697EXPORT_SYMBOL(bitmap_close_sync);
1698EXPORT_SYMBOL(bitmap_cond_end_sync);
1699