1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/kernel.h> 3 #include <linux/blkdev.h> 4 #include <linux/init.h> 5 #include <linux/mount.h> 6 #include <linux/major.h> 7 #include <linux/delay.h> 8 #include <linux/init_syscalls.h> 9 #include <linux/raid/detect.h> 10 #include <linux/raid/md_u.h> 11 #include <linux/raid/md_p.h> 12 #include "md.h" 13 14 /* 15 * When md (and any require personalities) are compiled into the kernel 16 * (not a module), arrays can be assembles are boot time using with AUTODETECT 17 * where specially marked partitions are registered with md_autodetect_dev(), 18 * and with MD_BOOT where devices to be collected are given on the boot line 19 * with md=..... 20 * The code for that is here. 21 */ 22 23 #ifdef CONFIG_MD_AUTODETECT 24 static int __initdata raid_noautodetect; 25 #else 26 static int __initdata raid_noautodetect=1; 27 #endif 28 static int __initdata raid_autopart; 29 30 static struct md_setup_args { 31 int minor; 32 int partitioned; 33 int level; 34 int chunk; 35 char *device_names; 36 } md_setup_args[256] __initdata; 37 38 static int md_setup_ents __initdata; 39 40 /* 41 * Parse the command-line parameters given our kernel, but do not 42 * actually try to invoke the MD device now; that is handled by 43 * md_setup_drive after the low-level disk drivers have initialised. 44 * 45 * 27/11/1999: Fixed to work correctly with the 2.3 kernel (which 46 * assigns the task of parsing integer arguments to the 47 * invoked program now). Added ability to initialise all 48 * the MD devices (by specifying multiple "md=" lines) 49 * instead of just one. -- KTK 50 * 18May2000: Added support for persistent-superblock arrays: 51 * md=n,0,factor,fault,device-list uses RAID0 for device n 52 * md=n,-1,factor,fault,device-list uses LINEAR for device n 53 * md=n,device-list reads a RAID superblock from the devices 54 * elements in device-list are read by name_to_kdev_t so can be 55 * a hex number or something like /dev/hda1 /dev/sdb 56 * 2001-06-03: Dave Cinege <dcinege@psychosis.com> 57 * Shifted name_to_kdev_t() and related operations to md_set_drive() 58 * for later execution. Rewrote section to make devfs compatible. 59 */ 60 static int __init md_setup(char *str) 61 { 62 int minor, level, factor, fault, partitioned = 0; 63 char *pername = ""; 64 char *str1; 65 int ent; 66 67 if (*str == 'd') { 68 partitioned = 1; 69 str++; 70 } 71 if (get_option(&str, &minor) != 2) { /* MD Number */ 72 printk(KERN_WARNING "md: Too few arguments supplied to md=.\n"); 73 return 0; 74 } 75 str1 = str; 76 for (ent=0 ; ent< md_setup_ents ; ent++) 77 if (md_setup_args[ent].minor == minor && 78 md_setup_args[ent].partitioned == partitioned) { 79 printk(KERN_WARNING "md: md=%s%d, Specified more than once. " 80 "Replacing previous definition.\n", partitioned?"d":"", minor); 81 break; 82 } 83 if (ent >= ARRAY_SIZE(md_setup_args)) { 84 printk(KERN_WARNING "md: md=%s%d - too many md initialisations\n", partitioned?"d":"", minor); 85 return 0; 86 } 87 if (ent >= md_setup_ents) 88 md_setup_ents++; 89 switch (get_option(&str, &level)) { /* RAID level */ 90 case 2: /* could be 0 or -1.. */ 91 if (level == 0 || level == LEVEL_LINEAR) { 92 if (get_option(&str, &factor) != 2 || /* Chunk Size */ 93 get_option(&str, &fault) != 2) { 94 printk(KERN_WARNING "md: Too few arguments supplied to md=.\n"); 95 return 0; 96 } 97 md_setup_args[ent].level = level; 98 md_setup_args[ent].chunk = 1 << (factor+12); 99 if (level == LEVEL_LINEAR) 100 pername = "linear"; 101 else 102 pername = "raid0"; 103 break; 104 } 105 fallthrough; 106 case 1: /* the first device is numeric */ 107 str = str1; 108 fallthrough; 109 case 0: 110 md_setup_args[ent].level = LEVEL_NONE; 111 pername="super-block"; 112 } 113 114 printk(KERN_INFO "md: Will configure md%d (%s) from %s, below.\n", 115 minor, pername, str); 116 md_setup_args[ent].device_names = str; 117 md_setup_args[ent].partitioned = partitioned; 118 md_setup_args[ent].minor = minor; 119 120 return 1; 121 } 122 123 static void __init md_setup_drive(struct md_setup_args *args) 124 { 125 char *devname = args->device_names; 126 dev_t devices[MD_SB_DISKS + 1], mdev; 127 struct mdu_array_info_s ainfo = { }; 128 struct mddev *mddev; 129 int err = 0, i; 130 char name[16]; 131 132 if (args->partitioned) { 133 mdev = MKDEV(mdp_major, args->minor << MdpMinorShift); 134 sprintf(name, "md_d%d", args->minor); 135 } else { 136 mdev = MKDEV(MD_MAJOR, args->minor); 137 sprintf(name, "md%d", args->minor); 138 } 139 140 for (i = 0; i < MD_SB_DISKS && devname != NULL; i++) { 141 struct kstat stat; 142 char *p; 143 char comp_name[64]; 144 dev_t dev; 145 146 p = strchr(devname, ','); 147 if (p) 148 *p++ = 0; 149 150 if (early_lookup_bdev(devname, &dev)) 151 dev = 0; 152 if (strncmp(devname, "/dev/", 5) == 0) 153 devname += 5; 154 snprintf(comp_name, 63, "/dev/%s", devname); 155 if (init_stat(comp_name, &stat, 0) == 0 && S_ISBLK(stat.mode)) 156 dev = new_decode_dev(stat.rdev); 157 if (!dev) { 158 pr_warn("md: Unknown device name: %s\n", devname); 159 break; 160 } 161 162 devices[i] = dev; 163 devname = p; 164 } 165 devices[i] = 0; 166 167 if (!i) 168 return; 169 170 pr_info("md: Loading %s: %s\n", name, args->device_names); 171 172 mddev = md_alloc(mdev, name); 173 if (IS_ERR(mddev)) { 174 pr_err("md: md_alloc failed - cannot start array %s\n", name); 175 return; 176 } 177 178 err = mddev_suspend_and_lock(mddev); 179 if (err) { 180 pr_err("md: failed to lock array %s\n", name); 181 goto out_mddev_put; 182 } 183 184 if (!list_empty(&mddev->disks) || mddev->raid_disks) { 185 pr_warn("md: Ignoring %s, already autodetected. (Use raid=noautodetect)\n", 186 name); 187 goto out_unlock; 188 } 189 190 if (args->level != LEVEL_NONE) { 191 /* non-persistent */ 192 ainfo.level = args->level; 193 ainfo.md_minor = args->minor; 194 ainfo.not_persistent = 1; 195 ainfo.state = (1 << MD_SB_CLEAN); 196 ainfo.chunk_size = args->chunk; 197 while (devices[ainfo.raid_disks]) 198 ainfo.raid_disks++; 199 } 200 201 err = md_set_array_info(mddev, &ainfo); 202 203 for (i = 0; i <= MD_SB_DISKS && devices[i]; i++) { 204 struct mdu_disk_info_s dinfo = { 205 .major = MAJOR(devices[i]), 206 .minor = MINOR(devices[i]), 207 }; 208 209 if (args->level != LEVEL_NONE) { 210 dinfo.number = i; 211 dinfo.raid_disk = i; 212 dinfo.state = 213 (1 << MD_DISK_ACTIVE) | (1 << MD_DISK_SYNC); 214 } 215 216 md_add_new_disk(mddev, &dinfo); 217 } 218 219 if (!err) 220 err = do_md_run(mddev); 221 if (err) 222 pr_warn("md: starting %s failed\n", name); 223 out_unlock: 224 mddev_unlock_and_resume(mddev); 225 out_mddev_put: 226 mddev_put(mddev); 227 } 228 229 static int __init raid_setup(char *str) 230 { 231 int len, pos; 232 233 len = strlen(str) + 1; 234 pos = 0; 235 236 while (pos < len) { 237 char *comma = strchr(str+pos, ','); 238 int wlen; 239 if (comma) 240 wlen = (comma-str)-pos; 241 else wlen = (len-1)-pos; 242 243 if (!strncmp(str, "noautodetect", wlen)) 244 raid_noautodetect = 1; 245 if (!strncmp(str, "autodetect", wlen)) 246 raid_noautodetect = 0; 247 if (strncmp(str, "partitionable", wlen)==0) 248 raid_autopart = 1; 249 if (strncmp(str, "part", wlen)==0) 250 raid_autopart = 1; 251 pos += wlen+1; 252 } 253 return 1; 254 } 255 256 __setup("raid=", raid_setup); 257 __setup("md=", md_setup); 258 259 static void __init autodetect_raid(void) 260 { 261 /* 262 * Since we don't want to detect and use half a raid array, we need to 263 * wait for the known devices to complete their probing 264 */ 265 printk(KERN_INFO "md: Waiting for all devices to be available before autodetect\n"); 266 printk(KERN_INFO "md: If you don't use raid, use raid=noautodetect\n"); 267 268 wait_for_device_probe(); 269 md_autostart_arrays(raid_autopart); 270 } 271 272 void __init md_run_setup(void) 273 { 274 int ent; 275 276 if (raid_noautodetect) 277 printk(KERN_INFO "md: Skipping autodetection of RAID arrays. (raid=autodetect will force)\n"); 278 else 279 autodetect_raid(); 280 281 for (ent = 0; ent < md_setup_ents; ent++) 282 md_setup_drive(&md_setup_args[ent]); 283 } 284