1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Partial Parity Log for closing the RAID5 write hole
4	* Copyright (c) 2017, Intel Corporation.
5	*/
6
7	#include <linux/kernel.h>
8	#include <linux/blkdev.h>
9	#include <linux/slab.h>
10	#include <linux/crc32c.h>
11	#include <linux/async_tx.h>
12	#include <linux/raid/md_p.h>
13	#include "md.h"
14	#include "raid5.h"
15	#include "raid5-log.h"
16
17	/*
18	* PPL consists of a 4KB header (struct ppl_header) and at least 128KB for
19	* partial parity data. The header contains an array of entries
20	* (struct ppl_header_entry) which describe the logged write requests.
21	* Partial parity for the entries comes after the header, written in the same
22	* sequence as the entries:
23	*
24	* Header
25	* entry0
26	* ...
27	* entryN
28	* PP data
29	* PP for entry0
30	* ...
31	* PP for entryN
32	*
33	* An entry describes one or more consecutive stripe_heads, up to a full
34	* stripe. The modifed raid data chunks form an m-by-n matrix, where m is the
35	* number of stripe_heads in the entry and n is the number of modified data
36	* disks. Every stripe_head in the entry must write to the same data disks.
37	* An example of a valid case described by a single entry (writes to the first
38	* stripe of a 4 disk array, 16k chunk size):
39	*
40	* sh->sector dd0 dd1 dd2 ppl
41	* +-----+-----+-----+
42	* 0 | --- | --- | --- | +----+
43	* 8 | -W- | -W- | --- | | pp | data_sector = 8
44	* 16 | -W- | -W- | --- | | pp | data_size = 3 * 2 * 4k
45	* 24 | -W- | -W- | --- | | pp | pp_size = 3 * 4k
46	* +-----+-----+-----+ +----+
47	*
48	* data_sector is the first raid sector of the modified data, data_size is the
49	* total size of modified data and pp_size is the size of partial parity for
50	* this entry. Entries for full stripe writes contain no partial parity
51	* (pp_size = 0), they only mark the stripes for which parity should be
52	* recalculated after an unclean shutdown. Every entry holds a checksum of its
53	* partial parity, the header also has a checksum of the header itself.
54	*
55	* A write request is always logged to the PPL instance stored on the parity
56	* disk of the corresponding stripe. For each member disk there is one ppl_log
57	* used to handle logging for this disk, independently from others. They are
58	* grouped in child_logs array in struct ppl_conf, which is assigned to
59	* r5conf->log_private.
60	*
61	* ppl_io_unit represents a full PPL write, header_page contains the ppl_header.
62	* PPL entries for logged stripes are added in ppl_log_stripe(). A stripe_head
63	* can be appended to the last entry if it meets the conditions for a valid
64	* entry described above, otherwise a new entry is added. Checksums of entries
65	* are calculated incrementally as stripes containing partial parity are being
66	* added. ppl_submit_iounit() calculates the checksum of the header and submits
67	* a bio containing the header page and partial parity pages (sh->ppl_page) for
68	* all stripes of the io_unit. When the PPL write completes, the stripes
69	* associated with the io_unit are released and raid5d starts writing their data
70	* and parity. When all stripes are written, the io_unit is freed and the next
71	* can be submitted.
72	*
73	* An io_unit is used to gather stripes until it is submitted or becomes full
74	* (if the maximum number of entries or size of PPL is reached). Another io_unit
75	* can't be submitted until the previous has completed (PPL and stripe
76	* data+parity is written). The log->io_list tracks all io_units of a log
77	* (for a single member disk). New io_units are added to the end of the list
78	* and the first io_unit is submitted, if it is not submitted already.
79	* The current io_unit accepting new stripes is always at the end of the list.
80	*
81	* If write-back cache is enabled for any of the disks in the array, its data
82	* must be flushed before next io_unit is submitted.
83	*/
84
85	#define PPL_SPACE_SIZE (128 * 1024)
86
87	struct ppl_conf {
88	struct mddev *mddev;
89
90	/* array of child logs, one for each raid disk */
91	struct ppl_log *child_logs;
92	int count;
93
94	int block_size; /* the logical block size used for data_sector
95	* in ppl_header_entry */
96	u32 signature; /* raid array identifier */
97	atomic64_t seq; /* current log write sequence number */
98
99	struct kmem_cache *io_kc;
100	mempool_t io_pool;
101	struct bio_set bs;
102	struct bio_set flush_bs;
103
104	/* used only for recovery */
105	int recovered_entries;
106	int mismatch_count;
107
108	/* stripes to retry if failed to allocate io_unit */
109	struct list_head no_mem_stripes;
110	spinlock_t no_mem_stripes_lock;
111
112	unsigned short write_hint;
113	};
114
115	struct ppl_log {
116	struct ppl_conf *ppl_conf; /* shared between all log instances */
117
118	struct md_rdev *rdev; /* array member disk associated with
119	* this log instance */
120	struct mutex io_mutex;
121	struct ppl_io_unit *current_io; /* current io_unit accepting new data
122	* always at the end of io_list */
123	spinlock_t io_list_lock;
124	struct list_head io_list; /* all io_units of this log */
125
126	sector_t next_io_sector;
127	unsigned int entry_space;
128	bool use_multippl;
129	bool wb_cache_on;
130	unsigned long disk_flush_bitmap;
131	};
132
133	#define PPL_IO_INLINE_BVECS 32
134
135	struct ppl_io_unit {
136	struct ppl_log *log;
137
138	struct page *header_page; /* for ppl_header */
139
140	unsigned int entries_count; /* number of entries in ppl_header */
141	unsigned int pp_size; /* total size current of partial parity */
142
143	u64 seq; /* sequence number of this log write */
144	struct list_head log_sibling; /* log->io_list */
145
146	struct list_head stripe_list; /* stripes added to the io_unit */
147	atomic_t pending_stripes; /* how many stripes not written to raid */
148	atomic_t pending_flushes; /* how many disk flushes are in progress */
149
150	bool submitted; /* true if write to log started */
151
152	/* inline bio and its biovec for submitting the iounit */
153	struct bio bio;
154	struct bio_vec biovec[PPL_IO_INLINE_BVECS];
155	};
156
157	struct dma_async_tx_descriptor *
158	ops_run_partial_parity(struct stripe_head *sh, struct raid5_percpu *percpu,
159	struct dma_async_tx_descriptor *tx)
160	{
161	int disks = sh->disks;
162	struct page **srcs = percpu->scribble;
163	int count = 0, pd_idx = sh->pd_idx, i;
164	struct async_submit_ctl submit;
165
166	pr_debug("%s: stripe %llu\n", __func__, (unsigned long long)sh->sector);
167
168	/*
169	* Partial parity is the XOR of stripe data chunks that are not changed
170	* during the write request. Depending on available data
171	* (read-modify-write vs. reconstruct-write case) we calculate it
172	* differently.
173	*/
174	if (sh->reconstruct_state == reconstruct_state_prexor_drain_run) {
175	/*
176	* rmw: xor old data and parity from updated disks
177	* This is calculated earlier by ops_run_prexor5() so just copy
178	* the parity dev page.
179	*/
180	srcs[count++] = sh->dev[pd_idx].page;
181	} else if (sh->reconstruct_state == reconstruct_state_drain_run) {
182	/* rcw: xor data from all not updated disks */
183	for (i = disks; i--;) {
184	struct r5dev *dev = &sh->dev[i];
185	if (test_bit(R5_UPTODATE, &dev->flags))
186	srcs[count++] = dev->page;
187	}
188	} else {
189	return tx;
190	}
191
192	init_async_submit(args: &submit, flags: ASYNC_TX_FENCE|ASYNC_TX_XOR_ZERO_DST, tx,
193	NULL, cb_param: sh, scribble: (void *) (srcs + sh->disks + 2));
194
195	if (count == 1)
196	tx = async_memcpy(dest: sh->ppl_page, src: srcs[0], dest_offset: 0, src_offset: 0, PAGE_SIZE,
197	submit: &submit);
198	else
199	tx = async_xor(dest: sh->ppl_page, src_list: srcs, offset: 0, src_cnt: count, PAGE_SIZE,
200	submit: &submit);
201
202	return tx;
203	}
204
205	static void *ppl_io_pool_alloc(gfp_t gfp_mask, void *pool_data)
206	{
207	struct kmem_cache *kc = pool_data;
208	struct ppl_io_unit *io;
209
210	io = kmem_cache_alloc(cachep: kc, flags: gfp_mask);
211	if (!io)
212	return NULL;
213
214	io->header_page = alloc_page(gfp_mask);
215	if (!io->header_page) {
216	kmem_cache_free(s: kc, objp: io);
217	return NULL;
218	}
219
220	return io;
221	}
222
223	static void ppl_io_pool_free(void *element, void *pool_data)
224	{
225	struct kmem_cache *kc = pool_data;
226	struct ppl_io_unit *io = element;
227
228	__free_page(io->header_page);
229	kmem_cache_free(s: kc, objp: io);
230	}
231
232	static struct ppl_io_unit *ppl_new_iounit(struct ppl_log *log,
233	struct stripe_head *sh)
234	{
235	struct ppl_conf *ppl_conf = log->ppl_conf;
236	struct ppl_io_unit *io;
237	struct ppl_header *pplhdr;
238	struct page *header_page;
239
240	io = mempool_alloc(pool: &ppl_conf->io_pool, GFP_NOWAIT);
241	if (!io)
242	return NULL;
243
244	header_page = io->header_page;
245	memset(io, 0, sizeof(*io));
246	io->header_page = header_page;
247
248	io->log = log;
249	INIT_LIST_HEAD(list: &io->log_sibling);
250	INIT_LIST_HEAD(list: &io->stripe_list);
251	atomic_set(v: &io->pending_stripes, i: 0);
252	atomic_set(v: &io->pending_flushes, i: 0);
253	bio_init(bio: &io->bio, bdev: log->rdev->bdev, table: io->biovec, PPL_IO_INLINE_BVECS,
254	opf: REQ_OP_WRITE | REQ_FUA);
255
256	pplhdr = page_address(io->header_page);
257	clear_page(page: pplhdr);
258	memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED);
259	pplhdr->signature = cpu_to_le32(ppl_conf->signature);
260
261	io->seq = atomic64_add_return(i: 1, v: &ppl_conf->seq);
262	pplhdr->generation = cpu_to_le64(io->seq);
263
264	return io;
265	}
266
267	static int ppl_log_stripe(struct ppl_log *log, struct stripe_head *sh)
268	{
269	struct ppl_io_unit *io = log->current_io;
270	struct ppl_header_entry *e = NULL;
271	struct ppl_header *pplhdr;
272	int i;
273	sector_t data_sector = 0;
274	int data_disks = 0;
275	struct r5conf *conf = sh->raid_conf;
276
277	pr_debug("%s: stripe: %llu\n", __func__, (unsigned long long)sh->sector);
278
279	/* check if current io_unit is full */
280	if (io && (io->pp_size == log->entry_space ||
281	io->entries_count == PPL_HDR_MAX_ENTRIES)) {
282	pr_debug("%s: add io_unit blocked by seq: %llu\n",
283	__func__, io->seq);
284	io = NULL;
285	}
286
287	/* add a new unit if there is none or the current is full */
288	if (!io) {
289	io = ppl_new_iounit(log, sh);
290	if (!io)
291	return -ENOMEM;
292	spin_lock_irq(lock: &log->io_list_lock);
293	list_add_tail(new: &io->log_sibling, head: &log->io_list);
294	spin_unlock_irq(lock: &log->io_list_lock);
295
296	log->current_io = io;
297	}
298
299	for (i = 0; i < sh->disks; i++) {
300	struct r5dev *dev = &sh->dev[i];
301
302	if (i != sh->pd_idx && test_bit(R5_Wantwrite, &dev->flags)) {
303	if (!data_disks || dev->sector < data_sector)
304	data_sector = dev->sector;
305	data_disks++;
306	}
307	}
308	BUG_ON(!data_disks);
309
310	pr_debug("%s: seq: %llu data_sector: %llu data_disks: %d\n", __func__,
311	io->seq, (unsigned long long)data_sector, data_disks);
312
313	pplhdr = page_address(io->header_page);
314
315	if (io->entries_count > 0) {
316	struct ppl_header_entry *last =
317	&pplhdr->entries[io->entries_count - 1];
318	struct stripe_head *sh_last = list_last_entry(
319	&io->stripe_list, struct stripe_head, log_list);
320	u64 data_sector_last = le64_to_cpu(last->data_sector);
321	u32 data_size_last = le32_to_cpu(last->data_size);
322
323	/*
324	* Check if we can append the stripe to the last entry. It must
325	* be just after the last logged stripe and write to the same
326	* disks. Use bit shift and logarithm to avoid 64-bit division.
327	*/
328	if ((sh->sector == sh_last->sector + RAID5_STRIPE_SECTORS(conf)) &&
329	(data_sector >> ilog2(conf->chunk_sectors) ==
330	data_sector_last >> ilog2(conf->chunk_sectors)) &&
331	((data_sector - data_sector_last) * data_disks ==
332	data_size_last >> 9))
333	e = last;
334	}
335
336	if (!e) {
337	e = &pplhdr->entries[io->entries_count++];
338	e->data_sector = cpu_to_le64(data_sector);
339	e->parity_disk = cpu_to_le32(sh->pd_idx);
340	e->checksum = cpu_to_le32(~0);
341	}
342
343	le32_add_cpu(var: &e->data_size, val: data_disks << PAGE_SHIFT);
344
345	/* don't write any PP if full stripe write */
346	if (!test_bit(STRIPE_FULL_WRITE, &sh->state)) {
347	le32_add_cpu(var: &e->pp_size, PAGE_SIZE);
348	io->pp_size += PAGE_SIZE;
349	e->checksum = cpu_to_le32(crc32c_le(le32_to_cpu(e->checksum),
350	page_address(sh->ppl_page),
351	PAGE_SIZE));
352	}
353
354	list_add_tail(new: &sh->log_list, head: &io->stripe_list);
355	atomic_inc(v: &io->pending_stripes);
356	sh->ppl_io = io;
357
358	return 0;
359	}
360
361	int ppl_write_stripe(struct r5conf *conf, struct stripe_head *sh)
362	{
363	struct ppl_conf *ppl_conf = conf->log_private;
364	struct ppl_io_unit *io = sh->ppl_io;
365	struct ppl_log *log;
366
367	if (io || test_bit(STRIPE_SYNCING, &sh->state) || !sh->ppl_page ||
368	!test_bit(R5_Wantwrite, &sh->dev[sh->pd_idx].flags) ||
369	!test_bit(R5_Insync, &sh->dev[sh->pd_idx].flags)) {
370	clear_bit(nr: STRIPE_LOG_TRAPPED, addr: &sh->state);
371	return -EAGAIN;
372	}
373
374	log = &ppl_conf->child_logs[sh->pd_idx];
375
376	mutex_lock(&log->io_mutex);
377
378	if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) {
379	mutex_unlock(lock: &log->io_mutex);
380	return -EAGAIN;
381	}
382
383	set_bit(nr: STRIPE_LOG_TRAPPED, addr: &sh->state);
384	clear_bit(nr: STRIPE_DELAYED, addr: &sh->state);
385	atomic_inc(v: &sh->count);
386
387	if (ppl_log_stripe(log, sh)) {
388	spin_lock_irq(lock: &ppl_conf->no_mem_stripes_lock);
389	list_add_tail(new: &sh->log_list, head: &ppl_conf->no_mem_stripes);
390	spin_unlock_irq(lock: &ppl_conf->no_mem_stripes_lock);
391	}
392
393	mutex_unlock(lock: &log->io_mutex);
394
395	return 0;
396	}
397
398	static void ppl_log_endio(struct bio *bio)
399	{
400	struct ppl_io_unit *io = bio->bi_private;
401	struct ppl_log *log = io->log;
402	struct ppl_conf *ppl_conf = log->ppl_conf;
403	struct stripe_head *sh, *next;
404
405	pr_debug("%s: seq: %llu\n", __func__, io->seq);
406
407	if (bio->bi_status)
408	md_error(mddev: ppl_conf->mddev, rdev: log->rdev);
409
410	list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) {
411	list_del_init(entry: &sh->log_list);
412
413	set_bit(nr: STRIPE_HANDLE, addr: &sh->state);
414	raid5_release_stripe(sh);
415	}
416	}
417
418	static void ppl_submit_iounit_bio(struct ppl_io_unit *io, struct bio *bio)
419	{
420	pr_debug("%s: seq: %llu size: %u sector: %llu dev: %pg\n",
421	__func__, io->seq, bio->bi_iter.bi_size,
422	(unsigned long long)bio->bi_iter.bi_sector,
423	bio->bi_bdev);
424
425	submit_bio(bio);
426	}
427
428	static void ppl_submit_iounit(struct ppl_io_unit *io)
429	{
430	struct ppl_log *log = io->log;
431	struct ppl_conf *ppl_conf = log->ppl_conf;
432	struct ppl_header *pplhdr = page_address(io->header_page);
433	struct bio *bio = &io->bio;
434	struct stripe_head *sh;
435	int i;
436
437	bio->bi_private = io;
438
439	if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) {
440	ppl_log_endio(bio);
441	return;
442	}
443
444	for (i = 0; i < io->entries_count; i++) {
445	struct ppl_header_entry *e = &pplhdr->entries[i];
446
447	pr_debug("%s: seq: %llu entry: %d data_sector: %llu pp_size: %u data_size: %u\n",
448	__func__, io->seq, i, le64_to_cpu(e->data_sector),
449	le32_to_cpu(e->pp_size), le32_to_cpu(e->data_size));
450
451	e->data_sector = cpu_to_le64(le64_to_cpu(e->data_sector) >>
452	ilog2(ppl_conf->block_size >> 9));
453	e->checksum = cpu_to_le32(~le32_to_cpu(e->checksum));
454	}
455
456	pplhdr->entries_count = cpu_to_le32(io->entries_count);
457	pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PPL_HEADER_SIZE));
458
459	/* Rewind the buffer if current PPL is larger then remaining space */
460	if (log->use_multippl &&
461	log->rdev->ppl.sector + log->rdev->ppl.size - log->next_io_sector <
462	(PPL_HEADER_SIZE + io->pp_size) >> 9)
463	log->next_io_sector = log->rdev->ppl.sector;
464
465
466	bio->bi_end_io = ppl_log_endio;
467	bio->bi_iter.bi_sector = log->next_io_sector;
468	__bio_add_page(bio, page: io->header_page, PAGE_SIZE, off: 0);
469
470	pr_debug("%s: log->current_io_sector: %llu\n", __func__,
471	(unsigned long long)log->next_io_sector);
472
473	if (log->use_multippl)
474	log->next_io_sector += (PPL_HEADER_SIZE + io->pp_size) >> 9;
475
476	WARN_ON(log->disk_flush_bitmap != 0);
477
478	list_for_each_entry(sh, &io->stripe_list, log_list) {
479	for (i = 0; i < sh->disks; i++) {
480	struct r5dev *dev = &sh->dev[i];
481
482	if ((ppl_conf->child_logs[i].wb_cache_on) &&
483	(test_bit(R5_Wantwrite, &dev->flags))) {
484	set_bit(nr: i, addr: &log->disk_flush_bitmap);
485	}
486	}
487
488	/* entries for full stripe writes have no partial parity */
489	if (test_bit(STRIPE_FULL_WRITE, &sh->state))
490	continue;
491
492	if (!bio_add_page(bio, page: sh->ppl_page, PAGE_SIZE, off: 0)) {
493	struct bio *prev = bio;
494
495	bio = bio_alloc_bioset(bdev: prev->bi_bdev, BIO_MAX_VECS,
496	opf: prev->bi_opf, GFP_NOIO,
497	bs: &ppl_conf->bs);
498	bio->bi_iter.bi_sector = bio_end_sector(prev);
499	__bio_add_page(bio, page: sh->ppl_page, PAGE_SIZE, off: 0);
500
501	bio_chain(bio, prev);
502	ppl_submit_iounit_bio(io, bio: prev);
503	}
504	}
505
506	ppl_submit_iounit_bio(io, bio);
507	}
508
509	static void ppl_submit_current_io(struct ppl_log *log)
510	{
511	struct ppl_io_unit *io;
512
513	spin_lock_irq(lock: &log->io_list_lock);
514
515	io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit,
516	log_sibling);
517	if (io && io->submitted)
518	io = NULL;
519
520	spin_unlock_irq(lock: &log->io_list_lock);
521
522	if (io) {
523	io->submitted = true;
524
525	if (io == log->current_io)
526	log->current_io = NULL;
527
528	ppl_submit_iounit(io);
529	}
530	}
531
532	void ppl_write_stripe_run(struct r5conf *conf)
533	{
534	struct ppl_conf *ppl_conf = conf->log_private;
535	struct ppl_log *log;
536	int i;
537
538	for (i = 0; i < ppl_conf->count; i++) {
539	log = &ppl_conf->child_logs[i];
540
541	mutex_lock(&log->io_mutex);
542	ppl_submit_current_io(log);
543	mutex_unlock(lock: &log->io_mutex);
544	}
545	}
546
547	static void ppl_io_unit_finished(struct ppl_io_unit *io)
548	{
549	struct ppl_log *log = io->log;
550	struct ppl_conf *ppl_conf = log->ppl_conf;
551	struct r5conf *conf = ppl_conf->mddev->private;
552	unsigned long flags;
553
554	pr_debug("%s: seq: %llu\n", __func__, io->seq);
555
556	local_irq_save(flags);
557
558	spin_lock(lock: &log->io_list_lock);
559	list_del(entry: &io->log_sibling);
560	spin_unlock(lock: &log->io_list_lock);
561
562	mempool_free(element: io, pool: &ppl_conf->io_pool);
563
564	spin_lock(lock: &ppl_conf->no_mem_stripes_lock);
565	if (!list_empty(head: &ppl_conf->no_mem_stripes)) {
566	struct stripe_head *sh;
567
568	sh = list_first_entry(&ppl_conf->no_mem_stripes,
569	struct stripe_head, log_list);
570	list_del_init(entry: &sh->log_list);
571	set_bit(nr: STRIPE_HANDLE, addr: &sh->state);
572	raid5_release_stripe(sh);
573	}
574	spin_unlock(lock: &ppl_conf->no_mem_stripes_lock);
575
576	local_irq_restore(flags);
577
578	wake_up(&conf->wait_for_quiescent);
579	}
580
581	static void ppl_flush_endio(struct bio *bio)
582	{
583	struct ppl_io_unit *io = bio->bi_private;
584	struct ppl_log *log = io->log;
585	struct ppl_conf *ppl_conf = log->ppl_conf;
586	struct r5conf *conf = ppl_conf->mddev->private;
587
588	pr_debug("%s: dev: %pg\n", __func__, bio->bi_bdev);
589
590	if (bio->bi_status) {
591	struct md_rdev *rdev;
592
593	rcu_read_lock();
594	rdev = md_find_rdev_rcu(mddev: conf->mddev, bio_dev(bio));
595	if (rdev)
596	md_error(mddev: rdev->mddev, rdev);
597	rcu_read_unlock();
598	}
599
600	bio_put(bio);
601
602	if (atomic_dec_and_test(v: &io->pending_flushes)) {
603	ppl_io_unit_finished(io);
604	md_wakeup_thread(thread: conf->mddev->thread);
605	}
606	}
607
608	static void ppl_do_flush(struct ppl_io_unit *io)
609	{
610	struct ppl_log *log = io->log;
611	struct ppl_conf *ppl_conf = log->ppl_conf;
612	struct r5conf *conf = ppl_conf->mddev->private;
613	int raid_disks = conf->raid_disks;
614	int flushed_disks = 0;
615	int i;
616
617	atomic_set(v: &io->pending_flushes, i: raid_disks);
618
619	for_each_set_bit(i, &log->disk_flush_bitmap, raid_disks) {
620	struct md_rdev *rdev;
621	struct block_device *bdev = NULL;
622
623	rcu_read_lock();
624	rdev = rcu_dereference(conf->disks[i].rdev);
625	if (rdev && !test_bit(Faulty, &rdev->flags))
626	bdev = rdev->bdev;
627	rcu_read_unlock();
628
629	if (bdev) {
630	struct bio *bio;
631
632	bio = bio_alloc_bioset(bdev, nr_vecs: 0,
633	opf: REQ_OP_WRITE | REQ_PREFLUSH,
634	GFP_NOIO, bs: &ppl_conf->flush_bs);
635	bio->bi_private = io;
636	bio->bi_end_io = ppl_flush_endio;
637
638	pr_debug("%s: dev: %ps\n", __func__, bio->bi_bdev);
639
640	submit_bio(bio);
641	flushed_disks++;
642	}
643	}
644
645	log->disk_flush_bitmap = 0;
646
647	for (i = flushed_disks ; i < raid_disks; i++) {
648	if (atomic_dec_and_test(v: &io->pending_flushes))
649	ppl_io_unit_finished(io);
650	}
651	}
652
653	static inline bool ppl_no_io_unit_submitted(struct r5conf *conf,
654	struct ppl_log *log)
655	{
656	struct ppl_io_unit *io;
657
658	io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit,
659	log_sibling);
660
661	return !io || !io->submitted;
662	}
663
664	void ppl_quiesce(struct r5conf *conf, int quiesce)
665	{
666	struct ppl_conf *ppl_conf = conf->log_private;
667	int i;
668
669	if (quiesce) {
670	for (i = 0; i < ppl_conf->count; i++) {
671	struct ppl_log *log = &ppl_conf->child_logs[i];
672
673	spin_lock_irq(lock: &log->io_list_lock);
674	wait_event_lock_irq(conf->wait_for_quiescent,
675	ppl_no_io_unit_submitted(conf, log),
676	log->io_list_lock);
677	spin_unlock_irq(lock: &log->io_list_lock);
678	}
679	}
680	}
681
682	int ppl_handle_flush_request(struct bio *bio)
683	{
684	if (bio->bi_iter.bi_size == 0) {
685	bio_endio(bio);
686	return 0;
687	}
688	bio->bi_opf &= ~REQ_PREFLUSH;
689	return -EAGAIN;
690	}
691
692	void ppl_stripe_write_finished(struct stripe_head *sh)
693	{
694	struct ppl_io_unit *io;
695
696	io = sh->ppl_io;
697	sh->ppl_io = NULL;
698
699	if (io && atomic_dec_and_test(v: &io->pending_stripes)) {
700	if (io->log->disk_flush_bitmap)
701	ppl_do_flush(io);
702	else
703	ppl_io_unit_finished(io);
704	}
705	}
706
707	static void ppl_xor(int size, struct page *page1, struct page *page2)
708	{
709	struct async_submit_ctl submit;
710	struct dma_async_tx_descriptor *tx;
711	struct page *xor_srcs[] = { page1, page2 };
712
713	init_async_submit(args: &submit, flags: ASYNC_TX_ACK|ASYNC_TX_XOR_DROP_DST,
714	NULL, NULL, NULL, NULL);
715	tx = async_xor(dest: page1, src_list: xor_srcs, offset: 0, src_cnt: 2, len: size, submit: &submit);
716
717	async_tx_quiesce(tx: &tx);
718	}
719
720	/*
721	* PPL recovery strategy: xor partial parity and data from all modified data
722	* disks within a stripe and write the result as the new stripe parity. If all
723	* stripe data disks are modified (full stripe write), no partial parity is
724	* available, so just xor the data disks.
725	*
726	* Recovery of a PPL entry shall occur only if all modified data disks are
727	* available and read from all of them succeeds.
728	*
729	* A PPL entry applies to a stripe, partial parity size for an entry is at most
730	* the size of the chunk. Examples of possible cases for a single entry:
731	*
732	* case 0: single data disk write:
733	* data0 data1 data2 ppl parity
734	* +--------+--------+--------+ +--------------------+
735	* | ------ | ------ | ------ | +----+ | (no change) |
736	* | ------ | -data- | ------ | | pp | -> | data1 ^ pp |
737	* | ------ | -data- | ------ | | pp | -> | data1 ^ pp |
738	* | ------ | ------ | ------ | +----+ | (no change) |
739	* +--------+--------+--------+ +--------------------+
740	* pp_size = data_size
741	*
742	* case 1: more than one data disk write:
743	* data0 data1 data2 ppl parity
744	* +--------+--------+--------+ +--------------------+
745	* | ------ | ------ | ------ | +----+ | (no change) |
746	* | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp |
747	* | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp |
748	* | ------ | ------ | ------ | +----+ | (no change) |
749	* +--------+--------+--------+ +--------------------+
750	* pp_size = data_size / modified_data_disks
751	*
752	* case 2: write to all data disks (also full stripe write):
753	* data0 data1 data2 parity
754	* +--------+--------+--------+ +--------------------+
755	* | ------ | ------ | ------ | | (no change) |
756	* | -data- | -data- | -data- | --------> | xor all data |
757	* | ------ | ------ | ------ | --------> | (no change) |
758	* | ------ | ------ | ------ | | (no change) |
759	* +--------+--------+--------+ +--------------------+
760	* pp_size = 0
761	*
762	* The following cases are possible only in other implementations. The recovery
763	* code can handle them, but they are not generated at runtime because they can
764	* be reduced to cases 0, 1 and 2:
765	*
766	* case 3:
767	* data0 data1 data2 ppl parity
768	* +--------+--------+--------+ +----+ +--------------------+
769	* | ------ | -data- | -data- | | pp | | data1 ^ data2 ^ pp |
770	* | ------ | -data- | -data- | | pp | -> | data1 ^ data2 ^ pp |
771	* | -data- | -data- | -data- | | -- | -> | xor all data |
772	* | -data- | -data- | ------ | | pp | | data0 ^ data1 ^ pp |
773	* +--------+--------+--------+ +----+ +--------------------+
774	* pp_size = chunk_size
775	*
776	* case 4:
777	* data0 data1 data2 ppl parity
778	* +--------+--------+--------+ +----+ +--------------------+
779	* | ------ | -data- | ------ | | pp | | data1 ^ pp |
780	* | ------ | ------ | ------ | | -- | -> | (no change) |
781	* | ------ | ------ | ------ | | -- | -> | (no change) |
782	* | -data- | ------ | ------ | | pp | | data0 ^ pp |
783	* +--------+--------+--------+ +----+ +--------------------+
784	* pp_size = chunk_size
785	*/
786	static int ppl_recover_entry(struct ppl_log *log, struct ppl_header_entry *e,
787	sector_t ppl_sector)
788	{
789	struct ppl_conf *ppl_conf = log->ppl_conf;
790	struct mddev *mddev = ppl_conf->mddev;
791	struct r5conf *conf = mddev->private;
792	int block_size = ppl_conf->block_size;
793	struct page *page1;
794	struct page *page2;
795	sector_t r_sector_first;
796	sector_t r_sector_last;
797	int strip_sectors;
798	int data_disks;
799	int i;
800	int ret = 0;
801	unsigned int pp_size = le32_to_cpu(e->pp_size);
802	unsigned int data_size = le32_to_cpu(e->data_size);
803
804	page1 = alloc_page(GFP_KERNEL);
805	page2 = alloc_page(GFP_KERNEL);
806
807	if (!page1 || !page2) {
808	ret = -ENOMEM;
809	goto out;
810	}
811
812	r_sector_first = le64_to_cpu(e->data_sector) * (block_size >> 9);
813
814	if ((pp_size >> 9) < conf->chunk_sectors) {
815	if (pp_size > 0) {
816	data_disks = data_size / pp_size;
817	strip_sectors = pp_size >> 9;
818	} else {
819	data_disks = conf->raid_disks - conf->max_degraded;
820	strip_sectors = (data_size >> 9) / data_disks;
821	}
822	r_sector_last = r_sector_first +
823	(data_disks - 1) * conf->chunk_sectors +
824	strip_sectors;
825	} else {
826	data_disks = conf->raid_disks - conf->max_degraded;
827	strip_sectors = conf->chunk_sectors;
828	r_sector_last = r_sector_first + (data_size >> 9);
829	}
830
831	pr_debug("%s: array sector first: %llu last: %llu\n", __func__,
832	(unsigned long long)r_sector_first,
833	(unsigned long long)r_sector_last);
834
835	/* if start and end is 4k aligned, use a 4k block */
836	if (block_size == 512 &&
837	(r_sector_first & (RAID5_STRIPE_SECTORS(conf) - 1)) == 0 &&
838	(r_sector_last & (RAID5_STRIPE_SECTORS(conf) - 1)) == 0)
839	block_size = RAID5_STRIPE_SIZE(conf);
840
841	/* iterate through blocks in strip */
842	for (i = 0; i < strip_sectors; i += (block_size >> 9)) {
843	bool update_parity = false;
844	sector_t parity_sector;
845	struct md_rdev *parity_rdev;
846	struct stripe_head sh;
847	int disk;
848	int indent = 0;
849
850	pr_debug("%s:%*s iter %d start\n", __func__, indent, "", i);
851	indent += 2;
852
853	memset(page_address(page1), 0, PAGE_SIZE);
854
855	/* iterate through data member disks */
856	for (disk = 0; disk < data_disks; disk++) {
857	int dd_idx;
858	struct md_rdev *rdev;
859	sector_t sector;
860	sector_t r_sector = r_sector_first + i +
861	(disk * conf->chunk_sectors);
862
863	pr_debug("%s:%*s data member disk %d start\n",
864	__func__, indent, "", disk);
865	indent += 2;
866
867	if (r_sector >= r_sector_last) {
868	pr_debug("%s:%*s array sector %llu doesn't need parity update\n",
869	__func__, indent, "",
870	(unsigned long long)r_sector);
871	indent -= 2;
872	continue;
873	}
874
875	update_parity = true;
876
877	/* map raid sector to member disk */
878	sector = raid5_compute_sector(conf, r_sector, previous: 0,
879	dd_idx: &dd_idx, NULL);
880	pr_debug("%s:%*s processing array sector %llu => data member disk %d, sector %llu\n",
881	__func__, indent, "",
882	(unsigned long long)r_sector, dd_idx,
883	(unsigned long long)sector);
884
885	/* Array has not started so rcu dereference is safe */
886	rdev = rcu_dereference_protected(
887	conf->disks[dd_idx].rdev, 1);
888	if (!rdev || (!test_bit(In_sync, &rdev->flags) &&
889	sector >= rdev->recovery_offset)) {
890	pr_debug("%s:%*s data member disk %d missing\n",
891	__func__, indent, "", dd_idx);
892	update_parity = false;
893	break;
894	}
895
896	pr_debug("%s:%*s reading data member disk %pg sector %llu\n",
897	__func__, indent, "", rdev->bdev,
898	(unsigned long long)sector);
899	if (!sync_page_io(rdev, sector, size: block_size, page: page2,
900	opf: REQ_OP_READ, metadata_op: false)) {
901	md_error(mddev, rdev);
902	pr_debug("%s:%*s read failed!\n", __func__,
903	indent, "");
904	ret = -EIO;
905	goto out;
906	}
907
908	ppl_xor(size: block_size, page1, page2);
909
910	indent -= 2;
911	}
912
913	if (!update_parity)
914	continue;
915
916	if (pp_size > 0) {
917	pr_debug("%s:%*s reading pp disk sector %llu\n",
918	__func__, indent, "",
919	(unsigned long long)(ppl_sector + i));
920	if (!sync_page_io(rdev: log->rdev,
921	sector: ppl_sector - log->rdev->data_offset + i,
922	size: block_size, page: page2, opf: REQ_OP_READ,
923	metadata_op: false)) {
924	pr_debug("%s:%*s read failed!\n", __func__,
925	indent, "");
926	md_error(mddev, rdev: log->rdev);
927	ret = -EIO;
928	goto out;
929	}
930
931	ppl_xor(size: block_size, page1, page2);
932	}
933
934	/* map raid sector to parity disk */
935	parity_sector = raid5_compute_sector(conf, r_sector: r_sector_first + i,
936	previous: 0, dd_idx: &disk, sh: &sh);
937	BUG_ON(sh.pd_idx != le32_to_cpu(e->parity_disk));
938
939	/* Array has not started so rcu dereference is safe */
940	parity_rdev = rcu_dereference_protected(
941	conf->disks[sh.pd_idx].rdev, 1);
942
943	BUG_ON(parity_rdev->bdev->bd_dev != log->rdev->bdev->bd_dev);
944	pr_debug("%s:%*s write parity at sector %llu, disk %pg\n",
945	__func__, indent, "",
946	(unsigned long long)parity_sector,
947	parity_rdev->bdev);
948	if (!sync_page_io(rdev: parity_rdev, sector: parity_sector, size: block_size,
949	page: page1, opf: REQ_OP_WRITE, metadata_op: false)) {
950	pr_debug("%s:%*s parity write error!\n", __func__,
951	indent, "");
952	md_error(mddev, rdev: parity_rdev);
953	ret = -EIO;
954	goto out;
955	}
956	}
957	out:
958	if (page1)
959	__free_page(page1);
960	if (page2)
961	__free_page(page2);
962	return ret;
963	}
964
965	static int ppl_recover(struct ppl_log *log, struct ppl_header *pplhdr,
966	sector_t offset)
967	{
968	struct ppl_conf *ppl_conf = log->ppl_conf;
969	struct md_rdev *rdev = log->rdev;
970	struct mddev *mddev = rdev->mddev;
971	sector_t ppl_sector = rdev->ppl.sector + offset +
972	(PPL_HEADER_SIZE >> 9);
973	struct page *page;
974	int i;
975	int ret = 0;
976
977	page = alloc_page(GFP_KERNEL);
978	if (!page)
979	return -ENOMEM;
980
981	/* iterate through all PPL entries saved */
982	for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++) {
983	struct ppl_header_entry *e = &pplhdr->entries[i];
984	u32 pp_size = le32_to_cpu(e->pp_size);
985	sector_t sector = ppl_sector;
986	int ppl_entry_sectors = pp_size >> 9;
987	u32 crc, crc_stored;
988
989	pr_debug("%s: disk: %d entry: %d ppl_sector: %llu pp_size: %u\n",
990	__func__, rdev->raid_disk, i,
991	(unsigned long long)ppl_sector, pp_size);
992
993	crc = ~0;
994	crc_stored = le32_to_cpu(e->checksum);
995
996	/* read parial parity for this entry and calculate its checksum */
997	while (pp_size) {
998	int s = pp_size > PAGE_SIZE ? PAGE_SIZE : pp_size;
999
1000	if (!sync_page_io(rdev, sector: sector - rdev->data_offset,
1001	size: s, page, opf: REQ_OP_READ, metadata_op: false)) {
1002	md_error(mddev, rdev);
1003	ret = -EIO;
1004	goto out;
1005	}
1006
1007	crc = crc32c_le(crc, page_address(page), length: s);
1008
1009	pp_size -= s;
1010	sector += s >> 9;
1011	}
1012
1013	crc = ~crc;
1014
1015	if (crc != crc_stored) {
1016	/*
1017	* Don't recover this entry if the checksum does not
1018	* match, but keep going and try to recover other
1019	* entries.
1020	*/
1021	pr_debug("%s: ppl entry crc does not match: stored: 0x%x calculated: 0x%x\n",
1022	__func__, crc_stored, crc);
1023	ppl_conf->mismatch_count++;
1024	} else {
1025	ret = ppl_recover_entry(log, e, ppl_sector);
1026	if (ret)
1027	goto out;
1028	ppl_conf->recovered_entries++;
1029	}
1030
1031	ppl_sector += ppl_entry_sectors;
1032	}
1033
1034	/* flush the disk cache after recovery if necessary */
1035	ret = blkdev_issue_flush(bdev: rdev->bdev);
1036	out:
1037	__free_page(page);
1038	return ret;
1039	}
1040
1041	static int ppl_write_empty_header(struct ppl_log *log)
1042	{
1043	struct page *page;
1044	struct ppl_header *pplhdr;
1045	struct md_rdev *rdev = log->rdev;
1046	int ret = 0;
1047
1048	pr_debug("%s: disk: %d ppl_sector: %llu\n", __func__,
1049	rdev->raid_disk, (unsigned long long)rdev->ppl.sector);
1050
1051	page = alloc_page(GFP_NOIO | __GFP_ZERO);
1052	if (!page)
1053	return -ENOMEM;
1054
1055	pplhdr = page_address(page);
1056	/* zero out PPL space to avoid collision with old PPLs */
1057	blkdev_issue_zeroout(bdev: rdev->bdev, sector: rdev->ppl.sector,
1058	nr_sects: log->rdev->ppl.size, GFP_NOIO, flags: 0);
1059	memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED);
1060	pplhdr->signature = cpu_to_le32(log->ppl_conf->signature);
1061	pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PAGE_SIZE));
1062
1063	if (!sync_page_io(rdev, sector: rdev->ppl.sector - rdev->data_offset,
1064	PPL_HEADER_SIZE, page, opf: REQ_OP_WRITE | REQ_SYNC |
1065	REQ_FUA, metadata_op: false)) {
1066	md_error(mddev: rdev->mddev, rdev);
1067	ret = -EIO;
1068	}
1069
1070	__free_page(page);
1071	return ret;
1072	}
1073
1074	static int ppl_load_distributed(struct ppl_log *log)
1075	{
1076	struct ppl_conf *ppl_conf = log->ppl_conf;
1077	struct md_rdev *rdev = log->rdev;
1078	struct mddev *mddev = rdev->mddev;
1079	struct page *page, *page2;
1080	struct ppl_header *pplhdr = NULL, *prev_pplhdr = NULL;
1081	u32 crc, crc_stored;
1082	u32 signature;
1083	int ret = 0, i;
1084	sector_t pplhdr_offset = 0, prev_pplhdr_offset = 0;
1085
1086	pr_debug("%s: disk: %d\n", __func__, rdev->raid_disk);
1087	/* read PPL headers, find the recent one */
1088	page = alloc_page(GFP_KERNEL);
1089	if (!page)
1090	return -ENOMEM;
1091
1092	page2 = alloc_page(GFP_KERNEL);
1093	if (!page2) {
1094	__free_page(page);
1095	return -ENOMEM;
1096	}
1097
1098	/* searching ppl area for latest ppl */
1099	while (pplhdr_offset < rdev->ppl.size - (PPL_HEADER_SIZE >> 9)) {
1100	if (!sync_page_io(rdev,
1101	sector: rdev->ppl.sector - rdev->data_offset +
1102	pplhdr_offset, PAGE_SIZE, page, opf: REQ_OP_READ,
1103	metadata_op: false)) {
1104	md_error(mddev, rdev);
1105	ret = -EIO;
1106	/* if not able to read - don't recover any PPL */
1107	pplhdr = NULL;
1108	break;
1109	}
1110	pplhdr = page_address(page);
1111
1112	/* check header validity */
1113	crc_stored = le32_to_cpu(pplhdr->checksum);
1114	pplhdr->checksum = 0;
1115	crc = ~crc32c_le(crc: ~0, address: pplhdr, PAGE_SIZE);
1116
1117	if (crc_stored != crc) {
1118	pr_debug("%s: ppl header crc does not match: stored: 0x%x calculated: 0x%x (offset: %llu)\n",
1119	__func__, crc_stored, crc,
1120	(unsigned long long)pplhdr_offset);
1121	pplhdr = prev_pplhdr;
1122	pplhdr_offset = prev_pplhdr_offset;
1123	break;
1124	}
1125
1126	signature = le32_to_cpu(pplhdr->signature);
1127
1128	if (mddev->external) {
1129	/*
1130	* For external metadata the header signature is set and
1131	* validated in userspace.
1132	*/
1133	ppl_conf->signature = signature;
1134	} else if (ppl_conf->signature != signature) {
1135	pr_debug("%s: ppl header signature does not match: stored: 0x%x configured: 0x%x (offset: %llu)\n",
1136	__func__, signature, ppl_conf->signature,
1137	(unsigned long long)pplhdr_offset);
1138	pplhdr = prev_pplhdr;
1139	pplhdr_offset = prev_pplhdr_offset;
1140	break;
1141	}
1142
1143	if (prev_pplhdr && le64_to_cpu(prev_pplhdr->generation) >
1144	le64_to_cpu(pplhdr->generation)) {
1145	/* previous was newest */
1146	pplhdr = prev_pplhdr;
1147	pplhdr_offset = prev_pplhdr_offset;
1148	break;
1149	}
1150
1151	prev_pplhdr_offset = pplhdr_offset;
1152	prev_pplhdr = pplhdr;
1153
1154	swap(page, page2);
1155
1156	/* calculate next potential ppl offset */
1157	for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++)
1158	pplhdr_offset +=
1159	le32_to_cpu(pplhdr->entries[i].pp_size) >> 9;
1160	pplhdr_offset += PPL_HEADER_SIZE >> 9;
1161	}
1162
1163	/* no valid ppl found */
1164	if (!pplhdr)
1165	ppl_conf->mismatch_count++;
1166	else
1167	pr_debug("%s: latest PPL found at offset: %llu, with generation: %llu\n",
1168	__func__, (unsigned long long)pplhdr_offset,
1169	le64_to_cpu(pplhdr->generation));
1170
1171	/* attempt to recover from log if we are starting a dirty array */
1172	if (pplhdr && !mddev->pers && mddev->recovery_cp != MaxSector)
1173	ret = ppl_recover(log, pplhdr, offset: pplhdr_offset);
1174
1175	/* write empty header if we are starting the array */
1176	if (!ret && !mddev->pers)
1177	ret = ppl_write_empty_header(log);
1178
1179	__free_page(page);
1180	__free_page(page2);
1181
1182	pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n",
1183	__func__, ret, ppl_conf->mismatch_count,
1184	ppl_conf->recovered_entries);
1185	return ret;
1186	}
1187
1188	static int ppl_load(struct ppl_conf *ppl_conf)
1189	{
1190	int ret = 0;
1191	u32 signature = 0;
1192	bool signature_set = false;
1193	int i;
1194
1195	for (i = 0; i < ppl_conf->count; i++) {
1196	struct ppl_log *log = &ppl_conf->child_logs[i];
1197
1198	/* skip missing drive */
1199	if (!log->rdev)
1200	continue;
1201
1202	ret = ppl_load_distributed(log);
1203	if (ret)
1204	break;
1205
1206	/*
1207	* For external metadata we can't check if the signature is
1208	* correct on a single drive, but we can check if it is the same
1209	* on all drives.
1210	*/
1211	if (ppl_conf->mddev->external) {
1212	if (!signature_set) {
1213	signature = ppl_conf->signature;
1214	signature_set = true;
1215	} else if (signature != ppl_conf->signature) {
1216	pr_warn("md/raid:%s: PPL header signature does not match on all member drives\n",
1217	mdname(ppl_conf->mddev));
1218	ret = -EINVAL;
1219	break;
1220	}
1221	}
1222	}
1223
1224	pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n",
1225	__func__, ret, ppl_conf->mismatch_count,
1226	ppl_conf->recovered_entries);
1227	return ret;
1228	}
1229
1230	static void __ppl_exit_log(struct ppl_conf *ppl_conf)
1231	{
1232	clear_bit(nr: MD_HAS_PPL, addr: &ppl_conf->mddev->flags);
1233	clear_bit(nr: MD_HAS_MULTIPLE_PPLS, addr: &ppl_conf->mddev->flags);
1234
1235	kfree(objp: ppl_conf->child_logs);
1236
1237	bioset_exit(&ppl_conf->bs);
1238	bioset_exit(&ppl_conf->flush_bs);
1239	mempool_exit(pool: &ppl_conf->io_pool);
1240	kmem_cache_destroy(s: ppl_conf->io_kc);
1241
1242	kfree(objp: ppl_conf);
1243	}
1244
1245	void ppl_exit_log(struct r5conf *conf)
1246	{
1247	struct ppl_conf *ppl_conf = conf->log_private;
1248
1249	if (ppl_conf) {
1250	__ppl_exit_log(ppl_conf);
1251	conf->log_private = NULL;
1252	}
1253	}
1254
1255	static int ppl_validate_rdev(struct md_rdev *rdev)
1256	{
1257	int ppl_data_sectors;
1258	int ppl_size_new;
1259
1260	/*
1261	* The configured PPL size must be enough to store
1262	* the header and (at the very least) partial parity
1263	* for one stripe. Round it down to ensure the data
1264	* space is cleanly divisible by stripe size.
1265	*/
1266	ppl_data_sectors = rdev->ppl.size - (PPL_HEADER_SIZE >> 9);
1267
1268	if (ppl_data_sectors > 0)
1269	ppl_data_sectors = rounddown(ppl_data_sectors,
1270	RAID5_STRIPE_SECTORS((struct r5conf *)rdev->mddev->private));
1271
1272	if (ppl_data_sectors <= 0) {
1273	pr_warn("md/raid:%s: PPL space too small on %pg\n",
1274	mdname(rdev->mddev), rdev->bdev);
1275	return -ENOSPC;
1276	}
1277
1278	ppl_size_new = ppl_data_sectors + (PPL_HEADER_SIZE >> 9);
1279
1280	if ((rdev->ppl.sector < rdev->data_offset &&
1281	rdev->ppl.sector + ppl_size_new > rdev->data_offset) ||
1282	(rdev->ppl.sector >= rdev->data_offset &&
1283	rdev->data_offset + rdev->sectors > rdev->ppl.sector)) {
1284	pr_warn("md/raid:%s: PPL space overlaps with data on %pg\n",
1285	mdname(rdev->mddev), rdev->bdev);
1286	return -EINVAL;
1287	}
1288
1289	if (!rdev->mddev->external &&
1290	((rdev->ppl.offset > 0 && rdev->ppl.offset < (rdev->sb_size >> 9)) ||
1291	(rdev->ppl.offset <= 0 && rdev->ppl.offset + ppl_size_new > 0))) {
1292	pr_warn("md/raid:%s: PPL space overlaps with superblock on %pg\n",
1293	mdname(rdev->mddev), rdev->bdev);
1294	return -EINVAL;
1295	}
1296
1297	rdev->ppl.size = ppl_size_new;
1298
1299	return 0;
1300	}
1301
1302	static void ppl_init_child_log(struct ppl_log *log, struct md_rdev *rdev)
1303	{
1304	if ((rdev->ppl.size << 9) >= (PPL_SPACE_SIZE +
1305	PPL_HEADER_SIZE) * 2) {
1306	log->use_multippl = true;
1307	set_bit(nr: MD_HAS_MULTIPLE_PPLS,
1308	addr: &log->ppl_conf->mddev->flags);
1309	log->entry_space = PPL_SPACE_SIZE;
1310	} else {
1311	log->use_multippl = false;
1312	log->entry_space = (log->rdev->ppl.size << 9) -
1313	PPL_HEADER_SIZE;
1314	}
1315	log->next_io_sector = rdev->ppl.sector;
1316
1317	if (bdev_write_cache(bdev: rdev->bdev))
1318	log->wb_cache_on = true;
1319	}
1320
1321	int ppl_init_log(struct r5conf *conf)
1322	{
1323	struct ppl_conf *ppl_conf;
1324	struct mddev *mddev = conf->mddev;
1325	int ret = 0;
1326	int max_disks;
1327	int i;
1328
1329	pr_debug("md/raid:%s: enabling distributed Partial Parity Log\n",
1330	mdname(conf->mddev));
1331
1332	if (PAGE_SIZE != 4096)
1333	return -EINVAL;
1334
1335	if (mddev->level != 5) {
1336	pr_warn("md/raid:%s PPL is not compatible with raid level %d\n",
1337	mdname(mddev), mddev->level);
1338	return -EINVAL;
1339	}
1340
1341	if (mddev->bitmap_info.file || mddev->bitmap_info.offset) {
1342	pr_warn("md/raid:%s PPL is not compatible with bitmap\n",
1343	mdname(mddev));
1344	return -EINVAL;
1345	}
1346
1347	if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
1348	pr_warn("md/raid:%s PPL is not compatible with journal\n",
1349	mdname(mddev));
1350	return -EINVAL;
1351	}
1352
1353	max_disks = sizeof_field(struct ppl_log, disk_flush_bitmap) *
1354	BITS_PER_BYTE;
1355	if (conf->raid_disks > max_disks) {
1356	pr_warn("md/raid:%s PPL doesn't support over %d disks in the array\n",
1357	mdname(mddev), max_disks);
1358	return -EINVAL;
1359	}
1360
1361	ppl_conf = kzalloc(size: sizeof(struct ppl_conf), GFP_KERNEL);
1362	if (!ppl_conf)
1363	return -ENOMEM;
1364
1365	ppl_conf->mddev = mddev;
1366
1367	ppl_conf->io_kc = KMEM_CACHE(ppl_io_unit, 0);
1368	if (!ppl_conf->io_kc) {
1369	ret = -ENOMEM;
1370	goto err;
1371	}
1372
1373	ret = mempool_init(pool: &ppl_conf->io_pool, min_nr: conf->raid_disks, alloc_fn: ppl_io_pool_alloc,
1374	free_fn: ppl_io_pool_free, pool_data: ppl_conf->io_kc);
1375	if (ret)
1376	goto err;
1377
1378	ret = bioset_init(&ppl_conf->bs, conf->raid_disks, 0, flags: BIOSET_NEED_BVECS);
1379	if (ret)
1380	goto err;
1381
1382	ret = bioset_init(&ppl_conf->flush_bs, conf->raid_disks, 0, flags: 0);
1383	if (ret)
1384	goto err;
1385
1386	ppl_conf->count = conf->raid_disks;
1387	ppl_conf->child_logs = kcalloc(n: ppl_conf->count, size: sizeof(struct ppl_log),
1388	GFP_KERNEL);
1389	if (!ppl_conf->child_logs) {
1390	ret = -ENOMEM;
1391	goto err;
1392	}
1393
1394	atomic64_set(v: &ppl_conf->seq, i: 0);
1395	INIT_LIST_HEAD(list: &ppl_conf->no_mem_stripes);
1396	spin_lock_init(&ppl_conf->no_mem_stripes_lock);
1397
1398	if (!mddev->external) {
1399	ppl_conf->signature = ~crc32c_le(crc: ~0, address: mddev->uuid, length: sizeof(mddev->uuid));
1400	ppl_conf->block_size = 512;
1401	} else {
1402	ppl_conf->block_size = queue_logical_block_size(q: mddev->queue);
1403	}
1404
1405	for (i = 0; i < ppl_conf->count; i++) {
1406	struct ppl_log *log = &ppl_conf->child_logs[i];
1407	/* Array has not started so rcu dereference is safe */
1408	struct md_rdev *rdev =
1409	rcu_dereference_protected(conf->disks[i].rdev, 1);
1410
1411	mutex_init(&log->io_mutex);
1412	spin_lock_init(&log->io_list_lock);
1413	INIT_LIST_HEAD(list: &log->io_list);
1414
1415	log->ppl_conf = ppl_conf;
1416	log->rdev = rdev;
1417
1418	if (rdev) {
1419	ret = ppl_validate_rdev(rdev);
1420	if (ret)
1421	goto err;
1422
1423	ppl_init_child_log(log, rdev);
1424	}
1425	}
1426
1427	/* load and possibly recover the logs from the member disks */
1428	ret = ppl_load(ppl_conf);
1429
1430	if (ret) {
1431	goto err;
1432	} else if (!mddev->pers && mddev->recovery_cp == 0 &&
1433	ppl_conf->recovered_entries > 0 &&
1434	ppl_conf->mismatch_count == 0) {
1435	/*
1436	* If we are starting a dirty array and the recovery succeeds
1437	* without any issues, set the array as clean.
1438	*/
1439	mddev->recovery_cp = MaxSector;
1440	set_bit(nr: MD_SB_CHANGE_CLEAN, addr: &mddev->sb_flags);
1441	} else if (mddev->pers && ppl_conf->mismatch_count > 0) {
1442	/* no mismatch allowed when enabling PPL for a running array */
1443	ret = -EINVAL;
1444	goto err;
1445	}
1446
1447	conf->log_private = ppl_conf;
1448	set_bit(nr: MD_HAS_PPL, addr: &ppl_conf->mddev->flags);
1449
1450	return 0;
1451	err:
1452	__ppl_exit_log(ppl_conf);
1453	return ret;
1454	}
1455
1456	int ppl_modify_log(struct r5conf *conf, struct md_rdev *rdev, bool add)
1457	{
1458	struct ppl_conf *ppl_conf = conf->log_private;
1459	struct ppl_log *log;
1460	int ret = 0;
1461
1462	if (!rdev)
1463	return -EINVAL;
1464
1465	pr_debug("%s: disk: %d operation: %s dev: %pg\n",
1466	__func__, rdev->raid_disk, add ? "add" : "remove",
1467	rdev->bdev);
1468
1469	if (rdev->raid_disk < 0)
1470	return 0;
1471
1472	if (rdev->raid_disk >= ppl_conf->count)
1473	return -ENODEV;
1474
1475	log = &ppl_conf->child_logs[rdev->raid_disk];
1476
1477	mutex_lock(&log->io_mutex);
1478	if (add) {
1479	ret = ppl_validate_rdev(rdev);
1480	if (!ret) {
1481	log->rdev = rdev;
1482	ret = ppl_write_empty_header(log);
1483	ppl_init_child_log(log, rdev);
1484	}
1485	} else {
1486	log->rdev = NULL;
1487	}
1488	mutex_unlock(lock: &log->io_mutex);
1489
1490	return ret;
1491	}
1492
1493	static ssize_t
1494	ppl_write_hint_show(struct mddev *mddev, char *buf)
1495	{
1496	return sprintf(buf, fmt: "%d\n", 0);
1497	}
1498
1499	static ssize_t
1500	ppl_write_hint_store(struct mddev *mddev, const char *page, size_t len)
1501	{
1502	struct r5conf *conf;
1503	int err = 0;
1504	unsigned short new;
1505
1506	if (len >= PAGE_SIZE)
1507	return -EINVAL;
1508	if (kstrtou16(s: page, base: 10, res: &new))
1509	return -EINVAL;
1510
1511	err = mddev_lock(mddev);
1512	if (err)
1513	return err;
1514
1515	conf = mddev->private;
1516	if (!conf)
1517	err = -ENODEV;
1518	else if (!raid5_has_ppl(conf) || !conf->log_private)
1519	err = -EINVAL;
1520
1521	mddev_unlock(mddev);
1522
1523	return err ?: len;
1524	}
1525
1526	struct md_sysfs_entry
1527	ppl_write_hint = __ATTR(ppl_write_hint, S_IRUGO | S_IWUSR,
1528	ppl_write_hint_show,
1529	ppl_write_hint_store);
1530