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