Lines Matching refs:mddev
94 static inline int speed_min(mddev_t *mddev)
96 return mddev->sync_speed_min ?
97 mddev->sync_speed_min : sysctl_speed_limit_min;
100 static inline int speed_max(mddev_t *mddev)
102 return mddev->sync_speed_max ?
103 mddev->sync_speed_max : sysctl_speed_limit_max;
166 void md_new_event(mddev_t *mddev)
170 sysfs_notify(&mddev->kobj, NULL, "sync_action");
177 static void md_new_event_inintr(mddev_t *mddev)
196 * a reference to the current mddev and must mddev_put it.
198 #define ITERATE_MDDEV(mddev,tmp) \
202 mddev = NULL;}); \
206 if (mddev) mddev_put(mddev); \
207 mddev = list_entry(tmp, mddev_t, all_mddevs); \
220 static inline mddev_t *mddev_get(mddev_t *mddev)
222 atomic_inc(&mddev->active);
223 return mddev;
226 static void mddev_put(mddev_t *mddev)
228 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
230 if (!mddev->raid_disks && list_empty(&mddev->disks)) {
231 list_del(&mddev->all_mddevs);
233 blk_cleanup_queue(mddev->queue);
234 kobject_unregister(&mddev->kobj);
241 mddev_t *mddev, *new = NULL;
245 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
246 if (mddev->unit == unit) {
247 mddev_get(mddev);
250 return mddev;
291 static inline int mddev_lock(mddev_t * mddev)
293 return mutex_lock_interruptible(&mddev->reconfig_mutex);
296 static inline int mddev_trylock(mddev_t * mddev)
298 return mutex_trylock(&mddev->reconfig_mutex);
301 static inline void mddev_unlock(mddev_t * mddev)
303 mutex_unlock(&mddev->reconfig_mutex);
305 md_wakeup_thread(mddev->thread);
308 static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
313 ITERATE_RDEV(mddev,rdev,tmp) {
320 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
325 ITERATE_RDEV(mddev,rdev,tmp) {
390 mddev_t *mddev = rdev->mddev;
398 md_error(mddev, rdev);
401 if (atomic_dec_and_test(&mddev->pending_writes))
402 wake_up(&mddev->sb_wait);
411 mddev_t *mddev = rdev->mddev;
420 mddev->barriers_work = 0;
421 spin_lock_irqsave(&mddev->write_lock, flags);
422 bio2->bi_next = mddev->biolist;
423 mddev->biolist = bio2;
424 spin_unlock_irqrestore(&mddev->write_lock, flags);
425 wake_up(&mddev->sb_wait);
434 void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
438 * Increment mddev->pending_writes before returning
456 atomic_inc(&mddev->pending_writes);
468 void md_super_wait(mddev_t *mddev)
475 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
476 if (atomic_read(&mddev->pending_writes)==0)
478 while (mddev->biolist) {
480 spin_lock_irq(&mddev->write_lock);
481 bio = mddev->biolist;
482 mddev->biolist = bio->bi_next ;
484 spin_unlock_irq(&mddev->write_lock);
489 finish_wait(&mddev->sb_wait, &wq);
651 * int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
652 * Verify that dev is acceptable into mddev.
653 * The first time, mddev->raid_disks will be 0, and data from
657 * void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
658 * Update the superblock for rdev with data in mddev
667 int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
668 void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
777 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
785 if (mddev->raid_disks == 0) {
786 mddev->major_version = 0;
787 mddev->minor_version = sb->minor_version;
788 mddev->patch_version = sb->patch_version;
789 mddev->persistent = ! sb->not_persistent;
790 mddev->chunk_size = sb->chunk_size;
791 mddev->ctime = sb->ctime;
792 mddev->utime = sb->utime;
793 mddev->level = sb->level;
794 mddev->clevel[0] = 0;
795 mddev->layout = sb->layout;
796 mddev->raid_disks = sb->raid_disks;
797 mddev->size = sb->size;
798 mddev->events = ev1;
799 mddev->bitmap_offset = 0;
800 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
802 if (mddev->minor_version >= 91) {
803 mddev->reshape_position = sb->reshape_position;
804 mddev->delta_disks = sb->delta_disks;
805 mddev->new_level = sb->new_level;
806 mddev->new_layout = sb->new_layout;
807 mddev->new_chunk = sb->new_chunk;
809 mddev->reshape_position = MaxSector;
810 mddev->delta_disks = 0;
811 mddev->new_level = mddev->level;
812 mddev->new_layout = mddev->layout;
813 mddev->new_chunk = mddev->chunk_size;
817 mddev->recovery_cp = MaxSector;
821 mddev->recovery_cp = sb->recovery_cp;
823 mddev->recovery_cp = 0;
826 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
827 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
828 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
829 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
831 mddev->max_disks = MD_SB_DISKS;
834 mddev->bitmap_file == NULL)
835 mddev->bitmap_offset = mddev->default_bitmap_offset;
837 } else if (mddev->pers == NULL) {
840 if (ev1 < mddev->events)
842 } else if (mddev->bitmap) {
846 if (ev1 < mddev->bitmap->events_cleared)
849 if (ev1 < mddev->events)
854 if (mddev->level != LEVEL_MULTIPATH) {
860 desc->raid_disk < mddev->raid_disks */) {
874 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
879 int next_spare = mddev->raid_disks;
882 /* make rdev->sb match mddev data..
902 sb->major_version = mddev->major_version;
903 sb->patch_version = mddev->patch_version;
905 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
906 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
907 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
908 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
910 sb->ctime = mddev->ctime;
911 sb->level = mddev->level;
912 sb->size = mddev->size;
913 sb->raid_disks = mddev->raid_disks;
914 sb->md_minor = mddev->md_minor;
915 sb->not_persistent = !mddev->persistent;
916 sb->utime = mddev->utime;
918 sb->events_hi = (mddev->events>>32);
919 sb->events_lo = (u32)mddev->events;
921 if (mddev->reshape_position == MaxSector)
925 sb->reshape_position = mddev->reshape_position;
926 sb->new_level = mddev->new_level;
927 sb->delta_disks = mddev->delta_disks;
928 sb->new_layout = mddev->new_layout;
929 sb->new_chunk = mddev->new_chunk;
931 mddev->minor_version = sb->minor_version;
932 if (mddev->in_sync)
934 sb->recovery_cp = mddev->recovery_cp;
935 sb->cp_events_hi = (mddev->events>>32);
936 sb->cp_events_lo = (u32)mddev->events;
937 if (mddev->recovery_cp == MaxSector)
942 sb->layout = mddev->layout;
943 sb->chunk_size = mddev->chunk_size;
945 if (mddev->bitmap && mddev->bitmap_file == NULL)
949 ITERATE_RDEV(mddev,rdev2,tmp) {
984 for (i=0 ; i < mddev->raid_disks ; i++) {
1158 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1165 if (mddev->raid_disks == 0) {
1166 mddev->major_version = 1;
1167 mddev->patch_version = 0;
1168 mddev->persistent = 1;
1169 mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
1170 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1171 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1172 mddev->level = le32_to_cpu(sb->level);
1173 mddev->clevel[0] = 0;
1174 mddev->layout = le32_to_cpu(sb->layout);
1175 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1176 mddev->size = le64_to_cpu(sb->size)/2;
1177 mddev->events = ev1;
1178 mddev->bitmap_offset = 0;
1179 mddev->default_bitmap_offset = 1024 >> 9;
1181 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1182 memcpy(mddev->uuid, sb->set_uuid, 16);
1184 mddev->max_disks = (4096-256)/2;
1187 mddev->bitmap_file == NULL )
1188 mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
1191 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1192 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1193 mddev->new_level = le32_to_cpu(sb->new_level);
1194 mddev->new_layout = le32_to_cpu(sb->new_layout);
1195 mddev->new_chunk = le32_to_cpu(sb->new_chunk)<<9;
1197 mddev->reshape_position = MaxSector;
1198 mddev->delta_disks = 0;
1199 mddev->new_level = mddev->level;
1200 mddev->new_layout = mddev->layout;
1201 mddev->new_chunk = mddev->chunk_size;
1204 } else if (mddev->pers == NULL) {
1207 if (ev1 < mddev->events)
1209 } else if (mddev->bitmap) {
1213 if (ev1 < mddev->bitmap->events_cleared)
1216 if (ev1 < mddev->events)
1220 if (mddev->level != LEVEL_MULTIPATH) {
1246 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1252 /* make rdev->sb match mddev and rdev data. */
1263 sb->utime = cpu_to_le64((__u64)mddev->utime);
1264 sb->events = cpu_to_le64(mddev->events);
1265 if (mddev->in_sync)
1266 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1272 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1273 sb->size = cpu_to_le64(mddev->size<<1);
1275 if (mddev->bitmap && mddev->bitmap_file == NULL) {
1276 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
1287 if (mddev->reshape_position != MaxSector) {
1289 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1290 sb->new_layout = cpu_to_le32(mddev->new_layout);
1291 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1292 sb->new_level = cpu_to_le32(mddev->new_level);
1293 sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
1297 ITERATE_RDEV(mddev,rdev2,tmp)
1306 ITERATE_RDEV(mddev,rdev2,tmp) {
1355 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1362 if (rdev->mddev) {
1366 /* make sure rdev->size exceeds mddev->size */
1367 if (rdev->size && (mddev->size == 0 || rdev->size < mddev->size)) {
1368 if (mddev->pers) {
1370 * If mddev->level <= 0, then we don't care
1373 if (mddev->level > 0)
1376 mddev->size = rdev->size;
1385 if (mddev->pers) choice = mddev->raid_disks;
1386 while (find_rdev_nr(mddev, choice))
1390 if (find_rdev_nr(mddev, rdev->desc_nr))
1399 rdev->mddev = mddev;
1402 rdev->kobj.parent = &mddev->kobj;
1414 list_add(&rdev->same_set, &mddev->disks);
1415 bd_claim_by_disk(rdev->bdev, rdev, mddev->gendisk);
1420 b, mdname(mddev));
1433 if (!rdev->mddev) {
1437 bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1440 rdev->mddev = NULL;
1495 if (rdev->mddev)
1512 static void export_array(mddev_t *mddev)
1517 ITERATE_RDEV(mddev,rdev,tmp) {
1518 if (!rdev->mddev) {
1524 if (!list_empty(&mddev->disks))
1526 mddev->raid_disks = 0;
1527 mddev->major_version = 0;
1588 mddev_t *mddev;
1595 ITERATE_MDDEV(mddev,tmp) {
1597 if (mddev->bitmap)
1598 bitmap_print_sb(mddev->bitmap);
1600 printk("%s: ", mdname(mddev));
1601 ITERATE_RDEV(mddev,rdev,tmp2)
1605 ITERATE_RDEV(mddev,rdev,tmp2)
1613 static void sync_sbs(mddev_t * mddev, int nospares)
1624 ITERATE_RDEV(mddev,rdev,tmp) {
1625 if (rdev->sb_events == mddev->events ||
1629 rdev->sb_events+1 == mddev->events)) {
1633 super_types[mddev->major_version].
1634 sync_super(mddev, rdev);
1640 static void md_update_sb(mddev_t * mddev, int force_change)
1649 spin_lock_irq(&mddev->write_lock);
1651 set_bit(MD_CHANGE_PENDING, &mddev->flags);
1652 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
1654 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
1662 if (mddev->degraded)
1674 sync_req = mddev->in_sync;
1675 mddev->utime = get_seconds();
1680 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
1681 && (mddev->events & 1)
1682 && mddev->events != 1)
1683 mddev->events--;
1686 mddev->events ++;
1687 if (!mddev->in_sync || mddev->recovery_cp != MaxSector) { /* not clean */
1689 if ((mddev->events&1)==0) {
1690 mddev->events++;
1695 if ((mddev->events&1)) {
1696 mddev->events++;
1702 if (!mddev->events) {
1709 mddev->events --;
1711 sync_sbs(mddev, nospares);
1717 if (!mddev->persistent) {
1718 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
1719 spin_unlock_irq(&mddev->write_lock);
1720 wake_up(&mddev->sb_wait);
1723 spin_unlock_irq(&mddev->write_lock);
1727 mdname(mddev),mddev->in_sync);
1729 err = bitmap_update_sb(mddev->bitmap);
1730 ITERATE_RDEV(mddev,rdev,tmp) {
1740 md_super_write(mddev,rdev,
1746 rdev->sb_events = mddev->events;
1750 if (mddev->level == LEVEL_MULTIPATH)
1754 md_super_wait(mddev);
1757 spin_lock_irq(&mddev->write_lock);
1758 if (mddev->in_sync != sync_req ||
1759 test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
1761 spin_unlock_irq(&mddev->write_lock);
1764 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
1765 spin_unlock_irq(&mddev->write_lock);
1766 wake_up(&mddev->sb_wait);
1832 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
1833 md_error(rdev->mddev, rdev);
1839 mddev_t *mddev = rdev->mddev;
1841 if (mddev->pers)
1842 md_update_sb(mddev, 1);
1843 md_new_event(mddev);
1907 if (rdev->mddev->pers)
1910 if (slot >= rdev->mddev->raid_disks)
1936 if (rdev->mddev->pers)
1958 if (rdev->mddev->pers)
1961 if (size < rdev->mddev->size || rdev->mddev->size == 0)
1962 rdev->mddev->size = size;
2106 static void analyze_sbs(mddev_t * mddev)
2114 ITERATE_RDEV(mddev,rdev,tmp)
2115 switch (super_types[mddev->major_version].
2116 load_super(rdev, freshest, mddev->minor_version)) {
2131 super_types[mddev->major_version].
2132 validate_super(mddev, freshest);
2135 ITERATE_RDEV(mddev,rdev,tmp) {
2137 if (super_types[mddev->major_version].
2138 validate_super(mddev, rdev)) {
2145 if (mddev->level == LEVEL_MULTIPATH) {
2149 } else if (rdev->raid_disk >= mddev->raid_disks) {
2157 if (mddev->recovery_cp != MaxSector &&
2158 mddev->level >= 1)
2161 mdname(mddev));
2166 safe_delay_show(mddev_t *mddev, char *page)
2168 int msec = (mddev->safemode_delay*1000)/HZ;
2172 safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
2202 mddev->safemode_delay = 0;
2204 mddev->safemode_delay = (msec*HZ)/1000;
2205 if (mddev->safemode_delay == 0)
2206 mddev->safemode_delay = 1;
2214 level_show(mddev_t *mddev, char *page)
2216 struct mdk_personality *p = mddev->pers;
2219 else if (mddev->clevel[0])
2220 return sprintf(page, "%s\n", mddev->clevel);
2221 else if (mddev->level != LEVEL_NONE)
2222 return sprintf(page, "%d\n", mddev->level);
2228 level_store(mddev_t *mddev, const char *buf, size_t len)
2231 if (mddev->pers)
2235 if (len >= sizeof(mddev->clevel))
2237 strncpy(mddev->clevel, buf, len);
2238 if (mddev->clevel[len-1] == '\n')
2240 mddev->clevel[len] = 0;
2241 mddev->level = LEVEL_NONE;
2250 layout_show(mddev_t *mddev, char *page)
2253 if (mddev->reshape_position != MaxSector &&
2254 mddev->layout != mddev->new_layout)
2256 mddev->new_layout, mddev->layout);
2257 return sprintf(page, "%d\n", mddev->layout);
2261 layout_store(mddev_t *mddev, const char *buf, size_t len)
2269 if (mddev->pers)
2271 if (mddev->reshape_position != MaxSector)
2272 mddev->new_layout = n;
2274 mddev->layout = n;
2282 raid_disks_show(mddev_t *mddev, char *page)
2284 if (mddev->raid_disks == 0)
2286 if (mddev->reshape_position != MaxSector &&
2287 mddev->delta_disks != 0)
2288 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
2289 mddev->raid_disks - mddev->delta_disks);
2290 return sprintf(page, "%d\n", mddev->raid_disks);
2293 static int update_raid_disks(mddev_t *mddev, int raid_disks);
2296 raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
2305 if (mddev->pers)
2306 rv = update_raid_disks(mddev, n);
2307 else if (mddev->reshape_position != MaxSector) {
2308 int olddisks = mddev->raid_disks - mddev->delta_disks;
2309 mddev->delta_disks = n - olddisks;
2310 mddev->raid_disks = n;
2312 mddev->raid_disks = n;
2319 chunk_size_show(mddev_t *mddev, char *page)
2321 if (mddev->reshape_position != MaxSector &&
2322 mddev->chunk_size != mddev->new_chunk)
2323 return sprintf(page, "%d (%d)\n", mddev->new_chunk,
2324 mddev->chunk_size);
2325 return sprintf(page, "%d\n", mddev->chunk_size);
2329 chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
2338 if (mddev->pers)
2340 else if (mddev->reshape_position != MaxSector)
2341 mddev->new_chunk = n;
2343 mddev->chunk_size = n;
2350 resync_start_show(mddev_t *mddev, char *page)
2352 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
2356 resync_start_store(mddev_t *mddev, const char *buf, size_t len)
2362 if (mddev->pers)
2367 mddev->recovery_cp = n;
2425 array_state_show(mddev_t *mddev, char *page)
2429 if (mddev->pers)
2430 switch(mddev->ro) {
2438 if (mddev->in_sync)
2440 else if (mddev->safemode)
2446 if (list_empty(&mddev->disks) &&
2447 mddev->raid_disks == 0 &&
2448 mddev->size == 0)
2456 static int do_md_stop(mddev_t * mddev, int ro);
2457 static int do_md_run(mddev_t * mddev);
2458 static int restart_array(mddev_t *mddev);
2461 array_state_store(mddev_t *mddev, const char *buf, size_t len)
2470 if (mddev->pers) {
2471 if (atomic_read(&mddev->active) > 1)
2473 err = do_md_stop(mddev, 0);
2478 if (mddev->pers) {
2479 if (atomic_read(&mddev->active) > 1)
2481 err = do_md_stop(mddev, 2);
2487 if (mddev->pers)
2488 err = do_md_stop(mddev, 1);
2490 mddev->ro = 1;
2491 err = do_md_run(mddev);
2496 if (mddev->pers) {
2497 err = do_md_stop(mddev, 1);
2499 mddev->ro = 2;
2501 mddev->ro = 2;
2502 err = do_md_run(mddev);
2506 if (mddev->pers) {
2507 restart_array(mddev);
2508 spin_lock_irq(&mddev->write_lock);
2509 if (atomic_read(&mddev->writes_pending) == 0) {
2510 mddev->in_sync = 1;
2511 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
2513 spin_unlock_irq(&mddev->write_lock);
2515 mddev->ro = 0;
2516 mddev->recovery_cp = MaxSector;
2517 err = do_md_run(mddev);
2521 if (mddev->pers) {
2522 restart_array(mddev);
2523 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2524 wake_up(&mddev->sb_wait);
2527 mddev->ro = 0;
2528 err = do_md_run(mddev);
2545 null_show(mddev_t *mddev, char *page)
2551 new_dev_store(mddev_t *mddev, const char *buf, size_t len)
2578 if (mddev->persistent) {
2579 rdev = md_import_device(dev, mddev->major_version,
2580 mddev->minor_version);
2581 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
2582 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2584 err = super_types[mddev->major_version]
2585 .load_super(rdev, rdev0, mddev->minor_version);
2594 err = bind_rdev_to_array(rdev, mddev);
2605 bitmap_store(mddev_t *mddev, const char *buf, size_t len)
2610 if (!mddev->bitmap)
2622 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
2626 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
2635 size_show(mddev_t *mddev, char *page)
2637 return sprintf(page, "%llu\n", (unsigned long long)mddev->size);
2640 static int update_size(mddev_t *mddev, unsigned long size);
2643 size_store(mddev_t *mddev, const char *buf, size_t len)
2656 if (mddev->pers) {
2657 err = update_size(mddev, size);
2658 md_update_sb(mddev, 1);
2660 if (mddev->size == 0 ||
2661 mddev->size > size)
2662 mddev->size = size;
2678 metadata_show(mddev_t *mddev, char *page)
2680 if (mddev->persistent)
2682 mddev->major_version, mddev->minor_version);
2688 metadata_store(mddev_t *mddev, const char *buf, size_t len)
2692 if (!list_empty(&mddev->disks))
2696 mddev->persistent = 0;
2697 mddev->major_version = 0;
2698 mddev->minor_version = 90;
2710 mddev->major_version = major;
2711 mddev->minor_version = minor;
2712 mddev->persistent = 1;
2720 action_show(mddev_t *mddev, char *page)
2723 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2724 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
2725 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
2727 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
2728 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
2730 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
2741 action_store(mddev_t *mddev, const char *page, size_t len)
2743 if (!mddev->pers || !mddev->pers->sync_request)
2747 if (mddev->sync_thread) {
2748 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2749 md_unregister_thread(mddev->sync_thread);
2750 mddev->sync_thread = NULL;
2751 mddev->recovery = 0;
2753 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2754 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
2757 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2760 if (mddev->pers->start_reshape == NULL)
2762 err = mddev->pers->start_reshape(mddev);
2767 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
2770 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
2771 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
2773 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2774 md_wakeup_thread(mddev->thread);
2779 mismatch_cnt_show(mddev_t *mddev, char *page)
2782 (unsigned long long) mddev->resync_mismatches);
2792 sync_min_show(mddev_t *mddev, char *page)
2794 return sprintf(page, "%d (%s)\n", speed_min(mddev),
2795 mddev->sync_speed_min ? "local": "system");
2799 sync_min_store(mddev_t *mddev, const char *buf, size_t len)
2804 mddev->sync_speed_min = 0;
2810 mddev->sync_speed_min = min;
2818 sync_max_show(mddev_t *mddev, char *page)
2820 return sprintf(page, "%d (%s)\n", speed_max(mddev),
2821 mddev->sync_speed_max ? "local": "system");
2825 sync_max_store(mddev_t *mddev, const char *buf, size_t len)
2830 mddev->sync_speed_max = 0;
2836 mddev->sync_speed_max = max;
2845 sync_speed_show(mddev_t *mddev, char *page)
2848 resync = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active));
2849 dt = ((jiffies - mddev->resync_mark) / HZ);
2851 db = resync - (mddev->resync_mark_cnt);
2858 sync_completed_show(mddev_t *mddev, char *page)
2862 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
2863 max_blocks = mddev->resync_max_sectors;
2865 max_blocks = mddev->size << 1;
2867 resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
2874 suspend_lo_show(mddev_t *mddev, char *page)
2876 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
2880 suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
2885 if (mddev->pers->quiesce == NULL)
2889 if (new >= mddev->suspend_hi ||
2890 (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
2891 mddev->suspend_lo = new;
2892 mddev->pers->quiesce(mddev, 2);
2902 suspend_hi_show(mddev_t *mddev, char *page)
2904 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
2908 suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
2913 if (mddev->pers->quiesce == NULL)
2917 if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
2918 (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
2919 mddev->suspend_hi = new;
2920 mddev->pers->quiesce(mddev, 1);
2921 mddev->pers->quiesce(mddev, 0);
2930 reshape_position_show(mddev_t *mddev, char *page)
2932 if (mddev->reshape_position != MaxSector)
2934 (unsigned long long)mddev->reshape_position);
2940 reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
2944 if (mddev->pers)
2948 mddev->reshape_position = new;
2949 mddev->delta_disks = 0;
2950 mddev->new_level = mddev->level;
2951 mddev->new_layout = mddev->layout;
2952 mddev->new_chunk = mddev->chunk_size;
2998 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
3003 rv = mddev_lock(mddev);
3005 rv = entry->show(mddev, page);
3006 mddev_unlock(mddev);
3016 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
3023 rv = mddev_lock(mddev);
3025 rv = entry->store(mddev, page, length);
3026 mddev_unlock(mddev);
3033 mddev_t *mddev = container_of(ko, mddev_t, kobj);
3034 kfree(mddev);
3052 mddev_t *mddev = mddev_find(dev);
3058 if (!mddev)
3062 if (mddev->gendisk) {
3064 mddev_put(mddev);
3070 mddev_put(mddev);
3080 disk->private_data = mddev;
3081 disk->queue = mddev->queue;
3083 mddev->gendisk = disk;
3085 mddev->kobj.parent = &disk->kobj;
3086 mddev->kobj.k_name = NULL;
3087 snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
3088 mddev->kobj.ktype = &md_ktype;
3089 if (kobject_register(&mddev->kobj))
3097 mddev_t *mddev = (mddev_t *) data;
3099 mddev->safemode = 1;
3100 md_wakeup_thread(mddev->thread);
3105 static int do_md_run(mddev_t * mddev)
3115 if (list_empty(&mddev->disks))
3119 if (mddev->pers)
3125 if (!mddev->raid_disks)
3126 analyze_sbs(mddev);
3128 chunk_size = mddev->chunk_size;
3150 ITERATE_RDEV(mddev,rdev,tmp) {
3166 if (mddev->level != LEVEL_NONE)
3167 request_module("md-level-%d", mddev->level);
3168 else if (mddev->clevel[0])
3169 request_module("md-%s", mddev->clevel);
3178 ITERATE_RDEV(mddev,rdev,tmp) {
3185 md_probe(mddev->unit, NULL, NULL);
3186 disk = mddev->gendisk;
3191 pers = find_pers(mddev->level, mddev->clevel);
3194 if (mddev->level != LEVEL_NONE)
3196 mddev->level);
3199 mddev->clevel);
3202 mddev->pers = pers;
3204 mddev->level = pers->level;
3205 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3207 if (mddev->reshape_position != MaxSector &&
3210 mddev->pers = NULL;
3223 ITERATE_RDEV(mddev, rdev, tmp) {
3224 ITERATE_RDEV(mddev, rdev2, tmp2) {
3232 mdname(mddev),
3245 mddev->recovery = 0;
3246 mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
3247 mddev->barriers_work = 1;
3248 mddev->ok_start_degraded = start_dirty_degraded;
3251 mddev->ro = 2; /* read-only, but switch on first write */
3253 err = mddev->pers->run(mddev);
3254 if (!err && mddev->pers->sync_request) {
3255 err = bitmap_create(mddev);
3258 mdname(mddev), err);
3259 mddev->pers->stop(mddev);
3264 module_put(mddev->pers->owner);
3265 mddev->pers = NULL;
3266 bitmap_destroy(mddev);
3269 if (mddev->pers->sync_request) {
3270 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3273 mdname(mddev));
3274 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
3275 mddev->ro = 0;
3277 atomic_set(&mddev->writes_pending,0);
3278 mddev->safemode = 0;
3279 mddev->safemode_timer.function = md_safemode_timeout;
3280 mddev->safemode_timer.data = (unsigned long) mddev;
3281 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
3282 mddev->in_sync = 1;
3284 ITERATE_RDEV(mddev,rdev,tmp)
3288 if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
3290 nm, mdname(mddev));
3293 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3295 if (mddev->flags)
3296 md_update_sb(mddev, 0);
3298 set_capacity(disk, mddev->array_size<<1);
3307 mddev->queue->queuedata = mddev;
3308 mddev->queue->make_request_fn = mddev->pers->make_request;
3314 if (mddev->degraded && !mddev->sync_thread) {
3317 ITERATE_RDEV(mddev,rdev,rtmp)
3323 if (spares && mddev->pers->sync_request) {
3324 mddev->recovery = 0;
3325 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
3326 mddev->sync_thread = md_register_thread(md_do_sync,
3327 mddev,
3329 if (!mddev->sync_thread) {
3332 mdname(mddev));
3334 mddev->recovery = 0;
3338 md_wakeup_thread(mddev->thread);
3339 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
3341 mddev->changed = 1;
3342 md_new_event(mddev);
3343 kobject_uevent(&mddev->gendisk->kobj, KOBJ_CHANGE);
3347 static int restart_array(mddev_t *mddev)
3349 struct gendisk *disk = mddev->gendisk;
3356 if (list_empty(&mddev->disks))
3359 if (mddev->pers) {
3361 if (!mddev->ro)
3364 mddev->safemode = 0;
3365 mddev->ro = 0;
3369 mdname(mddev));
3373 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3374 md_wakeup_thread(mddev->thread);
3375 md_wakeup_thread(mddev->sync_thread);
3415 static int do_md_stop(mddev_t * mddev, int mode)
3418 struct gendisk *disk = mddev->gendisk;
3420 if (mddev->pers) {
3421 if (atomic_read(&mddev->active)>2) {
3422 printk("md: %s still in use.\n",mdname(mddev));
3426 if (mddev->sync_thread) {
3427 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3428 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3429 md_unregister_thread(mddev->sync_thread);
3430 mddev->sync_thread = NULL;
3433 del_timer_sync(&mddev->safemode_timer);
3440 if (mddev->ro==1)
3442 mddev->ro = 1;
3446 bitmap_flush(mddev);
3447 md_super_wait(mddev);
3448 if (mddev->ro)
3450 blk_queue_make_request(mddev->queue, md_fail_request);
3451 mddev->pers->stop(mddev);
3452 mddev->queue->merge_bvec_fn = NULL;
3453 mddev->queue->unplug_fn = NULL;
3454 mddev->queue->issue_flush_fn = NULL;
3455 mddev->queue->backing_dev_info.congested_fn = NULL;
3456 if (mddev->pers->sync_request)
3457 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
3459 module_put(mddev->pers->owner);
3460 mddev->pers = NULL;
3463 mddev->changed = 1;
3465 if (mddev->ro)
3466 mddev->ro = 0;
3468 if (!mddev->in_sync || mddev->flags) {
3470 mddev->in_sync = 1;
3471 md_update_sb(mddev, 1);
3475 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3485 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
3487 bitmap_destroy(mddev);
3488 if (mddev->bitmap_file) {
3489 restore_bitmap_write_access(mddev->bitmap_file);
3490 fput(mddev->bitmap_file);
3491 mddev->bitmap_file = NULL;
3493 mddev->bitmap_offset = 0;
3495 ITERATE_RDEV(mddev,rdev,tmp)
3499 sysfs_remove_link(&mddev->kobj, nm);
3505 export_array(mddev);
3507 mddev->array_size = 0;
3508 mddev->size = 0;
3509 mddev->raid_disks = 0;
3510 mddev->recovery_cp = 0;
3511 mddev->reshape_position = MaxSector;
3513 } else if (mddev->pers)
3515 mdname(mddev));
3517 md_new_event(mddev);
3523 static void autorun_array(mddev_t *mddev)
3529 if (list_empty(&mddev->disks))
3534 ITERATE_RDEV(mddev,rdev,tmp) {
3540 err = do_md_run (mddev);
3543 do_md_stop (mddev, 0);
3563 mddev_t *mddev;
3586 * mddev.
3603 mddev = mddev_find(dev);
3604 if (!mddev) {
3609 if (mddev_lock(mddev))
3611 mdname(mddev));
3612 else if (mddev->raid_disks || mddev->major_version
3613 || !list_empty(&mddev->disks)) {
3616 mdname(mddev), bdevname(rdev0->bdev,b));
3617 mddev_unlock(mddev);
3619 printk(KERN_INFO "md: created %s\n", mdname(mddev));
3622 if (bind_rdev_to_array(rdev, mddev))
3625 autorun_array(mddev);
3626 mddev_unlock(mddev);
3633 mddev_put(mddev);
3653 static int get_array_info(mddev_t * mddev, void __user * arg)
3661 ITERATE_RDEV(mddev,rdev,tmp) {
3674 info.major_version = mddev->major_version;
3675 info.minor_version = mddev->minor_version;
3677 info.ctime = mddev->ctime;
3678 info.level = mddev->level;
3679 info.size = mddev->size;
3680 if (info.size != mddev->size) /* overflow */
3683 info.raid_disks = mddev->raid_disks;
3684 info.md_minor = mddev->md_minor;
3685 info.not_persistent= !mddev->persistent;
3687 info.utime = mddev->utime;
3689 if (mddev->in_sync)
3691 if (mddev->bitmap && mddev->bitmap_offset)
3698 info.layout = mddev->layout;
3699 info.chunk_size = mddev->chunk_size;
3707 static int get_bitmap_file(mddev_t * mddev, void __user * arg)
3713 md_allow_write(mddev);
3720 if (!mddev->bitmap || !mddev->bitmap->file) {
3729 ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
3745 static int get_disk_info(mddev_t * mddev, void __user * arg)
3756 rdev = find_rdev_nr(mddev, nr);
3782 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
3791 if (!mddev->raid_disks) {
3794 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
3801 if (!list_empty(&mddev->disks)) {
3802 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
3804 int err = super_types[mddev->major_version]
3805 .load_super(rdev, rdev0, mddev->minor_version);
3815 err = bind_rdev_to_array(rdev, mddev);
3826 if (mddev->pers) {
3828 if (!mddev->pers->hot_add_disk) {
3831 mdname(mddev));
3834 if (mddev->persistent)
3835 rdev = md_import_device(dev, mddev->major_version,
3836 mddev->minor_version);
3846 if (!mddev->persistent) {
3848 info->raid_disk < mddev->raid_disks)
3853 super_types[mddev->major_version].
3854 validate_super(mddev, rdev);
3862 err = bind_rdev_to_array(rdev, mddev);
3863 if (!err && !mddev->pers->hot_remove_disk) {
3868 super_types[mddev->major_version].
3869 validate_super(mddev, rdev);
3870 err = mddev->pers->hot_add_disk(mddev, rdev);
3877 md_update_sb(mddev, 1);
3878 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3879 md_wakeup_thread(mddev->thread);
3886 if (mddev->major_version != 0) {
3888 mdname(mddev));
3902 if (info->raid_disk < mddev->raid_disks)
3909 if (rdev->raid_disk < mddev->raid_disks)
3916 if (!mddev->persistent) {
3921 rdev->size = calc_dev_size(rdev, mddev->chunk_size);
3923 err = bind_rdev_to_array(rdev, mddev);
3933 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
3938 if (!mddev->pers)
3941 rdev = find_rdev(mddev, dev);
3949 md_update_sb(mddev, 1);
3950 md_new_event(mddev);
3955 bdevname(rdev->bdev,b), mdname(mddev));
3959 static int hot_add_disk(mddev_t * mddev, dev_t dev)
3966 if (!mddev->pers)
3969 if (mddev->major_version != 0) {
3972 mdname(mddev));
3975 if (!mddev->pers->hot_add_disk) {
3978 mdname(mddev));
3990 if (mddev->persistent)
3996 size = calc_dev_size(rdev, mddev->chunk_size);
4002 bdevname(rdev->bdev,b), mdname(mddev));
4009 err = bind_rdev_to_array(rdev, mddev);
4018 if (rdev->desc_nr == mddev->max_disks) {
4020 mdname(mddev));
4027 md_update_sb(mddev, 1);
4033 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4034 md_wakeup_thread(mddev->thread);
4035 md_new_event(mddev);
4046 static int set_bitmap_file(mddev_t *mddev, int fd)
4050 if (mddev->pers) {
4051 if (!mddev->pers->quiesce)
4053 if (mddev->recovery || mddev->sync_thread)
4060 if (mddev->bitmap)
4062 mddev->bitmap_file = fget(fd);
4064 if (mddev->bitmap_file == NULL) {
4066 mdname(mddev));
4070 err = deny_bitmap_write_access(mddev->bitmap_file);
4073 mdname(mddev));
4074 fput(mddev->bitmap_file);
4075 mddev->bitmap_file = NULL;
4078 mddev->bitmap_offset = 0; /* file overrides offset */
4079 } else if (mddev->bitmap == NULL)
4082 if (mddev->pers) {
4083 mddev->pers->quiesce(mddev, 1);
4085 err = bitmap_create(mddev);
4087 bitmap_destroy(mddev);
4090 mddev->pers->quiesce(mddev, 0);
4093 if (mddev->bitmap_file) {
4094 restore_bitmap_write_access(mddev->bitmap_file);
4095 fput(mddev->bitmap_file);
4097 mddev->bitmap_file = NULL;
4116 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
4130 mddev->major_version = info->major_version;
4131 mddev->minor_version = info->minor_version;
4132 mddev->patch_version = info->patch_version;
4133 mddev->persistent = !info->not_persistent;
4136 mddev->major_version = MD_MAJOR_VERSION;
4137 mddev->minor_version = MD_MINOR_VERSION;
4138 mddev->patch_version = MD_PATCHLEVEL_VERSION;
4139 mddev->ctime = get_seconds();
4141 mddev->level = info->level;
4142 mddev->clevel[0] = 0;
4143 mddev->size = info->size;
4144 mddev->raid_disks = info->raid_disks;
4149 mddev->recovery_cp = MaxSector;
4151 mddev->recovery_cp = 0;
4152 mddev->persistent = ! info->not_persistent;
4154 mddev->layout = info->layout;
4155 mddev->chunk_size = info->chunk_size;
4157 mddev->max_disks = MD_SB_DISKS;
4159 mddev->flags = 0;
4160 set_bit(MD_CHANGE_DEVS, &mddev->flags);
4162 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
4163 mddev->bitmap_offset = 0;
4165 mddev->reshape_position = MaxSector;
4170 get_random_bytes(mddev->uuid, 16);
4172 mddev->new_level = mddev->level;
4173 mddev->new_chunk = mddev->chunk_size;
4174 mddev->new_layout = mddev->layout;
4175 mddev->delta_disks = 0;
4180 static int update_size(mddev_t *mddev, unsigned long size)
4187 if (mddev->pers->resize == NULL)
4199 if (mddev->sync_thread)
4201 ITERATE_RDEV(mddev,rdev,tmp) {
4210 rv = mddev->pers->resize(mddev, (sector_t)size *2);
4214 bdev = bdget_disk(mddev->gendisk, 0);
4217 i_size_write(bdev->bd_inode, (loff_t)mddev->array_size << 10);
4225 static int update_raid_disks(mddev_t *mddev, int raid_disks)
4229 if (mddev->pers->check_reshape == NULL)
4232 raid_disks >= mddev->max_disks)
4234 if (mddev->sync_thread || mddev->reshape_position != MaxSector)
4236 mddev->delta_disks = raid_disks - mddev->raid_disks;
4238 rv = mddev->pers->check_reshape(mddev);
4251 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
4258 if (mddev->bitmap && mddev->bitmap_offset)
4261 if (mddev->major_version != info->major_version ||
4262 mddev->minor_version != info->minor_version ||
4263 /* mddev->patch_version != info->patch_version || */
4264 mddev->ctime != info->ctime ||
4265 mddev->level != info->level ||
4266 /* mddev->layout != info->layout || */
4267 !mddev->persistent != info->not_persistent||
4268 mddev->chunk_size != info->chunk_size ||
4274 if (info->size >= 0 && mddev->size != info->size) cnt++;
4275 if (mddev->raid_disks != info->raid_disks) cnt++;
4276 if (mddev->layout != info->layout) cnt++;
4281 if (mddev->layout != info->layout) {
4286 if (mddev->pers->reconfig == NULL)
4289 return mddev->pers->reconfig(mddev, info->layout, -1);
4291 if (info->size >= 0 && mddev->size != info->size)
4292 rv = update_size(mddev, info->size);
4294 if (mddev->raid_disks != info->raid_disks)
4295 rv = update_raid_disks(mddev, info->raid_disks);
4298 if (mddev->pers->quiesce == NULL)
4300 if (mddev->recovery || mddev->sync_thread)
4304 if (mddev->bitmap)
4306 if (mddev->default_bitmap_offset == 0)
4308 mddev->bitmap_offset = mddev->default_bitmap_offset;
4309 mddev->pers->quiesce(mddev, 1);
4310 rv = bitmap_create(mddev);
4312 bitmap_destroy(mddev);
4313 mddev->pers->quiesce(mddev, 0);
4316 if (!mddev->bitmap)
4318 if (mddev->bitmap->file)
4320 mddev->pers->quiesce(mddev, 1);
4321 bitmap_destroy(mddev);
4322 mddev->pers->quiesce(mddev, 0);
4323 mddev->bitmap_offset = 0;
4326 md_update_sb(mddev, 1);
4330 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
4334 if (mddev->pers == NULL)
4337 rdev = find_rdev(mddev, dev);
4341 md_error(mddev, rdev);
4347 mddev_t *mddev = bdev->bd_disk->private_data;
4351 geo->cylinders = get_capacity(mddev->gendisk) / 8;
4360 mddev_t *mddev = NULL;
4393 mddev = inode->i_bdev->bd_disk->private_data;
4395 if (!mddev) {
4400 err = mddev_lock(mddev);
4419 if (mddev->pers) {
4420 err = update_array_info(mddev, &info);
4428 if (!list_empty(&mddev->disks)) {
4431 mdname(mddev));
4435 if (mddev->raid_disks) {
4438 mdname(mddev));
4442 err = set_array_info(mddev, &info);
4459 if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
4472 err = get_array_info(mddev, argp);
4476 err = get_bitmap_file(mddev, argp);
4480 err = get_disk_info(mddev, argp);
4484 err = restart_array(mddev);
4488 err = do_md_stop (mddev, 0);
4492 err = do_md_stop (mddev, 1);
4511 mddev->ro && mddev->pers) {
4512 if (mddev->ro == 2) {
4513 mddev->ro = 0;
4514 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4515 md_wakeup_thread(mddev->thread);
4531 err = add_new_disk(mddev, &info);
4536 err = hot_remove_disk(mddev, new_decode_dev(arg));
4540 err = hot_add_disk(mddev, new_decode_dev(arg));
4544 err = set_disk_faulty(mddev, new_decode_dev(arg));
4548 err = do_md_run (mddev);
4552 err = set_bitmap_file(mddev, (int)arg);
4562 mddev_unlock(mddev);
4575 * Succeed if we can lock the mddev, which confirms that
4578 mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
4581 if ((err = mutex_lock_interruptible_nested(&mddev->reconfig_mutex, 1)))
4585 mddev_get(mddev);
4586 mddev_unlock(mddev);
4595 mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
4597 BUG_ON(!mddev);
4598 mddev_put(mddev);
4605 mddev_t *mddev = disk->private_data;
4607 return mddev->changed;
4612 mddev_t *mddev = disk->private_data;
4614 mddev->changed = 0;
4664 thread->run(thread->mddev);
4679 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
4691 thread->mddev = mddev;
4693 thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
4709 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
4711 if (!mddev) {
4720 mdname(mddev),
4725 if (!mddev->pers)
4727 if (!mddev->pers->error_handler)
4729 mddev->pers->error_handler(mddev,rdev);
4730 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4731 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4732 md_wakeup_thread(mddev->thread);
4733 md_new_event_inintr(mddev);
4759 static void status_resync(struct seq_file *seq, mddev_t * mddev)
4766 resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
4768 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
4769 max_blocks = mddev->resync_max_sectors >> 1;
4771 max_blocks = mddev->size;
4805 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
4807 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
4809 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
4824 dt = ((jiffies - mddev->resync_mark) / HZ);
4826 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
4827 - mddev->resync_mark_cnt;
4839 mddev_t *mddev;
4850 mddev = list_entry(tmp, mddev_t, all_mddevs);
4851 mddev_get(mddev);
4853 return mddev;
4864 mddev_t *next_mddev, *mddev = v;
4874 tmp = mddev->all_mddevs.next;
4884 mddev_put(mddev);
4891 mddev_t *mddev = v;
4893 if (mddev && v != (void*)1 && v != (void*)2)
4894 mddev_put(mddev);
4903 mddev_t *mddev = v;
4927 if (mddev_lock(mddev) < 0)
4930 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
4931 seq_printf(seq, "%s : %sactive", mdname(mddev),
4932 mddev->pers ? "" : "in");
4933 if (mddev->pers) {
4934 if (mddev->ro==1)
4936 if (mddev->ro==2)
4938 seq_printf(seq, " %s", mddev->pers->name);
4942 ITERATE_RDEV(mddev,rdev,tmp2) {
4956 if (!list_empty(&mddev->disks)) {
4957 if (mddev->pers)
4959 (unsigned long long)mddev->array_size);
4964 if (mddev->persistent) {
4965 if (mddev->major_version != 0 ||
4966 mddev->minor_version != 90) {
4968 mddev->major_version,
4969 mddev->minor_version);
4974 if (mddev->pers) {
4975 mddev->pers->status (seq, mddev);
4977 if (mddev->pers->sync_request) {
4978 if (mddev->curr_resync > 2) {
4979 status_resync (seq, mddev);
4981 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
4983 else if (mddev->recovery_cp < MaxSector)
4989 if ((bitmap = mddev->bitmap)) {
5014 mddev_unlock(mddev);
5087 static int is_mddev_idle(mddev_t *mddev)
5095 ITERATE_RDEV(mddev,rdev,tmp) {
5121 void md_done_sync(mddev_t *mddev, int blocks, int ok)
5124 atomic_sub(blocks, &mddev->recovery_active);
5125 wake_up(&mddev->recovery_wait);
5127 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
5128 md_wakeup_thread(mddev->thread);
5134 /* md_write_start(mddev, bi)
5139 void md_write_start(mddev_t *mddev, struct bio *bi)
5144 BUG_ON(mddev->ro == 1);
5145 if (mddev->ro == 2) {
5147 mddev->ro = 0;
5148 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5149 md_wakeup_thread(mddev->thread);
5151 atomic_inc(&mddev->writes_pending);
5152 if (mddev->in_sync) {
5153 spin_lock_irq(&mddev->write_lock);
5154 if (mddev->in_sync) {
5155 mddev->in_sync = 0;
5156 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5157 md_wakeup_thread(mddev->thread);
5159 spin_unlock_irq(&mddev->write_lock);
5161 wait_event(mddev->sb_wait, mddev->flags==0);
5164 void md_write_end(mddev_t *mddev)
5166 if (atomic_dec_and_test(&mddev->writes_pending)) {
5167 if (mddev->safemode == 2)
5168 md_wakeup_thread(mddev->thread);
5169 else if (mddev->safemode_delay)
5170 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
5174 /* md_allow_write(mddev)
5177 * attempting a GFP_KERNEL allocation while holding the mddev lock.
5180 void md_allow_write(mddev_t *mddev)
5182 if (!mddev->pers)
5184 if (mddev->ro)
5187 spin_lock_irq(&mddev->write_lock);
5188 if (mddev->in_sync) {
5189 mddev->in_sync = 0;
5190 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5191 if (mddev->safemode_delay &&
5192 mddev->safemode == 0)
5193 mddev->safemode = 1;
5194 spin_unlock_irq(&mddev->write_lock);
5195 md_update_sb(mddev, 0);
5197 spin_unlock_irq(&mddev->write_lock);
5205 void md_do_sync(mddev_t *mddev)
5222 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
5224 if (mddev->ro) /* never try to sync a read-only array */
5227 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5228 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
5230 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
5234 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5250 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
5256 mddev->curr_resync = 2;
5260 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5264 if (mddev2 == mddev)
5267 match_mddev_units(mddev,mddev2)) {
5269 if (mddev < mddev2 && mddev->curr_resync == 2) {
5271 mddev->curr_resync = 1;
5274 if (mddev > mddev2 && mddev->curr_resync == 1)
5281 mddev2->curr_resync >= mddev->curr_resync) {
5285 desc, mdname(mddev), mdname(mddev2));
5294 } while (mddev->curr_resync < 2);
5297 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5301 max_sectors = mddev->resync_max_sectors;
5302 mddev->resync_mismatches = 0;
5304 if (!mddev->bitmap &&
5305 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
5306 j = mddev->recovery_cp;
5307 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5308 max_sectors = mddev->size << 1;
5311 max_sectors = mddev->size << 1;
5313 ITERATE_RDEV(mddev,rdev,rtmp)
5321 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
5323 " %d KB/sec/disk.\n", speed_min(mddev));
5326 speed_max(mddev), desc);
5328 is_mddev_idle(mddev); /* this also initializes IO event counters */
5336 mddev->resync_mark = mark[last_mark];
5337 mddev->resync_mark_cnt = mark_cnt[last_mark];
5346 atomic_set(&mddev->recovery_active, 0);
5347 init_waitqueue_head(&mddev->recovery_wait);
5353 desc, mdname(mddev));
5354 mddev->curr_resync = j;
5361 sectors = mddev->pers->sync_request(mddev, j, &skipped,
5362 currspeed < speed_min(mddev));
5364 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
5370 atomic_add(sectors, &mddev->recovery_active);
5374 if (j>1) mddev->curr_resync = j;
5375 mddev->curr_mark_cnt = io_sectors;
5380 md_new_event(mddev);
5387 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
5388 test_bit(MD_RECOVERY_ERR, &mddev->recovery))
5396 mddev->resync_mark = mark[next];
5397 mddev->resync_mark_cnt = mark_cnt[next];
5399 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
5410 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5422 mddev->queue->unplug_fn(mddev->queue);
5425 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
5426 /((jiffies-mddev->resync_mark)/HZ +1) +1;
5428 if (currspeed > speed_min(mddev)) {
5429 if ((currspeed > speed_max(mddev)) ||
5430 !is_mddev_idle(mddev)) {
5436 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
5441 mddev->queue->unplug_fn(mddev->queue);
5443 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
5446 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
5448 if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
5449 !test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
5450 mddev->curr_resync > 2) {
5451 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5452 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
5453 if (mddev->curr_resync >= mddev->recovery_cp) {
5456 desc, mdname(mddev));
5457 mddev->recovery_cp = mddev->curr_resync;
5460 mddev->recovery_cp = MaxSector;
5462 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
5463 mddev->curr_resync = MaxSector;
5464 ITERATE_RDEV(mddev,rdev,rtmp)
5468 rdev->recovery_offset < mddev->curr_resync)
5469 rdev->recovery_offset = mddev->curr_resync;
5472 set_bit(MD_CHANGE_DEVS, &mddev->flags);
5475 mddev->curr_resync = 0;
5477 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
5478 md_wakeup_thread(mddev->thread);
5483 static int remove_and_add_spares(mddev_t *mddev)
5489 ITERATE_RDEV(mddev,rdev,rtmp)
5494 if (mddev->pers->hot_remove_disk(
5495 mddev, rdev->raid_disk)==0) {
5498 sysfs_remove_link(&mddev->kobj, nm);
5503 if (mddev->degraded) {
5504 ITERATE_RDEV(mddev,rdev,rtmp)
5508 if (mddev->pers->hot_add_disk(mddev,rdev)) {
5511 if (sysfs_create_link(&mddev->kobj,
5516 nm, mdname(mddev));
5518 md_new_event(mddev);
5547 void md_check_recovery(mddev_t *mddev)
5553 if (mddev->bitmap)
5554 bitmap_daemon_work(mddev->bitmap);
5556 if (mddev->ro)
5560 if (mddev->pers->sync_request) {
5562 mdname(mddev));
5563 mddev->safemode = 2;
5569 mddev->flags ||
5570 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
5571 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
5572 (mddev->safemode == 1) ||
5573 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
5574 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
5578 if (mddev_trylock(mddev)) {
5581 spin_lock_irq(&mddev->write_lock);
5582 if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
5583 !mddev->in_sync && mddev->recovery_cp == MaxSector) {
5584 mddev->in_sync = 1;
5585 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5587 if (mddev->safemode == 1)
5588 mddev->safemode = 0;
5589 spin_unlock_irq(&mddev->write_lock);
5591 if (mddev->flags)
5592 md_update_sb(mddev, 0);
5595 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
5596 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
5598 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5601 if (mddev->sync_thread) {
5603 md_unregister_thread(mddev->sync_thread);
5604 mddev->sync_thread = NULL;
5605 if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
5606 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
5609 mddev->pers->spare_active(mddev);
5611 md_update_sb(mddev, 1);
5616 if (!mddev->degraded)
5617 ITERATE_RDEV(mddev,rdev,rtmp)
5620 mddev->recovery = 0;
5622 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5623 md_new_event(mddev);
5629 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5630 clear_bit(MD_RECOVERY_ERR, &mddev->recovery);
5631 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
5632 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
5634 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
5643 if (mddev->reshape_position != MaxSector) {
5644 if (mddev->pers->check_reshape(mddev) != 0)
5647 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
5648 } else if ((spares = remove_and_add_spares(mddev))) {
5649 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5650 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
5651 } else if (mddev->recovery_cp < MaxSector) {
5652 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5653 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
5657 if (mddev->pers->sync_request) {
5658 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
5659 if (spares && mddev->bitmap && ! mddev->bitmap->file) {
5664 bitmap_write_all(mddev->bitmap);
5666 mddev->sync_thread = md_register_thread(md_do_sync,
5667 mddev,
5669 if (!mddev->sync_thread) {
5672 mdname(mddev));
5674 mddev->recovery = 0;
5676 md_wakeup_thread(mddev->sync_thread);
5677 md_new_event(mddev);
5680 mddev_unlock(mddev);
5688 mddev_t *mddev;
5694 ITERATE_MDDEV(mddev,tmp)
5695 if (mddev_trylock(mddev)) {
5696 do_md_stop (mddev, 1);
5697 mddev_unlock(mddev);
5793 mddev_t *mddev;
5804 ITERATE_MDDEV(mddev,tmp) {
5805 struct gendisk *disk = mddev->gendisk;
5808 export_array(mddev);
5811 mddev->gendisk = NULL;
5812 mddev_put(mddev);