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