blob: 3a5767968ba06c3083180f4299c5851f454289a8 [file] [log] [blame]
NeilBrown32a76272005-06-21 17:17:14 -07001/*
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
NeilBrown32a76272005-06-21 17:17:14 -070010 */
11
12/*
13 * Still to do:
14 *
15 * flush after percent set rather than just time based. (maybe both).
NeilBrown32a76272005-06-21 17:17:14 -070016 */
17
NeilBrownbff61972009-03-31 14:33:13 +110018#include <linux/blkdev.h>
NeilBrown32a76272005-06-21 17:17:14 -070019#include <linux/module.h>
NeilBrown32a76272005-06-21 17:17:14 -070020#include <linux/errno.h>
21#include <linux/slab.h>
22#include <linux/init.h>
NeilBrown32a76272005-06-21 17:17:14 -070023#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>
NeilBrown57148962012-03-19 12:46:40 +110029#include <linux/seq_file.h>
NeilBrown43b2e5d2009-03-31 14:33:13 +110030#include "md.h"
Christoph Hellwigef740c32009-03-31 14:27:03 +110031#include "bitmap.h"
NeilBrown32a76272005-06-21 17:17:14 -070032
NeilBrownac2f40b2010-06-01 19:37:31 +100033static inline char *bmname(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -070034{
35 return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";
36}
37
NeilBrown32a76272005-06-21 17:17:14 -070038/*
NeilBrown32a76272005-06-21 17:17:14 -070039 * 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 */
NeilBrown40cffcc2012-05-22 13:55:24 +100048static int bitmap_checkpage(struct bitmap_counts *bitmap,
NeilBrownac2f40b2010-06-01 19:37:31 +100049 unsigned long page, int create)
NeilBrownee305ac2009-09-23 18:06:44 +100050__releases(bitmap->lock)
51__acquires(bitmap->lock)
NeilBrown32a76272005-06-21 17:17:14 -070052{
53 unsigned char *mappage;
54
55 if (page >= bitmap->pages) {
NeilBrown1187cf02009-03-31 14:27:02 +110056 /* This can happen if bitmap_start_sync goes beyond
57 * End-of-device while looking for a whole page.
58 * It is harmless.
59 */
NeilBrown32a76272005-06-21 17:17:14 -070060 return -EINVAL;
61 }
62
NeilBrown32a76272005-06-21 17:17:14 -070063 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
NeilBrown32a76272005-06-21 17:17:14 -070072 /* this page has not been allocated yet */
73
NeilBrownac2f40b2010-06-01 19:37:31 +100074 spin_unlock_irq(&bitmap->lock);
NeilBrownd9590142015-02-02 17:08:03 +110075 /* 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();
NeilBrown792a1d42012-03-19 12:46:41 +110088 mappage = kzalloc(PAGE_SIZE, GFP_NOIO);
NeilBrownac2f40b2010-06-01 19:37:31 +100089 spin_lock_irq(&bitmap->lock);
90
91 if (mappage == NULL) {
NeilBrown40cffcc2012-05-22 13:55:24 +100092 pr_debug("md/bitmap: map page allocation failed, hijacking\n");
NeilBrown32a76272005-06-21 17:17:14 -070093 /* failed - set the hijacked flag so that we can use the
94 * pointer as a counter */
NeilBrown32a76272005-06-21 17:17:14 -070095 if (!bitmap->bp[page].map)
96 bitmap->bp[page].hijacked = 1;
NeilBrownac2f40b2010-06-01 19:37:31 +100097 } else if (bitmap->bp[page].map ||
98 bitmap->bp[page].hijacked) {
NeilBrown32a76272005-06-21 17:17:14 -070099 /* somebody beat us to getting the page */
NeilBrown792a1d42012-03-19 12:46:41 +1100100 kfree(mappage);
NeilBrown32a76272005-06-21 17:17:14 -0700101 return 0;
NeilBrownac2f40b2010-06-01 19:37:31 +1000102 } else {
103
104 /* no page was in place and we have one, so install it */
105
106 bitmap->bp[page].map = mappage;
107 bitmap->missing_pages--;
NeilBrown32a76272005-06-21 17:17:14 -0700108 }
NeilBrown32a76272005-06-21 17:17:14 -0700109 return 0;
110}
111
NeilBrown32a76272005-06-21 17:17:14 -0700112/* if page is completely empty, put it back on the free list, or dealloc it */
113/* if page was hijacked, unmark the flag so it might get alloced next time */
114/* Note: lock should be held when calling this */
NeilBrown40cffcc2012-05-22 13:55:24 +1000115static void bitmap_checkfree(struct bitmap_counts *bitmap, unsigned long page)
NeilBrown32a76272005-06-21 17:17:14 -0700116{
117 char *ptr;
118
119 if (bitmap->bp[page].count) /* page is still busy */
120 return;
121
122 /* page is no longer in use, it can be released */
123
124 if (bitmap->bp[page].hijacked) { /* page was hijacked, undo this now */
125 bitmap->bp[page].hijacked = 0;
126 bitmap->bp[page].map = NULL;
NeilBrownac2f40b2010-06-01 19:37:31 +1000127 } else {
128 /* normal case, free the page */
129 ptr = bitmap->bp[page].map;
130 bitmap->bp[page].map = NULL;
131 bitmap->missing_pages++;
NeilBrown792a1d42012-03-19 12:46:41 +1100132 kfree(ptr);
NeilBrown32a76272005-06-21 17:17:14 -0700133 }
NeilBrown32a76272005-06-21 17:17:14 -0700134}
135
NeilBrown32a76272005-06-21 17:17:14 -0700136/*
137 * bitmap file handling - read and write the bitmap file and its superblock
138 */
139
NeilBrown32a76272005-06-21 17:17:14 -0700140/*
141 * basic page I/O operations
142 */
143
NeilBrowna654b9d82005-06-21 17:17:27 -0700144/* IO operations when bitmap is stored near all superblocks */
NeilBrown27581e52012-05-22 13:55:08 +1000145static int read_sb_page(struct mddev *mddev, loff_t offset,
146 struct page *page,
147 unsigned long index, int size)
NeilBrowna654b9d82005-06-21 17:17:27 -0700148{
149 /* choose a good rdev and read the page from there */
150
NeilBrown3cb03002011-10-11 16:45:26 +1100151 struct md_rdev *rdev;
NeilBrowna654b9d82005-06-21 17:17:27 -0700152 sector_t target;
NeilBrowna654b9d82005-06-21 17:17:27 -0700153
NeilBrowndafb20f2012-03-19 12:46:39 +1100154 rdev_for_each(rdev, mddev) {
NeilBrownb2d444d2005-11-08 21:39:31 -0800155 if (! test_bit(In_sync, &rdev->flags)
156 || test_bit(Faulty, &rdev->flags))
NeilBrownab904d62005-09-09 16:23:52 -0700157 continue;
158
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100159 target = offset + index * (PAGE_SIZE/512);
NeilBrowna654b9d82005-06-21 17:17:27 -0700160
NeilBrown2b193362010-10-27 15:16:40 +1100161 if (sync_page_io(rdev, target,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400162 roundup(size, bdev_logical_block_size(rdev->bdev)),
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100163 page, READ, true)) {
NeilBrownab904d62005-09-09 16:23:52 -0700164 page->index = index;
NeilBrown27581e52012-05-22 13:55:08 +1000165 return 0;
NeilBrownab904d62005-09-09 16:23:52 -0700166 }
167 }
NeilBrown27581e52012-05-22 13:55:08 +1000168 return -EIO;
NeilBrowna654b9d82005-06-21 17:17:27 -0700169}
170
NeilBrownfd01b882011-10-11 16:47:53 +1100171static struct md_rdev *next_active_rdev(struct md_rdev *rdev, struct mddev *mddev)
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000172{
173 /* Iterate the disks of an mddev, using rcu to protect access to the
174 * linked list, and raising the refcount of devices we return to ensure
175 * they don't disappear while in use.
176 * As devices are only added or removed when raid_disk is < 0 and
177 * nr_pending is 0 and In_sync is clear, the entries we return will
178 * still be in the same position on the list when we re-enter
Michael Wangfd177482012-10-11 13:43:21 +1100179 * list_for_each_entry_continue_rcu.
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000180 */
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000181 rcu_read_lock();
182 if (rdev == NULL)
183 /* start at the beginning */
Michael Wangfd177482012-10-11 13:43:21 +1100184 rdev = list_entry_rcu(&mddev->disks, struct md_rdev, same_set);
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000185 else {
186 /* release the previous rdev and start from there. */
187 rdev_dec_pending(rdev, mddev);
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000188 }
Michael Wangfd177482012-10-11 13:43:21 +1100189 list_for_each_entry_continue_rcu(rdev, &mddev->disks, same_set) {
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000190 if (rdev->raid_disk >= 0 &&
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000191 !test_bit(Faulty, &rdev->flags)) {
192 /* this is a usable devices */
193 atomic_inc(&rdev->nr_pending);
194 rcu_read_unlock();
195 return rdev;
196 }
197 }
198 rcu_read_unlock();
199 return NULL;
200}
201
NeilBrownab6085c2007-05-23 13:58:10 -0700202static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
NeilBrowna654b9d82005-06-21 17:17:27 -0700203{
NeilBrown3cb03002011-10-11 16:45:26 +1100204 struct md_rdev *rdev = NULL;
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100205 struct block_device *bdev;
NeilBrownfd01b882011-10-11 16:47:53 +1100206 struct mddev *mddev = bitmap->mddev;
NeilBrown1ec885c2012-05-22 13:55:10 +1000207 struct bitmap_storage *store = &bitmap->storage;
NeilBrowna654b9d82005-06-21 17:17:27 -0700208
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000209 while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
NeilBrownac2f40b2010-06-01 19:37:31 +1000210 int size = PAGE_SIZE;
211 loff_t offset = mddev->bitmap_info.offset;
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100212
213 bdev = (rdev->meta_bdev) ? rdev->meta_bdev : rdev->bdev;
214
NeilBrown9b1215c2012-05-22 13:55:11 +1000215 if (page->index == store->file_pages-1) {
216 int last_page_size = store->bytes & (PAGE_SIZE-1);
217 if (last_page_size == 0)
218 last_page_size = PAGE_SIZE;
219 size = roundup(last_page_size,
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100220 bdev_logical_block_size(bdev));
NeilBrown9b1215c2012-05-22 13:55:11 +1000221 }
NeilBrownac2f40b2010-06-01 19:37:31 +1000222 /* Just make sure we aren't corrupting data or
223 * metadata
224 */
225 if (mddev->external) {
226 /* Bitmap could be anywhere. */
227 if (rdev->sb_start + offset + (page->index
228 * (PAGE_SIZE/512))
229 > rdev->data_offset
230 &&
231 rdev->sb_start + offset
232 < (rdev->data_offset + mddev->dev_sectors
233 + (PAGE_SIZE/512)))
234 goto bad_alignment;
235 } else if (offset < 0) {
236 /* DATA BITMAP METADATA */
237 if (offset
238 + (long)(page->index * (PAGE_SIZE/512))
239 + size/512 > 0)
240 /* bitmap runs in to metadata */
241 goto bad_alignment;
242 if (rdev->data_offset + mddev->dev_sectors
243 > rdev->sb_start + offset)
244 /* data runs in to bitmap */
245 goto bad_alignment;
246 } else if (rdev->sb_start < rdev->data_offset) {
247 /* METADATA BITMAP DATA */
248 if (rdev->sb_start
249 + offset
250 + page->index*(PAGE_SIZE/512) + size/512
251 > rdev->data_offset)
252 /* bitmap runs in to data */
253 goto bad_alignment;
254 } else {
255 /* DATA METADATA BITMAP - no problems */
256 }
257 md_super_write(mddev, rdev,
258 rdev->sb_start + offset
259 + page->index * (PAGE_SIZE/512),
260 size,
261 page);
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000262 }
NeilBrowna654b9d82005-06-21 17:17:27 -0700263
264 if (wait)
NeilBrowna9701a32005-11-08 21:39:34 -0800265 md_super_wait(mddev);
NeilBrowna654b9d82005-06-21 17:17:27 -0700266 return 0;
NeilBrown4b809912008-07-21 17:05:25 +1000267
268 bad_alignment:
NeilBrown4b809912008-07-21 17:05:25 +1000269 return -EINVAL;
NeilBrowna654b9d82005-06-21 17:17:27 -0700270}
271
NeilBrown4ad13662007-07-17 04:06:13 -0700272static void bitmap_file_kick(struct bitmap *bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700273/*
NeilBrowna654b9d82005-06-21 17:17:27 -0700274 * write out a page to a file
NeilBrown32a76272005-06-21 17:17:14 -0700275 */
NeilBrown4ad13662007-07-17 04:06:13 -0700276static void write_page(struct bitmap *bitmap, struct page *page, int wait)
NeilBrown32a76272005-06-21 17:17:14 -0700277{
NeilBrownd785a062006-06-26 00:27:48 -0700278 struct buffer_head *bh;
NeilBrown32a76272005-06-21 17:17:14 -0700279
NeilBrown1ec885c2012-05-22 13:55:10 +1000280 if (bitmap->storage.file == NULL) {
NeilBrownf0d76d72007-07-17 04:06:12 -0700281 switch (write_sb_page(bitmap, page, wait)) {
282 case -EINVAL:
NeilBrownb405fe92012-05-22 13:55:15 +1000283 set_bit(BITMAP_WRITE_ERROR, &bitmap->flags);
NeilBrownf0d76d72007-07-17 04:06:12 -0700284 }
NeilBrown4ad13662007-07-17 04:06:13 -0700285 } else {
NeilBrowna654b9d82005-06-21 17:17:27 -0700286
NeilBrown4ad13662007-07-17 04:06:13 -0700287 bh = page_buffers(page);
NeilBrownc7084432006-01-06 00:20:45 -0800288
NeilBrown4ad13662007-07-17 04:06:13 -0700289 while (bh && bh->b_blocknr) {
290 atomic_inc(&bitmap->pending_writes);
291 set_buffer_locked(bh);
292 set_buffer_mapped(bh);
Jens Axboe721a9602011-03-09 11:56:30 +0100293 submit_bh(WRITE | REQ_SYNC, bh);
NeilBrown4ad13662007-07-17 04:06:13 -0700294 bh = bh->b_this_page;
295 }
NeilBrown32a76272005-06-21 17:17:14 -0700296
NeilBrownac2f40b2010-06-01 19:37:31 +1000297 if (wait)
NeilBrown4ad13662007-07-17 04:06:13 -0700298 wait_event(bitmap->write_wait,
299 atomic_read(&bitmap->pending_writes)==0);
NeilBrown32a76272005-06-21 17:17:14 -0700300 }
NeilBrownb405fe92012-05-22 13:55:15 +1000301 if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))
NeilBrown4ad13662007-07-17 04:06:13 -0700302 bitmap_file_kick(bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700303}
304
NeilBrownd785a062006-06-26 00:27:48 -0700305static void end_bitmap_write(struct buffer_head *bh, int uptodate)
NeilBrown32a76272005-06-21 17:17:14 -0700306{
NeilBrownd785a062006-06-26 00:27:48 -0700307 struct bitmap *bitmap = bh->b_private;
NeilBrownd785a062006-06-26 00:27:48 -0700308
NeilBrownb405fe92012-05-22 13:55:15 +1000309 if (!uptodate)
310 set_bit(BITMAP_WRITE_ERROR, &bitmap->flags);
NeilBrownd785a062006-06-26 00:27:48 -0700311 if (atomic_dec_and_test(&bitmap->pending_writes))
312 wake_up(&bitmap->write_wait);
313}
314
315/* copied from buffer.c */
316static void
317__clear_page_buffers(struct page *page)
318{
319 ClearPagePrivate(page);
320 set_page_private(page, 0);
321 page_cache_release(page);
322}
323static void free_buffers(struct page *page)
324{
NeilBrown27581e52012-05-22 13:55:08 +1000325 struct buffer_head *bh;
NeilBrownd785a062006-06-26 00:27:48 -0700326
NeilBrown27581e52012-05-22 13:55:08 +1000327 if (!PagePrivate(page))
328 return;
329
330 bh = page_buffers(page);
NeilBrownd785a062006-06-26 00:27:48 -0700331 while (bh) {
332 struct buffer_head *next = bh->b_this_page;
333 free_buffer_head(bh);
334 bh = next;
335 }
336 __clear_page_buffers(page);
337 put_page(page);
338}
339
340/* read a page from a file.
341 * We both read the page, and attach buffers to the page to record the
342 * address of each block (using bmap). These addresses will be used
343 * to write the block later, completely bypassing the filesystem.
344 * This usage is similar to how swap files are handled, and allows us
345 * to write to a file with no concerns of memory allocation failing.
346 */
NeilBrown27581e52012-05-22 13:55:08 +1000347static int read_page(struct file *file, unsigned long index,
348 struct bitmap *bitmap,
349 unsigned long count,
350 struct page *page)
NeilBrownd785a062006-06-26 00:27:48 -0700351{
NeilBrown27581e52012-05-22 13:55:08 +1000352 int ret = 0;
Al Viro496ad9a2013-01-23 17:07:38 -0500353 struct inode *inode = file_inode(file);
NeilBrownd785a062006-06-26 00:27:48 -0700354 struct buffer_head *bh;
355 sector_t block;
NeilBrown32a76272005-06-21 17:17:14 -0700356
NeilBrown36a4e1f2011-10-07 14:23:17 +1100357 pr_debug("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,
358 (unsigned long long)index << PAGE_SHIFT);
NeilBrown32a76272005-06-21 17:17:14 -0700359
NeilBrownd785a062006-06-26 00:27:48 -0700360 bh = alloc_page_buffers(page, 1<<inode->i_blkbits, 0);
361 if (!bh) {
NeilBrown27581e52012-05-22 13:55:08 +1000362 ret = -ENOMEM;
NeilBrownd785a062006-06-26 00:27:48 -0700363 goto out;
364 }
365 attach_page_buffers(page, bh);
366 block = index << (PAGE_SHIFT - inode->i_blkbits);
367 while (bh) {
368 if (count == 0)
369 bh->b_blocknr = 0;
370 else {
371 bh->b_blocknr = bmap(inode, block);
372 if (bh->b_blocknr == 0) {
373 /* Cannot use this file! */
NeilBrown27581e52012-05-22 13:55:08 +1000374 ret = -EINVAL;
NeilBrownd785a062006-06-26 00:27:48 -0700375 goto out;
376 }
377 bh->b_bdev = inode->i_sb->s_bdev;
378 if (count < (1<<inode->i_blkbits))
379 count = 0;
380 else
381 count -= (1<<inode->i_blkbits);
NeilBrown32a76272005-06-21 17:17:14 -0700382
NeilBrownd785a062006-06-26 00:27:48 -0700383 bh->b_end_io = end_bitmap_write;
384 bh->b_private = bitmap;
NeilBrownce25c312006-06-26 00:27:49 -0700385 atomic_inc(&bitmap->pending_writes);
386 set_buffer_locked(bh);
387 set_buffer_mapped(bh);
388 submit_bh(READ, bh);
NeilBrownd785a062006-06-26 00:27:48 -0700389 }
390 block++;
391 bh = bh->b_this_page;
392 }
NeilBrownd785a062006-06-26 00:27:48 -0700393 page->index = index;
NeilBrownce25c312006-06-26 00:27:49 -0700394
395 wait_event(bitmap->write_wait,
396 atomic_read(&bitmap->pending_writes)==0);
NeilBrownb405fe92012-05-22 13:55:15 +1000397 if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))
NeilBrown27581e52012-05-22 13:55:08 +1000398 ret = -EIO;
NeilBrown32a76272005-06-21 17:17:14 -0700399out:
NeilBrown27581e52012-05-22 13:55:08 +1000400 if (ret)
401 printk(KERN_ALERT "md: bitmap read error: (%dB @ %llu): %d\n",
NeilBrown2d1f3b52006-01-06 00:20:31 -0800402 (int)PAGE_SIZE,
403 (unsigned long long)index << PAGE_SHIFT,
NeilBrown27581e52012-05-22 13:55:08 +1000404 ret);
405 return ret;
NeilBrown32a76272005-06-21 17:17:14 -0700406}
407
408/*
409 * bitmap file superblock operations
410 */
411
412/* update the event counter and sync the superblock to disk */
NeilBrown4ad13662007-07-17 04:06:13 -0700413void bitmap_update_sb(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -0700414{
415 bitmap_super_t *sb;
NeilBrown32a76272005-06-21 17:17:14 -0700416
417 if (!bitmap || !bitmap->mddev) /* no bitmap for this array */
NeilBrown4ad13662007-07-17 04:06:13 -0700418 return;
NeilBrownece5cff2009-12-14 12:49:56 +1100419 if (bitmap->mddev->bitmap_info.external)
420 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000421 if (!bitmap->storage.sb_page) /* no superblock */
NeilBrown4ad13662007-07-17 04:06:13 -0700422 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000423 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700424 sb->events = cpu_to_le64(bitmap->mddev->events);
NeilBrown8258c532011-05-11 14:26:30 +1000425 if (bitmap->mddev->events < bitmap->events_cleared)
Neil Browna0da84f2008-06-28 08:31:22 +1000426 /* rocking back to read-only */
427 bitmap->events_cleared = bitmap->mddev->events;
NeilBrown8258c532011-05-11 14:26:30 +1000428 sb->events_cleared = cpu_to_le64(bitmap->events_cleared);
429 sb->state = cpu_to_le32(bitmap->flags);
NeilBrown43a70502009-12-14 12:49:55 +1100430 /* Just in case these have been changed via sysfs: */
431 sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);
432 sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);
NeilBrownb81a0402012-05-22 13:55:26 +1000433 /* This might have been changed by a reshape */
434 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
435 sb->chunksize = cpu_to_le32(bitmap->mddev->bitmap_info.chunksize);
NeilBrown1dff2b82012-05-22 13:55:34 +1000436 sb->sectors_reserved = cpu_to_le32(bitmap->mddev->
437 bitmap_info.space);
Cong Wangb2f46e62011-11-28 13:25:44 +0800438 kunmap_atomic(sb);
NeilBrown1ec885c2012-05-22 13:55:10 +1000439 write_page(bitmap, bitmap->storage.sb_page, 1);
NeilBrown32a76272005-06-21 17:17:14 -0700440}
441
442/* print out the bitmap file superblock */
443void bitmap_print_sb(struct bitmap *bitmap)
444{
445 bitmap_super_t *sb;
446
NeilBrown1ec885c2012-05-22 13:55:10 +1000447 if (!bitmap || !bitmap->storage.sb_page)
NeilBrown32a76272005-06-21 17:17:14 -0700448 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000449 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700450 printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
NeilBrowna2cff262005-06-21 17:17:20 -0700451 printk(KERN_DEBUG " magic: %08x\n", le32_to_cpu(sb->magic));
452 printk(KERN_DEBUG " version: %d\n", le32_to_cpu(sb->version));
453 printk(KERN_DEBUG " uuid: %08x.%08x.%08x.%08x\n",
NeilBrown32a76272005-06-21 17:17:14 -0700454 *(__u32 *)(sb->uuid+0),
455 *(__u32 *)(sb->uuid+4),
456 *(__u32 *)(sb->uuid+8),
457 *(__u32 *)(sb->uuid+12));
NeilBrowna2cff262005-06-21 17:17:20 -0700458 printk(KERN_DEBUG " events: %llu\n",
NeilBrown32a76272005-06-21 17:17:14 -0700459 (unsigned long long) le64_to_cpu(sb->events));
NeilBrowna2cff262005-06-21 17:17:20 -0700460 printk(KERN_DEBUG "events cleared: %llu\n",
NeilBrown32a76272005-06-21 17:17:14 -0700461 (unsigned long long) le64_to_cpu(sb->events_cleared));
NeilBrowna2cff262005-06-21 17:17:20 -0700462 printk(KERN_DEBUG " state: %08x\n", le32_to_cpu(sb->state));
463 printk(KERN_DEBUG " chunksize: %d B\n", le32_to_cpu(sb->chunksize));
464 printk(KERN_DEBUG " daemon sleep: %ds\n", le32_to_cpu(sb->daemon_sleep));
465 printk(KERN_DEBUG " sync size: %llu KB\n",
466 (unsigned long long)le64_to_cpu(sb->sync_size)/2);
NeilBrown4b6d2872005-09-09 16:23:47 -0700467 printk(KERN_DEBUG "max write behind: %d\n", le32_to_cpu(sb->write_behind));
Cong Wangb2f46e62011-11-28 13:25:44 +0800468 kunmap_atomic(sb);
NeilBrown32a76272005-06-21 17:17:14 -0700469}
470
Jonathan Brassow9c810752011-06-08 17:59:30 -0500471/*
472 * bitmap_new_disk_sb
473 * @bitmap
474 *
475 * This function is somewhat the reverse of bitmap_read_sb. bitmap_read_sb
476 * reads and verifies the on-disk bitmap superblock and populates bitmap_info.
477 * This function verifies 'bitmap_info' and populates the on-disk bitmap
478 * structure, which is to be written to disk.
479 *
480 * Returns: 0 on success, -Exxx on error
481 */
482static int bitmap_new_disk_sb(struct bitmap *bitmap)
483{
484 bitmap_super_t *sb;
485 unsigned long chunksize, daemon_sleep, write_behind;
Jonathan Brassow9c810752011-06-08 17:59:30 -0500486
NeilBrown1ec885c2012-05-22 13:55:10 +1000487 bitmap->storage.sb_page = alloc_page(GFP_KERNEL);
Jianpeng Ma582e2e02012-10-11 13:45:36 +1100488 if (bitmap->storage.sb_page == NULL)
489 return -ENOMEM;
NeilBrown1ec885c2012-05-22 13:55:10 +1000490 bitmap->storage.sb_page->index = 0;
Jonathan Brassow9c810752011-06-08 17:59:30 -0500491
NeilBrown1ec885c2012-05-22 13:55:10 +1000492 sb = kmap_atomic(bitmap->storage.sb_page);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500493
494 sb->magic = cpu_to_le32(BITMAP_MAGIC);
495 sb->version = cpu_to_le32(BITMAP_MAJOR_HI);
496
497 chunksize = bitmap->mddev->bitmap_info.chunksize;
498 BUG_ON(!chunksize);
499 if (!is_power_of_2(chunksize)) {
Cong Wangb2f46e62011-11-28 13:25:44 +0800500 kunmap_atomic(sb);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500501 printk(KERN_ERR "bitmap chunksize not a power of 2\n");
502 return -EINVAL;
503 }
504 sb->chunksize = cpu_to_le32(chunksize);
505
506 daemon_sleep = bitmap->mddev->bitmap_info.daemon_sleep;
507 if (!daemon_sleep ||
508 (daemon_sleep < 1) || (daemon_sleep > MAX_SCHEDULE_TIMEOUT)) {
509 printk(KERN_INFO "Choosing daemon_sleep default (5 sec)\n");
510 daemon_sleep = 5 * HZ;
511 }
512 sb->daemon_sleep = cpu_to_le32(daemon_sleep);
513 bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
514
515 /*
516 * FIXME: write_behind for RAID1. If not specified, what
517 * is a good choice? We choose COUNTER_MAX / 2 arbitrarily.
518 */
519 write_behind = bitmap->mddev->bitmap_info.max_write_behind;
520 if (write_behind > COUNTER_MAX)
521 write_behind = COUNTER_MAX / 2;
522 sb->write_behind = cpu_to_le32(write_behind);
523 bitmap->mddev->bitmap_info.max_write_behind = write_behind;
524
525 /* keep the array size field of the bitmap superblock up to date */
526 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
527
528 memcpy(sb->uuid, bitmap->mddev->uuid, 16);
529
NeilBrownb405fe92012-05-22 13:55:15 +1000530 set_bit(BITMAP_STALE, &bitmap->flags);
NeilBrown84e92342012-05-22 13:55:14 +1000531 sb->state = cpu_to_le32(bitmap->flags);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500532 bitmap->events_cleared = bitmap->mddev->events;
533 sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
534
Cong Wangb2f46e62011-11-28 13:25:44 +0800535 kunmap_atomic(sb);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500536
537 return 0;
538}
539
NeilBrown32a76272005-06-21 17:17:14 -0700540/* read the superblock from the bitmap file and initialize some bitmap fields */
541static int bitmap_read_sb(struct bitmap *bitmap)
542{
543 char *reason = NULL;
544 bitmap_super_t *sb;
NeilBrown4b6d2872005-09-09 16:23:47 -0700545 unsigned long chunksize, daemon_sleep, write_behind;
NeilBrown32a76272005-06-21 17:17:14 -0700546 unsigned long long events;
NeilBrown1dff2b82012-05-22 13:55:34 +1000547 unsigned long sectors_reserved = 0;
NeilBrown32a76272005-06-21 17:17:14 -0700548 int err = -EINVAL;
NeilBrown27581e52012-05-22 13:55:08 +1000549 struct page *sb_page;
NeilBrown32a76272005-06-21 17:17:14 -0700550
NeilBrown1ec885c2012-05-22 13:55:10 +1000551 if (!bitmap->storage.file && !bitmap->mddev->bitmap_info.offset) {
NeilBrownef99bf42012-05-22 13:55:08 +1000552 chunksize = 128 * 1024 * 1024;
553 daemon_sleep = 5 * HZ;
554 write_behind = 0;
NeilBrownb405fe92012-05-22 13:55:15 +1000555 set_bit(BITMAP_STALE, &bitmap->flags);
NeilBrownef99bf42012-05-22 13:55:08 +1000556 err = 0;
557 goto out_no_sb;
558 }
NeilBrown32a76272005-06-21 17:17:14 -0700559 /* page 0 is the superblock, read it... */
NeilBrown27581e52012-05-22 13:55:08 +1000560 sb_page = alloc_page(GFP_KERNEL);
561 if (!sb_page)
562 return -ENOMEM;
NeilBrown1ec885c2012-05-22 13:55:10 +1000563 bitmap->storage.sb_page = sb_page;
NeilBrown27581e52012-05-22 13:55:08 +1000564
NeilBrown1ec885c2012-05-22 13:55:10 +1000565 if (bitmap->storage.file) {
566 loff_t isize = i_size_read(bitmap->storage.file->f_mapping->host);
NeilBrownf49d5e62007-01-26 00:57:03 -0800567 int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;
568
NeilBrown1ec885c2012-05-22 13:55:10 +1000569 err = read_page(bitmap->storage.file, 0,
NeilBrown27581e52012-05-22 13:55:08 +1000570 bitmap, bytes, sb_page);
NeilBrownf49d5e62007-01-26 00:57:03 -0800571 } else {
NeilBrown27581e52012-05-22 13:55:08 +1000572 err = read_sb_page(bitmap->mddev,
573 bitmap->mddev->bitmap_info.offset,
574 sb_page,
575 0, sizeof(bitmap_super_t));
NeilBrowna654b9d82005-06-21 17:17:27 -0700576 }
NeilBrown27581e52012-05-22 13:55:08 +1000577 if (err)
NeilBrown32a76272005-06-21 17:17:14 -0700578 return err;
NeilBrown32a76272005-06-21 17:17:14 -0700579
NeilBrown27581e52012-05-22 13:55:08 +1000580 sb = kmap_atomic(sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700581
NeilBrown32a76272005-06-21 17:17:14 -0700582 chunksize = le32_to_cpu(sb->chunksize);
NeilBrown1b04be92009-12-14 12:49:53 +1100583 daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
NeilBrown4b6d2872005-09-09 16:23:47 -0700584 write_behind = le32_to_cpu(sb->write_behind);
NeilBrown1dff2b82012-05-22 13:55:34 +1000585 sectors_reserved = le32_to_cpu(sb->sectors_reserved);
NeilBrown32a76272005-06-21 17:17:14 -0700586
587 /* verify that the bitmap-specific fields are valid */
588 if (sb->magic != cpu_to_le32(BITMAP_MAGIC))
589 reason = "bad magic";
NeilBrownbd926c62005-11-08 21:39:32 -0800590 else if (le32_to_cpu(sb->version) < BITMAP_MAJOR_LO ||
591 le32_to_cpu(sb->version) > BITMAP_MAJOR_HI)
NeilBrown32a76272005-06-21 17:17:14 -0700592 reason = "unrecognized superblock version";
NeilBrown1187cf02009-03-31 14:27:02 +1100593 else if (chunksize < 512)
NeilBrown7dd5d342006-01-06 00:20:39 -0800594 reason = "bitmap chunksize too small";
Jonathan Brassowd7445402011-06-08 18:01:10 -0500595 else if (!is_power_of_2(chunksize))
NeilBrown32a76272005-06-21 17:17:14 -0700596 reason = "bitmap chunksize not a power of 2";
NeilBrown1b04be92009-12-14 12:49:53 +1100597 else if (daemon_sleep < 1 || daemon_sleep > MAX_SCHEDULE_TIMEOUT)
NeilBrown7dd5d342006-01-06 00:20:39 -0800598 reason = "daemon sleep period out of range";
NeilBrown4b6d2872005-09-09 16:23:47 -0700599 else if (write_behind > COUNTER_MAX)
600 reason = "write-behind limit out of range (0 - 16383)";
NeilBrown32a76272005-06-21 17:17:14 -0700601 if (reason) {
602 printk(KERN_INFO "%s: invalid bitmap file superblock: %s\n",
603 bmname(bitmap), reason);
604 goto out;
605 }
606
607 /* keep the array size field of the bitmap superblock up to date */
608 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
609
NeilBrown278c1ca2012-03-19 12:46:40 +1100610 if (bitmap->mddev->persistent) {
611 /*
612 * We have a persistent array superblock, so compare the
613 * bitmap's UUID and event counter to the mddev's
614 */
615 if (memcmp(sb->uuid, bitmap->mddev->uuid, 16)) {
616 printk(KERN_INFO
617 "%s: bitmap superblock UUID mismatch\n",
618 bmname(bitmap));
619 goto out;
620 }
621 events = le64_to_cpu(sb->events);
622 if (events < bitmap->mddev->events) {
623 printk(KERN_INFO
624 "%s: bitmap file is out of date (%llu < %llu) "
625 "-- forcing full recovery\n",
626 bmname(bitmap), events,
627 (unsigned long long) bitmap->mddev->events);
NeilBrownb405fe92012-05-22 13:55:15 +1000628 set_bit(BITMAP_STALE, &bitmap->flags);
NeilBrown278c1ca2012-03-19 12:46:40 +1100629 }
630 }
NeilBrown32a76272005-06-21 17:17:14 -0700631
NeilBrown32a76272005-06-21 17:17:14 -0700632 /* assign fields using values from superblock */
NeilBrown4f2e6392006-10-21 10:24:09 -0700633 bitmap->flags |= le32_to_cpu(sb->state);
NeilBrownbd926c62005-11-08 21:39:32 -0800634 if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)
NeilBrownb405fe92012-05-22 13:55:15 +1000635 set_bit(BITMAP_HOSTENDIAN, &bitmap->flags);
NeilBrown32a76272005-06-21 17:17:14 -0700636 bitmap->events_cleared = le64_to_cpu(sb->events_cleared);
637 err = 0;
638out:
Cong Wangb2f46e62011-11-28 13:25:44 +0800639 kunmap_atomic(sb);
NeilBrownef99bf42012-05-22 13:55:08 +1000640out_no_sb:
NeilBrownb405fe92012-05-22 13:55:15 +1000641 if (test_bit(BITMAP_STALE, &bitmap->flags))
NeilBrownef99bf42012-05-22 13:55:08 +1000642 bitmap->events_cleared = bitmap->mddev->events;
643 bitmap->mddev->bitmap_info.chunksize = chunksize;
644 bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
645 bitmap->mddev->bitmap_info.max_write_behind = write_behind;
NeilBrown1dff2b82012-05-22 13:55:34 +1000646 if (bitmap->mddev->bitmap_info.space == 0 ||
647 bitmap->mddev->bitmap_info.space > sectors_reserved)
648 bitmap->mddev->bitmap_info.space = sectors_reserved;
NeilBrown32a76272005-06-21 17:17:14 -0700649 if (err)
650 bitmap_print_sb(bitmap);
651 return err;
652}
653
NeilBrown32a76272005-06-21 17:17:14 -0700654/*
655 * general bitmap file operations
656 */
657
NeilBrownece5cff2009-12-14 12:49:56 +1100658/*
659 * on-disk bitmap:
660 *
661 * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap
662 * file a page at a time. There's a superblock at the start of the file.
663 */
NeilBrown32a76272005-06-21 17:17:14 -0700664/* calculate the index of the page that contains this bit */
NeilBrown1ec885c2012-05-22 13:55:10 +1000665static inline unsigned long file_page_index(struct bitmap_storage *store,
666 unsigned long chunk)
NeilBrown32a76272005-06-21 17:17:14 -0700667{
NeilBrown1ec885c2012-05-22 13:55:10 +1000668 if (store->sb_page)
NeilBrownece5cff2009-12-14 12:49:56 +1100669 chunk += sizeof(bitmap_super_t) << 3;
670 return chunk >> PAGE_BIT_SHIFT;
NeilBrown32a76272005-06-21 17:17:14 -0700671}
672
673/* calculate the (bit) offset of this bit within a page */
NeilBrown1ec885c2012-05-22 13:55:10 +1000674static inline unsigned long file_page_offset(struct bitmap_storage *store,
675 unsigned long chunk)
NeilBrown32a76272005-06-21 17:17:14 -0700676{
NeilBrown1ec885c2012-05-22 13:55:10 +1000677 if (store->sb_page)
NeilBrownece5cff2009-12-14 12:49:56 +1100678 chunk += sizeof(bitmap_super_t) << 3;
679 return chunk & (PAGE_BITS - 1);
NeilBrown32a76272005-06-21 17:17:14 -0700680}
681
682/*
683 * return a pointer to the page in the filemap that contains the given bit
684 *
NeilBrown32a76272005-06-21 17:17:14 -0700685 */
NeilBrown1ec885c2012-05-22 13:55:10 +1000686static inline struct page *filemap_get_page(struct bitmap_storage *store,
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000687 unsigned long chunk)
NeilBrown32a76272005-06-21 17:17:14 -0700688{
NeilBrown1ec885c2012-05-22 13:55:10 +1000689 if (file_page_index(store, chunk) >= store->file_pages)
NeilBrownac2f40b2010-06-01 19:37:31 +1000690 return NULL;
NeilBrownf2e06c52014-05-28 13:39:23 +1000691 return store->filemap[file_page_index(store, chunk)];
NeilBrown32a76272005-06-21 17:17:14 -0700692}
693
NeilBrownd1244cb2012-05-22 13:55:12 +1000694static int bitmap_storage_alloc(struct bitmap_storage *store,
695 unsigned long chunks, int with_super)
696{
697 int pnum;
698 unsigned long num_pages;
699 unsigned long bytes;
700
701 bytes = DIV_ROUND_UP(chunks, 8);
702 if (with_super)
703 bytes += sizeof(bitmap_super_t);
704
705 num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE);
706
707 store->filemap = kmalloc(sizeof(struct page *)
708 * num_pages, GFP_KERNEL);
709 if (!store->filemap)
710 return -ENOMEM;
711
712 if (with_super && !store->sb_page) {
NeilBrownd60b4792012-05-22 13:55:25 +1000713 store->sb_page = alloc_page(GFP_KERNEL|__GFP_ZERO);
NeilBrownd1244cb2012-05-22 13:55:12 +1000714 if (store->sb_page == NULL)
715 return -ENOMEM;
716 store->sb_page->index = 0;
717 }
718 pnum = 0;
719 if (store->sb_page) {
720 store->filemap[0] = store->sb_page;
721 pnum = 1;
722 }
723 for ( ; pnum < num_pages; pnum++) {
NeilBrownd60b4792012-05-22 13:55:25 +1000724 store->filemap[pnum] = alloc_page(GFP_KERNEL|__GFP_ZERO);
NeilBrownd1244cb2012-05-22 13:55:12 +1000725 if (!store->filemap[pnum]) {
726 store->file_pages = pnum;
727 return -ENOMEM;
728 }
729 store->filemap[pnum]->index = pnum;
730 }
731 store->file_pages = pnum;
732
733 /* We need 4 bits per page, rounded up to a multiple
734 * of sizeof(unsigned long) */
735 store->filemap_attr = kzalloc(
736 roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
737 GFP_KERNEL);
738 if (!store->filemap_attr)
739 return -ENOMEM;
740
741 store->bytes = bytes;
742
743 return 0;
744}
745
NeilBrownfae7d322012-05-22 13:55:21 +1000746static void bitmap_file_unmap(struct bitmap_storage *store)
NeilBrown32a76272005-06-21 17:17:14 -0700747{
748 struct page **map, *sb_page;
NeilBrown32a76272005-06-21 17:17:14 -0700749 int pages;
NeilBrownfae7d322012-05-22 13:55:21 +1000750 struct file *file;
NeilBrown32a76272005-06-21 17:17:14 -0700751
NeilBrownfae7d322012-05-22 13:55:21 +1000752 file = store->file;
NeilBrown1ec885c2012-05-22 13:55:10 +1000753 map = store->filemap;
NeilBrown1ec885c2012-05-22 13:55:10 +1000754 pages = store->file_pages;
NeilBrown1ec885c2012-05-22 13:55:10 +1000755 sb_page = store->sb_page;
NeilBrown32a76272005-06-21 17:17:14 -0700756
757 while (pages--)
NeilBrownece5cff2009-12-14 12:49:56 +1100758 if (map[pages] != sb_page) /* 0 is sb_page, release it below */
NeilBrownd785a062006-06-26 00:27:48 -0700759 free_buffers(map[pages]);
NeilBrown32a76272005-06-21 17:17:14 -0700760 kfree(map);
NeilBrownfae7d322012-05-22 13:55:21 +1000761 kfree(store->filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700762
NeilBrownd785a062006-06-26 00:27:48 -0700763 if (sb_page)
764 free_buffers(sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700765
NeilBrownd785a062006-06-26 00:27:48 -0700766 if (file) {
Al Viro496ad9a2013-01-23 17:07:38 -0500767 struct inode *inode = file_inode(file);
Andrew Mortonfc0ecff2007-02-10 01:45:39 -0800768 invalidate_mapping_pages(inode->i_mapping, 0, -1);
NeilBrown32a76272005-06-21 17:17:14 -0700769 fput(file);
NeilBrownd785a062006-06-26 00:27:48 -0700770 }
NeilBrown32a76272005-06-21 17:17:14 -0700771}
772
NeilBrown32a76272005-06-21 17:17:14 -0700773/*
774 * bitmap_file_kick - if an error occurs while manipulating the bitmap file
775 * then it is no longer reliable, so we stop using it and we mark the file
776 * as failed in the superblock
777 */
778static void bitmap_file_kick(struct bitmap *bitmap)
779{
780 char *path, *ptr = NULL;
781
NeilBrownb405fe92012-05-22 13:55:15 +1000782 if (!test_and_set_bit(BITMAP_STALE, &bitmap->flags)) {
NeilBrown4ad13662007-07-17 04:06:13 -0700783 bitmap_update_sb(bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700784
NeilBrown1ec885c2012-05-22 13:55:10 +1000785 if (bitmap->storage.file) {
NeilBrown4ad13662007-07-17 04:06:13 -0700786 path = kmalloc(PAGE_SIZE, GFP_KERNEL);
787 if (path)
NeilBrown1ec885c2012-05-22 13:55:10 +1000788 ptr = d_path(&bitmap->storage.file->f_path,
789 path, PAGE_SIZE);
Christoph Hellwig6bcfd602008-05-23 13:04:34 -0700790
NeilBrown4ad13662007-07-17 04:06:13 -0700791 printk(KERN_ALERT
792 "%s: kicking failed bitmap file %s from array!\n",
Christoph Hellwig6bcfd602008-05-23 13:04:34 -0700793 bmname(bitmap), IS_ERR(ptr) ? "" : ptr);
NeilBrown32a76272005-06-21 17:17:14 -0700794
NeilBrown4ad13662007-07-17 04:06:13 -0700795 kfree(path);
796 } else
797 printk(KERN_ALERT
798 "%s: disabling internal bitmap due to errors\n",
799 bmname(bitmap));
NeilBrowna654b9d82005-06-21 17:17:27 -0700800 }
NeilBrown32a76272005-06-21 17:17:14 -0700801}
802
803enum bitmap_page_attr {
NeilBrownac2f40b2010-06-01 19:37:31 +1000804 BITMAP_PAGE_DIRTY = 0, /* there are set bits that need to be synced */
NeilBrown5a537df2011-09-21 15:37:46 +1000805 BITMAP_PAGE_PENDING = 1, /* there are bits that are being cleaned.
806 * i.e. counter is 1 or 2. */
NeilBrownac2f40b2010-06-01 19:37:31 +1000807 BITMAP_PAGE_NEEDWRITE = 2, /* there are cleared bits that need to be synced */
NeilBrown32a76272005-06-21 17:17:14 -0700808};
809
NeilBrownd1891222012-05-22 13:55:09 +1000810static inline void set_page_attr(struct bitmap *bitmap, int pnum,
811 enum bitmap_page_attr attr)
NeilBrown32a76272005-06-21 17:17:14 -0700812{
NeilBrownbdfd1142012-05-22 13:55:22 +1000813 set_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700814}
815
NeilBrownd1891222012-05-22 13:55:09 +1000816static inline void clear_page_attr(struct bitmap *bitmap, int pnum,
817 enum bitmap_page_attr attr)
NeilBrown32a76272005-06-21 17:17:14 -0700818{
NeilBrownbdfd1142012-05-22 13:55:22 +1000819 clear_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700820}
821
NeilBrownbdfd1142012-05-22 13:55:22 +1000822static inline int test_page_attr(struct bitmap *bitmap, int pnum,
823 enum bitmap_page_attr attr)
NeilBrown32a76272005-06-21 17:17:14 -0700824{
NeilBrown1ec885c2012-05-22 13:55:10 +1000825 return test_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700826}
827
NeilBrownbdfd1142012-05-22 13:55:22 +1000828static inline int test_and_clear_page_attr(struct bitmap *bitmap, int pnum,
829 enum bitmap_page_attr attr)
830{
831 return test_and_clear_bit((pnum<<2) + attr,
832 bitmap->storage.filemap_attr);
833}
NeilBrown32a76272005-06-21 17:17:14 -0700834/*
835 * bitmap_file_set_bit -- called before performing a write to the md device
836 * to set (and eventually sync) a particular bit in the bitmap file
837 *
838 * we set the bit immediately, then we record the page number so that
839 * when an unplug occurs, we can flush the dirty pages out to disk
840 */
841static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
842{
843 unsigned long bit;
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000844 struct page *page;
NeilBrown32a76272005-06-21 17:17:14 -0700845 void *kaddr;
NeilBrown40cffcc2012-05-22 13:55:24 +1000846 unsigned long chunk = block >> bitmap->counts.chunkshift;
NeilBrown32a76272005-06-21 17:17:14 -0700847
NeilBrown1ec885c2012-05-22 13:55:10 +1000848 page = filemap_get_page(&bitmap->storage, chunk);
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000849 if (!page)
850 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000851 bit = file_page_offset(&bitmap->storage, chunk);
NeilBrown32a76272005-06-21 17:17:14 -0700852
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000853 /* set the bit */
Cong Wangb2f46e62011-11-28 13:25:44 +0800854 kaddr = kmap_atomic(page);
NeilBrownb405fe92012-05-22 13:55:15 +1000855 if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000856 set_bit(bit, kaddr);
857 else
Akinobu Mita3f810b62013-04-24 11:42:41 +1000858 set_bit_le(bit, kaddr);
Cong Wangb2f46e62011-11-28 13:25:44 +0800859 kunmap_atomic(kaddr);
NeilBrown36a4e1f2011-10-07 14:23:17 +1100860 pr_debug("set file bit %lu page %lu\n", bit, page->index);
NeilBrown32a76272005-06-21 17:17:14 -0700861 /* record page number so it gets flushed to disk when unplug occurs */
NeilBrownd1891222012-05-22 13:55:09 +1000862 set_page_attr(bitmap, page->index, BITMAP_PAGE_DIRTY);
NeilBrown32a76272005-06-21 17:17:14 -0700863}
864
NeilBrownef99bf42012-05-22 13:55:08 +1000865static void bitmap_file_clear_bit(struct bitmap *bitmap, sector_t block)
866{
867 unsigned long bit;
868 struct page *page;
869 void *paddr;
NeilBrown40cffcc2012-05-22 13:55:24 +1000870 unsigned long chunk = block >> bitmap->counts.chunkshift;
NeilBrownef99bf42012-05-22 13:55:08 +1000871
NeilBrown1ec885c2012-05-22 13:55:10 +1000872 page = filemap_get_page(&bitmap->storage, chunk);
NeilBrownef99bf42012-05-22 13:55:08 +1000873 if (!page)
874 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000875 bit = file_page_offset(&bitmap->storage, chunk);
NeilBrownef99bf42012-05-22 13:55:08 +1000876 paddr = kmap_atomic(page);
NeilBrownb405fe92012-05-22 13:55:15 +1000877 if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))
NeilBrownef99bf42012-05-22 13:55:08 +1000878 clear_bit(bit, paddr);
879 else
Akinobu Mita3f810b62013-04-24 11:42:41 +1000880 clear_bit_le(bit, paddr);
NeilBrownef99bf42012-05-22 13:55:08 +1000881 kunmap_atomic(paddr);
NeilBrownd1891222012-05-22 13:55:09 +1000882 if (!test_page_attr(bitmap, page->index, BITMAP_PAGE_NEEDWRITE)) {
883 set_page_attr(bitmap, page->index, BITMAP_PAGE_PENDING);
NeilBrownef99bf42012-05-22 13:55:08 +1000884 bitmap->allclean = 0;
885 }
886}
887
NeilBrown32a76272005-06-21 17:17:14 -0700888/* this gets called when the md device is ready to unplug its underlying
889 * (slave) device queues -- before we let any writes go down, we need to
890 * sync the dirty pages of the bitmap file to disk */
NeilBrown4ad13662007-07-17 04:06:13 -0700891void bitmap_unplug(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -0700892{
NeilBrown74667122012-05-22 13:55:19 +1000893 unsigned long i;
NeilBrownec7a3192006-06-26 00:27:45 -0700894 int dirty, need_write;
NeilBrown32a76272005-06-21 17:17:14 -0700895
NeilBrown62f82fa2012-05-22 13:55:21 +1000896 if (!bitmap || !bitmap->storage.filemap ||
897 test_bit(BITMAP_STALE, &bitmap->flags))
NeilBrown4ad13662007-07-17 04:06:13 -0700898 return;
NeilBrown32a76272005-06-21 17:17:14 -0700899
900 /* look at each page to see if there are any set bits that need to be
901 * flushed out to disk */
NeilBrown1ec885c2012-05-22 13:55:10 +1000902 for (i = 0; i < bitmap->storage.file_pages; i++) {
NeilBrownbdfd1142012-05-22 13:55:22 +1000903 if (!bitmap->storage.filemap)
NeilBrown4ad13662007-07-17 04:06:13 -0700904 return;
NeilBrownbdfd1142012-05-22 13:55:22 +1000905 dirty = test_and_clear_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);
906 need_write = test_and_clear_page_attr(bitmap, i,
907 BITMAP_PAGE_NEEDWRITE);
908 if (dirty || need_write) {
NeilBrownd1891222012-05-22 13:55:09 +1000909 clear_page_attr(bitmap, i, BITMAP_PAGE_PENDING);
NeilBrownbdfd1142012-05-22 13:55:22 +1000910 write_page(bitmap, bitmap->storage.filemap[i], 0);
911 }
NeilBrown32a76272005-06-21 17:17:14 -0700912 }
NeilBrown4b5060d2014-09-09 14:13:51 +1000913 if (bitmap->storage.file)
914 wait_event(bitmap->write_wait,
915 atomic_read(&bitmap->pending_writes)==0);
916 else
917 md_super_wait(bitmap->mddev);
918
NeilBrownb405fe92012-05-22 13:55:15 +1000919 if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))
NeilBrownd785a062006-06-26 00:27:48 -0700920 bitmap_file_kick(bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700921}
NeilBrownac2f40b2010-06-01 19:37:31 +1000922EXPORT_SYMBOL(bitmap_unplug);
NeilBrown32a76272005-06-21 17:17:14 -0700923
NeilBrown6a079972005-09-09 16:23:44 -0700924static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed);
NeilBrown32a76272005-06-21 17:17:14 -0700925/* * bitmap_init_from_disk -- called at bitmap_create time to initialize
926 * the in-memory bitmap from the on-disk bitmap -- also, sets up the
927 * memory mapping of the bitmap file
928 * Special cases:
929 * if there's no bitmap file, or if the bitmap file had been
930 * previously kicked from the array, we mark all the bits as
931 * 1's in order to cause a full resync.
NeilBrown6a079972005-09-09 16:23:44 -0700932 *
933 * We ignore all bits for sectors that end earlier than 'start'.
934 * This is used when reading an out-of-date bitmap...
NeilBrown32a76272005-06-21 17:17:14 -0700935 */
NeilBrown6a079972005-09-09 16:23:44 -0700936static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
NeilBrown32a76272005-06-21 17:17:14 -0700937{
938 unsigned long i, chunks, index, oldindex, bit;
NeilBrown27581e52012-05-22 13:55:08 +1000939 struct page *page = NULL;
NeilBrownd1244cb2012-05-22 13:55:12 +1000940 unsigned long bit_cnt = 0;
NeilBrown32a76272005-06-21 17:17:14 -0700941 struct file *file;
NeilBrownd1244cb2012-05-22 13:55:12 +1000942 unsigned long offset;
NeilBrown32a76272005-06-21 17:17:14 -0700943 int outofdate;
944 int ret = -ENOSPC;
NeilBrownea03aff2006-01-06 00:20:34 -0800945 void *paddr;
NeilBrown1ec885c2012-05-22 13:55:10 +1000946 struct bitmap_storage *store = &bitmap->storage;
NeilBrown32a76272005-06-21 17:17:14 -0700947
NeilBrown40cffcc2012-05-22 13:55:24 +1000948 chunks = bitmap->counts.chunks;
NeilBrown1ec885c2012-05-22 13:55:10 +1000949 file = store->file;
NeilBrown32a76272005-06-21 17:17:14 -0700950
NeilBrownef99bf42012-05-22 13:55:08 +1000951 if (!file && !bitmap->mddev->bitmap_info.offset) {
952 /* No permanent bitmap - fill with '1s'. */
NeilBrown1ec885c2012-05-22 13:55:10 +1000953 store->filemap = NULL;
954 store->file_pages = 0;
NeilBrownef99bf42012-05-22 13:55:08 +1000955 for (i = 0; i < chunks ; i++) {
956 /* if the disk bit is set, set the memory bit */
NeilBrown40cffcc2012-05-22 13:55:24 +1000957 int needed = ((sector_t)(i+1) << (bitmap->counts.chunkshift)
NeilBrownef99bf42012-05-22 13:55:08 +1000958 >= start);
959 bitmap_set_memory_bits(bitmap,
NeilBrown40cffcc2012-05-22 13:55:24 +1000960 (sector_t)i << bitmap->counts.chunkshift,
NeilBrownef99bf42012-05-22 13:55:08 +1000961 needed);
962 }
963 return 0;
964 }
NeilBrown32a76272005-06-21 17:17:14 -0700965
NeilBrownb405fe92012-05-22 13:55:15 +1000966 outofdate = test_bit(BITMAP_STALE, &bitmap->flags);
NeilBrown32a76272005-06-21 17:17:14 -0700967 if (outofdate)
968 printk(KERN_INFO "%s: bitmap file is out of date, doing full "
969 "recovery\n", bmname(bitmap));
970
NeilBrownd1244cb2012-05-22 13:55:12 +1000971 if (file && i_size_read(file->f_mapping->host) < store->bytes) {
NeilBrown32a76272005-06-21 17:17:14 -0700972 printk(KERN_INFO "%s: bitmap file too short %lu < %lu\n",
NeilBrownd1244cb2012-05-22 13:55:12 +1000973 bmname(bitmap),
974 (unsigned long) i_size_read(file->f_mapping->host),
975 store->bytes);
NeilBrown4ad13662007-07-17 04:06:13 -0700976 goto err;
NeilBrown32a76272005-06-21 17:17:14 -0700977 }
NeilBrownbc7f77d2005-06-21 17:17:17 -0700978
NeilBrown32a76272005-06-21 17:17:14 -0700979 oldindex = ~0L;
NeilBrownd1244cb2012-05-22 13:55:12 +1000980 offset = 0;
981 if (!bitmap->mddev->bitmap_info.external)
982 offset = sizeof(bitmap_super_t);
NeilBrown32a76272005-06-21 17:17:14 -0700983
984 for (i = 0; i < chunks; i++) {
NeilBrownbd926c62005-11-08 21:39:32 -0800985 int b;
NeilBrown1ec885c2012-05-22 13:55:10 +1000986 index = file_page_index(&bitmap->storage, i);
987 bit = file_page_offset(&bitmap->storage, i);
NeilBrown32a76272005-06-21 17:17:14 -0700988 if (index != oldindex) { /* this is a new page, read it in */
NeilBrownd785a062006-06-26 00:27:48 -0700989 int count;
NeilBrown32a76272005-06-21 17:17:14 -0700990 /* unmap the old page, we're done with it */
NeilBrownd1244cb2012-05-22 13:55:12 +1000991 if (index == store->file_pages-1)
992 count = store->bytes - index * PAGE_SIZE;
NeilBrownd785a062006-06-26 00:27:48 -0700993 else
994 count = PAGE_SIZE;
NeilBrown1ec885c2012-05-22 13:55:10 +1000995 page = store->filemap[index];
NeilBrown27581e52012-05-22 13:55:08 +1000996 if (file)
997 ret = read_page(file, index, bitmap,
998 count, page);
999 else
1000 ret = read_sb_page(
1001 bitmap->mddev,
1002 bitmap->mddev->bitmap_info.offset,
1003 page,
1004 index, count);
1005
1006 if (ret)
NeilBrown4ad13662007-07-17 04:06:13 -07001007 goto err;
NeilBrowna654b9d82005-06-21 17:17:27 -07001008
NeilBrown32a76272005-06-21 17:17:14 -07001009 oldindex = index;
NeilBrown32a76272005-06-21 17:17:14 -07001010
1011 if (outofdate) {
1012 /*
1013 * if bitmap is out of date, dirty the
NeilBrownac2f40b2010-06-01 19:37:31 +10001014 * whole page and write it out
NeilBrown32a76272005-06-21 17:17:14 -07001015 */
Cong Wangb2f46e62011-11-28 13:25:44 +08001016 paddr = kmap_atomic(page);
NeilBrownea03aff2006-01-06 00:20:34 -08001017 memset(paddr + offset, 0xff,
NeilBrown6a079972005-09-09 16:23:44 -07001018 PAGE_SIZE - offset);
Cong Wangb2f46e62011-11-28 13:25:44 +08001019 kunmap_atomic(paddr);
NeilBrown4ad13662007-07-17 04:06:13 -07001020 write_page(bitmap, page, 1);
1021
1022 ret = -EIO;
NeilBrownb405fe92012-05-22 13:55:15 +10001023 if (test_bit(BITMAP_WRITE_ERROR,
1024 &bitmap->flags))
NeilBrown4ad13662007-07-17 04:06:13 -07001025 goto err;
NeilBrown32a76272005-06-21 17:17:14 -07001026 }
NeilBrown32a76272005-06-21 17:17:14 -07001027 }
Cong Wangb2f46e62011-11-28 13:25:44 +08001028 paddr = kmap_atomic(page);
NeilBrownb405fe92012-05-22 13:55:15 +10001029 if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))
NeilBrownea03aff2006-01-06 00:20:34 -08001030 b = test_bit(bit, paddr);
NeilBrownbd926c62005-11-08 21:39:32 -08001031 else
Akinobu Mita6b33aff2011-03-23 16:42:13 -07001032 b = test_bit_le(bit, paddr);
Cong Wangb2f46e62011-11-28 13:25:44 +08001033 kunmap_atomic(paddr);
NeilBrownbd926c62005-11-08 21:39:32 -08001034 if (b) {
NeilBrown32a76272005-06-21 17:17:14 -07001035 /* if the disk bit is set, set the memory bit */
NeilBrown40cffcc2012-05-22 13:55:24 +10001036 int needed = ((sector_t)(i+1) << bitmap->counts.chunkshift
NeilBrowndb305e52009-05-07 12:49:06 +10001037 >= start);
1038 bitmap_set_memory_bits(bitmap,
NeilBrown40cffcc2012-05-22 13:55:24 +10001039 (sector_t)i << bitmap->counts.chunkshift,
NeilBrowndb305e52009-05-07 12:49:06 +10001040 needed);
NeilBrown32a76272005-06-21 17:17:14 -07001041 bit_cnt++;
1042 }
NeilBrown27581e52012-05-22 13:55:08 +10001043 offset = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001044 }
1045
NeilBrown32a76272005-06-21 17:17:14 -07001046 printk(KERN_INFO "%s: bitmap initialized from disk: "
NeilBrownd1244cb2012-05-22 13:55:12 +10001047 "read %lu pages, set %lu of %lu bits\n",
NeilBrown1ec885c2012-05-22 13:55:10 +10001048 bmname(bitmap), store->file_pages,
NeilBrownd1244cb2012-05-22 13:55:12 +10001049 bit_cnt, chunks);
NeilBrown32a76272005-06-21 17:17:14 -07001050
NeilBrown4ad13662007-07-17 04:06:13 -07001051 return 0;
1052
1053 err:
1054 printk(KERN_INFO "%s: bitmap initialisation failed: %d\n",
1055 bmname(bitmap), ret);
NeilBrown32a76272005-06-21 17:17:14 -07001056 return ret;
1057}
1058
NeilBrowna654b9d82005-06-21 17:17:27 -07001059void bitmap_write_all(struct bitmap *bitmap)
1060{
1061 /* We don't actually write all bitmap blocks here,
1062 * just flag them as needing to be written
1063 */
NeilBrownec7a3192006-06-26 00:27:45 -07001064 int i;
NeilBrowna654b9d82005-06-21 17:17:27 -07001065
NeilBrown1ec885c2012-05-22 13:55:10 +10001066 if (!bitmap || !bitmap->storage.filemap)
NeilBrownef99bf42012-05-22 13:55:08 +10001067 return;
NeilBrown1ec885c2012-05-22 13:55:10 +10001068 if (bitmap->storage.file)
NeilBrownef99bf42012-05-22 13:55:08 +10001069 /* Only one copy, so nothing needed */
1070 return;
1071
NeilBrown1ec885c2012-05-22 13:55:10 +10001072 for (i = 0; i < bitmap->storage.file_pages; i++)
NeilBrownd1891222012-05-22 13:55:09 +10001073 set_page_attr(bitmap, i,
NeilBrownec7a3192006-06-26 00:27:45 -07001074 BITMAP_PAGE_NEEDWRITE);
NeilBrown2585f3e2011-09-21 15:37:46 +10001075 bitmap->allclean = 0;
NeilBrowna654b9d82005-06-21 17:17:27 -07001076}
1077
NeilBrown40cffcc2012-05-22 13:55:24 +10001078static void bitmap_count_page(struct bitmap_counts *bitmap,
1079 sector_t offset, int inc)
NeilBrown32a76272005-06-21 17:17:14 -07001080{
NeilBrown61a0d802012-03-19 12:46:41 +11001081 sector_t chunk = offset >> bitmap->chunkshift;
NeilBrown32a76272005-06-21 17:17:14 -07001082 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1083 bitmap->bp[page].count += inc;
NeilBrown32a76272005-06-21 17:17:14 -07001084 bitmap_checkfree(bitmap, page);
1085}
NeilBrownbf07bb72012-05-22 13:55:06 +10001086
NeilBrown40cffcc2012-05-22 13:55:24 +10001087static void bitmap_set_pending(struct bitmap_counts *bitmap, sector_t offset)
NeilBrownbf07bb72012-05-22 13:55:06 +10001088{
1089 sector_t chunk = offset >> bitmap->chunkshift;
1090 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1091 struct bitmap_page *bp = &bitmap->bp[page];
1092
1093 if (!bp->pending)
1094 bp->pending = 1;
1095}
1096
NeilBrown40cffcc2012-05-22 13:55:24 +10001097static bitmap_counter_t *bitmap_get_counter(struct bitmap_counts *bitmap,
NeilBrown57dab0b2010-10-19 10:03:39 +11001098 sector_t offset, sector_t *blocks,
NeilBrown32a76272005-06-21 17:17:14 -07001099 int create);
1100
1101/*
1102 * bitmap daemon -- periodically wakes up to clean bits and flush pages
1103 * out to disk
1104 */
1105
NeilBrownfd01b882011-10-11 16:47:53 +11001106void bitmap_daemon_work(struct mddev *mddev)
NeilBrown32a76272005-06-21 17:17:14 -07001107{
NeilBrownaa5cbd12009-12-14 12:49:46 +11001108 struct bitmap *bitmap;
NeilBrownaa3163f2005-06-21 17:17:22 -07001109 unsigned long j;
NeilBrownbf07bb72012-05-22 13:55:06 +10001110 unsigned long nextpage;
NeilBrown57dab0b2010-10-19 10:03:39 +11001111 sector_t blocks;
NeilBrown40cffcc2012-05-22 13:55:24 +10001112 struct bitmap_counts *counts;
NeilBrown32a76272005-06-21 17:17:14 -07001113
NeilBrownaa5cbd12009-12-14 12:49:46 +11001114 /* Use a mutex to guard daemon_work against
1115 * bitmap_destroy.
1116 */
NeilBrownc3d97142009-12-14 12:49:52 +11001117 mutex_lock(&mddev->bitmap_info.mutex);
NeilBrownaa5cbd12009-12-14 12:49:46 +11001118 bitmap = mddev->bitmap;
1119 if (bitmap == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001120 mutex_unlock(&mddev->bitmap_info.mutex);
NeilBrown4ad13662007-07-17 04:06:13 -07001121 return;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001122 }
NeilBrown42a04b52009-12-14 12:49:53 +11001123 if (time_before(jiffies, bitmap->daemon_lastrun
NeilBrown2e61ebb2011-12-23 10:17:50 +11001124 + mddev->bitmap_info.daemon_sleep))
NeilBrown7be3dfe2008-03-10 11:43:48 -07001125 goto done;
1126
NeilBrown32a76272005-06-21 17:17:14 -07001127 bitmap->daemon_lastrun = jiffies;
NeilBrown8311c292008-03-04 14:29:30 -08001128 if (bitmap->allclean) {
NeilBrown2e61ebb2011-12-23 10:17:50 +11001129 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001130 goto done;
NeilBrown8311c292008-03-04 14:29:30 -08001131 }
1132 bitmap->allclean = 1;
NeilBrown32a76272005-06-21 17:17:14 -07001133
NeilBrownbf07bb72012-05-22 13:55:06 +10001134 /* Any file-page which is PENDING now needs to be written.
1135 * So set NEEDWRITE now, then after we make any last-minute changes
1136 * we will write it.
1137 */
NeilBrown1ec885c2012-05-22 13:55:10 +10001138 for (j = 0; j < bitmap->storage.file_pages; j++)
NeilBrownbdfd1142012-05-22 13:55:22 +10001139 if (test_and_clear_page_attr(bitmap, j,
1140 BITMAP_PAGE_PENDING))
NeilBrownd1891222012-05-22 13:55:09 +10001141 set_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001142 BITMAP_PAGE_NEEDWRITE);
NeilBrownbf07bb72012-05-22 13:55:06 +10001143
1144 if (bitmap->need_sync &&
1145 mddev->bitmap_info.external == 0) {
1146 /* Arrange for superblock update as well as
1147 * other changes */
1148 bitmap_super_t *sb;
1149 bitmap->need_sync = 0;
NeilBrown1ec885c2012-05-22 13:55:10 +10001150 if (bitmap->storage.filemap) {
1151 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrownef99bf42012-05-22 13:55:08 +10001152 sb->events_cleared =
1153 cpu_to_le64(bitmap->events_cleared);
1154 kunmap_atomic(sb);
NeilBrownd1891222012-05-22 13:55:09 +10001155 set_page_attr(bitmap, 0,
NeilBrownef99bf42012-05-22 13:55:08 +10001156 BITMAP_PAGE_NEEDWRITE);
1157 }
NeilBrownbf07bb72012-05-22 13:55:06 +10001158 }
1159 /* Now look at the bitmap counters and if any are '2' or '1',
1160 * decrement and handle accordingly.
1161 */
NeilBrown40cffcc2012-05-22 13:55:24 +10001162 counts = &bitmap->counts;
1163 spin_lock_irq(&counts->lock);
NeilBrownbf07bb72012-05-22 13:55:06 +10001164 nextpage = 0;
NeilBrown40cffcc2012-05-22 13:55:24 +10001165 for (j = 0; j < counts->chunks; j++) {
NeilBrown32a76272005-06-21 17:17:14 -07001166 bitmap_counter_t *bmc;
NeilBrown40cffcc2012-05-22 13:55:24 +10001167 sector_t block = (sector_t)j << counts->chunkshift;
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001168
NeilBrownbf07bb72012-05-22 13:55:06 +10001169 if (j == nextpage) {
1170 nextpage += PAGE_COUNTER_RATIO;
NeilBrown40cffcc2012-05-22 13:55:24 +10001171 if (!counts->bp[j >> PAGE_COUNTER_SHIFT].pending) {
NeilBrownbf07bb72012-05-22 13:55:06 +10001172 j |= PAGE_COUNTER_MASK;
NeilBrownaa3163f2005-06-21 17:17:22 -07001173 continue;
1174 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001175 counts->bp[j >> PAGE_COUNTER_SHIFT].pending = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001176 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001177 bmc = bitmap_get_counter(counts,
NeilBrownef99bf42012-05-22 13:55:08 +10001178 block,
NeilBrowndb305e52009-05-07 12:49:06 +10001179 &blocks, 0);
NeilBrown32a76272005-06-21 17:17:14 -07001180
NeilBrownbf07bb72012-05-22 13:55:06 +10001181 if (!bmc) {
1182 j |= PAGE_COUNTER_MASK;
1183 continue;
1184 }
1185 if (*bmc == 1 && !bitmap->need_sync) {
1186 /* We can clear the bit */
NeilBrownbf07bb72012-05-22 13:55:06 +10001187 *bmc = 0;
NeilBrown40cffcc2012-05-22 13:55:24 +10001188 bitmap_count_page(counts, block, -1);
NeilBrownef99bf42012-05-22 13:55:08 +10001189 bitmap_file_clear_bit(bitmap, block);
NeilBrownbf07bb72012-05-22 13:55:06 +10001190 } else if (*bmc && *bmc <= 2) {
1191 *bmc = 1;
NeilBrown40cffcc2012-05-22 13:55:24 +10001192 bitmap_set_pending(counts, block);
NeilBrown2585f3e2011-09-21 15:37:46 +10001193 bitmap->allclean = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001194 }
NeilBrown32a76272005-06-21 17:17:14 -07001195 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001196 spin_unlock_irq(&counts->lock);
NeilBrown32a76272005-06-21 17:17:14 -07001197
NeilBrownbf07bb72012-05-22 13:55:06 +10001198 /* Now start writeout on any page in NEEDWRITE that isn't DIRTY.
1199 * DIRTY pages need to be written by bitmap_unplug so it can wait
1200 * for them.
1201 * If we find any DIRTY page we stop there and let bitmap_unplug
1202 * handle all the rest. This is important in the case where
1203 * the first blocking holds the superblock and it has been updated.
1204 * We mustn't write any other blocks before the superblock.
1205 */
NeilBrown62f82fa2012-05-22 13:55:21 +10001206 for (j = 0;
1207 j < bitmap->storage.file_pages
1208 && !test_bit(BITMAP_STALE, &bitmap->flags);
1209 j++) {
NeilBrownbf07bb72012-05-22 13:55:06 +10001210
NeilBrownd1891222012-05-22 13:55:09 +10001211 if (test_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001212 BITMAP_PAGE_DIRTY))
1213 /* bitmap_unplug will handle the rest */
1214 break;
NeilBrownbdfd1142012-05-22 13:55:22 +10001215 if (test_and_clear_page_attr(bitmap, j,
1216 BITMAP_PAGE_NEEDWRITE)) {
NeilBrown1ec885c2012-05-22 13:55:10 +10001217 write_page(bitmap, bitmap->storage.filemap[j], 0);
NeilBrownbf07bb72012-05-22 13:55:06 +10001218 }
1219 }
NeilBrownbf07bb72012-05-22 13:55:06 +10001220
NeilBrown7be3dfe2008-03-10 11:43:48 -07001221 done:
NeilBrown8311c292008-03-04 14:29:30 -08001222 if (bitmap->allclean == 0)
NeilBrown2e61ebb2011-12-23 10:17:50 +11001223 mddev->thread->timeout =
1224 mddev->bitmap_info.daemon_sleep;
NeilBrownc3d97142009-12-14 12:49:52 +11001225 mutex_unlock(&mddev->bitmap_info.mutex);
NeilBrown32a76272005-06-21 17:17:14 -07001226}
1227
NeilBrown40cffcc2012-05-22 13:55:24 +10001228static bitmap_counter_t *bitmap_get_counter(struct bitmap_counts *bitmap,
NeilBrown57dab0b2010-10-19 10:03:39 +11001229 sector_t offset, sector_t *blocks,
NeilBrown32a76272005-06-21 17:17:14 -07001230 int create)
NeilBrownee305ac2009-09-23 18:06:44 +10001231__releases(bitmap->lock)
1232__acquires(bitmap->lock)
NeilBrown32a76272005-06-21 17:17:14 -07001233{
1234 /* If 'create', we might release the lock and reclaim it.
1235 * The lock must have been taken with interrupts enabled.
1236 * If !create, we don't release the lock.
1237 */
NeilBrown61a0d802012-03-19 12:46:41 +11001238 sector_t chunk = offset >> bitmap->chunkshift;
NeilBrown32a76272005-06-21 17:17:14 -07001239 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1240 unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
1241 sector_t csize;
NeilBrownef425672010-06-01 19:37:33 +10001242 int err;
NeilBrown32a76272005-06-21 17:17:14 -07001243
NeilBrownef425672010-06-01 19:37:33 +10001244 err = bitmap_checkpage(bitmap, page, create);
1245
1246 if (bitmap->bp[page].hijacked ||
1247 bitmap->bp[page].map == NULL)
NeilBrown61a0d802012-03-19 12:46:41 +11001248 csize = ((sector_t)1) << (bitmap->chunkshift +
NeilBrownef425672010-06-01 19:37:33 +10001249 PAGE_COUNTER_SHIFT - 1);
1250 else
NeilBrown61a0d802012-03-19 12:46:41 +11001251 csize = ((sector_t)1) << bitmap->chunkshift;
NeilBrownef425672010-06-01 19:37:33 +10001252 *blocks = csize - (offset & (csize - 1));
1253
1254 if (err < 0)
NeilBrown32a76272005-06-21 17:17:14 -07001255 return NULL;
NeilBrownef425672010-06-01 19:37:33 +10001256
NeilBrown32a76272005-06-21 17:17:14 -07001257 /* now locked ... */
1258
1259 if (bitmap->bp[page].hijacked) { /* hijacked pointer */
1260 /* should we use the first or second counter field
1261 * of the hijacked pointer? */
1262 int hi = (pageoff > PAGE_COUNTER_MASK);
NeilBrown32a76272005-06-21 17:17:14 -07001263 return &((bitmap_counter_t *)
1264 &bitmap->bp[page].map)[hi];
NeilBrownef425672010-06-01 19:37:33 +10001265 } else /* page is allocated */
NeilBrown32a76272005-06-21 17:17:14 -07001266 return (bitmap_counter_t *)
1267 &(bitmap->bp[page].map[pageoff]);
NeilBrown32a76272005-06-21 17:17:14 -07001268}
1269
NeilBrown4b6d2872005-09-09 16:23:47 -07001270int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int behind)
NeilBrown32a76272005-06-21 17:17:14 -07001271{
NeilBrownac2f40b2010-06-01 19:37:31 +10001272 if (!bitmap)
1273 return 0;
NeilBrown4b6d2872005-09-09 16:23:47 -07001274
1275 if (behind) {
Paul Clements696fcd52010-03-08 16:02:37 +11001276 int bw;
NeilBrown4b6d2872005-09-09 16:23:47 -07001277 atomic_inc(&bitmap->behind_writes);
Paul Clements696fcd52010-03-08 16:02:37 +11001278 bw = atomic_read(&bitmap->behind_writes);
1279 if (bw > bitmap->behind_writes_used)
1280 bitmap->behind_writes_used = bw;
1281
NeilBrown36a4e1f2011-10-07 14:23:17 +11001282 pr_debug("inc write-behind count %d/%lu\n",
1283 bw, bitmap->mddev->bitmap_info.max_write_behind);
NeilBrown4b6d2872005-09-09 16:23:47 -07001284 }
1285
NeilBrown32a76272005-06-21 17:17:14 -07001286 while (sectors) {
NeilBrown57dab0b2010-10-19 10:03:39 +11001287 sector_t blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001288 bitmap_counter_t *bmc;
1289
NeilBrown40cffcc2012-05-22 13:55:24 +10001290 spin_lock_irq(&bitmap->counts.lock);
1291 bmc = bitmap_get_counter(&bitmap->counts, offset, &blocks, 1);
NeilBrown32a76272005-06-21 17:17:14 -07001292 if (!bmc) {
NeilBrown40cffcc2012-05-22 13:55:24 +10001293 spin_unlock_irq(&bitmap->counts.lock);
NeilBrown32a76272005-06-21 17:17:14 -07001294 return 0;
1295 }
1296
Namhyung Kim27d5ea02011-06-09 11:42:57 +10001297 if (unlikely(COUNTER(*bmc) == COUNTER_MAX)) {
Neil Brownda6e1a32007-02-08 14:20:37 -08001298 DEFINE_WAIT(__wait);
1299 /* note that it is safe to do the prepare_to_wait
1300 * after the test as long as we do it before dropping
1301 * the spinlock.
1302 */
1303 prepare_to_wait(&bitmap->overflow_wait, &__wait,
1304 TASK_UNINTERRUPTIBLE);
NeilBrown40cffcc2012-05-22 13:55:24 +10001305 spin_unlock_irq(&bitmap->counts.lock);
NeilBrownf54a9d02012-08-02 08:33:20 +10001306 schedule();
Neil Brownda6e1a32007-02-08 14:20:37 -08001307 finish_wait(&bitmap->overflow_wait, &__wait);
1308 continue;
1309 }
1310
NeilBrownac2f40b2010-06-01 19:37:31 +10001311 switch (*bmc) {
NeilBrown32a76272005-06-21 17:17:14 -07001312 case 0:
1313 bitmap_file_set_bit(bitmap, offset);
NeilBrown40cffcc2012-05-22 13:55:24 +10001314 bitmap_count_page(&bitmap->counts, offset, 1);
NeilBrown32a76272005-06-21 17:17:14 -07001315 /* fall through */
1316 case 1:
1317 *bmc = 2;
1318 }
Neil Brownda6e1a32007-02-08 14:20:37 -08001319
NeilBrown32a76272005-06-21 17:17:14 -07001320 (*bmc)++;
1321
NeilBrown40cffcc2012-05-22 13:55:24 +10001322 spin_unlock_irq(&bitmap->counts.lock);
NeilBrown32a76272005-06-21 17:17:14 -07001323
1324 offset += blocks;
1325 if (sectors > blocks)
1326 sectors -= blocks;
NeilBrownac2f40b2010-06-01 19:37:31 +10001327 else
1328 sectors = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001329 }
1330 return 0;
1331}
NeilBrownac2f40b2010-06-01 19:37:31 +10001332EXPORT_SYMBOL(bitmap_startwrite);
NeilBrown32a76272005-06-21 17:17:14 -07001333
1334void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
NeilBrown4b6d2872005-09-09 16:23:47 -07001335 int success, int behind)
NeilBrown32a76272005-06-21 17:17:14 -07001336{
NeilBrownac2f40b2010-06-01 19:37:31 +10001337 if (!bitmap)
1338 return;
NeilBrown4b6d2872005-09-09 16:23:47 -07001339 if (behind) {
NeilBrowne5551902010-03-31 11:21:44 +11001340 if (atomic_dec_and_test(&bitmap->behind_writes))
1341 wake_up(&bitmap->behind_wait);
NeilBrown36a4e1f2011-10-07 14:23:17 +11001342 pr_debug("dec write-behind count %d/%lu\n",
1343 atomic_read(&bitmap->behind_writes),
1344 bitmap->mddev->bitmap_info.max_write_behind);
NeilBrown4b6d2872005-09-09 16:23:47 -07001345 }
1346
NeilBrown32a76272005-06-21 17:17:14 -07001347 while (sectors) {
NeilBrown57dab0b2010-10-19 10:03:39 +11001348 sector_t blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001349 unsigned long flags;
1350 bitmap_counter_t *bmc;
1351
NeilBrown40cffcc2012-05-22 13:55:24 +10001352 spin_lock_irqsave(&bitmap->counts.lock, flags);
1353 bmc = bitmap_get_counter(&bitmap->counts, offset, &blocks, 0);
NeilBrown32a76272005-06-21 17:17:14 -07001354 if (!bmc) {
NeilBrown40cffcc2012-05-22 13:55:24 +10001355 spin_unlock_irqrestore(&bitmap->counts.lock, flags);
NeilBrown32a76272005-06-21 17:17:14 -07001356 return;
1357 }
1358
NeilBrown961902c2011-12-23 09:57:48 +11001359 if (success && !bitmap->mddev->degraded &&
Neil Browna0da84f2008-06-28 08:31:22 +10001360 bitmap->events_cleared < bitmap->mddev->events) {
1361 bitmap->events_cleared = bitmap->mddev->events;
1362 bitmap->need_sync = 1;
NeilBrown5ff5aff2010-06-01 19:37:32 +10001363 sysfs_notify_dirent_safe(bitmap->sysfs_can_clear);
Neil Browna0da84f2008-06-28 08:31:22 +10001364 }
1365
Namhyung Kim27d5ea02011-06-09 11:42:57 +10001366 if (!success && !NEEDED(*bmc))
NeilBrown32a76272005-06-21 17:17:14 -07001367 *bmc |= NEEDED_MASK;
1368
Namhyung Kim27d5ea02011-06-09 11:42:57 +10001369 if (COUNTER(*bmc) == COUNTER_MAX)
Neil Brownda6e1a32007-02-08 14:20:37 -08001370 wake_up(&bitmap->overflow_wait);
1371
NeilBrown32a76272005-06-21 17:17:14 -07001372 (*bmc)--;
NeilBrown2585f3e2011-09-21 15:37:46 +10001373 if (*bmc <= 2) {
NeilBrown40cffcc2012-05-22 13:55:24 +10001374 bitmap_set_pending(&bitmap->counts, offset);
NeilBrown2585f3e2011-09-21 15:37:46 +10001375 bitmap->allclean = 0;
1376 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001377 spin_unlock_irqrestore(&bitmap->counts.lock, flags);
NeilBrown32a76272005-06-21 17:17:14 -07001378 offset += blocks;
1379 if (sectors > blocks)
1380 sectors -= blocks;
NeilBrownac2f40b2010-06-01 19:37:31 +10001381 else
1382 sectors = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001383 }
1384}
NeilBrownac2f40b2010-06-01 19:37:31 +10001385EXPORT_SYMBOL(bitmap_endwrite);
NeilBrown32a76272005-06-21 17:17:14 -07001386
NeilBrown57dab0b2010-10-19 10:03:39 +11001387static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
NeilBrown1187cf02009-03-31 14:27:02 +11001388 int degraded)
NeilBrown32a76272005-06-21 17:17:14 -07001389{
1390 bitmap_counter_t *bmc;
1391 int rv;
1392 if (bitmap == NULL) {/* FIXME or bitmap set as 'failed' */
1393 *blocks = 1024;
1394 return 1; /* always resync if no bitmap */
1395 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001396 spin_lock_irq(&bitmap->counts.lock);
1397 bmc = bitmap_get_counter(&bitmap->counts, offset, blocks, 0);
NeilBrown32a76272005-06-21 17:17:14 -07001398 rv = 0;
1399 if (bmc) {
1400 /* locked */
1401 if (RESYNC(*bmc))
1402 rv = 1;
1403 else if (NEEDED(*bmc)) {
1404 rv = 1;
NeilBrown6a806c52005-07-15 03:56:35 -07001405 if (!degraded) { /* don't set/clear bits if degraded */
1406 *bmc |= RESYNC_MASK;
1407 *bmc &= ~NEEDED_MASK;
1408 }
NeilBrown32a76272005-06-21 17:17:14 -07001409 }
1410 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001411 spin_unlock_irq(&bitmap->counts.lock);
NeilBrown32a76272005-06-21 17:17:14 -07001412 return rv;
1413}
1414
NeilBrown57dab0b2010-10-19 10:03:39 +11001415int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
NeilBrown1187cf02009-03-31 14:27:02 +11001416 int degraded)
1417{
1418 /* bitmap_start_sync must always report on multiples of whole
1419 * pages, otherwise resync (which is very PAGE_SIZE based) will
1420 * get confused.
1421 * So call __bitmap_start_sync repeatedly (if needed) until
1422 * At least PAGE_SIZE>>9 blocks are covered.
1423 * Return the 'or' of the result.
1424 */
1425 int rv = 0;
NeilBrown57dab0b2010-10-19 10:03:39 +11001426 sector_t blocks1;
NeilBrown1187cf02009-03-31 14:27:02 +11001427
1428 *blocks = 0;
1429 while (*blocks < (PAGE_SIZE>>9)) {
1430 rv |= __bitmap_start_sync(bitmap, offset,
1431 &blocks1, degraded);
1432 offset += blocks1;
1433 *blocks += blocks1;
1434 }
1435 return rv;
1436}
NeilBrownac2f40b2010-06-01 19:37:31 +10001437EXPORT_SYMBOL(bitmap_start_sync);
NeilBrown1187cf02009-03-31 14:27:02 +11001438
NeilBrown57dab0b2010-10-19 10:03:39 +11001439void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted)
NeilBrown32a76272005-06-21 17:17:14 -07001440{
1441 bitmap_counter_t *bmc;
1442 unsigned long flags;
NeilBrownac2f40b2010-06-01 19:37:31 +10001443
1444 if (bitmap == NULL) {
NeilBrown32a76272005-06-21 17:17:14 -07001445 *blocks = 1024;
1446 return;
1447 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001448 spin_lock_irqsave(&bitmap->counts.lock, flags);
1449 bmc = bitmap_get_counter(&bitmap->counts, offset, blocks, 0);
NeilBrown32a76272005-06-21 17:17:14 -07001450 if (bmc == NULL)
1451 goto unlock;
1452 /* locked */
NeilBrown32a76272005-06-21 17:17:14 -07001453 if (RESYNC(*bmc)) {
1454 *bmc &= ~RESYNC_MASK;
1455
1456 if (!NEEDED(*bmc) && aborted)
1457 *bmc |= NEEDED_MASK;
1458 else {
NeilBrown2585f3e2011-09-21 15:37:46 +10001459 if (*bmc <= 2) {
NeilBrown40cffcc2012-05-22 13:55:24 +10001460 bitmap_set_pending(&bitmap->counts, offset);
NeilBrown2585f3e2011-09-21 15:37:46 +10001461 bitmap->allclean = 0;
1462 }
NeilBrown32a76272005-06-21 17:17:14 -07001463 }
1464 }
1465 unlock:
NeilBrown40cffcc2012-05-22 13:55:24 +10001466 spin_unlock_irqrestore(&bitmap->counts.lock, flags);
NeilBrown32a76272005-06-21 17:17:14 -07001467}
NeilBrownac2f40b2010-06-01 19:37:31 +10001468EXPORT_SYMBOL(bitmap_end_sync);
NeilBrown32a76272005-06-21 17:17:14 -07001469
1470void bitmap_close_sync(struct bitmap *bitmap)
1471{
1472 /* Sync has finished, and any bitmap chunks that weren't synced
1473 * properly have been aborted. It remains to us to clear the
1474 * RESYNC bit wherever it is still on
1475 */
1476 sector_t sector = 0;
NeilBrown57dab0b2010-10-19 10:03:39 +11001477 sector_t blocks;
NeilBrownb47490c2008-02-06 01:39:50 -08001478 if (!bitmap)
1479 return;
NeilBrown32a76272005-06-21 17:17:14 -07001480 while (sector < bitmap->mddev->resync_max_sectors) {
1481 bitmap_end_sync(bitmap, sector, &blocks, 0);
NeilBrownb47490c2008-02-06 01:39:50 -08001482 sector += blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001483 }
1484}
NeilBrownac2f40b2010-06-01 19:37:31 +10001485EXPORT_SYMBOL(bitmap_close_sync);
NeilBrown32a76272005-06-21 17:17:14 -07001486
NeilBrownb47490c2008-02-06 01:39:50 -08001487void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
1488{
1489 sector_t s = 0;
NeilBrown57dab0b2010-10-19 10:03:39 +11001490 sector_t blocks;
NeilBrownb47490c2008-02-06 01:39:50 -08001491
1492 if (!bitmap)
1493 return;
1494 if (sector == 0) {
1495 bitmap->last_end_sync = jiffies;
1496 return;
1497 }
1498 if (time_before(jiffies, (bitmap->last_end_sync
NeilBrown1b04be92009-12-14 12:49:53 +11001499 + bitmap->mddev->bitmap_info.daemon_sleep)))
NeilBrownb47490c2008-02-06 01:39:50 -08001500 return;
1501 wait_event(bitmap->mddev->recovery_wait,
1502 atomic_read(&bitmap->mddev->recovery_active) == 0);
1503
NeilBrown75d3da42011-01-14 09:14:34 +11001504 bitmap->mddev->curr_resync_completed = sector;
NeilBrown070dc6d2010-08-30 17:33:34 +10001505 set_bit(MD_CHANGE_CLEAN, &bitmap->mddev->flags);
NeilBrown40cffcc2012-05-22 13:55:24 +10001506 sector &= ~((1ULL << bitmap->counts.chunkshift) - 1);
NeilBrownb47490c2008-02-06 01:39:50 -08001507 s = 0;
1508 while (s < sector && s < bitmap->mddev->resync_max_sectors) {
1509 bitmap_end_sync(bitmap, s, &blocks, 0);
1510 s += blocks;
1511 }
1512 bitmap->last_end_sync = jiffies;
NeilBrownacb180b2009-04-14 16:28:34 +10001513 sysfs_notify(&bitmap->mddev->kobj, NULL, "sync_completed");
NeilBrownb47490c2008-02-06 01:39:50 -08001514}
NeilBrownac2f40b2010-06-01 19:37:31 +10001515EXPORT_SYMBOL(bitmap_cond_end_sync);
NeilBrownb47490c2008-02-06 01:39:50 -08001516
NeilBrown6a079972005-09-09 16:23:44 -07001517static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)
NeilBrown32a76272005-06-21 17:17:14 -07001518{
1519 /* For each chunk covered by any of these sectors, set the
NeilBrownef99bf42012-05-22 13:55:08 +10001520 * counter to 2 and possibly set resync_needed. They should all
NeilBrown32a76272005-06-21 17:17:14 -07001521 * be 0 at this point
1522 */
NeilBrown193f1c92005-08-04 12:53:33 -07001523
NeilBrown57dab0b2010-10-19 10:03:39 +11001524 sector_t secs;
NeilBrown193f1c92005-08-04 12:53:33 -07001525 bitmap_counter_t *bmc;
NeilBrown40cffcc2012-05-22 13:55:24 +10001526 spin_lock_irq(&bitmap->counts.lock);
1527 bmc = bitmap_get_counter(&bitmap->counts, offset, &secs, 1);
NeilBrown193f1c92005-08-04 12:53:33 -07001528 if (!bmc) {
NeilBrown40cffcc2012-05-22 13:55:24 +10001529 spin_unlock_irq(&bitmap->counts.lock);
NeilBrown193f1c92005-08-04 12:53:33 -07001530 return;
NeilBrown32a76272005-06-21 17:17:14 -07001531 }
NeilBrownac2f40b2010-06-01 19:37:31 +10001532 if (!*bmc) {
NeilBrown915c4202011-12-23 10:17:51 +11001533 *bmc = 2 | (needed ? NEEDED_MASK : 0);
NeilBrown40cffcc2012-05-22 13:55:24 +10001534 bitmap_count_page(&bitmap->counts, offset, 1);
1535 bitmap_set_pending(&bitmap->counts, offset);
NeilBrown2585f3e2011-09-21 15:37:46 +10001536 bitmap->allclean = 0;
NeilBrown193f1c92005-08-04 12:53:33 -07001537 }
NeilBrown40cffcc2012-05-22 13:55:24 +10001538 spin_unlock_irq(&bitmap->counts.lock);
NeilBrown32a76272005-06-21 17:17:14 -07001539}
1540
Paul Clements9b1d1da2006-10-03 01:15:49 -07001541/* dirty the memory and file bits for bitmap chunks "s" to "e" */
1542void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e)
1543{
1544 unsigned long chunk;
1545
1546 for (chunk = s; chunk <= e; chunk++) {
NeilBrown40cffcc2012-05-22 13:55:24 +10001547 sector_t sec = (sector_t)chunk << bitmap->counts.chunkshift;
Paul Clements9b1d1da2006-10-03 01:15:49 -07001548 bitmap_set_memory_bits(bitmap, sec, 1);
1549 bitmap_file_set_bit(bitmap, sec);
NeilBrownffa23322009-12-14 12:49:56 +11001550 if (sec < bitmap->mddev->recovery_cp)
1551 /* We are asserting that the array is dirty,
1552 * so move the recovery_cp address back so
1553 * that it is obvious that it is dirty
1554 */
1555 bitmap->mddev->recovery_cp = sec;
Paul Clements9b1d1da2006-10-03 01:15:49 -07001556 }
1557}
1558
NeilBrown32a76272005-06-21 17:17:14 -07001559/*
NeilBrown6b8b3e82005-08-04 12:53:35 -07001560 * flush out any pending updates
1561 */
NeilBrownfd01b882011-10-11 16:47:53 +11001562void bitmap_flush(struct mddev *mddev)
NeilBrown6b8b3e82005-08-04 12:53:35 -07001563{
1564 struct bitmap *bitmap = mddev->bitmap;
NeilBrown42a04b52009-12-14 12:49:53 +11001565 long sleep;
NeilBrown6b8b3e82005-08-04 12:53:35 -07001566
1567 if (!bitmap) /* there was no bitmap */
1568 return;
1569
1570 /* run the daemon_work three time to ensure everything is flushed
1571 * that can be
1572 */
NeilBrown1b04be92009-12-14 12:49:53 +11001573 sleep = mddev->bitmap_info.daemon_sleep * 2;
NeilBrown42a04b52009-12-14 12:49:53 +11001574 bitmap->daemon_lastrun -= sleep;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001575 bitmap_daemon_work(mddev);
NeilBrown42a04b52009-12-14 12:49:53 +11001576 bitmap->daemon_lastrun -= sleep;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001577 bitmap_daemon_work(mddev);
NeilBrown42a04b52009-12-14 12:49:53 +11001578 bitmap->daemon_lastrun -= sleep;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001579 bitmap_daemon_work(mddev);
NeilBrown6b8b3e82005-08-04 12:53:35 -07001580 bitmap_update_sb(bitmap);
1581}
1582
1583/*
NeilBrown32a76272005-06-21 17:17:14 -07001584 * free memory that was allocated
1585 */
NeilBrown3178b0d2005-09-09 16:23:50 -07001586static void bitmap_free(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -07001587{
1588 unsigned long k, pages;
1589 struct bitmap_page *bp;
NeilBrown32a76272005-06-21 17:17:14 -07001590
1591 if (!bitmap) /* there was no bitmap */
1592 return;
1593
NeilBrownfae7d322012-05-22 13:55:21 +10001594 /* Shouldn't be needed - but just in case.... */
1595 wait_event(bitmap->write_wait,
1596 atomic_read(&bitmap->pending_writes) == 0);
1597
1598 /* release the bitmap file */
1599 bitmap_file_unmap(&bitmap->storage);
NeilBrown32a76272005-06-21 17:17:14 -07001600
NeilBrown40cffcc2012-05-22 13:55:24 +10001601 bp = bitmap->counts.bp;
1602 pages = bitmap->counts.pages;
NeilBrown32a76272005-06-21 17:17:14 -07001603
1604 /* free all allocated memory */
1605
NeilBrown32a76272005-06-21 17:17:14 -07001606 if (bp) /* deallocate the page memory */
1607 for (k = 0; k < pages; k++)
1608 if (bp[k].map && !bp[k].hijacked)
1609 kfree(bp[k].map);
1610 kfree(bp);
1611 kfree(bitmap);
1612}
NeilBrownaa5cbd12009-12-14 12:49:46 +11001613
NeilBrownfd01b882011-10-11 16:47:53 +11001614void bitmap_destroy(struct mddev *mddev)
NeilBrown3178b0d2005-09-09 16:23:50 -07001615{
1616 struct bitmap *bitmap = mddev->bitmap;
1617
1618 if (!bitmap) /* there was no bitmap */
1619 return;
1620
NeilBrownc3d97142009-12-14 12:49:52 +11001621 mutex_lock(&mddev->bitmap_info.mutex);
NeilBrown978a7a42014-12-15 12:56:58 +11001622 spin_lock(&mddev->lock);
NeilBrown3178b0d2005-09-09 16:23:50 -07001623 mddev->bitmap = NULL; /* disconnect from the md device */
NeilBrown978a7a42014-12-15 12:56:58 +11001624 spin_unlock(&mddev->lock);
NeilBrownc3d97142009-12-14 12:49:52 +11001625 mutex_unlock(&mddev->bitmap_info.mutex);
NeilBrownb15c2e52006-01-06 00:20:16 -08001626 if (mddev->thread)
1627 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrown3178b0d2005-09-09 16:23:50 -07001628
NeilBrownece5cff2009-12-14 12:49:56 +11001629 if (bitmap->sysfs_can_clear)
1630 sysfs_put(bitmap->sysfs_can_clear);
1631
NeilBrown3178b0d2005-09-09 16:23:50 -07001632 bitmap_free(bitmap);
1633}
NeilBrown32a76272005-06-21 17:17:14 -07001634
1635/*
1636 * initialize the bitmap structure
1637 * if this returns an error, bitmap_destroy must be called to do clean up
1638 */
NeilBrownfd01b882011-10-11 16:47:53 +11001639int bitmap_create(struct mddev *mddev)
NeilBrown32a76272005-06-21 17:17:14 -07001640{
1641 struct bitmap *bitmap;
NeilBrown1f593902009-04-20 11:50:24 +10001642 sector_t blocks = mddev->resync_max_sectors;
NeilBrownc3d97142009-12-14 12:49:52 +11001643 struct file *file = mddev->bitmap_info.file;
NeilBrown32a76272005-06-21 17:17:14 -07001644 int err;
Tejun Heo324a56e2013-12-11 14:11:53 -05001645 struct kernfs_node *bm = NULL;
NeilBrown32a76272005-06-21 17:17:14 -07001646
Alexey Dobriyan5f6e3c832006-10-11 01:22:26 -07001647 BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
NeilBrown32a76272005-06-21 17:17:14 -07001648
NeilBrownc3d97142009-12-14 12:49:52 +11001649 BUG_ON(file && mddev->bitmap_info.offset);
NeilBrowna654b9d82005-06-21 17:17:27 -07001650
NeilBrown9ffae0c2006-01-06 00:20:32 -08001651 bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
NeilBrown32a76272005-06-21 17:17:14 -07001652 if (!bitmap)
1653 return -ENOMEM;
1654
NeilBrown40cffcc2012-05-22 13:55:24 +10001655 spin_lock_init(&bitmap->counts.lock);
NeilBrownce25c312006-06-26 00:27:49 -07001656 atomic_set(&bitmap->pending_writes, 0);
1657 init_waitqueue_head(&bitmap->write_wait);
Neil Brownda6e1a32007-02-08 14:20:37 -08001658 init_waitqueue_head(&bitmap->overflow_wait);
NeilBrowne5551902010-03-31 11:21:44 +11001659 init_waitqueue_head(&bitmap->behind_wait);
NeilBrownce25c312006-06-26 00:27:49 -07001660
NeilBrown32a76272005-06-21 17:17:14 -07001661 bitmap->mddev = mddev;
NeilBrown32a76272005-06-21 17:17:14 -07001662
NeilBrown5ff5aff2010-06-01 19:37:32 +10001663 if (mddev->kobj.sd)
Tejun Heo388975c2013-09-11 23:19:13 -04001664 bm = sysfs_get_dirent(mddev->kobj.sd, "bitmap");
NeilBrownece5cff2009-12-14 12:49:56 +11001665 if (bm) {
Tejun Heo388975c2013-09-11 23:19:13 -04001666 bitmap->sysfs_can_clear = sysfs_get_dirent(bm, "can_clear");
NeilBrownece5cff2009-12-14 12:49:56 +11001667 sysfs_put(bm);
1668 } else
1669 bitmap->sysfs_can_clear = NULL;
1670
NeilBrown1ec885c2012-05-22 13:55:10 +10001671 bitmap->storage.file = file;
NeilBrownce25c312006-06-26 00:27:49 -07001672 if (file) {
1673 get_file(file);
NeilBrownae8fa282009-10-16 15:56:01 +11001674 /* As future accesses to this file will use bmap,
1675 * and bypass the page cache, we must sync the file
1676 * first.
1677 */
Christoph Hellwig8018ab02010-03-22 17:32:25 +01001678 vfs_fsync(file, 1);
NeilBrownce25c312006-06-26 00:27:49 -07001679 }
NeilBrown42a04b52009-12-14 12:49:53 +11001680 /* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */
Jonathan Brassow9c810752011-06-08 17:59:30 -05001681 if (!mddev->bitmap_info.external) {
1682 /*
1683 * If 'MD_ARRAY_FIRST_USE' is set, then device-mapper is
1684 * instructing us to create a new on-disk bitmap instance.
1685 */
1686 if (test_and_clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags))
1687 err = bitmap_new_disk_sb(bitmap);
1688 else
1689 err = bitmap_read_sb(bitmap);
1690 } else {
NeilBrownece5cff2009-12-14 12:49:56 +11001691 err = 0;
1692 if (mddev->bitmap_info.chunksize == 0 ||
1693 mddev->bitmap_info.daemon_sleep == 0)
1694 /* chunksize and time_base need to be
1695 * set first. */
1696 err = -EINVAL;
1697 }
NeilBrown32a76272005-06-21 17:17:14 -07001698 if (err)
NeilBrown3178b0d2005-09-09 16:23:50 -07001699 goto error;
NeilBrown32a76272005-06-21 17:17:14 -07001700
NeilBrown624ce4f2009-12-14 12:49:56 +11001701 bitmap->daemon_lastrun = jiffies;
NeilBrownd60b4792012-05-22 13:55:25 +10001702 err = bitmap_resize(bitmap, blocks, mddev->bitmap_info.chunksize, 1);
1703 if (err)
NeilBrown3178b0d2005-09-09 16:23:50 -07001704 goto error;
NeilBrown32a76272005-06-21 17:17:14 -07001705
NeilBrown69e51b42010-06-01 19:37:35 +10001706 printk(KERN_INFO "created bitmap (%lu pages) for device %s\n",
NeilBrownd60b4792012-05-22 13:55:25 +10001707 bitmap->counts.pages, bmname(bitmap));
NeilBrown69e51b42010-06-01 19:37:35 +10001708
1709 mddev->bitmap = bitmap;
NeilBrownb405fe92012-05-22 13:55:15 +10001710 return test_bit(BITMAP_WRITE_ERROR, &bitmap->flags) ? -EIO : 0;
NeilBrown69e51b42010-06-01 19:37:35 +10001711
1712 error:
1713 bitmap_free(bitmap);
1714 return err;
1715}
1716
NeilBrownfd01b882011-10-11 16:47:53 +11001717int bitmap_load(struct mddev *mddev)
NeilBrown69e51b42010-06-01 19:37:35 +10001718{
1719 int err = 0;
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001720 sector_t start = 0;
NeilBrown69e51b42010-06-01 19:37:35 +10001721 sector_t sector = 0;
1722 struct bitmap *bitmap = mddev->bitmap;
1723
1724 if (!bitmap)
1725 goto out;
1726
1727 /* Clear out old bitmap info first: Either there is none, or we
1728 * are resuming after someone else has possibly changed things,
1729 * so we should forget old cached info.
1730 * All chunks should be clean, but some might need_sync.
1731 */
1732 while (sector < mddev->resync_max_sectors) {
NeilBrown57dab0b2010-10-19 10:03:39 +11001733 sector_t blocks;
NeilBrown69e51b42010-06-01 19:37:35 +10001734 bitmap_start_sync(bitmap, sector, &blocks, 0);
1735 sector += blocks;
1736 }
1737 bitmap_close_sync(bitmap);
1738
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001739 if (mddev->degraded == 0
1740 || bitmap->events_cleared == mddev->events)
1741 /* no need to keep dirty bits to optimise a
1742 * re-add of a missing device */
1743 start = mddev->recovery_cp;
NeilBrown69e51b42010-06-01 19:37:35 +10001744
NeilBrownafbaa902012-04-12 16:05:06 +10001745 mutex_lock(&mddev->bitmap_info.mutex);
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001746 err = bitmap_init_from_disk(bitmap, start);
NeilBrownafbaa902012-04-12 16:05:06 +10001747 mutex_unlock(&mddev->bitmap_info.mutex);
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001748
NeilBrown32a76272005-06-21 17:17:14 -07001749 if (err)
NeilBrown69e51b42010-06-01 19:37:35 +10001750 goto out;
NeilBrownb405fe92012-05-22 13:55:15 +10001751 clear_bit(BITMAP_STALE, &bitmap->flags);
NeilBrownef99bf42012-05-22 13:55:08 +10001752
1753 /* Kick recovery in case any bits were set */
1754 set_bit(MD_RECOVERY_NEEDED, &bitmap->mddev->recovery);
NeilBrown3178b0d2005-09-09 16:23:50 -07001755
NeilBrown1b04be92009-12-14 12:49:53 +11001756 mddev->thread->timeout = mddev->bitmap_info.daemon_sleep;
NeilBrown9cd30fd2009-12-14 12:49:54 +11001757 md_wakeup_thread(mddev->thread);
NeilBrownb15c2e52006-01-06 00:20:16 -08001758
NeilBrown4ad13662007-07-17 04:06:13 -07001759 bitmap_update_sb(bitmap);
1760
NeilBrownb405fe92012-05-22 13:55:15 +10001761 if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))
NeilBrown69e51b42010-06-01 19:37:35 +10001762 err = -EIO;
1763out:
NeilBrown3178b0d2005-09-09 16:23:50 -07001764 return err;
NeilBrown32a76272005-06-21 17:17:14 -07001765}
NeilBrown69e51b42010-06-01 19:37:35 +10001766EXPORT_SYMBOL_GPL(bitmap_load);
NeilBrown32a76272005-06-21 17:17:14 -07001767
NeilBrown57148962012-03-19 12:46:40 +11001768void bitmap_status(struct seq_file *seq, struct bitmap *bitmap)
1769{
1770 unsigned long chunk_kb;
NeilBrown40cffcc2012-05-22 13:55:24 +10001771 struct bitmap_counts *counts;
NeilBrown57148962012-03-19 12:46:40 +11001772
1773 if (!bitmap)
1774 return;
1775
NeilBrown40cffcc2012-05-22 13:55:24 +10001776 counts = &bitmap->counts;
1777
NeilBrown57148962012-03-19 12:46:40 +11001778 chunk_kb = bitmap->mddev->bitmap_info.chunksize >> 10;
1779 seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
1780 "%lu%s chunk",
NeilBrown40cffcc2012-05-22 13:55:24 +10001781 counts->pages - counts->missing_pages,
1782 counts->pages,
1783 (counts->pages - counts->missing_pages)
NeilBrown57148962012-03-19 12:46:40 +11001784 << (PAGE_SHIFT - 10),
1785 chunk_kb ? chunk_kb : bitmap->mddev->bitmap_info.chunksize,
1786 chunk_kb ? "KB" : "B");
NeilBrown1ec885c2012-05-22 13:55:10 +10001787 if (bitmap->storage.file) {
NeilBrown57148962012-03-19 12:46:40 +11001788 seq_printf(seq, ", file: ");
NeilBrown1ec885c2012-05-22 13:55:10 +10001789 seq_path(seq, &bitmap->storage.file->f_path, " \t\n");
NeilBrown57148962012-03-19 12:46:40 +11001790 }
1791
1792 seq_printf(seq, "\n");
NeilBrown57148962012-03-19 12:46:40 +11001793}
1794
NeilBrownd60b4792012-05-22 13:55:25 +10001795int bitmap_resize(struct bitmap *bitmap, sector_t blocks,
1796 int chunksize, int init)
1797{
1798 /* If chunk_size is 0, choose an appropriate chunk size.
1799 * Then possibly allocate new storage space.
1800 * Then quiesce, copy bits, replace bitmap, and re-start
1801 *
1802 * This function is called both to set up the initial bitmap
1803 * and to resize the bitmap while the array is active.
1804 * If this happens as a result of the array being resized,
1805 * chunksize will be zero, and we need to choose a suitable
1806 * chunksize, otherwise we use what we are given.
1807 */
1808 struct bitmap_storage store;
1809 struct bitmap_counts old_counts;
1810 unsigned long chunks;
1811 sector_t block;
1812 sector_t old_blocks, new_blocks;
1813 int chunkshift;
1814 int ret = 0;
1815 long pages;
1816 struct bitmap_page *new_bp;
1817
1818 if (chunksize == 0) {
1819 /* If there is enough space, leave the chunk size unchanged,
1820 * else increase by factor of two until there is enough space.
1821 */
1822 long bytes;
1823 long space = bitmap->mddev->bitmap_info.space;
1824
1825 if (space == 0) {
1826 /* We don't know how much space there is, so limit
1827 * to current size - in sectors.
1828 */
1829 bytes = DIV_ROUND_UP(bitmap->counts.chunks, 8);
1830 if (!bitmap->mddev->bitmap_info.external)
1831 bytes += sizeof(bitmap_super_t);
1832 space = DIV_ROUND_UP(bytes, 512);
1833 bitmap->mddev->bitmap_info.space = space;
1834 }
1835 chunkshift = bitmap->counts.chunkshift;
1836 chunkshift--;
1837 do {
1838 /* 'chunkshift' is shift from block size to chunk size */
1839 chunkshift++;
1840 chunks = DIV_ROUND_UP_SECTOR_T(blocks, 1 << chunkshift);
1841 bytes = DIV_ROUND_UP(chunks, 8);
1842 if (!bitmap->mddev->bitmap_info.external)
1843 bytes += sizeof(bitmap_super_t);
1844 } while (bytes > (space << 9));
1845 } else
1846 chunkshift = ffz(~chunksize) - BITMAP_BLOCK_SHIFT;
1847
1848 chunks = DIV_ROUND_UP_SECTOR_T(blocks, 1 << chunkshift);
1849 memset(&store, 0, sizeof(store));
1850 if (bitmap->mddev->bitmap_info.offset || bitmap->mddev->bitmap_info.file)
1851 ret = bitmap_storage_alloc(&store, chunks,
1852 !bitmap->mddev->bitmap_info.external);
1853 if (ret)
1854 goto err;
1855
1856 pages = DIV_ROUND_UP(chunks, PAGE_COUNTER_RATIO);
1857
1858 new_bp = kzalloc(pages * sizeof(*new_bp), GFP_KERNEL);
1859 ret = -ENOMEM;
1860 if (!new_bp) {
1861 bitmap_file_unmap(&store);
1862 goto err;
1863 }
1864
1865 if (!init)
1866 bitmap->mddev->pers->quiesce(bitmap->mddev, 1);
1867
1868 store.file = bitmap->storage.file;
1869 bitmap->storage.file = NULL;
1870
1871 if (store.sb_page && bitmap->storage.sb_page)
1872 memcpy(page_address(store.sb_page),
1873 page_address(bitmap->storage.sb_page),
1874 sizeof(bitmap_super_t));
1875 bitmap_file_unmap(&bitmap->storage);
1876 bitmap->storage = store;
1877
1878 old_counts = bitmap->counts;
1879 bitmap->counts.bp = new_bp;
1880 bitmap->counts.pages = pages;
1881 bitmap->counts.missing_pages = pages;
1882 bitmap->counts.chunkshift = chunkshift;
1883 bitmap->counts.chunks = chunks;
1884 bitmap->mddev->bitmap_info.chunksize = 1 << (chunkshift +
1885 BITMAP_BLOCK_SHIFT);
1886
1887 blocks = min(old_counts.chunks << old_counts.chunkshift,
1888 chunks << chunkshift);
1889
1890 spin_lock_irq(&bitmap->counts.lock);
1891 for (block = 0; block < blocks; ) {
1892 bitmap_counter_t *bmc_old, *bmc_new;
1893 int set;
1894
1895 bmc_old = bitmap_get_counter(&old_counts, block,
1896 &old_blocks, 0);
1897 set = bmc_old && NEEDED(*bmc_old);
1898
1899 if (set) {
1900 bmc_new = bitmap_get_counter(&bitmap->counts, block,
1901 &new_blocks, 1);
1902 if (*bmc_new == 0) {
1903 /* need to set on-disk bits too. */
1904 sector_t end = block + new_blocks;
1905 sector_t start = block >> chunkshift;
1906 start <<= chunkshift;
1907 while (start < end) {
1908 bitmap_file_set_bit(bitmap, block);
1909 start += 1 << chunkshift;
1910 }
1911 *bmc_new = 2;
1912 bitmap_count_page(&bitmap->counts,
1913 block, 1);
1914 bitmap_set_pending(&bitmap->counts,
1915 block);
1916 }
1917 *bmc_new |= NEEDED_MASK;
1918 if (new_blocks < old_blocks)
1919 old_blocks = new_blocks;
1920 }
1921 block += old_blocks;
1922 }
1923
1924 if (!init) {
1925 int i;
1926 while (block < (chunks << chunkshift)) {
1927 bitmap_counter_t *bmc;
1928 bmc = bitmap_get_counter(&bitmap->counts, block,
1929 &new_blocks, 1);
1930 if (bmc) {
1931 /* new space. It needs to be resynced, so
1932 * we set NEEDED_MASK.
1933 */
1934 if (*bmc == 0) {
1935 *bmc = NEEDED_MASK | 2;
1936 bitmap_count_page(&bitmap->counts,
1937 block, 1);
1938 bitmap_set_pending(&bitmap->counts,
1939 block);
1940 }
1941 }
1942 block += new_blocks;
1943 }
1944 for (i = 0; i < bitmap->storage.file_pages; i++)
1945 set_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);
1946 }
1947 spin_unlock_irq(&bitmap->counts.lock);
1948
1949 if (!init) {
1950 bitmap_unplug(bitmap);
1951 bitmap->mddev->pers->quiesce(bitmap->mddev, 0);
1952 }
1953 ret = 0;
1954err:
1955 return ret;
1956}
1957EXPORT_SYMBOL_GPL(bitmap_resize);
1958
NeilBrown43a70502009-12-14 12:49:55 +11001959static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11001960location_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11001961{
1962 ssize_t len;
NeilBrownac2f40b2010-06-01 19:37:31 +10001963 if (mddev->bitmap_info.file)
NeilBrown43a70502009-12-14 12:49:55 +11001964 len = sprintf(page, "file");
NeilBrownac2f40b2010-06-01 19:37:31 +10001965 else if (mddev->bitmap_info.offset)
NeilBrown43a70502009-12-14 12:49:55 +11001966 len = sprintf(page, "%+lld", (long long)mddev->bitmap_info.offset);
NeilBrownac2f40b2010-06-01 19:37:31 +10001967 else
NeilBrown43a70502009-12-14 12:49:55 +11001968 len = sprintf(page, "none");
1969 len += sprintf(page+len, "\n");
1970 return len;
1971}
1972
1973static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11001974location_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11001975{
1976
1977 if (mddev->pers) {
1978 if (!mddev->pers->quiesce)
1979 return -EBUSY;
1980 if (mddev->recovery || mddev->sync_thread)
1981 return -EBUSY;
1982 }
1983
1984 if (mddev->bitmap || mddev->bitmap_info.file ||
1985 mddev->bitmap_info.offset) {
1986 /* bitmap already configured. Only option is to clear it */
1987 if (strncmp(buf, "none", 4) != 0)
1988 return -EBUSY;
1989 if (mddev->pers) {
1990 mddev->pers->quiesce(mddev, 1);
1991 bitmap_destroy(mddev);
1992 mddev->pers->quiesce(mddev, 0);
1993 }
1994 mddev->bitmap_info.offset = 0;
1995 if (mddev->bitmap_info.file) {
1996 struct file *f = mddev->bitmap_info.file;
1997 mddev->bitmap_info.file = NULL;
NeilBrown43a70502009-12-14 12:49:55 +11001998 fput(f);
1999 }
2000 } else {
2001 /* No bitmap, OK to set a location */
2002 long long offset;
2003 if (strncmp(buf, "none", 4) == 0)
2004 /* nothing to be done */;
2005 else if (strncmp(buf, "file:", 5) == 0) {
2006 /* Not supported yet */
2007 return -EINVAL;
2008 } else {
2009 int rv;
2010 if (buf[0] == '+')
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002011 rv = kstrtoll(buf+1, 10, &offset);
NeilBrown43a70502009-12-14 12:49:55 +11002012 else
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002013 rv = kstrtoll(buf, 10, &offset);
NeilBrown43a70502009-12-14 12:49:55 +11002014 if (rv)
2015 return rv;
2016 if (offset == 0)
2017 return -EINVAL;
NeilBrownece5cff2009-12-14 12:49:56 +11002018 if (mddev->bitmap_info.external == 0 &&
2019 mddev->major_version == 0 &&
NeilBrown43a70502009-12-14 12:49:55 +11002020 offset != mddev->bitmap_info.default_offset)
2021 return -EINVAL;
2022 mddev->bitmap_info.offset = offset;
2023 if (mddev->pers) {
2024 mddev->pers->quiesce(mddev, 1);
2025 rv = bitmap_create(mddev);
NeilBrown4474ca42012-03-19 12:46:37 +11002026 if (!rv)
2027 rv = bitmap_load(mddev);
NeilBrown43a70502009-12-14 12:49:55 +11002028 if (rv) {
2029 bitmap_destroy(mddev);
2030 mddev->bitmap_info.offset = 0;
2031 }
2032 mddev->pers->quiesce(mddev, 0);
2033 if (rv)
2034 return rv;
2035 }
2036 }
2037 }
2038 if (!mddev->external) {
2039 /* Ensure new bitmap info is stored in
2040 * metadata promptly.
2041 */
2042 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2043 md_wakeup_thread(mddev->thread);
2044 }
2045 return len;
2046}
2047
2048static struct md_sysfs_entry bitmap_location =
2049__ATTR(location, S_IRUGO|S_IWUSR, location_show, location_store);
2050
NeilBrown6409bb02012-05-22 13:55:07 +10002051/* 'bitmap/space' is the space available at 'location' for the
2052 * bitmap. This allows the kernel to know when it is safe to
2053 * resize the bitmap to match a resized array.
2054 */
2055static ssize_t
2056space_show(struct mddev *mddev, char *page)
2057{
2058 return sprintf(page, "%lu\n", mddev->bitmap_info.space);
2059}
2060
2061static ssize_t
2062space_store(struct mddev *mddev, const char *buf, size_t len)
2063{
2064 unsigned long sectors;
2065 int rv;
2066
2067 rv = kstrtoul(buf, 10, &sectors);
2068 if (rv)
2069 return rv;
2070
2071 if (sectors == 0)
2072 return -EINVAL;
2073
2074 if (mddev->bitmap &&
NeilBrown9b1215c2012-05-22 13:55:11 +10002075 sectors < (mddev->bitmap->storage.bytes + 511) >> 9)
NeilBrown6409bb02012-05-22 13:55:07 +10002076 return -EFBIG; /* Bitmap is too big for this small space */
2077
2078 /* could make sure it isn't too big, but that isn't really
2079 * needed - user-space should be careful.
2080 */
2081 mddev->bitmap_info.space = sectors;
2082 return len;
2083}
2084
2085static struct md_sysfs_entry bitmap_space =
2086__ATTR(space, S_IRUGO|S_IWUSR, space_show, space_store);
2087
NeilBrown43a70502009-12-14 12:49:55 +11002088static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002089timeout_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11002090{
2091 ssize_t len;
2092 unsigned long secs = mddev->bitmap_info.daemon_sleep / HZ;
2093 unsigned long jifs = mddev->bitmap_info.daemon_sleep % HZ;
NeilBrownac2f40b2010-06-01 19:37:31 +10002094
NeilBrown43a70502009-12-14 12:49:55 +11002095 len = sprintf(page, "%lu", secs);
2096 if (jifs)
2097 len += sprintf(page+len, ".%03u", jiffies_to_msecs(jifs));
2098 len += sprintf(page+len, "\n");
2099 return len;
2100}
2101
2102static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002103timeout_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11002104{
2105 /* timeout can be set at any time */
2106 unsigned long timeout;
2107 int rv = strict_strtoul_scaled(buf, &timeout, 4);
2108 if (rv)
2109 return rv;
2110
2111 /* just to make sure we don't overflow... */
2112 if (timeout >= LONG_MAX / HZ)
2113 return -EINVAL;
2114
2115 timeout = timeout * HZ / 10000;
2116
2117 if (timeout >= MAX_SCHEDULE_TIMEOUT)
2118 timeout = MAX_SCHEDULE_TIMEOUT-1;
2119 if (timeout < 1)
2120 timeout = 1;
2121 mddev->bitmap_info.daemon_sleep = timeout;
2122 if (mddev->thread) {
2123 /* if thread->timeout is MAX_SCHEDULE_TIMEOUT, then
2124 * the bitmap is all clean and we don't need to
2125 * adjust the timeout right now
2126 */
2127 if (mddev->thread->timeout < MAX_SCHEDULE_TIMEOUT) {
2128 mddev->thread->timeout = timeout;
2129 md_wakeup_thread(mddev->thread);
2130 }
2131 }
2132 return len;
2133}
2134
2135static struct md_sysfs_entry bitmap_timeout =
2136__ATTR(time_base, S_IRUGO|S_IWUSR, timeout_show, timeout_store);
2137
2138static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002139backlog_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11002140{
2141 return sprintf(page, "%lu\n", mddev->bitmap_info.max_write_behind);
2142}
2143
2144static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002145backlog_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11002146{
2147 unsigned long backlog;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002148 int rv = kstrtoul(buf, 10, &backlog);
NeilBrown43a70502009-12-14 12:49:55 +11002149 if (rv)
2150 return rv;
2151 if (backlog > COUNTER_MAX)
2152 return -EINVAL;
2153 mddev->bitmap_info.max_write_behind = backlog;
2154 return len;
2155}
2156
2157static struct md_sysfs_entry bitmap_backlog =
2158__ATTR(backlog, S_IRUGO|S_IWUSR, backlog_show, backlog_store);
2159
2160static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002161chunksize_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11002162{
2163 return sprintf(page, "%lu\n", mddev->bitmap_info.chunksize);
2164}
2165
2166static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002167chunksize_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11002168{
2169 /* Can only be changed when no bitmap is active */
2170 int rv;
2171 unsigned long csize;
2172 if (mddev->bitmap)
2173 return -EBUSY;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002174 rv = kstrtoul(buf, 10, &csize);
NeilBrown43a70502009-12-14 12:49:55 +11002175 if (rv)
2176 return rv;
2177 if (csize < 512 ||
2178 !is_power_of_2(csize))
2179 return -EINVAL;
2180 mddev->bitmap_info.chunksize = csize;
2181 return len;
2182}
2183
2184static struct md_sysfs_entry bitmap_chunksize =
2185__ATTR(chunksize, S_IRUGO|S_IWUSR, chunksize_show, chunksize_store);
2186
NeilBrownfd01b882011-10-11 16:47:53 +11002187static ssize_t metadata_show(struct mddev *mddev, char *page)
NeilBrownece5cff2009-12-14 12:49:56 +11002188{
2189 return sprintf(page, "%s\n", (mddev->bitmap_info.external
2190 ? "external" : "internal"));
2191}
2192
NeilBrownfd01b882011-10-11 16:47:53 +11002193static ssize_t metadata_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownece5cff2009-12-14 12:49:56 +11002194{
2195 if (mddev->bitmap ||
2196 mddev->bitmap_info.file ||
2197 mddev->bitmap_info.offset)
2198 return -EBUSY;
2199 if (strncmp(buf, "external", 8) == 0)
2200 mddev->bitmap_info.external = 1;
2201 else if (strncmp(buf, "internal", 8) == 0)
2202 mddev->bitmap_info.external = 0;
2203 else
2204 return -EINVAL;
2205 return len;
2206}
2207
2208static struct md_sysfs_entry bitmap_metadata =
2209__ATTR(metadata, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
2210
NeilBrownfd01b882011-10-11 16:47:53 +11002211static ssize_t can_clear_show(struct mddev *mddev, char *page)
NeilBrownece5cff2009-12-14 12:49:56 +11002212{
2213 int len;
NeilBrownb7b17c92014-12-15 12:56:59 +11002214 spin_lock(&mddev->lock);
NeilBrownece5cff2009-12-14 12:49:56 +11002215 if (mddev->bitmap)
2216 len = sprintf(page, "%s\n", (mddev->bitmap->need_sync ?
2217 "false" : "true"));
2218 else
2219 len = sprintf(page, "\n");
NeilBrownb7b17c92014-12-15 12:56:59 +11002220 spin_unlock(&mddev->lock);
NeilBrownece5cff2009-12-14 12:49:56 +11002221 return len;
2222}
2223
NeilBrownfd01b882011-10-11 16:47:53 +11002224static ssize_t can_clear_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownece5cff2009-12-14 12:49:56 +11002225{
2226 if (mddev->bitmap == NULL)
2227 return -ENOENT;
2228 if (strncmp(buf, "false", 5) == 0)
2229 mddev->bitmap->need_sync = 1;
2230 else if (strncmp(buf, "true", 4) == 0) {
2231 if (mddev->degraded)
2232 return -EBUSY;
2233 mddev->bitmap->need_sync = 0;
2234 } else
2235 return -EINVAL;
2236 return len;
2237}
2238
2239static struct md_sysfs_entry bitmap_can_clear =
2240__ATTR(can_clear, S_IRUGO|S_IWUSR, can_clear_show, can_clear_store);
2241
Paul Clements696fcd52010-03-08 16:02:37 +11002242static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002243behind_writes_used_show(struct mddev *mddev, char *page)
Paul Clements696fcd52010-03-08 16:02:37 +11002244{
NeilBrownb7b17c92014-12-15 12:56:59 +11002245 ssize_t ret;
2246 spin_lock(&mddev->lock);
Paul Clements696fcd52010-03-08 16:02:37 +11002247 if (mddev->bitmap == NULL)
NeilBrownb7b17c92014-12-15 12:56:59 +11002248 ret = sprintf(page, "0\n");
2249 else
2250 ret = sprintf(page, "%lu\n",
2251 mddev->bitmap->behind_writes_used);
2252 spin_unlock(&mddev->lock);
2253 return ret;
Paul Clements696fcd52010-03-08 16:02:37 +11002254}
2255
2256static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002257behind_writes_used_reset(struct mddev *mddev, const char *buf, size_t len)
Paul Clements696fcd52010-03-08 16:02:37 +11002258{
2259 if (mddev->bitmap)
2260 mddev->bitmap->behind_writes_used = 0;
2261 return len;
2262}
2263
2264static struct md_sysfs_entry max_backlog_used =
2265__ATTR(max_backlog_used, S_IRUGO | S_IWUSR,
2266 behind_writes_used_show, behind_writes_used_reset);
2267
NeilBrown43a70502009-12-14 12:49:55 +11002268static struct attribute *md_bitmap_attrs[] = {
2269 &bitmap_location.attr,
NeilBrown6409bb02012-05-22 13:55:07 +10002270 &bitmap_space.attr,
NeilBrown43a70502009-12-14 12:49:55 +11002271 &bitmap_timeout.attr,
2272 &bitmap_backlog.attr,
2273 &bitmap_chunksize.attr,
NeilBrownece5cff2009-12-14 12:49:56 +11002274 &bitmap_metadata.attr,
2275 &bitmap_can_clear.attr,
Paul Clements696fcd52010-03-08 16:02:37 +11002276 &max_backlog_used.attr,
NeilBrown43a70502009-12-14 12:49:55 +11002277 NULL
2278};
2279struct attribute_group md_bitmap_group = {
2280 .name = "bitmap",
2281 .attrs = md_bitmap_attrs,
2282};
2283