Loading...
Note: File does not exist in v5.4.
1/*
2 * bitmap.c two-level bitmap (C) Peter T. Breuer (ptb@ot.uc3m.es) 2003
3 *
4 * bitmap_create - sets up the bitmap structure
5 * bitmap_destroy - destroys the bitmap structure
6 *
7 * additions, Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.:
8 * - added disk storage for bitmap
9 * - changes to allow various bitmap chunk sizes
10 */
11
12/*
13 * Still to do:
14 *
15 * flush after percent set rather than just time based. (maybe both).
16 */
17
18#include <linux/blkdev.h>
19#include <linux/module.h>
20#include <linux/errno.h>
21#include <linux/slab.h>
22#include <linux/init.h>
23#include <linux/timer.h>
24#include <linux/sched.h>
25#include <linux/list.h>
26#include <linux/file.h>
27#include <linux/mount.h>
28#include <linux/buffer_head.h>
29#include "md.h"
30#include "bitmap.h"
31
32/* debug macros */
33
34#define DEBUG 0
35
36#if DEBUG
37/* these are for debugging purposes only! */
38
39/* define one and only one of these */
40#define INJECT_FAULTS_1 0 /* cause bitmap_alloc_page to fail always */
41#define INJECT_FAULTS_2 0 /* cause bitmap file to be kicked when first bit set*/
42#define INJECT_FAULTS_3 0 /* treat bitmap file as kicked at init time */
43#define INJECT_FAULTS_4 0 /* undef */
44#define INJECT_FAULTS_5 0 /* undef */
45#define INJECT_FAULTS_6 0
46
47/* if these are defined, the driver will fail! debug only */
48#define INJECT_FATAL_FAULT_1 0 /* fail kmalloc, causing bitmap_create to fail */
49#define INJECT_FATAL_FAULT_2 0 /* undef */
50#define INJECT_FATAL_FAULT_3 0 /* undef */
51#endif
52
53#ifndef PRINTK
54# if DEBUG > 0
55# define PRINTK(x...) printk(KERN_DEBUG x)
56# else
57# define PRINTK(x...)
58# endif
59#endif
60
61static inline char *bmname(struct bitmap *bitmap)
62{
63 return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";
64}
65
66/*
67 * just a placeholder - calls kmalloc for bitmap pages
68 */
69static unsigned char *bitmap_alloc_page(struct bitmap *bitmap)
70{
71 unsigned char *page;
72
73#ifdef INJECT_FAULTS_1
74 page = NULL;
75#else
76 page = kzalloc(PAGE_SIZE, GFP_NOIO);
77#endif
78 if (!page)
79 printk("%s: bitmap_alloc_page FAILED\n", bmname(bitmap));
80 else
81 PRINTK("%s: bitmap_alloc_page: allocated page at %p\n",
82 bmname(bitmap), page);
83 return page;
84}
85
86/*
87 * for now just a placeholder -- just calls kfree for bitmap pages
88 */
89static void bitmap_free_page(struct bitmap *bitmap, unsigned char *page)
90{
91 PRINTK("%s: bitmap_free_page: free page %p\n", bmname(bitmap), page);
92 kfree(page);
93}
94
95/*
96 * check a page and, if necessary, allocate it (or hijack it if the alloc fails)
97 *
98 * 1) check to see if this page is allocated, if it's not then try to alloc
99 * 2) if the alloc fails, set the page's hijacked flag so we'll use the
100 * page pointer directly as a counter
101 *
102 * if we find our page, we increment the page's refcount so that it stays
103 * allocated while we're using it
104 */
105static int bitmap_checkpage(struct bitmap *bitmap,
106 unsigned long page, int create)
107__releases(bitmap->lock)
108__acquires(bitmap->lock)
109{
110 unsigned char *mappage;
111
112 if (page >= bitmap->pages) {
113 /* This can happen if bitmap_start_sync goes beyond
114 * End-of-device while looking for a whole page.
115 * It is harmless.
116 */
117 return -EINVAL;
118 }
119
120 if (bitmap->bp[page].hijacked) /* it's hijacked, don't try to alloc */
121 return 0;
122
123 if (bitmap->bp[page].map) /* page is already allocated, just return */
124 return 0;
125
126 if (!create)
127 return -ENOENT;
128
129 /* this page has not been allocated yet */
130
131 spin_unlock_irq(&bitmap->lock);
132 mappage = bitmap_alloc_page(bitmap);
133 spin_lock_irq(&bitmap->lock);
134
135 if (mappage == NULL) {
136 PRINTK("%s: bitmap map page allocation failed, hijacking\n",
137 bmname(bitmap));
138 /* failed - set the hijacked flag so that we can use the
139 * pointer as a counter */
140 if (!bitmap->bp[page].map)
141 bitmap->bp[page].hijacked = 1;
142 } else if (bitmap->bp[page].map ||
143 bitmap->bp[page].hijacked) {
144 /* somebody beat us to getting the page */
145 bitmap_free_page(bitmap, mappage);
146 return 0;
147 } else {
148
149 /* no page was in place and we have one, so install it */
150
151 bitmap->bp[page].map = mappage;
152 bitmap->missing_pages--;
153 }
154 return 0;
155}
156
157/* if page is completely empty, put it back on the free list, or dealloc it */
158/* if page was hijacked, unmark the flag so it might get alloced next time */
159/* Note: lock should be held when calling this */
160static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page)
161{
162 char *ptr;
163
164 if (bitmap->bp[page].count) /* page is still busy */
165 return;
166
167 /* page is no longer in use, it can be released */
168
169 if (bitmap->bp[page].hijacked) { /* page was hijacked, undo this now */
170 bitmap->bp[page].hijacked = 0;
171 bitmap->bp[page].map = NULL;
172 } else {
173 /* normal case, free the page */
174 ptr = bitmap->bp[page].map;
175 bitmap->bp[page].map = NULL;
176 bitmap->missing_pages++;
177 bitmap_free_page(bitmap, ptr);
178 }
179}
180
181/*
182 * bitmap file handling - read and write the bitmap file and its superblock
183 */
184
185/*
186 * basic page I/O operations
187 */
188
189/* IO operations when bitmap is stored near all superblocks */
190static struct page *read_sb_page(mddev_t *mddev, loff_t offset,
191 struct page *page,
192 unsigned long index, int size)
193{
194 /* choose a good rdev and read the page from there */
195
196 mdk_rdev_t *rdev;
197 sector_t target;
198 int did_alloc = 0;
199
200 if (!page) {
201 page = alloc_page(GFP_KERNEL);
202 if (!page)
203 return ERR_PTR(-ENOMEM);
204 did_alloc = 1;
205 }
206
207 list_for_each_entry(rdev, &mddev->disks, same_set) {
208 if (! test_bit(In_sync, &rdev->flags)
209 || test_bit(Faulty, &rdev->flags))
210 continue;
211
212 target = offset + index * (PAGE_SIZE/512);
213
214 if (sync_page_io(rdev, target,
215 roundup(size, bdev_logical_block_size(rdev->bdev)),
216 page, READ, true)) {
217 page->index = index;
218 attach_page_buffers(page, NULL); /* so that free_buffer will
219 * quietly no-op */
220 return page;
221 }
222 }
223 if (did_alloc)
224 put_page(page);
225 return ERR_PTR(-EIO);
226
227}
228
229static mdk_rdev_t *next_active_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
230{
231 /* Iterate the disks of an mddev, using rcu to protect access to the
232 * linked list, and raising the refcount of devices we return to ensure
233 * they don't disappear while in use.
234 * As devices are only added or removed when raid_disk is < 0 and
235 * nr_pending is 0 and In_sync is clear, the entries we return will
236 * still be in the same position on the list when we re-enter
237 * list_for_each_continue_rcu.
238 */
239 struct list_head *pos;
240 rcu_read_lock();
241 if (rdev == NULL)
242 /* start at the beginning */
243 pos = &mddev->disks;
244 else {
245 /* release the previous rdev and start from there. */
246 rdev_dec_pending(rdev, mddev);
247 pos = &rdev->same_set;
248 }
249 list_for_each_continue_rcu(pos, &mddev->disks) {
250 rdev = list_entry(pos, mdk_rdev_t, same_set);
251 if (rdev->raid_disk >= 0 &&
252 !test_bit(Faulty, &rdev->flags)) {
253 /* this is a usable devices */
254 atomic_inc(&rdev->nr_pending);
255 rcu_read_unlock();
256 return rdev;
257 }
258 }
259 rcu_read_unlock();
260 return NULL;
261}
262
263static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
264{
265 mdk_rdev_t *rdev = NULL;
266 struct block_device *bdev;
267 mddev_t *mddev = bitmap->mddev;
268
269 while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
270 int size = PAGE_SIZE;
271 loff_t offset = mddev->bitmap_info.offset;
272
273 bdev = (rdev->meta_bdev) ? rdev->meta_bdev : rdev->bdev;
274
275 if (page->index == bitmap->file_pages-1)
276 size = roundup(bitmap->last_page_size,
277 bdev_logical_block_size(bdev));
278 /* Just make sure we aren't corrupting data or
279 * metadata
280 */
281 if (mddev->external) {
282 /* Bitmap could be anywhere. */
283 if (rdev->sb_start + offset + (page->index
284 * (PAGE_SIZE/512))
285 > rdev->data_offset
286 &&
287 rdev->sb_start + offset
288 < (rdev->data_offset + mddev->dev_sectors
289 + (PAGE_SIZE/512)))
290 goto bad_alignment;
291 } else if (offset < 0) {
292 /* DATA BITMAP METADATA */
293 if (offset
294 + (long)(page->index * (PAGE_SIZE/512))
295 + size/512 > 0)
296 /* bitmap runs in to metadata */
297 goto bad_alignment;
298 if (rdev->data_offset + mddev->dev_sectors
299 > rdev->sb_start + offset)
300 /* data runs in to bitmap */
301 goto bad_alignment;
302 } else if (rdev->sb_start < rdev->data_offset) {
303 /* METADATA BITMAP DATA */
304 if (rdev->sb_start
305 + offset
306 + page->index*(PAGE_SIZE/512) + size/512
307 > rdev->data_offset)
308 /* bitmap runs in to data */
309 goto bad_alignment;
310 } else {
311 /* DATA METADATA BITMAP - no problems */
312 }
313 md_super_write(mddev, rdev,
314 rdev->sb_start + offset
315 + page->index * (PAGE_SIZE/512),
316 size,
317 page);
318 }
319
320 if (wait)
321 md_super_wait(mddev);
322 return 0;
323
324 bad_alignment:
325 return -EINVAL;
326}
327
328static void bitmap_file_kick(struct bitmap *bitmap);
329/*
330 * write out a page to a file
331 */
332static void write_page(struct bitmap *bitmap, struct page *page, int wait)
333{
334 struct buffer_head *bh;
335
336 if (bitmap->file == NULL) {
337 switch (write_sb_page(bitmap, page, wait)) {
338 case -EINVAL:
339 bitmap->flags |= BITMAP_WRITE_ERROR;
340 }
341 } else {
342
343 bh = page_buffers(page);
344
345 while (bh && bh->b_blocknr) {
346 atomic_inc(&bitmap->pending_writes);
347 set_buffer_locked(bh);
348 set_buffer_mapped(bh);
349 submit_bh(WRITE | REQ_SYNC, bh);
350 bh = bh->b_this_page;
351 }
352
353 if (wait)
354 wait_event(bitmap->write_wait,
355 atomic_read(&bitmap->pending_writes)==0);
356 }
357 if (bitmap->flags & BITMAP_WRITE_ERROR)
358 bitmap_file_kick(bitmap);
359}
360
361static void end_bitmap_write(struct buffer_head *bh, int uptodate)
362{
363 struct bitmap *bitmap = bh->b_private;
364 unsigned long flags;
365
366 if (!uptodate) {
367 spin_lock_irqsave(&bitmap->lock, flags);
368 bitmap->flags |= BITMAP_WRITE_ERROR;
369 spin_unlock_irqrestore(&bitmap->lock, flags);
370 }
371 if (atomic_dec_and_test(&bitmap->pending_writes))
372 wake_up(&bitmap->write_wait);
373}
374
375/* copied from buffer.c */
376static void
377__clear_page_buffers(struct page *page)
378{
379 ClearPagePrivate(page);
380 set_page_private(page, 0);
381 page_cache_release(page);
382}
383static void free_buffers(struct page *page)
384{
385 struct buffer_head *bh = page_buffers(page);
386
387 while (bh) {
388 struct buffer_head *next = bh->b_this_page;
389 free_buffer_head(bh);
390 bh = next;
391 }
392 __clear_page_buffers(page);
393 put_page(page);
394}
395
396/* read a page from a file.
397 * We both read the page, and attach buffers to the page to record the
398 * address of each block (using bmap). These addresses will be used
399 * to write the block later, completely bypassing the filesystem.
400 * This usage is similar to how swap files are handled, and allows us
401 * to write to a file with no concerns of memory allocation failing.
402 */
403static struct page *read_page(struct file *file, unsigned long index,
404 struct bitmap *bitmap,
405 unsigned long count)
406{
407 struct page *page = NULL;
408 struct inode *inode = file->f_path.dentry->d_inode;
409 struct buffer_head *bh;
410 sector_t block;
411
412 PRINTK("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,
413 (unsigned long long)index << PAGE_SHIFT);
414
415 page = alloc_page(GFP_KERNEL);
416 if (!page)
417 page = ERR_PTR(-ENOMEM);
418 if (IS_ERR(page))
419 goto out;
420
421 bh = alloc_page_buffers(page, 1<<inode->i_blkbits, 0);
422 if (!bh) {
423 put_page(page);
424 page = ERR_PTR(-ENOMEM);
425 goto out;
426 }
427 attach_page_buffers(page, bh);
428 block = index << (PAGE_SHIFT - inode->i_blkbits);
429 while (bh) {
430 if (count == 0)
431 bh->b_blocknr = 0;
432 else {
433 bh->b_blocknr = bmap(inode, block);
434 if (bh->b_blocknr == 0) {
435 /* Cannot use this file! */
436 free_buffers(page);
437 page = ERR_PTR(-EINVAL);
438 goto out;
439 }
440 bh->b_bdev = inode->i_sb->s_bdev;
441 if (count < (1<<inode->i_blkbits))
442 count = 0;
443 else
444 count -= (1<<inode->i_blkbits);
445
446 bh->b_end_io = end_bitmap_write;
447 bh->b_private = bitmap;
448 atomic_inc(&bitmap->pending_writes);
449 set_buffer_locked(bh);
450 set_buffer_mapped(bh);
451 submit_bh(READ, bh);
452 }
453 block++;
454 bh = bh->b_this_page;
455 }
456 page->index = index;
457
458 wait_event(bitmap->write_wait,
459 atomic_read(&bitmap->pending_writes)==0);
460 if (bitmap->flags & BITMAP_WRITE_ERROR) {
461 free_buffers(page);
462 page = ERR_PTR(-EIO);
463 }
464out:
465 if (IS_ERR(page))
466 printk(KERN_ALERT "md: bitmap read error: (%dB @ %llu): %ld\n",
467 (int)PAGE_SIZE,
468 (unsigned long long)index << PAGE_SHIFT,
469 PTR_ERR(page));
470 return page;
471}
472
473/*
474 * bitmap file superblock operations
475 */
476
477/* update the event counter and sync the superblock to disk */
478void bitmap_update_sb(struct bitmap *bitmap)
479{
480 bitmap_super_t *sb;
481 unsigned long flags;
482
483 if (!bitmap || !bitmap->mddev) /* no bitmap for this array */
484 return;
485 if (bitmap->mddev->bitmap_info.external)
486 return;
487 spin_lock_irqsave(&bitmap->lock, flags);
488 if (!bitmap->sb_page) { /* no superblock */
489 spin_unlock_irqrestore(&bitmap->lock, flags);
490 return;
491 }
492 spin_unlock_irqrestore(&bitmap->lock, flags);
493 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
494 sb->events = cpu_to_le64(bitmap->mddev->events);
495 if (bitmap->mddev->events < bitmap->events_cleared)
496 /* rocking back to read-only */
497 bitmap->events_cleared = bitmap->mddev->events;
498 sb->events_cleared = cpu_to_le64(bitmap->events_cleared);
499 sb->state = cpu_to_le32(bitmap->flags);
500 /* Just in case these have been changed via sysfs: */
501 sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);
502 sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);
503 kunmap_atomic(sb, KM_USER0);
504 write_page(bitmap, bitmap->sb_page, 1);
505}
506
507/* print out the bitmap file superblock */
508void bitmap_print_sb(struct bitmap *bitmap)
509{
510 bitmap_super_t *sb;
511
512 if (!bitmap || !bitmap->sb_page)
513 return;
514 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
515 printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
516 printk(KERN_DEBUG " magic: %08x\n", le32_to_cpu(sb->magic));
517 printk(KERN_DEBUG " version: %d\n", le32_to_cpu(sb->version));
518 printk(KERN_DEBUG " uuid: %08x.%08x.%08x.%08x\n",
519 *(__u32 *)(sb->uuid+0),
520 *(__u32 *)(sb->uuid+4),
521 *(__u32 *)(sb->uuid+8),
522 *(__u32 *)(sb->uuid+12));
523 printk(KERN_DEBUG " events: %llu\n",
524 (unsigned long long) le64_to_cpu(sb->events));
525 printk(KERN_DEBUG "events cleared: %llu\n",
526 (unsigned long long) le64_to_cpu(sb->events_cleared));
527 printk(KERN_DEBUG " state: %08x\n", le32_to_cpu(sb->state));
528 printk(KERN_DEBUG " chunksize: %d B\n", le32_to_cpu(sb->chunksize));
529 printk(KERN_DEBUG " daemon sleep: %ds\n", le32_to_cpu(sb->daemon_sleep));
530 printk(KERN_DEBUG " sync size: %llu KB\n",
531 (unsigned long long)le64_to_cpu(sb->sync_size)/2);
532 printk(KERN_DEBUG "max write behind: %d\n", le32_to_cpu(sb->write_behind));
533 kunmap_atomic(sb, KM_USER0);
534}
535
536/*
537 * bitmap_new_disk_sb
538 * @bitmap
539 *
540 * This function is somewhat the reverse of bitmap_read_sb. bitmap_read_sb
541 * reads and verifies the on-disk bitmap superblock and populates bitmap_info.
542 * This function verifies 'bitmap_info' and populates the on-disk bitmap
543 * structure, which is to be written to disk.
544 *
545 * Returns: 0 on success, -Exxx on error
546 */
547static int bitmap_new_disk_sb(struct bitmap *bitmap)
548{
549 bitmap_super_t *sb;
550 unsigned long chunksize, daemon_sleep, write_behind;
551 int err = -EINVAL;
552
553 bitmap->sb_page = alloc_page(GFP_KERNEL);
554 if (IS_ERR(bitmap->sb_page)) {
555 err = PTR_ERR(bitmap->sb_page);
556 bitmap->sb_page = NULL;
557 return err;
558 }
559 bitmap->sb_page->index = 0;
560
561 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
562
563 sb->magic = cpu_to_le32(BITMAP_MAGIC);
564 sb->version = cpu_to_le32(BITMAP_MAJOR_HI);
565
566 chunksize = bitmap->mddev->bitmap_info.chunksize;
567 BUG_ON(!chunksize);
568 if (!is_power_of_2(chunksize)) {
569 kunmap_atomic(sb, KM_USER0);
570 printk(KERN_ERR "bitmap chunksize not a power of 2\n");
571 return -EINVAL;
572 }
573 sb->chunksize = cpu_to_le32(chunksize);
574
575 daemon_sleep = bitmap->mddev->bitmap_info.daemon_sleep;
576 if (!daemon_sleep ||
577 (daemon_sleep < 1) || (daemon_sleep > MAX_SCHEDULE_TIMEOUT)) {
578 printk(KERN_INFO "Choosing daemon_sleep default (5 sec)\n");
579 daemon_sleep = 5 * HZ;
580 }
581 sb->daemon_sleep = cpu_to_le32(daemon_sleep);
582 bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
583
584 /*
585 * FIXME: write_behind for RAID1. If not specified, what
586 * is a good choice? We choose COUNTER_MAX / 2 arbitrarily.
587 */
588 write_behind = bitmap->mddev->bitmap_info.max_write_behind;
589 if (write_behind > COUNTER_MAX)
590 write_behind = COUNTER_MAX / 2;
591 sb->write_behind = cpu_to_le32(write_behind);
592 bitmap->mddev->bitmap_info.max_write_behind = write_behind;
593
594 /* keep the array size field of the bitmap superblock up to date */
595 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
596
597 memcpy(sb->uuid, bitmap->mddev->uuid, 16);
598
599 bitmap->flags |= BITMAP_STALE;
600 sb->state |= cpu_to_le32(BITMAP_STALE);
601 bitmap->events_cleared = bitmap->mddev->events;
602 sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
603
604 bitmap->flags |= BITMAP_HOSTENDIAN;
605 sb->version = cpu_to_le32(BITMAP_MAJOR_HOSTENDIAN);
606
607 kunmap_atomic(sb, KM_USER0);
608
609 return 0;
610}
611
612/* read the superblock from the bitmap file and initialize some bitmap fields */
613static int bitmap_read_sb(struct bitmap *bitmap)
614{
615 char *reason = NULL;
616 bitmap_super_t *sb;
617 unsigned long chunksize, daemon_sleep, write_behind;
618 unsigned long long events;
619 int err = -EINVAL;
620
621 /* page 0 is the superblock, read it... */
622 if (bitmap->file) {
623 loff_t isize = i_size_read(bitmap->file->f_mapping->host);
624 int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;
625
626 bitmap->sb_page = read_page(bitmap->file, 0, bitmap, bytes);
627 } else {
628 bitmap->sb_page = read_sb_page(bitmap->mddev,
629 bitmap->mddev->bitmap_info.offset,
630 NULL,
631 0, sizeof(bitmap_super_t));
632 }
633 if (IS_ERR(bitmap->sb_page)) {
634 err = PTR_ERR(bitmap->sb_page);
635 bitmap->sb_page = NULL;
636 return err;
637 }
638
639 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
640
641 chunksize = le32_to_cpu(sb->chunksize);
642 daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
643 write_behind = le32_to_cpu(sb->write_behind);
644
645 /* verify that the bitmap-specific fields are valid */
646 if (sb->magic != cpu_to_le32(BITMAP_MAGIC))
647 reason = "bad magic";
648 else if (le32_to_cpu(sb->version) < BITMAP_MAJOR_LO ||
649 le32_to_cpu(sb->version) > BITMAP_MAJOR_HI)
650 reason = "unrecognized superblock version";
651 else if (chunksize < 512)
652 reason = "bitmap chunksize too small";
653 else if (!is_power_of_2(chunksize))
654 reason = "bitmap chunksize not a power of 2";
655 else if (daemon_sleep < 1 || daemon_sleep > MAX_SCHEDULE_TIMEOUT)
656 reason = "daemon sleep period out of range";
657 else if (write_behind > COUNTER_MAX)
658 reason = "write-behind limit out of range (0 - 16383)";
659 if (reason) {
660 printk(KERN_INFO "%s: invalid bitmap file superblock: %s\n",
661 bmname(bitmap), reason);
662 goto out;
663 }
664
665 /* keep the array size field of the bitmap superblock up to date */
666 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
667
668 if (!bitmap->mddev->persistent)
669 goto success;
670
671 /*
672 * if we have a persistent array superblock, compare the
673 * bitmap's UUID and event counter to the mddev's
674 */
675 if (memcmp(sb->uuid, bitmap->mddev->uuid, 16)) {
676 printk(KERN_INFO "%s: bitmap superblock UUID mismatch\n",
677 bmname(bitmap));
678 goto out;
679 }
680 events = le64_to_cpu(sb->events);
681 if (events < bitmap->mddev->events) {
682 printk(KERN_INFO "%s: bitmap file is out of date (%llu < %llu) "
683 "-- forcing full recovery\n", bmname(bitmap), events,
684 (unsigned long long) bitmap->mddev->events);
685 sb->state |= cpu_to_le32(BITMAP_STALE);
686 }
687success:
688 /* assign fields using values from superblock */
689 bitmap->mddev->bitmap_info.chunksize = chunksize;
690 bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
691 bitmap->mddev->bitmap_info.max_write_behind = write_behind;
692 bitmap->flags |= le32_to_cpu(sb->state);
693 if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)
694 bitmap->flags |= BITMAP_HOSTENDIAN;
695 bitmap->events_cleared = le64_to_cpu(sb->events_cleared);
696 if (bitmap->flags & BITMAP_STALE)
697 bitmap->events_cleared = bitmap->mddev->events;
698 err = 0;
699out:
700 kunmap_atomic(sb, KM_USER0);
701 if (err)
702 bitmap_print_sb(bitmap);
703 return err;
704}
705
706enum bitmap_mask_op {
707 MASK_SET,
708 MASK_UNSET
709};
710
711/* record the state of the bitmap in the superblock. Return the old value */
712static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
713 enum bitmap_mask_op op)
714{
715 bitmap_super_t *sb;
716 unsigned long flags;
717 int old;
718
719 spin_lock_irqsave(&bitmap->lock, flags);
720 if (!bitmap->sb_page) { /* can't set the state */
721 spin_unlock_irqrestore(&bitmap->lock, flags);
722 return 0;
723 }
724 spin_unlock_irqrestore(&bitmap->lock, flags);
725 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
726 old = le32_to_cpu(sb->state) & bits;
727 switch (op) {
728 case MASK_SET:
729 sb->state |= cpu_to_le32(bits);
730 bitmap->flags |= bits;
731 break;
732 case MASK_UNSET:
733 sb->state &= cpu_to_le32(~bits);
734 bitmap->flags &= ~bits;
735 break;
736 default:
737 BUG();
738 }
739 kunmap_atomic(sb, KM_USER0);
740 return old;
741}
742
743/*
744 * general bitmap file operations
745 */
746
747/*
748 * on-disk bitmap:
749 *
750 * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap
751 * file a page at a time. There's a superblock at the start of the file.
752 */
753/* calculate the index of the page that contains this bit */
754static inline unsigned long file_page_index(struct bitmap *bitmap, unsigned long chunk)
755{
756 if (!bitmap->mddev->bitmap_info.external)
757 chunk += sizeof(bitmap_super_t) << 3;
758 return chunk >> PAGE_BIT_SHIFT;
759}
760
761/* calculate the (bit) offset of this bit within a page */
762static inline unsigned long file_page_offset(struct bitmap *bitmap, unsigned long chunk)
763{
764 if (!bitmap->mddev->bitmap_info.external)
765 chunk += sizeof(bitmap_super_t) << 3;
766 return chunk & (PAGE_BITS - 1);
767}
768
769/*
770 * return a pointer to the page in the filemap that contains the given bit
771 *
772 * this lookup is complicated by the fact that the bitmap sb might be exactly
773 * 1 page (e.g., x86) or less than 1 page -- so the bitmap might start on page
774 * 0 or page 1
775 */
776static inline struct page *filemap_get_page(struct bitmap *bitmap,
777 unsigned long chunk)
778{
779 if (file_page_index(bitmap, chunk) >= bitmap->file_pages)
780 return NULL;
781 return bitmap->filemap[file_page_index(bitmap, chunk)
782 - file_page_index(bitmap, 0)];
783}
784
785static void bitmap_file_unmap(struct bitmap *bitmap)
786{
787 struct page **map, *sb_page;
788 unsigned long *attr;
789 int pages;
790 unsigned long flags;
791
792 spin_lock_irqsave(&bitmap->lock, flags);
793 map = bitmap->filemap;
794 bitmap->filemap = NULL;
795 attr = bitmap->filemap_attr;
796 bitmap->filemap_attr = NULL;
797 pages = bitmap->file_pages;
798 bitmap->file_pages = 0;
799 sb_page = bitmap->sb_page;
800 bitmap->sb_page = NULL;
801 spin_unlock_irqrestore(&bitmap->lock, flags);
802
803 while (pages--)
804 if (map[pages] != sb_page) /* 0 is sb_page, release it below */
805 free_buffers(map[pages]);
806 kfree(map);
807 kfree(attr);
808
809 if (sb_page)
810 free_buffers(sb_page);
811}
812
813static void bitmap_file_put(struct bitmap *bitmap)
814{
815 struct file *file;
816 unsigned long flags;
817
818 spin_lock_irqsave(&bitmap->lock, flags);
819 file = bitmap->file;
820 bitmap->file = NULL;
821 spin_unlock_irqrestore(&bitmap->lock, flags);
822
823 if (file)
824 wait_event(bitmap->write_wait,
825 atomic_read(&bitmap->pending_writes)==0);
826 bitmap_file_unmap(bitmap);
827
828 if (file) {
829 struct inode *inode = file->f_path.dentry->d_inode;
830 invalidate_mapping_pages(inode->i_mapping, 0, -1);
831 fput(file);
832 }
833}
834
835/*
836 * bitmap_file_kick - if an error occurs while manipulating the bitmap file
837 * then it is no longer reliable, so we stop using it and we mark the file
838 * as failed in the superblock
839 */
840static void bitmap_file_kick(struct bitmap *bitmap)
841{
842 char *path, *ptr = NULL;
843
844 if (bitmap_mask_state(bitmap, BITMAP_STALE, MASK_SET) == 0) {
845 bitmap_update_sb(bitmap);
846
847 if (bitmap->file) {
848 path = kmalloc(PAGE_SIZE, GFP_KERNEL);
849 if (path)
850 ptr = d_path(&bitmap->file->f_path, path,
851 PAGE_SIZE);
852
853 printk(KERN_ALERT
854 "%s: kicking failed bitmap file %s from array!\n",
855 bmname(bitmap), IS_ERR(ptr) ? "" : ptr);
856
857 kfree(path);
858 } else
859 printk(KERN_ALERT
860 "%s: disabling internal bitmap due to errors\n",
861 bmname(bitmap));
862 }
863
864 bitmap_file_put(bitmap);
865
866 return;
867}
868
869enum bitmap_page_attr {
870 BITMAP_PAGE_DIRTY = 0, /* there are set bits that need to be synced */
871 BITMAP_PAGE_CLEAN = 1, /* there are bits that might need to be cleared */
872 BITMAP_PAGE_NEEDWRITE = 2, /* there are cleared bits that need to be synced */
873};
874
875static inline void set_page_attr(struct bitmap *bitmap, struct page *page,
876 enum bitmap_page_attr attr)
877{
878 __set_bit((page->index<<2) + attr, bitmap->filemap_attr);
879}
880
881static inline void clear_page_attr(struct bitmap *bitmap, struct page *page,
882 enum bitmap_page_attr attr)
883{
884 __clear_bit((page->index<<2) + attr, bitmap->filemap_attr);
885}
886
887static inline unsigned long test_page_attr(struct bitmap *bitmap, struct page *page,
888 enum bitmap_page_attr attr)
889{
890 return test_bit((page->index<<2) + attr, bitmap->filemap_attr);
891}
892
893/*
894 * bitmap_file_set_bit -- called before performing a write to the md device
895 * to set (and eventually sync) a particular bit in the bitmap file
896 *
897 * we set the bit immediately, then we record the page number so that
898 * when an unplug occurs, we can flush the dirty pages out to disk
899 */
900static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
901{
902 unsigned long bit;
903 struct page *page;
904 void *kaddr;
905 unsigned long chunk = block >> CHUNK_BLOCK_SHIFT(bitmap);
906
907 if (!bitmap->filemap)
908 return;
909
910 page = filemap_get_page(bitmap, chunk);
911 if (!page)
912 return;
913 bit = file_page_offset(bitmap, chunk);
914
915 /* set the bit */
916 kaddr = kmap_atomic(page, KM_USER0);
917 if (bitmap->flags & BITMAP_HOSTENDIAN)
918 set_bit(bit, kaddr);
919 else
920 __set_bit_le(bit, kaddr);
921 kunmap_atomic(kaddr, KM_USER0);
922 PRINTK("set file bit %lu page %lu\n", bit, page->index);
923 /* record page number so it gets flushed to disk when unplug occurs */
924 set_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
925}
926
927/* this gets called when the md device is ready to unplug its underlying
928 * (slave) device queues -- before we let any writes go down, we need to
929 * sync the dirty pages of the bitmap file to disk */
930void bitmap_unplug(struct bitmap *bitmap)
931{
932 unsigned long i, flags;
933 int dirty, need_write;
934 struct page *page;
935 int wait = 0;
936
937 if (!bitmap)
938 return;
939
940 /* look at each page to see if there are any set bits that need to be
941 * flushed out to disk */
942 for (i = 0; i < bitmap->file_pages; i++) {
943 spin_lock_irqsave(&bitmap->lock, flags);
944 if (!bitmap->filemap) {
945 spin_unlock_irqrestore(&bitmap->lock, flags);
946 return;
947 }
948 page = bitmap->filemap[i];
949 dirty = test_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
950 need_write = test_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);
951 clear_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
952 clear_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);
953 if (dirty)
954 wait = 1;
955 spin_unlock_irqrestore(&bitmap->lock, flags);
956
957 if (dirty || need_write)
958 write_page(bitmap, page, 0);
959 }
960 if (wait) { /* if any writes were performed, we need to wait on them */
961 if (bitmap->file)
962 wait_event(bitmap->write_wait,
963 atomic_read(&bitmap->pending_writes)==0);
964 else
965 md_super_wait(bitmap->mddev);
966 }
967 if (bitmap->flags & BITMAP_WRITE_ERROR)
968 bitmap_file_kick(bitmap);
969}
970EXPORT_SYMBOL(bitmap_unplug);
971
972static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed);
973/* * bitmap_init_from_disk -- called at bitmap_create time to initialize
974 * the in-memory bitmap from the on-disk bitmap -- also, sets up the
975 * memory mapping of the bitmap file
976 * Special cases:
977 * if there's no bitmap file, or if the bitmap file had been
978 * previously kicked from the array, we mark all the bits as
979 * 1's in order to cause a full resync.
980 *
981 * We ignore all bits for sectors that end earlier than 'start'.
982 * This is used when reading an out-of-date bitmap...
983 */
984static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
985{
986 unsigned long i, chunks, index, oldindex, bit;
987 struct page *page = NULL, *oldpage = NULL;
988 unsigned long num_pages, bit_cnt = 0;
989 struct file *file;
990 unsigned long bytes, offset;
991 int outofdate;
992 int ret = -ENOSPC;
993 void *paddr;
994
995 chunks = bitmap->chunks;
996 file = bitmap->file;
997
998 BUG_ON(!file && !bitmap->mddev->bitmap_info.offset);
999
1000#ifdef INJECT_FAULTS_3
1001 outofdate = 1;
1002#else
1003 outofdate = bitmap->flags & BITMAP_STALE;
1004#endif
1005 if (outofdate)
1006 printk(KERN_INFO "%s: bitmap file is out of date, doing full "
1007 "recovery\n", bmname(bitmap));
1008
1009 bytes = DIV_ROUND_UP(bitmap->chunks, 8);
1010 if (!bitmap->mddev->bitmap_info.external)
1011 bytes += sizeof(bitmap_super_t);
1012
1013 num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE);
1014
1015 if (file && i_size_read(file->f_mapping->host) < bytes) {
1016 printk(KERN_INFO "%s: bitmap file too short %lu < %lu\n",
1017 bmname(bitmap),
1018 (unsigned long) i_size_read(file->f_mapping->host),
1019 bytes);
1020 goto err;
1021 }
1022
1023 ret = -ENOMEM;
1024
1025 bitmap->filemap = kmalloc(sizeof(struct page *) * num_pages, GFP_KERNEL);
1026 if (!bitmap->filemap)
1027 goto err;
1028
1029 /* We need 4 bits per page, rounded up to a multiple of sizeof(unsigned long) */
1030 bitmap->filemap_attr = kzalloc(
1031 roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
1032 GFP_KERNEL);
1033 if (!bitmap->filemap_attr)
1034 goto err;
1035
1036 oldindex = ~0L;
1037
1038 for (i = 0; i < chunks; i++) {
1039 int b;
1040 index = file_page_index(bitmap, i);
1041 bit = file_page_offset(bitmap, i);
1042 if (index != oldindex) { /* this is a new page, read it in */
1043 int count;
1044 /* unmap the old page, we're done with it */
1045 if (index == num_pages-1)
1046 count = bytes - index * PAGE_SIZE;
1047 else
1048 count = PAGE_SIZE;
1049 if (index == 0 && bitmap->sb_page) {
1050 /*
1051 * if we're here then the superblock page
1052 * contains some bits (PAGE_SIZE != sizeof sb)
1053 * we've already read it in, so just use it
1054 */
1055 page = bitmap->sb_page;
1056 offset = sizeof(bitmap_super_t);
1057 if (!file)
1058 page = read_sb_page(
1059 bitmap->mddev,
1060 bitmap->mddev->bitmap_info.offset,
1061 page,
1062 index, count);
1063 } else if (file) {
1064 page = read_page(file, index, bitmap, count);
1065 offset = 0;
1066 } else {
1067 page = read_sb_page(bitmap->mddev,
1068 bitmap->mddev->bitmap_info.offset,
1069 NULL,
1070 index, count);
1071 offset = 0;
1072 }
1073 if (IS_ERR(page)) { /* read error */
1074 ret = PTR_ERR(page);
1075 goto err;
1076 }
1077
1078 oldindex = index;
1079 oldpage = page;
1080
1081 bitmap->filemap[bitmap->file_pages++] = page;
1082 bitmap->last_page_size = count;
1083
1084 if (outofdate) {
1085 /*
1086 * if bitmap is out of date, dirty the
1087 * whole page and write it out
1088 */
1089 paddr = kmap_atomic(page, KM_USER0);
1090 memset(paddr + offset, 0xff,
1091 PAGE_SIZE - offset);
1092 kunmap_atomic(paddr, KM_USER0);
1093 write_page(bitmap, page, 1);
1094
1095 ret = -EIO;
1096 if (bitmap->flags & BITMAP_WRITE_ERROR)
1097 goto err;
1098 }
1099 }
1100 paddr = kmap_atomic(page, KM_USER0);
1101 if (bitmap->flags & BITMAP_HOSTENDIAN)
1102 b = test_bit(bit, paddr);
1103 else
1104 b = test_bit_le(bit, paddr);
1105 kunmap_atomic(paddr, KM_USER0);
1106 if (b) {
1107 /* if the disk bit is set, set the memory bit */
1108 int needed = ((sector_t)(i+1) << (CHUNK_BLOCK_SHIFT(bitmap))
1109 >= start);
1110 bitmap_set_memory_bits(bitmap,
1111 (sector_t)i << CHUNK_BLOCK_SHIFT(bitmap),
1112 needed);
1113 bit_cnt++;
1114 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1115 }
1116 }
1117
1118 /* everything went OK */
1119 ret = 0;
1120 bitmap_mask_state(bitmap, BITMAP_STALE, MASK_UNSET);
1121
1122 if (bit_cnt) { /* Kick recovery if any bits were set */
1123 set_bit(MD_RECOVERY_NEEDED, &bitmap->mddev->recovery);
1124 md_wakeup_thread(bitmap->mddev->thread);
1125 }
1126
1127 printk(KERN_INFO "%s: bitmap initialized from disk: "
1128 "read %lu/%lu pages, set %lu of %lu bits\n",
1129 bmname(bitmap), bitmap->file_pages, num_pages, bit_cnt, chunks);
1130
1131 return 0;
1132
1133 err:
1134 printk(KERN_INFO "%s: bitmap initialisation failed: %d\n",
1135 bmname(bitmap), ret);
1136 return ret;
1137}
1138
1139void bitmap_write_all(struct bitmap *bitmap)
1140{
1141 /* We don't actually write all bitmap blocks here,
1142 * just flag them as needing to be written
1143 */
1144 int i;
1145
1146 for (i = 0; i < bitmap->file_pages; i++)
1147 set_page_attr(bitmap, bitmap->filemap[i],
1148 BITMAP_PAGE_NEEDWRITE);
1149}
1150
1151static void bitmap_count_page(struct bitmap *bitmap, sector_t offset, int inc)
1152{
1153 sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);
1154 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1155 bitmap->bp[page].count += inc;
1156 bitmap_checkfree(bitmap, page);
1157}
1158static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
1159 sector_t offset, sector_t *blocks,
1160 int create);
1161
1162/*
1163 * bitmap daemon -- periodically wakes up to clean bits and flush pages
1164 * out to disk
1165 */
1166
1167void bitmap_daemon_work(mddev_t *mddev)
1168{
1169 struct bitmap *bitmap;
1170 unsigned long j;
1171 unsigned long flags;
1172 struct page *page = NULL, *lastpage = NULL;
1173 sector_t blocks;
1174 void *paddr;
1175
1176 /* Use a mutex to guard daemon_work against
1177 * bitmap_destroy.
1178 */
1179 mutex_lock(&mddev->bitmap_info.mutex);
1180 bitmap = mddev->bitmap;
1181 if (bitmap == NULL) {
1182 mutex_unlock(&mddev->bitmap_info.mutex);
1183 return;
1184 }
1185 if (time_before(jiffies, bitmap->daemon_lastrun
1186 + bitmap->mddev->bitmap_info.daemon_sleep))
1187 goto done;
1188
1189 bitmap->daemon_lastrun = jiffies;
1190 if (bitmap->allclean) {
1191 bitmap->mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
1192 goto done;
1193 }
1194 bitmap->allclean = 1;
1195
1196 spin_lock_irqsave(&bitmap->lock, flags);
1197 for (j = 0; j < bitmap->chunks; j++) {
1198 bitmap_counter_t *bmc;
1199 if (!bitmap->filemap)
1200 /* error or shutdown */
1201 break;
1202
1203 page = filemap_get_page(bitmap, j);
1204
1205 if (page != lastpage) {
1206 /* skip this page unless it's marked as needing cleaning */
1207 if (!test_page_attr(bitmap, page, BITMAP_PAGE_CLEAN)) {
1208 int need_write = test_page_attr(bitmap, page,
1209 BITMAP_PAGE_NEEDWRITE);
1210 if (need_write)
1211 clear_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);
1212
1213 spin_unlock_irqrestore(&bitmap->lock, flags);
1214 if (need_write) {
1215 write_page(bitmap, page, 0);
1216 bitmap->allclean = 0;
1217 }
1218 spin_lock_irqsave(&bitmap->lock, flags);
1219 j |= (PAGE_BITS - 1);
1220 continue;
1221 }
1222
1223 /* grab the new page, sync and release the old */
1224 if (lastpage != NULL) {
1225 if (test_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE)) {
1226 clear_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1227 spin_unlock_irqrestore(&bitmap->lock, flags);
1228 write_page(bitmap, lastpage, 0);
1229 } else {
1230 set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1231 spin_unlock_irqrestore(&bitmap->lock, flags);
1232 }
1233 } else
1234 spin_unlock_irqrestore(&bitmap->lock, flags);
1235 lastpage = page;
1236
1237 /* We are possibly going to clear some bits, so make
1238 * sure that events_cleared is up-to-date.
1239 */
1240 if (bitmap->need_sync &&
1241 bitmap->mddev->bitmap_info.external == 0) {
1242 bitmap_super_t *sb;
1243 bitmap->need_sync = 0;
1244 sb = kmap_atomic(bitmap->sb_page, KM_USER0);
1245 sb->events_cleared =
1246 cpu_to_le64(bitmap->events_cleared);
1247 kunmap_atomic(sb, KM_USER0);
1248 write_page(bitmap, bitmap->sb_page, 1);
1249 }
1250 spin_lock_irqsave(&bitmap->lock, flags);
1251 if (!bitmap->need_sync)
1252 clear_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1253 }
1254 bmc = bitmap_get_counter(bitmap,
1255 (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),
1256 &blocks, 0);
1257 if (bmc) {
1258 if (*bmc)
1259 bitmap->allclean = 0;
1260
1261 if (*bmc == 2) {
1262 *bmc = 1; /* maybe clear the bit next time */
1263 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1264 } else if (*bmc == 1 && !bitmap->need_sync) {
1265 /* we can clear the bit */
1266 *bmc = 0;
1267 bitmap_count_page(bitmap,
1268 (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),
1269 -1);
1270
1271 /* clear the bit */
1272 paddr = kmap_atomic(page, KM_USER0);
1273 if (bitmap->flags & BITMAP_HOSTENDIAN)
1274 clear_bit(file_page_offset(bitmap, j),
1275 paddr);
1276 else
1277 __clear_bit_le(
1278 file_page_offset(bitmap,
1279 j),
1280 paddr);
1281 kunmap_atomic(paddr, KM_USER0);
1282 }
1283 } else
1284 j |= PAGE_COUNTER_MASK;
1285 }
1286 spin_unlock_irqrestore(&bitmap->lock, flags);
1287
1288 /* now sync the final page */
1289 if (lastpage != NULL) {
1290 spin_lock_irqsave(&bitmap->lock, flags);
1291 if (test_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE)) {
1292 clear_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1293 spin_unlock_irqrestore(&bitmap->lock, flags);
1294 write_page(bitmap, lastpage, 0);
1295 } else {
1296 set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
1297 spin_unlock_irqrestore(&bitmap->lock, flags);
1298 }
1299 }
1300
1301 done:
1302 if (bitmap->allclean == 0)
1303 bitmap->mddev->thread->timeout =
1304 bitmap->mddev->bitmap_info.daemon_sleep;
1305 mutex_unlock(&mddev->bitmap_info.mutex);
1306}
1307
1308static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
1309 sector_t offset, sector_t *blocks,
1310 int create)
1311__releases(bitmap->lock)
1312__acquires(bitmap->lock)
1313{
1314 /* If 'create', we might release the lock and reclaim it.
1315 * The lock must have been taken with interrupts enabled.
1316 * If !create, we don't release the lock.
1317 */
1318 sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);
1319 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1320 unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
1321 sector_t csize;
1322 int err;
1323
1324 err = bitmap_checkpage(bitmap, page, create);
1325
1326 if (bitmap->bp[page].hijacked ||
1327 bitmap->bp[page].map == NULL)
1328 csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap) +
1329 PAGE_COUNTER_SHIFT - 1);
1330 else
1331 csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap));
1332 *blocks = csize - (offset & (csize - 1));
1333
1334 if (err < 0)
1335 return NULL;
1336
1337 /* now locked ... */
1338
1339 if (bitmap->bp[page].hijacked) { /* hijacked pointer */
1340 /* should we use the first or second counter field
1341 * of the hijacked pointer? */
1342 int hi = (pageoff > PAGE_COUNTER_MASK);
1343 return &((bitmap_counter_t *)
1344 &bitmap->bp[page].map)[hi];
1345 } else /* page is allocated */
1346 return (bitmap_counter_t *)
1347 &(bitmap->bp[page].map[pageoff]);
1348}
1349
1350int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int behind)
1351{
1352 if (!bitmap)
1353 return 0;
1354
1355 if (behind) {
1356 int bw;
1357 atomic_inc(&bitmap->behind_writes);
1358 bw = atomic_read(&bitmap->behind_writes);
1359 if (bw > bitmap->behind_writes_used)
1360 bitmap->behind_writes_used = bw;
1361
1362 PRINTK(KERN_DEBUG "inc write-behind count %d/%d\n",
1363 bw, bitmap->max_write_behind);
1364 }
1365
1366 while (sectors) {
1367 sector_t blocks;
1368 bitmap_counter_t *bmc;
1369
1370 spin_lock_irq(&bitmap->lock);
1371 bmc = bitmap_get_counter(bitmap, offset, &blocks, 1);
1372 if (!bmc) {
1373 spin_unlock_irq(&bitmap->lock);
1374 return 0;
1375 }
1376
1377 if (unlikely(COUNTER(*bmc) == COUNTER_MAX)) {
1378 DEFINE_WAIT(__wait);
1379 /* note that it is safe to do the prepare_to_wait
1380 * after the test as long as we do it before dropping
1381 * the spinlock.
1382 */
1383 prepare_to_wait(&bitmap->overflow_wait, &__wait,
1384 TASK_UNINTERRUPTIBLE);
1385 spin_unlock_irq(&bitmap->lock);
1386 io_schedule();
1387 finish_wait(&bitmap->overflow_wait, &__wait);
1388 continue;
1389 }
1390
1391 switch (*bmc) {
1392 case 0:
1393 bitmap_file_set_bit(bitmap, offset);
1394 bitmap_count_page(bitmap, offset, 1);
1395 /* fall through */
1396 case 1:
1397 *bmc = 2;
1398 }
1399
1400 (*bmc)++;
1401
1402 spin_unlock_irq(&bitmap->lock);
1403
1404 offset += blocks;
1405 if (sectors > blocks)
1406 sectors -= blocks;
1407 else
1408 sectors = 0;
1409 }
1410 bitmap->allclean = 0;
1411 return 0;
1412}
1413EXPORT_SYMBOL(bitmap_startwrite);
1414
1415void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
1416 int success, int behind)
1417{
1418 if (!bitmap)
1419 return;
1420 if (behind) {
1421 if (atomic_dec_and_test(&bitmap->behind_writes))
1422 wake_up(&bitmap->behind_wait);
1423 PRINTK(KERN_DEBUG "dec write-behind count %d/%d\n",
1424 atomic_read(&bitmap->behind_writes), bitmap->max_write_behind);
1425 }
1426 if (bitmap->mddev->degraded)
1427 /* Never clear bits or update events_cleared when degraded */
1428 success = 0;
1429
1430 while (sectors) {
1431 sector_t blocks;
1432 unsigned long flags;
1433 bitmap_counter_t *bmc;
1434
1435 spin_lock_irqsave(&bitmap->lock, flags);
1436 bmc = bitmap_get_counter(bitmap, offset, &blocks, 0);
1437 if (!bmc) {
1438 spin_unlock_irqrestore(&bitmap->lock, flags);
1439 return;
1440 }
1441
1442 if (success &&
1443 bitmap->events_cleared < bitmap->mddev->events) {
1444 bitmap->events_cleared = bitmap->mddev->events;
1445 bitmap->need_sync = 1;
1446 sysfs_notify_dirent_safe(bitmap->sysfs_can_clear);
1447 }
1448
1449 if (!success && !NEEDED(*bmc))
1450 *bmc |= NEEDED_MASK;
1451
1452 if (COUNTER(*bmc) == COUNTER_MAX)
1453 wake_up(&bitmap->overflow_wait);
1454
1455 (*bmc)--;
1456 if (*bmc <= 2)
1457 set_page_attr(bitmap,
1458 filemap_get_page(
1459 bitmap,
1460 offset >> CHUNK_BLOCK_SHIFT(bitmap)),
1461 BITMAP_PAGE_CLEAN);
1462
1463 spin_unlock_irqrestore(&bitmap->lock, flags);
1464 offset += blocks;
1465 if (sectors > blocks)
1466 sectors -= blocks;
1467 else
1468 sectors = 0;
1469 }
1470}
1471EXPORT_SYMBOL(bitmap_endwrite);
1472
1473static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
1474 int degraded)
1475{
1476 bitmap_counter_t *bmc;
1477 int rv;
1478 if (bitmap == NULL) {/* FIXME or bitmap set as 'failed' */
1479 *blocks = 1024;
1480 return 1; /* always resync if no bitmap */
1481 }
1482 spin_lock_irq(&bitmap->lock);
1483 bmc = bitmap_get_counter(bitmap, offset, blocks, 0);
1484 rv = 0;
1485 if (bmc) {
1486 /* locked */
1487 if (RESYNC(*bmc))
1488 rv = 1;
1489 else if (NEEDED(*bmc)) {
1490 rv = 1;
1491 if (!degraded) { /* don't set/clear bits if degraded */
1492 *bmc |= RESYNC_MASK;
1493 *bmc &= ~NEEDED_MASK;
1494 }
1495 }
1496 }
1497 spin_unlock_irq(&bitmap->lock);
1498 bitmap->allclean = 0;
1499 return rv;
1500}
1501
1502int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
1503 int degraded)
1504{
1505 /* bitmap_start_sync must always report on multiples of whole
1506 * pages, otherwise resync (which is very PAGE_SIZE based) will
1507 * get confused.
1508 * So call __bitmap_start_sync repeatedly (if needed) until
1509 * At least PAGE_SIZE>>9 blocks are covered.
1510 * Return the 'or' of the result.
1511 */
1512 int rv = 0;
1513 sector_t blocks1;
1514
1515 *blocks = 0;
1516 while (*blocks < (PAGE_SIZE>>9)) {
1517 rv |= __bitmap_start_sync(bitmap, offset,
1518 &blocks1, degraded);
1519 offset += blocks1;
1520 *blocks += blocks1;
1521 }
1522 return rv;
1523}
1524EXPORT_SYMBOL(bitmap_start_sync);
1525
1526void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted)
1527{
1528 bitmap_counter_t *bmc;
1529 unsigned long flags;
1530
1531 if (bitmap == NULL) {
1532 *blocks = 1024;
1533 return;
1534 }
1535 spin_lock_irqsave(&bitmap->lock, flags);
1536 bmc = bitmap_get_counter(bitmap, offset, blocks, 0);
1537 if (bmc == NULL)
1538 goto unlock;
1539 /* locked */
1540 if (RESYNC(*bmc)) {
1541 *bmc &= ~RESYNC_MASK;
1542
1543 if (!NEEDED(*bmc) && aborted)
1544 *bmc |= NEEDED_MASK;
1545 else {
1546 if (*bmc <= 2)
1547 set_page_attr(bitmap,
1548 filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap)),
1549 BITMAP_PAGE_CLEAN);
1550 }
1551 }
1552 unlock:
1553 spin_unlock_irqrestore(&bitmap->lock, flags);
1554 bitmap->allclean = 0;
1555}
1556EXPORT_SYMBOL(bitmap_end_sync);
1557
1558void bitmap_close_sync(struct bitmap *bitmap)
1559{
1560 /* Sync has finished, and any bitmap chunks that weren't synced
1561 * properly have been aborted. It remains to us to clear the
1562 * RESYNC bit wherever it is still on
1563 */
1564 sector_t sector = 0;
1565 sector_t blocks;
1566 if (!bitmap)
1567 return;
1568 while (sector < bitmap->mddev->resync_max_sectors) {
1569 bitmap_end_sync(bitmap, sector, &blocks, 0);
1570 sector += blocks;
1571 }
1572}
1573EXPORT_SYMBOL(bitmap_close_sync);
1574
1575void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
1576{
1577 sector_t s = 0;
1578 sector_t blocks;
1579
1580 if (!bitmap)
1581 return;
1582 if (sector == 0) {
1583 bitmap->last_end_sync = jiffies;
1584 return;
1585 }
1586 if (time_before(jiffies, (bitmap->last_end_sync
1587 + bitmap->mddev->bitmap_info.daemon_sleep)))
1588 return;
1589 wait_event(bitmap->mddev->recovery_wait,
1590 atomic_read(&bitmap->mddev->recovery_active) == 0);
1591
1592 bitmap->mddev->curr_resync_completed = sector;
1593 set_bit(MD_CHANGE_CLEAN, &bitmap->mddev->flags);
1594 sector &= ~((1ULL << CHUNK_BLOCK_SHIFT(bitmap)) - 1);
1595 s = 0;
1596 while (s < sector && s < bitmap->mddev->resync_max_sectors) {
1597 bitmap_end_sync(bitmap, s, &blocks, 0);
1598 s += blocks;
1599 }
1600 bitmap->last_end_sync = jiffies;
1601 sysfs_notify(&bitmap->mddev->kobj, NULL, "sync_completed");
1602}
1603EXPORT_SYMBOL(bitmap_cond_end_sync);
1604
1605static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)
1606{
1607 /* For each chunk covered by any of these sectors, set the
1608 * counter to 1 and set resync_needed. They should all
1609 * be 0 at this point
1610 */
1611
1612 sector_t secs;
1613 bitmap_counter_t *bmc;
1614 spin_lock_irq(&bitmap->lock);
1615 bmc = bitmap_get_counter(bitmap, offset, &secs, 1);
1616 if (!bmc) {
1617 spin_unlock_irq(&bitmap->lock);
1618 return;
1619 }
1620 if (!*bmc) {
1621 struct page *page;
1622 *bmc = 1 | (needed ? NEEDED_MASK : 0);
1623 bitmap_count_page(bitmap, offset, 1);
1624 page = filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap));
1625 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
1626 }
1627 spin_unlock_irq(&bitmap->lock);
1628 bitmap->allclean = 0;
1629}
1630
1631/* dirty the memory and file bits for bitmap chunks "s" to "e" */
1632void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e)
1633{
1634 unsigned long chunk;
1635
1636 for (chunk = s; chunk <= e; chunk++) {
1637 sector_t sec = (sector_t)chunk << CHUNK_BLOCK_SHIFT(bitmap);
1638 bitmap_set_memory_bits(bitmap, sec, 1);
1639 bitmap_file_set_bit(bitmap, sec);
1640 if (sec < bitmap->mddev->recovery_cp)
1641 /* We are asserting that the array is dirty,
1642 * so move the recovery_cp address back so
1643 * that it is obvious that it is dirty
1644 */
1645 bitmap->mddev->recovery_cp = sec;
1646 }
1647}
1648
1649/*
1650 * flush out any pending updates
1651 */
1652void bitmap_flush(mddev_t *mddev)
1653{
1654 struct bitmap *bitmap = mddev->bitmap;
1655 long sleep;
1656
1657 if (!bitmap) /* there was no bitmap */
1658 return;
1659
1660 /* run the daemon_work three time to ensure everything is flushed
1661 * that can be
1662 */
1663 sleep = mddev->bitmap_info.daemon_sleep * 2;
1664 bitmap->daemon_lastrun -= sleep;
1665 bitmap_daemon_work(mddev);
1666 bitmap->daemon_lastrun -= sleep;
1667 bitmap_daemon_work(mddev);
1668 bitmap->daemon_lastrun -= sleep;
1669 bitmap_daemon_work(mddev);
1670 bitmap_update_sb(bitmap);
1671}
1672
1673/*
1674 * free memory that was allocated
1675 */
1676static void bitmap_free(struct bitmap *bitmap)
1677{
1678 unsigned long k, pages;
1679 struct bitmap_page *bp;
1680
1681 if (!bitmap) /* there was no bitmap */
1682 return;
1683
1684 /* release the bitmap file and kill the daemon */
1685 bitmap_file_put(bitmap);
1686
1687 bp = bitmap->bp;
1688 pages = bitmap->pages;
1689
1690 /* free all allocated memory */
1691
1692 if (bp) /* deallocate the page memory */
1693 for (k = 0; k < pages; k++)
1694 if (bp[k].map && !bp[k].hijacked)
1695 kfree(bp[k].map);
1696 kfree(bp);
1697 kfree(bitmap);
1698}
1699
1700void bitmap_destroy(mddev_t *mddev)
1701{
1702 struct bitmap *bitmap = mddev->bitmap;
1703
1704 if (!bitmap) /* there was no bitmap */
1705 return;
1706
1707 mutex_lock(&mddev->bitmap_info.mutex);
1708 mddev->bitmap = NULL; /* disconnect from the md device */
1709 mutex_unlock(&mddev->bitmap_info.mutex);
1710 if (mddev->thread)
1711 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
1712
1713 if (bitmap->sysfs_can_clear)
1714 sysfs_put(bitmap->sysfs_can_clear);
1715
1716 bitmap_free(bitmap);
1717}
1718
1719/*
1720 * initialize the bitmap structure
1721 * if this returns an error, bitmap_destroy must be called to do clean up
1722 */
1723int bitmap_create(mddev_t *mddev)
1724{
1725 struct bitmap *bitmap;
1726 sector_t blocks = mddev->resync_max_sectors;
1727 unsigned long chunks;
1728 unsigned long pages;
1729 struct file *file = mddev->bitmap_info.file;
1730 int err;
1731 struct sysfs_dirent *bm = NULL;
1732
1733 BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
1734
1735 if (!file
1736 && !mddev->bitmap_info.offset) /* bitmap disabled, nothing to do */
1737 return 0;
1738
1739 BUG_ON(file && mddev->bitmap_info.offset);
1740
1741 bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
1742 if (!bitmap)
1743 return -ENOMEM;
1744
1745 spin_lock_init(&bitmap->lock);
1746 atomic_set(&bitmap->pending_writes, 0);
1747 init_waitqueue_head(&bitmap->write_wait);
1748 init_waitqueue_head(&bitmap->overflow_wait);
1749 init_waitqueue_head(&bitmap->behind_wait);
1750
1751 bitmap->mddev = mddev;
1752
1753 if (mddev->kobj.sd)
1754 bm = sysfs_get_dirent(mddev->kobj.sd, NULL, "bitmap");
1755 if (bm) {
1756 bitmap->sysfs_can_clear = sysfs_get_dirent(bm, NULL, "can_clear");
1757 sysfs_put(bm);
1758 } else
1759 bitmap->sysfs_can_clear = NULL;
1760
1761 bitmap->file = file;
1762 if (file) {
1763 get_file(file);
1764 /* As future accesses to this file will use bmap,
1765 * and bypass the page cache, we must sync the file
1766 * first.
1767 */
1768 vfs_fsync(file, 1);
1769 }
1770 /* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */
1771 if (!mddev->bitmap_info.external) {
1772 /*
1773 * If 'MD_ARRAY_FIRST_USE' is set, then device-mapper is
1774 * instructing us to create a new on-disk bitmap instance.
1775 */
1776 if (test_and_clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags))
1777 err = bitmap_new_disk_sb(bitmap);
1778 else
1779 err = bitmap_read_sb(bitmap);
1780 } else {
1781 err = 0;
1782 if (mddev->bitmap_info.chunksize == 0 ||
1783 mddev->bitmap_info.daemon_sleep == 0)
1784 /* chunksize and time_base need to be
1785 * set first. */
1786 err = -EINVAL;
1787 }
1788 if (err)
1789 goto error;
1790
1791 bitmap->daemon_lastrun = jiffies;
1792 bitmap->chunkshift = ffz(~mddev->bitmap_info.chunksize);
1793
1794 /* now that chunksize and chunkshift are set, we can use these macros */
1795 chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
1796 CHUNK_BLOCK_SHIFT(bitmap);
1797 pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
1798
1799 BUG_ON(!pages);
1800
1801 bitmap->chunks = chunks;
1802 bitmap->pages = pages;
1803 bitmap->missing_pages = pages;
1804
1805#ifdef INJECT_FATAL_FAULT_1
1806 bitmap->bp = NULL;
1807#else
1808 bitmap->bp = kzalloc(pages * sizeof(*bitmap->bp), GFP_KERNEL);
1809#endif
1810 err = -ENOMEM;
1811 if (!bitmap->bp)
1812 goto error;
1813
1814 printk(KERN_INFO "created bitmap (%lu pages) for device %s\n",
1815 pages, bmname(bitmap));
1816
1817 mddev->bitmap = bitmap;
1818
1819
1820 return (bitmap->flags & BITMAP_WRITE_ERROR) ? -EIO : 0;
1821
1822 error:
1823 bitmap_free(bitmap);
1824 return err;
1825}
1826
1827int bitmap_load(mddev_t *mddev)
1828{
1829 int err = 0;
1830 sector_t start = 0;
1831 sector_t sector = 0;
1832 struct bitmap *bitmap = mddev->bitmap;
1833
1834 if (!bitmap)
1835 goto out;
1836
1837 /* Clear out old bitmap info first: Either there is none, or we
1838 * are resuming after someone else has possibly changed things,
1839 * so we should forget old cached info.
1840 * All chunks should be clean, but some might need_sync.
1841 */
1842 while (sector < mddev->resync_max_sectors) {
1843 sector_t blocks;
1844 bitmap_start_sync(bitmap, sector, &blocks, 0);
1845 sector += blocks;
1846 }
1847 bitmap_close_sync(bitmap);
1848
1849 if (mddev->degraded == 0
1850 || bitmap->events_cleared == mddev->events)
1851 /* no need to keep dirty bits to optimise a
1852 * re-add of a missing device */
1853 start = mddev->recovery_cp;
1854
1855 err = bitmap_init_from_disk(bitmap, start);
1856
1857 if (err)
1858 goto out;
1859
1860 mddev->thread->timeout = mddev->bitmap_info.daemon_sleep;
1861 md_wakeup_thread(mddev->thread);
1862
1863 bitmap_update_sb(bitmap);
1864
1865 if (bitmap->flags & BITMAP_WRITE_ERROR)
1866 err = -EIO;
1867out:
1868 return err;
1869}
1870EXPORT_SYMBOL_GPL(bitmap_load);
1871
1872static ssize_t
1873location_show(mddev_t *mddev, char *page)
1874{
1875 ssize_t len;
1876 if (mddev->bitmap_info.file)
1877 len = sprintf(page, "file");
1878 else if (mddev->bitmap_info.offset)
1879 len = sprintf(page, "%+lld", (long long)mddev->bitmap_info.offset);
1880 else
1881 len = sprintf(page, "none");
1882 len += sprintf(page+len, "\n");
1883 return len;
1884}
1885
1886static ssize_t
1887location_store(mddev_t *mddev, const char *buf, size_t len)
1888{
1889
1890 if (mddev->pers) {
1891 if (!mddev->pers->quiesce)
1892 return -EBUSY;
1893 if (mddev->recovery || mddev->sync_thread)
1894 return -EBUSY;
1895 }
1896
1897 if (mddev->bitmap || mddev->bitmap_info.file ||
1898 mddev->bitmap_info.offset) {
1899 /* bitmap already configured. Only option is to clear it */
1900 if (strncmp(buf, "none", 4) != 0)
1901 return -EBUSY;
1902 if (mddev->pers) {
1903 mddev->pers->quiesce(mddev, 1);
1904 bitmap_destroy(mddev);
1905 mddev->pers->quiesce(mddev, 0);
1906 }
1907 mddev->bitmap_info.offset = 0;
1908 if (mddev->bitmap_info.file) {
1909 struct file *f = mddev->bitmap_info.file;
1910 mddev->bitmap_info.file = NULL;
1911 restore_bitmap_write_access(f);
1912 fput(f);
1913 }
1914 } else {
1915 /* No bitmap, OK to set a location */
1916 long long offset;
1917 if (strncmp(buf, "none", 4) == 0)
1918 /* nothing to be done */;
1919 else if (strncmp(buf, "file:", 5) == 0) {
1920 /* Not supported yet */
1921 return -EINVAL;
1922 } else {
1923 int rv;
1924 if (buf[0] == '+')
1925 rv = strict_strtoll(buf+1, 10, &offset);
1926 else
1927 rv = strict_strtoll(buf, 10, &offset);
1928 if (rv)
1929 return rv;
1930 if (offset == 0)
1931 return -EINVAL;
1932 if (mddev->bitmap_info.external == 0 &&
1933 mddev->major_version == 0 &&
1934 offset != mddev->bitmap_info.default_offset)
1935 return -EINVAL;
1936 mddev->bitmap_info.offset = offset;
1937 if (mddev->pers) {
1938 mddev->pers->quiesce(mddev, 1);
1939 rv = bitmap_create(mddev);
1940 if (rv) {
1941 bitmap_destroy(mddev);
1942 mddev->bitmap_info.offset = 0;
1943 }
1944 mddev->pers->quiesce(mddev, 0);
1945 if (rv)
1946 return rv;
1947 }
1948 }
1949 }
1950 if (!mddev->external) {
1951 /* Ensure new bitmap info is stored in
1952 * metadata promptly.
1953 */
1954 set_bit(MD_CHANGE_DEVS, &mddev->flags);
1955 md_wakeup_thread(mddev->thread);
1956 }
1957 return len;
1958}
1959
1960static struct md_sysfs_entry bitmap_location =
1961__ATTR(location, S_IRUGO|S_IWUSR, location_show, location_store);
1962
1963static ssize_t
1964timeout_show(mddev_t *mddev, char *page)
1965{
1966 ssize_t len;
1967 unsigned long secs = mddev->bitmap_info.daemon_sleep / HZ;
1968 unsigned long jifs = mddev->bitmap_info.daemon_sleep % HZ;
1969
1970 len = sprintf(page, "%lu", secs);
1971 if (jifs)
1972 len += sprintf(page+len, ".%03u", jiffies_to_msecs(jifs));
1973 len += sprintf(page+len, "\n");
1974 return len;
1975}
1976
1977static ssize_t
1978timeout_store(mddev_t *mddev, const char *buf, size_t len)
1979{
1980 /* timeout can be set at any time */
1981 unsigned long timeout;
1982 int rv = strict_strtoul_scaled(buf, &timeout, 4);
1983 if (rv)
1984 return rv;
1985
1986 /* just to make sure we don't overflow... */
1987 if (timeout >= LONG_MAX / HZ)
1988 return -EINVAL;
1989
1990 timeout = timeout * HZ / 10000;
1991
1992 if (timeout >= MAX_SCHEDULE_TIMEOUT)
1993 timeout = MAX_SCHEDULE_TIMEOUT-1;
1994 if (timeout < 1)
1995 timeout = 1;
1996 mddev->bitmap_info.daemon_sleep = timeout;
1997 if (mddev->thread) {
1998 /* if thread->timeout is MAX_SCHEDULE_TIMEOUT, then
1999 * the bitmap is all clean and we don't need to
2000 * adjust the timeout right now
2001 */
2002 if (mddev->thread->timeout < MAX_SCHEDULE_TIMEOUT) {
2003 mddev->thread->timeout = timeout;
2004 md_wakeup_thread(mddev->thread);
2005 }
2006 }
2007 return len;
2008}
2009
2010static struct md_sysfs_entry bitmap_timeout =
2011__ATTR(time_base, S_IRUGO|S_IWUSR, timeout_show, timeout_store);
2012
2013static ssize_t
2014backlog_show(mddev_t *mddev, char *page)
2015{
2016 return sprintf(page, "%lu\n", mddev->bitmap_info.max_write_behind);
2017}
2018
2019static ssize_t
2020backlog_store(mddev_t *mddev, const char *buf, size_t len)
2021{
2022 unsigned long backlog;
2023 int rv = strict_strtoul(buf, 10, &backlog);
2024 if (rv)
2025 return rv;
2026 if (backlog > COUNTER_MAX)
2027 return -EINVAL;
2028 mddev->bitmap_info.max_write_behind = backlog;
2029 return len;
2030}
2031
2032static struct md_sysfs_entry bitmap_backlog =
2033__ATTR(backlog, S_IRUGO|S_IWUSR, backlog_show, backlog_store);
2034
2035static ssize_t
2036chunksize_show(mddev_t *mddev, char *page)
2037{
2038 return sprintf(page, "%lu\n", mddev->bitmap_info.chunksize);
2039}
2040
2041static ssize_t
2042chunksize_store(mddev_t *mddev, const char *buf, size_t len)
2043{
2044 /* Can only be changed when no bitmap is active */
2045 int rv;
2046 unsigned long csize;
2047 if (mddev->bitmap)
2048 return -EBUSY;
2049 rv = strict_strtoul(buf, 10, &csize);
2050 if (rv)
2051 return rv;
2052 if (csize < 512 ||
2053 !is_power_of_2(csize))
2054 return -EINVAL;
2055 mddev->bitmap_info.chunksize = csize;
2056 return len;
2057}
2058
2059static struct md_sysfs_entry bitmap_chunksize =
2060__ATTR(chunksize, S_IRUGO|S_IWUSR, chunksize_show, chunksize_store);
2061
2062static ssize_t metadata_show(mddev_t *mddev, char *page)
2063{
2064 return sprintf(page, "%s\n", (mddev->bitmap_info.external
2065 ? "external" : "internal"));
2066}
2067
2068static ssize_t metadata_store(mddev_t *mddev, const char *buf, size_t len)
2069{
2070 if (mddev->bitmap ||
2071 mddev->bitmap_info.file ||
2072 mddev->bitmap_info.offset)
2073 return -EBUSY;
2074 if (strncmp(buf, "external", 8) == 0)
2075 mddev->bitmap_info.external = 1;
2076 else if (strncmp(buf, "internal", 8) == 0)
2077 mddev->bitmap_info.external = 0;
2078 else
2079 return -EINVAL;
2080 return len;
2081}
2082
2083static struct md_sysfs_entry bitmap_metadata =
2084__ATTR(metadata, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
2085
2086static ssize_t can_clear_show(mddev_t *mddev, char *page)
2087{
2088 int len;
2089 if (mddev->bitmap)
2090 len = sprintf(page, "%s\n", (mddev->bitmap->need_sync ?
2091 "false" : "true"));
2092 else
2093 len = sprintf(page, "\n");
2094 return len;
2095}
2096
2097static ssize_t can_clear_store(mddev_t *mddev, const char *buf, size_t len)
2098{
2099 if (mddev->bitmap == NULL)
2100 return -ENOENT;
2101 if (strncmp(buf, "false", 5) == 0)
2102 mddev->bitmap->need_sync = 1;
2103 else if (strncmp(buf, "true", 4) == 0) {
2104 if (mddev->degraded)
2105 return -EBUSY;
2106 mddev->bitmap->need_sync = 0;
2107 } else
2108 return -EINVAL;
2109 return len;
2110}
2111
2112static struct md_sysfs_entry bitmap_can_clear =
2113__ATTR(can_clear, S_IRUGO|S_IWUSR, can_clear_show, can_clear_store);
2114
2115static ssize_t
2116behind_writes_used_show(mddev_t *mddev, char *page)
2117{
2118 if (mddev->bitmap == NULL)
2119 return sprintf(page, "0\n");
2120 return sprintf(page, "%lu\n",
2121 mddev->bitmap->behind_writes_used);
2122}
2123
2124static ssize_t
2125behind_writes_used_reset(mddev_t *mddev, const char *buf, size_t len)
2126{
2127 if (mddev->bitmap)
2128 mddev->bitmap->behind_writes_used = 0;
2129 return len;
2130}
2131
2132static struct md_sysfs_entry max_backlog_used =
2133__ATTR(max_backlog_used, S_IRUGO | S_IWUSR,
2134 behind_writes_used_show, behind_writes_used_reset);
2135
2136static struct attribute *md_bitmap_attrs[] = {
2137 &bitmap_location.attr,
2138 &bitmap_timeout.attr,
2139 &bitmap_backlog.attr,
2140 &bitmap_chunksize.attr,
2141 &bitmap_metadata.attr,
2142 &bitmap_can_clear.attr,
2143 &max_backlog_used.attr,
2144 NULL
2145};
2146struct attribute_group md_bitmap_group = {
2147 .name = "bitmap",
2148 .attrs = md_bitmap_attrs,
2149};
2150