Lines Matching refs:mddev
95 static inline int speed_min(mddev_t *mddev)
97 return mddev->sync_speed_min ?
98 mddev->sync_speed_min : sysctl_speed_limit_min;
101 static inline int speed_max(mddev_t *mddev)
103 return mddev->sync_speed_max ?
104 mddev->sync_speed_max : sysctl_speed_limit_max;
163 void md_new_event(mddev_t *mddev)
173 static void md_new_event_inintr(mddev_t *mddev)
192 * a reference to the current mddev and must mddev_put it.
194 #define for_each_mddev(mddev,tmp) \
198 mddev = NULL;}); \
202 if (mddev) mddev_put(mddev); \
203 mddev = list_entry(tmp, mddev_t, all_mddevs); \
220 mddev_t *mddev = q->queuedata;
225 if (mddev == NULL || mddev->pers == NULL
226 || !mddev->ready) {
232 if (mddev->suspended || mddev->barrier) {
235 prepare_to_wait(&mddev->sb_wait, &__wait,
237 if (!mddev->suspended && !mddev->barrier)
243 finish_wait(&mddev->sb_wait, &__wait);
245 atomic_inc(&mddev->active_io);
253 rv = mddev->pers->make_request(mddev, bio);
256 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
257 part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
260 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
261 wake_up(&mddev->sb_wait);
272 void mddev_suspend(mddev_t *mddev)
274 BUG_ON(mddev->suspended);
275 mddev->suspended = 1;
277 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
278 mddev->pers->quiesce(mddev, 1);
282 void mddev_resume(mddev_t *mddev)
284 mddev->suspended = 0;
285 wake_up(&mddev->sb_wait);
286 mddev->pers->quiesce(mddev, 0);
290 int mddev_congested(mddev_t *mddev, int bits)
292 if (mddev->barrier)
294 return mddev->suspended;
307 mddev_t *mddev = rdev->mddev;
308 if (err == -EOPNOTSUPP && mddev->barrier != POST_REQUEST_BARRIER)
309 set_bit(BIO_EOPNOTSUPP, &mddev->barrier->bi_flags);
311 rdev_dec_pending(rdev, mddev);
313 if (atomic_dec_and_test(&mddev->flush_pending)) {
314 if (mddev->barrier == POST_REQUEST_BARRIER) {
316 mddev->barrier = NULL;
317 wake_up(&mddev->sb_wait);
320 schedule_work(&mddev->barrier_work);
325 static void submit_barriers(mddev_t *mddev)
330 list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
345 atomic_inc(&mddev->flush_pending);
348 rdev_dec_pending(rdev, mddev);
355 mddev_t *mddev = container_of(ws, mddev_t, barrier_work);
356 struct bio *bio = mddev->barrier;
358 atomic_set(&mddev->flush_pending, 1);
367 if (mddev->pers->make_request(mddev, bio))
369 mddev->barrier = POST_REQUEST_BARRIER;
370 submit_barriers(mddev);
372 if (atomic_dec_and_test(&mddev->flush_pending)) {
373 mddev->barrier = NULL;
374 wake_up(&mddev->sb_wait);
378 void md_barrier_request(mddev_t *mddev, struct bio *bio)
380 spin_lock_irq(&mddev->write_lock);
381 wait_event_lock_irq(mddev->sb_wait,
382 !mddev->barrier,
383 mddev->write_lock, /*nothing*/);
384 mddev->barrier = bio;
385 spin_unlock_irq(&mddev->write_lock);
387 atomic_set(&mddev->flush_pending, 1);
388 INIT_WORK(&mddev->barrier_work, md_submit_barrier);
390 submit_barriers(mddev);
392 if (atomic_dec_and_test(&mddev->flush_pending))
393 schedule_work(&mddev->barrier_work);
442 static inline mddev_t *mddev_get(mddev_t *mddev)
444 atomic_inc(&mddev->active);
445 return mddev;
450 static void mddev_put(mddev_t *mddev)
452 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
454 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
455 mddev->ctime == 0 && !mddev->hold_active) {
458 list_del(&mddev->all_mddevs);
459 if (mddev->gendisk) {
466 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
467 schedule_work(&mddev->del_work);
469 kfree(mddev);
474 void mddev_init(mddev_t *mddev)
476 mutex_init(&mddev->open_mutex);
477 mutex_init(&mddev->reconfig_mutex);
478 mutex_init(&mddev->bitmap_info.mutex);
479 INIT_LIST_HEAD(&mddev->disks);
480 INIT_LIST_HEAD(&mddev->all_mddevs);
481 init_timer(&mddev->safemode_timer);
482 atomic_set(&mddev->active, 1);
483 atomic_set(&mddev->openers, 0);
484 atomic_set(&mddev->active_io, 0);
485 spin_lock_init(&mddev->write_lock);
486 atomic_set(&mddev->flush_pending, 0);
487 init_waitqueue_head(&mddev->sb_wait);
488 init_waitqueue_head(&mddev->recovery_wait);
489 mddev->reshape_position = MaxSector;
490 mddev->resync_min = 0;
491 mddev->resync_max = MaxSector;
492 mddev->level = LEVEL_NONE;
498 mddev_t *mddev, *new = NULL;
504 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
505 if (mddev->unit == unit) {
506 mddev_get(mddev);
509 return mddev;
537 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
538 if (mddev->unit == dev) {
567 static inline int mddev_lock(mddev_t * mddev)
569 return mutex_lock_interruptible(&mddev->reconfig_mutex);
572 static inline int mddev_is_locked(mddev_t *mddev)
574 return mutex_is_locked(&mddev->reconfig_mutex);
577 static inline int mddev_trylock(mddev_t * mddev)
579 return mutex_trylock(&mddev->reconfig_mutex);
584 static void mddev_unlock(mddev_t * mddev)
586 if (mddev->to_remove) {
599 struct attribute_group *to_remove = mddev->to_remove;
600 mddev->to_remove = NULL;
601 mddev->sysfs_active = 1;
602 mutex_unlock(&mddev->reconfig_mutex);
604 if (mddev->kobj.sd) {
606 sysfs_remove_group(&mddev->kobj, to_remove);
607 if (mddev->pers == NULL ||
608 mddev->pers->sync_request == NULL) {
609 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
610 if (mddev->sysfs_action)
611 sysfs_put(mddev->sysfs_action);
612 mddev->sysfs_action = NULL;
615 mddev->sysfs_active = 0;
617 mutex_unlock(&mddev->reconfig_mutex);
619 md_wakeup_thread(mddev->thread);
622 static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
626 list_for_each_entry(rdev, &mddev->disks, same_set)
633 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
637 list_for_each_entry(rdev, &mddev->disks, same_set)
692 mddev_t *mddev = rdev->mddev;
698 md_error(mddev, rdev);
701 if (atomic_dec_and_test(&mddev->pending_writes))
702 wake_up(&mddev->sb_wait);
710 mddev_t *mddev = rdev->mddev;
717 mddev->barriers_work = 0;
718 spin_lock_irqsave(&mddev->write_lock, flags);
719 bio2->bi_next = mddev->biolist;
720 mddev->biolist = bio2;
721 spin_unlock_irqrestore(&mddev->write_lock, flags);
722 wake_up(&mddev->sb_wait);
731 void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
735 * Increment mddev->pending_writes before returning
753 atomic_inc(&mddev->pending_writes);
765 void md_super_wait(mddev_t *mddev)
772 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
773 if (atomic_read(&mddev->pending_writes)==0)
775 while (mddev->biolist) {
777 spin_lock_irq(&mddev->write_lock);
778 bio = mddev->biolist;
779 mddev->biolist = bio->bi_next ;
781 spin_unlock_irq(&mddev->write_lock);
786 finish_wait(&mddev->sb_wait, &wq);
935 * int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
936 * Verify that dev is acceptable into mddev.
937 * The first time, mddev->raid_disks will be 0, and data from
941 * void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
942 * Update the superblock for rdev with data in mddev
952 int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
953 void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
959 * Check that the given mddev has no bitmap.
962 * support bitmaps. It prints an error message and returns non-zero if mddev
966 int md_check_no_bitmap(mddev_t *mddev)
968 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
971 mdname(mddev), mddev->pers->name);
1070 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1082 if (mddev->raid_disks == 0) {
1083 mddev->major_version = 0;
1084 mddev->minor_version = sb->minor_version;
1085 mddev->patch_version = sb->patch_version;
1086 mddev->external = 0;
1087 mddev->chunk_sectors = sb->chunk_size >> 9;
1088 mddev->ctime = sb->ctime;
1089 mddev->utime = sb->utime;
1090 mddev->level = sb->level;
1091 mddev->clevel[0] = 0;
1092 mddev->layout = sb->layout;
1093 mddev->raid_disks = sb->raid_disks;
1094 mddev->dev_sectors = sb->size * 2;
1095 mddev->events = ev1;
1096 mddev->bitmap_info.offset = 0;
1097 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1099 if (mddev->minor_version >= 91) {
1100 mddev->reshape_position = sb->reshape_position;
1101 mddev->delta_disks = sb->delta_disks;
1102 mddev->new_level = sb->new_level;
1103 mddev->new_layout = sb->new_layout;
1104 mddev->new_chunk_sectors = sb->new_chunk >> 9;
1106 mddev->reshape_position = MaxSector;
1107 mddev->delta_disks = 0;
1108 mddev->new_level = mddev->level;
1109 mddev->new_layout = mddev->layout;
1110 mddev->new_chunk_sectors = mddev->chunk_sectors;
1114 mddev->recovery_cp = MaxSector;
1118 mddev->recovery_cp = sb->recovery_cp;
1120 mddev->recovery_cp = 0;
1123 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1124 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1125 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1126 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1128 mddev->max_disks = MD_SB_DISKS;
1131 mddev->bitmap_info.file == NULL)
1132 mddev->bitmap_info.offset =
1133 mddev->bitmap_info.default_offset;
1135 } else if (mddev->pers == NULL) {
1141 if (ev1 < mddev->events)
1143 } else if (mddev->bitmap) {
1147 if (ev1 < mddev->bitmap->events_cleared)
1150 if (ev1 < mddev->events)
1155 if (mddev->level != LEVEL_MULTIPATH) {
1161 desc->raid_disk < mddev->raid_disks */) {
1168 if (mddev->minor_version >= 91) {
1183 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1187 int next_spare = mddev->raid_disks;
1190 /* make rdev->sb match mddev data..
1210 sb->major_version = mddev->major_version;
1211 sb->patch_version = mddev->patch_version;
1213 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1214 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1215 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1216 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1218 sb->ctime = mddev->ctime;
1219 sb->level = mddev->level;
1220 sb->size = mddev->dev_sectors / 2;
1221 sb->raid_disks = mddev->raid_disks;
1222 sb->md_minor = mddev->md_minor;
1224 sb->utime = mddev->utime;
1226 sb->events_hi = (mddev->events>>32);
1227 sb->events_lo = (u32)mddev->events;
1229 if (mddev->reshape_position == MaxSector)
1233 sb->reshape_position = mddev->reshape_position;
1234 sb->new_level = mddev->new_level;
1235 sb->delta_disks = mddev->delta_disks;
1236 sb->new_layout = mddev->new_layout;
1237 sb->new_chunk = mddev->new_chunk_sectors << 9;
1239 mddev->minor_version = sb->minor_version;
1240 if (mddev->in_sync)
1242 sb->recovery_cp = mddev->recovery_cp;
1243 sb->cp_events_hi = (mddev->events>>32);
1244 sb->cp_events_lo = (u32)mddev->events;
1245 if (mddev->recovery_cp == MaxSector)
1250 sb->layout = mddev->layout;
1251 sb->chunk_size = mddev->chunk_sectors << 9;
1253 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1257 list_for_each_entry(rdev2, &mddev->disks, same_set) {
1303 for (i=0 ; i < mddev->raid_disks ; i++) {
1329 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1331 if (rdev->mddev->bitmap_info.offset)
1336 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1338 md_super_wait(rdev->mddev);
1486 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1497 if (mddev->raid_disks == 0) {
1498 mddev->major_version = 1;
1499 mddev->patch_version = 0;
1500 mddev->external = 0;
1501 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
1502 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1503 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1504 mddev->level = le32_to_cpu(sb->level);
1505 mddev->clevel[0] = 0;
1506 mddev->layout = le32_to_cpu(sb->layout);
1507 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1508 mddev->dev_sectors = le64_to_cpu(sb->size);
1509 mddev->events = ev1;
1510 mddev->bitmap_info.offset = 0;
1511 mddev->bitmap_info.default_offset = 1024 >> 9;
1513 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1514 memcpy(mddev->uuid, sb->set_uuid, 16);
1516 mddev->max_disks = (4096-256)/2;
1519 mddev->bitmap_info.file == NULL )
1520 mddev->bitmap_info.offset =
1524 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1525 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1526 mddev->new_level = le32_to_cpu(sb->new_level);
1527 mddev->new_layout = le32_to_cpu(sb->new_layout);
1528 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1530 mddev->reshape_position = MaxSector;
1531 mddev->delta_disks = 0;
1532 mddev->new_level = mddev->level;
1533 mddev->new_layout = mddev->layout;
1534 mddev->new_chunk_sectors = mddev->chunk_sectors;
1537 } else if (mddev->pers == NULL) {
1544 if (ev1 < mddev->events)
1546 } else if (mddev->bitmap) {
1550 if (ev1 < mddev->bitmap->events_cleared)
1553 if (ev1 < mddev->events)
1557 if (mddev->level != LEVEL_MULTIPATH) {
1588 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1593 /* make rdev->sb match mddev and rdev data. */
1604 sb->utime = cpu_to_le64((__u64)mddev->utime);
1605 sb->events = cpu_to_le64(mddev->events);
1606 if (mddev->in_sync)
1607 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1613 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1614 sb->size = cpu_to_le64(mddev->dev_sectors);
1615 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1616 sb->level = cpu_to_le32(mddev->level);
1617 sb->layout = cpu_to_le32(mddev->layout);
1619 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1620 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1632 if (mddev->reshape_position != MaxSector) {
1634 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1635 sb->new_layout = cpu_to_le32(mddev->new_layout);
1636 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1637 sb->new_level = cpu_to_le32(mddev->new_level);
1638 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1642 list_for_each_entry(rdev2, &mddev->disks, same_set)
1659 list_for_each_entry(rdev2, &mddev->disks, same_set) {
1679 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1687 } else if (rdev->mddev->bitmap_info.offset) {
1704 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1706 md_super_wait(rdev->mddev);
1748 * Try to register data integrity profile for an mddev
1754 int md_integrity_register(mddev_t *mddev)
1758 if (list_empty(&mddev->disks))
1760 if (blk_get_integrity(mddev->gendisk))
1762 list_for_each_entry(rdev, &mddev->disks, same_set) {
1788 if (blk_integrity_register(mddev->gendisk,
1791 mdname(mddev));
1795 mdname(mddev));
1801 void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
1804 struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
1810 if (bi_rdev && blk_integrity_compare(mddev->gendisk,
1813 printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
1814 blk_integrity_unregister(mddev->gendisk);
1818 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1825 if (rdev->mddev) {
1831 if (find_rdev(mddev, rdev->bdev->bd_dev))
1834 /* make sure rdev->sectors exceeds mddev->dev_sectors */
1835 if (rdev->sectors && (mddev->dev_sectors == 0 ||
1836 rdev->sectors < mddev->dev_sectors)) {
1837 if (mddev->pers) {
1839 * If mddev->level <= 0, then we don't care
1842 if (mddev->level > 0)
1845 mddev->dev_sectors = rdev->sectors;
1854 if (mddev->pers) choice = mddev->raid_disks;
1855 while (find_rdev_nr(mddev, choice))
1859 if (find_rdev_nr(mddev, rdev->desc_nr))
1862 if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
1864 mdname(mddev), mddev->max_disks);
1871 rdev->mddev = mddev;
1874 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
1882 list_add_rcu(&rdev->same_set, &mddev->disks);
1883 bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
1886 mddev->recovery_disabled = 0;
1892 b, mdname(mddev));
1906 if (!rdev->mddev) {
1910 bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1913 rdev->mddev = NULL;
1974 if (rdev->mddev)
1991 static void export_array(mddev_t *mddev)
1995 rdev_for_each(rdev, tmp, mddev) {
1996 if (!rdev->mddev) {
2002 if (!list_empty(&mddev->disks))
2004 mddev->raid_disks = 0;
2005 mddev->major_version = 0;
2114 mddev_t *mddev;
2121 for_each_mddev(mddev, tmp) {
2123 if (mddev->bitmap)
2124 bitmap_print_sb(mddev->bitmap);
2126 printk("%s: ", mdname(mddev));
2127 list_for_each_entry(rdev, &mddev->disks, same_set)
2131 list_for_each_entry(rdev, &mddev->disks, same_set)
2132 print_rdev(rdev, mddev->major_version);
2139 static void sync_sbs(mddev_t * mddev, int nospares)
2148 list_for_each_entry(rdev, &mddev->disks, same_set) {
2149 if (rdev->sb_events == mddev->events ||
2152 rdev->sb_events+1 == mddev->events)) {
2156 super_types[mddev->major_version].
2157 sync_super(mddev, rdev);
2163 static void md_update_sb(mddev_t * mddev, int force_change)
2171 list_for_each_entry(rdev, &mddev->disks, same_set) {
2173 mddev->delta_disks >= 0 &&
2175 mddev->curr_resync_completed > rdev->recovery_offset)
2176 rdev->recovery_offset = mddev->curr_resync_completed;
2179 if (!mddev->persistent) {
2180 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2181 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2182 if (!mddev->external)
2183 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2184 wake_up(&mddev->sb_wait);
2188 spin_lock_irq(&mddev->write_lock);
2190 mddev->utime = get_seconds();
2192 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2194 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2202 if (mddev->degraded)
2214 sync_req = mddev->in_sync;
2219 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2220 && mddev->can_decrease_events
2221 && mddev->events != 1) {
2222 mddev->events--;
2223 mddev->can_decrease_events = 0;
2226 mddev->events ++;
2227 mddev->can_decrease_events = nospares;
2230 if (!mddev->events) {
2237 mddev->events --;
2239 sync_sbs(mddev, nospares);
2240 spin_unlock_irq(&mddev->write_lock);
2244 mdname(mddev),mddev->in_sync);
2246 bitmap_update_sb(mddev->bitmap);
2247 list_for_each_entry(rdev, &mddev->disks, same_set) {
2257 md_super_write(mddev,rdev,
2263 rdev->sb_events = mddev->events;
2267 if (mddev->level == LEVEL_MULTIPATH)
2271 md_super_wait(mddev);
2274 spin_lock_irq(&mddev->write_lock);
2275 if (mddev->in_sync != sync_req ||
2276 test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2278 spin_unlock_irq(&mddev->write_lock);
2281 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2282 spin_unlock_irq(&mddev->write_lock);
2283 wake_up(&mddev->sb_wait);
2284 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2285 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2358 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2359 md_error(rdev->mddev, rdev);
2365 mddev_t *mddev = rdev->mddev;
2367 if (mddev->pers)
2368 md_update_sb(mddev, 1);
2369 md_new_event(mddev);
2384 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2385 md_wakeup_thread(rdev->mddev->thread);
2439 if (rdev->mddev->pers && slot == -1) {
2450 if (rdev->mddev->pers->hot_add_disk == NULL)
2452 err = rdev->mddev->pers->
2453 hot_remove_disk(rdev->mddev, rdev->raid_disk);
2457 sysfs_remove_link(&rdev->mddev->kobj, nm);
2459 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2460 md_wakeup_thread(rdev->mddev->thread);
2461 } else if (rdev->mddev->pers) {
2470 if (rdev->mddev->pers->hot_add_disk == NULL)
2473 list_for_each_entry(rdev2, &rdev->mddev->disks, same_set)
2482 err = rdev->mddev->pers->
2483 hot_add_disk(rdev->mddev, rdev);
2490 if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
2494 if (slot >= rdev->mddev->raid_disks)
2523 if (rdev->mddev->pers && rdev->raid_disk >= 0)
2525 if (rdev->sectors && rdev->mddev->external)
2574 mddev_t *my_mddev = rdev->mddev;
2596 * do not overlap. We need to unlock the mddev to avoid
2600 mddev_t *mddev;
2605 for_each_mddev(mddev, tmp) {
2608 mddev_lock(mddev);
2609 list_for_each_entry(rdev2, &mddev->disks, same_set)
2619 mddev_unlock(mddev);
2621 mddev_put(mddev);
2664 if (rdev->mddev->pers &&
2693 mddev_t *mddev = rdev->mddev;
2699 rv = mddev ? mddev_lock(mddev) : -EBUSY;
2701 if (rdev->mddev == NULL)
2705 mddev_unlock(mddev);
2717 mddev_t *mddev = rdev->mddev;
2723 rv = mddev ? mddev_lock(mddev): -EBUSY;
2725 if (rdev->mddev == NULL)
2729 mddev_unlock(mddev);
2845 static void analyze_sbs(mddev_t * mddev)
2852 rdev_for_each(rdev, tmp, mddev)
2853 switch (super_types[mddev->major_version].
2854 load_super(rdev, freshest, mddev->minor_version)) {
2869 super_types[mddev->major_version].
2870 validate_super(mddev, freshest);
2873 rdev_for_each(rdev, tmp, mddev) {
2874 if (mddev->max_disks &&
2875 (rdev->desc_nr >= mddev->max_disks ||
2876 i > mddev->max_disks)) {
2879 mdname(mddev), bdevname(rdev->bdev, b),
2880 mddev->max_disks);
2885 if (super_types[mddev->major_version].
2886 validate_super(mddev, rdev)) {
2893 if (mddev->level == LEVEL_MULTIPATH) {
2897 } else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
2948 safe_delay_show(mddev_t *mddev, char *page)
2950 int msec = (mddev->safemode_delay*1000)/HZ;
2954 safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
2961 mddev->safemode_delay = 0;
2963 unsigned long old_delay = mddev->safemode_delay;
2964 mddev->safemode_delay = (msec*HZ)/1000;
2965 if (mddev->safemode_delay == 0)
2966 mddev->safemode_delay = 1;
2967 if (mddev->safemode_delay < old_delay)
2968 md_safemode_timeout((unsigned long)mddev);
2976 level_show(mddev_t *mddev, char *page)
2978 struct mdk_personality *p = mddev->pers;
2981 else if (mddev->clevel[0])
2982 return sprintf(page, "%s\n", mddev->clevel);
2983 else if (mddev->level != LEVEL_NONE)
2984 return sprintf(page, "%d\n", mddev->level);
2990 level_store(mddev_t *mddev, const char *buf, size_t len)
2999 if (mddev->pers == NULL) {
3002 if (len >= sizeof(mddev->clevel))
3004 strncpy(mddev->clevel, buf, len);
3005 if (mddev->clevel[len-1] == '\n')
3007 mddev->clevel[len] = 0;
3008 mddev->level = LEVEL_NONE;
3018 if (mddev->sync_thread ||
3019 mddev->reshape_position != MaxSector ||
3020 mddev->sysfs_active)
3023 if (!mddev->pers->quiesce) {
3025 mdname(mddev), mddev->pers->name);
3050 if (pers == mddev->pers) {
3058 mdname(mddev), clevel);
3062 list_for_each_entry(rdev, &mddev->disks, same_set)
3068 priv = pers->takeover(mddev);
3070 mddev->new_level = mddev->level;
3071 mddev->new_layout = mddev->layout;
3072 mddev->new_chunk_sectors = mddev->chunk_sectors;
3073 mddev->raid_disks -= mddev->delta_disks;
3074 mddev->delta_disks = 0;
3077 mdname(mddev), clevel);
3082 mddev_suspend(mddev);
3083 mddev->pers->stop(mddev);
3085 if (mddev->pers->sync_request == NULL &&
3088 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3091 mdname(mddev));
3092 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
3094 if (mddev->pers->sync_request != NULL &&
3097 if (mddev->to_remove == NULL)
3098 mddev->to_remove = &md_redundancy_group;
3101 if (mddev->pers->sync_request == NULL &&
3102 mddev->external) {
3110 mddev->in_sync = 0;
3111 mddev->safemode_delay = 0;
3112 mddev->safemode = 0;
3115 list_for_each_entry(rdev, &mddev->disks, same_set) {
3119 if (rdev->new_raid_disk >= mddev->raid_disks)
3124 sysfs_remove_link(&mddev->kobj, nm);
3126 list_for_each_entry(rdev, &mddev->disks, same_set) {
3137 if(sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
3139 nm, mdname(mddev));
3143 module_put(mddev->pers->owner);
3144 mddev->pers = pers;
3145 mddev->private = priv;
3146 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3147 mddev->level = mddev->new_level;
3148 mddev->layout = mddev->new_layout;
3149 mddev->chunk_sectors = mddev->new_chunk_sectors;
3150 mddev->delta_disks = 0;
3151 if (mddev->pers->sync_request == NULL) {
3155 mddev->in_sync = 1;
3156 del_timer_sync(&mddev->safemode_timer);
3158 pers->run(mddev);
3159 mddev_resume(mddev);
3160 set_bit(MD_CHANGE_DEVS, &mddev->flags);
3161 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3162 md_wakeup_thread(mddev->thread);
3163 sysfs_notify(&mddev->kobj, NULL, "level");
3164 md_new_event(mddev);
3173 layout_show(mddev_t *mddev, char *page)
3176 if (mddev->reshape_position != MaxSector &&
3177 mddev->layout != mddev->new_layout)
3179 mddev->new_layout, mddev->layout);
3180 return sprintf(page, "%d\n", mddev->layout);
3184 layout_store(mddev_t *mddev, const char *buf, size_t len)
3192 if (mddev->pers) {
3194 if (mddev->pers->check_reshape == NULL)
3196 mddev->new_layout = n;
3197 err = mddev->pers->check_reshape(mddev);
3199 mddev->new_layout = mddev->layout;
3203 mddev->new_layout = n;
3204 if (mddev->reshape_position == MaxSector)
3205 mddev->layout = n;
3214 raid_disks_show(mddev_t *mddev, char *page)
3216 if (mddev->raid_disks == 0)
3218 if (mddev->reshape_position != MaxSector &&
3219 mddev->delta_disks != 0)
3220 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3221 mddev->raid_disks - mddev->delta_disks);
3222 return sprintf(page, "%d\n", mddev->raid_disks);
3225 static int update_raid_disks(mddev_t *mddev, int raid_disks);
3228 raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
3237 if (mddev->pers)
3238 rv = update_raid_disks(mddev, n);
3239 else if (mddev->reshape_position != MaxSector) {
3240 int olddisks = mddev->raid_disks - mddev->delta_disks;
3241 mddev->delta_disks = n - olddisks;
3242 mddev->raid_disks = n;
3244 mddev->raid_disks = n;
3251 chunk_size_show(mddev_t *mddev, char *page)
3253 if (mddev->reshape_position != MaxSector &&
3254 mddev->chunk_sectors != mddev->new_chunk_sectors)
3256 mddev->new_chunk_sectors << 9,
3257 mddev->chunk_sectors << 9);
3258 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3262 chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
3270 if (mddev->pers) {
3272 if (mddev->pers->check_reshape == NULL)
3274 mddev->new_chunk_sectors = n >> 9;
3275 err = mddev->pers->check_reshape(mddev);
3277 mddev->new_chunk_sectors = mddev->chunk_sectors;
3281 mddev->new_chunk_sectors = n >> 9;
3282 if (mddev->reshape_position == MaxSector)
3283 mddev->chunk_sectors = n >> 9;
3291 resync_start_show(mddev_t *mddev, char *page)
3293 if (mddev->recovery_cp == MaxSector)
3295 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3299 resync_start_store(mddev_t *mddev, const char *buf, size_t len)
3304 if (mddev->pers)
3311 mddev->recovery_cp = n;
3369 array_state_show(mddev_t *mddev, char *page)
3373 if (mddev->pers)
3374 switch(mddev->ro) {
3382 if (mddev->in_sync)
3384 else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3386 else if (mddev->safemode)
3392 if (list_empty(&mddev->disks) &&
3393 mddev->raid_disks == 0 &&
3394 mddev->dev_sectors == 0)
3402 static int do_md_stop(mddev_t * mddev, int ro, int is_open);
3403 static int md_set_readonly(mddev_t * mddev, int is_open);
3404 static int do_md_run(mddev_t * mddev);
3405 static int restart_array(mddev_t *mddev);
3408 array_state_store(mddev_t *mddev, const char *buf, size_t len)
3417 if (atomic_read(&mddev->openers) > 0)
3419 err = do_md_stop(mddev, 0, 0);
3423 if (mddev->pers) {
3424 if (atomic_read(&mddev->openers) > 0)
3426 err = do_md_stop(mddev, 2, 0);
3433 if (mddev->pers)
3434 err = md_set_readonly(mddev, 0);
3436 mddev->ro = 1;
3437 set_disk_ro(mddev->gendisk, 1);
3438 err = do_md_run(mddev);
3442 if (mddev->pers) {
3443 if (mddev->ro == 0)
3444 err = md_set_readonly(mddev, 0);
3445 else if (mddev->ro == 1)
3446 err = restart_array(mddev);
3448 mddev->ro = 2;
3449 set_disk_ro(mddev->gendisk, 0);
3452 mddev->ro = 2;
3453 err = do_md_run(mddev);
3457 if (mddev->pers) {
3458 restart_array(mddev);
3459 spin_lock_irq(&mddev->write_lock);
3460 if (atomic_read(&mddev->writes_pending) == 0) {
3461 if (mddev->in_sync == 0) {
3462 mddev->in_sync = 1;
3463 if (mddev->safemode == 1)
3464 mddev->safemode = 0;
3465 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3470 spin_unlock_irq(&mddev->write_lock);
3475 if (mddev->pers) {
3476 restart_array(mddev);
3477 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3478 wake_up(&mddev->sb_wait);
3481 mddev->ro = 0;
3482 set_disk_ro(mddev->gendisk, 0);
3483 err = do_md_run(mddev);
3494 sysfs_notify_dirent_safe(mddev->sysfs_state);
3502 max_corrected_read_errors_show(mddev_t *mddev, char *page) {
3504 atomic_read(&mddev->max_corr_read_errors));
3508 max_corrected_read_errors_store(mddev_t *mddev, const char *buf, size_t len)
3514 atomic_set(&mddev->max_corr_read_errors, n);
3525 null_show(mddev_t *mddev, char *page)
3531 new_dev_store(mddev_t *mddev, const char *buf, size_t len)
3558 if (mddev->persistent) {
3559 rdev = md_import_device(dev, mddev->major_version,
3560 mddev->minor_version);
3561 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
3562 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
3564 err = super_types[mddev->major_version]
3565 .load_super(rdev, rdev0, mddev->minor_version);
3569 } else if (mddev->external)
3576 err = bind_rdev_to_array(rdev, mddev);
3587 bitmap_store(mddev_t *mddev, const char *buf, size_t len)
3592 if (!mddev->bitmap)
3604 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
3607 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
3616 size_show(mddev_t *mddev, char *page)
3619 (unsigned long long)mddev->dev_sectors / 2);
3622 static int update_size(mddev_t *mddev, sector_t num_sectors);
3625 size_store(mddev_t *mddev, const char *buf, size_t len)
3636 if (mddev->pers) {
3637 err = update_size(mddev, sectors);
3638 md_update_sb(mddev, 1);
3640 if (mddev->dev_sectors == 0 ||
3641 mddev->dev_sectors > sectors)
3642 mddev->dev_sectors = sectors;
3660 metadata_show(mddev_t *mddev, char *page)
3662 if (mddev->persistent)
3664 mddev->major_version, mddev->minor_version);
3665 else if (mddev->external)
3666 return sprintf(page, "external:%s\n", mddev->metadata_type);
3672 metadata_store(mddev_t *mddev, const char *buf, size_t len)
3680 if (mddev->external && strncmp(buf, "external:", 9) == 0)
3682 else if (!list_empty(&mddev->disks))
3686 mddev->persistent = 0;
3687 mddev->external = 0;
3688 mddev->major_version = 0;
3689 mddev->minor_version = 90;
3694 if (namelen >= sizeof(mddev->metadata_type))
3695 namelen = sizeof(mddev->metadata_type)-1;
3696 strncpy(mddev->metadata_type, buf+9, namelen);
3697 mddev->metadata_type[namelen] = 0;
3698 if (namelen && mddev->metadata_type[namelen-1] == '\n')
3699 mddev->metadata_type[--namelen] = 0;
3700 mddev->persistent = 0;
3701 mddev->external = 1;
3702 mddev->major_version = 0;
3703 mddev->minor_version = 90;
3715 mddev->major_version = major;
3716 mddev->minor_version = minor;
3717 mddev->persistent = 1;
3718 mddev->external = 0;
3726 action_show(mddev_t *mddev, char *page)
3729 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
3731 else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3732 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
3733 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
3735 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
3736 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
3738 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
3742 } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
3749 action_store(mddev_t *mddev, const char *page, size_t len)
3751 if (!mddev->pers || !mddev->pers->sync_request)
3755 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3757 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3760 if (mddev->sync_thread) {
3761 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3762 md_unregister_thread(mddev->sync_thread);
3763 mddev->sync_thread = NULL;
3764 mddev->recovery = 0;
3766 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3767 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
3770 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3772 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
3773 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3776 if (mddev->pers->start_reshape == NULL)
3778 err = mddev->pers->start_reshape(mddev);
3781 sysfs_notify(&mddev->kobj, NULL, "degraded");
3784 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
3787 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
3788 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
3790 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3791 md_wakeup_thread(mddev->thread);
3792 sysfs_notify_dirent_safe(mddev->sysfs_action);
3797 mismatch_cnt_show(mddev_t *mddev, char *page)
3800 (unsigned long long) mddev->resync_mismatches);
3810 sync_min_show(mddev_t *mddev, char *page)
3812 return sprintf(page, "%d (%s)\n", speed_min(mddev),
3813 mddev->sync_speed_min ? "local": "system");
3817 sync_min_store(mddev_t *mddev, const char *buf, size_t len)
3822 mddev->sync_speed_min = 0;
3828 mddev->sync_speed_min = min;
3836 sync_max_show(mddev_t *mddev, char *page)
3838 return sprintf(page, "%d (%s)\n", speed_max(mddev),
3839 mddev->sync_speed_max ? "local": "system");
3843 sync_max_store(mddev_t *mddev, const char *buf, size_t len)
3848 mddev->sync_speed_max = 0;
3854 mddev->sync_speed_max = max;
3862 degraded_show(mddev_t *mddev, char *page)
3864 return sprintf(page, "%d\n", mddev->degraded);
3869 sync_force_parallel_show(mddev_t *mddev, char *page)
3871 return sprintf(page, "%d\n", mddev->parallel_resync);
3875 sync_force_parallel_store(mddev_t *mddev, const char *buf, size_t len)
3885 mddev->parallel_resync = n;
3887 if (mddev->sync_thread)
3899 sync_speed_show(mddev_t *mddev, char *page)
3902 if (mddev->curr_resync == 0)
3904 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
3905 dt = (jiffies - mddev->resync_mark) / HZ;
3907 db = resync - mddev->resync_mark_cnt;
3914 sync_completed_show(mddev_t *mddev, char *page)
3918 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
3921 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
3922 max_sectors = mddev->resync_max_sectors;
3924 max_sectors = mddev->dev_sectors;
3926 resync = mddev->curr_resync_completed;
3933 min_sync_show(mddev_t *mddev, char *page)
3936 (unsigned long long)mddev->resync_min);
3939 min_sync_store(mddev_t *mddev, const char *buf, size_t len)
3944 if (min > mddev->resync_max)
3946 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
3950 if (mddev->chunk_sectors) {
3952 if (sector_div(temp, mddev->chunk_sectors))
3955 mddev->resync_min = min;
3964 max_sync_show(mddev_t *mddev, char *page)
3966 if (mddev->resync_max == MaxSector)
3970 (unsigned long long)mddev->resync_max);
3973 max_sync_store(mddev_t *mddev, const char *buf, size_t len)
3976 mddev->resync_max = MaxSector;
3981 if (max < mddev->resync_min)
3983 if (max < mddev->resync_max &&
3984 mddev->ro == 0 &&
3985 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
3989 if (mddev->chunk_sectors) {
3991 if (sector_div(temp, mddev->chunk_sectors))
3994 mddev->resync_max = max;
3996 wake_up(&mddev->recovery_wait);
4004 suspend_lo_show(mddev_t *mddev, char *page)
4006 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4010 suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
4015 if (mddev->pers == NULL ||
4016 mddev->pers->quiesce == NULL)
4020 if (new >= mddev->suspend_hi ||
4021 (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
4022 mddev->suspend_lo = new;
4023 mddev->pers->quiesce(mddev, 2);
4033 suspend_hi_show(mddev_t *mddev, char *page)
4035 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4039 suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
4044 if (mddev->pers == NULL ||
4045 mddev->pers->quiesce == NULL)
4049 if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
4050 (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
4051 mddev->suspend_hi = new;
4052 mddev->pers->quiesce(mddev, 1);
4053 mddev->pers->quiesce(mddev, 0);
4062 reshape_position_show(mddev_t *mddev, char *page)
4064 if (mddev->reshape_position != MaxSector)
4066 (unsigned long long)mddev->reshape_position);
4072 reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
4076 if (mddev->pers)
4080 mddev->reshape_position = new;
4081 mddev->delta_disks = 0;
4082 mddev->new_level = mddev->level;
4083 mddev->new_layout = mddev->layout;
4084 mddev->new_chunk_sectors = mddev->chunk_sectors;
4093 array_size_show(mddev_t *mddev, char *page)
4095 if (mddev->external_size)
4097 (unsigned long long)mddev->array_sectors/2);
4103 array_size_store(mddev_t *mddev, const char *buf, size_t len)
4108 if (mddev->pers)
4109 sectors = mddev->pers->size(mddev, 0, 0);
4111 sectors = mddev->array_sectors;
4113 mddev->external_size = 0;
4117 if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4120 mddev->external_size = 1;
4123 mddev->array_sectors = sectors;
4124 set_capacity(mddev->gendisk, mddev->array_sectors);
4125 if (mddev->pers)
4126 revalidate_disk(mddev->gendisk);
4178 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
4183 rv = mddev_lock(mddev);
4185 rv = entry->show(mddev, page);
4186 mddev_unlock(mddev);
4196 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
4203 rv = mddev_lock(mddev);
4204 if (mddev->hold_active == UNTIL_IOCTL)
4205 mddev->hold_active = 0;
4207 rv = entry->store(mddev, page, length);
4208 mddev_unlock(mddev);
4215 mddev_t *mddev = container_of(ko, mddev_t, kobj);
4217 if (mddev->sysfs_state)
4218 sysfs_put(mddev->sysfs_state);
4220 if (mddev->gendisk) {
4221 del_gendisk(mddev->gendisk);
4222 put_disk(mddev->gendisk);
4224 if (mddev->queue)
4225 blk_cleanup_queue(mddev->queue);
4227 kfree(mddev);
4244 mddev_t *mddev = container_of(ws, mddev_t, del_work);
4246 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4247 kobject_del(&mddev->kobj);
4248 kobject_put(&mddev->kobj);
4254 mddev_t *mddev = mddev_find(dev);
4261 if (!mddev)
4264 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4266 unit = MINOR(mddev->unit) >> shift;
4275 if (mddev->gendisk)
4294 mddev->queue = blk_alloc_queue(GFP_KERNEL);
4295 if (!mddev->queue)
4297 mddev->queue->queuedata = mddev;
4299 blk_queue_make_request(mddev->queue, md_make_request);
4303 blk_cleanup_queue(mddev->queue);
4304 mddev->queue = NULL;
4307 disk->major = MAJOR(mddev->unit);
4316 disk->private_data = mddev;
4317 disk->queue = mddev->queue;
4324 mddev->gendisk = disk;
4325 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
4335 if (mddev->kobj.sd &&
4336 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4340 if (!error && mddev->kobj.sd) {
4341 kobject_uevent(&mddev->kobj, KOBJ_ADD);
4342 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4344 mddev_put(mddev);
4375 mddev_t *mddev = (mddev_t *) data;
4377 if (!atomic_read(&mddev->writes_pending)) {
4378 mddev->safemode = 1;
4379 if (mddev->external)
4380 sysfs_notify_dirent_safe(mddev->sysfs_state);
4382 md_wakeup_thread(mddev->thread);
4387 int md_run(mddev_t *mddev)
4393 if (list_empty(&mddev->disks))
4397 if (mddev->pers)
4400 if (mddev->sysfs_active)
4406 if (!mddev->raid_disks) {
4407 if (!mddev->persistent)
4409 analyze_sbs(mddev);
4412 if (mddev->level != LEVEL_NONE)
4413 request_module("md-level-%d", mddev->level);
4414 else if (mddev->clevel[0])
4415 request_module("md-%s", mddev->clevel);
4422 list_for_each_entry(rdev, &mddev->disks, same_set) {
4433 if (mddev->dev_sectors &&
4434 rdev->data_offset + mddev->dev_sectors
4437 mdname(mddev));
4444 mdname(mddev));
4452 pers = find_pers(mddev->level, mddev->clevel);
4455 if (mddev->level != LEVEL_NONE)
4457 mddev->level);
4460 mddev->clevel);
4463 mddev->pers = pers;
4465 if (mddev->level != pers->level) {
4466 mddev->level = pers->level;
4467 mddev->new_level = pers->level;
4469 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
4471 if (mddev->reshape_position != MaxSector &&
4474 mddev->pers = NULL;
4487 list_for_each_entry(rdev, &mddev->disks, same_set)
4488 list_for_each_entry(rdev2, &mddev->disks, same_set) {
4496 mdname(mddev),
4509 mddev->recovery = 0;
4511 mddev->resync_max_sectors = mddev->dev_sectors;
4513 mddev->barriers_work = 1;
4514 mddev->ok_start_degraded = start_dirty_degraded;
4516 if (start_readonly && mddev->ro == 0)
4517 mddev->ro = 2; /* read-only, but switch on first write */
4519 err = mddev->pers->run(mddev);
4522 else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) {
4523 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
4527 (unsigned long long)mddev->array_sectors / 2,
4528 (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2);
4530 mddev->pers->stop(mddev);
4532 if (err == 0 && mddev->pers->sync_request) {
4533 err = bitmap_create(mddev);
4536 mdname(mddev), err);
4537 mddev->pers->stop(mddev);
4541 module_put(mddev->pers->owner);
4542 mddev->pers = NULL;
4543 bitmap_destroy(mddev);
4546 if (mddev->pers->sync_request) {
4547 if (mddev->kobj.sd &&
4548 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
4551 mdname(mddev));
4552 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
4553 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
4554 mddev->ro = 0;
4556 atomic_set(&mddev->writes_pending,0);
4557 atomic_set(&mddev->max_corr_read_errors,
4559 mddev->safemode = 0;
4560 mddev->safemode_timer.function = md_safemode_timeout;
4561 mddev->safemode_timer.data = (unsigned long) mddev;
4562 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
4563 mddev->in_sync = 1;
4565 mddev->ready = 1;
4566 list_for_each_entry(rdev, &mddev->disks, same_set)
4570 if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
4574 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4576 if (mddev->flags)
4577 md_update_sb(mddev, 0);
4579 md_wakeup_thread(mddev->thread);
4580 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
4582 md_new_event(mddev);
4583 sysfs_notify_dirent_safe(mddev->sysfs_state);
4584 sysfs_notify_dirent_safe(mddev->sysfs_action);
4585 sysfs_notify(&mddev->kobj, NULL, "degraded");
4590 static int do_md_run(mddev_t *mddev)
4594 err = md_run(mddev);
4597 err = bitmap_load(mddev);
4599 bitmap_destroy(mddev);
4602 set_capacity(mddev->gendisk, mddev->array_sectors);
4603 revalidate_disk(mddev->gendisk);
4604 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4609 static int restart_array(mddev_t *mddev)
4611 struct gendisk *disk = mddev->gendisk;
4614 if (list_empty(&mddev->disks))
4616 if (!mddev->pers)
4618 if (!mddev->ro)
4620 mddev->safemode = 0;
4621 mddev->ro = 0;
4624 mdname(mddev));
4626 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4627 md_wakeup_thread(mddev->thread);
4628 md_wakeup_thread(mddev->sync_thread);
4629 sysfs_notify_dirent_safe(mddev->sysfs_state);
4659 static void md_clean(mddev_t *mddev)
4661 mddev->array_sectors = 0;
4662 mddev->external_size = 0;
4663 mddev->dev_sectors = 0;
4664 mddev->raid_disks = 0;
4665 mddev->recovery_cp = 0;
4666 mddev->resync_min = 0;
4667 mddev->resync_max = MaxSector;
4668 mddev->reshape_position = MaxSector;
4669 mddev->external = 0;
4670 mddev->persistent = 0;
4671 mddev->level = LEVEL_NONE;
4672 mddev->clevel[0] = 0;
4673 mddev->flags = 0;
4674 mddev->ro = 0;
4675 mddev->metadata_type[0] = 0;
4676 mddev->chunk_sectors = 0;
4677 mddev->ctime = mddev->utime = 0;
4678 mddev->layout = 0;
4679 mddev->max_disks = 0;
4680 mddev->events = 0;
4681 mddev->can_decrease_events = 0;
4682 mddev->delta_disks = 0;
4683 mddev->new_level = LEVEL_NONE;
4684 mddev->new_layout = 0;
4685 mddev->new_chunk_sectors = 0;
4686 mddev->curr_resync = 0;
4687 mddev->resync_mismatches = 0;
4688 mddev->suspend_lo = mddev->suspend_hi = 0;
4689 mddev->sync_speed_min = mddev->sync_speed_max = 0;
4690 mddev->recovery = 0;
4691 mddev->in_sync = 0;
4692 mddev->degraded = 0;
4693 mddev->barriers_work = 0;
4694 mddev->safemode = 0;
4695 mddev->bitmap_info.offset = 0;
4696 mddev->bitmap_info.default_offset = 0;
4697 mddev->bitmap_info.chunksize = 0;
4698 mddev->bitmap_info.daemon_sleep = 0;
4699 mddev->bitmap_info.max_write_behind = 0;
4700 mddev->plug = NULL;
4703 void md_stop_writes(mddev_t *mddev)
4705 if (mddev->sync_thread) {
4706 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4707 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4708 md_unregister_thread(mddev->sync_thread);
4709 mddev->sync_thread = NULL;
4712 del_timer_sync(&mddev->safemode_timer);
4714 bitmap_flush(mddev);
4715 md_super_wait(mddev);
4717 if (!mddev->in_sync || mddev->flags) {
4719 mddev->in_sync = 1;
4720 md_update_sb(mddev, 1);
4725 void md_stop(mddev_t *mddev)
4727 mddev->ready = 0;
4728 mddev->pers->stop(mddev);
4729 if (mddev->pers->sync_request && mddev->to_remove == NULL)
4730 mddev->to_remove = &md_redundancy_group;
4731 module_put(mddev->pers->owner);
4732 mddev->pers = NULL;
4733 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4737 static int md_set_readonly(mddev_t *mddev, int is_open)
4740 mutex_lock(&mddev->open_mutex);
4741 if (atomic_read(&mddev->openers) > is_open) {
4742 printk("md: %s still in use.\n",mdname(mddev));
4746 if (mddev->pers) {
4747 md_stop_writes(mddev);
4750 if (mddev->ro==1)
4752 mddev->ro = 1;
4753 set_disk_ro(mddev->gendisk, 1);
4754 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4755 sysfs_notify_dirent_safe(mddev->sysfs_state);
4759 mutex_unlock(&mddev->open_mutex);
4767 static int do_md_stop(mddev_t * mddev, int mode, int is_open)
4769 struct gendisk *disk = mddev->gendisk;
4772 mutex_lock(&mddev->open_mutex);
4773 if (atomic_read(&mddev->openers) > is_open ||
4774 mddev->sysfs_active) {
4775 printk("md: %s still in use.\n",mdname(mddev));
4776 mutex_unlock(&mddev->open_mutex);
4780 if (mddev->pers) {
4781 if (mddev->ro)
4784 md_stop_writes(mddev);
4785 md_stop(mddev);
4786 mddev->queue->merge_bvec_fn = NULL;
4787 mddev->queue->unplug_fn = NULL;
4788 mddev->queue->backing_dev_info.congested_fn = NULL;
4791 sysfs_notify_dirent_safe(mddev->sysfs_state);
4793 list_for_each_entry(rdev, &mddev->disks, same_set)
4797 sysfs_remove_link(&mddev->kobj, nm);
4801 mutex_unlock(&mddev->open_mutex);
4804 if (mddev->ro)
4805 mddev->ro = 0;
4807 mutex_unlock(&mddev->open_mutex);
4812 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
4814 bitmap_destroy(mddev);
4815 if (mddev->bitmap_info.file) {
4816 restore_bitmap_write_access(mddev->bitmap_info.file);
4817 fput(mddev->bitmap_info.file);
4818 mddev->bitmap_info.file = NULL;
4820 mddev->bitmap_info.offset = 0;
4822 export_array(mddev);
4824 md_clean(mddev);
4825 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4826 if (mddev->hold_active == UNTIL_STOP)
4827 mddev->hold_active = 0;
4830 md_new_event(mddev);
4831 sysfs_notify_dirent_safe(mddev->sysfs_state);
4836 static void autorun_array(mddev_t *mddev)
4841 if (list_empty(&mddev->disks))
4846 list_for_each_entry(rdev, &mddev->disks, same_set) {
4852 err = do_md_run(mddev);
4855 do_md_stop(mddev, 0, 0);
4874 mddev_t *mddev;
4897 * mddev.
4914 mddev = mddev_find(dev);
4915 if (!mddev || !mddev->gendisk) {
4916 if (mddev)
4917 mddev_put(mddev);
4922 if (mddev_lock(mddev))
4924 mdname(mddev));
4925 else if (mddev->raid_disks || mddev->major_version
4926 || !list_empty(&mddev->disks)) {
4929 mdname(mddev), bdevname(rdev0->bdev,b));
4930 mddev_unlock(mddev);
4932 printk(KERN_INFO "md: created %s\n", mdname(mddev));
4933 mddev->persistent = 1;
4936 if (bind_rdev_to_array(rdev, mddev))
4939 autorun_array(mddev);
4940 mddev_unlock(mddev);
4949 mddev_put(mddev);
4969 static int get_array_info(mddev_t * mddev, void __user * arg)
4976 list_for_each_entry(rdev, &mddev->disks, same_set) {
4989 info.major_version = mddev->major_version;
4990 info.minor_version = mddev->minor_version;
4992 info.ctime = mddev->ctime;
4993 info.level = mddev->level;
4994 info.size = mddev->dev_sectors / 2;
4995 if (info.size != mddev->dev_sectors / 2) /* overflow */
4998 info.raid_disks = mddev->raid_disks;
4999 info.md_minor = mddev->md_minor;
5000 info.not_persistent= !mddev->persistent;
5002 info.utime = mddev->utime;
5004 if (mddev->in_sync)
5006 if (mddev->bitmap && mddev->bitmap_info.offset)
5013 info.layout = mddev->layout;
5014 info.chunk_size = mddev->chunk_sectors << 9;
5022 static int get_bitmap_file(mddev_t * mddev, void __user * arg)
5028 if (md_allow_write(mddev))
5037 if (!mddev->bitmap || !mddev->bitmap->file) {
5046 ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
5062 static int get_disk_info(mddev_t * mddev, void __user * arg)
5070 rdev = find_rdev_nr(mddev, info.number);
5096 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
5105 if (!mddev->raid_disks) {
5108 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5115 if (!list_empty(&mddev->disks)) {
5116 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
5118 err = super_types[mddev->major_version]
5119 .load_super(rdev, rdev0, mddev->minor_version);
5129 err = bind_rdev_to_array(rdev, mddev);
5140 if (mddev->pers) {
5142 if (!mddev->pers->hot_add_disk) {
5145 mdname(mddev));
5148 if (mddev->persistent)
5149 rdev = md_import_device(dev, mddev->major_version,
5150 mddev->minor_version);
5160 if (!mddev->persistent) {
5162 info->raid_disk < mddev->raid_disks) {
5168 super_types[mddev->major_version].
5169 validate_super(mddev, rdev);
5182 err = bind_rdev_to_array(rdev, mddev);
5183 if (!err && !mddev->pers->hot_remove_disk) {
5188 super_types[mddev->major_version].
5189 validate_super(mddev, rdev);
5190 err = mddev->pers->hot_add_disk(mddev, rdev);
5199 md_update_sb(mddev, 1);
5200 if (mddev->degraded)
5201 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5202 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5203 md_wakeup_thread(mddev->thread);
5210 if (mddev->major_version != 0) {
5212 mdname(mddev));
5226 if (info->raid_disk < mddev->raid_disks)
5231 if (rdev->raid_disk < mddev->raid_disks)
5238 if (!mddev->persistent) {
5245 err = bind_rdev_to_array(rdev, mddev);
5255 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
5260 rdev = find_rdev(mddev, dev);
5268 md_update_sb(mddev, 1);
5269 md_new_event(mddev);
5274 bdevname(rdev->bdev,b), mdname(mddev));
5278 static int hot_add_disk(mddev_t * mddev, dev_t dev)
5284 if (!mddev->pers)
5287 if (mddev->major_version != 0) {
5290 mdname(mddev));
5293 if (!mddev->pers->hot_add_disk) {
5296 mdname(mddev));
5308 if (mddev->persistent)
5318 bdevname(rdev->bdev,b), mdname(mddev));
5325 err = bind_rdev_to_array(rdev, mddev);
5336 md_update_sb(mddev, 1);
5342 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5343 md_wakeup_thread(mddev->thread);
5344 md_new_event(mddev);
5352 static int set_bitmap_file(mddev_t *mddev, int fd)
5356 if (mddev->pers) {
5357 if (!mddev->pers->quiesce)
5359 if (mddev->recovery || mddev->sync_thread)
5366 if (mddev->bitmap)
5368 mddev->bitmap_info.file = fget(fd);
5370 if (mddev->bitmap_info.file == NULL) {
5372 mdname(mddev));
5376 err = deny_bitmap_write_access(mddev->bitmap_info.file);
5379 mdname(mddev));
5380 fput(mddev->bitmap_info.file);
5381 mddev->bitmap_info.file = NULL;
5384 mddev->bitmap_info.offset = 0; /* file overrides offset */
5385 } else if (mddev->bitmap == NULL)
5388 if (mddev->pers) {
5389 mddev->pers->quiesce(mddev, 1);
5391 err = bitmap_create(mddev);
5393 err = bitmap_load(mddev);
5396 bitmap_destroy(mddev);
5399 mddev->pers->quiesce(mddev, 0);
5402 if (mddev->bitmap_info.file) {
5403 restore_bitmap_write_access(mddev->bitmap_info.file);
5404 fput(mddev->bitmap_info.file);
5406 mddev->bitmap_info.file = NULL;
5425 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
5439 mddev->major_version = info->major_version;
5440 mddev->minor_version = info->minor_version;
5441 mddev->patch_version = info->patch_version;
5442 mddev->persistent = !info->not_persistent;
5446 mddev->ctime = get_seconds();
5449 mddev->major_version = MD_MAJOR_VERSION;
5450 mddev->minor_version = MD_MINOR_VERSION;
5451 mddev->patch_version = MD_PATCHLEVEL_VERSION;
5452 mddev->ctime = get_seconds();
5454 mddev->level = info->level;
5455 mddev->clevel[0] = 0;
5456 mddev->dev_sectors = 2 * (sector_t)info->size;
5457 mddev->raid_disks = info->raid_disks;
5462 mddev->recovery_cp = MaxSector;
5464 mddev->recovery_cp = 0;
5465 mddev->persistent = ! info->not_persistent;
5466 mddev->external = 0;
5468 mddev->layout = info->layout;
5469 mddev->chunk_sectors = info->chunk_size >> 9;
5471 mddev->max_disks = MD_SB_DISKS;
5473 if (mddev->persistent)
5474 mddev->flags = 0;
5475 set_bit(MD_CHANGE_DEVS, &mddev->flags);
5477 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
5478 mddev->bitmap_info.offset = 0;
5480 mddev->reshape_position = MaxSector;
5485 get_random_bytes(mddev->uuid, 16);
5487 mddev->new_level = mddev->level;
5488 mddev->new_chunk_sectors = mddev->chunk_sectors;
5489 mddev->new_layout = mddev->layout;
5490 mddev->delta_disks = 0;
5495 void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
5497 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
5499 if (mddev->external_size)
5502 mddev->array_sectors = array_sectors;
5506 static int update_size(mddev_t *mddev, sector_t num_sectors)
5512 if (mddev->pers->resize == NULL)
5524 if (mddev->sync_thread)
5526 if (mddev->bitmap)
5531 list_for_each_entry(rdev, &mddev->disks, same_set) {
5539 rv = mddev->pers->resize(mddev, num_sectors);
5541 revalidate_disk(mddev->gendisk);
5545 static int update_raid_disks(mddev_t *mddev, int raid_disks)
5549 if (mddev->pers->check_reshape == NULL)
5552 (mddev->max_disks && raid_disks >= mddev->max_disks))
5554 if (mddev->sync_thread || mddev->reshape_position != MaxSector)
5556 mddev->delta_disks = raid_disks - mddev->raid_disks;
5558 rv = mddev->pers->check_reshape(mddev);
5571 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
5578 if (mddev->bitmap && mddev->bitmap_info.offset)
5581 if (mddev->major_version != info->major_version ||
5582 mddev->minor_version != info->minor_version ||
5583 /* mddev->patch_version != info->patch_version || */
5584 mddev->ctime != info->ctime ||
5585 mddev->level != info->level ||
5586 /* mddev->layout != info->layout || */
5587 !mddev->persistent != info->not_persistent||
5588 mddev->chunk_sectors != info->chunk_size >> 9 ||
5594 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
5596 if (mddev->raid_disks != info->raid_disks)
5598 if (mddev->layout != info->layout)
5607 if (mddev->layout != info->layout) {
5612 if (mddev->pers->check_reshape == NULL)
5615 mddev->new_layout = info->layout;
5616 rv = mddev->pers->check_reshape(mddev);
5618 mddev->new_layout = mddev->layout;
5622 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
5623 rv = update_size(mddev, (sector_t)info->size * 2);
5625 if (mddev->raid_disks != info->raid_disks)
5626 rv = update_raid_disks(mddev, info->raid_disks);
5629 if (mddev->pers->quiesce == NULL)
5631 if (mddev->recovery || mddev->sync_thread)
5635 if (mddev->bitmap)
5637 if (mddev->bitmap_info.default_offset == 0)
5639 mddev->bitmap_info.offset =
5640 mddev->bitmap_info.default_offset;
5641 mddev->pers->quiesce(mddev, 1);
5642 rv = bitmap_create(mddev);
5644 rv = bitmap_load(mddev);
5646 bitmap_destroy(mddev);
5647 mddev->pers->quiesce(mddev, 0);
5650 if (!mddev->bitmap)
5652 if (mddev->bitmap->file)
5654 mddev->pers->quiesce(mddev, 1);
5655 bitmap_destroy(mddev);
5656 mddev->pers->quiesce(mddev, 0);
5657 mddev->bitmap_info.offset = 0;
5660 md_update_sb(mddev, 1);
5664 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
5668 if (mddev->pers == NULL)
5671 rdev = find_rdev(mddev, dev);
5675 md_error(mddev, rdev);
5687 mddev_t *mddev = bdev->bd_disk->private_data;
5691 geo->cylinders = mddev->array_sectors / 8;
5700 mddev_t *mddev = NULL;
5734 mddev = bdev->bd_disk->private_data;
5736 if (!mddev) {
5741 err = mddev_lock(mddev);
5760 if (mddev->pers) {
5761 err = update_array_info(mddev, &info);
5769 if (!list_empty(&mddev->disks)) {
5772 mdname(mddev));
5776 if (mddev->raid_disks) {
5779 mdname(mddev));
5783 err = set_array_info(mddev, &info);
5800 if ((!mddev->raid_disks && !mddev->external)
5814 err = get_array_info(mddev, argp);
5818 err = get_bitmap_file(mddev, argp);
5822 err = get_disk_info(mddev, argp);
5826 err = restart_array(mddev);
5830 err = do_md_stop(mddev, 0, 1);
5834 err = md_set_readonly(mddev, 1);
5844 /* if the bdev is going readonly the value of mddev->ro
5851 if (mddev->ro != 1)
5857 if (mddev->pers) {
5858 err = restart_array(mddev);
5860 mddev->ro = 2;
5861 set_disk_ro(mddev->gendisk, 0);
5874 if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
5875 if (mddev->ro == 2) {
5876 mddev->ro = 0;
5877 sysfs_notify_dirent_safe(mddev->sysfs_state);
5878 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5879 md_wakeup_thread(mddev->thread);
5894 err = add_new_disk(mddev, &info);
5899 err = hot_remove_disk(mddev, new_decode_dev(arg));
5903 err = hot_add_disk(mddev, new_decode_dev(arg));
5907 err = set_disk_faulty(mddev, new_decode_dev(arg));
5911 err = do_md_run(mddev);
5915 err = set_bitmap_file(mddev, (int)arg);
5925 if (mddev->hold_active == UNTIL_IOCTL &&
5927 mddev->hold_active = 0;
5928 mddev_unlock(mddev);
5960 * Succeed if we can lock the mddev, which confirms that
5963 mddev_t *mddev = mddev_find(bdev->bd_dev);
5967 if (mddev->gendisk != bdev->bd_disk) {
5971 mddev_put(mddev);
5978 BUG_ON(mddev != bdev->bd_disk->private_data);
5980 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
5984 atomic_inc(&mddev->openers);
5985 mutex_unlock(&mddev->open_mutex);
5987 check_disk_size_change(mddev->gendisk, bdev);
5995 mddev_t *mddev = disk->private_data;
5997 BUG_ON(!mddev);
5999 atomic_dec(&mddev->openers);
6000 mddev_put(mddev);
6052 thread->run(thread->mddev);
6067 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
6079 thread->mddev = mddev;
6083 mdname(thread->mddev),
6084 name ?: mddev->pers->name);
6102 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
6104 if (!mddev) {
6112 if (mddev->external)
6116 mdname(mddev),
6121 if (!mddev->pers)
6123 if (!mddev->pers->error_handler)
6125 mddev->pers->error_handler(mddev,rdev);
6126 if (mddev->degraded)
6127 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
6129 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6130 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6131 md_wakeup_thread(mddev->thread);
6132 if (mddev->event_work.func)
6133 schedule_work(&mddev->event_work);
6134 md_new_event_inintr(mddev);
6159 static void status_resync(struct seq_file *seq, mddev_t * mddev)
6167 resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
6169 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
6170 max_sectors = mddev->resync_max_sectors;
6172 max_sectors = mddev->dev_sectors;
6206 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
6208 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
6210 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
6230 dt = ((jiffies - mddev->resync_mark) / HZ);
6232 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
6233 - mddev->resync_mark_cnt;
6250 mddev_t *mddev;
6261 mddev = list_entry(tmp, mddev_t, all_mddevs);
6262 mddev_get(mddev);
6264 return mddev;
6275 mddev_t *next_mddev, *mddev = v;
6285 tmp = mddev->all_mddevs.next;
6295 mddev_put(mddev);
6302 mddev_t *mddev = v;
6304 if (mddev && v != (void*)1 && v != (void*)2)
6305 mddev_put(mddev);
6314 mddev_t *mddev = v;
6337 if (mddev_lock(mddev) < 0)
6340 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
6341 seq_printf(seq, "%s : %sactive", mdname(mddev),
6342 mddev->pers ? "" : "in");
6343 if (mddev->pers) {
6344 if (mddev->ro==1)
6346 if (mddev->ro==2)
6348 seq_printf(seq, " %s", mddev->pers->name);
6352 list_for_each_entry(rdev, &mddev->disks, same_set) {
6366 if (!list_empty(&mddev->disks)) {
6367 if (mddev->pers)
6370 mddev->array_sectors / 2);
6375 if (mddev->persistent) {
6376 if (mddev->major_version != 0 ||
6377 mddev->minor_version != 90) {
6379 mddev->major_version,
6380 mddev->minor_version);
6382 } else if (mddev->external)
6384 mddev->metadata_type);
6388 if (mddev->pers) {
6389 mddev->pers->status(seq, mddev);
6391 if (mddev->pers->sync_request) {
6392 if (mddev->curr_resync > 2) {
6393 status_resync(seq, mddev);
6395 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
6397 else if (mddev->recovery_cp < MaxSector)
6403 if ((bitmap = mddev->bitmap)) {
6407 chunk_kb = mddev->bitmap_info.chunksize >> 10;
6414 chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,
6427 mddev_unlock(mddev);
6500 static int is_mddev_idle(mddev_t *mddev, int init)
6508 rdev_for_each_rcu(rdev, mddev) {
6544 void md_done_sync(mddev_t *mddev, int blocks, int ok)
6547 atomic_sub(blocks, &mddev->recovery_active);
6548 wake_up(&mddev->recovery_wait);
6550 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6551 md_wakeup_thread(mddev->thread);
6557 /* md_write_start(mddev, bi)
6562 void md_write_start(mddev_t *mddev, struct bio *bi)
6568 BUG_ON(mddev->ro == 1);
6569 if (mddev->ro == 2) {
6571 mddev->ro = 0;
6572 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6573 md_wakeup_thread(mddev->thread);
6574 md_wakeup_thread(mddev->sync_thread);
6577 atomic_inc(&mddev->writes_pending);
6578 if (mddev->safemode == 1)
6579 mddev->safemode = 0;
6580 if (mddev->in_sync) {
6581 spin_lock_irq(&mddev->write_lock);
6582 if (mddev->in_sync) {
6583 mddev->in_sync = 0;
6584 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6585 set_bit(MD_CHANGE_PENDING, &mddev->flags);
6586 md_wakeup_thread(mddev->thread);
6589 spin_unlock_irq(&mddev->write_lock);
6592 sysfs_notify_dirent_safe(mddev->sysfs_state);
6593 wait_event(mddev->sb_wait,
6594 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
6597 void md_write_end(mddev_t *mddev)
6599 if (atomic_dec_and_test(&mddev->writes_pending)) {
6600 if (mddev->safemode == 2)
6601 md_wakeup_thread(mddev->thread);
6602 else if (mddev->safemode_delay)
6603 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
6607 /* md_allow_write(mddev)
6610 * attempting a GFP_KERNEL allocation while holding the mddev lock.
6613 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
6616 int md_allow_write(mddev_t *mddev)
6618 if (!mddev->pers)
6620 if (mddev->ro)
6622 if (!mddev->pers->sync_request)
6625 spin_lock_irq(&mddev->write_lock);
6626 if (mddev->in_sync) {
6627 mddev->in_sync = 0;
6628 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6629 set_bit(MD_CHANGE_PENDING, &mddev->flags);
6630 if (mddev->safemode_delay &&
6631 mddev->safemode == 0)
6632 mddev->safemode = 1;
6633 spin_unlock_irq(&mddev->write_lock);
6634 md_update_sb(mddev, 0);
6635 sysfs_notify_dirent_safe(mddev->sysfs_state);
6637 spin_unlock_irq(&mddev->write_lock);
6639 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
6646 void md_unplug(mddev_t *mddev)
6648 if (mddev->queue)
6649 blk_unplug(mddev->queue);
6650 if (mddev->plug)
6651 mddev->plug->unplug_fn(mddev->plug);
6656 void md_do_sync(mddev_t *mddev)
6672 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
6674 if (mddev->ro) /* never try to sync a read-only array */
6677 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
6678 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
6680 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
6684 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
6700 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
6706 mddev->curr_resync = 2;
6710 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6712 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
6715 if (mddev2 == mddev)
6717 if (!mddev->parallel_resync
6719 && match_mddev_units(mddev, mddev2)) {
6721 if (mddev < mddev2 && mddev->curr_resync == 2) {
6723 mddev->curr_resync = 1;
6726 if (mddev > mddev2 && mddev->curr_resync == 1)
6737 mddev2->curr_resync >= mddev->curr_resync) {
6741 desc, mdname(mddev), mdname(mddev2));
6752 } while (mddev->curr_resync < 2);
6755 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
6759 max_sectors = mddev->resync_max_sectors;
6760 mddev->resync_mismatches = 0;
6762 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
6763 j = mddev->resync_min;
6764 else if (!mddev->bitmap)
6765 j = mddev->recovery_cp;
6767 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
6768 max_sectors = mddev->dev_sectors;
6771 max_sectors = mddev->dev_sectors;
6774 list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6783 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
6785 " %d KB/sec/disk.\n", speed_min(mddev));
6788 speed_max(mddev), desc);
6790 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
6798 mddev->resync_mark = mark[last_mark];
6799 mddev->resync_mark_cnt = mark_cnt[last_mark];
6808 atomic_set(&mddev->recovery_active, 0);
6814 desc, mdname(mddev));
6815 mddev->curr_resync = j;
6817 mddev->curr_resync_completed = mddev->curr_resync;
6824 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
6825 ((mddev->curr_resync > mddev->curr_resync_completed &&
6826 (mddev->curr_resync - mddev->curr_resync_completed)
6828 (j - mddev->curr_resync_completed)*2
6829 >= mddev->resync_max - mddev->curr_resync_completed
6832 md_unplug(mddev);
6833 wait_event(mddev->recovery_wait,
6834 atomic_read(&mddev->recovery_active) == 0);
6835 mddev->curr_resync_completed =
6836 mddev->curr_resync;
6837 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6838 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
6841 while (j >= mddev->resync_max && !kthread_should_stop()) {
6847 wait_event_interruptible(mddev->recovery_wait,
6848 mddev->resync_max > j
6855 sectors = mddev->pers->sync_request(mddev, j, &skipped,
6856 currspeed < speed_min(mddev));
6858 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6864 atomic_add(sectors, &mddev->recovery_active);
6868 if (j>1) mddev->curr_resync = j;
6869 mddev->curr_mark_cnt = io_sectors;
6874 md_new_event(mddev);
6881 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
6889 mddev->resync_mark = mark[next];
6890 mddev->resync_mark_cnt = mark_cnt[next];
6892 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
6909 md_unplug(mddev);
6912 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
6913 /((jiffies-mddev->resync_mark)/HZ +1) +1;
6915 if (currspeed > speed_min(mddev)) {
6916 if ((currspeed > speed_max(mddev)) ||
6917 !is_mddev_idle(mddev, 0)) {
6923 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
6928 md_unplug(mddev);
6930 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
6933 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
6935 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
6936 mddev->curr_resync > 2) {
6937 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
6938 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
6939 if (mddev->curr_resync >= mddev->recovery_cp) {
6942 desc, mdname(mddev));
6943 mddev->recovery_cp = mddev->curr_resync;
6946 mddev->recovery_cp = MaxSector;
6948 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
6949 mddev->curr_resync = MaxSector;
6951 list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6953 mddev->delta_disks >= 0 &&
6956 rdev->recovery_offset < mddev->curr_resync)
6957 rdev->recovery_offset = mddev->curr_resync;
6961 set_bit(MD_CHANGE_DEVS, &mddev->flags);
6964 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
6966 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
6967 mddev->resync_min = 0;
6968 mddev->resync_max = MaxSector;
6969 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
6970 mddev->resync_min = mddev->curr_resync_completed;
6971 mddev->curr_resync = 0;
6972 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
6973 mddev->curr_resync_completed = 0;
6974 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
6976 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
6977 md_wakeup_thread(mddev->thread);
6986 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6993 static int remove_and_add_spares(mddev_t *mddev)
6998 mddev->curr_resync_completed = 0;
7000 list_for_each_entry(rdev, &mddev->disks, same_set)
7006 if (mddev->pers->hot_remove_disk(
7007 mddev, rdev->raid_disk)==0) {
7010 sysfs_remove_link(&mddev->kobj, nm);
7015 if (mddev->degraded && ! mddev->ro && !mddev->recovery_disabled) {
7016 list_for_each_entry(rdev, &mddev->disks, same_set) {
7024 if (mddev->pers->
7025 hot_add_disk(mddev, rdev) == 0) {
7028 if (sysfs_create_link(&mddev->kobj,
7032 md_new_event(mddev);
7033 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7063 void md_check_recovery(mddev_t *mddev)
7068 if (mddev->bitmap)
7069 bitmap_daemon_work(mddev);
7071 if (mddev->ro)
7075 if (mddev->pers->sync_request && !mddev->external) {
7077 mdname(mddev));
7078 mddev->safemode = 2;
7083 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
7086 (mddev->flags & ~ (1<<MD_CHANGE_PENDING)) ||
7087 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7088 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
7089 (mddev->external == 0 && mddev->safemode == 1) ||
7090 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
7091 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
7095 if (mddev_trylock(mddev)) {
7098 if (mddev->ro) {
7102 remove_and_add_spares(mddev);
7103 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7107 if (!mddev->external) {
7109 spin_lock_irq(&mddev->write_lock);
7110 if (mddev->safemode &&
7111 !atomic_read(&mddev->writes_pending) &&
7112 !mddev->in_sync &&
7113 mddev->recovery_cp == MaxSector) {
7114 mddev->in_sync = 1;
7116 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7118 if (mddev->safemode == 1)
7119 mddev->safemode = 0;
7120 spin_unlock_irq(&mddev->write_lock);
7122 sysfs_notify_dirent_safe(mddev->sysfs_state);
7125 if (mddev->flags)
7126 md_update_sb(mddev, 0);
7128 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
7129 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
7131 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7134 if (mddev->sync_thread) {
7136 md_unregister_thread(mddev->sync_thread);
7137 mddev->sync_thread = NULL;
7138 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7139 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7142 if (mddev->pers->spare_active(mddev))
7143 sysfs_notify(&mddev->kobj, NULL,
7146 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7147 mddev->pers->finish_reshape)
7148 mddev->pers->finish_reshape(mddev);
7149 md_update_sb(mddev, 1);
7154 if (!mddev->degraded)
7155 list_for_each_entry(rdev, &mddev->disks, same_set)
7158 mddev->recovery = 0;
7160 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7161 sysfs_notify_dirent_safe(mddev->sysfs_action);
7162 md_new_event(mddev);
7168 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7169 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7173 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
7174 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
7176 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
7185 if (mddev->reshape_position != MaxSector) {
7186 if (mddev->pers->check_reshape == NULL ||
7187 mddev->pers->check_reshape(mddev) != 0)
7190 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7191 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7192 } else if ((spares = remove_and_add_spares(mddev))) {
7193 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7194 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7195 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7196 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7197 } else if (mddev->recovery_cp < MaxSector) {
7198 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7199 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7200 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
7204 if (mddev->pers->sync_request) {
7205 if (spares && mddev->bitmap && ! mddev->bitmap->file) {
7210 bitmap_write_all(mddev->bitmap);
7212 mddev->sync_thread = md_register_thread(md_do_sync,
7213 mddev,
7215 if (!mddev->sync_thread) {
7218 mdname(mddev));
7220 mddev->recovery = 0;
7222 md_wakeup_thread(mddev->sync_thread);
7223 sysfs_notify_dirent_safe(mddev->sysfs_action);
7224 md_new_event(mddev);
7227 if (!mddev->sync_thread) {
7228 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7230 &mddev->recovery))
7231 if (mddev->sysfs_action)
7232 sysfs_notify_dirent_safe(mddev->sysfs_action);
7234 mddev_unlock(mddev);
7238 void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
7244 rdev_dec_pending(rdev, mddev);
7252 mddev_t *mddev;
7258 for_each_mddev(mddev, tmp)
7259 if (mddev_trylock(mddev)) {
7264 md_set_readonly(mddev, 100);
7265 mddev_unlock(mddev);
7382 mddev_t *mddev;
7393 for_each_mddev(mddev, tmp) {
7394 export_array(mddev);
7395 mddev->hold_active = 0;