blob: cb8281605be8f7d23bbd0769309268b5f69d7c1a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 md.c : Multiple Devices driver for Linux
3 Copyright (C) 1998, 1999, 2000 Ingo Molnar
4
5 completely rewritten, based on the MD driver code from Marc Zyngier
6
7 Changes:
8
9 - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
10 - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
11 - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
12 - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
13 - kmod support by: Cyrus Durgin
14 - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
15 - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
16
17 - lots of fixes and improvements to the RAID1/RAID5 and generic
18 RAID code (such as request based resynchronization):
19
20 Neil Brown <neilb@cse.unsw.edu.au>.
21
NeilBrown32a76272005-06-21 17:17:14 -070022 - persistent bitmap code
23 Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
24
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 This program is free software; you can redistribute it and/or modify
26 it under the terms of the GNU General Public License as published by
27 the Free Software Foundation; either version 2, or (at your option)
28 any later version.
29
30 You should have received a copy of the GNU General Public License
31 (for example /usr/src/linux/COPYING); if not, write to the Free
32 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33*/
34
35#include <linux/module.h>
NeilBrowna6fb0932005-09-09 16:23:56 -070036#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/linkage.h>
38#include <linux/raid/md.h>
NeilBrown32a76272005-06-21 17:17:14 -070039#include <linux/raid/bitmap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/sysctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/buffer_head.h> /* for invalidate_bdev */
42#include <linux/suspend.h>
NeilBrownd7603b72006-01-06 00:20:30 -080043#include <linux/poll.h>
Arjan van de Ven48c9c272006-03-27 01:18:20 -080044#include <linux/mutex.h>
NeilBrown16f17b32006-06-26 00:27:37 -070045#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#include <linux/init.h>
48
NeilBrown32a76272005-06-21 17:17:14 -070049#include <linux/file.h>
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#ifdef CONFIG_KMOD
52#include <linux/kmod.h>
53#endif
54
55#include <asm/unaligned.h>
56
57#define MAJOR_NR MD_MAJOR
58#define MD_DRIVER
59
60/* 63 partitions with the alternate major number (mdp) */
61#define MdpMinorShift 6
62
63#define DEBUG 0
64#define dprintk(x...) ((void)(DEBUG && printk(x)))
65
66
67#ifndef MODULE
68static void autostart_arrays (int part);
69#endif
70
NeilBrown2604b702006-01-06 00:20:36 -080071static LIST_HEAD(pers_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static DEFINE_SPINLOCK(pers_lock);
73
Adrian Bunk5e563412006-06-26 00:27:42 -070074static void md_print_devices(void);
75
76#define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078/*
79 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
80 * is 1000 KB/sec, so the extra system load does not show up that much.
81 * Increase it if you want to have more _guaranteed_ speed. Note that
Adrian Bunk338cec32005-09-10 00:26:54 -070082 * the RAID driver will use the maximum available bandwidth if the IO
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 * subsystem is idle. There is also an 'absolute maximum' reconstruction
84 * speed limit - in case reconstruction slows down your system despite
85 * idle IO detection.
86 *
87 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
NeilBrown88202a02006-01-06 00:21:36 -080088 * or /sys/block/mdX/md/sync_speed_{min,max}
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 */
90
91static int sysctl_speed_limit_min = 1000;
92static int sysctl_speed_limit_max = 200000;
NeilBrown88202a02006-01-06 00:21:36 -080093static inline int speed_min(mddev_t *mddev)
94{
95 return mddev->sync_speed_min ?
96 mddev->sync_speed_min : sysctl_speed_limit_min;
97}
98
99static inline int speed_max(mddev_t *mddev)
100{
101 return mddev->sync_speed_max ?
102 mddev->sync_speed_max : sysctl_speed_limit_max;
103}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105static struct ctl_table_header *raid_table_header;
106
107static ctl_table raid_table[] = {
108 {
109 .ctl_name = DEV_RAID_SPEED_LIMIT_MIN,
110 .procname = "speed_limit_min",
111 .data = &sysctl_speed_limit_min,
112 .maxlen = sizeof(int),
NeilBrown80ca3a42006-07-10 04:44:18 -0700113 .mode = S_IRUGO|S_IWUSR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 .proc_handler = &proc_dointvec,
115 },
116 {
117 .ctl_name = DEV_RAID_SPEED_LIMIT_MAX,
118 .procname = "speed_limit_max",
119 .data = &sysctl_speed_limit_max,
120 .maxlen = sizeof(int),
NeilBrown80ca3a42006-07-10 04:44:18 -0700121 .mode = S_IRUGO|S_IWUSR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 .proc_handler = &proc_dointvec,
123 },
124 { .ctl_name = 0 }
125};
126
127static ctl_table raid_dir_table[] = {
128 {
129 .ctl_name = DEV_RAID,
130 .procname = "raid",
131 .maxlen = 0,
NeilBrown80ca3a42006-07-10 04:44:18 -0700132 .mode = S_IRUGO|S_IXUGO,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 .child = raid_table,
134 },
135 { .ctl_name = 0 }
136};
137
138static ctl_table raid_root_table[] = {
139 {
140 .ctl_name = CTL_DEV,
141 .procname = "dev",
142 .maxlen = 0,
143 .mode = 0555,
144 .child = raid_dir_table,
145 },
146 { .ctl_name = 0 }
147};
148
149static struct block_device_operations md_fops;
150
NeilBrownf91de922005-11-08 21:39:36 -0800151static int start_readonly;
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153/*
NeilBrownd7603b72006-01-06 00:20:30 -0800154 * We have a system wide 'event count' that is incremented
155 * on any 'interesting' event, and readers of /proc/mdstat
156 * can use 'poll' or 'select' to find out when the event
157 * count increases.
158 *
159 * Events are:
160 * start array, stop array, error, add device, remove device,
161 * start build, activate spare
162 */
NeilBrown2989ddb2006-01-06 00:20:43 -0800163static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
NeilBrownd7603b72006-01-06 00:20:30 -0800164static atomic_t md_event_count;
NeilBrown29269552006-03-27 01:18:10 -0800165void md_new_event(mddev_t *mddev)
NeilBrownd7603b72006-01-06 00:20:30 -0800166{
167 atomic_inc(&md_event_count);
168 wake_up(&md_event_waiters);
NeilBrown4508a7a2006-03-20 17:53:53 +1100169 sysfs_notify(&mddev->kobj, NULL, "sync_action");
NeilBrownd7603b72006-01-06 00:20:30 -0800170}
NeilBrown29269552006-03-27 01:18:10 -0800171EXPORT_SYMBOL_GPL(md_new_event);
NeilBrownd7603b72006-01-06 00:20:30 -0800172
NeilBrownc331eb02006-05-30 21:27:13 -0700173/* Alternate version that can be called from interrupts
174 * when calling sysfs_notify isn't needed.
175 */
Adrian Bunk05381952006-06-26 00:28:01 -0700176static void md_new_event_inintr(mddev_t *mddev)
NeilBrownc331eb02006-05-30 21:27:13 -0700177{
178 atomic_inc(&md_event_count);
179 wake_up(&md_event_waiters);
180}
181
NeilBrownd7603b72006-01-06 00:20:30 -0800182/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 * Enables to iterate over all existing md arrays
184 * all_mddevs_lock protects this list.
185 */
186static LIST_HEAD(all_mddevs);
187static DEFINE_SPINLOCK(all_mddevs_lock);
188
189
190/*
191 * iterates through all used mddevs in the system.
192 * We take care to grab the all_mddevs_lock whenever navigating
193 * the list, and to always hold a refcount when unlocked.
194 * Any code which breaks out of this loop while own
195 * a reference to the current mddev and must mddev_put it.
196 */
197#define ITERATE_MDDEV(mddev,tmp) \
198 \
199 for (({ spin_lock(&all_mddevs_lock); \
200 tmp = all_mddevs.next; \
201 mddev = NULL;}); \
202 ({ if (tmp != &all_mddevs) \
203 mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
204 spin_unlock(&all_mddevs_lock); \
205 if (mddev) mddev_put(mddev); \
206 mddev = list_entry(tmp, mddev_t, all_mddevs); \
207 tmp != &all_mddevs;}); \
208 ({ spin_lock(&all_mddevs_lock); \
209 tmp = tmp->next;}) \
210 )
211
212
213static int md_fail_request (request_queue_t *q, struct bio *bio)
214{
215 bio_io_error(bio, bio->bi_size);
216 return 0;
217}
218
219static inline mddev_t *mddev_get(mddev_t *mddev)
220{
221 atomic_inc(&mddev->active);
222 return mddev;
223}
224
225static void mddev_put(mddev_t *mddev)
226{
227 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
228 return;
229 if (!mddev->raid_disks && list_empty(&mddev->disks)) {
230 list_del(&mddev->all_mddevs);
NeilBrown926ce2d2006-03-31 02:32:02 -0800231 spin_unlock(&all_mddevs_lock);
Al Viro1312f402006-03-12 11:02:03 -0500232 blk_cleanup_queue(mddev->queue);
NeilBrowneae17012005-11-08 21:39:23 -0800233 kobject_unregister(&mddev->kobj);
NeilBrown926ce2d2006-03-31 02:32:02 -0800234 } else
235 spin_unlock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236}
237
238static mddev_t * mddev_find(dev_t unit)
239{
240 mddev_t *mddev, *new = NULL;
241
242 retry:
243 spin_lock(&all_mddevs_lock);
244 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
245 if (mddev->unit == unit) {
246 mddev_get(mddev);
247 spin_unlock(&all_mddevs_lock);
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700248 kfree(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 return mddev;
250 }
251
252 if (new) {
253 list_add(&new->all_mddevs, &all_mddevs);
254 spin_unlock(&all_mddevs_lock);
255 return new;
256 }
257 spin_unlock(&all_mddevs_lock);
258
NeilBrown9ffae0c2006-01-06 00:20:32 -0800259 new = kzalloc(sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (!new)
261 return NULL;
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 new->unit = unit;
264 if (MAJOR(unit) == MD_MAJOR)
265 new->md_minor = MINOR(unit);
266 else
267 new->md_minor = MINOR(unit) >> MdpMinorShift;
268
NeilBrowndf5b89b2006-03-27 01:18:20 -0800269 mutex_init(&new->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 INIT_LIST_HEAD(&new->disks);
271 INIT_LIST_HEAD(&new->all_mddevs);
272 init_timer(&new->safemode_timer);
273 atomic_set(&new->active, 1);
NeilBrown06d91a52005-06-21 17:17:12 -0700274 spin_lock_init(&new->write_lock);
NeilBrown3d310eb2005-06-21 17:17:26 -0700275 init_waitqueue_head(&new->sb_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277 new->queue = blk_alloc_queue(GFP_KERNEL);
278 if (!new->queue) {
279 kfree(new);
280 return NULL;
281 }
NeilBrown89e5c8b2006-03-27 01:18:02 -0800282 set_bit(QUEUE_FLAG_CLUSTER, &new->queue->queue_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 blk_queue_make_request(new->queue, md_fail_request);
285
286 goto retry;
287}
288
289static inline int mddev_lock(mddev_t * mddev)
290{
NeilBrowndf5b89b2006-03-27 01:18:20 -0800291 return mutex_lock_interruptible(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294static inline int mddev_trylock(mddev_t * mddev)
295{
NeilBrowndf5b89b2006-03-27 01:18:20 -0800296 return mutex_trylock(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297}
298
299static inline void mddev_unlock(mddev_t * mddev)
300{
NeilBrowndf5b89b2006-03-27 01:18:20 -0800301 mutex_unlock(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
NeilBrown005eca52005-08-22 13:11:08 -0700303 md_wakeup_thread(mddev->thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304}
305
NeilBrown2989ddb2006-01-06 00:20:43 -0800306static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
308 mdk_rdev_t * rdev;
309 struct list_head *tmp;
310
311 ITERATE_RDEV(mddev,rdev,tmp) {
312 if (rdev->desc_nr == nr)
313 return rdev;
314 }
315 return NULL;
316}
317
318static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
319{
320 struct list_head *tmp;
321 mdk_rdev_t *rdev;
322
323 ITERATE_RDEV(mddev,rdev,tmp) {
324 if (rdev->bdev->bd_dev == dev)
325 return rdev;
326 }
327 return NULL;
328}
329
NeilBrownd9d166c2006-01-06 00:20:51 -0800330static struct mdk_personality *find_pers(int level, char *clevel)
NeilBrown2604b702006-01-06 00:20:36 -0800331{
332 struct mdk_personality *pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800333 list_for_each_entry(pers, &pers_list, list) {
334 if (level != LEVEL_NONE && pers->level == level)
NeilBrown2604b702006-01-06 00:20:36 -0800335 return pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800336 if (strcmp(pers->name, clevel)==0)
337 return pers;
338 }
NeilBrown2604b702006-01-06 00:20:36 -0800339 return NULL;
340}
341
Jesper Juhl77933d72005-07-27 11:46:09 -0700342static inline sector_t calc_dev_sboffset(struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
344 sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
345 return MD_NEW_SIZE_BLOCKS(size);
346}
347
348static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
349{
350 sector_t size;
351
352 size = rdev->sb_offset;
353
354 if (chunk_size)
355 size &= ~((sector_t)chunk_size/1024 - 1);
356 return size;
357}
358
359static int alloc_disk_sb(mdk_rdev_t * rdev)
360{
361 if (rdev->sb_page)
362 MD_BUG();
363
364 rdev->sb_page = alloc_page(GFP_KERNEL);
365 if (!rdev->sb_page) {
366 printk(KERN_ALERT "md: out of memory.\n");
367 return -EINVAL;
368 }
369
370 return 0;
371}
372
373static void free_disk_sb(mdk_rdev_t * rdev)
374{
375 if (rdev->sb_page) {
NeilBrown2d1f3b52006-01-06 00:20:31 -0800376 put_page(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 rdev->sb_loaded = 0;
378 rdev->sb_page = NULL;
379 rdev->sb_offset = 0;
380 rdev->size = 0;
381 }
382}
383
384
NeilBrown7bfa19f2005-06-21 17:17:28 -0700385static int super_written(struct bio *bio, unsigned int bytes_done, int error)
386{
387 mdk_rdev_t *rdev = bio->bi_private;
NeilBrowna9701a32005-11-08 21:39:34 -0800388 mddev_t *mddev = rdev->mddev;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700389 if (bio->bi_size)
390 return 1;
391
NeilBrown3a0f5bb2006-10-03 01:16:03 -0700392 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
393 printk("md: super_written gets error=%d, uptodate=%d\n",
394 error, test_bit(BIO_UPTODATE, &bio->bi_flags));
395 WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
NeilBrowna9701a32005-11-08 21:39:34 -0800396 md_error(mddev, rdev);
NeilBrown3a0f5bb2006-10-03 01:16:03 -0700397 }
NeilBrown7bfa19f2005-06-21 17:17:28 -0700398
NeilBrowna9701a32005-11-08 21:39:34 -0800399 if (atomic_dec_and_test(&mddev->pending_writes))
400 wake_up(&mddev->sb_wait);
Neil Brownf8b58ed2005-06-27 22:29:34 -0700401 bio_put(bio);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700402 return 0;
403}
404
NeilBrowna9701a32005-11-08 21:39:34 -0800405static int super_written_barrier(struct bio *bio, unsigned int bytes_done, int error)
406{
407 struct bio *bio2 = bio->bi_private;
408 mdk_rdev_t *rdev = bio2->bi_private;
409 mddev_t *mddev = rdev->mddev;
410 if (bio->bi_size)
411 return 1;
412
413 if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
414 error == -EOPNOTSUPP) {
415 unsigned long flags;
416 /* barriers don't appear to be supported :-( */
417 set_bit(BarriersNotsupp, &rdev->flags);
418 mddev->barriers_work = 0;
419 spin_lock_irqsave(&mddev->write_lock, flags);
420 bio2->bi_next = mddev->biolist;
421 mddev->biolist = bio2;
422 spin_unlock_irqrestore(&mddev->write_lock, flags);
423 wake_up(&mddev->sb_wait);
424 bio_put(bio);
425 return 0;
426 }
427 bio_put(bio2);
428 bio->bi_private = rdev;
429 return super_written(bio, bytes_done, error);
430}
431
NeilBrown7bfa19f2005-06-21 17:17:28 -0700432void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
433 sector_t sector, int size, struct page *page)
434{
435 /* write first size bytes of page to sector of rdev
436 * Increment mddev->pending_writes before returning
437 * and decrement it on completion, waking up sb_wait
438 * if zero is reached.
439 * If an error occurred, call md_error
NeilBrowna9701a32005-11-08 21:39:34 -0800440 *
441 * As we might need to resubmit the request if BIO_RW_BARRIER
442 * causes ENOTSUPP, we allocate a spare bio...
NeilBrown7bfa19f2005-06-21 17:17:28 -0700443 */
444 struct bio *bio = bio_alloc(GFP_NOIO, 1);
NeilBrowna9701a32005-11-08 21:39:34 -0800445 int rw = (1<<BIO_RW) | (1<<BIO_RW_SYNC);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700446
447 bio->bi_bdev = rdev->bdev;
448 bio->bi_sector = sector;
449 bio_add_page(bio, page, size, 0);
450 bio->bi_private = rdev;
451 bio->bi_end_io = super_written;
NeilBrowna9701a32005-11-08 21:39:34 -0800452 bio->bi_rw = rw;
453
NeilBrown7bfa19f2005-06-21 17:17:28 -0700454 atomic_inc(&mddev->pending_writes);
NeilBrowna9701a32005-11-08 21:39:34 -0800455 if (!test_bit(BarriersNotsupp, &rdev->flags)) {
456 struct bio *rbio;
457 rw |= (1<<BIO_RW_BARRIER);
458 rbio = bio_clone(bio, GFP_NOIO);
459 rbio->bi_private = bio;
460 rbio->bi_end_io = super_written_barrier;
461 submit_bio(rw, rbio);
462 } else
463 submit_bio(rw, bio);
464}
465
466void md_super_wait(mddev_t *mddev)
467{
468 /* wait for all superblock writes that were scheduled to complete.
469 * if any had to be retried (due to BARRIER problems), retry them
470 */
471 DEFINE_WAIT(wq);
472 for(;;) {
473 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
474 if (atomic_read(&mddev->pending_writes)==0)
475 break;
476 while (mddev->biolist) {
477 struct bio *bio;
478 spin_lock_irq(&mddev->write_lock);
479 bio = mddev->biolist;
480 mddev->biolist = bio->bi_next ;
481 bio->bi_next = NULL;
482 spin_unlock_irq(&mddev->write_lock);
483 submit_bio(bio->bi_rw, bio);
484 }
485 schedule();
486 }
487 finish_wait(&mddev->sb_wait, &wq);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700488}
489
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490static int bi_complete(struct bio *bio, unsigned int bytes_done, int error)
491{
492 if (bio->bi_size)
493 return 1;
494
495 complete((struct completion*)bio->bi_private);
496 return 0;
497}
498
NeilBrowna654b9d82005-06-21 17:17:27 -0700499int sync_page_io(struct block_device *bdev, sector_t sector, int size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 struct page *page, int rw)
501{
Neil Brownbaaa2c52005-04-16 15:23:54 -0700502 struct bio *bio = bio_alloc(GFP_NOIO, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 struct completion event;
504 int ret;
505
506 rw |= (1 << BIO_RW_SYNC);
507
508 bio->bi_bdev = bdev;
509 bio->bi_sector = sector;
510 bio_add_page(bio, page, size, 0);
511 init_completion(&event);
512 bio->bi_private = &event;
513 bio->bi_end_io = bi_complete;
514 submit_bio(rw, bio);
515 wait_for_completion(&event);
516
517 ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
518 bio_put(bio);
519 return ret;
520}
NeilBrowna8745db2006-01-06 00:20:34 -0800521EXPORT_SYMBOL_GPL(sync_page_io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
NeilBrown0002b272005-09-09 16:23:53 -0700523static int read_disk_sb(mdk_rdev_t * rdev, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 char b[BDEVNAME_SIZE];
526 if (!rdev->sb_page) {
527 MD_BUG();
528 return -EINVAL;
529 }
530 if (rdev->sb_loaded)
531 return 0;
532
533
NeilBrown0002b272005-09-09 16:23:53 -0700534 if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 goto fail;
536 rdev->sb_loaded = 1;
537 return 0;
538
539fail:
540 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
541 bdevname(rdev->bdev,b));
542 return -EINVAL;
543}
544
545static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
546{
547 if ( (sb1->set_uuid0 == sb2->set_uuid0) &&
548 (sb1->set_uuid1 == sb2->set_uuid1) &&
549 (sb1->set_uuid2 == sb2->set_uuid2) &&
550 (sb1->set_uuid3 == sb2->set_uuid3))
551
552 return 1;
553
554 return 0;
555}
556
557
558static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
559{
560 int ret;
561 mdp_super_t *tmp1, *tmp2;
562
563 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
564 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
565
566 if (!tmp1 || !tmp2) {
567 ret = 0;
568 printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
569 goto abort;
570 }
571
572 *tmp1 = *sb1;
573 *tmp2 = *sb2;
574
575 /*
576 * nr_disks is not constant
577 */
578 tmp1->nr_disks = 0;
579 tmp2->nr_disks = 0;
580
581 if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
582 ret = 0;
583 else
584 ret = 1;
585
586abort:
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700587 kfree(tmp1);
588 kfree(tmp2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 return ret;
590}
591
592static unsigned int calc_sb_csum(mdp_super_t * sb)
593{
594 unsigned int disk_csum, csum;
595
596 disk_csum = sb->sb_csum;
597 sb->sb_csum = 0;
598 csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
599 sb->sb_csum = disk_csum;
600 return csum;
601}
602
603
604/*
605 * Handle superblock details.
606 * We want to be able to handle multiple superblock formats
607 * so we have a common interface to them all, and an array of
608 * different handlers.
609 * We rely on user-space to write the initial superblock, and support
610 * reading and updating of superblocks.
611 * Interface methods are:
612 * int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
613 * loads and validates a superblock on dev.
614 * if refdev != NULL, compare superblocks on both devices
615 * Return:
616 * 0 - dev has a superblock that is compatible with refdev
617 * 1 - dev has a superblock that is compatible and newer than refdev
618 * so dev should be used as the refdev in future
619 * -EINVAL superblock incompatible or invalid
620 * -othererror e.g. -EIO
621 *
622 * int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
623 * Verify that dev is acceptable into mddev.
624 * The first time, mddev->raid_disks will be 0, and data from
625 * dev should be merged in. Subsequent calls check that dev
626 * is new enough. Return 0 or -EINVAL
627 *
628 * void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
629 * Update the superblock for rdev with data in mddev
630 * This does not write to disc.
631 *
632 */
633
634struct super_type {
635 char *name;
636 struct module *owner;
637 int (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
638 int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
639 void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
640};
641
642/*
643 * load_super for 0.90.0
644 */
645static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
646{
647 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
648 mdp_super_t *sb;
649 int ret;
650 sector_t sb_offset;
651
652 /*
653 * Calculate the position of the superblock,
654 * it's at the end of the disk.
655 *
656 * It also happens to be a multiple of 4Kb.
657 */
658 sb_offset = calc_dev_sboffset(rdev->bdev);
659 rdev->sb_offset = sb_offset;
660
NeilBrown0002b272005-09-09 16:23:53 -0700661 ret = read_disk_sb(rdev, MD_SB_BYTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (ret) return ret;
663
664 ret = -EINVAL;
665
666 bdevname(rdev->bdev, b);
667 sb = (mdp_super_t*)page_address(rdev->sb_page);
668
669 if (sb->md_magic != MD_SB_MAGIC) {
670 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
671 b);
672 goto abort;
673 }
674
675 if (sb->major_version != 0 ||
NeilBrownf6705572006-03-27 01:18:11 -0800676 sb->minor_version < 90 ||
677 sb->minor_version > 91) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
679 sb->major_version, sb->minor_version,
680 b);
681 goto abort;
682 }
683
684 if (sb->raid_disks <= 0)
685 goto abort;
686
687 if (csum_fold(calc_sb_csum(sb)) != csum_fold(sb->sb_csum)) {
688 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
689 b);
690 goto abort;
691 }
692
693 rdev->preferred_minor = sb->md_minor;
694 rdev->data_offset = 0;
NeilBrown0002b272005-09-09 16:23:53 -0700695 rdev->sb_size = MD_SB_BYTES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 if (sb->level == LEVEL_MULTIPATH)
698 rdev->desc_nr = -1;
699 else
700 rdev->desc_nr = sb->this_disk.number;
701
702 if (refdev == 0)
703 ret = 1;
704 else {
705 __u64 ev1, ev2;
706 mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
707 if (!uuid_equal(refsb, sb)) {
708 printk(KERN_WARNING "md: %s has different UUID to %s\n",
709 b, bdevname(refdev->bdev,b2));
710 goto abort;
711 }
712 if (!sb_equal(refsb, sb)) {
713 printk(KERN_WARNING "md: %s has same UUID"
714 " but different superblock to %s\n",
715 b, bdevname(refdev->bdev, b2));
716 goto abort;
717 }
718 ev1 = md_event(sb);
719 ev2 = md_event(refsb);
720 if (ev1 > ev2)
721 ret = 1;
722 else
723 ret = 0;
724 }
725 rdev->size = calc_dev_size(rdev, sb->chunk_size);
726
NeilBrown2bf071b2006-01-06 00:20:55 -0800727 if (rdev->size < sb->size && sb->level > 1)
728 /* "this cannot possibly happen" ... */
729 ret = -EINVAL;
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 abort:
732 return ret;
733}
734
735/*
736 * validate_super for 0.90.0
737 */
738static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
739{
740 mdp_disk_t *desc;
741 mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -0700742 __u64 ev1 = md_event(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
NeilBrown41158c72005-06-21 17:17:25 -0700744 rdev->raid_disk = -1;
NeilBrownb2d444d2005-11-08 21:39:31 -0800745 rdev->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 if (mddev->raid_disks == 0) {
747 mddev->major_version = 0;
748 mddev->minor_version = sb->minor_version;
749 mddev->patch_version = sb->patch_version;
750 mddev->persistent = ! sb->not_persistent;
751 mddev->chunk_size = sb->chunk_size;
752 mddev->ctime = sb->ctime;
753 mddev->utime = sb->utime;
754 mddev->level = sb->level;
NeilBrownd9d166c2006-01-06 00:20:51 -0800755 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 mddev->layout = sb->layout;
757 mddev->raid_disks = sb->raid_disks;
758 mddev->size = sb->size;
NeilBrown07d84d102006-06-26 00:27:56 -0700759 mddev->events = ev1;
NeilBrown92232142005-08-18 11:24:16 -0700760 mddev->bitmap_offset = 0;
NeilBrown36fa3062005-09-09 16:23:45 -0700761 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
NeilBrownf6705572006-03-27 01:18:11 -0800763 if (mddev->minor_version >= 91) {
764 mddev->reshape_position = sb->reshape_position;
765 mddev->delta_disks = sb->delta_disks;
766 mddev->new_level = sb->new_level;
767 mddev->new_layout = sb->new_layout;
768 mddev->new_chunk = sb->new_chunk;
769 } else {
770 mddev->reshape_position = MaxSector;
771 mddev->delta_disks = 0;
772 mddev->new_level = mddev->level;
773 mddev->new_layout = mddev->layout;
774 mddev->new_chunk = mddev->chunk_size;
775 }
776
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 if (sb->state & (1<<MD_SB_CLEAN))
778 mddev->recovery_cp = MaxSector;
779 else {
780 if (sb->events_hi == sb->cp_events_hi &&
781 sb->events_lo == sb->cp_events_lo) {
782 mddev->recovery_cp = sb->recovery_cp;
783 } else
784 mddev->recovery_cp = 0;
785 }
786
787 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
788 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
789 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
790 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
791
792 mddev->max_disks = MD_SB_DISKS;
NeilBrowna654b9d82005-06-21 17:17:27 -0700793
794 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
795 mddev->bitmap_file == NULL) {
NeilBrownc5a10f62006-03-27 01:18:03 -0800796 if (mddev->level != 1 && mddev->level != 4
797 && mddev->level != 5 && mddev->level != 6
NeilBrown6cce3b22006-01-06 00:20:16 -0800798 && mddev->level != 10) {
NeilBrowna654b9d82005-06-21 17:17:27 -0700799 /* FIXME use a better test */
NeilBrown6cce3b22006-01-06 00:20:16 -0800800 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
NeilBrowna654b9d82005-06-21 17:17:27 -0700801 return -EINVAL;
802 }
NeilBrown36fa3062005-09-09 16:23:45 -0700803 mddev->bitmap_offset = mddev->default_bitmap_offset;
NeilBrowna654b9d82005-06-21 17:17:27 -0700804 }
805
NeilBrown41158c72005-06-21 17:17:25 -0700806 } else if (mddev->pers == NULL) {
807 /* Insist on good event counter while assembling */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 ++ev1;
809 if (ev1 < mddev->events)
810 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -0700811 } else if (mddev->bitmap) {
812 /* if adding to array with a bitmap, then we can accept an
813 * older device ... but not too old.
814 */
NeilBrown41158c72005-06-21 17:17:25 -0700815 if (ev1 < mddev->bitmap->events_cleared)
816 return 0;
NeilBrown07d84d102006-06-26 00:27:56 -0700817 } else {
818 if (ev1 < mddev->events)
819 /* just a hot-add of a new device, leave raid_disk at -1 */
820 return 0;
821 }
NeilBrown41158c72005-06-21 17:17:25 -0700822
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 if (mddev->level != LEVEL_MULTIPATH) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 desc = sb->disks + rdev->desc_nr;
825
826 if (desc->state & (1<<MD_DISK_FAULTY))
NeilBrownb2d444d2005-11-08 21:39:31 -0800827 set_bit(Faulty, &rdev->flags);
NeilBrown7c7546c2006-06-26 00:27:41 -0700828 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
829 desc->raid_disk < mddev->raid_disks */) {
NeilBrownb2d444d2005-11-08 21:39:31 -0800830 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 rdev->raid_disk = desc->raid_disk;
832 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -0700833 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
834 set_bit(WriteMostly, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -0700835 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -0800836 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 return 0;
838}
839
840/*
841 * sync_super for 0.90.0
842 */
843static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
844{
845 mdp_super_t *sb;
846 struct list_head *tmp;
847 mdk_rdev_t *rdev2;
848 int next_spare = mddev->raid_disks;
NeilBrown19133a42005-11-08 21:39:35 -0800849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851 /* make rdev->sb match mddev data..
852 *
853 * 1/ zero out disks
854 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
855 * 3/ any empty disks < next_spare become removed
856 *
857 * disks[0] gets initialised to REMOVED because
858 * we cannot be sure from other fields if it has
859 * been initialised or not.
860 */
861 int i;
862 int active=0, working=0,failed=0,spare=0,nr_disks=0;
863
NeilBrown61181562005-09-09 16:24:02 -0700864 rdev->sb_size = MD_SB_BYTES;
865
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 sb = (mdp_super_t*)page_address(rdev->sb_page);
867
868 memset(sb, 0, sizeof(*sb));
869
870 sb->md_magic = MD_SB_MAGIC;
871 sb->major_version = mddev->major_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 sb->patch_version = mddev->patch_version;
873 sb->gvalid_words = 0; /* ignored */
874 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
875 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
876 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
877 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
878
879 sb->ctime = mddev->ctime;
880 sb->level = mddev->level;
881 sb->size = mddev->size;
882 sb->raid_disks = mddev->raid_disks;
883 sb->md_minor = mddev->md_minor;
884 sb->not_persistent = !mddev->persistent;
885 sb->utime = mddev->utime;
886 sb->state = 0;
887 sb->events_hi = (mddev->events>>32);
888 sb->events_lo = (u32)mddev->events;
889
NeilBrownf6705572006-03-27 01:18:11 -0800890 if (mddev->reshape_position == MaxSector)
891 sb->minor_version = 90;
892 else {
893 sb->minor_version = 91;
894 sb->reshape_position = mddev->reshape_position;
895 sb->new_level = mddev->new_level;
896 sb->delta_disks = mddev->delta_disks;
897 sb->new_layout = mddev->new_layout;
898 sb->new_chunk = mddev->new_chunk;
899 }
900 mddev->minor_version = sb->minor_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 if (mddev->in_sync)
902 {
903 sb->recovery_cp = mddev->recovery_cp;
904 sb->cp_events_hi = (mddev->events>>32);
905 sb->cp_events_lo = (u32)mddev->events;
906 if (mddev->recovery_cp == MaxSector)
907 sb->state = (1<< MD_SB_CLEAN);
908 } else
909 sb->recovery_cp = 0;
910
911 sb->layout = mddev->layout;
912 sb->chunk_size = mddev->chunk_size;
913
NeilBrowna654b9d82005-06-21 17:17:27 -0700914 if (mddev->bitmap && mddev->bitmap_file == NULL)
915 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
916
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 sb->disks[0].state = (1<<MD_DISK_REMOVED);
918 ITERATE_RDEV(mddev,rdev2,tmp) {
919 mdp_disk_t *d;
NeilBrown86e6ffd2005-11-08 21:39:24 -0800920 int desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -0800921 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
922 && !test_bit(Faulty, &rdev2->flags))
NeilBrown86e6ffd2005-11-08 21:39:24 -0800923 desc_nr = rdev2->raid_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 else
NeilBrown86e6ffd2005-11-08 21:39:24 -0800925 desc_nr = next_spare++;
NeilBrown19133a42005-11-08 21:39:35 -0800926 rdev2->desc_nr = desc_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 d = &sb->disks[rdev2->desc_nr];
928 nr_disks++;
929 d->number = rdev2->desc_nr;
930 d->major = MAJOR(rdev2->bdev->bd_dev);
931 d->minor = MINOR(rdev2->bdev->bd_dev);
NeilBrownb2d444d2005-11-08 21:39:31 -0800932 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
933 && !test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 d->raid_disk = rdev2->raid_disk;
935 else
936 d->raid_disk = rdev2->desc_nr; /* compatibility */
NeilBrown1be78922006-03-27 01:18:03 -0800937 if (test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 d->state = (1<<MD_DISK_FAULTY);
NeilBrown1be78922006-03-27 01:18:03 -0800939 else if (test_bit(In_sync, &rdev2->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 d->state = (1<<MD_DISK_ACTIVE);
941 d->state |= (1<<MD_DISK_SYNC);
942 active++;
943 working++;
944 } else {
945 d->state = 0;
946 spare++;
947 working++;
948 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -0700949 if (test_bit(WriteMostly, &rdev2->flags))
950 d->state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 /* now set the "removed" and "faulty" bits on any missing devices */
953 for (i=0 ; i < mddev->raid_disks ; i++) {
954 mdp_disk_t *d = &sb->disks[i];
955 if (d->state == 0 && d->number == 0) {
956 d->number = i;
957 d->raid_disk = i;
958 d->state = (1<<MD_DISK_REMOVED);
959 d->state |= (1<<MD_DISK_FAULTY);
960 failed++;
961 }
962 }
963 sb->nr_disks = nr_disks;
964 sb->active_disks = active;
965 sb->working_disks = working;
966 sb->failed_disks = failed;
967 sb->spare_disks = spare;
968
969 sb->this_disk = sb->disks[rdev->desc_nr];
970 sb->sb_csum = calc_sb_csum(sb);
971}
972
973/*
974 * version 1 superblock
975 */
976
977static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
978{
979 unsigned int disk_csum, csum;
980 unsigned long long newcsum;
981 int size = 256 + le32_to_cpu(sb->max_dev)*2;
982 unsigned int *isuper = (unsigned int*)sb;
983 int i;
984
985 disk_csum = sb->sb_csum;
986 sb->sb_csum = 0;
987 newcsum = 0;
988 for (i=0; size>=4; size -= 4 )
989 newcsum += le32_to_cpu(*isuper++);
990
991 if (size == 2)
992 newcsum += le16_to_cpu(*(unsigned short*) isuper);
993
994 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
995 sb->sb_csum = disk_csum;
996 return cpu_to_le32(csum);
997}
998
999static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
1000{
1001 struct mdp_superblock_1 *sb;
1002 int ret;
1003 sector_t sb_offset;
1004 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown0002b272005-09-09 16:23:53 -07001005 int bmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006
1007 /*
1008 * Calculate the position of the superblock.
1009 * It is always aligned to a 4K boundary and
1010 * depeding on minor_version, it can be:
1011 * 0: At least 8K, but less than 12K, from end of device
1012 * 1: At start of device
1013 * 2: 4K from start of device.
1014 */
1015 switch(minor_version) {
1016 case 0:
1017 sb_offset = rdev->bdev->bd_inode->i_size >> 9;
1018 sb_offset -= 8*2;
NeilBrown39730962005-06-21 17:17:28 -07001019 sb_offset &= ~(sector_t)(4*2-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 /* convert from sectors to K */
1021 sb_offset /= 2;
1022 break;
1023 case 1:
1024 sb_offset = 0;
1025 break;
1026 case 2:
1027 sb_offset = 4;
1028 break;
1029 default:
1030 return -EINVAL;
1031 }
1032 rdev->sb_offset = sb_offset;
1033
NeilBrown0002b272005-09-09 16:23:53 -07001034 /* superblock is rarely larger than 1K, but it can be larger,
1035 * and it is safe to read 4k, so we do that
1036 */
1037 ret = read_disk_sb(rdev, 4096);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if (ret) return ret;
1039
1040
1041 sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1042
1043 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1044 sb->major_version != cpu_to_le32(1) ||
1045 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1046 le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
NeilBrown71c08052005-09-09 16:23:51 -07001047 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 return -EINVAL;
1049
1050 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1051 printk("md: invalid superblock checksum on %s\n",
1052 bdevname(rdev->bdev,b));
1053 return -EINVAL;
1054 }
1055 if (le64_to_cpu(sb->data_size) < 10) {
1056 printk("md: data_size too small on %s\n",
1057 bdevname(rdev->bdev,b));
1058 return -EINVAL;
1059 }
1060 rdev->preferred_minor = 0xffff;
1061 rdev->data_offset = le64_to_cpu(sb->data_offset);
NeilBrown4dbcdc72006-01-06 00:20:52 -08001062 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
NeilBrown0002b272005-09-09 16:23:53 -07001064 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
NeilBrown720a3dc2005-09-09 16:23:59 -07001065 bmask = queue_hardsect_size(rdev->bdev->bd_disk->queue)-1;
NeilBrown0002b272005-09-09 16:23:53 -07001066 if (rdev->sb_size & bmask)
1067 rdev-> sb_size = (rdev->sb_size | bmask)+1;
1068
NeilBrown31b65a02006-07-10 04:44:14 -07001069 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1070 rdev->desc_nr = -1;
1071 else
1072 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 if (refdev == 0)
NeilBrown8ed75462006-02-03 03:03:41 -08001075 ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 else {
1077 __u64 ev1, ev2;
1078 struct mdp_superblock_1 *refsb =
1079 (struct mdp_superblock_1*)page_address(refdev->sb_page);
1080
1081 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1082 sb->level != refsb->level ||
1083 sb->layout != refsb->layout ||
1084 sb->chunksize != refsb->chunksize) {
1085 printk(KERN_WARNING "md: %s has strangely different"
1086 " superblock to %s\n",
1087 bdevname(rdev->bdev,b),
1088 bdevname(refdev->bdev,b2));
1089 return -EINVAL;
1090 }
1091 ev1 = le64_to_cpu(sb->events);
1092 ev2 = le64_to_cpu(refsb->events);
1093
1094 if (ev1 > ev2)
NeilBrown8ed75462006-02-03 03:03:41 -08001095 ret = 1;
1096 else
1097 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 }
1099 if (minor_version)
1100 rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
1101 else
1102 rdev->size = rdev->sb_offset;
1103 if (rdev->size < le64_to_cpu(sb->data_size)/2)
1104 return -EINVAL;
1105 rdev->size = le64_to_cpu(sb->data_size)/2;
1106 if (le32_to_cpu(sb->chunksize))
1107 rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
NeilBrown2bf071b2006-01-06 00:20:55 -08001108
1109 if (le32_to_cpu(sb->size) > rdev->size*2)
1110 return -EINVAL;
NeilBrown8ed75462006-02-03 03:03:41 -08001111 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112}
1113
1114static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1115{
1116 struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001117 __u64 ev1 = le64_to_cpu(sb->events);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
NeilBrown41158c72005-06-21 17:17:25 -07001119 rdev->raid_disk = -1;
NeilBrownb2d444d2005-11-08 21:39:31 -08001120 rdev->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 if (mddev->raid_disks == 0) {
1122 mddev->major_version = 1;
1123 mddev->patch_version = 0;
1124 mddev->persistent = 1;
1125 mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
1126 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1127 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1128 mddev->level = le32_to_cpu(sb->level);
NeilBrownd9d166c2006-01-06 00:20:51 -08001129 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 mddev->layout = le32_to_cpu(sb->layout);
1131 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1132 mddev->size = le64_to_cpu(sb->size)/2;
NeilBrown07d84d102006-06-26 00:27:56 -07001133 mddev->events = ev1;
NeilBrown92232142005-08-18 11:24:16 -07001134 mddev->bitmap_offset = 0;
NeilBrown29fc7e32006-02-03 03:03:41 -08001135 mddev->default_bitmap_offset = 1024 >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1138 memcpy(mddev->uuid, sb->set_uuid, 16);
1139
1140 mddev->max_disks = (4096-256)/2;
NeilBrowna654b9d82005-06-21 17:17:27 -07001141
NeilBrown71c08052005-09-09 16:23:51 -07001142 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
NeilBrowna654b9d82005-06-21 17:17:27 -07001143 mddev->bitmap_file == NULL ) {
NeilBrown6cce3b22006-01-06 00:20:16 -08001144 if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
1145 && mddev->level != 10) {
1146 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
NeilBrowna654b9d82005-06-21 17:17:27 -07001147 return -EINVAL;
1148 }
1149 mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
1150 }
NeilBrownf6705572006-03-27 01:18:11 -08001151 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1152 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1153 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1154 mddev->new_level = le32_to_cpu(sb->new_level);
1155 mddev->new_layout = le32_to_cpu(sb->new_layout);
1156 mddev->new_chunk = le32_to_cpu(sb->new_chunk)<<9;
1157 } else {
1158 mddev->reshape_position = MaxSector;
1159 mddev->delta_disks = 0;
1160 mddev->new_level = mddev->level;
1161 mddev->new_layout = mddev->layout;
1162 mddev->new_chunk = mddev->chunk_size;
1163 }
1164
NeilBrown41158c72005-06-21 17:17:25 -07001165 } else if (mddev->pers == NULL) {
1166 /* Insist of good event counter while assembling */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 ++ev1;
1168 if (ev1 < mddev->events)
1169 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001170 } else if (mddev->bitmap) {
1171 /* If adding to array with a bitmap, then we can accept an
1172 * older device, but not too old.
1173 */
NeilBrown41158c72005-06-21 17:17:25 -07001174 if (ev1 < mddev->bitmap->events_cleared)
1175 return 0;
NeilBrown07d84d102006-06-26 00:27:56 -07001176 } else {
1177 if (ev1 < mddev->events)
1178 /* just a hot-add of a new device, leave raid_disk at -1 */
1179 return 0;
1180 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 if (mddev->level != LEVEL_MULTIPATH) {
1182 int role;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1184 switch(role) {
1185 case 0xffff: /* spare */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 break;
1187 case 0xfffe: /* faulty */
NeilBrownb2d444d2005-11-08 21:39:31 -08001188 set_bit(Faulty, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 break;
1190 default:
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001191 if ((le32_to_cpu(sb->feature_map) &
1192 MD_FEATURE_RECOVERY_OFFSET))
1193 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1194 else
1195 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 rdev->raid_disk = role;
1197 break;
1198 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001199 if (sb->devflags & WriteMostly1)
1200 set_bit(WriteMostly, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001201 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001202 set_bit(In_sync, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 return 0;
1205}
1206
1207static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1208{
1209 struct mdp_superblock_1 *sb;
1210 struct list_head *tmp;
1211 mdk_rdev_t *rdev2;
1212 int max_dev, i;
1213 /* make rdev->sb match mddev and rdev data. */
1214
1215 sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1216
1217 sb->feature_map = 0;
1218 sb->pad0 = 0;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001219 sb->recovery_offset = cpu_to_le64(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 memset(sb->pad1, 0, sizeof(sb->pad1));
1221 memset(sb->pad2, 0, sizeof(sb->pad2));
1222 memset(sb->pad3, 0, sizeof(sb->pad3));
1223
1224 sb->utime = cpu_to_le64((__u64)mddev->utime);
1225 sb->events = cpu_to_le64(mddev->events);
1226 if (mddev->in_sync)
1227 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1228 else
1229 sb->resync_offset = cpu_to_le64(0);
1230
NeilBrown4dbcdc72006-01-06 00:20:52 -08001231 sb->cnt_corrected_read = atomic_read(&rdev->corrected_errors);
1232
NeilBrownf0ca3402006-02-02 14:28:04 -08001233 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
NeilBrown29fc7e32006-02-03 03:03:41 -08001234 sb->size = cpu_to_le64(mddev->size<<1);
NeilBrownf0ca3402006-02-02 14:28:04 -08001235
NeilBrowna654b9d82005-06-21 17:17:27 -07001236 if (mddev->bitmap && mddev->bitmap_file == NULL) {
1237 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
NeilBrown71c08052005-09-09 16:23:51 -07001238 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
NeilBrowna654b9d82005-06-21 17:17:27 -07001239 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001240
1241 if (rdev->raid_disk >= 0 &&
1242 !test_bit(In_sync, &rdev->flags) &&
1243 rdev->recovery_offset > 0) {
1244 sb->feature_map |= cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1245 sb->recovery_offset = cpu_to_le64(rdev->recovery_offset);
1246 }
1247
NeilBrownf6705572006-03-27 01:18:11 -08001248 if (mddev->reshape_position != MaxSector) {
1249 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1250 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1251 sb->new_layout = cpu_to_le32(mddev->new_layout);
1252 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1253 sb->new_level = cpu_to_le32(mddev->new_level);
1254 sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
1255 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 max_dev = 0;
1258 ITERATE_RDEV(mddev,rdev2,tmp)
1259 if (rdev2->desc_nr+1 > max_dev)
1260 max_dev = rdev2->desc_nr+1;
1261
1262 sb->max_dev = cpu_to_le32(max_dev);
1263 for (i=0; i<max_dev;i++)
1264 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1265
1266 ITERATE_RDEV(mddev,rdev2,tmp) {
1267 i = rdev2->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08001268 if (test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 sb->dev_roles[i] = cpu_to_le16(0xfffe);
NeilBrownb2d444d2005-11-08 21:39:31 -08001270 else if (test_bit(In_sync, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001272 else if (rdev2->raid_disk >= 0 && rdev2->recovery_offset > 0)
1273 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 else
1275 sb->dev_roles[i] = cpu_to_le16(0xffff);
1276 }
1277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 sb->sb_csum = calc_sb_1_csum(sb);
1279}
1280
1281
Adrian Bunk75c96f82005-05-05 16:16:09 -07001282static struct super_type super_types[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 [0] = {
1284 .name = "0.90.0",
1285 .owner = THIS_MODULE,
1286 .load_super = super_90_load,
1287 .validate_super = super_90_validate,
1288 .sync_super = super_90_sync,
1289 },
1290 [1] = {
1291 .name = "md-1",
1292 .owner = THIS_MODULE,
1293 .load_super = super_1_load,
1294 .validate_super = super_1_validate,
1295 .sync_super = super_1_sync,
1296 },
1297};
1298
1299static mdk_rdev_t * match_dev_unit(mddev_t *mddev, mdk_rdev_t *dev)
1300{
1301 struct list_head *tmp;
1302 mdk_rdev_t *rdev;
1303
1304 ITERATE_RDEV(mddev,rdev,tmp)
1305 if (rdev->bdev->bd_contains == dev->bdev->bd_contains)
1306 return rdev;
1307
1308 return NULL;
1309}
1310
1311static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
1312{
1313 struct list_head *tmp;
1314 mdk_rdev_t *rdev;
1315
1316 ITERATE_RDEV(mddev1,rdev,tmp)
1317 if (match_dev_unit(mddev2, rdev))
1318 return 1;
1319
1320 return 0;
1321}
1322
1323static LIST_HEAD(pending_raid_disks);
1324
1325static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1326{
1327 mdk_rdev_t *same_pdev;
1328 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrownf637b9f2005-11-08 21:39:37 -08001329 struct kobject *ko;
Neil Brown1edf80d2006-01-12 01:05:23 -08001330 char *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
1332 if (rdev->mddev) {
1333 MD_BUG();
1334 return -EINVAL;
1335 }
NeilBrown2bf071b2006-01-06 00:20:55 -08001336 /* make sure rdev->size exceeds mddev->size */
1337 if (rdev->size && (mddev->size == 0 || rdev->size < mddev->size)) {
1338 if (mddev->pers)
1339 /* Cannot change size, so fail */
1340 return -ENOSPC;
1341 else
1342 mddev->size = rdev->size;
1343 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 same_pdev = match_dev_unit(mddev, rdev);
1345 if (same_pdev)
1346 printk(KERN_WARNING
1347 "%s: WARNING: %s appears to be on the same physical"
1348 " disk as %s. True\n protection against single-disk"
1349 " failure might be compromised.\n",
1350 mdname(mddev), bdevname(rdev->bdev,b),
1351 bdevname(same_pdev->bdev,b2));
1352
1353 /* Verify rdev->desc_nr is unique.
1354 * If it is -1, assign a free number, else
1355 * check number is not in use
1356 */
1357 if (rdev->desc_nr < 0) {
1358 int choice = 0;
1359 if (mddev->pers) choice = mddev->raid_disks;
1360 while (find_rdev_nr(mddev, choice))
1361 choice++;
1362 rdev->desc_nr = choice;
1363 } else {
1364 if (find_rdev_nr(mddev, rdev->desc_nr))
1365 return -EBUSY;
1366 }
NeilBrown19133a42005-11-08 21:39:35 -08001367 bdevname(rdev->bdev,b);
1368 if (kobject_set_name(&rdev->kobj, "dev-%s", b) < 0)
1369 return -ENOMEM;
Neil Brown1edf80d2006-01-12 01:05:23 -08001370 while ( (s=strchr(rdev->kobj.k_name, '/')) != NULL)
1371 *s = '!';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 list_add(&rdev->same_set, &mddev->disks);
1374 rdev->mddev = mddev;
NeilBrown19133a42005-11-08 21:39:35 -08001375 printk(KERN_INFO "md: bind<%s>\n", b);
NeilBrown86e6ffd2005-11-08 21:39:24 -08001376
NeilBrown9c791972005-11-08 21:39:28 -08001377 rdev->kobj.parent = &mddev->kobj;
NeilBrown86e6ffd2005-11-08 21:39:24 -08001378 kobject_add(&rdev->kobj);
1379
NeilBrownf637b9f2005-11-08 21:39:37 -08001380 if (rdev->bdev->bd_part)
1381 ko = &rdev->bdev->bd_part->kobj;
1382 else
1383 ko = &rdev->bdev->bd_disk->kobj;
1384 sysfs_create_link(&rdev->kobj, ko, "block");
Jun'ichi Nomura5463c792006-03-27 01:17:58 -08001385 bd_claim_by_disk(rdev->bdev, rdev, mddev->gendisk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 return 0;
1387}
1388
1389static void unbind_rdev_from_array(mdk_rdev_t * rdev)
1390{
1391 char b[BDEVNAME_SIZE];
1392 if (!rdev->mddev) {
1393 MD_BUG();
1394 return;
1395 }
Jun'ichi Nomura5463c792006-03-27 01:17:58 -08001396 bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 list_del_init(&rdev->same_set);
1398 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
1399 rdev->mddev = NULL;
NeilBrown86e6ffd2005-11-08 21:39:24 -08001400 sysfs_remove_link(&rdev->kobj, "block");
1401 kobject_del(&rdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402}
1403
1404/*
1405 * prevent the device from being mounted, repartitioned or
1406 * otherwise reused by a RAID array (or any other kernel
1407 * subsystem), by bd_claiming the device.
1408 */
1409static int lock_rdev(mdk_rdev_t *rdev, dev_t dev)
1410{
1411 int err = 0;
1412 struct block_device *bdev;
1413 char b[BDEVNAME_SIZE];
1414
Ingo Molnar663d4402006-07-03 00:25:33 -07001415 bdev = open_partition_by_devnum(dev, FMODE_READ|FMODE_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 if (IS_ERR(bdev)) {
1417 printk(KERN_ERR "md: could not open %s.\n",
1418 __bdevname(dev, b));
1419 return PTR_ERR(bdev);
1420 }
1421 err = bd_claim(bdev, rdev);
1422 if (err) {
1423 printk(KERN_ERR "md: could not bd_claim %s.\n",
1424 bdevname(bdev, b));
Ingo Molnar663d4402006-07-03 00:25:33 -07001425 blkdev_put_partition(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 return err;
1427 }
1428 rdev->bdev = bdev;
1429 return err;
1430}
1431
1432static void unlock_rdev(mdk_rdev_t *rdev)
1433{
1434 struct block_device *bdev = rdev->bdev;
1435 rdev->bdev = NULL;
1436 if (!bdev)
1437 MD_BUG();
1438 bd_release(bdev);
Ingo Molnar663d4402006-07-03 00:25:33 -07001439 blkdev_put_partition(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440}
1441
1442void md_autodetect_dev(dev_t dev);
1443
1444static void export_rdev(mdk_rdev_t * rdev)
1445{
1446 char b[BDEVNAME_SIZE];
1447 printk(KERN_INFO "md: export_rdev(%s)\n",
1448 bdevname(rdev->bdev,b));
1449 if (rdev->mddev)
1450 MD_BUG();
1451 free_disk_sb(rdev);
1452 list_del_init(&rdev->same_set);
1453#ifndef MODULE
1454 md_autodetect_dev(rdev->bdev->bd_dev);
1455#endif
1456 unlock_rdev(rdev);
NeilBrown86e6ffd2005-11-08 21:39:24 -08001457 kobject_put(&rdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458}
1459
1460static void kick_rdev_from_array(mdk_rdev_t * rdev)
1461{
1462 unbind_rdev_from_array(rdev);
1463 export_rdev(rdev);
1464}
1465
1466static void export_array(mddev_t *mddev)
1467{
1468 struct list_head *tmp;
1469 mdk_rdev_t *rdev;
1470
1471 ITERATE_RDEV(mddev,rdev,tmp) {
1472 if (!rdev->mddev) {
1473 MD_BUG();
1474 continue;
1475 }
1476 kick_rdev_from_array(rdev);
1477 }
1478 if (!list_empty(&mddev->disks))
1479 MD_BUG();
1480 mddev->raid_disks = 0;
1481 mddev->major_version = 0;
1482}
1483
1484static void print_desc(mdp_disk_t *desc)
1485{
1486 printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
1487 desc->major,desc->minor,desc->raid_disk,desc->state);
1488}
1489
1490static void print_sb(mdp_super_t *sb)
1491{
1492 int i;
1493
1494 printk(KERN_INFO
1495 "md: SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
1496 sb->major_version, sb->minor_version, sb->patch_version,
1497 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
1498 sb->ctime);
1499 printk(KERN_INFO "md: L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
1500 sb->level, sb->size, sb->nr_disks, sb->raid_disks,
1501 sb->md_minor, sb->layout, sb->chunk_size);
1502 printk(KERN_INFO "md: UT:%08x ST:%d AD:%d WD:%d"
1503 " FD:%d SD:%d CSUM:%08x E:%08lx\n",
1504 sb->utime, sb->state, sb->active_disks, sb->working_disks,
1505 sb->failed_disks, sb->spare_disks,
1506 sb->sb_csum, (unsigned long)sb->events_lo);
1507
1508 printk(KERN_INFO);
1509 for (i = 0; i < MD_SB_DISKS; i++) {
1510 mdp_disk_t *desc;
1511
1512 desc = sb->disks + i;
1513 if (desc->number || desc->major || desc->minor ||
1514 desc->raid_disk || (desc->state && (desc->state != 4))) {
1515 printk(" D %2d: ", i);
1516 print_desc(desc);
1517 }
1518 }
1519 printk(KERN_INFO "md: THIS: ");
1520 print_desc(&sb->this_disk);
1521
1522}
1523
1524static void print_rdev(mdk_rdev_t *rdev)
1525{
1526 char b[BDEVNAME_SIZE];
1527 printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
1528 bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
NeilBrownb2d444d2005-11-08 21:39:31 -08001529 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
1530 rdev->desc_nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 if (rdev->sb_loaded) {
1532 printk(KERN_INFO "md: rdev superblock:\n");
1533 print_sb((mdp_super_t*)page_address(rdev->sb_page));
1534 } else
1535 printk(KERN_INFO "md: no rdev superblock!\n");
1536}
1537
Adrian Bunk5e563412006-06-26 00:27:42 -07001538static void md_print_devices(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539{
1540 struct list_head *tmp, *tmp2;
1541 mdk_rdev_t *rdev;
1542 mddev_t *mddev;
1543 char b[BDEVNAME_SIZE];
1544
1545 printk("\n");
1546 printk("md: **********************************\n");
1547 printk("md: * <COMPLETE RAID STATE PRINTOUT> *\n");
1548 printk("md: **********************************\n");
1549 ITERATE_MDDEV(mddev,tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550
NeilBrown32a76272005-06-21 17:17:14 -07001551 if (mddev->bitmap)
1552 bitmap_print_sb(mddev->bitmap);
1553 else
1554 printk("%s: ", mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 ITERATE_RDEV(mddev,rdev,tmp2)
1556 printk("<%s>", bdevname(rdev->bdev,b));
1557 printk("\n");
1558
1559 ITERATE_RDEV(mddev,rdev,tmp2)
1560 print_rdev(rdev);
1561 }
1562 printk("md: **********************************\n");
1563 printk("\n");
1564}
1565
1566
NeilBrown42543762006-06-26 00:27:57 -07001567static void sync_sbs(mddev_t * mddev, int nospares)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568{
NeilBrown42543762006-06-26 00:27:57 -07001569 /* Update each superblock (in-memory image), but
1570 * if we are allowed to, skip spares which already
1571 * have the right event counter, or have one earlier
1572 * (which would mean they aren't being marked as dirty
1573 * with the rest of the array)
1574 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 mdk_rdev_t *rdev;
1576 struct list_head *tmp;
1577
1578 ITERATE_RDEV(mddev,rdev,tmp) {
NeilBrown42543762006-06-26 00:27:57 -07001579 if (rdev->sb_events == mddev->events ||
1580 (nospares &&
1581 rdev->raid_disk < 0 &&
1582 (rdev->sb_events&1)==0 &&
1583 rdev->sb_events+1 == mddev->events)) {
1584 /* Don't update this superblock */
1585 rdev->sb_loaded = 2;
1586 } else {
1587 super_types[mddev->major_version].
1588 sync_super(mddev, rdev);
1589 rdev->sb_loaded = 1;
1590 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 }
1592}
1593
NeilBrown850b2b42006-10-03 01:15:46 -07001594static void md_update_sb(mddev_t * mddev, int force_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595{
NeilBrown7bfa19f2005-06-21 17:17:28 -07001596 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 struct list_head *tmp;
1598 mdk_rdev_t *rdev;
NeilBrown06d91a52005-06-21 17:17:12 -07001599 int sync_req;
NeilBrown42543762006-06-26 00:27:57 -07001600 int nospares = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602repeat:
NeilBrowna9701a32005-11-08 21:39:34 -08001603 spin_lock_irq(&mddev->write_lock);
NeilBrown84692192006-08-27 01:23:49 -07001604
NeilBrown850b2b42006-10-03 01:15:46 -07001605 set_bit(MD_CHANGE_PENDING, &mddev->flags);
1606 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
1607 force_change = 1;
1608 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
1609 /* just a clean<-> dirty transition, possibly leave spares alone,
1610 * though if events isn't the right even/odd, we will have to do
1611 * spares after all
1612 */
1613 nospares = 1;
1614 if (force_change)
1615 nospares = 0;
1616 if (mddev->degraded)
NeilBrown84692192006-08-27 01:23:49 -07001617 /* If the array is degraded, then skipping spares is both
1618 * dangerous and fairly pointless.
1619 * Dangerous because a device that was removed from the array
1620 * might have a event_count that still looks up-to-date,
1621 * so it can be re-added without a resync.
1622 * Pointless because if there are any spares to skip,
1623 * then a recovery will happen and soon that array won't
1624 * be degraded any more and the spare can go back to sleep then.
1625 */
NeilBrown850b2b42006-10-03 01:15:46 -07001626 nospares = 0;
NeilBrown84692192006-08-27 01:23:49 -07001627
NeilBrown06d91a52005-06-21 17:17:12 -07001628 sync_req = mddev->in_sync;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 mddev->utime = get_seconds();
NeilBrown42543762006-06-26 00:27:57 -07001630
1631 /* If this is just a dirty<->clean transition, and the array is clean
1632 * and 'events' is odd, we can roll back to the previous clean state */
NeilBrown850b2b42006-10-03 01:15:46 -07001633 if (nospares
NeilBrown42543762006-06-26 00:27:57 -07001634 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
1635 && (mddev->events & 1))
1636 mddev->events--;
1637 else {
1638 /* otherwise we have to go forward and ... */
1639 mddev->events ++;
1640 if (!mddev->in_sync || mddev->recovery_cp != MaxSector) { /* not clean */
1641 /* .. if the array isn't clean, insist on an odd 'events' */
1642 if ((mddev->events&1)==0) {
1643 mddev->events++;
1644 nospares = 0;
1645 }
1646 } else {
1647 /* otherwise insist on an even 'events' (for clean states) */
1648 if ((mddev->events&1)) {
1649 mddev->events++;
1650 nospares = 0;
1651 }
1652 }
1653 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
1655 if (!mddev->events) {
1656 /*
1657 * oops, this 64-bit counter should never wrap.
1658 * Either we are in around ~1 trillion A.C., assuming
1659 * 1 reboot per second, or we have a bug:
1660 */
1661 MD_BUG();
1662 mddev->events --;
1663 }
NeilBrown42543762006-06-26 00:27:57 -07001664 sync_sbs(mddev, nospares);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 /*
1667 * do not write anything to disk if using
1668 * nonpersistent superblocks
1669 */
NeilBrown06d91a52005-06-21 17:17:12 -07001670 if (!mddev->persistent) {
NeilBrown850b2b42006-10-03 01:15:46 -07001671 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrowna9701a32005-11-08 21:39:34 -08001672 spin_unlock_irq(&mddev->write_lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07001673 wake_up(&mddev->sb_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 return;
NeilBrown06d91a52005-06-21 17:17:12 -07001675 }
NeilBrowna9701a32005-11-08 21:39:34 -08001676 spin_unlock_irq(&mddev->write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 dprintk(KERN_INFO
1679 "md: updating %s RAID superblock on device (in sync %d)\n",
1680 mdname(mddev),mddev->in_sync);
1681
NeilBrown32a76272005-06-21 17:17:14 -07001682 err = bitmap_update_sb(mddev->bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 ITERATE_RDEV(mddev,rdev,tmp) {
1684 char b[BDEVNAME_SIZE];
1685 dprintk(KERN_INFO "md: ");
NeilBrown42543762006-06-26 00:27:57 -07001686 if (rdev->sb_loaded != 1)
1687 continue; /* no noise on spare devices */
NeilBrownb2d444d2005-11-08 21:39:31 -08001688 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 dprintk("(skipping faulty ");
1690
1691 dprintk("%s ", bdevname(rdev->bdev,b));
NeilBrownb2d444d2005-11-08 21:39:31 -08001692 if (!test_bit(Faulty, &rdev->flags)) {
NeilBrown7bfa19f2005-06-21 17:17:28 -07001693 md_super_write(mddev,rdev,
NeilBrown0002b272005-09-09 16:23:53 -07001694 rdev->sb_offset<<1, rdev->sb_size,
NeilBrown7bfa19f2005-06-21 17:17:28 -07001695 rdev->sb_page);
1696 dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
1697 bdevname(rdev->bdev,b),
1698 (unsigned long long)rdev->sb_offset);
NeilBrown42543762006-06-26 00:27:57 -07001699 rdev->sb_events = mddev->events;
NeilBrown7bfa19f2005-06-21 17:17:28 -07001700
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 } else
1702 dprintk(")\n");
NeilBrown7bfa19f2005-06-21 17:17:28 -07001703 if (mddev->level == LEVEL_MULTIPATH)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 /* only need to write one superblock... */
1705 break;
1706 }
NeilBrowna9701a32005-11-08 21:39:34 -08001707 md_super_wait(mddev);
NeilBrown850b2b42006-10-03 01:15:46 -07001708 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
NeilBrown7bfa19f2005-06-21 17:17:28 -07001709
NeilBrowna9701a32005-11-08 21:39:34 -08001710 spin_lock_irq(&mddev->write_lock);
NeilBrown850b2b42006-10-03 01:15:46 -07001711 if (mddev->in_sync != sync_req ||
1712 test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
NeilBrown06d91a52005-06-21 17:17:12 -07001713 /* have to write it out again */
NeilBrowna9701a32005-11-08 21:39:34 -08001714 spin_unlock_irq(&mddev->write_lock);
NeilBrown06d91a52005-06-21 17:17:12 -07001715 goto repeat;
1716 }
NeilBrown850b2b42006-10-03 01:15:46 -07001717 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrowna9701a32005-11-08 21:39:34 -08001718 spin_unlock_irq(&mddev->write_lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07001719 wake_up(&mddev->sb_wait);
NeilBrown06d91a52005-06-21 17:17:12 -07001720
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721}
1722
NeilBrownbce74da2006-01-06 00:20:41 -08001723/* words written to sysfs files may, or my not, be \n terminated.
1724 * We want to accept with case. For this we use cmd_match.
1725 */
1726static int cmd_match(const char *cmd, const char *str)
1727{
1728 /* See if cmd, written into a sysfs file, matches
1729 * str. They must either be the same, or cmd can
1730 * have a trailing newline
1731 */
1732 while (*cmd && *str && *cmd == *str) {
1733 cmd++;
1734 str++;
1735 }
1736 if (*cmd == '\n')
1737 cmd++;
1738 if (*str || *cmd)
1739 return 0;
1740 return 1;
1741}
1742
NeilBrown86e6ffd2005-11-08 21:39:24 -08001743struct rdev_sysfs_entry {
1744 struct attribute attr;
1745 ssize_t (*show)(mdk_rdev_t *, char *);
1746 ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
1747};
1748
1749static ssize_t
NeilBrown96de1e62005-11-08 21:39:39 -08001750state_show(mdk_rdev_t *rdev, char *page)
NeilBrown86e6ffd2005-11-08 21:39:24 -08001751{
1752 char *sep = "";
1753 int len=0;
1754
NeilBrownb2d444d2005-11-08 21:39:31 -08001755 if (test_bit(Faulty, &rdev->flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08001756 len+= sprintf(page+len, "%sfaulty",sep);
1757 sep = ",";
1758 }
NeilBrownb2d444d2005-11-08 21:39:31 -08001759 if (test_bit(In_sync, &rdev->flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08001760 len += sprintf(page+len, "%sin_sync",sep);
1761 sep = ",";
1762 }
NeilBrownf6556752006-06-26 00:28:01 -07001763 if (test_bit(WriteMostly, &rdev->flags)) {
1764 len += sprintf(page+len, "%swrite_mostly",sep);
1765 sep = ",";
1766 }
NeilBrownb2d444d2005-11-08 21:39:31 -08001767 if (!test_bit(Faulty, &rdev->flags) &&
1768 !test_bit(In_sync, &rdev->flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08001769 len += sprintf(page+len, "%sspare", sep);
1770 sep = ",";
1771 }
1772 return len+sprintf(page+len, "\n");
1773}
1774
NeilBrown45dc2de2006-06-26 00:27:58 -07001775static ssize_t
1776state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1777{
1778 /* can write
1779 * faulty - simulates and error
1780 * remove - disconnects the device
NeilBrownf6556752006-06-26 00:28:01 -07001781 * writemostly - sets write_mostly
1782 * -writemostly - clears write_mostly
NeilBrown45dc2de2006-06-26 00:27:58 -07001783 */
1784 int err = -EINVAL;
1785 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
1786 md_error(rdev->mddev, rdev);
1787 err = 0;
1788 } else if (cmd_match(buf, "remove")) {
1789 if (rdev->raid_disk >= 0)
1790 err = -EBUSY;
1791 else {
1792 mddev_t *mddev = rdev->mddev;
1793 kick_rdev_from_array(rdev);
NeilBrown850b2b42006-10-03 01:15:46 -07001794 md_update_sb(mddev, 1);
NeilBrown45dc2de2006-06-26 00:27:58 -07001795 md_new_event(mddev);
1796 err = 0;
1797 }
NeilBrownf6556752006-06-26 00:28:01 -07001798 } else if (cmd_match(buf, "writemostly")) {
1799 set_bit(WriteMostly, &rdev->flags);
1800 err = 0;
1801 } else if (cmd_match(buf, "-writemostly")) {
1802 clear_bit(WriteMostly, &rdev->flags);
1803 err = 0;
NeilBrown45dc2de2006-06-26 00:27:58 -07001804 }
1805 return err ? err : len;
1806}
NeilBrown80ca3a42006-07-10 04:44:18 -07001807static struct rdev_sysfs_entry rdev_state =
1808__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
NeilBrown86e6ffd2005-11-08 21:39:24 -08001809
1810static ssize_t
NeilBrown96de1e62005-11-08 21:39:39 -08001811super_show(mdk_rdev_t *rdev, char *page)
NeilBrown86e6ffd2005-11-08 21:39:24 -08001812{
1813 if (rdev->sb_loaded && rdev->sb_size) {
1814 memcpy(page, page_address(rdev->sb_page), rdev->sb_size);
1815 return rdev->sb_size;
1816 } else
1817 return 0;
1818}
NeilBrown96de1e62005-11-08 21:39:39 -08001819static struct rdev_sysfs_entry rdev_super = __ATTR_RO(super);
1820
NeilBrown4dbcdc72006-01-06 00:20:52 -08001821static ssize_t
1822errors_show(mdk_rdev_t *rdev, char *page)
1823{
1824 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
1825}
1826
1827static ssize_t
1828errors_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1829{
1830 char *e;
1831 unsigned long n = simple_strtoul(buf, &e, 10);
1832 if (*buf && (*e == 0 || *e == '\n')) {
1833 atomic_set(&rdev->corrected_errors, n);
1834 return len;
1835 }
1836 return -EINVAL;
1837}
1838static struct rdev_sysfs_entry rdev_errors =
NeilBrown80ca3a42006-07-10 04:44:18 -07001839__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
NeilBrown4dbcdc72006-01-06 00:20:52 -08001840
NeilBrown014236d2006-01-06 00:20:55 -08001841static ssize_t
1842slot_show(mdk_rdev_t *rdev, char *page)
1843{
1844 if (rdev->raid_disk < 0)
1845 return sprintf(page, "none\n");
1846 else
1847 return sprintf(page, "%d\n", rdev->raid_disk);
1848}
1849
1850static ssize_t
1851slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1852{
1853 char *e;
1854 int slot = simple_strtoul(buf, &e, 10);
1855 if (strncmp(buf, "none", 4)==0)
1856 slot = -1;
1857 else if (e==buf || (*e && *e!= '\n'))
1858 return -EINVAL;
1859 if (rdev->mddev->pers)
1860 /* Cannot set slot in active array (yet) */
1861 return -EBUSY;
1862 if (slot >= rdev->mddev->raid_disks)
1863 return -ENOSPC;
1864 rdev->raid_disk = slot;
1865 /* assume it is working */
1866 rdev->flags = 0;
1867 set_bit(In_sync, &rdev->flags);
1868 return len;
1869}
1870
1871
1872static struct rdev_sysfs_entry rdev_slot =
NeilBrown80ca3a42006-07-10 04:44:18 -07001873__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
NeilBrown014236d2006-01-06 00:20:55 -08001874
NeilBrown93c8cad2006-01-06 00:20:56 -08001875static ssize_t
1876offset_show(mdk_rdev_t *rdev, char *page)
1877{
Andrew Morton6961ece2006-01-06 00:20:59 -08001878 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
NeilBrown93c8cad2006-01-06 00:20:56 -08001879}
1880
1881static ssize_t
1882offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1883{
1884 char *e;
1885 unsigned long long offset = simple_strtoull(buf, &e, 10);
1886 if (e==buf || (*e && *e != '\n'))
1887 return -EINVAL;
1888 if (rdev->mddev->pers)
1889 return -EBUSY;
1890 rdev->data_offset = offset;
1891 return len;
1892}
1893
1894static struct rdev_sysfs_entry rdev_offset =
NeilBrown80ca3a42006-07-10 04:44:18 -07001895__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
NeilBrown93c8cad2006-01-06 00:20:56 -08001896
NeilBrown83303b62006-01-06 00:21:06 -08001897static ssize_t
1898rdev_size_show(mdk_rdev_t *rdev, char *page)
1899{
1900 return sprintf(page, "%llu\n", (unsigned long long)rdev->size);
1901}
1902
1903static ssize_t
1904rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1905{
1906 char *e;
1907 unsigned long long size = simple_strtoull(buf, &e, 10);
1908 if (e==buf || (*e && *e != '\n'))
1909 return -EINVAL;
1910 if (rdev->mddev->pers)
1911 return -EBUSY;
1912 rdev->size = size;
1913 if (size < rdev->mddev->size || rdev->mddev->size == 0)
1914 rdev->mddev->size = size;
1915 return len;
1916}
1917
1918static struct rdev_sysfs_entry rdev_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07001919__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
NeilBrown83303b62006-01-06 00:21:06 -08001920
NeilBrown86e6ffd2005-11-08 21:39:24 -08001921static struct attribute *rdev_default_attrs[] = {
1922 &rdev_state.attr,
1923 &rdev_super.attr,
NeilBrown4dbcdc72006-01-06 00:20:52 -08001924 &rdev_errors.attr,
NeilBrown014236d2006-01-06 00:20:55 -08001925 &rdev_slot.attr,
NeilBrown93c8cad2006-01-06 00:20:56 -08001926 &rdev_offset.attr,
NeilBrown83303b62006-01-06 00:21:06 -08001927 &rdev_size.attr,
NeilBrown86e6ffd2005-11-08 21:39:24 -08001928 NULL,
1929};
1930static ssize_t
1931rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
1932{
1933 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1934 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1935
1936 if (!entry->show)
1937 return -EIO;
1938 return entry->show(rdev, page);
1939}
1940
1941static ssize_t
1942rdev_attr_store(struct kobject *kobj, struct attribute *attr,
1943 const char *page, size_t length)
1944{
1945 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1946 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1947
1948 if (!entry->store)
1949 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07001950 if (!capable(CAP_SYS_ADMIN))
1951 return -EACCES;
NeilBrown86e6ffd2005-11-08 21:39:24 -08001952 return entry->store(rdev, page, length);
1953}
1954
1955static void rdev_free(struct kobject *ko)
1956{
1957 mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
1958 kfree(rdev);
1959}
1960static struct sysfs_ops rdev_sysfs_ops = {
1961 .show = rdev_attr_show,
1962 .store = rdev_attr_store,
1963};
1964static struct kobj_type rdev_ktype = {
1965 .release = rdev_free,
1966 .sysfs_ops = &rdev_sysfs_ops,
1967 .default_attrs = rdev_default_attrs,
1968};
1969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970/*
1971 * Import a device. If 'super_format' >= 0, then sanity check the superblock
1972 *
1973 * mark the device faulty if:
1974 *
1975 * - the device is nonexistent (zero size)
1976 * - the device has no valid superblock
1977 *
1978 * a faulty rdev _never_ has rdev->sb set.
1979 */
1980static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
1981{
1982 char b[BDEVNAME_SIZE];
1983 int err;
1984 mdk_rdev_t *rdev;
1985 sector_t size;
1986
NeilBrown9ffae0c2006-01-06 00:20:32 -08001987 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 if (!rdev) {
1989 printk(KERN_ERR "md: could not alloc mem for new device!\n");
1990 return ERR_PTR(-ENOMEM);
1991 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992
1993 if ((err = alloc_disk_sb(rdev)))
1994 goto abort_free;
1995
1996 err = lock_rdev(rdev, newdev);
1997 if (err)
1998 goto abort_free;
1999
NeilBrown86e6ffd2005-11-08 21:39:24 -08002000 rdev->kobj.parent = NULL;
2001 rdev->kobj.ktype = &rdev_ktype;
2002 kobject_init(&rdev->kobj);
2003
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 rdev->desc_nr = -1;
NeilBrownb2d444d2005-11-08 21:39:31 -08002005 rdev->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 rdev->data_offset = 0;
NeilBrown42543762006-06-26 00:27:57 -07002007 rdev->sb_events = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 atomic_set(&rdev->nr_pending, 0);
NeilBrownba22dcb2005-11-08 21:39:31 -08002009 atomic_set(&rdev->read_errors, 0);
NeilBrown4dbcdc72006-01-06 00:20:52 -08002010 atomic_set(&rdev->corrected_errors, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011
2012 size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2013 if (!size) {
2014 printk(KERN_WARNING
2015 "md: %s has zero or unknown size, marking faulty!\n",
2016 bdevname(rdev->bdev,b));
2017 err = -EINVAL;
2018 goto abort_free;
2019 }
2020
2021 if (super_format >= 0) {
2022 err = super_types[super_format].
2023 load_super(rdev, NULL, super_minor);
2024 if (err == -EINVAL) {
2025 printk(KERN_WARNING
2026 "md: %s has invalid sb, not importing!\n",
2027 bdevname(rdev->bdev,b));
2028 goto abort_free;
2029 }
2030 if (err < 0) {
2031 printk(KERN_WARNING
2032 "md: could not read %s's sb, not importing!\n",
2033 bdevname(rdev->bdev,b));
2034 goto abort_free;
2035 }
2036 }
2037 INIT_LIST_HEAD(&rdev->same_set);
2038
2039 return rdev;
2040
2041abort_free:
2042 if (rdev->sb_page) {
2043 if (rdev->bdev)
2044 unlock_rdev(rdev);
2045 free_disk_sb(rdev);
2046 }
2047 kfree(rdev);
2048 return ERR_PTR(err);
2049}
2050
2051/*
2052 * Check a full RAID array for plausibility
2053 */
2054
2055
NeilBrowna757e642005-04-16 15:26:42 -07002056static void analyze_sbs(mddev_t * mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057{
2058 int i;
2059 struct list_head *tmp;
2060 mdk_rdev_t *rdev, *freshest;
2061 char b[BDEVNAME_SIZE];
2062
2063 freshest = NULL;
2064 ITERATE_RDEV(mddev,rdev,tmp)
2065 switch (super_types[mddev->major_version].
2066 load_super(rdev, freshest, mddev->minor_version)) {
2067 case 1:
2068 freshest = rdev;
2069 break;
2070 case 0:
2071 break;
2072 default:
2073 printk( KERN_ERR \
2074 "md: fatal superblock inconsistency in %s"
2075 " -- removing from array\n",
2076 bdevname(rdev->bdev,b));
2077 kick_rdev_from_array(rdev);
2078 }
2079
2080
2081 super_types[mddev->major_version].
2082 validate_super(mddev, freshest);
2083
2084 i = 0;
2085 ITERATE_RDEV(mddev,rdev,tmp) {
2086 if (rdev != freshest)
2087 if (super_types[mddev->major_version].
2088 validate_super(mddev, rdev)) {
2089 printk(KERN_WARNING "md: kicking non-fresh %s"
2090 " from array!\n",
2091 bdevname(rdev->bdev,b));
2092 kick_rdev_from_array(rdev);
2093 continue;
2094 }
2095 if (mddev->level == LEVEL_MULTIPATH) {
2096 rdev->desc_nr = i++;
2097 rdev->raid_disk = rdev->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08002098 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 }
2100 }
2101
2102
2103
2104 if (mddev->recovery_cp != MaxSector &&
2105 mddev->level >= 1)
2106 printk(KERN_ERR "md: %s: raid array is not clean"
2107 " -- starting background reconstruction\n",
2108 mdname(mddev));
2109
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110}
2111
NeilBrowneae17012005-11-08 21:39:23 -08002112static ssize_t
NeilBrown16f17b32006-06-26 00:27:37 -07002113safe_delay_show(mddev_t *mddev, char *page)
2114{
2115 int msec = (mddev->safemode_delay*1000)/HZ;
2116 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
2117}
2118static ssize_t
2119safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
2120{
2121 int scale=1;
2122 int dot=0;
2123 int i;
2124 unsigned long msec;
2125 char buf[30];
2126 char *e;
2127 /* remove a period, and count digits after it */
2128 if (len >= sizeof(buf))
2129 return -EINVAL;
2130 strlcpy(buf, cbuf, len);
2131 buf[len] = 0;
2132 for (i=0; i<len; i++) {
2133 if (dot) {
2134 if (isdigit(buf[i])) {
2135 buf[i-1] = buf[i];
2136 scale *= 10;
2137 }
2138 buf[i] = 0;
2139 } else if (buf[i] == '.') {
2140 dot=1;
2141 buf[i] = 0;
2142 }
2143 }
2144 msec = simple_strtoul(buf, &e, 10);
2145 if (e == buf || (*e && *e != '\n'))
2146 return -EINVAL;
2147 msec = (msec * 1000) / scale;
2148 if (msec == 0)
2149 mddev->safemode_delay = 0;
2150 else {
2151 mddev->safemode_delay = (msec*HZ)/1000;
2152 if (mddev->safemode_delay == 0)
2153 mddev->safemode_delay = 1;
2154 }
2155 return len;
2156}
2157static struct md_sysfs_entry md_safe_delay =
NeilBrown80ca3a42006-07-10 04:44:18 -07002158__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
NeilBrown16f17b32006-06-26 00:27:37 -07002159
2160static ssize_t
NeilBrown96de1e62005-11-08 21:39:39 -08002161level_show(mddev_t *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08002162{
NeilBrown2604b702006-01-06 00:20:36 -08002163 struct mdk_personality *p = mddev->pers;
NeilBrownd9d166c2006-01-06 00:20:51 -08002164 if (p)
NeilBrowneae17012005-11-08 21:39:23 -08002165 return sprintf(page, "%s\n", p->name);
NeilBrownd9d166c2006-01-06 00:20:51 -08002166 else if (mddev->clevel[0])
2167 return sprintf(page, "%s\n", mddev->clevel);
2168 else if (mddev->level != LEVEL_NONE)
2169 return sprintf(page, "%d\n", mddev->level);
2170 else
2171 return 0;
NeilBrowneae17012005-11-08 21:39:23 -08002172}
2173
NeilBrownd9d166c2006-01-06 00:20:51 -08002174static ssize_t
2175level_store(mddev_t *mddev, const char *buf, size_t len)
2176{
2177 int rv = len;
2178 if (mddev->pers)
2179 return -EBUSY;
2180 if (len == 0)
2181 return 0;
2182 if (len >= sizeof(mddev->clevel))
2183 return -ENOSPC;
2184 strncpy(mddev->clevel, buf, len);
2185 if (mddev->clevel[len-1] == '\n')
2186 len--;
2187 mddev->clevel[len] = 0;
2188 mddev->level = LEVEL_NONE;
2189 return rv;
2190}
2191
2192static struct md_sysfs_entry md_level =
NeilBrown80ca3a42006-07-10 04:44:18 -07002193__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
NeilBrowneae17012005-11-08 21:39:23 -08002194
NeilBrownd4dbd022006-06-26 00:27:59 -07002195
2196static ssize_t
2197layout_show(mddev_t *mddev, char *page)
2198{
2199 /* just a number, not meaningful for all levels */
2200 return sprintf(page, "%d\n", mddev->layout);
2201}
2202
2203static ssize_t
2204layout_store(mddev_t *mddev, const char *buf, size_t len)
2205{
2206 char *e;
2207 unsigned long n = simple_strtoul(buf, &e, 10);
2208 if (mddev->pers)
2209 return -EBUSY;
2210
2211 if (!*buf || (*e && *e != '\n'))
2212 return -EINVAL;
2213
2214 mddev->layout = n;
2215 return len;
2216}
2217static struct md_sysfs_entry md_layout =
NeilBrown80ca3a42006-07-10 04:44:18 -07002218__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
NeilBrownd4dbd022006-06-26 00:27:59 -07002219
2220
NeilBrowneae17012005-11-08 21:39:23 -08002221static ssize_t
NeilBrown96de1e62005-11-08 21:39:39 -08002222raid_disks_show(mddev_t *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08002223{
NeilBrownbb636542005-11-08 21:39:45 -08002224 if (mddev->raid_disks == 0)
2225 return 0;
NeilBrowneae17012005-11-08 21:39:23 -08002226 return sprintf(page, "%d\n", mddev->raid_disks);
2227}
2228
NeilBrownda943b992006-01-06 00:20:54 -08002229static int update_raid_disks(mddev_t *mddev, int raid_disks);
2230
2231static ssize_t
2232raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
2233{
2234 /* can only set raid_disks if array is not yet active */
2235 char *e;
2236 int rv = 0;
2237 unsigned long n = simple_strtoul(buf, &e, 10);
2238
2239 if (!*buf || (*e && *e != '\n'))
2240 return -EINVAL;
2241
2242 if (mddev->pers)
2243 rv = update_raid_disks(mddev, n);
2244 else
2245 mddev->raid_disks = n;
2246 return rv ? rv : len;
2247}
2248static struct md_sysfs_entry md_raid_disks =
NeilBrown80ca3a42006-07-10 04:44:18 -07002249__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
NeilBrowneae17012005-11-08 21:39:23 -08002250
NeilBrown24dd4692005-11-08 21:39:26 -08002251static ssize_t
NeilBrown3b343802006-01-06 00:20:47 -08002252chunk_size_show(mddev_t *mddev, char *page)
2253{
2254 return sprintf(page, "%d\n", mddev->chunk_size);
2255}
2256
2257static ssize_t
2258chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
2259{
2260 /* can only set chunk_size if array is not yet active */
2261 char *e;
2262 unsigned long n = simple_strtoul(buf, &e, 10);
2263
2264 if (mddev->pers)
2265 return -EBUSY;
2266 if (!*buf || (*e && *e != '\n'))
2267 return -EINVAL;
2268
2269 mddev->chunk_size = n;
2270 return len;
2271}
2272static struct md_sysfs_entry md_chunk_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07002273__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
NeilBrown3b343802006-01-06 00:20:47 -08002274
NeilBrowna94213b2006-06-26 00:28:00 -07002275static ssize_t
2276resync_start_show(mddev_t *mddev, char *page)
2277{
2278 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
2279}
2280
2281static ssize_t
2282resync_start_store(mddev_t *mddev, const char *buf, size_t len)
2283{
2284 /* can only set chunk_size if array is not yet active */
2285 char *e;
2286 unsigned long long n = simple_strtoull(buf, &e, 10);
2287
2288 if (mddev->pers)
2289 return -EBUSY;
2290 if (!*buf || (*e && *e != '\n'))
2291 return -EINVAL;
2292
2293 mddev->recovery_cp = n;
2294 return len;
2295}
2296static struct md_sysfs_entry md_resync_start =
NeilBrown80ca3a42006-07-10 04:44:18 -07002297__ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
NeilBrowna94213b2006-06-26 00:28:00 -07002298
NeilBrown9e653b62006-06-26 00:27:58 -07002299/*
2300 * The array state can be:
2301 *
2302 * clear
2303 * No devices, no size, no level
2304 * Equivalent to STOP_ARRAY ioctl
2305 * inactive
2306 * May have some settings, but array is not active
2307 * all IO results in error
2308 * When written, doesn't tear down array, but just stops it
2309 * suspended (not supported yet)
2310 * All IO requests will block. The array can be reconfigured.
2311 * Writing this, if accepted, will block until array is quiessent
2312 * readonly
2313 * no resync can happen. no superblocks get written.
2314 * write requests fail
2315 * read-auto
2316 * like readonly, but behaves like 'clean' on a write request.
2317 *
2318 * clean - no pending writes, but otherwise active.
2319 * When written to inactive array, starts without resync
2320 * If a write request arrives then
2321 * if metadata is known, mark 'dirty' and switch to 'active'.
2322 * if not known, block and switch to write-pending
2323 * If written to an active array that has pending writes, then fails.
2324 * active
2325 * fully active: IO and resync can be happening.
2326 * When written to inactive array, starts with resync
2327 *
2328 * write-pending
2329 * clean, but writes are blocked waiting for 'active' to be written.
2330 *
2331 * active-idle
2332 * like active, but no writes have been seen for a while (100msec).
2333 *
2334 */
2335enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
2336 write_pending, active_idle, bad_word};
Adrian Bunk05381952006-06-26 00:28:01 -07002337static char *array_states[] = {
NeilBrown9e653b62006-06-26 00:27:58 -07002338 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
2339 "write-pending", "active-idle", NULL };
2340
2341static int match_word(const char *word, char **list)
2342{
2343 int n;
2344 for (n=0; list[n]; n++)
2345 if (cmd_match(word, list[n]))
2346 break;
2347 return n;
2348}
2349
2350static ssize_t
2351array_state_show(mddev_t *mddev, char *page)
2352{
2353 enum array_state st = inactive;
2354
2355 if (mddev->pers)
2356 switch(mddev->ro) {
2357 case 1:
2358 st = readonly;
2359 break;
2360 case 2:
2361 st = read_auto;
2362 break;
2363 case 0:
2364 if (mddev->in_sync)
2365 st = clean;
2366 else if (mddev->safemode)
2367 st = active_idle;
2368 else
2369 st = active;
2370 }
2371 else {
2372 if (list_empty(&mddev->disks) &&
2373 mddev->raid_disks == 0 &&
2374 mddev->size == 0)
2375 st = clear;
2376 else
2377 st = inactive;
2378 }
2379 return sprintf(page, "%s\n", array_states[st]);
2380}
2381
2382static int do_md_stop(mddev_t * mddev, int ro);
2383static int do_md_run(mddev_t * mddev);
2384static int restart_array(mddev_t *mddev);
2385
2386static ssize_t
2387array_state_store(mddev_t *mddev, const char *buf, size_t len)
2388{
2389 int err = -EINVAL;
2390 enum array_state st = match_word(buf, array_states);
2391 switch(st) {
2392 case bad_word:
2393 break;
2394 case clear:
2395 /* stopping an active array */
2396 if (mddev->pers) {
2397 if (atomic_read(&mddev->active) > 1)
2398 return -EBUSY;
2399 err = do_md_stop(mddev, 0);
2400 }
2401 break;
2402 case inactive:
2403 /* stopping an active array */
2404 if (mddev->pers) {
2405 if (atomic_read(&mddev->active) > 1)
2406 return -EBUSY;
2407 err = do_md_stop(mddev, 2);
2408 }
2409 break;
2410 case suspended:
2411 break; /* not supported yet */
2412 case readonly:
2413 if (mddev->pers)
2414 err = do_md_stop(mddev, 1);
2415 else {
2416 mddev->ro = 1;
2417 err = do_md_run(mddev);
2418 }
2419 break;
2420 case read_auto:
2421 /* stopping an active array */
2422 if (mddev->pers) {
2423 err = do_md_stop(mddev, 1);
2424 if (err == 0)
2425 mddev->ro = 2; /* FIXME mark devices writable */
2426 } else {
2427 mddev->ro = 2;
2428 err = do_md_run(mddev);
2429 }
2430 break;
2431 case clean:
2432 if (mddev->pers) {
2433 restart_array(mddev);
2434 spin_lock_irq(&mddev->write_lock);
2435 if (atomic_read(&mddev->writes_pending) == 0) {
2436 mddev->in_sync = 1;
NeilBrown850b2b42006-10-03 01:15:46 -07002437 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown9e653b62006-06-26 00:27:58 -07002438 }
2439 spin_unlock_irq(&mddev->write_lock);
2440 } else {
2441 mddev->ro = 0;
2442 mddev->recovery_cp = MaxSector;
2443 err = do_md_run(mddev);
2444 }
2445 break;
2446 case active:
2447 if (mddev->pers) {
2448 restart_array(mddev);
NeilBrown850b2b42006-10-03 01:15:46 -07002449 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown9e653b62006-06-26 00:27:58 -07002450 wake_up(&mddev->sb_wait);
2451 err = 0;
2452 } else {
2453 mddev->ro = 0;
2454 err = do_md_run(mddev);
2455 }
2456 break;
2457 case write_pending:
2458 case active_idle:
2459 /* these cannot be set */
2460 break;
2461 }
2462 if (err)
2463 return err;
2464 else
2465 return len;
2466}
NeilBrown80ca3a42006-07-10 04:44:18 -07002467static struct md_sysfs_entry md_array_state =
2468__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
NeilBrown9e653b62006-06-26 00:27:58 -07002469
NeilBrown6d7ff732006-01-06 00:21:16 -08002470static ssize_t
2471null_show(mddev_t *mddev, char *page)
2472{
2473 return -EINVAL;
2474}
2475
2476static ssize_t
2477new_dev_store(mddev_t *mddev, const char *buf, size_t len)
2478{
2479 /* buf must be %d:%d\n? giving major and minor numbers */
2480 /* The new device is added to the array.
2481 * If the array has a persistent superblock, we read the
2482 * superblock to initialise info and check validity.
2483 * Otherwise, only checking done is that in bind_rdev_to_array,
2484 * which mainly checks size.
2485 */
2486 char *e;
2487 int major = simple_strtoul(buf, &e, 10);
2488 int minor;
2489 dev_t dev;
2490 mdk_rdev_t *rdev;
2491 int err;
2492
2493 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
2494 return -EINVAL;
2495 minor = simple_strtoul(e+1, &e, 10);
2496 if (*e && *e != '\n')
2497 return -EINVAL;
2498 dev = MKDEV(major, minor);
2499 if (major != MAJOR(dev) ||
2500 minor != MINOR(dev))
2501 return -EOVERFLOW;
2502
2503
2504 if (mddev->persistent) {
2505 rdev = md_import_device(dev, mddev->major_version,
2506 mddev->minor_version);
2507 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
2508 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2509 mdk_rdev_t, same_set);
2510 err = super_types[mddev->major_version]
2511 .load_super(rdev, rdev0, mddev->minor_version);
2512 if (err < 0)
2513 goto out;
2514 }
2515 } else
2516 rdev = md_import_device(dev, -1, -1);
2517
2518 if (IS_ERR(rdev))
2519 return PTR_ERR(rdev);
2520 err = bind_rdev_to_array(rdev, mddev);
2521 out:
2522 if (err)
2523 export_rdev(rdev);
2524 return err ? err : len;
2525}
2526
2527static struct md_sysfs_entry md_new_device =
NeilBrown80ca3a42006-07-10 04:44:18 -07002528__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
NeilBrown3b343802006-01-06 00:20:47 -08002529
2530static ssize_t
Paul Clements9b1d1da2006-10-03 01:15:49 -07002531bitmap_store(mddev_t *mddev, const char *buf, size_t len)
2532{
2533 char *end;
2534 unsigned long chunk, end_chunk;
2535
2536 if (!mddev->bitmap)
2537 goto out;
2538 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
2539 while (*buf) {
2540 chunk = end_chunk = simple_strtoul(buf, &end, 0);
2541 if (buf == end) break;
2542 if (*end == '-') { /* range */
2543 buf = end + 1;
2544 end_chunk = simple_strtoul(buf, &end, 0);
2545 if (buf == end) break;
2546 }
2547 if (*end && !isspace(*end)) break;
2548 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
2549 buf = end;
2550 while (isspace(*buf)) buf++;
2551 }
2552 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
2553out:
2554 return len;
2555}
2556
2557static struct md_sysfs_entry md_bitmap =
2558__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
2559
2560static ssize_t
NeilBrowna35b0d62006-01-06 00:20:49 -08002561size_show(mddev_t *mddev, char *page)
2562{
2563 return sprintf(page, "%llu\n", (unsigned long long)mddev->size);
2564}
2565
2566static int update_size(mddev_t *mddev, unsigned long size);
2567
2568static ssize_t
2569size_store(mddev_t *mddev, const char *buf, size_t len)
2570{
2571 /* If array is inactive, we can reduce the component size, but
2572 * not increase it (except from 0).
2573 * If array is active, we can try an on-line resize
2574 */
2575 char *e;
2576 int err = 0;
2577 unsigned long long size = simple_strtoull(buf, &e, 10);
2578 if (!*buf || *buf == '\n' ||
2579 (*e && *e != '\n'))
2580 return -EINVAL;
2581
2582 if (mddev->pers) {
2583 err = update_size(mddev, size);
NeilBrown850b2b42006-10-03 01:15:46 -07002584 md_update_sb(mddev, 1);
NeilBrowna35b0d62006-01-06 00:20:49 -08002585 } else {
2586 if (mddev->size == 0 ||
2587 mddev->size > size)
2588 mddev->size = size;
2589 else
2590 err = -ENOSPC;
2591 }
2592 return err ? err : len;
2593}
2594
2595static struct md_sysfs_entry md_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07002596__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
NeilBrowna35b0d62006-01-06 00:20:49 -08002597
NeilBrown8bb93aa2006-01-06 00:20:50 -08002598
2599/* Metdata version.
2600 * This is either 'none' for arrays with externally managed metadata,
2601 * or N.M for internally known formats
2602 */
2603static ssize_t
2604metadata_show(mddev_t *mddev, char *page)
2605{
2606 if (mddev->persistent)
2607 return sprintf(page, "%d.%d\n",
2608 mddev->major_version, mddev->minor_version);
2609 else
2610 return sprintf(page, "none\n");
2611}
2612
2613static ssize_t
2614metadata_store(mddev_t *mddev, const char *buf, size_t len)
2615{
2616 int major, minor;
2617 char *e;
2618 if (!list_empty(&mddev->disks))
2619 return -EBUSY;
2620
2621 if (cmd_match(buf, "none")) {
2622 mddev->persistent = 0;
2623 mddev->major_version = 0;
2624 mddev->minor_version = 90;
2625 return len;
2626 }
2627 major = simple_strtoul(buf, &e, 10);
2628 if (e==buf || *e != '.')
2629 return -EINVAL;
2630 buf = e+1;
2631 minor = simple_strtoul(buf, &e, 10);
2632 if (e==buf || *e != '\n')
2633 return -EINVAL;
2634 if (major >= sizeof(super_types)/sizeof(super_types[0]) ||
2635 super_types[major].name == NULL)
2636 return -ENOENT;
2637 mddev->major_version = major;
2638 mddev->minor_version = minor;
2639 mddev->persistent = 1;
2640 return len;
2641}
2642
2643static struct md_sysfs_entry md_metadata =
NeilBrown80ca3a42006-07-10 04:44:18 -07002644__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
NeilBrown8bb93aa2006-01-06 00:20:50 -08002645
NeilBrowna35b0d62006-01-06 00:20:49 -08002646static ssize_t
NeilBrown7eec3142005-11-08 21:39:44 -08002647action_show(mddev_t *mddev, char *page)
NeilBrown24dd4692005-11-08 21:39:26 -08002648{
NeilBrown7eec3142005-11-08 21:39:44 -08002649 char *type = "idle";
NeilBrown31399d92005-11-08 21:39:29 -08002650 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2651 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
NeilBrownccfcc3c2006-03-27 01:18:09 -08002652 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
2653 type = "reshape";
2654 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
NeilBrown24dd4692005-11-08 21:39:26 -08002655 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
2656 type = "resync";
2657 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
2658 type = "check";
2659 else
2660 type = "repair";
2661 } else
2662 type = "recover";
2663 }
2664 return sprintf(page, "%s\n", type);
2665}
2666
2667static ssize_t
NeilBrown7eec3142005-11-08 21:39:44 -08002668action_store(mddev_t *mddev, const char *page, size_t len)
NeilBrown24dd4692005-11-08 21:39:26 -08002669{
NeilBrown7eec3142005-11-08 21:39:44 -08002670 if (!mddev->pers || !mddev->pers->sync_request)
2671 return -EINVAL;
2672
NeilBrownbce74da2006-01-06 00:20:41 -08002673 if (cmd_match(page, "idle")) {
NeilBrown7eec3142005-11-08 21:39:44 -08002674 if (mddev->sync_thread) {
2675 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2676 md_unregister_thread(mddev->sync_thread);
2677 mddev->sync_thread = NULL;
2678 mddev->recovery = 0;
2679 }
NeilBrown03c902e2006-01-06 00:20:46 -08002680 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2681 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08002682 return -EBUSY;
NeilBrown03c902e2006-01-06 00:20:46 -08002683 else if (cmd_match(page, "resync") || cmd_match(page, "recover"))
NeilBrown7eec3142005-11-08 21:39:44 -08002684 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown16484bf2006-03-27 01:18:13 -08002685 else if (cmd_match(page, "reshape")) {
2686 int err;
2687 if (mddev->pers->start_reshape == NULL)
2688 return -EINVAL;
2689 err = mddev->pers->start_reshape(mddev);
2690 if (err)
2691 return err;
2692 } else {
NeilBrownbce74da2006-01-06 00:20:41 -08002693 if (cmd_match(page, "check"))
NeilBrown7eec3142005-11-08 21:39:44 -08002694 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrown2adc7d42006-05-20 14:59:57 -07002695 else if (!cmd_match(page, "repair"))
NeilBrown7eec3142005-11-08 21:39:44 -08002696 return -EINVAL;
2697 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
2698 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
NeilBrown7eec3142005-11-08 21:39:44 -08002699 }
NeilBrown03c902e2006-01-06 00:20:46 -08002700 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08002701 md_wakeup_thread(mddev->thread);
2702 return len;
2703}
2704
NeilBrown9d888832005-11-08 21:39:26 -08002705static ssize_t
NeilBrown96de1e62005-11-08 21:39:39 -08002706mismatch_cnt_show(mddev_t *mddev, char *page)
NeilBrown9d888832005-11-08 21:39:26 -08002707{
2708 return sprintf(page, "%llu\n",
2709 (unsigned long long) mddev->resync_mismatches);
2710}
2711
NeilBrown80ca3a42006-07-10 04:44:18 -07002712static struct md_sysfs_entry md_scan_mode =
2713__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
NeilBrown24dd4692005-11-08 21:39:26 -08002714
NeilBrown96de1e62005-11-08 21:39:39 -08002715
NeilBrown80ca3a42006-07-10 04:44:18 -07002716static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
NeilBrown9d888832005-11-08 21:39:26 -08002717
NeilBrown88202a02006-01-06 00:21:36 -08002718static ssize_t
2719sync_min_show(mddev_t *mddev, char *page)
2720{
2721 return sprintf(page, "%d (%s)\n", speed_min(mddev),
2722 mddev->sync_speed_min ? "local": "system");
2723}
2724
2725static ssize_t
2726sync_min_store(mddev_t *mddev, const char *buf, size_t len)
2727{
2728 int min;
2729 char *e;
2730 if (strncmp(buf, "system", 6)==0) {
2731 mddev->sync_speed_min = 0;
2732 return len;
2733 }
2734 min = simple_strtoul(buf, &e, 10);
2735 if (buf == e || (*e && *e != '\n') || min <= 0)
2736 return -EINVAL;
2737 mddev->sync_speed_min = min;
2738 return len;
2739}
2740
2741static struct md_sysfs_entry md_sync_min =
2742__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
2743
2744static ssize_t
2745sync_max_show(mddev_t *mddev, char *page)
2746{
2747 return sprintf(page, "%d (%s)\n", speed_max(mddev),
2748 mddev->sync_speed_max ? "local": "system");
2749}
2750
2751static ssize_t
2752sync_max_store(mddev_t *mddev, const char *buf, size_t len)
2753{
2754 int max;
2755 char *e;
2756 if (strncmp(buf, "system", 6)==0) {
2757 mddev->sync_speed_max = 0;
2758 return len;
2759 }
2760 max = simple_strtoul(buf, &e, 10);
2761 if (buf == e || (*e && *e != '\n') || max <= 0)
2762 return -EINVAL;
2763 mddev->sync_speed_max = max;
2764 return len;
2765}
2766
2767static struct md_sysfs_entry md_sync_max =
2768__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
2769
2770
2771static ssize_t
2772sync_speed_show(mddev_t *mddev, char *page)
2773{
2774 unsigned long resync, dt, db;
NeilBrownff4e8d92006-07-10 04:44:16 -07002775 resync = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active));
NeilBrown88202a02006-01-06 00:21:36 -08002776 dt = ((jiffies - mddev->resync_mark) / HZ);
2777 if (!dt) dt++;
2778 db = resync - (mddev->resync_mark_cnt);
2779 return sprintf(page, "%ld\n", db/dt/2); /* K/sec */
2780}
2781
NeilBrown80ca3a42006-07-10 04:44:18 -07002782static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
NeilBrown88202a02006-01-06 00:21:36 -08002783
2784static ssize_t
2785sync_completed_show(mddev_t *mddev, char *page)
2786{
2787 unsigned long max_blocks, resync;
2788
2789 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
2790 max_blocks = mddev->resync_max_sectors;
2791 else
2792 max_blocks = mddev->size << 1;
2793
2794 resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
2795 return sprintf(page, "%lu / %lu\n", resync, max_blocks);
2796}
2797
NeilBrown80ca3a42006-07-10 04:44:18 -07002798static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
NeilBrown88202a02006-01-06 00:21:36 -08002799
NeilBrowne464eaf2006-03-27 01:18:14 -08002800static ssize_t
2801suspend_lo_show(mddev_t *mddev, char *page)
2802{
2803 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
2804}
2805
2806static ssize_t
2807suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
2808{
2809 char *e;
2810 unsigned long long new = simple_strtoull(buf, &e, 10);
2811
2812 if (mddev->pers->quiesce == NULL)
2813 return -EINVAL;
2814 if (buf == e || (*e && *e != '\n'))
2815 return -EINVAL;
2816 if (new >= mddev->suspend_hi ||
2817 (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
2818 mddev->suspend_lo = new;
2819 mddev->pers->quiesce(mddev, 2);
2820 return len;
2821 } else
2822 return -EINVAL;
2823}
2824static struct md_sysfs_entry md_suspend_lo =
2825__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
2826
2827
2828static ssize_t
2829suspend_hi_show(mddev_t *mddev, char *page)
2830{
2831 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
2832}
2833
2834static ssize_t
2835suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
2836{
2837 char *e;
2838 unsigned long long new = simple_strtoull(buf, &e, 10);
2839
2840 if (mddev->pers->quiesce == NULL)
2841 return -EINVAL;
2842 if (buf == e || (*e && *e != '\n'))
2843 return -EINVAL;
2844 if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
2845 (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
2846 mddev->suspend_hi = new;
2847 mddev->pers->quiesce(mddev, 1);
2848 mddev->pers->quiesce(mddev, 0);
2849 return len;
2850 } else
2851 return -EINVAL;
2852}
2853static struct md_sysfs_entry md_suspend_hi =
2854__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
2855
2856
NeilBrowneae17012005-11-08 21:39:23 -08002857static struct attribute *md_default_attrs[] = {
2858 &md_level.attr,
NeilBrownd4dbd022006-06-26 00:27:59 -07002859 &md_layout.attr,
NeilBrowneae17012005-11-08 21:39:23 -08002860 &md_raid_disks.attr,
NeilBrown3b343802006-01-06 00:20:47 -08002861 &md_chunk_size.attr,
NeilBrowna35b0d62006-01-06 00:20:49 -08002862 &md_size.attr,
NeilBrowna94213b2006-06-26 00:28:00 -07002863 &md_resync_start.attr,
NeilBrown8bb93aa2006-01-06 00:20:50 -08002864 &md_metadata.attr,
NeilBrown6d7ff732006-01-06 00:21:16 -08002865 &md_new_device.attr,
NeilBrown16f17b32006-06-26 00:27:37 -07002866 &md_safe_delay.attr,
NeilBrown9e653b62006-06-26 00:27:58 -07002867 &md_array_state.attr,
NeilBrown411036f2005-11-08 21:39:40 -08002868 NULL,
2869};
2870
2871static struct attribute *md_redundancy_attrs[] = {
NeilBrown24dd4692005-11-08 21:39:26 -08002872 &md_scan_mode.attr,
NeilBrown9d888832005-11-08 21:39:26 -08002873 &md_mismatches.attr,
NeilBrown88202a02006-01-06 00:21:36 -08002874 &md_sync_min.attr,
2875 &md_sync_max.attr,
2876 &md_sync_speed.attr,
2877 &md_sync_completed.attr,
NeilBrowne464eaf2006-03-27 01:18:14 -08002878 &md_suspend_lo.attr,
2879 &md_suspend_hi.attr,
Paul Clements9b1d1da2006-10-03 01:15:49 -07002880 &md_bitmap.attr,
NeilBrowneae17012005-11-08 21:39:23 -08002881 NULL,
2882};
NeilBrown411036f2005-11-08 21:39:40 -08002883static struct attribute_group md_redundancy_group = {
2884 .name = NULL,
2885 .attrs = md_redundancy_attrs,
2886};
2887
NeilBrowneae17012005-11-08 21:39:23 -08002888
2889static ssize_t
2890md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
2891{
2892 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
2893 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08002894 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08002895
2896 if (!entry->show)
2897 return -EIO;
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07002898 rv = mddev_lock(mddev);
2899 if (!rv) {
2900 rv = entry->show(mddev, page);
2901 mddev_unlock(mddev);
2902 }
NeilBrown96de1e62005-11-08 21:39:39 -08002903 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08002904}
2905
2906static ssize_t
2907md_attr_store(struct kobject *kobj, struct attribute *attr,
2908 const char *page, size_t length)
2909{
2910 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
2911 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08002912 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08002913
2914 if (!entry->store)
2915 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07002916 if (!capable(CAP_SYS_ADMIN))
2917 return -EACCES;
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07002918 rv = mddev_lock(mddev);
2919 if (!rv) {
2920 rv = entry->store(mddev, page, length);
2921 mddev_unlock(mddev);
2922 }
NeilBrown96de1e62005-11-08 21:39:39 -08002923 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08002924}
2925
2926static void md_free(struct kobject *ko)
2927{
2928 mddev_t *mddev = container_of(ko, mddev_t, kobj);
2929 kfree(mddev);
2930}
2931
2932static struct sysfs_ops md_sysfs_ops = {
2933 .show = md_attr_show,
2934 .store = md_attr_store,
2935};
2936static struct kobj_type md_ktype = {
2937 .release = md_free,
2938 .sysfs_ops = &md_sysfs_ops,
2939 .default_attrs = md_default_attrs,
2940};
2941
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942int mdp_major = 0;
2943
2944static struct kobject *md_probe(dev_t dev, int *part, void *data)
2945{
Arjan van de Ven48c9c272006-03-27 01:18:20 -08002946 static DEFINE_MUTEX(disks_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 mddev_t *mddev = mddev_find(dev);
2948 struct gendisk *disk;
2949 int partitioned = (MAJOR(dev) != MD_MAJOR);
2950 int shift = partitioned ? MdpMinorShift : 0;
2951 int unit = MINOR(dev) >> shift;
2952
2953 if (!mddev)
2954 return NULL;
2955
Arjan van de Ven48c9c272006-03-27 01:18:20 -08002956 mutex_lock(&disks_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 if (mddev->gendisk) {
Arjan van de Ven48c9c272006-03-27 01:18:20 -08002958 mutex_unlock(&disks_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 mddev_put(mddev);
2960 return NULL;
2961 }
2962 disk = alloc_disk(1 << shift);
2963 if (!disk) {
Arjan van de Ven48c9c272006-03-27 01:18:20 -08002964 mutex_unlock(&disks_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 mddev_put(mddev);
2966 return NULL;
2967 }
2968 disk->major = MAJOR(dev);
2969 disk->first_minor = unit << shift;
Greg Kroah-Hartmance7b0f42005-06-20 21:15:16 -07002970 if (partitioned)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971 sprintf(disk->disk_name, "md_d%d", unit);
Greg Kroah-Hartmance7b0f42005-06-20 21:15:16 -07002972 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002973 sprintf(disk->disk_name, "md%d", unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974 disk->fops = &md_fops;
2975 disk->private_data = mddev;
2976 disk->queue = mddev->queue;
2977 add_disk(disk);
2978 mddev->gendisk = disk;
Arjan van de Ven48c9c272006-03-27 01:18:20 -08002979 mutex_unlock(&disks_mutex);
NeilBrown9c791972005-11-08 21:39:28 -08002980 mddev->kobj.parent = &disk->kobj;
NeilBrowneae17012005-11-08 21:39:23 -08002981 mddev->kobj.k_name = NULL;
2982 snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
2983 mddev->kobj.ktype = &md_ktype;
2984 kobject_register(&mddev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 return NULL;
2986}
2987
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988static void md_safemode_timeout(unsigned long data)
2989{
2990 mddev_t *mddev = (mddev_t *) data;
2991
2992 mddev->safemode = 1;
2993 md_wakeup_thread(mddev->thread);
2994}
2995
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08002996static int start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997
2998static int do_md_run(mddev_t * mddev)
2999{
NeilBrown2604b702006-01-06 00:20:36 -08003000 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 int chunk_size;
3002 struct list_head *tmp;
3003 mdk_rdev_t *rdev;
3004 struct gendisk *disk;
NeilBrown2604b702006-01-06 00:20:36 -08003005 struct mdk_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006 char b[BDEVNAME_SIZE];
3007
NeilBrowna757e642005-04-16 15:26:42 -07003008 if (list_empty(&mddev->disks))
3009 /* cannot run an array with no devices.. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011
3012 if (mddev->pers)
3013 return -EBUSY;
3014
3015 /*
3016 * Analyze all RAID superblock(s)
3017 */
NeilBrowna757e642005-04-16 15:26:42 -07003018 if (!mddev->raid_disks)
3019 analyze_sbs(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020
3021 chunk_size = mddev->chunk_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022
NeilBrown2604b702006-01-06 00:20:36 -08003023 if (chunk_size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 if (chunk_size > MAX_CHUNK_SIZE) {
3025 printk(KERN_ERR "too big chunk_size: %d > %d\n",
3026 chunk_size, MAX_CHUNK_SIZE);
3027 return -EINVAL;
3028 }
3029 /*
3030 * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
3031 */
3032 if ( (1 << ffz(~chunk_size)) != chunk_size) {
NeilBrowna757e642005-04-16 15:26:42 -07003033 printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 return -EINVAL;
3035 }
3036 if (chunk_size < PAGE_SIZE) {
3037 printk(KERN_ERR "too small chunk_size: %d < %ld\n",
3038 chunk_size, PAGE_SIZE);
3039 return -EINVAL;
3040 }
3041
3042 /* devices must have minimum size of one chunk */
3043 ITERATE_RDEV(mddev,rdev,tmp) {
NeilBrownb2d444d2005-11-08 21:39:31 -08003044 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 continue;
3046 if (rdev->size < chunk_size / 1024) {
3047 printk(KERN_WARNING
3048 "md: Dev %s smaller than chunk_size:"
3049 " %lluk < %dk\n",
3050 bdevname(rdev->bdev,b),
3051 (unsigned long long)rdev->size,
3052 chunk_size / 1024);
3053 return -EINVAL;
3054 }
3055 }
3056 }
3057
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058#ifdef CONFIG_KMOD
NeilBrownd9d166c2006-01-06 00:20:51 -08003059 if (mddev->level != LEVEL_NONE)
3060 request_module("md-level-%d", mddev->level);
3061 else if (mddev->clevel[0])
3062 request_module("md-%s", mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063#endif
3064
3065 /*
3066 * Drop all container device buffers, from now on
3067 * the only valid external interface is through the md
3068 * device.
3069 * Also find largest hardsector size
3070 */
3071 ITERATE_RDEV(mddev,rdev,tmp) {
NeilBrownb2d444d2005-11-08 21:39:31 -08003072 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073 continue;
3074 sync_blockdev(rdev->bdev);
3075 invalidate_bdev(rdev->bdev, 0);
3076 }
3077
3078 md_probe(mddev->unit, NULL, NULL);
3079 disk = mddev->gendisk;
3080 if (!disk)
3081 return -ENOMEM;
3082
3083 spin_lock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08003084 pers = find_pers(mddev->level, mddev->clevel);
NeilBrown2604b702006-01-06 00:20:36 -08003085 if (!pers || !try_module_get(pers->owner)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 spin_unlock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08003087 if (mddev->level != LEVEL_NONE)
3088 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
3089 mddev->level);
3090 else
3091 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
3092 mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 return -EINVAL;
3094 }
NeilBrown2604b702006-01-06 00:20:36 -08003095 mddev->pers = pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 spin_unlock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08003097 mddev->level = pers->level;
3098 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099
NeilBrownf6705572006-03-27 01:18:11 -08003100 if (mddev->reshape_position != MaxSector &&
NeilBrown63c70c42006-03-27 01:18:13 -08003101 pers->start_reshape == NULL) {
NeilBrownf6705572006-03-27 01:18:11 -08003102 /* This personality cannot handle reshaping... */
3103 mddev->pers = NULL;
3104 module_put(pers->owner);
3105 return -EINVAL;
3106 }
3107
NeilBrown657390d2005-08-26 18:34:16 -07003108 mddev->recovery = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109 mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
NeilBrowna9701a32005-11-08 21:39:34 -08003110 mddev->barriers_work = 1;
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08003111 mddev->ok_start_degraded = start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112
NeilBrownf91de922005-11-08 21:39:36 -08003113 if (start_readonly)
3114 mddev->ro = 2; /* read-only, but switch on first write */
3115
NeilBrownb15c2e52006-01-06 00:20:16 -08003116 err = mddev->pers->run(mddev);
3117 if (!err && mddev->pers->sync_request) {
3118 err = bitmap_create(mddev);
3119 if (err) {
3120 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
3121 mdname(mddev), err);
3122 mddev->pers->stop(mddev);
3123 }
3124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 if (err) {
3126 printk(KERN_ERR "md: pers->run() failed ...\n");
3127 module_put(mddev->pers->owner);
3128 mddev->pers = NULL;
NeilBrown32a76272005-06-21 17:17:14 -07003129 bitmap_destroy(mddev);
3130 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131 }
NeilBrown411036f2005-11-08 21:39:40 -08003132 if (mddev->pers->sync_request)
3133 sysfs_create_group(&mddev->kobj, &md_redundancy_group);
NeilBrownfd9d49c2005-11-08 21:39:42 -08003134 else if (mddev->ro == 2) /* auto-readonly not meaningful */
3135 mddev->ro = 0;
3136
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 atomic_set(&mddev->writes_pending,0);
3138 mddev->safemode = 0;
3139 mddev->safemode_timer.function = md_safemode_timeout;
3140 mddev->safemode_timer.data = (unsigned long) mddev;
NeilBrown16f17b32006-06-26 00:27:37 -07003141 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 mddev->in_sync = 1;
NeilBrown86e6ffd2005-11-08 21:39:24 -08003143
3144 ITERATE_RDEV(mddev,rdev,tmp)
3145 if (rdev->raid_disk >= 0) {
3146 char nm[20];
3147 sprintf(nm, "rd%d", rdev->raid_disk);
3148 sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
3149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150
3151 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3152
NeilBrown850b2b42006-10-03 01:15:46 -07003153 if (mddev->flags)
3154 md_update_sb(mddev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155
3156 set_capacity(disk, mddev->array_size<<1);
3157
3158 /* If we call blk_queue_make_request here, it will
3159 * re-initialise max_sectors etc which may have been
3160 * refined inside -> run. So just set the bits we need to set.
3161 * Most initialisation happended when we called
3162 * blk_queue_make_request(..., md_fail_request)
3163 * earlier.
3164 */
3165 mddev->queue->queuedata = mddev;
3166 mddev->queue->make_request_fn = mddev->pers->make_request;
3167
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003168 /* If there is a partially-recovered drive we need to
3169 * start recovery here. If we leave it to md_check_recovery,
3170 * it will remove the drives and not do the right thing
3171 */
NeilBrown0b8c9de2006-07-10 04:44:15 -07003172 if (mddev->degraded && !mddev->sync_thread) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003173 struct list_head *rtmp;
3174 int spares = 0;
3175 ITERATE_RDEV(mddev,rdev,rtmp)
3176 if (rdev->raid_disk >= 0 &&
3177 !test_bit(In_sync, &rdev->flags) &&
3178 !test_bit(Faulty, &rdev->flags))
3179 /* complete an interrupted recovery */
3180 spares++;
3181 if (spares && mddev->pers->sync_request) {
3182 mddev->recovery = 0;
3183 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
3184 mddev->sync_thread = md_register_thread(md_do_sync,
3185 mddev,
3186 "%s_resync");
3187 if (!mddev->sync_thread) {
3188 printk(KERN_ERR "%s: could not start resync"
3189 " thread...\n",
3190 mdname(mddev));
3191 /* leave the spares where they are, it shouldn't hurt */
3192 mddev->recovery = 0;
NeilBrown0b8c9de2006-07-10 04:44:15 -07003193 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003194 }
3195 }
NeilBrown0b8c9de2006-07-10 04:44:15 -07003196 md_wakeup_thread(mddev->thread);
3197 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003198
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 mddev->changed = 1;
NeilBrownd7603b72006-01-06 00:20:30 -08003200 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201 return 0;
3202}
3203
3204static int restart_array(mddev_t *mddev)
3205{
3206 struct gendisk *disk = mddev->gendisk;
3207 int err;
3208
3209 /*
3210 * Complain if it has no devices
3211 */
3212 err = -ENXIO;
3213 if (list_empty(&mddev->disks))
3214 goto out;
3215
3216 if (mddev->pers) {
3217 err = -EBUSY;
3218 if (!mddev->ro)
3219 goto out;
3220
3221 mddev->safemode = 0;
3222 mddev->ro = 0;
3223 set_disk_ro(disk, 0);
3224
3225 printk(KERN_INFO "md: %s switched to read-write mode.\n",
3226 mdname(mddev));
3227 /*
3228 * Kick recovery or resync if necessary
3229 */
3230 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3231 md_wakeup_thread(mddev->thread);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003232 md_wakeup_thread(mddev->sync_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233 err = 0;
NeilBrown9e653b62006-06-26 00:27:58 -07003234 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236
3237out:
3238 return err;
3239}
3240
NeilBrownacc55e22006-06-26 00:27:47 -07003241/* similar to deny_write_access, but accounts for our holding a reference
3242 * to the file ourselves */
3243static int deny_bitmap_write_access(struct file * file)
3244{
3245 struct inode *inode = file->f_mapping->host;
3246
3247 spin_lock(&inode->i_lock);
3248 if (atomic_read(&inode->i_writecount) > 1) {
3249 spin_unlock(&inode->i_lock);
3250 return -ETXTBSY;
3251 }
3252 atomic_set(&inode->i_writecount, -1);
3253 spin_unlock(&inode->i_lock);
3254
3255 return 0;
3256}
3257
3258static void restore_bitmap_write_access(struct file *file)
3259{
3260 struct inode *inode = file->f_mapping->host;
3261
3262 spin_lock(&inode->i_lock);
3263 atomic_set(&inode->i_writecount, 1);
3264 spin_unlock(&inode->i_lock);
3265}
3266
NeilBrown9e653b62006-06-26 00:27:58 -07003267/* mode:
3268 * 0 - completely stop and dis-assemble array
3269 * 1 - switch to readonly
3270 * 2 - stop but do not disassemble array
3271 */
3272static int do_md_stop(mddev_t * mddev, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273{
3274 int err = 0;
3275 struct gendisk *disk = mddev->gendisk;
3276
3277 if (mddev->pers) {
3278 if (atomic_read(&mddev->active)>2) {
3279 printk("md: %s still in use.\n",mdname(mddev));
3280 return -EBUSY;
3281 }
3282
3283 if (mddev->sync_thread) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003284 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3286 md_unregister_thread(mddev->sync_thread);
3287 mddev->sync_thread = NULL;
3288 }
3289
3290 del_timer_sync(&mddev->safemode_timer);
3291
3292 invalidate_partition(disk, 0);
3293
NeilBrown9e653b62006-06-26 00:27:58 -07003294 switch(mode) {
3295 case 1: /* readonly */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 err = -ENXIO;
NeilBrownf91de922005-11-08 21:39:36 -08003297 if (mddev->ro==1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298 goto out;
3299 mddev->ro = 1;
NeilBrown9e653b62006-06-26 00:27:58 -07003300 break;
3301 case 0: /* disassemble */
3302 case 2: /* stop */
NeilBrown6b8b3e82005-08-04 12:53:35 -07003303 bitmap_flush(mddev);
NeilBrowna9701a32005-11-08 21:39:34 -08003304 md_super_wait(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 if (mddev->ro)
3306 set_disk_ro(disk, 0);
3307 blk_queue_make_request(mddev->queue, md_fail_request);
3308 mddev->pers->stop(mddev);
NeilBrown411036f2005-11-08 21:39:40 -08003309 if (mddev->pers->sync_request)
3310 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
3311
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 module_put(mddev->pers->owner);
3313 mddev->pers = NULL;
3314 if (mddev->ro)
3315 mddev->ro = 0;
3316 }
NeilBrown850b2b42006-10-03 01:15:46 -07003317 if (!mddev->in_sync || mddev->flags) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003318 /* mark array as shutdown cleanly */
3319 mddev->in_sync = 1;
NeilBrown850b2b42006-10-03 01:15:46 -07003320 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003321 }
NeilBrown9e653b62006-06-26 00:27:58 -07003322 if (mode == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 set_disk_ro(disk, 1);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07003324 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325 }
NeilBrown32a76272005-06-21 17:17:14 -07003326
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327 /*
3328 * Free resources if final stop
3329 */
NeilBrown9e653b62006-06-26 00:27:58 -07003330 if (mode == 0) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08003331 mdk_rdev_t *rdev;
3332 struct list_head *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333 struct gendisk *disk;
3334 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
3335
NeilBrown978f9462006-02-02 14:28:05 -08003336 bitmap_destroy(mddev);
3337 if (mddev->bitmap_file) {
NeilBrownacc55e22006-06-26 00:27:47 -07003338 restore_bitmap_write_access(mddev->bitmap_file);
NeilBrown978f9462006-02-02 14:28:05 -08003339 fput(mddev->bitmap_file);
3340 mddev->bitmap_file = NULL;
3341 }
3342 mddev->bitmap_offset = 0;
3343
NeilBrown86e6ffd2005-11-08 21:39:24 -08003344 ITERATE_RDEV(mddev,rdev,tmp)
3345 if (rdev->raid_disk >= 0) {
3346 char nm[20];
3347 sprintf(nm, "rd%d", rdev->raid_disk);
3348 sysfs_remove_link(&mddev->kobj, nm);
3349 }
3350
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351 export_array(mddev);
3352
3353 mddev->array_size = 0;
NeilBrown9e653b62006-06-26 00:27:58 -07003354 mddev->size = 0;
3355 mddev->raid_disks = 0;
NeilBrowna94213b2006-06-26 00:28:00 -07003356 mddev->recovery_cp = 0;
NeilBrown9e653b62006-06-26 00:27:58 -07003357
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358 disk = mddev->gendisk;
3359 if (disk)
3360 set_capacity(disk, 0);
3361 mddev->changed = 1;
NeilBrowna8a55c32006-06-26 00:27:39 -07003362 } else if (mddev->pers)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003363 printk(KERN_INFO "md: %s switched to read-only mode.\n",
3364 mdname(mddev));
3365 err = 0;
NeilBrownd7603b72006-01-06 00:20:30 -08003366 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003367out:
3368 return err;
3369}
3370
3371static void autorun_array(mddev_t *mddev)
3372{
3373 mdk_rdev_t *rdev;
3374 struct list_head *tmp;
3375 int err;
3376
NeilBrowna757e642005-04-16 15:26:42 -07003377 if (list_empty(&mddev->disks))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379
3380 printk(KERN_INFO "md: running: ");
3381
3382 ITERATE_RDEV(mddev,rdev,tmp) {
3383 char b[BDEVNAME_SIZE];
3384 printk("<%s>", bdevname(rdev->bdev,b));
3385 }
3386 printk("\n");
3387
3388 err = do_md_run (mddev);
3389 if (err) {
3390 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
3391 do_md_stop (mddev, 0);
3392 }
3393}
3394
3395/*
3396 * lets try to run arrays based on all disks that have arrived
3397 * until now. (those are in pending_raid_disks)
3398 *
3399 * the method: pick the first pending disk, collect all disks with
3400 * the same UUID, remove all from the pending list and put them into
3401 * the 'same_array' list. Then order this list based on superblock
3402 * update time (freshest comes first), kick out 'old' disks and
3403 * compare superblocks. If everything's fine then run it.
3404 *
3405 * If "unit" is allocated, then bump its reference count
3406 */
3407static void autorun_devices(int part)
3408{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 struct list_head *tmp;
3410 mdk_rdev_t *rdev0, *rdev;
3411 mddev_t *mddev;
3412 char b[BDEVNAME_SIZE];
3413
3414 printk(KERN_INFO "md: autorun ...\n");
3415 while (!list_empty(&pending_raid_disks)) {
NeilBrowne8703fe2006-10-03 01:15:59 -07003416 int unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417 dev_t dev;
NeilBrownad01c9e2006-03-27 01:18:07 -08003418 LIST_HEAD(candidates);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419 rdev0 = list_entry(pending_raid_disks.next,
3420 mdk_rdev_t, same_set);
3421
3422 printk(KERN_INFO "md: considering %s ...\n",
3423 bdevname(rdev0->bdev,b));
3424 INIT_LIST_HEAD(&candidates);
3425 ITERATE_RDEV_PENDING(rdev,tmp)
3426 if (super_90_load(rdev, rdev0, 0) >= 0) {
3427 printk(KERN_INFO "md: adding %s ...\n",
3428 bdevname(rdev->bdev,b));
3429 list_move(&rdev->same_set, &candidates);
3430 }
3431 /*
3432 * now we have a set of devices, with all of them having
3433 * mostly sane superblocks. It's time to allocate the
3434 * mddev.
3435 */
NeilBrowne8703fe2006-10-03 01:15:59 -07003436 if (part) {
3437 dev = MKDEV(mdp_major,
3438 rdev0->preferred_minor << MdpMinorShift);
3439 unit = MINOR(dev) >> MdpMinorShift;
3440 } else {
3441 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
3442 unit = MINOR(dev);
3443 }
3444 if (rdev0->preferred_minor != unit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003445 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
3446 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
3447 break;
3448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449
3450 md_probe(dev, NULL, NULL);
3451 mddev = mddev_find(dev);
3452 if (!mddev) {
3453 printk(KERN_ERR
3454 "md: cannot allocate memory for md drive.\n");
3455 break;
3456 }
3457 if (mddev_lock(mddev))
3458 printk(KERN_WARNING "md: %s locked, cannot run\n",
3459 mdname(mddev));
3460 else if (mddev->raid_disks || mddev->major_version
3461 || !list_empty(&mddev->disks)) {
3462 printk(KERN_WARNING
3463 "md: %s already running, cannot run %s\n",
3464 mdname(mddev), bdevname(rdev0->bdev,b));
3465 mddev_unlock(mddev);
3466 } else {
3467 printk(KERN_INFO "md: created %s\n", mdname(mddev));
3468 ITERATE_RDEV_GENERIC(candidates,rdev,tmp) {
3469 list_del_init(&rdev->same_set);
3470 if (bind_rdev_to_array(rdev, mddev))
3471 export_rdev(rdev);
3472 }
3473 autorun_array(mddev);
3474 mddev_unlock(mddev);
3475 }
3476 /* on success, candidates will be empty, on error
3477 * it won't...
3478 */
3479 ITERATE_RDEV_GENERIC(candidates,rdev,tmp)
3480 export_rdev(rdev);
3481 mddev_put(mddev);
3482 }
3483 printk(KERN_INFO "md: ... autorun DONE.\n");
3484}
3485
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486static int get_version(void __user * arg)
3487{
3488 mdu_version_t ver;
3489
3490 ver.major = MD_MAJOR_VERSION;
3491 ver.minor = MD_MINOR_VERSION;
3492 ver.patchlevel = MD_PATCHLEVEL_VERSION;
3493
3494 if (copy_to_user(arg, &ver, sizeof(ver)))
3495 return -EFAULT;
3496
3497 return 0;
3498}
3499
3500static int get_array_info(mddev_t * mddev, void __user * arg)
3501{
3502 mdu_array_info_t info;
3503 int nr,working,active,failed,spare;
3504 mdk_rdev_t *rdev;
3505 struct list_head *tmp;
3506
3507 nr=working=active=failed=spare=0;
3508 ITERATE_RDEV(mddev,rdev,tmp) {
3509 nr++;
NeilBrownb2d444d2005-11-08 21:39:31 -08003510 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003511 failed++;
3512 else {
3513 working++;
NeilBrownb2d444d2005-11-08 21:39:31 -08003514 if (test_bit(In_sync, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515 active++;
3516 else
3517 spare++;
3518 }
3519 }
3520
3521 info.major_version = mddev->major_version;
3522 info.minor_version = mddev->minor_version;
3523 info.patch_version = MD_PATCHLEVEL_VERSION;
3524 info.ctime = mddev->ctime;
3525 info.level = mddev->level;
3526 info.size = mddev->size;
NeilBrown284ae7c2006-02-03 03:03:40 -08003527 if (info.size != mddev->size) /* overflow */
3528 info.size = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003529 info.nr_disks = nr;
3530 info.raid_disks = mddev->raid_disks;
3531 info.md_minor = mddev->md_minor;
3532 info.not_persistent= !mddev->persistent;
3533
3534 info.utime = mddev->utime;
3535 info.state = 0;
3536 if (mddev->in_sync)
3537 info.state = (1<<MD_SB_CLEAN);
NeilBrown36fa3062005-09-09 16:23:45 -07003538 if (mddev->bitmap && mddev->bitmap_offset)
3539 info.state = (1<<MD_SB_BITMAP_PRESENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540 info.active_disks = active;
3541 info.working_disks = working;
3542 info.failed_disks = failed;
3543 info.spare_disks = spare;
3544
3545 info.layout = mddev->layout;
3546 info.chunk_size = mddev->chunk_size;
3547
3548 if (copy_to_user(arg, &info, sizeof(info)))
3549 return -EFAULT;
3550
3551 return 0;
3552}
3553
viro@ZenIV.linux.org.uk87162a22005-09-09 20:36:43 +01003554static int get_bitmap_file(mddev_t * mddev, void __user * arg)
NeilBrown32a76272005-06-21 17:17:14 -07003555{
3556 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
3557 char *ptr, *buf = NULL;
3558 int err = -ENOMEM;
3559
3560 file = kmalloc(sizeof(*file), GFP_KERNEL);
3561 if (!file)
3562 goto out;
3563
3564 /* bitmap disabled, zero the first byte and copy out */
3565 if (!mddev->bitmap || !mddev->bitmap->file) {
3566 file->pathname[0] = '\0';
3567 goto copy_out;
3568 }
3569
3570 buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
3571 if (!buf)
3572 goto out;
3573
3574 ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
3575 if (!ptr)
3576 goto out;
3577
3578 strcpy(file->pathname, ptr);
3579
3580copy_out:
3581 err = 0;
3582 if (copy_to_user(arg, file, sizeof(*file)))
3583 err = -EFAULT;
3584out:
3585 kfree(buf);
3586 kfree(file);
3587 return err;
3588}
3589
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590static int get_disk_info(mddev_t * mddev, void __user * arg)
3591{
3592 mdu_disk_info_t info;
3593 unsigned int nr;
3594 mdk_rdev_t *rdev;
3595
3596 if (copy_from_user(&info, arg, sizeof(info)))
3597 return -EFAULT;
3598
3599 nr = info.number;
3600
3601 rdev = find_rdev_nr(mddev, nr);
3602 if (rdev) {
3603 info.major = MAJOR(rdev->bdev->bd_dev);
3604 info.minor = MINOR(rdev->bdev->bd_dev);
3605 info.raid_disk = rdev->raid_disk;
3606 info.state = 0;
NeilBrownb2d444d2005-11-08 21:39:31 -08003607 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 info.state |= (1<<MD_DISK_FAULTY);
NeilBrownb2d444d2005-11-08 21:39:31 -08003609 else if (test_bit(In_sync, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610 info.state |= (1<<MD_DISK_ACTIVE);
3611 info.state |= (1<<MD_DISK_SYNC);
3612 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07003613 if (test_bit(WriteMostly, &rdev->flags))
3614 info.state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615 } else {
3616 info.major = info.minor = 0;
3617 info.raid_disk = -1;
3618 info.state = (1<<MD_DISK_REMOVED);
3619 }
3620
3621 if (copy_to_user(arg, &info, sizeof(info)))
3622 return -EFAULT;
3623
3624 return 0;
3625}
3626
3627static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
3628{
3629 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3630 mdk_rdev_t *rdev;
3631 dev_t dev = MKDEV(info->major,info->minor);
3632
3633 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
3634 return -EOVERFLOW;
3635
3636 if (!mddev->raid_disks) {
3637 int err;
3638 /* expecting a device which has a superblock */
3639 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
3640 if (IS_ERR(rdev)) {
3641 printk(KERN_WARNING
3642 "md: md_import_device returned %ld\n",
3643 PTR_ERR(rdev));
3644 return PTR_ERR(rdev);
3645 }
3646 if (!list_empty(&mddev->disks)) {
3647 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
3648 mdk_rdev_t, same_set);
3649 int err = super_types[mddev->major_version]
3650 .load_super(rdev, rdev0, mddev->minor_version);
3651 if (err < 0) {
3652 printk(KERN_WARNING
3653 "md: %s has different UUID to %s\n",
3654 bdevname(rdev->bdev,b),
3655 bdevname(rdev0->bdev,b2));
3656 export_rdev(rdev);
3657 return -EINVAL;
3658 }
3659 }
3660 err = bind_rdev_to_array(rdev, mddev);
3661 if (err)
3662 export_rdev(rdev);
3663 return err;
3664 }
3665
3666 /*
3667 * add_new_disk can be used once the array is assembled
3668 * to add "hot spares". They must already have a superblock
3669 * written
3670 */
3671 if (mddev->pers) {
3672 int err;
3673 if (!mddev->pers->hot_add_disk) {
3674 printk(KERN_WARNING
3675 "%s: personality does not support diskops!\n",
3676 mdname(mddev));
3677 return -EINVAL;
3678 }
NeilBrown7b1e35f2005-09-09 16:23:50 -07003679 if (mddev->persistent)
3680 rdev = md_import_device(dev, mddev->major_version,
3681 mddev->minor_version);
3682 else
3683 rdev = md_import_device(dev, -1, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684 if (IS_ERR(rdev)) {
3685 printk(KERN_WARNING
3686 "md: md_import_device returned %ld\n",
3687 PTR_ERR(rdev));
3688 return PTR_ERR(rdev);
3689 }
NeilBrown41158c72005-06-21 17:17:25 -07003690 /* set save_raid_disk if appropriate */
3691 if (!mddev->persistent) {
3692 if (info->state & (1<<MD_DISK_SYNC) &&
3693 info->raid_disk < mddev->raid_disks)
3694 rdev->raid_disk = info->raid_disk;
3695 else
3696 rdev->raid_disk = -1;
3697 } else
3698 super_types[mddev->major_version].
3699 validate_super(mddev, rdev);
3700 rdev->saved_raid_disk = rdev->raid_disk;
3701
NeilBrownb2d444d2005-11-08 21:39:31 -08003702 clear_bit(In_sync, &rdev->flags); /* just to be sure */
NeilBrown8ddf9ef2005-09-09 16:23:45 -07003703 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
3704 set_bit(WriteMostly, &rdev->flags);
3705
Linus Torvalds1da177e2005-04-16 15:20:36 -07003706 rdev->raid_disk = -1;
3707 err = bind_rdev_to_array(rdev, mddev);
NeilBrown7c7546c2006-06-26 00:27:41 -07003708 if (!err && !mddev->pers->hot_remove_disk) {
3709 /* If there is hot_add_disk but no hot_remove_disk
3710 * then added disks for geometry changes,
3711 * and should be added immediately.
3712 */
3713 super_types[mddev->major_version].
3714 validate_super(mddev, rdev);
3715 err = mddev->pers->hot_add_disk(mddev, rdev);
3716 if (err)
3717 unbind_rdev_from_array(rdev);
3718 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003719 if (err)
3720 export_rdev(rdev);
NeilBrownc3617772005-06-21 17:17:10 -07003721
3722 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown005eca52005-08-22 13:11:08 -07003723 md_wakeup_thread(mddev->thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003724 return err;
3725 }
3726
3727 /* otherwise, add_new_disk is only allowed
3728 * for major_version==0 superblocks
3729 */
3730 if (mddev->major_version != 0) {
3731 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
3732 mdname(mddev));
3733 return -EINVAL;
3734 }
3735
3736 if (!(info->state & (1<<MD_DISK_FAULTY))) {
3737 int err;
3738 rdev = md_import_device (dev, -1, 0);
3739 if (IS_ERR(rdev)) {
3740 printk(KERN_WARNING
3741 "md: error, md_import_device() returned %ld\n",
3742 PTR_ERR(rdev));
3743 return PTR_ERR(rdev);
3744 }
3745 rdev->desc_nr = info->number;
3746 if (info->raid_disk < mddev->raid_disks)
3747 rdev->raid_disk = info->raid_disk;
3748 else
3749 rdev->raid_disk = -1;
3750
NeilBrownb2d444d2005-11-08 21:39:31 -08003751 rdev->flags = 0;
3752
Linus Torvalds1da177e2005-04-16 15:20:36 -07003753 if (rdev->raid_disk < mddev->raid_disks)
NeilBrownb2d444d2005-11-08 21:39:31 -08003754 if (info->state & (1<<MD_DISK_SYNC))
3755 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003756
NeilBrown8ddf9ef2005-09-09 16:23:45 -07003757 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
3758 set_bit(WriteMostly, &rdev->flags);
3759
Linus Torvalds1da177e2005-04-16 15:20:36 -07003760 if (!mddev->persistent) {
3761 printk(KERN_INFO "md: nonpersistent superblock ...\n");
3762 rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
3763 } else
3764 rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
3765 rdev->size = calc_dev_size(rdev, mddev->chunk_size);
3766
NeilBrown2bf071b2006-01-06 00:20:55 -08003767 err = bind_rdev_to_array(rdev, mddev);
3768 if (err) {
3769 export_rdev(rdev);
3770 return err;
3771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 }
3773
3774 return 0;
3775}
3776
3777static int hot_remove_disk(mddev_t * mddev, dev_t dev)
3778{
3779 char b[BDEVNAME_SIZE];
3780 mdk_rdev_t *rdev;
3781
3782 if (!mddev->pers)
3783 return -ENODEV;
3784
3785 rdev = find_rdev(mddev, dev);
3786 if (!rdev)
3787 return -ENXIO;
3788
3789 if (rdev->raid_disk >= 0)
3790 goto busy;
3791
3792 kick_rdev_from_array(rdev);
NeilBrown850b2b42006-10-03 01:15:46 -07003793 md_update_sb(mddev, 1);
NeilBrownd7603b72006-01-06 00:20:30 -08003794 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003795
3796 return 0;
3797busy:
3798 printk(KERN_WARNING "md: cannot remove active disk %s from %s ... \n",
3799 bdevname(rdev->bdev,b), mdname(mddev));
3800 return -EBUSY;
3801}
3802
3803static int hot_add_disk(mddev_t * mddev, dev_t dev)
3804{
3805 char b[BDEVNAME_SIZE];
3806 int err;
3807 unsigned int size;
3808 mdk_rdev_t *rdev;
3809
3810 if (!mddev->pers)
3811 return -ENODEV;
3812
3813 if (mddev->major_version != 0) {
3814 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
3815 " version-0 superblocks.\n",
3816 mdname(mddev));
3817 return -EINVAL;
3818 }
3819 if (!mddev->pers->hot_add_disk) {
3820 printk(KERN_WARNING
3821 "%s: personality does not support diskops!\n",
3822 mdname(mddev));
3823 return -EINVAL;
3824 }
3825
3826 rdev = md_import_device (dev, -1, 0);
3827 if (IS_ERR(rdev)) {
3828 printk(KERN_WARNING
3829 "md: error, md_import_device() returned %ld\n",
3830 PTR_ERR(rdev));
3831 return -EINVAL;
3832 }
3833
3834 if (mddev->persistent)
3835 rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
3836 else
3837 rdev->sb_offset =
3838 rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
3839
3840 size = calc_dev_size(rdev, mddev->chunk_size);
3841 rdev->size = size;
3842
NeilBrownb2d444d2005-11-08 21:39:31 -08003843 if (test_bit(Faulty, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844 printk(KERN_WARNING
3845 "md: can not hot-add faulty %s disk to %s!\n",
3846 bdevname(rdev->bdev,b), mdname(mddev));
3847 err = -EINVAL;
3848 goto abort_export;
3849 }
NeilBrownb2d444d2005-11-08 21:39:31 -08003850 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003851 rdev->desc_nr = -1;
NeilBrown2bf071b2006-01-06 00:20:55 -08003852 err = bind_rdev_to_array(rdev, mddev);
3853 if (err)
3854 goto abort_export;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003855
3856 /*
3857 * The rest should better be atomic, we can have disk failures
3858 * noticed in interrupt contexts ...
3859 */
3860
3861 if (rdev->desc_nr == mddev->max_disks) {
3862 printk(KERN_WARNING "%s: can not hot-add to full array!\n",
3863 mdname(mddev));
3864 err = -EBUSY;
3865 goto abort_unbind_export;
3866 }
3867
3868 rdev->raid_disk = -1;
3869
NeilBrown850b2b42006-10-03 01:15:46 -07003870 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871
3872 /*
3873 * Kick recovery, maybe this spare has to be added to the
3874 * array immediately.
3875 */
3876 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3877 md_wakeup_thread(mddev->thread);
NeilBrownd7603b72006-01-06 00:20:30 -08003878 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003879 return 0;
3880
3881abort_unbind_export:
3882 unbind_rdev_from_array(rdev);
3883
3884abort_export:
3885 export_rdev(rdev);
3886 return err;
3887}
3888
NeilBrown32a76272005-06-21 17:17:14 -07003889static int set_bitmap_file(mddev_t *mddev, int fd)
3890{
3891 int err;
3892
NeilBrown36fa3062005-09-09 16:23:45 -07003893 if (mddev->pers) {
3894 if (!mddev->pers->quiesce)
3895 return -EBUSY;
3896 if (mddev->recovery || mddev->sync_thread)
3897 return -EBUSY;
3898 /* we should be able to change the bitmap.. */
NeilBrown32a76272005-06-21 17:17:14 -07003899 }
3900
NeilBrown36fa3062005-09-09 16:23:45 -07003901
3902 if (fd >= 0) {
3903 if (mddev->bitmap)
3904 return -EEXIST; /* cannot add when bitmap is present */
3905 mddev->bitmap_file = fget(fd);
3906
3907 if (mddev->bitmap_file == NULL) {
3908 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
3909 mdname(mddev));
3910 return -EBADF;
3911 }
3912
3913 err = deny_bitmap_write_access(mddev->bitmap_file);
3914 if (err) {
3915 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
3916 mdname(mddev));
3917 fput(mddev->bitmap_file);
3918 mddev->bitmap_file = NULL;
3919 return err;
3920 }
NeilBrowna654b9d82005-06-21 17:17:27 -07003921 mddev->bitmap_offset = 0; /* file overrides offset */
NeilBrown36fa3062005-09-09 16:23:45 -07003922 } else if (mddev->bitmap == NULL)
3923 return -ENOENT; /* cannot remove what isn't there */
3924 err = 0;
3925 if (mddev->pers) {
3926 mddev->pers->quiesce(mddev, 1);
3927 if (fd >= 0)
3928 err = bitmap_create(mddev);
NeilBrownd7375ab322006-06-26 00:27:43 -07003929 if (fd < 0 || err) {
NeilBrown36fa3062005-09-09 16:23:45 -07003930 bitmap_destroy(mddev);
NeilBrownd7375ab322006-06-26 00:27:43 -07003931 fd = -1; /* make sure to put the file */
3932 }
NeilBrown36fa3062005-09-09 16:23:45 -07003933 mddev->pers->quiesce(mddev, 0);
NeilBrownd7375ab322006-06-26 00:27:43 -07003934 }
3935 if (fd < 0) {
NeilBrownacc55e22006-06-26 00:27:47 -07003936 if (mddev->bitmap_file) {
3937 restore_bitmap_write_access(mddev->bitmap_file);
NeilBrown36fa3062005-09-09 16:23:45 -07003938 fput(mddev->bitmap_file);
NeilBrownacc55e22006-06-26 00:27:47 -07003939 }
NeilBrown36fa3062005-09-09 16:23:45 -07003940 mddev->bitmap_file = NULL;
3941 }
3942
NeilBrown32a76272005-06-21 17:17:14 -07003943 return err;
3944}
3945
Linus Torvalds1da177e2005-04-16 15:20:36 -07003946/*
3947 * set_array_info is used two different ways
3948 * The original usage is when creating a new array.
3949 * In this usage, raid_disks is > 0 and it together with
3950 * level, size, not_persistent,layout,chunksize determine the
3951 * shape of the array.
3952 * This will always create an array with a type-0.90.0 superblock.
3953 * The newer usage is when assembling an array.
3954 * In this case raid_disks will be 0, and the major_version field is
3955 * use to determine which style super-blocks are to be found on the devices.
3956 * The minor and patch _version numbers are also kept incase the
3957 * super_block handler wishes to interpret them.
3958 */
3959static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
3960{
3961
3962 if (info->raid_disks == 0) {
3963 /* just setting version number for superblock loading */
3964 if (info->major_version < 0 ||
3965 info->major_version >= sizeof(super_types)/sizeof(super_types[0]) ||
3966 super_types[info->major_version].name == NULL) {
3967 /* maybe try to auto-load a module? */
3968 printk(KERN_INFO
3969 "md: superblock version %d not known\n",
3970 info->major_version);
3971 return -EINVAL;
3972 }
3973 mddev->major_version = info->major_version;
3974 mddev->minor_version = info->minor_version;
3975 mddev->patch_version = info->patch_version;
3976 return 0;
3977 }
3978 mddev->major_version = MD_MAJOR_VERSION;
3979 mddev->minor_version = MD_MINOR_VERSION;
3980 mddev->patch_version = MD_PATCHLEVEL_VERSION;
3981 mddev->ctime = get_seconds();
3982
3983 mddev->level = info->level;
NeilBrown17115e02006-01-16 22:14:57 -08003984 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985 mddev->size = info->size;
3986 mddev->raid_disks = info->raid_disks;
3987 /* don't set md_minor, it is determined by which /dev/md* was
3988 * openned
3989 */
3990 if (info->state & (1<<MD_SB_CLEAN))
3991 mddev->recovery_cp = MaxSector;
3992 else
3993 mddev->recovery_cp = 0;
3994 mddev->persistent = ! info->not_persistent;
3995
3996 mddev->layout = info->layout;
3997 mddev->chunk_size = info->chunk_size;
3998
3999 mddev->max_disks = MD_SB_DISKS;
4000
NeilBrown850b2b42006-10-03 01:15:46 -07004001 mddev->flags = 0;
4002 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004003
NeilBrownb2a27032005-11-28 13:44:12 -08004004 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
4005 mddev->bitmap_offset = 0;
4006
NeilBrownf6705572006-03-27 01:18:11 -08004007 mddev->reshape_position = MaxSector;
4008
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009 /*
4010 * Generate a 128 bit UUID
4011 */
4012 get_random_bytes(mddev->uuid, 16);
4013
NeilBrownf6705572006-03-27 01:18:11 -08004014 mddev->new_level = mddev->level;
4015 mddev->new_chunk = mddev->chunk_size;
4016 mddev->new_layout = mddev->layout;
4017 mddev->delta_disks = 0;
4018
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019 return 0;
4020}
4021
NeilBrowna35b0d62006-01-06 00:20:49 -08004022static int update_size(mddev_t *mddev, unsigned long size)
4023{
4024 mdk_rdev_t * rdev;
4025 int rv;
4026 struct list_head *tmp;
NeilBrown8ddeeae2006-03-27 01:18:18 -08004027 int fit = (size == 0);
NeilBrowna35b0d62006-01-06 00:20:49 -08004028
4029 if (mddev->pers->resize == NULL)
4030 return -EINVAL;
4031 /* The "size" is the amount of each device that is used.
4032 * This can only make sense for arrays with redundancy.
4033 * linear and raid0 always use whatever space is available
4034 * We can only consider changing the size if no resync
4035 * or reconstruction is happening, and if the new size
4036 * is acceptable. It must fit before the sb_offset or,
4037 * if that is <data_offset, it must fit before the
4038 * size of each device.
4039 * If size is zero, we find the largest size that fits.
4040 */
4041 if (mddev->sync_thread)
4042 return -EBUSY;
4043 ITERATE_RDEV(mddev,rdev,tmp) {
4044 sector_t avail;
NeilBrowna35b0d62006-01-06 00:20:49 -08004045 if (rdev->sb_offset > rdev->data_offset)
4046 avail = (rdev->sb_offset*2) - rdev->data_offset;
4047 else
4048 avail = get_capacity(rdev->bdev->bd_disk)
4049 - rdev->data_offset;
4050 if (fit && (size == 0 || size > avail/2))
4051 size = avail/2;
4052 if (avail < ((sector_t)size << 1))
4053 return -ENOSPC;
4054 }
4055 rv = mddev->pers->resize(mddev, (sector_t)size *2);
4056 if (!rv) {
4057 struct block_device *bdev;
4058
4059 bdev = bdget_disk(mddev->gendisk, 0);
4060 if (bdev) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08004061 mutex_lock(&bdev->bd_inode->i_mutex);
NeilBrown6d893322006-02-02 14:28:03 -08004062 i_size_write(bdev->bd_inode, (loff_t)mddev->array_size << 10);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08004063 mutex_unlock(&bdev->bd_inode->i_mutex);
NeilBrowna35b0d62006-01-06 00:20:49 -08004064 bdput(bdev);
4065 }
4066 }
4067 return rv;
4068}
4069
NeilBrownda943b992006-01-06 00:20:54 -08004070static int update_raid_disks(mddev_t *mddev, int raid_disks)
4071{
4072 int rv;
4073 /* change the number of raid disks */
NeilBrown63c70c42006-03-27 01:18:13 -08004074 if (mddev->pers->check_reshape == NULL)
NeilBrownda943b992006-01-06 00:20:54 -08004075 return -EINVAL;
4076 if (raid_disks <= 0 ||
4077 raid_disks >= mddev->max_disks)
4078 return -EINVAL;
NeilBrown63c70c42006-03-27 01:18:13 -08004079 if (mddev->sync_thread || mddev->reshape_position != MaxSector)
NeilBrownda943b992006-01-06 00:20:54 -08004080 return -EBUSY;
NeilBrown63c70c42006-03-27 01:18:13 -08004081 mddev->delta_disks = raid_disks - mddev->raid_disks;
4082
4083 rv = mddev->pers->check_reshape(mddev);
NeilBrownda943b992006-01-06 00:20:54 -08004084 return rv;
4085}
4086
4087
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088/*
4089 * update_array_info is used to change the configuration of an
4090 * on-line array.
4091 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
4092 * fields in the info are checked against the array.
4093 * Any differences that cannot be handled will cause an error.
4094 * Normally, only one change can be managed at a time.
4095 */
4096static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
4097{
4098 int rv = 0;
4099 int cnt = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07004100 int state = 0;
4101
4102 /* calculate expected state,ignoring low bits */
4103 if (mddev->bitmap && mddev->bitmap_offset)
4104 state |= (1 << MD_SB_BITMAP_PRESENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004105
4106 if (mddev->major_version != info->major_version ||
4107 mddev->minor_version != info->minor_version ||
4108/* mddev->patch_version != info->patch_version || */
4109 mddev->ctime != info->ctime ||
4110 mddev->level != info->level ||
4111/* mddev->layout != info->layout || */
4112 !mddev->persistent != info->not_persistent||
NeilBrown36fa3062005-09-09 16:23:45 -07004113 mddev->chunk_size != info->chunk_size ||
4114 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
4115 ((state^info->state) & 0xfffffe00)
4116 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117 return -EINVAL;
4118 /* Check there is only one change */
NeilBrown284ae7c2006-02-03 03:03:40 -08004119 if (info->size >= 0 && mddev->size != info->size) cnt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120 if (mddev->raid_disks != info->raid_disks) cnt++;
4121 if (mddev->layout != info->layout) cnt++;
NeilBrown36fa3062005-09-09 16:23:45 -07004122 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) cnt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004123 if (cnt == 0) return 0;
4124 if (cnt > 1) return -EINVAL;
4125
4126 if (mddev->layout != info->layout) {
4127 /* Change layout
4128 * we don't need to do anything at the md level, the
4129 * personality will take care of it all.
4130 */
4131 if (mddev->pers->reconfig == NULL)
4132 return -EINVAL;
4133 else
4134 return mddev->pers->reconfig(mddev, info->layout, -1);
4135 }
NeilBrown284ae7c2006-02-03 03:03:40 -08004136 if (info->size >= 0 && mddev->size != info->size)
NeilBrowna35b0d62006-01-06 00:20:49 -08004137 rv = update_size(mddev, info->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004138
NeilBrownda943b992006-01-06 00:20:54 -08004139 if (mddev->raid_disks != info->raid_disks)
4140 rv = update_raid_disks(mddev, info->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004141
NeilBrown36fa3062005-09-09 16:23:45 -07004142 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
4143 if (mddev->pers->quiesce == NULL)
4144 return -EINVAL;
4145 if (mddev->recovery || mddev->sync_thread)
4146 return -EBUSY;
4147 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
4148 /* add the bitmap */
4149 if (mddev->bitmap)
4150 return -EEXIST;
4151 if (mddev->default_bitmap_offset == 0)
4152 return -EINVAL;
4153 mddev->bitmap_offset = mddev->default_bitmap_offset;
4154 mddev->pers->quiesce(mddev, 1);
4155 rv = bitmap_create(mddev);
4156 if (rv)
4157 bitmap_destroy(mddev);
4158 mddev->pers->quiesce(mddev, 0);
4159 } else {
4160 /* remove the bitmap */
4161 if (!mddev->bitmap)
4162 return -ENOENT;
4163 if (mddev->bitmap->file)
4164 return -EINVAL;
4165 mddev->pers->quiesce(mddev, 1);
4166 bitmap_destroy(mddev);
4167 mddev->pers->quiesce(mddev, 0);
4168 mddev->bitmap_offset = 0;
4169 }
4170 }
NeilBrown850b2b42006-10-03 01:15:46 -07004171 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004172 return rv;
4173}
4174
4175static int set_disk_faulty(mddev_t *mddev, dev_t dev)
4176{
4177 mdk_rdev_t *rdev;
4178
4179 if (mddev->pers == NULL)
4180 return -ENODEV;
4181
4182 rdev = find_rdev(mddev, dev);
4183 if (!rdev)
4184 return -ENODEV;
4185
4186 md_error(mddev, rdev);
4187 return 0;
4188}
4189
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08004190static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
4191{
4192 mddev_t *mddev = bdev->bd_disk->private_data;
4193
4194 geo->heads = 2;
4195 geo->sectors = 4;
4196 geo->cylinders = get_capacity(mddev->gendisk) / 8;
4197 return 0;
4198}
4199
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200static int md_ioctl(struct inode *inode, struct file *file,
4201 unsigned int cmd, unsigned long arg)
4202{
4203 int err = 0;
4204 void __user *argp = (void __user *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004205 mddev_t *mddev = NULL;
4206
4207 if (!capable(CAP_SYS_ADMIN))
4208 return -EACCES;
4209
4210 /*
4211 * Commands dealing with the RAID driver but not any
4212 * particular array:
4213 */
4214 switch (cmd)
4215 {
4216 case RAID_VERSION:
4217 err = get_version(argp);
4218 goto done;
4219
4220 case PRINT_RAID_DEBUG:
4221 err = 0;
4222 md_print_devices();
4223 goto done;
4224
4225#ifndef MODULE
4226 case RAID_AUTORUN:
4227 err = 0;
4228 autostart_arrays(arg);
4229 goto done;
4230#endif
4231 default:;
4232 }
4233
4234 /*
4235 * Commands creating/starting a new array:
4236 */
4237
4238 mddev = inode->i_bdev->bd_disk->private_data;
4239
4240 if (!mddev) {
4241 BUG();
4242 goto abort;
4243 }
4244
Linus Torvalds1da177e2005-04-16 15:20:36 -07004245 err = mddev_lock(mddev);
4246 if (err) {
4247 printk(KERN_INFO
4248 "md: ioctl lock interrupted, reason %d, cmd %d\n",
4249 err, cmd);
4250 goto abort;
4251 }
4252
4253 switch (cmd)
4254 {
4255 case SET_ARRAY_INFO:
4256 {
4257 mdu_array_info_t info;
4258 if (!arg)
4259 memset(&info, 0, sizeof(info));
4260 else if (copy_from_user(&info, argp, sizeof(info))) {
4261 err = -EFAULT;
4262 goto abort_unlock;
4263 }
4264 if (mddev->pers) {
4265 err = update_array_info(mddev, &info);
4266 if (err) {
4267 printk(KERN_WARNING "md: couldn't update"
4268 " array info. %d\n", err);
4269 goto abort_unlock;
4270 }
4271 goto done_unlock;
4272 }
4273 if (!list_empty(&mddev->disks)) {
4274 printk(KERN_WARNING
4275 "md: array %s already has disks!\n",
4276 mdname(mddev));
4277 err = -EBUSY;
4278 goto abort_unlock;
4279 }
4280 if (mddev->raid_disks) {
4281 printk(KERN_WARNING
4282 "md: array %s already initialised!\n",
4283 mdname(mddev));
4284 err = -EBUSY;
4285 goto abort_unlock;
4286 }
4287 err = set_array_info(mddev, &info);
4288 if (err) {
4289 printk(KERN_WARNING "md: couldn't set"
4290 " array info. %d\n", err);
4291 goto abort_unlock;
4292 }
4293 }
4294 goto done_unlock;
4295
4296 default:;
4297 }
4298
4299 /*
4300 * Commands querying/configuring an existing array:
4301 */
NeilBrown32a76272005-06-21 17:17:14 -07004302 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
4303 * RUN_ARRAY, and SET_BITMAP_FILE are allowed */
4304 if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
4305 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004306 err = -ENODEV;
4307 goto abort_unlock;
4308 }
4309
4310 /*
4311 * Commands even a read-only array can execute:
4312 */
4313 switch (cmd)
4314 {
4315 case GET_ARRAY_INFO:
4316 err = get_array_info(mddev, argp);
4317 goto done_unlock;
4318
NeilBrown32a76272005-06-21 17:17:14 -07004319 case GET_BITMAP_FILE:
viro@ZenIV.linux.org.uk87162a22005-09-09 20:36:43 +01004320 err = get_bitmap_file(mddev, argp);
NeilBrown32a76272005-06-21 17:17:14 -07004321 goto done_unlock;
4322
Linus Torvalds1da177e2005-04-16 15:20:36 -07004323 case GET_DISK_INFO:
4324 err = get_disk_info(mddev, argp);
4325 goto done_unlock;
4326
4327 case RESTART_ARRAY_RW:
4328 err = restart_array(mddev);
4329 goto done_unlock;
4330
4331 case STOP_ARRAY:
4332 err = do_md_stop (mddev, 0);
4333 goto done_unlock;
4334
4335 case STOP_ARRAY_RO:
4336 err = do_md_stop (mddev, 1);
4337 goto done_unlock;
4338
4339 /*
4340 * We have a problem here : there is no easy way to give a CHS
4341 * virtual geometry. We currently pretend that we have a 2 heads
4342 * 4 sectors (with a BIG number of cylinders...). This drives
4343 * dosfs just mad... ;-)
4344 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004345 }
4346
4347 /*
4348 * The remaining ioctls are changing the state of the
NeilBrownf91de922005-11-08 21:39:36 -08004349 * superblock, so we do not allow them on read-only arrays.
4350 * However non-MD ioctls (e.g. get-size) will still come through
4351 * here and hit the 'default' below, so only disallow
4352 * 'md' ioctls, and switch to rw mode if started auto-readonly.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004353 */
NeilBrownf91de922005-11-08 21:39:36 -08004354 if (_IOC_TYPE(cmd) == MD_MAJOR &&
4355 mddev->ro && mddev->pers) {
4356 if (mddev->ro == 2) {
4357 mddev->ro = 0;
4358 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4359 md_wakeup_thread(mddev->thread);
4360
4361 } else {
4362 err = -EROFS;
4363 goto abort_unlock;
4364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004365 }
4366
4367 switch (cmd)
4368 {
4369 case ADD_NEW_DISK:
4370 {
4371 mdu_disk_info_t info;
4372 if (copy_from_user(&info, argp, sizeof(info)))
4373 err = -EFAULT;
4374 else
4375 err = add_new_disk(mddev, &info);
4376 goto done_unlock;
4377 }
4378
4379 case HOT_REMOVE_DISK:
4380 err = hot_remove_disk(mddev, new_decode_dev(arg));
4381 goto done_unlock;
4382
4383 case HOT_ADD_DISK:
4384 err = hot_add_disk(mddev, new_decode_dev(arg));
4385 goto done_unlock;
4386
4387 case SET_DISK_FAULTY:
4388 err = set_disk_faulty(mddev, new_decode_dev(arg));
4389 goto done_unlock;
4390
4391 case RUN_ARRAY:
4392 err = do_md_run (mddev);
4393 goto done_unlock;
4394
NeilBrown32a76272005-06-21 17:17:14 -07004395 case SET_BITMAP_FILE:
4396 err = set_bitmap_file(mddev, (int)arg);
4397 goto done_unlock;
4398
Linus Torvalds1da177e2005-04-16 15:20:36 -07004399 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004400 err = -EINVAL;
4401 goto abort_unlock;
4402 }
4403
4404done_unlock:
4405abort_unlock:
4406 mddev_unlock(mddev);
4407
4408 return err;
4409done:
4410 if (err)
4411 MD_BUG();
4412abort:
4413 return err;
4414}
4415
4416static int md_open(struct inode *inode, struct file *file)
4417{
4418 /*
4419 * Succeed if we can lock the mddev, which confirms that
4420 * it isn't being stopped right now.
4421 */
4422 mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
4423 int err;
4424
4425 if ((err = mddev_lock(mddev)))
4426 goto out;
4427
4428 err = 0;
4429 mddev_get(mddev);
4430 mddev_unlock(mddev);
4431
4432 check_disk_change(inode->i_bdev);
4433 out:
4434 return err;
4435}
4436
4437static int md_release(struct inode *inode, struct file * file)
4438{
4439 mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
4440
Eric Sesterhenn52e5f9d2006-10-03 23:33:23 +02004441 BUG_ON(!mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004442 mddev_put(mddev);
4443
4444 return 0;
4445}
4446
4447static int md_media_changed(struct gendisk *disk)
4448{
4449 mddev_t *mddev = disk->private_data;
4450
4451 return mddev->changed;
4452}
4453
4454static int md_revalidate(struct gendisk *disk)
4455{
4456 mddev_t *mddev = disk->private_data;
4457
4458 mddev->changed = 0;
4459 return 0;
4460}
4461static struct block_device_operations md_fops =
4462{
4463 .owner = THIS_MODULE,
4464 .open = md_open,
4465 .release = md_release,
4466 .ioctl = md_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08004467 .getgeo = md_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004468 .media_changed = md_media_changed,
4469 .revalidate_disk= md_revalidate,
4470};
4471
Adrian Bunk75c96f82005-05-05 16:16:09 -07004472static int md_thread(void * arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004473{
4474 mdk_thread_t *thread = arg;
4475
Linus Torvalds1da177e2005-04-16 15:20:36 -07004476 /*
4477 * md_thread is a 'system-thread', it's priority should be very
4478 * high. We avoid resource deadlocks individually in each
4479 * raid personality. (RAID5 does preallocation) We also use RR and
4480 * the very same RT priority as kswapd, thus we will never get
4481 * into a priority inversion deadlock.
4482 *
4483 * we definitely have to have equal or higher priority than
4484 * bdflush, otherwise bdflush will deadlock if there are too
4485 * many dirty RAID5 blocks.
4486 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004487
NeilBrown6985c432005-10-19 21:23:47 -07004488 allow_signal(SIGKILL);
NeilBrowna6fb0932005-09-09 16:23:56 -07004489 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490
NeilBrown93588e22005-11-15 00:09:12 -08004491 /* We need to wait INTERRUPTIBLE so that
4492 * we don't add to the load-average.
4493 * That means we need to be sure no signals are
4494 * pending
4495 */
4496 if (signal_pending(current))
4497 flush_signals(current);
4498
4499 wait_event_interruptible_timeout
4500 (thread->wqueue,
4501 test_bit(THREAD_WAKEUP, &thread->flags)
4502 || kthread_should_stop(),
4503 thread->timeout);
Christoph Lameter3e1d1d22005-06-24 23:13:50 -07004504 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004505
4506 clear_bit(THREAD_WAKEUP, &thread->flags);
4507
NeilBrown787453c2005-11-08 21:39:43 -08004508 thread->run(thread->mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004509 }
NeilBrowna6fb0932005-09-09 16:23:56 -07004510
Linus Torvalds1da177e2005-04-16 15:20:36 -07004511 return 0;
4512}
4513
4514void md_wakeup_thread(mdk_thread_t *thread)
4515{
4516 if (thread) {
4517 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
4518 set_bit(THREAD_WAKEUP, &thread->flags);
4519 wake_up(&thread->wqueue);
4520 }
4521}
4522
4523mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
4524 const char *name)
4525{
4526 mdk_thread_t *thread;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527
NeilBrown9ffae0c2006-01-06 00:20:32 -08004528 thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529 if (!thread)
4530 return NULL;
4531
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532 init_waitqueue_head(&thread->wqueue);
4533
Linus Torvalds1da177e2005-04-16 15:20:36 -07004534 thread->run = run;
4535 thread->mddev = mddev;
NeilBrown32a76272005-06-21 17:17:14 -07004536 thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrown6985c432005-10-19 21:23:47 -07004537 thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
NeilBrowna6fb0932005-09-09 16:23:56 -07004538 if (IS_ERR(thread->tsk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539 kfree(thread);
4540 return NULL;
4541 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004542 return thread;
4543}
4544
Linus Torvalds1da177e2005-04-16 15:20:36 -07004545void md_unregister_thread(mdk_thread_t *thread)
4546{
NeilBrownd28446f2005-04-16 15:26:41 -07004547 dprintk("interrupting MD-thread pid %d\n", thread->tsk->pid);
NeilBrowna6fb0932005-09-09 16:23:56 -07004548
4549 kthread_stop(thread->tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004550 kfree(thread);
4551}
4552
4553void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
4554{
4555 if (!mddev) {
4556 MD_BUG();
4557 return;
4558 }
4559
NeilBrownb2d444d2005-11-08 21:39:31 -08004560 if (!rdev || test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004561 return;
NeilBrown32a76272005-06-21 17:17:14 -07004562/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004563 dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
4564 mdname(mddev),
4565 MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
4566 __builtin_return_address(0),__builtin_return_address(1),
4567 __builtin_return_address(2),__builtin_return_address(3));
NeilBrown32a76272005-06-21 17:17:14 -07004568*/
Andrew Mortond0a0a5e2006-07-10 04:44:20 -07004569 if (!mddev->pers)
4570 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004571 if (!mddev->pers->error_handler)
4572 return;
4573 mddev->pers->error_handler(mddev,rdev);
4574 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4575 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4576 md_wakeup_thread(mddev->thread);
NeilBrownc331eb02006-05-30 21:27:13 -07004577 md_new_event_inintr(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004578}
4579
4580/* seq_file implementation /proc/mdstat */
4581
4582static void status_unused(struct seq_file *seq)
4583{
4584 int i = 0;
4585 mdk_rdev_t *rdev;
4586 struct list_head *tmp;
4587
4588 seq_printf(seq, "unused devices: ");
4589
4590 ITERATE_RDEV_PENDING(rdev,tmp) {
4591 char b[BDEVNAME_SIZE];
4592 i++;
4593 seq_printf(seq, "%s ",
4594 bdevname(rdev->bdev,b));
4595 }
4596 if (!i)
4597 seq_printf(seq, "<none>");
4598
4599 seq_printf(seq, "\n");
4600}
4601
4602
4603static void status_resync(struct seq_file *seq, mddev_t * mddev)
4604{
NeilBrown4588b422006-03-27 01:18:04 -08004605 sector_t max_blocks, resync, res;
4606 unsigned long dt, db, rt;
4607 int scale;
4608 unsigned int per_milli;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004609
4610 resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
4611
4612 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
4613 max_blocks = mddev->resync_max_sectors >> 1;
4614 else
4615 max_blocks = mddev->size;
4616
4617 /*
4618 * Should not happen.
4619 */
4620 if (!max_blocks) {
4621 MD_BUG();
4622 return;
4623 }
NeilBrown4588b422006-03-27 01:18:04 -08004624 /* Pick 'scale' such that (resync>>scale)*1000 will fit
4625 * in a sector_t, and (max_blocks>>scale) will fit in a
4626 * u32, as those are the requirements for sector_div.
4627 * Thus 'scale' must be at least 10
4628 */
4629 scale = 10;
4630 if (sizeof(sector_t) > sizeof(unsigned long)) {
4631 while ( max_blocks/2 > (1ULL<<(scale+32)))
4632 scale++;
4633 }
4634 res = (resync>>scale)*1000;
4635 sector_div(res, (u32)((max_blocks>>scale)+1));
4636
4637 per_milli = res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004638 {
NeilBrown4588b422006-03-27 01:18:04 -08004639 int i, x = per_milli/50, y = 20-x;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004640 seq_printf(seq, "[");
4641 for (i = 0; i < x; i++)
4642 seq_printf(seq, "=");
4643 seq_printf(seq, ">");
4644 for (i = 0; i < y; i++)
4645 seq_printf(seq, ".");
4646 seq_printf(seq, "] ");
4647 }
NeilBrown4588b422006-03-27 01:18:04 -08004648 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
NeilBrownccfcc3c2006-03-27 01:18:09 -08004649 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
4650 "reshape" :
NeilBrown61df9d92006-10-03 01:15:57 -07004651 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
4652 "check" :
4653 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
4654 "resync" : "recovery"))),
4655 per_milli/10, per_milli % 10,
NeilBrown4588b422006-03-27 01:18:04 -08004656 (unsigned long long) resync,
4657 (unsigned long long) max_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004658
4659 /*
4660 * We do not want to overflow, so the order of operands and
4661 * the * 100 / 100 trick are important. We do a +1 to be
4662 * safe against division by zero. We only estimate anyway.
4663 *
4664 * dt: time from mark until now
4665 * db: blocks written from mark until now
4666 * rt: remaining time
4667 */
4668 dt = ((jiffies - mddev->resync_mark) / HZ);
4669 if (!dt) dt++;
NeilBrownff4e8d92006-07-10 04:44:16 -07004670 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
4671 - mddev->resync_mark_cnt;
4672 rt = (dt * ((unsigned long)(max_blocks-resync) / (db/2/100+1)))/100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673
4674 seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
4675
NeilBrownff4e8d92006-07-10 04:44:16 -07004676 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004677}
4678
4679static void *md_seq_start(struct seq_file *seq, loff_t *pos)
4680{
4681 struct list_head *tmp;
4682 loff_t l = *pos;
4683 mddev_t *mddev;
4684
4685 if (l >= 0x10000)
4686 return NULL;
4687 if (!l--)
4688 /* header */
4689 return (void*)1;
4690
4691 spin_lock(&all_mddevs_lock);
4692 list_for_each(tmp,&all_mddevs)
4693 if (!l--) {
4694 mddev = list_entry(tmp, mddev_t, all_mddevs);
4695 mddev_get(mddev);
4696 spin_unlock(&all_mddevs_lock);
4697 return mddev;
4698 }
4699 spin_unlock(&all_mddevs_lock);
4700 if (!l--)
4701 return (void*)2;/* tail */
4702 return NULL;
4703}
4704
4705static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4706{
4707 struct list_head *tmp;
4708 mddev_t *next_mddev, *mddev = v;
4709
4710 ++*pos;
4711 if (v == (void*)2)
4712 return NULL;
4713
4714 spin_lock(&all_mddevs_lock);
4715 if (v == (void*)1)
4716 tmp = all_mddevs.next;
4717 else
4718 tmp = mddev->all_mddevs.next;
4719 if (tmp != &all_mddevs)
4720 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
4721 else {
4722 next_mddev = (void*)2;
4723 *pos = 0x10000;
4724 }
4725 spin_unlock(&all_mddevs_lock);
4726
4727 if (v != (void*)1)
4728 mddev_put(mddev);
4729 return next_mddev;
4730
4731}
4732
4733static void md_seq_stop(struct seq_file *seq, void *v)
4734{
4735 mddev_t *mddev = v;
4736
4737 if (mddev && v != (void*)1 && v != (void*)2)
4738 mddev_put(mddev);
4739}
4740
NeilBrownd7603b72006-01-06 00:20:30 -08004741struct mdstat_info {
4742 int event;
4743};
4744
Linus Torvalds1da177e2005-04-16 15:20:36 -07004745static int md_seq_show(struct seq_file *seq, void *v)
4746{
4747 mddev_t *mddev = v;
4748 sector_t size;
4749 struct list_head *tmp2;
4750 mdk_rdev_t *rdev;
NeilBrownd7603b72006-01-06 00:20:30 -08004751 struct mdstat_info *mi = seq->private;
NeilBrown32a76272005-06-21 17:17:14 -07004752 struct bitmap *bitmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004753
4754 if (v == (void*)1) {
NeilBrown2604b702006-01-06 00:20:36 -08004755 struct mdk_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004756 seq_printf(seq, "Personalities : ");
4757 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08004758 list_for_each_entry(pers, &pers_list, list)
4759 seq_printf(seq, "[%s] ", pers->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004760
4761 spin_unlock(&pers_lock);
4762 seq_printf(seq, "\n");
NeilBrownd7603b72006-01-06 00:20:30 -08004763 mi->event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004764 return 0;
4765 }
4766 if (v == (void*)2) {
4767 status_unused(seq);
4768 return 0;
4769 }
4770
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07004771 if (mddev_lock(mddev) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004772 return -EINTR;
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07004773
Linus Torvalds1da177e2005-04-16 15:20:36 -07004774 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
4775 seq_printf(seq, "%s : %sactive", mdname(mddev),
4776 mddev->pers ? "" : "in");
4777 if (mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08004778 if (mddev->ro==1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004779 seq_printf(seq, " (read-only)");
NeilBrownf91de922005-11-08 21:39:36 -08004780 if (mddev->ro==2)
4781 seq_printf(seq, "(auto-read-only)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004782 seq_printf(seq, " %s", mddev->pers->name);
4783 }
4784
4785 size = 0;
4786 ITERATE_RDEV(mddev,rdev,tmp2) {
4787 char b[BDEVNAME_SIZE];
4788 seq_printf(seq, " %s[%d]",
4789 bdevname(rdev->bdev,b), rdev->desc_nr);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07004790 if (test_bit(WriteMostly, &rdev->flags))
4791 seq_printf(seq, "(W)");
NeilBrownb2d444d2005-11-08 21:39:31 -08004792 if (test_bit(Faulty, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004793 seq_printf(seq, "(F)");
4794 continue;
NeilBrownb325a322005-09-09 16:24:00 -07004795 } else if (rdev->raid_disk < 0)
4796 seq_printf(seq, "(S)"); /* spare */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797 size += rdev->size;
4798 }
4799
4800 if (!list_empty(&mddev->disks)) {
4801 if (mddev->pers)
4802 seq_printf(seq, "\n %llu blocks",
4803 (unsigned long long)mddev->array_size);
4804 else
4805 seq_printf(seq, "\n %llu blocks",
4806 (unsigned long long)size);
4807 }
NeilBrown1cd6bf12005-09-09 16:24:00 -07004808 if (mddev->persistent) {
4809 if (mddev->major_version != 0 ||
4810 mddev->minor_version != 90) {
4811 seq_printf(seq," super %d.%d",
4812 mddev->major_version,
4813 mddev->minor_version);
4814 }
4815 } else
4816 seq_printf(seq, " super non-persistent");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004817
4818 if (mddev->pers) {
4819 mddev->pers->status (seq, mddev);
4820 seq_printf(seq, "\n ");
NeilBrown8e1b39d2005-11-08 21:39:41 -08004821 if (mddev->pers->sync_request) {
4822 if (mddev->curr_resync > 2) {
4823 status_resync (seq, mddev);
4824 seq_printf(seq, "\n ");
4825 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
4826 seq_printf(seq, "\tresync=DELAYED\n ");
4827 else if (mddev->recovery_cp < MaxSector)
4828 seq_printf(seq, "\tresync=PENDING\n ");
4829 }
NeilBrown32a76272005-06-21 17:17:14 -07004830 } else
4831 seq_printf(seq, "\n ");
4832
4833 if ((bitmap = mddev->bitmap)) {
NeilBrown32a76272005-06-21 17:17:14 -07004834 unsigned long chunk_kb;
4835 unsigned long flags;
NeilBrown32a76272005-06-21 17:17:14 -07004836 spin_lock_irqsave(&bitmap->lock, flags);
4837 chunk_kb = bitmap->chunksize >> 10;
4838 seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
4839 "%lu%s chunk",
4840 bitmap->pages - bitmap->missing_pages,
4841 bitmap->pages,
4842 (bitmap->pages - bitmap->missing_pages)
4843 << (PAGE_SHIFT - 10),
4844 chunk_kb ? chunk_kb : bitmap->chunksize,
4845 chunk_kb ? "KB" : "B");
NeilBrown78d742d2005-06-21 17:17:15 -07004846 if (bitmap->file) {
4847 seq_printf(seq, ", file: ");
4848 seq_path(seq, bitmap->file->f_vfsmnt,
4849 bitmap->file->f_dentry," \t\n");
NeilBrown32a76272005-06-21 17:17:14 -07004850 }
NeilBrown78d742d2005-06-21 17:17:15 -07004851
NeilBrown32a76272005-06-21 17:17:14 -07004852 seq_printf(seq, "\n");
4853 spin_unlock_irqrestore(&bitmap->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004854 }
4855
4856 seq_printf(seq, "\n");
4857 }
4858 mddev_unlock(mddev);
4859
4860 return 0;
4861}
4862
4863static struct seq_operations md_seq_ops = {
4864 .start = md_seq_start,
4865 .next = md_seq_next,
4866 .stop = md_seq_stop,
4867 .show = md_seq_show,
4868};
4869
4870static int md_seq_open(struct inode *inode, struct file *file)
4871{
4872 int error;
NeilBrownd7603b72006-01-06 00:20:30 -08004873 struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
4874 if (mi == NULL)
4875 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004876
4877 error = seq_open(file, &md_seq_ops);
NeilBrownd7603b72006-01-06 00:20:30 -08004878 if (error)
4879 kfree(mi);
4880 else {
4881 struct seq_file *p = file->private_data;
4882 p->private = mi;
4883 mi->event = atomic_read(&md_event_count);
4884 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004885 return error;
4886}
4887
NeilBrownd7603b72006-01-06 00:20:30 -08004888static int md_seq_release(struct inode *inode, struct file *file)
4889{
4890 struct seq_file *m = file->private_data;
4891 struct mdstat_info *mi = m->private;
4892 m->private = NULL;
4893 kfree(mi);
4894 return seq_release(inode, file);
4895}
4896
4897static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
4898{
4899 struct seq_file *m = filp->private_data;
4900 struct mdstat_info *mi = m->private;
4901 int mask;
4902
4903 poll_wait(filp, &md_event_waiters, wait);
4904
4905 /* always allow read */
4906 mask = POLLIN | POLLRDNORM;
4907
4908 if (mi->event != atomic_read(&md_event_count))
4909 mask |= POLLERR | POLLPRI;
4910 return mask;
4911}
4912
Linus Torvalds1da177e2005-04-16 15:20:36 -07004913static struct file_operations md_seq_fops = {
4914 .open = md_seq_open,
4915 .read = seq_read,
4916 .llseek = seq_lseek,
NeilBrownd7603b72006-01-06 00:20:30 -08004917 .release = md_seq_release,
4918 .poll = mdstat_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004919};
4920
NeilBrown2604b702006-01-06 00:20:36 -08004921int register_md_personality(struct mdk_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004922{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004923 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08004924 list_add_tail(&p->list, &pers_list);
4925 printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004926 spin_unlock(&pers_lock);
4927 return 0;
4928}
4929
NeilBrown2604b702006-01-06 00:20:36 -08004930int unregister_md_personality(struct mdk_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004931{
NeilBrown2604b702006-01-06 00:20:36 -08004932 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004933 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08004934 list_del_init(&p->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004935 spin_unlock(&pers_lock);
4936 return 0;
4937}
4938
4939static int is_mddev_idle(mddev_t *mddev)
4940{
4941 mdk_rdev_t * rdev;
4942 struct list_head *tmp;
4943 int idle;
4944 unsigned long curr_events;
4945
4946 idle = 1;
4947 ITERATE_RDEV(mddev,rdev,tmp) {
4948 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
Jens Axboea3623572005-11-01 09:26:16 +01004949 curr_events = disk_stat_read(disk, sectors[0]) +
4950 disk_stat_read(disk, sectors[1]) -
Linus Torvalds1da177e2005-04-16 15:20:36 -07004951 atomic_read(&disk->sync_io);
NeilBrownc0e48522005-11-18 01:11:01 -08004952 /* The difference between curr_events and last_events
4953 * will be affected by any new non-sync IO (making
4954 * curr_events bigger) and any difference in the amount of
4955 * in-flight syncio (making current_events bigger or smaller)
4956 * The amount in-flight is currently limited to
4957 * 32*64K in raid1/10 and 256*PAGE_SIZE in raid5/6
4958 * which is at most 4096 sectors.
4959 * These numbers are fairly fragile and should be made
4960 * more robust, probably by enforcing the
4961 * 'window size' that md_do_sync sort-of uses.
4962 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004963 * Note: the following is an unsigned comparison.
4964 */
NeilBrownc0e48522005-11-18 01:11:01 -08004965 if ((curr_events - rdev->last_events + 4096) > 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004966 rdev->last_events = curr_events;
4967 idle = 0;
4968 }
4969 }
4970 return idle;
4971}
4972
4973void md_done_sync(mddev_t *mddev, int blocks, int ok)
4974{
4975 /* another "blocks" (512byte) blocks have been synced */
4976 atomic_sub(blocks, &mddev->recovery_active);
4977 wake_up(&mddev->recovery_wait);
4978 if (!ok) {
4979 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
4980 md_wakeup_thread(mddev->thread);
4981 // stop recovery, signal do_sync ....
4982 }
4983}
4984
4985
NeilBrown06d91a52005-06-21 17:17:12 -07004986/* md_write_start(mddev, bi)
4987 * If we need to update some array metadata (e.g. 'active' flag
NeilBrown3d310eb2005-06-21 17:17:26 -07004988 * in superblock) before writing, schedule a superblock update
4989 * and wait for it to complete.
NeilBrown06d91a52005-06-21 17:17:12 -07004990 */
NeilBrown3d310eb2005-06-21 17:17:26 -07004991void md_write_start(mddev_t *mddev, struct bio *bi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004992{
NeilBrown06d91a52005-06-21 17:17:12 -07004993 if (bio_data_dir(bi) != WRITE)
NeilBrown3d310eb2005-06-21 17:17:26 -07004994 return;
NeilBrown06d91a52005-06-21 17:17:12 -07004995
NeilBrownf91de922005-11-08 21:39:36 -08004996 BUG_ON(mddev->ro == 1);
4997 if (mddev->ro == 2) {
4998 /* need to switch to read/write */
4999 mddev->ro = 0;
5000 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5001 md_wakeup_thread(mddev->thread);
5002 }
NeilBrown06d91a52005-06-21 17:17:12 -07005003 atomic_inc(&mddev->writes_pending);
NeilBrown06d91a52005-06-21 17:17:12 -07005004 if (mddev->in_sync) {
NeilBrowna9701a32005-11-08 21:39:34 -08005005 spin_lock_irq(&mddev->write_lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07005006 if (mddev->in_sync) {
5007 mddev->in_sync = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07005008 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown3d310eb2005-06-21 17:17:26 -07005009 md_wakeup_thread(mddev->thread);
5010 }
NeilBrowna9701a32005-11-08 21:39:34 -08005011 spin_unlock_irq(&mddev->write_lock);
NeilBrown06d91a52005-06-21 17:17:12 -07005012 }
NeilBrown850b2b42006-10-03 01:15:46 -07005013 wait_event(mddev->sb_wait, mddev->flags==0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005014}
5015
5016void md_write_end(mddev_t *mddev)
5017{
5018 if (atomic_dec_and_test(&mddev->writes_pending)) {
5019 if (mddev->safemode == 2)
5020 md_wakeup_thread(mddev->thread);
NeilBrown16f17b32006-06-26 00:27:37 -07005021 else if (mddev->safemode_delay)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005022 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
5023 }
5024}
5025
Adrian Bunk75c96f82005-05-05 16:16:09 -07005026static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005027
5028#define SYNC_MARKS 10
5029#define SYNC_MARK_STEP (3*HZ)
NeilBrown29269552006-03-27 01:18:10 -08005030void md_do_sync(mddev_t *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005031{
5032 mddev_t *mddev2;
5033 unsigned int currspeed = 0,
5034 window;
NeilBrown57afd892005-06-21 17:17:13 -07005035 sector_t max_sectors,j, io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005036 unsigned long mark[SYNC_MARKS];
5037 sector_t mark_cnt[SYNC_MARKS];
5038 int last_mark,m;
5039 struct list_head *tmp;
5040 sector_t last_check;
NeilBrown57afd892005-06-21 17:17:13 -07005041 int skipped = 0;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005042 struct list_head *rtmp;
5043 mdk_rdev_t *rdev;
NeilBrown61df9d92006-10-03 01:15:57 -07005044 char *desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005045
5046 /* just incase thread restarts... */
5047 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
5048 return;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005049 if (mddev->ro) /* never try to sync a read-only array */
5050 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005051
NeilBrown61df9d92006-10-03 01:15:57 -07005052 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5053 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
5054 desc = "data-check";
5055 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
5056 desc = "requested-resync";
5057 else
5058 desc = "resync";
5059 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5060 desc = "reshape";
5061 else
5062 desc = "recovery";
5063
Linus Torvalds1da177e2005-04-16 15:20:36 -07005064 /* we overload curr_resync somewhat here.
5065 * 0 == not engaged in resync at all
5066 * 2 == checking that there is no conflict with another sync
5067 * 1 == like 2, but have yielded to allow conflicting resync to
5068 * commense
5069 * other == active in resync - this many blocks
5070 *
5071 * Before starting a resync we must have set curr_resync to
5072 * 2, and then checked that every "conflicting" array has curr_resync
5073 * less than ours. When we find one that is the same or higher
5074 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
5075 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
5076 * This will mean we have to start checking from the beginning again.
5077 *
5078 */
5079
5080 do {
5081 mddev->curr_resync = 2;
5082
5083 try_again:
NeilBrown787453c2005-11-08 21:39:43 -08005084 if (kthread_should_stop()) {
NeilBrown6985c432005-10-19 21:23:47 -07005085 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005086 goto skip;
5087 }
5088 ITERATE_MDDEV(mddev2,tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005089 if (mddev2 == mddev)
5090 continue;
5091 if (mddev2->curr_resync &&
5092 match_mddev_units(mddev,mddev2)) {
5093 DEFINE_WAIT(wq);
5094 if (mddev < mddev2 && mddev->curr_resync == 2) {
5095 /* arbitrarily yield */
5096 mddev->curr_resync = 1;
5097 wake_up(&resync_wait);
5098 }
5099 if (mddev > mddev2 && mddev->curr_resync == 1)
5100 /* no need to wait here, we can wait the next
5101 * time 'round when curr_resync == 2
5102 */
5103 continue;
NeilBrown787453c2005-11-08 21:39:43 -08005104 prepare_to_wait(&resync_wait, &wq, TASK_UNINTERRUPTIBLE);
5105 if (!kthread_should_stop() &&
NeilBrown8712e552005-10-26 01:58:58 -07005106 mddev2->curr_resync >= mddev->curr_resync) {
NeilBrown61df9d92006-10-03 01:15:57 -07005107 printk(KERN_INFO "md: delaying %s of %s"
5108 " until %s has finished (they"
Linus Torvalds1da177e2005-04-16 15:20:36 -07005109 " share one or more physical units)\n",
NeilBrown61df9d92006-10-03 01:15:57 -07005110 desc, mdname(mddev), mdname(mddev2));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005111 mddev_put(mddev2);
5112 schedule();
5113 finish_wait(&resync_wait, &wq);
5114 goto try_again;
5115 }
5116 finish_wait(&resync_wait, &wq);
5117 }
5118 }
5119 } while (mddev->curr_resync < 2);
5120
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005121 j = 0;
NeilBrown9d888832005-11-08 21:39:26 -08005122 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005123 /* resync follows the size requested by the personality,
NeilBrown57afd892005-06-21 17:17:13 -07005124 * which defaults to physical size, but can be virtual size
Linus Torvalds1da177e2005-04-16 15:20:36 -07005125 */
5126 max_sectors = mddev->resync_max_sectors;
NeilBrown9d888832005-11-08 21:39:26 -08005127 mddev->resync_mismatches = 0;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005128 /* we don't use the checkpoint if there's a bitmap */
5129 if (!mddev->bitmap &&
5130 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
5131 j = mddev->recovery_cp;
NeilBrownccfcc3c2006-03-27 01:18:09 -08005132 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5133 max_sectors = mddev->size << 1;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005134 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005135 /* recovery follows the physical size of devices */
5136 max_sectors = mddev->size << 1;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005137 j = MaxSector;
5138 ITERATE_RDEV(mddev,rdev,rtmp)
5139 if (rdev->raid_disk >= 0 &&
5140 !test_bit(Faulty, &rdev->flags) &&
5141 !test_bit(In_sync, &rdev->flags) &&
5142 rdev->recovery_offset < j)
5143 j = rdev->recovery_offset;
5144 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005145
NeilBrown61df9d92006-10-03 01:15:57 -07005146 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
5147 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
5148 " %d KB/sec/disk.\n", speed_min(mddev));
Adrian Bunk338cec32005-09-10 00:26:54 -07005149 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
NeilBrown61df9d92006-10-03 01:15:57 -07005150 "(but not more than %d KB/sec) for %s.\n",
5151 speed_max(mddev), desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005152
5153 is_mddev_idle(mddev); /* this also initializes IO event counters */
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005154
NeilBrown57afd892005-06-21 17:17:13 -07005155 io_sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005156 for (m = 0; m < SYNC_MARKS; m++) {
5157 mark[m] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07005158 mark_cnt[m] = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005159 }
5160 last_mark = 0;
5161 mddev->resync_mark = mark[last_mark];
5162 mddev->resync_mark_cnt = mark_cnt[last_mark];
5163
5164 /*
5165 * Tune reconstruction:
5166 */
5167 window = 32*(PAGE_SIZE/512);
5168 printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
5169 window/2,(unsigned long long) max_sectors/2);
5170
5171 atomic_set(&mddev->recovery_active, 0);
5172 init_waitqueue_head(&mddev->recovery_wait);
5173 last_check = 0;
5174
5175 if (j>2) {
5176 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07005177 "md: resuming %s of %s from checkpoint.\n",
5178 desc, mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005179 mddev->curr_resync = j;
5180 }
5181
5182 while (j < max_sectors) {
NeilBrown57afd892005-06-21 17:17:13 -07005183 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005184
NeilBrown57afd892005-06-21 17:17:13 -07005185 skipped = 0;
5186 sectors = mddev->pers->sync_request(mddev, j, &skipped,
NeilBrown88202a02006-01-06 00:21:36 -08005187 currspeed < speed_min(mddev));
NeilBrown57afd892005-06-21 17:17:13 -07005188 if (sectors == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005189 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
5190 goto out;
5191 }
NeilBrown57afd892005-06-21 17:17:13 -07005192
5193 if (!skipped) { /* actual IO requested */
5194 io_sectors += sectors;
5195 atomic_add(sectors, &mddev->recovery_active);
5196 }
5197
Linus Torvalds1da177e2005-04-16 15:20:36 -07005198 j += sectors;
5199 if (j>1) mddev->curr_resync = j;
NeilBrownff4e8d92006-07-10 04:44:16 -07005200 mddev->curr_mark_cnt = io_sectors;
NeilBrownd7603b72006-01-06 00:20:30 -08005201 if (last_check == 0)
5202 /* this is the earliers that rebuilt will be
5203 * visible in /proc/mdstat
5204 */
5205 md_new_event(mddev);
NeilBrown57afd892005-06-21 17:17:13 -07005206
5207 if (last_check + window > io_sectors || j == max_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005208 continue;
5209
NeilBrown57afd892005-06-21 17:17:13 -07005210 last_check = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005211
5212 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
5213 test_bit(MD_RECOVERY_ERR, &mddev->recovery))
5214 break;
5215
5216 repeat:
5217 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
5218 /* step marks */
5219 int next = (last_mark+1) % SYNC_MARKS;
5220
5221 mddev->resync_mark = mark[next];
5222 mddev->resync_mark_cnt = mark_cnt[next];
5223 mark[next] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07005224 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005225 last_mark = next;
5226 }
5227
5228
NeilBrown787453c2005-11-08 21:39:43 -08005229 if (kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005230 /*
5231 * got a signal, exit.
5232 */
5233 printk(KERN_INFO
5234 "md: md_do_sync() got signal ... exiting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005235 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5236 goto out;
5237 }
5238
5239 /*
5240 * this loop exits only if either when we are slower than
5241 * the 'hard' speed limit, or the system was IO-idle for
5242 * a jiffy.
5243 * the system might be non-idle CPU-wise, but we only care
5244 * about not overloading the IO subsystem. (things like an
5245 * e2fsck being done on the RAID array should execute fast)
5246 */
5247 mddev->queue->unplug_fn(mddev->queue);
5248 cond_resched();
5249
NeilBrown57afd892005-06-21 17:17:13 -07005250 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
5251 /((jiffies-mddev->resync_mark)/HZ +1) +1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005252
NeilBrown88202a02006-01-06 00:21:36 -08005253 if (currspeed > speed_min(mddev)) {
5254 if ((currspeed > speed_max(mddev)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07005255 !is_mddev_idle(mddev)) {
NeilBrownc0e48522005-11-18 01:11:01 -08005256 msleep(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005257 goto repeat;
5258 }
5259 }
5260 }
NeilBrown61df9d92006-10-03 01:15:57 -07005261 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005262 /*
5263 * this also signals 'finished resyncing' to md_stop
5264 */
5265 out:
5266 mddev->queue->unplug_fn(mddev->queue);
5267
5268 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
5269
5270 /* tell personality that we are finished */
NeilBrown57afd892005-06-21 17:17:13 -07005271 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005272
5273 if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
NeilBrownccfcc3c2006-03-27 01:18:09 -08005274 test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
5275 !test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005276 mddev->curr_resync > 2) {
5277 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5278 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
5279 if (mddev->curr_resync >= mddev->recovery_cp) {
5280 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07005281 "md: checkpointing %s of %s.\n",
5282 desc, mdname(mddev));
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005283 mddev->recovery_cp = mddev->curr_resync;
5284 }
5285 } else
5286 mddev->recovery_cp = MaxSector;
5287 } else {
5288 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
5289 mddev->curr_resync = MaxSector;
5290 ITERATE_RDEV(mddev,rdev,rtmp)
5291 if (rdev->raid_disk >= 0 &&
5292 !test_bit(Faulty, &rdev->flags) &&
5293 !test_bit(In_sync, &rdev->flags) &&
5294 rdev->recovery_offset < mddev->curr_resync)
5295 rdev->recovery_offset = mddev->curr_resync;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005297 }
5298
Linus Torvalds1da177e2005-04-16 15:20:36 -07005299 skip:
5300 mddev->curr_resync = 0;
5301 wake_up(&resync_wait);
5302 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
5303 md_wakeup_thread(mddev->thread);
5304}
NeilBrown29269552006-03-27 01:18:10 -08005305EXPORT_SYMBOL_GPL(md_do_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005306
5307
5308/*
5309 * This routine is regularly called by all per-raid-array threads to
5310 * deal with generic issues like resync and super-block update.
5311 * Raid personalities that don't have a thread (linear/raid0) do not
5312 * need this as they never do any recovery or update the superblock.
5313 *
5314 * It does not do any resync itself, but rather "forks" off other threads
5315 * to do that as needed.
5316 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
5317 * "->recovery" and create a thread at ->sync_thread.
5318 * When the thread finishes it sets MD_RECOVERY_DONE (and might set MD_RECOVERY_ERR)
5319 * and wakeups up this thread which will reap the thread and finish up.
5320 * This thread also removes any faulty devices (with nr_pending == 0).
5321 *
5322 * The overall approach is:
5323 * 1/ if the superblock needs updating, update it.
5324 * 2/ If a recovery thread is running, don't do anything else.
5325 * 3/ If recovery has finished, clean up, possibly marking spares active.
5326 * 4/ If there are any faulty devices, remove them.
5327 * 5/ If array is degraded, try to add spares devices
5328 * 6/ If array has spares or is not in-sync, start a resync thread.
5329 */
5330void md_check_recovery(mddev_t *mddev)
5331{
5332 mdk_rdev_t *rdev;
5333 struct list_head *rtmp;
5334
5335
NeilBrown5f404022005-06-21 17:17:16 -07005336 if (mddev->bitmap)
5337 bitmap_daemon_work(mddev->bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005338
5339 if (mddev->ro)
5340 return;
NeilBrownfca4d842005-06-21 17:17:11 -07005341
5342 if (signal_pending(current)) {
5343 if (mddev->pers->sync_request) {
5344 printk(KERN_INFO "md: %s in immediate safe mode\n",
5345 mdname(mddev));
5346 mddev->safemode = 2;
5347 }
5348 flush_signals(current);
5349 }
5350
Linus Torvalds1da177e2005-04-16 15:20:36 -07005351 if ( ! (
NeilBrown850b2b42006-10-03 01:15:46 -07005352 mddev->flags ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07005353 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
NeilBrownfca4d842005-06-21 17:17:11 -07005354 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
5355 (mddev->safemode == 1) ||
5356 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
5357 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005358 ))
5359 return;
NeilBrownfca4d842005-06-21 17:17:11 -07005360
NeilBrowndf5b89b2006-03-27 01:18:20 -08005361 if (mddev_trylock(mddev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005362 int spares =0;
NeilBrownfca4d842005-06-21 17:17:11 -07005363
NeilBrowna9701a32005-11-08 21:39:34 -08005364 spin_lock_irq(&mddev->write_lock);
NeilBrownfca4d842005-06-21 17:17:11 -07005365 if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
5366 !mddev->in_sync && mddev->recovery_cp == MaxSector) {
5367 mddev->in_sync = 1;
NeilBrown850b2b42006-10-03 01:15:46 -07005368 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrownfca4d842005-06-21 17:17:11 -07005369 }
5370 if (mddev->safemode == 1)
5371 mddev->safemode = 0;
NeilBrowna9701a32005-11-08 21:39:34 -08005372 spin_unlock_irq(&mddev->write_lock);
NeilBrownfca4d842005-06-21 17:17:11 -07005373
NeilBrown850b2b42006-10-03 01:15:46 -07005374 if (mddev->flags)
5375 md_update_sb(mddev, 0);
NeilBrown06d91a52005-06-21 17:17:12 -07005376
NeilBrown06d91a52005-06-21 17:17:12 -07005377
Linus Torvalds1da177e2005-04-16 15:20:36 -07005378 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
5379 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
5380 /* resync/recovery still happening */
5381 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5382 goto unlock;
5383 }
5384 if (mddev->sync_thread) {
5385 /* resync has finished, collect result */
5386 md_unregister_thread(mddev->sync_thread);
5387 mddev->sync_thread = NULL;
5388 if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
5389 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
5390 /* success...*/
5391 /* activate any spares */
5392 mddev->pers->spare_active(mddev);
5393 }
NeilBrown850b2b42006-10-03 01:15:46 -07005394 md_update_sb(mddev, 1);
NeilBrown41158c72005-06-21 17:17:25 -07005395
5396 /* if array is no-longer degraded, then any saved_raid_disk
5397 * information must be scrapped
5398 */
5399 if (!mddev->degraded)
5400 ITERATE_RDEV(mddev,rdev,rtmp)
5401 rdev->saved_raid_disk = -1;
5402
Linus Torvalds1da177e2005-04-16 15:20:36 -07005403 mddev->recovery = 0;
5404 /* flag recovery needed just to double check */
5405 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownd7603b72006-01-06 00:20:30 -08005406 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005407 goto unlock;
5408 }
NeilBrown24dd4692005-11-08 21:39:26 -08005409 /* Clear some bits that don't mean anything, but
5410 * might be left set
5411 */
5412 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5413 clear_bit(MD_RECOVERY_ERR, &mddev->recovery);
5414 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
5415 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005416
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005417 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
5418 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005419 /* no recovery is running.
5420 * remove any failed drives, then
5421 * add spares if possible.
5422 * Spare are also removed and re-added, to allow
5423 * the personality to fail the re-add.
5424 */
5425 ITERATE_RDEV(mddev,rdev,rtmp)
5426 if (rdev->raid_disk >= 0 &&
NeilBrownb2d444d2005-11-08 21:39:31 -08005427 (test_bit(Faulty, &rdev->flags) || ! test_bit(In_sync, &rdev->flags)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07005428 atomic_read(&rdev->nr_pending)==0) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08005429 if (mddev->pers->hot_remove_disk(mddev, rdev->raid_disk)==0) {
5430 char nm[20];
5431 sprintf(nm,"rd%d", rdev->raid_disk);
5432 sysfs_remove_link(&mddev->kobj, nm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005433 rdev->raid_disk = -1;
NeilBrown86e6ffd2005-11-08 21:39:24 -08005434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005435 }
5436
5437 if (mddev->degraded) {
5438 ITERATE_RDEV(mddev,rdev,rtmp)
5439 if (rdev->raid_disk < 0
NeilBrownb2d444d2005-11-08 21:39:31 -08005440 && !test_bit(Faulty, &rdev->flags)) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07005441 rdev->recovery_offset = 0;
NeilBrown86e6ffd2005-11-08 21:39:24 -08005442 if (mddev->pers->hot_add_disk(mddev,rdev)) {
5443 char nm[20];
5444 sprintf(nm, "rd%d", rdev->raid_disk);
5445 sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005446 spares++;
NeilBrownd7603b72006-01-06 00:20:30 -08005447 md_new_event(mddev);
NeilBrown86e6ffd2005-11-08 21:39:24 -08005448 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07005449 break;
5450 }
5451 }
5452
NeilBrown24dd4692005-11-08 21:39:26 -08005453 if (spares) {
5454 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5455 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
5456 } else if (mddev->recovery_cp < MaxSector) {
5457 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5458 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
5459 /* nothing to be done ... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005460 goto unlock;
NeilBrown24dd4692005-11-08 21:39:26 -08005461
Linus Torvalds1da177e2005-04-16 15:20:36 -07005462 if (mddev->pers->sync_request) {
5463 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrowna654b9d82005-06-21 17:17:27 -07005464 if (spares && mddev->bitmap && ! mddev->bitmap->file) {
5465 /* We are adding a device or devices to an array
5466 * which has the bitmap stored on all devices.
5467 * So make sure all bitmap pages get written
5468 */
5469 bitmap_write_all(mddev->bitmap);
5470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005471 mddev->sync_thread = md_register_thread(md_do_sync,
5472 mddev,
5473 "%s_resync");
5474 if (!mddev->sync_thread) {
5475 printk(KERN_ERR "%s: could not start resync"
5476 " thread...\n",
5477 mdname(mddev));
5478 /* leave the spares where they are, it shouldn't hurt */
5479 mddev->recovery = 0;
NeilBrownd7603b72006-01-06 00:20:30 -08005480 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07005481 md_wakeup_thread(mddev->sync_thread);
NeilBrownd7603b72006-01-06 00:20:30 -08005482 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005483 }
5484 unlock:
5485 mddev_unlock(mddev);
5486 }
5487}
5488
Adrian Bunk75c96f82005-05-05 16:16:09 -07005489static int md_notify_reboot(struct notifier_block *this,
5490 unsigned long code, void *x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005491{
5492 struct list_head *tmp;
5493 mddev_t *mddev;
5494
5495 if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
5496
5497 printk(KERN_INFO "md: stopping all md devices.\n");
5498
5499 ITERATE_MDDEV(mddev,tmp)
Neil Brownc71d4882006-05-26 10:39:25 +10005500 if (mddev_trylock(mddev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005501 do_md_stop (mddev, 1);
Neil Brownc71d4882006-05-26 10:39:25 +10005502 mddev_unlock(mddev);
5503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005504 /*
5505 * certain more exotic SCSI devices are known to be
5506 * volatile wrt too early system reboots. While the
5507 * right place to handle this issue is the given
5508 * driver, we do want to have a safe RAID driver ...
5509 */
5510 mdelay(1000*1);
5511 }
5512 return NOTIFY_DONE;
5513}
5514
Adrian Bunk75c96f82005-05-05 16:16:09 -07005515static struct notifier_block md_notifier = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005516 .notifier_call = md_notify_reboot,
5517 .next = NULL,
5518 .priority = INT_MAX, /* before any real devices */
5519};
5520
5521static void md_geninit(void)
5522{
5523 struct proc_dir_entry *p;
5524
5525 dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
5526
5527 p = create_proc_entry("mdstat", S_IRUGO, NULL);
5528 if (p)
5529 p->proc_fops = &md_seq_fops;
5530}
5531
Adrian Bunk75c96f82005-05-05 16:16:09 -07005532static int __init md_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005533{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005534 if (register_blkdev(MAJOR_NR, "md"))
5535 return -1;
5536 if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
5537 unregister_blkdev(MAJOR_NR, "md");
5538 return -1;
5539 }
NeilBrowne8703fe2006-10-03 01:15:59 -07005540 blk_register_region(MKDEV(MAJOR_NR, 0), 1UL<<MINORBITS, THIS_MODULE,
5541 md_probe, NULL, NULL);
5542 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005543 md_probe, NULL, NULL);
5544
Linus Torvalds1da177e2005-04-16 15:20:36 -07005545 register_reboot_notifier(&md_notifier);
5546 raid_table_header = register_sysctl_table(raid_root_table, 1);
5547
5548 md_geninit();
5549 return (0);
5550}
5551
5552
5553#ifndef MODULE
5554
5555/*
5556 * Searches all registered partitions for autorun RAID arrays
5557 * at boot time.
5558 */
5559static dev_t detected_devices[128];
5560static int dev_cnt;
5561
5562void md_autodetect_dev(dev_t dev)
5563{
5564 if (dev_cnt >= 0 && dev_cnt < 127)
5565 detected_devices[dev_cnt++] = dev;
5566}
5567
5568
5569static void autostart_arrays(int part)
5570{
5571 mdk_rdev_t *rdev;
5572 int i;
5573
5574 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
5575
5576 for (i = 0; i < dev_cnt; i++) {
5577 dev_t dev = detected_devices[i];
5578
5579 rdev = md_import_device(dev,0, 0);
5580 if (IS_ERR(rdev))
5581 continue;
5582
NeilBrownb2d444d2005-11-08 21:39:31 -08005583 if (test_bit(Faulty, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005584 MD_BUG();
5585 continue;
5586 }
5587 list_add(&rdev->same_set, &pending_raid_disks);
5588 }
5589 dev_cnt = 0;
5590
5591 autorun_devices(part);
5592}
5593
5594#endif
5595
5596static __exit void md_exit(void)
5597{
5598 mddev_t *mddev;
5599 struct list_head *tmp;
Greg Kroah-Hartman8ab5e4c2005-06-20 21:15:16 -07005600
NeilBrowne8703fe2006-10-03 01:15:59 -07005601 blk_unregister_region(MKDEV(MAJOR_NR,0), 1U << MINORBITS);
5602 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005603
5604 unregister_blkdev(MAJOR_NR,"md");
5605 unregister_blkdev(mdp_major, "mdp");
5606 unregister_reboot_notifier(&md_notifier);
5607 unregister_sysctl_table(raid_table_header);
5608 remove_proc_entry("mdstat", NULL);
5609 ITERATE_MDDEV(mddev,tmp) {
5610 struct gendisk *disk = mddev->gendisk;
5611 if (!disk)
5612 continue;
5613 export_array(mddev);
5614 del_gendisk(disk);
5615 put_disk(disk);
5616 mddev->gendisk = NULL;
5617 mddev_put(mddev);
5618 }
5619}
5620
5621module_init(md_init)
5622module_exit(md_exit)
5623
NeilBrownf91de922005-11-08 21:39:36 -08005624static int get_ro(char *buffer, struct kernel_param *kp)
5625{
5626 return sprintf(buffer, "%d", start_readonly);
5627}
5628static int set_ro(const char *val, struct kernel_param *kp)
5629{
5630 char *e;
5631 int num = simple_strtoul(val, &e, 10);
5632 if (*val && (*e == '\0' || *e == '\n')) {
5633 start_readonly = num;
NeilBrown4dbcdc72006-01-06 00:20:52 -08005634 return 0;
NeilBrownf91de922005-11-08 21:39:36 -08005635 }
5636 return -EINVAL;
5637}
5638
NeilBrown80ca3a42006-07-10 04:44:18 -07005639module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
5640module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08005641
NeilBrownf91de922005-11-08 21:39:36 -08005642
Linus Torvalds1da177e2005-04-16 15:20:36 -07005643EXPORT_SYMBOL(register_md_personality);
5644EXPORT_SYMBOL(unregister_md_personality);
5645EXPORT_SYMBOL(md_error);
5646EXPORT_SYMBOL(md_done_sync);
5647EXPORT_SYMBOL(md_write_start);
5648EXPORT_SYMBOL(md_write_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005649EXPORT_SYMBOL(md_register_thread);
5650EXPORT_SYMBOL(md_unregister_thread);
5651EXPORT_SYMBOL(md_wakeup_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005652EXPORT_SYMBOL(md_check_recovery);
5653MODULE_LICENSE("GPL");
NeilBrownaa1595e2005-08-04 12:53:32 -07005654MODULE_ALIAS("md");
NeilBrown72008652005-08-26 18:34:15 -07005655MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);