^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1) // SPDX-License-Identifier: GPL-2.0-or-later
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3) md.c : Multiple Devices driver for Linux
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4) Copyright (C) 1998, 1999, 2000 Ingo Molnar
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6) completely rewritten, based on the MD driver code from Marc Zyngier
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8) Changes:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 10) - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 11) - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 12) - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 13) - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 14) - kmod support by: Cyrus Durgin
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 15) - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 16) - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 17)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 18) - lots of fixes and improvements to the RAID1/RAID5 and generic
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 19) RAID code (such as request based resynchronization):
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 20)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 21) Neil Brown <neilb@cse.unsw.edu.au>.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 22)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 23) - persistent bitmap code
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 24) Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 25)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 26)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 27) Errors, Warnings, etc.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 28) Please use:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 29) pr_crit() for error conditions that risk data loss
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 30) pr_err() for error conditions that are unexpected, like an IO error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 31) or internal inconsistency
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 32) pr_warn() for error conditions that could have been predicated, like
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 33) adding a device to an array when it has incompatible metadata
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 34) pr_info() for every interesting, very rare events, like an array starting
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 35) or stopping, or resync starting or stopping
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 36) pr_debug() for everything else.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 37)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 38) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 39)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 40) #include <linux/sched/mm.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 41) #include <linux/sched/signal.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 42) #include <linux/kthread.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 43) #include <linux/blkdev.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 44) #include <linux/badblocks.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 45) #include <linux/sysctl.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 46) #include <linux/seq_file.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 47) #include <linux/fs.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 48) #include <linux/poll.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 49) #include <linux/ctype.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 50) #include <linux/string.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 51) #include <linux/hdreg.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 52) #include <linux/proc_fs.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 53) #include <linux/random.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 54) #include <linux/module.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 55) #include <linux/reboot.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 56) #include <linux/file.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 57) #include <linux/compat.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 58) #include <linux/delay.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 59) #include <linux/raid/md_p.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 60) #include <linux/raid/md_u.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 61) #include <linux/raid/detect.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 62) #include <linux/slab.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 63) #include <linux/percpu-refcount.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 64) #include <linux/part_stat.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 65)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 66) #include <trace/events/block.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 67) #include "md.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 68) #include "md-bitmap.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 69) #include "md-cluster.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 70)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 71) /* pers_list is a list of registered personalities protected
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 72) * by pers_lock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 73) * pers_lock does extra service to protect accesses to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 74) * mddev->thread when the mutex cannot be held.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 75) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 76) static LIST_HEAD(pers_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 77) static DEFINE_SPINLOCK(pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 78)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 79) static struct kobj_type md_ktype;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 80)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 81) struct md_cluster_operations *md_cluster_ops;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 82) EXPORT_SYMBOL(md_cluster_ops);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 83) static struct module *md_cluster_mod;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 84)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 85) static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 86) static struct workqueue_struct *md_wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 87) static struct workqueue_struct *md_misc_wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 88) static struct workqueue_struct *md_rdev_misc_wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 89)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 90) static int remove_and_add_spares(struct mddev *mddev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 91) struct md_rdev *this);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 92) static void mddev_detach(struct mddev *mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 93)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 94) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 95) * Default number of read corrections we'll attempt on an rdev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 96) * before ejecting it from the array. We divide the read error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 97) * count by 2 for every hour elapsed between read errors.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 98) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 99) #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 100) /* Default safemode delay: 200 msec */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 101) #define DEFAULT_SAFEMODE_DELAY ((200 * HZ)/1000 +1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 102) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 103) * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 104) * is 1000 KB/sec, so the extra system load does not show up that much.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 105) * Increase it if you want to have more _guaranteed_ speed. Note that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 106) * the RAID driver will use the maximum available bandwidth if the IO
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 107) * subsystem is idle. There is also an 'absolute maximum' reconstruction
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 108) * speed limit - in case reconstruction slows down your system despite
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 109) * idle IO detection.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 110) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 111) * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 112) * or /sys/block/mdX/md/sync_speed_{min,max}
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 113) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 114)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 115) static int sysctl_speed_limit_min = 1000;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 116) static int sysctl_speed_limit_max = 200000;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 117) static inline int speed_min(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 118) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 119) return mddev->sync_speed_min ?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 120) mddev->sync_speed_min : sysctl_speed_limit_min;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 121) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 122)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 123) static inline int speed_max(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 124) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 125) return mddev->sync_speed_max ?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 126) mddev->sync_speed_max : sysctl_speed_limit_max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 127) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 128)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 129) static void rdev_uninit_serial(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 130) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 131) if (!test_and_clear_bit(CollisionCheck, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 132) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 133)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 134) kvfree(rdev->serial);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 135) rdev->serial = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 136) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 137)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 138) static void rdevs_uninit_serial(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 139) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 140) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 141)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 142) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 143) rdev_uninit_serial(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 144) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 145)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 146) static int rdev_init_serial(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 147) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 148) /* serial_nums equals with BARRIER_BUCKETS_NR */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 149) int i, serial_nums = 1 << ((PAGE_SHIFT - ilog2(sizeof(atomic_t))));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 150) struct serial_in_rdev *serial = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 151)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 152) if (test_bit(CollisionCheck, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 153) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 154)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 155) serial = kvmalloc(sizeof(struct serial_in_rdev) * serial_nums,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 156) GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 157) if (!serial)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 158) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 159)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 160) for (i = 0; i < serial_nums; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 161) struct serial_in_rdev *serial_tmp = &serial[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 162)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 163) spin_lock_init(&serial_tmp->serial_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 164) serial_tmp->serial_rb = RB_ROOT_CACHED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 165) init_waitqueue_head(&serial_tmp->serial_io_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 166) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 167)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 168) rdev->serial = serial;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 169) set_bit(CollisionCheck, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 171) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 172) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 173)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 174) static int rdevs_init_serial(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 175) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 176) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 177) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 178)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 179) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 180) ret = rdev_init_serial(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 181) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 182) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 183) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 184)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 185) /* Free all resources if pool is not existed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 186) if (ret && !mddev->serial_info_pool)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 187) rdevs_uninit_serial(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 188)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 189) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 190) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 191)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 192) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 193) * rdev needs to enable serial stuffs if it meets the conditions:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 194) * 1. it is multi-queue device flaged with writemostly.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 195) * 2. the write-behind mode is enabled.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 196) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 197) static int rdev_need_serial(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 198) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 199) return (rdev && rdev->mddev->bitmap_info.max_write_behind > 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 200) rdev->bdev->bd_disk->queue->nr_hw_queues != 1 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 201) test_bit(WriteMostly, &rdev->flags));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 202) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 203)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 204) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 205) * Init resource for rdev(s), then create serial_info_pool if:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 206) * 1. rdev is the first device which return true from rdev_enable_serial.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 207) * 2. rdev is NULL, means we want to enable serialization for all rdevs.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 208) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 209) void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 210) bool is_suspend)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 211) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 212) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 213)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 214) if (rdev && !rdev_need_serial(rdev) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 215) !test_bit(CollisionCheck, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 216) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 217)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 218) if (!is_suspend)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 219) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 220)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 221) if (!rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 222) ret = rdevs_init_serial(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 223) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 224) ret = rdev_init_serial(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 225) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 226) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 227)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 228) if (mddev->serial_info_pool == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 229) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 230) * already in memalloc noio context by
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 231) * mddev_suspend()
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 232) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 233) mddev->serial_info_pool =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 234) mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 235) sizeof(struct serial_info));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 236) if (!mddev->serial_info_pool) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 237) rdevs_uninit_serial(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 238) pr_err("can't alloc memory pool for serialization\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 239) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 240) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 241)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 242) abort:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 243) if (!is_suspend)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 244) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 245) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 246)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 247) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 248) * Free resource from rdev(s), and destroy serial_info_pool under conditions:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 249) * 1. rdev is the last device flaged with CollisionCheck.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 250) * 2. when bitmap is destroyed while policy is not enabled.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 251) * 3. for disable policy, the pool is destroyed only when no rdev needs it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 252) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 253) void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 254) bool is_suspend)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 255) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 256) if (rdev && !test_bit(CollisionCheck, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 257) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 258)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 259) if (mddev->serial_info_pool) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 260) struct md_rdev *temp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 261) int num = 0; /* used to track if other rdevs need the pool */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 262)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 263) if (!is_suspend)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 264) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 265) rdev_for_each(temp, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 266) if (!rdev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 267) if (!mddev->serialize_policy ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 268) !rdev_need_serial(temp))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 269) rdev_uninit_serial(temp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 270) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 271) num++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 272) } else if (temp != rdev &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 273) test_bit(CollisionCheck, &temp->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 274) num++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 275) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 276)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 277) if (rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 278) rdev_uninit_serial(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 279)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 280) if (num)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 281) pr_info("The mempool could be used by other devices\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 282) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 283) mempool_destroy(mddev->serial_info_pool);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 284) mddev->serial_info_pool = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 285) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 286) if (!is_suspend)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 287) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 288) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 289) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 290)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 291) static struct ctl_table_header *raid_table_header;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 292)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 293) static struct ctl_table raid_table[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 294) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 295) .procname = "speed_limit_min",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 296) .data = &sysctl_speed_limit_min,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 297) .maxlen = sizeof(int),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 298) .mode = S_IRUGO|S_IWUSR,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 299) .proc_handler = proc_dointvec,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 300) },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 301) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 302) .procname = "speed_limit_max",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 303) .data = &sysctl_speed_limit_max,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 304) .maxlen = sizeof(int),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 305) .mode = S_IRUGO|S_IWUSR,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 306) .proc_handler = proc_dointvec,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 307) },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 308) { }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 309) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 310)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 311) static struct ctl_table raid_dir_table[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 312) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 313) .procname = "raid",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 314) .maxlen = 0,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 315) .mode = S_IRUGO|S_IXUGO,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 316) .child = raid_table,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 317) },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 318) { }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 319) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 320)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 321) static struct ctl_table raid_root_table[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 322) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 323) .procname = "dev",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 324) .maxlen = 0,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 325) .mode = 0555,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 326) .child = raid_dir_table,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 327) },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 328) { }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 329) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 330)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 331) static int start_readonly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 332)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 333) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 334) * The original mechanism for creating an md device is to create
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 335) * a device node in /dev and to open it. This causes races with device-close.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 336) * The preferred method is to write to the "new_array" module parameter.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 337) * This can avoid races.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 338) * Setting create_on_open to false disables the original mechanism
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 339) * so all the races disappear.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 340) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 341) static bool create_on_open = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 342)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 343) struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 344) struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 345) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 346) if (!mddev || !bioset_initialized(&mddev->bio_set))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 347) return bio_alloc(gfp_mask, nr_iovecs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 348)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 349) return bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 350) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 351) EXPORT_SYMBOL_GPL(bio_alloc_mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 352)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 353) static struct bio *md_bio_alloc_sync(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 354) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 355) if (!mddev || !bioset_initialized(&mddev->sync_set))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 356) return bio_alloc(GFP_NOIO, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 357)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 358) return bio_alloc_bioset(GFP_NOIO, 1, &mddev->sync_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 359) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 360)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 361) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 362) * We have a system wide 'event count' that is incremented
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 363) * on any 'interesting' event, and readers of /proc/mdstat
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 364) * can use 'poll' or 'select' to find out when the event
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 365) * count increases.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 366) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 367) * Events are:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 368) * start array, stop array, error, add device, remove device,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 369) * start build, activate spare
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 370) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 371) static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 372) static atomic_t md_event_count;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 373) void md_new_event(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 374) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 375) atomic_inc(&md_event_count);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 376) wake_up(&md_event_waiters);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 377) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 378) EXPORT_SYMBOL_GPL(md_new_event);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 379)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 380) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 381) * Enables to iterate over all existing md arrays
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 382) * all_mddevs_lock protects this list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 383) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 384) static LIST_HEAD(all_mddevs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 385) static DEFINE_SPINLOCK(all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 386)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 387) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 388) * iterates through all used mddevs in the system.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 389) * We take care to grab the all_mddevs_lock whenever navigating
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 390) * the list, and to always hold a refcount when unlocked.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 391) * Any code which breaks out of this loop while own
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 392) * a reference to the current mddev and must mddev_put it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 393) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 394) #define for_each_mddev(_mddev,_tmp) \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 395) \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 396) for (({ spin_lock(&all_mddevs_lock); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 397) _tmp = all_mddevs.next; \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 398) _mddev = NULL;}); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 399) ({ if (_tmp != &all_mddevs) \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 400) mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 401) spin_unlock(&all_mddevs_lock); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 402) if (_mddev) mddev_put(_mddev); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 403) _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 404) _tmp != &all_mddevs;}); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 405) ({ spin_lock(&all_mddevs_lock); \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 406) _tmp = _tmp->next;}) \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 407) )
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 408)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 409) /* Rather than calling directly into the personality make_request function,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 410) * IO requests come here first so that we can check if the device is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 411) * being suspended pending a reconfiguration.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 412) * We hold a refcount over the call to ->make_request. By the time that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 413) * call has finished, the bio has been linked into some internal structure
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 414) * and so is visible to ->quiesce(), so we don't need the refcount any more.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 415) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 416) static bool is_suspended(struct mddev *mddev, struct bio *bio)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 417) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 418) if (mddev->suspended)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 419) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 420) if (bio_data_dir(bio) != WRITE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 421) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 422) if (mddev->suspend_lo >= mddev->suspend_hi)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 423) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 424) if (bio->bi_iter.bi_sector >= mddev->suspend_hi)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 425) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 426) if (bio_end_sector(bio) < mddev->suspend_lo)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 427) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 428) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 429) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 430)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 431) void md_handle_request(struct mddev *mddev, struct bio *bio)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 432) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 433) check_suspended:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 434) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 435) if (is_suspended(mddev, bio)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 436) DEFINE_WAIT(__wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 437) for (;;) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 438) prepare_to_wait(&mddev->sb_wait, &__wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 439) TASK_UNINTERRUPTIBLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 440) if (!is_suspended(mddev, bio))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 441) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 442) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 443) schedule();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 444) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 445) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 446) finish_wait(&mddev->sb_wait, &__wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 447) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 448) atomic_inc(&mddev->active_io);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 449) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 450)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 451) if (!mddev->pers->make_request(mddev, bio)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 452) atomic_dec(&mddev->active_io);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 453) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 454) goto check_suspended;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 455) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 456)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 457) if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 458) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 459) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 460) EXPORT_SYMBOL(md_handle_request);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 461)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 462) static blk_qc_t md_submit_bio(struct bio *bio)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 463) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 464) const int rw = bio_data_dir(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 465) const int sgrp = op_stat_group(bio_op(bio));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 466) struct mddev *mddev = bio->bi_disk->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 467) unsigned int sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 468)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 469) if (mddev == NULL || mddev->pers == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 470) bio_io_error(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 471) return BLK_QC_T_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 472) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 473)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 474) if (unlikely(test_bit(MD_BROKEN, &mddev->flags)) && (rw == WRITE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 475) bio_io_error(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 476) return BLK_QC_T_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 477) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 478)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 479) blk_queue_split(&bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 480)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 481) if (mddev->ro == 1 && unlikely(rw == WRITE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 482) if (bio_sectors(bio) != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 483) bio->bi_status = BLK_STS_IOERR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 484) bio_endio(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 485) return BLK_QC_T_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 486) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 487)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 488) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 489) * save the sectors now since our bio can
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 490) * go away inside make_request
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 491) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 492) sectors = bio_sectors(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 493) /* bio could be mergeable after passing to underlayer */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 494) bio->bi_opf &= ~REQ_NOMERGE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 495)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 496) md_handle_request(mddev, bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 497)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 498) part_stat_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 499) part_stat_inc(&mddev->gendisk->part0, ios[sgrp]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 500) part_stat_add(&mddev->gendisk->part0, sectors[sgrp], sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 501) part_stat_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 502)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 503) return BLK_QC_T_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 504) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 505)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 506) /* mddev_suspend makes sure no new requests are submitted
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 507) * to the device, and that any requests that have been submitted
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 508) * are completely handled.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 509) * Once mddev_detach() is called and completes, the module will be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 510) * completely unused.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 511) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 512) void mddev_suspend(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 513) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 514) WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 515) lockdep_assert_held(&mddev->reconfig_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 516) if (mddev->suspended++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 517) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 518) synchronize_rcu();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 519) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 520) set_bit(MD_ALLOW_SB_UPDATE, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 521) smp_mb__after_atomic();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 522) wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 523) mddev->pers->quiesce(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 524) clear_bit_unlock(MD_ALLOW_SB_UPDATE, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 525) wait_event(mddev->sb_wait, !test_bit(MD_UPDATING_SB, &mddev->flags));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 526)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 527) del_timer_sync(&mddev->safemode_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 528) /* restrict memory reclaim I/O during raid array is suspend */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 529) mddev->noio_flag = memalloc_noio_save();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 530) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 531) EXPORT_SYMBOL_GPL(mddev_suspend);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 532)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 533) void mddev_resume(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 534) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 535) /* entred the memalloc scope from mddev_suspend() */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 536) memalloc_noio_restore(mddev->noio_flag);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 537) lockdep_assert_held(&mddev->reconfig_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 538) if (--mddev->suspended)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 539) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 540) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 541) mddev->pers->quiesce(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 542)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 543) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 544) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 545) md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 546) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 547) EXPORT_SYMBOL_GPL(mddev_resume);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 548)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 549) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 550) * Generic flush handling for md
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 551) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 552)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 553) static void md_end_flush(struct bio *bio)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 554) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 555) struct md_rdev *rdev = bio->bi_private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 556) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 557)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 558) rdev_dec_pending(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 559)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 560) if (atomic_dec_and_test(&mddev->flush_pending)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 561) /* The pre-request flush has finished */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 562) queue_work(md_wq, &mddev->flush_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 563) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 564) bio_put(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 565) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 566)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 567) static void md_submit_flush_data(struct work_struct *ws);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 568)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 569) static void submit_flushes(struct work_struct *ws)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 570) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 571) struct mddev *mddev = container_of(ws, struct mddev, flush_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 572) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 573)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 574) mddev->start_flush = ktime_get_boottime();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 575) INIT_WORK(&mddev->flush_work, md_submit_flush_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 576) atomic_set(&mddev->flush_pending, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 577) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 578) rdev_for_each_rcu(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 579) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 580) !test_bit(Faulty, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 581) /* Take two references, one is dropped
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 582) * when request finishes, one after
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 583) * we reclaim rcu_read_lock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 584) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 585) struct bio *bi;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 586) atomic_inc(&rdev->nr_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 587) atomic_inc(&rdev->nr_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 588) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 589) bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 590) bi->bi_end_io = md_end_flush;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 591) bi->bi_private = rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 592) bio_set_dev(bi, rdev->bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 593) bi->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 594) atomic_inc(&mddev->flush_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 595) submit_bio(bi);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 596) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 597) rdev_dec_pending(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 598) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 599) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 600) if (atomic_dec_and_test(&mddev->flush_pending))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 601) queue_work(md_wq, &mddev->flush_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 602) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 603)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 604) static void md_submit_flush_data(struct work_struct *ws)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 605) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 606) struct mddev *mddev = container_of(ws, struct mddev, flush_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 607) struct bio *bio = mddev->flush_bio;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 608)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 609) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 610) * must reset flush_bio before calling into md_handle_request to avoid a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 611) * deadlock, because other bios passed md_handle_request suspend check
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 612) * could wait for this and below md_handle_request could wait for those
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 613) * bios because of suspend check
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 614) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 615) spin_lock_irq(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 616) mddev->last_flush = mddev->start_flush;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 617) mddev->flush_bio = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 618) spin_unlock_irq(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 619) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 620)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 621) if (bio->bi_iter.bi_size == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 622) /* an empty barrier - all done */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 623) bio_endio(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 624) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 625) bio->bi_opf &= ~REQ_PREFLUSH;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 626) md_handle_request(mddev, bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 627) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 628) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 629)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 630) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 631) * Manages consolidation of flushes and submitting any flushes needed for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 632) * a bio with REQ_PREFLUSH. Returns true if the bio is finished or is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 633) * being finished in another context. Returns false if the flushing is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 634) * complete but still needs the I/O portion of the bio to be processed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 635) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 636) bool md_flush_request(struct mddev *mddev, struct bio *bio)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 637) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 638) ktime_t start = ktime_get_boottime();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 639) spin_lock_irq(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 640) wait_event_lock_irq(mddev->sb_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 641) !mddev->flush_bio ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 642) ktime_after(mddev->last_flush, start),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 643) mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 644) if (!ktime_after(mddev->last_flush, start)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 645) WARN_ON(mddev->flush_bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 646) mddev->flush_bio = bio;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 647) bio = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 648) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 649) spin_unlock_irq(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 650)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 651) if (!bio) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 652) INIT_WORK(&mddev->flush_work, submit_flushes);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 653) queue_work(md_wq, &mddev->flush_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 654) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 655) /* flush was performed for some other bio while we waited. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 656) if (bio->bi_iter.bi_size == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 657) /* an empty barrier - all done */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 658) bio_endio(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 659) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 660) bio->bi_opf &= ~REQ_PREFLUSH;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 661) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 662) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 663) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 664) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 665) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 666) EXPORT_SYMBOL(md_flush_request);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 667)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 668) static inline struct mddev *mddev_get(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 669) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 670) atomic_inc(&mddev->active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 671) return mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 672) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 673)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 674) static void mddev_delayed_delete(struct work_struct *ws);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 675)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 676) static void mddev_put(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 677) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 678) if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 679) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 680) if (!mddev->raid_disks && list_empty(&mddev->disks) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 681) mddev->ctime == 0 && !mddev->hold_active) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 682) /* Array is not configured at all, and not held active,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 683) * so destroy it */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 684) list_del_init(&mddev->all_mddevs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 685)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 686) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 687) * Call queue_work inside the spinlock so that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 688) * flush_workqueue() after mddev_find will succeed in waiting
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 689) * for the work to be done.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 690) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 691) INIT_WORK(&mddev->del_work, mddev_delayed_delete);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 692) queue_work(md_misc_wq, &mddev->del_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 693) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 694) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 695) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 696)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 697) static void md_safemode_timeout(struct timer_list *t);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 698)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 699) void mddev_init(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 700) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 701) kobject_init(&mddev->kobj, &md_ktype);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 702) mutex_init(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 703) mutex_init(&mddev->reconfig_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 704) mutex_init(&mddev->bitmap_info.mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 705) INIT_LIST_HEAD(&mddev->disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 706) INIT_LIST_HEAD(&mddev->all_mddevs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 707) timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 708) atomic_set(&mddev->active, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 709) atomic_set(&mddev->openers, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 710) atomic_set(&mddev->active_io, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 711) spin_lock_init(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 712) atomic_set(&mddev->flush_pending, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 713) init_waitqueue_head(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 714) init_waitqueue_head(&mddev->recovery_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 715) mddev->reshape_position = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 716) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 717) mddev->last_sync_action = "none";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 718) mddev->resync_min = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 719) mddev->resync_max = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 720) mddev->level = LEVEL_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 721) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 722) EXPORT_SYMBOL_GPL(mddev_init);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 723)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 724) static struct mddev *mddev_find_locked(dev_t unit)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 725) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 726) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 727)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 728) list_for_each_entry(mddev, &all_mddevs, all_mddevs)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 729) if (mddev->unit == unit)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 730) return mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 731)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 732) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 733) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 734)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 735) static struct mddev *mddev_find(dev_t unit)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 736) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 737) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 738)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 739) if (MAJOR(unit) != MD_MAJOR)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 740) unit &= ~((1 << MdpMinorShift) - 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 741)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 742) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 743) mddev = mddev_find_locked(unit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 744) if (mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 745) mddev_get(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 746) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 747)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 748) return mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 749) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 750)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 751) static struct mddev *mddev_find_or_alloc(dev_t unit)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 752) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 753) struct mddev *mddev, *new = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 754)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 755) if (unit && MAJOR(unit) != MD_MAJOR)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 756) unit &= ~((1<<MdpMinorShift)-1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 757)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 758) retry:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 759) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 760)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 761) if (unit) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 762) mddev = mddev_find_locked(unit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 763) if (mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 764) mddev_get(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 765) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 766) kfree(new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 767) return mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 768) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 769)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 770) if (new) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 771) list_add(&new->all_mddevs, &all_mddevs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 772) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 773) new->hold_active = UNTIL_IOCTL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 774) return new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 775) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 776) } else if (new) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 777) /* find an unused unit number */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 778) static int next_minor = 512;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 779) int start = next_minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 780) int is_free = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 781) int dev = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 782) while (!is_free) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 783) dev = MKDEV(MD_MAJOR, next_minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 784) next_minor++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 785) if (next_minor > MINORMASK)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 786) next_minor = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 787) if (next_minor == start) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 788) /* Oh dear, all in use. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 789) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 790) kfree(new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 791) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 792) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 793)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 794) is_free = !mddev_find_locked(dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 795) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 796) new->unit = dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 797) new->md_minor = MINOR(dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 798) new->hold_active = UNTIL_STOP;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 799) list_add(&new->all_mddevs, &all_mddevs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 800) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 801) return new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 802) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 803) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 804)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 805) new = kzalloc(sizeof(*new), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 806) if (!new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 807) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 808)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 809) new->unit = unit;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 810) if (MAJOR(unit) == MD_MAJOR)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 811) new->md_minor = MINOR(unit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 812) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 813) new->md_minor = MINOR(unit) >> MdpMinorShift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 814)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 815) mddev_init(new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 816)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 817) goto retry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 818) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 819)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 820) static struct attribute_group md_redundancy_group;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 821)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 822) void mddev_unlock(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 823) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 824) if (mddev->to_remove) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 825) /* These cannot be removed under reconfig_mutex as
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 826) * an access to the files will try to take reconfig_mutex
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 827) * while holding the file unremovable, which leads to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 828) * a deadlock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 829) * So hold set sysfs_active while the remove in happeing,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 830) * and anything else which might set ->to_remove or my
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 831) * otherwise change the sysfs namespace will fail with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 832) * -EBUSY if sysfs_active is still set.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 833) * We set sysfs_active under reconfig_mutex and elsewhere
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 834) * test it under the same mutex to ensure its correct value
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 835) * is seen.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 836) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 837) struct attribute_group *to_remove = mddev->to_remove;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 838) mddev->to_remove = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 839) mddev->sysfs_active = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 840) mutex_unlock(&mddev->reconfig_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 841)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 842) if (mddev->kobj.sd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 843) if (to_remove != &md_redundancy_group)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 844) sysfs_remove_group(&mddev->kobj, to_remove);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 845) if (mddev->pers == NULL ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 846) mddev->pers->sync_request == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 847) sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 848) if (mddev->sysfs_action)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 849) sysfs_put(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 850) if (mddev->sysfs_completed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 851) sysfs_put(mddev->sysfs_completed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 852) if (mddev->sysfs_degraded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 853) sysfs_put(mddev->sysfs_degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 854) mddev->sysfs_action = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 855) mddev->sysfs_completed = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 856) mddev->sysfs_degraded = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 857) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 858) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 859) mddev->sysfs_active = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 860) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 861) mutex_unlock(&mddev->reconfig_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 862)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 863) /* As we've dropped the mutex we need a spinlock to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 864) * make sure the thread doesn't disappear
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 865) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 866) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 867) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 868) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 869) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 870) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 871) EXPORT_SYMBOL_GPL(mddev_unlock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 872)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 873) struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 874) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 875) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 876)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 877) rdev_for_each_rcu(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 878) if (rdev->desc_nr == nr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 879) return rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 880)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 881) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 882) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 883) EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 884)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 885) static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 886) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 887) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 888)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 889) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 890) if (rdev->bdev->bd_dev == dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 891) return rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 892)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 893) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 894) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 895)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 896) struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 897) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 898) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 899)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 900) rdev_for_each_rcu(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 901) if (rdev->bdev->bd_dev == dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 902) return rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 903)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 904) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 905) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 906) EXPORT_SYMBOL_GPL(md_find_rdev_rcu);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 907)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 908) static struct md_personality *find_pers(int level, char *clevel)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 909) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 910) struct md_personality *pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 911) list_for_each_entry(pers, &pers_list, list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 912) if (level != LEVEL_NONE && pers->level == level)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 913) return pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 914) if (strcmp(pers->name, clevel)==0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 915) return pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 916) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 917) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 918) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 919)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 920) /* return the offset of the super block in 512byte sectors */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 921) static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 922) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 923) sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 924) return MD_NEW_SIZE_SECTORS(num_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 925) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 926)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 927) static int alloc_disk_sb(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 928) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 929) rdev->sb_page = alloc_page(GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 930) if (!rdev->sb_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 931) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 932) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 933) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 934)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 935) void md_rdev_clear(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 936) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 937) if (rdev->sb_page) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 938) put_page(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 939) rdev->sb_loaded = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 940) rdev->sb_page = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 941) rdev->sb_start = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 942) rdev->sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 943) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 944) if (rdev->bb_page) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 945) put_page(rdev->bb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 946) rdev->bb_page = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 947) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 948) badblocks_exit(&rdev->badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 949) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 950) EXPORT_SYMBOL_GPL(md_rdev_clear);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 951)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 952) static void super_written(struct bio *bio)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 953) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 954) struct md_rdev *rdev = bio->bi_private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 955) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 956)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 957) if (bio->bi_status) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 958) pr_err("md: %s gets error=%d\n", __func__,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 959) blk_status_to_errno(bio->bi_status));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 960) md_error(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 961) if (!test_bit(Faulty, &rdev->flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 962) && (bio->bi_opf & MD_FAILFAST)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 963) set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 964) set_bit(LastDev, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 965) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 966) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 967) clear_bit(LastDev, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 968)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 969) if (atomic_dec_and_test(&mddev->pending_writes))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 970) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 971) rdev_dec_pending(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 972) bio_put(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 973) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 974)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 975) void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 976) sector_t sector, int size, struct page *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 977) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 978) /* write first size bytes of page to sector of rdev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 979) * Increment mddev->pending_writes before returning
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 980) * and decrement it on completion, waking up sb_wait
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 981) * if zero is reached.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 982) * If an error occurred, call md_error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 983) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 984) struct bio *bio;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 985) int ff = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 986)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 987) if (!page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 988) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 989)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 990) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 991) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 992)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 993) bio = md_bio_alloc_sync(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 994)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 995) atomic_inc(&rdev->nr_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 996)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 997) bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 998) bio->bi_iter.bi_sector = sector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 999) bio_add_page(bio, page, size, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1000) bio->bi_private = rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1001) bio->bi_end_io = super_written;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1002)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1003) if (test_bit(MD_FAILFAST_SUPPORTED, &mddev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1004) test_bit(FailFast, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1005) !test_bit(LastDev, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1006) ff = MD_FAILFAST;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1007) bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA | ff;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1008)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1009) atomic_inc(&mddev->pending_writes);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1010) submit_bio(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1011) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1012)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1013) int md_super_wait(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1014) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1015) /* wait for all superblock writes that were scheduled to complete */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1016) wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1017) if (test_and_clear_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1018) return -EAGAIN;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1019) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1020) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1021)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1022) int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1023) struct page *page, int op, int op_flags, bool metadata_op)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1024) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1025) struct bio *bio = md_bio_alloc_sync(rdev->mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1026) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1027)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1028) if (metadata_op && rdev->meta_bdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1029) bio_set_dev(bio, rdev->meta_bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1030) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1031) bio_set_dev(bio, rdev->bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1032) bio_set_op_attrs(bio, op, op_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1033) if (metadata_op)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1034) bio->bi_iter.bi_sector = sector + rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1035) else if (rdev->mddev->reshape_position != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1036) (rdev->mddev->reshape_backwards ==
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1037) (sector >= rdev->mddev->reshape_position)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1038) bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1039) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1040) bio->bi_iter.bi_sector = sector + rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1041) bio_add_page(bio, page, size, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1042)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1043) submit_bio_wait(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1044)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1045) ret = !bio->bi_status;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1046) bio_put(bio);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1047) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1048) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1049) EXPORT_SYMBOL_GPL(sync_page_io);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1050)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1051) static int read_disk_sb(struct md_rdev *rdev, int size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1052) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1053) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1054)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1055) if (rdev->sb_loaded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1056) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1057)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1058) if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1059) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1060) rdev->sb_loaded = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1061) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1062)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1063) fail:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1064) pr_err("md: disabled device %s, could not read superblock.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1065) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1066) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1067) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1068)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1069) static int md_uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1070) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1071) return sb1->set_uuid0 == sb2->set_uuid0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1072) sb1->set_uuid1 == sb2->set_uuid1 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1073) sb1->set_uuid2 == sb2->set_uuid2 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1074) sb1->set_uuid3 == sb2->set_uuid3;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1075) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1076)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1077) static int md_sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1078) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1079) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1080) mdp_super_t *tmp1, *tmp2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1081)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1082) tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1083) tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1084)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1085) if (!tmp1 || !tmp2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1086) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1087) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1088) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1089)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1090) *tmp1 = *sb1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1091) *tmp2 = *sb2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1092)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1093) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1094) * nr_disks is not constant
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1095) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1096) tmp1->nr_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1097) tmp2->nr_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1098)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1099) ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1100) abort:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1101) kfree(tmp1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1102) kfree(tmp2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1103) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1104) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1105)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1106) static u32 md_csum_fold(u32 csum)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1107) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1108) csum = (csum & 0xffff) + (csum >> 16);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1109) return (csum & 0xffff) + (csum >> 16);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1110) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1111)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1112) static unsigned int calc_sb_csum(mdp_super_t *sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1113) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1114) u64 newcsum = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1115) u32 *sb32 = (u32*)sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1116) int i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1117) unsigned int disk_csum, csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1118)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1119) disk_csum = sb->sb_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1120) sb->sb_csum = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1121)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1122) for (i = 0; i < MD_SB_BYTES/4 ; i++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1123) newcsum += sb32[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1124) csum = (newcsum & 0xffffffff) + (newcsum>>32);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1125)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1126) #ifdef CONFIG_ALPHA
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1127) /* This used to use csum_partial, which was wrong for several
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1128) * reasons including that different results are returned on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1129) * different architectures. It isn't critical that we get exactly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1130) * the same return value as before (we always csum_fold before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1131) * testing, and that removes any differences). However as we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1132) * know that csum_partial always returned a 16bit value on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1133) * alphas, do a fold to maximise conformity to previous behaviour.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1134) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1135) sb->sb_csum = md_csum_fold(disk_csum);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1136) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1137) sb->sb_csum = disk_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1138) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1139) return csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1140) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1141)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1142) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1143) * Handle superblock details.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1144) * We want to be able to handle multiple superblock formats
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1145) * so we have a common interface to them all, and an array of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1146) * different handlers.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1147) * We rely on user-space to write the initial superblock, and support
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1148) * reading and updating of superblocks.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1149) * Interface methods are:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1150) * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1151) * loads and validates a superblock on dev.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1152) * if refdev != NULL, compare superblocks on both devices
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1153) * Return:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1154) * 0 - dev has a superblock that is compatible with refdev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1155) * 1 - dev has a superblock that is compatible and newer than refdev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1156) * so dev should be used as the refdev in future
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1157) * -EINVAL superblock incompatible or invalid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1158) * -othererror e.g. -EIO
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1159) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1160) * int validate_super(struct mddev *mddev, struct md_rdev *dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1161) * Verify that dev is acceptable into mddev.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1162) * The first time, mddev->raid_disks will be 0, and data from
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1163) * dev should be merged in. Subsequent calls check that dev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1164) * is new enough. Return 0 or -EINVAL
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1165) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1166) * void sync_super(struct mddev *mddev, struct md_rdev *dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1167) * Update the superblock for rdev with data in mddev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1168) * This does not write to disc.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1169) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1170) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1171)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1172) struct super_type {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1173) char *name;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1174) struct module *owner;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1175) int (*load_super)(struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1176) struct md_rdev *refdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1177) int minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1178) int (*validate_super)(struct mddev *mddev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1179) struct md_rdev *rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1180) void (*sync_super)(struct mddev *mddev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1181) struct md_rdev *rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1182) unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1183) sector_t num_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1184) int (*allow_new_offset)(struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1185) unsigned long long new_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1186) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1187)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1188) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1189) * Check that the given mddev has no bitmap.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1190) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1191) * This function is called from the run method of all personalities that do not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1192) * support bitmaps. It prints an error message and returns non-zero if mddev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1193) * has a bitmap. Otherwise, it returns 0.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1194) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1195) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1196) int md_check_no_bitmap(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1197) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1198) if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1199) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1200) pr_warn("%s: bitmaps are not supported for %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1201) mdname(mddev), mddev->pers->name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1202) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1203) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1204) EXPORT_SYMBOL(md_check_no_bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1205)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1206) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1207) * load_super for 0.90.0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1208) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1209) static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1210) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1211) char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1212) mdp_super_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1213) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1214) bool spare_disk = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1215)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1216) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1217) * Calculate the position of the superblock (512byte sectors),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1218) * it's at the end of the disk.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1219) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1220) * It also happens to be a multiple of 4Kb.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1221) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1222) rdev->sb_start = calc_dev_sboffset(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1223)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1224) ret = read_disk_sb(rdev, MD_SB_BYTES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1225) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1226) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1227)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1228) ret = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1229)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1230) bdevname(rdev->bdev, b);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1231) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1232)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1233) if (sb->md_magic != MD_SB_MAGIC) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1234) pr_warn("md: invalid raid superblock magic on %s\n", b);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1235) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1236) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1237)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1238) if (sb->major_version != 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1239) sb->minor_version < 90 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1240) sb->minor_version > 91) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1241) pr_warn("Bad version number %d.%d on %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1242) sb->major_version, sb->minor_version, b);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1243) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1244) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1245)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1246) if (sb->raid_disks <= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1247) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1248)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1249) if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1250) pr_warn("md: invalid superblock checksum on %s\n", b);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1251) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1252) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1253)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1254) rdev->preferred_minor = sb->md_minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1255) rdev->data_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1256) rdev->new_data_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1257) rdev->sb_size = MD_SB_BYTES;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1258) rdev->badblocks.shift = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1259)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1260) if (sb->level == LEVEL_MULTIPATH)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1261) rdev->desc_nr = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1262) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1263) rdev->desc_nr = sb->this_disk.number;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1264)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1265) /* not spare disk, or LEVEL_MULTIPATH */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1266) if (sb->level == LEVEL_MULTIPATH ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1267) (rdev->desc_nr >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1268) rdev->desc_nr < MD_SB_DISKS &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1269) sb->disks[rdev->desc_nr].state &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1270) ((1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE))))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1271) spare_disk = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1272)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1273) if (!refdev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1274) if (!spare_disk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1275) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1276) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1277) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1278) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1279) __u64 ev1, ev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1280) mdp_super_t *refsb = page_address(refdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1281) if (!md_uuid_equal(refsb, sb)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1282) pr_warn("md: %s has different UUID to %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1283) b, bdevname(refdev->bdev,b2));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1284) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1285) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1286) if (!md_sb_equal(refsb, sb)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1287) pr_warn("md: %s has same UUID but different superblock to %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1288) b, bdevname(refdev->bdev, b2));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1289) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1290) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1291) ev1 = md_event(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1292) ev2 = md_event(refsb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1293)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1294) if (!spare_disk && ev1 > ev2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1295) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1296) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1297) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1298) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1299) rdev->sectors = rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1300) /* Limit to 4TB as metadata cannot record more than that.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1301) * (not needed for Linear and RAID0 as metadata doesn't
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1302) * record this size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1303) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1304) if ((u64)rdev->sectors >= (2ULL << 32) && sb->level >= 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1305) rdev->sectors = (sector_t)(2ULL << 32) - 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1306)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1307) if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1308) /* "this cannot possibly happen" ... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1309) ret = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1310)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1311) abort:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1312) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1313) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1314)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1315) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1316) * validate_super for 0.90.0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1317) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1318) static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1319) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1320) mdp_disk_t *desc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1321) mdp_super_t *sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1322) __u64 ev1 = md_event(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1323)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1324) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1325) clear_bit(Faulty, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1326) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1327) clear_bit(Bitmap_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1328) clear_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1329)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1330) if (mddev->raid_disks == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1331) mddev->major_version = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1332) mddev->minor_version = sb->minor_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1333) mddev->patch_version = sb->patch_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1334) mddev->external = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1335) mddev->chunk_sectors = sb->chunk_size >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1336) mddev->ctime = sb->ctime;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1337) mddev->utime = sb->utime;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1338) mddev->level = sb->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1339) mddev->clevel[0] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1340) mddev->layout = sb->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1341) mddev->raid_disks = sb->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1342) mddev->dev_sectors = ((sector_t)sb->size) * 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1343) mddev->events = ev1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1344) mddev->bitmap_info.offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1345) mddev->bitmap_info.space = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1346) /* bitmap can use 60 K after the 4K superblocks */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1347) mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1348) mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1349) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1350)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1351) if (mddev->minor_version >= 91) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1352) mddev->reshape_position = sb->reshape_position;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1353) mddev->delta_disks = sb->delta_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1354) mddev->new_level = sb->new_level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1355) mddev->new_layout = sb->new_layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1356) mddev->new_chunk_sectors = sb->new_chunk >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1357) if (mddev->delta_disks < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1358) mddev->reshape_backwards = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1359) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1360) mddev->reshape_position = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1361) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1362) mddev->new_level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1363) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1364) mddev->new_chunk_sectors = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1365) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1366) if (mddev->level == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1367) mddev->layout = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1368)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1369) if (sb->state & (1<<MD_SB_CLEAN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1370) mddev->recovery_cp = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1371) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1372) if (sb->events_hi == sb->cp_events_hi &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1373) sb->events_lo == sb->cp_events_lo) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1374) mddev->recovery_cp = sb->recovery_cp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1375) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1376) mddev->recovery_cp = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1377) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1378)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1379) memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1380) memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1381) memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1382) memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1383)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1384) mddev->max_disks = MD_SB_DISKS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1385)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1386) if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1387) mddev->bitmap_info.file == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1388) mddev->bitmap_info.offset =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1389) mddev->bitmap_info.default_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1390) mddev->bitmap_info.space =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1391) mddev->bitmap_info.default_space;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1392) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1393)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1394) } else if (mddev->pers == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1395) /* Insist on good event counter while assembling, except
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1396) * for spares (which don't need an event count) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1397) ++ev1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1398) if (sb->disks[rdev->desc_nr].state & (
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1399) (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1400) if (ev1 < mddev->events)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1401) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1402) } else if (mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1403) /* if adding to array with a bitmap, then we can accept an
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1404) * older device ... but not too old.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1405) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1406) if (ev1 < mddev->bitmap->events_cleared)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1407) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1408) if (ev1 < mddev->events)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1409) set_bit(Bitmap_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1410) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1411) if (ev1 < mddev->events)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1412) /* just a hot-add of a new device, leave raid_disk at -1 */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1413) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1414) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1415)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1416) if (mddev->level != LEVEL_MULTIPATH) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1417) desc = sb->disks + rdev->desc_nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1418)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1419) if (desc->state & (1<<MD_DISK_FAULTY))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1420) set_bit(Faulty, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1421) else if (desc->state & (1<<MD_DISK_SYNC) /* &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1422) desc->raid_disk < mddev->raid_disks */) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1423) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1424) rdev->raid_disk = desc->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1425) rdev->saved_raid_disk = desc->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1426) } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1427) /* active but not in sync implies recovery up to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1428) * reshape position. We don't know exactly where
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1429) * that is, so set to zero for now */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1430) if (mddev->minor_version >= 91) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1431) rdev->recovery_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1432) rdev->raid_disk = desc->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1433) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1434) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1435) if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1436) set_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1437) if (desc->state & (1<<MD_DISK_FAILFAST))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1438) set_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1439) } else /* MULTIPATH are always insync */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1440) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1441) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1442) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1443)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1444) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1445) * sync_super for 0.90.0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1446) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1447) static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1448) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1449) mdp_super_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1450) struct md_rdev *rdev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1451) int next_spare = mddev->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1452)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1453) /* make rdev->sb match mddev data..
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1454) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1455) * 1/ zero out disks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1456) * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1457) * 3/ any empty disks < next_spare become removed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1458) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1459) * disks[0] gets initialised to REMOVED because
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1460) * we cannot be sure from other fields if it has
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1461) * been initialised or not.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1462) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1463) int i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1464) int active=0, working=0,failed=0,spare=0,nr_disks=0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1465)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1466) rdev->sb_size = MD_SB_BYTES;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1467)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1468) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1469)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1470) memset(sb, 0, sizeof(*sb));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1471)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1472) sb->md_magic = MD_SB_MAGIC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1473) sb->major_version = mddev->major_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1474) sb->patch_version = mddev->patch_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1475) sb->gvalid_words = 0; /* ignored */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1476) memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1477) memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1478) memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1479) memcpy(&sb->set_uuid3, mddev->uuid+12,4);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1480)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1481) sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1482) sb->level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1483) sb->size = mddev->dev_sectors / 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1484) sb->raid_disks = mddev->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1485) sb->md_minor = mddev->md_minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1486) sb->not_persistent = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1487) sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1488) sb->state = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1489) sb->events_hi = (mddev->events>>32);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1490) sb->events_lo = (u32)mddev->events;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1491)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1492) if (mddev->reshape_position == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1493) sb->minor_version = 90;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1494) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1495) sb->minor_version = 91;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1496) sb->reshape_position = mddev->reshape_position;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1497) sb->new_level = mddev->new_level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1498) sb->delta_disks = mddev->delta_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1499) sb->new_layout = mddev->new_layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1500) sb->new_chunk = mddev->new_chunk_sectors << 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1501) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1502) mddev->minor_version = sb->minor_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1503) if (mddev->in_sync)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1504) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1505) sb->recovery_cp = mddev->recovery_cp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1506) sb->cp_events_hi = (mddev->events>>32);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1507) sb->cp_events_lo = (u32)mddev->events;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1508) if (mddev->recovery_cp == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1509) sb->state = (1<< MD_SB_CLEAN);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1510) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1511) sb->recovery_cp = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1512)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1513) sb->layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1514) sb->chunk_size = mddev->chunk_sectors << 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1515)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1516) if (mddev->bitmap && mddev->bitmap_info.file == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1517) sb->state |= (1<<MD_SB_BITMAP_PRESENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1518)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1519) sb->disks[0].state = (1<<MD_DISK_REMOVED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1520) rdev_for_each(rdev2, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1521) mdp_disk_t *d;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1522) int desc_nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1523) int is_active = test_bit(In_sync, &rdev2->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1524)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1525) if (rdev2->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1526) sb->minor_version >= 91)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1527) /* we have nowhere to store the recovery_offset,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1528) * but if it is not below the reshape_position,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1529) * we can piggy-back on that.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1530) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1531) is_active = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1532) if (rdev2->raid_disk < 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1533) test_bit(Faulty, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1534) is_active = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1535) if (is_active)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1536) desc_nr = rdev2->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1537) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1538) desc_nr = next_spare++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1539) rdev2->desc_nr = desc_nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1540) d = &sb->disks[rdev2->desc_nr];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1541) nr_disks++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1542) d->number = rdev2->desc_nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1543) d->major = MAJOR(rdev2->bdev->bd_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1544) d->minor = MINOR(rdev2->bdev->bd_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1545) if (is_active)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1546) d->raid_disk = rdev2->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1547) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1548) d->raid_disk = rdev2->desc_nr; /* compatibility */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1549) if (test_bit(Faulty, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1550) d->state = (1<<MD_DISK_FAULTY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1551) else if (is_active) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1552) d->state = (1<<MD_DISK_ACTIVE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1553) if (test_bit(In_sync, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1554) d->state |= (1<<MD_DISK_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1555) active++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1556) working++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1557) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1558) d->state = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1559) spare++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1560) working++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1561) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1562) if (test_bit(WriteMostly, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1563) d->state |= (1<<MD_DISK_WRITEMOSTLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1564) if (test_bit(FailFast, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1565) d->state |= (1<<MD_DISK_FAILFAST);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1566) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1567) /* now set the "removed" and "faulty" bits on any missing devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1568) for (i=0 ; i < mddev->raid_disks ; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1569) mdp_disk_t *d = &sb->disks[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1570) if (d->state == 0 && d->number == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1571) d->number = i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1572) d->raid_disk = i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1573) d->state = (1<<MD_DISK_REMOVED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1574) d->state |= (1<<MD_DISK_FAULTY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1575) failed++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1576) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1577) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1578) sb->nr_disks = nr_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1579) sb->active_disks = active;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1580) sb->working_disks = working;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1581) sb->failed_disks = failed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1582) sb->spare_disks = spare;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1583)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1584) sb->this_disk = sb->disks[rdev->desc_nr];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1585) sb->sb_csum = calc_sb_csum(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1586) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1587)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1588) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1589) * rdev_size_change for 0.90.0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1590) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1591) static unsigned long long
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1592) super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1593) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1594) if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1595) return 0; /* component must fit device */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1596) if (rdev->mddev->bitmap_info.offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1597) return 0; /* can't move bitmap */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1598) rdev->sb_start = calc_dev_sboffset(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1599) if (!num_sectors || num_sectors > rdev->sb_start)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1600) num_sectors = rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1601) /* Limit to 4TB as metadata cannot record more than that.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1602) * 4TB == 2^32 KB, or 2*2^32 sectors.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1603) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1604) if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1605) num_sectors = (sector_t)(2ULL << 32) - 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1606) do {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1607) md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1608) rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1609) } while (md_super_wait(rdev->mddev) < 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1610) return num_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1611) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1612)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1613) static int
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1614) super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1615) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1616) /* non-zero offset changes not possible with v0.90 */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1617) return new_offset == 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1618) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1619)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1620) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1621) * version 1 superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1622) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1623)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1624) static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1625) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1626) __le32 disk_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1627) u32 csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1628) unsigned long long newcsum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1629) int size = 256 + le32_to_cpu(sb->max_dev)*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1630) __le32 *isuper = (__le32*)sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1631)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1632) disk_csum = sb->sb_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1633) sb->sb_csum = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1634) newcsum = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1635) for (; size >= 4; size -= 4)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1636) newcsum += le32_to_cpu(*isuper++);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1637)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1638) if (size == 2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1639) newcsum += le16_to_cpu(*(__le16*) isuper);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1640)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1641) csum = (newcsum & 0xffffffff) + (newcsum >> 32);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1642) sb->sb_csum = disk_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1643) return cpu_to_le32(csum);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1644) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1645)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1646) static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1647) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1648) struct mdp_superblock_1 *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1649) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1650) sector_t sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1651) sector_t sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1652) char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1653) int bmask;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1654) bool spare_disk = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1655)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1656) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1657) * Calculate the position of the superblock in 512byte sectors.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1658) * It is always aligned to a 4K boundary and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1659) * depeding on minor_version, it can be:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1660) * 0: At least 8K, but less than 12K, from end of device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1661) * 1: At start of device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1662) * 2: 4K from start of device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1663) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1664) switch(minor_version) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1665) case 0:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1666) sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1667) sb_start -= 8*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1668) sb_start &= ~(sector_t)(4*2-1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1669) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1670) case 1:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1671) sb_start = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1672) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1673) case 2:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1674) sb_start = 8;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1675) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1676) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1677) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1678) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1679) rdev->sb_start = sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1680)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1681) /* superblock is rarely larger than 1K, but it can be larger,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1682) * and it is safe to read 4k, so we do that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1683) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1684) ret = read_disk_sb(rdev, 4096);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1685) if (ret) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1686)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1687) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1688)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1689) if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1690) sb->major_version != cpu_to_le32(1) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1691) le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1692) le64_to_cpu(sb->super_offset) != rdev->sb_start ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1693) (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1694) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1695)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1696) if (calc_sb_1_csum(sb) != sb->sb_csum) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1697) pr_warn("md: invalid superblock checksum on %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1698) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1699) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1700) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1701) if (le64_to_cpu(sb->data_size) < 10) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1702) pr_warn("md: data_size too small on %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1703) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1704) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1705) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1706) if (sb->pad0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1707) sb->pad3[0] ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1708) memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1709) /* Some padding is non-zero, might be a new feature */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1710) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1711)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1712) rdev->preferred_minor = 0xffff;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1713) rdev->data_offset = le64_to_cpu(sb->data_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1714) rdev->new_data_offset = rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1715) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1716) (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1717) rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1718) atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1719)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1720) rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1721) bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1722) if (rdev->sb_size & bmask)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1723) rdev->sb_size = (rdev->sb_size | bmask) + 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1724)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1725) if (minor_version
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1726) && rdev->data_offset < sb_start + (rdev->sb_size/512))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1727) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1728) if (minor_version
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1729) && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1730) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1731)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1732) if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1733) rdev->desc_nr = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1734) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1735) rdev->desc_nr = le32_to_cpu(sb->dev_number);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1736)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1737) if (!rdev->bb_page) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1738) rdev->bb_page = alloc_page(GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1739) if (!rdev->bb_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1740) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1741) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1742) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1743) rdev->badblocks.count == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1744) /* need to load the bad block list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1745) * Currently we limit it to one page.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1746) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1747) s32 offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1748) sector_t bb_sector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1749) __le64 *bbp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1750) int i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1751) int sectors = le16_to_cpu(sb->bblog_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1752) if (sectors > (PAGE_SIZE / 512))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1753) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1754) offset = le32_to_cpu(sb->bblog_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1755) if (offset == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1756) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1757) bb_sector = (long long)offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1758) if (!sync_page_io(rdev, bb_sector, sectors << 9,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1759) rdev->bb_page, REQ_OP_READ, 0, true))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1760) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1761) bbp = (__le64 *)page_address(rdev->bb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1762) rdev->badblocks.shift = sb->bblog_shift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1763) for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1764) u64 bb = le64_to_cpu(*bbp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1765) int count = bb & (0x3ff);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1766) u64 sector = bb >> 10;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1767) sector <<= sb->bblog_shift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1768) count <<= sb->bblog_shift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1769) if (bb + 1 == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1770) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1771) if (badblocks_set(&rdev->badblocks, sector, count, 1))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1772) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1773) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1774) } else if (sb->bblog_offset != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1775) rdev->badblocks.shift = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1776)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1777) if ((le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1778) (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1779) rdev->ppl.offset = (__s16)le16_to_cpu(sb->ppl.offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1780) rdev->ppl.size = le16_to_cpu(sb->ppl.size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1781) rdev->ppl.sector = rdev->sb_start + rdev->ppl.offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1782) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1784) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1785) sb->level != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1786) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1787)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1788) /* not spare disk, or LEVEL_MULTIPATH */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1789) if (sb->level == cpu_to_le32(LEVEL_MULTIPATH) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1790) (rdev->desc_nr >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1791) rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1792) (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1793) le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1794) spare_disk = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1795)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1796) if (!refdev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1797) if (!spare_disk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1798) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1799) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1800) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1801) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1802) __u64 ev1, ev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1803) struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1804)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1805) if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1806) sb->level != refsb->level ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1807) sb->layout != refsb->layout ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1808) sb->chunksize != refsb->chunksize) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1809) pr_warn("md: %s has strangely different superblock to %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1810) bdevname(rdev->bdev,b),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1811) bdevname(refdev->bdev,b2));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1812) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1813) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1814) ev1 = le64_to_cpu(sb->events);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1815) ev2 = le64_to_cpu(refsb->events);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1816)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1817) if (!spare_disk && ev1 > ev2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1818) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1819) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1820) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1821) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1822) if (minor_version) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1823) sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1824) sectors -= rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1825) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1826) sectors = rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1827) if (sectors < le64_to_cpu(sb->data_size))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1828) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1829) rdev->sectors = le64_to_cpu(sb->data_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1830) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1831) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1832)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1833) static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1834) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1835) struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1836) __u64 ev1 = le64_to_cpu(sb->events);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1837)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1838) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1839) clear_bit(Faulty, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1840) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1841) clear_bit(Bitmap_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1842) clear_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1843)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1844) if (mddev->raid_disks == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1845) mddev->major_version = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1846) mddev->patch_version = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1847) mddev->external = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1848) mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1849) mddev->ctime = le64_to_cpu(sb->ctime);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1850) mddev->utime = le64_to_cpu(sb->utime);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1851) mddev->level = le32_to_cpu(sb->level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1852) mddev->clevel[0] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1853) mddev->layout = le32_to_cpu(sb->layout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1854) mddev->raid_disks = le32_to_cpu(sb->raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1855) mddev->dev_sectors = le64_to_cpu(sb->size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1856) mddev->events = ev1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1857) mddev->bitmap_info.offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1858) mddev->bitmap_info.space = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1859) /* Default location for bitmap is 1K after superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1860) * using 3K - total of 4K
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1861) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1862) mddev->bitmap_info.default_offset = 1024 >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1863) mddev->bitmap_info.default_space = (4096-1024) >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1864) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1865)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1866) mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1867) memcpy(mddev->uuid, sb->set_uuid, 16);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1868)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1869) mddev->max_disks = (4096-256)/2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1870)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1871) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1872) mddev->bitmap_info.file == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1873) mddev->bitmap_info.offset =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1874) (__s32)le32_to_cpu(sb->bitmap_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1875) /* Metadata doesn't record how much space is available.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1876) * For 1.0, we assume we can use up to the superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1877) * if before, else to 4K beyond superblock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1878) * For others, assume no change is possible.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1879) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1880) if (mddev->minor_version > 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1881) mddev->bitmap_info.space = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1882) else if (mddev->bitmap_info.offset > 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1883) mddev->bitmap_info.space =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1884) 8 - mddev->bitmap_info.offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1885) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1886) mddev->bitmap_info.space =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1887) -mddev->bitmap_info.offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1888) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1889)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1890) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1891) mddev->reshape_position = le64_to_cpu(sb->reshape_position);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1892) mddev->delta_disks = le32_to_cpu(sb->delta_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1893) mddev->new_level = le32_to_cpu(sb->new_level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1894) mddev->new_layout = le32_to_cpu(sb->new_layout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1895) mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1896) if (mddev->delta_disks < 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1897) (mddev->delta_disks == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1898) (le32_to_cpu(sb->feature_map)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1899) & MD_FEATURE_RESHAPE_BACKWARDS)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1900) mddev->reshape_backwards = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1901) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1902) mddev->reshape_position = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1903) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1904) mddev->new_level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1905) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1906) mddev->new_chunk_sectors = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1907) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1908)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1909) if (mddev->level == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1910) !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1911) mddev->layout = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1912)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1913) if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1914) set_bit(MD_HAS_JOURNAL, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1915)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1916) if (le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1917) (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1918) if (le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1919) (MD_FEATURE_BITMAP_OFFSET | MD_FEATURE_JOURNAL))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1920) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1921) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1922) (le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1923) MD_FEATURE_MULTIPLE_PPLS))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1924) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1925) set_bit(MD_HAS_PPL, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1926) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1927) } else if (mddev->pers == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1928) /* Insist of good event counter while assembling, except for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1929) * spares (which don't need an event count) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1930) ++ev1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1931) if (rdev->desc_nr >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1932) rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1933) (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1934) le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1935) if (ev1 < mddev->events)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1936) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1937) } else if (mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1938) /* If adding to array with a bitmap, then we can accept an
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1939) * older device, but not too old.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1940) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1941) if (ev1 < mddev->bitmap->events_cleared)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1942) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1943) if (ev1 < mddev->events)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1944) set_bit(Bitmap_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1945) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1946) if (ev1 < mddev->events)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1947) /* just a hot-add of a new device, leave raid_disk at -1 */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1948) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1949) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1950) if (mddev->level != LEVEL_MULTIPATH) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1951) int role;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1952) if (rdev->desc_nr < 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1953) rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1954) role = MD_DISK_ROLE_SPARE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1955) rdev->desc_nr = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1956) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1957) role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1958) switch(role) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1959) case MD_DISK_ROLE_SPARE: /* spare */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1960) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1961) case MD_DISK_ROLE_FAULTY: /* faulty */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1962) set_bit(Faulty, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1963) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1964) case MD_DISK_ROLE_JOURNAL: /* journal device */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1965) if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1966) /* journal device without journal feature */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1967) pr_warn("md: journal device provided without journal feature, ignoring the device\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1968) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1969) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1970) set_bit(Journal, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1971) rdev->journal_tail = le64_to_cpu(sb->journal_tail);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1972) rdev->raid_disk = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1973) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1974) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1975) rdev->saved_raid_disk = role;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1976) if ((le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1977) MD_FEATURE_RECOVERY_OFFSET)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1978) rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1979) if (!(le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1980) MD_FEATURE_RECOVERY_BITMAP))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1981) rdev->saved_raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1982) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1983) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1984) * If the array is FROZEN, then the device can't
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1985) * be in_sync with rest of array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1986) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1987) if (!test_bit(MD_RECOVERY_FROZEN,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1988) &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1989) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1990) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1991) rdev->raid_disk = role;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1992) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1993) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1994) if (sb->devflags & WriteMostly1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1995) set_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1996) if (sb->devflags & FailFast1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1997) set_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1998) if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1999) set_bit(Replacement, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2000) } else /* MULTIPATH are always insync */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2001) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2002)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2003) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2004) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2005)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2006) static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2007) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2008) struct mdp_superblock_1 *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2009) struct md_rdev *rdev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2010) int max_dev, i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2011) /* make rdev->sb match mddev and rdev data. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2012)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2013) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2014)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2015) sb->feature_map = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2016) sb->pad0 = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2017) sb->recovery_offset = cpu_to_le64(0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2018) memset(sb->pad3, 0, sizeof(sb->pad3));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2019)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2020) sb->utime = cpu_to_le64((__u64)mddev->utime);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2021) sb->events = cpu_to_le64(mddev->events);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2022) if (mddev->in_sync)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2023) sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2024) else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2025) sb->resync_offset = cpu_to_le64(MaxSector);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2026) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2027) sb->resync_offset = cpu_to_le64(0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2028)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2029) sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2030)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2031) sb->raid_disks = cpu_to_le32(mddev->raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2032) sb->size = cpu_to_le64(mddev->dev_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2033) sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2034) sb->level = cpu_to_le32(mddev->level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2035) sb->layout = cpu_to_le32(mddev->layout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2036) if (test_bit(FailFast, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2037) sb->devflags |= FailFast1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2038) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2039) sb->devflags &= ~FailFast1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2040)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2041) if (test_bit(WriteMostly, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2042) sb->devflags |= WriteMostly1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2043) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2044) sb->devflags &= ~WriteMostly1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2045) sb->data_offset = cpu_to_le64(rdev->data_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2046) sb->data_size = cpu_to_le64(rdev->sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2047)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2048) if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2049) sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2050) sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2051) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2052)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2053) if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2054) !test_bit(In_sync, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2055) sb->feature_map |=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2056) cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2057) sb->recovery_offset =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2058) cpu_to_le64(rdev->recovery_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2059) if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2060) sb->feature_map |=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2061) cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2062) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2063) /* Note: recovery_offset and journal_tail share space */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2064) if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2065) sb->journal_tail = cpu_to_le64(rdev->journal_tail);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2066) if (test_bit(Replacement, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2067) sb->feature_map |=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2068) cpu_to_le32(MD_FEATURE_REPLACEMENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2069)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2070) if (mddev->reshape_position != MaxSector) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2071) sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2072) sb->reshape_position = cpu_to_le64(mddev->reshape_position);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2073) sb->new_layout = cpu_to_le32(mddev->new_layout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2074) sb->delta_disks = cpu_to_le32(mddev->delta_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2075) sb->new_level = cpu_to_le32(mddev->new_level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2076) sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2077) if (mddev->delta_disks == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2078) mddev->reshape_backwards)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2079) sb->feature_map
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2080) |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2081) if (rdev->new_data_offset != rdev->data_offset) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2082) sb->feature_map
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2083) |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2084) sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2085) - rdev->data_offset));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2086) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2087) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2088)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2089) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2090) sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2091)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2092) if (rdev->badblocks.count == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2093) /* Nothing to do for bad blocks*/ ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2094) else if (sb->bblog_offset == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2095) /* Cannot record bad blocks on this device */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2096) md_error(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2097) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2098) struct badblocks *bb = &rdev->badblocks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2099) __le64 *bbp = (__le64 *)page_address(rdev->bb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2100) u64 *p = bb->page;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2101) sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2102) if (bb->changed) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2103) unsigned seq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2104)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2105) retry:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2106) seq = read_seqbegin(&bb->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2107)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2108) memset(bbp, 0xff, PAGE_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2109)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2110) for (i = 0 ; i < bb->count ; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2111) u64 internal_bb = p[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2112) u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2113) | BB_LEN(internal_bb));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2114) bbp[i] = cpu_to_le64(store_bb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2115) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2116) bb->changed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2117) if (read_seqretry(&bb->lock, seq))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2118) goto retry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2119)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2120) bb->sector = (rdev->sb_start +
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2121) (int)le32_to_cpu(sb->bblog_offset));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2122) bb->size = le16_to_cpu(sb->bblog_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2123) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2124) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2125)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2126) max_dev = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2127) rdev_for_each(rdev2, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2128) if (rdev2->desc_nr+1 > max_dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2129) max_dev = rdev2->desc_nr+1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2130)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2131) if (max_dev > le32_to_cpu(sb->max_dev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2132) int bmask;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2133) sb->max_dev = cpu_to_le32(max_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2134) rdev->sb_size = max_dev * 2 + 256;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2135) bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2136) if (rdev->sb_size & bmask)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2137) rdev->sb_size = (rdev->sb_size | bmask) + 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2138) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2139) max_dev = le32_to_cpu(sb->max_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2140)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2141) for (i=0; i<max_dev;i++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2142) sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2143)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2144) if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2145) sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2146)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2147) if (test_bit(MD_HAS_PPL, &mddev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2148) if (test_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2149) sb->feature_map |=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2150) cpu_to_le32(MD_FEATURE_MULTIPLE_PPLS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2151) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2152) sb->feature_map |= cpu_to_le32(MD_FEATURE_PPL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2153) sb->ppl.offset = cpu_to_le16(rdev->ppl.offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2154) sb->ppl.size = cpu_to_le16(rdev->ppl.size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2155) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2156)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2157) rdev_for_each(rdev2, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2158) i = rdev2->desc_nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2159) if (test_bit(Faulty, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2160) sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2161) else if (test_bit(In_sync, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2162) sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2163) else if (test_bit(Journal, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2164) sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2165) else if (rdev2->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2166) sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2167) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2168) sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2169) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2171) sb->sb_csum = calc_sb_1_csum(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2172) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2173)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2174) static sector_t super_1_choose_bm_space(sector_t dev_size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2175) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2176) sector_t bm_space;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2177)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2178) /* if the device is bigger than 8Gig, save 64k for bitmap
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2179) * usage, if bigger than 200Gig, save 128k
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2180) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2181) if (dev_size < 64*2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2182) bm_space = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2183) else if (dev_size - 64*2 >= 200*1024*1024*2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2184) bm_space = 128*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2185) else if (dev_size - 4*2 > 8*1024*1024*2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2186) bm_space = 64*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2187) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2188) bm_space = 4*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2189) return bm_space;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2190) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2191)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2192) static unsigned long long
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2193) super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2194) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2195) struct mdp_superblock_1 *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2196) sector_t max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2197) if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2198) return 0; /* component must fit device */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2199) if (rdev->data_offset != rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2200) return 0; /* too confusing */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2201) if (rdev->sb_start < rdev->data_offset) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2202) /* minor versions 1 and 2; superblock before data */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2203) max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2204) max_sectors -= rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2205) if (!num_sectors || num_sectors > max_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2206) num_sectors = max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2207) } else if (rdev->mddev->bitmap_info.offset) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2208) /* minor version 0 with bitmap we can't move */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2209) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2210) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2211) /* minor version 0; superblock after data */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2212) sector_t sb_start, bm_space;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2213) sector_t dev_size = i_size_read(rdev->bdev->bd_inode) >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2214)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2215) /* 8K is for superblock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2216) sb_start = dev_size - 8*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2217) sb_start &= ~(sector_t)(4*2 - 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2218)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2219) bm_space = super_1_choose_bm_space(dev_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2220)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2221) /* Space that can be used to store date needs to decrease
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2222) * superblock bitmap space and bad block space(4K)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2223) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2224) max_sectors = sb_start - bm_space - 4*2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2225)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2226) if (!num_sectors || num_sectors > max_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2227) num_sectors = max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2228) rdev->sb_start = sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2229) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2230) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2231) sb->data_size = cpu_to_le64(num_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2232) sb->super_offset = cpu_to_le64(rdev->sb_start);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2233) sb->sb_csum = calc_sb_1_csum(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2234) do {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2235) md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2236) rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2237) } while (md_super_wait(rdev->mddev) < 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2238) return num_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2239)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2240) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2241)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2242) static int
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2243) super_1_allow_new_offset(struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2244) unsigned long long new_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2245) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2246) /* All necessary checks on new >= old have been done */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2247) struct bitmap *bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2248) if (new_offset >= rdev->data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2249) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2250)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2251) /* with 1.0 metadata, there is no metadata to tread on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2252) * so we can always move back */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2253) if (rdev->mddev->minor_version == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2254) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2255)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2256) /* otherwise we must be sure not to step on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2257) * any metadata, so stay:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2258) * 36K beyond start of superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2259) * beyond end of badblocks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2260) * beyond write-intent bitmap
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2261) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2262) if (rdev->sb_start + (32+4)*2 > new_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2263) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2264) bitmap = rdev->mddev->bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2265) if (bitmap && !rdev->mddev->bitmap_info.file &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2266) rdev->sb_start + rdev->mddev->bitmap_info.offset +
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2267) bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2268) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2269) if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2270) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2271)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2272) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2273) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2274)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2275) static struct super_type super_types[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2276) [0] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2277) .name = "0.90.0",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2278) .owner = THIS_MODULE,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2279) .load_super = super_90_load,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2280) .validate_super = super_90_validate,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2281) .sync_super = super_90_sync,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2282) .rdev_size_change = super_90_rdev_size_change,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2283) .allow_new_offset = super_90_allow_new_offset,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2284) },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2285) [1] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2286) .name = "md-1",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2287) .owner = THIS_MODULE,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2288) .load_super = super_1_load,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2289) .validate_super = super_1_validate,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2290) .sync_super = super_1_sync,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2291) .rdev_size_change = super_1_rdev_size_change,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2292) .allow_new_offset = super_1_allow_new_offset,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2293) },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2294) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2295)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2296) static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2297) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2298) if (mddev->sync_super) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2299) mddev->sync_super(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2300) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2301) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2302)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2303) BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2304)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2305) super_types[mddev->major_version].sync_super(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2306) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2307)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2308) static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2309) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2310) struct md_rdev *rdev, *rdev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2311)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2312) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2313) rdev_for_each_rcu(rdev, mddev1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2314) if (test_bit(Faulty, &rdev->flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2315) test_bit(Journal, &rdev->flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2316) rdev->raid_disk == -1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2317) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2318) rdev_for_each_rcu(rdev2, mddev2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2319) if (test_bit(Faulty, &rdev2->flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2320) test_bit(Journal, &rdev2->flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2321) rdev2->raid_disk == -1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2322) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2323) if (rdev->bdev->bd_disk == rdev2->bdev->bd_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2324) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2325) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2326) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2327) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2328) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2329) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2330) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2331) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2332)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2333) static LIST_HEAD(pending_raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2334)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2335) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2336) * Try to register data integrity profile for an mddev
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2337) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2338) * This is called when an array is started and after a disk has been kicked
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2339) * from the array. It only succeeds if all working and active component devices
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2340) * are integrity capable with matching profiles.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2341) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2342) int md_integrity_register(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2343) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2344) struct md_rdev *rdev, *reference = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2345)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2346) if (list_empty(&mddev->disks))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2347) return 0; /* nothing to do */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2348) if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2349) return 0; /* shouldn't register, or already is */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2350) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2351) /* skip spares and non-functional disks */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2352) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2353) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2354) if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2355) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2356) if (!reference) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2357) /* Use the first rdev as the reference */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2358) reference = rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2359) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2360) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2361) /* does this rdev's profile match the reference profile? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2362) if (blk_integrity_compare(reference->bdev->bd_disk,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2363) rdev->bdev->bd_disk) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2364) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2365) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2366) if (!reference || !bdev_get_integrity(reference->bdev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2367) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2368) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2369) * All component devices are integrity capable and have matching
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2370) * profiles, register the common profile for the md device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2371) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2372) blk_integrity_register(mddev->gendisk,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2373) bdev_get_integrity(reference->bdev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2374)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2375) pr_debug("md: data integrity enabled on %s\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2376) if (bioset_integrity_create(&mddev->bio_set, BIO_POOL_SIZE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2377) pr_err("md: failed to create integrity pool for %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2378) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2379) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2380) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2381) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2382) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2383) EXPORT_SYMBOL(md_integrity_register);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2384)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2385) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2386) * Attempt to add an rdev, but only if it is consistent with the current
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2387) * integrity profile
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2388) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2389) int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2390) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2391) struct blk_integrity *bi_mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2392) char name[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2393)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2394) if (!mddev->gendisk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2395) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2396)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2397) bi_mddev = blk_get_integrity(mddev->gendisk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2398)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2399) if (!bi_mddev) /* nothing to do */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2400) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2401)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2402) if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2403) pr_err("%s: incompatible integrity profile for %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2404) mdname(mddev), bdevname(rdev->bdev, name));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2405) return -ENXIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2406) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2407)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2408) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2409) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2410) EXPORT_SYMBOL(md_integrity_add_rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2411)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2412) static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2413) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2414) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2415) struct kobject *ko;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2416) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2417)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2418) /* prevent duplicates */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2419) if (find_rdev(mddev, rdev->bdev->bd_dev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2420) return -EEXIST;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2421)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2422) if ((bdev_read_only(rdev->bdev) || bdev_read_only(rdev->meta_bdev)) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2423) mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2424) return -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2425)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2426) /* make sure rdev->sectors exceeds mddev->dev_sectors */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2427) if (!test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2428) rdev->sectors &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2429) (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2430) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2431) /* Cannot change size, so fail
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2432) * If mddev->level <= 0, then we don't care
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2433) * about aligning sizes (e.g. linear)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2434) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2435) if (mddev->level > 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2436) return -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2437) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2438) mddev->dev_sectors = rdev->sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2439) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2440)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2441) /* Verify rdev->desc_nr is unique.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2442) * If it is -1, assign a free number, else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2443) * check number is not in use
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2444) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2445) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2446) if (rdev->desc_nr < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2447) int choice = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2448) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2449) choice = mddev->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2450) while (md_find_rdev_nr_rcu(mddev, choice))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2451) choice++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2452) rdev->desc_nr = choice;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2453) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2454) if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2455) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2456) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2457) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2458) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2459) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2460) if (!test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2461) mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2462) pr_warn("md: %s: array is limited to %d devices\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2463) mdname(mddev), mddev->max_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2464) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2465) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2466) bdevname(rdev->bdev,b);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2467) strreplace(b, '/', '!');
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2468)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2469) rdev->mddev = mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2470) pr_debug("md: bind<%s>\n", b);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2471)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2472) if (mddev->raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2473) mddev_create_serial_pool(mddev, rdev, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2474)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2475) if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2476) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2477)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2478) ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2479) /* failure here is OK */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2480) err = sysfs_create_link(&rdev->kobj, ko, "block");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2481) rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2482) rdev->sysfs_unack_badblocks =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2483) sysfs_get_dirent_safe(rdev->kobj.sd, "unacknowledged_bad_blocks");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2484) rdev->sysfs_badblocks =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2485) sysfs_get_dirent_safe(rdev->kobj.sd, "bad_blocks");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2486)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2487) list_add_rcu(&rdev->same_set, &mddev->disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2488) bd_link_disk_holder(rdev->bdev, mddev->gendisk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2489)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2490) /* May as well allow recovery to be retried once */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2491) mddev->recovery_disabled++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2492)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2493) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2494)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2495) fail:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2496) pr_warn("md: failed to register dev-%s for %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2497) b, mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2498) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2499) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2500)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2501) static void rdev_delayed_delete(struct work_struct *ws)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2502) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2503) struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2504) kobject_del(&rdev->kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2505) kobject_put(&rdev->kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2506) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2507)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2508) static void unbind_rdev_from_array(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2509) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2510) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2511)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2512) bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2513) list_del_rcu(&rdev->same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2514) pr_debug("md: unbind<%s>\n", bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2515) mddev_destroy_serial_pool(rdev->mddev, rdev, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2516) rdev->mddev = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2517) sysfs_remove_link(&rdev->kobj, "block");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2518) sysfs_put(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2519) sysfs_put(rdev->sysfs_unack_badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2520) sysfs_put(rdev->sysfs_badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2521) rdev->sysfs_state = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2522) rdev->sysfs_unack_badblocks = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2523) rdev->sysfs_badblocks = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2524) rdev->badblocks.count = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2525) /* We need to delay this, otherwise we can deadlock when
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2526) * writing to 'remove' to "dev/state". We also need
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2527) * to delay it due to rcu usage.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2528) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2529) synchronize_rcu();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2530) INIT_WORK(&rdev->del_work, rdev_delayed_delete);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2531) kobject_get(&rdev->kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2532) queue_work(md_rdev_misc_wq, &rdev->del_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2533) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2534)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2535) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2536) * prevent the device from being mounted, repartitioned or
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2537) * otherwise reused by a RAID array (or any other kernel
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2538) * subsystem), by bd_claiming the device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2539) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2540) static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2541) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2542) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2543) struct block_device *bdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2544)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2545) bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2546) shared ? (struct md_rdev *)lock_rdev : rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2547) if (IS_ERR(bdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2548) pr_warn("md: could not open device unknown-block(%u,%u).\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2549) MAJOR(dev), MINOR(dev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2550) return PTR_ERR(bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2551) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2552) rdev->bdev = bdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2553) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2554) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2555)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2556) static void unlock_rdev(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2557) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2558) struct block_device *bdev = rdev->bdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2559) rdev->bdev = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2560) blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2561) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2562)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2563) void md_autodetect_dev(dev_t dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2565) static void export_rdev(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2566) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2567) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2568)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2569) pr_debug("md: export_rdev(%s)\n", bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2570) md_rdev_clear(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2571) #ifndef MODULE
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2572) if (test_bit(AutoDetected, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2573) md_autodetect_dev(rdev->bdev->bd_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2574) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2575) unlock_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2576) kobject_put(&rdev->kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2577) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2578)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2579) void md_kick_rdev_from_array(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2580) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2581) unbind_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2582) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2583) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2584) EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2585)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2586) static void export_array(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2587) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2588) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2590) while (!list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2591) rdev = list_first_entry(&mddev->disks, struct md_rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2592) same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2593) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2594) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2595) mddev->raid_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2596) mddev->major_version = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2597) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2598)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2599) static bool set_in_sync(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2600) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2601) lockdep_assert_held(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2602) if (!mddev->in_sync) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2603) mddev->sync_checkers++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2604) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2605) percpu_ref_switch_to_atomic_sync(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2606) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2607) if (!mddev->in_sync &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2608) percpu_ref_is_zero(&mddev->writes_pending)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2609) mddev->in_sync = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2610) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2611) * Ensure ->in_sync is visible before we clear
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2612) * ->sync_checkers.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2613) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2614) smp_mb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2615) set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2616) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2617) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2618) if (--mddev->sync_checkers == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2619) percpu_ref_switch_to_percpu(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2620) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2621) if (mddev->safemode == 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2622) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2623) return mddev->in_sync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2624) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2625)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2626) static void sync_sbs(struct mddev *mddev, int nospares)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2627) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2628) /* Update each superblock (in-memory image), but
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2629) * if we are allowed to, skip spares which already
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2630) * have the right event counter, or have one earlier
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2631) * (which would mean they aren't being marked as dirty
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2632) * with the rest of the array)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2633) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2634) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2635) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2636) if (rdev->sb_events == mddev->events ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2637) (nospares &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2638) rdev->raid_disk < 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2639) rdev->sb_events+1 == mddev->events)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2640) /* Don't update this superblock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2641) rdev->sb_loaded = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2642) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2643) sync_super(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2644) rdev->sb_loaded = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2645) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2646) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2647) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2648)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2649) static bool does_sb_need_changing(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2650) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2651) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2652) struct mdp_superblock_1 *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2653) int role;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2654)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2655) /* Find a good rdev */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2656) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2657) if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2658) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2659)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2660) /* No good device found. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2661) if (!rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2662) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2663)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2664) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2665) /* Check if a device has become faulty or a spare become active */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2666) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2667) role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2668) /* Device activated? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2669) if (role == 0xffff && rdev->raid_disk >=0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2670) !test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2671) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2672) /* Device turned faulty? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2673) if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2674) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2675) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2676)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2677) /* Check if any mddev parameters have changed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2678) if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2679) (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2680) (mddev->layout != le32_to_cpu(sb->layout)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2681) (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2682) (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2683) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2684)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2685) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2686) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2687)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2688) void md_update_sb(struct mddev *mddev, int force_change)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2689) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2690) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2691) int sync_req;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2692) int nospares = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2693) int any_badblocks_changed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2694) int ret = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2695)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2696) if (mddev->ro) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2697) if (force_change)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2698) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2699) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2700) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2702) repeat:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2703) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2704) if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2705) force_change = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2706) if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2707) nospares = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2708) ret = md_cluster_ops->metadata_update_start(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2709) /* Has someone else has updated the sb */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2710) if (!does_sb_need_changing(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2711) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2712) md_cluster_ops->metadata_update_cancel(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2713) bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2714) BIT(MD_SB_CHANGE_DEVS) |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2715) BIT(MD_SB_CHANGE_CLEAN));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2716) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2717) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2718) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2719)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2720) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2721) * First make sure individual recovery_offsets are correct
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2722) * curr_resync_completed can only be used during recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2723) * During reshape/resync it might use array-addresses rather
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2724) * that device addresses.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2725) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2726) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2727) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2728) mddev->delta_disks >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2729) test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2730) test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2731) !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2732) !test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2733) !test_bit(In_sync, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2734) mddev->curr_resync_completed > rdev->recovery_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2735) rdev->recovery_offset = mddev->curr_resync_completed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2736)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2737) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2738) if (!mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2739) clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2740) clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2741) if (!mddev->external) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2742) clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2743) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2744) if (rdev->badblocks.changed) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2745) rdev->badblocks.changed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2746) ack_all_badblocks(&rdev->badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2747) md_error(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2748) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2749) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2750) clear_bit(BlockedBadBlocks, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2751) wake_up(&rdev->blocked_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2752) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2753) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2754) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2755) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2756) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2757)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2758) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2759)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2760) mddev->utime = ktime_get_real_seconds();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2761)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2762) if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2763) force_change = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2764) if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2765) /* just a clean<-> dirty transition, possibly leave spares alone,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2766) * though if events isn't the right even/odd, we will have to do
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2767) * spares after all
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2768) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2769) nospares = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2770) if (force_change)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2771) nospares = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2772) if (mddev->degraded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2773) /* If the array is degraded, then skipping spares is both
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2774) * dangerous and fairly pointless.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2775) * Dangerous because a device that was removed from the array
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2776) * might have a event_count that still looks up-to-date,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2777) * so it can be re-added without a resync.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2778) * Pointless because if there are any spares to skip,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2779) * then a recovery will happen and soon that array won't
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2780) * be degraded any more and the spare can go back to sleep then.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2781) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2782) nospares = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2784) sync_req = mddev->in_sync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2785)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2786) /* If this is just a dirty<->clean transition, and the array is clean
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2787) * and 'events' is odd, we can roll back to the previous clean state */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2788) if (nospares
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2789) && (mddev->in_sync && mddev->recovery_cp == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2790) && mddev->can_decrease_events
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2791) && mddev->events != 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2792) mddev->events--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2793) mddev->can_decrease_events = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2794) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2795) /* otherwise we have to go forward and ... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2796) mddev->events ++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2797) mddev->can_decrease_events = nospares;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2798) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2799)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2800) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2801) * This 64-bit counter should never wrap.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2802) * Either we are in around ~1 trillion A.C., assuming
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2803) * 1 reboot per second, or we have a bug...
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2804) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2805) WARN_ON(mddev->events == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2806)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2807) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2808) if (rdev->badblocks.changed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2809) any_badblocks_changed++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2810) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2811) set_bit(FaultRecorded, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2812) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2813)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2814) sync_sbs(mddev, nospares);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2815) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2816)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2817) pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2818) mdname(mddev), mddev->in_sync);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2819)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2820) if (mddev->queue)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2821) blk_add_trace_msg(mddev->queue, "md md_update_sb");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2822) rewrite:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2823) md_bitmap_update_sb(mddev->bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2824) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2825) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2826)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2827) if (rdev->sb_loaded != 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2828) continue; /* no noise on spare devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2829)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2830) if (!test_bit(Faulty, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2831) md_super_write(mddev,rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2832) rdev->sb_start, rdev->sb_size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2833) rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2834) pr_debug("md: (write) %s's sb offset: %llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2835) bdevname(rdev->bdev, b),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2836) (unsigned long long)rdev->sb_start);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2837) rdev->sb_events = mddev->events;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2838) if (rdev->badblocks.size) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2839) md_super_write(mddev, rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2840) rdev->badblocks.sector,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2841) rdev->badblocks.size << 9,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2842) rdev->bb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2843) rdev->badblocks.size = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2844) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2845)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2846) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2847) pr_debug("md: %s (skipping faulty)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2848) bdevname(rdev->bdev, b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2849)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2850) if (mddev->level == LEVEL_MULTIPATH)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2851) /* only need to write one superblock... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2852) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2853) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2854) if (md_super_wait(mddev) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2855) goto rewrite;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2856) /* if there was a failure, MD_SB_CHANGE_DEVS was set, and we re-write super */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2857)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2858) if (mddev_is_clustered(mddev) && ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2859) md_cluster_ops->metadata_update_finish(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2860)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2861) if (mddev->in_sync != sync_req ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2862) !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2863) BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2864) /* have to write it out again */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2865) goto repeat;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2866) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2867) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2868) sysfs_notify_dirent_safe(mddev->sysfs_completed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2869)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2870) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2871) if (test_and_clear_bit(FaultRecorded, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2872) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2873)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2874) if (any_badblocks_changed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2875) ack_all_badblocks(&rdev->badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2876) clear_bit(BlockedBadBlocks, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2877) wake_up(&rdev->blocked_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2878) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2879) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2880) EXPORT_SYMBOL(md_update_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2881)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2882) static int add_bound_rdev(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2883) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2884) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2885) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2886) bool add_journal = test_bit(Journal, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2887)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2888) if (!mddev->pers->hot_remove_disk || add_journal) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2889) /* If there is hot_add_disk but no hot_remove_disk
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2890) * then added disks for geometry changes,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2891) * and should be added immediately.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2892) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2893) super_types[mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2894) validate_super(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2895) if (add_journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2896) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2897) err = mddev->pers->hot_add_disk(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2898) if (add_journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2899) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2900) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2901) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2902) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2903) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2904) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2905) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2906)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2907) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2908) if (mddev->degraded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2909) set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2910) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2911) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2912) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2913) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2914) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2915)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2916) /* words written to sysfs files may, or may not, be \n terminated.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2917) * We want to accept with case. For this we use cmd_match.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2918) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2919) static int cmd_match(const char *cmd, const char *str)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2920) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2921) /* See if cmd, written into a sysfs file, matches
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2922) * str. They must either be the same, or cmd can
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2923) * have a trailing newline
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2924) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2925) while (*cmd && *str && *cmd == *str) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2926) cmd++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2927) str++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2928) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2929) if (*cmd == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2930) cmd++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2931) if (*str || *cmd)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2932) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2933) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2934) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2935)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2936) struct rdev_sysfs_entry {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2937) struct attribute attr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2938) ssize_t (*show)(struct md_rdev *, char *);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2939) ssize_t (*store)(struct md_rdev *, const char *, size_t);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2940) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2941)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2942) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2943) state_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2944) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2945) char *sep = ",";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2946) size_t len = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2947) unsigned long flags = READ_ONCE(rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2948)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2949) if (test_bit(Faulty, &flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2950) (!test_bit(ExternalBbl, &flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2951) rdev->badblocks.unacked_exist))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2952) len += sprintf(page+len, "faulty%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2953) if (test_bit(In_sync, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2954) len += sprintf(page+len, "in_sync%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2955) if (test_bit(Journal, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2956) len += sprintf(page+len, "journal%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2957) if (test_bit(WriteMostly, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2958) len += sprintf(page+len, "write_mostly%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2959) if (test_bit(Blocked, &flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2960) (rdev->badblocks.unacked_exist
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2961) && !test_bit(Faulty, &flags)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2962) len += sprintf(page+len, "blocked%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2963) if (!test_bit(Faulty, &flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2964) !test_bit(Journal, &flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2965) !test_bit(In_sync, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2966) len += sprintf(page+len, "spare%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2967) if (test_bit(WriteErrorSeen, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2968) len += sprintf(page+len, "write_error%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2969) if (test_bit(WantReplacement, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2970) len += sprintf(page+len, "want_replacement%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2971) if (test_bit(Replacement, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2972) len += sprintf(page+len, "replacement%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2973) if (test_bit(ExternalBbl, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2974) len += sprintf(page+len, "external_bbl%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2975) if (test_bit(FailFast, &flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2976) len += sprintf(page+len, "failfast%s", sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2977)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2978) if (len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2979) len -= strlen(sep);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2980)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2981) return len+sprintf(page+len, "\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2982) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2983)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2984) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2985) state_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2986) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2987) /* can write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2988) * faulty - simulates an error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2989) * remove - disconnects the device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2990) * writemostly - sets write_mostly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2991) * -writemostly - clears write_mostly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2992) * blocked - sets the Blocked flags
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2993) * -blocked - clears the Blocked and possibly simulates an error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2994) * insync - sets Insync providing device isn't active
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2995) * -insync - clear Insync for a device with a slot assigned,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2996) * so that it gets rebuilt based on bitmap
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2997) * write_error - sets WriteErrorSeen
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2998) * -write_error - clears WriteErrorSeen
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2999) * {,-}failfast - set/clear FailFast
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3000) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3001)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3002) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3003) int err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3004) bool need_update_sb = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3005)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3006) if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3007) md_error(rdev->mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3008) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3009) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3010) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3011) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3012) } else if (cmd_match(buf, "remove")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3013) if (rdev->mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3014) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3015) remove_and_add_spares(rdev->mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3016) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3017) if (rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3018) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3019) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3020) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3021) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3022) err = md_cluster_ops->remove_disk(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3023)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3024) if (err == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3025) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3026) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3027) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3028) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3029) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3030) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3031) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3032) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3033) } else if (cmd_match(buf, "writemostly")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3034) set_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3035) mddev_create_serial_pool(rdev->mddev, rdev, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3036) need_update_sb = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3037) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3038) } else if (cmd_match(buf, "-writemostly")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3039) mddev_destroy_serial_pool(rdev->mddev, rdev, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3040) clear_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3041) need_update_sb = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3042) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3043) } else if (cmd_match(buf, "blocked")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3044) set_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3045) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3046) } else if (cmd_match(buf, "-blocked")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3047) if (!test_bit(Faulty, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3048) !test_bit(ExternalBbl, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3049) rdev->badblocks.unacked_exist) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3050) /* metadata handler doesn't understand badblocks,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3051) * so we need to fail the device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3052) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3053) md_error(rdev->mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3054) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3055) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3056) clear_bit(BlockedBadBlocks, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3057) wake_up(&rdev->blocked_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3058) set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3059) md_wakeup_thread(rdev->mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3060)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3061) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3062) } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3063) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3064) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3065) } else if (cmd_match(buf, "failfast")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3066) set_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3067) need_update_sb = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3068) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3069) } else if (cmd_match(buf, "-failfast")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3070) clear_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3071) need_update_sb = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3072) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3073) } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3074) !test_bit(Journal, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3075) if (rdev->mddev->pers == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3076) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3077) rdev->saved_raid_disk = rdev->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3078) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3079) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3080) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3081) } else if (cmd_match(buf, "write_error")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3082) set_bit(WriteErrorSeen, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3083) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3084) } else if (cmd_match(buf, "-write_error")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3085) clear_bit(WriteErrorSeen, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3086) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3087) } else if (cmd_match(buf, "want_replacement")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3088) /* Any non-spare device that is not a replacement can
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3089) * become want_replacement at any time, but we then need to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3090) * check if recovery is needed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3091) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3092) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3093) !test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3094) !test_bit(Replacement, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3095) set_bit(WantReplacement, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3096) set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3097) md_wakeup_thread(rdev->mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3098) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3099) } else if (cmd_match(buf, "-want_replacement")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3100) /* Clearing 'want_replacement' is always allowed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3101) * Once replacements starts it is too late though.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3102) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3103) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3104) clear_bit(WantReplacement, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3105) } else if (cmd_match(buf, "replacement")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3106) /* Can only set a device as a replacement when array has not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3107) * yet been started. Once running, replacement is automatic
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3108) * from spares, or by assigning 'slot'.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3109) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3110) if (rdev->mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3111) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3112) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3113) set_bit(Replacement, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3114) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3115) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3116) } else if (cmd_match(buf, "-replacement")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3117) /* Similarly, can only clear Replacement before start */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3118) if (rdev->mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3119) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3120) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3121) clear_bit(Replacement, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3122) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3123) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3124) } else if (cmd_match(buf, "re-add")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3125) if (!rdev->mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3126) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3127) else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3128) rdev->saved_raid_disk >= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3129) /* clear_bit is performed _after_ all the devices
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3130) * have their local Faulty bit cleared. If any writes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3131) * happen in the meantime in the local node, they
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3132) * will land in the local bitmap, which will be synced
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3133) * by this node eventually
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3134) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3135) if (!mddev_is_clustered(rdev->mddev) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3136) (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3137) clear_bit(Faulty, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3138) err = add_bound_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3139) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3140) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3141) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3142) } else if (cmd_match(buf, "external_bbl") && (rdev->mddev->external)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3143) set_bit(ExternalBbl, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3144) rdev->badblocks.shift = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3145) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3146) } else if (cmd_match(buf, "-external_bbl") && (rdev->mddev->external)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3147) clear_bit(ExternalBbl, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3148) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3149) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3150) if (need_update_sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3151) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3152) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3153) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3154) return err ? err : len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3155) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3156) static struct rdev_sysfs_entry rdev_state =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3157) __ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3158)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3159) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3160) errors_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3161) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3162) return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3163) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3164)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3165) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3166) errors_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3167) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3168) unsigned int n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3169) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3171) rv = kstrtouint(buf, 10, &n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3172) if (rv < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3173) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3174) atomic_set(&rdev->corrected_errors, n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3175) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3176) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3177) static struct rdev_sysfs_entry rdev_errors =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3178) __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3179)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3180) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3181) slot_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3182) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3183) if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3184) return sprintf(page, "journal\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3185) else if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3186) return sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3187) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3188) return sprintf(page, "%d\n", rdev->raid_disk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3189) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3190)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3191) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3192) slot_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3193) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3194) int slot;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3195) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3196)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3197) if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3198) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3199) if (strncmp(buf, "none", 4)==0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3200) slot = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3201) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3202) err = kstrtouint(buf, 10, (unsigned int *)&slot);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3203) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3204) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3205) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3206) if (rdev->mddev->pers && slot == -1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3207) /* Setting 'slot' on an active array requires also
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3208) * updating the 'rd%d' link, and communicating
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3209) * with the personality with ->hot_*_disk.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3210) * For now we only support removing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3211) * failed/spare devices. This normally happens automatically,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3212) * but not when the metadata is externally managed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3213) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3214) if (rdev->raid_disk == -1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3215) return -EEXIST;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3216) /* personality does all needed checks */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3217) if (rdev->mddev->pers->hot_remove_disk == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3218) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3219) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3220) remove_and_add_spares(rdev->mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3221) if (rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3222) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3223) set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3224) md_wakeup_thread(rdev->mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3225) } else if (rdev->mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3226) /* Activating a spare .. or possibly reactivating
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3227) * if we ever get bitmaps working here.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3228) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3229) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3230)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3231) if (rdev->raid_disk != -1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3232) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3233)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3234) if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3235) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3236)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3237) if (rdev->mddev->pers->hot_add_disk == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3238) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3239)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3240) if (slot >= rdev->mddev->raid_disks &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3241) slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3242) return -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3243)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3244) rdev->raid_disk = slot;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3245) if (test_bit(In_sync, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3246) rdev->saved_raid_disk = slot;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3247) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3248) rdev->saved_raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3249) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3250) clear_bit(Bitmap_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3251) err = rdev->mddev->pers->hot_add_disk(rdev->mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3252) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3253) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3254) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3255) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3256) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3257) /* failure here is OK */;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3258) sysfs_link_rdev(rdev->mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3259) /* don't wakeup anyone, leave that to userspace. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3260) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3261) if (slot >= rdev->mddev->raid_disks &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3262) slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3263) return -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3264) rdev->raid_disk = slot;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3265) /* assume it is working */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3266) clear_bit(Faulty, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3267) clear_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3268) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3269) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3270) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3271) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3272) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3273)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3274) static struct rdev_sysfs_entry rdev_slot =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3275) __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3276)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3277) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3278) offset_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3279) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3280) return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3281) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3282)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3283) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3284) offset_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3285) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3286) unsigned long long offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3287) if (kstrtoull(buf, 10, &offset) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3288) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3289) if (rdev->mddev->pers && rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3290) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3291) if (rdev->sectors && rdev->mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3292) /* Must set offset before size, so overlap checks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3293) * can be sane */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3294) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3295) rdev->data_offset = offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3296) rdev->new_data_offset = offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3297) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3298) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3299)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3300) static struct rdev_sysfs_entry rdev_offset =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3301) __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3302)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3303) static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3304) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3305) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3306) (unsigned long long)rdev->new_data_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3307) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3308)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3309) static ssize_t new_offset_store(struct md_rdev *rdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3310) const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3311) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3312) unsigned long long new_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3313) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3314)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3315) if (kstrtoull(buf, 10, &new_offset) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3316) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3317)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3318) if (mddev->sync_thread ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3319) test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3320) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3321) if (new_offset == rdev->data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3322) /* reset is always permitted */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3323) ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3324) else if (new_offset > rdev->data_offset) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3325) /* must not push array size beyond rdev_sectors */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3326) if (new_offset - rdev->data_offset
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3327) + mddev->dev_sectors > rdev->sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3328) return -E2BIG;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3329) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3330) /* Metadata worries about other space details. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3331)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3332) /* decreasing the offset is inconsistent with a backwards
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3333) * reshape.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3334) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3335) if (new_offset < rdev->data_offset &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3336) mddev->reshape_backwards)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3337) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3338) /* Increasing offset is inconsistent with forwards
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3339) * reshape. reshape_direction should be set to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3340) * 'backwards' first.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3341) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3342) if (new_offset > rdev->data_offset &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3343) !mddev->reshape_backwards)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3344) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3345)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3346) if (mddev->pers && mddev->persistent &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3347) !super_types[mddev->major_version]
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3348) .allow_new_offset(rdev, new_offset))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3349) return -E2BIG;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3350) rdev->new_data_offset = new_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3351) if (new_offset > rdev->data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3352) mddev->reshape_backwards = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3353) else if (new_offset < rdev->data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3354) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3355)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3356) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3357) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3358) static struct rdev_sysfs_entry rdev_new_offset =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3359) __ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3360)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3361) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3362) rdev_size_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3363) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3364) return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3365) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3366)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3367) static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3368) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3369) /* check if two start/length pairs overlap */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3370) if (s1+l1 <= s2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3371) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3372) if (s2+l2 <= s1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3373) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3374) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3375) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3376)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3377) static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3378) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3379) unsigned long long blocks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3380) sector_t new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3381)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3382) if (kstrtoull(buf, 10, &blocks) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3383) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3384)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3385) if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3386) return -EINVAL; /* sector conversion overflow */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3387)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3388) new = blocks * 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3389) if (new != blocks * 2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3390) return -EINVAL; /* unsigned long long to sector_t overflow */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3391)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3392) *sectors = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3393) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3394) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3395)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3396) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3397) rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3398) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3399) struct mddev *my_mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3400) sector_t oldsectors = rdev->sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3401) sector_t sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3402)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3403) if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3404) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3405) if (strict_blocks_to_sectors(buf, §ors) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3406) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3407) if (rdev->data_offset != rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3408) return -EINVAL; /* too confusing */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3409) if (my_mddev->pers && rdev->raid_disk >= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3410) if (my_mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3411) sectors = super_types[my_mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3412) rdev_size_change(rdev, sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3413) if (!sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3414) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3415) } else if (!sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3416) sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3417) rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3418) if (!my_mddev->pers->resize)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3419) /* Cannot change size for RAID0 or Linear etc */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3420) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3421) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3422) if (sectors < my_mddev->dev_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3423) return -EINVAL; /* component must fit device */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3424)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3425) rdev->sectors = sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3426) if (sectors > oldsectors && my_mddev->external) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3427) /* Need to check that all other rdevs with the same
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3428) * ->bdev do not overlap. 'rcu' is sufficient to walk
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3429) * the rdev lists safely.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3430) * This check does not provide a hard guarantee, it
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3431) * just helps avoid dangerous mistakes.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3432) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3433) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3434) int overlap = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3435) struct list_head *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3436)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3437) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3438) for_each_mddev(mddev, tmp) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3439) struct md_rdev *rdev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3440)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3441) rdev_for_each(rdev2, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3442) if (rdev->bdev == rdev2->bdev &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3443) rdev != rdev2 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3444) overlaps(rdev->data_offset, rdev->sectors,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3445) rdev2->data_offset,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3446) rdev2->sectors)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3447) overlap = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3448) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3449) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3450) if (overlap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3451) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3452) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3453) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3454) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3455) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3456) if (overlap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3457) /* Someone else could have slipped in a size
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3458) * change here, but doing so is just silly.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3459) * We put oldsectors back because we *know* it is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3460) * safe, and trust userspace not to race with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3461) * itself
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3462) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3463) rdev->sectors = oldsectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3464) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3465) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3466) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3467) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3468) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3469)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3470) static struct rdev_sysfs_entry rdev_size =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3471) __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3472)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3473) static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3474) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3475) unsigned long long recovery_start = rdev->recovery_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3476)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3477) if (test_bit(In_sync, &rdev->flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3478) recovery_start == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3479) return sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3480)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3481) return sprintf(page, "%llu\n", recovery_start);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3482) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3483)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3484) static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3485) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3486) unsigned long long recovery_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3487)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3488) if (cmd_match(buf, "none"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3489) recovery_start = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3490) else if (kstrtoull(buf, 10, &recovery_start))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3491) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3492)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3493) if (rdev->mddev->pers &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3494) rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3495) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3496)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3497) rdev->recovery_offset = recovery_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3498) if (recovery_start == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3499) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3500) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3501) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3502) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3503) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3504)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3505) static struct rdev_sysfs_entry rdev_recovery_start =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3506) __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3507)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3508) /* sysfs access to bad-blocks list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3509) * We present two files.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3510) * 'bad-blocks' lists sector numbers and lengths of ranges that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3511) * are recorded as bad. The list is truncated to fit within
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3512) * the one-page limit of sysfs.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3513) * Writing "sector length" to this file adds an acknowledged
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3514) * bad block list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3515) * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3516) * been acknowledged. Writing to this file adds bad blocks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3517) * without acknowledging them. This is largely for testing.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3518) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3519) static ssize_t bb_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3520) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3521) return badblocks_show(&rdev->badblocks, page, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3522) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3523) static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3524) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3525) int rv = badblocks_store(&rdev->badblocks, page, len, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3526) /* Maybe that ack was all we needed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3527) if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3528) wake_up(&rdev->blocked_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3529) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3530) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3531) static struct rdev_sysfs_entry rdev_bad_blocks =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3532) __ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3533)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3534) static ssize_t ubb_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3535) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3536) return badblocks_show(&rdev->badblocks, page, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3537) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3538) static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3539) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3540) return badblocks_store(&rdev->badblocks, page, len, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3541) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3542) static struct rdev_sysfs_entry rdev_unack_bad_blocks =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3543) __ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3544)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3545) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3546) ppl_sector_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3547) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3548) return sprintf(page, "%llu\n", (unsigned long long)rdev->ppl.sector);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3549) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3550)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3551) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3552) ppl_sector_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3553) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3554) unsigned long long sector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3555)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3556) if (kstrtoull(buf, 10, §or) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3557) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3558) if (sector != (sector_t)sector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3559) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3560)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3561) if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3562) rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3563) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3565) if (rdev->mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3566) if (rdev->mddev->major_version == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3567) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3568) if ((sector > rdev->sb_start &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3569) sector - rdev->sb_start > S16_MAX) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3570) (sector < rdev->sb_start &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3571) rdev->sb_start - sector > -S16_MIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3572) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3573) rdev->ppl.offset = sector - rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3574) } else if (!rdev->mddev->external) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3575) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3576) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3577) rdev->ppl.sector = sector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3578) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3579) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3580)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3581) static struct rdev_sysfs_entry rdev_ppl_sector =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3582) __ATTR(ppl_sector, S_IRUGO|S_IWUSR, ppl_sector_show, ppl_sector_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3583)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3584) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3585) ppl_size_show(struct md_rdev *rdev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3586) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3587) return sprintf(page, "%u\n", rdev->ppl.size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3588) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3590) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3591) ppl_size_store(struct md_rdev *rdev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3592) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3593) unsigned int size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3594)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3595) if (kstrtouint(buf, 10, &size) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3596) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3597)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3598) if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3599) rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3600) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3601)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3602) if (rdev->mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3603) if (rdev->mddev->major_version == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3604) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3605) if (size > U16_MAX)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3606) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3607) } else if (!rdev->mddev->external) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3608) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3609) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3610) rdev->ppl.size = size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3611) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3612) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3613)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3614) static struct rdev_sysfs_entry rdev_ppl_size =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3615) __ATTR(ppl_size, S_IRUGO|S_IWUSR, ppl_size_show, ppl_size_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3616)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3617) static struct attribute *rdev_default_attrs[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3618) &rdev_state.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3619) &rdev_errors.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3620) &rdev_slot.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3621) &rdev_offset.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3622) &rdev_new_offset.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3623) &rdev_size.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3624) &rdev_recovery_start.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3625) &rdev_bad_blocks.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3626) &rdev_unack_bad_blocks.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3627) &rdev_ppl_sector.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3628) &rdev_ppl_size.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3629) NULL,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3630) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3631) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3632) rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3633) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3634) struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3635) struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3636)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3637) if (!entry->show)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3638) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3639) if (!rdev->mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3640) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3641) return entry->show(rdev, page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3642) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3643)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3644) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3645) rdev_attr_store(struct kobject *kobj, struct attribute *attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3646) const char *page, size_t length)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3647) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3648) struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3649) struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3650) ssize_t rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3651) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3652)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3653) if (!entry->store)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3654) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3655) if (!capable(CAP_SYS_ADMIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3656) return -EACCES;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3657) rv = mddev ? mddev_lock(mddev) : -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3658) if (!rv) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3659) if (rdev->mddev == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3660) rv = -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3661) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3662) rv = entry->store(rdev, page, length);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3663) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3664) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3665) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3666) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3667)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3668) static void rdev_free(struct kobject *ko)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3669) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3670) struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3671) kfree(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3672) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3673) static const struct sysfs_ops rdev_sysfs_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3674) .show = rdev_attr_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3675) .store = rdev_attr_store,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3676) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3677) static struct kobj_type rdev_ktype = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3678) .release = rdev_free,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3679) .sysfs_ops = &rdev_sysfs_ops,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3680) .default_attrs = rdev_default_attrs,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3681) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3682)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3683) int md_rdev_init(struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3684) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3685) rdev->desc_nr = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3686) rdev->saved_raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3687) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3688) rdev->flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3689) rdev->data_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3690) rdev->new_data_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3691) rdev->sb_events = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3692) rdev->last_read_error = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3693) rdev->sb_loaded = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3694) rdev->bb_page = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3695) atomic_set(&rdev->nr_pending, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3696) atomic_set(&rdev->read_errors, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3697) atomic_set(&rdev->corrected_errors, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3698)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3699) INIT_LIST_HEAD(&rdev->same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3700) init_waitqueue_head(&rdev->blocked_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3702) /* Add space to store bad block list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3703) * This reserves the space even on arrays where it cannot
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3704) * be used - I wonder if that matters
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3705) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3706) return badblocks_init(&rdev->badblocks, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3707) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3708) EXPORT_SYMBOL_GPL(md_rdev_init);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3709) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3710) * Import a device. If 'super_format' >= 0, then sanity check the superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3711) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3712) * mark the device faulty if:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3713) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3714) * - the device is nonexistent (zero size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3715) * - the device has no valid superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3716) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3717) * a faulty rdev _never_ has rdev->sb set.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3718) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3719) static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3720) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3721) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3722) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3723) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3724) sector_t size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3725)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3726) rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3727) if (!rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3728) return ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3729)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3730) err = md_rdev_init(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3731) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3732) goto abort_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3733) err = alloc_disk_sb(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3734) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3735) goto abort_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3736)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3737) err = lock_rdev(rdev, newdev, super_format == -2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3738) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3739) goto abort_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3740)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3741) kobject_init(&rdev->kobj, &rdev_ktype);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3742)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3743) size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3744) if (!size) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3745) pr_warn("md: %s has zero or unknown size, marking faulty!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3746) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3747) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3748) goto abort_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3749) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3750)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3751) if (super_format >= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3752) err = super_types[super_format].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3753) load_super(rdev, NULL, super_minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3754) if (err == -EINVAL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3755) pr_warn("md: %s does not have a valid v%d.%d superblock, not importing!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3756) bdevname(rdev->bdev,b),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3757) super_format, super_minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3758) goto abort_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3759) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3760) if (err < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3761) pr_warn("md: could not read %s's sb, not importing!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3762) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3763) goto abort_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3764) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3765) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3766)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3767) return rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3768)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3769) abort_free:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3770) if (rdev->bdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3771) unlock_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3772) md_rdev_clear(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3773) kfree(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3774) return ERR_PTR(err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3775) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3776)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3777) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3778) * Check a full RAID array for plausibility
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3779) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3780)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3781) static int analyze_sbs(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3782) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3783) int i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3784) struct md_rdev *rdev, *freshest, *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3785) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3786)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3787) freshest = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3788) rdev_for_each_safe(rdev, tmp, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3789) switch (super_types[mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3790) load_super(rdev, freshest, mddev->minor_version)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3791) case 1:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3792) freshest = rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3793) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3794) case 0:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3795) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3796) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3797) pr_warn("md: fatal superblock inconsistency in %s -- removing from array\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3798) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3799) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3800) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3801)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3802) /* Cannot find a valid fresh disk */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3803) if (!freshest) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3804) pr_warn("md: cannot find a valid disk\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3805) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3806) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3807)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3808) super_types[mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3809) validate_super(mddev, freshest);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3810)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3811) i = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3812) rdev_for_each_safe(rdev, tmp, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3813) if (mddev->max_disks &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3814) (rdev->desc_nr >= mddev->max_disks ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3815) i > mddev->max_disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3816) pr_warn("md: %s: %s: only %d devices permitted\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3817) mdname(mddev), bdevname(rdev->bdev, b),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3818) mddev->max_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3819) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3820) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3821) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3822) if (rdev != freshest) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3823) if (super_types[mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3824) validate_super(mddev, rdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3825) pr_warn("md: kicking non-fresh %s from array!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3826) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3827) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3828) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3829) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3830) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3831) if (mddev->level == LEVEL_MULTIPATH) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3832) rdev->desc_nr = i++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3833) rdev->raid_disk = rdev->desc_nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3834) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3835) } else if (rdev->raid_disk >=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3836) (mddev->raid_disks - min(0, mddev->delta_disks)) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3837) !test_bit(Journal, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3838) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3839) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3840) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3841) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3842)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3843) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3844) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3845)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3846) /* Read a fixed-point number.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3847) * Numbers in sysfs attributes should be in "standard" units where
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3848) * possible, so time should be in seconds.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3849) * However we internally use a a much smaller unit such as
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3850) * milliseconds or jiffies.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3851) * This function takes a decimal number with a possible fractional
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3852) * component, and produces an integer which is the result of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3853) * multiplying that number by 10^'scale'.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3854) * all without any floating-point arithmetic.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3855) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3856) int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3857) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3858) unsigned long result = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3859) long decimals = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3860) while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3861) if (*cp == '.')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3862) decimals = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3863) else if (decimals < scale) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3864) unsigned int value;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3865) value = *cp - '0';
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3866) result = result * 10 + value;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3867) if (decimals >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3868) decimals++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3869) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3870) cp++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3871) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3872) if (*cp == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3873) cp++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3874) if (*cp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3875) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3876) if (decimals < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3877) decimals = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3878) *res = result * int_pow(10, scale - decimals);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3879) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3880) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3881)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3882) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3883) safe_delay_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3884) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3885) int msec = (mddev->safemode_delay*1000)/HZ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3886) return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3887) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3888) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3889) safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3890) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3891) unsigned long msec;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3892)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3893) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3894) pr_warn("md: Safemode is disabled for clustered mode\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3895) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3896) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3897)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3898) if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3899) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3900) if (msec == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3901) mddev->safemode_delay = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3902) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3903) unsigned long old_delay = mddev->safemode_delay;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3904) unsigned long new_delay = (msec*HZ)/1000;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3905)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3906) if (new_delay == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3907) new_delay = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3908) mddev->safemode_delay = new_delay;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3909) if (new_delay < old_delay || old_delay == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3910) mod_timer(&mddev->safemode_timer, jiffies+1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3911) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3912) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3913) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3914) static struct md_sysfs_entry md_safe_delay =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3915) __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3916)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3917) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3918) level_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3919) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3920) struct md_personality *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3921) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3922) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3923) p = mddev->pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3924) if (p)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3925) ret = sprintf(page, "%s\n", p->name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3926) else if (mddev->clevel[0])
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3927) ret = sprintf(page, "%s\n", mddev->clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3928) else if (mddev->level != LEVEL_NONE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3929) ret = sprintf(page, "%d\n", mddev->level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3930) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3931) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3932) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3933) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3934) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3935)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3936) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3937) level_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3938) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3939) char clevel[16];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3940) ssize_t rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3941) size_t slen = len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3942) struct md_personality *pers, *oldpers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3943) long level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3944) void *priv, *oldpriv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3945) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3946)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3947) if (slen == 0 || slen >= sizeof(clevel))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3948) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3949)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3950) rv = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3951) if (rv)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3952) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3953)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3954) if (mddev->pers == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3955) strncpy(mddev->clevel, buf, slen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3956) if (mddev->clevel[slen-1] == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3957) slen--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3958) mddev->clevel[slen] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3959) mddev->level = LEVEL_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3960) rv = len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3961) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3962) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3963) rv = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3964) if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3965) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3966)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3967) /* request to change the personality. Need to ensure:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3968) * - array is not engaged in resync/recovery/reshape
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3969) * - old personality can be suspended
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3970) * - new personality will access other array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3971) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3972)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3973) rv = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3974) if (mddev->sync_thread ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3975) test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3976) mddev->reshape_position != MaxSector ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3977) mddev->sysfs_active)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3978) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3979)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3980) rv = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3981) if (!mddev->pers->quiesce) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3982) pr_warn("md: %s: %s does not support online personality change\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3983) mdname(mddev), mddev->pers->name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3984) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3985) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3986)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3987) /* Now find the new personality */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3988) strncpy(clevel, buf, slen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3989) if (clevel[slen-1] == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3990) slen--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3991) clevel[slen] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3992) if (kstrtol(clevel, 10, &level))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3993) level = LEVEL_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3994)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3995) if (request_module("md-%s", clevel) != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3996) request_module("md-level-%s", clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3997) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3998) pers = find_pers(level, clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3999) if (!pers || !try_module_get(pers->owner)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4000) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4001) pr_warn("md: personality %s not loaded\n", clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4002) rv = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4003) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4004) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4005) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4006)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4007) if (pers == mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4008) /* Nothing to do! */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4009) module_put(pers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4010) rv = len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4011) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4012) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4013) if (!pers->takeover) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4014) module_put(pers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4015) pr_warn("md: %s: %s does not support personality takeover\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4016) mdname(mddev), clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4017) rv = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4018) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4019) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4020)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4021) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4022) rdev->new_raid_disk = rdev->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4023)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4024) /* ->takeover must set new_* and/or delta_disks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4025) * if it succeeds, and may set them when it fails.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4026) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4027) priv = pers->takeover(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4028) if (IS_ERR(priv)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4029) mddev->new_level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4030) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4031) mddev->new_chunk_sectors = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4032) mddev->raid_disks -= mddev->delta_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4033) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4034) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4035) module_put(pers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4036) pr_warn("md: %s: %s would not accept array\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4037) mdname(mddev), clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4038) rv = PTR_ERR(priv);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4039) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4040) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4041)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4042) /* Looks like we have a winner */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4043) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4044) mddev_detach(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4045)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4046) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4047) oldpers = mddev->pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4048) oldpriv = mddev->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4049) mddev->pers = pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4050) mddev->private = priv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4051) strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4052) mddev->level = mddev->new_level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4053) mddev->layout = mddev->new_layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4054) mddev->chunk_sectors = mddev->new_chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4055) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4056) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4057) mddev->degraded = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4058) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4059)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4060) if (oldpers->sync_request == NULL &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4061) mddev->external) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4062) /* We are converting from a no-redundancy array
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4063) * to a redundancy array and metadata is managed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4064) * externally so we need to be sure that writes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4065) * won't block due to a need to transition
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4066) * clean->dirty
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4067) * until external management is started.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4068) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4069) mddev->in_sync = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4070) mddev->safemode_delay = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4071) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4072) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4073)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4074) oldpers->free(mddev, oldpriv);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4075)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4076) if (oldpers->sync_request == NULL &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4077) pers->sync_request != NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4078) /* need to add the md_redundancy_group */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4079) if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4080) pr_warn("md: cannot register extra attributes for %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4081) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4082) mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4083) mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4084) mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4085) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4086) if (oldpers->sync_request != NULL &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4087) pers->sync_request == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4088) /* need to remove the md_redundancy_group */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4089) if (mddev->to_remove == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4090) mddev->to_remove = &md_redundancy_group;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4091) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4092)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4093) module_put(oldpers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4094)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4095) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4096) if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4097) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4098) if (rdev->new_raid_disk >= mddev->raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4099) rdev->new_raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4100) if (rdev->new_raid_disk == rdev->raid_disk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4101) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4102) sysfs_unlink_rdev(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4103) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4104) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4105) if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4106) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4107) if (rdev->new_raid_disk == rdev->raid_disk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4108) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4109) rdev->raid_disk = rdev->new_raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4110) if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4111) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4112) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4113) if (sysfs_link_rdev(mddev, rdev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4114) pr_warn("md: cannot register rd%d for %s after level change\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4115) rdev->raid_disk, mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4116) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4117) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4118)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4119) if (pers->sync_request == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4120) /* this is now an array without redundancy, so
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4121) * it must always be in_sync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4122) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4123) mddev->in_sync = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4124) del_timer_sync(&mddev->safemode_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4125) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4126) blk_set_stacking_limits(&mddev->queue->limits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4127) pers->run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4128) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4129) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4130) if (!mddev->thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4131) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4132) sysfs_notify_dirent_safe(mddev->sysfs_level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4133) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4134) rv = len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4135) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4136) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4137) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4138) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4139)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4140) static struct md_sysfs_entry md_level =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4141) __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4142)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4143) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4144) layout_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4145) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4146) /* just a number, not meaningful for all levels */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4147) if (mddev->reshape_position != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4148) mddev->layout != mddev->new_layout)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4149) return sprintf(page, "%d (%d)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4150) mddev->new_layout, mddev->layout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4151) return sprintf(page, "%d\n", mddev->layout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4152) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4153)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4154) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4155) layout_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4156) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4157) unsigned int n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4158) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4159)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4160) err = kstrtouint(buf, 10, &n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4161) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4162) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4163) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4164) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4165) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4166)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4167) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4168) if (mddev->pers->check_reshape == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4169) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4170) else if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4171) err = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4172) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4173) mddev->new_layout = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4174) err = mddev->pers->check_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4175) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4176) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4177) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4178) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4179) mddev->new_layout = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4180) if (mddev->reshape_position == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4181) mddev->layout = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4182) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4183) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4184) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4185) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4186) static struct md_sysfs_entry md_layout =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4187) __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4188)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4189) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4190) raid_disks_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4191) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4192) if (mddev->raid_disks == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4193) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4194) if (mddev->reshape_position != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4195) mddev->delta_disks != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4196) return sprintf(page, "%d (%d)\n", mddev->raid_disks,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4197) mddev->raid_disks - mddev->delta_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4198) return sprintf(page, "%d\n", mddev->raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4199) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4200)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4201) static int update_raid_disks(struct mddev *mddev, int raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4202)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4203) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4204) raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4205) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4206) unsigned int n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4207) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4208)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4209) err = kstrtouint(buf, 10, &n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4210) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4211) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4212)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4213) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4214) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4215) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4216) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4217) err = update_raid_disks(mddev, n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4218) else if (mddev->reshape_position != MaxSector) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4219) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4220) int olddisks = mddev->raid_disks - mddev->delta_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4221)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4222) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4223) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4224) if (olddisks < n &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4225) rdev->data_offset < rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4226) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4227) if (olddisks > n &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4228) rdev->data_offset > rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4229) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4230) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4231) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4232) mddev->delta_disks = n - olddisks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4233) mddev->raid_disks = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4234) mddev->reshape_backwards = (mddev->delta_disks < 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4235) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4236) mddev->raid_disks = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4237) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4238) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4239) return err ? err : len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4240) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4241) static struct md_sysfs_entry md_raid_disks =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4242) __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4243)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4244) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4245) uuid_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4246) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4247) return sprintf(page, "%pU\n", mddev->uuid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4248) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4249) static struct md_sysfs_entry md_uuid =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4250) __ATTR(uuid, S_IRUGO, uuid_show, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4251)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4252) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4253) chunk_size_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4254) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4255) if (mddev->reshape_position != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4256) mddev->chunk_sectors != mddev->new_chunk_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4257) return sprintf(page, "%d (%d)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4258) mddev->new_chunk_sectors << 9,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4259) mddev->chunk_sectors << 9);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4260) return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4261) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4262)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4263) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4264) chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4265) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4266) unsigned long n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4267) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4268)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4269) err = kstrtoul(buf, 10, &n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4270) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4271) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4272)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4273) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4274) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4275) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4276) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4277) if (mddev->pers->check_reshape == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4278) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4279) else if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4280) err = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4281) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4282) mddev->new_chunk_sectors = n >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4283) err = mddev->pers->check_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4284) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4285) mddev->new_chunk_sectors = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4286) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4287) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4288) mddev->new_chunk_sectors = n >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4289) if (mddev->reshape_position == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4290) mddev->chunk_sectors = n >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4291) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4292) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4293) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4294) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4295) static struct md_sysfs_entry md_chunk_size =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4296) __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4297)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4298) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4299) resync_start_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4300) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4301) if (mddev->recovery_cp == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4302) return sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4303) return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4304) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4305)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4306) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4307) resync_start_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4308) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4309) unsigned long long n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4310) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4311)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4312) if (cmd_match(buf, "none"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4313) n = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4314) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4315) err = kstrtoull(buf, 10, &n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4316) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4317) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4318) if (n != (sector_t)n)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4319) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4320) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4321)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4322) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4323) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4324) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4325) if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4326) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4327)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4328) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4329) mddev->recovery_cp = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4330) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4331) set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4332) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4333) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4334) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4335) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4336) static struct md_sysfs_entry md_resync_start =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4337) __ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4338) resync_start_show, resync_start_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4339)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4340) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4341) * The array state can be:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4342) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4343) * clear
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4344) * No devices, no size, no level
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4345) * Equivalent to STOP_ARRAY ioctl
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4346) * inactive
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4347) * May have some settings, but array is not active
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4348) * all IO results in error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4349) * When written, doesn't tear down array, but just stops it
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4350) * suspended (not supported yet)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4351) * All IO requests will block. The array can be reconfigured.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4352) * Writing this, if accepted, will block until array is quiescent
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4353) * readonly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4354) * no resync can happen. no superblocks get written.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4355) * write requests fail
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4356) * read-auto
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4357) * like readonly, but behaves like 'clean' on a write request.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4358) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4359) * clean - no pending writes, but otherwise active.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4360) * When written to inactive array, starts without resync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4361) * If a write request arrives then
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4362) * if metadata is known, mark 'dirty' and switch to 'active'.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4363) * if not known, block and switch to write-pending
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4364) * If written to an active array that has pending writes, then fails.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4365) * active
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4366) * fully active: IO and resync can be happening.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4367) * When written to inactive array, starts with resync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4368) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4369) * write-pending
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4370) * clean, but writes are blocked waiting for 'active' to be written.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4371) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4372) * active-idle
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4373) * like active, but no writes have been seen for a while (100msec).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4374) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4375) * broken
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4376) * RAID0/LINEAR-only: same as clean, but array is missing a member.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4377) * It's useful because RAID0/LINEAR mounted-arrays aren't stopped
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4378) * when a member is gone, so this state will at least alert the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4379) * user that something is wrong.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4380) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4381) enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4382) write_pending, active_idle, broken, bad_word};
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4383) static char *array_states[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4384) "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4385) "write-pending", "active-idle", "broken", NULL };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4386)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4387) static int match_word(const char *word, char **list)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4388) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4389) int n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4390) for (n=0; list[n]; n++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4391) if (cmd_match(word, list[n]))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4392) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4393) return n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4394) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4395)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4396) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4397) array_state_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4398) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4399) enum array_state st = inactive;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4400)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4401) if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4402) switch(mddev->ro) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4403) case 1:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4404) st = readonly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4405) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4406) case 2:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4407) st = read_auto;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4408) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4409) case 0:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4410) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4411) if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4412) st = write_pending;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4413) else if (mddev->in_sync)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4414) st = clean;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4415) else if (mddev->safemode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4416) st = active_idle;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4417) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4418) st = active;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4419) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4420) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4421)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4422) if (test_bit(MD_BROKEN, &mddev->flags) && st == clean)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4423) st = broken;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4424) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4425) if (list_empty(&mddev->disks) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4426) mddev->raid_disks == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4427) mddev->dev_sectors == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4428) st = clear;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4429) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4430) st = inactive;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4431) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4432) return sprintf(page, "%s\n", array_states[st]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4433) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4434)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4435) static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4436) static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4437) static int restart_array(struct mddev *mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4438)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4439) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4440) array_state_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4441) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4442) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4443) enum array_state st = match_word(buf, array_states);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4444)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4445) if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4446) /* don't take reconfig_mutex when toggling between
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4447) * clean and active
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4448) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4449) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4450) if (st == active) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4451) restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4452) clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4453) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4454) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4455) } else /* st == clean */ {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4456) restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4457) if (!set_in_sync(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4458) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4459) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4460) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4461) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4462) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4463) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4464) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4465) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4466) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4467) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4468) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4469) switch(st) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4470) case bad_word:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4471) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4472) case clear:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4473) /* stopping an active array */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4474) err = do_md_stop(mddev, 0, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4475) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4476) case inactive:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4477) /* stopping an active array */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4478) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4479) err = do_md_stop(mddev, 2, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4480) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4481) err = 0; /* already inactive */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4482) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4483) case suspended:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4484) break; /* not supported yet */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4485) case readonly:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4486) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4487) err = md_set_readonly(mddev, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4488) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4489) mddev->ro = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4490) set_disk_ro(mddev->gendisk, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4491) err = do_md_run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4492) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4493) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4494) case read_auto:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4495) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4496) if (mddev->ro == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4497) err = md_set_readonly(mddev, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4498) else if (mddev->ro == 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4499) err = restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4500) if (err == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4501) mddev->ro = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4502) set_disk_ro(mddev->gendisk, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4503) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4504) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4505) mddev->ro = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4506) err = do_md_run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4507) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4508) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4509) case clean:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4510) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4511) err = restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4512) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4513) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4514) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4515) if (!set_in_sync(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4516) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4517) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4518) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4519) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4520) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4521) case active:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4522) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4523) err = restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4524) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4525) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4526) clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4527) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4528) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4529) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4530) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4531) set_disk_ro(mddev->gendisk, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4532) err = do_md_run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4533) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4534) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4535) case write_pending:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4536) case active_idle:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4537) case broken:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4538) /* these cannot be set */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4539) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4540) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4541)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4542) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4543) if (mddev->hold_active == UNTIL_IOCTL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4544) mddev->hold_active = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4545) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4546) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4547) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4548) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4549) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4550) static struct md_sysfs_entry md_array_state =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4551) __ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4552)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4553) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4554) max_corrected_read_errors_show(struct mddev *mddev, char *page) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4555) return sprintf(page, "%d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4556) atomic_read(&mddev->max_corr_read_errors));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4557) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4558)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4559) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4560) max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4561) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4562) unsigned int n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4563) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4565) rv = kstrtouint(buf, 10, &n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4566) if (rv < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4567) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4568) atomic_set(&mddev->max_corr_read_errors, n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4569) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4570) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4571)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4572) static struct md_sysfs_entry max_corr_read_errors =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4573) __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4574) max_corrected_read_errors_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4575)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4576) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4577) null_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4578) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4579) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4580) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4581)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4582) /* need to ensure rdev_delayed_delete() has completed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4583) static void flush_rdev_wq(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4584) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4585) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4586)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4587) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4588) rdev_for_each_rcu(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4589) if (work_pending(&rdev->del_work)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4590) flush_workqueue(md_rdev_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4591) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4592) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4593) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4594) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4595)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4596) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4597) new_dev_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4598) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4599) /* buf must be %d:%d\n? giving major and minor numbers */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4600) /* The new device is added to the array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4601) * If the array has a persistent superblock, we read the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4602) * superblock to initialise info and check validity.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4603) * Otherwise, only checking done is that in bind_rdev_to_array,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4604) * which mainly checks size.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4605) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4606) char *e;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4607) int major = simple_strtoul(buf, &e, 10);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4608) int minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4609) dev_t dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4610) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4611) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4612)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4613) if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4614) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4615) minor = simple_strtoul(e+1, &e, 10);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4616) if (*e && *e != '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4617) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4618) dev = MKDEV(major, minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4619) if (major != MAJOR(dev) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4620) minor != MINOR(dev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4621) return -EOVERFLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4622)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4623) flush_rdev_wq(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4624) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4625) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4626) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4627) if (mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4628) rdev = md_import_device(dev, mddev->major_version,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4629) mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4630) if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4631) struct md_rdev *rdev0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4632) = list_entry(mddev->disks.next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4633) struct md_rdev, same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4634) err = super_types[mddev->major_version]
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4635) .load_super(rdev, rdev0, mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4636) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4637) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4638) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4639) } else if (mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4640) rdev = md_import_device(dev, -2, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4641) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4642) rdev = md_import_device(dev, -1, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4643)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4644) if (IS_ERR(rdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4645) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4646) return PTR_ERR(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4647) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4648) err = bind_rdev_to_array(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4649) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4650) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4651) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4652) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4653) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4654) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4655) return err ? err : len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4656) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4657)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4658) static struct md_sysfs_entry md_new_device =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4659) __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4660)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4661) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4662) bitmap_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4663) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4664) char *end;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4665) unsigned long chunk, end_chunk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4666) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4667)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4668) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4669) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4670) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4671) if (!mddev->bitmap)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4672) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4673) /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4674) while (*buf) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4675) chunk = end_chunk = simple_strtoul(buf, &end, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4676) if (buf == end) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4677) if (*end == '-') { /* range */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4678) buf = end + 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4679) end_chunk = simple_strtoul(buf, &end, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4680) if (buf == end) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4681) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4682) if (*end && !isspace(*end)) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4683) md_bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4684) buf = skip_spaces(end);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4685) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4686) md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4687) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4688) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4689) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4690) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4691)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4692) static struct md_sysfs_entry md_bitmap =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4693) __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4694)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4695) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4696) size_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4697) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4698) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4699) (unsigned long long)mddev->dev_sectors / 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4700) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4702) static int update_size(struct mddev *mddev, sector_t num_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4703)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4704) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4705) size_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4706) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4707) /* If array is inactive, we can reduce the component size, but
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4708) * not increase it (except from 0).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4709) * If array is active, we can try an on-line resize
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4710) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4711) sector_t sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4712) int err = strict_blocks_to_sectors(buf, §ors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4713)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4714) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4715) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4716) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4717) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4718) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4719) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4720) err = update_size(mddev, sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4721) if (err == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4722) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4723) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4724) if (mddev->dev_sectors == 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4725) mddev->dev_sectors > sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4726) mddev->dev_sectors = sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4727) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4728) err = -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4729) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4730) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4731) return err ? err : len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4732) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4733)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4734) static struct md_sysfs_entry md_size =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4735) __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4736)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4737) /* Metadata version.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4738) * This is one of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4739) * 'none' for arrays with no metadata (good luck...)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4740) * 'external' for arrays with externally managed metadata,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4741) * or N.M for internally known formats
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4742) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4743) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4744) metadata_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4745) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4746) if (mddev->persistent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4747) return sprintf(page, "%d.%d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4748) mddev->major_version, mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4749) else if (mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4750) return sprintf(page, "external:%s\n", mddev->metadata_type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4751) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4752) return sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4753) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4754)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4755) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4756) metadata_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4757) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4758) int major, minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4759) char *e;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4760) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4761) /* Changing the details of 'external' metadata is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4762) * always permitted. Otherwise there must be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4763) * no devices attached to the array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4764) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4765)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4766) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4767) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4768) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4769) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4770) if (mddev->external && strncmp(buf, "external:", 9) == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4771) ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4772) else if (!list_empty(&mddev->disks))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4773) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4774)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4775) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4776) if (cmd_match(buf, "none")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4777) mddev->persistent = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4778) mddev->external = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4779) mddev->major_version = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4780) mddev->minor_version = 90;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4781) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4782) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4783) if (strncmp(buf, "external:", 9) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4784) size_t namelen = len-9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4785) if (namelen >= sizeof(mddev->metadata_type))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4786) namelen = sizeof(mddev->metadata_type)-1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4787) strncpy(mddev->metadata_type, buf+9, namelen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4788) mddev->metadata_type[namelen] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4789) if (namelen && mddev->metadata_type[namelen-1] == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4790) mddev->metadata_type[--namelen] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4791) mddev->persistent = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4792) mddev->external = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4793) mddev->major_version = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4794) mddev->minor_version = 90;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4795) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4796) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4797) major = simple_strtoul(buf, &e, 10);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4798) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4799) if (e==buf || *e != '.')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4800) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4801) buf = e+1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4802) minor = simple_strtoul(buf, &e, 10);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4803) if (e==buf || (*e && *e != '\n') )
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4804) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4805) err = -ENOENT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4806) if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4807) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4808) mddev->major_version = major;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4809) mddev->minor_version = minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4810) mddev->persistent = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4811) mddev->external = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4812) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4813) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4814) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4815) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4816) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4817)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4818) static struct md_sysfs_entry md_metadata =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4819) __ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4820)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4821) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4822) action_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4823) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4824) char *type = "idle";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4825) unsigned long recovery = mddev->recovery;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4826) if (test_bit(MD_RECOVERY_FROZEN, &recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4827) type = "frozen";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4828) else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4829) (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4830) if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4831) type = "reshape";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4832) else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4833) if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4834) type = "resync";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4835) else if (test_bit(MD_RECOVERY_CHECK, &recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4836) type = "check";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4837) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4838) type = "repair";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4839) } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4840) type = "recover";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4841) else if (mddev->reshape_position != MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4842) type = "reshape";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4843) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4844) return sprintf(page, "%s\n", type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4845) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4846)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4847) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4848) action_store(struct mddev *mddev, const char *page, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4849) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4850) if (!mddev->pers || !mddev->pers->sync_request)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4851) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4852)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4853)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4854) if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4855) if (cmd_match(page, "frozen"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4856) set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4857) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4858) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4859) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4860) mddev_lock(mddev) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4861) if (work_pending(&mddev->del_work))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4862) flush_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4863) if (mddev->sync_thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4864) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4865) md_reap_sync_thread(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4866) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4867) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4868) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4869) } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4870) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4871) else if (cmd_match(page, "resync"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4872) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4873) else if (cmd_match(page, "recover")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4874) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4875) set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4876) } else if (cmd_match(page, "reshape")) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4877) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4878) if (mddev->pers->start_reshape == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4879) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4880) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4881) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4882) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4883) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4884) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4885) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4886) err = mddev->pers->start_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4887) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4888) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4889) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4890) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4891) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4892) sysfs_notify_dirent_safe(mddev->sysfs_degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4893) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4894) if (cmd_match(page, "check"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4895) set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4896) else if (!cmd_match(page, "repair"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4897) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4898) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4899) set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4900) set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4901) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4902) if (mddev->ro == 2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4903) /* A write to sync_action is enough to justify
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4904) * canceling read-auto mode
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4905) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4906) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4907) md_wakeup_thread(mddev->sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4908) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4909) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4910) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4911) sysfs_notify_dirent_safe(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4912) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4913) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4914)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4915) static struct md_sysfs_entry md_scan_mode =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4916) __ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4917)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4918) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4919) last_sync_action_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4920) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4921) return sprintf(page, "%s\n", mddev->last_sync_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4922) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4923)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4924) static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4925)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4926) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4927) mismatch_cnt_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4928) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4929) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4930) (unsigned long long)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4931) atomic64_read(&mddev->resync_mismatches));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4932) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4933)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4934) static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4935)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4936) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4937) sync_min_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4938) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4939) return sprintf(page, "%d (%s)\n", speed_min(mddev),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4940) mddev->sync_speed_min ? "local": "system");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4941) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4942)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4943) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4944) sync_min_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4945) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4946) unsigned int min;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4947) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4948)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4949) if (strncmp(buf, "system", 6)==0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4950) min = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4951) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4952) rv = kstrtouint(buf, 10, &min);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4953) if (rv < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4954) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4955) if (min == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4956) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4957) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4958) mddev->sync_speed_min = min;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4959) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4960) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4961)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4962) static struct md_sysfs_entry md_sync_min =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4963) __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4964)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4965) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4966) sync_max_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4967) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4968) return sprintf(page, "%d (%s)\n", speed_max(mddev),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4969) mddev->sync_speed_max ? "local": "system");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4970) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4971)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4972) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4973) sync_max_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4974) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4975) unsigned int max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4976) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4977)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4978) if (strncmp(buf, "system", 6)==0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4979) max = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4980) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4981) rv = kstrtouint(buf, 10, &max);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4982) if (rv < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4983) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4984) if (max == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4985) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4986) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4987) mddev->sync_speed_max = max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4988) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4989) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4990)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4991) static struct md_sysfs_entry md_sync_max =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4992) __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4993)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4994) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4995) degraded_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4996) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4997) return sprintf(page, "%d\n", mddev->degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4998) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4999) static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5000)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5001) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5002) sync_force_parallel_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5003) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5004) return sprintf(page, "%d\n", mddev->parallel_resync);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5005) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5006)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5007) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5008) sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5009) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5010) long n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5011)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5012) if (kstrtol(buf, 10, &n))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5013) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5014)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5015) if (n != 0 && n != 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5016) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5017)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5018) mddev->parallel_resync = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5019)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5020) if (mddev->sync_thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5021) wake_up(&resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5022)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5023) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5024) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5025)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5026) /* force parallel resync, even with shared block devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5027) static struct md_sysfs_entry md_sync_force_parallel =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5028) __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5029) sync_force_parallel_show, sync_force_parallel_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5030)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5031) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5032) sync_speed_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5033) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5034) unsigned long resync, dt, db;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5035) if (mddev->curr_resync == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5036) return sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5037) resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5038) dt = (jiffies - mddev->resync_mark) / HZ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5039) if (!dt) dt++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5040) db = resync - mddev->resync_mark_cnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5041) return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5042) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5043)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5044) static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5045)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5046) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5047) sync_completed_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5048) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5049) unsigned long long max_sectors, resync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5050)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5051) if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5052) return sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5053)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5054) if (mddev->curr_resync == 1 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5055) mddev->curr_resync == 2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5056) return sprintf(page, "delayed\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5057)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5058) if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5059) test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5060) max_sectors = mddev->resync_max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5061) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5062) max_sectors = mddev->dev_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5063)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5064) resync = mddev->curr_resync_completed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5065) return sprintf(page, "%llu / %llu\n", resync, max_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5066) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5067)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5068) static struct md_sysfs_entry md_sync_completed =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5069) __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5070)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5071) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5072) min_sync_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5073) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5074) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5075) (unsigned long long)mddev->resync_min);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5076) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5077) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5078) min_sync_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5079) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5080) unsigned long long min;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5081) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5082)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5083) if (kstrtoull(buf, 10, &min))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5084) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5085)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5086) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5087) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5088) if (min > mddev->resync_max)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5089) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5090)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5091) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5092) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5093) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5094)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5095) /* Round down to multiple of 4K for safety */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5096) mddev->resync_min = round_down(min, 8);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5097) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5098)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5099) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5100) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5101) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5102) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5103)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5104) static struct md_sysfs_entry md_min_sync =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5105) __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5106)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5107) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5108) max_sync_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5109) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5110) if (mddev->resync_max == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5111) return sprintf(page, "max\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5112) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5113) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5114) (unsigned long long)mddev->resync_max);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5115) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5116) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5117) max_sync_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5118) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5119) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5120) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5121) if (strncmp(buf, "max", 3) == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5122) mddev->resync_max = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5123) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5124) unsigned long long max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5125) int chunk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5126)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5127) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5128) if (kstrtoull(buf, 10, &max))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5129) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5130) if (max < mddev->resync_min)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5131) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5132)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5133) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5134) if (max < mddev->resync_max &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5135) mddev->ro == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5136) test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5137) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5138)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5139) /* Must be a multiple of chunk_size */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5140) chunk = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5141) if (chunk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5142) sector_t temp = max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5143)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5144) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5145) if (sector_div(temp, chunk))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5146) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5147) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5148) mddev->resync_max = max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5149) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5150) wake_up(&mddev->recovery_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5151) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5152) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5153) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5154) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5155) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5156)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5157) static struct md_sysfs_entry md_max_sync =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5158) __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5159)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5160) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5161) suspend_lo_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5162) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5163) return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5164) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5165)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5166) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5167) suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5168) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5169) unsigned long long new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5170) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5171)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5172) err = kstrtoull(buf, 10, &new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5173) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5174) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5175) if (new != (sector_t)new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5176) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5177)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5178) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5179) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5180) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5181) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5182) if (mddev->pers == NULL ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5183) mddev->pers->quiesce == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5184) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5185) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5186) mddev->suspend_lo = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5187) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5188)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5189) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5190) unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5191) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5192) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5193) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5194) static struct md_sysfs_entry md_suspend_lo =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5195) __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5196)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5197) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5198) suspend_hi_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5199) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5200) return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5201) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5202)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5203) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5204) suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5205) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5206) unsigned long long new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5207) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5208)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5209) err = kstrtoull(buf, 10, &new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5210) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5211) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5212) if (new != (sector_t)new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5213) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5214)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5215) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5216) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5217) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5218) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5219) if (mddev->pers == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5220) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5221)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5222) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5223) mddev->suspend_hi = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5224) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5225)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5226) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5227) unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5228) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5229) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5230) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5231) static struct md_sysfs_entry md_suspend_hi =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5232) __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5233)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5234) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5235) reshape_position_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5236) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5237) if (mddev->reshape_position != MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5238) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5239) (unsigned long long)mddev->reshape_position);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5240) strcpy(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5241) return 5;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5242) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5243)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5244) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5245) reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5246) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5247) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5248) unsigned long long new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5249) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5250)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5251) err = kstrtoull(buf, 10, &new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5252) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5253) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5254) if (new != (sector_t)new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5255) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5256) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5257) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5258) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5259) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5260) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5261) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5262) mddev->reshape_position = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5263) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5264) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5265) mddev->new_level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5266) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5267) mddev->new_chunk_sectors = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5268) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5269) rdev->new_data_offset = rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5270) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5271) unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5272) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5273) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5274) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5275)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5276) static struct md_sysfs_entry md_reshape_position =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5277) __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5278) reshape_position_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5279)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5280) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5281) reshape_direction_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5282) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5283) return sprintf(page, "%s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5284) mddev->reshape_backwards ? "backwards" : "forwards");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5285) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5286)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5287) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5288) reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5289) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5290) int backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5291) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5292)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5293) if (cmd_match(buf, "forwards"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5294) backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5295) else if (cmd_match(buf, "backwards"))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5296) backwards = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5297) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5298) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5299) if (mddev->reshape_backwards == backwards)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5300) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5301)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5302) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5303) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5304) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5305) /* check if we are allowed to change */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5306) if (mddev->delta_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5307) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5308) else if (mddev->persistent &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5309) mddev->major_version == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5310) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5311) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5312) mddev->reshape_backwards = backwards;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5313) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5314) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5315) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5316)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5317) static struct md_sysfs_entry md_reshape_direction =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5318) __ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5319) reshape_direction_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5320)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5321) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5322) array_size_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5323) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5324) if (mddev->external_size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5325) return sprintf(page, "%llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5326) (unsigned long long)mddev->array_sectors/2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5327) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5328) return sprintf(page, "default\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5329) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5330)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5331) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5332) array_size_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5333) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5334) sector_t sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5335) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5336)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5337) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5338) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5339) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5340)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5341) /* cluster raid doesn't support change array_sectors */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5342) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5343) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5344) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5345) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5346)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5347) if (strncmp(buf, "default", 7) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5348) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5349) sectors = mddev->pers->size(mddev, 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5350) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5351) sectors = mddev->array_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5352)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5353) mddev->external_size = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5354) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5355) if (strict_blocks_to_sectors(buf, §ors) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5356) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5357) else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5358) err = -E2BIG;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5359) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5360) mddev->external_size = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5361) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5362)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5363) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5364) mddev->array_sectors = sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5365) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5366) set_capacity(mddev->gendisk, mddev->array_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5367) revalidate_disk_size(mddev->gendisk, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5368) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5369) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5370) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5371) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5372) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5373)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5374) static struct md_sysfs_entry md_array_size =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5375) __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5376) array_size_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5377)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5378) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5379) consistency_policy_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5380) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5381) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5382)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5383) if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5384) ret = sprintf(page, "journal\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5385) } else if (test_bit(MD_HAS_PPL, &mddev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5386) ret = sprintf(page, "ppl\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5387) } else if (mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5388) ret = sprintf(page, "bitmap\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5389) } else if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5390) if (mddev->pers->sync_request)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5391) ret = sprintf(page, "resync\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5392) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5393) ret = sprintf(page, "none\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5394) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5395) ret = sprintf(page, "unknown\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5396) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5397)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5398) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5399) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5400)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5401) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5402) consistency_policy_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5403) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5404) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5405)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5406) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5407) if (mddev->pers->change_consistency_policy)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5408) err = mddev->pers->change_consistency_policy(mddev, buf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5409) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5410) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5411) } else if (mddev->external && strncmp(buf, "ppl", 3) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5412) set_bit(MD_HAS_PPL, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5413) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5414) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5415) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5416)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5417) return err ? err : len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5418) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5419)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5420) static struct md_sysfs_entry md_consistency_policy =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5421) __ATTR(consistency_policy, S_IRUGO | S_IWUSR, consistency_policy_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5422) consistency_policy_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5423)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5424) static ssize_t fail_last_dev_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5425) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5426) return sprintf(page, "%d\n", mddev->fail_last_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5427) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5428)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5429) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5430) * Setting fail_last_dev to true to allow last device to be forcibly removed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5431) * from RAID1/RAID10.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5432) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5433) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5434) fail_last_dev_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5435) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5436) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5437) bool value;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5438)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5439) ret = kstrtobool(buf, &value);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5440) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5441) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5442)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5443) if (value != mddev->fail_last_dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5444) mddev->fail_last_dev = value;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5445)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5446) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5447) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5448) static struct md_sysfs_entry md_fail_last_dev =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5449) __ATTR(fail_last_dev, S_IRUGO | S_IWUSR, fail_last_dev_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5450) fail_last_dev_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5451)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5452) static ssize_t serialize_policy_show(struct mddev *mddev, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5453) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5454) if (mddev->pers == NULL || (mddev->pers->level != 1))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5455) return sprintf(page, "n/a\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5456) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5457) return sprintf(page, "%d\n", mddev->serialize_policy);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5458) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5459)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5460) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5461) * Setting serialize_policy to true to enforce write IO is not reordered
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5462) * for raid1.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5463) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5464) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5465) serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5466) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5467) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5468) bool value;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5469)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5470) err = kstrtobool(buf, &value);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5471) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5472) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5473)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5474) if (value == mddev->serialize_policy)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5475) return len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5476)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5477) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5478) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5479) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5480) if (mddev->pers == NULL || (mddev->pers->level != 1)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5481) pr_err("md: serialize_policy is only effective for raid1\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5482) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5483) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5484) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5485)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5486) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5487) if (value)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5488) mddev_create_serial_pool(mddev, NULL, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5489) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5490) mddev_destroy_serial_pool(mddev, NULL, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5491) mddev->serialize_policy = value;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5492) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5493) unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5494) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5495) return err ?: len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5496) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5497)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5498) static struct md_sysfs_entry md_serialize_policy =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5499) __ATTR(serialize_policy, S_IRUGO | S_IWUSR, serialize_policy_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5500) serialize_policy_store);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5501)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5502)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5503) static struct attribute *md_default_attrs[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5504) &md_level.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5505) &md_layout.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5506) &md_raid_disks.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5507) &md_uuid.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5508) &md_chunk_size.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5509) &md_size.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5510) &md_resync_start.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5511) &md_metadata.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5512) &md_new_device.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5513) &md_safe_delay.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5514) &md_array_state.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5515) &md_reshape_position.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5516) &md_reshape_direction.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5517) &md_array_size.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5518) &max_corr_read_errors.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5519) &md_consistency_policy.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5520) &md_fail_last_dev.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5521) &md_serialize_policy.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5522) NULL,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5523) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5524)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5525) static struct attribute *md_redundancy_attrs[] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5526) &md_scan_mode.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5527) &md_last_scan_mode.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5528) &md_mismatches.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5529) &md_sync_min.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5530) &md_sync_max.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5531) &md_sync_speed.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5532) &md_sync_force_parallel.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5533) &md_sync_completed.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5534) &md_min_sync.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5535) &md_max_sync.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5536) &md_suspend_lo.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5537) &md_suspend_hi.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5538) &md_bitmap.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5539) &md_degraded.attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5540) NULL,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5541) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5542) static struct attribute_group md_redundancy_group = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5543) .name = NULL,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5544) .attrs = md_redundancy_attrs,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5545) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5546)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5547) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5548) md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5549) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5550) struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5551) struct mddev *mddev = container_of(kobj, struct mddev, kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5552) ssize_t rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5553)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5554) if (!entry->show)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5555) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5556) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5557) if (list_empty(&mddev->all_mddevs)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5558) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5559) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5560) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5561) mddev_get(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5562) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5563)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5564) rv = entry->show(mddev, page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5565) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5566) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5567) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5568)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5569) static ssize_t
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5570) md_attr_store(struct kobject *kobj, struct attribute *attr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5571) const char *page, size_t length)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5572) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5573) struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5574) struct mddev *mddev = container_of(kobj, struct mddev, kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5575) ssize_t rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5576)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5577) if (!entry->store)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5578) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5579) if (!capable(CAP_SYS_ADMIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5580) return -EACCES;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5581) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5582) if (list_empty(&mddev->all_mddevs)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5583) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5584) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5585) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5586) mddev_get(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5587) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5588) rv = entry->store(mddev, page, length);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5589) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5590) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5591) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5592)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5593) static void md_free(struct kobject *ko)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5594) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5595) struct mddev *mddev = container_of(ko, struct mddev, kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5596)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5597) if (mddev->sysfs_state)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5598) sysfs_put(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5599) if (mddev->sysfs_level)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5600) sysfs_put(mddev->sysfs_level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5601)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5602) if (mddev->gendisk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5603) del_gendisk(mddev->gendisk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5604) if (mddev->queue)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5605) blk_cleanup_queue(mddev->queue);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5606) if (mddev->gendisk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5607) put_disk(mddev->gendisk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5608) percpu_ref_exit(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5609)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5610) bioset_exit(&mddev->bio_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5611) bioset_exit(&mddev->sync_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5612) kfree(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5613) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5614)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5615) static const struct sysfs_ops md_sysfs_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5616) .show = md_attr_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5617) .store = md_attr_store,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5618) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5619) static struct kobj_type md_ktype = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5620) .release = md_free,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5621) .sysfs_ops = &md_sysfs_ops,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5622) .default_attrs = md_default_attrs,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5623) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5624)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5625) int mdp_major = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5626)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5627) static void mddev_delayed_delete(struct work_struct *ws)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5628) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5629) struct mddev *mddev = container_of(ws, struct mddev, del_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5630)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5631) sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5632) kobject_del(&mddev->kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5633) kobject_put(&mddev->kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5634) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5635)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5636) static void no_op(struct percpu_ref *r) {}
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5637)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5638) int mddev_init_writes_pending(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5639) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5640) if (mddev->writes_pending.percpu_count_ptr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5641) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5642) if (percpu_ref_init(&mddev->writes_pending, no_op,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5643) PERCPU_REF_ALLOW_REINIT, GFP_KERNEL) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5644) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5645) /* We want to start with the refcount at zero */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5646) percpu_ref_put(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5647) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5648) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5649) EXPORT_SYMBOL_GPL(mddev_init_writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5650)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5651) static int md_alloc(dev_t dev, char *name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5652) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5653) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5654) * If dev is zero, name is the name of a device to allocate with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5655) * an arbitrary minor number. It will be "md_???"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5656) * If dev is non-zero it must be a device number with a MAJOR of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5657) * MD_MAJOR or mdp_major. In this case, if "name" is NULL, then
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5658) * the device is being created by opening a node in /dev.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5659) * If "name" is not NULL, the device is being created by
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5660) * writing to /sys/module/md_mod/parameters/new_array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5661) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5662) static DEFINE_MUTEX(disks_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5663) struct mddev *mddev = mddev_find_or_alloc(dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5664) struct gendisk *disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5665) int partitioned;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5666) int shift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5667) int unit;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5668) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5669)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5670) if (!mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5671) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5672)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5673) partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5674) shift = partitioned ? MdpMinorShift : 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5675) unit = MINOR(mddev->unit) >> shift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5676)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5677) /* wait for any previous instance of this device to be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5678) * completely removed (mddev_delayed_delete).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5679) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5680) flush_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5681)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5682) mutex_lock(&disks_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5683) error = -EEXIST;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5684) if (mddev->gendisk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5685) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5686)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5687) if (name && !dev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5688) /* Need to ensure that 'name' is not a duplicate.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5689) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5690) struct mddev *mddev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5691) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5692)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5693) list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5694) if (mddev2->gendisk &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5695) strcmp(mddev2->gendisk->disk_name, name) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5696) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5697) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5698) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5699) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5700) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5701) if (name && dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5702) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5703) * Creating /dev/mdNNN via "newarray", so adjust hold_active.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5704) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5705) mddev->hold_active = UNTIL_STOP;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5706)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5707) error = -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5708) mddev->queue = blk_alloc_queue(NUMA_NO_NODE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5709) if (!mddev->queue)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5710) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5711)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5712) blk_set_stacking_limits(&mddev->queue->limits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5713)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5714) disk = alloc_disk(1 << shift);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5715) if (!disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5716) blk_cleanup_queue(mddev->queue);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5717) mddev->queue = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5718) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5719) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5720) disk->major = MAJOR(mddev->unit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5721) disk->first_minor = unit << shift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5722) if (name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5723) strcpy(disk->disk_name, name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5724) else if (partitioned)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5725) sprintf(disk->disk_name, "md_d%d", unit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5726) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5727) sprintf(disk->disk_name, "md%d", unit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5728) disk->fops = &md_fops;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5729) disk->private_data = mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5730) disk->queue = mddev->queue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5731) blk_queue_write_cache(mddev->queue, true, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5732) /* Allow extended partitions. This makes the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5733) * 'mdp' device redundant, but we can't really
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5734) * remove it now.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5735) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5736) disk->flags |= GENHD_FL_EXT_DEVT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5737) disk->events |= DISK_EVENT_MEDIA_CHANGE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5738) mddev->gendisk = disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5739) add_disk(disk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5740)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5741) error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5742) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5743) /* This isn't possible, but as kobject_init_and_add is marked
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5744) * __must_check, we must do something with the result
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5745) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5746) pr_debug("md: cannot register %s/md - name in use\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5747) disk->disk_name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5748) error = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5749) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5750) if (mddev->kobj.sd &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5751) sysfs_create_group(&mddev->kobj, &md_bitmap_group))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5752) pr_debug("pointless warning\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5753) abort:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5754) mutex_unlock(&disks_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5755) if (!error && mddev->kobj.sd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5756) kobject_uevent(&mddev->kobj, KOBJ_ADD);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5757) mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5758) mddev->sysfs_level = sysfs_get_dirent_safe(mddev->kobj.sd, "level");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5759) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5760) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5761) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5762) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5763)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5764) static struct kobject *md_probe(dev_t dev, int *part, void *data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5765) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5766) if (create_on_open)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5767) md_alloc(dev, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5768) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5769) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5770)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5771) static int add_named_array(const char *val, const struct kernel_param *kp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5772) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5773) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5774) * val must be "md_*" or "mdNNN".
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5775) * For "md_*" we allocate an array with a large free minor number, and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5776) * set the name to val. val must not already be an active name.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5777) * For "mdNNN" we allocate an array with the minor number NNN
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5778) * which must not already be in use.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5779) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5780) int len = strlen(val);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5781) char buf[DISK_NAME_LEN];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5782) unsigned long devnum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5784) while (len && val[len-1] == '\n')
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5785) len--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5786) if (len >= DISK_NAME_LEN)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5787) return -E2BIG;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5788) strlcpy(buf, val, len+1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5789) if (strncmp(buf, "md_", 3) == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5790) return md_alloc(0, buf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5791) if (strncmp(buf, "md", 2) == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5792) isdigit(buf[2]) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5793) kstrtoul(buf+2, 10, &devnum) == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5794) devnum <= MINORMASK)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5795) return md_alloc(MKDEV(MD_MAJOR, devnum), NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5796)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5797) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5798) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5799)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5800) static void md_safemode_timeout(struct timer_list *t)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5801) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5802) struct mddev *mddev = from_timer(mddev, t, safemode_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5803)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5804) mddev->safemode = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5805) if (mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5806) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5807)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5808) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5809) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5810)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5811) static int start_dirty_degraded;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5812)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5813) int md_run(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5814) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5815) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5816) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5817) struct md_personality *pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5818)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5819) if (list_empty(&mddev->disks))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5820) /* cannot run an array with no devices.. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5821) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5822)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5823) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5824) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5825) /* Cannot run until previous stop completes properly */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5826) if (mddev->sysfs_active)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5827) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5828)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5829) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5830) * Analyze all RAID superblock(s)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5831) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5832) if (!mddev->raid_disks) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5833) if (!mddev->persistent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5834) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5835) err = analyze_sbs(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5836) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5837) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5838) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5839)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5840) if (mddev->level != LEVEL_NONE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5841) request_module("md-level-%d", mddev->level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5842) else if (mddev->clevel[0])
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5843) request_module("md-%s", mddev->clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5844)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5845) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5846) * Drop all container device buffers, from now on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5847) * the only valid external interface is through the md
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5848) * device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5849) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5850) mddev->has_superblocks = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5851) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5852) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5853) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5854) sync_blockdev(rdev->bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5855) invalidate_bdev(rdev->bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5856) if (mddev->ro != 1 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5857) (bdev_read_only(rdev->bdev) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5858) bdev_read_only(rdev->meta_bdev))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5859) mddev->ro = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5860) if (mddev->gendisk)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5861) set_disk_ro(mddev->gendisk, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5862) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5863)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5864) if (rdev->sb_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5865) mddev->has_superblocks = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5866)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5867) /* perform some consistency tests on the device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5868) * We don't want the data to overlap the metadata,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5869) * Internal Bitmap issues have been handled elsewhere.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5870) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5871) if (rdev->meta_bdev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5872) /* Nothing to check */;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5873) } else if (rdev->data_offset < rdev->sb_start) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5874) if (mddev->dev_sectors &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5875) rdev->data_offset + mddev->dev_sectors
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5876) > rdev->sb_start) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5877) pr_warn("md: %s: data overlaps metadata\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5878) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5879) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5880) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5881) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5882) if (rdev->sb_start + rdev->sb_size/512
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5883) > rdev->data_offset) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5884) pr_warn("md: %s: metadata overlaps data\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5885) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5886) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5887) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5888) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5889) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5890) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5891)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5892) if (!bioset_initialized(&mddev->bio_set)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5893) err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5894) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5895) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5896) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5897) if (!bioset_initialized(&mddev->sync_set)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5898) err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5899) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5900) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5901) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5902)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5903) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5904) pers = find_pers(mddev->level, mddev->clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5905) if (!pers || !try_module_get(pers->owner)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5906) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5907) if (mddev->level != LEVEL_NONE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5908) pr_warn("md: personality for level %d is not loaded!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5909) mddev->level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5910) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5911) pr_warn("md: personality for level %s is not loaded!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5912) mddev->clevel);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5913) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5914) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5915) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5916) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5917) if (mddev->level != pers->level) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5918) mddev->level = pers->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5919) mddev->new_level = pers->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5920) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5921) strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5922)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5923) if (mddev->reshape_position != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5924) pers->start_reshape == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5925) /* This personality cannot handle reshaping... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5926) module_put(pers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5927) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5928) goto abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5929) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5930)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5931) if (pers->sync_request) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5932) /* Warn if this is a potentially silly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5933) * configuration.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5934) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5935) char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5936) struct md_rdev *rdev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5937) int warned = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5938)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5939) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5940) rdev_for_each(rdev2, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5941) if (rdev < rdev2 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5942) rdev->bdev->bd_disk ==
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5943) rdev2->bdev->bd_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5944) pr_warn("%s: WARNING: %s appears to be on the same physical disk as %s.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5945) mdname(mddev),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5946) bdevname(rdev->bdev,b),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5947) bdevname(rdev2->bdev,b2));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5948) warned = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5949) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5950) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5951)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5952) if (warned)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5953) pr_warn("True protection against single-disk failure might be compromised.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5954) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5955)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5956) mddev->recovery = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5957) /* may be over-ridden by personality */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5958) mddev->resync_max_sectors = mddev->dev_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5959)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5960) mddev->ok_start_degraded = start_dirty_degraded;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5961)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5962) if (start_readonly && mddev->ro == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5963) mddev->ro = 2; /* read-only, but switch on first write */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5964)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5965) err = pers->run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5966) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5967) pr_warn("md: pers->run() failed ...\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5968) else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5969) WARN_ONCE(!mddev->external_size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5970) "%s: default size too small, but 'external_size' not in effect?\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5971) __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5972) pr_warn("md: invalid array_size %llu > default size %llu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5973) (unsigned long long)mddev->array_sectors / 2,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5974) (unsigned long long)pers->size(mddev, 0, 0) / 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5975) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5976) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5977) if (err == 0 && pers->sync_request &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5978) (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5979) struct bitmap *bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5980)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5981) bitmap = md_bitmap_create(mddev, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5982) if (IS_ERR(bitmap)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5983) err = PTR_ERR(bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5984) pr_warn("%s: failed to create bitmap (%d)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5985) mdname(mddev), err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5986) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5987) mddev->bitmap = bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5988)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5989) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5990) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5991) goto bitmap_abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5992)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5993) if (mddev->bitmap_info.max_write_behind > 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5994) bool create_pool = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5995)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5996) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5997) if (test_bit(WriteMostly, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5998) rdev_init_serial(rdev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5999) create_pool = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6000) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6001) if (create_pool && mddev->serial_info_pool == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6002) mddev->serial_info_pool =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6003) mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6004) sizeof(struct serial_info));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6005) if (!mddev->serial_info_pool) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6006) err = -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6007) goto bitmap_abort;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6008) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6009) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6010) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6011)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6012) if (mddev->queue) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6013) bool nonrot = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6014)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6015) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6016) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6017) !blk_queue_nonrot(bdev_get_queue(rdev->bdev))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6018) nonrot = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6019) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6020) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6021) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6022) if (mddev->degraded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6023) nonrot = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6024) if (nonrot)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6025) blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6026) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6027) blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6028) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6029) if (pers->sync_request) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6030) if (mddev->kobj.sd &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6031) sysfs_create_group(&mddev->kobj, &md_redundancy_group))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6032) pr_warn("md: cannot register extra attributes for %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6033) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6034) mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6035) mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6036) mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6037) } else if (mddev->ro == 2) /* auto-readonly not meaningful */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6038) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6039)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6040) atomic_set(&mddev->max_corr_read_errors,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6041) MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6042) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6043) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6044) mddev->safemode_delay = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6045) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6046) mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6047) mddev->in_sync = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6048) smp_wmb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6049) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6050) mddev->pers = pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6051) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6052) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6053) if (rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6054) sysfs_link_rdev(mddev, rdev); /* failure here is OK */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6055)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6056) if (mddev->degraded && !mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6057) /* This ensures that recovering status is reported immediately
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6058) * via sysfs - until a lack of spares is confirmed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6059) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6060) set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6061) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6062)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6063) if (mddev->sb_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6064) md_update_sb(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6065)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6066) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6067) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6068)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6069) bitmap_abort:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6070) mddev_detach(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6071) if (mddev->private)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6072) pers->free(mddev, mddev->private);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6073) mddev->private = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6074) module_put(pers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6075) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6076) abort:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6077) bioset_exit(&mddev->bio_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6078) bioset_exit(&mddev->sync_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6079) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6080) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6081) EXPORT_SYMBOL_GPL(md_run);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6082)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6083) int do_md_run(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6084) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6085) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6086)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6087) set_bit(MD_NOT_READY, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6088) err = md_run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6089) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6090) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6091) err = md_bitmap_load(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6092) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6093) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6094) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6095) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6096)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6097) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6098) md_allow_write(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6099)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6100) /* run start up tasks that require md_thread */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6101) md_start(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6102)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6103) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6104) md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6105)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6106) set_capacity(mddev->gendisk, mddev->array_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6107) revalidate_disk_size(mddev->gendisk, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6108) clear_bit(MD_NOT_READY, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6109) mddev->changed = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6110) kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6111) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6112) sysfs_notify_dirent_safe(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6113) sysfs_notify_dirent_safe(mddev->sysfs_degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6114) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6115) clear_bit(MD_NOT_READY, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6116) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6117) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6118)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6119) int md_start(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6120) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6121) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6122)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6123) if (mddev->pers->start) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6124) set_bit(MD_RECOVERY_WAIT, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6125) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6126) ret = mddev->pers->start(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6127) clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6128) md_wakeup_thread(mddev->sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6129) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6130) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6131) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6132) EXPORT_SYMBOL_GPL(md_start);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6133)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6134) static int restart_array(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6135) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6136) struct gendisk *disk = mddev->gendisk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6137) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6138) bool has_journal = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6139) bool has_readonly = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6140)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6141) /* Complain if it has no devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6142) if (list_empty(&mddev->disks))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6143) return -ENXIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6144) if (!mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6145) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6146) if (!mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6147) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6148)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6149) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6150) rdev_for_each_rcu(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6151) if (test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6152) !test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6153) has_journal = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6154) if (bdev_read_only(rdev->bdev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6155) has_readonly = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6156) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6157) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6158) if (test_bit(MD_HAS_JOURNAL, &mddev->flags) && !has_journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6159) /* Don't restart rw with journal missing/faulty */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6160) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6161) if (has_readonly)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6162) return -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6163)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6164) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6165) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6166) set_disk_ro(disk, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6167) pr_debug("md: %s switched to read-write mode.\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6168) /* Kick recovery or resync if necessary */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6169) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6170) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6171) md_wakeup_thread(mddev->sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6172) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6173) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6174) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6175)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6176) static void md_clean(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6177) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6178) mddev->array_sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6179) mddev->external_size = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6180) mddev->dev_sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6181) mddev->raid_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6182) mddev->recovery_cp = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6183) mddev->resync_min = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6184) mddev->resync_max = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6185) mddev->reshape_position = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6186) mddev->external = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6187) mddev->persistent = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6188) mddev->level = LEVEL_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6189) mddev->clevel[0] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6190) mddev->flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6191) mddev->sb_flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6192) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6193) mddev->metadata_type[0] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6194) mddev->chunk_sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6195) mddev->ctime = mddev->utime = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6196) mddev->layout = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6197) mddev->max_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6198) mddev->events = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6199) mddev->can_decrease_events = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6200) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6201) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6202) mddev->new_level = LEVEL_NONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6203) mddev->new_layout = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6204) mddev->new_chunk_sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6205) mddev->curr_resync = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6206) atomic64_set(&mddev->resync_mismatches, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6207) mddev->suspend_lo = mddev->suspend_hi = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6208) mddev->sync_speed_min = mddev->sync_speed_max = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6209) mddev->recovery = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6210) mddev->in_sync = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6211) mddev->changed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6212) mddev->degraded = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6213) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6214) mddev->private = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6215) mddev->cluster_info = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6216) mddev->bitmap_info.offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6217) mddev->bitmap_info.default_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6218) mddev->bitmap_info.default_space = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6219) mddev->bitmap_info.chunksize = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6220) mddev->bitmap_info.daemon_sleep = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6221) mddev->bitmap_info.max_write_behind = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6222) mddev->bitmap_info.nodes = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6223) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6224)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6225) static void __md_stop_writes(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6226) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6227) set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6228) if (work_pending(&mddev->del_work))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6229) flush_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6230) if (mddev->sync_thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6231) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6232) md_reap_sync_thread(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6233) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6234)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6235) del_timer_sync(&mddev->safemode_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6236)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6237) if (mddev->pers && mddev->pers->quiesce) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6238) mddev->pers->quiesce(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6239) mddev->pers->quiesce(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6240) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6241) md_bitmap_flush(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6242)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6243) if (mddev->ro == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6244) ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6245) mddev->sb_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6246) /* mark array as shutdown cleanly */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6247) if (!mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6248) mddev->in_sync = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6249) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6250) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6251) /* disable policy to guarantee rdevs free resources for serialization */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6252) mddev->serialize_policy = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6253) mddev_destroy_serial_pool(mddev, NULL, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6254) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6255)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6256) void md_stop_writes(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6257) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6258) mddev_lock_nointr(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6259) __md_stop_writes(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6260) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6261) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6262) EXPORT_SYMBOL_GPL(md_stop_writes);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6263)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6264) static void mddev_detach(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6265) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6266) md_bitmap_wait_behind_writes(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6267) if (mddev->pers && mddev->pers->quiesce && !mddev->suspended) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6268) mddev->pers->quiesce(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6269) mddev->pers->quiesce(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6270) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6271) md_unregister_thread(&mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6272) if (mddev->queue)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6273) blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6274) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6275)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6276) static void __md_stop(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6277) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6278) struct md_personality *pers = mddev->pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6279) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6280) mddev_detach(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6281) /* Ensure ->event_work is done */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6282) if (mddev->event_work.func)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6283) flush_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6284) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6285) mddev->pers = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6286) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6287) pers->free(mddev, mddev->private);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6288) mddev->private = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6289) if (pers->sync_request && mddev->to_remove == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6290) mddev->to_remove = &md_redundancy_group;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6291) module_put(pers->owner);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6292) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6293) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6294)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6295) void md_stop(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6296) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6297) /* stop the array and free an attached data structures.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6298) * This is called from dm-raid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6299) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6300) __md_stop(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6301) bioset_exit(&mddev->bio_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6302) bioset_exit(&mddev->sync_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6303) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6304)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6305) EXPORT_SYMBOL_GPL(md_stop);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6306)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6307) static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6308) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6309) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6310) int did_freeze = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6311)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6312) if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6313) did_freeze = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6314) set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6315) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6316) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6317) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6318) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6319) if (mddev->sync_thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6320) /* Thread might be blocked waiting for metadata update
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6321) * which will now never happen */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6322) wake_up_process(mddev->sync_thread->tsk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6323)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6324) if (mddev->external && test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6325) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6326) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6327) wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6328) &mddev->recovery));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6329) wait_event(mddev->sb_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6330) !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6331) mddev_lock_nointr(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6332)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6333) mutex_lock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6334) if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6335) mddev->sync_thread ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6336) test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6337) pr_warn("md: %s still in use.\n",mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6338) if (did_freeze) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6339) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6340) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6341) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6342) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6343) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6344) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6345) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6346) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6347) __md_stop_writes(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6348)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6349) err = -ENXIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6350) if (mddev->ro==1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6351) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6352) mddev->ro = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6353) set_disk_ro(mddev->gendisk, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6354) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6355) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6356) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6357) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6358) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6359) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6360) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6361) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6362) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6363) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6364)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6365) /* mode:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6366) * 0 - completely stop and dis-assemble array
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6367) * 2 - stop but do not disassemble array
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6368) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6369) static int do_md_stop(struct mddev *mddev, int mode,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6370) struct block_device *bdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6371) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6372) struct gendisk *disk = mddev->gendisk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6373) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6374) int did_freeze = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6375)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6376) if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6377) did_freeze = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6378) set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6379) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6380) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6381) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6382) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6383) if (mddev->sync_thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6384) /* Thread might be blocked waiting for metadata update
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6385) * which will now never happen */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6386) wake_up_process(mddev->sync_thread->tsk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6387)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6388) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6389) wait_event(resync_wait, (mddev->sync_thread == NULL &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6390) !test_bit(MD_RECOVERY_RUNNING,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6391) &mddev->recovery)));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6392) mddev_lock_nointr(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6393)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6394) mutex_lock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6395) if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6396) mddev->sysfs_active ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6397) mddev->sync_thread ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6398) test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6399) pr_warn("md: %s still in use.\n",mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6400) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6401) if (did_freeze) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6402) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6403) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6404) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6405) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6406) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6407) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6408) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6409) if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6410) set_disk_ro(disk, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6411)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6412) __md_stop_writes(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6413) __md_stop(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6414)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6415) /* tell userspace to handle 'inactive' */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6416) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6417)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6418) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6419) if (rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6420) sysfs_unlink_rdev(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6421)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6422) set_capacity(disk, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6423) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6424) mddev->changed = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6425) revalidate_disk_size(disk, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6426)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6427) if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6428) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6429) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6430) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6431) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6432) * Free resources if final stop
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6433) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6434) if (mode == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6435) pr_info("md: %s stopped.\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6436)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6437) if (mddev->bitmap_info.file) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6438) struct file *f = mddev->bitmap_info.file;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6439) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6440) mddev->bitmap_info.file = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6441) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6442) fput(f);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6443) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6444) mddev->bitmap_info.offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6445)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6446) export_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6447)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6448) md_clean(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6449) if (mddev->hold_active == UNTIL_STOP)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6450) mddev->hold_active = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6451) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6452) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6453) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6454) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6455) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6456)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6457) #ifndef MODULE
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6458) static void autorun_array(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6459) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6460) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6461) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6462)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6463) if (list_empty(&mddev->disks))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6464) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6465)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6466) pr_info("md: running: ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6467)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6468) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6469) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6470) pr_cont("<%s>", bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6471) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6472) pr_cont("\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6473)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6474) err = do_md_run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6475) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6476) pr_warn("md: do_md_run() returned %d\n", err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6477) do_md_stop(mddev, 0, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6478) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6479) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6480)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6481) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6482) * lets try to run arrays based on all disks that have arrived
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6483) * until now. (those are in pending_raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6484) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6485) * the method: pick the first pending disk, collect all disks with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6486) * the same UUID, remove all from the pending list and put them into
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6487) * the 'same_array' list. Then order this list based on superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6488) * update time (freshest comes first), kick out 'old' disks and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6489) * compare superblocks. If everything's fine then run it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6490) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6491) * If "unit" is allocated, then bump its reference count
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6492) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6493) static void autorun_devices(int part)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6494) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6495) struct md_rdev *rdev0, *rdev, *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6496) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6497) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6498)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6499) pr_info("md: autorun ...\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6500) while (!list_empty(&pending_raid_disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6501) int unit;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6502) dev_t dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6503) LIST_HEAD(candidates);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6504) rdev0 = list_entry(pending_raid_disks.next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6505) struct md_rdev, same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6506)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6507) pr_debug("md: considering %s ...\n", bdevname(rdev0->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6508) INIT_LIST_HEAD(&candidates);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6509) rdev_for_each_list(rdev, tmp, &pending_raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6510) if (super_90_load(rdev, rdev0, 0) >= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6511) pr_debug("md: adding %s ...\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6512) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6513) list_move(&rdev->same_set, &candidates);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6514) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6515) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6516) * now we have a set of devices, with all of them having
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6517) * mostly sane superblocks. It's time to allocate the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6518) * mddev.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6519) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6520) if (part) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6521) dev = MKDEV(mdp_major,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6522) rdev0->preferred_minor << MdpMinorShift);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6523) unit = MINOR(dev) >> MdpMinorShift;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6524) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6525) dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6526) unit = MINOR(dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6527) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6528) if (rdev0->preferred_minor != unit) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6529) pr_warn("md: unit number in %s is bad: %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6530) bdevname(rdev0->bdev, b), rdev0->preferred_minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6531) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6532) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6533)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6534) md_probe(dev, NULL, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6535) mddev = mddev_find(dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6536) if (!mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6537) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6538)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6539) if (mddev_lock(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6540) pr_warn("md: %s locked, cannot run\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6541) else if (mddev->raid_disks || mddev->major_version
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6542) || !list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6543) pr_warn("md: %s already running, cannot run %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6544) mdname(mddev), bdevname(rdev0->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6545) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6546) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6547) pr_debug("md: created %s\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6548) mddev->persistent = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6549) rdev_for_each_list(rdev, tmp, &candidates) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6550) list_del_init(&rdev->same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6551) if (bind_rdev_to_array(rdev, mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6552) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6553) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6554) autorun_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6555) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6556) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6557) /* on success, candidates will be empty, on error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6558) * it won't...
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6559) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6560) rdev_for_each_list(rdev, tmp, &candidates) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6561) list_del_init(&rdev->same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6562) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6563) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6564) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6565) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6566) pr_info("md: ... autorun DONE.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6567) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6568) #endif /* !MODULE */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6569)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6570) static int get_version(void __user *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6571) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6572) mdu_version_t ver;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6573)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6574) ver.major = MD_MAJOR_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6575) ver.minor = MD_MINOR_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6576) ver.patchlevel = MD_PATCHLEVEL_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6577)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6578) if (copy_to_user(arg, &ver, sizeof(ver)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6579) return -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6580)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6581) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6582) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6583)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6584) static int get_array_info(struct mddev *mddev, void __user *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6585) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6586) mdu_array_info_t info;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6587) int nr,working,insync,failed,spare;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6588) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6590) nr = working = insync = failed = spare = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6591) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6592) rdev_for_each_rcu(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6593) nr++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6594) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6595) failed++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6596) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6597) working++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6598) if (test_bit(In_sync, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6599) insync++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6600) else if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6601) /* TODO: add journal count to md_u.h */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6602) ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6603) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6604) spare++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6605) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6606) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6607) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6608)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6609) info.major_version = mddev->major_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6610) info.minor_version = mddev->minor_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6611) info.patch_version = MD_PATCHLEVEL_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6612) info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6613) info.level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6614) info.size = mddev->dev_sectors / 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6615) if (info.size != mddev->dev_sectors / 2) /* overflow */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6616) info.size = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6617) info.nr_disks = nr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6618) info.raid_disks = mddev->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6619) info.md_minor = mddev->md_minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6620) info.not_persistent= !mddev->persistent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6621)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6622) info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6623) info.state = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6624) if (mddev->in_sync)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6625) info.state = (1<<MD_SB_CLEAN);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6626) if (mddev->bitmap && mddev->bitmap_info.offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6627) info.state |= (1<<MD_SB_BITMAP_PRESENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6628) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6629) info.state |= (1<<MD_SB_CLUSTERED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6630) info.active_disks = insync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6631) info.working_disks = working;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6632) info.failed_disks = failed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6633) info.spare_disks = spare;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6634)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6635) info.layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6636) info.chunk_size = mddev->chunk_sectors << 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6637)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6638) if (copy_to_user(arg, &info, sizeof(info)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6639) return -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6640)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6641) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6642) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6643)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6644) static int get_bitmap_file(struct mddev *mddev, void __user * arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6645) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6646) mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6647) char *ptr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6648) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6649)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6650) file = kzalloc(sizeof(*file), GFP_NOIO);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6651) if (!file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6652) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6653)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6654) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6655) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6656) /* bitmap enabled */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6657) if (mddev->bitmap_info.file) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6658) ptr = file_path(mddev->bitmap_info.file, file->pathname,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6659) sizeof(file->pathname));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6660) if (IS_ERR(ptr))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6661) err = PTR_ERR(ptr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6662) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6663) memmove(file->pathname, ptr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6664) sizeof(file->pathname)-(ptr-file->pathname));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6665) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6666) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6667)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6668) if (err == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6669) copy_to_user(arg, file, sizeof(*file)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6670) err = -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6671)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6672) kfree(file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6673) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6674) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6675)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6676) static int get_disk_info(struct mddev *mddev, void __user * arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6677) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6678) mdu_disk_info_t info;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6679) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6680)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6681) if (copy_from_user(&info, arg, sizeof(info)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6682) return -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6683)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6684) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6685) rdev = md_find_rdev_nr_rcu(mddev, info.number);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6686) if (rdev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6687) info.major = MAJOR(rdev->bdev->bd_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6688) info.minor = MINOR(rdev->bdev->bd_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6689) info.raid_disk = rdev->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6690) info.state = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6691) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6692) info.state |= (1<<MD_DISK_FAULTY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6693) else if (test_bit(In_sync, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6694) info.state |= (1<<MD_DISK_ACTIVE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6695) info.state |= (1<<MD_DISK_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6696) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6697) if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6698) info.state |= (1<<MD_DISK_JOURNAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6699) if (test_bit(WriteMostly, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6700) info.state |= (1<<MD_DISK_WRITEMOSTLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6701) if (test_bit(FailFast, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6702) info.state |= (1<<MD_DISK_FAILFAST);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6703) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6704) info.major = info.minor = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6705) info.raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6706) info.state = (1<<MD_DISK_REMOVED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6707) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6708) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6709)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6710) if (copy_to_user(arg, &info, sizeof(info)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6711) return -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6712)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6713) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6714) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6715)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6716) int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6717) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6718) char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6719) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6720) dev_t dev = MKDEV(info->major,info->minor);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6721)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6722) if (mddev_is_clustered(mddev) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6723) !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6724) pr_warn("%s: Cannot add to clustered mddev.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6725) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6726) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6727) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6728)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6729) if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6730) return -EOVERFLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6731)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6732) if (!mddev->raid_disks) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6733) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6734) /* expecting a device which has a superblock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6735) rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6736) if (IS_ERR(rdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6737) pr_warn("md: md_import_device returned %ld\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6738) PTR_ERR(rdev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6739) return PTR_ERR(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6740) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6741) if (!list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6742) struct md_rdev *rdev0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6743) = list_entry(mddev->disks.next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6744) struct md_rdev, same_set);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6745) err = super_types[mddev->major_version]
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6746) .load_super(rdev, rdev0, mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6747) if (err < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6748) pr_warn("md: %s has different UUID to %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6749) bdevname(rdev->bdev,b),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6750) bdevname(rdev0->bdev,b2));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6751) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6752) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6753) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6754) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6755) err = bind_rdev_to_array(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6756) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6757) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6758) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6759) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6760)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6761) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6762) * md_add_new_disk can be used once the array is assembled
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6763) * to add "hot spares". They must already have a superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6764) * written
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6765) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6766) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6767) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6768) if (!mddev->pers->hot_add_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6769) pr_warn("%s: personality does not support diskops!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6770) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6771) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6772) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6773) if (mddev->persistent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6774) rdev = md_import_device(dev, mddev->major_version,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6775) mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6776) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6777) rdev = md_import_device(dev, -1, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6778) if (IS_ERR(rdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6779) pr_warn("md: md_import_device returned %ld\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6780) PTR_ERR(rdev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6781) return PTR_ERR(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6782) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6783) /* set saved_raid_disk if appropriate */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6784) if (!mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6785) if (info->state & (1<<MD_DISK_SYNC) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6786) info->raid_disk < mddev->raid_disks) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6787) rdev->raid_disk = info->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6788) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6789) clear_bit(Bitmap_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6790) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6791) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6792) rdev->saved_raid_disk = rdev->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6793) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6794) super_types[mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6795) validate_super(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6796) if ((info->state & (1<<MD_DISK_SYNC)) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6797) rdev->raid_disk != info->raid_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6798) /* This was a hot-add request, but events doesn't
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6799) * match, so reject it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6800) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6801) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6802) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6803) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6804)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6805) clear_bit(In_sync, &rdev->flags); /* just to be sure */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6806) if (info->state & (1<<MD_DISK_WRITEMOSTLY))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6807) set_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6808) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6809) clear_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6810) if (info->state & (1<<MD_DISK_FAILFAST))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6811) set_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6812) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6813) clear_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6814)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6815) if (info->state & (1<<MD_DISK_JOURNAL)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6816) struct md_rdev *rdev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6817) bool has_journal = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6818)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6819) /* make sure no existing journal disk */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6820) rdev_for_each(rdev2, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6821) if (test_bit(Journal, &rdev2->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6822) has_journal = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6823) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6824) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6825) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6826) if (has_journal || mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6827) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6828) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6829) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6830) set_bit(Journal, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6831) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6832) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6833) * check whether the device shows up in other nodes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6834) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6835) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6836) if (info->state & (1 << MD_DISK_CANDIDATE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6837) set_bit(Candidate, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6838) else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6839) /* --add initiated by this node */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6840) err = md_cluster_ops->add_new_disk(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6841) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6842) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6843) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6844) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6845) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6846) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6847)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6848) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6849) err = bind_rdev_to_array(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6850)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6851) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6852) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6853)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6854) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6855) if (info->state & (1 << MD_DISK_CANDIDATE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6856) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6857) err = md_cluster_ops->new_disk_ack(mddev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6858) err == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6859) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6860) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6861) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6862) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6863) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6864) md_cluster_ops->add_new_disk_cancel(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6865) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6866) err = add_bound_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6867) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6868)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6869) } else if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6870) err = add_bound_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6871)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6872) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6873) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6874)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6875) /* otherwise, md_add_new_disk is only allowed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6876) * for major_version==0 superblocks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6877) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6878) if (mddev->major_version != 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6879) pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6880) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6881) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6882)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6883) if (!(info->state & (1<<MD_DISK_FAULTY))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6884) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6885) rdev = md_import_device(dev, -1, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6886) if (IS_ERR(rdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6887) pr_warn("md: error, md_import_device() returned %ld\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6888) PTR_ERR(rdev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6889) return PTR_ERR(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6890) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6891) rdev->desc_nr = info->number;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6892) if (info->raid_disk < mddev->raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6893) rdev->raid_disk = info->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6894) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6895) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6896)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6897) if (rdev->raid_disk < mddev->raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6898) if (info->state & (1<<MD_DISK_SYNC))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6899) set_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6900)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6901) if (info->state & (1<<MD_DISK_WRITEMOSTLY))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6902) set_bit(WriteMostly, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6903) if (info->state & (1<<MD_DISK_FAILFAST))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6904) set_bit(FailFast, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6905)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6906) if (!mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6907) pr_debug("md: nonpersistent superblock ...\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6908) rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6909) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6910) rdev->sb_start = calc_dev_sboffset(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6911) rdev->sectors = rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6912)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6913) err = bind_rdev_to_array(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6914) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6915) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6916) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6917) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6918) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6919)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6920) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6921) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6922)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6923) static int hot_remove_disk(struct mddev *mddev, dev_t dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6924) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6925) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6926) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6927)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6928) if (!mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6929) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6930)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6931) rdev = find_rdev(mddev, dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6932) if (!rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6933) return -ENXIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6934)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6935) if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6936) goto kick_rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6937)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6938) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6939) remove_and_add_spares(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6940)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6941) if (rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6942) goto busy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6943)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6944) kick_rdev:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6945) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6946) if (md_cluster_ops->remove_disk(mddev, rdev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6947) goto busy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6948) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6949)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6950) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6951) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6952) if (mddev->thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6953) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6954) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6955) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6956) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6957)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6958) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6959) busy:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6960) pr_debug("md: cannot remove active disk %s from %s ...\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6961) bdevname(rdev->bdev,b), mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6962) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6963) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6964)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6965) static int hot_add_disk(struct mddev *mddev, dev_t dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6966) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6967) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6968) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6969) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6970)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6971) if (!mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6972) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6973)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6974) if (mddev->major_version != 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6975) pr_warn("%s: HOT_ADD may only be used with version-0 superblocks.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6976) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6977) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6978) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6979) if (!mddev->pers->hot_add_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6980) pr_warn("%s: personality does not support diskops!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6981) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6982) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6983) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6984)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6985) rdev = md_import_device(dev, -1, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6986) if (IS_ERR(rdev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6987) pr_warn("md: error, md_import_device() returned %ld\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6988) PTR_ERR(rdev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6989) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6990) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6991)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6992) if (mddev->persistent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6993) rdev->sb_start = calc_dev_sboffset(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6994) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6995) rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6996)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6997) rdev->sectors = rdev->sb_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6998)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6999) if (test_bit(Faulty, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7000) pr_warn("md: can not hot-add faulty %s disk to %s!\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7001) bdevname(rdev->bdev,b), mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7002) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7003) goto abort_export;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7004) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7005)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7006) clear_bit(In_sync, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7007) rdev->desc_nr = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7008) rdev->saved_raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7009) err = bind_rdev_to_array(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7010) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7011) goto abort_export;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7012)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7013) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7014) * The rest should better be atomic, we can have disk failures
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7015) * noticed in interrupt contexts ...
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7016) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7017)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7018) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7019)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7020) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7021) if (!mddev->thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7022) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7023) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7024) * Kick recovery, maybe this spare has to be added to the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7025) * array immediately.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7026) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7027) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7028) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7029) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7030) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7031)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7032) abort_export:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7033) export_rdev(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7034) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7035) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7036)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7037) static int set_bitmap_file(struct mddev *mddev, int fd)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7038) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7039) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7040)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7041) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7042) if (!mddev->pers->quiesce || !mddev->thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7043) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7044) if (mddev->recovery || mddev->sync_thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7045) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7046) /* we should be able to change the bitmap.. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7047) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7048)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7049) if (fd >= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7050) struct inode *inode;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7051) struct file *f;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7052)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7053) if (mddev->bitmap || mddev->bitmap_info.file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7054) return -EEXIST; /* cannot add when bitmap is present */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7055) f = fget(fd);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7056)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7057) if (f == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7058) pr_warn("%s: error: failed to get bitmap file\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7059) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7060) return -EBADF;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7061) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7062)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7063) inode = f->f_mapping->host;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7064) if (!S_ISREG(inode->i_mode)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7065) pr_warn("%s: error: bitmap file must be a regular file\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7066) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7067) err = -EBADF;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7068) } else if (!(f->f_mode & FMODE_WRITE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7069) pr_warn("%s: error: bitmap file must open for write\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7070) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7071) err = -EBADF;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7072) } else if (atomic_read(&inode->i_writecount) != 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7073) pr_warn("%s: error: bitmap file is already in use\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7074) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7075) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7076) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7077) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7078) fput(f);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7079) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7080) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7081) mddev->bitmap_info.file = f;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7082) mddev->bitmap_info.offset = 0; /* file overrides offset */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7083) } else if (mddev->bitmap == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7084) return -ENOENT; /* cannot remove what isn't there */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7085) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7086) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7087) if (fd >= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7088) struct bitmap *bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7089)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7090) bitmap = md_bitmap_create(mddev, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7091) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7092) if (!IS_ERR(bitmap)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7093) mddev->bitmap = bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7094) err = md_bitmap_load(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7095) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7096) err = PTR_ERR(bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7097) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7098) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7099) fd = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7100) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7101) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7102) } else if (fd < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7103) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7104) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7105) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7106) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7107) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7108) if (fd < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7109) struct file *f = mddev->bitmap_info.file;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7110) if (f) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7111) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7112) mddev->bitmap_info.file = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7113) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7114) fput(f);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7115) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7116) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7117)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7118) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7119) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7120)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7121) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7122) * md_set_array_info is used two different ways
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7123) * The original usage is when creating a new array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7124) * In this usage, raid_disks is > 0 and it together with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7125) * level, size, not_persistent,layout,chunksize determine the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7126) * shape of the array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7127) * This will always create an array with a type-0.90.0 superblock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7128) * The newer usage is when assembling an array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7129) * In this case raid_disks will be 0, and the major_version field is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7130) * use to determine which style super-blocks are to be found on the devices.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7131) * The minor and patch _version numbers are also kept incase the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7132) * super_block handler wishes to interpret them.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7133) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7134) int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7135) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7136) if (info->raid_disks == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7137) /* just setting version number for superblock loading */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7138) if (info->major_version < 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7139) info->major_version >= ARRAY_SIZE(super_types) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7140) super_types[info->major_version].name == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7141) /* maybe try to auto-load a module? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7142) pr_warn("md: superblock version %d not known\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7143) info->major_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7144) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7145) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7146) mddev->major_version = info->major_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7147) mddev->minor_version = info->minor_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7148) mddev->patch_version = info->patch_version;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7149) mddev->persistent = !info->not_persistent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7150) /* ensure mddev_put doesn't delete this now that there
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7151) * is some minimal configuration.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7152) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7153) mddev->ctime = ktime_get_real_seconds();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7154) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7155) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7156) mddev->major_version = MD_MAJOR_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7157) mddev->minor_version = MD_MINOR_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7158) mddev->patch_version = MD_PATCHLEVEL_VERSION;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7159) mddev->ctime = ktime_get_real_seconds();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7160)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7161) mddev->level = info->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7162) mddev->clevel[0] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7163) mddev->dev_sectors = 2 * (sector_t)info->size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7164) mddev->raid_disks = info->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7165) /* don't set md_minor, it is determined by which /dev/md* was
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7166) * openned
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7167) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7168) if (info->state & (1<<MD_SB_CLEAN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7169) mddev->recovery_cp = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7170) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7171) mddev->recovery_cp = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7172) mddev->persistent = ! info->not_persistent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7173) mddev->external = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7174)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7175) mddev->layout = info->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7176) if (mddev->level == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7177) /* Cannot trust RAID0 layout info here */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7178) mddev->layout = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7179) mddev->chunk_sectors = info->chunk_size >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7180)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7181) if (mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7182) mddev->max_disks = MD_SB_DISKS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7183) mddev->flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7184) mddev->sb_flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7185) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7186) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7187)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7188) mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7189) mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7190) mddev->bitmap_info.offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7191)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7192) mddev->reshape_position = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7193)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7194) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7195) * Generate a 128 bit UUID
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7196) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7197) get_random_bytes(mddev->uuid, 16);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7198)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7199) mddev->new_level = mddev->level;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7200) mddev->new_chunk_sectors = mddev->chunk_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7201) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7202) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7203) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7204)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7205) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7206) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7207)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7208) void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7209) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7210) lockdep_assert_held(&mddev->reconfig_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7211)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7212) if (mddev->external_size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7213) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7214)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7215) mddev->array_sectors = array_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7216) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7217) EXPORT_SYMBOL(md_set_array_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7218)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7219) static int update_size(struct mddev *mddev, sector_t num_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7220) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7221) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7222) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7223) int fit = (num_sectors == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7224) sector_t old_dev_sectors = mddev->dev_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7225)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7226) if (mddev->pers->resize == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7227) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7228) /* The "num_sectors" is the number of sectors of each device that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7229) * is used. This can only make sense for arrays with redundancy.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7230) * linear and raid0 always use whatever space is available. We can only
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7231) * consider changing this number if no resync or reconstruction is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7232) * happening, and if the new size is acceptable. It must fit before the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7233) * sb_start or, if that is <data_offset, it must fit before the size
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7234) * of each device. If num_sectors is zero, we find the largest size
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7235) * that fits.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7236) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7237) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7238) mddev->sync_thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7239) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7240) if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7241) return -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7242)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7243) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7244) sector_t avail = rdev->sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7245)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7246) if (fit && (num_sectors == 0 || num_sectors > avail))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7247) num_sectors = avail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7248) if (avail < num_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7249) return -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7250) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7251) rv = mddev->pers->resize(mddev, num_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7252) if (!rv) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7253) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7254) md_cluster_ops->update_size(mddev, old_dev_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7255) else if (mddev->queue) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7256) set_capacity(mddev->gendisk, mddev->array_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7257) revalidate_disk_size(mddev->gendisk, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7258) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7259) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7260) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7261) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7262)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7263) static int update_raid_disks(struct mddev *mddev, int raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7264) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7265) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7266) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7267) /* change the number of raid disks */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7268) if (mddev->pers->check_reshape == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7269) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7270) if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7271) return -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7272) if (raid_disks <= 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7273) (mddev->max_disks && raid_disks >= mddev->max_disks))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7274) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7275) if (mddev->sync_thread ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7276) test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7277) test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7278) mddev->reshape_position != MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7279) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7280)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7281) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7282) if (mddev->raid_disks < raid_disks &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7283) rdev->data_offset < rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7284) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7285) if (mddev->raid_disks > raid_disks &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7286) rdev->data_offset > rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7287) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7288) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7289)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7290) mddev->delta_disks = raid_disks - mddev->raid_disks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7291) if (mddev->delta_disks < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7292) mddev->reshape_backwards = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7293) else if (mddev->delta_disks > 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7294) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7295)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7296) rv = mddev->pers->check_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7297) if (rv < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7298) mddev->delta_disks = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7299) mddev->reshape_backwards = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7300) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7301) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7302) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7303)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7304) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7305) * update_array_info is used to change the configuration of an
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7306) * on-line array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7307) * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7308) * fields in the info are checked against the array.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7309) * Any differences that cannot be handled will cause an error.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7310) * Normally, only one change can be managed at a time.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7311) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7312) static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7313) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7314) int rv = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7315) int cnt = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7316) int state = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7317)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7318) /* calculate expected state,ignoring low bits */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7319) if (mddev->bitmap && mddev->bitmap_info.offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7320) state |= (1 << MD_SB_BITMAP_PRESENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7321)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7322) if (mddev->major_version != info->major_version ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7323) mddev->minor_version != info->minor_version ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7324) /* mddev->patch_version != info->patch_version || */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7325) mddev->ctime != info->ctime ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7326) mddev->level != info->level ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7327) /* mddev->layout != info->layout || */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7328) mddev->persistent != !info->not_persistent ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7329) mddev->chunk_sectors != info->chunk_size >> 9 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7330) /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7331) ((state^info->state) & 0xfffffe00)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7332) )
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7333) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7334) /* Check there is only one change */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7335) if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7336) cnt++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7337) if (mddev->raid_disks != info->raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7338) cnt++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7339) if (mddev->layout != info->layout)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7340) cnt++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7341) if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7342) cnt++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7343) if (cnt == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7344) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7345) if (cnt > 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7346) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7347)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7348) if (mddev->layout != info->layout) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7349) /* Change layout
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7350) * we don't need to do anything at the md level, the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7351) * personality will take care of it all.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7352) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7353) if (mddev->pers->check_reshape == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7354) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7355) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7356) mddev->new_layout = info->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7357) rv = mddev->pers->check_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7358) if (rv)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7359) mddev->new_layout = mddev->layout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7360) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7361) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7362) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7363) if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7364) rv = update_size(mddev, (sector_t)info->size * 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7365)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7366) if (mddev->raid_disks != info->raid_disks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7367) rv = update_raid_disks(mddev, info->raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7368)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7369) if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7370) if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7371) rv = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7372) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7373) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7374) if (mddev->recovery || mddev->sync_thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7375) rv = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7376) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7377) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7378) if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7379) struct bitmap *bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7380) /* add the bitmap */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7381) if (mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7382) rv = -EEXIST;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7383) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7384) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7385) if (mddev->bitmap_info.default_offset == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7386) rv = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7387) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7388) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7389) mddev->bitmap_info.offset =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7390) mddev->bitmap_info.default_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7391) mddev->bitmap_info.space =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7392) mddev->bitmap_info.default_space;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7393) bitmap = md_bitmap_create(mddev, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7394) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7395) if (!IS_ERR(bitmap)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7396) mddev->bitmap = bitmap;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7397) rv = md_bitmap_load(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7398) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7399) rv = PTR_ERR(bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7400) if (rv)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7401) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7402) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7403) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7404) /* remove the bitmap */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7405) if (!mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7406) rv = -ENOENT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7407) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7408) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7409) if (mddev->bitmap->storage.file) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7410) rv = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7411) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7412) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7413) if (mddev->bitmap_info.nodes) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7414) /* hold PW on all the bitmap lock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7415) if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7416) pr_warn("md: can't change bitmap to none since the array is in use by more than one node\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7417) rv = -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7418) md_cluster_ops->unlock_all_bitmaps(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7419) goto err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7420) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7421)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7422) mddev->bitmap_info.nodes = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7423) md_cluster_ops->leave(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7424) module_put(md_cluster_mod);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7425) mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7426) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7427) mddev_suspend(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7428) md_bitmap_destroy(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7429) mddev_resume(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7430) mddev->bitmap_info.offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7431) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7432) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7433) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7434) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7435) err:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7436) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7437) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7438)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7439) static int set_disk_faulty(struct mddev *mddev, dev_t dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7440) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7441) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7442) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7443)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7444) if (mddev->pers == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7445) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7446)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7447) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7448) rdev = md_find_rdev_rcu(mddev, dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7449) if (!rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7450) err = -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7451) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7452) md_error(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7453) if (!test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7454) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7455) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7456) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7457) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7458) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7459)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7460) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7461) * We have a problem here : there is no easy way to give a CHS
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7462) * virtual geometry. We currently pretend that we have a 2 heads
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7463) * 4 sectors (with a BIG number of cylinders...). This drives
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7464) * dosfs just mad... ;-)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7465) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7466) static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7467) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7468) struct mddev *mddev = bdev->bd_disk->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7469)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7470) geo->heads = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7471) geo->sectors = 4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7472) geo->cylinders = mddev->array_sectors / 8;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7473) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7474) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7475)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7476) static inline bool md_ioctl_valid(unsigned int cmd)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7477) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7478) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7479) case ADD_NEW_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7480) case BLKROSET:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7481) case GET_ARRAY_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7482) case GET_BITMAP_FILE:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7483) case GET_DISK_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7484) case HOT_ADD_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7485) case HOT_REMOVE_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7486) case RAID_VERSION:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7487) case RESTART_ARRAY_RW:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7488) case RUN_ARRAY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7489) case SET_ARRAY_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7490) case SET_BITMAP_FILE:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7491) case SET_DISK_FAULTY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7492) case STOP_ARRAY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7493) case STOP_ARRAY_RO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7494) case CLUSTERED_DISK_NACK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7495) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7496) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7497) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7498) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7499) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7500)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7501) static int md_ioctl(struct block_device *bdev, fmode_t mode,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7502) unsigned int cmd, unsigned long arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7503) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7504) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7505) void __user *argp = (void __user *)arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7506) struct mddev *mddev = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7507) int ro;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7508) bool did_set_md_closing = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7509)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7510) if (!md_ioctl_valid(cmd))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7511) return -ENOTTY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7512)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7513) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7514) case RAID_VERSION:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7515) case GET_ARRAY_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7516) case GET_DISK_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7517) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7518) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7519) if (!capable(CAP_SYS_ADMIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7520) return -EACCES;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7521) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7522)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7523) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7524) * Commands dealing with the RAID driver but not any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7525) * particular array:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7526) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7527) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7528) case RAID_VERSION:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7529) err = get_version(argp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7530) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7531) default:;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7532) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7533)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7534) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7535) * Commands creating/starting a new array:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7536) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7537)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7538) mddev = bdev->bd_disk->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7539)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7540) if (!mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7541) BUG();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7542) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7543) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7544)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7545) /* Some actions do not requires the mutex */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7546) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7547) case GET_ARRAY_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7548) if (!mddev->raid_disks && !mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7549) err = -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7550) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7551) err = get_array_info(mddev, argp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7552) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7553)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7554) case GET_DISK_INFO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7555) if (!mddev->raid_disks && !mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7556) err = -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7557) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7558) err = get_disk_info(mddev, argp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7559) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7560)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7561) case SET_DISK_FAULTY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7562) err = set_disk_faulty(mddev, new_decode_dev(arg));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7563) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7565) case GET_BITMAP_FILE:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7566) err = get_bitmap_file(mddev, argp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7567) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7568)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7569) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7570)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7571) if (cmd == ADD_NEW_DISK || cmd == HOT_ADD_DISK)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7572) flush_rdev_wq(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7573)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7574) if (cmd == HOT_REMOVE_DISK)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7575) /* need to ensure recovery thread has run */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7576) wait_event_interruptible_timeout(mddev->sb_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7577) !test_bit(MD_RECOVERY_NEEDED,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7578) &mddev->recovery),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7579) msecs_to_jiffies(5000));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7580) if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7581) /* Need to flush page cache, and ensure no-one else opens
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7582) * and writes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7583) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7584) mutex_lock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7585) if (mddev->pers && atomic_read(&mddev->openers) > 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7586) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7587) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7588) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7589) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7590) if (test_and_set_bit(MD_CLOSING, &mddev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7591) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7592) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7593) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7594) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7595) did_set_md_closing = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7596) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7597) sync_blockdev(bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7598) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7599) err = mddev_lock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7600) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7601) pr_debug("md: ioctl lock interrupted, reason %d, cmd %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7602) err, cmd);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7603) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7604) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7605)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7606) if (cmd == SET_ARRAY_INFO) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7607) mdu_array_info_t info;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7608) if (!arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7609) memset(&info, 0, sizeof(info));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7610) else if (copy_from_user(&info, argp, sizeof(info))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7611) err = -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7612) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7613) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7614) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7615) err = update_array_info(mddev, &info);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7616) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7617) pr_warn("md: couldn't update array info. %d\n", err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7618) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7619) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7620) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7621) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7622) if (!list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7623) pr_warn("md: array %s already has disks!\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7624) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7625) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7626) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7627) if (mddev->raid_disks) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7628) pr_warn("md: array %s already initialised!\n", mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7629) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7630) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7631) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7632) err = md_set_array_info(mddev, &info);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7633) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7634) pr_warn("md: couldn't set array info. %d\n", err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7635) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7636) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7637) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7638) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7639)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7640) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7641) * Commands querying/configuring an existing array:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7642) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7643) /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7644) * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7645) if ((!mddev->raid_disks && !mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7646) && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7647) && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7648) && cmd != GET_BITMAP_FILE) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7649) err = -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7650) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7651) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7652)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7653) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7654) * Commands even a read-only array can execute:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7655) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7656) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7657) case RESTART_ARRAY_RW:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7658) err = restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7659) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7660)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7661) case STOP_ARRAY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7662) err = do_md_stop(mddev, 0, bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7663) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7664)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7665) case STOP_ARRAY_RO:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7666) err = md_set_readonly(mddev, bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7667) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7668)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7669) case HOT_REMOVE_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7670) err = hot_remove_disk(mddev, new_decode_dev(arg));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7671) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7672)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7673) case ADD_NEW_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7674) /* We can support ADD_NEW_DISK on read-only arrays
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7675) * only if we are re-adding a preexisting device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7676) * So require mddev->pers and MD_DISK_SYNC.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7677) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7678) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7679) mdu_disk_info_t info;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7680) if (copy_from_user(&info, argp, sizeof(info)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7681) err = -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7682) else if (!(info.state & (1<<MD_DISK_SYNC)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7683) /* Need to clear read-only for this */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7684) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7685) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7686) err = md_add_new_disk(mddev, &info);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7687) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7688) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7689) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7690)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7691) case BLKROSET:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7692) if (get_user(ro, (int __user *)(arg))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7693) err = -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7694) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7695) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7696) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7697)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7698) /* if the bdev is going readonly the value of mddev->ro
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7699) * does not matter, no writes are coming
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7700) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7701) if (ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7702) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7703)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7704) /* are we are already prepared for writes? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7705) if (mddev->ro != 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7706) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7707)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7708) /* transitioning to readauto need only happen for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7709) * arrays that call md_write_start
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7710) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7711) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7712) err = restart_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7713) if (err == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7714) mddev->ro = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7715) set_disk_ro(mddev->gendisk, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7716) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7717) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7718) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7719) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7720)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7721) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7722) * The remaining ioctls are changing the state of the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7723) * superblock, so we do not allow them on read-only arrays.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7724) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7725) if (mddev->ro && mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7726) if (mddev->ro == 2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7727) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7728) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7729) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7730) /* mddev_unlock will wake thread */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7731) /* If a device failed while we were read-only, we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7732) * need to make sure the metadata is updated now.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7733) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7734) if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7735) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7736) wait_event(mddev->sb_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7737) !test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7738) !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7739) mddev_lock_nointr(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7740) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7741) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7742) err = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7743) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7744) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7745) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7746)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7747) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7748) case ADD_NEW_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7749) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7750) mdu_disk_info_t info;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7751) if (copy_from_user(&info, argp, sizeof(info)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7752) err = -EFAULT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7753) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7754) err = md_add_new_disk(mddev, &info);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7755) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7756) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7757)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7758) case CLUSTERED_DISK_NACK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7759) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7760) md_cluster_ops->new_disk_ack(mddev, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7761) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7762) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7763) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7764)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7765) case HOT_ADD_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7766) err = hot_add_disk(mddev, new_decode_dev(arg));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7767) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7768)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7769) case RUN_ARRAY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7770) err = do_md_run(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7771) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7772)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7773) case SET_BITMAP_FILE:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7774) err = set_bitmap_file(mddev, (int)arg);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7775) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7776)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7777) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7778) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7779) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7780) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7781)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7782) unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7783) if (mddev->hold_active == UNTIL_IOCTL &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7784) err != -EINVAL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7785) mddev->hold_active = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7786) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7787) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7788) if(did_set_md_closing)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7789) clear_bit(MD_CLOSING, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7790) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7791) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7792) #ifdef CONFIG_COMPAT
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7793) static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7794) unsigned int cmd, unsigned long arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7795) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7796) switch (cmd) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7797) case HOT_REMOVE_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7798) case HOT_ADD_DISK:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7799) case SET_DISK_FAULTY:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7800) case SET_BITMAP_FILE:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7801) /* These take in integer arg, do not convert */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7802) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7803) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7804) arg = (unsigned long)compat_ptr(arg);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7805) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7806) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7807)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7808) return md_ioctl(bdev, mode, cmd, arg);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7809) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7810) #endif /* CONFIG_COMPAT */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7811)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7812) static int md_open(struct block_device *bdev, fmode_t mode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7813) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7814) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7815) * Succeed if we can lock the mddev, which confirms that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7816) * it isn't being stopped right now.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7817) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7818) struct mddev *mddev = mddev_find(bdev->bd_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7819) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7820)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7821) if (!mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7822) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7823)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7824) if (mddev->gendisk != bdev->bd_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7825) /* we are racing with mddev_put which is discarding this
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7826) * bd_disk.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7827) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7828) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7829) /* Wait until bdev->bd_disk is definitely gone */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7830) if (work_pending(&mddev->del_work))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7831) flush_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7832) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7833) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7834) BUG_ON(mddev != bdev->bd_disk->private_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7835)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7836) if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7837) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7838)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7839) if (test_bit(MD_CLOSING, &mddev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7840) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7841) err = -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7842) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7843) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7844)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7845) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7846) atomic_inc(&mddev->openers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7847) mutex_unlock(&mddev->open_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7848)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7849) bdev_check_media_change(bdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7850) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7851) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7852) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7853) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7854) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7855)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7856) static void md_release(struct gendisk *disk, fmode_t mode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7857) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7858) struct mddev *mddev = disk->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7859)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7860) BUG_ON(!mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7861) atomic_dec(&mddev->openers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7862) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7863) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7864)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7865) static unsigned int md_check_events(struct gendisk *disk, unsigned int clearing)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7866) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7867) struct mddev *mddev = disk->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7868) unsigned int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7869)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7870) if (mddev->changed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7871) ret = DISK_EVENT_MEDIA_CHANGE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7872) mddev->changed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7873) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7874) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7875)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7876) const struct block_device_operations md_fops =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7877) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7878) .owner = THIS_MODULE,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7879) .submit_bio = md_submit_bio,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7880) .open = md_open,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7881) .release = md_release,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7882) .ioctl = md_ioctl,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7883) #ifdef CONFIG_COMPAT
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7884) .compat_ioctl = md_compat_ioctl,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7885) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7886) .getgeo = md_getgeo,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7887) .check_events = md_check_events,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7888) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7889)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7890) static int md_thread(void *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7891) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7892) struct md_thread *thread = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7893)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7894) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7895) * md_thread is a 'system-thread', it's priority should be very
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7896) * high. We avoid resource deadlocks individually in each
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7897) * raid personality. (RAID5 does preallocation) We also use RR and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7898) * the very same RT priority as kswapd, thus we will never get
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7899) * into a priority inversion deadlock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7900) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7901) * we definitely have to have equal or higher priority than
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7902) * bdflush, otherwise bdflush will deadlock if there are too
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7903) * many dirty RAID5 blocks.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7904) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7905)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7906) allow_signal(SIGKILL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7907) while (!kthread_should_stop()) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7908)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7909) /* We need to wait INTERRUPTIBLE so that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7910) * we don't add to the load-average.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7911) * That means we need to be sure no signals are
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7912) * pending
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7913) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7914) if (signal_pending(current))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7915) flush_signals(current);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7916)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7917) wait_event_interruptible_timeout
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7918) (thread->wqueue,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7919) test_bit(THREAD_WAKEUP, &thread->flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7920) || kthread_should_stop() || kthread_should_park(),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7921) thread->timeout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7922)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7923) clear_bit(THREAD_WAKEUP, &thread->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7924) if (kthread_should_park())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7925) kthread_parkme();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7926) if (!kthread_should_stop())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7927) thread->run(thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7928) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7929)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7930) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7931) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7932)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7933) void md_wakeup_thread(struct md_thread *thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7934) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7935) if (thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7936) pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7937) set_bit(THREAD_WAKEUP, &thread->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7938) wake_up(&thread->wqueue);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7939) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7940) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7941) EXPORT_SYMBOL(md_wakeup_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7942)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7943) struct md_thread *md_register_thread(void (*run) (struct md_thread *),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7944) struct mddev *mddev, const char *name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7945) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7946) struct md_thread *thread;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7947)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7948) thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7949) if (!thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7950) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7951)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7952) init_waitqueue_head(&thread->wqueue);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7953)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7954) thread->run = run;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7955) thread->mddev = mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7956) thread->timeout = MAX_SCHEDULE_TIMEOUT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7957) thread->tsk = kthread_run(md_thread, thread,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7958) "%s_%s",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7959) mdname(thread->mddev),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7960) name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7961) if (IS_ERR(thread->tsk)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7962) kfree(thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7963) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7964) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7965) return thread;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7966) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7967) EXPORT_SYMBOL(md_register_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7968)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7969) void md_unregister_thread(struct md_thread **threadp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7970) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7971) struct md_thread *thread = *threadp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7972) if (!thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7973) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7974) pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7975) /* Locking ensures that mddev_unlock does not wake_up a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7976) * non-existent thread
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7977) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7978) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7979) *threadp = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7980) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7981)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7982) kthread_stop(thread->tsk);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7983) kfree(thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7984) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7985) EXPORT_SYMBOL(md_unregister_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7986)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7987) void md_error(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7988) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7989) if (!rdev || test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7990) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7991)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7992) if (!mddev->pers || !mddev->pers->error_handler)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7993) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7994) mddev->pers->error_handler(mddev,rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7995) if (mddev->degraded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7996) set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7997) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7998) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7999) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8000) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8001) if (mddev->event_work.func)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8002) queue_work(md_misc_wq, &mddev->event_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8003) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8004) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8005) EXPORT_SYMBOL(md_error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8006)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8007) /* seq_file implementation /proc/mdstat */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8008)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8009) static void status_unused(struct seq_file *seq)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8010) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8011) int i = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8012) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8013)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8014) seq_printf(seq, "unused devices: ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8015)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8016) list_for_each_entry(rdev, &pending_raid_disks, same_set) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8017) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8018) i++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8019) seq_printf(seq, "%s ",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8020) bdevname(rdev->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8021) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8022) if (!i)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8023) seq_printf(seq, "<none>");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8024)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8025) seq_printf(seq, "\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8026) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8027)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8028) static int status_resync(struct seq_file *seq, struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8029) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8030) sector_t max_sectors, resync, res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8031) unsigned long dt, db = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8032) sector_t rt, curr_mark_cnt, resync_mark_cnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8033) int scale, recovery_active;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8034) unsigned int per_milli;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8035)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8036) if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8037) test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8038) max_sectors = mddev->resync_max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8039) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8040) max_sectors = mddev->dev_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8041)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8042) resync = mddev->curr_resync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8043) if (resync <= 3) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8044) if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8045) /* Still cleaning up */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8046) resync = max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8047) } else if (resync > max_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8048) resync = max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8049) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8050) resync -= atomic_read(&mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8051)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8052) if (resync == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8053) if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8054) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8055)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8056) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8057) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8058) !test_bit(Faulty, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8059) rdev->recovery_offset != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8060) rdev->recovery_offset) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8061) seq_printf(seq, "\trecover=REMOTE");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8062) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8063) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8064) if (mddev->reshape_position != MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8065) seq_printf(seq, "\treshape=REMOTE");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8066) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8067) seq_printf(seq, "\tresync=REMOTE");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8068) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8069) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8070) if (mddev->recovery_cp < MaxSector) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8071) seq_printf(seq, "\tresync=PENDING");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8072) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8073) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8074) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8075) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8076) if (resync < 3) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8077) seq_printf(seq, "\tresync=DELAYED");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8078) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8079) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8080)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8081) WARN_ON(max_sectors == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8082) /* Pick 'scale' such that (resync>>scale)*1000 will fit
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8083) * in a sector_t, and (max_sectors>>scale) will fit in a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8084) * u32, as those are the requirements for sector_div.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8085) * Thus 'scale' must be at least 10
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8086) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8087) scale = 10;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8088) if (sizeof(sector_t) > sizeof(unsigned long)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8089) while ( max_sectors/2 > (1ULL<<(scale+32)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8090) scale++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8091) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8092) res = (resync>>scale)*1000;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8093) sector_div(res, (u32)((max_sectors>>scale)+1));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8094)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8095) per_milli = res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8096) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8097) int i, x = per_milli/50, y = 20-x;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8098) seq_printf(seq, "[");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8099) for (i = 0; i < x; i++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8100) seq_printf(seq, "=");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8101) seq_printf(seq, ">");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8102) for (i = 0; i < y; i++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8103) seq_printf(seq, ".");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8104) seq_printf(seq, "] ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8105) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8106) seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8107) (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8108) "reshape" :
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8109) (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8110) "check" :
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8111) (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8112) "resync" : "recovery"))),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8113) per_milli/10, per_milli % 10,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8114) (unsigned long long) resync/2,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8115) (unsigned long long) max_sectors/2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8116)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8117) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8118) * dt: time from mark until now
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8119) * db: blocks written from mark until now
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8120) * rt: remaining time
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8121) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8122) * rt is a sector_t, which is always 64bit now. We are keeping
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8123) * the original algorithm, but it is not really necessary.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8124) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8125) * Original algorithm:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8126) * So we divide before multiply in case it is 32bit and close
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8127) * to the limit.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8128) * We scale the divisor (db) by 32 to avoid losing precision
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8129) * near the end of resync when the number of remaining sectors
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8130) * is close to 'db'.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8131) * We then divide rt by 32 after multiplying by db to compensate.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8132) * The '+1' avoids division by zero if db is very small.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8133) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8134) dt = ((jiffies - mddev->resync_mark) / HZ);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8135) if (!dt) dt++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8136)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8137) curr_mark_cnt = mddev->curr_mark_cnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8138) recovery_active = atomic_read(&mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8139) resync_mark_cnt = mddev->resync_mark_cnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8140)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8141) if (curr_mark_cnt >= (recovery_active + resync_mark_cnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8142) db = curr_mark_cnt - (recovery_active + resync_mark_cnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8143)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8144) rt = max_sectors - resync; /* number of remaining sectors */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8145) rt = div64_u64(rt, db/32+1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8146) rt *= dt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8147) rt >>= 5;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8148)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8149) seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8150) ((unsigned long)rt % 60)/6);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8151)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8152) seq_printf(seq, " speed=%ldK/sec", db/2/dt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8153) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8154) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8155)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8156) static void *md_seq_start(struct seq_file *seq, loff_t *pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8157) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8158) struct list_head *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8159) loff_t l = *pos;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8160) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8161)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8162) if (l == 0x10000) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8163) ++*pos;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8164) return (void *)2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8165) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8166) if (l > 0x10000)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8167) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8168) if (!l--)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8169) /* header */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8170) return (void*)1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8171)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8172) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8173) list_for_each(tmp,&all_mddevs)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8174) if (!l--) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8175) mddev = list_entry(tmp, struct mddev, all_mddevs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8176) mddev_get(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8177) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8178) return mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8179) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8180) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8181) if (!l--)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8182) return (void*)2;/* tail */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8183) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8184) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8185)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8186) static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8187) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8188) struct list_head *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8189) struct mddev *next_mddev, *mddev = v;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8190)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8191) ++*pos;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8192) if (v == (void*)2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8193) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8194)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8195) spin_lock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8196) if (v == (void*)1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8197) tmp = all_mddevs.next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8198) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8199) tmp = mddev->all_mddevs.next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8200) if (tmp != &all_mddevs)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8201) next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8202) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8203) next_mddev = (void*)2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8204) *pos = 0x10000;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8205) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8206) spin_unlock(&all_mddevs_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8207)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8208) if (v != (void*)1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8209) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8210) return next_mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8211)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8212) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8213)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8214) static void md_seq_stop(struct seq_file *seq, void *v)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8215) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8216) struct mddev *mddev = v;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8217)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8218) if (mddev && v != (void*)1 && v != (void*)2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8219) mddev_put(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8220) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8221)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8222) static int md_seq_show(struct seq_file *seq, void *v)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8223) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8224) struct mddev *mddev = v;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8225) sector_t sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8226) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8227)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8228) if (v == (void*)1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8229) struct md_personality *pers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8230) seq_printf(seq, "Personalities : ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8231) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8232) list_for_each_entry(pers, &pers_list, list)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8233) seq_printf(seq, "[%s] ", pers->name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8234)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8235) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8236) seq_printf(seq, "\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8237) seq->poll_event = atomic_read(&md_event_count);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8238) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8239) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8240) if (v == (void*)2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8241) status_unused(seq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8242) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8243) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8244)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8245) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8246) if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8247) seq_printf(seq, "%s : %sactive", mdname(mddev),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8248) mddev->pers ? "" : "in");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8249) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8250) if (mddev->ro==1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8251) seq_printf(seq, " (read-only)");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8252) if (mddev->ro==2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8253) seq_printf(seq, " (auto-read-only)");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8254) seq_printf(seq, " %s", mddev->pers->name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8255) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8256)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8257) sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8258) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8259) rdev_for_each_rcu(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8260) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8261) seq_printf(seq, " %s[%d]",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8262) bdevname(rdev->bdev,b), rdev->desc_nr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8263) if (test_bit(WriteMostly, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8264) seq_printf(seq, "(W)");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8265) if (test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8266) seq_printf(seq, "(J)");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8267) if (test_bit(Faulty, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8268) seq_printf(seq, "(F)");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8269) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8270) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8271) if (rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8272) seq_printf(seq, "(S)"); /* spare */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8273) if (test_bit(Replacement, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8274) seq_printf(seq, "(R)");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8275) sectors += rdev->sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8276) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8277) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8278)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8279) if (!list_empty(&mddev->disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8280) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8281) seq_printf(seq, "\n %llu blocks",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8282) (unsigned long long)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8283) mddev->array_sectors / 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8284) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8285) seq_printf(seq, "\n %llu blocks",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8286) (unsigned long long)sectors / 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8287) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8288) if (mddev->persistent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8289) if (mddev->major_version != 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8290) mddev->minor_version != 90) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8291) seq_printf(seq," super %d.%d",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8292) mddev->major_version,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8293) mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8294) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8295) } else if (mddev->external)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8296) seq_printf(seq, " super external:%s",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8297) mddev->metadata_type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8298) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8299) seq_printf(seq, " super non-persistent");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8300)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8301) if (mddev->pers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8302) mddev->pers->status(seq, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8303) seq_printf(seq, "\n ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8304) if (mddev->pers->sync_request) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8305) if (status_resync(seq, mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8306) seq_printf(seq, "\n ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8307) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8308) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8309) seq_printf(seq, "\n ");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8310)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8311) md_bitmap_status(seq, mddev->bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8312)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8313) seq_printf(seq, "\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8314) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8315) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8316)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8317) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8318) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8319)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8320) static const struct seq_operations md_seq_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8321) .start = md_seq_start,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8322) .next = md_seq_next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8323) .stop = md_seq_stop,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8324) .show = md_seq_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8325) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8326)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8327) static int md_seq_open(struct inode *inode, struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8328) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8329) struct seq_file *seq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8330) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8331)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8332) error = seq_open(file, &md_seq_ops);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8333) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8334) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8335)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8336) seq = file->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8337) seq->poll_event = atomic_read(&md_event_count);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8338) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8339) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8340)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8341) static int md_unloading;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8342) static __poll_t mdstat_poll(struct file *filp, poll_table *wait)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8343) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8344) struct seq_file *seq = filp->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8345) __poll_t mask;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8346)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8347) if (md_unloading)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8348) return EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8349) poll_wait(filp, &md_event_waiters, wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8350)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8351) /* always allow read */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8352) mask = EPOLLIN | EPOLLRDNORM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8353)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8354) if (seq->poll_event != atomic_read(&md_event_count))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8355) mask |= EPOLLERR | EPOLLPRI;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8356) return mask;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8357) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8358)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8359) static const struct proc_ops mdstat_proc_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8360) .proc_open = md_seq_open,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8361) .proc_read = seq_read,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8362) .proc_lseek = seq_lseek,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8363) .proc_release = seq_release,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8364) .proc_poll = mdstat_poll,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8365) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8366)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8367) int register_md_personality(struct md_personality *p)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8368) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8369) pr_debug("md: %s personality registered for level %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8370) p->name, p->level);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8371) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8372) list_add_tail(&p->list, &pers_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8373) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8374) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8375) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8376) EXPORT_SYMBOL(register_md_personality);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8377)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8378) int unregister_md_personality(struct md_personality *p)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8379) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8380) pr_debug("md: %s personality unregistered\n", p->name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8381) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8382) list_del_init(&p->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8383) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8384) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8385) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8386) EXPORT_SYMBOL(unregister_md_personality);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8387)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8388) int register_md_cluster_operations(struct md_cluster_operations *ops,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8389) struct module *module)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8390) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8391) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8392) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8393) if (md_cluster_ops != NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8394) ret = -EALREADY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8395) else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8396) md_cluster_ops = ops;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8397) md_cluster_mod = module;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8398) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8399) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8400) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8401) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8402) EXPORT_SYMBOL(register_md_cluster_operations);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8403)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8404) int unregister_md_cluster_operations(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8405) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8406) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8407) md_cluster_ops = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8408) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8409) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8410) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8411) EXPORT_SYMBOL(unregister_md_cluster_operations);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8412)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8413) int md_setup_cluster(struct mddev *mddev, int nodes)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8414) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8415) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8416) if (!md_cluster_ops)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8417) request_module("md-cluster");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8418) spin_lock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8419) /* ensure module won't be unloaded */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8420) if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8421) pr_warn("can't find md-cluster module or get it's reference.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8422) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8423) return -ENOENT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8424) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8425) spin_unlock(&pers_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8426)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8427) ret = md_cluster_ops->join(mddev, nodes);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8428) if (!ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8429) mddev->safemode_delay = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8430) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8431) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8432)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8433) void md_cluster_stop(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8434) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8435) if (!md_cluster_ops)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8436) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8437) md_cluster_ops->leave(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8438) module_put(md_cluster_mod);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8439) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8440)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8441) static int is_mddev_idle(struct mddev *mddev, int init)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8442) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8443) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8444) int idle;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8445) int curr_events;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8446)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8447) idle = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8448) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8449) rdev_for_each_rcu(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8450) struct gendisk *disk = rdev->bdev->bd_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8451) curr_events = (int)part_stat_read_accum(&disk->part0, sectors) -
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8452) atomic_read(&disk->sync_io);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8453) /* sync IO will cause sync_io to increase before the disk_stats
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8454) * as sync_io is counted when a request starts, and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8455) * disk_stats is counted when it completes.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8456) * So resync activity will cause curr_events to be smaller than
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8457) * when there was no such activity.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8458) * non-sync IO will cause disk_stat to increase without
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8459) * increasing sync_io so curr_events will (eventually)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8460) * be larger than it was before. Once it becomes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8461) * substantially larger, the test below will cause
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8462) * the array to appear non-idle, and resync will slow
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8463) * down.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8464) * If there is a lot of outstanding resync activity when
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8465) * we set last_event to curr_events, then all that activity
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8466) * completing might cause the array to appear non-idle
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8467) * and resync will be slowed down even though there might
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8468) * not have been non-resync activity. This will only
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8469) * happen once though. 'last_events' will soon reflect
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8470) * the state where there is little or no outstanding
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8471) * resync requests, and further resync activity will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8472) * always make curr_events less than last_events.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8473) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8474) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8475) if (init || curr_events - rdev->last_events > 64) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8476) rdev->last_events = curr_events;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8477) idle = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8478) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8479) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8480) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8481) return idle;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8482) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8483)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8484) void md_done_sync(struct mddev *mddev, int blocks, int ok)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8485) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8486) /* another "blocks" (512byte) blocks have been synced */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8487) atomic_sub(blocks, &mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8488) wake_up(&mddev->recovery_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8489) if (!ok) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8490) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8491) set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8492) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8493) // stop recovery, signal do_sync ....
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8494) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8495) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8496) EXPORT_SYMBOL(md_done_sync);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8497)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8498) /* md_write_start(mddev, bi)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8499) * If we need to update some array metadata (e.g. 'active' flag
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8500) * in superblock) before writing, schedule a superblock update
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8501) * and wait for it to complete.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8502) * A return value of 'false' means that the write wasn't recorded
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8503) * and cannot proceed as the array is being suspend.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8504) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8505) bool md_write_start(struct mddev *mddev, struct bio *bi)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8506) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8507) int did_change = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8508)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8509) if (bio_data_dir(bi) != WRITE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8510) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8511)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8512) BUG_ON(mddev->ro == 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8513) if (mddev->ro == 2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8514) /* need to switch to read/write */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8515) mddev->ro = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8516) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8517) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8518) md_wakeup_thread(mddev->sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8519) did_change = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8520) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8521) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8522) percpu_ref_get(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8523) smp_mb(); /* Match smp_mb in set_in_sync() */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8524) if (mddev->safemode == 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8525) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8526) /* sync_checkers is always 0 when writes_pending is in per-cpu mode */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8527) if (mddev->in_sync || mddev->sync_checkers) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8528) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8529) if (mddev->in_sync) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8530) mddev->in_sync = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8531) set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8532) set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8533) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8534) did_change = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8535) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8536) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8537) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8538) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8539) if (did_change)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8540) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8541) if (!mddev->has_superblocks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8542) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8543) wait_event(mddev->sb_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8544) !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8545) mddev->suspended);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8546) if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8547) percpu_ref_put(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8548) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8549) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8550) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8551) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8552) EXPORT_SYMBOL(md_write_start);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8553)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8554) /* md_write_inc can only be called when md_write_start() has
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8555) * already been called at least once of the current request.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8556) * It increments the counter and is useful when a single request
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8557) * is split into several parts. Each part causes an increment and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8558) * so needs a matching md_write_end().
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8559) * Unlike md_write_start(), it is safe to call md_write_inc() inside
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8560) * a spinlocked region.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8561) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8562) void md_write_inc(struct mddev *mddev, struct bio *bi)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8563) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8564) if (bio_data_dir(bi) != WRITE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8565) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8566) WARN_ON_ONCE(mddev->in_sync || mddev->ro);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8567) percpu_ref_get(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8568) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8569) EXPORT_SYMBOL(md_write_inc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8570)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8571) void md_write_end(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8572) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8573) percpu_ref_put(&mddev->writes_pending);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8574)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8575) if (mddev->safemode == 2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8576) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8577) else if (mddev->safemode_delay)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8578) /* The roundup() ensures this only performs locking once
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8579) * every ->safemode_delay jiffies
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8580) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8581) mod_timer(&mddev->safemode_timer,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8582) roundup(jiffies, mddev->safemode_delay) +
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8583) mddev->safemode_delay);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8584) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8585)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8586) EXPORT_SYMBOL(md_write_end);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8587)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8588) /* md_allow_write(mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8589) * Calling this ensures that the array is marked 'active' so that writes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8590) * may proceed without blocking. It is important to call this before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8591) * attempting a GFP_KERNEL allocation while holding the mddev lock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8592) * Must be called with mddev_lock held.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8593) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8594) void md_allow_write(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8595) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8596) if (!mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8597) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8598) if (mddev->ro)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8599) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8600) if (!mddev->pers->sync_request)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8601) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8602)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8603) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8604) if (mddev->in_sync) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8605) mddev->in_sync = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8606) set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8607) set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8608) if (mddev->safemode_delay &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8609) mddev->safemode == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8610) mddev->safemode = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8611) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8612) md_update_sb(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8613) sysfs_notify_dirent_safe(mddev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8614) /* wait for the dirty state to be recorded in the metadata */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8615) wait_event(mddev->sb_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8616) !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8617) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8618) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8619) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8620) EXPORT_SYMBOL_GPL(md_allow_write);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8621)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8622) #define SYNC_MARKS 10
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8623) #define SYNC_MARK_STEP (3*HZ)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8624) #define UPDATE_FREQUENCY (5*60*HZ)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8625) void md_do_sync(struct md_thread *thread)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8626) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8627) struct mddev *mddev = thread->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8628) struct mddev *mddev2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8629) unsigned int currspeed = 0, window;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8630) sector_t max_sectors,j, io_sectors, recovery_done;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8631) unsigned long mark[SYNC_MARKS];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8632) unsigned long update_time;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8633) sector_t mark_cnt[SYNC_MARKS];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8634) int last_mark,m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8635) struct list_head *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8636) sector_t last_check;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8637) int skipped = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8638) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8639) char *desc, *action = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8640) struct blk_plug plug;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8641) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8642)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8643) /* just incase thread restarts... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8644) if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8645) test_bit(MD_RECOVERY_WAIT, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8646) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8647) if (mddev->ro) {/* never try to sync a read-only array */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8648) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8649) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8650) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8651)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8652) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8653) ret = md_cluster_ops->resync_start(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8654) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8655) goto skip;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8656)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8657) set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8658) if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8659) test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8660) test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8661) && ((unsigned long long)mddev->curr_resync_completed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8662) < (unsigned long long)mddev->resync_max_sectors))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8663) goto skip;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8664) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8665)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8666) if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8667) if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8668) desc = "data-check";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8669) action = "check";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8670) } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8671) desc = "requested-resync";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8672) action = "repair";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8673) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8674) desc = "resync";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8675) } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8676) desc = "reshape";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8677) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8678) desc = "recovery";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8679)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8680) mddev->last_sync_action = action ?: desc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8681)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8682) /* we overload curr_resync somewhat here.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8683) * 0 == not engaged in resync at all
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8684) * 2 == checking that there is no conflict with another sync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8685) * 1 == like 2, but have yielded to allow conflicting resync to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8686) * commence
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8687) * other == active in resync - this many blocks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8688) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8689) * Before starting a resync we must have set curr_resync to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8690) * 2, and then checked that every "conflicting" array has curr_resync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8691) * less than ours. When we find one that is the same or higher
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8692) * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8693) * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8694) * This will mean we have to start checking from the beginning again.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8695) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8696) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8697)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8698) do {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8699) int mddev2_minor = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8700) mddev->curr_resync = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8702) try_again:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8703) if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8704) goto skip;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8705) for_each_mddev(mddev2, tmp) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8706) if (mddev2 == mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8707) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8708) if (!mddev->parallel_resync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8709) && mddev2->curr_resync
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8710) && match_mddev_units(mddev, mddev2)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8711) DEFINE_WAIT(wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8712) if (mddev < mddev2 && mddev->curr_resync == 2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8713) /* arbitrarily yield */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8714) mddev->curr_resync = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8715) wake_up(&resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8716) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8717) if (mddev > mddev2 && mddev->curr_resync == 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8718) /* no need to wait here, we can wait the next
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8719) * time 'round when curr_resync == 2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8720) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8721) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8722) /* We need to wait 'interruptible' so as not to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8723) * contribute to the load average, and not to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8724) * be caught by 'softlockup'
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8725) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8726) prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8727) if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8728) mddev2->curr_resync >= mddev->curr_resync) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8729) if (mddev2_minor != mddev2->md_minor) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8730) mddev2_minor = mddev2->md_minor;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8731) pr_info("md: delaying %s of %s until %s has finished (they share one or more physical units)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8732) desc, mdname(mddev),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8733) mdname(mddev2));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8734) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8735) mddev_put(mddev2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8736) if (signal_pending(current))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8737) flush_signals(current);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8738) schedule();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8739) finish_wait(&resync_wait, &wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8740) goto try_again;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8741) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8742) finish_wait(&resync_wait, &wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8743) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8744) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8745) } while (mddev->curr_resync < 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8746)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8747) j = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8748) if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8749) /* resync follows the size requested by the personality,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8750) * which defaults to physical size, but can be virtual size
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8751) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8752) max_sectors = mddev->resync_max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8753) atomic64_set(&mddev->resync_mismatches, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8754) /* we don't use the checkpoint if there's a bitmap */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8755) if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8756) j = mddev->resync_min;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8757) else if (!mddev->bitmap)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8758) j = mddev->recovery_cp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8759)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8760) } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8761) max_sectors = mddev->resync_max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8762) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8763) * If the original node aborts reshaping then we continue the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8764) * reshaping, so set j again to avoid restart reshape from the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8765) * first beginning
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8766) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8767) if (mddev_is_clustered(mddev) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8768) mddev->reshape_position != MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8769) j = mddev->reshape_position;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8770) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8771) /* recovery follows the physical size of devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8772) max_sectors = mddev->dev_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8773) j = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8774) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8775) rdev_for_each_rcu(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8776) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8777) !test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8778) !test_bit(Faulty, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8779) !test_bit(In_sync, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8780) rdev->recovery_offset < j)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8781) j = rdev->recovery_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8782) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8784) /* If there is a bitmap, we need to make sure all
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8785) * writes that started before we added a spare
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8786) * complete before we start doing a recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8787) * Otherwise the write might complete and (via
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8788) * bitmap_endwrite) set a bit in the bitmap after the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8789) * recovery has checked that bit and skipped that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8790) * region.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8791) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8792) if (mddev->bitmap) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8793) mddev->pers->quiesce(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8794) mddev->pers->quiesce(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8795) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8796) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8797)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8798) pr_info("md: %s of RAID array %s\n", desc, mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8799) pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8800) pr_debug("md: using maximum available idle IO bandwidth (but not more than %d KB/sec) for %s.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8801) speed_max(mddev), desc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8802)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8803) is_mddev_idle(mddev, 1); /* this initializes IO event counters */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8804)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8805) io_sectors = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8806) for (m = 0; m < SYNC_MARKS; m++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8807) mark[m] = jiffies;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8808) mark_cnt[m] = io_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8809) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8810) last_mark = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8811) mddev->resync_mark = mark[last_mark];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8812) mddev->resync_mark_cnt = mark_cnt[last_mark];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8813)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8814) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8815) * Tune reconstruction:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8816) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8817) window = 32 * (PAGE_SIZE / 512);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8818) pr_debug("md: using %dk window, over a total of %lluk.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8819) window/2, (unsigned long long)max_sectors/2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8820)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8821) atomic_set(&mddev->recovery_active, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8822) last_check = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8823)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8824) if (j>2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8825) pr_debug("md: resuming %s of %s from checkpoint.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8826) desc, mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8827) mddev->curr_resync = j;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8828) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8829) mddev->curr_resync = 3; /* no longer delayed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8830) mddev->curr_resync_completed = j;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8831) sysfs_notify_dirent_safe(mddev->sysfs_completed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8832) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8833) update_time = jiffies;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8834)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8835) blk_start_plug(&plug);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8836) while (j < max_sectors) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8837) sector_t sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8838)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8839) skipped = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8840)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8841) if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8842) ((mddev->curr_resync > mddev->curr_resync_completed &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8843) (mddev->curr_resync - mddev->curr_resync_completed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8844) > (max_sectors >> 4)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8845) time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8846) (j - mddev->curr_resync_completed)*2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8847) >= mddev->resync_max - mddev->curr_resync_completed ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8848) mddev->curr_resync_completed > mddev->resync_max
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8849) )) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8850) /* time to update curr_resync_completed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8851) wait_event(mddev->recovery_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8852) atomic_read(&mddev->recovery_active) == 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8853) mddev->curr_resync_completed = j;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8854) if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8855) j > mddev->recovery_cp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8856) mddev->recovery_cp = j;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8857) update_time = jiffies;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8858) set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8859) sysfs_notify_dirent_safe(mddev->sysfs_completed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8860) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8861)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8862) while (j >= mddev->resync_max &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8863) !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8864) /* As this condition is controlled by user-space,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8865) * we can block indefinitely, so use '_interruptible'
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8866) * to avoid triggering warnings.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8867) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8868) flush_signals(current); /* just in case */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8869) wait_event_interruptible(mddev->recovery_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8870) mddev->resync_max > j
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8871) || test_bit(MD_RECOVERY_INTR,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8872) &mddev->recovery));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8873) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8874)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8875) if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8876) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8877)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8878) sectors = mddev->pers->sync_request(mddev, j, &skipped);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8879) if (sectors == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8880) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8881) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8882) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8883)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8884) if (!skipped) { /* actual IO requested */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8885) io_sectors += sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8886) atomic_add(sectors, &mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8887) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8888)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8889) if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8890) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8891)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8892) j += sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8893) if (j > max_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8894) /* when skipping, extra large numbers can be returned. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8895) j = max_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8896) if (j > 2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8897) mddev->curr_resync = j;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8898) mddev->curr_mark_cnt = io_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8899) if (last_check == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8900) /* this is the earliest that rebuild will be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8901) * visible in /proc/mdstat
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8902) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8903) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8904)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8905) if (last_check + window > io_sectors || j == max_sectors)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8906) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8907)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8908) last_check = io_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8909) repeat:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8910) if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8911) /* step marks */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8912) int next = (last_mark+1) % SYNC_MARKS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8913)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8914) mddev->resync_mark = mark[next];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8915) mddev->resync_mark_cnt = mark_cnt[next];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8916) mark[next] = jiffies;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8917) mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8918) last_mark = next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8919) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8920)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8921) if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8922) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8923)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8924) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8925) * this loop exits only if either when we are slower than
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8926) * the 'hard' speed limit, or the system was IO-idle for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8927) * a jiffy.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8928) * the system might be non-idle CPU-wise, but we only care
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8929) * about not overloading the IO subsystem. (things like an
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8930) * e2fsck being done on the RAID array should execute fast)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8931) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8932) cond_resched();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8933)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8934) recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8935) currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8936) /((jiffies-mddev->resync_mark)/HZ +1) +1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8937)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8938) if (currspeed > speed_min(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8939) if (currspeed > speed_max(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8940) msleep(500);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8941) goto repeat;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8942) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8943) if (!is_mddev_idle(mddev, 0)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8944) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8945) * Give other IO more of a chance.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8946) * The faster the devices, the less we wait.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8947) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8948) wait_event(mddev->recovery_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8949) !atomic_read(&mddev->recovery_active));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8950) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8951) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8952) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8953) pr_info("md: %s: %s %s.\n",mdname(mddev), desc,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8954) test_bit(MD_RECOVERY_INTR, &mddev->recovery)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8955) ? "interrupted" : "done");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8956) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8957) * this also signals 'finished resyncing' to md_stop
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8958) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8959) blk_finish_plug(&plug);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8960) wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8961)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8962) if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8963) !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8964) mddev->curr_resync > 3) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8965) mddev->curr_resync_completed = mddev->curr_resync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8966) sysfs_notify_dirent_safe(mddev->sysfs_completed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8967) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8968) mddev->pers->sync_request(mddev, max_sectors, &skipped);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8969)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8970) if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8971) mddev->curr_resync > 3) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8972) if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8973) if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8974) if (mddev->curr_resync >= mddev->recovery_cp) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8975) pr_debug("md: checkpointing %s of %s.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8976) desc, mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8977) if (test_bit(MD_RECOVERY_ERROR,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8978) &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8979) mddev->recovery_cp =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8980) mddev->curr_resync_completed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8981) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8982) mddev->recovery_cp =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8983) mddev->curr_resync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8984) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8985) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8986) mddev->recovery_cp = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8987) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8988) if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8989) mddev->curr_resync = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8990) if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8991) test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8992) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8993) rdev_for_each_rcu(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8994) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8995) mddev->delta_disks >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8996) !test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8997) !test_bit(Faulty, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8998) !test_bit(In_sync, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8999) rdev->recovery_offset < mddev->curr_resync)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9000) rdev->recovery_offset = mddev->curr_resync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9001) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9002) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9003) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9004) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9005) skip:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9006) /* set CHANGE_PENDING here since maybe another update is needed,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9007) * so other nodes are informed. It should be harmless for normal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9008) * raid */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9009) set_mask_bits(&mddev->sb_flags, 0,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9010) BIT(MD_SB_CHANGE_PENDING) | BIT(MD_SB_CHANGE_DEVS));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9011)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9012) if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9013) !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9014) mddev->delta_disks > 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9015) mddev->pers->finish_reshape &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9016) mddev->pers->size &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9017) mddev->queue) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9018) mddev_lock_nointr(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9019) md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9020) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9021) if (!mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9022) set_capacity(mddev->gendisk, mddev->array_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9023) revalidate_disk_size(mddev->gendisk, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9024) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9025) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9026)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9027) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9028) if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9029) /* We completed so min/max setting can be forgotten if used. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9030) if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9031) mddev->resync_min = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9032) mddev->resync_max = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9033) } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9034) mddev->resync_min = mddev->curr_resync_completed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9035) set_bit(MD_RECOVERY_DONE, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9036) mddev->curr_resync = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9037) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9038)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9039) wake_up(&resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9040) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9041) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9042) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9043) EXPORT_SYMBOL_GPL(md_do_sync);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9044)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9045) static int remove_and_add_spares(struct mddev *mddev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9046) struct md_rdev *this)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9047) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9048) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9049) int spares = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9050) int removed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9051) bool remove_some = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9052)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9053) if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9054) /* Mustn't remove devices when resync thread is running */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9055) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9056)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9057) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9058) if ((this == NULL || rdev == this) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9059) rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9060) !test_bit(Blocked, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9061) test_bit(Faulty, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9062) atomic_read(&rdev->nr_pending)==0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9063) /* Faulty non-Blocked devices with nr_pending == 0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9064) * never get nr_pending incremented,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9065) * never get Faulty cleared, and never get Blocked set.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9066) * So we can synchronize_rcu now rather than once per device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9067) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9068) remove_some = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9069) set_bit(RemoveSynchronized, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9070) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9071) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9072)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9073) if (remove_some)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9074) synchronize_rcu();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9075) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9076) if ((this == NULL || rdev == this) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9077) rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9078) !test_bit(Blocked, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9079) ((test_bit(RemoveSynchronized, &rdev->flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9080) (!test_bit(In_sync, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9081) !test_bit(Journal, &rdev->flags))) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9082) atomic_read(&rdev->nr_pending)==0)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9083) if (mddev->pers->hot_remove_disk(
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9084) mddev, rdev) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9085) sysfs_unlink_rdev(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9086) rdev->saved_raid_disk = rdev->raid_disk;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9087) rdev->raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9088) removed++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9089) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9090) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9091) if (remove_some && test_bit(RemoveSynchronized, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9092) clear_bit(RemoveSynchronized, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9093) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9094)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9095) if (removed && mddev->kobj.sd)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9096) sysfs_notify_dirent_safe(mddev->sysfs_degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9097)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9098) if (this && removed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9099) goto no_add;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9100)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9101) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9102) if (this && this != rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9103) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9104) if (test_bit(Candidate, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9105) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9106) if (rdev->raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9107) !test_bit(In_sync, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9108) !test_bit(Journal, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9109) !test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9110) spares++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9111) if (rdev->raid_disk >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9112) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9113) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9114) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9115) if (!test_bit(Journal, &rdev->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9116) if (mddev->ro &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9117) ! (rdev->saved_raid_disk >= 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9118) !test_bit(Bitmap_sync, &rdev->flags)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9119) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9120)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9121) rdev->recovery_offset = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9122) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9123) if (mddev->pers->hot_add_disk(mddev, rdev) == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9124) /* failure here is OK */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9125) sysfs_link_rdev(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9126) if (!test_bit(Journal, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9127) spares++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9128) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9129) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9130) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9131) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9132) no_add:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9133) if (removed)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9134) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9135) return spares;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9136) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9137)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9138) static void md_start_sync(struct work_struct *ws)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9139) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9140) struct mddev *mddev = container_of(ws, struct mddev, del_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9141)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9142) mddev->sync_thread = md_register_thread(md_do_sync,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9143) mddev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9144) "resync");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9145) if (!mddev->sync_thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9146) pr_warn("%s: could not start resync thread...\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9147) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9148) /* leave the spares where they are, it shouldn't hurt */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9149) clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9150) clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9151) clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9152) clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9153) clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9154) wake_up(&resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9155) if (test_and_clear_bit(MD_RECOVERY_RECOVER,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9156) &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9157) if (mddev->sysfs_action)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9158) sysfs_notify_dirent_safe(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9159) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9160) md_wakeup_thread(mddev->sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9161) sysfs_notify_dirent_safe(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9162) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9163) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9164)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9165) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9166) * This routine is regularly called by all per-raid-array threads to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9167) * deal with generic issues like resync and super-block update.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9168) * Raid personalities that don't have a thread (linear/raid0) do not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9169) * need this as they never do any recovery or update the superblock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9170) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9171) * It does not do any resync itself, but rather "forks" off other threads
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9172) * to do that as needed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9173) * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9174) * "->recovery" and create a thread at ->sync_thread.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9175) * When the thread finishes it sets MD_RECOVERY_DONE
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9176) * and wakeups up this thread which will reap the thread and finish up.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9177) * This thread also removes any faulty devices (with nr_pending == 0).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9178) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9179) * The overall approach is:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9180) * 1/ if the superblock needs updating, update it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9181) * 2/ If a recovery thread is running, don't do anything else.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9182) * 3/ If recovery has finished, clean up, possibly marking spares active.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9183) * 4/ If there are any faulty devices, remove them.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9184) * 5/ If array is degraded, try to add spares devices
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9185) * 6/ If array has spares or is not in-sync, start a resync thread.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9186) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9187) void md_check_recovery(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9188) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9189) if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags) && mddev->sb_flags) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9190) /* Write superblock - thread that called mddev_suspend()
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9191) * holds reconfig_mutex for us.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9192) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9193) set_bit(MD_UPDATING_SB, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9194) smp_mb__after_atomic();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9195) if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9196) md_update_sb(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9197) clear_bit_unlock(MD_UPDATING_SB, &mddev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9198) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9199) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9200)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9201) if (mddev->suspended)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9202) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9203)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9204) if (mddev->bitmap)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9205) md_bitmap_daemon_work(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9206)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9207) if (signal_pending(current)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9208) if (mddev->pers->sync_request && !mddev->external) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9209) pr_debug("md: %s in immediate safe mode\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9210) mdname(mddev));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9211) mddev->safemode = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9212) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9213) flush_signals(current);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9214) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9215)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9216) if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9217) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9218) if ( ! (
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9219) (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9220) test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9221) test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9222) (mddev->external == 0 && mddev->safemode == 1) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9223) (mddev->safemode == 2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9224) && !mddev->in_sync && mddev->recovery_cp == MaxSector)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9225) ))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9226) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9227)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9228) if (mddev_trylock(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9229) int spares = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9230) bool try_set_sync = mddev->safemode != 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9231)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9232) if (!mddev->external && mddev->safemode == 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9233) mddev->safemode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9234)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9235) if (mddev->ro) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9236) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9237) if (!mddev->external && mddev->in_sync)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9238) /* 'Blocked' flag not needed as failed devices
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9239) * will be recorded if array switched to read/write.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9240) * Leaving it set will prevent the device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9241) * from being removed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9242) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9243) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9244) clear_bit(Blocked, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9245) /* On a read-only array we can:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9246) * - remove failed devices
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9247) * - add already-in_sync devices if the array itself
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9248) * is in-sync.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9249) * As we only add devices that are already in-sync,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9250) * we can activate the spares immediately.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9251) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9252) remove_and_add_spares(mddev, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9253) /* There is no thread, but we need to call
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9254) * ->spare_active and clear saved_raid_disk
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9255) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9256) set_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9257) md_reap_sync_thread(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9258) clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9259) clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9260) clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9261) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9262) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9263)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9264) if (mddev_is_clustered(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9265) struct md_rdev *rdev, *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9266) /* kick the device if another node issued a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9267) * remove disk.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9268) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9269) rdev_for_each_safe(rdev, tmp, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9270) if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9271) rdev->raid_disk < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9272) md_kick_rdev_from_array(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9273) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9274) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9275)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9276) if (try_set_sync && !mddev->external && !mddev->in_sync) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9277) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9278) set_in_sync(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9279) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9280) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9281)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9282) if (mddev->sb_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9283) md_update_sb(mddev, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9284)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9285) if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9286) !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9287) /* resync/recovery still happening */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9288) clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9289) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9290) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9291) if (mddev->sync_thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9292) md_reap_sync_thread(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9293) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9294) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9295) /* Set RUNNING before clearing NEEDED to avoid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9296) * any transients in the value of "sync_action".
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9297) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9298) mddev->curr_resync_completed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9299) spin_lock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9300) set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9301) spin_unlock(&mddev->lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9302) /* Clear some bits that don't mean anything, but
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9303) * might be left set
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9304) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9305) clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9306) clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9307)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9308) if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9309) test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9310) goto not_running;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9311) /* no recovery is running.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9312) * remove any failed drives, then
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9313) * add spares if possible.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9314) * Spares are also removed and re-added, to allow
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9315) * the personality to fail the re-add.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9316) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9317)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9318) if (mddev->reshape_position != MaxSector) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9319) if (mddev->pers->check_reshape == NULL ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9320) mddev->pers->check_reshape(mddev) != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9321) /* Cannot proceed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9322) goto not_running;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9323) set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9324) clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9325) } else if ((spares = remove_and_add_spares(mddev, NULL))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9326) clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9327) clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9328) clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9329) set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9330) } else if (mddev->recovery_cp < MaxSector) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9331) set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9332) clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9333) } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9334) /* nothing to be done ... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9335) goto not_running;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9336)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9337) if (mddev->pers->sync_request) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9338) if (spares) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9339) /* We are adding a device or devices to an array
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9340) * which has the bitmap stored on all devices.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9341) * So make sure all bitmap pages get written
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9342) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9343) md_bitmap_write_all(mddev->bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9344) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9345) INIT_WORK(&mddev->del_work, md_start_sync);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9346) queue_work(md_misc_wq, &mddev->del_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9347) goto unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9348) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9349) not_running:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9350) if (!mddev->sync_thread) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9351) clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9352) wake_up(&resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9353) if (test_and_clear_bit(MD_RECOVERY_RECOVER,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9354) &mddev->recovery))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9355) if (mddev->sysfs_action)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9356) sysfs_notify_dirent_safe(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9357) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9358) unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9359) wake_up(&mddev->sb_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9360) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9361) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9362) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9363) EXPORT_SYMBOL(md_check_recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9364)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9365) void md_reap_sync_thread(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9366) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9367) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9368) sector_t old_dev_sectors = mddev->dev_sectors;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9369) bool is_reshaped = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9370)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9371) /* resync has finished, collect result */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9372) md_unregister_thread(&mddev->sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9373) if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9374) !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9375) mddev->degraded != mddev->raid_disks) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9376) /* success...*/
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9377) /* activate any spares */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9378) if (mddev->pers->spare_active(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9379) sysfs_notify_dirent_safe(mddev->sysfs_degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9380) set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9381) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9382) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9383) if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9384) mddev->pers->finish_reshape) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9385) mddev->pers->finish_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9386) if (mddev_is_clustered(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9387) is_reshaped = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9388) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9389)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9390) /* If array is no-longer degraded, then any saved_raid_disk
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9391) * information must be scrapped.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9392) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9393) if (!mddev->degraded)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9394) rdev_for_each(rdev, mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9395) rdev->saved_raid_disk = -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9396)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9397) md_update_sb(mddev, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9398) /* MD_SB_CHANGE_PENDING should be cleared by md_update_sb, so we can
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9399) * call resync_finish here if MD_CLUSTER_RESYNC_LOCKED is set by
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9400) * clustered raid */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9401) if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9402) md_cluster_ops->resync_finish(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9403) clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9404) clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9405) clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9406) clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9407) clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9408) clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9409) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9410) * We call md_cluster_ops->update_size here because sync_size could
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9411) * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9412) * so it is time to update size across cluster.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9413) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9414) if (mddev_is_clustered(mddev) && is_reshaped
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9415) && !test_bit(MD_CLOSING, &mddev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9416) md_cluster_ops->update_size(mddev, old_dev_sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9417) wake_up(&resync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9418) /* flag recovery needed just to double check */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9419) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9420) sysfs_notify_dirent_safe(mddev->sysfs_action);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9421) md_new_event(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9422) if (mddev->event_work.func)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9423) queue_work(md_misc_wq, &mddev->event_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9424) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9425) EXPORT_SYMBOL(md_reap_sync_thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9426)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9427) void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9428) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9429) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9430) wait_event_timeout(rdev->blocked_wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9431) !test_bit(Blocked, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9432) !test_bit(BlockedBadBlocks, &rdev->flags),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9433) msecs_to_jiffies(5000));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9434) rdev_dec_pending(rdev, mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9435) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9436) EXPORT_SYMBOL(md_wait_for_blocked_rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9437)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9438) void md_finish_reshape(struct mddev *mddev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9439) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9440) /* called be personality module when reshape completes. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9441) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9442)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9443) rdev_for_each(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9444) if (rdev->data_offset > rdev->new_data_offset)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9445) rdev->sectors += rdev->data_offset - rdev->new_data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9446) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9447) rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9448) rdev->data_offset = rdev->new_data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9449) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9450) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9451) EXPORT_SYMBOL(md_finish_reshape);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9452)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9453) /* Bad block management */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9454)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9455) /* Returns 1 on success, 0 on failure */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9456) int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9457) int is_new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9458) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9459) struct mddev *mddev = rdev->mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9460) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9461) if (is_new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9462) s += rdev->new_data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9463) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9464) s += rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9465) rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9466) if (rv == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9467) /* Make sure they get written out promptly */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9468) if (test_bit(ExternalBbl, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9469) sysfs_notify_dirent_safe(rdev->sysfs_unack_badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9470) sysfs_notify_dirent_safe(rdev->sysfs_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9471) set_mask_bits(&mddev->sb_flags, 0,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9472) BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9473) md_wakeup_thread(rdev->mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9474) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9475) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9476) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9477) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9478) EXPORT_SYMBOL_GPL(rdev_set_badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9479)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9480) int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9481) int is_new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9482) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9483) int rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9484) if (is_new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9485) s += rdev->new_data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9486) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9487) s += rdev->data_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9488) rv = badblocks_clear(&rdev->badblocks, s, sectors);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9489) if ((rv == 0) && test_bit(ExternalBbl, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9490) sysfs_notify_dirent_safe(rdev->sysfs_badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9491) return rv;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9492) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9493) EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9494)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9495) static int md_notify_reboot(struct notifier_block *this,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9496) unsigned long code, void *x)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9497) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9498) struct list_head *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9499) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9500) int need_delay = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9501)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9502) for_each_mddev(mddev, tmp) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9503) if (mddev_trylock(mddev)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9504) if (mddev->pers)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9505) __md_stop_writes(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9506) if (mddev->persistent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9507) mddev->safemode = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9508) mddev_unlock(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9509) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9510) need_delay = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9511) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9512) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9513) * certain more exotic SCSI devices are known to be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9514) * volatile wrt too early system reboots. While the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9515) * right place to handle this issue is the given
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9516) * driver, we do want to have a safe RAID driver ...
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9517) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9518) if (need_delay)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9519) mdelay(1000*1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9520)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9521) return NOTIFY_DONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9522) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9523)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9524) static struct notifier_block md_notifier = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9525) .notifier_call = md_notify_reboot,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9526) .next = NULL,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9527) .priority = INT_MAX, /* before any real devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9528) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9529)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9530) static void md_geninit(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9531) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9532) pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9533)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9534) proc_create("mdstat", S_IRUGO, NULL, &mdstat_proc_ops);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9535) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9536)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9537) static int __init md_init(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9538) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9539) int ret = -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9540)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9541) md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9542) if (!md_wq)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9543) goto err_wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9544)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9545) md_misc_wq = alloc_workqueue("md_misc", 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9546) if (!md_misc_wq)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9547) goto err_misc_wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9548)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9549) md_rdev_misc_wq = alloc_workqueue("md_rdev_misc", 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9550) if (!md_rdev_misc_wq)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9551) goto err_rdev_misc_wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9552)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9553) if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9554) goto err_md;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9555)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9556) if ((ret = register_blkdev(0, "mdp")) < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9557) goto err_mdp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9558) mdp_major = ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9559)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9560) blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9561) md_probe, NULL, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9562) blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9563) md_probe, NULL, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9565) register_reboot_notifier(&md_notifier);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9566) raid_table_header = register_sysctl_table(raid_root_table);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9567)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9568) md_geninit();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9569) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9570)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9571) err_mdp:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9572) unregister_blkdev(MD_MAJOR, "md");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9573) err_md:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9574) destroy_workqueue(md_rdev_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9575) err_rdev_misc_wq:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9576) destroy_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9577) err_misc_wq:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9578) destroy_workqueue(md_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9579) err_wq:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9580) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9581) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9582)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9583) static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9584) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9585) struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9586) struct md_rdev *rdev2, *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9587) int role, ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9588) char b[BDEVNAME_SIZE];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9590) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9591) * If size is changed in another node then we need to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9592) * do resize as well.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9593) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9594) if (mddev->dev_sectors != le64_to_cpu(sb->size)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9595) ret = mddev->pers->resize(mddev, le64_to_cpu(sb->size));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9596) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9597) pr_info("md-cluster: resize failed\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9598) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9599) md_bitmap_update_sb(mddev->bitmap);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9600) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9601)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9602) /* Check for change of roles in the active devices */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9603) rdev_for_each_safe(rdev2, tmp, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9604) if (test_bit(Faulty, &rdev2->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9605) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9606)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9607) /* Check if the roles changed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9608) role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9609)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9610) if (test_bit(Candidate, &rdev2->flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9611) if (role == 0xfffe) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9612) pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9613) md_kick_rdev_from_array(rdev2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9614) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9615) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9616) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9617) clear_bit(Candidate, &rdev2->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9618) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9619)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9620) if (role != rdev2->raid_disk) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9621) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9622) * got activated except reshape is happening.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9623) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9624) if (rdev2->raid_disk == -1 && role != 0xffff &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9625) !(le32_to_cpu(sb->feature_map) &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9626) MD_FEATURE_RESHAPE_ACTIVE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9627) rdev2->saved_raid_disk = role;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9628) ret = remove_and_add_spares(mddev, rdev2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9629) pr_info("Activated spare: %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9630) bdevname(rdev2->bdev,b));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9631) /* wakeup mddev->thread here, so array could
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9632) * perform resync with the new activated disk */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9633) set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9634) md_wakeup_thread(mddev->thread);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9635) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9636) /* device faulty
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9637) * We just want to do the minimum to mark the disk
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9638) * as faulty. The recovery is performed by the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9639) * one who initiated the error.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9640) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9641) if ((role == 0xfffe) || (role == 0xfffd)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9642) md_error(mddev, rdev2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9643) clear_bit(Blocked, &rdev2->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9644) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9645) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9646) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9647)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9648) if (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9649) ret = update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9650) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9651) pr_warn("md: updating array disks failed. %d\n", ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9652) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9653)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9654) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9655) * Since mddev->delta_disks has already updated in update_raid_disks,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9656) * so it is time to check reshape.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9657) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9658) if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9659) (le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9660) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9661) * reshape is happening in the remote node, we need to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9662) * update reshape_position and call start_reshape.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9663) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9664) mddev->reshape_position = le64_to_cpu(sb->reshape_position);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9665) if (mddev->pers->update_reshape_pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9666) mddev->pers->update_reshape_pos(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9667) if (mddev->pers->start_reshape)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9668) mddev->pers->start_reshape(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9669) } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9670) mddev->reshape_position != MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9671) !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9672) /* reshape is just done in another node. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9673) mddev->reshape_position = MaxSector;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9674) if (mddev->pers->update_reshape_pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9675) mddev->pers->update_reshape_pos(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9676) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9677)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9678) /* Finally set the event to be up to date */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9679) mddev->events = le64_to_cpu(sb->events);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9680) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9681)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9682) static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9683) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9684) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9685) struct page *swapout = rdev->sb_page;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9686) struct mdp_superblock_1 *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9687)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9688) /* Store the sb page of the rdev in the swapout temporary
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9689) * variable in case we err in the future
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9690) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9691) rdev->sb_page = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9692) err = alloc_disk_sb(rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9693) if (err == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9694) ClearPageUptodate(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9695) rdev->sb_loaded = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9696) err = super_types[mddev->major_version].
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9697) load_super(rdev, NULL, mddev->minor_version);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9698) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9699) if (err < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9700) pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9701) __func__, __LINE__, rdev->desc_nr, err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9702) if (rdev->sb_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9703) put_page(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9704) rdev->sb_page = swapout;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9705) rdev->sb_loaded = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9706) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9707) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9708)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9709) sb = page_address(rdev->sb_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9710) /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9711) * is not set
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9712) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9713)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9714) if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9715) rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9716)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9717) /* The other node finished recovery, call spare_active to set
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9718) * device In_sync and mddev->degraded
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9719) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9720) if (rdev->recovery_offset == MaxSector &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9721) !test_bit(In_sync, &rdev->flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9722) mddev->pers->spare_active(mddev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9723) sysfs_notify_dirent_safe(mddev->sysfs_degraded);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9724)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9725) put_page(swapout);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9726) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9727) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9728)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9729) void md_reload_sb(struct mddev *mddev, int nr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9730) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9731) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9732) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9733)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9734) /* Find the rdev */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9735) rdev_for_each_rcu(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9736) if (rdev->desc_nr == nr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9737) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9738) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9739)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9740) if (!rdev || rdev->desc_nr != nr) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9741) pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9742) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9743) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9744)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9745) err = read_rdev(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9746) if (err < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9747) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9748)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9749) check_sb_changes(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9750)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9751) /* Read all rdev's to update recovery_offset */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9752) rdev_for_each_rcu(rdev, mddev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9753) if (!test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9754) read_rdev(mddev, rdev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9755) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9756) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9757) EXPORT_SYMBOL(md_reload_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9758)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9759) #ifndef MODULE
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9760)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9761) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9762) * Searches all registered partitions for autorun RAID arrays
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9763) * at boot time.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9764) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9765)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9766) static DEFINE_MUTEX(detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9767) static LIST_HEAD(all_detected_devices);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9768) struct detected_devices_node {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9769) struct list_head list;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9770) dev_t dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9771) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9772)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9773) void md_autodetect_dev(dev_t dev)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9774) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9775) struct detected_devices_node *node_detected_dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9776)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9777) node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9778) if (node_detected_dev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9779) node_detected_dev->dev = dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9780) mutex_lock(&detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9781) list_add_tail(&node_detected_dev->list, &all_detected_devices);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9782) mutex_unlock(&detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9783) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9784) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9785)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9786) void md_autostart_arrays(int part)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9787) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9788) struct md_rdev *rdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9789) struct detected_devices_node *node_detected_dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9790) dev_t dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9791) int i_scanned, i_passed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9792)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9793) i_scanned = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9794) i_passed = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9795)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9796) pr_info("md: Autodetecting RAID arrays.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9797)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9798) mutex_lock(&detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9799) while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9800) i_scanned++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9801) node_detected_dev = list_entry(all_detected_devices.next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9802) struct detected_devices_node, list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9803) list_del(&node_detected_dev->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9804) dev = node_detected_dev->dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9805) kfree(node_detected_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9806) mutex_unlock(&detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9807) rdev = md_import_device(dev,0, 90);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9808) mutex_lock(&detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9809) if (IS_ERR(rdev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9810) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9811)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9812) if (test_bit(Faulty, &rdev->flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9813) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9814)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9815) set_bit(AutoDetected, &rdev->flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9816) list_add(&rdev->same_set, &pending_raid_disks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9817) i_passed++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9818) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9819) mutex_unlock(&detected_devices_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9820)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9821) pr_debug("md: Scanned %d and added %d devices.\n", i_scanned, i_passed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9822)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9823) autorun_devices(part);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9824) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9825)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9826) #endif /* !MODULE */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9827)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9828) static __exit void md_exit(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9829) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9830) struct mddev *mddev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9831) struct list_head *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9832) int delay = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9833)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9834) blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9835) blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9836)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9837) unregister_blkdev(MD_MAJOR,"md");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9838) unregister_blkdev(mdp_major, "mdp");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9839) unregister_reboot_notifier(&md_notifier);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9840) unregister_sysctl_table(raid_table_header);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9841)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9842) /* We cannot unload the modules while some process is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9843) * waiting for us in select() or poll() - wake them up
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9844) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9845) md_unloading = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9846) while (waitqueue_active(&md_event_waiters)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9847) /* not safe to leave yet */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9848) wake_up(&md_event_waiters);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9849) msleep(delay);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9850) delay += delay;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9851) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9852) remove_proc_entry("mdstat", NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9853)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9854) for_each_mddev(mddev, tmp) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9855) export_array(mddev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9856) mddev->ctime = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9857) mddev->hold_active = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9858) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9859) * for_each_mddev() will call mddev_put() at the end of each
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9860) * iteration. As the mddev is now fully clear, this will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9861) * schedule the mddev for destruction by a workqueue, and the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9862) * destroy_workqueue() below will wait for that to complete.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9863) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9864) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9865) destroy_workqueue(md_rdev_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9866) destroy_workqueue(md_misc_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9867) destroy_workqueue(md_wq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9868) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9869)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9870) subsys_initcall(md_init);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9871) module_exit(md_exit)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9872)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9873) static int get_ro(char *buffer, const struct kernel_param *kp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9874) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9875) return sprintf(buffer, "%d\n", start_readonly);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9876) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9877) static int set_ro(const char *val, const struct kernel_param *kp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9878) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9879) return kstrtouint(val, 10, (unsigned int *)&start_readonly);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9880) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9881)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9882) module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9883) module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9884) module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9885) module_param(create_on_open, bool, S_IRUSR|S_IWUSR);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9886)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9887) MODULE_LICENSE("GPL");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9888) MODULE_DESCRIPTION("MD RAID framework");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9889) MODULE_ALIAS("md");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9890) MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
Orange Pi5 kernel
Deprecated Linux kernel 5.10.110 for OrangePi 5/5B/5+ boards
3 Commits
0 Branches
0 Tags