drivers/md/bitmap.c

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