xref: /openbmc/linux/drivers/md/raid5-ppl.c (revision 6eea4ff8)
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 *
ops_run_partial_parity(struct stripe_head * sh,struct raid5_percpu * percpu,struct dma_async_tx_descriptor * tx)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(&submit, ASYNC_TX_FENCE|ASYNC_TX_XOR_ZERO_DST, tx,
193 			  NULL, sh, (void *) (srcs + sh->disks + 2));
194 
195 	if (count == 1)
196 		tx = async_memcpy(sh->ppl_page, srcs[0], 0, 0, PAGE_SIZE,
197 				  &submit);
198 	else
199 		tx = async_xor(sh->ppl_page, srcs, 0, count, PAGE_SIZE,
200 			       &submit);
201 
202 	return tx;
203 }
204 
ppl_io_pool_alloc(gfp_t gfp_mask,void * pool_data)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(kc, 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(kc, io);
217 		return NULL;
218 	}
219 
220 	return io;
221 }
222 
ppl_io_pool_free(void * element,void * pool_data)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(kc, io);
230 }
231 
ppl_new_iounit(struct ppl_log * log,struct stripe_head * sh)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(&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(&io->log_sibling);
250 	INIT_LIST_HEAD(&io->stripe_list);
251 	atomic_set(&io->pending_stripes, 0);
252 	atomic_set(&io->pending_flushes, 0);
253 	bio_init(&io->bio, log->rdev->bdev, io->biovec, PPL_IO_INLINE_BVECS,
254 		 REQ_OP_WRITE | REQ_FUA);
255 
256 	pplhdr = page_address(io->header_page);
257 	clear_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(1, &ppl_conf->seq);
262 	pplhdr->generation = cpu_to_le64(io->seq);
263 
264 	return io;
265 }
266 
ppl_log_stripe(struct ppl_log * log,struct stripe_head * sh)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(&log->io_list_lock);
293 		list_add_tail(&io->log_sibling, &log->io_list);
294 		spin_unlock_irq(&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(&e->data_size, 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(&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(&sh->log_list, &io->stripe_list);
355 	atomic_inc(&io->pending_stripes);
356 	sh->ppl_io = io;
357 
358 	return 0;
359 }
360 
ppl_write_stripe(struct r5conf * conf,struct stripe_head * sh)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(STRIPE_LOG_TRAPPED, &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(&log->io_mutex);
380 		return -EAGAIN;
381 	}
382 
383 	set_bit(STRIPE_LOG_TRAPPED, &sh->state);
384 	clear_bit(STRIPE_DELAYED, &sh->state);
385 	atomic_inc(&sh->count);
386 
387 	if (ppl_log_stripe(log, sh)) {
388 		spin_lock_irq(&ppl_conf->no_mem_stripes_lock);
389 		list_add_tail(&sh->log_list, &ppl_conf->no_mem_stripes);
390 		spin_unlock_irq(&ppl_conf->no_mem_stripes_lock);
391 	}
392 
393 	mutex_unlock(&log->io_mutex);
394 
395 	return 0;
396 }
397 
ppl_log_endio(struct bio * bio)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(ppl_conf->mddev, log->rdev);
409 
410 	list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) {
411 		list_del_init(&sh->log_list);
412 
413 		set_bit(STRIPE_HANDLE, &sh->state);
414 		raid5_release_stripe(sh);
415 	}
416 }
417 
ppl_submit_iounit_bio(struct ppl_io_unit * io,struct bio * bio)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 
ppl_submit_iounit(struct ppl_io_unit * io)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, io->header_page, PAGE_SIZE, 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(i, &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, sh->ppl_page, PAGE_SIZE, 0)) {
493 			struct bio *prev = bio;
494 
495 			bio = bio_alloc_bioset(prev->bi_bdev, BIO_MAX_VECS,
496 					       prev->bi_opf, GFP_NOIO,
497 					       &ppl_conf->bs);
498 			bio->bi_iter.bi_sector = bio_end_sector(prev);
499 			__bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0);
500 
501 			bio_chain(bio, prev);
502 			ppl_submit_iounit_bio(io, prev);
503 		}
504 	}
505 
506 	ppl_submit_iounit_bio(io, bio);
507 }
508 
ppl_submit_current_io(struct ppl_log * log)509 static void ppl_submit_current_io(struct ppl_log *log)
510 {
511 	struct ppl_io_unit *io;
512 
513 	spin_lock_irq(&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(&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 
ppl_write_stripe_run(struct r5conf * conf)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(&log->io_mutex);
544 	}
545 }
546 
ppl_io_unit_finished(struct ppl_io_unit * io)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(&log->io_list_lock);
559 	list_del(&io->log_sibling);
560 	spin_unlock(&log->io_list_lock);
561 
562 	mempool_free(io, &ppl_conf->io_pool);
563 
564 	spin_lock(&ppl_conf->no_mem_stripes_lock);
565 	if (!list_empty(&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(&sh->log_list);
571 		set_bit(STRIPE_HANDLE, &sh->state);
572 		raid5_release_stripe(sh);
573 	}
574 	spin_unlock(&ppl_conf->no_mem_stripes_lock);
575 
576 	local_irq_restore(flags);
577 
578 	wake_up(&conf->wait_for_quiescent);
579 }
580 
ppl_flush_endio(struct bio * bio)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(conf->mddev, bio_dev(bio));
595 		if (rdev)
596 			md_error(rdev->mddev, rdev);
597 		rcu_read_unlock();
598 	}
599 
600 	bio_put(bio);
601 
602 	if (atomic_dec_and_test(&io->pending_flushes)) {
603 		ppl_io_unit_finished(io);
604 		md_wakeup_thread(conf->mddev->thread);
605 	}
606 }
607 
ppl_do_flush(struct ppl_io_unit * io)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(&io->pending_flushes, 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, 0,
633 					       REQ_OP_WRITE | REQ_PREFLUSH,
634 					       GFP_NOIO, &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(&io->pending_flushes))
649 			ppl_io_unit_finished(io);
650 	}
651 }
652 
ppl_no_io_unit_submitted(struct r5conf * conf,struct ppl_log * log)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 
ppl_quiesce(struct r5conf * conf,int quiesce)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(&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(&log->io_list_lock);
678 		}
679 	}
680 }
681 
ppl_handle_flush_request(struct bio * bio)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 
ppl_stripe_write_finished(struct stripe_head * sh)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(&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 
ppl_xor(int size,struct page * page1,struct page * page2)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(&submit, ASYNC_TX_ACK|ASYNC_TX_XOR_DROP_DST,
714 			  NULL, NULL, NULL, NULL);
715 	tx = async_xor(page1, xor_srcs, 0, 2, size, &submit);
716 
717 	async_tx_quiesce(&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  */
ppl_recover_entry(struct ppl_log * log,struct ppl_header_entry * e,sector_t ppl_sector)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, 0,
879 						      &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, block_size, page2,
900 					REQ_OP_READ, 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(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(log->rdev,
921 					ppl_sector - log->rdev->data_offset + i,
922 					block_size, page2, REQ_OP_READ,
923 					false)) {
924 				pr_debug("%s:%*s read failed!\n", __func__,
925 					 indent, "");
926 				md_error(mddev, log->rdev);
927 				ret = -EIO;
928 				goto out;
929 			}
930 
931 			ppl_xor(block_size, page1, page2);
932 		}
933 
934 		/* map raid sector to parity disk */
935 		parity_sector = raid5_compute_sector(conf, r_sector_first + i,
936 				0, &disk, &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(parity_rdev, parity_sector, block_size,
949 				  page1, REQ_OP_WRITE, false)) {
950 			pr_debug("%s:%*s parity write error!\n", __func__,
951 				 indent, "");
952 			md_error(mddev, 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 
ppl_recover(struct ppl_log * log,struct ppl_header * pplhdr,sector_t offset)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 - rdev->data_offset,
1001 					s, page, REQ_OP_READ, false)) {
1002 				md_error(mddev, rdev);
1003 				ret = -EIO;
1004 				goto out;
1005 			}
1006 
1007 			crc = crc32c_le(crc, page_address(page), 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(rdev->bdev);
1036 out:
1037 	__free_page(page);
1038 	return ret;
1039 }
1040 
ppl_write_empty_header(struct ppl_log * log)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(rdev->bdev, rdev->ppl.sector,
1058 			    log->rdev->ppl.size, GFP_NOIO, 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, rdev->ppl.sector - rdev->data_offset,
1064 			  PPL_HEADER_SIZE, page, REQ_OP_WRITE | REQ_SYNC |
1065 			  REQ_FUA, false)) {
1066 		md_error(rdev->mddev, rdev);
1067 		ret = -EIO;
1068 	}
1069 
1070 	__free_page(page);
1071 	return ret;
1072 }
1073 
ppl_load_distributed(struct ppl_log * log)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 				  rdev->ppl.sector - rdev->data_offset +
1102 				  pplhdr_offset, PAGE_SIZE, page, REQ_OP_READ,
1103 				  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(~0, 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, 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 
ppl_load(struct ppl_conf * ppl_conf)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 
__ppl_exit_log(struct ppl_conf * ppl_conf)1230 static void __ppl_exit_log(struct ppl_conf *ppl_conf)
1231 {
1232 	clear_bit(MD_HAS_PPL, &ppl_conf->mddev->flags);
1233 	clear_bit(MD_HAS_MULTIPLE_PPLS, &ppl_conf->mddev->flags);
1234 
1235 	kfree(ppl_conf->child_logs);
1236 
1237 	bioset_exit(&ppl_conf->bs);
1238 	bioset_exit(&ppl_conf->flush_bs);
1239 	mempool_exit(&ppl_conf->io_pool);
1240 	kmem_cache_destroy(ppl_conf->io_kc);
1241 
1242 	kfree(ppl_conf);
1243 }
1244 
ppl_exit_log(struct r5conf * conf)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 
ppl_validate_rdev(struct md_rdev * rdev)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 
ppl_init_child_log(struct ppl_log * log,struct md_rdev * rdev)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(MD_HAS_MULTIPLE_PPLS,
1308 			&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(rdev->bdev))
1318 		log->wb_cache_on = true;
1319 }
1320 
ppl_init_log(struct r5conf * conf)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(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(&ppl_conf->io_pool, conf->raid_disks, ppl_io_pool_alloc,
1374 			   ppl_io_pool_free, ppl_conf->io_kc);
1375 	if (ret)
1376 		goto err;
1377 
1378 	ret = bioset_init(&ppl_conf->bs, conf->raid_disks, 0, BIOSET_NEED_BVECS);
1379 	if (ret)
1380 		goto err;
1381 
1382 	ret = bioset_init(&ppl_conf->flush_bs, conf->raid_disks, 0, 0);
1383 	if (ret)
1384 		goto err;
1385 
1386 	ppl_conf->count = conf->raid_disks;
1387 	ppl_conf->child_logs = kcalloc(ppl_conf->count, sizeof(struct ppl_log),
1388 				       GFP_KERNEL);
1389 	if (!ppl_conf->child_logs) {
1390 		ret = -ENOMEM;
1391 		goto err;
1392 	}
1393 
1394 	atomic64_set(&ppl_conf->seq, 0);
1395 	INIT_LIST_HEAD(&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(~0, mddev->uuid, sizeof(mddev->uuid));
1400 		ppl_conf->block_size = 512;
1401 	} else {
1402 		ppl_conf->block_size = queue_logical_block_size(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(&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(MD_SB_CHANGE_CLEAN, &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(MD_HAS_PPL, &ppl_conf->mddev->flags);
1449 
1450 	return 0;
1451 err:
1452 	__ppl_exit_log(ppl_conf);
1453 	return ret;
1454 }
1455 
ppl_modify_log(struct r5conf * conf,struct md_rdev * rdev,bool add)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(&log->io_mutex);
1489 
1490 	return ret;
1491 }
1492 
1493 static ssize_t
ppl_write_hint_show(struct mddev * mddev,char * buf)1494 ppl_write_hint_show(struct mddev *mddev, char *buf)
1495 {
1496 	return sprintf(buf, "%d\n", 0);
1497 }
1498 
1499 static ssize_t
ppl_write_hint_store(struct mddev * mddev,const char * page,size_t len)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(page, 10, &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