Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : md.c : Multiple Devices driver for Linux
4 : : Copyright (C) 1998, 1999, 2000 Ingo Molnar
5 : :
6 : : completely rewritten, based on the MD driver code from Marc Zyngier
7 : :
8 : : Changes:
9 : :
10 : : - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
11 : : - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
12 : : - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
13 : : - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
14 : : - kmod support by: Cyrus Durgin
15 : : - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
16 : : - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
17 : :
18 : : - lots of fixes and improvements to the RAID1/RAID5 and generic
19 : : RAID code (such as request based resynchronization):
20 : :
21 : : Neil Brown <neilb@cse.unsw.edu.au>.
22 : :
23 : : - persistent bitmap code
24 : : Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
25 : :
26 : :
27 : : Errors, Warnings, etc.
28 : : Please use:
29 : : pr_crit() for error conditions that risk data loss
30 : : pr_err() for error conditions that are unexpected, like an IO error
31 : : or internal inconsistency
32 : : pr_warn() for error conditions that could have been predicated, like
33 : : adding a device to an array when it has incompatible metadata
34 : : pr_info() for every interesting, very rare events, like an array starting
35 : : or stopping, or resync starting or stopping
36 : : pr_debug() for everything else.
37 : :
38 : : */
39 : :
40 : : #include <linux/sched/mm.h>
41 : : #include <linux/sched/signal.h>
42 : : #include <linux/kthread.h>
43 : : #include <linux/blkdev.h>
44 : : #include <linux/badblocks.h>
45 : : #include <linux/sysctl.h>
46 : : #include <linux/seq_file.h>
47 : : #include <linux/fs.h>
48 : : #include <linux/poll.h>
49 : : #include <linux/ctype.h>
50 : : #include <linux/string.h>
51 : : #include <linux/hdreg.h>
52 : : #include <linux/proc_fs.h>
53 : : #include <linux/random.h>
54 : : #include <linux/module.h>
55 : : #include <linux/reboot.h>
56 : : #include <linux/file.h>
57 : : #include <linux/compat.h>
58 : : #include <linux/delay.h>
59 : : #include <linux/raid/md_p.h>
60 : : #include <linux/raid/md_u.h>
61 : : #include <linux/slab.h>
62 : : #include <linux/percpu-refcount.h>
63 : :
64 : : #include <trace/events/block.h>
65 : : #include "md.h"
66 : : #include "md-bitmap.h"
67 : : #include "md-cluster.h"
68 : :
69 : : #ifndef MODULE
70 : : static void autostart_arrays(int part);
71 : : #endif
72 : :
73 : : /* pers_list is a list of registered personalities protected
74 : : * by pers_lock.
75 : : * pers_lock does extra service to protect accesses to
76 : : * mddev->thread when the mutex cannot be held.
77 : : */
78 : : static LIST_HEAD(pers_list);
79 : : static DEFINE_SPINLOCK(pers_lock);
80 : :
81 : : static struct kobj_type md_ktype;
82 : :
83 : : struct md_cluster_operations *md_cluster_ops;
84 : : EXPORT_SYMBOL(md_cluster_ops);
85 : : static struct module *md_cluster_mod;
86 : :
87 : : static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
88 : : static struct workqueue_struct *md_wq;
89 : : static struct workqueue_struct *md_misc_wq;
90 : :
91 : : static int remove_and_add_spares(struct mddev *mddev,
92 : : struct md_rdev *this);
93 : : static void mddev_detach(struct mddev *mddev);
94 : :
95 : : /*
96 : : * Default number of read corrections we'll attempt on an rdev
97 : : * before ejecting it from the array. We divide the read error
98 : : * count by 2 for every hour elapsed between read errors.
99 : : */
100 : : #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
101 : : /*
102 : : * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
103 : : * is 1000 KB/sec, so the extra system load does not show up that much.
104 : : * Increase it if you want to have more _guaranteed_ speed. Note that
105 : : * the RAID driver will use the maximum available bandwidth if the IO
106 : : * subsystem is idle. There is also an 'absolute maximum' reconstruction
107 : : * speed limit - in case reconstruction slows down your system despite
108 : : * idle IO detection.
109 : : *
110 : : * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
111 : : * or /sys/block/mdX/md/sync_speed_{min,max}
112 : : */
113 : :
114 : : static int sysctl_speed_limit_min = 1000;
115 : : static int sysctl_speed_limit_max = 200000;
116 : 0 : static inline int speed_min(struct mddev *mddev)
117 : : {
118 : 0 : return mddev->sync_speed_min ?
119 [ # # ]: 0 : mddev->sync_speed_min : sysctl_speed_limit_min;
120 : : }
121 : :
122 : 0 : static inline int speed_max(struct mddev *mddev)
123 : : {
124 : 0 : return mddev->sync_speed_max ?
125 [ # # ]: 0 : mddev->sync_speed_max : sysctl_speed_limit_max;
126 : : }
127 : :
128 : 0 : static void rdev_uninit_serial(struct md_rdev *rdev)
129 : : {
130 [ # # ]: 0 : if (!test_and_clear_bit(CollisionCheck, &rdev->flags))
131 : : return;
132 : :
133 : 0 : kvfree(rdev->serial);
134 : 0 : rdev->serial = NULL;
135 : : }
136 : :
137 : 0 : static void rdevs_uninit_serial(struct mddev *mddev)
138 : : {
139 : 0 : struct md_rdev *rdev;
140 : :
141 [ # # # # ]: 0 : rdev_for_each(rdev, mddev)
142 : 0 : rdev_uninit_serial(rdev);
143 : : }
144 : :
145 : 0 : static int rdev_init_serial(struct md_rdev *rdev)
146 : : {
147 : : /* serial_nums equals with BARRIER_BUCKETS_NR */
148 : 0 : int i, serial_nums = 1 << ((PAGE_SHIFT - ilog2(sizeof(atomic_t))));
149 : 0 : struct serial_in_rdev *serial = NULL;
150 : :
151 [ # # ]: 0 : if (test_bit(CollisionCheck, &rdev->flags))
152 : : return 0;
153 : :
154 : 0 : serial = kvmalloc(sizeof(struct serial_in_rdev) * serial_nums,
155 : : GFP_KERNEL);
156 [ # # ]: 0 : if (!serial)
157 : : return -ENOMEM;
158 : :
159 [ # # ]: 0 : for (i = 0; i < serial_nums; i++) {
160 : 0 : struct serial_in_rdev *serial_tmp = &serial[i];
161 : :
162 : 0 : spin_lock_init(&serial_tmp->serial_lock);
163 : 0 : serial_tmp->serial_rb = RB_ROOT_CACHED;
164 : 0 : init_waitqueue_head(&serial_tmp->serial_io_wait);
165 : : }
166 : :
167 : 0 : rdev->serial = serial;
168 : 0 : set_bit(CollisionCheck, &rdev->flags);
169 : :
170 : 0 : return 0;
171 : : }
172 : :
173 : 0 : static int rdevs_init_serial(struct mddev *mddev)
174 : : {
175 : 0 : struct md_rdev *rdev;
176 : 0 : int ret = 0;
177 : :
178 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
179 : 0 : ret = rdev_init_serial(rdev);
180 [ # # ]: 0 : if (ret)
181 : : break;
182 : : }
183 : :
184 : : /* Free all resources if pool is not existed */
185 [ # # # # ]: 0 : if (ret && !mddev->serial_info_pool)
186 : 0 : rdevs_uninit_serial(mddev);
187 : :
188 : 0 : return ret;
189 : : }
190 : :
191 : : /*
192 : : * rdev needs to enable serial stuffs if it meets the conditions:
193 : : * 1. it is multi-queue device flaged with writemostly.
194 : : * 2. the write-behind mode is enabled.
195 : : */
196 : 0 : static int rdev_need_serial(struct md_rdev *rdev)
197 : : {
198 [ # # ]: 0 : return (rdev && rdev->mddev->bitmap_info.max_write_behind > 0 &&
199 [ # # # # : 0 : rdev->bdev->bd_queue->nr_hw_queues != 1 &&
# # ]
200 : 0 : test_bit(WriteMostly, &rdev->flags));
201 : : }
202 : :
203 : : /*
204 : : * Init resource for rdev(s), then create serial_info_pool if:
205 : : * 1. rdev is the first device which return true from rdev_enable_serial.
206 : : * 2. rdev is NULL, means we want to enable serialization for all rdevs.
207 : : */
208 : 0 : void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
209 : : bool is_suspend)
210 : : {
211 : 0 : int ret = 0;
212 : :
213 [ # # # # : 0 : if (rdev && !rdev_need_serial(rdev) &&
# # ]
214 : 0 : !test_bit(CollisionCheck, &rdev->flags))
215 : : return;
216 : :
217 [ # # ]: 0 : if (!is_suspend)
218 : 0 : mddev_suspend(mddev);
219 : :
220 [ # # ]: 0 : if (!rdev)
221 : 0 : ret = rdevs_init_serial(mddev);
222 : : else
223 : 0 : ret = rdev_init_serial(rdev);
224 [ # # ]: 0 : if (ret)
225 : 0 : goto abort;
226 : :
227 [ # # ]: 0 : if (mddev->serial_info_pool == NULL) {
228 : 0 : unsigned int noio_flag;
229 : :
230 : 0 : noio_flag = memalloc_noio_save();
231 : 0 : mddev->serial_info_pool =
232 : : mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
233 : : sizeof(struct serial_info));
234 [ # # ]: 0 : memalloc_noio_restore(noio_flag);
235 [ # # ]: 0 : if (!mddev->serial_info_pool) {
236 : 0 : rdevs_uninit_serial(mddev);
237 : 0 : pr_err("can't alloc memory pool for serialization\n");
238 : : }
239 : : }
240 : :
241 : 0 : abort:
242 [ # # ]: 0 : if (!is_suspend)
243 : 0 : mddev_resume(mddev);
244 : : }
245 : :
246 : : /*
247 : : * Free resource from rdev(s), and destroy serial_info_pool under conditions:
248 : : * 1. rdev is the last device flaged with CollisionCheck.
249 : : * 2. when bitmap is destroyed while policy is not enabled.
250 : : * 3. for disable policy, the pool is destroyed only when no rdev needs it.
251 : : */
252 : 0 : void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
253 : : bool is_suspend)
254 : : {
255 [ # # # # ]: 0 : if (rdev && !test_bit(CollisionCheck, &rdev->flags))
256 : : return;
257 : :
258 [ # # ]: 0 : if (mddev->serial_info_pool) {
259 : 0 : struct md_rdev *temp;
260 : 0 : int num = 0; /* used to track if other rdevs need the pool */
261 : :
262 [ # # ]: 0 : if (!is_suspend)
263 : 0 : mddev_suspend(mddev);
264 [ # # ]: 0 : rdev_for_each(temp, mddev) {
265 [ # # ]: 0 : if (!rdev) {
266 [ # # # # ]: 0 : if (!mddev->serialize_policy ||
267 : 0 : !rdev_need_serial(temp))
268 : 0 : rdev_uninit_serial(temp);
269 : : else
270 : 0 : num++;
271 [ # # # # ]: 0 : } else if (temp != rdev &&
272 : 0 : test_bit(CollisionCheck, &temp->flags))
273 : 0 : num++;
274 : : }
275 : :
276 [ # # ]: 0 : if (rdev)
277 : 0 : rdev_uninit_serial(rdev);
278 : :
279 [ # # ]: 0 : if (num)
280 : 0 : pr_info("The mempool could be used by other devices\n");
281 : : else {
282 : 0 : mempool_destroy(mddev->serial_info_pool);
283 : 0 : mddev->serial_info_pool = NULL;
284 : : }
285 [ # # ]: 0 : if (!is_suspend)
286 : 0 : mddev_resume(mddev);
287 : : }
288 : : }
289 : :
290 : : static struct ctl_table_header *raid_table_header;
291 : :
292 : : static struct ctl_table raid_table[] = {
293 : : {
294 : : .procname = "speed_limit_min",
295 : : .data = &sysctl_speed_limit_min,
296 : : .maxlen = sizeof(int),
297 : : .mode = S_IRUGO|S_IWUSR,
298 : : .proc_handler = proc_dointvec,
299 : : },
300 : : {
301 : : .procname = "speed_limit_max",
302 : : .data = &sysctl_speed_limit_max,
303 : : .maxlen = sizeof(int),
304 : : .mode = S_IRUGO|S_IWUSR,
305 : : .proc_handler = proc_dointvec,
306 : : },
307 : : { }
308 : : };
309 : :
310 : : static struct ctl_table raid_dir_table[] = {
311 : : {
312 : : .procname = "raid",
313 : : .maxlen = 0,
314 : : .mode = S_IRUGO|S_IXUGO,
315 : : .child = raid_table,
316 : : },
317 : : { }
318 : : };
319 : :
320 : : static struct ctl_table raid_root_table[] = {
321 : : {
322 : : .procname = "dev",
323 : : .maxlen = 0,
324 : : .mode = 0555,
325 : : .child = raid_dir_table,
326 : : },
327 : : { }
328 : : };
329 : :
330 : : static const struct block_device_operations md_fops;
331 : :
332 : : static int start_readonly;
333 : :
334 : : /*
335 : : * The original mechanism for creating an md device is to create
336 : : * a device node in /dev and to open it. This causes races with device-close.
337 : : * The preferred method is to write to the "new_array" module parameter.
338 : : * This can avoid races.
339 : : * Setting create_on_open to false disables the original mechanism
340 : : * so all the races disappear.
341 : : */
342 : : static bool create_on_open = true;
343 : :
344 : 0 : struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
345 : : struct mddev *mddev)
346 : : {
347 [ # # # # ]: 0 : if (!mddev || !bioset_initialized(&mddev->bio_set))
348 : 0 : return bio_alloc(gfp_mask, nr_iovecs);
349 : :
350 : 0 : return bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
351 : : }
352 : : EXPORT_SYMBOL_GPL(bio_alloc_mddev);
353 : :
354 : 0 : static struct bio *md_bio_alloc_sync(struct mddev *mddev)
355 : : {
356 [ # # # # ]: 0 : if (!mddev || !bioset_initialized(&mddev->sync_set))
357 : 0 : return bio_alloc(GFP_NOIO, 1);
358 : :
359 : 0 : return bio_alloc_bioset(GFP_NOIO, 1, &mddev->sync_set);
360 : : }
361 : :
362 : : /*
363 : : * We have a system wide 'event count' that is incremented
364 : : * on any 'interesting' event, and readers of /proc/mdstat
365 : : * can use 'poll' or 'select' to find out when the event
366 : : * count increases.
367 : : *
368 : : * Events are:
369 : : * start array, stop array, error, add device, remove device,
370 : : * start build, activate spare
371 : : */
372 : : static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
373 : : static atomic_t md_event_count;
374 : 0 : void md_new_event(struct mddev *mddev)
375 : : {
376 : 0 : atomic_inc(&md_event_count);
377 : 0 : wake_up(&md_event_waiters);
378 : 0 : }
379 : : EXPORT_SYMBOL_GPL(md_new_event);
380 : :
381 : : /*
382 : : * Enables to iterate over all existing md arrays
383 : : * all_mddevs_lock protects this list.
384 : : */
385 : : static LIST_HEAD(all_mddevs);
386 : : static DEFINE_SPINLOCK(all_mddevs_lock);
387 : :
388 : : /*
389 : : * iterates through all used mddevs in the system.
390 : : * We take care to grab the all_mddevs_lock whenever navigating
391 : : * the list, and to always hold a refcount when unlocked.
392 : : * Any code which breaks out of this loop while own
393 : : * a reference to the current mddev and must mddev_put it.
394 : : */
395 : : #define for_each_mddev(_mddev,_tmp) \
396 : : \
397 : : for (({ spin_lock(&all_mddevs_lock); \
398 : : _tmp = all_mddevs.next; \
399 : : _mddev = NULL;}); \
400 : : ({ if (_tmp != &all_mddevs) \
401 : : mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
402 : : spin_unlock(&all_mddevs_lock); \
403 : : if (_mddev) mddev_put(_mddev); \
404 : : _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
405 : : _tmp != &all_mddevs;}); \
406 : : ({ spin_lock(&all_mddevs_lock); \
407 : : _tmp = _tmp->next;}) \
408 : : )
409 : :
410 : : /* Rather than calling directly into the personality make_request function,
411 : : * IO requests come here first so that we can check if the device is
412 : : * being suspended pending a reconfiguration.
413 : : * We hold a refcount over the call to ->make_request. By the time that
414 : : * call has finished, the bio has been linked into some internal structure
415 : : * and so is visible to ->quiesce(), so we don't need the refcount any more.
416 : : */
417 : 0 : static bool is_suspended(struct mddev *mddev, struct bio *bio)
418 : : {
419 : 0 : if (mddev->suspended)
420 : : return true;
421 [ # # # # ]: 0 : if (bio_data_dir(bio) != WRITE)
422 : : return false;
423 [ # # # # ]: 0 : if (mddev->suspend_lo >= mddev->suspend_hi)
424 : : return false;
425 [ # # # # ]: 0 : if (bio->bi_iter.bi_sector >= mddev->suspend_hi)
426 : : return false;
427 [ # # # # ]: 0 : if (bio_end_sector(bio) < mddev->suspend_lo)
428 : : return false;
429 : : return true;
430 : : }
431 : :
432 : 0 : void md_handle_request(struct mddev *mddev, struct bio *bio)
433 : : {
434 : 0 : check_suspended:
435 : 0 : rcu_read_lock();
436 [ # # ]: 0 : if (is_suspended(mddev, bio)) {
437 : 0 : DEFINE_WAIT(__wait);
438 : 0 : for (;;) {
439 : 0 : prepare_to_wait(&mddev->sb_wait, &__wait,
440 : : TASK_UNINTERRUPTIBLE);
441 [ # # ]: 0 : if (!is_suspended(mddev, bio))
442 : : break;
443 : 0 : rcu_read_unlock();
444 : 0 : schedule();
445 : 0 : rcu_read_lock();
446 : : }
447 : 0 : finish_wait(&mddev->sb_wait, &__wait);
448 : : }
449 : 0 : atomic_inc(&mddev->active_io);
450 : 0 : rcu_read_unlock();
451 : :
452 [ # # ]: 0 : if (!mddev->pers->make_request(mddev, bio)) {
453 : 0 : atomic_dec(&mddev->active_io);
454 : 0 : wake_up(&mddev->sb_wait);
455 : 0 : goto check_suspended;
456 : : }
457 : :
458 [ # # # # ]: 0 : if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
459 : 0 : wake_up(&mddev->sb_wait);
460 : 0 : }
461 : : EXPORT_SYMBOL(md_handle_request);
462 : :
463 : 0 : static blk_qc_t md_make_request(struct request_queue *q, struct bio *bio)
464 : : {
465 [ # # ]: 0 : const int rw = bio_data_dir(bio);
466 [ # # ]: 0 : const int sgrp = op_stat_group(bio_op(bio));
467 : 0 : struct mddev *mddev = q->queuedata;
468 : 0 : unsigned int sectors;
469 : :
470 [ # # # # ]: 0 : if (unlikely(test_bit(MD_BROKEN, &mddev->flags)) && (rw == WRITE)) {
471 : 0 : bio_io_error(bio);
472 : 0 : return BLK_QC_T_NONE;
473 : : }
474 : :
475 : 0 : blk_queue_split(q, &bio);
476 : :
477 [ # # # # ]: 0 : if (mddev == NULL || mddev->pers == NULL) {
478 : 0 : bio_io_error(bio);
479 : 0 : return BLK_QC_T_NONE;
480 : : }
481 [ # # # # ]: 0 : if (mddev->ro == 1 && unlikely(rw == WRITE)) {
482 [ # # ]: 0 : if (bio_sectors(bio) != 0)
483 : 0 : bio->bi_status = BLK_STS_IOERR;
484 : 0 : bio_endio(bio);
485 : 0 : return BLK_QC_T_NONE;
486 : : }
487 : :
488 : : /*
489 : : * save the sectors now since our bio can
490 : : * go away inside make_request
491 : : */
492 : 0 : sectors = bio_sectors(bio);
493 : : /* bio could be mergeable after passing to underlayer */
494 : 0 : bio->bi_opf &= ~REQ_NOMERGE;
495 : :
496 : 0 : md_handle_request(mddev, bio);
497 : :
498 [ # # ]: 0 : part_stat_lock();
499 [ # # # # ]: 0 : part_stat_inc(&mddev->gendisk->part0, ios[sgrp]);
500 [ # # # # ]: 0 : part_stat_add(&mddev->gendisk->part0, sectors[sgrp], sectors);
501 : 0 : part_stat_unlock();
502 : :
503 : 0 : return BLK_QC_T_NONE;
504 : : }
505 : :
506 : : /* mddev_suspend makes sure no new requests are submitted
507 : : * to the device, and that any requests that have been submitted
508 : : * are completely handled.
509 : : * Once mddev_detach() is called and completes, the module will be
510 : : * completely unused.
511 : : */
512 : 0 : void mddev_suspend(struct mddev *mddev)
513 : : {
514 [ # # # # : 0 : WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk);
# # ]
515 : 0 : lockdep_assert_held(&mddev->reconfig_mutex);
516 [ # # ]: 0 : if (mddev->suspended++)
517 : : return;
518 : 0 : synchronize_rcu();
519 : 0 : wake_up(&mddev->sb_wait);
520 : 0 : set_bit(MD_ALLOW_SB_UPDATE, &mddev->flags);
521 : 0 : smp_mb__after_atomic();
522 [ # # # # ]: 0 : wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
523 : 0 : mddev->pers->quiesce(mddev, 1);
524 : 0 : clear_bit_unlock(MD_ALLOW_SB_UPDATE, &mddev->flags);
525 [ # # # # ]: 0 : wait_event(mddev->sb_wait, !test_bit(MD_UPDATING_SB, &mddev->flags));
526 : :
527 : 0 : del_timer_sync(&mddev->safemode_timer);
528 : : }
529 : : EXPORT_SYMBOL_GPL(mddev_suspend);
530 : :
531 : 0 : void mddev_resume(struct mddev *mddev)
532 : : {
533 : 0 : lockdep_assert_held(&mddev->reconfig_mutex);
534 [ # # ]: 0 : if (--mddev->suspended)
535 : : return;
536 : 0 : wake_up(&mddev->sb_wait);
537 : 0 : mddev->pers->quiesce(mddev, 0);
538 : :
539 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
540 : 0 : md_wakeup_thread(mddev->thread);
541 : 0 : md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
542 : : }
543 : : EXPORT_SYMBOL_GPL(mddev_resume);
544 : :
545 : 0 : int mddev_congested(struct mddev *mddev, int bits)
546 : : {
547 : 0 : struct md_personality *pers = mddev->pers;
548 : 0 : int ret = 0;
549 : :
550 : 0 : rcu_read_lock();
551 [ # # # # ]: 0 : if (mddev->suspended)
552 : : ret = 1;
553 [ # # # # : 0 : else if (pers && pers->congested)
# # # # ]
554 : 0 : ret = pers->congested(mddev, bits);
555 : 0 : rcu_read_unlock();
556 : 0 : return ret;
557 : : }
558 : : EXPORT_SYMBOL_GPL(mddev_congested);
559 : 0 : static int md_congested(void *data, int bits)
560 : : {
561 : 0 : struct mddev *mddev = data;
562 : 0 : return mddev_congested(mddev, bits);
563 : : }
564 : :
565 : : /*
566 : : * Generic flush handling for md
567 : : */
568 : :
569 : 0 : static void md_end_flush(struct bio *bio)
570 : : {
571 : 0 : struct md_rdev *rdev = bio->bi_private;
572 : 0 : struct mddev *mddev = rdev->mddev;
573 : :
574 : 0 : rdev_dec_pending(rdev, mddev);
575 : :
576 [ # # ]: 0 : if (atomic_dec_and_test(&mddev->flush_pending)) {
577 : : /* The pre-request flush has finished */
578 : 0 : queue_work(md_wq, &mddev->flush_work);
579 : : }
580 : 0 : bio_put(bio);
581 : 0 : }
582 : :
583 : : static void md_submit_flush_data(struct work_struct *ws);
584 : :
585 : 0 : static void submit_flushes(struct work_struct *ws)
586 : : {
587 : 0 : struct mddev *mddev = container_of(ws, struct mddev, flush_work);
588 : 0 : struct md_rdev *rdev;
589 : :
590 : 0 : mddev->start_flush = ktime_get_boottime();
591 : 0 : INIT_WORK(&mddev->flush_work, md_submit_flush_data);
592 : 0 : atomic_set(&mddev->flush_pending, 1);
593 : 0 : rcu_read_lock();
594 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev)
595 [ # # # # ]: 0 : if (rdev->raid_disk >= 0 &&
596 : 0 : !test_bit(Faulty, &rdev->flags)) {
597 : : /* Take two references, one is dropped
598 : : * when request finishes, one after
599 : : * we reclaim rcu_read_lock
600 : : */
601 : 0 : struct bio *bi;
602 : 0 : atomic_inc(&rdev->nr_pending);
603 : 0 : atomic_inc(&rdev->nr_pending);
604 : 0 : rcu_read_unlock();
605 : 0 : bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
606 : 0 : bi->bi_end_io = md_end_flush;
607 : 0 : bi->bi_private = rdev;
608 [ # # ]: 0 : bio_set_dev(bi, rdev->bdev);
609 : 0 : bi->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
610 : 0 : atomic_inc(&mddev->flush_pending);
611 : 0 : submit_bio(bi);
612 : 0 : rcu_read_lock();
613 : 0 : rdev_dec_pending(rdev, mddev);
614 : : }
615 : 0 : rcu_read_unlock();
616 [ # # ]: 0 : if (atomic_dec_and_test(&mddev->flush_pending))
617 : 0 : queue_work(md_wq, &mddev->flush_work);
618 : 0 : }
619 : :
620 : 0 : static void md_submit_flush_data(struct work_struct *ws)
621 : : {
622 : 0 : struct mddev *mddev = container_of(ws, struct mddev, flush_work);
623 : 0 : struct bio *bio = mddev->flush_bio;
624 : :
625 : : /*
626 : : * must reset flush_bio before calling into md_handle_request to avoid a
627 : : * deadlock, because other bios passed md_handle_request suspend check
628 : : * could wait for this and below md_handle_request could wait for those
629 : : * bios because of suspend check
630 : : */
631 : 0 : mddev->last_flush = mddev->start_flush;
632 : 0 : mddev->flush_bio = NULL;
633 : 0 : wake_up(&mddev->sb_wait);
634 : :
635 [ # # ]: 0 : if (bio->bi_iter.bi_size == 0) {
636 : : /* an empty barrier - all done */
637 : 0 : bio_endio(bio);
638 : : } else {
639 : 0 : bio->bi_opf &= ~REQ_PREFLUSH;
640 : 0 : md_handle_request(mddev, bio);
641 : : }
642 : 0 : }
643 : :
644 : : /*
645 : : * Manages consolidation of flushes and submitting any flushes needed for
646 : : * a bio with REQ_PREFLUSH. Returns true if the bio is finished or is
647 : : * being finished in another context. Returns false if the flushing is
648 : : * complete but still needs the I/O portion of the bio to be processed.
649 : : */
650 : 0 : bool md_flush_request(struct mddev *mddev, struct bio *bio)
651 : : {
652 : 0 : ktime_t start = ktime_get_boottime();
653 : 0 : spin_lock_irq(&mddev->lock);
654 [ # # # # : 0 : wait_event_lock_irq(mddev->sb_wait,
# # # # ]
655 : : !mddev->flush_bio ||
656 : : ktime_after(mddev->last_flush, start),
657 : : mddev->lock);
658 [ # # ]: 0 : if (!ktime_after(mddev->last_flush, start)) {
659 [ # # ]: 0 : WARN_ON(mddev->flush_bio);
660 : 0 : mddev->flush_bio = bio;
661 : 0 : bio = NULL;
662 : : }
663 : 0 : spin_unlock_irq(&mddev->lock);
664 : :
665 [ # # ]: 0 : if (!bio) {
666 : 0 : INIT_WORK(&mddev->flush_work, submit_flushes);
667 : 0 : queue_work(md_wq, &mddev->flush_work);
668 : : } else {
669 : : /* flush was performed for some other bio while we waited. */
670 [ # # ]: 0 : if (bio->bi_iter.bi_size == 0)
671 : : /* an empty barrier - all done */
672 : 0 : bio_endio(bio);
673 : : else {
674 : 0 : bio->bi_opf &= ~REQ_PREFLUSH;
675 : 0 : return false;
676 : : }
677 : : }
678 : : return true;
679 : : }
680 : : EXPORT_SYMBOL(md_flush_request);
681 : :
682 : 39 : static inline struct mddev *mddev_get(struct mddev *mddev)
683 : : {
684 : 39 : atomic_inc(&mddev->active);
685 : 0 : return mddev;
686 : : }
687 : :
688 : : static void mddev_delayed_delete(struct work_struct *ws);
689 : :
690 : 52 : static void mddev_put(struct mddev *mddev)
691 : : {
692 [ + - ]: 52 : if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
693 : : return;
694 [ + - + - ]: 52 : if (!mddev->raid_disks && list_empty(&mddev->disks) &&
695 [ + - - + ]: 52 : mddev->ctime == 0 && !mddev->hold_active) {
696 : : /* Array is not configured at all, and not held active,
697 : : * so destroy it */
698 : 0 : list_del_init(&mddev->all_mddevs);
699 : :
700 : : /*
701 : : * Call queue_work inside the spinlock so that
702 : : * flush_workqueue() after mddev_find will succeed in waiting
703 : : * for the work to be done.
704 : : */
705 : 0 : INIT_WORK(&mddev->del_work, mddev_delayed_delete);
706 : 0 : queue_work(md_misc_wq, &mddev->del_work);
707 : : }
708 : 52 : spin_unlock(&all_mddevs_lock);
709 : : }
710 : :
711 : : static void md_safemode_timeout(struct timer_list *t);
712 : :
713 : 13 : void mddev_init(struct mddev *mddev)
714 : : {
715 : 13 : kobject_init(&mddev->kobj, &md_ktype);
716 : 13 : mutex_init(&mddev->open_mutex);
717 : 13 : mutex_init(&mddev->reconfig_mutex);
718 : 13 : mutex_init(&mddev->bitmap_info.mutex);
719 : 13 : INIT_LIST_HEAD(&mddev->disks);
720 : 13 : INIT_LIST_HEAD(&mddev->all_mddevs);
721 : 13 : timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0);
722 : 13 : atomic_set(&mddev->active, 1);
723 : 13 : atomic_set(&mddev->openers, 0);
724 : 13 : atomic_set(&mddev->active_io, 0);
725 : 13 : spin_lock_init(&mddev->lock);
726 : 13 : atomic_set(&mddev->flush_pending, 0);
727 : 13 : init_waitqueue_head(&mddev->sb_wait);
728 : 13 : init_waitqueue_head(&mddev->recovery_wait);
729 : 13 : mddev->reshape_position = MaxSector;
730 : 13 : mddev->reshape_backwards = 0;
731 : 13 : mddev->last_sync_action = "none";
732 : 13 : mddev->resync_min = 0;
733 : 13 : mddev->resync_max = MaxSector;
734 : 13 : mddev->level = LEVEL_NONE;
735 : 13 : }
736 : : EXPORT_SYMBOL_GPL(mddev_init);
737 : :
738 : 26 : static struct mddev *mddev_find(dev_t unit)
739 : : {
740 : 26 : struct mddev *mddev, *new = NULL;
741 : :
742 [ - + + - ]: 26 : if (unit && MAJOR(unit) != MD_MAJOR)
743 : 0 : unit &= ~((1<<MdpMinorShift)-1);
744 : :
745 : 26 : retry:
746 : 39 : spin_lock(&all_mddevs_lock);
747 : :
748 [ + - ]: 39 : if (unit) {
749 [ + + ]: 39 : list_for_each_entry(mddev, &all_mddevs, all_mddevs)
750 [ + - ]: 13 : if (mddev->unit == unit) {
751 : 13 : mddev_get(mddev);
752 : 13 : spin_unlock(&all_mddevs_lock);
753 : 13 : kfree(new);
754 : 13 : return mddev;
755 : : }
756 : :
757 [ + + ]: 26 : if (new) {
758 : 13 : list_add(&new->all_mddevs, &all_mddevs);
759 : 13 : spin_unlock(&all_mddevs_lock);
760 : 13 : new->hold_active = UNTIL_IOCTL;
761 : 13 : return new;
762 : : }
763 [ # # ]: 0 : } else if (new) {
764 : : /* find an unused unit number */
765 : 0 : static int next_minor = 512;
766 : 0 : int start = next_minor;
767 : 0 : int is_free = 0;
768 : 0 : int dev = 0;
769 [ # # ]: 0 : while (!is_free) {
770 : 0 : dev = MKDEV(MD_MAJOR, next_minor);
771 : 0 : next_minor++;
772 [ # # ]: 0 : if (next_minor > MINORMASK)
773 : 0 : next_minor = 0;
774 [ # # ]: 0 : if (next_minor == start) {
775 : : /* Oh dear, all in use. */
776 : 0 : spin_unlock(&all_mddevs_lock);
777 : 0 : kfree(new);
778 : 0 : return NULL;
779 : : }
780 : :
781 : 0 : is_free = 1;
782 [ # # ]: 0 : list_for_each_entry(mddev, &all_mddevs, all_mddevs)
783 [ # # ]: 0 : if (mddev->unit == dev) {
784 : : is_free = 0;
785 : : break;
786 : : }
787 : : }
788 : 0 : new->unit = dev;
789 : 0 : new->md_minor = MINOR(dev);
790 : 0 : new->hold_active = UNTIL_STOP;
791 : 0 : list_add(&new->all_mddevs, &all_mddevs);
792 : 0 : spin_unlock(&all_mddevs_lock);
793 : 0 : return new;
794 : : }
795 : 13 : spin_unlock(&all_mddevs_lock);
796 : :
797 : 13 : new = kzalloc(sizeof(*new), GFP_KERNEL);
798 [ + - ]: 13 : if (!new)
799 : : return NULL;
800 : :
801 : 13 : new->unit = unit;
802 [ + - ]: 13 : if (MAJOR(unit) == MD_MAJOR)
803 : 13 : new->md_minor = MINOR(unit);
804 : : else
805 : 0 : new->md_minor = MINOR(unit) >> MdpMinorShift;
806 : :
807 : 13 : mddev_init(new);
808 : :
809 : 13 : goto retry;
810 : : }
811 : :
812 : : static struct attribute_group md_redundancy_group;
813 : :
814 : 0 : void mddev_unlock(struct mddev *mddev)
815 : : {
816 [ # # ]: 0 : if (mddev->to_remove) {
817 : : /* These cannot be removed under reconfig_mutex as
818 : : * an access to the files will try to take reconfig_mutex
819 : : * while holding the file unremovable, which leads to
820 : : * a deadlock.
821 : : * So hold set sysfs_active while the remove in happeing,
822 : : * and anything else which might set ->to_remove or my
823 : : * otherwise change the sysfs namespace will fail with
824 : : * -EBUSY if sysfs_active is still set.
825 : : * We set sysfs_active under reconfig_mutex and elsewhere
826 : : * test it under the same mutex to ensure its correct value
827 : : * is seen.
828 : : */
829 : 0 : struct attribute_group *to_remove = mddev->to_remove;
830 : 0 : mddev->to_remove = NULL;
831 : 0 : mddev->sysfs_active = 1;
832 : 0 : mutex_unlock(&mddev->reconfig_mutex);
833 : :
834 [ # # ]: 0 : if (mddev->kobj.sd) {
835 [ # # ]: 0 : if (to_remove != &md_redundancy_group)
836 : 0 : sysfs_remove_group(&mddev->kobj, to_remove);
837 [ # # ]: 0 : if (mddev->pers == NULL ||
838 [ # # ]: 0 : mddev->pers->sync_request == NULL) {
839 : 0 : sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
840 [ # # ]: 0 : if (mddev->sysfs_action)
841 : 0 : sysfs_put(mddev->sysfs_action);
842 : 0 : mddev->sysfs_action = NULL;
843 : : }
844 : : }
845 : 0 : mddev->sysfs_active = 0;
846 : : } else
847 : 0 : mutex_unlock(&mddev->reconfig_mutex);
848 : :
849 : : /* As we've dropped the mutex we need a spinlock to
850 : : * make sure the thread doesn't disappear
851 : : */
852 : 0 : spin_lock(&pers_lock);
853 : 0 : md_wakeup_thread(mddev->thread);
854 : 0 : wake_up(&mddev->sb_wait);
855 : 0 : spin_unlock(&pers_lock);
856 : 0 : }
857 : : EXPORT_SYMBOL_GPL(mddev_unlock);
858 : :
859 : 0 : struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
860 : : {
861 : 0 : struct md_rdev *rdev;
862 : :
863 [ # # # # : 0 : rdev_for_each_rcu(rdev, mddev)
# # # # ]
864 [ # # # # : 0 : if (rdev->desc_nr == nr)
# # # # ]
865 : 0 : return rdev;
866 : :
867 : : return NULL;
868 : : }
869 : : EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
870 : :
871 : 0 : static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
872 : : {
873 : 0 : struct md_rdev *rdev;
874 : :
875 [ # # # # ]: 0 : rdev_for_each(rdev, mddev)
876 [ # # # # ]: 0 : if (rdev->bdev->bd_dev == dev)
877 : : return rdev;
878 : :
879 : : return NULL;
880 : : }
881 : :
882 : 0 : struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev)
883 : : {
884 : 0 : struct md_rdev *rdev;
885 : :
886 [ # # # # ]: 0 : rdev_for_each_rcu(rdev, mddev)
887 [ # # # # ]: 0 : if (rdev->bdev->bd_dev == dev)
888 : 0 : return rdev;
889 : :
890 : : return NULL;
891 : : }
892 : : EXPORT_SYMBOL_GPL(md_find_rdev_rcu);
893 : :
894 : 0 : static struct md_personality *find_pers(int level, char *clevel)
895 : : {
896 : 0 : struct md_personality *pers;
897 [ # # ]: 0 : list_for_each_entry(pers, &pers_list, list) {
898 [ # # # # ]: 0 : if (level != LEVEL_NONE && pers->level == level)
899 : 0 : return pers;
900 [ # # ]: 0 : if (strcmp(pers->name, clevel)==0)
901 : 0 : return pers;
902 : : }
903 : : return NULL;
904 : : }
905 : :
906 : : /* return the offset of the super block in 512byte sectors */
907 : 0 : static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
908 : : {
909 : 0 : sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
910 : 0 : return MD_NEW_SIZE_SECTORS(num_sectors);
911 : : }
912 : :
913 : 0 : static int alloc_disk_sb(struct md_rdev *rdev)
914 : : {
915 : 0 : rdev->sb_page = alloc_page(GFP_KERNEL);
916 [ # # # # ]: 0 : if (!rdev->sb_page)
917 : 0 : return -ENOMEM;
918 : : return 0;
919 : : }
920 : :
921 : 0 : void md_rdev_clear(struct md_rdev *rdev)
922 : : {
923 [ # # ]: 0 : if (rdev->sb_page) {
924 : 0 : put_page(rdev->sb_page);
925 : 0 : rdev->sb_loaded = 0;
926 : 0 : rdev->sb_page = NULL;
927 : 0 : rdev->sb_start = 0;
928 : 0 : rdev->sectors = 0;
929 : : }
930 [ # # ]: 0 : if (rdev->bb_page) {
931 : 0 : put_page(rdev->bb_page);
932 : 0 : rdev->bb_page = NULL;
933 : : }
934 : 0 : badblocks_exit(&rdev->badblocks);
935 : 0 : }
936 : : EXPORT_SYMBOL_GPL(md_rdev_clear);
937 : :
938 : 0 : static void super_written(struct bio *bio)
939 : : {
940 : 0 : struct md_rdev *rdev = bio->bi_private;
941 : 0 : struct mddev *mddev = rdev->mddev;
942 : :
943 [ # # ]: 0 : if (bio->bi_status) {
944 : 0 : pr_err("md: super_written gets error=%d\n", bio->bi_status);
945 : 0 : md_error(mddev, rdev);
946 [ # # ]: 0 : if (!test_bit(Faulty, &rdev->flags)
947 [ # # ]: 0 : && (bio->bi_opf & MD_FAILFAST)) {
948 : 0 : set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags);
949 : 0 : set_bit(LastDev, &rdev->flags);
950 : : }
951 : : } else
952 : 0 : clear_bit(LastDev, &rdev->flags);
953 : :
954 [ # # ]: 0 : if (atomic_dec_and_test(&mddev->pending_writes))
955 : 0 : wake_up(&mddev->sb_wait);
956 : 0 : rdev_dec_pending(rdev, mddev);
957 : 0 : bio_put(bio);
958 : 0 : }
959 : :
960 : 0 : void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
961 : : sector_t sector, int size, struct page *page)
962 : : {
963 : : /* write first size bytes of page to sector of rdev
964 : : * Increment mddev->pending_writes before returning
965 : : * and decrement it on completion, waking up sb_wait
966 : : * if zero is reached.
967 : : * If an error occurred, call md_error
968 : : */
969 : 0 : struct bio *bio;
970 : 0 : int ff = 0;
971 : :
972 [ # # ]: 0 : if (!page)
973 : : return;
974 : :
975 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
976 : : return;
977 : :
978 : 0 : bio = md_bio_alloc_sync(mddev);
979 : :
980 : 0 : atomic_inc(&rdev->nr_pending);
981 : :
982 [ # # # # : 0 : bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev);
# # # # ]
983 : 0 : bio->bi_iter.bi_sector = sector;
984 : 0 : bio_add_page(bio, page, size, 0);
985 : 0 : bio->bi_private = rdev;
986 : 0 : bio->bi_end_io = super_written;
987 : :
988 [ # # # # ]: 0 : if (test_bit(MD_FAILFAST_SUPPORTED, &mddev->flags) &&
989 [ # # ]: 0 : test_bit(FailFast, &rdev->flags) &&
990 : : !test_bit(LastDev, &rdev->flags))
991 : 0 : ff = MD_FAILFAST;
992 : 0 : bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA | ff;
993 : :
994 : 0 : atomic_inc(&mddev->pending_writes);
995 : 0 : submit_bio(bio);
996 : : }
997 : :
998 : 0 : int md_super_wait(struct mddev *mddev)
999 : : {
1000 : : /* wait for all superblock writes that were scheduled to complete */
1001 [ # # # # ]: 0 : wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
1002 [ # # ]: 0 : if (test_and_clear_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags))
1003 : 0 : return -EAGAIN;
1004 : : return 0;
1005 : : }
1006 : :
1007 : 0 : int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
1008 : : struct page *page, int op, int op_flags, bool metadata_op)
1009 : : {
1010 : 0 : struct bio *bio = md_bio_alloc_sync(rdev->mddev);
1011 : 0 : int ret;
1012 : :
1013 [ # # # # ]: 0 : if (metadata_op && rdev->meta_bdev)
1014 [ # # ]: 0 : bio_set_dev(bio, rdev->meta_bdev);
1015 : : else
1016 [ # # ]: 0 : bio_set_dev(bio, rdev->bdev);
1017 [ # # ]: 0 : bio_set_op_attrs(bio, op, op_flags);
1018 [ # # ]: 0 : if (metadata_op)
1019 : 0 : bio->bi_iter.bi_sector = sector + rdev->sb_start;
1020 [ # # ]: 0 : else if (rdev->mddev->reshape_position != MaxSector &&
1021 : 0 : (rdev->mddev->reshape_backwards ==
1022 [ # # ]: 0 : (sector >= rdev->mddev->reshape_position)))
1023 : 0 : bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
1024 : : else
1025 : 0 : bio->bi_iter.bi_sector = sector + rdev->data_offset;
1026 : 0 : bio_add_page(bio, page, size, 0);
1027 : :
1028 : 0 : submit_bio_wait(bio);
1029 : :
1030 : 0 : ret = !bio->bi_status;
1031 : 0 : bio_put(bio);
1032 : 0 : return ret;
1033 : : }
1034 : : EXPORT_SYMBOL_GPL(sync_page_io);
1035 : :
1036 : 0 : static int read_disk_sb(struct md_rdev *rdev, int size)
1037 : : {
1038 : 0 : char b[BDEVNAME_SIZE];
1039 : :
1040 [ # # ]: 0 : if (rdev->sb_loaded)
1041 : : return 0;
1042 : :
1043 [ # # ]: 0 : if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true))
1044 : 0 : goto fail;
1045 : 0 : rdev->sb_loaded = 1;
1046 : 0 : return 0;
1047 : :
1048 : : fail:
1049 : 0 : pr_err("md: disabled device %s, could not read superblock.\n",
1050 : : bdevname(rdev->bdev,b));
1051 : 0 : return -EINVAL;
1052 : : }
1053 : :
1054 : 0 : static int md_uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
1055 : : {
1056 : 0 : return sb1->set_uuid0 == sb2->set_uuid0 &&
1057 [ # # ]: 0 : sb1->set_uuid1 == sb2->set_uuid1 &&
1058 [ # # ]: 0 : sb1->set_uuid2 == sb2->set_uuid2 &&
1059 : : sb1->set_uuid3 == sb2->set_uuid3;
1060 : : }
1061 : :
1062 : 0 : static int md_sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
1063 : : {
1064 : 0 : int ret;
1065 : 0 : mdp_super_t *tmp1, *tmp2;
1066 : :
1067 : 0 : tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
1068 : 0 : tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
1069 : :
1070 [ # # ]: 0 : if (!tmp1 || !tmp2) {
1071 : 0 : ret = 0;
1072 : 0 : goto abort;
1073 : : }
1074 : :
1075 : 0 : *tmp1 = *sb1;
1076 : 0 : *tmp2 = *sb2;
1077 : :
1078 : : /*
1079 : : * nr_disks is not constant
1080 : : */
1081 : 0 : tmp1->nr_disks = 0;
1082 : 0 : tmp2->nr_disks = 0;
1083 : :
1084 : 0 : ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
1085 : 0 : abort:
1086 : 0 : kfree(tmp1);
1087 : 0 : kfree(tmp2);
1088 : 0 : return ret;
1089 : : }
1090 : :
1091 : 0 : static u32 md_csum_fold(u32 csum)
1092 : : {
1093 : 0 : csum = (csum & 0xffff) + (csum >> 16);
1094 : 0 : return (csum & 0xffff) + (csum >> 16);
1095 : : }
1096 : :
1097 : 0 : static unsigned int calc_sb_csum(mdp_super_t *sb)
1098 : : {
1099 : 0 : u64 newcsum = 0;
1100 : 0 : u32 *sb32 = (u32*)sb;
1101 : 0 : int i;
1102 : 0 : unsigned int disk_csum, csum;
1103 : :
1104 : 0 : disk_csum = sb->sb_csum;
1105 : 0 : sb->sb_csum = 0;
1106 : :
1107 [ # # # # ]: 0 : for (i = 0; i < MD_SB_BYTES/4 ; i++)
1108 : 0 : newcsum += sb32[i];
1109 : 0 : csum = (newcsum & 0xffffffff) + (newcsum>>32);
1110 : :
1111 : : #ifdef CONFIG_ALPHA
1112 : : /* This used to use csum_partial, which was wrong for several
1113 : : * reasons including that different results are returned on
1114 : : * different architectures. It isn't critical that we get exactly
1115 : : * the same return value as before (we always csum_fold before
1116 : : * testing, and that removes any differences). However as we
1117 : : * know that csum_partial always returned a 16bit value on
1118 : : * alphas, do a fold to maximise conformity to previous behaviour.
1119 : : */
1120 : : sb->sb_csum = md_csum_fold(disk_csum);
1121 : : #else
1122 : 0 : sb->sb_csum = disk_csum;
1123 : : #endif
1124 : 0 : return csum;
1125 : : }
1126 : :
1127 : : /*
1128 : : * Handle superblock details.
1129 : : * We want to be able to handle multiple superblock formats
1130 : : * so we have a common interface to them all, and an array of
1131 : : * different handlers.
1132 : : * We rely on user-space to write the initial superblock, and support
1133 : : * reading and updating of superblocks.
1134 : : * Interface methods are:
1135 : : * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
1136 : : * loads and validates a superblock on dev.
1137 : : * if refdev != NULL, compare superblocks on both devices
1138 : : * Return:
1139 : : * 0 - dev has a superblock that is compatible with refdev
1140 : : * 1 - dev has a superblock that is compatible and newer than refdev
1141 : : * so dev should be used as the refdev in future
1142 : : * -EINVAL superblock incompatible or invalid
1143 : : * -othererror e.g. -EIO
1144 : : *
1145 : : * int validate_super(struct mddev *mddev, struct md_rdev *dev)
1146 : : * Verify that dev is acceptable into mddev.
1147 : : * The first time, mddev->raid_disks will be 0, and data from
1148 : : * dev should be merged in. Subsequent calls check that dev
1149 : : * is new enough. Return 0 or -EINVAL
1150 : : *
1151 : : * void sync_super(struct mddev *mddev, struct md_rdev *dev)
1152 : : * Update the superblock for rdev with data in mddev
1153 : : * This does not write to disc.
1154 : : *
1155 : : */
1156 : :
1157 : : struct super_type {
1158 : : char *name;
1159 : : struct module *owner;
1160 : : int (*load_super)(struct md_rdev *rdev,
1161 : : struct md_rdev *refdev,
1162 : : int minor_version);
1163 : : int (*validate_super)(struct mddev *mddev,
1164 : : struct md_rdev *rdev);
1165 : : void (*sync_super)(struct mddev *mddev,
1166 : : struct md_rdev *rdev);
1167 : : unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
1168 : : sector_t num_sectors);
1169 : : int (*allow_new_offset)(struct md_rdev *rdev,
1170 : : unsigned long long new_offset);
1171 : : };
1172 : :
1173 : : /*
1174 : : * Check that the given mddev has no bitmap.
1175 : : *
1176 : : * This function is called from the run method of all personalities that do not
1177 : : * support bitmaps. It prints an error message and returns non-zero if mddev
1178 : : * has a bitmap. Otherwise, it returns 0.
1179 : : *
1180 : : */
1181 : 0 : int md_check_no_bitmap(struct mddev *mddev)
1182 : : {
1183 [ # # # # ]: 0 : if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
1184 : : return 0;
1185 [ # # ]: 0 : pr_warn("%s: bitmaps are not supported for %s\n",
1186 : : mdname(mddev), mddev->pers->name);
1187 : 0 : return 1;
1188 : : }
1189 : : EXPORT_SYMBOL(md_check_no_bitmap);
1190 : :
1191 : : /*
1192 : : * load_super for 0.90.0
1193 : : */
1194 : 0 : static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1195 : : {
1196 : 0 : char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1197 : 0 : mdp_super_t *sb;
1198 : 0 : int ret;
1199 : 0 : bool spare_disk = true;
1200 : :
1201 : : /*
1202 : : * Calculate the position of the superblock (512byte sectors),
1203 : : * it's at the end of the disk.
1204 : : *
1205 : : * It also happens to be a multiple of 4Kb.
1206 : : */
1207 : 0 : rdev->sb_start = calc_dev_sboffset(rdev);
1208 : :
1209 : 0 : ret = read_disk_sb(rdev, MD_SB_BYTES);
1210 [ # # ]: 0 : if (ret)
1211 : : return ret;
1212 : :
1213 : 0 : ret = -EINVAL;
1214 : :
1215 : 0 : bdevname(rdev->bdev, b);
1216 [ # # ]: 0 : sb = page_address(rdev->sb_page);
1217 : :
1218 [ # # ]: 0 : if (sb->md_magic != MD_SB_MAGIC) {
1219 : 0 : pr_warn("md: invalid raid superblock magic on %s\n", b);
1220 : 0 : goto abort;
1221 : : }
1222 : :
1223 [ # # ]: 0 : if (sb->major_version != 0 ||
1224 [ # # # # ]: 0 : sb->minor_version < 90 ||
1225 : : sb->minor_version > 91) {
1226 : 0 : pr_warn("Bad version number %d.%d on %s\n",
1227 : : sb->major_version, sb->minor_version, b);
1228 : 0 : goto abort;
1229 : : }
1230 : :
1231 [ # # ]: 0 : if (sb->raid_disks <= 0)
1232 : 0 : goto abort;
1233 : :
1234 [ # # ]: 0 : if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
1235 : 0 : pr_warn("md: invalid superblock checksum on %s\n", b);
1236 : 0 : goto abort;
1237 : : }
1238 : :
1239 : 0 : rdev->preferred_minor = sb->md_minor;
1240 : 0 : rdev->data_offset = 0;
1241 : 0 : rdev->new_data_offset = 0;
1242 : 0 : rdev->sb_size = MD_SB_BYTES;
1243 : 0 : rdev->badblocks.shift = -1;
1244 : :
1245 [ # # ]: 0 : if (sb->level == LEVEL_MULTIPATH)
1246 : 0 : rdev->desc_nr = -1;
1247 : : else
1248 : 0 : rdev->desc_nr = sb->this_disk.number;
1249 : :
1250 : : /* not spare disk, or LEVEL_MULTIPATH */
1251 [ # # ]: 0 : if (sb->level == LEVEL_MULTIPATH ||
1252 [ # # ]: 0 : (rdev->desc_nr >= 0 &&
1253 : 0 : rdev->desc_nr < MD_SB_DISKS &&
1254 [ # # ]: 0 : sb->disks[rdev->desc_nr].state &
1255 : : ((1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE))))
1256 : 0 : spare_disk = false;
1257 : :
1258 [ # # ]: 0 : if (!refdev) {
1259 [ # # ]: 0 : if (!spare_disk)
1260 : : ret = 1;
1261 : : else
1262 : 0 : ret = 0;
1263 : : } else {
1264 : 0 : __u64 ev1, ev2;
1265 [ # # ]: 0 : mdp_super_t *refsb = page_address(refdev->sb_page);
1266 [ # # ]: 0 : if (!md_uuid_equal(refsb, sb)) {
1267 : 0 : pr_warn("md: %s has different UUID to %s\n",
1268 : : b, bdevname(refdev->bdev,b2));
1269 : 0 : goto abort;
1270 : : }
1271 [ # # ]: 0 : if (!md_sb_equal(refsb, sb)) {
1272 : 0 : pr_warn("md: %s has same UUID but different superblock to %s\n",
1273 : : b, bdevname(refdev->bdev, b2));
1274 : 0 : goto abort;
1275 : : }
1276 [ # # ]: 0 : ev1 = md_event(sb);
1277 : 0 : ev2 = md_event(refsb);
1278 : :
1279 [ # # ]: 0 : if (!spare_disk && ev1 > ev2)
1280 : : ret = 1;
1281 : : else
1282 : 0 : ret = 0;
1283 : : }
1284 : 0 : rdev->sectors = rdev->sb_start;
1285 : : /* Limit to 4TB as metadata cannot record more than that.
1286 : : * (not needed for Linear and RAID0 as metadata doesn't
1287 : : * record this size)
1288 : : */
1289 [ # # # # ]: 0 : if ((u64)rdev->sectors >= (2ULL << 32) && sb->level >= 1)
1290 : 0 : rdev->sectors = (sector_t)(2ULL << 32) - 2;
1291 : :
1292 [ # # # # ]: 0 : if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1293 : : /* "this cannot possibly happen" ... */
1294 : 0 : ret = -EINVAL;
1295 : :
1296 : 0 : abort:
1297 : : return ret;
1298 : : }
1299 : :
1300 : : /*
1301 : : * validate_super for 0.90.0
1302 : : */
1303 : 0 : static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
1304 : : {
1305 : 0 : mdp_disk_t *desc;
1306 : 0 : mdp_super_t *sb = page_address(rdev->sb_page);
1307 : 0 : __u64 ev1 = md_event(sb);
1308 : :
1309 : 0 : rdev->raid_disk = -1;
1310 : 0 : clear_bit(Faulty, &rdev->flags);
1311 : 0 : clear_bit(In_sync, &rdev->flags);
1312 : 0 : clear_bit(Bitmap_sync, &rdev->flags);
1313 : 0 : clear_bit(WriteMostly, &rdev->flags);
1314 : :
1315 [ # # ]: 0 : if (mddev->raid_disks == 0) {
1316 : 0 : mddev->major_version = 0;
1317 : 0 : mddev->minor_version = sb->minor_version;
1318 : 0 : mddev->patch_version = sb->patch_version;
1319 : 0 : mddev->external = 0;
1320 : 0 : mddev->chunk_sectors = sb->chunk_size >> 9;
1321 : 0 : mddev->ctime = sb->ctime;
1322 : 0 : mddev->utime = sb->utime;
1323 : 0 : mddev->level = sb->level;
1324 : 0 : mddev->clevel[0] = 0;
1325 : 0 : mddev->layout = sb->layout;
1326 : 0 : mddev->raid_disks = sb->raid_disks;
1327 : 0 : mddev->dev_sectors = ((sector_t)sb->size) * 2;
1328 : 0 : mddev->events = ev1;
1329 : 0 : mddev->bitmap_info.offset = 0;
1330 : 0 : mddev->bitmap_info.space = 0;
1331 : : /* bitmap can use 60 K after the 4K superblocks */
1332 : 0 : mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1333 : 0 : mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
1334 : 0 : mddev->reshape_backwards = 0;
1335 : :
1336 [ # # ]: 0 : if (mddev->minor_version >= 91) {
1337 : 0 : mddev->reshape_position = sb->reshape_position;
1338 : 0 : mddev->delta_disks = sb->delta_disks;
1339 : 0 : mddev->new_level = sb->new_level;
1340 : 0 : mddev->new_layout = sb->new_layout;
1341 : 0 : mddev->new_chunk_sectors = sb->new_chunk >> 9;
1342 [ # # ]: 0 : if (mddev->delta_disks < 0)
1343 : 0 : mddev->reshape_backwards = 1;
1344 : : } else {
1345 : 0 : mddev->reshape_position = MaxSector;
1346 : 0 : mddev->delta_disks = 0;
1347 : 0 : mddev->new_level = mddev->level;
1348 : 0 : mddev->new_layout = mddev->layout;
1349 : 0 : mddev->new_chunk_sectors = mddev->chunk_sectors;
1350 : : }
1351 [ # # ]: 0 : if (mddev->level == 0)
1352 : 0 : mddev->layout = -1;
1353 : :
1354 [ # # ]: 0 : if (sb->state & (1<<MD_SB_CLEAN))
1355 : 0 : mddev->recovery_cp = MaxSector;
1356 : : else {
1357 [ # # ]: 0 : if (sb->events_hi == sb->cp_events_hi &&
1358 [ # # ]: 0 : sb->events_lo == sb->cp_events_lo) {
1359 : 0 : mddev->recovery_cp = sb->recovery_cp;
1360 : : } else
1361 : 0 : mddev->recovery_cp = 0;
1362 : : }
1363 : :
1364 : 0 : memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1365 : 0 : memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1366 : 0 : memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1367 : 0 : memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1368 : :
1369 : 0 : mddev->max_disks = MD_SB_DISKS;
1370 : :
1371 [ # # ]: 0 : if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1372 [ # # ]: 0 : mddev->bitmap_info.file == NULL) {
1373 : 0 : mddev->bitmap_info.offset =
1374 : : mddev->bitmap_info.default_offset;
1375 : 0 : mddev->bitmap_info.space =
1376 : : mddev->bitmap_info.default_space;
1377 : : }
1378 : :
1379 [ # # ]: 0 : } else if (mddev->pers == NULL) {
1380 : : /* Insist on good event counter while assembling, except
1381 : : * for spares (which don't need an event count) */
1382 : 0 : ++ev1;
1383 [ # # ]: 0 : if (sb->disks[rdev->desc_nr].state & (
1384 : : (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
1385 [ # # ]: 0 : if (ev1 < mddev->events)
1386 : : return -EINVAL;
1387 [ # # ]: 0 : } else if (mddev->bitmap) {
1388 : : /* if adding to array with a bitmap, then we can accept an
1389 : : * older device ... but not too old.
1390 : : */
1391 [ # # ]: 0 : if (ev1 < mddev->bitmap->events_cleared)
1392 : : return 0;
1393 [ # # ]: 0 : if (ev1 < mddev->events)
1394 : 0 : set_bit(Bitmap_sync, &rdev->flags);
1395 : : } else {
1396 [ # # ]: 0 : if (ev1 < mddev->events)
1397 : : /* just a hot-add of a new device, leave raid_disk at -1 */
1398 : : return 0;
1399 : : }
1400 : :
1401 [ # # ]: 0 : if (mddev->level != LEVEL_MULTIPATH) {
1402 : 0 : desc = sb->disks + rdev->desc_nr;
1403 : :
1404 [ # # ]: 0 : if (desc->state & (1<<MD_DISK_FAULTY))
1405 : 0 : set_bit(Faulty, &rdev->flags);
1406 [ # # ]: 0 : else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1407 : : desc->raid_disk < mddev->raid_disks */) {
1408 : 0 : set_bit(In_sync, &rdev->flags);
1409 : 0 : rdev->raid_disk = desc->raid_disk;
1410 : 0 : rdev->saved_raid_disk = desc->raid_disk;
1411 [ # # ]: 0 : } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1412 : : /* active but not in sync implies recovery up to
1413 : : * reshape position. We don't know exactly where
1414 : : * that is, so set to zero for now */
1415 [ # # ]: 0 : if (mddev->minor_version >= 91) {
1416 : 0 : rdev->recovery_offset = 0;
1417 : 0 : rdev->raid_disk = desc->raid_disk;
1418 : : }
1419 : : }
1420 [ # # ]: 0 : if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1421 : 0 : set_bit(WriteMostly, &rdev->flags);
1422 [ # # ]: 0 : if (desc->state & (1<<MD_DISK_FAILFAST))
1423 : 0 : set_bit(FailFast, &rdev->flags);
1424 : : } else /* MULTIPATH are always insync */
1425 : 0 : set_bit(In_sync, &rdev->flags);
1426 : : return 0;
1427 : : }
1428 : :
1429 : : /*
1430 : : * sync_super for 0.90.0
1431 : : */
1432 : 0 : static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
1433 : : {
1434 : 0 : mdp_super_t *sb;
1435 : 0 : struct md_rdev *rdev2;
1436 : 0 : int next_spare = mddev->raid_disks;
1437 : :
1438 : : /* make rdev->sb match mddev data..
1439 : : *
1440 : : * 1/ zero out disks
1441 : : * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1442 : : * 3/ any empty disks < next_spare become removed
1443 : : *
1444 : : * disks[0] gets initialised to REMOVED because
1445 : : * we cannot be sure from other fields if it has
1446 : : * been initialised or not.
1447 : : */
1448 : 0 : int i;
1449 : 0 : int active=0, working=0,failed=0,spare=0,nr_disks=0;
1450 : :
1451 : 0 : rdev->sb_size = MD_SB_BYTES;
1452 : :
1453 [ # # ]: 0 : sb = page_address(rdev->sb_page);
1454 : :
1455 : 0 : memset(sb, 0, sizeof(*sb));
1456 : :
1457 : 0 : sb->md_magic = MD_SB_MAGIC;
1458 : 0 : sb->major_version = mddev->major_version;
1459 : 0 : sb->patch_version = mddev->patch_version;
1460 : 0 : sb->gvalid_words = 0; /* ignored */
1461 : 0 : memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1462 : 0 : memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1463 : 0 : memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1464 : 0 : memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1465 : :
1466 : 0 : sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
1467 : 0 : sb->level = mddev->level;
1468 : 0 : sb->size = mddev->dev_sectors / 2;
1469 : 0 : sb->raid_disks = mddev->raid_disks;
1470 : 0 : sb->md_minor = mddev->md_minor;
1471 : 0 : sb->not_persistent = 0;
1472 : 0 : sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
1473 : 0 : sb->state = 0;
1474 : 0 : sb->events_hi = (mddev->events>>32);
1475 : 0 : sb->events_lo = (u32)mddev->events;
1476 : :
1477 [ # # ]: 0 : if (mddev->reshape_position == MaxSector)
1478 : 0 : sb->minor_version = 90;
1479 : : else {
1480 : 0 : sb->minor_version = 91;
1481 : 0 : sb->reshape_position = mddev->reshape_position;
1482 : 0 : sb->new_level = mddev->new_level;
1483 : 0 : sb->delta_disks = mddev->delta_disks;
1484 : 0 : sb->new_layout = mddev->new_layout;
1485 : 0 : sb->new_chunk = mddev->new_chunk_sectors << 9;
1486 : : }
1487 : 0 : mddev->minor_version = sb->minor_version;
1488 [ # # ]: 0 : if (mddev->in_sync)
1489 : : {
1490 : 0 : sb->recovery_cp = mddev->recovery_cp;
1491 : 0 : sb->cp_events_hi = (mddev->events>>32);
1492 : 0 : sb->cp_events_lo = (u32)mddev->events;
1493 [ # # ]: 0 : if (mddev->recovery_cp == MaxSector)
1494 : 0 : sb->state = (1<< MD_SB_CLEAN);
1495 : : } else
1496 : 0 : sb->recovery_cp = 0;
1497 : :
1498 : 0 : sb->layout = mddev->layout;
1499 : 0 : sb->chunk_size = mddev->chunk_sectors << 9;
1500 : :
1501 [ # # # # ]: 0 : if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1502 : 0 : sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1503 : :
1504 : 0 : sb->disks[0].state = (1<<MD_DISK_REMOVED);
1505 [ # # ]: 0 : rdev_for_each(rdev2, mddev) {
1506 : 0 : mdp_disk_t *d;
1507 : 0 : int desc_nr;
1508 : 0 : int is_active = test_bit(In_sync, &rdev2->flags);
1509 : :
1510 [ # # ]: 0 : if (rdev2->raid_disk >= 0 &&
1511 [ # # ]: 0 : sb->minor_version >= 91)
1512 : : /* we have nowhere to store the recovery_offset,
1513 : : * but if it is not below the reshape_position,
1514 : : * we can piggy-back on that.
1515 : : */
1516 : 0 : is_active = 1;
1517 [ # # # # ]: 0 : if (rdev2->raid_disk < 0 ||
1518 : : test_bit(Faulty, &rdev2->flags))
1519 : : is_active = 0;
1520 [ # # ]: 0 : if (is_active)
1521 : 0 : desc_nr = rdev2->raid_disk;
1522 : : else
1523 : 0 : desc_nr = next_spare++;
1524 : 0 : rdev2->desc_nr = desc_nr;
1525 : 0 : d = &sb->disks[rdev2->desc_nr];
1526 : 0 : nr_disks++;
1527 : 0 : d->number = rdev2->desc_nr;
1528 : 0 : d->major = MAJOR(rdev2->bdev->bd_dev);
1529 : 0 : d->minor = MINOR(rdev2->bdev->bd_dev);
1530 [ # # ]: 0 : if (is_active)
1531 : 0 : d->raid_disk = rdev2->raid_disk;
1532 : : else
1533 : 0 : d->raid_disk = rdev2->desc_nr; /* compatibility */
1534 [ # # ]: 0 : if (test_bit(Faulty, &rdev2->flags))
1535 : 0 : d->state = (1<<MD_DISK_FAULTY);
1536 [ # # ]: 0 : else if (is_active) {
1537 : 0 : d->state = (1<<MD_DISK_ACTIVE);
1538 [ # # ]: 0 : if (test_bit(In_sync, &rdev2->flags))
1539 : 0 : d->state |= (1<<MD_DISK_SYNC);
1540 : 0 : active++;
1541 : 0 : working++;
1542 : : } else {
1543 : 0 : d->state = 0;
1544 : 0 : spare++;
1545 : 0 : working++;
1546 : : }
1547 [ # # ]: 0 : if (test_bit(WriteMostly, &rdev2->flags))
1548 : 0 : d->state |= (1<<MD_DISK_WRITEMOSTLY);
1549 [ # # ]: 0 : if (test_bit(FailFast, &rdev2->flags))
1550 : 0 : d->state |= (1<<MD_DISK_FAILFAST);
1551 : : }
1552 : : /* now set the "removed" and "faulty" bits on any missing devices */
1553 [ # # ]: 0 : for (i=0 ; i < mddev->raid_disks ; i++) {
1554 : 0 : mdp_disk_t *d = &sb->disks[i];
1555 [ # # # # ]: 0 : if (d->state == 0 && d->number == 0) {
1556 : 0 : d->number = i;
1557 : 0 : d->raid_disk = i;
1558 : 0 : d->state = (1<<MD_DISK_REMOVED);
1559 : 0 : d->state |= (1<<MD_DISK_FAULTY);
1560 : 0 : failed++;
1561 : : }
1562 : : }
1563 : 0 : sb->nr_disks = nr_disks;
1564 : 0 : sb->active_disks = active;
1565 : 0 : sb->working_disks = working;
1566 : 0 : sb->failed_disks = failed;
1567 : 0 : sb->spare_disks = spare;
1568 : :
1569 : 0 : sb->this_disk = sb->disks[rdev->desc_nr];
1570 : 0 : sb->sb_csum = calc_sb_csum(sb);
1571 : 0 : }
1572 : :
1573 : : /*
1574 : : * rdev_size_change for 0.90.0
1575 : : */
1576 : : static unsigned long long
1577 : 0 : super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1578 : : {
1579 [ # # # # ]: 0 : if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1580 : : return 0; /* component must fit device */
1581 [ # # ]: 0 : if (rdev->mddev->bitmap_info.offset)
1582 : : return 0; /* can't move bitmap */
1583 [ # # ]: 0 : rdev->sb_start = calc_dev_sboffset(rdev);
1584 [ # # # # ]: 0 : if (!num_sectors || num_sectors > rdev->sb_start)
1585 : 0 : num_sectors = rdev->sb_start;
1586 : : /* Limit to 4TB as metadata cannot record more than that.
1587 : : * 4TB == 2^32 KB, or 2*2^32 sectors.
1588 : : */
1589 [ # # # # ]: 0 : if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
1590 : 0 : num_sectors = (sector_t)(2ULL << 32) - 2;
1591 : 0 : do {
1592 : 0 : md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1593 : : rdev->sb_page);
1594 [ # # ]: 0 : } while (md_super_wait(rdev->mddev) < 0);
1595 : : return num_sectors;
1596 : : }
1597 : :
1598 : : static int
1599 : 0 : super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1600 : : {
1601 : : /* non-zero offset changes not possible with v0.90 */
1602 : 0 : return new_offset == 0;
1603 : : }
1604 : :
1605 : : /*
1606 : : * version 1 superblock
1607 : : */
1608 : :
1609 : 0 : static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
1610 : : {
1611 : 0 : __le32 disk_csum;
1612 : 0 : u32 csum;
1613 : 0 : unsigned long long newcsum;
1614 : 0 : int size = 256 + le32_to_cpu(sb->max_dev)*2;
1615 : 0 : __le32 *isuper = (__le32*)sb;
1616 : :
1617 : 0 : disk_csum = sb->sb_csum;
1618 : 0 : sb->sb_csum = 0;
1619 : 0 : newcsum = 0;
1620 [ # # # # : 0 : for (; size >= 4; size -= 4)
# # ]
1621 : 0 : newcsum += le32_to_cpu(*isuper++);
1622 : :
1623 [ # # # # : 0 : if (size == 2)
# # ]
1624 : 0 : newcsum += le16_to_cpu(*(__le16*) isuper);
1625 : :
1626 : 0 : csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1627 : 0 : sb->sb_csum = disk_csum;
1628 : 0 : return cpu_to_le32(csum);
1629 : : }
1630 : :
1631 : 0 : static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1632 : : {
1633 : 0 : struct mdp_superblock_1 *sb;
1634 : 0 : int ret;
1635 : 0 : sector_t sb_start;
1636 : 0 : sector_t sectors;
1637 : 0 : char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1638 : 0 : int bmask;
1639 : 0 : bool spare_disk = true;
1640 : :
1641 : : /*
1642 : : * Calculate the position of the superblock in 512byte sectors.
1643 : : * It is always aligned to a 4K boundary and
1644 : : * depeding on minor_version, it can be:
1645 : : * 0: At least 8K, but less than 12K, from end of device
1646 : : * 1: At start of device
1647 : : * 2: 4K from start of device.
1648 : : */
1649 [ # # # # ]: 0 : switch(minor_version) {
1650 : 0 : case 0:
1651 : 0 : sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
1652 : 0 : sb_start -= 8*2;
1653 : 0 : sb_start &= ~(sector_t)(4*2-1);
1654 : 0 : break;
1655 : : case 1:
1656 : : sb_start = 0;
1657 : : break;
1658 : 0 : case 2:
1659 : 0 : sb_start = 8;
1660 : 0 : break;
1661 : : default:
1662 : : return -EINVAL;
1663 : : }
1664 : 0 : rdev->sb_start = sb_start;
1665 : :
1666 : : /* superblock is rarely larger than 1K, but it can be larger,
1667 : : * and it is safe to read 4k, so we do that
1668 : : */
1669 : 0 : ret = read_disk_sb(rdev, 4096);
1670 [ # # ]: 0 : if (ret) return ret;
1671 : :
1672 [ # # ]: 0 : sb = page_address(rdev->sb_page);
1673 : :
1674 [ # # ]: 0 : if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1675 : 0 : sb->major_version != cpu_to_le32(1) ||
1676 [ # # ]: 0 : le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1677 [ # # ]: 0 : le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1678 [ # # ]: 0 : (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1679 : : return -EINVAL;
1680 : :
1681 [ # # ]: 0 : if (calc_sb_1_csum(sb) != sb->sb_csum) {
1682 : 0 : pr_warn("md: invalid superblock checksum on %s\n",
1683 : : bdevname(rdev->bdev,b));
1684 : 0 : return -EINVAL;
1685 : : }
1686 [ # # ]: 0 : if (le64_to_cpu(sb->data_size) < 10) {
1687 : 0 : pr_warn("md: data_size too small on %s\n",
1688 : : bdevname(rdev->bdev,b));
1689 : 0 : return -EINVAL;
1690 : : }
1691 [ # # ]: 0 : if (sb->pad0 ||
1692 [ # # ]: 0 : sb->pad3[0] ||
1693 [ # # ]: 0 : memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1694 : : /* Some padding is non-zero, might be a new feature */
1695 : : return -EINVAL;
1696 : :
1697 : 0 : rdev->preferred_minor = 0xffff;
1698 : 0 : rdev->data_offset = le64_to_cpu(sb->data_offset);
1699 : 0 : rdev->new_data_offset = rdev->data_offset;
1700 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1701 : : (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1702 : 0 : rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
1703 : 0 : atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1704 : :
1705 : 0 : rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1706 [ # # ]: 0 : bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1707 [ # # ]: 0 : if (rdev->sb_size & bmask)
1708 : 0 : rdev->sb_size = (rdev->sb_size | bmask) + 1;
1709 : :
1710 [ # # ]: 0 : if (minor_version
1711 [ # # ]: 0 : && rdev->data_offset < sb_start + (rdev->sb_size/512))
1712 : : return -EINVAL;
1713 [ # # ]: 0 : if (minor_version
1714 [ # # ]: 0 : && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1715 : : return -EINVAL;
1716 : :
1717 [ # # ]: 0 : if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1718 : 0 : rdev->desc_nr = -1;
1719 : : else
1720 : 0 : rdev->desc_nr = le32_to_cpu(sb->dev_number);
1721 : :
1722 [ # # ]: 0 : if (!rdev->bb_page) {
1723 : 0 : rdev->bb_page = alloc_page(GFP_KERNEL);
1724 [ # # ]: 0 : if (!rdev->bb_page)
1725 : : return -ENOMEM;
1726 : : }
1727 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1728 [ # # ]: 0 : rdev->badblocks.count == 0) {
1729 : : /* need to load the bad block list.
1730 : : * Currently we limit it to one page.
1731 : : */
1732 : 0 : s32 offset;
1733 : 0 : sector_t bb_sector;
1734 : 0 : __le64 *bbp;
1735 : 0 : int i;
1736 : 0 : int sectors = le16_to_cpu(sb->bblog_size);
1737 [ # # ]: 0 : if (sectors > (PAGE_SIZE / 512))
1738 : : return -EINVAL;
1739 : 0 : offset = le32_to_cpu(sb->bblog_offset);
1740 [ # # ]: 0 : if (offset == 0)
1741 : : return -EINVAL;
1742 : 0 : bb_sector = (long long)offset;
1743 [ # # ]: 0 : if (!sync_page_io(rdev, bb_sector, sectors << 9,
1744 : : rdev->bb_page, REQ_OP_READ, 0, true))
1745 : : return -EIO;
1746 : 0 : bbp = (__le64 *)page_address(rdev->bb_page);
1747 : 0 : rdev->badblocks.shift = sb->bblog_shift;
1748 [ # # ]: 0 : for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1749 : 0 : u64 bb = le64_to_cpu(*bbp);
1750 : 0 : int count = bb & (0x3ff);
1751 : 0 : u64 sector = bb >> 10;
1752 : 0 : sector <<= sb->bblog_shift;
1753 : 0 : count <<= sb->bblog_shift;
1754 [ # # ]: 0 : if (bb + 1 == 0)
1755 : : break;
1756 [ # # ]: 0 : if (badblocks_set(&rdev->badblocks, sector, count, 1))
1757 : : return -EINVAL;
1758 : : }
1759 [ # # ]: 0 : } else if (sb->bblog_offset != 0)
1760 : 0 : rdev->badblocks.shift = 0;
1761 : :
1762 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) &
1763 : : (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS))) {
1764 : 0 : rdev->ppl.offset = (__s16)le16_to_cpu(sb->ppl.offset);
1765 : 0 : rdev->ppl.size = le16_to_cpu(sb->ppl.size);
1766 : 0 : rdev->ppl.sector = rdev->sb_start + rdev->ppl.offset;
1767 : : }
1768 : :
1769 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT) &&
1770 [ # # ]: 0 : sb->level != 0)
1771 : : return -EINVAL;
1772 : :
1773 : : /* not spare disk, or LEVEL_MULTIPATH */
1774 [ # # ]: 0 : if (sb->level == cpu_to_le32(LEVEL_MULTIPATH) ||
1775 [ # # ]: 0 : (rdev->desc_nr >= 0 &&
1776 [ # # ]: 0 : rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1777 [ # # ]: 0 : (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1778 : : le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL)))
1779 : 0 : spare_disk = false;
1780 : :
1781 [ # # ]: 0 : if (!refdev) {
1782 [ # # ]: 0 : if (!spare_disk)
1783 : : ret = 1;
1784 : : else
1785 : 0 : ret = 0;
1786 : : } else {
1787 : 0 : __u64 ev1, ev2;
1788 [ # # ]: 0 : struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
1789 : :
1790 [ # # ]: 0 : if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1791 [ # # ]: 0 : sb->level != refsb->level ||
1792 : 0 : sb->layout != refsb->layout ||
1793 [ # # ]: 0 : sb->chunksize != refsb->chunksize) {
1794 : 0 : pr_warn("md: %s has strangely different superblock to %s\n",
1795 : : bdevname(rdev->bdev,b),
1796 : : bdevname(refdev->bdev,b2));
1797 : 0 : return -EINVAL;
1798 : : }
1799 : 0 : ev1 = le64_to_cpu(sb->events);
1800 : 0 : ev2 = le64_to_cpu(refsb->events);
1801 : :
1802 [ # # ]: 0 : if (!spare_disk && ev1 > ev2)
1803 : : ret = 1;
1804 : : else
1805 : 0 : ret = 0;
1806 : : }
1807 [ # # ]: 0 : if (minor_version) {
1808 : 0 : sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1809 : 0 : sectors -= rdev->data_offset;
1810 : : } else
1811 : 0 : sectors = rdev->sb_start;
1812 [ # # ]: 0 : if (sectors < le64_to_cpu(sb->data_size))
1813 : : return -EINVAL;
1814 : 0 : rdev->sectors = le64_to_cpu(sb->data_size);
1815 : 0 : return ret;
1816 : : }
1817 : :
1818 : 0 : static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
1819 : : {
1820 : 0 : struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1821 : 0 : __u64 ev1 = le64_to_cpu(sb->events);
1822 : :
1823 : 0 : rdev->raid_disk = -1;
1824 : 0 : clear_bit(Faulty, &rdev->flags);
1825 : 0 : clear_bit(In_sync, &rdev->flags);
1826 : 0 : clear_bit(Bitmap_sync, &rdev->flags);
1827 : 0 : clear_bit(WriteMostly, &rdev->flags);
1828 : :
1829 [ # # ]: 0 : if (mddev->raid_disks == 0) {
1830 : 0 : mddev->major_version = 1;
1831 : 0 : mddev->patch_version = 0;
1832 : 0 : mddev->external = 0;
1833 : 0 : mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
1834 : 0 : mddev->ctime = le64_to_cpu(sb->ctime);
1835 : 0 : mddev->utime = le64_to_cpu(sb->utime);
1836 : 0 : mddev->level = le32_to_cpu(sb->level);
1837 : 0 : mddev->clevel[0] = 0;
1838 : 0 : mddev->layout = le32_to_cpu(sb->layout);
1839 : 0 : mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1840 : 0 : mddev->dev_sectors = le64_to_cpu(sb->size);
1841 : 0 : mddev->events = ev1;
1842 : 0 : mddev->bitmap_info.offset = 0;
1843 : 0 : mddev->bitmap_info.space = 0;
1844 : : /* Default location for bitmap is 1K after superblock
1845 : : * using 3K - total of 4K
1846 : : */
1847 : 0 : mddev->bitmap_info.default_offset = 1024 >> 9;
1848 : 0 : mddev->bitmap_info.default_space = (4096-1024) >> 9;
1849 : 0 : mddev->reshape_backwards = 0;
1850 : :
1851 : 0 : mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1852 : 0 : memcpy(mddev->uuid, sb->set_uuid, 16);
1853 : :
1854 : 0 : mddev->max_disks = (4096-256)/2;
1855 : :
1856 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1857 [ # # ]: 0 : mddev->bitmap_info.file == NULL) {
1858 : 0 : mddev->bitmap_info.offset =
1859 : 0 : (__s32)le32_to_cpu(sb->bitmap_offset);
1860 : : /* Metadata doesn't record how much space is available.
1861 : : * For 1.0, we assume we can use up to the superblock
1862 : : * if before, else to 4K beyond superblock.
1863 : : * For others, assume no change is possible.
1864 : : */
1865 [ # # ]: 0 : if (mddev->minor_version > 0)
1866 : : mddev->bitmap_info.space = 0;
1867 [ # # ]: 0 : else if (mddev->bitmap_info.offset > 0)
1868 : 0 : mddev->bitmap_info.space =
1869 : 0 : 8 - mddev->bitmap_info.offset;
1870 : : else
1871 : 0 : mddev->bitmap_info.space =
1872 : 0 : -mddev->bitmap_info.offset;
1873 : : }
1874 : :
1875 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1876 : 0 : mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1877 : 0 : mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1878 : 0 : mddev->new_level = le32_to_cpu(sb->new_level);
1879 : 0 : mddev->new_layout = le32_to_cpu(sb->new_layout);
1880 : 0 : mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1881 [ # # # # ]: 0 : if (mddev->delta_disks < 0 ||
1882 : 0 : (mddev->delta_disks == 0 &&
1883 : 0 : (le32_to_cpu(sb->feature_map)
1884 [ # # ]: 0 : & MD_FEATURE_RESHAPE_BACKWARDS)))
1885 : 0 : mddev->reshape_backwards = 1;
1886 : : } else {
1887 : 0 : mddev->reshape_position = MaxSector;
1888 : 0 : mddev->delta_disks = 0;
1889 : 0 : mddev->new_level = mddev->level;
1890 : 0 : mddev->new_layout = mddev->layout;
1891 : 0 : mddev->new_chunk_sectors = mddev->chunk_sectors;
1892 : : }
1893 : :
1894 [ # # ]: 0 : if (mddev->level == 0 &&
1895 [ # # ]: 0 : !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT))
1896 : 0 : mddev->layout = -1;
1897 : :
1898 [ # # ]: 0 : if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)
1899 : 0 : set_bit(MD_HAS_JOURNAL, &mddev->flags);
1900 : :
1901 [ # # ]: 0 : if (le32_to_cpu(sb->feature_map) &
1902 : : (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS)) {
1903 [ # # ]: 0 : if (le32_to_cpu(sb->feature_map) &
1904 : : (MD_FEATURE_BITMAP_OFFSET | MD_FEATURE_JOURNAL))
1905 : : return -EINVAL;
1906 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL) &&
1907 : : (le32_to_cpu(sb->feature_map) &
1908 : : MD_FEATURE_MULTIPLE_PPLS))
1909 : : return -EINVAL;
1910 : 0 : set_bit(MD_HAS_PPL, &mddev->flags);
1911 : : }
1912 [ # # ]: 0 : } else if (mddev->pers == NULL) {
1913 : : /* Insist of good event counter while assembling, except for
1914 : : * spares (which don't need an event count) */
1915 : 0 : ++ev1;
1916 [ # # ]: 0 : if (rdev->desc_nr >= 0 &&
1917 [ # # ]: 0 : rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1918 [ # # ]: 0 : (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1919 : : le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
1920 [ # # ]: 0 : if (ev1 < mddev->events)
1921 : : return -EINVAL;
1922 [ # # ]: 0 : } else if (mddev->bitmap) {
1923 : : /* If adding to array with a bitmap, then we can accept an
1924 : : * older device, but not too old.
1925 : : */
1926 [ # # ]: 0 : if (ev1 < mddev->bitmap->events_cleared)
1927 : : return 0;
1928 [ # # ]: 0 : if (ev1 < mddev->events)
1929 : 0 : set_bit(Bitmap_sync, &rdev->flags);
1930 : : } else {
1931 [ # # ]: 0 : if (ev1 < mddev->events)
1932 : : /* just a hot-add of a new device, leave raid_disk at -1 */
1933 : : return 0;
1934 : : }
1935 [ # # ]: 0 : if (mddev->level != LEVEL_MULTIPATH) {
1936 : 0 : int role;
1937 [ # # ]: 0 : if (rdev->desc_nr < 0 ||
1938 [ # # ]: 0 : rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
1939 : 0 : role = MD_DISK_ROLE_SPARE;
1940 : 0 : rdev->desc_nr = -1;
1941 : : } else
1942 : 0 : role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1943 [ # # # # ]: 0 : switch(role) {
1944 : : case MD_DISK_ROLE_SPARE: /* spare */
1945 : : break;
1946 : 0 : case MD_DISK_ROLE_FAULTY: /* faulty */
1947 : 0 : set_bit(Faulty, &rdev->flags);
1948 : 0 : break;
1949 : 0 : case MD_DISK_ROLE_JOURNAL: /* journal device */
1950 [ # # ]: 0 : if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
1951 : : /* journal device without journal feature */
1952 : 0 : pr_warn("md: journal device provided without journal feature, ignoring the device\n");
1953 : 0 : return -EINVAL;
1954 : : }
1955 : 0 : set_bit(Journal, &rdev->flags);
1956 : 0 : rdev->journal_tail = le64_to_cpu(sb->journal_tail);
1957 : 0 : rdev->raid_disk = 0;
1958 : 0 : break;
1959 : 0 : default:
1960 : 0 : rdev->saved_raid_disk = role;
1961 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) &
1962 : : MD_FEATURE_RECOVERY_OFFSET)) {
1963 : 0 : rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1964 [ # # ]: 0 : if (!(le32_to_cpu(sb->feature_map) &
1965 : : MD_FEATURE_RECOVERY_BITMAP))
1966 : 0 : rdev->saved_raid_disk = -1;
1967 : : } else {
1968 : : /*
1969 : : * If the array is FROZEN, then the device can't
1970 : : * be in_sync with rest of array.
1971 : : */
1972 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_FROZEN,
1973 : 0 : &mddev->recovery))
1974 : 0 : set_bit(In_sync, &rdev->flags);
1975 : : }
1976 : 0 : rdev->raid_disk = role;
1977 : 0 : break;
1978 : : }
1979 [ # # ]: 0 : if (sb->devflags & WriteMostly1)
1980 : 0 : set_bit(WriteMostly, &rdev->flags);
1981 [ # # ]: 0 : if (sb->devflags & FailFast1)
1982 : 0 : set_bit(FailFast, &rdev->flags);
1983 [ # # ]: 0 : if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1984 : 0 : set_bit(Replacement, &rdev->flags);
1985 : : } else /* MULTIPATH are always insync */
1986 : 0 : set_bit(In_sync, &rdev->flags);
1987 : :
1988 : : return 0;
1989 : : }
1990 : :
1991 : 0 : static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
1992 : : {
1993 : 0 : struct mdp_superblock_1 *sb;
1994 : 0 : struct md_rdev *rdev2;
1995 : 0 : int max_dev, i;
1996 : : /* make rdev->sb match mddev and rdev data. */
1997 : :
1998 [ # # ]: 0 : sb = page_address(rdev->sb_page);
1999 : :
2000 : 0 : sb->feature_map = 0;
2001 : 0 : sb->pad0 = 0;
2002 : 0 : sb->recovery_offset = cpu_to_le64(0);
2003 : 0 : memset(sb->pad3, 0, sizeof(sb->pad3));
2004 : :
2005 : 0 : sb->utime = cpu_to_le64((__u64)mddev->utime);
2006 : 0 : sb->events = cpu_to_le64(mddev->events);
2007 [ # # ]: 0 : if (mddev->in_sync)
2008 : 0 : sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
2009 [ # # ]: 0 : else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
2010 : 0 : sb->resync_offset = cpu_to_le64(MaxSector);
2011 : : else
2012 : 0 : sb->resync_offset = cpu_to_le64(0);
2013 : :
2014 : 0 : sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
2015 : :
2016 : 0 : sb->raid_disks = cpu_to_le32(mddev->raid_disks);
2017 : 0 : sb->size = cpu_to_le64(mddev->dev_sectors);
2018 : 0 : sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
2019 : 0 : sb->level = cpu_to_le32(mddev->level);
2020 : 0 : sb->layout = cpu_to_le32(mddev->layout);
2021 [ # # ]: 0 : if (test_bit(FailFast, &rdev->flags))
2022 : 0 : sb->devflags |= FailFast1;
2023 : : else
2024 : 0 : sb->devflags &= ~FailFast1;
2025 : :
2026 [ # # ]: 0 : if (test_bit(WriteMostly, &rdev->flags))
2027 : 0 : sb->devflags |= WriteMostly1;
2028 : : else
2029 : 0 : sb->devflags &= ~WriteMostly1;
2030 : 0 : sb->data_offset = cpu_to_le64(rdev->data_offset);
2031 : 0 : sb->data_size = cpu_to_le64(rdev->sectors);
2032 : :
2033 [ # # # # ]: 0 : if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
2034 : 0 : sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
2035 : 0 : sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
2036 : : }
2037 : :
2038 [ # # # # : 0 : if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
# # ]
2039 : : !test_bit(In_sync, &rdev->flags)) {
2040 : 0 : sb->feature_map |=
2041 : : cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
2042 : 0 : sb->recovery_offset =
2043 : 0 : cpu_to_le64(rdev->recovery_offset);
2044 [ # # # # ]: 0 : if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
2045 : 0 : sb->feature_map |=
2046 : : cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
2047 : : }
2048 : : /* Note: recovery_offset and journal_tail share space */
2049 [ # # ]: 0 : if (test_bit(Journal, &rdev->flags))
2050 : 0 : sb->journal_tail = cpu_to_le64(rdev->journal_tail);
2051 [ # # ]: 0 : if (test_bit(Replacement, &rdev->flags))
2052 : 0 : sb->feature_map |=
2053 : : cpu_to_le32(MD_FEATURE_REPLACEMENT);
2054 : :
2055 [ # # ]: 0 : if (mddev->reshape_position != MaxSector) {
2056 : 0 : sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
2057 : 0 : sb->reshape_position = cpu_to_le64(mddev->reshape_position);
2058 : 0 : sb->new_layout = cpu_to_le32(mddev->new_layout);
2059 : 0 : sb->delta_disks = cpu_to_le32(mddev->delta_disks);
2060 : 0 : sb->new_level = cpu_to_le32(mddev->new_level);
2061 : 0 : sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
2062 [ # # ]: 0 : if (mddev->delta_disks == 0 &&
2063 [ # # ]: 0 : mddev->reshape_backwards)
2064 : 0 : sb->feature_map
2065 : 0 : |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
2066 [ # # ]: 0 : if (rdev->new_data_offset != rdev->data_offset) {
2067 : 0 : sb->feature_map
2068 : 0 : |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
2069 : 0 : sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
2070 : : - rdev->data_offset));
2071 : : }
2072 : : }
2073 : :
2074 [ # # ]: 0 : if (mddev_is_clustered(mddev))
2075 : 0 : sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
2076 : :
2077 [ # # ]: 0 : if (rdev->badblocks.count == 0)
2078 : : /* Nothing to do for bad blocks*/ ;
2079 [ # # ]: 0 : else if (sb->bblog_offset == 0)
2080 : : /* Cannot record bad blocks on this device */
2081 : 0 : md_error(mddev, rdev);
2082 : : else {
2083 : 0 : struct badblocks *bb = &rdev->badblocks;
2084 [ # # ]: 0 : __le64 *bbp = (__le64 *)page_address(rdev->bb_page);
2085 : 0 : u64 *p = bb->page;
2086 : 0 : sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
2087 [ # # ]: 0 : if (bb->changed) {
2088 : 0 : unsigned seq;
2089 : :
2090 : 0 : retry:
2091 : 0 : seq = read_seqbegin(&bb->lock);
2092 : :
2093 : 0 : memset(bbp, 0xff, PAGE_SIZE);
2094 : :
2095 [ # # ]: 0 : for (i = 0 ; i < bb->count ; i++) {
2096 : 0 : u64 internal_bb = p[i];
2097 : 0 : u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
2098 : 0 : | BB_LEN(internal_bb));
2099 : 0 : bbp[i] = cpu_to_le64(store_bb);
2100 : : }
2101 : 0 : bb->changed = 0;
2102 [ # # ]: 0 : if (read_seqretry(&bb->lock, seq))
2103 : 0 : goto retry;
2104 : :
2105 : 0 : bb->sector = (rdev->sb_start +
2106 : 0 : (int)le32_to_cpu(sb->bblog_offset));
2107 : 0 : bb->size = le16_to_cpu(sb->bblog_size);
2108 : : }
2109 : : }
2110 : :
2111 : 0 : max_dev = 0;
2112 [ # # ]: 0 : rdev_for_each(rdev2, mddev)
2113 : 0 : if (rdev2->desc_nr+1 > max_dev)
2114 : : max_dev = rdev2->desc_nr+1;
2115 : :
2116 [ # # ]: 0 : if (max_dev > le32_to_cpu(sb->max_dev)) {
2117 : 0 : int bmask;
2118 : 0 : sb->max_dev = cpu_to_le32(max_dev);
2119 : 0 : rdev->sb_size = max_dev * 2 + 256;
2120 [ # # ]: 0 : bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
2121 [ # # ]: 0 : if (rdev->sb_size & bmask)
2122 : 0 : rdev->sb_size = (rdev->sb_size | bmask) + 1;
2123 : : } else
2124 : 0 : max_dev = le32_to_cpu(sb->max_dev);
2125 : :
2126 [ # # ]: 0 : for (i=0; i<max_dev;i++)
2127 : 0 : sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
2128 : :
2129 [ # # ]: 0 : if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
2130 : 0 : sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
2131 : :
2132 [ # # ]: 0 : if (test_bit(MD_HAS_PPL, &mddev->flags)) {
2133 [ # # ]: 0 : if (test_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags))
2134 : 0 : sb->feature_map |=
2135 : : cpu_to_le32(MD_FEATURE_MULTIPLE_PPLS);
2136 : : else
2137 : 0 : sb->feature_map |= cpu_to_le32(MD_FEATURE_PPL);
2138 : 0 : sb->ppl.offset = cpu_to_le16(rdev->ppl.offset);
2139 : 0 : sb->ppl.size = cpu_to_le16(rdev->ppl.size);
2140 : : }
2141 : :
2142 [ # # ]: 0 : rdev_for_each(rdev2, mddev) {
2143 : 0 : i = rdev2->desc_nr;
2144 [ # # ]: 0 : if (test_bit(Faulty, &rdev2->flags))
2145 : 0 : sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
2146 [ # # ]: 0 : else if (test_bit(In_sync, &rdev2->flags))
2147 : 0 : sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
2148 [ # # ]: 0 : else if (test_bit(Journal, &rdev2->flags))
2149 : 0 : sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
2150 [ # # ]: 0 : else if (rdev2->raid_disk >= 0)
2151 : 0 : sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
2152 : : else
2153 : 0 : sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
2154 : : }
2155 : :
2156 : 0 : sb->sb_csum = calc_sb_1_csum(sb);
2157 : 0 : }
2158 : :
2159 : : static unsigned long long
2160 : 0 : super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
2161 : : {
2162 : 0 : struct mdp_superblock_1 *sb;
2163 : 0 : sector_t max_sectors;
2164 [ # # # # ]: 0 : if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
2165 : : return 0; /* component must fit device */
2166 [ # # ]: 0 : if (rdev->data_offset != rdev->new_data_offset)
2167 : : return 0; /* too confusing */
2168 [ # # ]: 0 : if (rdev->sb_start < rdev->data_offset) {
2169 : : /* minor versions 1 and 2; superblock before data */
2170 [ # # ]: 0 : max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
2171 : 0 : max_sectors -= rdev->data_offset;
2172 [ # # ]: 0 : if (!num_sectors || num_sectors > max_sectors)
2173 : 0 : num_sectors = max_sectors;
2174 [ # # ]: 0 : } else if (rdev->mddev->bitmap_info.offset) {
2175 : : /* minor version 0 with bitmap we can't move */
2176 : : return 0;
2177 : : } else {
2178 : : /* minor version 0; superblock after data */
2179 : 0 : sector_t sb_start;
2180 [ # # ]: 0 : sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
2181 : 0 : sb_start &= ~(sector_t)(4*2 - 1);
2182 : 0 : max_sectors = rdev->sectors + sb_start - rdev->sb_start;
2183 [ # # ]: 0 : if (!num_sectors || num_sectors > max_sectors)
2184 : 0 : num_sectors = max_sectors;
2185 : 0 : rdev->sb_start = sb_start;
2186 : : }
2187 : 0 : sb = page_address(rdev->sb_page);
2188 : 0 : sb->data_size = cpu_to_le64(num_sectors);
2189 : 0 : sb->super_offset = cpu_to_le64(rdev->sb_start);
2190 : 0 : sb->sb_csum = calc_sb_1_csum(sb);
2191 : 0 : do {
2192 : 0 : md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
2193 : : rdev->sb_page);
2194 [ # # ]: 0 : } while (md_super_wait(rdev->mddev) < 0);
2195 : : return num_sectors;
2196 : :
2197 : : }
2198 : :
2199 : : static int
2200 : 0 : super_1_allow_new_offset(struct md_rdev *rdev,
2201 : : unsigned long long new_offset)
2202 : : {
2203 : : /* All necessary checks on new >= old have been done */
2204 : 0 : struct bitmap *bitmap;
2205 [ # # ]: 0 : if (new_offset >= rdev->data_offset)
2206 : : return 1;
2207 : :
2208 : : /* with 1.0 metadata, there is no metadata to tread on
2209 : : * so we can always move back */
2210 [ # # ]: 0 : if (rdev->mddev->minor_version == 0)
2211 : : return 1;
2212 : :
2213 : : /* otherwise we must be sure not to step on
2214 : : * any metadata, so stay:
2215 : : * 36K beyond start of superblock
2216 : : * beyond end of badblocks
2217 : : * beyond write-intent bitmap
2218 : : */
2219 [ # # ]: 0 : if (rdev->sb_start + (32+4)*2 > new_offset)
2220 : : return 0;
2221 : 0 : bitmap = rdev->mddev->bitmap;
2222 [ # # # # ]: 0 : if (bitmap && !rdev->mddev->bitmap_info.file &&
2223 : 0 : rdev->sb_start + rdev->mddev->bitmap_info.offset +
2224 [ # # ]: 0 : bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
2225 : : return 0;
2226 [ # # ]: 0 : if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
2227 : 0 : return 0;
2228 : :
2229 : : return 1;
2230 : : }
2231 : :
2232 : : static struct super_type super_types[] = {
2233 : : [0] = {
2234 : : .name = "0.90.0",
2235 : : .owner = THIS_MODULE,
2236 : : .load_super = super_90_load,
2237 : : .validate_super = super_90_validate,
2238 : : .sync_super = super_90_sync,
2239 : : .rdev_size_change = super_90_rdev_size_change,
2240 : : .allow_new_offset = super_90_allow_new_offset,
2241 : : },
2242 : : [1] = {
2243 : : .name = "md-1",
2244 : : .owner = THIS_MODULE,
2245 : : .load_super = super_1_load,
2246 : : .validate_super = super_1_validate,
2247 : : .sync_super = super_1_sync,
2248 : : .rdev_size_change = super_1_rdev_size_change,
2249 : : .allow_new_offset = super_1_allow_new_offset,
2250 : : },
2251 : : };
2252 : :
2253 : 0 : static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
2254 : : {
2255 [ # # ]: 0 : if (mddev->sync_super) {
2256 : 0 : mddev->sync_super(mddev, rdev);
2257 : 0 : return;
2258 : : }
2259 : :
2260 [ # # ]: 0 : BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
2261 : :
2262 : 0 : super_types[mddev->major_version].sync_super(mddev, rdev);
2263 : : }
2264 : :
2265 : 0 : static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
2266 : : {
2267 : 0 : struct md_rdev *rdev, *rdev2;
2268 : :
2269 : 0 : rcu_read_lock();
2270 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev1) {
2271 [ # # # # ]: 0 : if (test_bit(Faulty, &rdev->flags) ||
2272 : 0 : test_bit(Journal, &rdev->flags) ||
2273 [ # # ]: 0 : rdev->raid_disk == -1)
2274 : 0 : continue;
2275 [ # # ]: 0 : rdev_for_each_rcu(rdev2, mddev2) {
2276 [ # # # # ]: 0 : if (test_bit(Faulty, &rdev2->flags) ||
2277 : 0 : test_bit(Journal, &rdev2->flags) ||
2278 [ # # ]: 0 : rdev2->raid_disk == -1)
2279 : 0 : continue;
2280 : 0 : if (rdev->bdev->bd_contains ==
2281 [ # # ]: 0 : rdev2->bdev->bd_contains) {
2282 : 0 : rcu_read_unlock();
2283 : 0 : return 1;
2284 : : }
2285 : : }
2286 : : }
2287 : 0 : rcu_read_unlock();
2288 : 0 : return 0;
2289 : : }
2290 : :
2291 : : static LIST_HEAD(pending_raid_disks);
2292 : :
2293 : : /*
2294 : : * Try to register data integrity profile for an mddev
2295 : : *
2296 : : * This is called when an array is started and after a disk has been kicked
2297 : : * from the array. It only succeeds if all working and active component devices
2298 : : * are integrity capable with matching profiles.
2299 : : */
2300 : 0 : int md_integrity_register(struct mddev *mddev)
2301 : : {
2302 : 0 : struct md_rdev *rdev, *reference = NULL;
2303 : :
2304 [ # # ]: 0 : if (list_empty(&mddev->disks))
2305 : : return 0; /* nothing to do */
2306 [ # # ]: 0 : if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
2307 : : return 0; /* shouldn't register, or already is */
2308 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2309 : : /* skip spares and non-functional disks */
2310 : 0 : if (test_bit(Faulty, &rdev->flags))
2311 : : continue;
2312 : 0 : if (rdev->raid_disk < 0)
2313 : : continue;
2314 : 0 : if (!reference) {
2315 : : /* Use the first rdev as the reference */
2316 : : reference = rdev;
2317 : : continue;
2318 : : }
2319 : : /* does this rdev's profile match the reference profile? */
2320 : 0 : if (blk_integrity_compare(reference->bdev->bd_disk,
2321 : : rdev->bdev->bd_disk) < 0)
2322 : : return -EINVAL;
2323 : : }
2324 : : if (!reference || !bdev_get_integrity(reference->bdev))
2325 : : return 0;
2326 : : /*
2327 : : * All component devices are integrity capable and have matching
2328 : : * profiles, register the common profile for the md device.
2329 : : */
2330 : : blk_integrity_register(mddev->gendisk,
2331 : : bdev_get_integrity(reference->bdev));
2332 : :
2333 : : pr_debug("md: data integrity enabled on %s\n", mdname(mddev));
2334 : : if (bioset_integrity_create(&mddev->bio_set, BIO_POOL_SIZE)) {
2335 : : pr_err("md: failed to create integrity pool for %s\n",
2336 : : mdname(mddev));
2337 : : return -EINVAL;
2338 : : }
2339 : : return 0;
2340 : : }
2341 : : EXPORT_SYMBOL(md_integrity_register);
2342 : :
2343 : : /*
2344 : : * Attempt to add an rdev, but only if it is consistent with the current
2345 : : * integrity profile
2346 : : */
2347 : 0 : int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
2348 : : {
2349 : 0 : struct blk_integrity *bi_mddev;
2350 : 0 : char name[BDEVNAME_SIZE];
2351 : :
2352 : 0 : if (!mddev->gendisk)
2353 : : return 0;
2354 : :
2355 : 0 : bi_mddev = blk_get_integrity(mddev->gendisk);
2356 : :
2357 : 0 : if (!bi_mddev) /* nothing to do */
2358 : 0 : return 0;
2359 : :
2360 : : if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
2361 : : pr_err("%s: incompatible integrity profile for %s\n",
2362 : : mdname(mddev), bdevname(rdev->bdev, name));
2363 : : return -ENXIO;
2364 : : }
2365 : :
2366 : : return 0;
2367 : : }
2368 : : EXPORT_SYMBOL(md_integrity_add_rdev);
2369 : :
2370 : 0 : static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
2371 : : {
2372 : 0 : char b[BDEVNAME_SIZE];
2373 : 0 : struct kobject *ko;
2374 : 0 : int err;
2375 : :
2376 : : /* prevent duplicates */
2377 [ # # ]: 0 : if (find_rdev(mddev, rdev->bdev->bd_dev))
2378 : : return -EEXIST;
2379 : :
2380 [ # # # # ]: 0 : if ((bdev_read_only(rdev->bdev) || bdev_read_only(rdev->meta_bdev)) &&
2381 [ # # ]: 0 : mddev->pers)
2382 : : return -EROFS;
2383 : :
2384 : : /* make sure rdev->sectors exceeds mddev->dev_sectors */
2385 [ # # ]: 0 : if (!test_bit(Journal, &rdev->flags) &&
2386 [ # # ]: 0 : rdev->sectors &&
2387 [ # # # # ]: 0 : (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
2388 [ # # ]: 0 : if (mddev->pers) {
2389 : : /* Cannot change size, so fail
2390 : : * If mddev->level <= 0, then we don't care
2391 : : * about aligning sizes (e.g. linear)
2392 : : */
2393 [ # # ]: 0 : if (mddev->level > 0)
2394 : : return -ENOSPC;
2395 : : } else
2396 : 0 : mddev->dev_sectors = rdev->sectors;
2397 : : }
2398 : :
2399 : : /* Verify rdev->desc_nr is unique.
2400 : : * If it is -1, assign a free number, else
2401 : : * check number is not in use
2402 : : */
2403 : 0 : rcu_read_lock();
2404 [ # # ]: 0 : if (rdev->desc_nr < 0) {
2405 : 0 : int choice = 0;
2406 [ # # ]: 0 : if (mddev->pers)
2407 : 0 : choice = mddev->raid_disks;
2408 [ # # ]: 0 : while (md_find_rdev_nr_rcu(mddev, choice))
2409 : 0 : choice++;
2410 : 0 : rdev->desc_nr = choice;
2411 : : } else {
2412 [ # # ]: 0 : if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
2413 : 0 : rcu_read_unlock();
2414 : 0 : return -EBUSY;
2415 : : }
2416 : : }
2417 : 0 : rcu_read_unlock();
2418 [ # # ]: 0 : if (!test_bit(Journal, &rdev->flags) &&
2419 [ # # # # ]: 0 : mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
2420 [ # # ]: 0 : pr_warn("md: %s: array is limited to %d devices\n",
2421 : : mdname(mddev), mddev->max_disks);
2422 : 0 : return -EBUSY;
2423 : : }
2424 : 0 : bdevname(rdev->bdev,b);
2425 : 0 : strreplace(b, '/', '!');
2426 : :
2427 : 0 : rdev->mddev = mddev;
2428 : 0 : pr_debug("md: bind<%s>\n", b);
2429 : :
2430 [ # # ]: 0 : if (mddev->raid_disks)
2431 : 0 : mddev_create_serial_pool(mddev, rdev, false);
2432 : :
2433 [ # # ]: 0 : if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2434 : 0 : goto fail;
2435 : :
2436 : 0 : ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
2437 : 0 : if (sysfs_create_link(&rdev->kobj, ko, "block"))
2438 : : /* failure here is OK */;
2439 [ # # ]: 0 : rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
2440 : :
2441 : 0 : list_add_rcu(&rdev->same_set, &mddev->disks);
2442 : 0 : bd_link_disk_holder(rdev->bdev, mddev->gendisk);
2443 : :
2444 : : /* May as well allow recovery to be retried once */
2445 : 0 : mddev->recovery_disabled++;
2446 : :
2447 : 0 : return 0;
2448 : :
2449 : : fail:
2450 [ # # ]: 0 : pr_warn("md: failed to register dev-%s for %s\n",
2451 : : b, mdname(mddev));
2452 : 0 : return err;
2453 : : }
2454 : :
2455 : 0 : static void md_delayed_delete(struct work_struct *ws)
2456 : : {
2457 : 0 : struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2458 : 0 : kobject_del(&rdev->kobj);
2459 : 0 : kobject_put(&rdev->kobj);
2460 : 0 : }
2461 : :
2462 : 0 : static void unbind_rdev_from_array(struct md_rdev *rdev)
2463 : : {
2464 : 0 : char b[BDEVNAME_SIZE];
2465 : :
2466 : 0 : bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2467 : 0 : list_del_rcu(&rdev->same_set);
2468 : 0 : pr_debug("md: unbind<%s>\n", bdevname(rdev->bdev,b));
2469 : 0 : mddev_destroy_serial_pool(rdev->mddev, rdev, false);
2470 : 0 : rdev->mddev = NULL;
2471 : 0 : sysfs_remove_link(&rdev->kobj, "block");
2472 : 0 : sysfs_put(rdev->sysfs_state);
2473 : 0 : rdev->sysfs_state = NULL;
2474 : 0 : rdev->badblocks.count = 0;
2475 : : /* We need to delay this, otherwise we can deadlock when
2476 : : * writing to 'remove' to "dev/state". We also need
2477 : : * to delay it due to rcu usage.
2478 : : */
2479 : 0 : synchronize_rcu();
2480 : 0 : INIT_WORK(&rdev->del_work, md_delayed_delete);
2481 : 0 : kobject_get(&rdev->kobj);
2482 : 0 : queue_work(md_misc_wq, &rdev->del_work);
2483 : 0 : }
2484 : :
2485 : : /*
2486 : : * prevent the device from being mounted, repartitioned or
2487 : : * otherwise reused by a RAID array (or any other kernel
2488 : : * subsystem), by bd_claiming the device.
2489 : : */
2490 : 0 : static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
2491 : : {
2492 : 0 : int err = 0;
2493 : 0 : struct block_device *bdev;
2494 : 0 : char b[BDEVNAME_SIZE];
2495 : :
2496 [ # # ]: 0 : bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2497 : : shared ? (struct md_rdev *)lock_rdev : rdev);
2498 [ # # ]: 0 : if (IS_ERR(bdev)) {
2499 : 0 : pr_warn("md: could not open %s.\n", __bdevname(dev, b));
2500 : 0 : return PTR_ERR(bdev);
2501 : : }
2502 : 0 : rdev->bdev = bdev;
2503 : 0 : return err;
2504 : : }
2505 : :
2506 : 0 : static void unlock_rdev(struct md_rdev *rdev)
2507 : : {
2508 : 0 : struct block_device *bdev = rdev->bdev;
2509 : 0 : rdev->bdev = NULL;
2510 : 0 : blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
2511 : 0 : }
2512 : :
2513 : : void md_autodetect_dev(dev_t dev);
2514 : :
2515 : 0 : static void export_rdev(struct md_rdev *rdev)
2516 : : {
2517 : 0 : char b[BDEVNAME_SIZE];
2518 : :
2519 : 0 : pr_debug("md: export_rdev(%s)\n", bdevname(rdev->bdev,b));
2520 : 0 : md_rdev_clear(rdev);
2521 : : #ifndef MODULE
2522 [ # # ]: 0 : if (test_bit(AutoDetected, &rdev->flags))
2523 : 0 : md_autodetect_dev(rdev->bdev->bd_dev);
2524 : : #endif
2525 : 0 : unlock_rdev(rdev);
2526 : 0 : kobject_put(&rdev->kobj);
2527 : 0 : }
2528 : :
2529 : 0 : void md_kick_rdev_from_array(struct md_rdev *rdev)
2530 : : {
2531 : 0 : unbind_rdev_from_array(rdev);
2532 : 0 : export_rdev(rdev);
2533 : 0 : }
2534 : : EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
2535 : :
2536 : 0 : static void export_array(struct mddev *mddev)
2537 : : {
2538 : 0 : struct md_rdev *rdev;
2539 : :
2540 [ # # ]: 0 : while (!list_empty(&mddev->disks)) {
2541 : 0 : rdev = list_first_entry(&mddev->disks, struct md_rdev,
2542 : : same_set);
2543 : 0 : md_kick_rdev_from_array(rdev);
2544 : : }
2545 : 0 : mddev->raid_disks = 0;
2546 : 0 : mddev->major_version = 0;
2547 : 0 : }
2548 : :
2549 : 0 : static bool set_in_sync(struct mddev *mddev)
2550 : : {
2551 : 0 : lockdep_assert_held(&mddev->lock);
2552 [ # # ]: 0 : if (!mddev->in_sync) {
2553 : 0 : mddev->sync_checkers++;
2554 : 0 : spin_unlock(&mddev->lock);
2555 : 0 : percpu_ref_switch_to_atomic_sync(&mddev->writes_pending);
2556 : 0 : spin_lock(&mddev->lock);
2557 [ # # # # ]: 0 : if (!mddev->in_sync &&
2558 : : percpu_ref_is_zero(&mddev->writes_pending)) {
2559 : 0 : mddev->in_sync = 1;
2560 : : /*
2561 : : * Ensure ->in_sync is visible before we clear
2562 : : * ->sync_checkers.
2563 : : */
2564 : 0 : smp_mb();
2565 : 0 : set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
2566 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
2567 : : }
2568 [ # # ]: 0 : if (--mddev->sync_checkers == 0)
2569 : 0 : percpu_ref_switch_to_percpu(&mddev->writes_pending);
2570 : : }
2571 [ # # ]: 0 : if (mddev->safemode == 1)
2572 : 0 : mddev->safemode = 0;
2573 : 0 : return mddev->in_sync;
2574 : : }
2575 : :
2576 : 0 : static void sync_sbs(struct mddev *mddev, int nospares)
2577 : : {
2578 : : /* Update each superblock (in-memory image), but
2579 : : * if we are allowed to, skip spares which already
2580 : : * have the right event counter, or have one earlier
2581 : : * (which would mean they aren't being marked as dirty
2582 : : * with the rest of the array)
2583 : : */
2584 : 0 : struct md_rdev *rdev;
2585 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2586 [ # # # # ]: 0 : if (rdev->sb_events == mddev->events ||
2587 : 0 : (nospares &&
2588 [ # # ]: 0 : rdev->raid_disk < 0 &&
2589 [ # # ]: 0 : rdev->sb_events+1 == mddev->events)) {
2590 : : /* Don't update this superblock */
2591 : 0 : rdev->sb_loaded = 2;
2592 : : } else {
2593 : 0 : sync_super(mddev, rdev);
2594 : 0 : rdev->sb_loaded = 1;
2595 : : }
2596 : : }
2597 : 0 : }
2598 : :
2599 : 0 : static bool does_sb_need_changing(struct mddev *mddev)
2600 : : {
2601 : 0 : struct md_rdev *rdev;
2602 : 0 : struct mdp_superblock_1 *sb;
2603 : 0 : int role;
2604 : :
2605 : : /* Find a good rdev */
2606 [ # # ]: 0 : rdev_for_each(rdev, mddev)
2607 [ # # # # ]: 0 : if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
2608 : : break;
2609 : :
2610 : : /* No good device found. */
2611 [ # # ]: 0 : if (!rdev)
2612 : : return false;
2613 : :
2614 : 0 : sb = page_address(rdev->sb_page);
2615 : : /* Check if a device has become faulty or a spare become active */
2616 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2617 : 0 : role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
2618 : : /* Device activated? */
2619 [ # # # # : 0 : if (role == 0xffff && rdev->raid_disk >=0 &&
# # ]
2620 : 0 : !test_bit(Faulty, &rdev->flags))
2621 : : return true;
2622 : : /* Device turned faulty? */
2623 [ # # # # ]: 0 : if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
2624 : : return true;
2625 : : }
2626 : :
2627 : : /* Check if any mddev parameters have changed */
2628 [ # # ]: 0 : if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
2629 [ # # ]: 0 : (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
2630 [ # # ]: 0 : (mddev->layout != le32_to_cpu(sb->layout)) ||
2631 [ # # ]: 0 : (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
2632 [ # # ]: 0 : (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
2633 : 0 : return true;
2634 : :
2635 : : return false;
2636 : : }
2637 : :
2638 : 0 : void md_update_sb(struct mddev *mddev, int force_change)
2639 : : {
2640 : 0 : struct md_rdev *rdev;
2641 : 0 : int sync_req;
2642 : 0 : int nospares = 0;
2643 : 0 : int any_badblocks_changed = 0;
2644 : 0 : int ret = -1;
2645 : :
2646 [ # # ]: 0 : if (mddev->ro) {
2647 [ # # ]: 0 : if (force_change)
2648 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2649 : 0 : return;
2650 : : }
2651 : :
2652 : 0 : repeat:
2653 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
2654 [ # # ]: 0 : if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
2655 : 0 : force_change = 1;
2656 [ # # ]: 0 : if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
2657 : 0 : nospares = 1;
2658 : 0 : ret = md_cluster_ops->metadata_update_start(mddev);
2659 : : /* Has someone else has updated the sb */
2660 [ # # ]: 0 : if (!does_sb_need_changing(mddev)) {
2661 [ # # ]: 0 : if (ret == 0)
2662 : 0 : md_cluster_ops->metadata_update_cancel(mddev);
2663 [ # # # # ]: 0 : bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
2664 : : BIT(MD_SB_CHANGE_DEVS) |
2665 : : BIT(MD_SB_CHANGE_CLEAN));
2666 : 0 : return;
2667 : : }
2668 : : }
2669 : :
2670 : : /*
2671 : : * First make sure individual recovery_offsets are correct
2672 : : * curr_resync_completed can only be used during recovery.
2673 : : * During reshape/resync it might use array-addresses rather
2674 : : * that device addresses.
2675 : : */
2676 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2677 [ # # ]: 0 : if (rdev->raid_disk >= 0 &&
2678 [ # # # # ]: 0 : mddev->delta_disks >= 0 &&
2679 [ # # ]: 0 : test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
2680 [ # # ]: 0 : test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
2681 [ # # ]: 0 : !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
2682 [ # # ]: 0 : !test_bit(Journal, &rdev->flags) &&
2683 : 0 : !test_bit(In_sync, &rdev->flags) &&
2684 [ # # ]: 0 : mddev->curr_resync_completed > rdev->recovery_offset)
2685 : 0 : rdev->recovery_offset = mddev->curr_resync_completed;
2686 : :
2687 : : }
2688 [ # # ]: 0 : if (!mddev->persistent) {
2689 : 0 : clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
2690 : 0 : clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2691 [ # # ]: 0 : if (!mddev->external) {
2692 : 0 : clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
2693 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2694 [ # # ]: 0 : if (rdev->badblocks.changed) {
2695 : 0 : rdev->badblocks.changed = 0;
2696 : 0 : ack_all_badblocks(&rdev->badblocks);
2697 : 0 : md_error(mddev, rdev);
2698 : : }
2699 : 0 : clear_bit(Blocked, &rdev->flags);
2700 : 0 : clear_bit(BlockedBadBlocks, &rdev->flags);
2701 : 0 : wake_up(&rdev->blocked_wait);
2702 : : }
2703 : : }
2704 : 0 : wake_up(&mddev->sb_wait);
2705 : 0 : return;
2706 : : }
2707 : :
2708 : 0 : spin_lock(&mddev->lock);
2709 : :
2710 : 0 : mddev->utime = ktime_get_real_seconds();
2711 : :
2712 [ # # ]: 0 : if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
2713 : 0 : force_change = 1;
2714 [ # # ]: 0 : if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
2715 : : /* just a clean<-> dirty transition, possibly leave spares alone,
2716 : : * though if events isn't the right even/odd, we will have to do
2717 : : * spares after all
2718 : : */
2719 : 0 : nospares = 1;
2720 [ # # ]: 0 : if (force_change)
2721 : 0 : nospares = 0;
2722 [ # # ]: 0 : if (mddev->degraded)
2723 : : /* If the array is degraded, then skipping spares is both
2724 : : * dangerous and fairly pointless.
2725 : : * Dangerous because a device that was removed from the array
2726 : : * might have a event_count that still looks up-to-date,
2727 : : * so it can be re-added without a resync.
2728 : : * Pointless because if there are any spares to skip,
2729 : : * then a recovery will happen and soon that array won't
2730 : : * be degraded any more and the spare can go back to sleep then.
2731 : : */
2732 : 0 : nospares = 0;
2733 : :
2734 : 0 : sync_req = mddev->in_sync;
2735 : :
2736 : : /* If this is just a dirty<->clean transition, and the array is clean
2737 : : * and 'events' is odd, we can roll back to the previous clean state */
2738 [ # # ]: 0 : if (nospares
2739 [ # # # # ]: 0 : && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2740 [ # # ]: 0 : && mddev->can_decrease_events
2741 [ # # ]: 0 : && mddev->events != 1) {
2742 : 0 : mddev->events--;
2743 : 0 : mddev->can_decrease_events = 0;
2744 : : } else {
2745 : : /* otherwise we have to go forward and ... */
2746 : 0 : mddev->events ++;
2747 : 0 : mddev->can_decrease_events = nospares;
2748 : : }
2749 : :
2750 : : /*
2751 : : * This 64-bit counter should never wrap.
2752 : : * Either we are in around ~1 trillion A.C., assuming
2753 : : * 1 reboot per second, or we have a bug...
2754 : : */
2755 [ # # ]: 0 : WARN_ON(mddev->events == 0);
2756 : :
2757 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2758 [ # # ]: 0 : if (rdev->badblocks.changed)
2759 : 0 : any_badblocks_changed++;
2760 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
2761 : 0 : set_bit(FaultRecorded, &rdev->flags);
2762 : : }
2763 : :
2764 : 0 : sync_sbs(mddev, nospares);
2765 : 0 : spin_unlock(&mddev->lock);
2766 : :
2767 : 0 : pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2768 : : mdname(mddev), mddev->in_sync);
2769 : :
2770 [ # # ]: 0 : if (mddev->queue)
2771 [ # # ]: 0 : blk_add_trace_msg(mddev->queue, "md md_update_sb");
2772 : 0 : rewrite:
2773 : 0 : md_bitmap_update_sb(mddev->bitmap);
2774 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2775 : 0 : char b[BDEVNAME_SIZE];
2776 : :
2777 [ # # ]: 0 : if (rdev->sb_loaded != 1)
2778 : 0 : continue; /* no noise on spare devices */
2779 : :
2780 [ # # ]: 0 : if (!test_bit(Faulty, &rdev->flags)) {
2781 : 0 : md_super_write(mddev,rdev,
2782 : : rdev->sb_start, rdev->sb_size,
2783 : : rdev->sb_page);
2784 : 0 : pr_debug("md: (write) %s's sb offset: %llu\n",
2785 : : bdevname(rdev->bdev, b),
2786 : : (unsigned long long)rdev->sb_start);
2787 : 0 : rdev->sb_events = mddev->events;
2788 [ # # ]: 0 : if (rdev->badblocks.size) {
2789 : 0 : md_super_write(mddev, rdev,
2790 : : rdev->badblocks.sector,
2791 : 0 : rdev->badblocks.size << 9,
2792 : : rdev->bb_page);
2793 : 0 : rdev->badblocks.size = 0;
2794 : : }
2795 : :
2796 : : } else
2797 : : pr_debug("md: %s (skipping faulty)\n",
2798 : : bdevname(rdev->bdev, b));
2799 : :
2800 [ # # ]: 0 : if (mddev->level == LEVEL_MULTIPATH)
2801 : : /* only need to write one superblock... */
2802 : : break;
2803 : : }
2804 [ # # ]: 0 : if (md_super_wait(mddev) < 0)
2805 : 0 : goto rewrite;
2806 : : /* if there was a failure, MD_SB_CHANGE_DEVS was set, and we re-write super */
2807 : :
2808 [ # # # # ]: 0 : if (mddev_is_clustered(mddev) && ret == 0)
2809 : 0 : md_cluster_ops->metadata_update_finish(mddev);
2810 : :
2811 [ # # ]: 0 : if (mddev->in_sync != sync_req ||
2812 [ # # # # : 0 : !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
# # ]
2813 : : BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN)))
2814 : : /* have to write it out again */
2815 : 0 : goto repeat;
2816 : 0 : wake_up(&mddev->sb_wait);
2817 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2818 : 0 : sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2819 : :
2820 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
2821 [ # # ]: 0 : if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2822 : 0 : clear_bit(Blocked, &rdev->flags);
2823 : :
2824 [ # # ]: 0 : if (any_badblocks_changed)
2825 : 0 : ack_all_badblocks(&rdev->badblocks);
2826 : 0 : clear_bit(BlockedBadBlocks, &rdev->flags);
2827 : 0 : wake_up(&rdev->blocked_wait);
2828 : : }
2829 : : }
2830 : : EXPORT_SYMBOL(md_update_sb);
2831 : :
2832 : 0 : static int add_bound_rdev(struct md_rdev *rdev)
2833 : : {
2834 : 0 : struct mddev *mddev = rdev->mddev;
2835 : 0 : int err = 0;
2836 : 0 : bool add_journal = test_bit(Journal, &rdev->flags);
2837 : :
2838 [ # # # # ]: 0 : if (!mddev->pers->hot_remove_disk || add_journal) {
2839 : : /* If there is hot_add_disk but no hot_remove_disk
2840 : : * then added disks for geometry changes,
2841 : : * and should be added immediately.
2842 : : */
2843 : 0 : super_types[mddev->major_version].
2844 : : validate_super(mddev, rdev);
2845 [ # # ]: 0 : if (add_journal)
2846 : 0 : mddev_suspend(mddev);
2847 : 0 : err = mddev->pers->hot_add_disk(mddev, rdev);
2848 [ # # ]: 0 : if (add_journal)
2849 : 0 : mddev_resume(mddev);
2850 [ # # ]: 0 : if (err) {
2851 : 0 : md_kick_rdev_from_array(rdev);
2852 : 0 : return err;
2853 : : }
2854 : : }
2855 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
2856 : :
2857 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2858 [ # # ]: 0 : if (mddev->degraded)
2859 : 0 : set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2860 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2861 : 0 : md_new_event(mddev);
2862 : 0 : md_wakeup_thread(mddev->thread);
2863 : 0 : return 0;
2864 : : }
2865 : :
2866 : : /* words written to sysfs files may, or may not, be \n terminated.
2867 : : * We want to accept with case. For this we use cmd_match.
2868 : : */
2869 : 0 : static int cmd_match(const char *cmd, const char *str)
2870 : : {
2871 : : /* See if cmd, written into a sysfs file, matches
2872 : : * str. They must either be the same, or cmd can
2873 : : * have a trailing newline
2874 : : */
2875 [ # # # # : 0 : while (*cmd && *str && *cmd == *str) {
# # ]
2876 : 0 : cmd++;
2877 : 0 : str++;
2878 : : }
2879 [ # # ]: 0 : if (*cmd == '\n')
2880 : 0 : cmd++;
2881 [ # # # # ]: 0 : if (*str || *cmd)
2882 : 0 : return 0;
2883 : : return 1;
2884 : : }
2885 : :
2886 : : struct rdev_sysfs_entry {
2887 : : struct attribute attr;
2888 : : ssize_t (*show)(struct md_rdev *, char *);
2889 : : ssize_t (*store)(struct md_rdev *, const char *, size_t);
2890 : : };
2891 : :
2892 : : static ssize_t
2893 : 0 : state_show(struct md_rdev *rdev, char *page)
2894 : : {
2895 : 0 : char *sep = ",";
2896 : 0 : size_t len = 0;
2897 : 0 : unsigned long flags = READ_ONCE(rdev->flags);
2898 : :
2899 [ # # # # ]: 0 : if (test_bit(Faulty, &flags) ||
2900 : 0 : (!test_bit(ExternalBbl, &flags) &&
2901 [ # # ]: 0 : rdev->badblocks.unacked_exist))
2902 : 0 : len += sprintf(page+len, "faulty%s", sep);
2903 [ # # ]: 0 : if (test_bit(In_sync, &flags))
2904 : 0 : len += sprintf(page+len, "in_sync%s", sep);
2905 [ # # ]: 0 : if (test_bit(Journal, &flags))
2906 : 0 : len += sprintf(page+len, "journal%s", sep);
2907 [ # # ]: 0 : if (test_bit(WriteMostly, &flags))
2908 : 0 : len += sprintf(page+len, "write_mostly%s", sep);
2909 [ # # ]: 0 : if (test_bit(Blocked, &flags) ||
2910 [ # # ]: 0 : (rdev->badblocks.unacked_exist
2911 [ # # ]: 0 : && !test_bit(Faulty, &flags)))
2912 : 0 : len += sprintf(page+len, "blocked%s", sep);
2913 [ # # # # ]: 0 : if (!test_bit(Faulty, &flags) &&
2914 [ # # ]: 0 : !test_bit(Journal, &flags) &&
2915 : : !test_bit(In_sync, &flags))
2916 : 0 : len += sprintf(page+len, "spare%s", sep);
2917 [ # # ]: 0 : if (test_bit(WriteErrorSeen, &flags))
2918 : 0 : len += sprintf(page+len, "write_error%s", sep);
2919 [ # # ]: 0 : if (test_bit(WantReplacement, &flags))
2920 : 0 : len += sprintf(page+len, "want_replacement%s", sep);
2921 [ # # ]: 0 : if (test_bit(Replacement, &flags))
2922 : 0 : len += sprintf(page+len, "replacement%s", sep);
2923 [ # # ]: 0 : if (test_bit(ExternalBbl, &flags))
2924 : 0 : len += sprintf(page+len, "external_bbl%s", sep);
2925 [ # # ]: 0 : if (test_bit(FailFast, &flags))
2926 : 0 : len += sprintf(page+len, "failfast%s", sep);
2927 : :
2928 [ # # ]: 0 : if (len)
2929 : 0 : len -= strlen(sep);
2930 : :
2931 : 0 : return len+sprintf(page+len, "\n");
2932 : : }
2933 : :
2934 : : static ssize_t
2935 : 0 : state_store(struct md_rdev *rdev, const char *buf, size_t len)
2936 : : {
2937 : : /* can write
2938 : : * faulty - simulates an error
2939 : : * remove - disconnects the device
2940 : : * writemostly - sets write_mostly
2941 : : * -writemostly - clears write_mostly
2942 : : * blocked - sets the Blocked flags
2943 : : * -blocked - clears the Blocked and possibly simulates an error
2944 : : * insync - sets Insync providing device isn't active
2945 : : * -insync - clear Insync for a device with a slot assigned,
2946 : : * so that it gets rebuilt based on bitmap
2947 : : * write_error - sets WriteErrorSeen
2948 : : * -write_error - clears WriteErrorSeen
2949 : : * {,-}failfast - set/clear FailFast
2950 : : */
2951 : 0 : int err = -EINVAL;
2952 [ # # # # ]: 0 : if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2953 : 0 : md_error(rdev->mddev, rdev);
2954 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
2955 : : err = 0;
2956 : : else
2957 : : err = -EBUSY;
2958 [ # # ]: 0 : } else if (cmd_match(buf, "remove")) {
2959 [ # # ]: 0 : if (rdev->mddev->pers) {
2960 : 0 : clear_bit(Blocked, &rdev->flags);
2961 : 0 : remove_and_add_spares(rdev->mddev, rdev);
2962 : : }
2963 [ # # ]: 0 : if (rdev->raid_disk >= 0)
2964 : : err = -EBUSY;
2965 : : else {
2966 : 0 : struct mddev *mddev = rdev->mddev;
2967 : 0 : err = 0;
2968 [ # # ]: 0 : if (mddev_is_clustered(mddev))
2969 : 0 : err = md_cluster_ops->remove_disk(mddev, rdev);
2970 : :
2971 [ # # ]: 0 : if (err == 0) {
2972 : 0 : md_kick_rdev_from_array(rdev);
2973 [ # # ]: 0 : if (mddev->pers) {
2974 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2975 : 0 : md_wakeup_thread(mddev->thread);
2976 : : }
2977 : 0 : md_new_event(mddev);
2978 : : }
2979 : : }
2980 [ # # ]: 0 : } else if (cmd_match(buf, "writemostly")) {
2981 : 0 : set_bit(WriteMostly, &rdev->flags);
2982 : 0 : mddev_create_serial_pool(rdev->mddev, rdev, false);
2983 : 0 : err = 0;
2984 [ # # ]: 0 : } else if (cmd_match(buf, "-writemostly")) {
2985 : 0 : mddev_destroy_serial_pool(rdev->mddev, rdev, false);
2986 : 0 : clear_bit(WriteMostly, &rdev->flags);
2987 : 0 : err = 0;
2988 [ # # ]: 0 : } else if (cmd_match(buf, "blocked")) {
2989 : 0 : set_bit(Blocked, &rdev->flags);
2990 : 0 : err = 0;
2991 [ # # ]: 0 : } else if (cmd_match(buf, "-blocked")) {
2992 [ # # # # ]: 0 : if (!test_bit(Faulty, &rdev->flags) &&
2993 : 0 : !test_bit(ExternalBbl, &rdev->flags) &&
2994 [ # # ]: 0 : rdev->badblocks.unacked_exist) {
2995 : : /* metadata handler doesn't understand badblocks,
2996 : : * so we need to fail the device
2997 : : */
2998 : 0 : md_error(rdev->mddev, rdev);
2999 : : }
3000 : 0 : clear_bit(Blocked, &rdev->flags);
3001 : 0 : clear_bit(BlockedBadBlocks, &rdev->flags);
3002 : 0 : wake_up(&rdev->blocked_wait);
3003 : 0 : set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3004 : 0 : md_wakeup_thread(rdev->mddev->thread);
3005 : :
3006 : 0 : err = 0;
3007 [ # # # # ]: 0 : } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
3008 : 0 : set_bit(In_sync, &rdev->flags);
3009 : 0 : err = 0;
3010 [ # # ]: 0 : } else if (cmd_match(buf, "failfast")) {
3011 : 0 : set_bit(FailFast, &rdev->flags);
3012 : 0 : err = 0;
3013 [ # # ]: 0 : } else if (cmd_match(buf, "-failfast")) {
3014 : 0 : clear_bit(FailFast, &rdev->flags);
3015 : 0 : err = 0;
3016 [ # # # # : 0 : } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
# # ]
3017 : 0 : !test_bit(Journal, &rdev->flags)) {
3018 [ # # ]: 0 : if (rdev->mddev->pers == NULL) {
3019 : 0 : clear_bit(In_sync, &rdev->flags);
3020 : 0 : rdev->saved_raid_disk = rdev->raid_disk;
3021 : 0 : rdev->raid_disk = -1;
3022 : 0 : err = 0;
3023 : : }
3024 [ # # ]: 0 : } else if (cmd_match(buf, "write_error")) {
3025 : 0 : set_bit(WriteErrorSeen, &rdev->flags);
3026 : 0 : err = 0;
3027 [ # # ]: 0 : } else if (cmd_match(buf, "-write_error")) {
3028 : 0 : clear_bit(WriteErrorSeen, &rdev->flags);
3029 : 0 : err = 0;
3030 [ # # ]: 0 : } else if (cmd_match(buf, "want_replacement")) {
3031 : : /* Any non-spare device that is not a replacement can
3032 : : * become want_replacement at any time, but we then need to
3033 : : * check if recovery is needed.
3034 : : */
3035 [ # # # # ]: 0 : if (rdev->raid_disk >= 0 &&
3036 [ # # ]: 0 : !test_bit(Journal, &rdev->flags) &&
3037 : : !test_bit(Replacement, &rdev->flags))
3038 : 0 : set_bit(WantReplacement, &rdev->flags);
3039 : 0 : set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3040 : 0 : md_wakeup_thread(rdev->mddev->thread);
3041 : 0 : err = 0;
3042 [ # # ]: 0 : } else if (cmd_match(buf, "-want_replacement")) {
3043 : : /* Clearing 'want_replacement' is always allowed.
3044 : : * Once replacements starts it is too late though.
3045 : : */
3046 : 0 : err = 0;
3047 : 0 : clear_bit(WantReplacement, &rdev->flags);
3048 [ # # ]: 0 : } else if (cmd_match(buf, "replacement")) {
3049 : : /* Can only set a device as a replacement when array has not
3050 : : * yet been started. Once running, replacement is automatic
3051 : : * from spares, or by assigning 'slot'.
3052 : : */
3053 [ # # ]: 0 : if (rdev->mddev->pers)
3054 : : err = -EBUSY;
3055 : : else {
3056 : 0 : set_bit(Replacement, &rdev->flags);
3057 : 0 : err = 0;
3058 : : }
3059 [ # # ]: 0 : } else if (cmd_match(buf, "-replacement")) {
3060 : : /* Similarly, can only clear Replacement before start */
3061 [ # # ]: 0 : if (rdev->mddev->pers)
3062 : : err = -EBUSY;
3063 : : else {
3064 : 0 : clear_bit(Replacement, &rdev->flags);
3065 : 0 : err = 0;
3066 : : }
3067 [ # # ]: 0 : } else if (cmd_match(buf, "re-add")) {
3068 [ # # ]: 0 : if (!rdev->mddev->pers)
3069 : : err = -EINVAL;
3070 [ # # # # ]: 0 : else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
3071 [ # # ]: 0 : rdev->saved_raid_disk >= 0) {
3072 : : /* clear_bit is performed _after_ all the devices
3073 : : * have their local Faulty bit cleared. If any writes
3074 : : * happen in the meantime in the local node, they
3075 : : * will land in the local bitmap, which will be synced
3076 : : * by this node eventually
3077 : : */
3078 [ # # # # ]: 0 : if (!mddev_is_clustered(rdev->mddev) ||
3079 : 0 : (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
3080 : 0 : clear_bit(Faulty, &rdev->flags);
3081 : 0 : err = add_bound_rdev(rdev);
3082 : : }
3083 : : } else
3084 : : err = -EBUSY;
3085 [ # # # # ]: 0 : } else if (cmd_match(buf, "external_bbl") && (rdev->mddev->external)) {
3086 : 0 : set_bit(ExternalBbl, &rdev->flags);
3087 : 0 : rdev->badblocks.shift = 0;
3088 : 0 : err = 0;
3089 [ # # # # ]: 0 : } else if (cmd_match(buf, "-external_bbl") && (rdev->mddev->external)) {
3090 : 0 : clear_bit(ExternalBbl, &rdev->flags);
3091 : 0 : err = 0;
3092 : : }
3093 [ # # ]: 0 : if (!err)
3094 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
3095 [ # # ]: 0 : return err ? err : len;
3096 : : }
3097 : : static struct rdev_sysfs_entry rdev_state =
3098 : : __ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
3099 : :
3100 : : static ssize_t
3101 : 0 : errors_show(struct md_rdev *rdev, char *page)
3102 : : {
3103 : 0 : return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
3104 : : }
3105 : :
3106 : : static ssize_t
3107 : 0 : errors_store(struct md_rdev *rdev, const char *buf, size_t len)
3108 : : {
3109 : 0 : unsigned int n;
3110 : 0 : int rv;
3111 : :
3112 : 0 : rv = kstrtouint(buf, 10, &n);
3113 [ # # ]: 0 : if (rv < 0)
3114 : 0 : return rv;
3115 : 0 : atomic_set(&rdev->corrected_errors, n);
3116 : 0 : return len;
3117 : : }
3118 : : static struct rdev_sysfs_entry rdev_errors =
3119 : : __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
3120 : :
3121 : : static ssize_t
3122 : 0 : slot_show(struct md_rdev *rdev, char *page)
3123 : : {
3124 [ # # ]: 0 : if (test_bit(Journal, &rdev->flags))
3125 : 0 : return sprintf(page, "journal\n");
3126 [ # # ]: 0 : else if (rdev->raid_disk < 0)
3127 : 0 : return sprintf(page, "none\n");
3128 : : else
3129 : 0 : return sprintf(page, "%d\n", rdev->raid_disk);
3130 : : }
3131 : :
3132 : : static ssize_t
3133 : 0 : slot_store(struct md_rdev *rdev, const char *buf, size_t len)
3134 : : {
3135 : 0 : int slot;
3136 : 0 : int err;
3137 : :
3138 [ # # ]: 0 : if (test_bit(Journal, &rdev->flags))
3139 : : return -EBUSY;
3140 [ # # ]: 0 : if (strncmp(buf, "none", 4)==0)
3141 : 0 : slot = -1;
3142 : : else {
3143 : 0 : err = kstrtouint(buf, 10, (unsigned int *)&slot);
3144 [ # # ]: 0 : if (err < 0)
3145 : 0 : return err;
3146 : : }
3147 [ # # # # ]: 0 : if (rdev->mddev->pers && slot == -1) {
3148 : : /* Setting 'slot' on an active array requires also
3149 : : * updating the 'rd%d' link, and communicating
3150 : : * with the personality with ->hot_*_disk.
3151 : : * For now we only support removing
3152 : : * failed/spare devices. This normally happens automatically,
3153 : : * but not when the metadata is externally managed.
3154 : : */
3155 [ # # ]: 0 : if (rdev->raid_disk == -1)
3156 : : return -EEXIST;
3157 : : /* personality does all needed checks */
3158 [ # # ]: 0 : if (rdev->mddev->pers->hot_remove_disk == NULL)
3159 : : return -EINVAL;
3160 : 0 : clear_bit(Blocked, &rdev->flags);
3161 : 0 : remove_and_add_spares(rdev->mddev, rdev);
3162 [ # # ]: 0 : if (rdev->raid_disk >= 0)
3163 : : return -EBUSY;
3164 : 0 : set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3165 : 0 : md_wakeup_thread(rdev->mddev->thread);
3166 [ # # ]: 0 : } else if (rdev->mddev->pers) {
3167 : : /* Activating a spare .. or possibly reactivating
3168 : : * if we ever get bitmaps working here.
3169 : : */
3170 : 0 : int err;
3171 : :
3172 [ # # ]: 0 : if (rdev->raid_disk != -1)
3173 : : return -EBUSY;
3174 : :
3175 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
3176 : : return -EBUSY;
3177 : :
3178 [ # # ]: 0 : if (rdev->mddev->pers->hot_add_disk == NULL)
3179 : : return -EINVAL;
3180 : :
3181 [ # # ]: 0 : if (slot >= rdev->mddev->raid_disks &&
3182 [ # # ]: 0 : slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
3183 : : return -ENOSPC;
3184 : :
3185 : 0 : rdev->raid_disk = slot;
3186 [ # # ]: 0 : if (test_bit(In_sync, &rdev->flags))
3187 : 0 : rdev->saved_raid_disk = slot;
3188 : : else
3189 : 0 : rdev->saved_raid_disk = -1;
3190 : 0 : clear_bit(In_sync, &rdev->flags);
3191 : 0 : clear_bit(Bitmap_sync, &rdev->flags);
3192 : 0 : err = rdev->mddev->pers->
3193 : : hot_add_disk(rdev->mddev, rdev);
3194 [ # # ]: 0 : if (err) {
3195 : 0 : rdev->raid_disk = -1;
3196 : 0 : return err;
3197 : : } else
3198 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
3199 : 0 : if (sysfs_link_rdev(rdev->mddev, rdev))
3200 : : /* failure here is OK */;
3201 : : /* don't wakeup anyone, leave that to userspace. */
3202 : : } else {
3203 [ # # ]: 0 : if (slot >= rdev->mddev->raid_disks &&
3204 [ # # ]: 0 : slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
3205 : : return -ENOSPC;
3206 : 0 : rdev->raid_disk = slot;
3207 : : /* assume it is working */
3208 : 0 : clear_bit(Faulty, &rdev->flags);
3209 : 0 : clear_bit(WriteMostly, &rdev->flags);
3210 : 0 : set_bit(In_sync, &rdev->flags);
3211 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
3212 : : }
3213 : 0 : return len;
3214 : : }
3215 : :
3216 : : static struct rdev_sysfs_entry rdev_slot =
3217 : : __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
3218 : :
3219 : : static ssize_t
3220 : 0 : offset_show(struct md_rdev *rdev, char *page)
3221 : : {
3222 : 0 : return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
3223 : : }
3224 : :
3225 : : static ssize_t
3226 : 0 : offset_store(struct md_rdev *rdev, const char *buf, size_t len)
3227 : : {
3228 : 0 : unsigned long long offset;
3229 [ # # ]: 0 : if (kstrtoull(buf, 10, &offset) < 0)
3230 : : return -EINVAL;
3231 [ # # # # ]: 0 : if (rdev->mddev->pers && rdev->raid_disk >= 0)
3232 : : return -EBUSY;
3233 [ # # # # ]: 0 : if (rdev->sectors && rdev->mddev->external)
3234 : : /* Must set offset before size, so overlap checks
3235 : : * can be sane */
3236 : : return -EBUSY;
3237 : 0 : rdev->data_offset = offset;
3238 : 0 : rdev->new_data_offset = offset;
3239 : 0 : return len;
3240 : : }
3241 : :
3242 : : static struct rdev_sysfs_entry rdev_offset =
3243 : : __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
3244 : :
3245 : 0 : static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
3246 : : {
3247 : 0 : return sprintf(page, "%llu\n",
3248 : 0 : (unsigned long long)rdev->new_data_offset);
3249 : : }
3250 : :
3251 : 0 : static ssize_t new_offset_store(struct md_rdev *rdev,
3252 : : const char *buf, size_t len)
3253 : : {
3254 : 0 : unsigned long long new_offset;
3255 : 0 : struct mddev *mddev = rdev->mddev;
3256 : :
3257 [ # # ]: 0 : if (kstrtoull(buf, 10, &new_offset) < 0)
3258 : : return -EINVAL;
3259 : :
3260 [ # # # # ]: 0 : if (mddev->sync_thread ||
3261 : 0 : test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
3262 : 0 : return -EBUSY;
3263 [ # # ]: 0 : if (new_offset == rdev->data_offset)
3264 : : /* reset is always permitted */
3265 : : ;
3266 [ # # ]: 0 : else if (new_offset > rdev->data_offset) {
3267 : : /* must not push array size beyond rdev_sectors */
3268 : 0 : if (new_offset - rdev->data_offset
3269 [ # # ]: 0 : + mddev->dev_sectors > rdev->sectors)
3270 : : return -E2BIG;
3271 : : }
3272 : : /* Metadata worries about other space details. */
3273 : :
3274 : : /* decreasing the offset is inconsistent with a backwards
3275 : : * reshape.
3276 : : */
3277 [ # # ]: 0 : if (new_offset < rdev->data_offset &&
3278 [ # # ]: 0 : mddev->reshape_backwards)
3279 : : return -EINVAL;
3280 : : /* Increasing offset is inconsistent with forwards
3281 : : * reshape. reshape_direction should be set to
3282 : : * 'backwards' first.
3283 : : */
3284 [ # # ]: 0 : if (new_offset > rdev->data_offset &&
3285 [ # # ]: 0 : !mddev->reshape_backwards)
3286 : : return -EINVAL;
3287 : :
3288 [ # # # # : 0 : if (mddev->pers && mddev->persistent &&
# # ]
3289 : 0 : !super_types[mddev->major_version]
3290 : 0 : .allow_new_offset(rdev, new_offset))
3291 : : return -E2BIG;
3292 : 0 : rdev->new_data_offset = new_offset;
3293 [ # # ]: 0 : if (new_offset > rdev->data_offset)
3294 : 0 : mddev->reshape_backwards = 1;
3295 [ # # ]: 0 : else if (new_offset < rdev->data_offset)
3296 : 0 : mddev->reshape_backwards = 0;
3297 : :
3298 : 0 : return len;
3299 : : }
3300 : : static struct rdev_sysfs_entry rdev_new_offset =
3301 : : __ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
3302 : :
3303 : : static ssize_t
3304 : 0 : rdev_size_show(struct md_rdev *rdev, char *page)
3305 : : {
3306 : 0 : return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
3307 : : }
3308 : :
3309 : 0 : static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
3310 : : {
3311 : : /* check if two start/length pairs overlap */
3312 : 0 : if (s1+l1 <= s2)
3313 : : return 0;
3314 [ # # ]: 0 : if (s2+l2 <= s1)
3315 : : return 0;
3316 : : return 1;
3317 : : }
3318 : :
3319 : 0 : static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
3320 : : {
3321 : 0 : unsigned long long blocks;
3322 : 0 : sector_t new;
3323 : :
3324 [ # # ]: 0 : if (kstrtoull(buf, 10, &blocks) < 0)
3325 : : return -EINVAL;
3326 : :
3327 [ # # ]: 0 : if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
3328 : : return -EINVAL; /* sector conversion overflow */
3329 : :
3330 : 0 : new = blocks * 2;
3331 : 0 : if (new != blocks * 2)
3332 : : return -EINVAL; /* unsigned long long to sector_t overflow */
3333 : :
3334 : 0 : *sectors = new;
3335 : 0 : return 0;
3336 : : }
3337 : :
3338 : : static ssize_t
3339 : 0 : rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
3340 : : {
3341 : 0 : struct mddev *my_mddev = rdev->mddev;
3342 : 0 : sector_t oldsectors = rdev->sectors;
3343 : 0 : sector_t sectors;
3344 : :
3345 [ # # ]: 0 : if (test_bit(Journal, &rdev->flags))
3346 : : return -EBUSY;
3347 [ # # ]: 0 : if (strict_blocks_to_sectors(buf, §ors) < 0)
3348 : : return -EINVAL;
3349 [ # # ]: 0 : if (rdev->data_offset != rdev->new_data_offset)
3350 : : return -EINVAL; /* too confusing */
3351 [ # # # # ]: 0 : if (my_mddev->pers && rdev->raid_disk >= 0) {
3352 [ # # ]: 0 : if (my_mddev->persistent) {
3353 : 0 : sectors = super_types[my_mddev->major_version].
3354 : : rdev_size_change(rdev, sectors);
3355 [ # # ]: 0 : if (!sectors)
3356 : : return -EBUSY;
3357 [ # # ]: 0 : } else if (!sectors)
3358 : 0 : sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
3359 : : rdev->data_offset;
3360 [ # # ]: 0 : if (!my_mddev->pers->resize)
3361 : : /* Cannot change size for RAID0 or Linear etc */
3362 : : return -EINVAL;
3363 : : }
3364 [ # # ]: 0 : if (sectors < my_mddev->dev_sectors)
3365 : : return -EINVAL; /* component must fit device */
3366 : :
3367 : 0 : rdev->sectors = sectors;
3368 [ # # # # ]: 0 : if (sectors > oldsectors && my_mddev->external) {
3369 : : /* Need to check that all other rdevs with the same
3370 : : * ->bdev do not overlap. 'rcu' is sufficient to walk
3371 : : * the rdev lists safely.
3372 : : * This check does not provide a hard guarantee, it
3373 : : * just helps avoid dangerous mistakes.
3374 : : */
3375 : 0 : struct mddev *mddev;
3376 : 0 : int overlap = 0;
3377 : 0 : struct list_head *tmp;
3378 : :
3379 : 0 : rcu_read_lock();
3380 [ # # # # : 0 : for_each_mddev(mddev, tmp) {
# # ]
3381 : 0 : struct md_rdev *rdev2;
3382 : :
3383 [ # # ]: 0 : rdev_for_each(rdev2, mddev)
3384 [ # # # # ]: 0 : if (rdev->bdev == rdev2->bdev &&
3385 : : rdev != rdev2 &&
3386 [ # # ]: 0 : overlaps(rdev->data_offset, rdev->sectors,
3387 : : rdev2->data_offset,
3388 : : rdev2->sectors)) {
3389 : : overlap = 1;
3390 : : break;
3391 : : }
3392 [ # # ]: 0 : if (overlap) {
3393 : 0 : mddev_put(mddev);
3394 : 0 : break;
3395 : : }
3396 : : }
3397 : 0 : rcu_read_unlock();
3398 [ # # ]: 0 : if (overlap) {
3399 : : /* Someone else could have slipped in a size
3400 : : * change here, but doing so is just silly.
3401 : : * We put oldsectors back because we *know* it is
3402 : : * safe, and trust userspace not to race with
3403 : : * itself
3404 : : */
3405 : 0 : rdev->sectors = oldsectors;
3406 : 0 : return -EBUSY;
3407 : : }
3408 : : }
3409 : 0 : return len;
3410 : : }
3411 : :
3412 : : static struct rdev_sysfs_entry rdev_size =
3413 : : __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
3414 : :
3415 : 0 : static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
3416 : : {
3417 : 0 : unsigned long long recovery_start = rdev->recovery_offset;
3418 : :
3419 [ # # # # ]: 0 : if (test_bit(In_sync, &rdev->flags) ||
3420 : : recovery_start == MaxSector)
3421 : 0 : return sprintf(page, "none\n");
3422 : :
3423 : 0 : return sprintf(page, "%llu\n", recovery_start);
3424 : : }
3425 : :
3426 : 0 : static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
3427 : : {
3428 : 0 : unsigned long long recovery_start;
3429 : :
3430 [ # # ]: 0 : if (cmd_match(buf, "none"))
3431 : 0 : recovery_start = MaxSector;
3432 [ # # ]: 0 : else if (kstrtoull(buf, 10, &recovery_start))
3433 : : return -EINVAL;
3434 : :
3435 [ # # ]: 0 : if (rdev->mddev->pers &&
3436 [ # # ]: 0 : rdev->raid_disk >= 0)
3437 : : return -EBUSY;
3438 : :
3439 : 0 : rdev->recovery_offset = recovery_start;
3440 [ # # ]: 0 : if (recovery_start == MaxSector)
3441 : 0 : set_bit(In_sync, &rdev->flags);
3442 : : else
3443 : 0 : clear_bit(In_sync, &rdev->flags);
3444 : 0 : return len;
3445 : : }
3446 : :
3447 : : static struct rdev_sysfs_entry rdev_recovery_start =
3448 : : __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
3449 : :
3450 : : /* sysfs access to bad-blocks list.
3451 : : * We present two files.
3452 : : * 'bad-blocks' lists sector numbers and lengths of ranges that
3453 : : * are recorded as bad. The list is truncated to fit within
3454 : : * the one-page limit of sysfs.
3455 : : * Writing "sector length" to this file adds an acknowledged
3456 : : * bad block list.
3457 : : * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
3458 : : * been acknowledged. Writing to this file adds bad blocks
3459 : : * without acknowledging them. This is largely for testing.
3460 : : */
3461 : 0 : static ssize_t bb_show(struct md_rdev *rdev, char *page)
3462 : : {
3463 : 0 : return badblocks_show(&rdev->badblocks, page, 0);
3464 : : }
3465 : 0 : static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
3466 : : {
3467 : 0 : int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3468 : : /* Maybe that ack was all we needed */
3469 [ # # ]: 0 : if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3470 : 0 : wake_up(&rdev->blocked_wait);
3471 : 0 : return rv;
3472 : : }
3473 : : static struct rdev_sysfs_entry rdev_bad_blocks =
3474 : : __ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3475 : :
3476 : 0 : static ssize_t ubb_show(struct md_rdev *rdev, char *page)
3477 : : {
3478 : 0 : return badblocks_show(&rdev->badblocks, page, 1);
3479 : : }
3480 : 0 : static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
3481 : : {
3482 : 0 : return badblocks_store(&rdev->badblocks, page, len, 1);
3483 : : }
3484 : : static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3485 : : __ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3486 : :
3487 : : static ssize_t
3488 : 0 : ppl_sector_show(struct md_rdev *rdev, char *page)
3489 : : {
3490 : 0 : return sprintf(page, "%llu\n", (unsigned long long)rdev->ppl.sector);
3491 : : }
3492 : :
3493 : : static ssize_t
3494 : 0 : ppl_sector_store(struct md_rdev *rdev, const char *buf, size_t len)
3495 : : {
3496 : 0 : unsigned long long sector;
3497 : :
3498 [ # # ]: 0 : if (kstrtoull(buf, 10, §or) < 0)
3499 : : return -EINVAL;
3500 : 0 : if (sector != (sector_t)sector)
3501 : : return -EINVAL;
3502 : :
3503 [ # # # # ]: 0 : if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
3504 [ # # ]: 0 : rdev->raid_disk >= 0)
3505 : : return -EBUSY;
3506 : :
3507 [ # # ]: 0 : if (rdev->mddev->persistent) {
3508 [ # # ]: 0 : if (rdev->mddev->major_version == 0)
3509 : : return -EINVAL;
3510 [ # # ]: 0 : if ((sector > rdev->sb_start &&
3511 [ # # # # ]: 0 : sector - rdev->sb_start > S16_MAX) ||
3512 : 0 : (sector < rdev->sb_start &&
3513 [ # # ]: 0 : rdev->sb_start - sector > -S16_MIN))
3514 : : return -EINVAL;
3515 : 0 : rdev->ppl.offset = sector - rdev->sb_start;
3516 [ # # ]: 0 : } else if (!rdev->mddev->external) {
3517 : : return -EBUSY;
3518 : : }
3519 : 0 : rdev->ppl.sector = sector;
3520 : 0 : return len;
3521 : : }
3522 : :
3523 : : static struct rdev_sysfs_entry rdev_ppl_sector =
3524 : : __ATTR(ppl_sector, S_IRUGO|S_IWUSR, ppl_sector_show, ppl_sector_store);
3525 : :
3526 : : static ssize_t
3527 : 0 : ppl_size_show(struct md_rdev *rdev, char *page)
3528 : : {
3529 : 0 : return sprintf(page, "%u\n", rdev->ppl.size);
3530 : : }
3531 : :
3532 : : static ssize_t
3533 : 0 : ppl_size_store(struct md_rdev *rdev, const char *buf, size_t len)
3534 : : {
3535 : 0 : unsigned int size;
3536 : :
3537 [ # # ]: 0 : if (kstrtouint(buf, 10, &size) < 0)
3538 : : return -EINVAL;
3539 : :
3540 [ # # # # ]: 0 : if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
3541 [ # # ]: 0 : rdev->raid_disk >= 0)
3542 : : return -EBUSY;
3543 : :
3544 [ # # ]: 0 : if (rdev->mddev->persistent) {
3545 [ # # ]: 0 : if (rdev->mddev->major_version == 0)
3546 : : return -EINVAL;
3547 [ # # ]: 0 : if (size > U16_MAX)
3548 : : return -EINVAL;
3549 [ # # ]: 0 : } else if (!rdev->mddev->external) {
3550 : : return -EBUSY;
3551 : : }
3552 : 0 : rdev->ppl.size = size;
3553 : 0 : return len;
3554 : : }
3555 : :
3556 : : static struct rdev_sysfs_entry rdev_ppl_size =
3557 : : __ATTR(ppl_size, S_IRUGO|S_IWUSR, ppl_size_show, ppl_size_store);
3558 : :
3559 : : static struct attribute *rdev_default_attrs[] = {
3560 : : &rdev_state.attr,
3561 : : &rdev_errors.attr,
3562 : : &rdev_slot.attr,
3563 : : &rdev_offset.attr,
3564 : : &rdev_new_offset.attr,
3565 : : &rdev_size.attr,
3566 : : &rdev_recovery_start.attr,
3567 : : &rdev_bad_blocks.attr,
3568 : : &rdev_unack_bad_blocks.attr,
3569 : : &rdev_ppl_sector.attr,
3570 : : &rdev_ppl_size.attr,
3571 : : NULL,
3572 : : };
3573 : : static ssize_t
3574 : 0 : rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3575 : : {
3576 : 0 : struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3577 : 0 : struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3578 : :
3579 [ # # ]: 0 : if (!entry->show)
3580 : : return -EIO;
3581 [ # # ]: 0 : if (!rdev->mddev)
3582 : : return -ENODEV;
3583 : 0 : return entry->show(rdev, page);
3584 : : }
3585 : :
3586 : : static ssize_t
3587 : 0 : rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3588 : : const char *page, size_t length)
3589 : : {
3590 : 0 : struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3591 : 0 : struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3592 : 0 : ssize_t rv;
3593 : 0 : struct mddev *mddev = rdev->mddev;
3594 : :
3595 [ # # ]: 0 : if (!entry->store)
3596 : : return -EIO;
3597 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
3598 : : return -EACCES;
3599 [ # # ]: 0 : rv = mddev ? mddev_lock(mddev) : -ENODEV;
3600 [ # # ]: 0 : if (!rv) {
3601 [ # # ]: 0 : if (rdev->mddev == NULL)
3602 : : rv = -ENODEV;
3603 : : else
3604 : 0 : rv = entry->store(rdev, page, length);
3605 : 0 : mddev_unlock(mddev);
3606 : : }
3607 : : return rv;
3608 : : }
3609 : :
3610 : 0 : static void rdev_free(struct kobject *ko)
3611 : : {
3612 : 0 : struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
3613 : 0 : kfree(rdev);
3614 : 0 : }
3615 : : static const struct sysfs_ops rdev_sysfs_ops = {
3616 : : .show = rdev_attr_show,
3617 : : .store = rdev_attr_store,
3618 : : };
3619 : : static struct kobj_type rdev_ktype = {
3620 : : .release = rdev_free,
3621 : : .sysfs_ops = &rdev_sysfs_ops,
3622 : : .default_attrs = rdev_default_attrs,
3623 : : };
3624 : :
3625 : 0 : int md_rdev_init(struct md_rdev *rdev)
3626 : : {
3627 : 0 : rdev->desc_nr = -1;
3628 : 0 : rdev->saved_raid_disk = -1;
3629 : 0 : rdev->raid_disk = -1;
3630 : 0 : rdev->flags = 0;
3631 : 0 : rdev->data_offset = 0;
3632 : 0 : rdev->new_data_offset = 0;
3633 : 0 : rdev->sb_events = 0;
3634 : 0 : rdev->last_read_error = 0;
3635 : 0 : rdev->sb_loaded = 0;
3636 : 0 : rdev->bb_page = NULL;
3637 : 0 : atomic_set(&rdev->nr_pending, 0);
3638 : 0 : atomic_set(&rdev->read_errors, 0);
3639 : 0 : atomic_set(&rdev->corrected_errors, 0);
3640 : :
3641 : 0 : INIT_LIST_HEAD(&rdev->same_set);
3642 : 0 : init_waitqueue_head(&rdev->blocked_wait);
3643 : :
3644 : : /* Add space to store bad block list.
3645 : : * This reserves the space even on arrays where it cannot
3646 : : * be used - I wonder if that matters
3647 : : */
3648 : 0 : return badblocks_init(&rdev->badblocks, 0);
3649 : : }
3650 : : EXPORT_SYMBOL_GPL(md_rdev_init);
3651 : : /*
3652 : : * Import a device. If 'super_format' >= 0, then sanity check the superblock
3653 : : *
3654 : : * mark the device faulty if:
3655 : : *
3656 : : * - the device is nonexistent (zero size)
3657 : : * - the device has no valid superblock
3658 : : *
3659 : : * a faulty rdev _never_ has rdev->sb set.
3660 : : */
3661 : 0 : static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3662 : : {
3663 : 0 : char b[BDEVNAME_SIZE];
3664 : 0 : int err;
3665 : 0 : struct md_rdev *rdev;
3666 : 0 : sector_t size;
3667 : :
3668 : 0 : rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
3669 [ # # ]: 0 : if (!rdev)
3670 : : return ERR_PTR(-ENOMEM);
3671 : :
3672 : 0 : err = md_rdev_init(rdev);
3673 [ # # ]: 0 : if (err)
3674 : 0 : goto abort_free;
3675 : 0 : err = alloc_disk_sb(rdev);
3676 : 0 : if (err)
3677 : 0 : goto abort_free;
3678 : :
3679 : 0 : err = lock_rdev(rdev, newdev, super_format == -2);
3680 [ # # ]: 0 : if (err)
3681 : 0 : goto abort_free;
3682 : :
3683 : 0 : kobject_init(&rdev->kobj, &rdev_ktype);
3684 : :
3685 [ # # ]: 0 : size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
3686 [ # # ]: 0 : if (!size) {
3687 : 0 : pr_warn("md: %s has zero or unknown size, marking faulty!\n",
3688 : : bdevname(rdev->bdev,b));
3689 : 0 : err = -EINVAL;
3690 : 0 : goto abort_free;
3691 : : }
3692 : :
3693 [ # # ]: 0 : if (super_format >= 0) {
3694 : 0 : err = super_types[super_format].
3695 : : load_super(rdev, NULL, super_minor);
3696 [ # # ]: 0 : if (err == -EINVAL) {
3697 : 0 : pr_warn("md: %s does not have a valid v%d.%d superblock, not importing!\n",
3698 : : bdevname(rdev->bdev,b),
3699 : : super_format, super_minor);
3700 : 0 : goto abort_free;
3701 : : }
3702 [ # # ]: 0 : if (err < 0) {
3703 : 0 : pr_warn("md: could not read %s's sb, not importing!\n",
3704 : : bdevname(rdev->bdev,b));
3705 : 0 : goto abort_free;
3706 : : }
3707 : : }
3708 : :
3709 : : return rdev;
3710 : :
3711 : 0 : abort_free:
3712 [ # # ]: 0 : if (rdev->bdev)
3713 : 0 : unlock_rdev(rdev);
3714 : 0 : md_rdev_clear(rdev);
3715 : 0 : kfree(rdev);
3716 : 0 : return ERR_PTR(err);
3717 : : }
3718 : :
3719 : : /*
3720 : : * Check a full RAID array for plausibility
3721 : : */
3722 : :
3723 : 0 : static int analyze_sbs(struct mddev *mddev)
3724 : : {
3725 : 0 : int i;
3726 : 0 : struct md_rdev *rdev, *freshest, *tmp;
3727 : 0 : char b[BDEVNAME_SIZE];
3728 : :
3729 : 0 : freshest = NULL;
3730 [ # # ]: 0 : rdev_for_each_safe(rdev, tmp, mddev)
3731 [ # # # ]: 0 : switch (super_types[mddev->major_version].
3732 : : load_super(rdev, freshest, mddev->minor_version)) {
3733 : 0 : case 1:
3734 : 0 : freshest = rdev;
3735 : 0 : break;
3736 : : case 0:
3737 : : break;
3738 : 0 : default:
3739 : 0 : pr_warn("md: fatal superblock inconsistency in %s -- removing from array\n",
3740 : : bdevname(rdev->bdev,b));
3741 : 0 : md_kick_rdev_from_array(rdev);
3742 : : }
3743 : :
3744 : : /* Cannot find a valid fresh disk */
3745 [ # # ]: 0 : if (!freshest) {
3746 : 0 : pr_warn("md: cannot find a valid disk\n");
3747 : 0 : return -EINVAL;
3748 : : }
3749 : :
3750 : 0 : super_types[mddev->major_version].
3751 : : validate_super(mddev, freshest);
3752 : :
3753 : 0 : i = 0;
3754 [ # # ]: 0 : rdev_for_each_safe(rdev, tmp, mddev) {
3755 [ # # ]: 0 : if (mddev->max_disks &&
3756 [ # # # # ]: 0 : (rdev->desc_nr >= mddev->max_disks ||
3757 : : i > mddev->max_disks)) {
3758 [ # # ]: 0 : pr_warn("md: %s: %s: only %d devices permitted\n",
3759 : : mdname(mddev), bdevname(rdev->bdev, b),
3760 : : mddev->max_disks);
3761 : 0 : md_kick_rdev_from_array(rdev);
3762 : 0 : continue;
3763 : : }
3764 [ # # ]: 0 : if (rdev != freshest) {
3765 [ # # ]: 0 : if (super_types[mddev->major_version].
3766 : : validate_super(mddev, rdev)) {
3767 : 0 : pr_warn("md: kicking non-fresh %s from array!\n",
3768 : : bdevname(rdev->bdev,b));
3769 : 0 : md_kick_rdev_from_array(rdev);
3770 : 0 : continue;
3771 : : }
3772 : : }
3773 [ # # ]: 0 : if (mddev->level == LEVEL_MULTIPATH) {
3774 : 0 : rdev->desc_nr = i++;
3775 : 0 : rdev->raid_disk = rdev->desc_nr;
3776 : 0 : set_bit(In_sync, &rdev->flags);
3777 : 0 : } else if (rdev->raid_disk >=
3778 [ # # # # ]: 0 : (mddev->raid_disks - min(0, mddev->delta_disks)) &&
3779 : 0 : !test_bit(Journal, &rdev->flags)) {
3780 : 0 : rdev->raid_disk = -1;
3781 : 0 : clear_bit(In_sync, &rdev->flags);
3782 : : }
3783 : : }
3784 : :
3785 : : return 0;
3786 : : }
3787 : :
3788 : : /* Read a fixed-point number.
3789 : : * Numbers in sysfs attributes should be in "standard" units where
3790 : : * possible, so time should be in seconds.
3791 : : * However we internally use a a much smaller unit such as
3792 : : * milliseconds or jiffies.
3793 : : * This function takes a decimal number with a possible fractional
3794 : : * component, and produces an integer which is the result of
3795 : : * multiplying that number by 10^'scale'.
3796 : : * all without any floating-point arithmetic.
3797 : : */
3798 : 0 : int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3799 : : {
3800 : 0 : unsigned long result = 0;
3801 : 0 : long decimals = -1;
3802 [ # # # # : 0 : while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
# # ]
3803 [ # # ]: 0 : if (*cp == '.')
3804 : : decimals = 0;
3805 [ # # ]: 0 : else if (decimals < scale) {
3806 : 0 : unsigned int value;
3807 : 0 : value = *cp - '0';
3808 : 0 : result = result * 10 + value;
3809 [ # # ]: 0 : if (decimals >= 0)
3810 : 0 : decimals++;
3811 : : }
3812 : 0 : cp++;
3813 : : }
3814 [ # # ]: 0 : if (*cp == '\n')
3815 : 0 : cp++;
3816 [ # # ]: 0 : if (*cp)
3817 : : return -EINVAL;
3818 : 0 : if (decimals < 0)
3819 : : decimals = 0;
3820 : 0 : *res = result * int_pow(10, scale - decimals);
3821 : 0 : return 0;
3822 : : }
3823 : :
3824 : : static ssize_t
3825 : 0 : safe_delay_show(struct mddev *mddev, char *page)
3826 : : {
3827 : 0 : int msec = (mddev->safemode_delay*1000)/HZ;
3828 : 0 : return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3829 : : }
3830 : : static ssize_t
3831 : 0 : safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3832 : : {
3833 : 0 : unsigned long msec;
3834 : :
3835 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
3836 : 0 : pr_warn("md: Safemode is disabled for clustered mode\n");
3837 : 0 : return -EINVAL;
3838 : : }
3839 : :
3840 [ # # ]: 0 : if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
3841 : : return -EINVAL;
3842 [ # # ]: 0 : if (msec == 0)
3843 : 0 : mddev->safemode_delay = 0;
3844 : : else {
3845 : 0 : unsigned long old_delay = mddev->safemode_delay;
3846 : 0 : unsigned long new_delay = (msec*HZ)/1000;
3847 : :
3848 [ # # ]: 0 : if (new_delay == 0)
3849 : 0 : new_delay = 1;
3850 : 0 : mddev->safemode_delay = new_delay;
3851 [ # # ]: 0 : if (new_delay < old_delay || old_delay == 0)
3852 : 0 : mod_timer(&mddev->safemode_timer, jiffies+1);
3853 : : }
3854 : 0 : return len;
3855 : : }
3856 : : static struct md_sysfs_entry md_safe_delay =
3857 : : __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3858 : :
3859 : : static ssize_t
3860 : 0 : level_show(struct mddev *mddev, char *page)
3861 : : {
3862 : 0 : struct md_personality *p;
3863 : 0 : int ret;
3864 : 0 : spin_lock(&mddev->lock);
3865 : 0 : p = mddev->pers;
3866 [ # # ]: 0 : if (p)
3867 : 0 : ret = sprintf(page, "%s\n", p->name);
3868 [ # # ]: 0 : else if (mddev->clevel[0])
3869 : 0 : ret = sprintf(page, "%s\n", mddev->clevel);
3870 [ # # ]: 0 : else if (mddev->level != LEVEL_NONE)
3871 : 0 : ret = sprintf(page, "%d\n", mddev->level);
3872 : : else
3873 : : ret = 0;
3874 : 0 : spin_unlock(&mddev->lock);
3875 : 0 : return ret;
3876 : : }
3877 : :
3878 : : static ssize_t
3879 : 0 : level_store(struct mddev *mddev, const char *buf, size_t len)
3880 : : {
3881 : 0 : char clevel[16];
3882 : 0 : ssize_t rv;
3883 : 0 : size_t slen = len;
3884 : 0 : struct md_personality *pers, *oldpers;
3885 : 0 : long level;
3886 : 0 : void *priv, *oldpriv;
3887 : 0 : struct md_rdev *rdev;
3888 : :
3889 [ # # ]: 0 : if (slen == 0 || slen >= sizeof(clevel))
3890 : : return -EINVAL;
3891 : :
3892 : 0 : rv = mddev_lock(mddev);
3893 [ # # ]: 0 : if (rv)
3894 : : return rv;
3895 : :
3896 [ # # ]: 0 : if (mddev->pers == NULL) {
3897 : 0 : strncpy(mddev->clevel, buf, slen);
3898 [ # # ]: 0 : if (mddev->clevel[slen-1] == '\n')
3899 : 0 : slen--;
3900 : 0 : mddev->clevel[slen] = 0;
3901 : 0 : mddev->level = LEVEL_NONE;
3902 : 0 : rv = len;
3903 : 0 : goto out_unlock;
3904 : : }
3905 : 0 : rv = -EROFS;
3906 [ # # ]: 0 : if (mddev->ro)
3907 : 0 : goto out_unlock;
3908 : :
3909 : : /* request to change the personality. Need to ensure:
3910 : : * - array is not engaged in resync/recovery/reshape
3911 : : * - old personality can be suspended
3912 : : * - new personality will access other array.
3913 : : */
3914 : :
3915 : 0 : rv = -EBUSY;
3916 [ # # # # ]: 0 : if (mddev->sync_thread ||
3917 : 0 : test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3918 [ # # ]: 0 : mddev->reshape_position != MaxSector ||
3919 [ # # ]: 0 : mddev->sysfs_active)
3920 : 0 : goto out_unlock;
3921 : :
3922 : 0 : rv = -EINVAL;
3923 [ # # ]: 0 : if (!mddev->pers->quiesce) {
3924 [ # # ]: 0 : pr_warn("md: %s: %s does not support online personality change\n",
3925 : : mdname(mddev), mddev->pers->name);
3926 : 0 : goto out_unlock;
3927 : : }
3928 : :
3929 : : /* Now find the new personality */
3930 : 0 : strncpy(clevel, buf, slen);
3931 [ # # ]: 0 : if (clevel[slen-1] == '\n')
3932 : 0 : slen--;
3933 : 0 : clevel[slen] = 0;
3934 [ # # ]: 0 : if (kstrtol(clevel, 10, &level))
3935 : 0 : level = LEVEL_NONE;
3936 : :
3937 [ # # ]: 0 : if (request_module("md-%s", clevel) != 0)
3938 : 0 : request_module("md-level-%s", clevel);
3939 : 0 : spin_lock(&pers_lock);
3940 : 0 : pers = find_pers(level, clevel);
3941 [ # # # # ]: 0 : if (!pers || !try_module_get(pers->owner)) {
3942 : 0 : spin_unlock(&pers_lock);
3943 : 0 : pr_warn("md: personality %s not loaded\n", clevel);
3944 : 0 : rv = -EINVAL;
3945 : 0 : goto out_unlock;
3946 : : }
3947 : 0 : spin_unlock(&pers_lock);
3948 : :
3949 [ # # ]: 0 : if (pers == mddev->pers) {
3950 : : /* Nothing to do! */
3951 : 0 : module_put(pers->owner);
3952 : 0 : rv = len;
3953 : 0 : goto out_unlock;
3954 : : }
3955 [ # # ]: 0 : if (!pers->takeover) {
3956 : 0 : module_put(pers->owner);
3957 [ # # ]: 0 : pr_warn("md: %s: %s does not support personality takeover\n",
3958 : : mdname(mddev), clevel);
3959 : 0 : rv = -EINVAL;
3960 : 0 : goto out_unlock;
3961 : : }
3962 : :
3963 [ # # ]: 0 : rdev_for_each(rdev, mddev)
3964 : 0 : rdev->new_raid_disk = rdev->raid_disk;
3965 : :
3966 : : /* ->takeover must set new_* and/or delta_disks
3967 : : * if it succeeds, and may set them when it fails.
3968 : : */
3969 : 0 : priv = pers->takeover(mddev);
3970 [ # # ]: 0 : if (IS_ERR(priv)) {
3971 : 0 : mddev->new_level = mddev->level;
3972 : 0 : mddev->new_layout = mddev->layout;
3973 : 0 : mddev->new_chunk_sectors = mddev->chunk_sectors;
3974 : 0 : mddev->raid_disks -= mddev->delta_disks;
3975 : 0 : mddev->delta_disks = 0;
3976 : 0 : mddev->reshape_backwards = 0;
3977 : 0 : module_put(pers->owner);
3978 [ # # ]: 0 : pr_warn("md: %s: %s would not accept array\n",
3979 : : mdname(mddev), clevel);
3980 : 0 : rv = PTR_ERR(priv);
3981 : 0 : goto out_unlock;
3982 : : }
3983 : :
3984 : : /* Looks like we have a winner */
3985 : 0 : mddev_suspend(mddev);
3986 : 0 : mddev_detach(mddev);
3987 : :
3988 : 0 : spin_lock(&mddev->lock);
3989 : 0 : oldpers = mddev->pers;
3990 : 0 : oldpriv = mddev->private;
3991 : 0 : mddev->pers = pers;
3992 : 0 : mddev->private = priv;
3993 : 0 : strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3994 : 0 : mddev->level = mddev->new_level;
3995 : 0 : mddev->layout = mddev->new_layout;
3996 : 0 : mddev->chunk_sectors = mddev->new_chunk_sectors;
3997 : 0 : mddev->delta_disks = 0;
3998 : 0 : mddev->reshape_backwards = 0;
3999 : 0 : mddev->degraded = 0;
4000 : 0 : spin_unlock(&mddev->lock);
4001 : :
4002 [ # # ]: 0 : if (oldpers->sync_request == NULL &&
4003 [ # # ]: 0 : mddev->external) {
4004 : : /* We are converting from a no-redundancy array
4005 : : * to a redundancy array and metadata is managed
4006 : : * externally so we need to be sure that writes
4007 : : * won't block due to a need to transition
4008 : : * clean->dirty
4009 : : * until external management is started.
4010 : : */
4011 : 0 : mddev->in_sync = 0;
4012 : 0 : mddev->safemode_delay = 0;
4013 : 0 : mddev->safemode = 0;
4014 : : }
4015 : :
4016 : 0 : oldpers->free(mddev, oldpriv);
4017 : :
4018 [ # # ]: 0 : if (oldpers->sync_request == NULL &&
4019 [ # # ]: 0 : pers->sync_request != NULL) {
4020 : : /* need to add the md_redundancy_group */
4021 [ # # ]: 0 : if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
4022 [ # # ]: 0 : pr_warn("md: cannot register extra attributes for %s\n",
4023 : : mdname(mddev));
4024 : 0 : mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
4025 : : }
4026 [ # # ]: 0 : if (oldpers->sync_request != NULL &&
4027 [ # # ]: 0 : pers->sync_request == NULL) {
4028 : : /* need to remove the md_redundancy_group */
4029 [ # # ]: 0 : if (mddev->to_remove == NULL)
4030 : 0 : mddev->to_remove = &md_redundancy_group;
4031 : : }
4032 : :
4033 : 0 : module_put(oldpers->owner);
4034 : :
4035 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
4036 [ # # ]: 0 : if (rdev->raid_disk < 0)
4037 : 0 : continue;
4038 [ # # ]: 0 : if (rdev->new_raid_disk >= mddev->raid_disks)
4039 : 0 : rdev->new_raid_disk = -1;
4040 [ # # ]: 0 : if (rdev->new_raid_disk == rdev->raid_disk)
4041 : 0 : continue;
4042 : 0 : sysfs_unlink_rdev(mddev, rdev);
4043 : : }
4044 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
4045 [ # # ]: 0 : if (rdev->raid_disk < 0)
4046 : 0 : continue;
4047 [ # # ]: 0 : if (rdev->new_raid_disk == rdev->raid_disk)
4048 : 0 : continue;
4049 : 0 : rdev->raid_disk = rdev->new_raid_disk;
4050 [ # # ]: 0 : if (rdev->raid_disk < 0)
4051 : 0 : clear_bit(In_sync, &rdev->flags);
4052 : : else {
4053 [ # # ]: 0 : if (sysfs_link_rdev(mddev, rdev))
4054 [ # # ]: 0 : pr_warn("md: cannot register rd%d for %s after level change\n",
4055 : : rdev->raid_disk, mdname(mddev));
4056 : : }
4057 : : }
4058 : :
4059 [ # # ]: 0 : if (pers->sync_request == NULL) {
4060 : : /* this is now an array without redundancy, so
4061 : : * it must always be in_sync
4062 : : */
4063 : 0 : mddev->in_sync = 1;
4064 : 0 : del_timer_sync(&mddev->safemode_timer);
4065 : : }
4066 : 0 : blk_set_stacking_limits(&mddev->queue->limits);
4067 : 0 : pers->run(mddev);
4068 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
4069 : 0 : mddev_resume(mddev);
4070 [ # # ]: 0 : if (!mddev->thread)
4071 : 0 : md_update_sb(mddev, 1);
4072 : 0 : sysfs_notify(&mddev->kobj, NULL, "level");
4073 : 0 : md_new_event(mddev);
4074 : 0 : rv = len;
4075 : 0 : out_unlock:
4076 : 0 : mddev_unlock(mddev);
4077 : 0 : return rv;
4078 : : }
4079 : :
4080 : : static struct md_sysfs_entry md_level =
4081 : : __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
4082 : :
4083 : : static ssize_t
4084 : 0 : layout_show(struct mddev *mddev, char *page)
4085 : : {
4086 : : /* just a number, not meaningful for all levels */
4087 [ # # ]: 0 : if (mddev->reshape_position != MaxSector &&
4088 [ # # ]: 0 : mddev->layout != mddev->new_layout)
4089 : 0 : return sprintf(page, "%d (%d)\n",
4090 : : mddev->new_layout, mddev->layout);
4091 : 0 : return sprintf(page, "%d\n", mddev->layout);
4092 : : }
4093 : :
4094 : : static ssize_t
4095 : 0 : layout_store(struct mddev *mddev, const char *buf, size_t len)
4096 : : {
4097 : 0 : unsigned int n;
4098 : 0 : int err;
4099 : :
4100 : 0 : err = kstrtouint(buf, 10, &n);
4101 [ # # ]: 0 : if (err < 0)
4102 : 0 : return err;
4103 : 0 : err = mddev_lock(mddev);
4104 [ # # ]: 0 : if (err)
4105 : 0 : return err;
4106 : :
4107 [ # # ]: 0 : if (mddev->pers) {
4108 [ # # ]: 0 : if (mddev->pers->check_reshape == NULL)
4109 : : err = -EBUSY;
4110 [ # # ]: 0 : else if (mddev->ro)
4111 : : err = -EROFS;
4112 : : else {
4113 : 0 : mddev->new_layout = n;
4114 : 0 : err = mddev->pers->check_reshape(mddev);
4115 [ # # ]: 0 : if (err)
4116 : 0 : mddev->new_layout = mddev->layout;
4117 : : }
4118 : : } else {
4119 : 0 : mddev->new_layout = n;
4120 [ # # ]: 0 : if (mddev->reshape_position == MaxSector)
4121 : 0 : mddev->layout = n;
4122 : : }
4123 : 0 : mddev_unlock(mddev);
4124 [ # # ]: 0 : return err ?: len;
4125 : : }
4126 : : static struct md_sysfs_entry md_layout =
4127 : : __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
4128 : :
4129 : : static ssize_t
4130 : 0 : raid_disks_show(struct mddev *mddev, char *page)
4131 : : {
4132 [ # # ]: 0 : if (mddev->raid_disks == 0)
4133 : : return 0;
4134 [ # # ]: 0 : if (mddev->reshape_position != MaxSector &&
4135 [ # # ]: 0 : mddev->delta_disks != 0)
4136 : 0 : return sprintf(page, "%d (%d)\n", mddev->raid_disks,
4137 : : mddev->raid_disks - mddev->delta_disks);
4138 : 0 : return sprintf(page, "%d\n", mddev->raid_disks);
4139 : : }
4140 : :
4141 : : static int update_raid_disks(struct mddev *mddev, int raid_disks);
4142 : :
4143 : : static ssize_t
4144 : 0 : raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
4145 : : {
4146 : 0 : unsigned int n;
4147 : 0 : int err;
4148 : :
4149 : 0 : err = kstrtouint(buf, 10, &n);
4150 [ # # ]: 0 : if (err < 0)
4151 : 0 : return err;
4152 : :
4153 : 0 : err = mddev_lock(mddev);
4154 [ # # ]: 0 : if (err)
4155 : 0 : return err;
4156 [ # # ]: 0 : if (mddev->pers)
4157 : 0 : err = update_raid_disks(mddev, n);
4158 [ # # ]: 0 : else if (mddev->reshape_position != MaxSector) {
4159 : 0 : struct md_rdev *rdev;
4160 : 0 : int olddisks = mddev->raid_disks - mddev->delta_disks;
4161 : :
4162 : 0 : err = -EINVAL;
4163 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
4164 [ # # ]: 0 : if (olddisks < n &&
4165 [ # # ]: 0 : rdev->data_offset < rdev->new_data_offset)
4166 : 0 : goto out_unlock;
4167 [ # # ]: 0 : if (olddisks > n &&
4168 [ # # ]: 0 : rdev->data_offset > rdev->new_data_offset)
4169 : 0 : goto out_unlock;
4170 : : }
4171 : 0 : err = 0;
4172 : 0 : mddev->delta_disks = n - olddisks;
4173 : 0 : mddev->raid_disks = n;
4174 : 0 : mddev->reshape_backwards = (mddev->delta_disks < 0);
4175 : : } else
4176 : 0 : mddev->raid_disks = n;
4177 : 0 : out_unlock:
4178 : 0 : mddev_unlock(mddev);
4179 [ # # ]: 0 : return err ? err : len;
4180 : : }
4181 : : static struct md_sysfs_entry md_raid_disks =
4182 : : __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
4183 : :
4184 : : static ssize_t
4185 : 0 : chunk_size_show(struct mddev *mddev, char *page)
4186 : : {
4187 [ # # ]: 0 : if (mddev->reshape_position != MaxSector &&
4188 [ # # ]: 0 : mddev->chunk_sectors != mddev->new_chunk_sectors)
4189 : 0 : return sprintf(page, "%d (%d)\n",
4190 : : mddev->new_chunk_sectors << 9,
4191 : : mddev->chunk_sectors << 9);
4192 : 0 : return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
4193 : : }
4194 : :
4195 : : static ssize_t
4196 : 0 : chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
4197 : : {
4198 : 0 : unsigned long n;
4199 : 0 : int err;
4200 : :
4201 : 0 : err = kstrtoul(buf, 10, &n);
4202 [ # # ]: 0 : if (err < 0)
4203 : 0 : return err;
4204 : :
4205 : 0 : err = mddev_lock(mddev);
4206 [ # # ]: 0 : if (err)
4207 : 0 : return err;
4208 [ # # ]: 0 : if (mddev->pers) {
4209 [ # # ]: 0 : if (mddev->pers->check_reshape == NULL)
4210 : : err = -EBUSY;
4211 [ # # ]: 0 : else if (mddev->ro)
4212 : : err = -EROFS;
4213 : : else {
4214 : 0 : mddev->new_chunk_sectors = n >> 9;
4215 : 0 : err = mddev->pers->check_reshape(mddev);
4216 [ # # ]: 0 : if (err)
4217 : 0 : mddev->new_chunk_sectors = mddev->chunk_sectors;
4218 : : }
4219 : : } else {
4220 : 0 : mddev->new_chunk_sectors = n >> 9;
4221 [ # # ]: 0 : if (mddev->reshape_position == MaxSector)
4222 : 0 : mddev->chunk_sectors = n >> 9;
4223 : : }
4224 : 0 : mddev_unlock(mddev);
4225 [ # # ]: 0 : return err ?: len;
4226 : : }
4227 : : static struct md_sysfs_entry md_chunk_size =
4228 : : __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
4229 : :
4230 : : static ssize_t
4231 : 0 : resync_start_show(struct mddev *mddev, char *page)
4232 : : {
4233 [ # # ]: 0 : if (mddev->recovery_cp == MaxSector)
4234 : 0 : return sprintf(page, "none\n");
4235 : 0 : return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
4236 : : }
4237 : :
4238 : : static ssize_t
4239 : 0 : resync_start_store(struct mddev *mddev, const char *buf, size_t len)
4240 : : {
4241 : 0 : unsigned long long n;
4242 : 0 : int err;
4243 : :
4244 [ # # ]: 0 : if (cmd_match(buf, "none"))
4245 : 0 : n = MaxSector;
4246 : : else {
4247 : 0 : err = kstrtoull(buf, 10, &n);
4248 [ # # ]: 0 : if (err < 0)
4249 : 0 : return err;
4250 : : if (n != (sector_t)n)
4251 : : return -EINVAL;
4252 : : }
4253 : :
4254 : 0 : err = mddev_lock(mddev);
4255 [ # # ]: 0 : if (err)
4256 : 0 : return err;
4257 [ # # # # ]: 0 : if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
4258 : : err = -EBUSY;
4259 : :
4260 : 0 : if (!err) {
4261 : 0 : mddev->recovery_cp = n;
4262 [ # # ]: 0 : if (mddev->pers)
4263 : 0 : set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
4264 : : }
4265 : 0 : mddev_unlock(mddev);
4266 [ # # ]: 0 : return err ?: len;
4267 : : }
4268 : : static struct md_sysfs_entry md_resync_start =
4269 : : __ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
4270 : : resync_start_show, resync_start_store);
4271 : :
4272 : : /*
4273 : : * The array state can be:
4274 : : *
4275 : : * clear
4276 : : * No devices, no size, no level
4277 : : * Equivalent to STOP_ARRAY ioctl
4278 : : * inactive
4279 : : * May have some settings, but array is not active
4280 : : * all IO results in error
4281 : : * When written, doesn't tear down array, but just stops it
4282 : : * suspended (not supported yet)
4283 : : * All IO requests will block. The array can be reconfigured.
4284 : : * Writing this, if accepted, will block until array is quiescent
4285 : : * readonly
4286 : : * no resync can happen. no superblocks get written.
4287 : : * write requests fail
4288 : : * read-auto
4289 : : * like readonly, but behaves like 'clean' on a write request.
4290 : : *
4291 : : * clean - no pending writes, but otherwise active.
4292 : : * When written to inactive array, starts without resync
4293 : : * If a write request arrives then
4294 : : * if metadata is known, mark 'dirty' and switch to 'active'.
4295 : : * if not known, block and switch to write-pending
4296 : : * If written to an active array that has pending writes, then fails.
4297 : : * active
4298 : : * fully active: IO and resync can be happening.
4299 : : * When written to inactive array, starts with resync
4300 : : *
4301 : : * write-pending
4302 : : * clean, but writes are blocked waiting for 'active' to be written.
4303 : : *
4304 : : * active-idle
4305 : : * like active, but no writes have been seen for a while (100msec).
4306 : : *
4307 : : * broken
4308 : : * RAID0/LINEAR-only: same as clean, but array is missing a member.
4309 : : * It's useful because RAID0/LINEAR mounted-arrays aren't stopped
4310 : : * when a member is gone, so this state will at least alert the
4311 : : * user that something is wrong.
4312 : : */
4313 : : enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
4314 : : write_pending, active_idle, broken, bad_word};
4315 : : static char *array_states[] = {
4316 : : "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
4317 : : "write-pending", "active-idle", "broken", NULL };
4318 : :
4319 : 0 : static int match_word(const char *word, char **list)
4320 : : {
4321 : 0 : int n;
4322 [ # # ]: 0 : for (n=0; list[n]; n++)
4323 [ # # ]: 0 : if (cmd_match(word, list[n]))
4324 : : break;
4325 : 0 : return n;
4326 : : }
4327 : :
4328 : : static ssize_t
4329 : 26 : array_state_show(struct mddev *mddev, char *page)
4330 : : {
4331 : 26 : enum array_state st = inactive;
4332 : :
4333 [ - + - - ]: 26 : if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags)) {
4334 [ # # # # ]: 0 : switch(mddev->ro) {
4335 : 0 : case 1:
4336 : 0 : st = readonly;
4337 : 0 : break;
4338 : 0 : case 2:
4339 : 0 : st = read_auto;
4340 : 0 : break;
4341 : 0 : case 0:
4342 : 0 : spin_lock(&mddev->lock);
4343 [ # # ]: 0 : if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
4344 : : st = write_pending;
4345 [ # # ]: 0 : else if (mddev->in_sync)
4346 : : st = clean;
4347 [ # # ]: 0 : else if (mddev->safemode)
4348 : : st = active_idle;
4349 : : else
4350 : 0 : st = active;
4351 : 0 : spin_unlock(&mddev->lock);
4352 : : }
4353 : :
4354 [ # # # # ]: 0 : if (test_bit(MD_BROKEN, &mddev->flags) && st == clean)
4355 : 0 : st = broken;
4356 : : } else {
4357 [ + - ]: 26 : if (list_empty(&mddev->disks) &&
4358 [ + - ]: 26 : mddev->raid_disks == 0 &&
4359 [ - + ]: 26 : mddev->dev_sectors == 0)
4360 : : st = clear;
4361 : : else
4362 : 0 : st = inactive;
4363 : : }
4364 : 26 : return sprintf(page, "%s\n", array_states[st]);
4365 : : }
4366 : :
4367 : : static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
4368 : : static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
4369 : : static int do_md_run(struct mddev *mddev);
4370 : : static int restart_array(struct mddev *mddev);
4371 : :
4372 : : static ssize_t
4373 : 0 : array_state_store(struct mddev *mddev, const char *buf, size_t len)
4374 : : {
4375 : 0 : int err = 0;
4376 : 0 : enum array_state st = match_word(buf, array_states);
4377 : :
4378 [ # # # # : 0 : if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
# # ]
4379 : : /* don't take reconfig_mutex when toggling between
4380 : : * clean and active
4381 : : */
4382 : 0 : spin_lock(&mddev->lock);
4383 [ # # ]: 0 : if (st == active) {
4384 : 0 : restart_array(mddev);
4385 : 0 : clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
4386 : 0 : md_wakeup_thread(mddev->thread);
4387 : 0 : wake_up(&mddev->sb_wait);
4388 : : } else /* st == clean */ {
4389 : 0 : restart_array(mddev);
4390 [ # # ]: 0 : if (!set_in_sync(mddev))
4391 : : err = -EBUSY;
4392 : : }
4393 : 0 : if (!err)
4394 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
4395 : 0 : spin_unlock(&mddev->lock);
4396 [ # # ]: 0 : return err ?: len;
4397 : : }
4398 : 0 : err = mddev_lock(mddev);
4399 [ # # ]: 0 : if (err)
4400 : 0 : return err;
4401 : 0 : err = -EINVAL;
4402 [ # # # # : 0 : switch(st) {
# # # ]
4403 : : case bad_word:
4404 : : break;
4405 : 0 : case clear:
4406 : : /* stopping an active array */
4407 : 0 : err = do_md_stop(mddev, 0, NULL);
4408 : 0 : break;
4409 : 0 : case inactive:
4410 : : /* stopping an active array */
4411 [ # # ]: 0 : if (mddev->pers)
4412 : 0 : err = do_md_stop(mddev, 2, NULL);
4413 : : else
4414 : : err = 0; /* already inactive */
4415 : : break;
4416 : : case suspended:
4417 : : break; /* not supported yet */
4418 : 0 : case readonly:
4419 [ # # ]: 0 : if (mddev->pers)
4420 : 0 : err = md_set_readonly(mddev, NULL);
4421 : : else {
4422 : 0 : mddev->ro = 1;
4423 : 0 : set_disk_ro(mddev->gendisk, 1);
4424 : 0 : err = do_md_run(mddev);
4425 : : }
4426 : : break;
4427 : 0 : case read_auto:
4428 [ # # ]: 0 : if (mddev->pers) {
4429 [ # # ]: 0 : if (mddev->ro == 0)
4430 : 0 : err = md_set_readonly(mddev, NULL);
4431 [ # # ]: 0 : else if (mddev->ro == 1)
4432 : 0 : err = restart_array(mddev);
4433 [ # # ]: 0 : if (err == 0) {
4434 : 0 : mddev->ro = 2;
4435 : 0 : set_disk_ro(mddev->gendisk, 0);
4436 : : }
4437 : : } else {
4438 : 0 : mddev->ro = 2;
4439 : 0 : err = do_md_run(mddev);
4440 : : }
4441 : : break;
4442 : 0 : case clean:
4443 [ # # ]: 0 : if (mddev->pers) {
4444 : 0 : err = restart_array(mddev);
4445 [ # # ]: 0 : if (err)
4446 : : break;
4447 : 0 : spin_lock(&mddev->lock);
4448 [ # # ]: 0 : if (!set_in_sync(mddev))
4449 : 0 : err = -EBUSY;
4450 : 0 : spin_unlock(&mddev->lock);
4451 : : } else
4452 : : err = -EINVAL;
4453 : : break;
4454 : 0 : case active:
4455 [ # # ]: 0 : if (mddev->pers) {
4456 : 0 : err = restart_array(mddev);
4457 [ # # ]: 0 : if (err)
4458 : : break;
4459 : 0 : clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
4460 : 0 : wake_up(&mddev->sb_wait);
4461 : 0 : err = 0;
4462 : : } else {
4463 : 0 : mddev->ro = 0;
4464 : 0 : set_disk_ro(mddev->gendisk, 0);
4465 : 0 : err = do_md_run(mddev);
4466 : : }
4467 : : break;
4468 : : case write_pending:
4469 : : case active_idle:
4470 : : case broken:
4471 : : /* these cannot be set */
4472 : : break;
4473 : : }
4474 : :
4475 [ # # ]: 0 : if (!err) {
4476 [ # # ]: 0 : if (mddev->hold_active == UNTIL_IOCTL)
4477 : 0 : mddev->hold_active = 0;
4478 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
4479 : : }
4480 : 0 : mddev_unlock(mddev);
4481 [ # # ]: 0 : return err ?: len;
4482 : : }
4483 : : static struct md_sysfs_entry md_array_state =
4484 : : __ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
4485 : :
4486 : : static ssize_t
4487 : 0 : max_corrected_read_errors_show(struct mddev *mddev, char *page) {
4488 : 0 : return sprintf(page, "%d\n",
4489 : 0 : atomic_read(&mddev->max_corr_read_errors));
4490 : : }
4491 : :
4492 : : static ssize_t
4493 : 0 : max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
4494 : : {
4495 : 0 : unsigned int n;
4496 : 0 : int rv;
4497 : :
4498 : 0 : rv = kstrtouint(buf, 10, &n);
4499 [ # # ]: 0 : if (rv < 0)
4500 : 0 : return rv;
4501 : 0 : atomic_set(&mddev->max_corr_read_errors, n);
4502 : 0 : return len;
4503 : : }
4504 : :
4505 : : static struct md_sysfs_entry max_corr_read_errors =
4506 : : __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
4507 : : max_corrected_read_errors_store);
4508 : :
4509 : : static ssize_t
4510 : 0 : null_show(struct mddev *mddev, char *page)
4511 : : {
4512 : 0 : return -EINVAL;
4513 : : }
4514 : :
4515 : : static ssize_t
4516 : 0 : new_dev_store(struct mddev *mddev, const char *buf, size_t len)
4517 : : {
4518 : : /* buf must be %d:%d\n? giving major and minor numbers */
4519 : : /* The new device is added to the array.
4520 : : * If the array has a persistent superblock, we read the
4521 : : * superblock to initialise info and check validity.
4522 : : * Otherwise, only checking done is that in bind_rdev_to_array,
4523 : : * which mainly checks size.
4524 : : */
4525 : 0 : char *e;
4526 : 0 : int major = simple_strtoul(buf, &e, 10);
4527 : 0 : int minor;
4528 : 0 : dev_t dev;
4529 : 0 : struct md_rdev *rdev;
4530 : 0 : int err;
4531 : :
4532 [ # # # # : 0 : if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
# # # # ]
4533 : : return -EINVAL;
4534 : 0 : minor = simple_strtoul(e+1, &e, 10);
4535 [ # # ]: 0 : if (*e && *e != '\n')
4536 : : return -EINVAL;
4537 : 0 : dev = MKDEV(major, minor);
4538 [ # # ]: 0 : if (major != MAJOR(dev) ||
4539 [ # # ]: 0 : minor != MINOR(dev))
4540 : : return -EOVERFLOW;
4541 : :
4542 : 0 : flush_workqueue(md_misc_wq);
4543 : :
4544 : 0 : err = mddev_lock(mddev);
4545 [ # # ]: 0 : if (err)
4546 : 0 : return err;
4547 [ # # ]: 0 : if (mddev->persistent) {
4548 : 0 : rdev = md_import_device(dev, mddev->major_version,
4549 : : mddev->minor_version);
4550 [ # # # # ]: 0 : if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
4551 : 0 : struct md_rdev *rdev0
4552 : 0 : = list_entry(mddev->disks.next,
4553 : : struct md_rdev, same_set);
4554 : 0 : err = super_types[mddev->major_version]
4555 : 0 : .load_super(rdev, rdev0, mddev->minor_version);
4556 [ # # ]: 0 : if (err < 0)
4557 : 0 : goto out;
4558 : : }
4559 [ # # ]: 0 : } else if (mddev->external)
4560 : 0 : rdev = md_import_device(dev, -2, -1);
4561 : : else
4562 : 0 : rdev = md_import_device(dev, -1, -1);
4563 : :
4564 [ # # ]: 0 : if (IS_ERR(rdev)) {
4565 : 0 : mddev_unlock(mddev);
4566 : 0 : return PTR_ERR(rdev);
4567 : : }
4568 : 0 : err = bind_rdev_to_array(rdev, mddev);
4569 : 0 : out:
4570 [ # # ]: 0 : if (err)
4571 : 0 : export_rdev(rdev);
4572 : 0 : mddev_unlock(mddev);
4573 [ # # ]: 0 : if (!err)
4574 : 0 : md_new_event(mddev);
4575 [ # # ]: 0 : return err ? err : len;
4576 : : }
4577 : :
4578 : : static struct md_sysfs_entry md_new_device =
4579 : : __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
4580 : :
4581 : : static ssize_t
4582 : 0 : bitmap_store(struct mddev *mddev, const char *buf, size_t len)
4583 : : {
4584 : 0 : char *end;
4585 : 0 : unsigned long chunk, end_chunk;
4586 : 0 : int err;
4587 : :
4588 : 0 : err = mddev_lock(mddev);
4589 [ # # ]: 0 : if (err)
4590 : 0 : return err;
4591 [ # # ]: 0 : if (!mddev->bitmap)
4592 : 0 : goto out;
4593 : : /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4594 [ # # ]: 0 : while (*buf) {
4595 : 0 : chunk = end_chunk = simple_strtoul(buf, &end, 0);
4596 [ # # ]: 0 : if (buf == end) break;
4597 [ # # ]: 0 : if (*end == '-') { /* range */
4598 : 0 : buf = end + 1;
4599 : 0 : end_chunk = simple_strtoul(buf, &end, 0);
4600 [ # # ]: 0 : if (buf == end) break;
4601 : : }
4602 [ # # # # ]: 0 : if (*end && !isspace(*end)) break;
4603 : 0 : md_bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
4604 : 0 : buf = skip_spaces(end);
4605 : : }
4606 : 0 : md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4607 : 0 : out:
4608 : 0 : mddev_unlock(mddev);
4609 : 0 : return len;
4610 : : }
4611 : :
4612 : : static struct md_sysfs_entry md_bitmap =
4613 : : __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4614 : :
4615 : : static ssize_t
4616 : 0 : size_show(struct mddev *mddev, char *page)
4617 : : {
4618 : 0 : return sprintf(page, "%llu\n",
4619 : 0 : (unsigned long long)mddev->dev_sectors / 2);
4620 : : }
4621 : :
4622 : : static int update_size(struct mddev *mddev, sector_t num_sectors);
4623 : :
4624 : : static ssize_t
4625 : 0 : size_store(struct mddev *mddev, const char *buf, size_t len)
4626 : : {
4627 : : /* If array is inactive, we can reduce the component size, but
4628 : : * not increase it (except from 0).
4629 : : * If array is active, we can try an on-line resize
4630 : : */
4631 : 0 : sector_t sectors;
4632 : 0 : int err = strict_blocks_to_sectors(buf, §ors);
4633 : :
4634 [ # # ]: 0 : if (err < 0)
4635 : 0 : return err;
4636 : 0 : err = mddev_lock(mddev);
4637 [ # # ]: 0 : if (err)
4638 : 0 : return err;
4639 [ # # ]: 0 : if (mddev->pers) {
4640 : 0 : err = update_size(mddev, sectors);
4641 [ # # ]: 0 : if (err == 0)
4642 : 0 : md_update_sb(mddev, 1);
4643 : : } else {
4644 [ # # ]: 0 : if (mddev->dev_sectors == 0 ||
4645 [ # # ]: 0 : mddev->dev_sectors > sectors)
4646 : 0 : mddev->dev_sectors = sectors;
4647 : : else
4648 : : err = -ENOSPC;
4649 : : }
4650 : 0 : mddev_unlock(mddev);
4651 [ # # ]: 0 : return err ? err : len;
4652 : : }
4653 : :
4654 : : static struct md_sysfs_entry md_size =
4655 : : __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
4656 : :
4657 : : /* Metadata version.
4658 : : * This is one of
4659 : : * 'none' for arrays with no metadata (good luck...)
4660 : : * 'external' for arrays with externally managed metadata,
4661 : : * or N.M for internally known formats
4662 : : */
4663 : : static ssize_t
4664 : 0 : metadata_show(struct mddev *mddev, char *page)
4665 : : {
4666 [ # # ]: 0 : if (mddev->persistent)
4667 : 0 : return sprintf(page, "%d.%d\n",
4668 : : mddev->major_version, mddev->minor_version);
4669 [ # # ]: 0 : else if (mddev->external)
4670 : 0 : return sprintf(page, "external:%s\n", mddev->metadata_type);
4671 : : else
4672 : 0 : return sprintf(page, "none\n");
4673 : : }
4674 : :
4675 : : static ssize_t
4676 : 0 : metadata_store(struct mddev *mddev, const char *buf, size_t len)
4677 : : {
4678 : 0 : int major, minor;
4679 : 0 : char *e;
4680 : 0 : int err;
4681 : : /* Changing the details of 'external' metadata is
4682 : : * always permitted. Otherwise there must be
4683 : : * no devices attached to the array.
4684 : : */
4685 : :
4686 : 0 : err = mddev_lock(mddev);
4687 [ # # ]: 0 : if (err)
4688 : 0 : return err;
4689 : 0 : err = -EBUSY;
4690 [ # # # # ]: 0 : if (mddev->external && strncmp(buf, "external:", 9) == 0)
4691 : : ;
4692 [ # # ]: 0 : else if (!list_empty(&mddev->disks))
4693 : 0 : goto out_unlock;
4694 : :
4695 : 0 : err = 0;
4696 [ # # ]: 0 : if (cmd_match(buf, "none")) {
4697 : 0 : mddev->persistent = 0;
4698 : 0 : mddev->external = 0;
4699 : 0 : mddev->major_version = 0;
4700 : 0 : mddev->minor_version = 90;
4701 : 0 : goto out_unlock;
4702 : : }
4703 [ # # ]: 0 : if (strncmp(buf, "external:", 9) == 0) {
4704 : 0 : size_t namelen = len-9;
4705 : 0 : if (namelen >= sizeof(mddev->metadata_type))
4706 : : namelen = sizeof(mddev->metadata_type)-1;
4707 : 0 : strncpy(mddev->metadata_type, buf+9, namelen);
4708 : 0 : mddev->metadata_type[namelen] = 0;
4709 [ # # # # ]: 0 : if (namelen && mddev->metadata_type[namelen-1] == '\n')
4710 : 0 : mddev->metadata_type[--namelen] = 0;
4711 : 0 : mddev->persistent = 0;
4712 : 0 : mddev->external = 1;
4713 : 0 : mddev->major_version = 0;
4714 : 0 : mddev->minor_version = 90;
4715 : 0 : goto out_unlock;
4716 : : }
4717 : 0 : major = simple_strtoul(buf, &e, 10);
4718 : 0 : err = -EINVAL;
4719 [ # # # # ]: 0 : if (e==buf || *e != '.')
4720 : 0 : goto out_unlock;
4721 : 0 : buf = e+1;
4722 : 0 : minor = simple_strtoul(buf, &e, 10);
4723 [ # # # # ]: 0 : if (e==buf || (*e && *e != '\n') )
4724 : 0 : goto out_unlock;
4725 : 0 : err = -ENOENT;
4726 [ # # # # ]: 0 : if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
4727 : 0 : goto out_unlock;
4728 : 0 : mddev->major_version = major;
4729 : 0 : mddev->minor_version = minor;
4730 : 0 : mddev->persistent = 1;
4731 : 0 : mddev->external = 0;
4732 : 0 : err = 0;
4733 : 0 : out_unlock:
4734 : 0 : mddev_unlock(mddev);
4735 [ # # ]: 0 : return err ?: len;
4736 : : }
4737 : :
4738 : : static struct md_sysfs_entry md_metadata =
4739 : : __ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
4740 : :
4741 : : static ssize_t
4742 : 0 : action_show(struct mddev *mddev, char *page)
4743 : : {
4744 : 0 : char *type = "idle";
4745 : 0 : unsigned long recovery = mddev->recovery;
4746 [ # # ]: 0 : if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4747 : : type = "frozen";
4748 [ # # ]: 0 : else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4749 [ # # # # ]: 0 : (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4750 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4751 : : type = "reshape";
4752 [ # # ]: 0 : else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4753 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4754 : : type = "resync";
4755 [ # # ]: 0 : else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4756 : : type = "check";
4757 : : else
4758 : 0 : type = "repair";
4759 [ # # ]: 0 : } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4760 : : type = "recover";
4761 [ # # ]: 0 : else if (mddev->reshape_position != MaxSector)
4762 : 0 : type = "reshape";
4763 : : }
4764 : 0 : return sprintf(page, "%s\n", type);
4765 : : }
4766 : :
4767 : : static ssize_t
4768 : 0 : action_store(struct mddev *mddev, const char *page, size_t len)
4769 : : {
4770 [ # # # # ]: 0 : if (!mddev->pers || !mddev->pers->sync_request)
4771 : : return -EINVAL;
4772 : :
4773 : :
4774 [ # # # # ]: 0 : if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
4775 [ # # ]: 0 : if (cmd_match(page, "frozen"))
4776 : 0 : set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4777 : : else
4778 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4779 [ # # # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4780 : : mddev_lock(mddev) == 0) {
4781 : 0 : flush_workqueue(md_misc_wq);
4782 [ # # ]: 0 : if (mddev->sync_thread) {
4783 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4784 : 0 : md_reap_sync_thread(mddev);
4785 : : }
4786 : 0 : mddev_unlock(mddev);
4787 : : }
4788 [ # # ]: 0 : } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4789 : : return -EBUSY;
4790 [ # # ]: 0 : else if (cmd_match(page, "resync"))
4791 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4792 [ # # ]: 0 : else if (cmd_match(page, "recover")) {
4793 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4794 : 0 : set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4795 [ # # ]: 0 : } else if (cmd_match(page, "reshape")) {
4796 : 0 : int err;
4797 [ # # ]: 0 : if (mddev->pers->start_reshape == NULL)
4798 : : return -EINVAL;
4799 : 0 : err = mddev_lock(mddev);
4800 [ # # ]: 0 : if (!err) {
4801 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4802 : : err = -EBUSY;
4803 : : else {
4804 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4805 : 0 : err = mddev->pers->start_reshape(mddev);
4806 : : }
4807 : 0 : mddev_unlock(mddev);
4808 : : }
4809 [ # # ]: 0 : if (err)
4810 : 0 : return err;
4811 : 0 : sysfs_notify(&mddev->kobj, NULL, "degraded");
4812 : : } else {
4813 [ # # ]: 0 : if (cmd_match(page, "check"))
4814 : 0 : set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4815 [ # # ]: 0 : else if (!cmd_match(page, "repair"))
4816 : : return -EINVAL;
4817 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4818 : 0 : set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4819 : 0 : set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4820 : : }
4821 [ # # ]: 0 : if (mddev->ro == 2) {
4822 : : /* A write to sync_action is enough to justify
4823 : : * canceling read-auto mode
4824 : : */
4825 : 0 : mddev->ro = 0;
4826 : 0 : md_wakeup_thread(mddev->sync_thread);
4827 : : }
4828 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4829 : 0 : md_wakeup_thread(mddev->thread);
4830 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_action);
4831 : 0 : return len;
4832 : : }
4833 : :
4834 : : static struct md_sysfs_entry md_scan_mode =
4835 : : __ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4836 : :
4837 : : static ssize_t
4838 : 0 : last_sync_action_show(struct mddev *mddev, char *page)
4839 : : {
4840 : 0 : return sprintf(page, "%s\n", mddev->last_sync_action);
4841 : : }
4842 : :
4843 : : static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4844 : :
4845 : : static ssize_t
4846 : 0 : mismatch_cnt_show(struct mddev *mddev, char *page)
4847 : : {
4848 : 0 : return sprintf(page, "%llu\n",
4849 : : (unsigned long long)
4850 : 0 : atomic64_read(&mddev->resync_mismatches));
4851 : : }
4852 : :
4853 : : static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4854 : :
4855 : : static ssize_t
4856 : 0 : sync_min_show(struct mddev *mddev, char *page)
4857 : : {
4858 : 0 : return sprintf(page, "%d (%s)\n", speed_min(mddev),
4859 [ # # ]: 0 : mddev->sync_speed_min ? "local": "system");
4860 : : }
4861 : :
4862 : : static ssize_t
4863 : 0 : sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4864 : : {
4865 : 0 : unsigned int min;
4866 : 0 : int rv;
4867 : :
4868 [ # # ]: 0 : if (strncmp(buf, "system", 6)==0) {
4869 : 0 : min = 0;
4870 : : } else {
4871 : 0 : rv = kstrtouint(buf, 10, &min);
4872 [ # # ]: 0 : if (rv < 0)
4873 : 0 : return rv;
4874 [ # # ]: 0 : if (min == 0)
4875 : : return -EINVAL;
4876 : : }
4877 : 0 : mddev->sync_speed_min = min;
4878 : 0 : return len;
4879 : : }
4880 : :
4881 : : static struct md_sysfs_entry md_sync_min =
4882 : : __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4883 : :
4884 : : static ssize_t
4885 : 0 : sync_max_show(struct mddev *mddev, char *page)
4886 : : {
4887 : 0 : return sprintf(page, "%d (%s)\n", speed_max(mddev),
4888 [ # # ]: 0 : mddev->sync_speed_max ? "local": "system");
4889 : : }
4890 : :
4891 : : static ssize_t
4892 : 0 : sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4893 : : {
4894 : 0 : unsigned int max;
4895 : 0 : int rv;
4896 : :
4897 [ # # ]: 0 : if (strncmp(buf, "system", 6)==0) {
4898 : 0 : max = 0;
4899 : : } else {
4900 : 0 : rv = kstrtouint(buf, 10, &max);
4901 [ # # ]: 0 : if (rv < 0)
4902 : 0 : return rv;
4903 [ # # ]: 0 : if (max == 0)
4904 : : return -EINVAL;
4905 : : }
4906 : 0 : mddev->sync_speed_max = max;
4907 : 0 : return len;
4908 : : }
4909 : :
4910 : : static struct md_sysfs_entry md_sync_max =
4911 : : __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4912 : :
4913 : : static ssize_t
4914 : 0 : degraded_show(struct mddev *mddev, char *page)
4915 : : {
4916 : 0 : return sprintf(page, "%d\n", mddev->degraded);
4917 : : }
4918 : : static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4919 : :
4920 : : static ssize_t
4921 : 0 : sync_force_parallel_show(struct mddev *mddev, char *page)
4922 : : {
4923 : 0 : return sprintf(page, "%d\n", mddev->parallel_resync);
4924 : : }
4925 : :
4926 : : static ssize_t
4927 : 0 : sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4928 : : {
4929 : 0 : long n;
4930 : :
4931 [ # # ]: 0 : if (kstrtol(buf, 10, &n))
4932 : : return -EINVAL;
4933 : :
4934 [ # # ]: 0 : if (n != 0 && n != 1)
4935 : : return -EINVAL;
4936 : :
4937 : 0 : mddev->parallel_resync = n;
4938 : :
4939 [ # # ]: 0 : if (mddev->sync_thread)
4940 : 0 : wake_up(&resync_wait);
4941 : :
4942 : 0 : return len;
4943 : : }
4944 : :
4945 : : /* force parallel resync, even with shared block devices */
4946 : : static struct md_sysfs_entry md_sync_force_parallel =
4947 : : __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4948 : : sync_force_parallel_show, sync_force_parallel_store);
4949 : :
4950 : : static ssize_t
4951 : 0 : sync_speed_show(struct mddev *mddev, char *page)
4952 : : {
4953 : 0 : unsigned long resync, dt, db;
4954 [ # # ]: 0 : if (mddev->curr_resync == 0)
4955 : 0 : return sprintf(page, "none\n");
4956 : 0 : resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4957 : 0 : dt = (jiffies - mddev->resync_mark) / HZ;
4958 [ # # ]: 0 : if (!dt) dt++;
4959 : 0 : db = resync - mddev->resync_mark_cnt;
4960 : 0 : return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
4961 : : }
4962 : :
4963 : : static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4964 : :
4965 : : static ssize_t
4966 : 0 : sync_completed_show(struct mddev *mddev, char *page)
4967 : : {
4968 : 0 : unsigned long long max_sectors, resync;
4969 : :
4970 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4971 : 0 : return sprintf(page, "none\n");
4972 : :
4973 [ # # ]: 0 : if (mddev->curr_resync == 1 ||
4974 : : mddev->curr_resync == 2)
4975 : 0 : return sprintf(page, "delayed\n");
4976 : :
4977 [ # # # # ]: 0 : if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4978 : : test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
4979 : 0 : max_sectors = mddev->resync_max_sectors;
4980 : : else
4981 : 0 : max_sectors = mddev->dev_sectors;
4982 : :
4983 : 0 : resync = mddev->curr_resync_completed;
4984 : 0 : return sprintf(page, "%llu / %llu\n", resync, max_sectors);
4985 : : }
4986 : :
4987 : : static struct md_sysfs_entry md_sync_completed =
4988 : : __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
4989 : :
4990 : : static ssize_t
4991 : 0 : min_sync_show(struct mddev *mddev, char *page)
4992 : : {
4993 : 0 : return sprintf(page, "%llu\n",
4994 : 0 : (unsigned long long)mddev->resync_min);
4995 : : }
4996 : : static ssize_t
4997 : 0 : min_sync_store(struct mddev *mddev, const char *buf, size_t len)
4998 : : {
4999 : 0 : unsigned long long min;
5000 : 0 : int err;
5001 : :
5002 [ # # ]: 0 : if (kstrtoull(buf, 10, &min))
5003 : : return -EINVAL;
5004 : :
5005 : 0 : spin_lock(&mddev->lock);
5006 : 0 : err = -EINVAL;
5007 [ # # ]: 0 : if (min > mddev->resync_max)
5008 : 0 : goto out_unlock;
5009 : :
5010 : 0 : err = -EBUSY;
5011 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5012 : 0 : goto out_unlock;
5013 : :
5014 : : /* Round down to multiple of 4K for safety */
5015 : 0 : mddev->resync_min = round_down(min, 8);
5016 : 0 : err = 0;
5017 : :
5018 : 0 : out_unlock:
5019 : 0 : spin_unlock(&mddev->lock);
5020 [ # # ]: 0 : return err ?: len;
5021 : : }
5022 : :
5023 : : static struct md_sysfs_entry md_min_sync =
5024 : : __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
5025 : :
5026 : : static ssize_t
5027 : 0 : max_sync_show(struct mddev *mddev, char *page)
5028 : : {
5029 [ # # ]: 0 : if (mddev->resync_max == MaxSector)
5030 : 0 : return sprintf(page, "max\n");
5031 : : else
5032 : 0 : return sprintf(page, "%llu\n",
5033 : : (unsigned long long)mddev->resync_max);
5034 : : }
5035 : : static ssize_t
5036 : 0 : max_sync_store(struct mddev *mddev, const char *buf, size_t len)
5037 : : {
5038 : 0 : int err;
5039 : 0 : spin_lock(&mddev->lock);
5040 [ # # ]: 0 : if (strncmp(buf, "max", 3) == 0)
5041 : 0 : mddev->resync_max = MaxSector;
5042 : : else {
5043 : 0 : unsigned long long max;
5044 : 0 : int chunk;
5045 : :
5046 : 0 : err = -EINVAL;
5047 [ # # ]: 0 : if (kstrtoull(buf, 10, &max))
5048 : 0 : goto out_unlock;
5049 [ # # ]: 0 : if (max < mddev->resync_min)
5050 : 0 : goto out_unlock;
5051 : :
5052 : 0 : err = -EBUSY;
5053 [ # # ]: 0 : if (max < mddev->resync_max &&
5054 [ # # # # ]: 0 : mddev->ro == 0 &&
5055 : 0 : test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5056 : 0 : goto out_unlock;
5057 : :
5058 : : /* Must be a multiple of chunk_size */
5059 : 0 : chunk = mddev->chunk_sectors;
5060 [ # # ]: 0 : if (chunk) {
5061 : 0 : sector_t temp = max;
5062 : :
5063 : 0 : err = -EINVAL;
5064 [ # # ]: 0 : if (sector_div(temp, chunk))
5065 : 0 : goto out_unlock;
5066 : : }
5067 : 0 : mddev->resync_max = max;
5068 : : }
5069 : 0 : wake_up(&mddev->recovery_wait);
5070 : 0 : err = 0;
5071 : 0 : out_unlock:
5072 : 0 : spin_unlock(&mddev->lock);
5073 [ # # ]: 0 : return err ?: len;
5074 : : }
5075 : :
5076 : : static struct md_sysfs_entry md_max_sync =
5077 : : __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
5078 : :
5079 : : static ssize_t
5080 : 0 : suspend_lo_show(struct mddev *mddev, char *page)
5081 : : {
5082 : 0 : return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
5083 : : }
5084 : :
5085 : : static ssize_t
5086 : 0 : suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
5087 : : {
5088 : 0 : unsigned long long new;
5089 : 0 : int err;
5090 : :
5091 : 0 : err = kstrtoull(buf, 10, &new);
5092 [ # # ]: 0 : if (err < 0)
5093 : 0 : return err;
5094 : 0 : if (new != (sector_t)new)
5095 : : return -EINVAL;
5096 : :
5097 : 0 : err = mddev_lock(mddev);
5098 [ # # ]: 0 : if (err)
5099 : 0 : return err;
5100 : 0 : err = -EINVAL;
5101 [ # # ]: 0 : if (mddev->pers == NULL ||
5102 [ # # ]: 0 : mddev->pers->quiesce == NULL)
5103 : 0 : goto unlock;
5104 : 0 : mddev_suspend(mddev);
5105 : 0 : mddev->suspend_lo = new;
5106 : 0 : mddev_resume(mddev);
5107 : :
5108 : 0 : err = 0;
5109 : 0 : unlock:
5110 : 0 : mddev_unlock(mddev);
5111 [ # # ]: 0 : return err ?: len;
5112 : : }
5113 : : static struct md_sysfs_entry md_suspend_lo =
5114 : : __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
5115 : :
5116 : : static ssize_t
5117 : 0 : suspend_hi_show(struct mddev *mddev, char *page)
5118 : : {
5119 : 0 : return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
5120 : : }
5121 : :
5122 : : static ssize_t
5123 : 0 : suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
5124 : : {
5125 : 0 : unsigned long long new;
5126 : 0 : int err;
5127 : :
5128 : 0 : err = kstrtoull(buf, 10, &new);
5129 [ # # ]: 0 : if (err < 0)
5130 : 0 : return err;
5131 : 0 : if (new != (sector_t)new)
5132 : : return -EINVAL;
5133 : :
5134 : 0 : err = mddev_lock(mddev);
5135 [ # # ]: 0 : if (err)
5136 : 0 : return err;
5137 : 0 : err = -EINVAL;
5138 [ # # ]: 0 : if (mddev->pers == NULL)
5139 : 0 : goto unlock;
5140 : :
5141 : 0 : mddev_suspend(mddev);
5142 : 0 : mddev->suspend_hi = new;
5143 : 0 : mddev_resume(mddev);
5144 : :
5145 : 0 : err = 0;
5146 : 0 : unlock:
5147 : 0 : mddev_unlock(mddev);
5148 [ # # ]: 0 : return err ?: len;
5149 : : }
5150 : : static struct md_sysfs_entry md_suspend_hi =
5151 : : __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
5152 : :
5153 : : static ssize_t
5154 : 0 : reshape_position_show(struct mddev *mddev, char *page)
5155 : : {
5156 [ # # ]: 0 : if (mddev->reshape_position != MaxSector)
5157 : 0 : return sprintf(page, "%llu\n",
5158 : : (unsigned long long)mddev->reshape_position);
5159 : 0 : strcpy(page, "none\n");
5160 : 0 : return 5;
5161 : : }
5162 : :
5163 : : static ssize_t
5164 : 0 : reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
5165 : : {
5166 : 0 : struct md_rdev *rdev;
5167 : 0 : unsigned long long new;
5168 : 0 : int err;
5169 : :
5170 : 0 : err = kstrtoull(buf, 10, &new);
5171 [ # # ]: 0 : if (err < 0)
5172 : 0 : return err;
5173 : 0 : if (new != (sector_t)new)
5174 : : return -EINVAL;
5175 : 0 : err = mddev_lock(mddev);
5176 [ # # ]: 0 : if (err)
5177 : 0 : return err;
5178 : 0 : err = -EBUSY;
5179 [ # # ]: 0 : if (mddev->pers)
5180 : 0 : goto unlock;
5181 : 0 : mddev->reshape_position = new;
5182 : 0 : mddev->delta_disks = 0;
5183 : 0 : mddev->reshape_backwards = 0;
5184 : 0 : mddev->new_level = mddev->level;
5185 : 0 : mddev->new_layout = mddev->layout;
5186 : 0 : mddev->new_chunk_sectors = mddev->chunk_sectors;
5187 [ # # ]: 0 : rdev_for_each(rdev, mddev)
5188 : 0 : rdev->new_data_offset = rdev->data_offset;
5189 : : err = 0;
5190 : 0 : unlock:
5191 : 0 : mddev_unlock(mddev);
5192 [ # # ]: 0 : return err ?: len;
5193 : : }
5194 : :
5195 : : static struct md_sysfs_entry md_reshape_position =
5196 : : __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
5197 : : reshape_position_store);
5198 : :
5199 : : static ssize_t
5200 : 0 : reshape_direction_show(struct mddev *mddev, char *page)
5201 : : {
5202 : 0 : return sprintf(page, "%s\n",
5203 [ # # ]: 0 : mddev->reshape_backwards ? "backwards" : "forwards");
5204 : : }
5205 : :
5206 : : static ssize_t
5207 : 0 : reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
5208 : : {
5209 : 0 : int backwards = 0;
5210 : 0 : int err;
5211 : :
5212 [ # # ]: 0 : if (cmd_match(buf, "forwards"))
5213 : : backwards = 0;
5214 [ # # ]: 0 : else if (cmd_match(buf, "backwards"))
5215 : : backwards = 1;
5216 : : else
5217 : : return -EINVAL;
5218 [ # # ]: 0 : if (mddev->reshape_backwards == backwards)
5219 : 0 : return len;
5220 : :
5221 : 0 : err = mddev_lock(mddev);
5222 [ # # ]: 0 : if (err)
5223 : 0 : return err;
5224 : : /* check if we are allowed to change */
5225 [ # # ]: 0 : if (mddev->delta_disks)
5226 : : err = -EBUSY;
5227 [ # # ]: 0 : else if (mddev->persistent &&
5228 [ # # ]: 0 : mddev->major_version == 0)
5229 : : err = -EINVAL;
5230 : : else
5231 : 0 : mddev->reshape_backwards = backwards;
5232 : 0 : mddev_unlock(mddev);
5233 [ # # ]: 0 : return err ?: len;
5234 : : }
5235 : :
5236 : : static struct md_sysfs_entry md_reshape_direction =
5237 : : __ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
5238 : : reshape_direction_store);
5239 : :
5240 : : static ssize_t
5241 : 0 : array_size_show(struct mddev *mddev, char *page)
5242 : : {
5243 [ # # ]: 0 : if (mddev->external_size)
5244 : 0 : return sprintf(page, "%llu\n",
5245 : 0 : (unsigned long long)mddev->array_sectors/2);
5246 : : else
5247 : 0 : return sprintf(page, "default\n");
5248 : : }
5249 : :
5250 : : static ssize_t
5251 : 0 : array_size_store(struct mddev *mddev, const char *buf, size_t len)
5252 : : {
5253 : 0 : sector_t sectors;
5254 : 0 : int err;
5255 : :
5256 : 0 : err = mddev_lock(mddev);
5257 [ # # ]: 0 : if (err)
5258 : 0 : return err;
5259 : :
5260 : : /* cluster raid doesn't support change array_sectors */
5261 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
5262 : 0 : mddev_unlock(mddev);
5263 : 0 : return -EINVAL;
5264 : : }
5265 : :
5266 [ # # ]: 0 : if (strncmp(buf, "default", 7) == 0) {
5267 [ # # ]: 0 : if (mddev->pers)
5268 : 0 : sectors = mddev->pers->size(mddev, 0, 0);
5269 : : else
5270 : 0 : sectors = mddev->array_sectors;
5271 : :
5272 : 0 : mddev->external_size = 0;
5273 : : } else {
5274 [ # # ]: 0 : if (strict_blocks_to_sectors(buf, §ors) < 0)
5275 : : err = -EINVAL;
5276 [ # # # # ]: 0 : else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
5277 : : err = -E2BIG;
5278 : : else
5279 : 0 : mddev->external_size = 1;
5280 : : }
5281 : :
5282 : 0 : if (!err) {
5283 : 0 : mddev->array_sectors = sectors;
5284 [ # # ]: 0 : if (mddev->pers) {
5285 : 0 : set_capacity(mddev->gendisk, mddev->array_sectors);
5286 : 0 : revalidate_disk(mddev->gendisk);
5287 : : }
5288 : : }
5289 : 0 : mddev_unlock(mddev);
5290 [ # # ]: 0 : return err ?: len;
5291 : : }
5292 : :
5293 : : static struct md_sysfs_entry md_array_size =
5294 : : __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
5295 : : array_size_store);
5296 : :
5297 : : static ssize_t
5298 : 0 : consistency_policy_show(struct mddev *mddev, char *page)
5299 : : {
5300 : 0 : int ret;
5301 : :
5302 [ # # ]: 0 : if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
5303 : 0 : ret = sprintf(page, "journal\n");
5304 [ # # ]: 0 : } else if (test_bit(MD_HAS_PPL, &mddev->flags)) {
5305 : 0 : ret = sprintf(page, "ppl\n");
5306 [ # # ]: 0 : } else if (mddev->bitmap) {
5307 : 0 : ret = sprintf(page, "bitmap\n");
5308 [ # # ]: 0 : } else if (mddev->pers) {
5309 [ # # ]: 0 : if (mddev->pers->sync_request)
5310 : 0 : ret = sprintf(page, "resync\n");
5311 : : else
5312 : 0 : ret = sprintf(page, "none\n");
5313 : : } else {
5314 : 0 : ret = sprintf(page, "unknown\n");
5315 : : }
5316 : :
5317 : 0 : return ret;
5318 : : }
5319 : :
5320 : : static ssize_t
5321 : 0 : consistency_policy_store(struct mddev *mddev, const char *buf, size_t len)
5322 : : {
5323 : 0 : int err = 0;
5324 : :
5325 [ # # ]: 0 : if (mddev->pers) {
5326 [ # # ]: 0 : if (mddev->pers->change_consistency_policy)
5327 : 0 : err = mddev->pers->change_consistency_policy(mddev, buf);
5328 : : else
5329 : : err = -EBUSY;
5330 [ # # # # ]: 0 : } else if (mddev->external && strncmp(buf, "ppl", 3) == 0) {
5331 : 0 : set_bit(MD_HAS_PPL, &mddev->flags);
5332 : : } else {
5333 : : err = -EINVAL;
5334 : : }
5335 : :
5336 [ # # ]: 0 : return err ? err : len;
5337 : : }
5338 : :
5339 : : static struct md_sysfs_entry md_consistency_policy =
5340 : : __ATTR(consistency_policy, S_IRUGO | S_IWUSR, consistency_policy_show,
5341 : : consistency_policy_store);
5342 : :
5343 : 0 : static ssize_t fail_last_dev_show(struct mddev *mddev, char *page)
5344 : : {
5345 : 0 : return sprintf(page, "%d\n", mddev->fail_last_dev);
5346 : : }
5347 : :
5348 : : /*
5349 : : * Setting fail_last_dev to true to allow last device to be forcibly removed
5350 : : * from RAID1/RAID10.
5351 : : */
5352 : : static ssize_t
5353 : 0 : fail_last_dev_store(struct mddev *mddev, const char *buf, size_t len)
5354 : : {
5355 : 0 : int ret;
5356 : 0 : bool value;
5357 : :
5358 : 0 : ret = kstrtobool(buf, &value);
5359 [ # # ]: 0 : if (ret)
5360 : 0 : return ret;
5361 : :
5362 [ # # ]: 0 : if (value != mddev->fail_last_dev)
5363 : 0 : mddev->fail_last_dev = value;
5364 : :
5365 : 0 : return len;
5366 : : }
5367 : : static struct md_sysfs_entry md_fail_last_dev =
5368 : : __ATTR(fail_last_dev, S_IRUGO | S_IWUSR, fail_last_dev_show,
5369 : : fail_last_dev_store);
5370 : :
5371 : 0 : static ssize_t serialize_policy_show(struct mddev *mddev, char *page)
5372 : : {
5373 [ # # # # ]: 0 : if (mddev->pers == NULL || (mddev->pers->level != 1))
5374 : 0 : return sprintf(page, "n/a\n");
5375 : : else
5376 : 0 : return sprintf(page, "%d\n", mddev->serialize_policy);
5377 : : }
5378 : :
5379 : : /*
5380 : : * Setting serialize_policy to true to enforce write IO is not reordered
5381 : : * for raid1.
5382 : : */
5383 : : static ssize_t
5384 : 0 : serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)
5385 : : {
5386 : 0 : int err;
5387 : 0 : bool value;
5388 : :
5389 : 0 : err = kstrtobool(buf, &value);
5390 [ # # ]: 0 : if (err)
5391 : 0 : return err;
5392 : :
5393 [ # # ]: 0 : if (value == mddev->serialize_policy)
5394 : 0 : return len;
5395 : :
5396 : 0 : err = mddev_lock(mddev);
5397 [ # # ]: 0 : if (err)
5398 : 0 : return err;
5399 [ # # # # ]: 0 : if (mddev->pers == NULL || (mddev->pers->level != 1)) {
5400 : 0 : pr_err("md: serialize_policy is only effective for raid1\n");
5401 : 0 : err = -EINVAL;
5402 : 0 : goto unlock;
5403 : : }
5404 : :
5405 : 0 : mddev_suspend(mddev);
5406 [ # # ]: 0 : if (value)
5407 : 0 : mddev_create_serial_pool(mddev, NULL, true);
5408 : : else
5409 : 0 : mddev_destroy_serial_pool(mddev, NULL, true);
5410 : 0 : mddev->serialize_policy = value;
5411 : 0 : mddev_resume(mddev);
5412 : 0 : unlock:
5413 : 0 : mddev_unlock(mddev);
5414 [ # # ]: 0 : return err ?: len;
5415 : : }
5416 : :
5417 : : static struct md_sysfs_entry md_serialize_policy =
5418 : : __ATTR(serialize_policy, S_IRUGO | S_IWUSR, serialize_policy_show,
5419 : : serialize_policy_store);
5420 : :
5421 : :
5422 : : static struct attribute *md_default_attrs[] = {
5423 : : &md_level.attr,
5424 : : &md_layout.attr,
5425 : : &md_raid_disks.attr,
5426 : : &md_chunk_size.attr,
5427 : : &md_size.attr,
5428 : : &md_resync_start.attr,
5429 : : &md_metadata.attr,
5430 : : &md_new_device.attr,
5431 : : &md_safe_delay.attr,
5432 : : &md_array_state.attr,
5433 : : &md_reshape_position.attr,
5434 : : &md_reshape_direction.attr,
5435 : : &md_array_size.attr,
5436 : : &max_corr_read_errors.attr,
5437 : : &md_consistency_policy.attr,
5438 : : &md_fail_last_dev.attr,
5439 : : &md_serialize_policy.attr,
5440 : : NULL,
5441 : : };
5442 : :
5443 : : static struct attribute *md_redundancy_attrs[] = {
5444 : : &md_scan_mode.attr,
5445 : : &md_last_scan_mode.attr,
5446 : : &md_mismatches.attr,
5447 : : &md_sync_min.attr,
5448 : : &md_sync_max.attr,
5449 : : &md_sync_speed.attr,
5450 : : &md_sync_force_parallel.attr,
5451 : : &md_sync_completed.attr,
5452 : : &md_min_sync.attr,
5453 : : &md_max_sync.attr,
5454 : : &md_suspend_lo.attr,
5455 : : &md_suspend_hi.attr,
5456 : : &md_bitmap.attr,
5457 : : &md_degraded.attr,
5458 : : NULL,
5459 : : };
5460 : : static struct attribute_group md_redundancy_group = {
5461 : : .name = NULL,
5462 : : .attrs = md_redundancy_attrs,
5463 : : };
5464 : :
5465 : : static ssize_t
5466 : 26 : md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
5467 : : {
5468 : 26 : struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
5469 : 26 : struct mddev *mddev = container_of(kobj, struct mddev, kobj);
5470 : 26 : ssize_t rv;
5471 : :
5472 [ + - ]: 26 : if (!entry->show)
5473 : : return -EIO;
5474 : 26 : spin_lock(&all_mddevs_lock);
5475 [ - + ]: 26 : if (list_empty(&mddev->all_mddevs)) {
5476 : 0 : spin_unlock(&all_mddevs_lock);
5477 : 0 : return -EBUSY;
5478 : : }
5479 : 26 : mddev_get(mddev);
5480 : 26 : spin_unlock(&all_mddevs_lock);
5481 : :
5482 : 26 : rv = entry->show(mddev, page);
5483 : 26 : mddev_put(mddev);
5484 : 26 : return rv;
5485 : : }
5486 : :
5487 : : static ssize_t
5488 : 0 : md_attr_store(struct kobject *kobj, struct attribute *attr,
5489 : : const char *page, size_t length)
5490 : : {
5491 : 0 : struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
5492 : 0 : struct mddev *mddev = container_of(kobj, struct mddev, kobj);
5493 : 0 : ssize_t rv;
5494 : :
5495 [ # # ]: 0 : if (!entry->store)
5496 : : return -EIO;
5497 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
5498 : : return -EACCES;
5499 : 0 : spin_lock(&all_mddevs_lock);
5500 [ # # ]: 0 : if (list_empty(&mddev->all_mddevs)) {
5501 : 0 : spin_unlock(&all_mddevs_lock);
5502 : 0 : return -EBUSY;
5503 : : }
5504 : 0 : mddev_get(mddev);
5505 : 0 : spin_unlock(&all_mddevs_lock);
5506 : 0 : rv = entry->store(mddev, page, length);
5507 : 0 : mddev_put(mddev);
5508 : 0 : return rv;
5509 : : }
5510 : :
5511 : 0 : static void md_free(struct kobject *ko)
5512 : : {
5513 : 0 : struct mddev *mddev = container_of(ko, struct mddev, kobj);
5514 : :
5515 [ # # ]: 0 : if (mddev->sysfs_state)
5516 : 0 : sysfs_put(mddev->sysfs_state);
5517 : :
5518 [ # # ]: 0 : if (mddev->gendisk)
5519 : 0 : del_gendisk(mddev->gendisk);
5520 [ # # ]: 0 : if (mddev->queue)
5521 : 0 : blk_cleanup_queue(mddev->queue);
5522 [ # # ]: 0 : if (mddev->gendisk)
5523 : 0 : put_disk(mddev->gendisk);
5524 : 0 : percpu_ref_exit(&mddev->writes_pending);
5525 : :
5526 : 0 : bioset_exit(&mddev->bio_set);
5527 : 0 : bioset_exit(&mddev->sync_set);
5528 : 0 : kfree(mddev);
5529 : 0 : }
5530 : :
5531 : : static const struct sysfs_ops md_sysfs_ops = {
5532 : : .show = md_attr_show,
5533 : : .store = md_attr_store,
5534 : : };
5535 : : static struct kobj_type md_ktype = {
5536 : : .release = md_free,
5537 : : .sysfs_ops = &md_sysfs_ops,
5538 : : .default_attrs = md_default_attrs,
5539 : : };
5540 : :
5541 : : int mdp_major = 0;
5542 : :
5543 : 0 : static void mddev_delayed_delete(struct work_struct *ws)
5544 : : {
5545 : 0 : struct mddev *mddev = container_of(ws, struct mddev, del_work);
5546 : :
5547 : 0 : sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
5548 : 0 : kobject_del(&mddev->kobj);
5549 : 0 : kobject_put(&mddev->kobj);
5550 : 0 : }
5551 : :
5552 : 0 : static void no_op(struct percpu_ref *r) {}
5553 : :
5554 : 0 : int mddev_init_writes_pending(struct mddev *mddev)
5555 : : {
5556 [ # # ]: 0 : if (mddev->writes_pending.percpu_count_ptr)
5557 : : return 0;
5558 [ # # ]: 0 : if (percpu_ref_init(&mddev->writes_pending, no_op,
5559 : : PERCPU_REF_ALLOW_REINIT, GFP_KERNEL) < 0)
5560 : : return -ENOMEM;
5561 : : /* We want to start with the refcount at zero */
5562 : 0 : percpu_ref_put(&mddev->writes_pending);
5563 : 0 : return 0;
5564 : : }
5565 : : EXPORT_SYMBOL_GPL(mddev_init_writes_pending);
5566 : :
5567 : 13 : static int md_alloc(dev_t dev, char *name)
5568 : : {
5569 : : /*
5570 : : * If dev is zero, name is the name of a device to allocate with
5571 : : * an arbitrary minor number. It will be "md_???"
5572 : : * If dev is non-zero it must be a device number with a MAJOR of
5573 : : * MD_MAJOR or mdp_major. In this case, if "name" is NULL, then
5574 : : * the device is being created by opening a node in /dev.
5575 : : * If "name" is not NULL, the device is being created by
5576 : : * writing to /sys/module/md_mod/parameters/new_array.
5577 : : */
5578 : 13 : static DEFINE_MUTEX(disks_mutex);
5579 : 13 : struct mddev *mddev = mddev_find(dev);
5580 : 13 : struct gendisk *disk;
5581 : 13 : int partitioned;
5582 : 13 : int shift;
5583 : 13 : int unit;
5584 : 13 : int error;
5585 : :
5586 [ + - ]: 13 : if (!mddev)
5587 : : return -ENODEV;
5588 : :
5589 : 13 : partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
5590 [ + - ]: 13 : shift = partitioned ? MdpMinorShift : 0;
5591 : 13 : unit = MINOR(mddev->unit) >> shift;
5592 : :
5593 : : /* wait for any previous instance of this device to be
5594 : : * completely removed (mddev_delayed_delete).
5595 : : */
5596 : 13 : flush_workqueue(md_misc_wq);
5597 : :
5598 : 13 : mutex_lock(&disks_mutex);
5599 : 13 : error = -EEXIST;
5600 [ - + ]: 13 : if (mddev->gendisk)
5601 : 0 : goto abort;
5602 : :
5603 [ - + ]: 13 : if (name && !dev) {
5604 : : /* Need to ensure that 'name' is not a duplicate.
5605 : : */
5606 : 0 : struct mddev *mddev2;
5607 : 0 : spin_lock(&all_mddevs_lock);
5608 : :
5609 [ # # ]: 0 : list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
5610 [ # # ]: 0 : if (mddev2->gendisk &&
5611 [ # # ]: 0 : strcmp(mddev2->gendisk->disk_name, name) == 0) {
5612 : 0 : spin_unlock(&all_mddevs_lock);
5613 : 0 : goto abort;
5614 : : }
5615 : 0 : spin_unlock(&all_mddevs_lock);
5616 : : }
5617 [ - + ]: 13 : if (name && dev)
5618 : : /*
5619 : : * Creating /dev/mdNNN via "newarray", so adjust hold_active.
5620 : : */
5621 : 0 : mddev->hold_active = UNTIL_STOP;
5622 : :
5623 : 13 : error = -ENOMEM;
5624 : 13 : mddev->queue = blk_alloc_queue(GFP_KERNEL);
5625 [ - + ]: 13 : if (!mddev->queue)
5626 : 0 : goto abort;
5627 : 13 : mddev->queue->queuedata = mddev;
5628 : :
5629 : 13 : blk_queue_make_request(mddev->queue, md_make_request);
5630 : 13 : blk_set_stacking_limits(&mddev->queue->limits);
5631 : :
5632 : 13 : disk = alloc_disk(1 << shift);
5633 [ - + ]: 13 : if (!disk) {
5634 : 0 : blk_cleanup_queue(mddev->queue);
5635 : 0 : mddev->queue = NULL;
5636 : 0 : goto abort;
5637 : : }
5638 : 13 : disk->major = MAJOR(mddev->unit);
5639 : 13 : disk->first_minor = unit << shift;
5640 [ - + ]: 13 : if (name)
5641 : 0 : strcpy(disk->disk_name, name);
5642 [ - + ]: 13 : else if (partitioned)
5643 : 0 : sprintf(disk->disk_name, "md_d%d", unit);
5644 : : else
5645 : 13 : sprintf(disk->disk_name, "md%d", unit);
5646 : 13 : disk->fops = &md_fops;
5647 : 13 : disk->private_data = mddev;
5648 : 13 : disk->queue = mddev->queue;
5649 : 13 : blk_queue_write_cache(mddev->queue, true, true);
5650 : : /* Allow extended partitions. This makes the
5651 : : * 'mdp' device redundant, but we can't really
5652 : : * remove it now.
5653 : : */
5654 : 13 : disk->flags |= GENHD_FL_EXT_DEVT;
5655 : 13 : mddev->gendisk = disk;
5656 : : /* As soon as we call add_disk(), another thread could get
5657 : : * through to md_open, so make sure it doesn't get too far
5658 : : */
5659 : 13 : mutex_lock(&mddev->open_mutex);
5660 : 13 : add_disk(disk);
5661 : :
5662 : 13 : error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md");
5663 [ - + ]: 13 : if (error) {
5664 : : /* This isn't possible, but as kobject_init_and_add is marked
5665 : : * __must_check, we must do something with the result
5666 : : */
5667 : 0 : pr_debug("md: cannot register %s/md - name in use\n",
5668 : : disk->disk_name);
5669 : 0 : error = 0;
5670 : : }
5671 [ + - ]: 13 : if (mddev->kobj.sd &&
5672 : 13 : sysfs_create_group(&mddev->kobj, &md_bitmap_group))
5673 : : pr_debug("pointless warning\n");
5674 : 13 : mutex_unlock(&mddev->open_mutex);
5675 : 13 : abort:
5676 : 13 : mutex_unlock(&disks_mutex);
5677 [ + - + - ]: 13 : if (!error && mddev->kobj.sd) {
5678 : 13 : kobject_uevent(&mddev->kobj, KOBJ_ADD);
5679 [ + - ]: 26 : mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
5680 : : }
5681 : 13 : mddev_put(mddev);
5682 : 13 : return error;
5683 : : }
5684 : :
5685 : 13 : static struct kobject *md_probe(dev_t dev, int *part, void *data)
5686 : : {
5687 [ + - ]: 13 : if (create_on_open)
5688 : 13 : md_alloc(dev, NULL);
5689 : 13 : return NULL;
5690 : : }
5691 : :
5692 : 0 : static int add_named_array(const char *val, const struct kernel_param *kp)
5693 : : {
5694 : : /*
5695 : : * val must be "md_*" or "mdNNN".
5696 : : * For "md_*" we allocate an array with a large free minor number, and
5697 : : * set the name to val. val must not already be an active name.
5698 : : * For "mdNNN" we allocate an array with the minor number NNN
5699 : : * which must not already be in use.
5700 : : */
5701 : 0 : int len = strlen(val);
5702 : 0 : char buf[DISK_NAME_LEN];
5703 : 0 : unsigned long devnum;
5704 : :
5705 [ # # # # ]: 0 : while (len && val[len-1] == '\n')
5706 : : len--;
5707 [ # # ]: 0 : if (len >= DISK_NAME_LEN)
5708 : : return -E2BIG;
5709 : 0 : strlcpy(buf, val, len+1);
5710 [ # # ]: 0 : if (strncmp(buf, "md_", 3) == 0)
5711 : 0 : return md_alloc(0, buf);
5712 [ # # # # ]: 0 : if (strncmp(buf, "md", 2) == 0 &&
5713 [ # # # # ]: 0 : isdigit(buf[2]) &&
5714 : 0 : kstrtoul(buf+2, 10, &devnum) == 0 &&
5715 [ # # ]: 0 : devnum <= MINORMASK)
5716 : 0 : return md_alloc(MKDEV(MD_MAJOR, devnum), NULL);
5717 : :
5718 : : return -EINVAL;
5719 : : }
5720 : :
5721 : 0 : static void md_safemode_timeout(struct timer_list *t)
5722 : : {
5723 : 0 : struct mddev *mddev = from_timer(mddev, t, safemode_timer);
5724 : :
5725 : 0 : mddev->safemode = 1;
5726 [ # # ]: 0 : if (mddev->external)
5727 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
5728 : :
5729 : 0 : md_wakeup_thread(mddev->thread);
5730 : 0 : }
5731 : :
5732 : : static int start_dirty_degraded;
5733 : :
5734 : 0 : int md_run(struct mddev *mddev)
5735 : : {
5736 : 0 : int err;
5737 : 0 : struct md_rdev *rdev;
5738 : 0 : struct md_personality *pers;
5739 : :
5740 [ # # ]: 0 : if (list_empty(&mddev->disks))
5741 : : /* cannot run an array with no devices.. */
5742 : : return -EINVAL;
5743 : :
5744 [ # # ]: 0 : if (mddev->pers)
5745 : : return -EBUSY;
5746 : : /* Cannot run until previous stop completes properly */
5747 [ # # ]: 0 : if (mddev->sysfs_active)
5748 : : return -EBUSY;
5749 : :
5750 : : /*
5751 : : * Analyze all RAID superblock(s)
5752 : : */
5753 [ # # ]: 0 : if (!mddev->raid_disks) {
5754 [ # # ]: 0 : if (!mddev->persistent)
5755 : : return -EINVAL;
5756 : 0 : err = analyze_sbs(mddev);
5757 [ # # ]: 0 : if (err)
5758 : : return -EINVAL;
5759 : : }
5760 : :
5761 [ # # ]: 0 : if (mddev->level != LEVEL_NONE)
5762 : 0 : request_module("md-level-%d", mddev->level);
5763 [ # # ]: 0 : else if (mddev->clevel[0])
5764 : 0 : request_module("md-%s", mddev->clevel);
5765 : :
5766 : : /*
5767 : : * Drop all container device buffers, from now on
5768 : : * the only valid external interface is through the md
5769 : : * device.
5770 : : */
5771 : 0 : mddev->has_superblocks = false;
5772 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
5773 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
5774 : 0 : continue;
5775 : 0 : sync_blockdev(rdev->bdev);
5776 : 0 : invalidate_bdev(rdev->bdev);
5777 [ # # # # ]: 0 : if (mddev->ro != 1 &&
5778 [ # # ]: 0 : (bdev_read_only(rdev->bdev) ||
5779 : 0 : bdev_read_only(rdev->meta_bdev))) {
5780 : 0 : mddev->ro = 1;
5781 [ # # ]: 0 : if (mddev->gendisk)
5782 : 0 : set_disk_ro(mddev->gendisk, 1);
5783 : : }
5784 : :
5785 [ # # ]: 0 : if (rdev->sb_page)
5786 : 0 : mddev->has_superblocks = true;
5787 : :
5788 : : /* perform some consistency tests on the device.
5789 : : * We don't want the data to overlap the metadata,
5790 : : * Internal Bitmap issues have been handled elsewhere.
5791 : : */
5792 [ # # ]: 0 : if (rdev->meta_bdev) {
5793 : : /* Nothing to check */;
5794 [ # # ]: 0 : } else if (rdev->data_offset < rdev->sb_start) {
5795 [ # # ]: 0 : if (mddev->dev_sectors &&
5796 [ # # ]: 0 : rdev->data_offset + mddev->dev_sectors
5797 : : > rdev->sb_start) {
5798 [ # # ]: 0 : pr_warn("md: %s: data overlaps metadata\n",
5799 : : mdname(mddev));
5800 : 0 : return -EINVAL;
5801 : : }
5802 : : } else {
5803 [ # # ]: 0 : if (rdev->sb_start + rdev->sb_size/512
5804 : : > rdev->data_offset) {
5805 [ # # ]: 0 : pr_warn("md: %s: metadata overlaps data\n",
5806 : : mdname(mddev));
5807 : 0 : return -EINVAL;
5808 : : }
5809 : : }
5810 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
5811 : : }
5812 : :
5813 [ # # ]: 0 : if (!bioset_initialized(&mddev->bio_set)) {
5814 : 0 : err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
5815 [ # # ]: 0 : if (err)
5816 : : return err;
5817 : : }
5818 [ # # ]: 0 : if (!bioset_initialized(&mddev->sync_set)) {
5819 : 0 : err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
5820 [ # # ]: 0 : if (err)
5821 : : return err;
5822 : : }
5823 : :
5824 : 0 : spin_lock(&pers_lock);
5825 : 0 : pers = find_pers(mddev->level, mddev->clevel);
5826 [ # # # # ]: 0 : if (!pers || !try_module_get(pers->owner)) {
5827 : 0 : spin_unlock(&pers_lock);
5828 [ # # ]: 0 : if (mddev->level != LEVEL_NONE)
5829 : 0 : pr_warn("md: personality for level %d is not loaded!\n",
5830 : : mddev->level);
5831 : : else
5832 : 0 : pr_warn("md: personality for level %s is not loaded!\n",
5833 : : mddev->clevel);
5834 : 0 : err = -EINVAL;
5835 : 0 : goto abort;
5836 : : }
5837 : 0 : spin_unlock(&pers_lock);
5838 [ # # ]: 0 : if (mddev->level != pers->level) {
5839 : 0 : mddev->level = pers->level;
5840 : 0 : mddev->new_level = pers->level;
5841 : : }
5842 : 0 : strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
5843 : :
5844 [ # # ]: 0 : if (mddev->reshape_position != MaxSector &&
5845 [ # # ]: 0 : pers->start_reshape == NULL) {
5846 : : /* This personality cannot handle reshaping... */
5847 : 0 : module_put(pers->owner);
5848 : 0 : err = -EINVAL;
5849 : 0 : goto abort;
5850 : : }
5851 : :
5852 [ # # ]: 0 : if (pers->sync_request) {
5853 : : /* Warn if this is a potentially silly
5854 : : * configuration.
5855 : : */
5856 : 0 : char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5857 : 0 : struct md_rdev *rdev2;
5858 : 0 : int warned = 0;
5859 : :
5860 [ # # ]: 0 : rdev_for_each(rdev, mddev)
5861 [ # # ]: 0 : rdev_for_each(rdev2, mddev) {
5862 [ # # ]: 0 : if (rdev < rdev2 &&
5863 : 0 : rdev->bdev->bd_contains ==
5864 [ # # ]: 0 : rdev2->bdev->bd_contains) {
5865 [ # # ]: 0 : pr_warn("%s: WARNING: %s appears to be on the same physical disk as %s.\n",
5866 : : mdname(mddev),
5867 : : bdevname(rdev->bdev,b),
5868 : : bdevname(rdev2->bdev,b2));
5869 : 0 : warned = 1;
5870 : : }
5871 : : }
5872 : :
5873 [ # # ]: 0 : if (warned)
5874 : 0 : pr_warn("True protection against single-disk failure might be compromised.\n");
5875 : : }
5876 : :
5877 : 0 : mddev->recovery = 0;
5878 : : /* may be over-ridden by personality */
5879 : 0 : mddev->resync_max_sectors = mddev->dev_sectors;
5880 : :
5881 : 0 : mddev->ok_start_degraded = start_dirty_degraded;
5882 : :
5883 [ # # # # ]: 0 : if (start_readonly && mddev->ro == 0)
5884 : 0 : mddev->ro = 2; /* read-only, but switch on first write */
5885 : :
5886 : 0 : err = pers->run(mddev);
5887 [ # # ]: 0 : if (err)
5888 : 0 : pr_warn("md: pers->run() failed ...\n");
5889 [ # # ]: 0 : else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
5890 [ # # # # ]: 0 : WARN_ONCE(!mddev->external_size,
5891 : : "%s: default size too small, but 'external_size' not in effect?\n",
5892 : : __func__);
5893 : 0 : pr_warn("md: invalid array_size %llu > default size %llu\n",
5894 : : (unsigned long long)mddev->array_sectors / 2,
5895 : : (unsigned long long)pers->size(mddev, 0, 0) / 2);
5896 : 0 : err = -EINVAL;
5897 : : }
5898 [ # # # # ]: 0 : if (err == 0 && pers->sync_request &&
5899 [ # # # # ]: 0 : (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
5900 : 0 : struct bitmap *bitmap;
5901 : :
5902 : 0 : bitmap = md_bitmap_create(mddev, -1);
5903 [ # # ]: 0 : if (IS_ERR(bitmap)) {
5904 [ # # ]: 0 : err = PTR_ERR(bitmap);
5905 [ # # ]: 0 : pr_warn("%s: failed to create bitmap (%d)\n",
5906 : : mdname(mddev), err);
5907 : : } else
5908 : 0 : mddev->bitmap = bitmap;
5909 : :
5910 : : }
5911 [ # # ]: 0 : if (err)
5912 : 0 : goto bitmap_abort;
5913 : :
5914 [ # # ]: 0 : if (mddev->bitmap_info.max_write_behind > 0) {
5915 : 0 : bool create_pool = false;
5916 : :
5917 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
5918 [ # # # # ]: 0 : if (test_bit(WriteMostly, &rdev->flags) &&
5919 : 0 : rdev_init_serial(rdev))
5920 : 0 : create_pool = true;
5921 : : }
5922 [ # # # # ]: 0 : if (create_pool && mddev->serial_info_pool == NULL) {
5923 : 0 : mddev->serial_info_pool =
5924 : : mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
5925 : : sizeof(struct serial_info));
5926 [ # # ]: 0 : if (!mddev->serial_info_pool) {
5927 : 0 : err = -ENOMEM;
5928 : 0 : goto bitmap_abort;
5929 : : }
5930 : : }
5931 : : }
5932 : :
5933 [ # # ]: 0 : if (mddev->queue) {
5934 : 0 : bool nonrot = true;
5935 : :
5936 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
5937 [ # # # # ]: 0 : if (rdev->raid_disk >= 0 &&
5938 : 0 : !blk_queue_nonrot(bdev_get_queue(rdev->bdev))) {
5939 : : nonrot = false;
5940 : : break;
5941 : : }
5942 : : }
5943 [ # # ]: 0 : if (mddev->degraded)
5944 : : nonrot = false;
5945 [ # # ]: 0 : if (nonrot)
5946 : 0 : blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
5947 : : else
5948 : 0 : blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
5949 : 0 : mddev->queue->backing_dev_info->congested_data = mddev;
5950 : 0 : mddev->queue->backing_dev_info->congested_fn = md_congested;
5951 : : }
5952 [ # # ]: 0 : if (pers->sync_request) {
5953 [ # # # # ]: 0 : if (mddev->kobj.sd &&
5954 : 0 : sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5955 [ # # ]: 0 : pr_warn("md: cannot register extra attributes for %s\n",
5956 : : mdname(mddev));
5957 [ # # ]: 0 : mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5958 [ # # ]: 0 : } else if (mddev->ro == 2) /* auto-readonly not meaningful */
5959 : 0 : mddev->ro = 0;
5960 : :
5961 : 0 : atomic_set(&mddev->max_corr_read_errors,
5962 : : MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
5963 : 0 : mddev->safemode = 0;
5964 [ # # ]: 0 : if (mddev_is_clustered(mddev))
5965 : 0 : mddev->safemode_delay = 0;
5966 : : else
5967 : 0 : mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
5968 : 0 : mddev->in_sync = 1;
5969 : 0 : smp_wmb();
5970 : 0 : spin_lock(&mddev->lock);
5971 : 0 : mddev->pers = pers;
5972 : 0 : spin_unlock(&mddev->lock);
5973 [ # # ]: 0 : rdev_for_each(rdev, mddev)
5974 [ # # ]: 0 : if (rdev->raid_disk >= 0)
5975 : 0 : sysfs_link_rdev(mddev, rdev); /* failure here is OK */
5976 : :
5977 [ # # # # ]: 0 : if (mddev->degraded && !mddev->ro)
5978 : : /* This ensures that recovering status is reported immediately
5979 : : * via sysfs - until a lack of spares is confirmed.
5980 : : */
5981 : 0 : set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5982 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5983 : :
5984 [ # # ]: 0 : if (mddev->sb_flags)
5985 : 0 : md_update_sb(mddev, 0);
5986 : :
5987 : 0 : md_new_event(mddev);
5988 : 0 : return 0;
5989 : :
5990 : 0 : bitmap_abort:
5991 : 0 : mddev_detach(mddev);
5992 [ # # ]: 0 : if (mddev->private)
5993 : 0 : pers->free(mddev, mddev->private);
5994 : 0 : mddev->private = NULL;
5995 : 0 : module_put(pers->owner);
5996 : 0 : md_bitmap_destroy(mddev);
5997 : 0 : abort:
5998 : 0 : bioset_exit(&mddev->bio_set);
5999 : 0 : bioset_exit(&mddev->sync_set);
6000 : 0 : return err;
6001 : : }
6002 : : EXPORT_SYMBOL_GPL(md_run);
6003 : :
6004 : 0 : static int do_md_run(struct mddev *mddev)
6005 : : {
6006 : 0 : int err;
6007 : :
6008 : 0 : set_bit(MD_NOT_READY, &mddev->flags);
6009 : 0 : err = md_run(mddev);
6010 [ # # ]: 0 : if (err)
6011 : 0 : goto out;
6012 : 0 : err = md_bitmap_load(mddev);
6013 [ # # ]: 0 : if (err) {
6014 : 0 : md_bitmap_destroy(mddev);
6015 : 0 : goto out;
6016 : : }
6017 : :
6018 [ # # ]: 0 : if (mddev_is_clustered(mddev))
6019 : 0 : md_allow_write(mddev);
6020 : :
6021 : : /* run start up tasks that require md_thread */
6022 : 0 : md_start(mddev);
6023 : :
6024 : 0 : md_wakeup_thread(mddev->thread);
6025 : 0 : md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
6026 : :
6027 : 0 : set_capacity(mddev->gendisk, mddev->array_sectors);
6028 : 0 : revalidate_disk(mddev->gendisk);
6029 : 0 : clear_bit(MD_NOT_READY, &mddev->flags);
6030 : 0 : mddev->changed = 1;
6031 : 0 : kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
6032 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
6033 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_action);
6034 : 0 : sysfs_notify(&mddev->kobj, NULL, "degraded");
6035 : 0 : out:
6036 : 0 : clear_bit(MD_NOT_READY, &mddev->flags);
6037 : 0 : return err;
6038 : : }
6039 : :
6040 : 0 : int md_start(struct mddev *mddev)
6041 : : {
6042 : 0 : int ret = 0;
6043 : :
6044 [ # # ]: 0 : if (mddev->pers->start) {
6045 : 0 : set_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6046 : 0 : md_wakeup_thread(mddev->thread);
6047 : 0 : ret = mddev->pers->start(mddev);
6048 : 0 : clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6049 : 0 : md_wakeup_thread(mddev->sync_thread);
6050 : : }
6051 : 0 : return ret;
6052 : : }
6053 : : EXPORT_SYMBOL_GPL(md_start);
6054 : :
6055 : 0 : static int restart_array(struct mddev *mddev)
6056 : : {
6057 : 0 : struct gendisk *disk = mddev->gendisk;
6058 : 0 : struct md_rdev *rdev;
6059 : 0 : bool has_journal = false;
6060 : 0 : bool has_readonly = false;
6061 : :
6062 : : /* Complain if it has no devices */
6063 [ # # ]: 0 : if (list_empty(&mddev->disks))
6064 : : return -ENXIO;
6065 [ # # ]: 0 : if (!mddev->pers)
6066 : : return -EINVAL;
6067 [ # # ]: 0 : if (!mddev->ro)
6068 : : return -EBUSY;
6069 : :
6070 : 0 : rcu_read_lock();
6071 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev) {
6072 [ # # # # ]: 0 : if (test_bit(Journal, &rdev->flags) &&
6073 : : !test_bit(Faulty, &rdev->flags))
6074 : 0 : has_journal = true;
6075 [ # # ]: 0 : if (bdev_read_only(rdev->bdev))
6076 : 0 : has_readonly = true;
6077 : : }
6078 : 0 : rcu_read_unlock();
6079 [ # # # # ]: 0 : if (test_bit(MD_HAS_JOURNAL, &mddev->flags) && !has_journal)
6080 : : /* Don't restart rw with journal missing/faulty */
6081 : : return -EINVAL;
6082 [ # # ]: 0 : if (has_readonly)
6083 : : return -EROFS;
6084 : :
6085 : 0 : mddev->safemode = 0;
6086 : 0 : mddev->ro = 0;
6087 : 0 : set_disk_ro(disk, 0);
6088 : 0 : pr_debug("md: %s switched to read-write mode.\n", mdname(mddev));
6089 : : /* Kick recovery or resync if necessary */
6090 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6091 : 0 : md_wakeup_thread(mddev->thread);
6092 : 0 : md_wakeup_thread(mddev->sync_thread);
6093 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
6094 : : return 0;
6095 : : }
6096 : :
6097 : 0 : static void md_clean(struct mddev *mddev)
6098 : : {
6099 : 0 : mddev->array_sectors = 0;
6100 : 0 : mddev->external_size = 0;
6101 : 0 : mddev->dev_sectors = 0;
6102 : 0 : mddev->raid_disks = 0;
6103 : 0 : mddev->recovery_cp = 0;
6104 : 0 : mddev->resync_min = 0;
6105 : 0 : mddev->resync_max = MaxSector;
6106 : 0 : mddev->reshape_position = MaxSector;
6107 : 0 : mddev->external = 0;
6108 : 0 : mddev->persistent = 0;
6109 : 0 : mddev->level = LEVEL_NONE;
6110 : 0 : mddev->clevel[0] = 0;
6111 : 0 : mddev->flags = 0;
6112 : 0 : mddev->sb_flags = 0;
6113 : 0 : mddev->ro = 0;
6114 : 0 : mddev->metadata_type[0] = 0;
6115 : 0 : mddev->chunk_sectors = 0;
6116 : 0 : mddev->ctime = mddev->utime = 0;
6117 : 0 : mddev->layout = 0;
6118 : 0 : mddev->max_disks = 0;
6119 : 0 : mddev->events = 0;
6120 : 0 : mddev->can_decrease_events = 0;
6121 : 0 : mddev->delta_disks = 0;
6122 : 0 : mddev->reshape_backwards = 0;
6123 : 0 : mddev->new_level = LEVEL_NONE;
6124 : 0 : mddev->new_layout = 0;
6125 : 0 : mddev->new_chunk_sectors = 0;
6126 : 0 : mddev->curr_resync = 0;
6127 : 0 : atomic64_set(&mddev->resync_mismatches, 0);
6128 : 0 : mddev->suspend_lo = mddev->suspend_hi = 0;
6129 : 0 : mddev->sync_speed_min = mddev->sync_speed_max = 0;
6130 : 0 : mddev->recovery = 0;
6131 : 0 : mddev->in_sync = 0;
6132 : 0 : mddev->changed = 0;
6133 : 0 : mddev->degraded = 0;
6134 : 0 : mddev->safemode = 0;
6135 : 0 : mddev->private = NULL;
6136 : 0 : mddev->cluster_info = NULL;
6137 : 0 : mddev->bitmap_info.offset = 0;
6138 : 0 : mddev->bitmap_info.default_offset = 0;
6139 : 0 : mddev->bitmap_info.default_space = 0;
6140 : 0 : mddev->bitmap_info.chunksize = 0;
6141 : 0 : mddev->bitmap_info.daemon_sleep = 0;
6142 : 0 : mddev->bitmap_info.max_write_behind = 0;
6143 : 0 : mddev->bitmap_info.nodes = 0;
6144 : 0 : }
6145 : :
6146 : 0 : static void __md_stop_writes(struct mddev *mddev)
6147 : : {
6148 : 0 : set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6149 : 0 : flush_workqueue(md_misc_wq);
6150 [ # # ]: 0 : if (mddev->sync_thread) {
6151 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6152 : 0 : md_reap_sync_thread(mddev);
6153 : : }
6154 : :
6155 : 0 : del_timer_sync(&mddev->safemode_timer);
6156 : :
6157 [ # # # # ]: 0 : if (mddev->pers && mddev->pers->quiesce) {
6158 : 0 : mddev->pers->quiesce(mddev, 1);
6159 : 0 : mddev->pers->quiesce(mddev, 0);
6160 : : }
6161 : 0 : md_bitmap_flush(mddev);
6162 : :
6163 [ # # ]: 0 : if (mddev->ro == 0 &&
6164 [ # # # # ]: 0 : ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
6165 [ # # ]: 0 : mddev->sb_flags)) {
6166 : : /* mark array as shutdown cleanly */
6167 [ # # ]: 0 : if (!mddev_is_clustered(mddev))
6168 : 0 : mddev->in_sync = 1;
6169 : 0 : md_update_sb(mddev, 1);
6170 : : }
6171 : : /* disable policy to guarantee rdevs free resources for serialization */
6172 : 0 : mddev->serialize_policy = 0;
6173 : 0 : mddev_destroy_serial_pool(mddev, NULL, true);
6174 : 0 : }
6175 : :
6176 : 0 : void md_stop_writes(struct mddev *mddev)
6177 : : {
6178 : 0 : mddev_lock_nointr(mddev);
6179 : 0 : __md_stop_writes(mddev);
6180 : 0 : mddev_unlock(mddev);
6181 : 0 : }
6182 : : EXPORT_SYMBOL_GPL(md_stop_writes);
6183 : :
6184 : 0 : static void mddev_detach(struct mddev *mddev)
6185 : : {
6186 : 0 : md_bitmap_wait_behind_writes(mddev);
6187 [ # # # # ]: 0 : if (mddev->pers && mddev->pers->quiesce) {
6188 : 0 : mddev->pers->quiesce(mddev, 1);
6189 : 0 : mddev->pers->quiesce(mddev, 0);
6190 : : }
6191 : 0 : md_unregister_thread(&mddev->thread);
6192 [ # # ]: 0 : if (mddev->queue)
6193 : 0 : blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
6194 : 0 : }
6195 : :
6196 : 0 : static void __md_stop(struct mddev *mddev)
6197 : : {
6198 : 0 : struct md_personality *pers = mddev->pers;
6199 : 0 : md_bitmap_destroy(mddev);
6200 : 0 : mddev_detach(mddev);
6201 : : /* Ensure ->event_work is done */
6202 : 0 : flush_workqueue(md_misc_wq);
6203 : 0 : spin_lock(&mddev->lock);
6204 : 0 : mddev->pers = NULL;
6205 : 0 : spin_unlock(&mddev->lock);
6206 : 0 : pers->free(mddev, mddev->private);
6207 : 0 : mddev->private = NULL;
6208 [ # # # # ]: 0 : if (pers->sync_request && mddev->to_remove == NULL)
6209 : 0 : mddev->to_remove = &md_redundancy_group;
6210 : 0 : module_put(pers->owner);
6211 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6212 : 0 : }
6213 : :
6214 : 0 : void md_stop(struct mddev *mddev)
6215 : : {
6216 : : /* stop the array and free an attached data structures.
6217 : : * This is called from dm-raid
6218 : : */
6219 : 0 : __md_stop(mddev);
6220 : 0 : bioset_exit(&mddev->bio_set);
6221 : 0 : bioset_exit(&mddev->sync_set);
6222 : 0 : }
6223 : :
6224 : : EXPORT_SYMBOL_GPL(md_stop);
6225 : :
6226 : 0 : static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
6227 : : {
6228 : 0 : int err = 0;
6229 : 0 : int did_freeze = 0;
6230 : :
6231 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6232 : 0 : did_freeze = 1;
6233 : 0 : set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6234 : 0 : md_wakeup_thread(mddev->thread);
6235 : : }
6236 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6237 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6238 [ # # ]: 0 : if (mddev->sync_thread)
6239 : : /* Thread might be blocked waiting for metadata update
6240 : : * which will now never happen */
6241 : 0 : wake_up_process(mddev->sync_thread->tsk);
6242 : :
6243 [ # # # # ]: 0 : if (mddev->external && test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
6244 : : return -EBUSY;
6245 : 0 : mddev_unlock(mddev);
6246 [ # # # # ]: 0 : wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
6247 : : &mddev->recovery));
6248 [ # # # # ]: 0 : wait_event(mddev->sb_wait,
6249 : : !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
6250 : 0 : mddev_lock_nointr(mddev);
6251 : :
6252 : 0 : mutex_lock(&mddev->open_mutex);
6253 [ # # # # ]: 0 : if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
6254 [ # # # # ]: 0 : mddev->sync_thread ||
6255 : : test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6256 [ # # ]: 0 : pr_warn("md: %s still in use.\n",mdname(mddev));
6257 [ # # ]: 0 : if (did_freeze) {
6258 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6259 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6260 : 0 : md_wakeup_thread(mddev->thread);
6261 : : }
6262 : 0 : err = -EBUSY;
6263 : 0 : goto out;
6264 : : }
6265 [ # # ]: 0 : if (mddev->pers) {
6266 : 0 : __md_stop_writes(mddev);
6267 : :
6268 : 0 : err = -ENXIO;
6269 [ # # ]: 0 : if (mddev->ro==1)
6270 : 0 : goto out;
6271 : 0 : mddev->ro = 1;
6272 : 0 : set_disk_ro(mddev->gendisk, 1);
6273 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6274 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6275 : 0 : md_wakeup_thread(mddev->thread);
6276 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
6277 : : err = 0;
6278 : : }
6279 : 0 : out:
6280 : 0 : mutex_unlock(&mddev->open_mutex);
6281 : 0 : return err;
6282 : : }
6283 : :
6284 : : /* mode:
6285 : : * 0 - completely stop and dis-assemble array
6286 : : * 2 - stop but do not disassemble array
6287 : : */
6288 : 0 : static int do_md_stop(struct mddev *mddev, int mode,
6289 : : struct block_device *bdev)
6290 : : {
6291 : 0 : struct gendisk *disk = mddev->gendisk;
6292 : 0 : struct md_rdev *rdev;
6293 : 0 : int did_freeze = 0;
6294 : :
6295 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6296 : 0 : did_freeze = 1;
6297 : 0 : set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6298 : 0 : md_wakeup_thread(mddev->thread);
6299 : : }
6300 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6301 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6302 [ # # ]: 0 : if (mddev->sync_thread)
6303 : : /* Thread might be blocked waiting for metadata update
6304 : : * which will now never happen */
6305 : 0 : wake_up_process(mddev->sync_thread->tsk);
6306 : :
6307 : 0 : mddev_unlock(mddev);
6308 [ # # # # : 0 : wait_event(resync_wait, (mddev->sync_thread == NULL &&
# # # # ]
6309 : : !test_bit(MD_RECOVERY_RUNNING,
6310 : : &mddev->recovery)));
6311 : 0 : mddev_lock_nointr(mddev);
6312 : :
6313 : 0 : mutex_lock(&mddev->open_mutex);
6314 [ # # # # ]: 0 : if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
6315 [ # # ]: 0 : mddev->sysfs_active ||
6316 [ # # # # ]: 0 : mddev->sync_thread ||
6317 : : test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6318 [ # # ]: 0 : pr_warn("md: %s still in use.\n",mdname(mddev));
6319 : 0 : mutex_unlock(&mddev->open_mutex);
6320 [ # # ]: 0 : if (did_freeze) {
6321 : 0 : clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6322 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6323 : 0 : md_wakeup_thread(mddev->thread);
6324 : : }
6325 : 0 : return -EBUSY;
6326 : : }
6327 [ # # ]: 0 : if (mddev->pers) {
6328 [ # # ]: 0 : if (mddev->ro)
6329 : 0 : set_disk_ro(disk, 0);
6330 : :
6331 : 0 : __md_stop_writes(mddev);
6332 : 0 : __md_stop(mddev);
6333 : 0 : mddev->queue->backing_dev_info->congested_fn = NULL;
6334 : :
6335 : : /* tell userspace to handle 'inactive' */
6336 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
6337 : :
6338 [ # # ]: 0 : rdev_for_each(rdev, mddev)
6339 [ # # ]: 0 : if (rdev->raid_disk >= 0)
6340 : 0 : sysfs_unlink_rdev(mddev, rdev);
6341 : :
6342 : 0 : set_capacity(disk, 0);
6343 : 0 : mutex_unlock(&mddev->open_mutex);
6344 : 0 : mddev->changed = 1;
6345 : 0 : revalidate_disk(disk);
6346 : :
6347 [ # # ]: 0 : if (mddev->ro)
6348 : 0 : mddev->ro = 0;
6349 : : } else
6350 : 0 : mutex_unlock(&mddev->open_mutex);
6351 : : /*
6352 : : * Free resources if final stop
6353 : : */
6354 [ # # ]: 0 : if (mode == 0) {
6355 [ # # ]: 0 : pr_info("md: %s stopped.\n", mdname(mddev));
6356 : :
6357 [ # # ]: 0 : if (mddev->bitmap_info.file) {
6358 : 0 : struct file *f = mddev->bitmap_info.file;
6359 : 0 : spin_lock(&mddev->lock);
6360 : 0 : mddev->bitmap_info.file = NULL;
6361 : 0 : spin_unlock(&mddev->lock);
6362 : 0 : fput(f);
6363 : : }
6364 : 0 : mddev->bitmap_info.offset = 0;
6365 : :
6366 : 0 : export_array(mddev);
6367 : :
6368 : 0 : md_clean(mddev);
6369 [ # # ]: 0 : if (mddev->hold_active == UNTIL_STOP)
6370 : 0 : mddev->hold_active = 0;
6371 : : }
6372 : 0 : md_new_event(mddev);
6373 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
6374 : : return 0;
6375 : : }
6376 : :
6377 : : #ifndef MODULE
6378 : 0 : static void autorun_array(struct mddev *mddev)
6379 : : {
6380 : 0 : struct md_rdev *rdev;
6381 : 0 : int err;
6382 : :
6383 [ # # ]: 0 : if (list_empty(&mddev->disks))
6384 : : return;
6385 : :
6386 : 0 : pr_info("md: running: ");
6387 : :
6388 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
6389 : 0 : char b[BDEVNAME_SIZE];
6390 : 0 : pr_cont("<%s>", bdevname(rdev->bdev,b));
6391 : : }
6392 : 0 : pr_cont("\n");
6393 : :
6394 : 0 : err = do_md_run(mddev);
6395 [ # # ]: 0 : if (err) {
6396 : 0 : pr_warn("md: do_md_run() returned %d\n", err);
6397 : 0 : do_md_stop(mddev, 0, NULL);
6398 : : }
6399 : : }
6400 : :
6401 : : /*
6402 : : * lets try to run arrays based on all disks that have arrived
6403 : : * until now. (those are in pending_raid_disks)
6404 : : *
6405 : : * the method: pick the first pending disk, collect all disks with
6406 : : * the same UUID, remove all from the pending list and put them into
6407 : : * the 'same_array' list. Then order this list based on superblock
6408 : : * update time (freshest comes first), kick out 'old' disks and
6409 : : * compare superblocks. If everything's fine then run it.
6410 : : *
6411 : : * If "unit" is allocated, then bump its reference count
6412 : : */
6413 : 13 : static void autorun_devices(int part)
6414 : : {
6415 : 13 : struct md_rdev *rdev0, *rdev, *tmp;
6416 : 13 : struct mddev *mddev;
6417 : 13 : char b[BDEVNAME_SIZE];
6418 : :
6419 : 13 : pr_info("md: autorun ...\n");
6420 [ - + ]: 13 : while (!list_empty(&pending_raid_disks)) {
6421 : 0 : int unit;
6422 : 0 : dev_t dev;
6423 : 0 : LIST_HEAD(candidates);
6424 : 0 : rdev0 = list_entry(pending_raid_disks.next,
6425 : : struct md_rdev, same_set);
6426 : :
6427 : 0 : pr_debug("md: considering %s ...\n", bdevname(rdev0->bdev,b));
6428 : 0 : INIT_LIST_HEAD(&candidates);
6429 [ # # ]: 0 : rdev_for_each_list(rdev, tmp, &pending_raid_disks)
6430 [ # # ]: 0 : if (super_90_load(rdev, rdev0, 0) >= 0) {
6431 : 0 : pr_debug("md: adding %s ...\n",
6432 : : bdevname(rdev->bdev,b));
6433 : 0 : list_move(&rdev->same_set, &candidates);
6434 : : }
6435 : : /*
6436 : : * now we have a set of devices, with all of them having
6437 : : * mostly sane superblocks. It's time to allocate the
6438 : : * mddev.
6439 : : */
6440 [ # # ]: 0 : if (part) {
6441 : 0 : dev = MKDEV(mdp_major,
6442 : : rdev0->preferred_minor << MdpMinorShift);
6443 : 0 : unit = MINOR(dev) >> MdpMinorShift;
6444 : : } else {
6445 : 0 : dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
6446 : 0 : unit = MINOR(dev);
6447 : : }
6448 [ # # ]: 0 : if (rdev0->preferred_minor != unit) {
6449 : 0 : pr_warn("md: unit number in %s is bad: %d\n",
6450 : : bdevname(rdev0->bdev, b), rdev0->preferred_minor);
6451 : 0 : break;
6452 : : }
6453 : :
6454 [ # # ]: 0 : md_probe(dev, NULL, NULL);
6455 : 0 : mddev = mddev_find(dev);
6456 [ # # # # ]: 0 : if (!mddev || !mddev->gendisk) {
6457 [ # # ]: 0 : if (mddev)
6458 : 0 : mddev_put(mddev);
6459 : : break;
6460 : : }
6461 [ # # ]: 0 : if (mddev_lock(mddev))
6462 [ # # ]: 0 : pr_warn("md: %s locked, cannot run\n", mdname(mddev));
6463 [ # # # # ]: 0 : else if (mddev->raid_disks || mddev->major_version
6464 [ # # ]: 0 : || !list_empty(&mddev->disks)) {
6465 [ # # ]: 0 : pr_warn("md: %s already running, cannot run %s\n",
6466 : : mdname(mddev), bdevname(rdev0->bdev,b));
6467 : 0 : mddev_unlock(mddev);
6468 : : } else {
6469 : 0 : pr_debug("md: created %s\n", mdname(mddev));
6470 : 0 : mddev->persistent = 1;
6471 [ # # ]: 0 : rdev_for_each_list(rdev, tmp, &candidates) {
6472 : 0 : list_del_init(&rdev->same_set);
6473 [ # # ]: 0 : if (bind_rdev_to_array(rdev, mddev))
6474 : 0 : export_rdev(rdev);
6475 : : }
6476 : 0 : autorun_array(mddev);
6477 : 0 : mddev_unlock(mddev);
6478 : : }
6479 : : /* on success, candidates will be empty, on error
6480 : : * it won't...
6481 : : */
6482 [ # # ]: 0 : rdev_for_each_list(rdev, tmp, &candidates) {
6483 : 0 : list_del_init(&rdev->same_set);
6484 : 0 : export_rdev(rdev);
6485 : : }
6486 : 0 : mddev_put(mddev);
6487 : : }
6488 : 13 : pr_info("md: ... autorun DONE.\n");
6489 : 13 : }
6490 : : #endif /* !MODULE */
6491 : :
6492 : 0 : static int get_version(void __user *arg)
6493 : : {
6494 : 0 : mdu_version_t ver;
6495 : :
6496 : 0 : ver.major = MD_MAJOR_VERSION;
6497 : 0 : ver.minor = MD_MINOR_VERSION;
6498 : 0 : ver.patchlevel = MD_PATCHLEVEL_VERSION;
6499 : :
6500 [ # # ]: 0 : if (copy_to_user(arg, &ver, sizeof(ver)))
6501 : 0 : return -EFAULT;
6502 : :
6503 : : return 0;
6504 : : }
6505 : :
6506 : 0 : static int get_array_info(struct mddev *mddev, void __user *arg)
6507 : : {
6508 : 0 : mdu_array_info_t info;
6509 : 0 : int nr,working,insync,failed,spare;
6510 : 0 : struct md_rdev *rdev;
6511 : :
6512 : 0 : nr = working = insync = failed = spare = 0;
6513 : 0 : rcu_read_lock();
6514 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev) {
6515 : 0 : nr++;
6516 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
6517 : 0 : failed++;
6518 : : else {
6519 : 0 : working++;
6520 [ # # ]: 0 : if (test_bit(In_sync, &rdev->flags))
6521 : 0 : insync++;
6522 [ # # ]: 0 : else if (test_bit(Journal, &rdev->flags))
6523 : : /* TODO: add journal count to md_u.h */
6524 : : ;
6525 : : else
6526 : 0 : spare++;
6527 : : }
6528 : : }
6529 : 0 : rcu_read_unlock();
6530 : :
6531 : 0 : info.major_version = mddev->major_version;
6532 : 0 : info.minor_version = mddev->minor_version;
6533 : 0 : info.patch_version = MD_PATCHLEVEL_VERSION;
6534 : 0 : info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
6535 : 0 : info.level = mddev->level;
6536 : 0 : info.size = mddev->dev_sectors / 2;
6537 [ # # ]: 0 : if (info.size != mddev->dev_sectors / 2) /* overflow */
6538 : 0 : info.size = -1;
6539 : 0 : info.nr_disks = nr;
6540 : 0 : info.raid_disks = mddev->raid_disks;
6541 : 0 : info.md_minor = mddev->md_minor;
6542 : 0 : info.not_persistent= !mddev->persistent;
6543 : :
6544 : 0 : info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
6545 : 0 : info.state = 0;
6546 [ # # ]: 0 : if (mddev->in_sync)
6547 : 0 : info.state = (1<<MD_SB_CLEAN);
6548 [ # # # # ]: 0 : if (mddev->bitmap && mddev->bitmap_info.offset)
6549 : 0 : info.state |= (1<<MD_SB_BITMAP_PRESENT);
6550 [ # # ]: 0 : if (mddev_is_clustered(mddev))
6551 : 0 : info.state |= (1<<MD_SB_CLUSTERED);
6552 : 0 : info.active_disks = insync;
6553 : 0 : info.working_disks = working;
6554 : 0 : info.failed_disks = failed;
6555 : 0 : info.spare_disks = spare;
6556 : :
6557 : 0 : info.layout = mddev->layout;
6558 : 0 : info.chunk_size = mddev->chunk_sectors << 9;
6559 : :
6560 [ # # ]: 0 : if (copy_to_user(arg, &info, sizeof(info)))
6561 : 0 : return -EFAULT;
6562 : :
6563 : : return 0;
6564 : : }
6565 : :
6566 : 0 : static int get_bitmap_file(struct mddev *mddev, void __user * arg)
6567 : : {
6568 : 0 : mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
6569 : 0 : char *ptr;
6570 : 0 : int err;
6571 : :
6572 : 0 : file = kzalloc(sizeof(*file), GFP_NOIO);
6573 [ # # ]: 0 : if (!file)
6574 : : return -ENOMEM;
6575 : :
6576 : 0 : err = 0;
6577 : 0 : spin_lock(&mddev->lock);
6578 : : /* bitmap enabled */
6579 [ # # ]: 0 : if (mddev->bitmap_info.file) {
6580 : 0 : ptr = file_path(mddev->bitmap_info.file, file->pathname,
6581 : : sizeof(file->pathname));
6582 [ # # ]: 0 : if (IS_ERR(ptr))
6583 : 0 : err = PTR_ERR(ptr);
6584 : : else
6585 : 0 : memmove(file->pathname, ptr,
6586 : 0 : sizeof(file->pathname)-(ptr-file->pathname));
6587 : : }
6588 : 0 : spin_unlock(&mddev->lock);
6589 : :
6590 [ # # # # ]: 0 : if (err == 0 &&
6591 : : copy_to_user(arg, file, sizeof(*file)))
6592 : : err = -EFAULT;
6593 : :
6594 : 0 : kfree(file);
6595 : 0 : return err;
6596 : : }
6597 : :
6598 : 0 : static int get_disk_info(struct mddev *mddev, void __user * arg)
6599 : : {
6600 : 0 : mdu_disk_info_t info;
6601 : 0 : struct md_rdev *rdev;
6602 : :
6603 [ # # ]: 0 : if (copy_from_user(&info, arg, sizeof(info)))
6604 : : return -EFAULT;
6605 : :
6606 : 0 : rcu_read_lock();
6607 : 0 : rdev = md_find_rdev_nr_rcu(mddev, info.number);
6608 [ # # ]: 0 : if (rdev) {
6609 : 0 : info.major = MAJOR(rdev->bdev->bd_dev);
6610 : 0 : info.minor = MINOR(rdev->bdev->bd_dev);
6611 : 0 : info.raid_disk = rdev->raid_disk;
6612 : 0 : info.state = 0;
6613 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
6614 : 0 : info.state |= (1<<MD_DISK_FAULTY);
6615 [ # # ]: 0 : else if (test_bit(In_sync, &rdev->flags)) {
6616 : 0 : info.state |= (1<<MD_DISK_ACTIVE);
6617 : 0 : info.state |= (1<<MD_DISK_SYNC);
6618 : : }
6619 [ # # ]: 0 : if (test_bit(Journal, &rdev->flags))
6620 : 0 : info.state |= (1<<MD_DISK_JOURNAL);
6621 [ # # ]: 0 : if (test_bit(WriteMostly, &rdev->flags))
6622 : 0 : info.state |= (1<<MD_DISK_WRITEMOSTLY);
6623 [ # # ]: 0 : if (test_bit(FailFast, &rdev->flags))
6624 : 0 : info.state |= (1<<MD_DISK_FAILFAST);
6625 : : } else {
6626 : 0 : info.major = info.minor = 0;
6627 : 0 : info.raid_disk = -1;
6628 : 0 : info.state = (1<<MD_DISK_REMOVED);
6629 : : }
6630 : 0 : rcu_read_unlock();
6631 : :
6632 [ # # ]: 0 : if (copy_to_user(arg, &info, sizeof(info)))
6633 : 0 : return -EFAULT;
6634 : :
6635 : : return 0;
6636 : : }
6637 : :
6638 : 0 : static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
6639 : : {
6640 : 0 : char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
6641 : 0 : struct md_rdev *rdev;
6642 : 0 : dev_t dev = MKDEV(info->major,info->minor);
6643 : :
6644 [ # # ]: 0 : if (mddev_is_clustered(mddev) &&
6645 [ # # ]: 0 : !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
6646 [ # # ]: 0 : pr_warn("%s: Cannot add to clustered mddev.\n",
6647 : : mdname(mddev));
6648 : 0 : return -EINVAL;
6649 : : }
6650 : :
6651 [ # # # # ]: 0 : if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
6652 : : return -EOVERFLOW;
6653 : :
6654 [ # # ]: 0 : if (!mddev->raid_disks) {
6655 : 0 : int err;
6656 : : /* expecting a device which has a superblock */
6657 : 0 : rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
6658 [ # # ]: 0 : if (IS_ERR(rdev)) {
6659 : 0 : pr_warn("md: md_import_device returned %ld\n",
6660 : : PTR_ERR(rdev));
6661 : 0 : return PTR_ERR(rdev);
6662 : : }
6663 [ # # ]: 0 : if (!list_empty(&mddev->disks)) {
6664 : 0 : struct md_rdev *rdev0
6665 : 0 : = list_entry(mddev->disks.next,
6666 : : struct md_rdev, same_set);
6667 : 0 : err = super_types[mddev->major_version]
6668 : 0 : .load_super(rdev, rdev0, mddev->minor_version);
6669 [ # # ]: 0 : if (err < 0) {
6670 : 0 : pr_warn("md: %s has different UUID to %s\n",
6671 : : bdevname(rdev->bdev,b),
6672 : : bdevname(rdev0->bdev,b2));
6673 : 0 : export_rdev(rdev);
6674 : 0 : return -EINVAL;
6675 : : }
6676 : : }
6677 : 0 : err = bind_rdev_to_array(rdev, mddev);
6678 [ # # ]: 0 : if (err)
6679 : 0 : export_rdev(rdev);
6680 : 0 : return err;
6681 : : }
6682 : :
6683 : : /*
6684 : : * add_new_disk can be used once the array is assembled
6685 : : * to add "hot spares". They must already have a superblock
6686 : : * written
6687 : : */
6688 [ # # ]: 0 : if (mddev->pers) {
6689 : 0 : int err;
6690 [ # # ]: 0 : if (!mddev->pers->hot_add_disk) {
6691 [ # # ]: 0 : pr_warn("%s: personality does not support diskops!\n",
6692 : : mdname(mddev));
6693 : 0 : return -EINVAL;
6694 : : }
6695 [ # # ]: 0 : if (mddev->persistent)
6696 : 0 : rdev = md_import_device(dev, mddev->major_version,
6697 : : mddev->minor_version);
6698 : : else
6699 : 0 : rdev = md_import_device(dev, -1, -1);
6700 [ # # ]: 0 : if (IS_ERR(rdev)) {
6701 : 0 : pr_warn("md: md_import_device returned %ld\n",
6702 : : PTR_ERR(rdev));
6703 : 0 : return PTR_ERR(rdev);
6704 : : }
6705 : : /* set saved_raid_disk if appropriate */
6706 [ # # ]: 0 : if (!mddev->persistent) {
6707 [ # # ]: 0 : if (info->state & (1<<MD_DISK_SYNC) &&
6708 [ # # ]: 0 : info->raid_disk < mddev->raid_disks) {
6709 : 0 : rdev->raid_disk = info->raid_disk;
6710 : 0 : set_bit(In_sync, &rdev->flags);
6711 : 0 : clear_bit(Bitmap_sync, &rdev->flags);
6712 : : } else
6713 : 0 : rdev->raid_disk = -1;
6714 : 0 : rdev->saved_raid_disk = rdev->raid_disk;
6715 : : } else
6716 : 0 : super_types[mddev->major_version].
6717 : : validate_super(mddev, rdev);
6718 [ # # ]: 0 : if ((info->state & (1<<MD_DISK_SYNC)) &&
6719 [ # # ]: 0 : rdev->raid_disk != info->raid_disk) {
6720 : : /* This was a hot-add request, but events doesn't
6721 : : * match, so reject it.
6722 : : */
6723 : 0 : export_rdev(rdev);
6724 : 0 : return -EINVAL;
6725 : : }
6726 : :
6727 : 0 : clear_bit(In_sync, &rdev->flags); /* just to be sure */
6728 [ # # ]: 0 : if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6729 : 0 : set_bit(WriteMostly, &rdev->flags);
6730 : : else
6731 : 0 : clear_bit(WriteMostly, &rdev->flags);
6732 [ # # ]: 0 : if (info->state & (1<<MD_DISK_FAILFAST))
6733 : 0 : set_bit(FailFast, &rdev->flags);
6734 : : else
6735 : 0 : clear_bit(FailFast, &rdev->flags);
6736 : :
6737 [ # # ]: 0 : if (info->state & (1<<MD_DISK_JOURNAL)) {
6738 : 0 : struct md_rdev *rdev2;
6739 : 0 : bool has_journal = false;
6740 : :
6741 : : /* make sure no existing journal disk */
6742 [ # # ]: 0 : rdev_for_each(rdev2, mddev) {
6743 [ # # ]: 0 : if (test_bit(Journal, &rdev2->flags)) {
6744 : : has_journal = true;
6745 : : break;
6746 : : }
6747 : : }
6748 [ # # # # ]: 0 : if (has_journal || mddev->bitmap) {
6749 : 0 : export_rdev(rdev);
6750 : 0 : return -EBUSY;
6751 : : }
6752 : 0 : set_bit(Journal, &rdev->flags);
6753 : : }
6754 : : /*
6755 : : * check whether the device shows up in other nodes
6756 : : */
6757 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
6758 [ # # ]: 0 : if (info->state & (1 << MD_DISK_CANDIDATE))
6759 : 0 : set_bit(Candidate, &rdev->flags);
6760 [ # # ]: 0 : else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
6761 : : /* --add initiated by this node */
6762 : 0 : err = md_cluster_ops->add_new_disk(mddev, rdev);
6763 [ # # ]: 0 : if (err) {
6764 : 0 : export_rdev(rdev);
6765 : 0 : return err;
6766 : : }
6767 : : }
6768 : : }
6769 : :
6770 : 0 : rdev->raid_disk = -1;
6771 : 0 : err = bind_rdev_to_array(rdev, mddev);
6772 : :
6773 [ # # ]: 0 : if (err)
6774 : 0 : export_rdev(rdev);
6775 : :
6776 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
6777 [ # # ]: 0 : if (info->state & (1 << MD_DISK_CANDIDATE)) {
6778 [ # # ]: 0 : if (!err) {
6779 : 0 : err = md_cluster_ops->new_disk_ack(mddev,
6780 : : err == 0);
6781 [ # # ]: 0 : if (err)
6782 : 0 : md_kick_rdev_from_array(rdev);
6783 : : }
6784 : : } else {
6785 [ # # ]: 0 : if (err)
6786 : 0 : md_cluster_ops->add_new_disk_cancel(mddev);
6787 : : else
6788 : 0 : err = add_bound_rdev(rdev);
6789 : : }
6790 : :
6791 [ # # ]: 0 : } else if (!err)
6792 : 0 : err = add_bound_rdev(rdev);
6793 : :
6794 : 0 : return err;
6795 : : }
6796 : :
6797 : : /* otherwise, add_new_disk is only allowed
6798 : : * for major_version==0 superblocks
6799 : : */
6800 [ # # ]: 0 : if (mddev->major_version != 0) {
6801 [ # # ]: 0 : pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev));
6802 : 0 : return -EINVAL;
6803 : : }
6804 : :
6805 [ # # ]: 0 : if (!(info->state & (1<<MD_DISK_FAULTY))) {
6806 : 0 : int err;
6807 : 0 : rdev = md_import_device(dev, -1, 0);
6808 [ # # ]: 0 : if (IS_ERR(rdev)) {
6809 : 0 : pr_warn("md: error, md_import_device() returned %ld\n",
6810 : : PTR_ERR(rdev));
6811 : 0 : return PTR_ERR(rdev);
6812 : : }
6813 : 0 : rdev->desc_nr = info->number;
6814 [ # # ]: 0 : if (info->raid_disk < mddev->raid_disks)
6815 : 0 : rdev->raid_disk = info->raid_disk;
6816 : : else
6817 : 0 : rdev->raid_disk = -1;
6818 : :
6819 [ # # ]: 0 : if (rdev->raid_disk < mddev->raid_disks)
6820 [ # # ]: 0 : if (info->state & (1<<MD_DISK_SYNC))
6821 : 0 : set_bit(In_sync, &rdev->flags);
6822 : :
6823 [ # # ]: 0 : if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6824 : 0 : set_bit(WriteMostly, &rdev->flags);
6825 [ # # ]: 0 : if (info->state & (1<<MD_DISK_FAILFAST))
6826 : 0 : set_bit(FailFast, &rdev->flags);
6827 : :
6828 [ # # ]: 0 : if (!mddev->persistent) {
6829 : 0 : pr_debug("md: nonpersistent superblock ...\n");
6830 : 0 : rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6831 : : } else
6832 : 0 : rdev->sb_start = calc_dev_sboffset(rdev);
6833 : 0 : rdev->sectors = rdev->sb_start;
6834 : :
6835 : 0 : err = bind_rdev_to_array(rdev, mddev);
6836 [ # # ]: 0 : if (err) {
6837 : 0 : export_rdev(rdev);
6838 : 0 : return err;
6839 : : }
6840 : : }
6841 : :
6842 : : return 0;
6843 : : }
6844 : :
6845 : 0 : static int hot_remove_disk(struct mddev *mddev, dev_t dev)
6846 : : {
6847 : 0 : char b[BDEVNAME_SIZE];
6848 : 0 : struct md_rdev *rdev;
6849 : :
6850 [ # # ]: 0 : if (!mddev->pers)
6851 : : return -ENODEV;
6852 : :
6853 : 0 : rdev = find_rdev(mddev, dev);
6854 [ # # ]: 0 : if (!rdev)
6855 : : return -ENXIO;
6856 : :
6857 [ # # ]: 0 : if (rdev->raid_disk < 0)
6858 : 0 : goto kick_rdev;
6859 : :
6860 : 0 : clear_bit(Blocked, &rdev->flags);
6861 : 0 : remove_and_add_spares(mddev, rdev);
6862 : :
6863 [ # # ]: 0 : if (rdev->raid_disk >= 0)
6864 : 0 : goto busy;
6865 : :
6866 : 0 : kick_rdev:
6867 [ # # ]: 0 : if (mddev_is_clustered(mddev))
6868 : 0 : md_cluster_ops->remove_disk(mddev, rdev);
6869 : :
6870 : 0 : md_kick_rdev_from_array(rdev);
6871 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
6872 [ # # ]: 0 : if (mddev->thread)
6873 : 0 : md_wakeup_thread(mddev->thread);
6874 : : else
6875 : 0 : md_update_sb(mddev, 1);
6876 : 0 : md_new_event(mddev);
6877 : :
6878 : 0 : return 0;
6879 : : busy:
6880 : 0 : pr_debug("md: cannot remove active disk %s from %s ...\n",
6881 : : bdevname(rdev->bdev,b), mdname(mddev));
6882 : 0 : return -EBUSY;
6883 : : }
6884 : :
6885 : 0 : static int hot_add_disk(struct mddev *mddev, dev_t dev)
6886 : : {
6887 : 0 : char b[BDEVNAME_SIZE];
6888 : 0 : int err;
6889 : 0 : struct md_rdev *rdev;
6890 : :
6891 [ # # ]: 0 : if (!mddev->pers)
6892 : : return -ENODEV;
6893 : :
6894 [ # # ]: 0 : if (mddev->major_version != 0) {
6895 [ # # ]: 0 : pr_warn("%s: HOT_ADD may only be used with version-0 superblocks.\n",
6896 : : mdname(mddev));
6897 : 0 : return -EINVAL;
6898 : : }
6899 [ # # ]: 0 : if (!mddev->pers->hot_add_disk) {
6900 [ # # ]: 0 : pr_warn("%s: personality does not support diskops!\n",
6901 : : mdname(mddev));
6902 : 0 : return -EINVAL;
6903 : : }
6904 : :
6905 : 0 : rdev = md_import_device(dev, -1, 0);
6906 [ # # ]: 0 : if (IS_ERR(rdev)) {
6907 : 0 : pr_warn("md: error, md_import_device() returned %ld\n",
6908 : : PTR_ERR(rdev));
6909 : 0 : return -EINVAL;
6910 : : }
6911 : :
6912 [ # # ]: 0 : if (mddev->persistent)
6913 : 0 : rdev->sb_start = calc_dev_sboffset(rdev);
6914 : : else
6915 : 0 : rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6916 : :
6917 : 0 : rdev->sectors = rdev->sb_start;
6918 : :
6919 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags)) {
6920 [ # # ]: 0 : pr_warn("md: can not hot-add faulty %s disk to %s!\n",
6921 : : bdevname(rdev->bdev,b), mdname(mddev));
6922 : 0 : err = -EINVAL;
6923 : 0 : goto abort_export;
6924 : : }
6925 : :
6926 : 0 : clear_bit(In_sync, &rdev->flags);
6927 : 0 : rdev->desc_nr = -1;
6928 : 0 : rdev->saved_raid_disk = -1;
6929 : 0 : err = bind_rdev_to_array(rdev, mddev);
6930 [ # # ]: 0 : if (err)
6931 : 0 : goto abort_export;
6932 : :
6933 : : /*
6934 : : * The rest should better be atomic, we can have disk failures
6935 : : * noticed in interrupt contexts ...
6936 : : */
6937 : :
6938 : 0 : rdev->raid_disk = -1;
6939 : :
6940 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
6941 [ # # ]: 0 : if (!mddev->thread)
6942 : 0 : md_update_sb(mddev, 1);
6943 : : /*
6944 : : * Kick recovery, maybe this spare has to be added to the
6945 : : * array immediately.
6946 : : */
6947 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6948 : 0 : md_wakeup_thread(mddev->thread);
6949 : 0 : md_new_event(mddev);
6950 : 0 : return 0;
6951 : :
6952 : 0 : abort_export:
6953 : 0 : export_rdev(rdev);
6954 : 0 : return err;
6955 : : }
6956 : :
6957 : 0 : static int set_bitmap_file(struct mddev *mddev, int fd)
6958 : : {
6959 : 0 : int err = 0;
6960 : :
6961 [ # # ]: 0 : if (mddev->pers) {
6962 [ # # # # ]: 0 : if (!mddev->pers->quiesce || !mddev->thread)
6963 : : return -EBUSY;
6964 [ # # # # ]: 0 : if (mddev->recovery || mddev->sync_thread)
6965 : : return -EBUSY;
6966 : : /* we should be able to change the bitmap.. */
6967 : : }
6968 : :
6969 [ # # ]: 0 : if (fd >= 0) {
6970 : 0 : struct inode *inode;
6971 : 0 : struct file *f;
6972 : :
6973 [ # # # # ]: 0 : if (mddev->bitmap || mddev->bitmap_info.file)
6974 : : return -EEXIST; /* cannot add when bitmap is present */
6975 : 0 : f = fget(fd);
6976 : :
6977 [ # # ]: 0 : if (f == NULL) {
6978 [ # # ]: 0 : pr_warn("%s: error: failed to get bitmap file\n",
6979 : : mdname(mddev));
6980 : 0 : return -EBADF;
6981 : : }
6982 : :
6983 : 0 : inode = f->f_mapping->host;
6984 [ # # ]: 0 : if (!S_ISREG(inode->i_mode)) {
6985 [ # # ]: 0 : pr_warn("%s: error: bitmap file must be a regular file\n",
6986 : : mdname(mddev));
6987 : 0 : err = -EBADF;
6988 [ # # ]: 0 : } else if (!(f->f_mode & FMODE_WRITE)) {
6989 [ # # ]: 0 : pr_warn("%s: error: bitmap file must open for write\n",
6990 : : mdname(mddev));
6991 : 0 : err = -EBADF;
6992 [ # # ]: 0 : } else if (atomic_read(&inode->i_writecount) != 1) {
6993 [ # # ]: 0 : pr_warn("%s: error: bitmap file is already in use\n",
6994 : : mdname(mddev));
6995 : 0 : err = -EBUSY;
6996 : : }
6997 : 0 : if (err) {
6998 : 0 : fput(f);
6999 : 0 : return err;
7000 : : }
7001 : 0 : mddev->bitmap_info.file = f;
7002 : 0 : mddev->bitmap_info.offset = 0; /* file overrides offset */
7003 [ # # ]: 0 : } else if (mddev->bitmap == NULL)
7004 : : return -ENOENT; /* cannot remove what isn't there */
7005 : 0 : err = 0;
7006 [ # # ]: 0 : if (mddev->pers) {
7007 [ # # ]: 0 : if (fd >= 0) {
7008 : 0 : struct bitmap *bitmap;
7009 : :
7010 : 0 : bitmap = md_bitmap_create(mddev, -1);
7011 : 0 : mddev_suspend(mddev);
7012 [ # # ]: 0 : if (!IS_ERR(bitmap)) {
7013 : 0 : mddev->bitmap = bitmap;
7014 : 0 : err = md_bitmap_load(mddev);
7015 : : } else
7016 : 0 : err = PTR_ERR(bitmap);
7017 [ # # ]: 0 : if (err) {
7018 : 0 : md_bitmap_destroy(mddev);
7019 : 0 : fd = -1;
7020 : : }
7021 : 0 : mddev_resume(mddev);
7022 : 0 : } else if (fd < 0) {
7023 : 0 : mddev_suspend(mddev);
7024 : 0 : md_bitmap_destroy(mddev);
7025 : 0 : mddev_resume(mddev);
7026 : : }
7027 : : }
7028 [ # # ]: 0 : if (fd < 0) {
7029 : 0 : struct file *f = mddev->bitmap_info.file;
7030 [ # # ]: 0 : if (f) {
7031 : 0 : spin_lock(&mddev->lock);
7032 : 0 : mddev->bitmap_info.file = NULL;
7033 : 0 : spin_unlock(&mddev->lock);
7034 : 0 : fput(f);
7035 : : }
7036 : : }
7037 : :
7038 : : return err;
7039 : : }
7040 : :
7041 : : /*
7042 : : * set_array_info is used two different ways
7043 : : * The original usage is when creating a new array.
7044 : : * In this usage, raid_disks is > 0 and it together with
7045 : : * level, size, not_persistent,layout,chunksize determine the
7046 : : * shape of the array.
7047 : : * This will always create an array with a type-0.90.0 superblock.
7048 : : * The newer usage is when assembling an array.
7049 : : * In this case raid_disks will be 0, and the major_version field is
7050 : : * use to determine which style super-blocks are to be found on the devices.
7051 : : * The minor and patch _version numbers are also kept incase the
7052 : : * super_block handler wishes to interpret them.
7053 : : */
7054 : 0 : static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
7055 : : {
7056 : :
7057 [ # # ]: 0 : if (info->raid_disks == 0) {
7058 : : /* just setting version number for superblock loading */
7059 [ # # ]: 0 : if (info->major_version < 0 ||
7060 : 0 : info->major_version >= ARRAY_SIZE(super_types) ||
7061 [ # # ]: 0 : super_types[info->major_version].name == NULL) {
7062 : : /* maybe try to auto-load a module? */
7063 : 0 : pr_warn("md: superblock version %d not known\n",
7064 : : info->major_version);
7065 : 0 : return -EINVAL;
7066 : : }
7067 : 0 : mddev->major_version = info->major_version;
7068 : 0 : mddev->minor_version = info->minor_version;
7069 : 0 : mddev->patch_version = info->patch_version;
7070 : 0 : mddev->persistent = !info->not_persistent;
7071 : : /* ensure mddev_put doesn't delete this now that there
7072 : : * is some minimal configuration.
7073 : : */
7074 : 0 : mddev->ctime = ktime_get_real_seconds();
7075 : 0 : return 0;
7076 : : }
7077 : 0 : mddev->major_version = MD_MAJOR_VERSION;
7078 : 0 : mddev->minor_version = MD_MINOR_VERSION;
7079 : 0 : mddev->patch_version = MD_PATCHLEVEL_VERSION;
7080 : 0 : mddev->ctime = ktime_get_real_seconds();
7081 : :
7082 : 0 : mddev->level = info->level;
7083 : 0 : mddev->clevel[0] = 0;
7084 : 0 : mddev->dev_sectors = 2 * (sector_t)info->size;
7085 : 0 : mddev->raid_disks = info->raid_disks;
7086 : : /* don't set md_minor, it is determined by which /dev/md* was
7087 : : * openned
7088 : : */
7089 [ # # ]: 0 : if (info->state & (1<<MD_SB_CLEAN))
7090 : 0 : mddev->recovery_cp = MaxSector;
7091 : : else
7092 : 0 : mddev->recovery_cp = 0;
7093 : 0 : mddev->persistent = ! info->not_persistent;
7094 : 0 : mddev->external = 0;
7095 : :
7096 : 0 : mddev->layout = info->layout;
7097 [ # # ]: 0 : if (mddev->level == 0)
7098 : : /* Cannot trust RAID0 layout info here */
7099 : 0 : mddev->layout = -1;
7100 : 0 : mddev->chunk_sectors = info->chunk_size >> 9;
7101 : :
7102 [ # # ]: 0 : if (mddev->persistent) {
7103 : 0 : mddev->max_disks = MD_SB_DISKS;
7104 : 0 : mddev->flags = 0;
7105 : 0 : mddev->sb_flags = 0;
7106 : : }
7107 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
7108 : :
7109 : 0 : mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
7110 : 0 : mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
7111 : 0 : mddev->bitmap_info.offset = 0;
7112 : :
7113 : 0 : mddev->reshape_position = MaxSector;
7114 : :
7115 : : /*
7116 : : * Generate a 128 bit UUID
7117 : : */
7118 : 0 : get_random_bytes(mddev->uuid, 16);
7119 : :
7120 : 0 : mddev->new_level = mddev->level;
7121 : 0 : mddev->new_chunk_sectors = mddev->chunk_sectors;
7122 : 0 : mddev->new_layout = mddev->layout;
7123 : 0 : mddev->delta_disks = 0;
7124 : 0 : mddev->reshape_backwards = 0;
7125 : :
7126 : 0 : return 0;
7127 : : }
7128 : :
7129 : 0 : void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
7130 : : {
7131 : 0 : lockdep_assert_held(&mddev->reconfig_mutex);
7132 : :
7133 [ # # # # ]: 0 : if (mddev->external_size)
7134 : : return;
7135 : :
7136 : 0 : mddev->array_sectors = array_sectors;
7137 : : }
7138 : : EXPORT_SYMBOL(md_set_array_sectors);
7139 : :
7140 : 0 : static int update_size(struct mddev *mddev, sector_t num_sectors)
7141 : : {
7142 : 0 : struct md_rdev *rdev;
7143 : 0 : int rv;
7144 : 0 : int fit = (num_sectors == 0);
7145 : 0 : sector_t old_dev_sectors = mddev->dev_sectors;
7146 : :
7147 [ # # ]: 0 : if (mddev->pers->resize == NULL)
7148 : : return -EINVAL;
7149 : : /* The "num_sectors" is the number of sectors of each device that
7150 : : * is used. This can only make sense for arrays with redundancy.
7151 : : * linear and raid0 always use whatever space is available. We can only
7152 : : * consider changing this number if no resync or reconstruction is
7153 : : * happening, and if the new size is acceptable. It must fit before the
7154 : : * sb_start or, if that is <data_offset, it must fit before the size
7155 : : * of each device. If num_sectors is zero, we find the largest size
7156 : : * that fits.
7157 : : */
7158 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7159 [ # # ]: 0 : mddev->sync_thread)
7160 : : return -EBUSY;
7161 [ # # ]: 0 : if (mddev->ro)
7162 : : return -EROFS;
7163 : :
7164 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
7165 : 0 : sector_t avail = rdev->sectors;
7166 : :
7167 [ # # # # ]: 0 : if (fit && (num_sectors == 0 || num_sectors > avail))
7168 : 0 : num_sectors = avail;
7169 [ # # ]: 0 : if (avail < num_sectors)
7170 : : return -ENOSPC;
7171 : : }
7172 : 0 : rv = mddev->pers->resize(mddev, num_sectors);
7173 [ # # ]: 0 : if (!rv) {
7174 [ # # ]: 0 : if (mddev_is_clustered(mddev))
7175 : 0 : md_cluster_ops->update_size(mddev, old_dev_sectors);
7176 [ # # ]: 0 : else if (mddev->queue) {
7177 : 0 : set_capacity(mddev->gendisk, mddev->array_sectors);
7178 : 0 : revalidate_disk(mddev->gendisk);
7179 : : }
7180 : : }
7181 : : return rv;
7182 : : }
7183 : :
7184 : 0 : static int update_raid_disks(struct mddev *mddev, int raid_disks)
7185 : : {
7186 : 0 : int rv;
7187 : 0 : struct md_rdev *rdev;
7188 : : /* change the number of raid disks */
7189 [ # # ]: 0 : if (mddev->pers->check_reshape == NULL)
7190 : : return -EINVAL;
7191 [ # # ]: 0 : if (mddev->ro)
7192 : : return -EROFS;
7193 [ # # ]: 0 : if (raid_disks <= 0 ||
7194 [ # # # # ]: 0 : (mddev->max_disks && raid_disks >= mddev->max_disks))
7195 : : return -EINVAL;
7196 [ # # # # ]: 0 : if (mddev->sync_thread ||
7197 : 0 : test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7198 [ # # ]: 0 : mddev->reshape_position != MaxSector)
7199 : 0 : return -EBUSY;
7200 : :
7201 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
7202 [ # # ]: 0 : if (mddev->raid_disks < raid_disks &&
7203 [ # # ]: 0 : rdev->data_offset < rdev->new_data_offset)
7204 : : return -EINVAL;
7205 [ # # ]: 0 : if (mddev->raid_disks > raid_disks &&
7206 [ # # ]: 0 : rdev->data_offset > rdev->new_data_offset)
7207 : : return -EINVAL;
7208 : : }
7209 : :
7210 : 0 : mddev->delta_disks = raid_disks - mddev->raid_disks;
7211 [ # # ]: 0 : if (mddev->delta_disks < 0)
7212 : 0 : mddev->reshape_backwards = 1;
7213 [ # # ]: 0 : else if (mddev->delta_disks > 0)
7214 : 0 : mddev->reshape_backwards = 0;
7215 : :
7216 : 0 : rv = mddev->pers->check_reshape(mddev);
7217 [ # # ]: 0 : if (rv < 0) {
7218 : 0 : mddev->delta_disks = 0;
7219 : 0 : mddev->reshape_backwards = 0;
7220 : : }
7221 : : return rv;
7222 : : }
7223 : :
7224 : : /*
7225 : : * update_array_info is used to change the configuration of an
7226 : : * on-line array.
7227 : : * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
7228 : : * fields in the info are checked against the array.
7229 : : * Any differences that cannot be handled will cause an error.
7230 : : * Normally, only one change can be managed at a time.
7231 : : */
7232 : 0 : static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
7233 : : {
7234 : 0 : int rv = 0;
7235 : 0 : int cnt = 0;
7236 : 0 : int state = 0;
7237 : :
7238 : : /* calculate expected state,ignoring low bits */
7239 [ # # # # ]: 0 : if (mddev->bitmap && mddev->bitmap_info.offset)
7240 : 0 : state |= (1 << MD_SB_BITMAP_PRESENT);
7241 : :
7242 [ # # ]: 0 : if (mddev->major_version != info->major_version ||
7243 [ # # ]: 0 : mddev->minor_version != info->minor_version ||
7244 : : /* mddev->patch_version != info->patch_version || */
7245 [ # # ]: 0 : mddev->ctime != info->ctime ||
7246 [ # # ]: 0 : mddev->level != info->level ||
7247 : : /* mddev->layout != info->layout || */
7248 [ # # ]: 0 : mddev->persistent != !info->not_persistent ||
7249 [ # # ]: 0 : mddev->chunk_sectors != info->chunk_size >> 9 ||
7250 : : /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
7251 [ # # ]: 0 : ((state^info->state) & 0xfffffe00)
7252 : : )
7253 : : return -EINVAL;
7254 : : /* Check there is only one change */
7255 [ # # # # ]: 0 : if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
7256 : 0 : cnt++;
7257 [ # # ]: 0 : if (mddev->raid_disks != info->raid_disks)
7258 : 0 : cnt++;
7259 [ # # ]: 0 : if (mddev->layout != info->layout)
7260 : 0 : cnt++;
7261 [ # # ]: 0 : if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
7262 : 0 : cnt++;
7263 [ # # ]: 0 : if (cnt == 0)
7264 : : return 0;
7265 [ # # ]: 0 : if (cnt > 1)
7266 : : return -EINVAL;
7267 : :
7268 [ # # ]: 0 : if (mddev->layout != info->layout) {
7269 : : /* Change layout
7270 : : * we don't need to do anything at the md level, the
7271 : : * personality will take care of it all.
7272 : : */
7273 [ # # ]: 0 : if (mddev->pers->check_reshape == NULL)
7274 : : return -EINVAL;
7275 : : else {
7276 : 0 : mddev->new_layout = info->layout;
7277 : 0 : rv = mddev->pers->check_reshape(mddev);
7278 [ # # ]: 0 : if (rv)
7279 : 0 : mddev->new_layout = mddev->layout;
7280 : 0 : return rv;
7281 : : }
7282 : : }
7283 [ # # # # ]: 0 : if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
7284 : 0 : rv = update_size(mddev, (sector_t)info->size * 2);
7285 : :
7286 [ # # ]: 0 : if (mddev->raid_disks != info->raid_disks)
7287 : 0 : rv = update_raid_disks(mddev, info->raid_disks);
7288 : :
7289 [ # # ]: 0 : if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
7290 [ # # # # ]: 0 : if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
7291 : 0 : rv = -EINVAL;
7292 : 0 : goto err;
7293 : : }
7294 [ # # # # ]: 0 : if (mddev->recovery || mddev->sync_thread) {
7295 : 0 : rv = -EBUSY;
7296 : 0 : goto err;
7297 : : }
7298 [ # # ]: 0 : if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
7299 : 0 : struct bitmap *bitmap;
7300 : : /* add the bitmap */
7301 [ # # ]: 0 : if (mddev->bitmap) {
7302 : 0 : rv = -EEXIST;
7303 : 0 : goto err;
7304 : : }
7305 [ # # ]: 0 : if (mddev->bitmap_info.default_offset == 0) {
7306 : 0 : rv = -EINVAL;
7307 : 0 : goto err;
7308 : : }
7309 : 0 : mddev->bitmap_info.offset =
7310 : : mddev->bitmap_info.default_offset;
7311 : 0 : mddev->bitmap_info.space =
7312 : 0 : mddev->bitmap_info.default_space;
7313 : 0 : bitmap = md_bitmap_create(mddev, -1);
7314 : 0 : mddev_suspend(mddev);
7315 [ # # ]: 0 : if (!IS_ERR(bitmap)) {
7316 : 0 : mddev->bitmap = bitmap;
7317 : 0 : rv = md_bitmap_load(mddev);
7318 : : } else
7319 : 0 : rv = PTR_ERR(bitmap);
7320 [ # # ]: 0 : if (rv)
7321 : 0 : md_bitmap_destroy(mddev);
7322 : 0 : mddev_resume(mddev);
7323 : : } else {
7324 : : /* remove the bitmap */
7325 [ # # ]: 0 : if (!mddev->bitmap) {
7326 : 0 : rv = -ENOENT;
7327 : 0 : goto err;
7328 : : }
7329 [ # # ]: 0 : if (mddev->bitmap->storage.file) {
7330 : 0 : rv = -EINVAL;
7331 : 0 : goto err;
7332 : : }
7333 [ # # ]: 0 : if (mddev->bitmap_info.nodes) {
7334 : : /* hold PW on all the bitmap lock */
7335 [ # # ]: 0 : if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
7336 : 0 : pr_warn("md: can't change bitmap to none since the array is in use by more than one node\n");
7337 : 0 : rv = -EPERM;
7338 : 0 : md_cluster_ops->unlock_all_bitmaps(mddev);
7339 : 0 : goto err;
7340 : : }
7341 : :
7342 : 0 : mddev->bitmap_info.nodes = 0;
7343 : 0 : md_cluster_ops->leave(mddev);
7344 : : }
7345 : 0 : mddev_suspend(mddev);
7346 : 0 : md_bitmap_destroy(mddev);
7347 : 0 : mddev_resume(mddev);
7348 : 0 : mddev->bitmap_info.offset = 0;
7349 : : }
7350 : : }
7351 : 0 : md_update_sb(mddev, 1);
7352 : 0 : return rv;
7353 : : err:
7354 : : return rv;
7355 : : }
7356 : :
7357 : 0 : static int set_disk_faulty(struct mddev *mddev, dev_t dev)
7358 : : {
7359 : 0 : struct md_rdev *rdev;
7360 : 0 : int err = 0;
7361 : :
7362 [ # # ]: 0 : if (mddev->pers == NULL)
7363 : : return -ENODEV;
7364 : :
7365 : 0 : rcu_read_lock();
7366 : 0 : rdev = md_find_rdev_rcu(mddev, dev);
7367 [ # # ]: 0 : if (!rdev)
7368 : : err = -ENODEV;
7369 : : else {
7370 : 0 : md_error(mddev, rdev);
7371 [ # # ]: 0 : if (!test_bit(Faulty, &rdev->flags))
7372 : 0 : err = -EBUSY;
7373 : : }
7374 : 0 : rcu_read_unlock();
7375 : 0 : return err;
7376 : : }
7377 : :
7378 : : /*
7379 : : * We have a problem here : there is no easy way to give a CHS
7380 : : * virtual geometry. We currently pretend that we have a 2 heads
7381 : : * 4 sectors (with a BIG number of cylinders...). This drives
7382 : : * dosfs just mad... ;-)
7383 : : */
7384 : 0 : static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
7385 : : {
7386 : 0 : struct mddev *mddev = bdev->bd_disk->private_data;
7387 : :
7388 : 0 : geo->heads = 2;
7389 : 0 : geo->sectors = 4;
7390 : 0 : geo->cylinders = mddev->array_sectors / 8;
7391 : 0 : return 0;
7392 : : }
7393 : :
7394 : 13 : static inline bool md_ioctl_valid(unsigned int cmd)
7395 : : {
7396 [ - + ]: 13 : switch (cmd) {
7397 : : case ADD_NEW_DISK:
7398 : : case BLKROSET:
7399 : : case GET_ARRAY_INFO:
7400 : : case GET_BITMAP_FILE:
7401 : : case GET_DISK_INFO:
7402 : : case HOT_ADD_DISK:
7403 : : case HOT_REMOVE_DISK:
7404 : : case RAID_AUTORUN:
7405 : : case RAID_VERSION:
7406 : : case RESTART_ARRAY_RW:
7407 : : case RUN_ARRAY:
7408 : : case SET_ARRAY_INFO:
7409 : : case SET_BITMAP_FILE:
7410 : : case SET_DISK_FAULTY:
7411 : : case STOP_ARRAY:
7412 : : case STOP_ARRAY_RO:
7413 : : case CLUSTERED_DISK_NACK:
7414 : : return true;
7415 : 0 : default:
7416 : 0 : return false;
7417 : : }
7418 : : }
7419 : :
7420 : 13 : static int md_ioctl(struct block_device *bdev, fmode_t mode,
7421 : : unsigned int cmd, unsigned long arg)
7422 : : {
7423 : 13 : int err = 0;
7424 : 13 : void __user *argp = (void __user *)arg;
7425 : 13 : struct mddev *mddev = NULL;
7426 : 13 : int ro;
7427 : 13 : bool did_set_md_closing = false;
7428 : :
7429 [ + - ]: 13 : if (!md_ioctl_valid(cmd))
7430 : : return -ENOTTY;
7431 : :
7432 [ + - ]: 13 : switch (cmd) {
7433 : : case RAID_VERSION:
7434 : : case GET_ARRAY_INFO:
7435 : : case GET_DISK_INFO:
7436 : : break;
7437 : 13 : default:
7438 [ + - ]: 13 : if (!capable(CAP_SYS_ADMIN))
7439 : : return -EACCES;
7440 : : }
7441 : :
7442 : : /*
7443 : : * Commands dealing with the RAID driver but not any
7444 : : * particular array:
7445 : : */
7446 [ - + - ]: 13 : switch (cmd) {
7447 : : case RAID_VERSION:
7448 : 0 : err = get_version(argp);
7449 : 0 : goto out;
7450 : :
7451 : : #ifndef MODULE
7452 : 13 : case RAID_AUTORUN:
7453 : 13 : err = 0;
7454 : 13 : autostart_arrays(arg);
7455 : 13 : goto out;
7456 : : #endif
7457 : 0 : default:;
7458 : : }
7459 : :
7460 : : /*
7461 : : * Commands creating/starting a new array:
7462 : : */
7463 : :
7464 : 0 : mddev = bdev->bd_disk->private_data;
7465 : :
7466 [ # # ]: 0 : if (!mddev) {
7467 : 0 : BUG();
7468 : : goto out;
7469 : : }
7470 : :
7471 : : /* Some actions do not requires the mutex */
7472 [ # # # # : 0 : switch (cmd) {
# ]
7473 : 0 : case GET_ARRAY_INFO:
7474 [ # # # # ]: 0 : if (!mddev->raid_disks && !mddev->external)
7475 : : err = -ENODEV;
7476 : : else
7477 : 0 : err = get_array_info(mddev, argp);
7478 : 0 : goto out;
7479 : :
7480 : 0 : case GET_DISK_INFO:
7481 [ # # # # ]: 0 : if (!mddev->raid_disks && !mddev->external)
7482 : : err = -ENODEV;
7483 : : else
7484 : 0 : err = get_disk_info(mddev, argp);
7485 : 0 : goto out;
7486 : :
7487 : 0 : case SET_DISK_FAULTY:
7488 : 0 : err = set_disk_faulty(mddev, new_decode_dev(arg));
7489 : 0 : goto out;
7490 : :
7491 : 0 : case GET_BITMAP_FILE:
7492 : 0 : err = get_bitmap_file(mddev, argp);
7493 : 0 : goto out;
7494 : :
7495 : : }
7496 : :
7497 [ # # ]: 0 : if (cmd == ADD_NEW_DISK)
7498 : : /* need to ensure md_delayed_delete() has completed */
7499 : 0 : flush_workqueue(md_misc_wq);
7500 : :
7501 [ # # ]: 0 : if (cmd == HOT_REMOVE_DISK)
7502 : : /* need to ensure recovery thread has run */
7503 [ # # # # : 0 : wait_event_interruptible_timeout(mddev->sb_wait,
# # # # ]
7504 : : !test_bit(MD_RECOVERY_NEEDED,
7505 : : &mddev->recovery),
7506 : : msecs_to_jiffies(5000));
7507 [ # # ]: 0 : if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
7508 : : /* Need to flush page cache, and ensure no-one else opens
7509 : : * and writes
7510 : : */
7511 : 0 : mutex_lock(&mddev->open_mutex);
7512 [ # # # # ]: 0 : if (mddev->pers && atomic_read(&mddev->openers) > 1) {
7513 : 0 : mutex_unlock(&mddev->open_mutex);
7514 : 0 : err = -EBUSY;
7515 : 0 : goto out;
7516 : : }
7517 [ # # ]: 0 : WARN_ON_ONCE(test_bit(MD_CLOSING, &mddev->flags));
7518 : 0 : set_bit(MD_CLOSING, &mddev->flags);
7519 : 0 : did_set_md_closing = true;
7520 : 0 : mutex_unlock(&mddev->open_mutex);
7521 : 0 : sync_blockdev(bdev);
7522 : : }
7523 : 0 : err = mddev_lock(mddev);
7524 [ # # ]: 0 : if (err) {
7525 : 0 : pr_debug("md: ioctl lock interrupted, reason %d, cmd %d\n",
7526 : : err, cmd);
7527 : 0 : goto out;
7528 : : }
7529 : :
7530 [ # # ]: 0 : if (cmd == SET_ARRAY_INFO) {
7531 : 0 : mdu_array_info_t info;
7532 [ # # ]: 0 : if (!arg)
7533 : 0 : memset(&info, 0, sizeof(info));
7534 [ # # ]: 0 : else if (copy_from_user(&info, argp, sizeof(info))) {
7535 : 0 : err = -EFAULT;
7536 : 0 : goto unlock;
7537 : : }
7538 [ # # ]: 0 : if (mddev->pers) {
7539 : 0 : err = update_array_info(mddev, &info);
7540 [ # # ]: 0 : if (err) {
7541 : 0 : pr_warn("md: couldn't update array info. %d\n", err);
7542 : 0 : goto unlock;
7543 : : }
7544 : 0 : goto unlock;
7545 : : }
7546 [ # # ]: 0 : if (!list_empty(&mddev->disks)) {
7547 [ # # ]: 0 : pr_warn("md: array %s already has disks!\n", mdname(mddev));
7548 : 0 : err = -EBUSY;
7549 : 0 : goto unlock;
7550 : : }
7551 [ # # ]: 0 : if (mddev->raid_disks) {
7552 [ # # ]: 0 : pr_warn("md: array %s already initialised!\n", mdname(mddev));
7553 : 0 : err = -EBUSY;
7554 : 0 : goto unlock;
7555 : : }
7556 : 0 : err = set_array_info(mddev, &info);
7557 [ # # ]: 0 : if (err) {
7558 : 0 : pr_warn("md: couldn't set array info. %d\n", err);
7559 : 0 : goto unlock;
7560 : : }
7561 : 0 : goto unlock;
7562 : : }
7563 : :
7564 : : /*
7565 : : * Commands querying/configuring an existing array:
7566 : : */
7567 : : /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
7568 : : * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
7569 [ # # # # ]: 0 : if ((!mddev->raid_disks && !mddev->external)
7570 [ # # ]: 0 : && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
7571 [ # # ]: 0 : && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
7572 [ # # ]: 0 : && cmd != GET_BITMAP_FILE) {
7573 : 0 : err = -ENODEV;
7574 : 0 : goto unlock;
7575 : : }
7576 : :
7577 : : /*
7578 : : * Commands even a read-only array can execute:
7579 : : */
7580 [ # # # # : 0 : switch (cmd) {
# # # ]
7581 : 0 : case RESTART_ARRAY_RW:
7582 : 0 : err = restart_array(mddev);
7583 : 0 : goto unlock;
7584 : :
7585 : 0 : case STOP_ARRAY:
7586 : 0 : err = do_md_stop(mddev, 0, bdev);
7587 : 0 : goto unlock;
7588 : :
7589 : 0 : case STOP_ARRAY_RO:
7590 : 0 : err = md_set_readonly(mddev, bdev);
7591 : 0 : goto unlock;
7592 : :
7593 : 0 : case HOT_REMOVE_DISK:
7594 : 0 : err = hot_remove_disk(mddev, new_decode_dev(arg));
7595 : 0 : goto unlock;
7596 : :
7597 : 0 : case ADD_NEW_DISK:
7598 : : /* We can support ADD_NEW_DISK on read-only arrays
7599 : : * only if we are re-adding a preexisting device.
7600 : : * So require mddev->pers and MD_DISK_SYNC.
7601 : : */
7602 [ # # ]: 0 : if (mddev->pers) {
7603 : 0 : mdu_disk_info_t info;
7604 [ # # ]: 0 : if (copy_from_user(&info, argp, sizeof(info)))
7605 : : err = -EFAULT;
7606 [ # # ]: 0 : else if (!(info.state & (1<<MD_DISK_SYNC)))
7607 : : /* Need to clear read-only for this */
7608 : : break;
7609 : : else
7610 : 0 : err = add_new_disk(mddev, &info);
7611 : 0 : goto unlock;
7612 : : }
7613 : : break;
7614 : :
7615 : : case BLKROSET:
7616 [ # # ]: 0 : if (get_user(ro, (int __user *)(arg))) {
7617 : 0 : err = -EFAULT;
7618 : 0 : goto unlock;
7619 : : }
7620 : 0 : err = -EINVAL;
7621 : :
7622 : : /* if the bdev is going readonly the value of mddev->ro
7623 : : * does not matter, no writes are coming
7624 : : */
7625 [ # # ]: 0 : if (ro)
7626 : 0 : goto unlock;
7627 : :
7628 : : /* are we are already prepared for writes? */
7629 [ # # ]: 0 : if (mddev->ro != 1)
7630 : 0 : goto unlock;
7631 : :
7632 : : /* transitioning to readauto need only happen for
7633 : : * arrays that call md_write_start
7634 : : */
7635 [ # # ]: 0 : if (mddev->pers) {
7636 : 0 : err = restart_array(mddev);
7637 [ # # ]: 0 : if (err == 0) {
7638 : 0 : mddev->ro = 2;
7639 : 0 : set_disk_ro(mddev->gendisk, 0);
7640 : : }
7641 : : }
7642 : 0 : goto unlock;
7643 : : }
7644 : :
7645 : : /*
7646 : : * The remaining ioctls are changing the state of the
7647 : : * superblock, so we do not allow them on read-only arrays.
7648 : : */
7649 [ # # # # ]: 0 : if (mddev->ro && mddev->pers) {
7650 [ # # ]: 0 : if (mddev->ro == 2) {
7651 : 0 : mddev->ro = 0;
7652 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
7653 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7654 : : /* mddev_unlock will wake thread */
7655 : : /* If a device failed while we were read-only, we
7656 : : * need to make sure the metadata is updated now.
7657 : : */
7658 [ # # ]: 0 : if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) {
7659 : 0 : mddev_unlock(mddev);
7660 [ # # # # : 0 : wait_event(mddev->sb_wait,
# # # # ]
7661 : : !test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) &&
7662 : : !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
7663 : 0 : mddev_lock_nointr(mddev);
7664 : : }
7665 : : } else {
7666 : 0 : err = -EROFS;
7667 : 0 : goto unlock;
7668 : : }
7669 : : }
7670 : :
7671 [ # # # # : 0 : switch (cmd) {
# # ]
7672 : : case ADD_NEW_DISK:
7673 : : {
7674 : 0 : mdu_disk_info_t info;
7675 [ # # ]: 0 : if (copy_from_user(&info, argp, sizeof(info)))
7676 : : err = -EFAULT;
7677 : : else
7678 : 0 : err = add_new_disk(mddev, &info);
7679 : 0 : goto unlock;
7680 : : }
7681 : :
7682 : 0 : case CLUSTERED_DISK_NACK:
7683 [ # # ]: 0 : if (mddev_is_clustered(mddev))
7684 : 0 : md_cluster_ops->new_disk_ack(mddev, false);
7685 : : else
7686 : : err = -EINVAL;
7687 : 0 : goto unlock;
7688 : :
7689 : 0 : case HOT_ADD_DISK:
7690 : 0 : err = hot_add_disk(mddev, new_decode_dev(arg));
7691 : 0 : goto unlock;
7692 : :
7693 : 0 : case RUN_ARRAY:
7694 : 0 : err = do_md_run(mddev);
7695 : 0 : goto unlock;
7696 : :
7697 : 0 : case SET_BITMAP_FILE:
7698 : 0 : err = set_bitmap_file(mddev, (int)arg);
7699 : 0 : goto unlock;
7700 : :
7701 : 0 : default:
7702 : 0 : err = -EINVAL;
7703 : 0 : goto unlock;
7704 : : }
7705 : :
7706 : 0 : unlock:
7707 [ # # # # ]: 0 : if (mddev->hold_active == UNTIL_IOCTL &&
7708 : : err != -EINVAL)
7709 : 0 : mddev->hold_active = 0;
7710 : 0 : mddev_unlock(mddev);
7711 : 13 : out:
7712 [ - + ]: 13 : if(did_set_md_closing)
7713 : 0 : clear_bit(MD_CLOSING, &mddev->flags);
7714 : : return err;
7715 : : }
7716 : : #ifdef CONFIG_COMPAT
7717 : 0 : static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
7718 : : unsigned int cmd, unsigned long arg)
7719 : : {
7720 [ # # ]: 0 : switch (cmd) {
7721 : : case HOT_REMOVE_DISK:
7722 : : case HOT_ADD_DISK:
7723 : : case SET_DISK_FAULTY:
7724 : : case SET_BITMAP_FILE:
7725 : : /* These take in integer arg, do not convert */
7726 : : break;
7727 : 0 : default:
7728 : 0 : arg = (unsigned long)compat_ptr(arg);
7729 : 0 : break;
7730 : : }
7731 : :
7732 : 0 : return md_ioctl(bdev, mode, cmd, arg);
7733 : : }
7734 : : #endif /* CONFIG_COMPAT */
7735 : :
7736 : 13 : static int md_open(struct block_device *bdev, fmode_t mode)
7737 : : {
7738 : : /*
7739 : : * Succeed if we can lock the mddev, which confirms that
7740 : : * it isn't being stopped right now.
7741 : : */
7742 : 13 : struct mddev *mddev = mddev_find(bdev->bd_dev);
7743 : 13 : int err;
7744 : :
7745 [ + - ]: 13 : if (!mddev)
7746 : : return -ENODEV;
7747 : :
7748 [ - + ]: 13 : if (mddev->gendisk != bdev->bd_disk) {
7749 : : /* we are racing with mddev_put which is discarding this
7750 : : * bd_disk.
7751 : : */
7752 : 0 : mddev_put(mddev);
7753 : : /* Wait until bdev->bd_disk is definitely gone */
7754 : 0 : flush_workqueue(md_misc_wq);
7755 : : /* Then retry the open from the top */
7756 : 0 : return -ERESTARTSYS;
7757 : : }
7758 [ - + ]: 13 : BUG_ON(mddev != bdev->bd_disk->private_data);
7759 : :
7760 [ - + ]: 13 : if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
7761 : 0 : goto out;
7762 : :
7763 [ - + ]: 13 : if (test_bit(MD_CLOSING, &mddev->flags)) {
7764 : 0 : mutex_unlock(&mddev->open_mutex);
7765 : 0 : err = -ENODEV;
7766 : 0 : goto out;
7767 : : }
7768 : :
7769 : 13 : err = 0;
7770 : 13 : atomic_inc(&mddev->openers);
7771 : 13 : mutex_unlock(&mddev->open_mutex);
7772 : :
7773 : 13 : check_disk_change(bdev);
7774 : : out:
7775 : 13 : if (err)
7776 : 0 : mddev_put(mddev);
7777 : : return err;
7778 : : }
7779 : :
7780 : 13 : static void md_release(struct gendisk *disk, fmode_t mode)
7781 : : {
7782 : 13 : struct mddev *mddev = disk->private_data;
7783 : :
7784 [ - + ]: 13 : BUG_ON(!mddev);
7785 : 13 : atomic_dec(&mddev->openers);
7786 : 13 : mddev_put(mddev);
7787 : 13 : }
7788 : :
7789 : 13 : static int md_media_changed(struct gendisk *disk)
7790 : : {
7791 : 13 : struct mddev *mddev = disk->private_data;
7792 : :
7793 : 13 : return mddev->changed;
7794 : : }
7795 : :
7796 : 0 : static int md_revalidate(struct gendisk *disk)
7797 : : {
7798 : 0 : struct mddev *mddev = disk->private_data;
7799 : :
7800 : 0 : mddev->changed = 0;
7801 : 0 : return 0;
7802 : : }
7803 : : static const struct block_device_operations md_fops =
7804 : : {
7805 : : .owner = THIS_MODULE,
7806 : : .open = md_open,
7807 : : .release = md_release,
7808 : : .ioctl = md_ioctl,
7809 : : #ifdef CONFIG_COMPAT
7810 : : .compat_ioctl = md_compat_ioctl,
7811 : : #endif
7812 : : .getgeo = md_getgeo,
7813 : : .media_changed = md_media_changed,
7814 : : .revalidate_disk= md_revalidate,
7815 : : };
7816 : :
7817 : 0 : static int md_thread(void *arg)
7818 : : {
7819 : 0 : struct md_thread *thread = arg;
7820 : :
7821 : : /*
7822 : : * md_thread is a 'system-thread', it's priority should be very
7823 : : * high. We avoid resource deadlocks individually in each
7824 : : * raid personality. (RAID5 does preallocation) We also use RR and
7825 : : * the very same RT priority as kswapd, thus we will never get
7826 : : * into a priority inversion deadlock.
7827 : : *
7828 : : * we definitely have to have equal or higher priority than
7829 : : * bdflush, otherwise bdflush will deadlock if there are too
7830 : : * many dirty RAID5 blocks.
7831 : : */
7832 : :
7833 : 0 : allow_signal(SIGKILL);
7834 [ # # ]: 0 : while (!kthread_should_stop()) {
7835 : :
7836 : : /* We need to wait INTERRUPTIBLE so that
7837 : : * we don't add to the load-average.
7838 : : * That means we need to be sure no signals are
7839 : : * pending
7840 : : */
7841 [ # # ]: 0 : if (signal_pending(current))
7842 : 0 : flush_signals(current);
7843 : :
7844 [ # # # # : 0 : wait_event_interruptible_timeout
# # # # #
# # # # #
# # # # #
# # # ]
7845 : : (thread->wqueue,
7846 : : test_bit(THREAD_WAKEUP, &thread->flags)
7847 : : || kthread_should_stop() || kthread_should_park(),
7848 : : thread->timeout);
7849 : :
7850 : 0 : clear_bit(THREAD_WAKEUP, &thread->flags);
7851 [ # # ]: 0 : if (kthread_should_park())
7852 : 0 : kthread_parkme();
7853 [ # # ]: 0 : if (!kthread_should_stop())
7854 : 0 : thread->run(thread);
7855 : : }
7856 : :
7857 : 0 : return 0;
7858 : : }
7859 : :
7860 : 0 : void md_wakeup_thread(struct md_thread *thread)
7861 : : {
7862 [ # # ]: 0 : if (thread) {
7863 : 0 : pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
7864 : 0 : set_bit(THREAD_WAKEUP, &thread->flags);
7865 : 0 : wake_up(&thread->wqueue);
7866 : : }
7867 : 0 : }
7868 : : EXPORT_SYMBOL(md_wakeup_thread);
7869 : :
7870 : 0 : struct md_thread *md_register_thread(void (*run) (struct md_thread *),
7871 : : struct mddev *mddev, const char *name)
7872 : : {
7873 : 0 : struct md_thread *thread;
7874 : :
7875 : 0 : thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
7876 [ # # ]: 0 : if (!thread)
7877 : : return NULL;
7878 : :
7879 : 0 : init_waitqueue_head(&thread->wqueue);
7880 : :
7881 : 0 : thread->run = run;
7882 : 0 : thread->mddev = mddev;
7883 : 0 : thread->timeout = MAX_SCHEDULE_TIMEOUT;
7884 [ # # # # ]: 0 : thread->tsk = kthread_run(md_thread, thread,
7885 : : "%s_%s",
7886 : : mdname(thread->mddev),
7887 : : name);
7888 [ # # ]: 0 : if (IS_ERR(thread->tsk)) {
7889 : 0 : kfree(thread);
7890 : 0 : return NULL;
7891 : : }
7892 : : return thread;
7893 : : }
7894 : : EXPORT_SYMBOL(md_register_thread);
7895 : :
7896 : 0 : void md_unregister_thread(struct md_thread **threadp)
7897 : : {
7898 : 0 : struct md_thread *thread = *threadp;
7899 [ # # ]: 0 : if (!thread)
7900 : : return;
7901 : 0 : pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7902 : : /* Locking ensures that mddev_unlock does not wake_up a
7903 : : * non-existent thread
7904 : : */
7905 : 0 : spin_lock(&pers_lock);
7906 : 0 : *threadp = NULL;
7907 : 0 : spin_unlock(&pers_lock);
7908 : :
7909 : 0 : kthread_stop(thread->tsk);
7910 : 0 : kfree(thread);
7911 : : }
7912 : : EXPORT_SYMBOL(md_unregister_thread);
7913 : :
7914 : 0 : void md_error(struct mddev *mddev, struct md_rdev *rdev)
7915 : : {
7916 [ # # # # ]: 0 : if (!rdev || test_bit(Faulty, &rdev->flags))
7917 : 0 : return;
7918 : :
7919 [ # # # # ]: 0 : if (!mddev->pers || !mddev->pers->error_handler)
7920 : : return;
7921 : 0 : mddev->pers->error_handler(mddev,rdev);
7922 [ # # ]: 0 : if (mddev->degraded)
7923 : 0 : set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7924 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
7925 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7926 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7927 : 0 : md_wakeup_thread(mddev->thread);
7928 [ # # ]: 0 : if (mddev->event_work.func)
7929 : 0 : queue_work(md_misc_wq, &mddev->event_work);
7930 : 0 : md_new_event(mddev);
7931 : : }
7932 : : EXPORT_SYMBOL(md_error);
7933 : :
7934 : : /* seq_file implementation /proc/mdstat */
7935 : :
7936 : 0 : static void status_unused(struct seq_file *seq)
7937 : : {
7938 : 0 : int i = 0;
7939 : 0 : struct md_rdev *rdev;
7940 : :
7941 : 0 : seq_printf(seq, "unused devices: ");
7942 : :
7943 [ # # ]: 0 : list_for_each_entry(rdev, &pending_raid_disks, same_set) {
7944 : 0 : char b[BDEVNAME_SIZE];
7945 : 0 : i++;
7946 : 0 : seq_printf(seq, "%s ",
7947 : : bdevname(rdev->bdev,b));
7948 : : }
7949 [ # # ]: 0 : if (!i)
7950 : 0 : seq_printf(seq, "<none>");
7951 : :
7952 : 0 : seq_printf(seq, "\n");
7953 : 0 : }
7954 : :
7955 : 0 : static int status_resync(struct seq_file *seq, struct mddev *mddev)
7956 : : {
7957 : 0 : sector_t max_sectors, resync, res;
7958 : 0 : unsigned long dt, db = 0;
7959 : 0 : sector_t rt, curr_mark_cnt, resync_mark_cnt;
7960 : 0 : int scale, recovery_active;
7961 : 0 : unsigned int per_milli;
7962 : :
7963 [ # # # # ]: 0 : if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7964 : : test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7965 : 0 : max_sectors = mddev->resync_max_sectors;
7966 : : else
7967 : 0 : max_sectors = mddev->dev_sectors;
7968 : :
7969 : 0 : resync = mddev->curr_resync;
7970 [ # # ]: 0 : if (resync <= 3) {
7971 [ # # ]: 0 : if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7972 : : /* Still cleaning up */
7973 : 0 : resync = max_sectors;
7974 [ # # ]: 0 : } else if (resync > max_sectors)
7975 : : resync = max_sectors;
7976 : : else
7977 : 0 : resync -= atomic_read(&mddev->recovery_active);
7978 : :
7979 [ # # ]: 0 : if (resync == 0) {
7980 [ # # ]: 0 : if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {
7981 : 0 : struct md_rdev *rdev;
7982 : :
7983 [ # # ]: 0 : rdev_for_each(rdev, mddev)
7984 [ # # # # ]: 0 : if (rdev->raid_disk >= 0 &&
7985 : 0 : !test_bit(Faulty, &rdev->flags) &&
7986 [ # # # # ]: 0 : rdev->recovery_offset != MaxSector &&
7987 : : rdev->recovery_offset) {
7988 : 0 : seq_printf(seq, "\trecover=REMOTE");
7989 : 0 : return 1;
7990 : : }
7991 [ # # ]: 0 : if (mddev->reshape_position != MaxSector)
7992 : 0 : seq_printf(seq, "\treshape=REMOTE");
7993 : : else
7994 : 0 : seq_printf(seq, "\tresync=REMOTE");
7995 : 0 : return 1;
7996 : : }
7997 [ # # ]: 0 : if (mddev->recovery_cp < MaxSector) {
7998 : 0 : seq_printf(seq, "\tresync=PENDING");
7999 : 0 : return 1;
8000 : : }
8001 : : return 0;
8002 : : }
8003 [ # # ]: 0 : if (resync < 3) {
8004 : 0 : seq_printf(seq, "\tresync=DELAYED");
8005 : 0 : return 1;
8006 : : }
8007 : :
8008 [ # # ]: 0 : WARN_ON(max_sectors == 0);
8009 : : /* Pick 'scale' such that (resync>>scale)*1000 will fit
8010 : : * in a sector_t, and (max_sectors>>scale) will fit in a
8011 : : * u32, as those are the requirements for sector_div.
8012 : : * Thus 'scale' must be at least 10
8013 : : */
8014 : 0 : scale = 10;
8015 : 0 : if (sizeof(sector_t) > sizeof(unsigned long)) {
8016 : : while ( max_sectors/2 > (1ULL<<(scale+32)))
8017 : : scale++;
8018 : : }
8019 : 0 : res = (resync>>scale)*1000;
8020 : 0 : sector_div(res, (u32)((max_sectors>>scale)+1));
8021 : :
8022 : 0 : per_milli = res;
8023 : : {
8024 : 0 : int i, x = per_milli/50, y = 20-x;
8025 : 0 : seq_printf(seq, "[");
8026 [ # # ]: 0 : for (i = 0; i < x; i++)
8027 : 0 : seq_printf(seq, "=");
8028 : 0 : seq_printf(seq, ">");
8029 [ # # ]: 0 : for (i = 0; i < y; i++)
8030 : 0 : seq_printf(seq, ".");
8031 : 0 : seq_printf(seq, "] ");
8032 : : }
8033 [ # # ]: 0 : seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
8034 : : (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
8035 : : "reshape" :
8036 : : (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
8037 [ # # ]: 0 : "check" :
8038 : : (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
8039 [ # # ]: 0 : "resync" : "recovery"))),
8040 : : per_milli/10, per_milli % 10,
8041 : : (unsigned long long) resync/2,
8042 : : (unsigned long long) max_sectors/2);
8043 : :
8044 : : /*
8045 : : * dt: time from mark until now
8046 : : * db: blocks written from mark until now
8047 : : * rt: remaining time
8048 : : *
8049 : : * rt is a sector_t, which is always 64bit now. We are keeping
8050 : : * the original algorithm, but it is not really necessary.
8051 : : *
8052 : : * Original algorithm:
8053 : : * So we divide before multiply in case it is 32bit and close
8054 : : * to the limit.
8055 : : * We scale the divisor (db) by 32 to avoid losing precision
8056 : : * near the end of resync when the number of remaining sectors
8057 : : * is close to 'db'.
8058 : : * We then divide rt by 32 after multiplying by db to compensate.
8059 : : * The '+1' avoids division by zero if db is very small.
8060 : : */
8061 : 0 : dt = ((jiffies - mddev->resync_mark) / HZ);
8062 [ # # ]: 0 : if (!dt) dt++;
8063 : :
8064 : 0 : curr_mark_cnt = mddev->curr_mark_cnt;
8065 : 0 : recovery_active = atomic_read(&mddev->recovery_active);
8066 : 0 : resync_mark_cnt = mddev->resync_mark_cnt;
8067 : :
8068 [ # # ]: 0 : if (curr_mark_cnt >= (recovery_active + resync_mark_cnt))
8069 : 0 : db = curr_mark_cnt - (recovery_active + resync_mark_cnt);
8070 : :
8071 : 0 : rt = max_sectors - resync; /* number of remaining sectors */
8072 : 0 : rt = div64_u64(rt, db/32+1);
8073 : 0 : rt *= dt;
8074 : 0 : rt >>= 5;
8075 : :
8076 : 0 : seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
8077 : 0 : ((unsigned long)rt % 60)/6);
8078 : :
8079 : 0 : seq_printf(seq, " speed=%ldK/sec", db/2/dt);
8080 : 0 : return 1;
8081 : : }
8082 : :
8083 : 0 : static void *md_seq_start(struct seq_file *seq, loff_t *pos)
8084 : : {
8085 : 0 : struct list_head *tmp;
8086 : 0 : loff_t l = *pos;
8087 : 0 : struct mddev *mddev;
8088 : :
8089 [ # # ]: 0 : if (l >= 0x10000)
8090 : : return NULL;
8091 [ # # ]: 0 : if (!l--)
8092 : : /* header */
8093 : : return (void*)1;
8094 : :
8095 : 0 : spin_lock(&all_mddevs_lock);
8096 [ # # ]: 0 : list_for_each(tmp,&all_mddevs)
8097 [ # # ]: 0 : if (!l--) {
8098 : 0 : mddev = list_entry(tmp, struct mddev, all_mddevs);
8099 : 0 : mddev_get(mddev);
8100 : 0 : spin_unlock(&all_mddevs_lock);
8101 : 0 : return mddev;
8102 : : }
8103 : 0 : spin_unlock(&all_mddevs_lock);
8104 [ # # ]: 0 : if (!l--)
8105 : 0 : return (void*)2;/* tail */
8106 : : return NULL;
8107 : : }
8108 : :
8109 : 0 : static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
8110 : : {
8111 : 0 : struct list_head *tmp;
8112 : 0 : struct mddev *next_mddev, *mddev = v;
8113 : :
8114 : 0 : ++*pos;
8115 [ # # ]: 0 : if (v == (void*)2)
8116 : : return NULL;
8117 : :
8118 : 0 : spin_lock(&all_mddevs_lock);
8119 [ # # ]: 0 : if (v == (void*)1)
8120 : 0 : tmp = all_mddevs.next;
8121 : : else
8122 : 0 : tmp = mddev->all_mddevs.next;
8123 [ # # ]: 0 : if (tmp != &all_mddevs)
8124 : 0 : next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
8125 : : else {
8126 : 0 : next_mddev = (void*)2;
8127 : 0 : *pos = 0x10000;
8128 : : }
8129 : 0 : spin_unlock(&all_mddevs_lock);
8130 : :
8131 [ # # ]: 0 : if (v != (void*)1)
8132 : 0 : mddev_put(mddev);
8133 : : return next_mddev;
8134 : :
8135 : : }
8136 : :
8137 : 0 : static void md_seq_stop(struct seq_file *seq, void *v)
8138 : : {
8139 : 0 : struct mddev *mddev = v;
8140 : :
8141 [ # # # # ]: 0 : if (mddev && v != (void*)1 && v != (void*)2)
8142 : 0 : mddev_put(mddev);
8143 : 0 : }
8144 : :
8145 : 0 : static int md_seq_show(struct seq_file *seq, void *v)
8146 : : {
8147 : 0 : struct mddev *mddev = v;
8148 : 0 : sector_t sectors;
8149 : 0 : struct md_rdev *rdev;
8150 : :
8151 [ # # ]: 0 : if (v == (void*)1) {
8152 : 0 : struct md_personality *pers;
8153 : 0 : seq_printf(seq, "Personalities : ");
8154 : 0 : spin_lock(&pers_lock);
8155 [ # # ]: 0 : list_for_each_entry(pers, &pers_list, list)
8156 : 0 : seq_printf(seq, "[%s] ", pers->name);
8157 : :
8158 : 0 : spin_unlock(&pers_lock);
8159 : 0 : seq_printf(seq, "\n");
8160 : 0 : seq->poll_event = atomic_read(&md_event_count);
8161 : 0 : return 0;
8162 : : }
8163 [ # # ]: 0 : if (v == (void*)2) {
8164 : 0 : status_unused(seq);
8165 : 0 : return 0;
8166 : : }
8167 : :
8168 : 0 : spin_lock(&mddev->lock);
8169 [ # # # # : 0 : if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
# # ]
8170 [ # # # # ]: 0 : seq_printf(seq, "%s : %sactive", mdname(mddev),
8171 : : mddev->pers ? "" : "in");
8172 [ # # ]: 0 : if (mddev->pers) {
8173 [ # # ]: 0 : if (mddev->ro==1)
8174 : 0 : seq_printf(seq, " (read-only)");
8175 [ # # ]: 0 : if (mddev->ro==2)
8176 : 0 : seq_printf(seq, " (auto-read-only)");
8177 : 0 : seq_printf(seq, " %s", mddev->pers->name);
8178 : : }
8179 : :
8180 : 0 : sectors = 0;
8181 : 0 : rcu_read_lock();
8182 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev) {
8183 : 0 : char b[BDEVNAME_SIZE];
8184 : 0 : seq_printf(seq, " %s[%d]",
8185 : : bdevname(rdev->bdev,b), rdev->desc_nr);
8186 [ # # ]: 0 : if (test_bit(WriteMostly, &rdev->flags))
8187 : 0 : seq_printf(seq, "(W)");
8188 [ # # ]: 0 : if (test_bit(Journal, &rdev->flags))
8189 : 0 : seq_printf(seq, "(J)");
8190 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags)) {
8191 : 0 : seq_printf(seq, "(F)");
8192 : 0 : continue;
8193 : : }
8194 [ # # ]: 0 : if (rdev->raid_disk < 0)
8195 : 0 : seq_printf(seq, "(S)"); /* spare */
8196 [ # # ]: 0 : if (test_bit(Replacement, &rdev->flags))
8197 : 0 : seq_printf(seq, "(R)");
8198 : 0 : sectors += rdev->sectors;
8199 : : }
8200 : 0 : rcu_read_unlock();
8201 : :
8202 [ # # ]: 0 : if (!list_empty(&mddev->disks)) {
8203 [ # # ]: 0 : if (mddev->pers)
8204 : 0 : seq_printf(seq, "\n %llu blocks",
8205 : : (unsigned long long)
8206 : 0 : mddev->array_sectors / 2);
8207 : : else
8208 : 0 : seq_printf(seq, "\n %llu blocks",
8209 : : (unsigned long long)sectors / 2);
8210 : : }
8211 [ # # ]: 0 : if (mddev->persistent) {
8212 [ # # ]: 0 : if (mddev->major_version != 0 ||
8213 [ # # ]: 0 : mddev->minor_version != 90) {
8214 : 0 : seq_printf(seq," super %d.%d",
8215 : : mddev->major_version,
8216 : : mddev->minor_version);
8217 : : }
8218 [ # # ]: 0 : } else if (mddev->external)
8219 : 0 : seq_printf(seq, " super external:%s",
8220 : 0 : mddev->metadata_type);
8221 : : else
8222 : 0 : seq_printf(seq, " super non-persistent");
8223 : :
8224 [ # # ]: 0 : if (mddev->pers) {
8225 : 0 : mddev->pers->status(seq, mddev);
8226 : 0 : seq_printf(seq, "\n ");
8227 [ # # ]: 0 : if (mddev->pers->sync_request) {
8228 [ # # ]: 0 : if (status_resync(seq, mddev))
8229 : 0 : seq_printf(seq, "\n ");
8230 : : }
8231 : : } else
8232 : 0 : seq_printf(seq, "\n ");
8233 : :
8234 : 0 : md_bitmap_status(seq, mddev->bitmap);
8235 : :
8236 : 0 : seq_printf(seq, "\n");
8237 : : }
8238 : 0 : spin_unlock(&mddev->lock);
8239 : :
8240 : 0 : return 0;
8241 : : }
8242 : :
8243 : : static const struct seq_operations md_seq_ops = {
8244 : : .start = md_seq_start,
8245 : : .next = md_seq_next,
8246 : : .stop = md_seq_stop,
8247 : : .show = md_seq_show,
8248 : : };
8249 : :
8250 : 0 : static int md_seq_open(struct inode *inode, struct file *file)
8251 : : {
8252 : 0 : struct seq_file *seq;
8253 : 0 : int error;
8254 : :
8255 : 0 : error = seq_open(file, &md_seq_ops);
8256 [ # # ]: 0 : if (error)
8257 : : return error;
8258 : :
8259 : 0 : seq = file->private_data;
8260 : 0 : seq->poll_event = atomic_read(&md_event_count);
8261 : 0 : return error;
8262 : : }
8263 : :
8264 : : static int md_unloading;
8265 : 0 : static __poll_t mdstat_poll(struct file *filp, poll_table *wait)
8266 : : {
8267 : 0 : struct seq_file *seq = filp->private_data;
8268 : 0 : __poll_t mask;
8269 : :
8270 [ # # ]: 0 : if (md_unloading)
8271 : : return EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
8272 [ # # ]: 0 : poll_wait(filp, &md_event_waiters, wait);
8273 : :
8274 : : /* always allow read */
8275 : 0 : mask = EPOLLIN | EPOLLRDNORM;
8276 : :
8277 [ # # ]: 0 : if (seq->poll_event != atomic_read(&md_event_count))
8278 : 0 : mask |= EPOLLERR | EPOLLPRI;
8279 : : return mask;
8280 : : }
8281 : :
8282 : : static const struct proc_ops mdstat_proc_ops = {
8283 : : .proc_open = md_seq_open,
8284 : : .proc_read = seq_read,
8285 : : .proc_lseek = seq_lseek,
8286 : : .proc_release = seq_release,
8287 : : .proc_poll = mdstat_poll,
8288 : : };
8289 : :
8290 : 0 : int register_md_personality(struct md_personality *p)
8291 : : {
8292 : 0 : pr_debug("md: %s personality registered for level %d\n",
8293 : : p->name, p->level);
8294 : 0 : spin_lock(&pers_lock);
8295 : 0 : list_add_tail(&p->list, &pers_list);
8296 : 0 : spin_unlock(&pers_lock);
8297 : 0 : return 0;
8298 : : }
8299 : : EXPORT_SYMBOL(register_md_personality);
8300 : :
8301 : 0 : int unregister_md_personality(struct md_personality *p)
8302 : : {
8303 : 0 : pr_debug("md: %s personality unregistered\n", p->name);
8304 : 0 : spin_lock(&pers_lock);
8305 : 0 : list_del_init(&p->list);
8306 : 0 : spin_unlock(&pers_lock);
8307 : 0 : return 0;
8308 : : }
8309 : : EXPORT_SYMBOL(unregister_md_personality);
8310 : :
8311 : 0 : int register_md_cluster_operations(struct md_cluster_operations *ops,
8312 : : struct module *module)
8313 : : {
8314 : 0 : int ret = 0;
8315 : 0 : spin_lock(&pers_lock);
8316 [ # # ]: 0 : if (md_cluster_ops != NULL)
8317 : : ret = -EALREADY;
8318 : : else {
8319 : 0 : md_cluster_ops = ops;
8320 : 0 : md_cluster_mod = module;
8321 : : }
8322 : 0 : spin_unlock(&pers_lock);
8323 : 0 : return ret;
8324 : : }
8325 : : EXPORT_SYMBOL(register_md_cluster_operations);
8326 : :
8327 : 0 : int unregister_md_cluster_operations(void)
8328 : : {
8329 : 0 : spin_lock(&pers_lock);
8330 : 0 : md_cluster_ops = NULL;
8331 : 0 : spin_unlock(&pers_lock);
8332 : 0 : return 0;
8333 : : }
8334 : : EXPORT_SYMBOL(unregister_md_cluster_operations);
8335 : :
8336 : 0 : int md_setup_cluster(struct mddev *mddev, int nodes)
8337 : : {
8338 [ # # ]: 0 : if (!md_cluster_ops)
8339 : 0 : request_module("md-cluster");
8340 : 0 : spin_lock(&pers_lock);
8341 : : /* ensure module won't be unloaded */
8342 [ # # # # ]: 0 : if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
8343 : 0 : pr_warn("can't find md-cluster module or get it's reference.\n");
8344 : 0 : spin_unlock(&pers_lock);
8345 : 0 : return -ENOENT;
8346 : : }
8347 : 0 : spin_unlock(&pers_lock);
8348 : :
8349 : 0 : return md_cluster_ops->join(mddev, nodes);
8350 : : }
8351 : :
8352 : 0 : void md_cluster_stop(struct mddev *mddev)
8353 : : {
8354 [ # # ]: 0 : if (!md_cluster_ops)
8355 : : return;
8356 : 0 : md_cluster_ops->leave(mddev);
8357 : 0 : module_put(md_cluster_mod);
8358 : : }
8359 : :
8360 : 0 : static int is_mddev_idle(struct mddev *mddev, int init)
8361 : : {
8362 : 0 : struct md_rdev *rdev;
8363 : 0 : int idle;
8364 : 0 : int curr_events;
8365 : :
8366 : 0 : idle = 1;
8367 : 0 : rcu_read_lock();
8368 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev) {
8369 : 0 : struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
8370 [ # # # # : 0 : curr_events = (int)part_stat_read_accum(&disk->part0, sectors) -
# # ]
8371 : 0 : atomic_read(&disk->sync_io);
8372 : : /* sync IO will cause sync_io to increase before the disk_stats
8373 : : * as sync_io is counted when a request starts, and
8374 : : * disk_stats is counted when it completes.
8375 : : * So resync activity will cause curr_events to be smaller than
8376 : : * when there was no such activity.
8377 : : * non-sync IO will cause disk_stat to increase without
8378 : : * increasing sync_io so curr_events will (eventually)
8379 : : * be larger than it was before. Once it becomes
8380 : : * substantially larger, the test below will cause
8381 : : * the array to appear non-idle, and resync will slow
8382 : : * down.
8383 : : * If there is a lot of outstanding resync activity when
8384 : : * we set last_event to curr_events, then all that activity
8385 : : * completing might cause the array to appear non-idle
8386 : : * and resync will be slowed down even though there might
8387 : : * not have been non-resync activity. This will only
8388 : : * happen once though. 'last_events' will soon reflect
8389 : : * the state where there is little or no outstanding
8390 : : * resync requests, and further resync activity will
8391 : : * always make curr_events less than last_events.
8392 : : *
8393 : : */
8394 [ # # # # ]: 0 : if (init || curr_events - rdev->last_events > 64) {
8395 : 0 : rdev->last_events = curr_events;
8396 : 0 : idle = 0;
8397 : : }
8398 : : }
8399 : 0 : rcu_read_unlock();
8400 : 0 : return idle;
8401 : : }
8402 : :
8403 : 0 : void md_done_sync(struct mddev *mddev, int blocks, int ok)
8404 : : {
8405 : : /* another "blocks" (512byte) blocks have been synced */
8406 : 0 : atomic_sub(blocks, &mddev->recovery_active);
8407 : 0 : wake_up(&mddev->recovery_wait);
8408 [ # # ]: 0 : if (!ok) {
8409 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8410 : 0 : set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
8411 : 0 : md_wakeup_thread(mddev->thread);
8412 : : // stop recovery, signal do_sync ....
8413 : : }
8414 : 0 : }
8415 : : EXPORT_SYMBOL(md_done_sync);
8416 : :
8417 : : /* md_write_start(mddev, bi)
8418 : : * If we need to update some array metadata (e.g. 'active' flag
8419 : : * in superblock) before writing, schedule a superblock update
8420 : : * and wait for it to complete.
8421 : : * A return value of 'false' means that the write wasn't recorded
8422 : : * and cannot proceed as the array is being suspend.
8423 : : */
8424 : 0 : bool md_write_start(struct mddev *mddev, struct bio *bi)
8425 : : {
8426 : 0 : int did_change = 0;
8427 : :
8428 [ # # ]: 0 : if (bio_data_dir(bi) != WRITE)
8429 : : return true;
8430 : :
8431 [ # # ]: 0 : BUG_ON(mddev->ro == 1);
8432 [ # # ]: 0 : if (mddev->ro == 2) {
8433 : : /* need to switch to read/write */
8434 : 0 : mddev->ro = 0;
8435 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8436 : 0 : md_wakeup_thread(mddev->thread);
8437 : 0 : md_wakeup_thread(mddev->sync_thread);
8438 : 0 : did_change = 1;
8439 : : }
8440 : 0 : rcu_read_lock();
8441 : 0 : percpu_ref_get(&mddev->writes_pending);
8442 : 0 : smp_mb(); /* Match smp_mb in set_in_sync() */
8443 [ # # ]: 0 : if (mddev->safemode == 1)
8444 : 0 : mddev->safemode = 0;
8445 : : /* sync_checkers is always 0 when writes_pending is in per-cpu mode */
8446 [ # # # # ]: 0 : if (mddev->in_sync || mddev->sync_checkers) {
8447 : 0 : spin_lock(&mddev->lock);
8448 [ # # ]: 0 : if (mddev->in_sync) {
8449 : 0 : mddev->in_sync = 0;
8450 : 0 : set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8451 : 0 : set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
8452 : 0 : md_wakeup_thread(mddev->thread);
8453 : 0 : did_change = 1;
8454 : : }
8455 : 0 : spin_unlock(&mddev->lock);
8456 : : }
8457 : 0 : rcu_read_unlock();
8458 [ # # ]: 0 : if (did_change)
8459 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
8460 [ # # ]: 0 : if (!mddev->has_superblocks)
8461 : : return true;
8462 [ # # # # : 0 : wait_event(mddev->sb_wait,
# # # # ]
8463 : : !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) ||
8464 : : mddev->suspended);
8465 [ # # ]: 0 : if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {
8466 : 0 : percpu_ref_put(&mddev->writes_pending);
8467 : 0 : return false;
8468 : : }
8469 : : return true;
8470 : : }
8471 : : EXPORT_SYMBOL(md_write_start);
8472 : :
8473 : : /* md_write_inc can only be called when md_write_start() has
8474 : : * already been called at least once of the current request.
8475 : : * It increments the counter and is useful when a single request
8476 : : * is split into several parts. Each part causes an increment and
8477 : : * so needs a matching md_write_end().
8478 : : * Unlike md_write_start(), it is safe to call md_write_inc() inside
8479 : : * a spinlocked region.
8480 : : */
8481 : 0 : void md_write_inc(struct mddev *mddev, struct bio *bi)
8482 : : {
8483 [ # # ]: 0 : if (bio_data_dir(bi) != WRITE)
8484 : : return;
8485 [ # # # # : 0 : WARN_ON_ONCE(mddev->in_sync || mddev->ro);
# # ]
8486 : 0 : percpu_ref_get(&mddev->writes_pending);
8487 : : }
8488 : : EXPORT_SYMBOL(md_write_inc);
8489 : :
8490 : 0 : void md_write_end(struct mddev *mddev)
8491 : : {
8492 : 0 : percpu_ref_put(&mddev->writes_pending);
8493 : :
8494 [ # # ]: 0 : if (mddev->safemode == 2)
8495 : 0 : md_wakeup_thread(mddev->thread);
8496 [ # # ]: 0 : else if (mddev->safemode_delay)
8497 : : /* The roundup() ensures this only performs locking once
8498 : : * every ->safemode_delay jiffies
8499 : : */
8500 : 0 : mod_timer(&mddev->safemode_timer,
8501 : 0 : roundup(jiffies, mddev->safemode_delay) +
8502 : : mddev->safemode_delay);
8503 : 0 : }
8504 : :
8505 : : EXPORT_SYMBOL(md_write_end);
8506 : :
8507 : : /* md_allow_write(mddev)
8508 : : * Calling this ensures that the array is marked 'active' so that writes
8509 : : * may proceed without blocking. It is important to call this before
8510 : : * attempting a GFP_KERNEL allocation while holding the mddev lock.
8511 : : * Must be called with mddev_lock held.
8512 : : */
8513 : 0 : void md_allow_write(struct mddev *mddev)
8514 : : {
8515 [ # # ]: 0 : if (!mddev->pers)
8516 : : return;
8517 [ # # ]: 0 : if (mddev->ro)
8518 : : return;
8519 [ # # ]: 0 : if (!mddev->pers->sync_request)
8520 : : return;
8521 : :
8522 : 0 : spin_lock(&mddev->lock);
8523 [ # # ]: 0 : if (mddev->in_sync) {
8524 : 0 : mddev->in_sync = 0;
8525 : 0 : set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8526 : 0 : set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
8527 [ # # ]: 0 : if (mddev->safemode_delay &&
8528 [ # # ]: 0 : mddev->safemode == 0)
8529 : 0 : mddev->safemode = 1;
8530 : 0 : spin_unlock(&mddev->lock);
8531 : 0 : md_update_sb(mddev, 0);
8532 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_state);
8533 : : /* wait for the dirty state to be recorded in the metadata */
8534 [ # # # # ]: 0 : wait_event(mddev->sb_wait,
8535 : : !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
8536 : : } else
8537 : 0 : spin_unlock(&mddev->lock);
8538 : : }
8539 : : EXPORT_SYMBOL_GPL(md_allow_write);
8540 : :
8541 : : #define SYNC_MARKS 10
8542 : : #define SYNC_MARK_STEP (3*HZ)
8543 : : #define UPDATE_FREQUENCY (5*60*HZ)
8544 : 0 : void md_do_sync(struct md_thread *thread)
8545 : : {
8546 : 0 : struct mddev *mddev = thread->mddev;
8547 : 0 : struct mddev *mddev2;
8548 : 0 : unsigned int currspeed = 0, window;
8549 : 0 : sector_t max_sectors,j, io_sectors, recovery_done;
8550 : 0 : unsigned long mark[SYNC_MARKS];
8551 : 0 : unsigned long update_time;
8552 : 0 : sector_t mark_cnt[SYNC_MARKS];
8553 : 0 : int last_mark,m;
8554 : 0 : struct list_head *tmp;
8555 : 0 : sector_t last_check;
8556 : 0 : int skipped = 0;
8557 : 0 : struct md_rdev *rdev;
8558 : 0 : char *desc, *action = NULL;
8559 : 0 : struct blk_plug plug;
8560 : 0 : int ret;
8561 : :
8562 : : /* just incase thread restarts... */
8563 [ # # # # ]: 0 : if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8564 : : test_bit(MD_RECOVERY_WAIT, &mddev->recovery))
8565 : 0 : return;
8566 [ # # ]: 0 : if (mddev->ro) {/* never try to sync a read-only array */
8567 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8568 : 0 : return;
8569 : : }
8570 : :
8571 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
8572 : 0 : ret = md_cluster_ops->resync_start(mddev);
8573 [ # # ]: 0 : if (ret)
8574 : 0 : goto skip;
8575 : :
8576 : 0 : set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);
8577 [ # # # # : 0 : if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
# # ]
8578 : : test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
8579 : : test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
8580 : 0 : && ((unsigned long long)mddev->curr_resync_completed
8581 [ # # ]: 0 : < (unsigned long long)mddev->resync_max_sectors))
8582 : 0 : goto skip;
8583 : : }
8584 : :
8585 [ # # ]: 0 : if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8586 [ # # ]: 0 : if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
8587 : : desc = "data-check";
8588 : : action = "check";
8589 [ # # ]: 0 : } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8590 : : desc = "requested-resync";
8591 : : action = "repair";
8592 : : } else
8593 : : desc = "resync";
8594 [ # # ]: 0 : } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8595 : : desc = "reshape";
8596 : : else
8597 : : desc = "recovery";
8598 : :
8599 : 0 : mddev->last_sync_action = action ?: desc;
8600 : :
8601 : : /* we overload curr_resync somewhat here.
8602 : : * 0 == not engaged in resync at all
8603 : : * 2 == checking that there is no conflict with another sync
8604 : : * 1 == like 2, but have yielded to allow conflicting resync to
8605 : : * commence
8606 : : * other == active in resync - this many blocks
8607 : : *
8608 : : * Before starting a resync we must have set curr_resync to
8609 : : * 2, and then checked that every "conflicting" array has curr_resync
8610 : : * less than ours. When we find one that is the same or higher
8611 : : * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
8612 : : * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
8613 : : * This will mean we have to start checking from the beginning again.
8614 : : *
8615 : : */
8616 : :
8617 : 0 : do {
8618 : 0 : int mddev2_minor = -1;
8619 : 0 : mddev->curr_resync = 2;
8620 : :
8621 : 0 : try_again:
8622 [ # # ]: 0 : if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8623 : 0 : goto skip;
8624 [ # # # # : 0 : for_each_mddev(mddev2, tmp) {
# # ]
8625 [ # # ]: 0 : if (mddev2 == mddev)
8626 : 0 : continue;
8627 [ # # ]: 0 : if (!mddev->parallel_resync
8628 [ # # ]: 0 : && mddev2->curr_resync
8629 [ # # ]: 0 : && match_mddev_units(mddev, mddev2)) {
8630 [ # # ]: 0 : DEFINE_WAIT(wq);
8631 [ # # # # ]: 0 : if (mddev < mddev2 && mddev->curr_resync == 2) {
8632 : : /* arbitrarily yield */
8633 : 0 : mddev->curr_resync = 1;
8634 : 0 : wake_up(&resync_wait);
8635 : : }
8636 [ # # # # ]: 0 : if (mddev > mddev2 && mddev->curr_resync == 1)
8637 : : /* no need to wait here, we can wait the next
8638 : : * time 'round when curr_resync == 2
8639 : : */
8640 : 0 : continue;
8641 : : /* We need to wait 'interruptible' so as not to
8642 : : * contribute to the load average, and not to
8643 : : * be caught by 'softlockup'
8644 : : */
8645 : 0 : prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
8646 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8647 [ # # ]: 0 : mddev2->curr_resync >= mddev->curr_resync) {
8648 [ # # ]: 0 : if (mddev2_minor != mddev2->md_minor) {
8649 : 0 : mddev2_minor = mddev2->md_minor;
8650 [ # # # # ]: 0 : pr_info("md: delaying %s of %s until %s has finished (they share one or more physical units)\n",
8651 : : desc, mdname(mddev),
8652 : : mdname(mddev2));
8653 : : }
8654 : 0 : mddev_put(mddev2);
8655 [ # # ]: 0 : if (signal_pending(current))
8656 : 0 : flush_signals(current);
8657 : 0 : schedule();
8658 : 0 : finish_wait(&resync_wait, &wq);
8659 : 0 : goto try_again;
8660 : : }
8661 : 0 : finish_wait(&resync_wait, &wq);
8662 : : }
8663 : : }
8664 [ # # ]: 0 : } while (mddev->curr_resync < 2);
8665 : :
8666 : 0 : j = 0;
8667 [ # # ]: 0 : if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8668 : : /* resync follows the size requested by the personality,
8669 : : * which defaults to physical size, but can be virtual size
8670 : : */
8671 : 0 : max_sectors = mddev->resync_max_sectors;
8672 : 0 : atomic64_set(&mddev->resync_mismatches, 0);
8673 : : /* we don't use the checkpoint if there's a bitmap */
8674 [ # # ]: 0 : if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8675 : 0 : j = mddev->resync_min;
8676 [ # # ]: 0 : else if (!mddev->bitmap)
8677 : 0 : j = mddev->recovery_cp;
8678 : :
8679 [ # # ]: 0 : } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
8680 : 0 : max_sectors = mddev->resync_max_sectors;
8681 : : /*
8682 : : * If the original node aborts reshaping then we continue the
8683 : : * reshaping, so set j again to avoid restart reshape from the
8684 : : * first beginning
8685 : : */
8686 [ # # ]: 0 : if (mddev_is_clustered(mddev) &&
8687 [ # # ]: 0 : mddev->reshape_position != MaxSector)
8688 : 0 : j = mddev->reshape_position;
8689 : : } else {
8690 : : /* recovery follows the physical size of devices */
8691 : 0 : max_sectors = mddev->dev_sectors;
8692 : 0 : j = MaxSector;
8693 : 0 : rcu_read_lock();
8694 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev)
8695 [ # # # # ]: 0 : if (rdev->raid_disk >= 0 &&
8696 [ # # ]: 0 : !test_bit(Journal, &rdev->flags) &&
8697 [ # # ]: 0 : !test_bit(Faulty, &rdev->flags) &&
8698 : : !test_bit(In_sync, &rdev->flags) &&
8699 : 0 : rdev->recovery_offset < j)
8700 : : j = rdev->recovery_offset;
8701 : 0 : rcu_read_unlock();
8702 : :
8703 : : /* If there is a bitmap, we need to make sure all
8704 : : * writes that started before we added a spare
8705 : : * complete before we start doing a recovery.
8706 : : * Otherwise the write might complete and (via
8707 : : * bitmap_endwrite) set a bit in the bitmap after the
8708 : : * recovery has checked that bit and skipped that
8709 : : * region.
8710 : : */
8711 [ # # ]: 0 : if (mddev->bitmap) {
8712 : 0 : mddev->pers->quiesce(mddev, 1);
8713 : 0 : mddev->pers->quiesce(mddev, 0);
8714 : : }
8715 : : }
8716 : :
8717 [ # # ]: 0 : pr_info("md: %s of RAID array %s\n", desc, mdname(mddev));
8718 : 0 : pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev));
8719 : 0 : pr_debug("md: using maximum available idle IO bandwidth (but not more than %d KB/sec) for %s.\n",
8720 : : speed_max(mddev), desc);
8721 : :
8722 : 0 : is_mddev_idle(mddev, 1); /* this initializes IO event counters */
8723 : :
8724 : 0 : io_sectors = 0;
8725 [ # # ]: 0 : for (m = 0; m < SYNC_MARKS; m++) {
8726 : 0 : mark[m] = jiffies;
8727 : 0 : mark_cnt[m] = io_sectors;
8728 : : }
8729 : 0 : last_mark = 0;
8730 : 0 : mddev->resync_mark = mark[last_mark];
8731 : 0 : mddev->resync_mark_cnt = mark_cnt[last_mark];
8732 : :
8733 : : /*
8734 : : * Tune reconstruction:
8735 : : */
8736 : 0 : window = 32 * (PAGE_SIZE / 512);
8737 : 0 : pr_debug("md: using %dk window, over a total of %lluk.\n",
8738 : : window/2, (unsigned long long)max_sectors/2);
8739 : :
8740 : 0 : atomic_set(&mddev->recovery_active, 0);
8741 : 0 : last_check = 0;
8742 : :
8743 [ # # ]: 0 : if (j>2) {
8744 : 0 : pr_debug("md: resuming %s of %s from checkpoint.\n",
8745 : : desc, mdname(mddev));
8746 : 0 : mddev->curr_resync = j;
8747 : : } else
8748 : 0 : mddev->curr_resync = 3; /* no longer delayed */
8749 : 0 : mddev->curr_resync_completed = j;
8750 : 0 : sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8751 : 0 : md_new_event(mddev);
8752 : 0 : update_time = jiffies;
8753 : :
8754 : 0 : blk_start_plug(&plug);
8755 : 0 : while (j < max_sectors) {
8756 : 0 : sector_t sectors;
8757 : :
8758 : 0 : skipped = 0;
8759 : :
8760 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8761 [ # # ]: 0 : ((mddev->curr_resync > mddev->curr_resync_completed &&
8762 : 0 : (mddev->curr_resync - mddev->curr_resync_completed)
8763 [ # # ]: 0 : > (max_sectors >> 4)) ||
8764 [ # # ]: 0 : time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
8765 : 0 : (j - mddev->curr_resync_completed)*2
8766 [ # # # # ]: 0 : >= mddev->resync_max - mddev->curr_resync_completed ||
8767 : : mddev->curr_resync_completed > mddev->resync_max
8768 : : )) {
8769 : : /* time to update curr_resync_completed */
8770 [ # # # # ]: 0 : wait_event(mddev->recovery_wait,
8771 : : atomic_read(&mddev->recovery_active) == 0);
8772 : 0 : mddev->curr_resync_completed = j;
8773 [ # # ]: 0 : if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
8774 [ # # ]: 0 : j > mddev->recovery_cp)
8775 : 0 : mddev->recovery_cp = j;
8776 : 0 : update_time = jiffies;
8777 : 0 : set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8778 : 0 : sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8779 : : }
8780 : :
8781 [ # # # # ]: 0 : while (j >= mddev->resync_max &&
8782 : : !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8783 : : /* As this condition is controlled by user-space,
8784 : : * we can block indefinitely, so use '_interruptible'
8785 : : * to avoid triggering warnings.
8786 : : */
8787 : 0 : flush_signals(current); /* just in case */
8788 [ # # # # : 0 : wait_event_interruptible(mddev->recovery_wait,
# # # # #
# ]
8789 : : mddev->resync_max > j
8790 : : || test_bit(MD_RECOVERY_INTR,
8791 : : &mddev->recovery));
8792 : : }
8793 : :
8794 [ # # ]: 0 : if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8795 : : break;
8796 : :
8797 : 0 : sectors = mddev->pers->sync_request(mddev, j, &skipped);
8798 [ # # ]: 0 : if (sectors == 0) {
8799 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8800 : 0 : break;
8801 : : }
8802 : :
8803 [ # # ]: 0 : if (!skipped) { /* actual IO requested */
8804 : 0 : io_sectors += sectors;
8805 : 0 : atomic_add(sectors, &mddev->recovery_active);
8806 : : }
8807 : :
8808 [ # # ]: 0 : if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8809 : : break;
8810 : :
8811 : 0 : j += sectors;
8812 : 0 : if (j > max_sectors)
8813 : : /* when skipping, extra large numbers can be returned. */
8814 : : j = max_sectors;
8815 [ # # ]: 0 : if (j > 2)
8816 : 0 : mddev->curr_resync = j;
8817 : 0 : mddev->curr_mark_cnt = io_sectors;
8818 [ # # ]: 0 : if (last_check == 0)
8819 : : /* this is the earliest that rebuild will be
8820 : : * visible in /proc/mdstat
8821 : : */
8822 : 0 : md_new_event(mddev);
8823 : :
8824 [ # # # # ]: 0 : if (last_check + window > io_sectors || j == max_sectors)
8825 : 0 : continue;
8826 : :
8827 : : last_check = io_sectors;
8828 : 0 : repeat:
8829 [ # # ]: 0 : if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
8830 : : /* step marks */
8831 : 0 : int next = (last_mark+1) % SYNC_MARKS;
8832 : :
8833 : 0 : mddev->resync_mark = mark[next];
8834 : 0 : mddev->resync_mark_cnt = mark_cnt[next];
8835 : 0 : mark[next] = jiffies;
8836 : 0 : mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
8837 : 0 : last_mark = next;
8838 : : }
8839 : :
8840 [ # # ]: 0 : if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8841 : : break;
8842 : :
8843 : : /*
8844 : : * this loop exits only if either when we are slower than
8845 : : * the 'hard' speed limit, or the system was IO-idle for
8846 : : * a jiffy.
8847 : : * the system might be non-idle CPU-wise, but we only care
8848 : : * about not overloading the IO subsystem. (things like an
8849 : : * e2fsck being done on the RAID array should execute fast)
8850 : : */
8851 : 0 : cond_resched();
8852 : :
8853 : 0 : recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
8854 : 0 : currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
8855 : 0 : /((jiffies-mddev->resync_mark)/HZ +1) +1;
8856 : :
8857 [ # # # # ]: 0 : if (currspeed > speed_min(mddev)) {
8858 [ # # # # ]: 0 : if (currspeed > speed_max(mddev)) {
8859 : 0 : msleep(500);
8860 : 0 : goto repeat;
8861 : : }
8862 [ # # ]: 0 : if (!is_mddev_idle(mddev, 0)) {
8863 : : /*
8864 : : * Give other IO more of a chance.
8865 : : * The faster the devices, the less we wait.
8866 : : */
8867 [ # # # # : 0 : wait_event(mddev->recovery_wait,
# # ]
8868 : : !atomic_read(&mddev->recovery_active));
8869 : : }
8870 : : }
8871 : : }
8872 [ # # # # ]: 0 : pr_info("md: %s: %s %s.\n",mdname(mddev), desc,
8873 : : test_bit(MD_RECOVERY_INTR, &mddev->recovery)
8874 : : ? "interrupted" : "done");
8875 : : /*
8876 : : * this also signals 'finished resyncing' to md_stop
8877 : : */
8878 : 0 : blk_finish_plug(&plug);
8879 [ # # # # ]: 0 : wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
8880 : :
8881 [ # # # # ]: 0 : if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8882 : 0 : !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8883 [ # # ]: 0 : mddev->curr_resync > 3) {
8884 : 0 : mddev->curr_resync_completed = mddev->curr_resync;
8885 : 0 : sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8886 : : }
8887 : 0 : mddev->pers->sync_request(mddev, max_sectors, &skipped);
8888 : :
8889 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
8890 [ # # ]: 0 : mddev->curr_resync > 3) {
8891 [ # # ]: 0 : if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8892 [ # # ]: 0 : if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8893 [ # # ]: 0 : if (mddev->curr_resync >= mddev->recovery_cp) {
8894 : 0 : pr_debug("md: checkpointing %s of %s.\n",
8895 : : desc, mdname(mddev));
8896 [ # # ]: 0 : if (test_bit(MD_RECOVERY_ERROR,
8897 : : &mddev->recovery))
8898 : 0 : mddev->recovery_cp =
8899 : 0 : mddev->curr_resync_completed;
8900 : : else
8901 : 0 : mddev->recovery_cp =
8902 : 0 : mddev->curr_resync;
8903 : : }
8904 : : } else
8905 : 0 : mddev->recovery_cp = MaxSector;
8906 : : } else {
8907 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8908 : 0 : mddev->curr_resync = MaxSector;
8909 [ # # # # ]: 0 : if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8910 : : test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) {
8911 : 0 : rcu_read_lock();
8912 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev)
8913 [ # # ]: 0 : if (rdev->raid_disk >= 0 &&
8914 [ # # # # ]: 0 : mddev->delta_disks >= 0 &&
8915 [ # # ]: 0 : !test_bit(Journal, &rdev->flags) &&
8916 [ # # ]: 0 : !test_bit(Faulty, &rdev->flags) &&
8917 : 0 : !test_bit(In_sync, &rdev->flags) &&
8918 [ # # ]: 0 : rdev->recovery_offset < mddev->curr_resync)
8919 : 0 : rdev->recovery_offset = mddev->curr_resync;
8920 : 0 : rcu_read_unlock();
8921 : : }
8922 : : }
8923 : : }
8924 : 0 : skip:
8925 : : /* set CHANGE_PENDING here since maybe another update is needed,
8926 : : * so other nodes are informed. It should be harmless for normal
8927 : : * raid */
8928 [ # # ]: 0 : set_mask_bits(&mddev->sb_flags, 0,
8929 : : BIT(MD_SB_CHANGE_PENDING) | BIT(MD_SB_CHANGE_DEVS));
8930 : :
8931 [ # # # # ]: 0 : if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8932 : 0 : !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8933 [ # # ]: 0 : mddev->delta_disks > 0 &&
8934 [ # # ]: 0 : mddev->pers->finish_reshape &&
8935 [ # # ]: 0 : mddev->pers->size &&
8936 [ # # ]: 0 : mddev->queue) {
8937 : 0 : mddev_lock_nointr(mddev);
8938 : 0 : md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
8939 : 0 : mddev_unlock(mddev);
8940 [ # # ]: 0 : if (!mddev_is_clustered(mddev)) {
8941 : 0 : set_capacity(mddev->gendisk, mddev->array_sectors);
8942 : 0 : revalidate_disk(mddev->gendisk);
8943 : : }
8944 : : }
8945 : :
8946 : 0 : spin_lock(&mddev->lock);
8947 [ # # ]: 0 : if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8948 : : /* We completed so min/max setting can be forgotten if used. */
8949 [ # # ]: 0 : if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8950 : 0 : mddev->resync_min = 0;
8951 : 0 : mddev->resync_max = MaxSector;
8952 [ # # ]: 0 : } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8953 : 0 : mddev->resync_min = mddev->curr_resync_completed;
8954 : 0 : set_bit(MD_RECOVERY_DONE, &mddev->recovery);
8955 : 0 : mddev->curr_resync = 0;
8956 : 0 : spin_unlock(&mddev->lock);
8957 : :
8958 : 0 : wake_up(&resync_wait);
8959 : 0 : md_wakeup_thread(mddev->thread);
8960 : 0 : return;
8961 : : }
8962 : : EXPORT_SYMBOL_GPL(md_do_sync);
8963 : :
8964 : 0 : static int remove_and_add_spares(struct mddev *mddev,
8965 : : struct md_rdev *this)
8966 : : {
8967 : 0 : struct md_rdev *rdev;
8968 : 0 : int spares = 0;
8969 : 0 : int removed = 0;
8970 : 0 : bool remove_some = false;
8971 : :
8972 [ # # # # ]: 0 : if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
8973 : : /* Mustn't remove devices when resync thread is running */
8974 : : return 0;
8975 : :
8976 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
8977 [ # # ]: 0 : if ((this == NULL || rdev == this) &&
8978 [ # # # # ]: 0 : rdev->raid_disk >= 0 &&
8979 [ # # ]: 0 : !test_bit(Blocked, &rdev->flags) &&
8980 [ # # ]: 0 : test_bit(Faulty, &rdev->flags) &&
8981 : 0 : atomic_read(&rdev->nr_pending)==0) {
8982 : : /* Faulty non-Blocked devices with nr_pending == 0
8983 : : * never get nr_pending incremented,
8984 : : * never get Faulty cleared, and never get Blocked set.
8985 : : * So we can synchronize_rcu now rather than once per device
8986 : : */
8987 : 0 : remove_some = true;
8988 : 0 : set_bit(RemoveSynchronized, &rdev->flags);
8989 : : }
8990 : : }
8991 : :
8992 [ # # ]: 0 : if (remove_some)
8993 : 0 : synchronize_rcu();
8994 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
8995 [ # # ]: 0 : if ((this == NULL || rdev == this) &&
8996 [ # # # # ]: 0 : rdev->raid_disk >= 0 &&
8997 [ # # ]: 0 : !test_bit(Blocked, &rdev->flags) &&
8998 [ # # ]: 0 : ((test_bit(RemoveSynchronized, &rdev->flags) ||
8999 [ # # ]: 0 : (!test_bit(In_sync, &rdev->flags) &&
9000 [ # # ]: 0 : !test_bit(Journal, &rdev->flags))) &&
9001 : 0 : atomic_read(&rdev->nr_pending)==0)) {
9002 [ # # ]: 0 : if (mddev->pers->hot_remove_disk(
9003 : : mddev, rdev) == 0) {
9004 : 0 : sysfs_unlink_rdev(mddev, rdev);
9005 : 0 : rdev->saved_raid_disk = rdev->raid_disk;
9006 : 0 : rdev->raid_disk = -1;
9007 : 0 : removed++;
9008 : : }
9009 : : }
9010 [ # # # # ]: 0 : if (remove_some && test_bit(RemoveSynchronized, &rdev->flags))
9011 : 0 : clear_bit(RemoveSynchronized, &rdev->flags);
9012 : : }
9013 : :
9014 [ # # # # ]: 0 : if (removed && mddev->kobj.sd)
9015 : 0 : sysfs_notify(&mddev->kobj, NULL, "degraded");
9016 : :
9017 [ # # ]: 0 : if (this && removed)
9018 : 0 : goto no_add;
9019 : :
9020 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
9021 [ # # ]: 0 : if (this && this != rdev)
9022 : 0 : continue;
9023 [ # # ]: 0 : if (test_bit(Candidate, &rdev->flags))
9024 : 0 : continue;
9025 [ # # # # ]: 0 : if (rdev->raid_disk >= 0 &&
9026 [ # # ]: 0 : !test_bit(In_sync, &rdev->flags) &&
9027 [ # # ]: 0 : !test_bit(Journal, &rdev->flags) &&
9028 : : !test_bit(Faulty, &rdev->flags))
9029 : 0 : spares++;
9030 [ # # ]: 0 : if (rdev->raid_disk >= 0)
9031 : 0 : continue;
9032 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
9033 : 0 : continue;
9034 [ # # ]: 0 : if (!test_bit(Journal, &rdev->flags)) {
9035 [ # # ]: 0 : if (mddev->ro &&
9036 [ # # # # ]: 0 : ! (rdev->saved_raid_disk >= 0 &&
9037 : : !test_bit(Bitmap_sync, &rdev->flags)))
9038 : 0 : continue;
9039 : :
9040 : 0 : rdev->recovery_offset = 0;
9041 : : }
9042 [ # # ]: 0 : if (mddev->pers->
9043 : : hot_add_disk(mddev, rdev) == 0) {
9044 : 0 : if (sysfs_link_rdev(mddev, rdev))
9045 : : /* failure here is OK */;
9046 [ # # ]: 0 : if (!test_bit(Journal, &rdev->flags))
9047 : 0 : spares++;
9048 : 0 : md_new_event(mddev);
9049 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9050 : : }
9051 : : }
9052 : 0 : no_add:
9053 [ # # ]: 0 : if (removed)
9054 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9055 : : return spares;
9056 : : }
9057 : :
9058 : 0 : static void md_start_sync(struct work_struct *ws)
9059 : : {
9060 : 0 : struct mddev *mddev = container_of(ws, struct mddev, del_work);
9061 : :
9062 : 0 : mddev->sync_thread = md_register_thread(md_do_sync,
9063 : : mddev,
9064 : : "resync");
9065 [ # # ]: 0 : if (!mddev->sync_thread) {
9066 [ # # ]: 0 : pr_warn("%s: could not start resync thread...\n",
9067 : : mdname(mddev));
9068 : : /* leave the spares where they are, it shouldn't hurt */
9069 : 0 : clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9070 : 0 : clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9071 : 0 : clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9072 : 0 : clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9073 : 0 : clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9074 : 0 : wake_up(&resync_wait);
9075 [ # # ]: 0 : if (test_and_clear_bit(MD_RECOVERY_RECOVER,
9076 : : &mddev->recovery))
9077 [ # # ]: 0 : if (mddev->sysfs_action)
9078 : 0 : sysfs_notify_dirent_safe(mddev->sysfs_action);
9079 : : } else
9080 : 0 : md_wakeup_thread(mddev->sync_thread);
9081 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_action);
9082 : 0 : md_new_event(mddev);
9083 : 0 : }
9084 : :
9085 : : /*
9086 : : * This routine is regularly called by all per-raid-array threads to
9087 : : * deal with generic issues like resync and super-block update.
9088 : : * Raid personalities that don't have a thread (linear/raid0) do not
9089 : : * need this as they never do any recovery or update the superblock.
9090 : : *
9091 : : * It does not do any resync itself, but rather "forks" off other threads
9092 : : * to do that as needed.
9093 : : * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
9094 : : * "->recovery" and create a thread at ->sync_thread.
9095 : : * When the thread finishes it sets MD_RECOVERY_DONE
9096 : : * and wakeups up this thread which will reap the thread and finish up.
9097 : : * This thread also removes any faulty devices (with nr_pending == 0).
9098 : : *
9099 : : * The overall approach is:
9100 : : * 1/ if the superblock needs updating, update it.
9101 : : * 2/ If a recovery thread is running, don't do anything else.
9102 : : * 3/ If recovery has finished, clean up, possibly marking spares active.
9103 : : * 4/ If there are any faulty devices, remove them.
9104 : : * 5/ If array is degraded, try to add spares devices
9105 : : * 6/ If array has spares or is not in-sync, start a resync thread.
9106 : : */
9107 : 0 : void md_check_recovery(struct mddev *mddev)
9108 : : {
9109 [ # # # # ]: 0 : if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags) && mddev->sb_flags) {
9110 : : /* Write superblock - thread that called mddev_suspend()
9111 : : * holds reconfig_mutex for us.
9112 : : */
9113 : 0 : set_bit(MD_UPDATING_SB, &mddev->flags);
9114 : 0 : smp_mb__after_atomic();
9115 [ # # ]: 0 : if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags))
9116 : 0 : md_update_sb(mddev, 0);
9117 : 0 : clear_bit_unlock(MD_UPDATING_SB, &mddev->flags);
9118 : 0 : wake_up(&mddev->sb_wait);
9119 : : }
9120 : :
9121 [ # # ]: 0 : if (mddev->suspended)
9122 : : return;
9123 : :
9124 [ # # ]: 0 : if (mddev->bitmap)
9125 : 0 : md_bitmap_daemon_work(mddev);
9126 : :
9127 [ # # ]: 0 : if (signal_pending(current)) {
9128 [ # # # # ]: 0 : if (mddev->pers->sync_request && !mddev->external) {
9129 : 0 : pr_debug("md: %s in immediate safe mode\n",
9130 : : mdname(mddev));
9131 : 0 : mddev->safemode = 2;
9132 : : }
9133 : 0 : flush_signals(current);
9134 : : }
9135 : :
9136 [ # # # # ]: 0 : if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
9137 : : return;
9138 : 0 : if ( ! (
9139 [ # # # # ]: 0 : (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) ||
9140 [ # # ]: 0 : test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9141 : 0 : test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
9142 [ # # # # ]: 0 : (mddev->external == 0 && mddev->safemode == 1) ||
9143 [ # # ]: 0 : (mddev->safemode == 2
9144 [ # # # # ]: 0 : && !mddev->in_sync && mddev->recovery_cp == MaxSector)
9145 : : ))
9146 : : return;
9147 : :
9148 [ # # ]: 0 : if (mddev_trylock(mddev)) {
9149 : 0 : int spares = 0;
9150 : 0 : bool try_set_sync = mddev->safemode != 0;
9151 : :
9152 [ # # # # ]: 0 : if (!mddev->external && mddev->safemode == 1)
9153 : 0 : mddev->safemode = 0;
9154 : :
9155 [ # # ]: 0 : if (mddev->ro) {
9156 : 0 : struct md_rdev *rdev;
9157 [ # # # # ]: 0 : if (!mddev->external && mddev->in_sync)
9158 : : /* 'Blocked' flag not needed as failed devices
9159 : : * will be recorded if array switched to read/write.
9160 : : * Leaving it set will prevent the device
9161 : : * from being removed.
9162 : : */
9163 [ # # ]: 0 : rdev_for_each(rdev, mddev)
9164 : 0 : clear_bit(Blocked, &rdev->flags);
9165 : : /* On a read-only array we can:
9166 : : * - remove failed devices
9167 : : * - add already-in_sync devices if the array itself
9168 : : * is in-sync.
9169 : : * As we only add devices that are already in-sync,
9170 : : * we can activate the spares immediately.
9171 : : */
9172 : 0 : remove_and_add_spares(mddev, NULL);
9173 : : /* There is no thread, but we need to call
9174 : : * ->spare_active and clear saved_raid_disk
9175 : : */
9176 : 0 : set_bit(MD_RECOVERY_INTR, &mddev->recovery);
9177 : 0 : md_reap_sync_thread(mddev);
9178 : 0 : clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9179 : 0 : clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9180 : 0 : clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
9181 : 0 : goto unlock;
9182 : : }
9183 : :
9184 [ # # ]: 0 : if (mddev_is_clustered(mddev)) {
9185 : 0 : struct md_rdev *rdev;
9186 : : /* kick the device if another node issued a
9187 : : * remove disk.
9188 : : */
9189 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
9190 [ # # ]: 0 : if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
9191 [ # # ]: 0 : rdev->raid_disk < 0)
9192 : 0 : md_kick_rdev_from_array(rdev);
9193 : : }
9194 : : }
9195 : :
9196 [ # # # # : 0 : if (try_set_sync && !mddev->external && !mddev->in_sync) {
# # ]
9197 : 0 : spin_lock(&mddev->lock);
9198 : 0 : set_in_sync(mddev);
9199 : 0 : spin_unlock(&mddev->lock);
9200 : : }
9201 : :
9202 [ # # ]: 0 : if (mddev->sb_flags)
9203 : 0 : md_update_sb(mddev, 0);
9204 : :
9205 [ # # # # ]: 0 : if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
9206 : : !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
9207 : : /* resync/recovery still happening */
9208 : 0 : clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9209 : 0 : goto unlock;
9210 : : }
9211 [ # # ]: 0 : if (mddev->sync_thread) {
9212 : 0 : md_reap_sync_thread(mddev);
9213 : 0 : goto unlock;
9214 : : }
9215 : : /* Set RUNNING before clearing NEEDED to avoid
9216 : : * any transients in the value of "sync_action".
9217 : : */
9218 : 0 : mddev->curr_resync_completed = 0;
9219 : 0 : spin_lock(&mddev->lock);
9220 : 0 : set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9221 : 0 : spin_unlock(&mddev->lock);
9222 : : /* Clear some bits that don't mean anything, but
9223 : : * might be left set
9224 : : */
9225 : 0 : clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
9226 : 0 : clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9227 : :
9228 [ # # # # ]: 0 : if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9229 : : test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
9230 : 0 : goto not_running;
9231 : : /* no recovery is running.
9232 : : * remove any failed drives, then
9233 : : * add spares if possible.
9234 : : * Spares are also removed and re-added, to allow
9235 : : * the personality to fail the re-add.
9236 : : */
9237 : :
9238 [ # # ]: 0 : if (mddev->reshape_position != MaxSector) {
9239 [ # # # # ]: 0 : if (mddev->pers->check_reshape == NULL ||
9240 : 0 : mddev->pers->check_reshape(mddev) != 0)
9241 : : /* Cannot proceed */
9242 : 0 : goto not_running;
9243 : 0 : set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9244 : 0 : clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9245 [ # # ]: 0 : } else if ((spares = remove_and_add_spares(mddev, NULL))) {
9246 : 0 : clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9247 : 0 : clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9248 : 0 : clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9249 : 0 : set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9250 [ # # ]: 0 : } else if (mddev->recovery_cp < MaxSector) {
9251 : 0 : set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9252 : 0 : clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9253 [ # # ]: 0 : } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
9254 : : /* nothing to be done ... */
9255 : 0 : goto not_running;
9256 : :
9257 [ # # ]: 0 : if (mddev->pers->sync_request) {
9258 [ # # ]: 0 : if (spares) {
9259 : : /* We are adding a device or devices to an array
9260 : : * which has the bitmap stored on all devices.
9261 : : * So make sure all bitmap pages get written
9262 : : */
9263 : 0 : md_bitmap_write_all(mddev->bitmap);
9264 : : }
9265 : 0 : INIT_WORK(&mddev->del_work, md_start_sync);
9266 : 0 : queue_work(md_misc_wq, &mddev->del_work);
9267 : 0 : goto unlock;
9268 : : }
9269 : 0 : not_running:
9270 [ # # ]: 0 : if (!mddev->sync_thread) {
9271 : 0 : clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9272 : 0 : wake_up(&resync_wait);
9273 [ # # ]: 0 : if (test_and_clear_bit(MD_RECOVERY_RECOVER,
9274 : : &mddev->recovery))
9275 [ # # ]: 0 : if (mddev->sysfs_action)
9276 : 0 : sysfs_notify_dirent_safe(mddev->sysfs_action);
9277 : : }
9278 : 0 : unlock:
9279 : 0 : wake_up(&mddev->sb_wait);
9280 : 0 : mddev_unlock(mddev);
9281 : : }
9282 : : }
9283 : : EXPORT_SYMBOL(md_check_recovery);
9284 : :
9285 : 0 : void md_reap_sync_thread(struct mddev *mddev)
9286 : : {
9287 : 0 : struct md_rdev *rdev;
9288 : 0 : sector_t old_dev_sectors = mddev->dev_sectors;
9289 : 0 : bool is_reshaped = false;
9290 : :
9291 : : /* resync has finished, collect result */
9292 : 0 : md_unregister_thread(&mddev->sync_thread);
9293 [ # # # # ]: 0 : if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9294 : 0 : !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
9295 [ # # ]: 0 : mddev->degraded != mddev->raid_disks) {
9296 : : /* success...*/
9297 : : /* activate any spares */
9298 [ # # ]: 0 : if (mddev->pers->spare_active(mddev)) {
9299 : 0 : sysfs_notify(&mddev->kobj, NULL,
9300 : : "degraded");
9301 : 0 : set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9302 : : }
9303 : : }
9304 [ # # ]: 0 : if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9305 [ # # ]: 0 : mddev->pers->finish_reshape) {
9306 : 0 : mddev->pers->finish_reshape(mddev);
9307 [ # # ]: 0 : if (mddev_is_clustered(mddev))
9308 : : is_reshaped = true;
9309 : : }
9310 : :
9311 : : /* If array is no-longer degraded, then any saved_raid_disk
9312 : : * information must be scrapped.
9313 : : */
9314 [ # # ]: 0 : if (!mddev->degraded)
9315 [ # # ]: 0 : rdev_for_each(rdev, mddev)
9316 : 0 : rdev->saved_raid_disk = -1;
9317 : :
9318 : 0 : md_update_sb(mddev, 1);
9319 : : /* MD_SB_CHANGE_PENDING should be cleared by md_update_sb, so we can
9320 : : * call resync_finish here if MD_CLUSTER_RESYNC_LOCKED is set by
9321 : : * clustered raid */
9322 [ # # ]: 0 : if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags))
9323 : 0 : md_cluster_ops->resync_finish(mddev);
9324 : 0 : clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9325 : 0 : clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9326 : 0 : clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9327 : 0 : clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9328 : 0 : clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9329 : 0 : clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9330 : : /*
9331 : : * We call md_cluster_ops->update_size here because sync_size could
9332 : : * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared,
9333 : : * so it is time to update size across cluster.
9334 : : */
9335 [ # # # # ]: 0 : if (mddev_is_clustered(mddev) && is_reshaped
9336 [ # # ]: 0 : && !test_bit(MD_CLOSING, &mddev->flags))
9337 : 0 : md_cluster_ops->update_size(mddev, old_dev_sectors);
9338 : 0 : wake_up(&resync_wait);
9339 : : /* flag recovery needed just to double check */
9340 : 0 : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9341 [ # # ]: 0 : sysfs_notify_dirent_safe(mddev->sysfs_action);
9342 : 0 : md_new_event(mddev);
9343 [ # # ]: 0 : if (mddev->event_work.func)
9344 : 0 : queue_work(md_misc_wq, &mddev->event_work);
9345 : 0 : }
9346 : : EXPORT_SYMBOL(md_reap_sync_thread);
9347 : :
9348 : 0 : void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
9349 : : {
9350 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
9351 [ # # # # : 0 : wait_event_timeout(rdev->blocked_wait,
# # # # #
# # # ]
9352 : : !test_bit(Blocked, &rdev->flags) &&
9353 : : !test_bit(BlockedBadBlocks, &rdev->flags),
9354 : : msecs_to_jiffies(5000));
9355 : 0 : rdev_dec_pending(rdev, mddev);
9356 : 0 : }
9357 : : EXPORT_SYMBOL(md_wait_for_blocked_rdev);
9358 : :
9359 : 0 : void md_finish_reshape(struct mddev *mddev)
9360 : : {
9361 : : /* called be personality module when reshape completes. */
9362 : 0 : struct md_rdev *rdev;
9363 : :
9364 [ # # ]: 0 : rdev_for_each(rdev, mddev) {
9365 [ # # ]: 0 : if (rdev->data_offset > rdev->new_data_offset)
9366 : 0 : rdev->sectors += rdev->data_offset - rdev->new_data_offset;
9367 : : else
9368 : 0 : rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
9369 : 0 : rdev->data_offset = rdev->new_data_offset;
9370 : : }
9371 : 0 : }
9372 : : EXPORT_SYMBOL(md_finish_reshape);
9373 : :
9374 : : /* Bad block management */
9375 : :
9376 : : /* Returns 1 on success, 0 on failure */
9377 : 0 : int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
9378 : : int is_new)
9379 : : {
9380 : 0 : struct mddev *mddev = rdev->mddev;
9381 : 0 : int rv;
9382 [ # # ]: 0 : if (is_new)
9383 : 0 : s += rdev->new_data_offset;
9384 : : else
9385 : 0 : s += rdev->data_offset;
9386 : 0 : rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
9387 [ # # ]: 0 : if (rv == 0) {
9388 : : /* Make sure they get written out promptly */
9389 [ # # ]: 0 : if (test_bit(ExternalBbl, &rdev->flags))
9390 : 0 : sysfs_notify(&rdev->kobj, NULL,
9391 : : "unacknowledged_bad_blocks");
9392 [ # # ]: 0 : sysfs_notify_dirent_safe(rdev->sysfs_state);
9393 [ # # ]: 0 : set_mask_bits(&mddev->sb_flags, 0,
9394 : : BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING));
9395 : 0 : md_wakeup_thread(rdev->mddev->thread);
9396 : 0 : return 1;
9397 : : } else
9398 : : return 0;
9399 : : }
9400 : : EXPORT_SYMBOL_GPL(rdev_set_badblocks);
9401 : :
9402 : 0 : int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
9403 : : int is_new)
9404 : : {
9405 : 0 : int rv;
9406 [ # # ]: 0 : if (is_new)
9407 : 0 : s += rdev->new_data_offset;
9408 : : else
9409 : 0 : s += rdev->data_offset;
9410 : 0 : rv = badblocks_clear(&rdev->badblocks, s, sectors);
9411 [ # # # # ]: 0 : if ((rv == 0) && test_bit(ExternalBbl, &rdev->flags))
9412 : 0 : sysfs_notify(&rdev->kobj, NULL, "bad_blocks");
9413 : 0 : return rv;
9414 : : }
9415 : : EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
9416 : :
9417 : 0 : static int md_notify_reboot(struct notifier_block *this,
9418 : : unsigned long code, void *x)
9419 : : {
9420 : 0 : struct list_head *tmp;
9421 : 0 : struct mddev *mddev;
9422 : 0 : int need_delay = 0;
9423 : :
9424 [ # # # # : 0 : for_each_mddev(mddev, tmp) {
# # ]
9425 [ # # ]: 0 : if (mddev_trylock(mddev)) {
9426 [ # # ]: 0 : if (mddev->pers)
9427 : 0 : __md_stop_writes(mddev);
9428 [ # # ]: 0 : if (mddev->persistent)
9429 : 0 : mddev->safemode = 2;
9430 : 0 : mddev_unlock(mddev);
9431 : : }
9432 : 0 : need_delay = 1;
9433 : : }
9434 : : /*
9435 : : * certain more exotic SCSI devices are known to be
9436 : : * volatile wrt too early system reboots. While the
9437 : : * right place to handle this issue is the given
9438 : : * driver, we do want to have a safe RAID driver ...
9439 : : */
9440 [ # # ]: 0 : if (need_delay)
9441 [ # # ]: 0 : mdelay(1000*1);
9442 : :
9443 : 0 : return NOTIFY_DONE;
9444 : : }
9445 : :
9446 : : static struct notifier_block md_notifier = {
9447 : : .notifier_call = md_notify_reboot,
9448 : : .next = NULL,
9449 : : .priority = INT_MAX, /* before any real devices */
9450 : : };
9451 : :
9452 : 13 : static void md_geninit(void)
9453 : : {
9454 : 13 : pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
9455 : :
9456 : 13 : proc_create("mdstat", S_IRUGO, NULL, &mdstat_proc_ops);
9457 : : }
9458 : :
9459 : 13 : static int __init md_init(void)
9460 : : {
9461 : 13 : int ret = -ENOMEM;
9462 : :
9463 : 13 : md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
9464 [ - + ]: 13 : if (!md_wq)
9465 : 0 : goto err_wq;
9466 : :
9467 : 13 : md_misc_wq = alloc_workqueue("md_misc", 0, 0);
9468 [ - + ]: 13 : if (!md_misc_wq)
9469 : 0 : goto err_misc_wq;
9470 : :
9471 [ - + ]: 13 : if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
9472 : 0 : goto err_md;
9473 : :
9474 [ - + ]: 13 : if ((ret = register_blkdev(0, "mdp")) < 0)
9475 : 0 : goto err_mdp;
9476 : 13 : mdp_major = ret;
9477 : :
9478 : 13 : blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
9479 : : md_probe, NULL, NULL);
9480 : 13 : blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
9481 : : md_probe, NULL, NULL);
9482 : :
9483 : 13 : register_reboot_notifier(&md_notifier);
9484 : 13 : raid_table_header = register_sysctl_table(raid_root_table);
9485 : :
9486 : 13 : md_geninit();
9487 : 13 : return 0;
9488 : :
9489 : : err_mdp:
9490 : 0 : unregister_blkdev(MD_MAJOR, "md");
9491 : 0 : err_md:
9492 : 0 : destroy_workqueue(md_misc_wq);
9493 : 0 : err_misc_wq:
9494 : 0 : destroy_workqueue(md_wq);
9495 : : err_wq:
9496 : : return ret;
9497 : : }
9498 : :
9499 : : static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
9500 : : {
9501 : : struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
9502 : : struct md_rdev *rdev2;
9503 : : int role, ret;
9504 : : char b[BDEVNAME_SIZE];
9505 : :
9506 : : /*
9507 : : * If size is changed in another node then we need to
9508 : : * do resize as well.
9509 : : */
9510 : : if (mddev->dev_sectors != le64_to_cpu(sb->size)) {
9511 : : ret = mddev->pers->resize(mddev, le64_to_cpu(sb->size));
9512 : : if (ret)
9513 : : pr_info("md-cluster: resize failed\n");
9514 : : else
9515 : : md_bitmap_update_sb(mddev->bitmap);
9516 : : }
9517 : :
9518 : : /* Check for change of roles in the active devices */
9519 : : rdev_for_each(rdev2, mddev) {
9520 : : if (test_bit(Faulty, &rdev2->flags))
9521 : : continue;
9522 : :
9523 : : /* Check if the roles changed */
9524 : : role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
9525 : :
9526 : : if (test_bit(Candidate, &rdev2->flags)) {
9527 : : if (role == 0xfffe) {
9528 : : pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
9529 : : md_kick_rdev_from_array(rdev2);
9530 : : continue;
9531 : : }
9532 : : else
9533 : : clear_bit(Candidate, &rdev2->flags);
9534 : : }
9535 : :
9536 : : if (role != rdev2->raid_disk) {
9537 : : /*
9538 : : * got activated except reshape is happening.
9539 : : */
9540 : : if (rdev2->raid_disk == -1 && role != 0xffff &&
9541 : : !(le32_to_cpu(sb->feature_map) &
9542 : : MD_FEATURE_RESHAPE_ACTIVE)) {
9543 : : rdev2->saved_raid_disk = role;
9544 : : ret = remove_and_add_spares(mddev, rdev2);
9545 : : pr_info("Activated spare: %s\n",
9546 : : bdevname(rdev2->bdev,b));
9547 : : /* wakeup mddev->thread here, so array could
9548 : : * perform resync with the new activated disk */
9549 : : set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9550 : : md_wakeup_thread(mddev->thread);
9551 : : }
9552 : : /* device faulty
9553 : : * We just want to do the minimum to mark the disk
9554 : : * as faulty. The recovery is performed by the
9555 : : * one who initiated the error.
9556 : : */
9557 : : if ((role == 0xfffe) || (role == 0xfffd)) {
9558 : : md_error(mddev, rdev2);
9559 : : clear_bit(Blocked, &rdev2->flags);
9560 : : }
9561 : : }
9562 : : }
9563 : :
9564 : : if (mddev->raid_disks != le32_to_cpu(sb->raid_disks))
9565 : : update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
9566 : :
9567 : : /*
9568 : : * Since mddev->delta_disks has already updated in update_raid_disks,
9569 : : * so it is time to check reshape.
9570 : : */
9571 : : if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
9572 : : (le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
9573 : : /*
9574 : : * reshape is happening in the remote node, we need to
9575 : : * update reshape_position and call start_reshape.
9576 : : */
9577 : : mddev->reshape_position = le64_to_cpu(sb->reshape_position);
9578 : : if (mddev->pers->update_reshape_pos)
9579 : : mddev->pers->update_reshape_pos(mddev);
9580 : : if (mddev->pers->start_reshape)
9581 : : mddev->pers->start_reshape(mddev);
9582 : : } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
9583 : : mddev->reshape_position != MaxSector &&
9584 : : !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
9585 : : /* reshape is just done in another node. */
9586 : : mddev->reshape_position = MaxSector;
9587 : : if (mddev->pers->update_reshape_pos)
9588 : : mddev->pers->update_reshape_pos(mddev);
9589 : : }
9590 : :
9591 : : /* Finally set the event to be up to date */
9592 : : mddev->events = le64_to_cpu(sb->events);
9593 : : }
9594 : :
9595 : 0 : static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
9596 : : {
9597 : 0 : int err;
9598 : 0 : struct page *swapout = rdev->sb_page;
9599 : 0 : struct mdp_superblock_1 *sb;
9600 : :
9601 : : /* Store the sb page of the rdev in the swapout temporary
9602 : : * variable in case we err in the future
9603 : : */
9604 : 0 : rdev->sb_page = NULL;
9605 : 0 : err = alloc_disk_sb(rdev);
9606 : 0 : if (err == 0) {
9607 [ # # ]: 0 : ClearPageUptodate(rdev->sb_page);
9608 : 0 : rdev->sb_loaded = 0;
9609 : 0 : err = super_types[mddev->major_version].
9610 : : load_super(rdev, NULL, mddev->minor_version);
9611 : : }
9612 [ # # ]: 0 : if (err < 0) {
9613 : 0 : pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
9614 : : __func__, __LINE__, rdev->desc_nr, err);
9615 [ # # ]: 0 : if (rdev->sb_page)
9616 : 0 : put_page(rdev->sb_page);
9617 : 0 : rdev->sb_page = swapout;
9618 : 0 : rdev->sb_loaded = 1;
9619 : 0 : return err;
9620 : : }
9621 : :
9622 [ # # ]: 0 : sb = page_address(rdev->sb_page);
9623 : : /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
9624 : : * is not set
9625 : : */
9626 : :
9627 [ # # ]: 0 : if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
9628 : 0 : rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
9629 : :
9630 : : /* The other node finished recovery, call spare_active to set
9631 : : * device In_sync and mddev->degraded
9632 : : */
9633 [ # # # # ]: 0 : if (rdev->recovery_offset == MaxSector &&
9634 [ # # ]: 0 : !test_bit(In_sync, &rdev->flags) &&
9635 : 0 : mddev->pers->spare_active(mddev))
9636 : 0 : sysfs_notify(&mddev->kobj, NULL, "degraded");
9637 : :
9638 : 0 : put_page(swapout);
9639 : 0 : return 0;
9640 : : }
9641 : :
9642 : 0 : void md_reload_sb(struct mddev *mddev, int nr)
9643 : : {
9644 : 0 : struct md_rdev *rdev;
9645 : 0 : int err;
9646 : :
9647 : : /* Find the rdev */
9648 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev) {
9649 [ # # ]: 0 : if (rdev->desc_nr == nr)
9650 : : break;
9651 : : }
9652 : :
9653 [ # # # # ]: 0 : if (!rdev || rdev->desc_nr != nr) {
9654 : 0 : pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
9655 : 0 : return;
9656 : : }
9657 : :
9658 : 0 : err = read_rdev(mddev, rdev);
9659 [ # # ]: 0 : if (err < 0)
9660 : : return;
9661 : :
9662 : 0 : check_sb_changes(mddev, rdev);
9663 : :
9664 : : /* Read all rdev's to update recovery_offset */
9665 [ # # ]: 0 : rdev_for_each_rcu(rdev, mddev) {
9666 [ # # ]: 0 : if (!test_bit(Faulty, &rdev->flags))
9667 : 0 : read_rdev(mddev, rdev);
9668 : : }
9669 : : }
9670 : : EXPORT_SYMBOL(md_reload_sb);
9671 : :
9672 : : #ifndef MODULE
9673 : :
9674 : : /*
9675 : : * Searches all registered partitions for autorun RAID arrays
9676 : : * at boot time.
9677 : : */
9678 : :
9679 : : static DEFINE_MUTEX(detected_devices_mutex);
9680 : : static LIST_HEAD(all_detected_devices);
9681 : : struct detected_devices_node {
9682 : : struct list_head list;
9683 : : dev_t dev;
9684 : : };
9685 : :
9686 : 0 : void md_autodetect_dev(dev_t dev)
9687 : : {
9688 : 0 : struct detected_devices_node *node_detected_dev;
9689 : :
9690 : 0 : node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
9691 [ # # ]: 0 : if (node_detected_dev) {
9692 : 0 : node_detected_dev->dev = dev;
9693 : 0 : mutex_lock(&detected_devices_mutex);
9694 : 0 : list_add_tail(&node_detected_dev->list, &all_detected_devices);
9695 : 0 : mutex_unlock(&detected_devices_mutex);
9696 : : }
9697 : 0 : }
9698 : :
9699 : 13 : static void autostart_arrays(int part)
9700 : : {
9701 : 13 : struct md_rdev *rdev;
9702 : 13 : struct detected_devices_node *node_detected_dev;
9703 : 13 : dev_t dev;
9704 : 13 : int i_scanned, i_passed;
9705 : :
9706 : 13 : i_scanned = 0;
9707 : 13 : i_passed = 0;
9708 : :
9709 : 13 : pr_info("md: Autodetecting RAID arrays.\n");
9710 : :
9711 : 13 : mutex_lock(&detected_devices_mutex);
9712 [ - + - - ]: 13 : while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
9713 : 0 : i_scanned++;
9714 : 0 : node_detected_dev = list_entry(all_detected_devices.next,
9715 : : struct detected_devices_node, list);
9716 : 0 : list_del(&node_detected_dev->list);
9717 : 0 : dev = node_detected_dev->dev;
9718 : 0 : kfree(node_detected_dev);
9719 : 0 : mutex_unlock(&detected_devices_mutex);
9720 : 0 : rdev = md_import_device(dev,0, 90);
9721 : 0 : mutex_lock(&detected_devices_mutex);
9722 [ # # ]: 0 : if (IS_ERR(rdev))
9723 : 0 : continue;
9724 : :
9725 [ # # ]: 0 : if (test_bit(Faulty, &rdev->flags))
9726 : 0 : continue;
9727 : :
9728 : 0 : set_bit(AutoDetected, &rdev->flags);
9729 : 0 : list_add(&rdev->same_set, &pending_raid_disks);
9730 : 0 : i_passed++;
9731 : : }
9732 : 13 : mutex_unlock(&detected_devices_mutex);
9733 : :
9734 : 13 : pr_debug("md: Scanned %d and added %d devices.\n", i_scanned, i_passed);
9735 : :
9736 : 13 : autorun_devices(part);
9737 : 13 : }
9738 : :
9739 : : #endif /* !MODULE */
9740 : :
9741 : 0 : static __exit void md_exit(void)
9742 : : {
9743 : 0 : struct mddev *mddev;
9744 : 0 : struct list_head *tmp;
9745 : 0 : int delay = 1;
9746 : :
9747 : 0 : blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
9748 : 0 : blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
9749 : :
9750 : 0 : unregister_blkdev(MD_MAJOR,"md");
9751 : 0 : unregister_blkdev(mdp_major, "mdp");
9752 : 0 : unregister_reboot_notifier(&md_notifier);
9753 : 0 : unregister_sysctl_table(raid_table_header);
9754 : :
9755 : : /* We cannot unload the modules while some process is
9756 : : * waiting for us in select() or poll() - wake them up
9757 : : */
9758 : 0 : md_unloading = 1;
9759 [ # # ]: 0 : while (waitqueue_active(&md_event_waiters)) {
9760 : : /* not safe to leave yet */
9761 : 0 : wake_up(&md_event_waiters);
9762 : 0 : msleep(delay);
9763 : 0 : delay += delay;
9764 : : }
9765 : 0 : remove_proc_entry("mdstat", NULL);
9766 : :
9767 [ # # # # : 0 : for_each_mddev(mddev, tmp) {
# # ]
9768 : 0 : export_array(mddev);
9769 : 0 : mddev->ctime = 0;
9770 : 0 : mddev->hold_active = 0;
9771 : : /*
9772 : : * for_each_mddev() will call mddev_put() at the end of each
9773 : : * iteration. As the mddev is now fully clear, this will
9774 : : * schedule the mddev for destruction by a workqueue, and the
9775 : : * destroy_workqueue() below will wait for that to complete.
9776 : : */
9777 : : }
9778 : 0 : destroy_workqueue(md_misc_wq);
9779 : 0 : destroy_workqueue(md_wq);
9780 : 0 : }
9781 : :
9782 : : subsys_initcall(md_init);
9783 : : module_exit(md_exit)
9784 : :
9785 : 0 : static int get_ro(char *buffer, const struct kernel_param *kp)
9786 : : {
9787 : 0 : return sprintf(buffer, "%d", start_readonly);
9788 : : }
9789 : 0 : static int set_ro(const char *val, const struct kernel_param *kp)
9790 : : {
9791 : 0 : return kstrtouint(val, 10, (unsigned int *)&start_readonly);
9792 : : }
9793 : :
9794 : : module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
9795 : : module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
9796 : : module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
9797 : : module_param(create_on_open, bool, S_IRUSR|S_IWUSR);
9798 : :
9799 : : MODULE_LICENSE("GPL");
9800 : : MODULE_DESCRIPTION("MD RAID framework");
9801 : : MODULE_ALIAS("md");
9802 : : MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
|
