~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	md.c : Multiple Devices driver for Linux
3	4	Copyright (C) 1998, 1999, 2000 Ingo Molnar
..	..	@@ -22,14 +23,6 @@
22	23	- persistent bitmap code
23	24	Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
24	25
25		- This program is free software; you can redistribute it and/or modify
26		- it under the terms of the GNU General Public License as published by
27		- the Free Software Foundation; either version 2, or (at your option)
28		- any later version.
29		-
30		- You should have received a copy of the GNU General Public License
31		- (for example /usr/src/linux/COPYING); if not, write to the Free
32		- Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33	26
34	27	Errors, Warnings, etc.
35	28	Please use:
..	..	@@ -44,6 +37,7 @@
44	37
45	38	*/
46	39
	40	+#include <linux/sched/mm.h>
47	41	#include <linux/sched/signal.h>
48	42	#include <linux/kthread.h>
49	43	#include <linux/blkdev.h>
..	..	@@ -64,17 +58,15 @@
64	58	#include <linux/delay.h>
65	59	#include <linux/raid/md_p.h>
66	60	#include <linux/raid/md_u.h>
	61	+#include <linux/raid/detect.h>
67	62	#include <linux/slab.h>
68	63	#include <linux/percpu-refcount.h>
	64	+#include <linux/part_stat.h>
69	65
70	66	#include <trace/events/block.h>
71	67	#include "md.h"
72	68	#include "md-bitmap.h"
73	69	#include "md-cluster.h"
74		-
75		-#ifndef MODULE
76		-static void autostart_arrays(int part);
77		-#endif
78	70
79	71	/* pers_list is a list of registered personalities protected
80	72	* by pers_lock.
..	..	@@ -88,12 +80,12 @@
88	80
89	81	struct md_cluster_operations *md_cluster_ops;
90	82	EXPORT_SYMBOL(md_cluster_ops);
91		-struct module *md_cluster_mod;
92		-EXPORT_SYMBOL(md_cluster_mod);
	83	+static struct module *md_cluster_mod;
93	84
94	85	static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
95	86	static struct workqueue_struct *md_wq;
96	87	static struct workqueue_struct *md_misc_wq;
	88	+static struct workqueue_struct *md_rdev_misc_wq;
97	89
98	90	static int remove_and_add_spares(struct mddev *mddev,
99	91	struct md_rdev *this);
..	..	@@ -105,6 +97,8 @@
105	97	* count by 2 for every hour elapsed between read errors.
106	98	*/
107	99	#define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
	100	+/* Default safemode delay: 200 msec */
	101	+#define DEFAULT_SAFEMODE_DELAY ((200 * HZ)/1000 +1)
108	102	/*
109	103	* Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
110	104	* is 1000 KB/sec, so the extra system load does not show up that much.
..	..	@@ -130,6 +124,168 @@
130	124	{
131	125	return mddev->sync_speed_max ?
132	126	mddev->sync_speed_max : sysctl_speed_limit_max;
	127	+}
	128	+
	129	+static void rdev_uninit_serial(struct md_rdev *rdev)
	130	+{
	131	+ if (!test_and_clear_bit(CollisionCheck, &rdev->flags))
	132	+ return;
	133	+
	134	+ kvfree(rdev->serial);
	135	+ rdev->serial = NULL;
	136	+}
	137	+
	138	+static void rdevs_uninit_serial(struct mddev *mddev)
	139	+{
	140	+ struct md_rdev *rdev;
	141	+
	142	+ rdev_for_each(rdev, mddev)
	143	+ rdev_uninit_serial(rdev);
	144	+}
	145	+
	146	+static int rdev_init_serial(struct md_rdev *rdev)
	147	+{
	148	+ /* serial_nums equals with BARRIER_BUCKETS_NR */
	149	+ int i, serial_nums = 1 << ((PAGE_SHIFT - ilog2(sizeof(atomic_t))));
	150	+ struct serial_in_rdev *serial = NULL;
	151	+
	152	+ if (test_bit(CollisionCheck, &rdev->flags))
	153	+ return 0;
	154	+
	155	+ serial = kvmalloc(sizeof(struct serial_in_rdev) * serial_nums,
	156	+ GFP_KERNEL);
	157	+ if (!serial)
	158	+ return -ENOMEM;
	159	+
	160	+ for (i = 0; i < serial_nums; i++) {
	161	+ struct serial_in_rdev *serial_tmp = &serial[i];
	162	+
	163	+ spin_lock_init(&serial_tmp->serial_lock);
	164	+ serial_tmp->serial_rb = RB_ROOT_CACHED;
	165	+ init_waitqueue_head(&serial_tmp->serial_io_wait);
	166	+ }
	167	+
	168	+ rdev->serial = serial;
	169	+ set_bit(CollisionCheck, &rdev->flags);
	170	+
	171	+ return 0;
	172	+}
	173	+
	174	+static int rdevs_init_serial(struct mddev *mddev)
	175	+{
	176	+ struct md_rdev *rdev;
	177	+ int ret = 0;
	178	+
	179	+ rdev_for_each(rdev, mddev) {
	180	+ ret = rdev_init_serial(rdev);
	181	+ if (ret)
	182	+ break;
	183	+ }
	184	+
	185	+ /* Free all resources if pool is not existed */
	186	+ if (ret && !mddev->serial_info_pool)
	187	+ rdevs_uninit_serial(mddev);
	188	+
	189	+ return ret;
	190	+}
	191	+
	192	+/*
	193	+ * rdev needs to enable serial stuffs if it meets the conditions:
	194	+ * 1. it is multi-queue device flaged with writemostly.
	195	+ * 2. the write-behind mode is enabled.
	196	+ */
	197	+static int rdev_need_serial(struct md_rdev *rdev)
	198	+{
	199	+ return (rdev && rdev->mddev->bitmap_info.max_write_behind > 0 &&
	200	+ rdev->bdev->bd_disk->queue->nr_hw_queues != 1 &&
	201	+ test_bit(WriteMostly, &rdev->flags));
	202	+}
	203	+
	204	+/*
	205	+ * Init resource for rdev(s), then create serial_info_pool if:
	206	+ * 1. rdev is the first device which return true from rdev_enable_serial.
	207	+ * 2. rdev is NULL, means we want to enable serialization for all rdevs.
	208	+ */
	209	+void mddev_create_serial_pool(struct mddev mddev, struct md_rdev rdev,
	210	+ bool is_suspend)
	211	+{
	212	+ int ret = 0;
	213	+
	214	+ if (rdev && !rdev_need_serial(rdev) &&
	215	+ !test_bit(CollisionCheck, &rdev->flags))
	216	+ return;
	217	+
	218	+ if (!is_suspend)
	219	+ mddev_suspend(mddev);
	220	+
	221	+ if (!rdev)
	222	+ ret = rdevs_init_serial(mddev);
	223	+ else
	224	+ ret = rdev_init_serial(rdev);
	225	+ if (ret)
	226	+ goto abort;
	227	+
	228	+ if (mddev->serial_info_pool == NULL) {
	229	+ /*
	230	+ * already in memalloc noio context by
	231	+ * mddev_suspend()
	232	+ */
	233	+ mddev->serial_info_pool =
	234	+ mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
	235	+ sizeof(struct serial_info));
	236	+ if (!mddev->serial_info_pool) {
	237	+ rdevs_uninit_serial(mddev);
	238	+ pr_err("can't alloc memory pool for serialization\n");
	239	+ }
	240	+ }
	241	+
	242	+abort:
	243	+ if (!is_suspend)
	244	+ mddev_resume(mddev);
	245	+}
	246	+
	247	+/*
	248	+ * Free resource from rdev(s), and destroy serial_info_pool under conditions:
	249	+ * 1. rdev is the last device flaged with CollisionCheck.
	250	+ * 2. when bitmap is destroyed while policy is not enabled.
	251	+ * 3. for disable policy, the pool is destroyed only when no rdev needs it.
	252	+ */
	253	+void mddev_destroy_serial_pool(struct mddev mddev, struct md_rdev rdev,
	254	+ bool is_suspend)
	255	+{
	256	+ if (rdev && !test_bit(CollisionCheck, &rdev->flags))
	257	+ return;
	258	+
	259	+ if (mddev->serial_info_pool) {
	260	+ struct md_rdev *temp;
	261	+ int num = 0; /* used to track if other rdevs need the pool */
	262	+
	263	+ if (!is_suspend)
	264	+ mddev_suspend(mddev);
	265	+ rdev_for_each(temp, mddev) {
	266	+ if (!rdev) {
	267	+ if (!mddev->serialize_policy \|\|
	268	+ !rdev_need_serial(temp))
	269	+ rdev_uninit_serial(temp);
	270	+ else
	271	+ num++;
	272	+ } else if (temp != rdev &&
	273	+ test_bit(CollisionCheck, &temp->flags))
	274	+ num++;
	275	+ }
	276	+
	277	+ if (rdev)
	278	+ rdev_uninit_serial(rdev);
	279	+
	280	+ if (num)
	281	+ pr_info("The mempool could be used by other devices\n");
	282	+ else {
	283	+ mempool_destroy(mddev->serial_info_pool);
	284	+ mddev->serial_info_pool = NULL;
	285	+ }
	286	+ if (!is_suspend)
	287	+ mddev_resume(mddev);
	288	+ }
133	289	}
134	290
135	291	static struct ctl_table_header *raid_table_header;
..	..	@@ -172,8 +328,6 @@
172	328	{ }
173	329	};
174	330
175		-static const struct block_device_operations md_fops;
176		-
177	331	static int start_readonly;
178	332
179	333	/*
..	..	@@ -189,15 +343,10 @@
189	343	struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
190	344	struct mddev *mddev)
191	345	{
192		- struct bio *b;
193		-
194	346	if (!mddev \|\| !bioset_initialized(&mddev->bio_set))
195	347	return bio_alloc(gfp_mask, nr_iovecs);
196	348
197		- b = bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
198		- if (!b)
199		- return NULL;
200		- return b;
	349	+ return bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
201	350	}
202	351	EXPORT_SYMBOL_GPL(bio_alloc_mddev);
203	352
..	..	@@ -310,20 +459,25 @@
310	459	}
311	460	EXPORT_SYMBOL(md_handle_request);
312	461
313		-static blk_qc_t md_make_request(struct request_queue q, struct bio bio)
	462	+static blk_qc_t md_submit_bio(struct bio *bio)
314	463	{
315	464	const int rw = bio_data_dir(bio);
316	465	const int sgrp = op_stat_group(bio_op(bio));
317		- struct mddev *mddev = q->queuedata;
	466	+ struct mddev *mddev = bio->bi_disk->private_data;
318	467	unsigned int sectors;
319		- int cpu;
320		-
321		- blk_queue_split(q, &bio);
322	468
323	469	if (mddev == NULL \|\| mddev->pers == NULL) {
324	470	bio_io_error(bio);
325	471	return BLK_QC_T_NONE;
326	472	}
	473	+
	474	+ if (unlikely(test_bit(MD_BROKEN, &mddev->flags)) && (rw == WRITE)) {
	475	+ bio_io_error(bio);
	476	+ return BLK_QC_T_NONE;
	477	+ }
	478	+
	479	+ blk_queue_split(&bio);
	480	+
327	481	if (mddev->ro == 1 && unlikely(rw == WRITE)) {
328	482	if (bio_sectors(bio) != 0)
329	483	bio->bi_status = BLK_STS_IOERR;
..	..	@@ -341,9 +495,9 @@
341	495
342	496	md_handle_request(mddev, bio);
343	497
344		- cpu = part_stat_lock();
345		- part_stat_inc(cpu, &mddev->gendisk->part0, ios[sgrp]);
346		- part_stat_add(cpu, &mddev->gendisk->part0, sectors[sgrp], sectors);
	498	+ part_stat_lock();
	499	+ part_stat_inc(&mddev->gendisk->part0, ios[sgrp]);
	500	+ part_stat_add(&mddev->gendisk->part0, sectors[sgrp], sectors);
347	501	part_stat_unlock();
348	502
349	503	return BLK_QC_T_NONE;
..	..	@@ -371,11 +525,15 @@
371	525	wait_event(mddev->sb_wait, !test_bit(MD_UPDATING_SB, &mddev->flags));
372	526
373	527	del_timer_sync(&mddev->safemode_timer);
	528	+ /* restrict memory reclaim I/O during raid array is suspend */
	529	+ mddev->noio_flag = memalloc_noio_save();
374	530	}
375	531	EXPORT_SYMBOL_GPL(mddev_suspend);
376	532
377	533	void mddev_resume(struct mddev *mddev)
378	534	{
	535	+ /* entred the memalloc scope from mddev_suspend() */
	536	+ memalloc_noio_restore(mddev->noio_flag);
379	537	lockdep_assert_held(&mddev->reconfig_mutex);
380	538	if (--mddev->suspended)
381	539	return;
..	..	@@ -387,26 +545,6 @@
387	545	md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
388	546	}
389	547	EXPORT_SYMBOL_GPL(mddev_resume);
390		-
391		-int mddev_congested(struct mddev *mddev, int bits)
392		-{
393		- struct md_personality *pers = mddev->pers;
394		- int ret = 0;
395		-
396		- rcu_read_lock();
397		- if (mddev->suspended)
398		- ret = 1;
399		- else if (pers && pers->congested)
400		- ret = pers->congested(mddev, bits);
401		- rcu_read_unlock();
402		- return ret;
403		-}
404		-EXPORT_SYMBOL_GPL(mddev_congested);
405		-static int md_congested(void *data, int bits)
406		-{
407		- struct mddev *mddev = data;
408		- return mddev_congested(mddev, bits);
409		-}
410	548
411	549	/*
412	550	* Generic flush handling for md
..	..	@@ -709,7 +847,13 @@
709	847	sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
710	848	if (mddev->sysfs_action)
711	849	sysfs_put(mddev->sysfs_action);
	850	+ if (mddev->sysfs_completed)
	851	+ sysfs_put(mddev->sysfs_completed);
	852	+ if (mddev->sysfs_degraded)
	853	+ sysfs_put(mddev->sysfs_degraded);
712	854	mddev->sysfs_action = NULL;
	855	+ mddev->sysfs_completed = NULL;
	856	+ mddev->sysfs_degraded = NULL;
713	857	}
714	858	}
715	859	mddev->sysfs_active = 0;
..	..	@@ -811,7 +955,8 @@
811	955	struct mddev *mddev = rdev->mddev;
812	956
813	957	if (bio->bi_status) {
814		- pr_err("md: super_written gets error=%d\n", bio->bi_status);
	958	+ pr_err("md: %s gets error=%d\n", __func__,
	959	+ blk_status_to_errno(bio->bi_status));
815	960	md_error(mddev, rdev);
816	961	if (!test_bit(Faulty, &rdev->flags)
817	962	&& (bio->bi_opf & MD_FAILFAST)) {
..	..	@@ -1066,6 +1211,7 @@
1066	1211	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1067	1212	mdp_super_t *sb;
1068	1213	int ret;
	1214	+ bool spare_disk = true;
1069	1215
1070	1216	/*
1071	1217	* Calculate the position of the superblock (512byte sectors),
..	..	@@ -1116,8 +1262,19 @@
1116	1262	else
1117	1263	rdev->desc_nr = sb->this_disk.number;
1118	1264
	1265	+ /* not spare disk, or LEVEL_MULTIPATH */
	1266	+ if (sb->level == LEVEL_MULTIPATH \|\|
	1267	+ (rdev->desc_nr >= 0 &&
	1268	+ rdev->desc_nr < MD_SB_DISKS &&
	1269	+ sb->disks[rdev->desc_nr].state &
	1270	+ ((1<<MD_DISK_SYNC) \| (1 << MD_DISK_ACTIVE))))
	1271	+ spare_disk = false;
	1272	+
1119	1273	if (!refdev) {
1120		- ret = 1;
	1274	+ if (!spare_disk)
	1275	+ ret = 1;
	1276	+ else
	1277	+ ret = 0;
1121	1278	} else {
1122	1279	__u64 ev1, ev2;
1123	1280	mdp_super_t *refsb = page_address(refdev->sb_page);
..	..	@@ -1133,7 +1290,8 @@
1133	1290	}
1134	1291	ev1 = md_event(sb);
1135	1292	ev2 = md_event(refsb);
1136		- if (ev1 > ev2)
	1293	+
	1294	+ if (!spare_disk && ev1 > ev2)
1137	1295	ret = 1;
1138	1296	else
1139	1297	ret = 0;
..	..	@@ -1143,8 +1301,7 @@
1143	1301	* (not needed for Linear and RAID0 as metadata doesn't
1144	1302	* record this size)
1145	1303	*/
1146		- if (IS_ENABLED(CONFIG_LBDAF) && (u64)rdev->sectors >= (2ULL << 32) &&
1147		- sb->level >= 1)
	1304	+ if ((u64)rdev->sectors >= (2ULL << 32) && sb->level >= 1)
1148	1305	rdev->sectors = (sector_t)(2ULL << 32) - 2;
1149	1306
1150	1307	if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
..	..	@@ -1444,8 +1601,7 @@
1444	1601	/* Limit to 4TB as metadata cannot record more than that.
1445	1602	* 4TB == 2^32 KB, or 2*2^32 sectors.
1446	1603	*/
1447		- if (IS_ENABLED(CONFIG_LBDAF) && (u64)num_sectors >= (2ULL << 32) &&
1448		- rdev->mddev->level >= 1)
	1604	+ if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
1449	1605	num_sectors = (sector_t)(2ULL << 32) - 2;
1450	1606	do {
1451	1607	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
..	..	@@ -1495,6 +1651,7 @@
1495	1651	sector_t sectors;
1496	1652	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1497	1653	int bmask;
	1654	+ bool spare_disk = true;
1498	1655
1499	1656	/*
1500	1657	* Calculate the position of the superblock in 512byte sectors.
..	..	@@ -1589,7 +1746,7 @@
1589	1746	*/
1590	1747	s32 offset;
1591	1748	sector_t bb_sector;
1592		- u64 *bbp;
	1749	+ __le64 *bbp;
1593	1750	int i;
1594	1751	int sectors = le16_to_cpu(sb->bblog_size);
1595	1752	if (sectors > (PAGE_SIZE / 512))
..	..	@@ -1601,7 +1758,7 @@
1601	1758	if (!sync_page_io(rdev, bb_sector, sectors << 9,
1602	1759	rdev->bb_page, REQ_OP_READ, 0, true))
1603	1760	return -EIO;
1604		- bbp = (u64 *)page_address(rdev->bb_page);
	1761	+ bbp = (__le64 *)page_address(rdev->bb_page);
1605	1762	rdev->badblocks.shift = sb->bblog_shift;
1606	1763	for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1607	1764	u64 bb = le64_to_cpu(*bbp);
..	..	@@ -1628,8 +1785,19 @@
1628	1785	sb->level != 0)
1629	1786	return -EINVAL;
1630	1787
	1788	+ /* not spare disk, or LEVEL_MULTIPATH */
	1789	+ if (sb->level == cpu_to_le32(LEVEL_MULTIPATH) \|\|
	1790	+ (rdev->desc_nr >= 0 &&
	1791	+ rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
	1792	+ (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX \|\|
	1793	+ le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL)))
	1794	+ spare_disk = false;
	1795	+
1631	1796	if (!refdev) {
1632		- ret = 1;
	1797	+ if (!spare_disk)
	1798	+ ret = 1;
	1799	+ else
	1800	+ ret = 0;
1633	1801	} else {
1634	1802	__u64 ev1, ev2;
1635	1803	struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
..	..	@@ -1646,7 +1814,7 @@
1646	1814	ev1 = le64_to_cpu(sb->events);
1647	1815	ev2 = le64_to_cpu(refsb->events);
1648	1816
1649		- if (ev1 > ev2)
	1817	+ if (!spare_disk && ev1 > ev2)
1650	1818	ret = 1;
1651	1819	else
1652	1820	ret = 0;
..	..	@@ -1928,7 +2096,7 @@
1928	2096	md_error(mddev, rdev);
1929	2097	else {
1930	2098	struct badblocks *bb = &rdev->badblocks;
1931		- u64 bbp = (u64 )page_address(rdev->bb_page);
	2099	+ __le64 bbp = (__le64 )page_address(rdev->bb_page);
1932	2100	u64 *p = bb->page;
1933	2101	sb->feature_map \|= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1934	2102	if (bb->changed) {
..	..	@@ -2003,6 +2171,24 @@
2003	2171	sb->sb_csum = calc_sb_1_csum(sb);
2004	2172	}
2005	2173
	2174	+static sector_t super_1_choose_bm_space(sector_t dev_size)
	2175	+{
	2176	+ sector_t bm_space;
	2177	+
	2178	+ /* if the device is bigger than 8Gig, save 64k for bitmap
	2179	+ * usage, if bigger than 200Gig, save 128k
	2180	+ */
	2181	+ if (dev_size < 64*2)
	2182	+ bm_space = 0;
	2183	+ else if (dev_size - 642 >= 200102410242)
	2184	+ bm_space = 128*2;
	2185	+ else if (dev_size - 42 > 8102410242)
	2186	+ bm_space = 64*2;
	2187	+ else
	2188	+ bm_space = 4*2;
	2189	+ return bm_space;
	2190	+}
	2191	+
2006	2192	static unsigned long long
2007	2193	super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
2008	2194	{
..	..	@@ -2023,10 +2209,20 @@
2023	2209	return 0;
2024	2210	} else {
2025	2211	/* minor version 0; superblock after data */
2026		- sector_t sb_start;
2027		- sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
	2212	+ sector_t sb_start, bm_space;
	2213	+ sector_t dev_size = i_size_read(rdev->bdev->bd_inode) >> 9;
	2214	+
	2215	+ /* 8K is for superblock */
	2216	+ sb_start = dev_size - 8*2;
2028	2217	sb_start &= ~(sector_t)(4*2 - 1);
2029		- max_sectors = rdev->sectors + sb_start - rdev->sb_start;
	2218	+
	2219	+ bm_space = super_1_choose_bm_space(dev_size);
	2220	+
	2221	+ /* Space that can be used to store date needs to decrease
	2222	+ * superblock bitmap space and bad block space(4K)
	2223	+ */
	2224	+ max_sectors = sb_start - bm_space - 4*2;
	2225	+
2030	2226	if (!num_sectors \|\| num_sectors > max_sectors)
2031	2227	num_sectors = max_sectors;
2032	2228	rdev->sb_start = sb_start;
..	..	@@ -2124,8 +2320,7 @@
2124	2320	test_bit(Journal, &rdev2->flags) \|\|
2125	2321	rdev2->raid_disk == -1)
2126	2322	continue;
2127		- if (rdev->bdev->bd_contains ==
2128		- rdev2->bdev->bd_contains) {
	2323	+ if (rdev->bdev->bd_disk == rdev2->bdev->bd_disk) {
2129	2324	rcu_read_unlock();
2130	2325	return 1;
2131	2326	}
..	..	@@ -2193,14 +2388,12 @@
2193	2388	*/
2194	2389	int md_integrity_add_rdev(struct md_rdev rdev, struct mddev mddev)
2195	2390	{
2196		- struct blk_integrity *bi_rdev;
2197	2391	struct blk_integrity *bi_mddev;
2198	2392	char name[BDEVNAME_SIZE];
2199	2393
2200	2394	if (!mddev->gendisk)
2201	2395	return 0;
2202	2396
2203		- bi_rdev = bdev_get_integrity(rdev->bdev);
2204	2397	bi_mddev = blk_get_integrity(mddev->gendisk);
2205	2398
2206	2399	if (!bi_mddev) /* nothing to do */
..	..	@@ -2276,13 +2469,20 @@
2276	2469	rdev->mddev = mddev;
2277	2470	pr_debug("md: bind<%s>\n", b);
2278	2471
	2472	+ if (mddev->raid_disks)
	2473	+ mddev_create_serial_pool(mddev, rdev, false);
	2474	+
2279	2475	if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2280	2476	goto fail;
2281	2477
2282	2478	ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
2283		- if (sysfs_create_link(&rdev->kobj, ko, "block"))
2284		- /* failure here is OK */;
	2479	+ /* failure here is OK */
	2480	+ err = sysfs_create_link(&rdev->kobj, ko, "block");
2285	2481	rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
	2482	+ rdev->sysfs_unack_badblocks =
	2483	+ sysfs_get_dirent_safe(rdev->kobj.sd, "unacknowledged_bad_blocks");
	2484	+ rdev->sysfs_badblocks =
	2485	+ sysfs_get_dirent_safe(rdev->kobj.sd, "bad_blocks");
2286	2486
2287	2487	list_add_rcu(&rdev->same_set, &mddev->disks);
2288	2488	bd_link_disk_holder(rdev->bdev, mddev->gendisk);
..	..	@@ -2298,7 +2498,7 @@
2298	2498	return err;
2299	2499	}
2300	2500
2301		-static void md_delayed_delete(struct work_struct *ws)
	2501	+static void rdev_delayed_delete(struct work_struct *ws)
2302	2502	{
2303	2503	struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2304	2504	kobject_del(&rdev->kobj);
..	..	@@ -2312,19 +2512,24 @@
2312	2512	bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2313	2513	list_del_rcu(&rdev->same_set);
2314	2514	pr_debug("md: unbind<%s>\n", bdevname(rdev->bdev,b));
	2515	+ mddev_destroy_serial_pool(rdev->mddev, rdev, false);
2315	2516	rdev->mddev = NULL;
2316	2517	sysfs_remove_link(&rdev->kobj, "block");
2317	2518	sysfs_put(rdev->sysfs_state);
	2519	+ sysfs_put(rdev->sysfs_unack_badblocks);
	2520	+ sysfs_put(rdev->sysfs_badblocks);
2318	2521	rdev->sysfs_state = NULL;
	2522	+ rdev->sysfs_unack_badblocks = NULL;
	2523	+ rdev->sysfs_badblocks = NULL;
2319	2524	rdev->badblocks.count = 0;
2320	2525	/* We need to delay this, otherwise we can deadlock when
2321	2526	* writing to 'remove' to "dev/state". We also need
2322	2527	* to delay it due to rcu usage.
2323	2528	*/
2324	2529	synchronize_rcu();
2325		- INIT_WORK(&rdev->del_work, md_delayed_delete);
	2530	+ INIT_WORK(&rdev->del_work, rdev_delayed_delete);
2326	2531	kobject_get(&rdev->kobj);
2327		- queue_work(md_misc_wq, &rdev->del_work);
	2532	+ queue_work(md_rdev_misc_wq, &rdev->del_work);
2328	2533	}
2329	2534
2330	2535	/*
..	..	@@ -2336,12 +2541,12 @@
2336	2541	{
2337	2542	int err = 0;
2338	2543	struct block_device *bdev;
2339		- char b[BDEVNAME_SIZE];
2340	2544
2341	2545	bdev = blkdev_get_by_dev(dev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL,
2342	2546	shared ? (struct md_rdev *)lock_rdev : rdev);
2343	2547	if (IS_ERR(bdev)) {
2344		- pr_warn("md: could not open %s.\n", __bdevname(dev, b));
	2548	+ pr_warn("md: could not open device unknown-block(%u,%u).\n",
	2549	+ MAJOR(dev), MINOR(dev));
2345	2550	return PTR_ERR(bdev);
2346	2551	}
2347	2552	rdev->bdev = bdev;
..	..	@@ -2443,14 +2648,16 @@
2443	2648
2444	2649	static bool does_sb_need_changing(struct mddev *mddev)
2445	2650	{
2446		- struct md_rdev *rdev;
	2651	+ struct md_rdev rdev = NULL, iter;
2447	2652	struct mdp_superblock_1 *sb;
2448	2653	int role;
2449	2654
2450	2655	/* Find a good rdev */
2451		- rdev_for_each(rdev, mddev)
2452		- if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
	2656	+ rdev_for_each(iter, mddev)
	2657	+ if ((iter->raid_disk >= 0) && !test_bit(Faulty, &iter->flags)) {
	2658	+ rdev = iter;
2453	2659	break;
	2660	+ }
2454	2661
2455	2662	/* No good device found. */
2456	2663	if (!rdev)
..	..	@@ -2660,7 +2867,7 @@
2660	2867	goto repeat;
2661	2868	wake_up(&mddev->sb_wait);
2662	2869	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2663		- sysfs_notify(&mddev->kobj, NULL, "sync_completed");
	2870	+ sysfs_notify_dirent_safe(mddev->sysfs_completed);
2664	2871
2665	2872	rdev_for_each(rdev, mddev) {
2666	2873	if (test_and_clear_bit(FaultRecorded, &rdev->flags))
..	..	@@ -2793,7 +3000,11 @@
2793	3000	* -write_error - clears WriteErrorSeen
2794	3001	* {,-}failfast - set/clear FailFast
2795	3002	*/
	3003	+
	3004	+ struct mddev *mddev = rdev->mddev;
2796	3005	int err = -EINVAL;
	3006	+ bool need_update_sb = false;
	3007	+
2797	3008	if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2798	3009	md_error(rdev->mddev, rdev);
2799	3010	if (test_bit(Faulty, &rdev->flags))
..	..	@@ -2808,7 +3019,6 @@
2808	3019	if (rdev->raid_disk >= 0)
2809	3020	err = -EBUSY;
2810	3021	else {
2811		- struct mddev *mddev = rdev->mddev;
2812	3022	err = 0;
2813	3023	if (mddev_is_clustered(mddev))
2814	3024	err = md_cluster_ops->remove_disk(mddev, rdev);
..	..	@@ -2824,9 +3034,13 @@
2824	3034	}
2825	3035	} else if (cmd_match(buf, "writemostly")) {
2826	3036	set_bit(WriteMostly, &rdev->flags);
	3037	+ mddev_create_serial_pool(rdev->mddev, rdev, false);
	3038	+ need_update_sb = true;
2827	3039	err = 0;
2828	3040	} else if (cmd_match(buf, "-writemostly")) {
	3041	+ mddev_destroy_serial_pool(rdev->mddev, rdev, false);
2829	3042	clear_bit(WriteMostly, &rdev->flags);
	3043	+ need_update_sb = true;
2830	3044	err = 0;
2831	3045	} else if (cmd_match(buf, "blocked")) {
2832	3046	set_bit(Blocked, &rdev->flags);
..	..	@@ -2852,9 +3066,11 @@
2852	3066	err = 0;
2853	3067	} else if (cmd_match(buf, "failfast")) {
2854	3068	set_bit(FailFast, &rdev->flags);
	3069	+ need_update_sb = true;
2855	3070	err = 0;
2856	3071	} else if (cmd_match(buf, "-failfast")) {
2857	3072	clear_bit(FailFast, &rdev->flags);
	3073	+ need_update_sb = true;
2858	3074	err = 0;
2859	3075	} else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
2860	3076	!test_bit(Journal, &rdev->flags)) {
..	..	@@ -2933,6 +3149,8 @@
2933	3149	clear_bit(ExternalBbl, &rdev->flags);
2934	3150	err = 0;
2935	3151	}
	3152	+ if (need_update_sb)
	3153	+ md_update_sb(mddev, 1);
2936	3154	if (!err)
2937	3155	sysfs_notify_dirent_safe(rdev->sysfs_state);
2938	3156	return err ? err : len;
..	..	@@ -3032,15 +3250,14 @@
3032	3250	rdev->saved_raid_disk = -1;
3033	3251	clear_bit(In_sync, &rdev->flags);
3034	3252	clear_bit(Bitmap_sync, &rdev->flags);
3035		- err = rdev->mddev->pers->
3036		- hot_add_disk(rdev->mddev, rdev);
	3253	+ err = rdev->mddev->pers->hot_add_disk(rdev->mddev, rdev);
3037	3254	if (err) {
3038	3255	rdev->raid_disk = -1;
3039	3256	return err;
3040	3257	} else
3041	3258	sysfs_notify_dirent_safe(rdev->sysfs_state);
3042		- if (sysfs_link_rdev(rdev->mddev, rdev))
3043		- /* failure here is OK */;
	3259	+ /* failure here is OK */;
	3260	+ sysfs_link_rdev(rdev->mddev, rdev);
3044	3261	/* don't wakeup anyone, leave that to userspace. */
3045	3262	} else {
3046	3263	if (slot >= rdev->mddev->raid_disks &&
..	..	@@ -3422,7 +3639,7 @@
3422	3639	if (!entry->show)
3423	3640	return -EIO;
3424	3641	if (!rdev->mddev)
3425		- return -EBUSY;
	3642	+ return -ENODEV;
3426	3643	return entry->show(rdev, page);
3427	3644	}
3428	3645
..	..	@@ -3439,10 +3656,10 @@
3439	3656	return -EIO;
3440	3657	if (!capable(CAP_SYS_ADMIN))
3441	3658	return -EACCES;
3442		- rv = mddev ? mddev_lock(mddev): -EBUSY;
	3659	+ rv = mddev ? mddev_lock(mddev) : -ENODEV;
3443	3660	if (!rv) {
3444	3661	if (rdev->mddev == NULL)
3445		- rv = -EBUSY;
	3662	+ rv = -ENODEV;
3446	3663	else
3447	3664	rv = entry->store(rdev, page, length);
3448	3665	mddev_unlock(mddev);
..	..	@@ -3563,7 +3780,7 @@
3563	3780	* Check a full RAID array for plausibility
3564	3781	*/
3565	3782
3566		-static void analyze_sbs(struct mddev *mddev)
	3783	+static int analyze_sbs(struct mddev *mddev)
3567	3784	{
3568	3785	int i;
3569	3786	struct md_rdev rdev, freshest, *tmp;
..	..	@@ -3583,6 +3800,12 @@
3583	3800	bdevname(rdev->bdev,b));
3584	3801	md_kick_rdev_from_array(rdev);
3585	3802	}
	3803	+
	3804	+ /* Cannot find a valid fresh disk */
	3805	+ if (!freshest) {
	3806	+ pr_warn("md: cannot find a valid disk\n");
	3807	+ return -EINVAL;
	3808	+ }
3586	3809
3587	3810	super_types[mddev->major_version].
3588	3811	validate_super(mddev, freshest);
..	..	@@ -3618,6 +3841,8 @@
3618	3841	clear_bit(In_sync, &rdev->flags);
3619	3842	}
3620	3843	}
	3844	+
	3845	+ return 0;
3621	3846	}
3622	3847
3623	3848	/* Read a fixed-point number.
..	..	@@ -3652,11 +3877,7 @@
3652	3877	return -EINVAL;
3653	3878	if (decimals < 0)
3654	3879	decimals = 0;
3655		- while (decimals < scale) {
3656		- result *= 10;
3657		- decimals ++;
3658		- }
3659		- *res = result;
	3880	+ res = result int_pow(10, scale - decimals);
3660	3881	return 0;
3661	3882	}
3662	3883
..	..	@@ -3861,6 +4082,8 @@
3861	4082	pr_warn("md: cannot register extra attributes for %s\n",
3862	4083	mdname(mddev));
3863	4084	mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
	4085	+ mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
	4086	+ mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
3864	4087	}
3865	4088	if (oldpers->sync_request != NULL &&
3866	4089	pers->sync_request == NULL) {
..	..	@@ -3908,7 +4131,7 @@
3908	4131	mddev_resume(mddev);
3909	4132	if (!mddev->thread)
3910	4133	md_update_sb(mddev, 1);
3911		- sysfs_notify(&mddev->kobj, NULL, "level");
	4134	+ sysfs_notify_dirent_safe(mddev->sysfs_level);
3912	4135	md_new_event(mddev);
3913	4136	rv = len;
3914	4137	out_unlock:
..	..	@@ -4019,6 +4242,14 @@
4019	4242	}
4020	4243	static struct md_sysfs_entry md_raid_disks =
4021	4244	__ATTR(raid_disks, S_IRUGO\|S_IWUSR, raid_disks_show, raid_disks_store);
	4245	+
	4246	+static ssize_t
	4247	+uuid_show(struct mddev mddev, char page)
	4248	+{
	4249	+ return sprintf(page, "%pU\n", mddev->uuid);
	4250	+}
	4251	+static struct md_sysfs_entry md_uuid =
	4252	+__ATTR(uuid, S_IRUGO, uuid_show, NULL);
4022	4253
4023	4254	static ssize_t
4024	4255	chunk_size_show(struct mddev mddev, char page)
..	..	@@ -4143,12 +4374,17 @@
4143	4374	* active-idle
4144	4375	* like active, but no writes have been seen for a while (100msec).
4145	4376	*
	4377	+ * broken
	4378	+ * RAID0/LINEAR-only: same as clean, but array is missing a member.
	4379	+ * It's useful because RAID0/LINEAR mounted-arrays aren't stopped
	4380	+ * when a member is gone, so this state will at least alert the
	4381	+ * user that something is wrong.
4146	4382	*/
4147	4383	enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
4148		- write_pending, active_idle, bad_word};
	4384	+ write_pending, active_idle, broken, bad_word};
4149	4385	static char *array_states[] = {
4150	4386	"clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
4151		- "write-pending", "active-idle", NULL };
	4387	+ "write-pending", "active-idle", "broken", NULL };
4152	4388
4153	4389	static int match_word(const char word, char *list)
4154	4390	{
..	..	@@ -4164,7 +4400,7 @@
4164	4400	{
4165	4401	enum array_state st = inactive;
4166	4402
4167		- if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags))
	4403	+ if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags)) {
4168	4404	switch(mddev->ro) {
4169	4405	case 1:
4170	4406	st = readonly;
..	..	@@ -4184,7 +4420,10 @@
4184	4420	st = active;
4185	4421	spin_unlock(&mddev->lock);
4186	4422	}
4187		- else {
	4423	+
	4424	+ if (test_bit(MD_BROKEN, &mddev->flags) && st == clean)
	4425	+ st = broken;
	4426	+ } else {
4188	4427	if (list_empty(&mddev->disks) &&
4189	4428	mddev->raid_disks == 0 &&
4190	4429	mddev->dev_sectors == 0)
..	..	@@ -4197,7 +4436,6 @@
4197	4436
4198	4437	static int do_md_stop(struct mddev mddev, int ro, struct block_device bdev);
4199	4438	static int md_set_readonly(struct mddev mddev, struct block_device bdev);
4200		-static int do_md_run(struct mddev *mddev);
4201	4439	static int restart_array(struct mddev *mddev);
4202	4440
4203	4441	static ssize_t
..	..	@@ -4298,6 +4536,7 @@
4298	4536	break;
4299	4537	case write_pending:
4300	4538	case active_idle:
	4539	+ case broken:
4301	4540	/* these cannot be set */
4302	4541	break;
4303	4542	}
..	..	@@ -4342,6 +4581,20 @@
4342	4581	return -EINVAL;
4343	4582	}
4344	4583
	4584	+/* need to ensure rdev_delayed_delete() has completed */
	4585	+static void flush_rdev_wq(struct mddev *mddev)
	4586	+{
	4587	+ struct md_rdev *rdev;
	4588	+
	4589	+ rcu_read_lock();
	4590	+ rdev_for_each_rcu(rdev, mddev)
	4591	+ if (work_pending(&rdev->del_work)) {
	4592	+ flush_workqueue(md_rdev_misc_wq);
	4593	+ break;
	4594	+ }
	4595	+ rcu_read_unlock();
	4596	+}
	4597	+
4345	4598	static ssize_t
4346	4599	new_dev_store(struct mddev mddev, const char buf, size_t len)
4347	4600	{
..	..	@@ -4369,8 +4622,7 @@
4369	4622	minor != MINOR(dev))
4370	4623	return -EOVERFLOW;
4371	4624
4372		- flush_workqueue(md_misc_wq);
4373		-
	4625	+ flush_rdev_wq(mddev);
4374	4626	err = mddev_lock(mddev);
4375	4627	if (err)
4376	4628	return err;
..	..	@@ -4608,7 +4860,8 @@
4608	4860	clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4609	4861	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4610	4862	mddev_lock(mddev) == 0) {
4611		- flush_workqueue(md_misc_wq);
	4863	+ if (work_pending(&mddev->del_work))
	4864	+ flush_workqueue(md_misc_wq);
4612	4865	if (mddev->sync_thread) {
4613	4866	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4614	4867	md_reap_sync_thread(mddev);
..	..	@@ -4638,7 +4891,7 @@
4638	4891	}
4639	4892	if (err)
4640	4893	return err;
4641		- sysfs_notify(&mddev->kobj, NULL, "degraded");
	4894	+ sysfs_notify_dirent_safe(mddev->sysfs_degraded);
4642	4895	} else {
4643	4896	if (cmd_match(page, "check"))
4644	4897	set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
..	..	@@ -5113,7 +5366,7 @@
5113	5366	mddev->array_sectors = sectors;
5114	5367	if (mddev->pers) {
5115	5368	set_capacity(mddev->gendisk, mddev->array_sectors);
5116		- revalidate_disk(mddev->gendisk);
	5369	+ revalidate_disk_size(mddev->gendisk, true);
5117	5370	}
5118	5371	}
5119	5372	mddev_unlock(mddev);
..	..	@@ -5170,10 +5423,90 @@
5170	5423	__ATTR(consistency_policy, S_IRUGO \| S_IWUSR, consistency_policy_show,
5171	5424	consistency_policy_store);
5172	5425
	5426	+static ssize_t fail_last_dev_show(struct mddev mddev, char page)
	5427	+{
	5428	+ return sprintf(page, "%d\n", mddev->fail_last_dev);
	5429	+}
	5430	+
	5431	+/*
	5432	+ * Setting fail_last_dev to true to allow last device to be forcibly removed
	5433	+ * from RAID1/RAID10.
	5434	+ */
	5435	+static ssize_t
	5436	+fail_last_dev_store(struct mddev mddev, const char buf, size_t len)
	5437	+{
	5438	+ int ret;
	5439	+ bool value;
	5440	+
	5441	+ ret = kstrtobool(buf, &value);
	5442	+ if (ret)
	5443	+ return ret;
	5444	+
	5445	+ if (value != mddev->fail_last_dev)
	5446	+ mddev->fail_last_dev = value;
	5447	+
	5448	+ return len;
	5449	+}
	5450	+static struct md_sysfs_entry md_fail_last_dev =
	5451	+__ATTR(fail_last_dev, S_IRUGO \| S_IWUSR, fail_last_dev_show,
	5452	+ fail_last_dev_store);
	5453	+
	5454	+static ssize_t serialize_policy_show(struct mddev mddev, char page)
	5455	+{
	5456	+ if (mddev->pers == NULL \|\| (mddev->pers->level != 1))
	5457	+ return sprintf(page, "n/a\n");
	5458	+ else
	5459	+ return sprintf(page, "%d\n", mddev->serialize_policy);
	5460	+}
	5461	+
	5462	+/*
	5463	+ * Setting serialize_policy to true to enforce write IO is not reordered
	5464	+ * for raid1.
	5465	+ */
	5466	+static ssize_t
	5467	+serialize_policy_store(struct mddev mddev, const char buf, size_t len)
	5468	+{
	5469	+ int err;
	5470	+ bool value;
	5471	+
	5472	+ err = kstrtobool(buf, &value);
	5473	+ if (err)
	5474	+ return err;
	5475	+
	5476	+ if (value == mddev->serialize_policy)
	5477	+ return len;
	5478	+
	5479	+ err = mddev_lock(mddev);
	5480	+ if (err)
	5481	+ return err;
	5482	+ if (mddev->pers == NULL \|\| (mddev->pers->level != 1)) {
	5483	+ pr_err("md: serialize_policy is only effective for raid1\n");
	5484	+ err = -EINVAL;
	5485	+ goto unlock;
	5486	+ }
	5487	+
	5488	+ mddev_suspend(mddev);
	5489	+ if (value)
	5490	+ mddev_create_serial_pool(mddev, NULL, true);
	5491	+ else
	5492	+ mddev_destroy_serial_pool(mddev, NULL, true);
	5493	+ mddev->serialize_policy = value;
	5494	+ mddev_resume(mddev);
	5495	+unlock:
	5496	+ mddev_unlock(mddev);
	5497	+ return err ?: len;
	5498	+}
	5499	+
	5500	+static struct md_sysfs_entry md_serialize_policy =
	5501	+__ATTR(serialize_policy, S_IRUGO \| S_IWUSR, serialize_policy_show,
	5502	+ serialize_policy_store);
	5503	+
	5504	+
5173	5505	static struct attribute *md_default_attrs[] = {
5174	5506	&md_level.attr,
5175	5507	&md_layout.attr,
5176	5508	&md_raid_disks.attr,
	5509	+ &md_uuid.attr,
5177	5510	&md_chunk_size.attr,
5178	5511	&md_size.attr,
5179	5512	&md_resync_start.attr,
..	..	@@ -5186,6 +5519,8 @@
5186	5519	&md_array_size.attr,
5187	5520	&max_corr_read_errors.attr,
5188	5521	&md_consistency_policy.attr,
	5522	+ &md_fail_last_dev.attr,
	5523	+ &md_serialize_policy.attr,
5189	5524	NULL,
5190	5525	};
5191	5526
..	..	@@ -5263,6 +5598,8 @@
5263	5598
5264	5599	if (mddev->sysfs_state)
5265	5600	sysfs_put(mddev->sysfs_state);
	5601	+ if (mddev->sysfs_level)
	5602	+ sysfs_put(mddev->sysfs_level);
5266	5603
5267	5604	if (mddev->gendisk)
5268	5605	del_gendisk(mddev->gendisk);
..	..	@@ -5304,7 +5641,8 @@
5304	5641	{
5305	5642	if (mddev->writes_pending.percpu_count_ptr)
5306	5643	return 0;
5307		- if (percpu_ref_init(&mddev->writes_pending, no_op, 0, GFP_KERNEL) < 0)
	5644	+ if (percpu_ref_init(&mddev->writes_pending, no_op,
	5645	+ PERCPU_REF_ALLOW_REINIT, GFP_KERNEL) < 0)
5308	5646	return -ENOMEM;
5309	5647	/* We want to start with the refcount at zero */
5310	5648	percpu_ref_put(&mddev->writes_pending);
..	..	@@ -5369,12 +5707,10 @@
5369	5707	mddev->hold_active = UNTIL_STOP;
5370	5708
5371	5709	error = -ENOMEM;
5372		- mddev->queue = blk_alloc_queue(GFP_KERNEL);
	5710	+ mddev->queue = blk_alloc_queue(NUMA_NO_NODE);
5373	5711	if (!mddev->queue)
5374	5712	goto abort;
5375		- mddev->queue->queuedata = mddev;
5376	5713
5377		- blk_queue_make_request(mddev->queue, md_make_request);
5378	5714	blk_set_stacking_limits(&mddev->queue->limits);
5379	5715
5380	5716	disk = alloc_disk(1 << shift);
..	..	@@ -5400,6 +5736,7 @@
5400	5736	* remove it now.
5401	5737	*/
5402	5738	disk->flags \|= GENHD_FL_EXT_DEVT;
	5739	+ disk->events \|= DISK_EVENT_MEDIA_CHANGE;
5403	5740	mddev->gendisk = disk;
5404	5741	add_disk(disk);
5405	5742
..	..	@@ -5420,6 +5757,7 @@
5420	5757	if (!error && mddev->kobj.sd) {
5421	5758	kobject_uevent(&mddev->kobj, KOBJ_ADD);
5422	5759	mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
	5760	+ mddev->sysfs_level = sysfs_get_dirent_safe(mddev->kobj.sd, "level");
5423	5761	}
5424	5762	mddev_put(mddev);
5425	5763	return error;
..	..	@@ -5496,7 +5834,9 @@
5496	5834	if (!mddev->raid_disks) {
5497	5835	if (!mddev->persistent)
5498	5836	return -EINVAL;
5499		- analyze_sbs(mddev);
	5837	+ err = analyze_sbs(mddev);
	5838	+ if (err)
	5839	+ return -EINVAL;
5500	5840	}
5501	5841
5502	5842	if (mddev->level != LEVEL_NONE)
..	..	@@ -5601,8 +5941,8 @@
5601	5941	rdev_for_each(rdev, mddev)
5602	5942	rdev_for_each(rdev2, mddev) {
5603	5943	if (rdev < rdev2 &&
5604		- rdev->bdev->bd_contains ==
5605		- rdev2->bdev->bd_contains) {
	5944	+ rdev->bdev->bd_disk ==
	5945	+ rdev2->bdev->bd_disk) {
5606	5946	pr_warn("%s: WARNING: %s appears to be on the same physical disk as %s.\n",
5607	5947	mdname(mddev),
5608	5948	bdevname(rdev->bdev,b),
..	..	@@ -5649,15 +5989,28 @@
5649	5989	mddev->bitmap = bitmap;
5650	5990
5651	5991	}
5652		- if (err) {
5653		- mddev_detach(mddev);
5654		- if (mddev->private)
5655		- pers->free(mddev, mddev->private);
5656		- mddev->private = NULL;
5657		- module_put(pers->owner);
5658		- md_bitmap_destroy(mddev);
5659		- goto abort;
	5992	+ if (err)
	5993	+ goto bitmap_abort;
	5994	+
	5995	+ if (mddev->bitmap_info.max_write_behind > 0) {
	5996	+ bool create_pool = false;
	5997	+
	5998	+ rdev_for_each(rdev, mddev) {
	5999	+ if (test_bit(WriteMostly, &rdev->flags) &&
	6000	+ rdev_init_serial(rdev))
	6001	+ create_pool = true;
	6002	+ }
	6003	+ if (create_pool && mddev->serial_info_pool == NULL) {
	6004	+ mddev->serial_info_pool =
	6005	+ mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
	6006	+ sizeof(struct serial_info));
	6007	+ if (!mddev->serial_info_pool) {
	6008	+ err = -ENOMEM;
	6009	+ goto bitmap_abort;
	6010	+ }
	6011	+ }
5660	6012	}
	6013	+
5661	6014	if (mddev->queue) {
5662	6015	bool nonrot = true;
5663	6016
..	..	@@ -5674,8 +6027,6 @@
5674	6027	blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
5675	6028	else
5676	6029	blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
5677		- mddev->queue->backing_dev_info->congested_data = mddev;
5678		- mddev->queue->backing_dev_info->congested_fn = md_congested;
5679	6030	}
5680	6031	if (pers->sync_request) {
5681	6032	if (mddev->kobj.sd &&
..	..	@@ -5683,6 +6034,8 @@
5683	6034	pr_warn("md: cannot register extra attributes for %s\n",
5684	6035	mdname(mddev));
5685	6036	mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
	6037	+ mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
	6038	+ mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
5686	6039	} else if (mddev->ro == 2) /* auto-readonly not meaningful */
5687	6040	mddev->ro = 0;
5688	6041
..	..	@@ -5692,7 +6045,7 @@
5692	6045	if (mddev_is_clustered(mddev))
5693	6046	mddev->safemode_delay = 0;
5694	6047	else
5695		- mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
	6048	+ mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
5696	6049	mddev->in_sync = 1;
5697	6050	smp_wmb();
5698	6051	spin_lock(&mddev->lock);
..	..	@@ -5700,8 +6053,7 @@
5700	6053	spin_unlock(&mddev->lock);
5701	6054	rdev_for_each(rdev, mddev)
5702	6055	if (rdev->raid_disk >= 0)
5703		- if (sysfs_link_rdev(mddev, rdev))
5704		- /* failure here is OK */;
	6056	+ sysfs_link_rdev(mddev, rdev); /* failure here is OK */
5705	6057
5706	6058	if (mddev->degraded && !mddev->ro)
5707	6059	/* This ensures that recovering status is reported immediately
..	..	@@ -5716,6 +6068,13 @@
5716	6068	md_new_event(mddev);
5717	6069	return 0;
5718	6070
	6071	+bitmap_abort:
	6072	+ mddev_detach(mddev);
	6073	+ if (mddev->private)
	6074	+ pers->free(mddev, mddev->private);
	6075	+ mddev->private = NULL;
	6076	+ module_put(pers->owner);
	6077	+ md_bitmap_destroy(mddev);
5719	6078	abort:
5720	6079	bioset_exit(&mddev->bio_set);
5721	6080	bioset_exit(&mddev->sync_set);
..	..	@@ -5723,7 +6082,7 @@
5723	6082	}
5724	6083	EXPORT_SYMBOL_GPL(md_run);
5725	6084
5726		-static int do_md_run(struct mddev *mddev)
	6085	+int do_md_run(struct mddev *mddev)
5727	6086	{
5728	6087	int err;
5729	6088
..	..	@@ -5747,13 +6106,13 @@
5747	6106	md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5748	6107
5749	6108	set_capacity(mddev->gendisk, mddev->array_sectors);
5750		- revalidate_disk(mddev->gendisk);
	6109	+ revalidate_disk_size(mddev->gendisk, true);
5751	6110	clear_bit(MD_NOT_READY, &mddev->flags);
5752	6111	mddev->changed = 1;
5753	6112	kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5754	6113	sysfs_notify_dirent_safe(mddev->sysfs_state);
5755	6114	sysfs_notify_dirent_safe(mddev->sysfs_action);
5756		- sysfs_notify(&mddev->kobj, NULL, "degraded");
	6115	+ sysfs_notify_dirent_safe(mddev->sysfs_degraded);
5757	6116	out:
5758	6117	clear_bit(MD_NOT_READY, &mddev->flags);
5759	6118	return err;
..	..	@@ -5868,7 +6227,8 @@
5868	6227	static void __md_stop_writes(struct mddev *mddev)
5869	6228	{
5870	6229	set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5871		- flush_workqueue(md_misc_wq);
	6230	+ if (work_pending(&mddev->del_work))
	6231	+ flush_workqueue(md_misc_wq);
5872	6232	if (mddev->sync_thread) {
5873	6233	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5874	6234	md_reap_sync_thread(mddev);
..	..	@@ -5890,6 +6250,9 @@
5890	6250	mddev->in_sync = 1;
5891	6251	md_update_sb(mddev, 1);
5892	6252	}
	6253	+ /* disable policy to guarantee rdevs free resources for serialization */
	6254	+ mddev->serialize_policy = 0;
	6255	+ mddev_destroy_serial_pool(mddev, NULL, true);
5893	6256	}
5894	6257
5895	6258	void md_stop_writes(struct mddev *mddev)
..	..	@@ -5918,7 +6281,8 @@
5918	6281	md_bitmap_destroy(mddev);
5919	6282	mddev_detach(mddev);
5920	6283	/* Ensure ->event_work is done */
5921		- flush_workqueue(md_misc_wq);
	6284	+ if (mddev->event_work.func)
	6285	+ flush_workqueue(md_misc_wq);
5922	6286	spin_lock(&mddev->lock);
5923	6287	mddev->pers = NULL;
5924	6288	spin_unlock(&mddev->lock);
..	..	@@ -5935,6 +6299,7 @@
5935	6299	/* stop the array and free an attached data structures.
5936	6300	* This is called from dm-raid
5937	6301	*/
	6302	+ __md_stop_writes(mddev);
5938	6303	__md_stop(mddev);
5939	6304	bioset_exit(&mddev->bio_set);
5940	6305	bioset_exit(&mddev->sync_set);
..	..	@@ -6049,7 +6414,6 @@
6049	6414
6050	6415	__md_stop_writes(mddev);
6051	6416	__md_stop(mddev);
6052		- mddev->queue->backing_dev_info->congested_fn = NULL;
6053	6417
6054	6418	/* tell userspace to handle 'inactive' */
6055	6419	sysfs_notify_dirent_safe(mddev->sysfs_state);
..	..	@@ -6061,7 +6425,7 @@
6061	6425	set_capacity(disk, 0);
6062	6426	mutex_unlock(&mddev->open_mutex);
6063	6427	mddev->changed = 1;
6064		- revalidate_disk(disk);
	6428	+ revalidate_disk_size(disk, true);
6065	6429
6066	6430	if (mddev->ro)
6067	6431	mddev->ro = 0;
..	..	@@ -6352,7 +6716,7 @@
6352	6716	return 0;
6353	6717	}
6354	6718
6355		-static int add_new_disk(struct mddev mddev, mdu_disk_info_t info)
	6719	+int md_add_new_disk(struct mddev mddev, struct mdu_disk_info_s info)
6356	6720	{
6357	6721	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
6358	6722	struct md_rdev *rdev;
..	..	@@ -6398,7 +6762,7 @@
6398	6762	}
6399	6763
6400	6764	/*
6401		- * add_new_disk can be used once the array is assembled
	6765	+ * md_add_new_disk can be used once the array is assembled
6402	6766	* to add "hot spares". They must already have a superblock
6403	6767	* written
6404	6768	*/
..	..	@@ -6511,7 +6875,7 @@
6511	6875	return err;
6512	6876	}
6513	6877
6514		- /* otherwise, add_new_disk is only allowed
	6878	+ /* otherwise, md_add_new_disk is only allowed
6515	6879	* for major_version==0 superblocks
6516	6880	*/
6517	6881	if (mddev->major_version != 0) {
..	..	@@ -6758,7 +7122,7 @@
6758	7122	}
6759	7123
6760	7124	/*
6761		- * set_array_info is used two different ways
	7125	+ * md_set_array_info is used two different ways
6762	7126	* The original usage is when creating a new array.
6763	7127	* In this usage, raid_disks is > 0 and it together with
6764	7128	* level, size, not_persistent,layout,chunksize determine the
..	..	@@ -6770,9 +7134,8 @@
6770	7134	* The minor and patch _version numbers are also kept incase the
6771	7135	* super_block handler wishes to interpret them.
6772	7136	*/
6773		-static int set_array_info(struct mddev mddev, mdu_array_info_t info)
	7137	+int md_set_array_info(struct mddev mddev, struct mdu_array_info_s info)
6774	7138	{
6775		-
6776	7139	if (info->raid_disks == 0) {
6777	7140	/* just setting version number for superblock loading */
6778	7141	if (info->major_version < 0 \|\|
..	..	@@ -6894,7 +7257,7 @@
6894	7257	md_cluster_ops->update_size(mddev, old_dev_sectors);
6895	7258	else if (mddev->queue) {
6896	7259	set_capacity(mddev->gendisk, mddev->array_sectors);
6897		- revalidate_disk(mddev->gendisk);
	7260	+ revalidate_disk_size(mddev->gendisk, true);
6898	7261	}
6899	7262	}
6900	7263	return rv;
..	..	@@ -7061,6 +7424,8 @@
7061	7424
7062	7425	mddev->bitmap_info.nodes = 0;
7063	7426	md_cluster_ops->leave(mddev);
	7427	+ module_put(md_cluster_mod);
	7428	+ mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
7064	7429	}
7065	7430	mddev_suspend(mddev);
7066	7431	md_bitmap_destroy(mddev);
..	..	@@ -7121,7 +7486,6 @@
7121	7486	case GET_DISK_INFO:
7122	7487	case HOT_ADD_DISK:
7123	7488	case HOT_REMOVE_DISK:
7124		- case RAID_AUTORUN:
7125	7489	case RAID_VERSION:
7126	7490	case RESTART_ARRAY_RW:
7127	7491	case RUN_ARRAY:
..	..	@@ -7167,13 +7531,6 @@
7167	7531	case RAID_VERSION:
7168	7532	err = get_version(argp);
7169	7533	goto out;
7170		-
7171		-#ifndef MODULE
7172		- case RAID_AUTORUN:
7173		- err = 0;
7174		- autostart_arrays(arg);
7175		- goto out;
7176		-#endif
7177	7534	default:;
7178	7535	}
7179	7536
..	..	@@ -7214,9 +7571,8 @@
7214	7571
7215	7572	}
7216	7573
7217		- if (cmd == ADD_NEW_DISK)
7218		- /* need to ensure md_delayed_delete() has completed */
7219		- flush_workqueue(md_misc_wq);
	7574	+ if (cmd == ADD_NEW_DISK \|\| cmd == HOT_ADD_DISK)
	7575	+ flush_rdev_wq(mddev);
7220	7576
7221	7577	if (cmd == HOT_REMOVE_DISK)
7222	7578	/* need to ensure recovery thread has run */
..	..	@@ -7276,7 +7632,7 @@
7276	7632	err = -EBUSY;
7277	7633	goto unlock;
7278	7634	}
7279		- err = set_array_info(mddev, &info);
	7635	+ err = md_set_array_info(mddev, &info);
7280	7636	if (err) {
7281	7637	pr_warn("md: couldn't set array info. %d\n", err);
7282	7638	goto unlock;
..	..	@@ -7330,7 +7686,7 @@
7330	7686	/* Need to clear read-only for this */
7331	7687	break;
7332	7688	else
7333		- err = add_new_disk(mddev, &info);
	7689	+ err = md_add_new_disk(mddev, &info);
7334	7690	goto unlock;
7335	7691	}
7336	7692	break;
..	..	@@ -7398,7 +7754,7 @@
7398	7754	if (copy_from_user(&info, argp, sizeof(info)))
7399	7755	err = -EFAULT;
7400	7756	else
7401		- err = add_new_disk(mddev, &info);
	7757	+ err = md_add_new_disk(mddev, &info);
7402	7758	goto unlock;
7403	7759	}
7404	7760
..	..	@@ -7493,7 +7849,7 @@
7493	7849	atomic_inc(&mddev->openers);
7494	7850	mutex_unlock(&mddev->open_mutex);
7495	7851
7496		- check_disk_change(bdev);
	7852	+ bdev_check_media_change(bdev);
7497	7853	out:
7498	7854	if (err)
7499	7855	mddev_put(mddev);
..	..	@@ -7509,23 +7865,21 @@
7509	7865	mddev_put(mddev);
7510	7866	}
7511	7867
7512		-static int md_media_changed(struct gendisk *disk)
	7868	+static unsigned int md_check_events(struct gendisk *disk, unsigned int clearing)
7513	7869	{
7514	7870	struct mddev *mddev = disk->private_data;
	7871	+ unsigned int ret = 0;
7515	7872
7516		- return mddev->changed;
7517		-}
7518		-
7519		-static int md_revalidate(struct gendisk *disk)
7520		-{
7521		- struct mddev *mddev = disk->private_data;
7522		-
	7873	+ if (mddev->changed)
	7874	+ ret = DISK_EVENT_MEDIA_CHANGE;
7523	7875	mddev->changed = 0;
7524		- return 0;
	7876	+ return ret;
7525	7877	}
7526		-static const struct block_device_operations md_fops =
	7878	+
	7879	+const struct block_device_operations md_fops =
7527	7880	{
7528	7881	.owner = THIS_MODULE,
	7882	+ .submit_bio = md_submit_bio,
7529	7883	.open = md_open,
7530	7884	.release = md_release,
7531	7885	.ioctl = md_ioctl,
..	..	@@ -7533,8 +7887,7 @@
7533	7887	.compat_ioctl = md_compat_ioctl,
7534	7888	#endif
7535	7889	.getgeo = md_getgeo,
7536		- .media_changed = md_media_changed,
7537		- .revalidate_disk= md_revalidate,
	7890	+ .check_events = md_check_events,
7538	7891	};
7539	7892
7540	7893	static int md_thread(void *arg)
..	..	@@ -7618,17 +7971,22 @@
7618	7971
7619	7972	void md_unregister_thread(struct md_thread **threadp)
7620	7973	{
7621		- struct md_thread thread = threadp;
7622		- if (!thread)
7623		- return;
7624		- pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7625		- /* Locking ensures that mddev_unlock does not wake_up a
	7974	+ struct md_thread *thread;
	7975	+
	7976	+ /*
	7977	+ * Locking ensures that mddev_unlock does not wake_up a
7626	7978	* non-existent thread
7627	7979	*/
7628	7980	spin_lock(&pers_lock);
	7981	+ thread = *threadp;
	7982	+ if (!thread) {
	7983	+ spin_unlock(&pers_lock);
	7984	+ return;
	7985	+ }
7629	7986	*threadp = NULL;
7630	7987	spin_unlock(&pers_lock);
7631	7988
	7989	+ pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7632	7990	kthread_stop(thread->tsk);
7633	7991	kfree(thread);
7634	7992	}
..	..	@@ -8006,13 +8364,12 @@
8006	8364	return mask;
8007	8365	}
8008	8366
8009		-static const struct file_operations md_seq_fops = {
8010		- .owner = THIS_MODULE,
8011		- .open = md_seq_open,
8012		- .read = seq_read,
8013		- .llseek = seq_lseek,
8014		- .release = seq_release,
8015		- .poll = mdstat_poll,
	8367	+static const struct proc_ops mdstat_proc_ops = {
	8368	+ .proc_open = md_seq_open,
	8369	+ .proc_read = seq_read,
	8370	+ .proc_lseek = seq_lseek,
	8371	+ .proc_release = seq_release,
	8372	+ .proc_poll = mdstat_poll,
8016	8373	};
8017	8374
8018	8375	int register_md_personality(struct md_personality *p)
..	..	@@ -8063,6 +8420,7 @@
8063	8420
8064	8421	int md_setup_cluster(struct mddev *mddev, int nodes)
8065	8422	{
	8423	+ int ret;
8066	8424	if (!md_cluster_ops)
8067	8425	request_module("md-cluster");
8068	8426	spin_lock(&pers_lock);
..	..	@@ -8074,7 +8432,10 @@
8074	8432	}
8075	8433	spin_unlock(&pers_lock);
8076	8434
8077		- return md_cluster_ops->join(mddev, nodes);
	8435	+ ret = md_cluster_ops->join(mddev, nodes);
	8436	+ if (!ret)
	8437	+ mddev->safemode_delay = 0;
	8438	+ return ret;
8078	8439	}
8079	8440
8080	8441	void md_cluster_stop(struct mddev *mddev)
..	..	@@ -8094,7 +8455,7 @@
8094	8455	idle = 1;
8095	8456	rcu_read_lock();
8096	8457	rdev_for_each_rcu(rdev, mddev) {
8097		- struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
	8458	+ struct gendisk *disk = rdev->bdev->bd_disk;
8098	8459	curr_events = (int)part_stat_read_accum(&disk->part0, sectors) -
8099	8460	atomic_read(&disk->sync_io);
8100	8461	/* sync IO will cause sync_io to increase before the disk_stats
..	..	@@ -8273,8 +8634,7 @@
8273	8634	{
8274	8635	struct mddev *mddev = thread->mddev;
8275	8636	struct mddev *mddev2;
8276		- unsigned int currspeed = 0,
8277		- window;
	8637	+ unsigned int currspeed = 0, window;
8278	8638	sector_t max_sectors,j, io_sectors, recovery_done;
8279	8639	unsigned long mark[SYNC_MARKS];
8280	8640	unsigned long update_time;
..	..	@@ -8331,7 +8691,7 @@
8331	8691	* 0 == not engaged in resync at all
8332	8692	* 2 == checking that there is no conflict with another sync
8333	8693	* 1 == like 2, but have yielded to allow conflicting resync to
8334		- * commense
	8694	+ * commence
8335	8695	* other == active in resync - this many blocks
8336	8696	*
8337	8697	* Before starting a resync we must have set curr_resync to
..	..	@@ -8405,9 +8765,17 @@
8405	8765	else if (!mddev->bitmap)
8406	8766	j = mddev->recovery_cp;
8407	8767
8408		- } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
	8768	+ } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
8409	8769	max_sectors = mddev->resync_max_sectors;
8410		- else {
	8770	+ /*
	8771	+ * If the original node aborts reshaping then we continue the
	8772	+ * reshaping, so set j again to avoid restart reshape from the
	8773	+ * first beginning
	8774	+ */
	8775	+ if (mddev_is_clustered(mddev) &&
	8776	+ mddev->reshape_position != MaxSector)
	8777	+ j = mddev->reshape_position;
	8778	+ } else {
8411	8779	/* recovery follows the physical size of devices */
8412	8780	max_sectors = mddev->dev_sectors;
8413	8781	j = MaxSector;
..	..	@@ -8454,7 +8822,7 @@
8454	8822	/*
8455	8823	* Tune reconstruction:
8456	8824	*/
8457		- window = 32*(PAGE_SIZE/512);
	8825	+ window = 32 * (PAGE_SIZE / 512);
8458	8826	pr_debug("md: using %dk window, over a total of %lluk.\n",
8459	8827	window/2, (unsigned long long)max_sectors/2);
8460	8828
..	..	@@ -8468,7 +8836,7 @@
8468	8836	} else
8469	8837	mddev->curr_resync = 3; /* no longer delayed */
8470	8838	mddev->curr_resync_completed = j;
8471		- sysfs_notify(&mddev->kobj, NULL, "sync_completed");
	8839	+ sysfs_notify_dirent_safe(mddev->sysfs_completed);
8472	8840	md_new_event(mddev);
8473	8841	update_time = jiffies;
8474	8842
..	..	@@ -8496,7 +8864,7 @@
8496	8864	mddev->recovery_cp = j;
8497	8865	update_time = jiffies;
8498	8866	set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8499		- sysfs_notify(&mddev->kobj, NULL, "sync_completed");
	8867	+ sysfs_notify_dirent_safe(mddev->sysfs_completed);
8500	8868	}
8501	8869
8502	8870	while (j >= mddev->resync_max &&
..	..	@@ -8603,7 +8971,7 @@
8603	8971	!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8604	8972	mddev->curr_resync > 3) {
8605	8973	mddev->curr_resync_completed = mddev->curr_resync;
8606		- sysfs_notify(&mddev->kobj, NULL, "sync_completed");
	8974	+ sysfs_notify_dirent_safe(mddev->sysfs_completed);
8607	8975	}
8608	8976	mddev->pers->sync_request(mddev, max_sectors, &skipped);
8609	8977
..	..	@@ -8658,8 +9026,10 @@
8658	9026	mddev_lock_nointr(mddev);
8659	9027	md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
8660	9028	mddev_unlock(mddev);
8661		- set_capacity(mddev->gendisk, mddev->array_sectors);
8662		- revalidate_disk(mddev->gendisk);
	9029	+ if (!mddev_is_clustered(mddev)) {
	9030	+ set_capacity(mddev->gendisk, mddev->array_sectors);
	9031	+ revalidate_disk_size(mddev->gendisk, true);
	9032	+ }
8663	9033	}
8664	9034
8665	9035	spin_lock(&mddev->lock);
..	..	@@ -8731,7 +9101,7 @@
8731	9101	}
8732	9102
8733	9103	if (removed && mddev->kobj.sd)
8734		- sysfs_notify(&mddev->kobj, NULL, "degraded");
	9104	+ sysfs_notify_dirent_safe(mddev->sysfs_degraded);
8735	9105
8736	9106	if (this && removed)
8737	9107	goto no_add;
..	..	@@ -8758,10 +9128,9 @@
8758	9128
8759	9129	rdev->recovery_offset = 0;
8760	9130	}
8761		- if (mddev->pers->
8762		- hot_add_disk(mddev, rdev) == 0) {
8763		- if (sysfs_link_rdev(mddev, rdev))
8764		- /* failure here is OK */;
	9131	+ if (mddev->pers->hot_add_disk(mddev, rdev) == 0) {
	9132	+ /* failure here is OK */
	9133	+ sysfs_link_rdev(mddev, rdev);
8765	9134	if (!test_bit(Journal, &rdev->flags))
8766	9135	spares++;
8767	9136	md_new_event(mddev);
..	..	@@ -9004,6 +9373,8 @@
9004	9373	void md_reap_sync_thread(struct mddev *mddev)
9005	9374	{
9006	9375	struct md_rdev *rdev;
	9376	+ sector_t old_dev_sectors = mddev->dev_sectors;
	9377	+ bool is_reshaped = false;
9007	9378
9008	9379	/* resync has finished, collect result */
9009	9380	md_unregister_thread(&mddev->sync_thread);
..	..	@@ -9013,14 +9384,16 @@
9013	9384	/* success...*/
9014	9385	/* activate any spares */
9015	9386	if (mddev->pers->spare_active(mddev)) {
9016		- sysfs_notify(&mddev->kobj, NULL,
9017		- "degraded");
	9387	+ sysfs_notify_dirent_safe(mddev->sysfs_degraded);
9018	9388	set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9019	9389	}
9020	9390	}
9021	9391	if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9022		- mddev->pers->finish_reshape)
	9392	+ mddev->pers->finish_reshape) {
9023	9393	mddev->pers->finish_reshape(mddev);
	9394	+ if (mddev_is_clustered(mddev))
	9395	+ is_reshaped = true;
	9396	+ }
9024	9397
9025	9398	/* If array is no-longer degraded, then any saved_raid_disk
9026	9399	* information must be scrapped.
..	..	@@ -9041,9 +9414,18 @@
9041	9414	clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9042	9415	clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9043	9416	clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
	9417	+ /*
	9418	+ * We call md_cluster_ops->update_size here because sync_size could
	9419	+ * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared,
	9420	+ * so it is time to update size across cluster.
	9421	+ */
	9422	+ if (mddev_is_clustered(mddev) && is_reshaped
	9423	+ && !test_bit(MD_CLOSING, &mddev->flags))
	9424	+ md_cluster_ops->update_size(mddev, old_dev_sectors);
9044	9425	wake_up(&resync_wait);
9045	9426	/* flag recovery needed just to double check */
9046	9427	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	9428	+ sysfs_notify_dirent_safe(mddev->sysfs_completed);
9047	9429	sysfs_notify_dirent_safe(mddev->sysfs_action);
9048	9430	md_new_event(mddev);
9049	9431	if (mddev->event_work.func)
..	..	@@ -9093,8 +9475,7 @@
9093	9475	if (rv == 0) {
9094	9476	/* Make sure they get written out promptly */
9095	9477	if (test_bit(ExternalBbl, &rdev->flags))
9096		- sysfs_notify(&rdev->kobj, NULL,
9097		- "unacknowledged_bad_blocks");
	9478	+ sysfs_notify_dirent_safe(rdev->sysfs_unack_badblocks);
9098	9479	sysfs_notify_dirent_safe(rdev->sysfs_state);
9099	9480	set_mask_bits(&mddev->sb_flags, 0,
9100	9481	BIT(MD_SB_CHANGE_CLEAN) \| BIT(MD_SB_CHANGE_PENDING));
..	..	@@ -9115,7 +9496,7 @@
9115	9496	s += rdev->data_offset;
9116	9497	rv = badblocks_clear(&rdev->badblocks, s, sectors);
9117	9498	if ((rv == 0) && test_bit(ExternalBbl, &rdev->flags))
9118		- sysfs_notify(&rdev->kobj, NULL, "bad_blocks");
	9499	+ sysfs_notify_dirent_safe(rdev->sysfs_badblocks);
9119	9500	return rv;
9120	9501	}
9121	9502	EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
..	..	@@ -9159,7 +9540,7 @@
9159	9540	{
9160	9541	pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
9161	9542
9162		- proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
	9543	+ proc_create("mdstat", S_IRUGO, NULL, &mdstat_proc_ops);
9163	9544	}
9164	9545
9165	9546	static int __init md_init(void)
..	..	@@ -9173,6 +9554,10 @@
9173	9554	md_misc_wq = alloc_workqueue("md_misc", 0, 0);
9174	9555	if (!md_misc_wq)
9175	9556	goto err_misc_wq;
	9557	+
	9558	+ md_rdev_misc_wq = alloc_workqueue("md_rdev_misc", 0, 0);
	9559	+ if (!md_rdev_misc_wq)
	9560	+ goto err_rdev_misc_wq;
9176	9561
9177	9562	if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
9178	9563	goto err_md;
..	..	@@ -9195,6 +9580,8 @@
9195	9580	err_mdp:
9196	9581	unregister_blkdev(MD_MAJOR, "md");
9197	9582	err_md:
	9583	+ destroy_workqueue(md_rdev_misc_wq);
	9584	+err_rdev_misc_wq:
9198	9585	destroy_workqueue(md_misc_wq);
9199	9586	err_misc_wq:
9200	9587	destroy_workqueue(md_wq);
..	..	@@ -9240,8 +9627,12 @@
9240	9627	}
9241	9628
9242	9629	if (role != rdev2->raid_disk) {
9243		- /* got activated */
9244		- if (rdev2->raid_disk == -1 && role != 0xffff) {
	9630	+ /*
	9631	+ * got activated except reshape is happening.
	9632	+ */
	9633	+ if (rdev2->raid_disk == -1 && role != 0xffff &&
	9634	+ !(le32_to_cpu(sb->feature_map) &
	9635	+ MD_FEATURE_RESHAPE_ACTIVE)) {
9245	9636	rdev2->saved_raid_disk = role;
9246	9637	ret = remove_and_add_spares(mddev, rdev2);
9247	9638	pr_info("Activated spare: %s\n",
..	..	@@ -9250,7 +9641,6 @@
9250	9641	* perform resync with the new activated disk */
9251	9642	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9252	9643	md_wakeup_thread(mddev->thread);
9253		-
9254	9644	}
9255	9645	/* device faulty
9256	9646	* We just want to do the minimum to mark the disk
..	..	@@ -9268,6 +9658,30 @@
9268	9658	ret = update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
9269	9659	if (ret)
9270	9660	pr_warn("md: updating array disks failed. %d\n", ret);
	9661	+ }
	9662	+
	9663	+ /*
	9664	+ * Since mddev->delta_disks has already updated in update_raid_disks,
	9665	+ * so it is time to check reshape.
	9666	+ */
	9667	+ if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
	9668	+ (le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
	9669	+ /*
	9670	+ * reshape is happening in the remote node, we need to
	9671	+ * update reshape_position and call start_reshape.
	9672	+ */
	9673	+ mddev->reshape_position = le64_to_cpu(sb->reshape_position);
	9674	+ if (mddev->pers->update_reshape_pos)
	9675	+ mddev->pers->update_reshape_pos(mddev);
	9676	+ if (mddev->pers->start_reshape)
	9677	+ mddev->pers->start_reshape(mddev);
	9678	+ } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
	9679	+ mddev->reshape_position != MaxSector &&
	9680	+ !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
	9681	+ /* reshape is just done in another node. */
	9682	+ mddev->reshape_position = MaxSector;
	9683	+ if (mddev->pers->update_reshape_pos)
	9684	+ mddev->pers->update_reshape_pos(mddev);
9271	9685	}
9272	9686
9273	9687	/* Finally set the event to be up to date */
..	..	@@ -9315,7 +9729,7 @@
9315	9729	if (rdev->recovery_offset == MaxSector &&
9316	9730	!test_bit(In_sync, &rdev->flags) &&
9317	9731	mddev->pers->spare_active(mddev))
9318		- sysfs_notify(&mddev->kobj, NULL, "degraded");
	9732	+ sysfs_notify_dirent_safe(mddev->sysfs_degraded);
9319	9733
9320	9734	put_page(swapout);
9321	9735	return 0;
..	..	@@ -9323,16 +9737,18 @@
9323	9737
9324	9738	void md_reload_sb(struct mddev *mddev, int nr)
9325	9739	{
9326		- struct md_rdev *rdev;
	9740	+ struct md_rdev rdev = NULL, iter;
9327	9741	int err;
9328	9742
9329	9743	/* Find the rdev */
9330		- rdev_for_each_rcu(rdev, mddev) {
9331		- if (rdev->desc_nr == nr)
	9744	+ rdev_for_each_rcu(iter, mddev) {
	9745	+ if (iter->desc_nr == nr) {
	9746	+ rdev = iter;
9332	9747	break;
	9748	+ }
9333	9749	}
9334	9750
9335		- if (!rdev \|\| rdev->desc_nr != nr) {
	9751	+ if (!rdev) {
9336	9752	pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
9337	9753	return;
9338	9754	}
..	..	@@ -9378,7 +9794,7 @@
9378	9794	}
9379	9795	}
9380	9796
9381		-static void autostart_arrays(int part)
	9797	+void md_autostart_arrays(int part)
9382	9798	{
9383	9799	struct md_rdev *rdev;
9384	9800	struct detected_devices_node *node_detected_dev;
..	..	@@ -9457,6 +9873,7 @@
9457	9873	* destroy_workqueue() below will wait for that to complete.
9458	9874	*/
9459	9875	}
	9876	+ destroy_workqueue(md_rdev_misc_wq);
9460	9877	destroy_workqueue(md_misc_wq);
9461	9878	destroy_workqueue(md_wq);
9462	9879	}
..	..	@@ -9466,7 +9883,7 @@
9466	9883
9467	9884	static int get_ro(char buffer, const struct kernel_param kp)
9468	9885	{
9469		- return sprintf(buffer, "%d", start_readonly);
	9886	+ return sprintf(buffer, "%d\n", start_readonly);
9470	9887	}
9471	9888	static int set_ro(const char val, const struct kernel_param kp)
9472	9889	{