blob: c98f2fee1bd0c7eb7b4d06934047582c0763251a [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 */
NeilBrownac2f40b2010-06-01 19:37:31 +100048static int bitmap_checkpage(struct bitmap *bitmap,
49 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);
NeilBrown792a1d42012-03-19 12:46:41 +110075 mappage = kzalloc(PAGE_SIZE, GFP_NOIO);
NeilBrownac2f40b2010-06-01 19:37:31 +100076 spin_lock_irq(&bitmap->lock);
77
78 if (mappage == NULL) {
NeilBrown36a4e1f2011-10-07 14:23:17 +110079 pr_debug("%s: bitmap map page allocation failed, hijacking\n",
80 bmname(bitmap));
NeilBrown32a76272005-06-21 17:17:14 -070081 /* failed - set the hijacked flag so that we can use the
82 * pointer as a counter */
NeilBrown32a76272005-06-21 17:17:14 -070083 if (!bitmap->bp[page].map)
84 bitmap->bp[page].hijacked = 1;
NeilBrownac2f40b2010-06-01 19:37:31 +100085 } else if (bitmap->bp[page].map ||
86 bitmap->bp[page].hijacked) {
NeilBrown32a76272005-06-21 17:17:14 -070087 /* somebody beat us to getting the page */
NeilBrown792a1d42012-03-19 12:46:41 +110088 kfree(mappage);
NeilBrown32a76272005-06-21 17:17:14 -070089 return 0;
NeilBrownac2f40b2010-06-01 19:37:31 +100090 } else {
91
92 /* no page was in place and we have one, so install it */
93
94 bitmap->bp[page].map = mappage;
95 bitmap->missing_pages--;
NeilBrown32a76272005-06-21 17:17:14 -070096 }
NeilBrown32a76272005-06-21 17:17:14 -070097 return 0;
98}
99
NeilBrown32a76272005-06-21 17:17:14 -0700100/* if page is completely empty, put it back on the free list, or dealloc it */
101/* if page was hijacked, unmark the flag so it might get alloced next time */
102/* Note: lock should be held when calling this */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800103static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page)
NeilBrown32a76272005-06-21 17:17:14 -0700104{
105 char *ptr;
106
107 if (bitmap->bp[page].count) /* page is still busy */
108 return;
109
110 /* page is no longer in use, it can be released */
111
112 if (bitmap->bp[page].hijacked) { /* page was hijacked, undo this now */
113 bitmap->bp[page].hijacked = 0;
114 bitmap->bp[page].map = NULL;
NeilBrownac2f40b2010-06-01 19:37:31 +1000115 } else {
116 /* normal case, free the page */
117 ptr = bitmap->bp[page].map;
118 bitmap->bp[page].map = NULL;
119 bitmap->missing_pages++;
NeilBrown792a1d42012-03-19 12:46:41 +1100120 kfree(ptr);
NeilBrown32a76272005-06-21 17:17:14 -0700121 }
NeilBrown32a76272005-06-21 17:17:14 -0700122}
123
NeilBrown32a76272005-06-21 17:17:14 -0700124/*
125 * bitmap file handling - read and write the bitmap file and its superblock
126 */
127
NeilBrown32a76272005-06-21 17:17:14 -0700128/*
129 * basic page I/O operations
130 */
131
NeilBrowna654b9d82005-06-21 17:17:27 -0700132/* IO operations when bitmap is stored near all superblocks */
NeilBrown27581e52012-05-22 13:55:08 +1000133static int read_sb_page(struct mddev *mddev, loff_t offset,
134 struct page *page,
135 unsigned long index, int size)
NeilBrowna654b9d82005-06-21 17:17:27 -0700136{
137 /* choose a good rdev and read the page from there */
138
NeilBrown3cb03002011-10-11 16:45:26 +1100139 struct md_rdev *rdev;
NeilBrowna654b9d82005-06-21 17:17:27 -0700140 sector_t target;
NeilBrowna654b9d82005-06-21 17:17:27 -0700141
NeilBrowndafb20f2012-03-19 12:46:39 +1100142 rdev_for_each(rdev, mddev) {
NeilBrownb2d444d2005-11-08 21:39:31 -0800143 if (! test_bit(In_sync, &rdev->flags)
144 || test_bit(Faulty, &rdev->flags))
NeilBrownab904d62005-09-09 16:23:52 -0700145 continue;
146
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100147 target = offset + index * (PAGE_SIZE/512);
NeilBrowna654b9d82005-06-21 17:17:27 -0700148
NeilBrown2b193362010-10-27 15:16:40 +1100149 if (sync_page_io(rdev, target,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400150 roundup(size, bdev_logical_block_size(rdev->bdev)),
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100151 page, READ, true)) {
NeilBrownab904d62005-09-09 16:23:52 -0700152 page->index = index;
NeilBrown27581e52012-05-22 13:55:08 +1000153 return 0;
NeilBrownab904d62005-09-09 16:23:52 -0700154 }
155 }
NeilBrown27581e52012-05-22 13:55:08 +1000156 return -EIO;
NeilBrowna654b9d82005-06-21 17:17:27 -0700157}
158
NeilBrownfd01b882011-10-11 16:47:53 +1100159static struct md_rdev *next_active_rdev(struct md_rdev *rdev, struct mddev *mddev)
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000160{
161 /* Iterate the disks of an mddev, using rcu to protect access to the
162 * linked list, and raising the refcount of devices we return to ensure
163 * they don't disappear while in use.
164 * As devices are only added or removed when raid_disk is < 0 and
165 * nr_pending is 0 and In_sync is clear, the entries we return will
166 * still be in the same position on the list when we re-enter
167 * list_for_each_continue_rcu.
168 */
169 struct list_head *pos;
170 rcu_read_lock();
171 if (rdev == NULL)
172 /* start at the beginning */
173 pos = &mddev->disks;
174 else {
175 /* release the previous rdev and start from there. */
176 rdev_dec_pending(rdev, mddev);
177 pos = &rdev->same_set;
178 }
179 list_for_each_continue_rcu(pos, &mddev->disks) {
NeilBrown3cb03002011-10-11 16:45:26 +1100180 rdev = list_entry(pos, struct md_rdev, same_set);
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000181 if (rdev->raid_disk >= 0 &&
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000182 !test_bit(Faulty, &rdev->flags)) {
183 /* this is a usable devices */
184 atomic_inc(&rdev->nr_pending);
185 rcu_read_unlock();
186 return rdev;
187 }
188 }
189 rcu_read_unlock();
190 return NULL;
191}
192
NeilBrownab6085c2007-05-23 13:58:10 -0700193static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
NeilBrowna654b9d82005-06-21 17:17:27 -0700194{
NeilBrown3cb03002011-10-11 16:45:26 +1100195 struct md_rdev *rdev = NULL;
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100196 struct block_device *bdev;
NeilBrownfd01b882011-10-11 16:47:53 +1100197 struct mddev *mddev = bitmap->mddev;
NeilBrown1ec885c2012-05-22 13:55:10 +1000198 struct bitmap_storage *store = &bitmap->storage;
NeilBrowna654b9d82005-06-21 17:17:27 -0700199
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000200 while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
NeilBrownac2f40b2010-06-01 19:37:31 +1000201 int size = PAGE_SIZE;
202 loff_t offset = mddev->bitmap_info.offset;
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100203
204 bdev = (rdev->meta_bdev) ? rdev->meta_bdev : rdev->bdev;
205
NeilBrown1ec885c2012-05-22 13:55:10 +1000206 if (page->index == store->file_pages-1)
207 size = roundup(store->last_page_size,
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100208 bdev_logical_block_size(bdev));
NeilBrownac2f40b2010-06-01 19:37:31 +1000209 /* Just make sure we aren't corrupting data or
210 * metadata
211 */
212 if (mddev->external) {
213 /* Bitmap could be anywhere. */
214 if (rdev->sb_start + offset + (page->index
215 * (PAGE_SIZE/512))
216 > rdev->data_offset
217 &&
218 rdev->sb_start + offset
219 < (rdev->data_offset + mddev->dev_sectors
220 + (PAGE_SIZE/512)))
221 goto bad_alignment;
222 } else if (offset < 0) {
223 /* DATA BITMAP METADATA */
224 if (offset
225 + (long)(page->index * (PAGE_SIZE/512))
226 + size/512 > 0)
227 /* bitmap runs in to metadata */
228 goto bad_alignment;
229 if (rdev->data_offset + mddev->dev_sectors
230 > rdev->sb_start + offset)
231 /* data runs in to bitmap */
232 goto bad_alignment;
233 } else if (rdev->sb_start < rdev->data_offset) {
234 /* METADATA BITMAP DATA */
235 if (rdev->sb_start
236 + offset
237 + page->index*(PAGE_SIZE/512) + size/512
238 > rdev->data_offset)
239 /* bitmap runs in to data */
240 goto bad_alignment;
241 } else {
242 /* DATA METADATA BITMAP - no problems */
243 }
244 md_super_write(mddev, rdev,
245 rdev->sb_start + offset
246 + page->index * (PAGE_SIZE/512),
247 size,
248 page);
NeilBrownb2d2c4c2008-09-01 12:48:13 +1000249 }
NeilBrowna654b9d82005-06-21 17:17:27 -0700250
251 if (wait)
NeilBrowna9701a32005-11-08 21:39:34 -0800252 md_super_wait(mddev);
NeilBrowna654b9d82005-06-21 17:17:27 -0700253 return 0;
NeilBrown4b809912008-07-21 17:05:25 +1000254
255 bad_alignment:
NeilBrown4b809912008-07-21 17:05:25 +1000256 return -EINVAL;
NeilBrowna654b9d82005-06-21 17:17:27 -0700257}
258
NeilBrown4ad13662007-07-17 04:06:13 -0700259static void bitmap_file_kick(struct bitmap *bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700260/*
NeilBrowna654b9d82005-06-21 17:17:27 -0700261 * write out a page to a file
NeilBrown32a76272005-06-21 17:17:14 -0700262 */
NeilBrown4ad13662007-07-17 04:06:13 -0700263static void write_page(struct bitmap *bitmap, struct page *page, int wait)
NeilBrown32a76272005-06-21 17:17:14 -0700264{
NeilBrownd785a062006-06-26 00:27:48 -0700265 struct buffer_head *bh;
NeilBrown32a76272005-06-21 17:17:14 -0700266
NeilBrown1ec885c2012-05-22 13:55:10 +1000267 if (bitmap->storage.file == NULL) {
NeilBrownf0d76d72007-07-17 04:06:12 -0700268 switch (write_sb_page(bitmap, page, wait)) {
269 case -EINVAL:
270 bitmap->flags |= BITMAP_WRITE_ERROR;
NeilBrownf0d76d72007-07-17 04:06:12 -0700271 }
NeilBrown4ad13662007-07-17 04:06:13 -0700272 } else {
NeilBrowna654b9d82005-06-21 17:17:27 -0700273
NeilBrown4ad13662007-07-17 04:06:13 -0700274 bh = page_buffers(page);
NeilBrownc7084432006-01-06 00:20:45 -0800275
NeilBrown4ad13662007-07-17 04:06:13 -0700276 while (bh && bh->b_blocknr) {
277 atomic_inc(&bitmap->pending_writes);
278 set_buffer_locked(bh);
279 set_buffer_mapped(bh);
Jens Axboe721a9602011-03-09 11:56:30 +0100280 submit_bh(WRITE | REQ_SYNC, bh);
NeilBrown4ad13662007-07-17 04:06:13 -0700281 bh = bh->b_this_page;
282 }
NeilBrown32a76272005-06-21 17:17:14 -0700283
NeilBrownac2f40b2010-06-01 19:37:31 +1000284 if (wait)
NeilBrown4ad13662007-07-17 04:06:13 -0700285 wait_event(bitmap->write_wait,
286 atomic_read(&bitmap->pending_writes)==0);
NeilBrown32a76272005-06-21 17:17:14 -0700287 }
NeilBrown4ad13662007-07-17 04:06:13 -0700288 if (bitmap->flags & BITMAP_WRITE_ERROR)
289 bitmap_file_kick(bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700290}
291
NeilBrownd785a062006-06-26 00:27:48 -0700292static void end_bitmap_write(struct buffer_head *bh, int uptodate)
NeilBrown32a76272005-06-21 17:17:14 -0700293{
NeilBrownd785a062006-06-26 00:27:48 -0700294 struct bitmap *bitmap = bh->b_private;
295 unsigned long flags;
296
297 if (!uptodate) {
298 spin_lock_irqsave(&bitmap->lock, flags);
299 bitmap->flags |= BITMAP_WRITE_ERROR;
300 spin_unlock_irqrestore(&bitmap->lock, flags);
301 }
302 if (atomic_dec_and_test(&bitmap->pending_writes))
303 wake_up(&bitmap->write_wait);
304}
305
306/* copied from buffer.c */
307static void
308__clear_page_buffers(struct page *page)
309{
310 ClearPagePrivate(page);
311 set_page_private(page, 0);
312 page_cache_release(page);
313}
314static void free_buffers(struct page *page)
315{
NeilBrown27581e52012-05-22 13:55:08 +1000316 struct buffer_head *bh;
NeilBrownd785a062006-06-26 00:27:48 -0700317
NeilBrown27581e52012-05-22 13:55:08 +1000318 if (!PagePrivate(page))
319 return;
320
321 bh = page_buffers(page);
NeilBrownd785a062006-06-26 00:27:48 -0700322 while (bh) {
323 struct buffer_head *next = bh->b_this_page;
324 free_buffer_head(bh);
325 bh = next;
326 }
327 __clear_page_buffers(page);
328 put_page(page);
329}
330
331/* read a page from a file.
332 * We both read the page, and attach buffers to the page to record the
333 * address of each block (using bmap). These addresses will be used
334 * to write the block later, completely bypassing the filesystem.
335 * This usage is similar to how swap files are handled, and allows us
336 * to write to a file with no concerns of memory allocation failing.
337 */
NeilBrown27581e52012-05-22 13:55:08 +1000338static int read_page(struct file *file, unsigned long index,
339 struct bitmap *bitmap,
340 unsigned long count,
341 struct page *page)
NeilBrownd785a062006-06-26 00:27:48 -0700342{
NeilBrown27581e52012-05-22 13:55:08 +1000343 int ret = 0;
Josef Sipekc649bb92006-12-08 02:37:19 -0800344 struct inode *inode = file->f_path.dentry->d_inode;
NeilBrownd785a062006-06-26 00:27:48 -0700345 struct buffer_head *bh;
346 sector_t block;
NeilBrown32a76272005-06-21 17:17:14 -0700347
NeilBrown36a4e1f2011-10-07 14:23:17 +1100348 pr_debug("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,
349 (unsigned long long)index << PAGE_SHIFT);
NeilBrown32a76272005-06-21 17:17:14 -0700350
NeilBrownd785a062006-06-26 00:27:48 -0700351 bh = alloc_page_buffers(page, 1<<inode->i_blkbits, 0);
352 if (!bh) {
NeilBrown27581e52012-05-22 13:55:08 +1000353 ret = -ENOMEM;
NeilBrownd785a062006-06-26 00:27:48 -0700354 goto out;
355 }
356 attach_page_buffers(page, bh);
357 block = index << (PAGE_SHIFT - inode->i_blkbits);
358 while (bh) {
359 if (count == 0)
360 bh->b_blocknr = 0;
361 else {
362 bh->b_blocknr = bmap(inode, block);
363 if (bh->b_blocknr == 0) {
364 /* Cannot use this file! */
NeilBrown27581e52012-05-22 13:55:08 +1000365 ret = -EINVAL;
NeilBrownd785a062006-06-26 00:27:48 -0700366 goto out;
367 }
368 bh->b_bdev = inode->i_sb->s_bdev;
369 if (count < (1<<inode->i_blkbits))
370 count = 0;
371 else
372 count -= (1<<inode->i_blkbits);
NeilBrown32a76272005-06-21 17:17:14 -0700373
NeilBrownd785a062006-06-26 00:27:48 -0700374 bh->b_end_io = end_bitmap_write;
375 bh->b_private = bitmap;
NeilBrownce25c312006-06-26 00:27:49 -0700376 atomic_inc(&bitmap->pending_writes);
377 set_buffer_locked(bh);
378 set_buffer_mapped(bh);
379 submit_bh(READ, bh);
NeilBrownd785a062006-06-26 00:27:48 -0700380 }
381 block++;
382 bh = bh->b_this_page;
383 }
NeilBrownd785a062006-06-26 00:27:48 -0700384 page->index = index;
NeilBrownce25c312006-06-26 00:27:49 -0700385
386 wait_event(bitmap->write_wait,
387 atomic_read(&bitmap->pending_writes)==0);
NeilBrown27581e52012-05-22 13:55:08 +1000388 if (bitmap->flags & BITMAP_WRITE_ERROR)
389 ret = -EIO;
NeilBrown32a76272005-06-21 17:17:14 -0700390out:
NeilBrown27581e52012-05-22 13:55:08 +1000391 if (ret)
392 printk(KERN_ALERT "md: bitmap read error: (%dB @ %llu): %d\n",
NeilBrown2d1f3b52006-01-06 00:20:31 -0800393 (int)PAGE_SIZE,
394 (unsigned long long)index << PAGE_SHIFT,
NeilBrown27581e52012-05-22 13:55:08 +1000395 ret);
396 return ret;
NeilBrown32a76272005-06-21 17:17:14 -0700397}
398
399/*
400 * bitmap file superblock operations
401 */
402
403/* update the event counter and sync the superblock to disk */
NeilBrown4ad13662007-07-17 04:06:13 -0700404void bitmap_update_sb(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -0700405{
406 bitmap_super_t *sb;
NeilBrown32a76272005-06-21 17:17:14 -0700407
408 if (!bitmap || !bitmap->mddev) /* no bitmap for this array */
NeilBrown4ad13662007-07-17 04:06:13 -0700409 return;
NeilBrownece5cff2009-12-14 12:49:56 +1100410 if (bitmap->mddev->bitmap_info.external)
411 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000412 if (!bitmap->storage.sb_page) /* no superblock */
NeilBrown4ad13662007-07-17 04:06:13 -0700413 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000414 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700415 sb->events = cpu_to_le64(bitmap->mddev->events);
NeilBrown8258c532011-05-11 14:26:30 +1000416 if (bitmap->mddev->events < bitmap->events_cleared)
Neil Browna0da84f2008-06-28 08:31:22 +1000417 /* rocking back to read-only */
418 bitmap->events_cleared = bitmap->mddev->events;
NeilBrown8258c532011-05-11 14:26:30 +1000419 sb->events_cleared = cpu_to_le64(bitmap->events_cleared);
420 sb->state = cpu_to_le32(bitmap->flags);
NeilBrown43a70502009-12-14 12:49:55 +1100421 /* Just in case these have been changed via sysfs: */
422 sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);
423 sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);
Cong Wangb2f46e62011-11-28 13:25:44 +0800424 kunmap_atomic(sb);
NeilBrown1ec885c2012-05-22 13:55:10 +1000425 write_page(bitmap, bitmap->storage.sb_page, 1);
NeilBrown32a76272005-06-21 17:17:14 -0700426}
427
428/* print out the bitmap file superblock */
429void bitmap_print_sb(struct bitmap *bitmap)
430{
431 bitmap_super_t *sb;
432
NeilBrown1ec885c2012-05-22 13:55:10 +1000433 if (!bitmap || !bitmap->storage.sb_page)
NeilBrown32a76272005-06-21 17:17:14 -0700434 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000435 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700436 printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
NeilBrowna2cff262005-06-21 17:17:20 -0700437 printk(KERN_DEBUG " magic: %08x\n", le32_to_cpu(sb->magic));
438 printk(KERN_DEBUG " version: %d\n", le32_to_cpu(sb->version));
439 printk(KERN_DEBUG " uuid: %08x.%08x.%08x.%08x\n",
NeilBrown32a76272005-06-21 17:17:14 -0700440 *(__u32 *)(sb->uuid+0),
441 *(__u32 *)(sb->uuid+4),
442 *(__u32 *)(sb->uuid+8),
443 *(__u32 *)(sb->uuid+12));
NeilBrowna2cff262005-06-21 17:17:20 -0700444 printk(KERN_DEBUG " events: %llu\n",
NeilBrown32a76272005-06-21 17:17:14 -0700445 (unsigned long long) le64_to_cpu(sb->events));
NeilBrowna2cff262005-06-21 17:17:20 -0700446 printk(KERN_DEBUG "events cleared: %llu\n",
NeilBrown32a76272005-06-21 17:17:14 -0700447 (unsigned long long) le64_to_cpu(sb->events_cleared));
NeilBrowna2cff262005-06-21 17:17:20 -0700448 printk(KERN_DEBUG " state: %08x\n", le32_to_cpu(sb->state));
449 printk(KERN_DEBUG " chunksize: %d B\n", le32_to_cpu(sb->chunksize));
450 printk(KERN_DEBUG " daemon sleep: %ds\n", le32_to_cpu(sb->daemon_sleep));
451 printk(KERN_DEBUG " sync size: %llu KB\n",
452 (unsigned long long)le64_to_cpu(sb->sync_size)/2);
NeilBrown4b6d2872005-09-09 16:23:47 -0700453 printk(KERN_DEBUG "max write behind: %d\n", le32_to_cpu(sb->write_behind));
Cong Wangb2f46e62011-11-28 13:25:44 +0800454 kunmap_atomic(sb);
NeilBrown32a76272005-06-21 17:17:14 -0700455}
456
Jonathan Brassow9c810752011-06-08 17:59:30 -0500457/*
458 * bitmap_new_disk_sb
459 * @bitmap
460 *
461 * This function is somewhat the reverse of bitmap_read_sb. bitmap_read_sb
462 * reads and verifies the on-disk bitmap superblock and populates bitmap_info.
463 * This function verifies 'bitmap_info' and populates the on-disk bitmap
464 * structure, which is to be written to disk.
465 *
466 * Returns: 0 on success, -Exxx on error
467 */
468static int bitmap_new_disk_sb(struct bitmap *bitmap)
469{
470 bitmap_super_t *sb;
471 unsigned long chunksize, daemon_sleep, write_behind;
472 int err = -EINVAL;
473
NeilBrown1ec885c2012-05-22 13:55:10 +1000474 bitmap->storage.sb_page = alloc_page(GFP_KERNEL);
475 if (IS_ERR(bitmap->storage.sb_page)) {
476 err = PTR_ERR(bitmap->storage.sb_page);
477 bitmap->storage.sb_page = NULL;
Jonathan Brassow9c810752011-06-08 17:59:30 -0500478 return err;
479 }
NeilBrown1ec885c2012-05-22 13:55:10 +1000480 bitmap->storage.sb_page->index = 0;
Jonathan Brassow9c810752011-06-08 17:59:30 -0500481
NeilBrown1ec885c2012-05-22 13:55:10 +1000482 sb = kmap_atomic(bitmap->storage.sb_page);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500483
484 sb->magic = cpu_to_le32(BITMAP_MAGIC);
485 sb->version = cpu_to_le32(BITMAP_MAJOR_HI);
486
487 chunksize = bitmap->mddev->bitmap_info.chunksize;
488 BUG_ON(!chunksize);
489 if (!is_power_of_2(chunksize)) {
Cong Wangb2f46e62011-11-28 13:25:44 +0800490 kunmap_atomic(sb);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500491 printk(KERN_ERR "bitmap chunksize not a power of 2\n");
492 return -EINVAL;
493 }
494 sb->chunksize = cpu_to_le32(chunksize);
495
496 daemon_sleep = bitmap->mddev->bitmap_info.daemon_sleep;
497 if (!daemon_sleep ||
498 (daemon_sleep < 1) || (daemon_sleep > MAX_SCHEDULE_TIMEOUT)) {
499 printk(KERN_INFO "Choosing daemon_sleep default (5 sec)\n");
500 daemon_sleep = 5 * HZ;
501 }
502 sb->daemon_sleep = cpu_to_le32(daemon_sleep);
503 bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
504
505 /*
506 * FIXME: write_behind for RAID1. If not specified, what
507 * is a good choice? We choose COUNTER_MAX / 2 arbitrarily.
508 */
509 write_behind = bitmap->mddev->bitmap_info.max_write_behind;
510 if (write_behind > COUNTER_MAX)
511 write_behind = COUNTER_MAX / 2;
512 sb->write_behind = cpu_to_le32(write_behind);
513 bitmap->mddev->bitmap_info.max_write_behind = write_behind;
514
515 /* keep the array size field of the bitmap superblock up to date */
516 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
517
518 memcpy(sb->uuid, bitmap->mddev->uuid, 16);
519
520 bitmap->flags |= BITMAP_STALE;
521 sb->state |= cpu_to_le32(BITMAP_STALE);
522 bitmap->events_cleared = bitmap->mddev->events;
523 sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
524
Cong Wangb2f46e62011-11-28 13:25:44 +0800525 kunmap_atomic(sb);
Jonathan Brassow9c810752011-06-08 17:59:30 -0500526
527 return 0;
528}
529
NeilBrown32a76272005-06-21 17:17:14 -0700530/* read the superblock from the bitmap file and initialize some bitmap fields */
531static int bitmap_read_sb(struct bitmap *bitmap)
532{
533 char *reason = NULL;
534 bitmap_super_t *sb;
NeilBrown4b6d2872005-09-09 16:23:47 -0700535 unsigned long chunksize, daemon_sleep, write_behind;
NeilBrown32a76272005-06-21 17:17:14 -0700536 unsigned long long events;
537 int err = -EINVAL;
NeilBrown27581e52012-05-22 13:55:08 +1000538 struct page *sb_page;
NeilBrown32a76272005-06-21 17:17:14 -0700539
NeilBrown1ec885c2012-05-22 13:55:10 +1000540 if (!bitmap->storage.file && !bitmap->mddev->bitmap_info.offset) {
NeilBrownef99bf42012-05-22 13:55:08 +1000541 chunksize = 128 * 1024 * 1024;
542 daemon_sleep = 5 * HZ;
543 write_behind = 0;
544 bitmap->flags = BITMAP_STALE;
545 err = 0;
546 goto out_no_sb;
547 }
NeilBrown32a76272005-06-21 17:17:14 -0700548 /* page 0 is the superblock, read it... */
NeilBrown27581e52012-05-22 13:55:08 +1000549 sb_page = alloc_page(GFP_KERNEL);
550 if (!sb_page)
551 return -ENOMEM;
NeilBrown1ec885c2012-05-22 13:55:10 +1000552 bitmap->storage.sb_page = sb_page;
NeilBrown27581e52012-05-22 13:55:08 +1000553
NeilBrown1ec885c2012-05-22 13:55:10 +1000554 if (bitmap->storage.file) {
555 loff_t isize = i_size_read(bitmap->storage.file->f_mapping->host);
NeilBrownf49d5e62007-01-26 00:57:03 -0800556 int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;
557
NeilBrown1ec885c2012-05-22 13:55:10 +1000558 err = read_page(bitmap->storage.file, 0,
NeilBrown27581e52012-05-22 13:55:08 +1000559 bitmap, bytes, sb_page);
NeilBrownf49d5e62007-01-26 00:57:03 -0800560 } else {
NeilBrown27581e52012-05-22 13:55:08 +1000561 err = read_sb_page(bitmap->mddev,
562 bitmap->mddev->bitmap_info.offset,
563 sb_page,
564 0, sizeof(bitmap_super_t));
NeilBrowna654b9d82005-06-21 17:17:27 -0700565 }
NeilBrown27581e52012-05-22 13:55:08 +1000566 if (err)
NeilBrown32a76272005-06-21 17:17:14 -0700567 return err;
NeilBrown32a76272005-06-21 17:17:14 -0700568
NeilBrown27581e52012-05-22 13:55:08 +1000569 sb = kmap_atomic(sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700570
NeilBrown32a76272005-06-21 17:17:14 -0700571 chunksize = le32_to_cpu(sb->chunksize);
NeilBrown1b04be92009-12-14 12:49:53 +1100572 daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
NeilBrown4b6d2872005-09-09 16:23:47 -0700573 write_behind = le32_to_cpu(sb->write_behind);
NeilBrown32a76272005-06-21 17:17:14 -0700574
575 /* verify that the bitmap-specific fields are valid */
576 if (sb->magic != cpu_to_le32(BITMAP_MAGIC))
577 reason = "bad magic";
NeilBrownbd926c62005-11-08 21:39:32 -0800578 else if (le32_to_cpu(sb->version) < BITMAP_MAJOR_LO ||
579 le32_to_cpu(sb->version) > BITMAP_MAJOR_HI)
NeilBrown32a76272005-06-21 17:17:14 -0700580 reason = "unrecognized superblock version";
NeilBrown1187cf02009-03-31 14:27:02 +1100581 else if (chunksize < 512)
NeilBrown7dd5d342006-01-06 00:20:39 -0800582 reason = "bitmap chunksize too small";
Jonathan Brassowd7445402011-06-08 18:01:10 -0500583 else if (!is_power_of_2(chunksize))
NeilBrown32a76272005-06-21 17:17:14 -0700584 reason = "bitmap chunksize not a power of 2";
NeilBrown1b04be92009-12-14 12:49:53 +1100585 else if (daemon_sleep < 1 || daemon_sleep > MAX_SCHEDULE_TIMEOUT)
NeilBrown7dd5d342006-01-06 00:20:39 -0800586 reason = "daemon sleep period out of range";
NeilBrown4b6d2872005-09-09 16:23:47 -0700587 else if (write_behind > COUNTER_MAX)
588 reason = "write-behind limit out of range (0 - 16383)";
NeilBrown32a76272005-06-21 17:17:14 -0700589 if (reason) {
590 printk(KERN_INFO "%s: invalid bitmap file superblock: %s\n",
591 bmname(bitmap), reason);
592 goto out;
593 }
594
595 /* keep the array size field of the bitmap superblock up to date */
596 sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);
597
NeilBrown278c1ca2012-03-19 12:46:40 +1100598 if (bitmap->mddev->persistent) {
599 /*
600 * We have a persistent array superblock, so compare the
601 * bitmap's UUID and event counter to the mddev's
602 */
603 if (memcmp(sb->uuid, bitmap->mddev->uuid, 16)) {
604 printk(KERN_INFO
605 "%s: bitmap superblock UUID mismatch\n",
606 bmname(bitmap));
607 goto out;
608 }
609 events = le64_to_cpu(sb->events);
610 if (events < bitmap->mddev->events) {
611 printk(KERN_INFO
612 "%s: bitmap file is out of date (%llu < %llu) "
613 "-- forcing full recovery\n",
614 bmname(bitmap), events,
615 (unsigned long long) bitmap->mddev->events);
616 sb->state |= cpu_to_le32(BITMAP_STALE);
617 }
618 }
NeilBrown32a76272005-06-21 17:17:14 -0700619
NeilBrown32a76272005-06-21 17:17:14 -0700620 /* assign fields using values from superblock */
NeilBrown4f2e6392006-10-21 10:24:09 -0700621 bitmap->flags |= le32_to_cpu(sb->state);
NeilBrownbd926c62005-11-08 21:39:32 -0800622 if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)
623 bitmap->flags |= BITMAP_HOSTENDIAN;
NeilBrown32a76272005-06-21 17:17:14 -0700624 bitmap->events_cleared = le64_to_cpu(sb->events_cleared);
625 err = 0;
626out:
Cong Wangb2f46e62011-11-28 13:25:44 +0800627 kunmap_atomic(sb);
NeilBrownef99bf42012-05-22 13:55:08 +1000628out_no_sb:
629 if (bitmap->flags & BITMAP_STALE)
630 bitmap->events_cleared = bitmap->mddev->events;
631 bitmap->mddev->bitmap_info.chunksize = chunksize;
632 bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
633 bitmap->mddev->bitmap_info.max_write_behind = write_behind;
NeilBrown32a76272005-06-21 17:17:14 -0700634 if (err)
635 bitmap_print_sb(bitmap);
636 return err;
637}
638
639enum bitmap_mask_op {
640 MASK_SET,
641 MASK_UNSET
642};
643
NeilBrown4ad13662007-07-17 04:06:13 -0700644/* record the state of the bitmap in the superblock. Return the old value */
645static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
646 enum bitmap_mask_op op)
NeilBrown32a76272005-06-21 17:17:14 -0700647{
648 bitmap_super_t *sb;
NeilBrown4ad13662007-07-17 04:06:13 -0700649 int old;
NeilBrown32a76272005-06-21 17:17:14 -0700650
NeilBrown1ec885c2012-05-22 13:55:10 +1000651 if (!bitmap->storage.sb_page) /* can't set the state */
NeilBrown4ad13662007-07-17 04:06:13 -0700652 return 0;
NeilBrown1ec885c2012-05-22 13:55:10 +1000653 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrown4ad13662007-07-17 04:06:13 -0700654 old = le32_to_cpu(sb->state) & bits;
NeilBrown32a76272005-06-21 17:17:14 -0700655 switch (op) {
NeilBrownac2f40b2010-06-01 19:37:31 +1000656 case MASK_SET:
657 sb->state |= cpu_to_le32(bits);
NeilBrown8258c532011-05-11 14:26:30 +1000658 bitmap->flags |= bits;
NeilBrownac2f40b2010-06-01 19:37:31 +1000659 break;
660 case MASK_UNSET:
661 sb->state &= cpu_to_le32(~bits);
NeilBrown8258c532011-05-11 14:26:30 +1000662 bitmap->flags &= ~bits;
NeilBrownac2f40b2010-06-01 19:37:31 +1000663 break;
664 default:
665 BUG();
NeilBrown32a76272005-06-21 17:17:14 -0700666 }
Cong Wangb2f46e62011-11-28 13:25:44 +0800667 kunmap_atomic(sb);
NeilBrown4ad13662007-07-17 04:06:13 -0700668 return old;
NeilBrown32a76272005-06-21 17:17:14 -0700669}
670
671/*
672 * general bitmap file operations
673 */
674
NeilBrownece5cff2009-12-14 12:49:56 +1100675/*
676 * on-disk bitmap:
677 *
678 * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap
679 * file a page at a time. There's a superblock at the start of the file.
680 */
NeilBrown32a76272005-06-21 17:17:14 -0700681/* calculate the index of the page that contains this bit */
NeilBrown1ec885c2012-05-22 13:55:10 +1000682static inline unsigned long file_page_index(struct bitmap_storage *store,
683 unsigned long chunk)
NeilBrown32a76272005-06-21 17:17:14 -0700684{
NeilBrown1ec885c2012-05-22 13:55:10 +1000685 if (store->sb_page)
NeilBrownece5cff2009-12-14 12:49:56 +1100686 chunk += sizeof(bitmap_super_t) << 3;
687 return chunk >> PAGE_BIT_SHIFT;
NeilBrown32a76272005-06-21 17:17:14 -0700688}
689
690/* calculate the (bit) offset of this bit within a page */
NeilBrown1ec885c2012-05-22 13:55:10 +1000691static inline unsigned long file_page_offset(struct bitmap_storage *store,
692 unsigned long chunk)
NeilBrown32a76272005-06-21 17:17:14 -0700693{
NeilBrown1ec885c2012-05-22 13:55:10 +1000694 if (store->sb_page)
NeilBrownece5cff2009-12-14 12:49:56 +1100695 chunk += sizeof(bitmap_super_t) << 3;
696 return chunk & (PAGE_BITS - 1);
NeilBrown32a76272005-06-21 17:17:14 -0700697}
698
699/*
700 * return a pointer to the page in the filemap that contains the given bit
701 *
702 * this lookup is complicated by the fact that the bitmap sb might be exactly
703 * 1 page (e.g., x86) or less than 1 page -- so the bitmap might start on page
704 * 0 or page 1
705 */
NeilBrown1ec885c2012-05-22 13:55:10 +1000706static inline struct page *filemap_get_page(struct bitmap_storage *store,
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000707 unsigned long chunk)
NeilBrown32a76272005-06-21 17:17:14 -0700708{
NeilBrown1ec885c2012-05-22 13:55:10 +1000709 if (file_page_index(store, chunk) >= store->file_pages)
NeilBrownac2f40b2010-06-01 19:37:31 +1000710 return NULL;
NeilBrown1ec885c2012-05-22 13:55:10 +1000711 return store->filemap[file_page_index(store, chunk)
712 - file_page_index(store, 0)];
NeilBrown32a76272005-06-21 17:17:14 -0700713}
714
NeilBrown32a76272005-06-21 17:17:14 -0700715static void bitmap_file_unmap(struct bitmap *bitmap)
716{
717 struct page **map, *sb_page;
718 unsigned long *attr;
719 int pages;
720 unsigned long flags;
NeilBrown1ec885c2012-05-22 13:55:10 +1000721 struct bitmap_storage *store = &bitmap->storage;
NeilBrown32a76272005-06-21 17:17:14 -0700722
723 spin_lock_irqsave(&bitmap->lock, flags);
NeilBrown1ec885c2012-05-22 13:55:10 +1000724 map = store->filemap;
725 store->filemap = NULL;
726 attr = store->filemap_attr;
727 store->filemap_attr = NULL;
728 pages = store->file_pages;
729 store->file_pages = 0;
730 sb_page = store->sb_page;
731 store->sb_page = NULL;
NeilBrown32a76272005-06-21 17:17:14 -0700732 spin_unlock_irqrestore(&bitmap->lock, flags);
733
734 while (pages--)
NeilBrownece5cff2009-12-14 12:49:56 +1100735 if (map[pages] != sb_page) /* 0 is sb_page, release it below */
NeilBrownd785a062006-06-26 00:27:48 -0700736 free_buffers(map[pages]);
NeilBrown32a76272005-06-21 17:17:14 -0700737 kfree(map);
738 kfree(attr);
739
NeilBrownd785a062006-06-26 00:27:48 -0700740 if (sb_page)
741 free_buffers(sb_page);
NeilBrown32a76272005-06-21 17:17:14 -0700742}
743
744static void bitmap_file_put(struct bitmap *bitmap)
745{
746 struct file *file;
NeilBrown32a76272005-06-21 17:17:14 -0700747 unsigned long flags;
748
749 spin_lock_irqsave(&bitmap->lock, flags);
NeilBrown1ec885c2012-05-22 13:55:10 +1000750 file = bitmap->storage.file;
751 bitmap->storage.file = NULL;
NeilBrown32a76272005-06-21 17:17:14 -0700752 spin_unlock_irqrestore(&bitmap->lock, flags);
753
NeilBrownd785a062006-06-26 00:27:48 -0700754 if (file)
755 wait_event(bitmap->write_wait,
756 atomic_read(&bitmap->pending_writes)==0);
NeilBrown32a76272005-06-21 17:17:14 -0700757 bitmap_file_unmap(bitmap);
758
NeilBrownd785a062006-06-26 00:27:48 -0700759 if (file) {
Josef Sipekc649bb92006-12-08 02:37:19 -0800760 struct inode *inode = file->f_path.dentry->d_inode;
Andrew Mortonfc0ecff2007-02-10 01:45:39 -0800761 invalidate_mapping_pages(inode->i_mapping, 0, -1);
NeilBrown32a76272005-06-21 17:17:14 -0700762 fput(file);
NeilBrownd785a062006-06-26 00:27:48 -0700763 }
NeilBrown32a76272005-06-21 17:17:14 -0700764}
765
NeilBrown32a76272005-06-21 17:17:14 -0700766/*
767 * bitmap_file_kick - if an error occurs while manipulating the bitmap file
768 * then it is no longer reliable, so we stop using it and we mark the file
769 * as failed in the superblock
770 */
771static void bitmap_file_kick(struct bitmap *bitmap)
772{
773 char *path, *ptr = NULL;
774
NeilBrown4ad13662007-07-17 04:06:13 -0700775 if (bitmap_mask_state(bitmap, BITMAP_STALE, MASK_SET) == 0) {
776 bitmap_update_sb(bitmap);
NeilBrown32a76272005-06-21 17:17:14 -0700777
NeilBrown1ec885c2012-05-22 13:55:10 +1000778 if (bitmap->storage.file) {
NeilBrown4ad13662007-07-17 04:06:13 -0700779 path = kmalloc(PAGE_SIZE, GFP_KERNEL);
780 if (path)
NeilBrown1ec885c2012-05-22 13:55:10 +1000781 ptr = d_path(&bitmap->storage.file->f_path,
782 path, PAGE_SIZE);
Christoph Hellwig6bcfd602008-05-23 13:04:34 -0700783
NeilBrown4ad13662007-07-17 04:06:13 -0700784 printk(KERN_ALERT
785 "%s: kicking failed bitmap file %s from array!\n",
Christoph Hellwig6bcfd602008-05-23 13:04:34 -0700786 bmname(bitmap), IS_ERR(ptr) ? "" : ptr);
NeilBrown32a76272005-06-21 17:17:14 -0700787
NeilBrown4ad13662007-07-17 04:06:13 -0700788 kfree(path);
789 } else
790 printk(KERN_ALERT
791 "%s: disabling internal bitmap due to errors\n",
792 bmname(bitmap));
NeilBrowna654b9d82005-06-21 17:17:27 -0700793 }
NeilBrown32a76272005-06-21 17:17:14 -0700794
795 bitmap_file_put(bitmap);
796
797 return;
798}
799
800enum bitmap_page_attr {
NeilBrownac2f40b2010-06-01 19:37:31 +1000801 BITMAP_PAGE_DIRTY = 0, /* there are set bits that need to be synced */
NeilBrown5a537df2011-09-21 15:37:46 +1000802 BITMAP_PAGE_PENDING = 1, /* there are bits that are being cleaned.
803 * i.e. counter is 1 or 2. */
NeilBrownac2f40b2010-06-01 19:37:31 +1000804 BITMAP_PAGE_NEEDWRITE = 2, /* there are cleared bits that need to be synced */
NeilBrown32a76272005-06-21 17:17:14 -0700805};
806
NeilBrownd1891222012-05-22 13:55:09 +1000807static inline void set_page_attr(struct bitmap *bitmap, int pnum,
808 enum bitmap_page_attr attr)
NeilBrown32a76272005-06-21 17:17:14 -0700809{
NeilBrown1ec885c2012-05-22 13:55:10 +1000810 __set_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700811}
812
NeilBrownd1891222012-05-22 13:55:09 +1000813static inline void clear_page_attr(struct bitmap *bitmap, int pnum,
814 enum bitmap_page_attr attr)
NeilBrown32a76272005-06-21 17:17:14 -0700815{
NeilBrown1ec885c2012-05-22 13:55:10 +1000816 __clear_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700817}
818
NeilBrownd1891222012-05-22 13:55:09 +1000819static inline unsigned long test_page_attr(struct bitmap *bitmap, int pnum,
NeilBrownec7a3192006-06-26 00:27:45 -0700820 enum bitmap_page_attr attr)
NeilBrown32a76272005-06-21 17:17:14 -0700821{
NeilBrown1ec885c2012-05-22 13:55:10 +1000822 return test_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
NeilBrown32a76272005-06-21 17:17:14 -0700823}
824
825/*
826 * bitmap_file_set_bit -- called before performing a write to the md device
827 * to set (and eventually sync) a particular bit in the bitmap file
828 *
829 * we set the bit immediately, then we record the page number so that
830 * when an unplug occurs, we can flush the dirty pages out to disk
831 */
832static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
833{
834 unsigned long bit;
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000835 struct page *page;
NeilBrown32a76272005-06-21 17:17:14 -0700836 void *kaddr;
NeilBrown61a0d802012-03-19 12:46:41 +1100837 unsigned long chunk = block >> bitmap->chunkshift;
NeilBrown32a76272005-06-21 17:17:14 -0700838
NeilBrown1ec885c2012-05-22 13:55:10 +1000839 page = filemap_get_page(&bitmap->storage, chunk);
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000840 if (!page)
841 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000842 bit = file_page_offset(&bitmap->storage, chunk);
NeilBrown32a76272005-06-21 17:17:14 -0700843
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000844 /* set the bit */
Cong Wangb2f46e62011-11-28 13:25:44 +0800845 kaddr = kmap_atomic(page);
Jonathan Brassow3520fa42011-07-27 11:00:37 +1000846 if (bitmap->flags & BITMAP_HOSTENDIAN)
847 set_bit(bit, kaddr);
848 else
849 __set_bit_le(bit, kaddr);
Cong Wangb2f46e62011-11-28 13:25:44 +0800850 kunmap_atomic(kaddr);
NeilBrown36a4e1f2011-10-07 14:23:17 +1100851 pr_debug("set file bit %lu page %lu\n", bit, page->index);
NeilBrown32a76272005-06-21 17:17:14 -0700852 /* record page number so it gets flushed to disk when unplug occurs */
NeilBrownd1891222012-05-22 13:55:09 +1000853 set_page_attr(bitmap, page->index, BITMAP_PAGE_DIRTY);
NeilBrown32a76272005-06-21 17:17:14 -0700854}
855
NeilBrownef99bf42012-05-22 13:55:08 +1000856static void bitmap_file_clear_bit(struct bitmap *bitmap, sector_t block)
857{
858 unsigned long bit;
859 struct page *page;
860 void *paddr;
861 unsigned long chunk = block >> bitmap->chunkshift;
862
NeilBrown1ec885c2012-05-22 13:55:10 +1000863 page = filemap_get_page(&bitmap->storage, chunk);
NeilBrownef99bf42012-05-22 13:55:08 +1000864 if (!page)
865 return;
NeilBrown1ec885c2012-05-22 13:55:10 +1000866 bit = file_page_offset(&bitmap->storage, chunk);
NeilBrownef99bf42012-05-22 13:55:08 +1000867 paddr = kmap_atomic(page);
868 if (bitmap->flags & BITMAP_HOSTENDIAN)
869 clear_bit(bit, paddr);
870 else
871 __clear_bit_le(bit, paddr);
872 kunmap_atomic(paddr);
NeilBrownd1891222012-05-22 13:55:09 +1000873 if (!test_page_attr(bitmap, page->index, BITMAP_PAGE_NEEDWRITE)) {
874 set_page_attr(bitmap, page->index, BITMAP_PAGE_PENDING);
NeilBrownef99bf42012-05-22 13:55:08 +1000875 bitmap->allclean = 0;
876 }
877}
878
NeilBrown32a76272005-06-21 17:17:14 -0700879/* this gets called when the md device is ready to unplug its underlying
880 * (slave) device queues -- before we let any writes go down, we need to
881 * sync the dirty pages of the bitmap file to disk */
NeilBrown4ad13662007-07-17 04:06:13 -0700882void bitmap_unplug(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -0700883{
NeilBrownec7a3192006-06-26 00:27:45 -0700884 unsigned long i, flags;
885 int dirty, need_write;
NeilBrown32a76272005-06-21 17:17:14 -0700886 int wait = 0;
887
NeilBrown1ec885c2012-05-22 13:55:10 +1000888 if (!bitmap || !bitmap->storage.filemap)
NeilBrown4ad13662007-07-17 04:06:13 -0700889 return;
NeilBrown32a76272005-06-21 17:17:14 -0700890
891 /* look at each page to see if there are any set bits that need to be
892 * flushed out to disk */
NeilBrown1ec885c2012-05-22 13:55:10 +1000893 for (i = 0; i < bitmap->storage.file_pages; i++) {
NeilBrown32a76272005-06-21 17:17:14 -0700894 spin_lock_irqsave(&bitmap->lock, flags);
NeilBrown1ec885c2012-05-22 13:55:10 +1000895 if (!bitmap->storage.filemap) {
NeilBrown32a76272005-06-21 17:17:14 -0700896 spin_unlock_irqrestore(&bitmap->lock, flags);
NeilBrown4ad13662007-07-17 04:06:13 -0700897 return;
NeilBrown32a76272005-06-21 17:17:14 -0700898 }
NeilBrownd1891222012-05-22 13:55:09 +1000899 dirty = test_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);
900 need_write = test_page_attr(bitmap, i, BITMAP_PAGE_NEEDWRITE);
901 clear_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);
902 clear_page_attr(bitmap, i, BITMAP_PAGE_NEEDWRITE);
NeilBrownbf07bb72012-05-22 13:55:06 +1000903 if (dirty || need_write)
NeilBrownd1891222012-05-22 13:55:09 +1000904 clear_page_attr(bitmap, i, BITMAP_PAGE_PENDING);
NeilBrownec7a3192006-06-26 00:27:45 -0700905 if (dirty)
NeilBrown32a76272005-06-21 17:17:14 -0700906 wait = 1;
907 spin_unlock_irqrestore(&bitmap->lock, flags);
908
NeilBrownac2f40b2010-06-01 19:37:31 +1000909 if (dirty || need_write)
NeilBrown1ec885c2012-05-22 13:55:10 +1000910 write_page(bitmap, bitmap->storage.filemap[i], 0);
NeilBrown32a76272005-06-21 17:17:14 -0700911 }
912 if (wait) { /* if any writes were performed, we need to wait on them */
NeilBrown1ec885c2012-05-22 13:55:10 +1000913 if (bitmap->storage.file)
NeilBrownd785a062006-06-26 00:27:48 -0700914 wait_event(bitmap->write_wait,
915 atomic_read(&bitmap->pending_writes)==0);
NeilBrown0b79ccf2006-06-26 00:27:44 -0700916 else
NeilBrowna9701a32005-11-08 21:39:34 -0800917 md_super_wait(bitmap->mddev);
NeilBrown32a76272005-06-21 17:17:14 -0700918 }
NeilBrownd785a062006-06-26 00:27:48 -0700919 if (bitmap->flags & BITMAP_WRITE_ERROR)
920 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 int pnum;
940 struct page *page = NULL;
NeilBrown32a76272005-06-21 17:17:14 -0700941 unsigned long num_pages, bit_cnt = 0;
942 struct file *file;
NeilBrownd785a062006-06-26 00:27:48 -0700943 unsigned long bytes, offset;
NeilBrown32a76272005-06-21 17:17:14 -0700944 int outofdate;
945 int ret = -ENOSPC;
NeilBrownea03aff2006-01-06 00:20:34 -0800946 void *paddr;
NeilBrown1ec885c2012-05-22 13:55:10 +1000947 struct bitmap_storage *store = &bitmap->storage;
NeilBrown32a76272005-06-21 17:17:14 -0700948
949 chunks = bitmap->chunks;
NeilBrown1ec885c2012-05-22 13:55:10 +1000950 file = store->file;
NeilBrown32a76272005-06-21 17:17:14 -0700951
NeilBrownef99bf42012-05-22 13:55:08 +1000952 if (!file && !bitmap->mddev->bitmap_info.offset) {
953 /* No permanent bitmap - fill with '1s'. */
NeilBrown1ec885c2012-05-22 13:55:10 +1000954 store->filemap = NULL;
955 store->file_pages = 0;
NeilBrownef99bf42012-05-22 13:55:08 +1000956 for (i = 0; i < chunks ; i++) {
957 /* if the disk bit is set, set the memory bit */
958 int needed = ((sector_t)(i+1) << (bitmap->chunkshift)
959 >= start);
960 bitmap_set_memory_bits(bitmap,
961 (sector_t)i << bitmap->chunkshift,
962 needed);
963 }
964 return 0;
965 }
NeilBrown32a76272005-06-21 17:17:14 -0700966
NeilBrown32a76272005-06-21 17:17:14 -0700967 outofdate = bitmap->flags & BITMAP_STALE;
NeilBrown32a76272005-06-21 17:17:14 -0700968 if (outofdate)
969 printk(KERN_INFO "%s: bitmap file is out of date, doing full "
970 "recovery\n", bmname(bitmap));
971
NeilBrowne384e582010-06-01 19:37:34 +1000972 bytes = DIV_ROUND_UP(bitmap->chunks, 8);
NeilBrownece5cff2009-12-14 12:49:56 +1100973 if (!bitmap->mddev->bitmap_info.external)
974 bytes += sizeof(bitmap_super_t);
NeilBrownbc7f77d2005-06-21 17:17:17 -0700975
NeilBrowne384e582010-06-01 19:37:34 +1000976 num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE);
NeilBrownbc7f77d2005-06-21 17:17:17 -0700977
NeilBrownece5cff2009-12-14 12:49:56 +1100978 if (file && i_size_read(file->f_mapping->host) < bytes) {
NeilBrown32a76272005-06-21 17:17:14 -0700979 printk(KERN_INFO "%s: bitmap file too short %lu < %lu\n",
980 bmname(bitmap),
981 (unsigned long) i_size_read(file->f_mapping->host),
NeilBrownece5cff2009-12-14 12:49:56 +1100982 bytes);
NeilBrown4ad13662007-07-17 04:06:13 -0700983 goto err;
NeilBrown32a76272005-06-21 17:17:14 -0700984 }
NeilBrownbc7f77d2005-06-21 17:17:17 -0700985
986 ret = -ENOMEM;
987
NeilBrown1ec885c2012-05-22 13:55:10 +1000988 store->filemap = kmalloc(sizeof(struct page *)
989 * num_pages, GFP_KERNEL);
990 if (!store->filemap)
NeilBrown4ad13662007-07-17 04:06:13 -0700991 goto err;
NeilBrown32a76272005-06-21 17:17:14 -0700992
NeilBrown27581e52012-05-22 13:55:08 +1000993 pnum = 0;
994 offset = 0;
NeilBrown1ec885c2012-05-22 13:55:10 +1000995 if (store->sb_page) {
996 store->filemap[0] = store->sb_page;
NeilBrown27581e52012-05-22 13:55:08 +1000997 pnum = 1;
998 offset = sizeof(bitmap_super_t);
999 }
1000 for ( ; pnum < num_pages; pnum++) {
NeilBrown1ec885c2012-05-22 13:55:10 +10001001 store->filemap[pnum] = alloc_page(GFP_KERNEL);
1002 if (!store->filemap[pnum]) {
1003 store->file_pages = pnum;
NeilBrown27581e52012-05-22 13:55:08 +10001004 goto err;
1005 }
1006 }
NeilBrown1ec885c2012-05-22 13:55:10 +10001007 store->file_pages = pnum;
NeilBrown27581e52012-05-22 13:55:08 +10001008
NeilBrowne16b68b2006-06-26 00:27:45 -07001009 /* We need 4 bits per page, rounded up to a multiple of sizeof(unsigned long) */
NeilBrown1ec885c2012-05-22 13:55:10 +10001010 store->filemap_attr = kzalloc(
NeilBrownac2f40b2010-06-01 19:37:31 +10001011 roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
NeilBrowne16b68b2006-06-26 00:27:45 -07001012 GFP_KERNEL);
NeilBrown1ec885c2012-05-22 13:55:10 +10001013 if (!store->filemap_attr)
NeilBrown4ad13662007-07-17 04:06:13 -07001014 goto err;
NeilBrown32a76272005-06-21 17:17:14 -07001015
NeilBrown32a76272005-06-21 17:17:14 -07001016 oldindex = ~0L;
1017
1018 for (i = 0; i < chunks; i++) {
NeilBrownbd926c62005-11-08 21:39:32 -08001019 int b;
NeilBrown1ec885c2012-05-22 13:55:10 +10001020 index = file_page_index(&bitmap->storage, i);
1021 bit = file_page_offset(&bitmap->storage, i);
NeilBrown32a76272005-06-21 17:17:14 -07001022 if (index != oldindex) { /* this is a new page, read it in */
NeilBrownd785a062006-06-26 00:27:48 -07001023 int count;
NeilBrown32a76272005-06-21 17:17:14 -07001024 /* unmap the old page, we're done with it */
NeilBrownd785a062006-06-26 00:27:48 -07001025 if (index == num_pages-1)
NeilBrownece5cff2009-12-14 12:49:56 +11001026 count = bytes - index * PAGE_SIZE;
NeilBrownd785a062006-06-26 00:27:48 -07001027 else
1028 count = PAGE_SIZE;
NeilBrown1ec885c2012-05-22 13:55:10 +10001029 page = store->filemap[index];
NeilBrown27581e52012-05-22 13:55:08 +10001030 if (file)
1031 ret = read_page(file, index, bitmap,
1032 count, page);
1033 else
1034 ret = read_sb_page(
1035 bitmap->mddev,
1036 bitmap->mddev->bitmap_info.offset,
1037 page,
1038 index, count);
1039
1040 if (ret)
NeilBrown4ad13662007-07-17 04:06:13 -07001041 goto err;
NeilBrowna654b9d82005-06-21 17:17:27 -07001042
NeilBrown32a76272005-06-21 17:17:14 -07001043 oldindex = index;
NeilBrown32a76272005-06-21 17:17:14 -07001044
NeilBrown1ec885c2012-05-22 13:55:10 +10001045 store->last_page_size = count;
NeilBrownb74fd282009-05-07 12:47:19 +10001046
NeilBrown32a76272005-06-21 17:17:14 -07001047 if (outofdate) {
1048 /*
1049 * if bitmap is out of date, dirty the
NeilBrownac2f40b2010-06-01 19:37:31 +10001050 * whole page and write it out
NeilBrown32a76272005-06-21 17:17:14 -07001051 */
Cong Wangb2f46e62011-11-28 13:25:44 +08001052 paddr = kmap_atomic(page);
NeilBrownea03aff2006-01-06 00:20:34 -08001053 memset(paddr + offset, 0xff,
NeilBrown6a079972005-09-09 16:23:44 -07001054 PAGE_SIZE - offset);
Cong Wangb2f46e62011-11-28 13:25:44 +08001055 kunmap_atomic(paddr);
NeilBrown4ad13662007-07-17 04:06:13 -07001056 write_page(bitmap, page, 1);
1057
1058 ret = -EIO;
NeilBrownb74fd282009-05-07 12:47:19 +10001059 if (bitmap->flags & BITMAP_WRITE_ERROR)
NeilBrown4ad13662007-07-17 04:06:13 -07001060 goto err;
NeilBrown32a76272005-06-21 17:17:14 -07001061 }
NeilBrown32a76272005-06-21 17:17:14 -07001062 }
Cong Wangb2f46e62011-11-28 13:25:44 +08001063 paddr = kmap_atomic(page);
NeilBrownbd926c62005-11-08 21:39:32 -08001064 if (bitmap->flags & BITMAP_HOSTENDIAN)
NeilBrownea03aff2006-01-06 00:20:34 -08001065 b = test_bit(bit, paddr);
NeilBrownbd926c62005-11-08 21:39:32 -08001066 else
Akinobu Mita6b33aff2011-03-23 16:42:13 -07001067 b = test_bit_le(bit, paddr);
Cong Wangb2f46e62011-11-28 13:25:44 +08001068 kunmap_atomic(paddr);
NeilBrownbd926c62005-11-08 21:39:32 -08001069 if (b) {
NeilBrown32a76272005-06-21 17:17:14 -07001070 /* if the disk bit is set, set the memory bit */
NeilBrown61a0d802012-03-19 12:46:41 +11001071 int needed = ((sector_t)(i+1) << bitmap->chunkshift
NeilBrowndb305e52009-05-07 12:49:06 +10001072 >= start);
1073 bitmap_set_memory_bits(bitmap,
NeilBrown61a0d802012-03-19 12:46:41 +11001074 (sector_t)i << bitmap->chunkshift,
NeilBrowndb305e52009-05-07 12:49:06 +10001075 needed);
NeilBrown32a76272005-06-21 17:17:14 -07001076 bit_cnt++;
1077 }
NeilBrown27581e52012-05-22 13:55:08 +10001078 offset = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001079 }
1080
NeilBrown32a76272005-06-21 17:17:14 -07001081 printk(KERN_INFO "%s: bitmap initialized from disk: "
Jonathan Brassow9c810752011-06-08 17:59:30 -05001082 "read %lu/%lu pages, set %lu of %lu bits\n",
NeilBrown1ec885c2012-05-22 13:55:10 +10001083 bmname(bitmap), store->file_pages,
1084 num_pages, bit_cnt, chunks);
NeilBrown32a76272005-06-21 17:17:14 -07001085
NeilBrown4ad13662007-07-17 04:06:13 -07001086 return 0;
1087
1088 err:
1089 printk(KERN_INFO "%s: bitmap initialisation failed: %d\n",
1090 bmname(bitmap), ret);
NeilBrown32a76272005-06-21 17:17:14 -07001091 return ret;
1092}
1093
NeilBrowna654b9d82005-06-21 17:17:27 -07001094void bitmap_write_all(struct bitmap *bitmap)
1095{
1096 /* We don't actually write all bitmap blocks here,
1097 * just flag them as needing to be written
1098 */
NeilBrownec7a3192006-06-26 00:27:45 -07001099 int i;
NeilBrowna654b9d82005-06-21 17:17:27 -07001100
NeilBrown1ec885c2012-05-22 13:55:10 +10001101 if (!bitmap || !bitmap->storage.filemap)
NeilBrownef99bf42012-05-22 13:55:08 +10001102 return;
NeilBrown1ec885c2012-05-22 13:55:10 +10001103 if (bitmap->storage.file)
NeilBrownef99bf42012-05-22 13:55:08 +10001104 /* Only one copy, so nothing needed */
1105 return;
1106
NeilBrown7c8f4242011-11-23 10:18:52 +11001107 spin_lock_irq(&bitmap->lock);
NeilBrown1ec885c2012-05-22 13:55:10 +10001108 for (i = 0; i < bitmap->storage.file_pages; i++)
NeilBrownd1891222012-05-22 13:55:09 +10001109 set_page_attr(bitmap, i,
NeilBrownec7a3192006-06-26 00:27:45 -07001110 BITMAP_PAGE_NEEDWRITE);
NeilBrown2585f3e2011-09-21 15:37:46 +10001111 bitmap->allclean = 0;
NeilBrown7c8f4242011-11-23 10:18:52 +11001112 spin_unlock_irq(&bitmap->lock);
NeilBrowna654b9d82005-06-21 17:17:27 -07001113}
1114
NeilBrown32a76272005-06-21 17:17:14 -07001115static void bitmap_count_page(struct bitmap *bitmap, sector_t offset, int inc)
1116{
NeilBrown61a0d802012-03-19 12:46:41 +11001117 sector_t chunk = offset >> bitmap->chunkshift;
NeilBrown32a76272005-06-21 17:17:14 -07001118 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1119 bitmap->bp[page].count += inc;
NeilBrown32a76272005-06-21 17:17:14 -07001120 bitmap_checkfree(bitmap, page);
1121}
NeilBrownbf07bb72012-05-22 13:55:06 +10001122
1123static void bitmap_set_pending(struct bitmap *bitmap, sector_t offset)
1124{
1125 sector_t chunk = offset >> bitmap->chunkshift;
1126 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1127 struct bitmap_page *bp = &bitmap->bp[page];
1128
1129 if (!bp->pending)
1130 bp->pending = 1;
1131}
1132
NeilBrown32a76272005-06-21 17:17:14 -07001133static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
NeilBrown57dab0b2010-10-19 10:03:39 +11001134 sector_t offset, sector_t *blocks,
NeilBrown32a76272005-06-21 17:17:14 -07001135 int create);
1136
1137/*
1138 * bitmap daemon -- periodically wakes up to clean bits and flush pages
1139 * out to disk
1140 */
1141
NeilBrownfd01b882011-10-11 16:47:53 +11001142void bitmap_daemon_work(struct mddev *mddev)
NeilBrown32a76272005-06-21 17:17:14 -07001143{
NeilBrownaa5cbd12009-12-14 12:49:46 +11001144 struct bitmap *bitmap;
NeilBrownaa3163f2005-06-21 17:17:22 -07001145 unsigned long j;
NeilBrownbf07bb72012-05-22 13:55:06 +10001146 unsigned long nextpage;
NeilBrown32a76272005-06-21 17:17:14 -07001147 unsigned long flags;
NeilBrown57dab0b2010-10-19 10:03:39 +11001148 sector_t blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001149
NeilBrownaa5cbd12009-12-14 12:49:46 +11001150 /* Use a mutex to guard daemon_work against
1151 * bitmap_destroy.
1152 */
NeilBrownc3d97142009-12-14 12:49:52 +11001153 mutex_lock(&mddev->bitmap_info.mutex);
NeilBrownaa5cbd12009-12-14 12:49:46 +11001154 bitmap = mddev->bitmap;
1155 if (bitmap == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001156 mutex_unlock(&mddev->bitmap_info.mutex);
NeilBrown4ad13662007-07-17 04:06:13 -07001157 return;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001158 }
NeilBrown42a04b52009-12-14 12:49:53 +11001159 if (time_before(jiffies, bitmap->daemon_lastrun
NeilBrown2e61ebb2011-12-23 10:17:50 +11001160 + mddev->bitmap_info.daemon_sleep))
NeilBrown7be3dfe2008-03-10 11:43:48 -07001161 goto done;
1162
NeilBrown32a76272005-06-21 17:17:14 -07001163 bitmap->daemon_lastrun = jiffies;
NeilBrown8311c292008-03-04 14:29:30 -08001164 if (bitmap->allclean) {
NeilBrown2e61ebb2011-12-23 10:17:50 +11001165 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001166 goto done;
NeilBrown8311c292008-03-04 14:29:30 -08001167 }
1168 bitmap->allclean = 1;
NeilBrown32a76272005-06-21 17:17:14 -07001169
NeilBrownbf07bb72012-05-22 13:55:06 +10001170 /* Any file-page which is PENDING now needs to be written.
1171 * So set NEEDWRITE now, then after we make any last-minute changes
1172 * we will write it.
1173 */
NeilBrownbe512692009-05-26 09:41:17 +10001174 spin_lock_irqsave(&bitmap->lock, flags);
NeilBrown1ec885c2012-05-22 13:55:10 +10001175 for (j = 0; j < bitmap->storage.file_pages; j++)
NeilBrownd1891222012-05-22 13:55:09 +10001176 if (test_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001177 BITMAP_PAGE_PENDING)) {
NeilBrownd1891222012-05-22 13:55:09 +10001178 set_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001179 BITMAP_PAGE_NEEDWRITE);
NeilBrownd1891222012-05-22 13:55:09 +10001180 clear_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001181 BITMAP_PAGE_PENDING);
1182 }
1183
1184 if (bitmap->need_sync &&
1185 mddev->bitmap_info.external == 0) {
1186 /* Arrange for superblock update as well as
1187 * other changes */
1188 bitmap_super_t *sb;
1189 bitmap->need_sync = 0;
NeilBrown1ec885c2012-05-22 13:55:10 +10001190 if (bitmap->storage.filemap) {
1191 sb = kmap_atomic(bitmap->storage.sb_page);
NeilBrownef99bf42012-05-22 13:55:08 +10001192 sb->events_cleared =
1193 cpu_to_le64(bitmap->events_cleared);
1194 kunmap_atomic(sb);
NeilBrownd1891222012-05-22 13:55:09 +10001195 set_page_attr(bitmap, 0,
NeilBrownef99bf42012-05-22 13:55:08 +10001196 BITMAP_PAGE_NEEDWRITE);
1197 }
NeilBrownbf07bb72012-05-22 13:55:06 +10001198 }
1199 /* Now look at the bitmap counters and if any are '2' or '1',
1200 * decrement and handle accordingly.
1201 */
1202 nextpage = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001203 for (j = 0; j < bitmap->chunks; j++) {
1204 bitmap_counter_t *bmc;
NeilBrownef99bf42012-05-22 13:55:08 +10001205 sector_t block = (sector_t)j << bitmap->chunkshift;
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001206
NeilBrownbf07bb72012-05-22 13:55:06 +10001207 if (j == nextpage) {
1208 nextpage += PAGE_COUNTER_RATIO;
1209 if (!bitmap->bp[j >> PAGE_COUNTER_SHIFT].pending) {
1210 j |= PAGE_COUNTER_MASK;
NeilBrownaa3163f2005-06-21 17:17:22 -07001211 continue;
1212 }
NeilBrownbf07bb72012-05-22 13:55:06 +10001213 bitmap->bp[j >> PAGE_COUNTER_SHIFT].pending = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001214 }
NeilBrowndb305e52009-05-07 12:49:06 +10001215 bmc = bitmap_get_counter(bitmap,
NeilBrownef99bf42012-05-22 13:55:08 +10001216 block,
NeilBrowndb305e52009-05-07 12:49:06 +10001217 &blocks, 0);
NeilBrown32a76272005-06-21 17:17:14 -07001218
NeilBrownbf07bb72012-05-22 13:55:06 +10001219 if (!bmc) {
1220 j |= PAGE_COUNTER_MASK;
1221 continue;
1222 }
1223 if (*bmc == 1 && !bitmap->need_sync) {
1224 /* We can clear the bit */
NeilBrownbf07bb72012-05-22 13:55:06 +10001225 *bmc = 0;
NeilBrownef99bf42012-05-22 13:55:08 +10001226 bitmap_count_page(bitmap, block, -1);
1227 bitmap_file_clear_bit(bitmap, block);
NeilBrownbf07bb72012-05-22 13:55:06 +10001228 } else if (*bmc && *bmc <= 2) {
1229 *bmc = 1;
NeilBrownef99bf42012-05-22 13:55:08 +10001230 bitmap_set_pending(bitmap, block);
NeilBrown2585f3e2011-09-21 15:37:46 +10001231 bitmap->allclean = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001232 }
NeilBrown32a76272005-06-21 17:17:14 -07001233 }
1234
NeilBrownbf07bb72012-05-22 13:55:06 +10001235 /* Now start writeout on any page in NEEDWRITE that isn't DIRTY.
1236 * DIRTY pages need to be written by bitmap_unplug so it can wait
1237 * for them.
1238 * If we find any DIRTY page we stop there and let bitmap_unplug
1239 * handle all the rest. This is important in the case where
1240 * the first blocking holds the superblock and it has been updated.
1241 * We mustn't write any other blocks before the superblock.
1242 */
NeilBrown1ec885c2012-05-22 13:55:10 +10001243 for (j = 0; j < bitmap->storage.file_pages; j++) {
NeilBrownbf07bb72012-05-22 13:55:06 +10001244
NeilBrownd1891222012-05-22 13:55:09 +10001245 if (test_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001246 BITMAP_PAGE_DIRTY))
1247 /* bitmap_unplug will handle the rest */
1248 break;
NeilBrownd1891222012-05-22 13:55:09 +10001249 if (test_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001250 BITMAP_PAGE_NEEDWRITE)) {
NeilBrownd1891222012-05-22 13:55:09 +10001251 clear_page_attr(bitmap, j,
NeilBrownbf07bb72012-05-22 13:55:06 +10001252 BITMAP_PAGE_NEEDWRITE);
1253 spin_unlock_irqrestore(&bitmap->lock, flags);
NeilBrown1ec885c2012-05-22 13:55:10 +10001254 write_page(bitmap, bitmap->storage.filemap[j], 0);
NeilBrownbf07bb72012-05-22 13:55:06 +10001255 spin_lock_irqsave(&bitmap->lock, flags);
NeilBrown1ec885c2012-05-22 13:55:10 +10001256 if (!bitmap->storage.filemap)
NeilBrownbf07bb72012-05-22 13:55:06 +10001257 break;
1258 }
1259 }
NeilBrownbf07bb72012-05-22 13:55:06 +10001260 spin_unlock_irqrestore(&bitmap->lock, flags);
1261
NeilBrown7be3dfe2008-03-10 11:43:48 -07001262 done:
NeilBrown8311c292008-03-04 14:29:30 -08001263 if (bitmap->allclean == 0)
NeilBrown2e61ebb2011-12-23 10:17:50 +11001264 mddev->thread->timeout =
1265 mddev->bitmap_info.daemon_sleep;
NeilBrownc3d97142009-12-14 12:49:52 +11001266 mutex_unlock(&mddev->bitmap_info.mutex);
NeilBrown32a76272005-06-21 17:17:14 -07001267}
1268
NeilBrown32a76272005-06-21 17:17:14 -07001269static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
NeilBrown57dab0b2010-10-19 10:03:39 +11001270 sector_t offset, sector_t *blocks,
NeilBrown32a76272005-06-21 17:17:14 -07001271 int create)
NeilBrownee305ac2009-09-23 18:06:44 +10001272__releases(bitmap->lock)
1273__acquires(bitmap->lock)
NeilBrown32a76272005-06-21 17:17:14 -07001274{
1275 /* If 'create', we might release the lock and reclaim it.
1276 * The lock must have been taken with interrupts enabled.
1277 * If !create, we don't release the lock.
1278 */
NeilBrown61a0d802012-03-19 12:46:41 +11001279 sector_t chunk = offset >> bitmap->chunkshift;
NeilBrown32a76272005-06-21 17:17:14 -07001280 unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
1281 unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
1282 sector_t csize;
NeilBrownef425672010-06-01 19:37:33 +10001283 int err;
NeilBrown32a76272005-06-21 17:17:14 -07001284
NeilBrownef425672010-06-01 19:37:33 +10001285 err = bitmap_checkpage(bitmap, page, create);
1286
1287 if (bitmap->bp[page].hijacked ||
1288 bitmap->bp[page].map == NULL)
NeilBrown61a0d802012-03-19 12:46:41 +11001289 csize = ((sector_t)1) << (bitmap->chunkshift +
NeilBrownef425672010-06-01 19:37:33 +10001290 PAGE_COUNTER_SHIFT - 1);
1291 else
NeilBrown61a0d802012-03-19 12:46:41 +11001292 csize = ((sector_t)1) << bitmap->chunkshift;
NeilBrownef425672010-06-01 19:37:33 +10001293 *blocks = csize - (offset & (csize - 1));
1294
1295 if (err < 0)
NeilBrown32a76272005-06-21 17:17:14 -07001296 return NULL;
NeilBrownef425672010-06-01 19:37:33 +10001297
NeilBrown32a76272005-06-21 17:17:14 -07001298 /* now locked ... */
1299
1300 if (bitmap->bp[page].hijacked) { /* hijacked pointer */
1301 /* should we use the first or second counter field
1302 * of the hijacked pointer? */
1303 int hi = (pageoff > PAGE_COUNTER_MASK);
NeilBrown32a76272005-06-21 17:17:14 -07001304 return &((bitmap_counter_t *)
1305 &bitmap->bp[page].map)[hi];
NeilBrownef425672010-06-01 19:37:33 +10001306 } else /* page is allocated */
NeilBrown32a76272005-06-21 17:17:14 -07001307 return (bitmap_counter_t *)
1308 &(bitmap->bp[page].map[pageoff]);
NeilBrown32a76272005-06-21 17:17:14 -07001309}
1310
NeilBrown4b6d2872005-09-09 16:23:47 -07001311int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int behind)
NeilBrown32a76272005-06-21 17:17:14 -07001312{
NeilBrownac2f40b2010-06-01 19:37:31 +10001313 if (!bitmap)
1314 return 0;
NeilBrown4b6d2872005-09-09 16:23:47 -07001315
1316 if (behind) {
Paul Clements696fcd52010-03-08 16:02:37 +11001317 int bw;
NeilBrown4b6d2872005-09-09 16:23:47 -07001318 atomic_inc(&bitmap->behind_writes);
Paul Clements696fcd52010-03-08 16:02:37 +11001319 bw = atomic_read(&bitmap->behind_writes);
1320 if (bw > bitmap->behind_writes_used)
1321 bitmap->behind_writes_used = bw;
1322
NeilBrown36a4e1f2011-10-07 14:23:17 +11001323 pr_debug("inc write-behind count %d/%lu\n",
1324 bw, bitmap->mddev->bitmap_info.max_write_behind);
NeilBrown4b6d2872005-09-09 16:23:47 -07001325 }
1326
NeilBrown32a76272005-06-21 17:17:14 -07001327 while (sectors) {
NeilBrown57dab0b2010-10-19 10:03:39 +11001328 sector_t blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001329 bitmap_counter_t *bmc;
1330
1331 spin_lock_irq(&bitmap->lock);
1332 bmc = bitmap_get_counter(bitmap, offset, &blocks, 1);
1333 if (!bmc) {
1334 spin_unlock_irq(&bitmap->lock);
1335 return 0;
1336 }
1337
Namhyung Kim27d5ea02011-06-09 11:42:57 +10001338 if (unlikely(COUNTER(*bmc) == COUNTER_MAX)) {
Neil Brownda6e1a32007-02-08 14:20:37 -08001339 DEFINE_WAIT(__wait);
1340 /* note that it is safe to do the prepare_to_wait
1341 * after the test as long as we do it before dropping
1342 * the spinlock.
1343 */
1344 prepare_to_wait(&bitmap->overflow_wait, &__wait,
1345 TASK_UNINTERRUPTIBLE);
1346 spin_unlock_irq(&bitmap->lock);
Jens Axboe7eaceac2011-03-10 08:52:07 +01001347 io_schedule();
Neil Brownda6e1a32007-02-08 14:20:37 -08001348 finish_wait(&bitmap->overflow_wait, &__wait);
1349 continue;
1350 }
1351
NeilBrownac2f40b2010-06-01 19:37:31 +10001352 switch (*bmc) {
NeilBrown32a76272005-06-21 17:17:14 -07001353 case 0:
1354 bitmap_file_set_bit(bitmap, offset);
NeilBrownac2f40b2010-06-01 19:37:31 +10001355 bitmap_count_page(bitmap, offset, 1);
NeilBrown32a76272005-06-21 17:17:14 -07001356 /* fall through */
1357 case 1:
1358 *bmc = 2;
1359 }
Neil Brownda6e1a32007-02-08 14:20:37 -08001360
NeilBrown32a76272005-06-21 17:17:14 -07001361 (*bmc)++;
1362
1363 spin_unlock_irq(&bitmap->lock);
1364
1365 offset += blocks;
1366 if (sectors > blocks)
1367 sectors -= blocks;
NeilBrownac2f40b2010-06-01 19:37:31 +10001368 else
1369 sectors = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001370 }
1371 return 0;
1372}
NeilBrownac2f40b2010-06-01 19:37:31 +10001373EXPORT_SYMBOL(bitmap_startwrite);
NeilBrown32a76272005-06-21 17:17:14 -07001374
1375void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
NeilBrown4b6d2872005-09-09 16:23:47 -07001376 int success, int behind)
NeilBrown32a76272005-06-21 17:17:14 -07001377{
NeilBrownac2f40b2010-06-01 19:37:31 +10001378 if (!bitmap)
1379 return;
NeilBrown4b6d2872005-09-09 16:23:47 -07001380 if (behind) {
NeilBrowne5551902010-03-31 11:21:44 +11001381 if (atomic_dec_and_test(&bitmap->behind_writes))
1382 wake_up(&bitmap->behind_wait);
NeilBrown36a4e1f2011-10-07 14:23:17 +11001383 pr_debug("dec write-behind count %d/%lu\n",
1384 atomic_read(&bitmap->behind_writes),
1385 bitmap->mddev->bitmap_info.max_write_behind);
NeilBrown4b6d2872005-09-09 16:23:47 -07001386 }
1387
NeilBrown32a76272005-06-21 17:17:14 -07001388 while (sectors) {
NeilBrown57dab0b2010-10-19 10:03:39 +11001389 sector_t blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001390 unsigned long flags;
1391 bitmap_counter_t *bmc;
1392
1393 spin_lock_irqsave(&bitmap->lock, flags);
1394 bmc = bitmap_get_counter(bitmap, offset, &blocks, 0);
1395 if (!bmc) {
1396 spin_unlock_irqrestore(&bitmap->lock, flags);
1397 return;
1398 }
1399
NeilBrown961902c2011-12-23 09:57:48 +11001400 if (success && !bitmap->mddev->degraded &&
Neil Browna0da84f2008-06-28 08:31:22 +10001401 bitmap->events_cleared < bitmap->mddev->events) {
1402 bitmap->events_cleared = bitmap->mddev->events;
1403 bitmap->need_sync = 1;
NeilBrown5ff5aff2010-06-01 19:37:32 +10001404 sysfs_notify_dirent_safe(bitmap->sysfs_can_clear);
Neil Browna0da84f2008-06-28 08:31:22 +10001405 }
1406
Namhyung Kim27d5ea02011-06-09 11:42:57 +10001407 if (!success && !NEEDED(*bmc))
NeilBrown32a76272005-06-21 17:17:14 -07001408 *bmc |= NEEDED_MASK;
1409
Namhyung Kim27d5ea02011-06-09 11:42:57 +10001410 if (COUNTER(*bmc) == COUNTER_MAX)
Neil Brownda6e1a32007-02-08 14:20:37 -08001411 wake_up(&bitmap->overflow_wait);
1412
NeilBrown32a76272005-06-21 17:17:14 -07001413 (*bmc)--;
NeilBrown2585f3e2011-09-21 15:37:46 +10001414 if (*bmc <= 2) {
NeilBrownbf07bb72012-05-22 13:55:06 +10001415 bitmap_set_pending(bitmap, offset);
NeilBrown2585f3e2011-09-21 15:37:46 +10001416 bitmap->allclean = 0;
1417 }
NeilBrown32a76272005-06-21 17:17:14 -07001418 spin_unlock_irqrestore(&bitmap->lock, flags);
1419 offset += blocks;
1420 if (sectors > blocks)
1421 sectors -= blocks;
NeilBrownac2f40b2010-06-01 19:37:31 +10001422 else
1423 sectors = 0;
NeilBrown32a76272005-06-21 17:17:14 -07001424 }
1425}
NeilBrownac2f40b2010-06-01 19:37:31 +10001426EXPORT_SYMBOL(bitmap_endwrite);
NeilBrown32a76272005-06-21 17:17:14 -07001427
NeilBrown57dab0b2010-10-19 10:03:39 +11001428static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
NeilBrown1187cf02009-03-31 14:27:02 +11001429 int degraded)
NeilBrown32a76272005-06-21 17:17:14 -07001430{
1431 bitmap_counter_t *bmc;
1432 int rv;
1433 if (bitmap == NULL) {/* FIXME or bitmap set as 'failed' */
1434 *blocks = 1024;
1435 return 1; /* always resync if no bitmap */
1436 }
1437 spin_lock_irq(&bitmap->lock);
1438 bmc = bitmap_get_counter(bitmap, offset, blocks, 0);
1439 rv = 0;
1440 if (bmc) {
1441 /* locked */
1442 if (RESYNC(*bmc))
1443 rv = 1;
1444 else if (NEEDED(*bmc)) {
1445 rv = 1;
NeilBrown6a806c52005-07-15 03:56:35 -07001446 if (!degraded) { /* don't set/clear bits if degraded */
1447 *bmc |= RESYNC_MASK;
1448 *bmc &= ~NEEDED_MASK;
1449 }
NeilBrown32a76272005-06-21 17:17:14 -07001450 }
1451 }
1452 spin_unlock_irq(&bitmap->lock);
1453 return rv;
1454}
1455
NeilBrown57dab0b2010-10-19 10:03:39 +11001456int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
NeilBrown1187cf02009-03-31 14:27:02 +11001457 int degraded)
1458{
1459 /* bitmap_start_sync must always report on multiples of whole
1460 * pages, otherwise resync (which is very PAGE_SIZE based) will
1461 * get confused.
1462 * So call __bitmap_start_sync repeatedly (if needed) until
1463 * At least PAGE_SIZE>>9 blocks are covered.
1464 * Return the 'or' of the result.
1465 */
1466 int rv = 0;
NeilBrown57dab0b2010-10-19 10:03:39 +11001467 sector_t blocks1;
NeilBrown1187cf02009-03-31 14:27:02 +11001468
1469 *blocks = 0;
1470 while (*blocks < (PAGE_SIZE>>9)) {
1471 rv |= __bitmap_start_sync(bitmap, offset,
1472 &blocks1, degraded);
1473 offset += blocks1;
1474 *blocks += blocks1;
1475 }
1476 return rv;
1477}
NeilBrownac2f40b2010-06-01 19:37:31 +10001478EXPORT_SYMBOL(bitmap_start_sync);
NeilBrown1187cf02009-03-31 14:27:02 +11001479
NeilBrown57dab0b2010-10-19 10:03:39 +11001480void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted)
NeilBrown32a76272005-06-21 17:17:14 -07001481{
1482 bitmap_counter_t *bmc;
1483 unsigned long flags;
NeilBrownac2f40b2010-06-01 19:37:31 +10001484
1485 if (bitmap == NULL) {
NeilBrown32a76272005-06-21 17:17:14 -07001486 *blocks = 1024;
1487 return;
1488 }
1489 spin_lock_irqsave(&bitmap->lock, flags);
1490 bmc = bitmap_get_counter(bitmap, offset, blocks, 0);
1491 if (bmc == NULL)
1492 goto unlock;
1493 /* locked */
NeilBrown32a76272005-06-21 17:17:14 -07001494 if (RESYNC(*bmc)) {
1495 *bmc &= ~RESYNC_MASK;
1496
1497 if (!NEEDED(*bmc) && aborted)
1498 *bmc |= NEEDED_MASK;
1499 else {
NeilBrown2585f3e2011-09-21 15:37:46 +10001500 if (*bmc <= 2) {
NeilBrownbf07bb72012-05-22 13:55:06 +10001501 bitmap_set_pending(bitmap, offset);
NeilBrown2585f3e2011-09-21 15:37:46 +10001502 bitmap->allclean = 0;
1503 }
NeilBrown32a76272005-06-21 17:17:14 -07001504 }
1505 }
1506 unlock:
1507 spin_unlock_irqrestore(&bitmap->lock, flags);
1508}
NeilBrownac2f40b2010-06-01 19:37:31 +10001509EXPORT_SYMBOL(bitmap_end_sync);
NeilBrown32a76272005-06-21 17:17:14 -07001510
1511void bitmap_close_sync(struct bitmap *bitmap)
1512{
1513 /* Sync has finished, and any bitmap chunks that weren't synced
1514 * properly have been aborted. It remains to us to clear the
1515 * RESYNC bit wherever it is still on
1516 */
1517 sector_t sector = 0;
NeilBrown57dab0b2010-10-19 10:03:39 +11001518 sector_t blocks;
NeilBrownb47490c2008-02-06 01:39:50 -08001519 if (!bitmap)
1520 return;
NeilBrown32a76272005-06-21 17:17:14 -07001521 while (sector < bitmap->mddev->resync_max_sectors) {
1522 bitmap_end_sync(bitmap, sector, &blocks, 0);
NeilBrownb47490c2008-02-06 01:39:50 -08001523 sector += blocks;
NeilBrown32a76272005-06-21 17:17:14 -07001524 }
1525}
NeilBrownac2f40b2010-06-01 19:37:31 +10001526EXPORT_SYMBOL(bitmap_close_sync);
NeilBrown32a76272005-06-21 17:17:14 -07001527
NeilBrownb47490c2008-02-06 01:39:50 -08001528void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
1529{
1530 sector_t s = 0;
NeilBrown57dab0b2010-10-19 10:03:39 +11001531 sector_t blocks;
NeilBrownb47490c2008-02-06 01:39:50 -08001532
1533 if (!bitmap)
1534 return;
1535 if (sector == 0) {
1536 bitmap->last_end_sync = jiffies;
1537 return;
1538 }
1539 if (time_before(jiffies, (bitmap->last_end_sync
NeilBrown1b04be92009-12-14 12:49:53 +11001540 + bitmap->mddev->bitmap_info.daemon_sleep)))
NeilBrownb47490c2008-02-06 01:39:50 -08001541 return;
1542 wait_event(bitmap->mddev->recovery_wait,
1543 atomic_read(&bitmap->mddev->recovery_active) == 0);
1544
NeilBrown75d3da42011-01-14 09:14:34 +11001545 bitmap->mddev->curr_resync_completed = sector;
NeilBrown070dc6d2010-08-30 17:33:34 +10001546 set_bit(MD_CHANGE_CLEAN, &bitmap->mddev->flags);
NeilBrown61a0d802012-03-19 12:46:41 +11001547 sector &= ~((1ULL << bitmap->chunkshift) - 1);
NeilBrownb47490c2008-02-06 01:39:50 -08001548 s = 0;
1549 while (s < sector && s < bitmap->mddev->resync_max_sectors) {
1550 bitmap_end_sync(bitmap, s, &blocks, 0);
1551 s += blocks;
1552 }
1553 bitmap->last_end_sync = jiffies;
NeilBrownacb180b2009-04-14 16:28:34 +10001554 sysfs_notify(&bitmap->mddev->kobj, NULL, "sync_completed");
NeilBrownb47490c2008-02-06 01:39:50 -08001555}
NeilBrownac2f40b2010-06-01 19:37:31 +10001556EXPORT_SYMBOL(bitmap_cond_end_sync);
NeilBrownb47490c2008-02-06 01:39:50 -08001557
NeilBrown6a079972005-09-09 16:23:44 -07001558static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)
NeilBrown32a76272005-06-21 17:17:14 -07001559{
1560 /* For each chunk covered by any of these sectors, set the
NeilBrownef99bf42012-05-22 13:55:08 +10001561 * counter to 2 and possibly set resync_needed. They should all
NeilBrown32a76272005-06-21 17:17:14 -07001562 * be 0 at this point
1563 */
NeilBrown193f1c92005-08-04 12:53:33 -07001564
NeilBrown57dab0b2010-10-19 10:03:39 +11001565 sector_t secs;
NeilBrown193f1c92005-08-04 12:53:33 -07001566 bitmap_counter_t *bmc;
1567 spin_lock_irq(&bitmap->lock);
1568 bmc = bitmap_get_counter(bitmap, offset, &secs, 1);
1569 if (!bmc) {
NeilBrown32a76272005-06-21 17:17:14 -07001570 spin_unlock_irq(&bitmap->lock);
NeilBrown193f1c92005-08-04 12:53:33 -07001571 return;
NeilBrown32a76272005-06-21 17:17:14 -07001572 }
NeilBrownac2f40b2010-06-01 19:37:31 +10001573 if (!*bmc) {
NeilBrown915c4202011-12-23 10:17:51 +11001574 *bmc = 2 | (needed ? NEEDED_MASK : 0);
NeilBrown193f1c92005-08-04 12:53:33 -07001575 bitmap_count_page(bitmap, offset, 1);
NeilBrownbf07bb72012-05-22 13:55:06 +10001576 bitmap_set_pending(bitmap, offset);
NeilBrown2585f3e2011-09-21 15:37:46 +10001577 bitmap->allclean = 0;
NeilBrown193f1c92005-08-04 12:53:33 -07001578 }
1579 spin_unlock_irq(&bitmap->lock);
NeilBrown32a76272005-06-21 17:17:14 -07001580}
1581
Paul Clements9b1d1da2006-10-03 01:15:49 -07001582/* dirty the memory and file bits for bitmap chunks "s" to "e" */
1583void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e)
1584{
1585 unsigned long chunk;
1586
1587 for (chunk = s; chunk <= e; chunk++) {
NeilBrown61a0d802012-03-19 12:46:41 +11001588 sector_t sec = (sector_t)chunk << bitmap->chunkshift;
Paul Clements9b1d1da2006-10-03 01:15:49 -07001589 bitmap_set_memory_bits(bitmap, sec, 1);
NeilBrown7c8f4242011-11-23 10:18:52 +11001590 spin_lock_irq(&bitmap->lock);
Paul Clements9b1d1da2006-10-03 01:15:49 -07001591 bitmap_file_set_bit(bitmap, sec);
NeilBrown7c8f4242011-11-23 10:18:52 +11001592 spin_unlock_irq(&bitmap->lock);
NeilBrownffa23322009-12-14 12:49:56 +11001593 if (sec < bitmap->mddev->recovery_cp)
1594 /* We are asserting that the array is dirty,
1595 * so move the recovery_cp address back so
1596 * that it is obvious that it is dirty
1597 */
1598 bitmap->mddev->recovery_cp = sec;
Paul Clements9b1d1da2006-10-03 01:15:49 -07001599 }
1600}
1601
NeilBrown32a76272005-06-21 17:17:14 -07001602/*
NeilBrown6b8b3e82005-08-04 12:53:35 -07001603 * flush out any pending updates
1604 */
NeilBrownfd01b882011-10-11 16:47:53 +11001605void bitmap_flush(struct mddev *mddev)
NeilBrown6b8b3e82005-08-04 12:53:35 -07001606{
1607 struct bitmap *bitmap = mddev->bitmap;
NeilBrown42a04b52009-12-14 12:49:53 +11001608 long sleep;
NeilBrown6b8b3e82005-08-04 12:53:35 -07001609
1610 if (!bitmap) /* there was no bitmap */
1611 return;
1612
1613 /* run the daemon_work three time to ensure everything is flushed
1614 * that can be
1615 */
NeilBrown1b04be92009-12-14 12:49:53 +11001616 sleep = mddev->bitmap_info.daemon_sleep * 2;
NeilBrown42a04b52009-12-14 12:49:53 +11001617 bitmap->daemon_lastrun -= sleep;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001618 bitmap_daemon_work(mddev);
NeilBrown42a04b52009-12-14 12:49:53 +11001619 bitmap->daemon_lastrun -= sleep;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001620 bitmap_daemon_work(mddev);
NeilBrown42a04b52009-12-14 12:49:53 +11001621 bitmap->daemon_lastrun -= sleep;
NeilBrownaa5cbd12009-12-14 12:49:46 +11001622 bitmap_daemon_work(mddev);
NeilBrown6b8b3e82005-08-04 12:53:35 -07001623 bitmap_update_sb(bitmap);
1624}
1625
1626/*
NeilBrown32a76272005-06-21 17:17:14 -07001627 * free memory that was allocated
1628 */
NeilBrown3178b0d2005-09-09 16:23:50 -07001629static void bitmap_free(struct bitmap *bitmap)
NeilBrown32a76272005-06-21 17:17:14 -07001630{
1631 unsigned long k, pages;
1632 struct bitmap_page *bp;
NeilBrown32a76272005-06-21 17:17:14 -07001633
1634 if (!bitmap) /* there was no bitmap */
1635 return;
1636
NeilBrown32a76272005-06-21 17:17:14 -07001637 /* release the bitmap file and kill the daemon */
1638 bitmap_file_put(bitmap);
1639
1640 bp = bitmap->bp;
1641 pages = bitmap->pages;
1642
1643 /* free all allocated memory */
1644
NeilBrown32a76272005-06-21 17:17:14 -07001645 if (bp) /* deallocate the page memory */
1646 for (k = 0; k < pages; k++)
1647 if (bp[k].map && !bp[k].hijacked)
1648 kfree(bp[k].map);
1649 kfree(bp);
1650 kfree(bitmap);
1651}
NeilBrownaa5cbd12009-12-14 12:49:46 +11001652
NeilBrownfd01b882011-10-11 16:47:53 +11001653void bitmap_destroy(struct mddev *mddev)
NeilBrown3178b0d2005-09-09 16:23:50 -07001654{
1655 struct bitmap *bitmap = mddev->bitmap;
1656
1657 if (!bitmap) /* there was no bitmap */
1658 return;
1659
NeilBrownc3d97142009-12-14 12:49:52 +11001660 mutex_lock(&mddev->bitmap_info.mutex);
NeilBrown3178b0d2005-09-09 16:23:50 -07001661 mddev->bitmap = NULL; /* disconnect from the md device */
NeilBrownc3d97142009-12-14 12:49:52 +11001662 mutex_unlock(&mddev->bitmap_info.mutex);
NeilBrownb15c2e52006-01-06 00:20:16 -08001663 if (mddev->thread)
1664 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrown3178b0d2005-09-09 16:23:50 -07001665
NeilBrownece5cff2009-12-14 12:49:56 +11001666 if (bitmap->sysfs_can_clear)
1667 sysfs_put(bitmap->sysfs_can_clear);
1668
NeilBrown3178b0d2005-09-09 16:23:50 -07001669 bitmap_free(bitmap);
1670}
NeilBrown32a76272005-06-21 17:17:14 -07001671
1672/*
1673 * initialize the bitmap structure
1674 * if this returns an error, bitmap_destroy must be called to do clean up
1675 */
NeilBrownfd01b882011-10-11 16:47:53 +11001676int bitmap_create(struct mddev *mddev)
NeilBrown32a76272005-06-21 17:17:14 -07001677{
1678 struct bitmap *bitmap;
NeilBrown1f5939032009-04-20 11:50:24 +10001679 sector_t blocks = mddev->resync_max_sectors;
NeilBrown32a76272005-06-21 17:17:14 -07001680 unsigned long chunks;
1681 unsigned long pages;
NeilBrownc3d97142009-12-14 12:49:52 +11001682 struct file *file = mddev->bitmap_info.file;
NeilBrown32a76272005-06-21 17:17:14 -07001683 int err;
NeilBrown5ff5aff2010-06-01 19:37:32 +10001684 struct sysfs_dirent *bm = NULL;
NeilBrown32a76272005-06-21 17:17:14 -07001685
Alexey Dobriyan5f6e3c832006-10-11 01:22:26 -07001686 BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
NeilBrown32a76272005-06-21 17:17:14 -07001687
NeilBrownc3d97142009-12-14 12:49:52 +11001688 BUG_ON(file && mddev->bitmap_info.offset);
NeilBrowna654b9d82005-06-21 17:17:27 -07001689
NeilBrown9ffae0c2006-01-06 00:20:32 -08001690 bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
NeilBrown32a76272005-06-21 17:17:14 -07001691 if (!bitmap)
1692 return -ENOMEM;
1693
NeilBrown32a76272005-06-21 17:17:14 -07001694 spin_lock_init(&bitmap->lock);
NeilBrownce25c312006-06-26 00:27:49 -07001695 atomic_set(&bitmap->pending_writes, 0);
1696 init_waitqueue_head(&bitmap->write_wait);
Neil Brownda6e1a32007-02-08 14:20:37 -08001697 init_waitqueue_head(&bitmap->overflow_wait);
NeilBrowne5551902010-03-31 11:21:44 +11001698 init_waitqueue_head(&bitmap->behind_wait);
NeilBrownce25c312006-06-26 00:27:49 -07001699
NeilBrown32a76272005-06-21 17:17:14 -07001700 bitmap->mddev = mddev;
NeilBrown32a76272005-06-21 17:17:14 -07001701
NeilBrown5ff5aff2010-06-01 19:37:32 +10001702 if (mddev->kobj.sd)
1703 bm = sysfs_get_dirent(mddev->kobj.sd, NULL, "bitmap");
NeilBrownece5cff2009-12-14 12:49:56 +11001704 if (bm) {
Eric W. Biederman3ff195b2010-03-30 11:31:26 -07001705 bitmap->sysfs_can_clear = sysfs_get_dirent(bm, NULL, "can_clear");
NeilBrownece5cff2009-12-14 12:49:56 +11001706 sysfs_put(bm);
1707 } else
1708 bitmap->sysfs_can_clear = NULL;
1709
NeilBrown1ec885c2012-05-22 13:55:10 +10001710 bitmap->storage.file = file;
NeilBrownce25c312006-06-26 00:27:49 -07001711 if (file) {
1712 get_file(file);
NeilBrownae8fa282009-10-16 15:56:01 +11001713 /* As future accesses to this file will use bmap,
1714 * and bypass the page cache, we must sync the file
1715 * first.
1716 */
Christoph Hellwig8018ab02010-03-22 17:32:25 +01001717 vfs_fsync(file, 1);
NeilBrownce25c312006-06-26 00:27:49 -07001718 }
NeilBrown42a04b52009-12-14 12:49:53 +11001719 /* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */
Jonathan Brassow9c810752011-06-08 17:59:30 -05001720 if (!mddev->bitmap_info.external) {
1721 /*
1722 * If 'MD_ARRAY_FIRST_USE' is set, then device-mapper is
1723 * instructing us to create a new on-disk bitmap instance.
1724 */
1725 if (test_and_clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags))
1726 err = bitmap_new_disk_sb(bitmap);
1727 else
1728 err = bitmap_read_sb(bitmap);
1729 } else {
NeilBrownece5cff2009-12-14 12:49:56 +11001730 err = 0;
1731 if (mddev->bitmap_info.chunksize == 0 ||
1732 mddev->bitmap_info.daemon_sleep == 0)
1733 /* chunksize and time_base need to be
1734 * set first. */
1735 err = -EINVAL;
1736 }
NeilBrown32a76272005-06-21 17:17:14 -07001737 if (err)
NeilBrown3178b0d2005-09-09 16:23:50 -07001738 goto error;
NeilBrown32a76272005-06-21 17:17:14 -07001739
NeilBrown624ce4f2009-12-14 12:49:56 +11001740 bitmap->daemon_lastrun = jiffies;
NeilBrown61a0d802012-03-19 12:46:41 +11001741 bitmap->chunkshift = (ffz(~mddev->bitmap_info.chunksize)
1742 - BITMAP_BLOCK_SHIFT);
NeilBrown32a76272005-06-21 17:17:14 -07001743
NeilBrownb16b1b62012-05-04 17:03:18 +10001744 chunks = (blocks + (1 << bitmap->chunkshift) - 1) >>
NeilBrown61a0d802012-03-19 12:46:41 +11001745 bitmap->chunkshift;
NeilBrownac2f40b2010-06-01 19:37:31 +10001746 pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
NeilBrown32a76272005-06-21 17:17:14 -07001747
1748 BUG_ON(!pages);
1749
1750 bitmap->chunks = chunks;
1751 bitmap->pages = pages;
1752 bitmap->missing_pages = pages;
NeilBrown32a76272005-06-21 17:17:14 -07001753
NeilBrown9ffae0c2006-01-06 00:20:32 -08001754 bitmap->bp = kzalloc(pages * sizeof(*bitmap->bp), GFP_KERNEL);
NeilBrown29d32472011-10-11 16:49:56 +11001755
NeilBrown3178b0d2005-09-09 16:23:50 -07001756 err = -ENOMEM;
NeilBrown32a76272005-06-21 17:17:14 -07001757 if (!bitmap->bp)
NeilBrown3178b0d2005-09-09 16:23:50 -07001758 goto error;
NeilBrown32a76272005-06-21 17:17:14 -07001759
NeilBrown69e51b42010-06-01 19:37:35 +10001760 printk(KERN_INFO "created bitmap (%lu pages) for device %s\n",
1761 pages, bmname(bitmap));
1762
1763 mddev->bitmap = bitmap;
1764
1765
1766 return (bitmap->flags & BITMAP_WRITE_ERROR) ? -EIO : 0;
1767
1768 error:
1769 bitmap_free(bitmap);
1770 return err;
1771}
1772
NeilBrownfd01b882011-10-11 16:47:53 +11001773int bitmap_load(struct mddev *mddev)
NeilBrown69e51b42010-06-01 19:37:35 +10001774{
1775 int err = 0;
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001776 sector_t start = 0;
NeilBrown69e51b42010-06-01 19:37:35 +10001777 sector_t sector = 0;
1778 struct bitmap *bitmap = mddev->bitmap;
1779
1780 if (!bitmap)
1781 goto out;
1782
1783 /* Clear out old bitmap info first: Either there is none, or we
1784 * are resuming after someone else has possibly changed things,
1785 * so we should forget old cached info.
1786 * All chunks should be clean, but some might need_sync.
1787 */
1788 while (sector < mddev->resync_max_sectors) {
NeilBrown57dab0b2010-10-19 10:03:39 +11001789 sector_t blocks;
NeilBrown69e51b42010-06-01 19:37:35 +10001790 bitmap_start_sync(bitmap, sector, &blocks, 0);
1791 sector += blocks;
1792 }
1793 bitmap_close_sync(bitmap);
1794
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001795 if (mddev->degraded == 0
1796 || bitmap->events_cleared == mddev->events)
1797 /* no need to keep dirty bits to optimise a
1798 * re-add of a missing device */
1799 start = mddev->recovery_cp;
NeilBrown69e51b42010-06-01 19:37:35 +10001800
NeilBrownafbaa902012-04-12 16:05:06 +10001801 mutex_lock(&mddev->bitmap_info.mutex);
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001802 err = bitmap_init_from_disk(bitmap, start);
NeilBrownafbaa902012-04-12 16:05:06 +10001803 mutex_unlock(&mddev->bitmap_info.mutex);
Jonathan Brassow3520fa42011-07-27 11:00:37 +10001804
NeilBrown32a76272005-06-21 17:17:14 -07001805 if (err)
NeilBrown69e51b42010-06-01 19:37:35 +10001806 goto out;
NeilBrownef99bf42012-05-22 13:55:08 +10001807 bitmap_mask_state(bitmap, BITMAP_STALE, MASK_UNSET);
1808
1809 /* Kick recovery in case any bits were set */
1810 set_bit(MD_RECOVERY_NEEDED, &bitmap->mddev->recovery);
NeilBrown3178b0d2005-09-09 16:23:50 -07001811
NeilBrown1b04be92009-12-14 12:49:53 +11001812 mddev->thread->timeout = mddev->bitmap_info.daemon_sleep;
NeilBrown9cd30fd2009-12-14 12:49:54 +11001813 md_wakeup_thread(mddev->thread);
NeilBrownb15c2e52006-01-06 00:20:16 -08001814
NeilBrown4ad13662007-07-17 04:06:13 -07001815 bitmap_update_sb(bitmap);
1816
NeilBrown69e51b42010-06-01 19:37:35 +10001817 if (bitmap->flags & BITMAP_WRITE_ERROR)
1818 err = -EIO;
1819out:
NeilBrown3178b0d2005-09-09 16:23:50 -07001820 return err;
NeilBrown32a76272005-06-21 17:17:14 -07001821}
NeilBrown69e51b42010-06-01 19:37:35 +10001822EXPORT_SYMBOL_GPL(bitmap_load);
NeilBrown32a76272005-06-21 17:17:14 -07001823
NeilBrown57148962012-03-19 12:46:40 +11001824void bitmap_status(struct seq_file *seq, struct bitmap *bitmap)
1825{
1826 unsigned long chunk_kb;
1827 unsigned long flags;
1828
1829 if (!bitmap)
1830 return;
1831
1832 spin_lock_irqsave(&bitmap->lock, flags);
1833 chunk_kb = bitmap->mddev->bitmap_info.chunksize >> 10;
1834 seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
1835 "%lu%s chunk",
1836 bitmap->pages - bitmap->missing_pages,
1837 bitmap->pages,
1838 (bitmap->pages - bitmap->missing_pages)
1839 << (PAGE_SHIFT - 10),
1840 chunk_kb ? chunk_kb : bitmap->mddev->bitmap_info.chunksize,
1841 chunk_kb ? "KB" : "B");
NeilBrown1ec885c2012-05-22 13:55:10 +10001842 if (bitmap->storage.file) {
NeilBrown57148962012-03-19 12:46:40 +11001843 seq_printf(seq, ", file: ");
NeilBrown1ec885c2012-05-22 13:55:10 +10001844 seq_path(seq, &bitmap->storage.file->f_path, " \t\n");
NeilBrown57148962012-03-19 12:46:40 +11001845 }
1846
1847 seq_printf(seq, "\n");
1848 spin_unlock_irqrestore(&bitmap->lock, flags);
1849}
1850
NeilBrown43a70502009-12-14 12:49:55 +11001851static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11001852location_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11001853{
1854 ssize_t len;
NeilBrownac2f40b2010-06-01 19:37:31 +10001855 if (mddev->bitmap_info.file)
NeilBrown43a70502009-12-14 12:49:55 +11001856 len = sprintf(page, "file");
NeilBrownac2f40b2010-06-01 19:37:31 +10001857 else if (mddev->bitmap_info.offset)
NeilBrown43a70502009-12-14 12:49:55 +11001858 len = sprintf(page, "%+lld", (long long)mddev->bitmap_info.offset);
NeilBrownac2f40b2010-06-01 19:37:31 +10001859 else
NeilBrown43a70502009-12-14 12:49:55 +11001860 len = sprintf(page, "none");
1861 len += sprintf(page+len, "\n");
1862 return len;
1863}
1864
1865static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11001866location_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11001867{
1868
1869 if (mddev->pers) {
1870 if (!mddev->pers->quiesce)
1871 return -EBUSY;
1872 if (mddev->recovery || mddev->sync_thread)
1873 return -EBUSY;
1874 }
1875
1876 if (mddev->bitmap || mddev->bitmap_info.file ||
1877 mddev->bitmap_info.offset) {
1878 /* bitmap already configured. Only option is to clear it */
1879 if (strncmp(buf, "none", 4) != 0)
1880 return -EBUSY;
1881 if (mddev->pers) {
1882 mddev->pers->quiesce(mddev, 1);
1883 bitmap_destroy(mddev);
1884 mddev->pers->quiesce(mddev, 0);
1885 }
1886 mddev->bitmap_info.offset = 0;
1887 if (mddev->bitmap_info.file) {
1888 struct file *f = mddev->bitmap_info.file;
1889 mddev->bitmap_info.file = NULL;
1890 restore_bitmap_write_access(f);
1891 fput(f);
1892 }
1893 } else {
1894 /* No bitmap, OK to set a location */
1895 long long offset;
1896 if (strncmp(buf, "none", 4) == 0)
1897 /* nothing to be done */;
1898 else if (strncmp(buf, "file:", 5) == 0) {
1899 /* Not supported yet */
1900 return -EINVAL;
1901 } else {
1902 int rv;
1903 if (buf[0] == '+')
1904 rv = strict_strtoll(buf+1, 10, &offset);
1905 else
1906 rv = strict_strtoll(buf, 10, &offset);
1907 if (rv)
1908 return rv;
1909 if (offset == 0)
1910 return -EINVAL;
NeilBrownece5cff2009-12-14 12:49:56 +11001911 if (mddev->bitmap_info.external == 0 &&
1912 mddev->major_version == 0 &&
NeilBrown43a70502009-12-14 12:49:55 +11001913 offset != mddev->bitmap_info.default_offset)
1914 return -EINVAL;
1915 mddev->bitmap_info.offset = offset;
1916 if (mddev->pers) {
1917 mddev->pers->quiesce(mddev, 1);
1918 rv = bitmap_create(mddev);
NeilBrown4474ca42012-03-19 12:46:37 +11001919 if (!rv)
1920 rv = bitmap_load(mddev);
NeilBrown43a70502009-12-14 12:49:55 +11001921 if (rv) {
1922 bitmap_destroy(mddev);
1923 mddev->bitmap_info.offset = 0;
1924 }
1925 mddev->pers->quiesce(mddev, 0);
1926 if (rv)
1927 return rv;
1928 }
1929 }
1930 }
1931 if (!mddev->external) {
1932 /* Ensure new bitmap info is stored in
1933 * metadata promptly.
1934 */
1935 set_bit(MD_CHANGE_DEVS, &mddev->flags);
1936 md_wakeup_thread(mddev->thread);
1937 }
1938 return len;
1939}
1940
1941static struct md_sysfs_entry bitmap_location =
1942__ATTR(location, S_IRUGO|S_IWUSR, location_show, location_store);
1943
NeilBrown6409bb02012-05-22 13:55:07 +10001944/* 'bitmap/space' is the space available at 'location' for the
1945 * bitmap. This allows the kernel to know when it is safe to
1946 * resize the bitmap to match a resized array.
1947 */
1948static ssize_t
1949space_show(struct mddev *mddev, char *page)
1950{
1951 return sprintf(page, "%lu\n", mddev->bitmap_info.space);
1952}
1953
1954static ssize_t
1955space_store(struct mddev *mddev, const char *buf, size_t len)
1956{
1957 unsigned long sectors;
1958 int rv;
1959
1960 rv = kstrtoul(buf, 10, &sectors);
1961 if (rv)
1962 return rv;
1963
1964 if (sectors == 0)
1965 return -EINVAL;
1966
1967 if (mddev->bitmap &&
NeilBrown1ec885c2012-05-22 13:55:10 +10001968 sectors < ((mddev->bitmap->storage.file_pages - 1)
1969 * PAGE_SIZE
1970 + mddev->bitmap->storage.last_page_size + 511) >> 9)
NeilBrown6409bb02012-05-22 13:55:07 +10001971 return -EFBIG; /* Bitmap is too big for this small space */
1972
1973 /* could make sure it isn't too big, but that isn't really
1974 * needed - user-space should be careful.
1975 */
1976 mddev->bitmap_info.space = sectors;
1977 return len;
1978}
1979
1980static struct md_sysfs_entry bitmap_space =
1981__ATTR(space, S_IRUGO|S_IWUSR, space_show, space_store);
1982
NeilBrown43a70502009-12-14 12:49:55 +11001983static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11001984timeout_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11001985{
1986 ssize_t len;
1987 unsigned long secs = mddev->bitmap_info.daemon_sleep / HZ;
1988 unsigned long jifs = mddev->bitmap_info.daemon_sleep % HZ;
NeilBrownac2f40b2010-06-01 19:37:31 +10001989
NeilBrown43a70502009-12-14 12:49:55 +11001990 len = sprintf(page, "%lu", secs);
1991 if (jifs)
1992 len += sprintf(page+len, ".%03u", jiffies_to_msecs(jifs));
1993 len += sprintf(page+len, "\n");
1994 return len;
1995}
1996
1997static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11001998timeout_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11001999{
2000 /* timeout can be set at any time */
2001 unsigned long timeout;
2002 int rv = strict_strtoul_scaled(buf, &timeout, 4);
2003 if (rv)
2004 return rv;
2005
2006 /* just to make sure we don't overflow... */
2007 if (timeout >= LONG_MAX / HZ)
2008 return -EINVAL;
2009
2010 timeout = timeout * HZ / 10000;
2011
2012 if (timeout >= MAX_SCHEDULE_TIMEOUT)
2013 timeout = MAX_SCHEDULE_TIMEOUT-1;
2014 if (timeout < 1)
2015 timeout = 1;
2016 mddev->bitmap_info.daemon_sleep = timeout;
2017 if (mddev->thread) {
2018 /* if thread->timeout is MAX_SCHEDULE_TIMEOUT, then
2019 * the bitmap is all clean and we don't need to
2020 * adjust the timeout right now
2021 */
2022 if (mddev->thread->timeout < MAX_SCHEDULE_TIMEOUT) {
2023 mddev->thread->timeout = timeout;
2024 md_wakeup_thread(mddev->thread);
2025 }
2026 }
2027 return len;
2028}
2029
2030static struct md_sysfs_entry bitmap_timeout =
2031__ATTR(time_base, S_IRUGO|S_IWUSR, timeout_show, timeout_store);
2032
2033static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002034backlog_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11002035{
2036 return sprintf(page, "%lu\n", mddev->bitmap_info.max_write_behind);
2037}
2038
2039static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002040backlog_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11002041{
2042 unsigned long backlog;
2043 int rv = strict_strtoul(buf, 10, &backlog);
2044 if (rv)
2045 return rv;
2046 if (backlog > COUNTER_MAX)
2047 return -EINVAL;
2048 mddev->bitmap_info.max_write_behind = backlog;
2049 return len;
2050}
2051
2052static struct md_sysfs_entry bitmap_backlog =
2053__ATTR(backlog, S_IRUGO|S_IWUSR, backlog_show, backlog_store);
2054
2055static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002056chunksize_show(struct mddev *mddev, char *page)
NeilBrown43a70502009-12-14 12:49:55 +11002057{
2058 return sprintf(page, "%lu\n", mddev->bitmap_info.chunksize);
2059}
2060
2061static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002062chunksize_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown43a70502009-12-14 12:49:55 +11002063{
2064 /* Can only be changed when no bitmap is active */
2065 int rv;
2066 unsigned long csize;
2067 if (mddev->bitmap)
2068 return -EBUSY;
2069 rv = strict_strtoul(buf, 10, &csize);
2070 if (rv)
2071 return rv;
2072 if (csize < 512 ||
2073 !is_power_of_2(csize))
2074 return -EINVAL;
2075 mddev->bitmap_info.chunksize = csize;
2076 return len;
2077}
2078
2079static struct md_sysfs_entry bitmap_chunksize =
2080__ATTR(chunksize, S_IRUGO|S_IWUSR, chunksize_show, chunksize_store);
2081
NeilBrownfd01b882011-10-11 16:47:53 +11002082static ssize_t metadata_show(struct mddev *mddev, char *page)
NeilBrownece5cff2009-12-14 12:49:56 +11002083{
2084 return sprintf(page, "%s\n", (mddev->bitmap_info.external
2085 ? "external" : "internal"));
2086}
2087
NeilBrownfd01b882011-10-11 16:47:53 +11002088static ssize_t metadata_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownece5cff2009-12-14 12:49:56 +11002089{
2090 if (mddev->bitmap ||
2091 mddev->bitmap_info.file ||
2092 mddev->bitmap_info.offset)
2093 return -EBUSY;
2094 if (strncmp(buf, "external", 8) == 0)
2095 mddev->bitmap_info.external = 1;
2096 else if (strncmp(buf, "internal", 8) == 0)
2097 mddev->bitmap_info.external = 0;
2098 else
2099 return -EINVAL;
2100 return len;
2101}
2102
2103static struct md_sysfs_entry bitmap_metadata =
2104__ATTR(metadata, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
2105
NeilBrownfd01b882011-10-11 16:47:53 +11002106static ssize_t can_clear_show(struct mddev *mddev, char *page)
NeilBrownece5cff2009-12-14 12:49:56 +11002107{
2108 int len;
2109 if (mddev->bitmap)
2110 len = sprintf(page, "%s\n", (mddev->bitmap->need_sync ?
2111 "false" : "true"));
2112 else
2113 len = sprintf(page, "\n");
2114 return len;
2115}
2116
NeilBrownfd01b882011-10-11 16:47:53 +11002117static ssize_t can_clear_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownece5cff2009-12-14 12:49:56 +11002118{
2119 if (mddev->bitmap == NULL)
2120 return -ENOENT;
2121 if (strncmp(buf, "false", 5) == 0)
2122 mddev->bitmap->need_sync = 1;
2123 else if (strncmp(buf, "true", 4) == 0) {
2124 if (mddev->degraded)
2125 return -EBUSY;
2126 mddev->bitmap->need_sync = 0;
2127 } else
2128 return -EINVAL;
2129 return len;
2130}
2131
2132static struct md_sysfs_entry bitmap_can_clear =
2133__ATTR(can_clear, S_IRUGO|S_IWUSR, can_clear_show, can_clear_store);
2134
Paul Clements696fcd52010-03-08 16:02:37 +11002135static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002136behind_writes_used_show(struct mddev *mddev, char *page)
Paul Clements696fcd52010-03-08 16:02:37 +11002137{
2138 if (mddev->bitmap == NULL)
2139 return sprintf(page, "0\n");
2140 return sprintf(page, "%lu\n",
2141 mddev->bitmap->behind_writes_used);
2142}
2143
2144static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11002145behind_writes_used_reset(struct mddev *mddev, const char *buf, size_t len)
Paul Clements696fcd52010-03-08 16:02:37 +11002146{
2147 if (mddev->bitmap)
2148 mddev->bitmap->behind_writes_used = 0;
2149 return len;
2150}
2151
2152static struct md_sysfs_entry max_backlog_used =
2153__ATTR(max_backlog_used, S_IRUGO | S_IWUSR,
2154 behind_writes_used_show, behind_writes_used_reset);
2155
NeilBrown43a70502009-12-14 12:49:55 +11002156static struct attribute *md_bitmap_attrs[] = {
2157 &bitmap_location.attr,
NeilBrown6409bb02012-05-22 13:55:07 +10002158 &bitmap_space.attr,
NeilBrown43a70502009-12-14 12:49:55 +11002159 &bitmap_timeout.attr,
2160 &bitmap_backlog.attr,
2161 &bitmap_chunksize.attr,
NeilBrownece5cff2009-12-14 12:49:56 +11002162 &bitmap_metadata.attr,
2163 &bitmap_can_clear.attr,
Paul Clements696fcd52010-03-08 16:02:37 +11002164 &max_backlog_used.attr,
NeilBrown43a70502009-12-14 12:49:55 +11002165 NULL
2166};
2167struct attribute_group md_bitmap_group = {
2168 .name = "bitmap",
2169 .attrs = md_bitmap_attrs,
2170};
2171