12025cf9eSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
23418d036SArtur Paszkiewicz /*
33418d036SArtur Paszkiewicz * Partial Parity Log for closing the RAID5 write hole
43418d036SArtur Paszkiewicz * Copyright (c) 2017, Intel Corporation.
53418d036SArtur Paszkiewicz */
63418d036SArtur Paszkiewicz
73418d036SArtur Paszkiewicz #include <linux/kernel.h>
83418d036SArtur Paszkiewicz #include <linux/blkdev.h>
93418d036SArtur Paszkiewicz #include <linux/slab.h>
103418d036SArtur Paszkiewicz #include <linux/crc32c.h>
113418d036SArtur Paszkiewicz #include <linux/async_tx.h>
123418d036SArtur Paszkiewicz #include <linux/raid/md_p.h>
133418d036SArtur Paszkiewicz #include "md.h"
143418d036SArtur Paszkiewicz #include "raid5.h"
15a596d086SMariusz Dabrowski #include "raid5-log.h"
163418d036SArtur Paszkiewicz
173418d036SArtur Paszkiewicz /*
183418d036SArtur Paszkiewicz * PPL consists of a 4KB header (struct ppl_header) and at least 128KB for
193418d036SArtur Paszkiewicz * partial parity data. The header contains an array of entries
203418d036SArtur Paszkiewicz * (struct ppl_header_entry) which describe the logged write requests.
213418d036SArtur Paszkiewicz * Partial parity for the entries comes after the header, written in the same
223418d036SArtur Paszkiewicz * sequence as the entries:
233418d036SArtur Paszkiewicz *
243418d036SArtur Paszkiewicz * Header
253418d036SArtur Paszkiewicz * entry0
263418d036SArtur Paszkiewicz * ...
273418d036SArtur Paszkiewicz * entryN
283418d036SArtur Paszkiewicz * PP data
293418d036SArtur Paszkiewicz * PP for entry0
303418d036SArtur Paszkiewicz * ...
313418d036SArtur Paszkiewicz * PP for entryN
323418d036SArtur Paszkiewicz *
333418d036SArtur Paszkiewicz * An entry describes one or more consecutive stripe_heads, up to a full
343418d036SArtur Paszkiewicz * stripe. The modifed raid data chunks form an m-by-n matrix, where m is the
353418d036SArtur Paszkiewicz * number of stripe_heads in the entry and n is the number of modified data
363418d036SArtur Paszkiewicz * disks. Every stripe_head in the entry must write to the same data disks.
373418d036SArtur Paszkiewicz * An example of a valid case described by a single entry (writes to the first
383418d036SArtur Paszkiewicz * stripe of a 4 disk array, 16k chunk size):
393418d036SArtur Paszkiewicz *
403418d036SArtur Paszkiewicz * sh->sector dd0 dd1 dd2 ppl
413418d036SArtur Paszkiewicz * +-----+-----+-----+
423418d036SArtur Paszkiewicz * 0 | --- | --- | --- | +----+
433418d036SArtur Paszkiewicz * 8 | -W- | -W- | --- | | pp | data_sector = 8
443418d036SArtur Paszkiewicz * 16 | -W- | -W- | --- | | pp | data_size = 3 * 2 * 4k
453418d036SArtur Paszkiewicz * 24 | -W- | -W- | --- | | pp | pp_size = 3 * 4k
463418d036SArtur Paszkiewicz * +-----+-----+-----+ +----+
473418d036SArtur Paszkiewicz *
483418d036SArtur Paszkiewicz * data_sector is the first raid sector of the modified data, data_size is the
493418d036SArtur Paszkiewicz * total size of modified data and pp_size is the size of partial parity for
503418d036SArtur Paszkiewicz * this entry. Entries for full stripe writes contain no partial parity
513418d036SArtur Paszkiewicz * (pp_size = 0), they only mark the stripes for which parity should be
523418d036SArtur Paszkiewicz * recalculated after an unclean shutdown. Every entry holds a checksum of its
533418d036SArtur Paszkiewicz * partial parity, the header also has a checksum of the header itself.
543418d036SArtur Paszkiewicz *
553418d036SArtur Paszkiewicz * A write request is always logged to the PPL instance stored on the parity
563418d036SArtur Paszkiewicz * disk of the corresponding stripe. For each member disk there is one ppl_log
573418d036SArtur Paszkiewicz * used to handle logging for this disk, independently from others. They are
583418d036SArtur Paszkiewicz * grouped in child_logs array in struct ppl_conf, which is assigned to
593418d036SArtur Paszkiewicz * r5conf->log_private.
603418d036SArtur Paszkiewicz *
613418d036SArtur Paszkiewicz * ppl_io_unit represents a full PPL write, header_page contains the ppl_header.
623418d036SArtur Paszkiewicz * PPL entries for logged stripes are added in ppl_log_stripe(). A stripe_head
633418d036SArtur Paszkiewicz * can be appended to the last entry if it meets the conditions for a valid
643418d036SArtur Paszkiewicz * entry described above, otherwise a new entry is added. Checksums of entries
653418d036SArtur Paszkiewicz * are calculated incrementally as stripes containing partial parity are being
663418d036SArtur Paszkiewicz * added. ppl_submit_iounit() calculates the checksum of the header and submits
673418d036SArtur Paszkiewicz * a bio containing the header page and partial parity pages (sh->ppl_page) for
683418d036SArtur Paszkiewicz * all stripes of the io_unit. When the PPL write completes, the stripes
693418d036SArtur Paszkiewicz * associated with the io_unit are released and raid5d starts writing their data
703418d036SArtur Paszkiewicz * and parity. When all stripes are written, the io_unit is freed and the next
713418d036SArtur Paszkiewicz * can be submitted.
723418d036SArtur Paszkiewicz *
733418d036SArtur Paszkiewicz * An io_unit is used to gather stripes until it is submitted or becomes full
743418d036SArtur Paszkiewicz * (if the maximum number of entries or size of PPL is reached). Another io_unit
753418d036SArtur Paszkiewicz * can't be submitted until the previous has completed (PPL and stripe
763418d036SArtur Paszkiewicz * data+parity is written). The log->io_list tracks all io_units of a log
773418d036SArtur Paszkiewicz * (for a single member disk). New io_units are added to the end of the list
783418d036SArtur Paszkiewicz * and the first io_unit is submitted, if it is not submitted already.
793418d036SArtur Paszkiewicz * The current io_unit accepting new stripes is always at the end of the list.
801532d9e8STomasz Majchrzak *
811532d9e8STomasz Majchrzak * If write-back cache is enabled for any of the disks in the array, its data
821532d9e8STomasz Majchrzak * must be flushed before next io_unit is submitted.
833418d036SArtur Paszkiewicz */
843418d036SArtur Paszkiewicz
85ddc08823SPawel Baldysiak #define PPL_SPACE_SIZE (128 * 1024)
86ddc08823SPawel Baldysiak
873418d036SArtur Paszkiewicz struct ppl_conf {
883418d036SArtur Paszkiewicz struct mddev *mddev;
893418d036SArtur Paszkiewicz
903418d036SArtur Paszkiewicz /* array of child logs, one for each raid disk */
913418d036SArtur Paszkiewicz struct ppl_log *child_logs;
923418d036SArtur Paszkiewicz int count;
933418d036SArtur Paszkiewicz
943418d036SArtur Paszkiewicz int block_size; /* the logical block size used for data_sector
953418d036SArtur Paszkiewicz * in ppl_header_entry */
963418d036SArtur Paszkiewicz u32 signature; /* raid array identifier */
973418d036SArtur Paszkiewicz atomic64_t seq; /* current log write sequence number */
983418d036SArtur Paszkiewicz
993418d036SArtur Paszkiewicz struct kmem_cache *io_kc;
100afeee514SKent Overstreet mempool_t io_pool;
101afeee514SKent Overstreet struct bio_set bs;
102afeee514SKent Overstreet struct bio_set flush_bs;
1034536bf9bSArtur Paszkiewicz
1044536bf9bSArtur Paszkiewicz /* used only for recovery */
1054536bf9bSArtur Paszkiewicz int recovered_entries;
1064536bf9bSArtur Paszkiewicz int mismatch_count;
10794568f64SArtur Paszkiewicz
10894568f64SArtur Paszkiewicz /* stripes to retry if failed to allocate io_unit */
10994568f64SArtur Paszkiewicz struct list_head no_mem_stripes;
11094568f64SArtur Paszkiewicz spinlock_t no_mem_stripes_lock;
111a596d086SMariusz Dabrowski
112a596d086SMariusz Dabrowski unsigned short write_hint;
1133418d036SArtur Paszkiewicz };
1143418d036SArtur Paszkiewicz
1153418d036SArtur Paszkiewicz struct ppl_log {
1163418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf; /* shared between all log instances */
1173418d036SArtur Paszkiewicz
1183418d036SArtur Paszkiewicz struct md_rdev *rdev; /* array member disk associated with
1193418d036SArtur Paszkiewicz * this log instance */
1203418d036SArtur Paszkiewicz struct mutex io_mutex;
1213418d036SArtur Paszkiewicz struct ppl_io_unit *current_io; /* current io_unit accepting new data
1223418d036SArtur Paszkiewicz * always at the end of io_list */
1233418d036SArtur Paszkiewicz spinlock_t io_list_lock;
1243418d036SArtur Paszkiewicz struct list_head io_list; /* all io_units of this log */
125ddc08823SPawel Baldysiak
126ddc08823SPawel Baldysiak sector_t next_io_sector;
127ddc08823SPawel Baldysiak unsigned int entry_space;
128ddc08823SPawel Baldysiak bool use_multippl;
1291532d9e8STomasz Majchrzak bool wb_cache_on;
1301532d9e8STomasz Majchrzak unsigned long disk_flush_bitmap;
1313418d036SArtur Paszkiewicz };
1323418d036SArtur Paszkiewicz
1333418d036SArtur Paszkiewicz #define PPL_IO_INLINE_BVECS 32
1343418d036SArtur Paszkiewicz
1353418d036SArtur Paszkiewicz struct ppl_io_unit {
1363418d036SArtur Paszkiewicz struct ppl_log *log;
1373418d036SArtur Paszkiewicz
1383418d036SArtur Paszkiewicz struct page *header_page; /* for ppl_header */
1393418d036SArtur Paszkiewicz
1403418d036SArtur Paszkiewicz unsigned int entries_count; /* number of entries in ppl_header */
1413418d036SArtur Paszkiewicz unsigned int pp_size; /* total size current of partial parity */
1423418d036SArtur Paszkiewicz
1433418d036SArtur Paszkiewicz u64 seq; /* sequence number of this log write */
1443418d036SArtur Paszkiewicz struct list_head log_sibling; /* log->io_list */
1453418d036SArtur Paszkiewicz
1463418d036SArtur Paszkiewicz struct list_head stripe_list; /* stripes added to the io_unit */
1473418d036SArtur Paszkiewicz atomic_t pending_stripes; /* how many stripes not written to raid */
1481532d9e8STomasz Majchrzak atomic_t pending_flushes; /* how many disk flushes are in progress */
1493418d036SArtur Paszkiewicz
1503418d036SArtur Paszkiewicz bool submitted; /* true if write to log started */
1513418d036SArtur Paszkiewicz
1523418d036SArtur Paszkiewicz /* inline bio and its biovec for submitting the iounit */
1533418d036SArtur Paszkiewicz struct bio bio;
1543418d036SArtur Paszkiewicz struct bio_vec biovec[PPL_IO_INLINE_BVECS];
1553418d036SArtur Paszkiewicz };
1563418d036SArtur Paszkiewicz
1573418d036SArtur Paszkiewicz struct dma_async_tx_descriptor *
ops_run_partial_parity(struct stripe_head * sh,struct raid5_percpu * percpu,struct dma_async_tx_descriptor * tx)1583418d036SArtur Paszkiewicz ops_run_partial_parity(struct stripe_head *sh, struct raid5_percpu *percpu,
1593418d036SArtur Paszkiewicz struct dma_async_tx_descriptor *tx)
1603418d036SArtur Paszkiewicz {
1613418d036SArtur Paszkiewicz int disks = sh->disks;
162b330e6a4SKent Overstreet struct page **srcs = percpu->scribble;
1633418d036SArtur Paszkiewicz int count = 0, pd_idx = sh->pd_idx, i;
1643418d036SArtur Paszkiewicz struct async_submit_ctl submit;
1653418d036SArtur Paszkiewicz
1663418d036SArtur Paszkiewicz pr_debug("%s: stripe %llu\n", __func__, (unsigned long long)sh->sector);
1673418d036SArtur Paszkiewicz
1683418d036SArtur Paszkiewicz /*
1693418d036SArtur Paszkiewicz * Partial parity is the XOR of stripe data chunks that are not changed
1703418d036SArtur Paszkiewicz * during the write request. Depending on available data
1713418d036SArtur Paszkiewicz * (read-modify-write vs. reconstruct-write case) we calculate it
1723418d036SArtur Paszkiewicz * differently.
1733418d036SArtur Paszkiewicz */
1743418d036SArtur Paszkiewicz if (sh->reconstruct_state == reconstruct_state_prexor_drain_run) {
175ae1713e2SArtur Paszkiewicz /*
176ae1713e2SArtur Paszkiewicz * rmw: xor old data and parity from updated disks
177ae1713e2SArtur Paszkiewicz * This is calculated earlier by ops_run_prexor5() so just copy
178ae1713e2SArtur Paszkiewicz * the parity dev page.
179ae1713e2SArtur Paszkiewicz */
180ae1713e2SArtur Paszkiewicz srcs[count++] = sh->dev[pd_idx].page;
1813418d036SArtur Paszkiewicz } else if (sh->reconstruct_state == reconstruct_state_drain_run) {
1823418d036SArtur Paszkiewicz /* rcw: xor data from all not updated disks */
1833418d036SArtur Paszkiewicz for (i = disks; i--;) {
1843418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i];
1853418d036SArtur Paszkiewicz if (test_bit(R5_UPTODATE, &dev->flags))
186ae1713e2SArtur Paszkiewicz srcs[count++] = dev->page;
1873418d036SArtur Paszkiewicz }
1883418d036SArtur Paszkiewicz } else {
1893418d036SArtur Paszkiewicz return tx;
1903418d036SArtur Paszkiewicz }
1913418d036SArtur Paszkiewicz
1923418d036SArtur Paszkiewicz init_async_submit(&submit, ASYNC_TX_FENCE|ASYNC_TX_XOR_ZERO_DST, tx,
193b330e6a4SKent Overstreet NULL, sh, (void *) (srcs + sh->disks + 2));
1943418d036SArtur Paszkiewicz
1953418d036SArtur Paszkiewicz if (count == 1)
196ae1713e2SArtur Paszkiewicz tx = async_memcpy(sh->ppl_page, srcs[0], 0, 0, PAGE_SIZE,
1973418d036SArtur Paszkiewicz &submit);
1983418d036SArtur Paszkiewicz else
199ae1713e2SArtur Paszkiewicz tx = async_xor(sh->ppl_page, srcs, 0, count, PAGE_SIZE,
2003418d036SArtur Paszkiewicz &submit);
2013418d036SArtur Paszkiewicz
2023418d036SArtur Paszkiewicz return tx;
2033418d036SArtur Paszkiewicz }
2043418d036SArtur Paszkiewicz
ppl_io_pool_alloc(gfp_t gfp_mask,void * pool_data)205fcd403afSArtur Paszkiewicz static void *ppl_io_pool_alloc(gfp_t gfp_mask, void *pool_data)
206fcd403afSArtur Paszkiewicz {
207fcd403afSArtur Paszkiewicz struct kmem_cache *kc = pool_data;
208fcd403afSArtur Paszkiewicz struct ppl_io_unit *io;
209fcd403afSArtur Paszkiewicz
210fcd403afSArtur Paszkiewicz io = kmem_cache_alloc(kc, gfp_mask);
211fcd403afSArtur Paszkiewicz if (!io)
212fcd403afSArtur Paszkiewicz return NULL;
213fcd403afSArtur Paszkiewicz
214fcd403afSArtur Paszkiewicz io->header_page = alloc_page(gfp_mask);
215fcd403afSArtur Paszkiewicz if (!io->header_page) {
216fcd403afSArtur Paszkiewicz kmem_cache_free(kc, io);
217fcd403afSArtur Paszkiewicz return NULL;
218fcd403afSArtur Paszkiewicz }
219fcd403afSArtur Paszkiewicz
220fcd403afSArtur Paszkiewicz return io;
221fcd403afSArtur Paszkiewicz }
222fcd403afSArtur Paszkiewicz
ppl_io_pool_free(void * element,void * pool_data)223fcd403afSArtur Paszkiewicz static void ppl_io_pool_free(void *element, void *pool_data)
224fcd403afSArtur Paszkiewicz {
225fcd403afSArtur Paszkiewicz struct kmem_cache *kc = pool_data;
226fcd403afSArtur Paszkiewicz struct ppl_io_unit *io = element;
227fcd403afSArtur Paszkiewicz
228fcd403afSArtur Paszkiewicz __free_page(io->header_page);
229fcd403afSArtur Paszkiewicz kmem_cache_free(kc, io);
230fcd403afSArtur Paszkiewicz }
231fcd403afSArtur Paszkiewicz
ppl_new_iounit(struct ppl_log * log,struct stripe_head * sh)2323418d036SArtur Paszkiewicz static struct ppl_io_unit *ppl_new_iounit(struct ppl_log *log,
2333418d036SArtur Paszkiewicz struct stripe_head *sh)
2343418d036SArtur Paszkiewicz {
2353418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
2363418d036SArtur Paszkiewicz struct ppl_io_unit *io;
2373418d036SArtur Paszkiewicz struct ppl_header *pplhdr;
238fcd403afSArtur Paszkiewicz struct page *header_page;
2393418d036SArtur Paszkiewicz
240afeee514SKent Overstreet io = mempool_alloc(&ppl_conf->io_pool, GFP_NOWAIT);
2413418d036SArtur Paszkiewicz if (!io)
2423418d036SArtur Paszkiewicz return NULL;
2433418d036SArtur Paszkiewicz
244fcd403afSArtur Paszkiewicz header_page = io->header_page;
2453418d036SArtur Paszkiewicz memset(io, 0, sizeof(*io));
246fcd403afSArtur Paszkiewicz io->header_page = header_page;
247fcd403afSArtur Paszkiewicz
2483418d036SArtur Paszkiewicz io->log = log;
2493418d036SArtur Paszkiewicz INIT_LIST_HEAD(&io->log_sibling);
2503418d036SArtur Paszkiewicz INIT_LIST_HEAD(&io->stripe_list);
2513418d036SArtur Paszkiewicz atomic_set(&io->pending_stripes, 0);
2521532d9e8STomasz Majchrzak atomic_set(&io->pending_flushes, 0);
2539f7c3f83SChristoph Hellwig bio_init(&io->bio, log->rdev->bdev, io->biovec, PPL_IO_INLINE_BVECS,
2549f7c3f83SChristoph Hellwig REQ_OP_WRITE | REQ_FUA);
2553418d036SArtur Paszkiewicz
2563418d036SArtur Paszkiewicz pplhdr = page_address(io->header_page);
2573418d036SArtur Paszkiewicz clear_page(pplhdr);
2583418d036SArtur Paszkiewicz memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED);
2593418d036SArtur Paszkiewicz pplhdr->signature = cpu_to_le32(ppl_conf->signature);
2603418d036SArtur Paszkiewicz
2613418d036SArtur Paszkiewicz io->seq = atomic64_add_return(1, &ppl_conf->seq);
2623418d036SArtur Paszkiewicz pplhdr->generation = cpu_to_le64(io->seq);
2633418d036SArtur Paszkiewicz
2643418d036SArtur Paszkiewicz return io;
2653418d036SArtur Paszkiewicz }
2663418d036SArtur Paszkiewicz
ppl_log_stripe(struct ppl_log * log,struct stripe_head * sh)2673418d036SArtur Paszkiewicz static int ppl_log_stripe(struct ppl_log *log, struct stripe_head *sh)
2683418d036SArtur Paszkiewicz {
2693418d036SArtur Paszkiewicz struct ppl_io_unit *io = log->current_io;
2703418d036SArtur Paszkiewicz struct ppl_header_entry *e = NULL;
2713418d036SArtur Paszkiewicz struct ppl_header *pplhdr;
2723418d036SArtur Paszkiewicz int i;
2733418d036SArtur Paszkiewicz sector_t data_sector = 0;
2743418d036SArtur Paszkiewicz int data_disks = 0;
2753418d036SArtur Paszkiewicz struct r5conf *conf = sh->raid_conf;
2763418d036SArtur Paszkiewicz
2773418d036SArtur Paszkiewicz pr_debug("%s: stripe: %llu\n", __func__, (unsigned long long)sh->sector);
2783418d036SArtur Paszkiewicz
2793418d036SArtur Paszkiewicz /* check if current io_unit is full */
280ddc08823SPawel Baldysiak if (io && (io->pp_size == log->entry_space ||
2813418d036SArtur Paszkiewicz io->entries_count == PPL_HDR_MAX_ENTRIES)) {
2823418d036SArtur Paszkiewicz pr_debug("%s: add io_unit blocked by seq: %llu\n",
2833418d036SArtur Paszkiewicz __func__, io->seq);
2843418d036SArtur Paszkiewicz io = NULL;
2853418d036SArtur Paszkiewicz }
2863418d036SArtur Paszkiewicz
2873418d036SArtur Paszkiewicz /* add a new unit if there is none or the current is full */
2883418d036SArtur Paszkiewicz if (!io) {
2893418d036SArtur Paszkiewicz io = ppl_new_iounit(log, sh);
2903418d036SArtur Paszkiewicz if (!io)
2913418d036SArtur Paszkiewicz return -ENOMEM;
2923418d036SArtur Paszkiewicz spin_lock_irq(&log->io_list_lock);
2933418d036SArtur Paszkiewicz list_add_tail(&io->log_sibling, &log->io_list);
2943418d036SArtur Paszkiewicz spin_unlock_irq(&log->io_list_lock);
2953418d036SArtur Paszkiewicz
2963418d036SArtur Paszkiewicz log->current_io = io;
2973418d036SArtur Paszkiewicz }
2983418d036SArtur Paszkiewicz
2993418d036SArtur Paszkiewicz for (i = 0; i < sh->disks; i++) {
3003418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i];
3013418d036SArtur Paszkiewicz
3023418d036SArtur Paszkiewicz if (i != sh->pd_idx && test_bit(R5_Wantwrite, &dev->flags)) {
3033418d036SArtur Paszkiewicz if (!data_disks || dev->sector < data_sector)
3043418d036SArtur Paszkiewicz data_sector = dev->sector;
3053418d036SArtur Paszkiewicz data_disks++;
3063418d036SArtur Paszkiewicz }
3073418d036SArtur Paszkiewicz }
3083418d036SArtur Paszkiewicz BUG_ON(!data_disks);
3093418d036SArtur Paszkiewicz
3103418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu data_sector: %llu data_disks: %d\n", __func__,
3113418d036SArtur Paszkiewicz io->seq, (unsigned long long)data_sector, data_disks);
3123418d036SArtur Paszkiewicz
3133418d036SArtur Paszkiewicz pplhdr = page_address(io->header_page);
3143418d036SArtur Paszkiewicz
3153418d036SArtur Paszkiewicz if (io->entries_count > 0) {
3163418d036SArtur Paszkiewicz struct ppl_header_entry *last =
3173418d036SArtur Paszkiewicz &pplhdr->entries[io->entries_count - 1];
3183418d036SArtur Paszkiewicz struct stripe_head *sh_last = list_last_entry(
3193418d036SArtur Paszkiewicz &io->stripe_list, struct stripe_head, log_list);
3203418d036SArtur Paszkiewicz u64 data_sector_last = le64_to_cpu(last->data_sector);
3213418d036SArtur Paszkiewicz u32 data_size_last = le32_to_cpu(last->data_size);
3223418d036SArtur Paszkiewicz
3233418d036SArtur Paszkiewicz /*
3243418d036SArtur Paszkiewicz * Check if we can append the stripe to the last entry. It must
3253418d036SArtur Paszkiewicz * be just after the last logged stripe and write to the same
3263418d036SArtur Paszkiewicz * disks. Use bit shift and logarithm to avoid 64-bit division.
3273418d036SArtur Paszkiewicz */
328c911c46cSYufen Yu if ((sh->sector == sh_last->sector + RAID5_STRIPE_SECTORS(conf)) &&
3293418d036SArtur Paszkiewicz (data_sector >> ilog2(conf->chunk_sectors) ==
3303418d036SArtur Paszkiewicz data_sector_last >> ilog2(conf->chunk_sectors)) &&
3313418d036SArtur Paszkiewicz ((data_sector - data_sector_last) * data_disks ==
3323418d036SArtur Paszkiewicz data_size_last >> 9))
3333418d036SArtur Paszkiewicz e = last;
3343418d036SArtur Paszkiewicz }
3353418d036SArtur Paszkiewicz
3363418d036SArtur Paszkiewicz if (!e) {
3373418d036SArtur Paszkiewicz e = &pplhdr->entries[io->entries_count++];
3383418d036SArtur Paszkiewicz e->data_sector = cpu_to_le64(data_sector);
3393418d036SArtur Paszkiewicz e->parity_disk = cpu_to_le32(sh->pd_idx);
3403418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(~0);
3413418d036SArtur Paszkiewicz }
3423418d036SArtur Paszkiewicz
3433418d036SArtur Paszkiewicz le32_add_cpu(&e->data_size, data_disks << PAGE_SHIFT);
3443418d036SArtur Paszkiewicz
3453418d036SArtur Paszkiewicz /* don't write any PP if full stripe write */
3463418d036SArtur Paszkiewicz if (!test_bit(STRIPE_FULL_WRITE, &sh->state)) {
3473418d036SArtur Paszkiewicz le32_add_cpu(&e->pp_size, PAGE_SIZE);
3483418d036SArtur Paszkiewicz io->pp_size += PAGE_SIZE;
3493418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(crc32c_le(le32_to_cpu(e->checksum),
3503418d036SArtur Paszkiewicz page_address(sh->ppl_page),
3513418d036SArtur Paszkiewicz PAGE_SIZE));
3523418d036SArtur Paszkiewicz }
3533418d036SArtur Paszkiewicz
3543418d036SArtur Paszkiewicz list_add_tail(&sh->log_list, &io->stripe_list);
3553418d036SArtur Paszkiewicz atomic_inc(&io->pending_stripes);
3563418d036SArtur Paszkiewicz sh->ppl_io = io;
3573418d036SArtur Paszkiewicz
3583418d036SArtur Paszkiewicz return 0;
3593418d036SArtur Paszkiewicz }
3603418d036SArtur Paszkiewicz
ppl_write_stripe(struct r5conf * conf,struct stripe_head * sh)3613418d036SArtur Paszkiewicz int ppl_write_stripe(struct r5conf *conf, struct stripe_head *sh)
3623418d036SArtur Paszkiewicz {
3633418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private;
3643418d036SArtur Paszkiewicz struct ppl_io_unit *io = sh->ppl_io;
3653418d036SArtur Paszkiewicz struct ppl_log *log;
3663418d036SArtur Paszkiewicz
367845b9e22SArtur Paszkiewicz if (io || test_bit(STRIPE_SYNCING, &sh->state) || !sh->ppl_page ||
3683418d036SArtur Paszkiewicz !test_bit(R5_Wantwrite, &sh->dev[sh->pd_idx].flags) ||
3693418d036SArtur Paszkiewicz !test_bit(R5_Insync, &sh->dev[sh->pd_idx].flags)) {
3703418d036SArtur Paszkiewicz clear_bit(STRIPE_LOG_TRAPPED, &sh->state);
3713418d036SArtur Paszkiewicz return -EAGAIN;
3723418d036SArtur Paszkiewicz }
3733418d036SArtur Paszkiewicz
3743418d036SArtur Paszkiewicz log = &ppl_conf->child_logs[sh->pd_idx];
3753418d036SArtur Paszkiewicz
3763418d036SArtur Paszkiewicz mutex_lock(&log->io_mutex);
3773418d036SArtur Paszkiewicz
3783418d036SArtur Paszkiewicz if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) {
3793418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex);
3803418d036SArtur Paszkiewicz return -EAGAIN;
3813418d036SArtur Paszkiewicz }
3823418d036SArtur Paszkiewicz
3833418d036SArtur Paszkiewicz set_bit(STRIPE_LOG_TRAPPED, &sh->state);
3843418d036SArtur Paszkiewicz clear_bit(STRIPE_DELAYED, &sh->state);
3853418d036SArtur Paszkiewicz atomic_inc(&sh->count);
3863418d036SArtur Paszkiewicz
3873418d036SArtur Paszkiewicz if (ppl_log_stripe(log, sh)) {
38894568f64SArtur Paszkiewicz spin_lock_irq(&ppl_conf->no_mem_stripes_lock);
38994568f64SArtur Paszkiewicz list_add_tail(&sh->log_list, &ppl_conf->no_mem_stripes);
39094568f64SArtur Paszkiewicz spin_unlock_irq(&ppl_conf->no_mem_stripes_lock);
3913418d036SArtur Paszkiewicz }
3923418d036SArtur Paszkiewicz
3933418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex);
3943418d036SArtur Paszkiewicz
3953418d036SArtur Paszkiewicz return 0;
3963418d036SArtur Paszkiewicz }
3973418d036SArtur Paszkiewicz
ppl_log_endio(struct bio * bio)3983418d036SArtur Paszkiewicz static void ppl_log_endio(struct bio *bio)
3993418d036SArtur Paszkiewicz {
4003418d036SArtur Paszkiewicz struct ppl_io_unit *io = bio->bi_private;
4013418d036SArtur Paszkiewicz struct ppl_log *log = io->log;
4023418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
4033418d036SArtur Paszkiewicz struct stripe_head *sh, *next;
4043418d036SArtur Paszkiewicz
4053418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu\n", __func__, io->seq);
4063418d036SArtur Paszkiewicz
4074e4cbee9SChristoph Hellwig if (bio->bi_status)
4083418d036SArtur Paszkiewicz md_error(ppl_conf->mddev, log->rdev);
4093418d036SArtur Paszkiewicz
4103418d036SArtur Paszkiewicz list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) {
4113418d036SArtur Paszkiewicz list_del_init(&sh->log_list);
4123418d036SArtur Paszkiewicz
4133418d036SArtur Paszkiewicz set_bit(STRIPE_HANDLE, &sh->state);
4143418d036SArtur Paszkiewicz raid5_release_stripe(sh);
4153418d036SArtur Paszkiewicz }
4163418d036SArtur Paszkiewicz }
4173418d036SArtur Paszkiewicz
ppl_submit_iounit_bio(struct ppl_io_unit * io,struct bio * bio)4183418d036SArtur Paszkiewicz static void ppl_submit_iounit_bio(struct ppl_io_unit *io, struct bio *bio)
4193418d036SArtur Paszkiewicz {
420c7dec462SChristoph Hellwig pr_debug("%s: seq: %llu size: %u sector: %llu dev: %pg\n",
4213418d036SArtur Paszkiewicz __func__, io->seq, bio->bi_iter.bi_size,
4223418d036SArtur Paszkiewicz (unsigned long long)bio->bi_iter.bi_sector,
423c7dec462SChristoph Hellwig bio->bi_bdev);
4243418d036SArtur Paszkiewicz
4253418d036SArtur Paszkiewicz submit_bio(bio);
4263418d036SArtur Paszkiewicz }
4273418d036SArtur Paszkiewicz
ppl_submit_iounit(struct ppl_io_unit * io)4283418d036SArtur Paszkiewicz static void ppl_submit_iounit(struct ppl_io_unit *io)
4293418d036SArtur Paszkiewicz {
4303418d036SArtur Paszkiewicz struct ppl_log *log = io->log;
4313418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
4323418d036SArtur Paszkiewicz struct ppl_header *pplhdr = page_address(io->header_page);
4333418d036SArtur Paszkiewicz struct bio *bio = &io->bio;
4343418d036SArtur Paszkiewicz struct stripe_head *sh;
4353418d036SArtur Paszkiewicz int i;
4363418d036SArtur Paszkiewicz
4376358c239SArtur Paszkiewicz bio->bi_private = io;
4386358c239SArtur Paszkiewicz
4396358c239SArtur Paszkiewicz if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) {
4406358c239SArtur Paszkiewicz ppl_log_endio(bio);
4416358c239SArtur Paszkiewicz return;
4426358c239SArtur Paszkiewicz }
4436358c239SArtur Paszkiewicz
4443418d036SArtur Paszkiewicz for (i = 0; i < io->entries_count; i++) {
4453418d036SArtur Paszkiewicz struct ppl_header_entry *e = &pplhdr->entries[i];
4463418d036SArtur Paszkiewicz
4473418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu entry: %d data_sector: %llu pp_size: %u data_size: %u\n",
4483418d036SArtur Paszkiewicz __func__, io->seq, i, le64_to_cpu(e->data_sector),
4493418d036SArtur Paszkiewicz le32_to_cpu(e->pp_size), le32_to_cpu(e->data_size));
4503418d036SArtur Paszkiewicz
4513418d036SArtur Paszkiewicz e->data_sector = cpu_to_le64(le64_to_cpu(e->data_sector) >>
4523418d036SArtur Paszkiewicz ilog2(ppl_conf->block_size >> 9));
4533418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(~le32_to_cpu(e->checksum));
4543418d036SArtur Paszkiewicz }
4553418d036SArtur Paszkiewicz
4563418d036SArtur Paszkiewicz pplhdr->entries_count = cpu_to_le32(io->entries_count);
4573418d036SArtur Paszkiewicz pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PPL_HEADER_SIZE));
4583418d036SArtur Paszkiewicz
459ddc08823SPawel Baldysiak /* Rewind the buffer if current PPL is larger then remaining space */
460ddc08823SPawel Baldysiak if (log->use_multippl &&
461ddc08823SPawel Baldysiak log->rdev->ppl.sector + log->rdev->ppl.size - log->next_io_sector <
462ddc08823SPawel Baldysiak (PPL_HEADER_SIZE + io->pp_size) >> 9)
463ddc08823SPawel Baldysiak log->next_io_sector = log->rdev->ppl.sector;
464ddc08823SPawel Baldysiak
465ddc08823SPawel Baldysiak
4663418d036SArtur Paszkiewicz bio->bi_end_io = ppl_log_endio;
467ddc08823SPawel Baldysiak bio->bi_iter.bi_sector = log->next_io_sector;
468*6eea4ff8SJohannes Thumshirn __bio_add_page(bio, io->header_page, PAGE_SIZE, 0);
4693418d036SArtur Paszkiewicz
470ddc08823SPawel Baldysiak pr_debug("%s: log->current_io_sector: %llu\n", __func__,
471ddc08823SPawel Baldysiak (unsigned long long)log->next_io_sector);
472ddc08823SPawel Baldysiak
473ddc08823SPawel Baldysiak if (log->use_multippl)
474ddc08823SPawel Baldysiak log->next_io_sector += (PPL_HEADER_SIZE + io->pp_size) >> 9;
475ddc08823SPawel Baldysiak
4761532d9e8STomasz Majchrzak WARN_ON(log->disk_flush_bitmap != 0);
4771532d9e8STomasz Majchrzak
4783418d036SArtur Paszkiewicz list_for_each_entry(sh, &io->stripe_list, log_list) {
4791532d9e8STomasz Majchrzak for (i = 0; i < sh->disks; i++) {
4801532d9e8STomasz Majchrzak struct r5dev *dev = &sh->dev[i];
4811532d9e8STomasz Majchrzak
4821532d9e8STomasz Majchrzak if ((ppl_conf->child_logs[i].wb_cache_on) &&
4831532d9e8STomasz Majchrzak (test_bit(R5_Wantwrite, &dev->flags))) {
4841532d9e8STomasz Majchrzak set_bit(i, &log->disk_flush_bitmap);
4851532d9e8STomasz Majchrzak }
4861532d9e8STomasz Majchrzak }
4871532d9e8STomasz Majchrzak
4883418d036SArtur Paszkiewicz /* entries for full stripe writes have no partial parity */
4893418d036SArtur Paszkiewicz if (test_bit(STRIPE_FULL_WRITE, &sh->state))
4903418d036SArtur Paszkiewicz continue;
4913418d036SArtur Paszkiewicz
4923418d036SArtur Paszkiewicz if (!bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0)) {
4933418d036SArtur Paszkiewicz struct bio *prev = bio;
4943418d036SArtur Paszkiewicz
495609be106SChristoph Hellwig bio = bio_alloc_bioset(prev->bi_bdev, BIO_MAX_VECS,
496609be106SChristoph Hellwig prev->bi_opf, GFP_NOIO,
497afeee514SKent Overstreet &ppl_conf->bs);
4983418d036SArtur Paszkiewicz bio->bi_iter.bi_sector = bio_end_sector(prev);
499*6eea4ff8SJohannes Thumshirn __bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0);
5003418d036SArtur Paszkiewicz
5013418d036SArtur Paszkiewicz bio_chain(bio, prev);
5023418d036SArtur Paszkiewicz ppl_submit_iounit_bio(io, prev);
5033418d036SArtur Paszkiewicz }
5043418d036SArtur Paszkiewicz }
5053418d036SArtur Paszkiewicz
5063418d036SArtur Paszkiewicz ppl_submit_iounit_bio(io, bio);
5073418d036SArtur Paszkiewicz }
5083418d036SArtur Paszkiewicz
ppl_submit_current_io(struct ppl_log * log)5093418d036SArtur Paszkiewicz static void ppl_submit_current_io(struct ppl_log *log)
5103418d036SArtur Paszkiewicz {
5113418d036SArtur Paszkiewicz struct ppl_io_unit *io;
5123418d036SArtur Paszkiewicz
5133418d036SArtur Paszkiewicz spin_lock_irq(&log->io_list_lock);
5143418d036SArtur Paszkiewicz
5153418d036SArtur Paszkiewicz io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit,
5163418d036SArtur Paszkiewicz log_sibling);
5173418d036SArtur Paszkiewicz if (io && io->submitted)
5183418d036SArtur Paszkiewicz io = NULL;
5193418d036SArtur Paszkiewicz
5203418d036SArtur Paszkiewicz spin_unlock_irq(&log->io_list_lock);
5213418d036SArtur Paszkiewicz
5223418d036SArtur Paszkiewicz if (io) {
5233418d036SArtur Paszkiewicz io->submitted = true;
5243418d036SArtur Paszkiewicz
5253418d036SArtur Paszkiewicz if (io == log->current_io)
5263418d036SArtur Paszkiewicz log->current_io = NULL;
5273418d036SArtur Paszkiewicz
5283418d036SArtur Paszkiewicz ppl_submit_iounit(io);
5293418d036SArtur Paszkiewicz }
5303418d036SArtur Paszkiewicz }
5313418d036SArtur Paszkiewicz
ppl_write_stripe_run(struct r5conf * conf)5323418d036SArtur Paszkiewicz void ppl_write_stripe_run(struct r5conf *conf)
5333418d036SArtur Paszkiewicz {
5343418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private;
5353418d036SArtur Paszkiewicz struct ppl_log *log;
5363418d036SArtur Paszkiewicz int i;
5373418d036SArtur Paszkiewicz
5383418d036SArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) {
5393418d036SArtur Paszkiewicz log = &ppl_conf->child_logs[i];
5403418d036SArtur Paszkiewicz
5413418d036SArtur Paszkiewicz mutex_lock(&log->io_mutex);
5423418d036SArtur Paszkiewicz ppl_submit_current_io(log);
5433418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex);
5443418d036SArtur Paszkiewicz }
5453418d036SArtur Paszkiewicz }
5463418d036SArtur Paszkiewicz
ppl_io_unit_finished(struct ppl_io_unit * io)5473418d036SArtur Paszkiewicz static void ppl_io_unit_finished(struct ppl_io_unit *io)
5483418d036SArtur Paszkiewicz {
5493418d036SArtur Paszkiewicz struct ppl_log *log = io->log;
55094568f64SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
5511532d9e8STomasz Majchrzak struct r5conf *conf = ppl_conf->mddev->private;
5523418d036SArtur Paszkiewicz unsigned long flags;
5533418d036SArtur Paszkiewicz
5543418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu\n", __func__, io->seq);
5553418d036SArtur Paszkiewicz
55694568f64SArtur Paszkiewicz local_irq_save(flags);
5573418d036SArtur Paszkiewicz
55894568f64SArtur Paszkiewicz spin_lock(&log->io_list_lock);
5593418d036SArtur Paszkiewicz list_del(&io->log_sibling);
56094568f64SArtur Paszkiewicz spin_unlock(&log->io_list_lock);
5613418d036SArtur Paszkiewicz
562afeee514SKent Overstreet mempool_free(io, &ppl_conf->io_pool);
56394568f64SArtur Paszkiewicz
56494568f64SArtur Paszkiewicz spin_lock(&ppl_conf->no_mem_stripes_lock);
56594568f64SArtur Paszkiewicz if (!list_empty(&ppl_conf->no_mem_stripes)) {
56694568f64SArtur Paszkiewicz struct stripe_head *sh;
56794568f64SArtur Paszkiewicz
56894568f64SArtur Paszkiewicz sh = list_first_entry(&ppl_conf->no_mem_stripes,
56994568f64SArtur Paszkiewicz struct stripe_head, log_list);
5703418d036SArtur Paszkiewicz list_del_init(&sh->log_list);
5713418d036SArtur Paszkiewicz set_bit(STRIPE_HANDLE, &sh->state);
5723418d036SArtur Paszkiewicz raid5_release_stripe(sh);
5733418d036SArtur Paszkiewicz }
57494568f64SArtur Paszkiewicz spin_unlock(&ppl_conf->no_mem_stripes_lock);
5753418d036SArtur Paszkiewicz
57694568f64SArtur Paszkiewicz local_irq_restore(flags);
5771532d9e8STomasz Majchrzak
5781532d9e8STomasz Majchrzak wake_up(&conf->wait_for_quiescent);
5791532d9e8STomasz Majchrzak }
5801532d9e8STomasz Majchrzak
ppl_flush_endio(struct bio * bio)5811532d9e8STomasz Majchrzak static void ppl_flush_endio(struct bio *bio)
5821532d9e8STomasz Majchrzak {
5831532d9e8STomasz Majchrzak struct ppl_io_unit *io = bio->bi_private;
5841532d9e8STomasz Majchrzak struct ppl_log *log = io->log;
5851532d9e8STomasz Majchrzak struct ppl_conf *ppl_conf = log->ppl_conf;
5861532d9e8STomasz Majchrzak struct r5conf *conf = ppl_conf->mddev->private;
5871532d9e8STomasz Majchrzak
588c7dec462SChristoph Hellwig pr_debug("%s: dev: %pg\n", __func__, bio->bi_bdev);
5891532d9e8STomasz Majchrzak
5901532d9e8STomasz Majchrzak if (bio->bi_status) {
5911532d9e8STomasz Majchrzak struct md_rdev *rdev;
5921532d9e8STomasz Majchrzak
5931532d9e8STomasz Majchrzak rcu_read_lock();
5941532d9e8STomasz Majchrzak rdev = md_find_rdev_rcu(conf->mddev, bio_dev(bio));
5951532d9e8STomasz Majchrzak if (rdev)
5961532d9e8STomasz Majchrzak md_error(rdev->mddev, rdev);
5971532d9e8STomasz Majchrzak rcu_read_unlock();
5981532d9e8STomasz Majchrzak }
5991532d9e8STomasz Majchrzak
6001532d9e8STomasz Majchrzak bio_put(bio);
6011532d9e8STomasz Majchrzak
6021532d9e8STomasz Majchrzak if (atomic_dec_and_test(&io->pending_flushes)) {
6031532d9e8STomasz Majchrzak ppl_io_unit_finished(io);
6041532d9e8STomasz Majchrzak md_wakeup_thread(conf->mddev->thread);
6051532d9e8STomasz Majchrzak }
6061532d9e8STomasz Majchrzak }
6071532d9e8STomasz Majchrzak
ppl_do_flush(struct ppl_io_unit * io)6081532d9e8STomasz Majchrzak static void ppl_do_flush(struct ppl_io_unit *io)
6091532d9e8STomasz Majchrzak {
6101532d9e8STomasz Majchrzak struct ppl_log *log = io->log;
6111532d9e8STomasz Majchrzak struct ppl_conf *ppl_conf = log->ppl_conf;
6121532d9e8STomasz Majchrzak struct r5conf *conf = ppl_conf->mddev->private;
6131532d9e8STomasz Majchrzak int raid_disks = conf->raid_disks;
6141532d9e8STomasz Majchrzak int flushed_disks = 0;
6151532d9e8STomasz Majchrzak int i;
6161532d9e8STomasz Majchrzak
6171532d9e8STomasz Majchrzak atomic_set(&io->pending_flushes, raid_disks);
6181532d9e8STomasz Majchrzak
6191532d9e8STomasz Majchrzak for_each_set_bit(i, &log->disk_flush_bitmap, raid_disks) {
6201532d9e8STomasz Majchrzak struct md_rdev *rdev;
6211532d9e8STomasz Majchrzak struct block_device *bdev = NULL;
6221532d9e8STomasz Majchrzak
6231532d9e8STomasz Majchrzak rcu_read_lock();
6241532d9e8STomasz Majchrzak rdev = rcu_dereference(conf->disks[i].rdev);
6251532d9e8STomasz Majchrzak if (rdev && !test_bit(Faulty, &rdev->flags))
6261532d9e8STomasz Majchrzak bdev = rdev->bdev;
6271532d9e8STomasz Majchrzak rcu_read_unlock();
6281532d9e8STomasz Majchrzak
6291532d9e8STomasz Majchrzak if (bdev) {
6301532d9e8STomasz Majchrzak struct bio *bio;
6311532d9e8STomasz Majchrzak
632f34fdcd4SLogan Gunthorpe bio = bio_alloc_bioset(bdev, 0,
633609be106SChristoph Hellwig REQ_OP_WRITE | REQ_PREFLUSH,
634f34fdcd4SLogan Gunthorpe GFP_NOIO, &ppl_conf->flush_bs);
6351532d9e8STomasz Majchrzak bio->bi_private = io;
6361532d9e8STomasz Majchrzak bio->bi_end_io = ppl_flush_endio;
6371532d9e8STomasz Majchrzak
638c7dec462SChristoph Hellwig pr_debug("%s: dev: %ps\n", __func__, bio->bi_bdev);
6391532d9e8STomasz Majchrzak
6401532d9e8STomasz Majchrzak submit_bio(bio);
6411532d9e8STomasz Majchrzak flushed_disks++;
6421532d9e8STomasz Majchrzak }
6431532d9e8STomasz Majchrzak }
6441532d9e8STomasz Majchrzak
6451532d9e8STomasz Majchrzak log->disk_flush_bitmap = 0;
6461532d9e8STomasz Majchrzak
6471532d9e8STomasz Majchrzak for (i = flushed_disks ; i < raid_disks; i++) {
6481532d9e8STomasz Majchrzak if (atomic_dec_and_test(&io->pending_flushes))
6491532d9e8STomasz Majchrzak ppl_io_unit_finished(io);
6501532d9e8STomasz Majchrzak }
6511532d9e8STomasz Majchrzak }
6521532d9e8STomasz Majchrzak
ppl_no_io_unit_submitted(struct r5conf * conf,struct ppl_log * log)6531532d9e8STomasz Majchrzak static inline bool ppl_no_io_unit_submitted(struct r5conf *conf,
6541532d9e8STomasz Majchrzak struct ppl_log *log)
6551532d9e8STomasz Majchrzak {
6561532d9e8STomasz Majchrzak struct ppl_io_unit *io;
6571532d9e8STomasz Majchrzak
6581532d9e8STomasz Majchrzak io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit,
6591532d9e8STomasz Majchrzak log_sibling);
6601532d9e8STomasz Majchrzak
6611532d9e8STomasz Majchrzak return !io || !io->submitted;
6621532d9e8STomasz Majchrzak }
6631532d9e8STomasz Majchrzak
ppl_quiesce(struct r5conf * conf,int quiesce)6641532d9e8STomasz Majchrzak void ppl_quiesce(struct r5conf *conf, int quiesce)
6651532d9e8STomasz Majchrzak {
6661532d9e8STomasz Majchrzak struct ppl_conf *ppl_conf = conf->log_private;
6671532d9e8STomasz Majchrzak int i;
6681532d9e8STomasz Majchrzak
6691532d9e8STomasz Majchrzak if (quiesce) {
6701532d9e8STomasz Majchrzak for (i = 0; i < ppl_conf->count; i++) {
6711532d9e8STomasz Majchrzak struct ppl_log *log = &ppl_conf->child_logs[i];
6721532d9e8STomasz Majchrzak
6731532d9e8STomasz Majchrzak spin_lock_irq(&log->io_list_lock);
6741532d9e8STomasz Majchrzak wait_event_lock_irq(conf->wait_for_quiescent,
6751532d9e8STomasz Majchrzak ppl_no_io_unit_submitted(conf, log),
6761532d9e8STomasz Majchrzak log->io_list_lock);
6771532d9e8STomasz Majchrzak spin_unlock_irq(&log->io_list_lock);
6781532d9e8STomasz Majchrzak }
6791532d9e8STomasz Majchrzak }
6803418d036SArtur Paszkiewicz }
6813418d036SArtur Paszkiewicz
ppl_handle_flush_request(struct bio * bio)682e0fccdafSLogan Gunthorpe int ppl_handle_flush_request(struct bio *bio)
683f4bc0c81SArtur Paszkiewicz {
684f4bc0c81SArtur Paszkiewicz if (bio->bi_iter.bi_size == 0) {
685f4bc0c81SArtur Paszkiewicz bio_endio(bio);
686f4bc0c81SArtur Paszkiewicz return 0;
687f4bc0c81SArtur Paszkiewicz }
688f4bc0c81SArtur Paszkiewicz bio->bi_opf &= ~REQ_PREFLUSH;
689f4bc0c81SArtur Paszkiewicz return -EAGAIN;
690f4bc0c81SArtur Paszkiewicz }
691f4bc0c81SArtur Paszkiewicz
ppl_stripe_write_finished(struct stripe_head * sh)6923418d036SArtur Paszkiewicz void ppl_stripe_write_finished(struct stripe_head *sh)
6933418d036SArtur Paszkiewicz {
6943418d036SArtur Paszkiewicz struct ppl_io_unit *io;
6953418d036SArtur Paszkiewicz
6963418d036SArtur Paszkiewicz io = sh->ppl_io;
6973418d036SArtur Paszkiewicz sh->ppl_io = NULL;
6983418d036SArtur Paszkiewicz
6991532d9e8STomasz Majchrzak if (io && atomic_dec_and_test(&io->pending_stripes)) {
7001532d9e8STomasz Majchrzak if (io->log->disk_flush_bitmap)
7011532d9e8STomasz Majchrzak ppl_do_flush(io);
7021532d9e8STomasz Majchrzak else
7033418d036SArtur Paszkiewicz ppl_io_unit_finished(io);
7043418d036SArtur Paszkiewicz }
7051532d9e8STomasz Majchrzak }
7063418d036SArtur Paszkiewicz
ppl_xor(int size,struct page * page1,struct page * page2)7074536bf9bSArtur Paszkiewicz static void ppl_xor(int size, struct page *page1, struct page *page2)
7084536bf9bSArtur Paszkiewicz {
7094536bf9bSArtur Paszkiewicz struct async_submit_ctl submit;
7104536bf9bSArtur Paszkiewicz struct dma_async_tx_descriptor *tx;
7114536bf9bSArtur Paszkiewicz struct page *xor_srcs[] = { page1, page2 };
7124536bf9bSArtur Paszkiewicz
7134536bf9bSArtur Paszkiewicz init_async_submit(&submit, ASYNC_TX_ACK|ASYNC_TX_XOR_DROP_DST,
7144536bf9bSArtur Paszkiewicz NULL, NULL, NULL, NULL);
7154536bf9bSArtur Paszkiewicz tx = async_xor(page1, xor_srcs, 0, 2, size, &submit);
7164536bf9bSArtur Paszkiewicz
7174536bf9bSArtur Paszkiewicz async_tx_quiesce(&tx);
7184536bf9bSArtur Paszkiewicz }
7194536bf9bSArtur Paszkiewicz
7204536bf9bSArtur Paszkiewicz /*
7214536bf9bSArtur Paszkiewicz * PPL recovery strategy: xor partial parity and data from all modified data
7224536bf9bSArtur Paszkiewicz * disks within a stripe and write the result as the new stripe parity. If all
7234536bf9bSArtur Paszkiewicz * stripe data disks are modified (full stripe write), no partial parity is
7244536bf9bSArtur Paszkiewicz * available, so just xor the data disks.
7254536bf9bSArtur Paszkiewicz *
7264536bf9bSArtur Paszkiewicz * Recovery of a PPL entry shall occur only if all modified data disks are
7274536bf9bSArtur Paszkiewicz * available and read from all of them succeeds.
7284536bf9bSArtur Paszkiewicz *
7294536bf9bSArtur Paszkiewicz * A PPL entry applies to a stripe, partial parity size for an entry is at most
7304536bf9bSArtur Paszkiewicz * the size of the chunk. Examples of possible cases for a single entry:
7314536bf9bSArtur Paszkiewicz *
7324536bf9bSArtur Paszkiewicz * case 0: single data disk write:
7334536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity
7344536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+
7354536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) |
7364536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | -> | data1 ^ pp |
7374536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | -> | data1 ^ pp |
7384536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) |
7394536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+
7404536bf9bSArtur Paszkiewicz * pp_size = data_size
7414536bf9bSArtur Paszkiewicz *
7424536bf9bSArtur Paszkiewicz * case 1: more than one data disk write:
7434536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity
7444536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+
7454536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) |
7464536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp |
7474536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp |
7484536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) |
7494536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+
7504536bf9bSArtur Paszkiewicz * pp_size = data_size / modified_data_disks
7514536bf9bSArtur Paszkiewicz *
7524536bf9bSArtur Paszkiewicz * case 2: write to all data disks (also full stripe write):
7534536bf9bSArtur Paszkiewicz * data0 data1 data2 parity
7544536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+
7554536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | (no change) |
7564536bf9bSArtur Paszkiewicz * | -data- | -data- | -data- | --------> | xor all data |
7574536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | --------> | (no change) |
7584536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | (no change) |
7594536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+
7604536bf9bSArtur Paszkiewicz * pp_size = 0
7614536bf9bSArtur Paszkiewicz *
7624536bf9bSArtur Paszkiewicz * The following cases are possible only in other implementations. The recovery
7634536bf9bSArtur Paszkiewicz * code can handle them, but they are not generated at runtime because they can
7644536bf9bSArtur Paszkiewicz * be reduced to cases 0, 1 and 2:
7654536bf9bSArtur Paszkiewicz *
7664536bf9bSArtur Paszkiewicz * case 3:
7674536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity
7684536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+
7694536bf9bSArtur Paszkiewicz * | ------ | -data- | -data- | | pp | | data1 ^ data2 ^ pp |
7704536bf9bSArtur Paszkiewicz * | ------ | -data- | -data- | | pp | -> | data1 ^ data2 ^ pp |
7714536bf9bSArtur Paszkiewicz * | -data- | -data- | -data- | | -- | -> | xor all data |
7724536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | | data0 ^ data1 ^ pp |
7734536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+
7744536bf9bSArtur Paszkiewicz * pp_size = chunk_size
7754536bf9bSArtur Paszkiewicz *
7764536bf9bSArtur Paszkiewicz * case 4:
7774536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity
7784536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+
7794536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | | data1 ^ pp |
7804536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | -- | -> | (no change) |
7814536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | -- | -> | (no change) |
7824536bf9bSArtur Paszkiewicz * | -data- | ------ | ------ | | pp | | data0 ^ pp |
7834536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+
7844536bf9bSArtur Paszkiewicz * pp_size = chunk_size
7854536bf9bSArtur Paszkiewicz */
ppl_recover_entry(struct ppl_log * log,struct ppl_header_entry * e,sector_t ppl_sector)7864536bf9bSArtur Paszkiewicz static int ppl_recover_entry(struct ppl_log *log, struct ppl_header_entry *e,
7874536bf9bSArtur Paszkiewicz sector_t ppl_sector)
7884536bf9bSArtur Paszkiewicz {
7894536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
7904536bf9bSArtur Paszkiewicz struct mddev *mddev = ppl_conf->mddev;
7914536bf9bSArtur Paszkiewicz struct r5conf *conf = mddev->private;
7924536bf9bSArtur Paszkiewicz int block_size = ppl_conf->block_size;
7934536bf9bSArtur Paszkiewicz struct page *page1;
7944536bf9bSArtur Paszkiewicz struct page *page2;
7954536bf9bSArtur Paszkiewicz sector_t r_sector_first;
7964536bf9bSArtur Paszkiewicz sector_t r_sector_last;
7974536bf9bSArtur Paszkiewicz int strip_sectors;
7984536bf9bSArtur Paszkiewicz int data_disks;
7994536bf9bSArtur Paszkiewicz int i;
8004536bf9bSArtur Paszkiewicz int ret = 0;
8014536bf9bSArtur Paszkiewicz unsigned int pp_size = le32_to_cpu(e->pp_size);
8024536bf9bSArtur Paszkiewicz unsigned int data_size = le32_to_cpu(e->data_size);
8034536bf9bSArtur Paszkiewicz
8044536bf9bSArtur Paszkiewicz page1 = alloc_page(GFP_KERNEL);
8054536bf9bSArtur Paszkiewicz page2 = alloc_page(GFP_KERNEL);
8064536bf9bSArtur Paszkiewicz
8074536bf9bSArtur Paszkiewicz if (!page1 || !page2) {
8084536bf9bSArtur Paszkiewicz ret = -ENOMEM;
8094536bf9bSArtur Paszkiewicz goto out;
8104536bf9bSArtur Paszkiewicz }
8114536bf9bSArtur Paszkiewicz
8124536bf9bSArtur Paszkiewicz r_sector_first = le64_to_cpu(e->data_sector) * (block_size >> 9);
8134536bf9bSArtur Paszkiewicz
8144536bf9bSArtur Paszkiewicz if ((pp_size >> 9) < conf->chunk_sectors) {
8154536bf9bSArtur Paszkiewicz if (pp_size > 0) {
8164536bf9bSArtur Paszkiewicz data_disks = data_size / pp_size;
8174536bf9bSArtur Paszkiewicz strip_sectors = pp_size >> 9;
8184536bf9bSArtur Paszkiewicz } else {
8194536bf9bSArtur Paszkiewicz data_disks = conf->raid_disks - conf->max_degraded;
8204536bf9bSArtur Paszkiewicz strip_sectors = (data_size >> 9) / data_disks;
8214536bf9bSArtur Paszkiewicz }
8224536bf9bSArtur Paszkiewicz r_sector_last = r_sector_first +
8234536bf9bSArtur Paszkiewicz (data_disks - 1) * conf->chunk_sectors +
8244536bf9bSArtur Paszkiewicz strip_sectors;
8254536bf9bSArtur Paszkiewicz } else {
8264536bf9bSArtur Paszkiewicz data_disks = conf->raid_disks - conf->max_degraded;
8274536bf9bSArtur Paszkiewicz strip_sectors = conf->chunk_sectors;
8284536bf9bSArtur Paszkiewicz r_sector_last = r_sector_first + (data_size >> 9);
8294536bf9bSArtur Paszkiewicz }
8304536bf9bSArtur Paszkiewicz
8314536bf9bSArtur Paszkiewicz pr_debug("%s: array sector first: %llu last: %llu\n", __func__,
8324536bf9bSArtur Paszkiewicz (unsigned long long)r_sector_first,
8334536bf9bSArtur Paszkiewicz (unsigned long long)r_sector_last);
8344536bf9bSArtur Paszkiewicz
8354536bf9bSArtur Paszkiewicz /* if start and end is 4k aligned, use a 4k block */
8364536bf9bSArtur Paszkiewicz if (block_size == 512 &&
837c911c46cSYufen Yu (r_sector_first & (RAID5_STRIPE_SECTORS(conf) - 1)) == 0 &&
838c911c46cSYufen Yu (r_sector_last & (RAID5_STRIPE_SECTORS(conf) - 1)) == 0)
839c911c46cSYufen Yu block_size = RAID5_STRIPE_SIZE(conf);
8404536bf9bSArtur Paszkiewicz
8414536bf9bSArtur Paszkiewicz /* iterate through blocks in strip */
8424536bf9bSArtur Paszkiewicz for (i = 0; i < strip_sectors; i += (block_size >> 9)) {
8434536bf9bSArtur Paszkiewicz bool update_parity = false;
8444536bf9bSArtur Paszkiewicz sector_t parity_sector;
8454536bf9bSArtur Paszkiewicz struct md_rdev *parity_rdev;
8464536bf9bSArtur Paszkiewicz struct stripe_head sh;
8474536bf9bSArtur Paszkiewicz int disk;
8484536bf9bSArtur Paszkiewicz int indent = 0;
8494536bf9bSArtur Paszkiewicz
8504536bf9bSArtur Paszkiewicz pr_debug("%s:%*s iter %d start\n", __func__, indent, "", i);
8514536bf9bSArtur Paszkiewicz indent += 2;
8524536bf9bSArtur Paszkiewicz
8534536bf9bSArtur Paszkiewicz memset(page_address(page1), 0, PAGE_SIZE);
8544536bf9bSArtur Paszkiewicz
8554536bf9bSArtur Paszkiewicz /* iterate through data member disks */
8564536bf9bSArtur Paszkiewicz for (disk = 0; disk < data_disks; disk++) {
8574536bf9bSArtur Paszkiewicz int dd_idx;
8584536bf9bSArtur Paszkiewicz struct md_rdev *rdev;
8594536bf9bSArtur Paszkiewicz sector_t sector;
8604536bf9bSArtur Paszkiewicz sector_t r_sector = r_sector_first + i +
8614536bf9bSArtur Paszkiewicz (disk * conf->chunk_sectors);
8624536bf9bSArtur Paszkiewicz
8634536bf9bSArtur Paszkiewicz pr_debug("%s:%*s data member disk %d start\n",
8644536bf9bSArtur Paszkiewicz __func__, indent, "", disk);
8654536bf9bSArtur Paszkiewicz indent += 2;
8664536bf9bSArtur Paszkiewicz
8674536bf9bSArtur Paszkiewicz if (r_sector >= r_sector_last) {
8684536bf9bSArtur Paszkiewicz pr_debug("%s:%*s array sector %llu doesn't need parity update\n",
8694536bf9bSArtur Paszkiewicz __func__, indent, "",
8704536bf9bSArtur Paszkiewicz (unsigned long long)r_sector);
8714536bf9bSArtur Paszkiewicz indent -= 2;
8724536bf9bSArtur Paszkiewicz continue;
8734536bf9bSArtur Paszkiewicz }
8744536bf9bSArtur Paszkiewicz
8754536bf9bSArtur Paszkiewicz update_parity = true;
8764536bf9bSArtur Paszkiewicz
8774536bf9bSArtur Paszkiewicz /* map raid sector to member disk */
8784536bf9bSArtur Paszkiewicz sector = raid5_compute_sector(conf, r_sector, 0,
8794536bf9bSArtur Paszkiewicz &dd_idx, NULL);
8804536bf9bSArtur Paszkiewicz pr_debug("%s:%*s processing array sector %llu => data member disk %d, sector %llu\n",
8814536bf9bSArtur Paszkiewicz __func__, indent, "",
8824536bf9bSArtur Paszkiewicz (unsigned long long)r_sector, dd_idx,
8834536bf9bSArtur Paszkiewicz (unsigned long long)sector);
8844536bf9bSArtur Paszkiewicz
8854f4ee2bfSLogan Gunthorpe /* Array has not started so rcu dereference is safe */
8864f4ee2bfSLogan Gunthorpe rdev = rcu_dereference_protected(
8874f4ee2bfSLogan Gunthorpe conf->disks[dd_idx].rdev, 1);
88807719ff7SArtur Paszkiewicz if (!rdev || (!test_bit(In_sync, &rdev->flags) &&
88907719ff7SArtur Paszkiewicz sector >= rdev->recovery_offset)) {
8904536bf9bSArtur Paszkiewicz pr_debug("%s:%*s data member disk %d missing\n",
8914536bf9bSArtur Paszkiewicz __func__, indent, "", dd_idx);
8924536bf9bSArtur Paszkiewicz update_parity = false;
8934536bf9bSArtur Paszkiewicz break;
8944536bf9bSArtur Paszkiewicz }
8954536bf9bSArtur Paszkiewicz
896913cce5aSChristoph Hellwig pr_debug("%s:%*s reading data member disk %pg sector %llu\n",
897913cce5aSChristoph Hellwig __func__, indent, "", rdev->bdev,
8984536bf9bSArtur Paszkiewicz (unsigned long long)sector);
8994536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, sector, block_size, page2,
9004ce4c73fSBart Van Assche REQ_OP_READ, false)) {
9014536bf9bSArtur Paszkiewicz md_error(mddev, rdev);
9024536bf9bSArtur Paszkiewicz pr_debug("%s:%*s read failed!\n", __func__,
9034536bf9bSArtur Paszkiewicz indent, "");
9044536bf9bSArtur Paszkiewicz ret = -EIO;
9054536bf9bSArtur Paszkiewicz goto out;
9064536bf9bSArtur Paszkiewicz }
9074536bf9bSArtur Paszkiewicz
9084536bf9bSArtur Paszkiewicz ppl_xor(block_size, page1, page2);
9094536bf9bSArtur Paszkiewicz
9104536bf9bSArtur Paszkiewicz indent -= 2;
9114536bf9bSArtur Paszkiewicz }
9124536bf9bSArtur Paszkiewicz
9134536bf9bSArtur Paszkiewicz if (!update_parity)
9144536bf9bSArtur Paszkiewicz continue;
9154536bf9bSArtur Paszkiewicz
9164536bf9bSArtur Paszkiewicz if (pp_size > 0) {
9174536bf9bSArtur Paszkiewicz pr_debug("%s:%*s reading pp disk sector %llu\n",
9184536bf9bSArtur Paszkiewicz __func__, indent, "",
9194536bf9bSArtur Paszkiewicz (unsigned long long)(ppl_sector + i));
9204536bf9bSArtur Paszkiewicz if (!sync_page_io(log->rdev,
9214536bf9bSArtur Paszkiewicz ppl_sector - log->rdev->data_offset + i,
9224ce4c73fSBart Van Assche block_size, page2, REQ_OP_READ,
9234536bf9bSArtur Paszkiewicz false)) {
9244536bf9bSArtur Paszkiewicz pr_debug("%s:%*s read failed!\n", __func__,
9254536bf9bSArtur Paszkiewicz indent, "");
9264536bf9bSArtur Paszkiewicz md_error(mddev, log->rdev);
9274536bf9bSArtur Paszkiewicz ret = -EIO;
9284536bf9bSArtur Paszkiewicz goto out;
9294536bf9bSArtur Paszkiewicz }
9304536bf9bSArtur Paszkiewicz
9314536bf9bSArtur Paszkiewicz ppl_xor(block_size, page1, page2);
9324536bf9bSArtur Paszkiewicz }
9334536bf9bSArtur Paszkiewicz
9344536bf9bSArtur Paszkiewicz /* map raid sector to parity disk */
9354536bf9bSArtur Paszkiewicz parity_sector = raid5_compute_sector(conf, r_sector_first + i,
9364536bf9bSArtur Paszkiewicz 0, &disk, &sh);
9374536bf9bSArtur Paszkiewicz BUG_ON(sh.pd_idx != le32_to_cpu(e->parity_disk));
9384f4ee2bfSLogan Gunthorpe
9394f4ee2bfSLogan Gunthorpe /* Array has not started so rcu dereference is safe */
9404f4ee2bfSLogan Gunthorpe parity_rdev = rcu_dereference_protected(
9414f4ee2bfSLogan Gunthorpe conf->disks[sh.pd_idx].rdev, 1);
9424536bf9bSArtur Paszkiewicz
9434536bf9bSArtur Paszkiewicz BUG_ON(parity_rdev->bdev->bd_dev != log->rdev->bdev->bd_dev);
944913cce5aSChristoph Hellwig pr_debug("%s:%*s write parity at sector %llu, disk %pg\n",
9454536bf9bSArtur Paszkiewicz __func__, indent, "",
9464536bf9bSArtur Paszkiewicz (unsigned long long)parity_sector,
947913cce5aSChristoph Hellwig parity_rdev->bdev);
9484536bf9bSArtur Paszkiewicz if (!sync_page_io(parity_rdev, parity_sector, block_size,
9494ce4c73fSBart Van Assche page1, REQ_OP_WRITE, false)) {
9504536bf9bSArtur Paszkiewicz pr_debug("%s:%*s parity write error!\n", __func__,
9514536bf9bSArtur Paszkiewicz indent, "");
9524536bf9bSArtur Paszkiewicz md_error(mddev, parity_rdev);
9534536bf9bSArtur Paszkiewicz ret = -EIO;
9544536bf9bSArtur Paszkiewicz goto out;
9554536bf9bSArtur Paszkiewicz }
9564536bf9bSArtur Paszkiewicz }
9574536bf9bSArtur Paszkiewicz out:
9584536bf9bSArtur Paszkiewicz if (page1)
9594536bf9bSArtur Paszkiewicz __free_page(page1);
9604536bf9bSArtur Paszkiewicz if (page2)
9614536bf9bSArtur Paszkiewicz __free_page(page2);
9624536bf9bSArtur Paszkiewicz return ret;
9634536bf9bSArtur Paszkiewicz }
9644536bf9bSArtur Paszkiewicz
ppl_recover(struct ppl_log * log,struct ppl_header * pplhdr,sector_t offset)965675dc2ccSPawel Baldysiak static int ppl_recover(struct ppl_log *log, struct ppl_header *pplhdr,
966675dc2ccSPawel Baldysiak sector_t offset)
9674536bf9bSArtur Paszkiewicz {
9684536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
9694536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev;
9704536bf9bSArtur Paszkiewicz struct mddev *mddev = rdev->mddev;
971675dc2ccSPawel Baldysiak sector_t ppl_sector = rdev->ppl.sector + offset +
972675dc2ccSPawel Baldysiak (PPL_HEADER_SIZE >> 9);
9734536bf9bSArtur Paszkiewicz struct page *page;
9744536bf9bSArtur Paszkiewicz int i;
9754536bf9bSArtur Paszkiewicz int ret = 0;
9764536bf9bSArtur Paszkiewicz
9774536bf9bSArtur Paszkiewicz page = alloc_page(GFP_KERNEL);
9784536bf9bSArtur Paszkiewicz if (!page)
9794536bf9bSArtur Paszkiewicz return -ENOMEM;
9804536bf9bSArtur Paszkiewicz
9814536bf9bSArtur Paszkiewicz /* iterate through all PPL entries saved */
9824536bf9bSArtur Paszkiewicz for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++) {
9834536bf9bSArtur Paszkiewicz struct ppl_header_entry *e = &pplhdr->entries[i];
9844536bf9bSArtur Paszkiewicz u32 pp_size = le32_to_cpu(e->pp_size);
9854536bf9bSArtur Paszkiewicz sector_t sector = ppl_sector;
9864536bf9bSArtur Paszkiewicz int ppl_entry_sectors = pp_size >> 9;
9874536bf9bSArtur Paszkiewicz u32 crc, crc_stored;
9884536bf9bSArtur Paszkiewicz
9894536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d entry: %d ppl_sector: %llu pp_size: %u\n",
9904536bf9bSArtur Paszkiewicz __func__, rdev->raid_disk, i,
9914536bf9bSArtur Paszkiewicz (unsigned long long)ppl_sector, pp_size);
9924536bf9bSArtur Paszkiewicz
9934536bf9bSArtur Paszkiewicz crc = ~0;
9944536bf9bSArtur Paszkiewicz crc_stored = le32_to_cpu(e->checksum);
9954536bf9bSArtur Paszkiewicz
9964536bf9bSArtur Paszkiewicz /* read parial parity for this entry and calculate its checksum */
9974536bf9bSArtur Paszkiewicz while (pp_size) {
9984536bf9bSArtur Paszkiewicz int s = pp_size > PAGE_SIZE ? PAGE_SIZE : pp_size;
9994536bf9bSArtur Paszkiewicz
10004536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, sector - rdev->data_offset,
10014ce4c73fSBart Van Assche s, page, REQ_OP_READ, false)) {
10024536bf9bSArtur Paszkiewicz md_error(mddev, rdev);
10034536bf9bSArtur Paszkiewicz ret = -EIO;
10044536bf9bSArtur Paszkiewicz goto out;
10054536bf9bSArtur Paszkiewicz }
10064536bf9bSArtur Paszkiewicz
10074536bf9bSArtur Paszkiewicz crc = crc32c_le(crc, page_address(page), s);
10084536bf9bSArtur Paszkiewicz
10094536bf9bSArtur Paszkiewicz pp_size -= s;
10104536bf9bSArtur Paszkiewicz sector += s >> 9;
10114536bf9bSArtur Paszkiewicz }
10124536bf9bSArtur Paszkiewicz
10134536bf9bSArtur Paszkiewicz crc = ~crc;
10144536bf9bSArtur Paszkiewicz
10154536bf9bSArtur Paszkiewicz if (crc != crc_stored) {
10164536bf9bSArtur Paszkiewicz /*
10174536bf9bSArtur Paszkiewicz * Don't recover this entry if the checksum does not
10184536bf9bSArtur Paszkiewicz * match, but keep going and try to recover other
10194536bf9bSArtur Paszkiewicz * entries.
10204536bf9bSArtur Paszkiewicz */
10214536bf9bSArtur Paszkiewicz pr_debug("%s: ppl entry crc does not match: stored: 0x%x calculated: 0x%x\n",
10224536bf9bSArtur Paszkiewicz __func__, crc_stored, crc);
10234536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count++;
10244536bf9bSArtur Paszkiewicz } else {
10254536bf9bSArtur Paszkiewicz ret = ppl_recover_entry(log, e, ppl_sector);
10264536bf9bSArtur Paszkiewicz if (ret)
10274536bf9bSArtur Paszkiewicz goto out;
10284536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries++;
10294536bf9bSArtur Paszkiewicz }
10304536bf9bSArtur Paszkiewicz
10314536bf9bSArtur Paszkiewicz ppl_sector += ppl_entry_sectors;
10324536bf9bSArtur Paszkiewicz }
10334536bf9bSArtur Paszkiewicz
10344536bf9bSArtur Paszkiewicz /* flush the disk cache after recovery if necessary */
1035c6bf3f0eSChristoph Hellwig ret = blkdev_issue_flush(rdev->bdev);
10364536bf9bSArtur Paszkiewicz out:
10374536bf9bSArtur Paszkiewicz __free_page(page);
10384536bf9bSArtur Paszkiewicz return ret;
10394536bf9bSArtur Paszkiewicz }
10404536bf9bSArtur Paszkiewicz
ppl_write_empty_header(struct ppl_log * log)10414536bf9bSArtur Paszkiewicz static int ppl_write_empty_header(struct ppl_log *log)
10424536bf9bSArtur Paszkiewicz {
10434536bf9bSArtur Paszkiewicz struct page *page;
10444536bf9bSArtur Paszkiewicz struct ppl_header *pplhdr;
10454536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev;
10464536bf9bSArtur Paszkiewicz int ret = 0;
10474536bf9bSArtur Paszkiewicz
10484536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d ppl_sector: %llu\n", __func__,
10494536bf9bSArtur Paszkiewicz rdev->raid_disk, (unsigned long long)rdev->ppl.sector);
10504536bf9bSArtur Paszkiewicz
10514536bf9bSArtur Paszkiewicz page = alloc_page(GFP_NOIO | __GFP_ZERO);
10524536bf9bSArtur Paszkiewicz if (!page)
10534536bf9bSArtur Paszkiewicz return -ENOMEM;
10544536bf9bSArtur Paszkiewicz
10554536bf9bSArtur Paszkiewicz pplhdr = page_address(page);
1056675dc2ccSPawel Baldysiak /* zero out PPL space to avoid collision with old PPLs */
1057675dc2ccSPawel Baldysiak blkdev_issue_zeroout(rdev->bdev, rdev->ppl.sector,
1058675dc2ccSPawel Baldysiak log->rdev->ppl.size, GFP_NOIO, 0);
10594536bf9bSArtur Paszkiewicz memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED);
10604536bf9bSArtur Paszkiewicz pplhdr->signature = cpu_to_le32(log->ppl_conf->signature);
10614536bf9bSArtur Paszkiewicz pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PAGE_SIZE));
10624536bf9bSArtur Paszkiewicz
10634536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, rdev->ppl.sector - rdev->data_offset,
10645a8948f8SJan Kara PPL_HEADER_SIZE, page, REQ_OP_WRITE | REQ_SYNC |
10654ce4c73fSBart Van Assche REQ_FUA, false)) {
10664536bf9bSArtur Paszkiewicz md_error(rdev->mddev, rdev);
10674536bf9bSArtur Paszkiewicz ret = -EIO;
10684536bf9bSArtur Paszkiewicz }
10694536bf9bSArtur Paszkiewicz
10704536bf9bSArtur Paszkiewicz __free_page(page);
10714536bf9bSArtur Paszkiewicz return ret;
10724536bf9bSArtur Paszkiewicz }
10734536bf9bSArtur Paszkiewicz
ppl_load_distributed(struct ppl_log * log)10744536bf9bSArtur Paszkiewicz static int ppl_load_distributed(struct ppl_log *log)
10754536bf9bSArtur Paszkiewicz {
10764536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf;
10774536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev;
10784536bf9bSArtur Paszkiewicz struct mddev *mddev = rdev->mddev;
10791e37799bSYang Guang struct page *page, *page2;
1080675dc2ccSPawel Baldysiak struct ppl_header *pplhdr = NULL, *prev_pplhdr = NULL;
10814536bf9bSArtur Paszkiewicz u32 crc, crc_stored;
10824536bf9bSArtur Paszkiewicz u32 signature;
1083675dc2ccSPawel Baldysiak int ret = 0, i;
1084675dc2ccSPawel Baldysiak sector_t pplhdr_offset = 0, prev_pplhdr_offset = 0;
10854536bf9bSArtur Paszkiewicz
10864536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d\n", __func__, rdev->raid_disk);
1087675dc2ccSPawel Baldysiak /* read PPL headers, find the recent one */
10884536bf9bSArtur Paszkiewicz page = alloc_page(GFP_KERNEL);
10894536bf9bSArtur Paszkiewicz if (!page)
10904536bf9bSArtur Paszkiewicz return -ENOMEM;
10914536bf9bSArtur Paszkiewicz
1092675dc2ccSPawel Baldysiak page2 = alloc_page(GFP_KERNEL);
1093675dc2ccSPawel Baldysiak if (!page2) {
1094675dc2ccSPawel Baldysiak __free_page(page);
1095675dc2ccSPawel Baldysiak return -ENOMEM;
1096675dc2ccSPawel Baldysiak }
1097675dc2ccSPawel Baldysiak
1098675dc2ccSPawel Baldysiak /* searching ppl area for latest ppl */
1099675dc2ccSPawel Baldysiak while (pplhdr_offset < rdev->ppl.size - (PPL_HEADER_SIZE >> 9)) {
1100675dc2ccSPawel Baldysiak if (!sync_page_io(rdev,
1101675dc2ccSPawel Baldysiak rdev->ppl.sector - rdev->data_offset +
1102675dc2ccSPawel Baldysiak pplhdr_offset, PAGE_SIZE, page, REQ_OP_READ,
11034ce4c73fSBart Van Assche false)) {
11044536bf9bSArtur Paszkiewicz md_error(mddev, rdev);
11054536bf9bSArtur Paszkiewicz ret = -EIO;
1106675dc2ccSPawel Baldysiak /* if not able to read - don't recover any PPL */
1107675dc2ccSPawel Baldysiak pplhdr = NULL;
1108675dc2ccSPawel Baldysiak break;
11094536bf9bSArtur Paszkiewicz }
11104536bf9bSArtur Paszkiewicz pplhdr = page_address(page);
11114536bf9bSArtur Paszkiewicz
11124536bf9bSArtur Paszkiewicz /* check header validity */
11134536bf9bSArtur Paszkiewicz crc_stored = le32_to_cpu(pplhdr->checksum);
11144536bf9bSArtur Paszkiewicz pplhdr->checksum = 0;
11154536bf9bSArtur Paszkiewicz crc = ~crc32c_le(~0, pplhdr, PAGE_SIZE);
11164536bf9bSArtur Paszkiewicz
11174536bf9bSArtur Paszkiewicz if (crc_stored != crc) {
1118675dc2ccSPawel Baldysiak pr_debug("%s: ppl header crc does not match: stored: 0x%x calculated: 0x%x (offset: %llu)\n",
1119675dc2ccSPawel Baldysiak __func__, crc_stored, crc,
1120675dc2ccSPawel Baldysiak (unsigned long long)pplhdr_offset);
1121675dc2ccSPawel Baldysiak pplhdr = prev_pplhdr;
1122675dc2ccSPawel Baldysiak pplhdr_offset = prev_pplhdr_offset;
1123675dc2ccSPawel Baldysiak break;
11244536bf9bSArtur Paszkiewicz }
11254536bf9bSArtur Paszkiewicz
11264536bf9bSArtur Paszkiewicz signature = le32_to_cpu(pplhdr->signature);
11274536bf9bSArtur Paszkiewicz
11284536bf9bSArtur Paszkiewicz if (mddev->external) {
11294536bf9bSArtur Paszkiewicz /*
11304536bf9bSArtur Paszkiewicz * For external metadata the header signature is set and
11314536bf9bSArtur Paszkiewicz * validated in userspace.
11324536bf9bSArtur Paszkiewicz */
11334536bf9bSArtur Paszkiewicz ppl_conf->signature = signature;
11344536bf9bSArtur Paszkiewicz } else if (ppl_conf->signature != signature) {
1135675dc2ccSPawel Baldysiak pr_debug("%s: ppl header signature does not match: stored: 0x%x configured: 0x%x (offset: %llu)\n",
1136675dc2ccSPawel Baldysiak __func__, signature, ppl_conf->signature,
1137675dc2ccSPawel Baldysiak (unsigned long long)pplhdr_offset);
1138675dc2ccSPawel Baldysiak pplhdr = prev_pplhdr;
1139675dc2ccSPawel Baldysiak pplhdr_offset = prev_pplhdr_offset;
1140675dc2ccSPawel Baldysiak break;
11414536bf9bSArtur Paszkiewicz }
11424536bf9bSArtur Paszkiewicz
1143675dc2ccSPawel Baldysiak if (prev_pplhdr && le64_to_cpu(prev_pplhdr->generation) >
1144675dc2ccSPawel Baldysiak le64_to_cpu(pplhdr->generation)) {
1145675dc2ccSPawel Baldysiak /* previous was newest */
1146675dc2ccSPawel Baldysiak pplhdr = prev_pplhdr;
1147675dc2ccSPawel Baldysiak pplhdr_offset = prev_pplhdr_offset;
1148675dc2ccSPawel Baldysiak break;
1149675dc2ccSPawel Baldysiak }
1150675dc2ccSPawel Baldysiak
1151675dc2ccSPawel Baldysiak prev_pplhdr_offset = pplhdr_offset;
1152675dc2ccSPawel Baldysiak prev_pplhdr = pplhdr;
1153675dc2ccSPawel Baldysiak
11541e37799bSYang Guang swap(page, page2);
1155675dc2ccSPawel Baldysiak
1156675dc2ccSPawel Baldysiak /* calculate next potential ppl offset */
1157675dc2ccSPawel Baldysiak for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++)
1158675dc2ccSPawel Baldysiak pplhdr_offset +=
1159675dc2ccSPawel Baldysiak le32_to_cpu(pplhdr->entries[i].pp_size) >> 9;
1160675dc2ccSPawel Baldysiak pplhdr_offset += PPL_HEADER_SIZE >> 9;
1161675dc2ccSPawel Baldysiak }
1162675dc2ccSPawel Baldysiak
1163675dc2ccSPawel Baldysiak /* no valid ppl found */
1164675dc2ccSPawel Baldysiak if (!pplhdr)
1165675dc2ccSPawel Baldysiak ppl_conf->mismatch_count++;
1166675dc2ccSPawel Baldysiak else
1167675dc2ccSPawel Baldysiak pr_debug("%s: latest PPL found at offset: %llu, with generation: %llu\n",
1168675dc2ccSPawel Baldysiak __func__, (unsigned long long)pplhdr_offset,
1169675dc2ccSPawel Baldysiak le64_to_cpu(pplhdr->generation));
1170675dc2ccSPawel Baldysiak
11714536bf9bSArtur Paszkiewicz /* attempt to recover from log if we are starting a dirty array */
1172675dc2ccSPawel Baldysiak if (pplhdr && !mddev->pers && mddev->recovery_cp != MaxSector)
1173675dc2ccSPawel Baldysiak ret = ppl_recover(log, pplhdr, pplhdr_offset);
1174675dc2ccSPawel Baldysiak
11754536bf9bSArtur Paszkiewicz /* write empty header if we are starting the array */
11764536bf9bSArtur Paszkiewicz if (!ret && !mddev->pers)
11774536bf9bSArtur Paszkiewicz ret = ppl_write_empty_header(log);
11784536bf9bSArtur Paszkiewicz
11794536bf9bSArtur Paszkiewicz __free_page(page);
1180675dc2ccSPawel Baldysiak __free_page(page2);
11814536bf9bSArtur Paszkiewicz
11824536bf9bSArtur Paszkiewicz pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n",
11834536bf9bSArtur Paszkiewicz __func__, ret, ppl_conf->mismatch_count,
11844536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries);
11854536bf9bSArtur Paszkiewicz return ret;
11864536bf9bSArtur Paszkiewicz }
11874536bf9bSArtur Paszkiewicz
ppl_load(struct ppl_conf * ppl_conf)11884536bf9bSArtur Paszkiewicz static int ppl_load(struct ppl_conf *ppl_conf)
11894536bf9bSArtur Paszkiewicz {
11904536bf9bSArtur Paszkiewicz int ret = 0;
11914536bf9bSArtur Paszkiewicz u32 signature = 0;
11924536bf9bSArtur Paszkiewicz bool signature_set = false;
11934536bf9bSArtur Paszkiewicz int i;
11944536bf9bSArtur Paszkiewicz
11954536bf9bSArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) {
11964536bf9bSArtur Paszkiewicz struct ppl_log *log = &ppl_conf->child_logs[i];
11974536bf9bSArtur Paszkiewicz
11984536bf9bSArtur Paszkiewicz /* skip missing drive */
11994536bf9bSArtur Paszkiewicz if (!log->rdev)
12004536bf9bSArtur Paszkiewicz continue;
12014536bf9bSArtur Paszkiewicz
12024536bf9bSArtur Paszkiewicz ret = ppl_load_distributed(log);
12034536bf9bSArtur Paszkiewicz if (ret)
12044536bf9bSArtur Paszkiewicz break;
12054536bf9bSArtur Paszkiewicz
12064536bf9bSArtur Paszkiewicz /*
12074536bf9bSArtur Paszkiewicz * For external metadata we can't check if the signature is
12084536bf9bSArtur Paszkiewicz * correct on a single drive, but we can check if it is the same
12094536bf9bSArtur Paszkiewicz * on all drives.
12104536bf9bSArtur Paszkiewicz */
12114536bf9bSArtur Paszkiewicz if (ppl_conf->mddev->external) {
12124536bf9bSArtur Paszkiewicz if (!signature_set) {
12134536bf9bSArtur Paszkiewicz signature = ppl_conf->signature;
12144536bf9bSArtur Paszkiewicz signature_set = true;
12154536bf9bSArtur Paszkiewicz } else if (signature != ppl_conf->signature) {
12164536bf9bSArtur Paszkiewicz pr_warn("md/raid:%s: PPL header signature does not match on all member drives\n",
12174536bf9bSArtur Paszkiewicz mdname(ppl_conf->mddev));
12184536bf9bSArtur Paszkiewicz ret = -EINVAL;
12194536bf9bSArtur Paszkiewicz break;
12204536bf9bSArtur Paszkiewicz }
12214536bf9bSArtur Paszkiewicz }
12224536bf9bSArtur Paszkiewicz }
12234536bf9bSArtur Paszkiewicz
12244536bf9bSArtur Paszkiewicz pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n",
12254536bf9bSArtur Paszkiewicz __func__, ret, ppl_conf->mismatch_count,
12264536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries);
12274536bf9bSArtur Paszkiewicz return ret;
12284536bf9bSArtur Paszkiewicz }
12294536bf9bSArtur Paszkiewicz
__ppl_exit_log(struct ppl_conf * ppl_conf)12303418d036SArtur Paszkiewicz static void __ppl_exit_log(struct ppl_conf *ppl_conf)
12313418d036SArtur Paszkiewicz {
12323418d036SArtur Paszkiewicz clear_bit(MD_HAS_PPL, &ppl_conf->mddev->flags);
1233ddc08823SPawel Baldysiak clear_bit(MD_HAS_MULTIPLE_PPLS, &ppl_conf->mddev->flags);
12343418d036SArtur Paszkiewicz
12353418d036SArtur Paszkiewicz kfree(ppl_conf->child_logs);
12363418d036SArtur Paszkiewicz
1237afeee514SKent Overstreet bioset_exit(&ppl_conf->bs);
1238afeee514SKent Overstreet bioset_exit(&ppl_conf->flush_bs);
1239afeee514SKent Overstreet mempool_exit(&ppl_conf->io_pool);
12403418d036SArtur Paszkiewicz kmem_cache_destroy(ppl_conf->io_kc);
12413418d036SArtur Paszkiewicz
12423418d036SArtur Paszkiewicz kfree(ppl_conf);
12433418d036SArtur Paszkiewicz }
12443418d036SArtur Paszkiewicz
ppl_exit_log(struct r5conf * conf)12453418d036SArtur Paszkiewicz void ppl_exit_log(struct r5conf *conf)
12463418d036SArtur Paszkiewicz {
12473418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private;
12483418d036SArtur Paszkiewicz
12493418d036SArtur Paszkiewicz if (ppl_conf) {
12503418d036SArtur Paszkiewicz __ppl_exit_log(ppl_conf);
12513418d036SArtur Paszkiewicz conf->log_private = NULL;
12523418d036SArtur Paszkiewicz }
12533418d036SArtur Paszkiewicz }
12543418d036SArtur Paszkiewicz
ppl_validate_rdev(struct md_rdev * rdev)12553418d036SArtur Paszkiewicz static int ppl_validate_rdev(struct md_rdev *rdev)
12563418d036SArtur Paszkiewicz {
12573418d036SArtur Paszkiewicz int ppl_data_sectors;
12583418d036SArtur Paszkiewicz int ppl_size_new;
12593418d036SArtur Paszkiewicz
12603418d036SArtur Paszkiewicz /*
12613418d036SArtur Paszkiewicz * The configured PPL size must be enough to store
12623418d036SArtur Paszkiewicz * the header and (at the very least) partial parity
12633418d036SArtur Paszkiewicz * for one stripe. Round it down to ensure the data
12643418d036SArtur Paszkiewicz * space is cleanly divisible by stripe size.
12653418d036SArtur Paszkiewicz */
12663418d036SArtur Paszkiewicz ppl_data_sectors = rdev->ppl.size - (PPL_HEADER_SIZE >> 9);
12673418d036SArtur Paszkiewicz
12683418d036SArtur Paszkiewicz if (ppl_data_sectors > 0)
1269c911c46cSYufen Yu ppl_data_sectors = rounddown(ppl_data_sectors,
1270c911c46cSYufen Yu RAID5_STRIPE_SECTORS((struct r5conf *)rdev->mddev->private));
12713418d036SArtur Paszkiewicz
12723418d036SArtur Paszkiewicz if (ppl_data_sectors <= 0) {
1273913cce5aSChristoph Hellwig pr_warn("md/raid:%s: PPL space too small on %pg\n",
1274913cce5aSChristoph Hellwig mdname(rdev->mddev), rdev->bdev);
12753418d036SArtur Paszkiewicz return -ENOSPC;
12763418d036SArtur Paszkiewicz }
12773418d036SArtur Paszkiewicz
12783418d036SArtur Paszkiewicz ppl_size_new = ppl_data_sectors + (PPL_HEADER_SIZE >> 9);
12793418d036SArtur Paszkiewicz
12803418d036SArtur Paszkiewicz if ((rdev->ppl.sector < rdev->data_offset &&
12813418d036SArtur Paszkiewicz rdev->ppl.sector + ppl_size_new > rdev->data_offset) ||
12823418d036SArtur Paszkiewicz (rdev->ppl.sector >= rdev->data_offset &&
12833418d036SArtur Paszkiewicz rdev->data_offset + rdev->sectors > rdev->ppl.sector)) {
1284913cce5aSChristoph Hellwig pr_warn("md/raid:%s: PPL space overlaps with data on %pg\n",
1285913cce5aSChristoph Hellwig mdname(rdev->mddev), rdev->bdev);
12863418d036SArtur Paszkiewicz return -EINVAL;
12873418d036SArtur Paszkiewicz }
12883418d036SArtur Paszkiewicz
12893418d036SArtur Paszkiewicz if (!rdev->mddev->external &&
12903418d036SArtur Paszkiewicz ((rdev->ppl.offset > 0 && rdev->ppl.offset < (rdev->sb_size >> 9)) ||
12913418d036SArtur Paszkiewicz (rdev->ppl.offset <= 0 && rdev->ppl.offset + ppl_size_new > 0))) {
1292913cce5aSChristoph Hellwig pr_warn("md/raid:%s: PPL space overlaps with superblock on %pg\n",
1293913cce5aSChristoph Hellwig mdname(rdev->mddev), rdev->bdev);
12943418d036SArtur Paszkiewicz return -EINVAL;
12953418d036SArtur Paszkiewicz }
12963418d036SArtur Paszkiewicz
12973418d036SArtur Paszkiewicz rdev->ppl.size = ppl_size_new;
12983418d036SArtur Paszkiewicz
12993418d036SArtur Paszkiewicz return 0;
13003418d036SArtur Paszkiewicz }
13013418d036SArtur Paszkiewicz
ppl_init_child_log(struct ppl_log * log,struct md_rdev * rdev)1302ddc08823SPawel Baldysiak static void ppl_init_child_log(struct ppl_log *log, struct md_rdev *rdev)
1303ddc08823SPawel Baldysiak {
1304ddc08823SPawel Baldysiak if ((rdev->ppl.size << 9) >= (PPL_SPACE_SIZE +
1305ddc08823SPawel Baldysiak PPL_HEADER_SIZE) * 2) {
1306ddc08823SPawel Baldysiak log->use_multippl = true;
1307ddc08823SPawel Baldysiak set_bit(MD_HAS_MULTIPLE_PPLS,
1308ddc08823SPawel Baldysiak &log->ppl_conf->mddev->flags);
1309ddc08823SPawel Baldysiak log->entry_space = PPL_SPACE_SIZE;
1310ddc08823SPawel Baldysiak } else {
1311ddc08823SPawel Baldysiak log->use_multippl = false;
1312ddc08823SPawel Baldysiak log->entry_space = (log->rdev->ppl.size << 9) -
1313ddc08823SPawel Baldysiak PPL_HEADER_SIZE;
1314ddc08823SPawel Baldysiak }
1315ddc08823SPawel Baldysiak log->next_io_sector = rdev->ppl.sector;
13161532d9e8STomasz Majchrzak
1317ad831a16SChristoph Hellwig if (bdev_write_cache(rdev->bdev))
13181532d9e8STomasz Majchrzak log->wb_cache_on = true;
1319ddc08823SPawel Baldysiak }
1320ddc08823SPawel Baldysiak
ppl_init_log(struct r5conf * conf)13213418d036SArtur Paszkiewicz int ppl_init_log(struct r5conf *conf)
13223418d036SArtur Paszkiewicz {
13233418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf;
13243418d036SArtur Paszkiewicz struct mddev *mddev = conf->mddev;
13253418d036SArtur Paszkiewicz int ret = 0;
13261532d9e8STomasz Majchrzak int max_disks;
13273418d036SArtur Paszkiewicz int i;
13283418d036SArtur Paszkiewicz
13293418d036SArtur Paszkiewicz pr_debug("md/raid:%s: enabling distributed Partial Parity Log\n",
13303418d036SArtur Paszkiewicz mdname(conf->mddev));
13313418d036SArtur Paszkiewicz
13323418d036SArtur Paszkiewicz if (PAGE_SIZE != 4096)
13333418d036SArtur Paszkiewicz return -EINVAL;
13343418d036SArtur Paszkiewicz
13353418d036SArtur Paszkiewicz if (mddev->level != 5) {
13363418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with raid level %d\n",
13373418d036SArtur Paszkiewicz mdname(mddev), mddev->level);
13383418d036SArtur Paszkiewicz return -EINVAL;
13393418d036SArtur Paszkiewicz }
13403418d036SArtur Paszkiewicz
13413418d036SArtur Paszkiewicz if (mddev->bitmap_info.file || mddev->bitmap_info.offset) {
13423418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with bitmap\n",
13433418d036SArtur Paszkiewicz mdname(mddev));
13443418d036SArtur Paszkiewicz return -EINVAL;
13453418d036SArtur Paszkiewicz }
13463418d036SArtur Paszkiewicz
13473418d036SArtur Paszkiewicz if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
13483418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with journal\n",
13493418d036SArtur Paszkiewicz mdname(mddev));
13503418d036SArtur Paszkiewicz return -EINVAL;
13513418d036SArtur Paszkiewicz }
13523418d036SArtur Paszkiewicz
1353c593642cSPankaj Bharadiya max_disks = sizeof_field(struct ppl_log, disk_flush_bitmap) *
13541532d9e8STomasz Majchrzak BITS_PER_BYTE;
13551532d9e8STomasz Majchrzak if (conf->raid_disks > max_disks) {
13561532d9e8STomasz Majchrzak pr_warn("md/raid:%s PPL doesn't support over %d disks in the array\n",
13571532d9e8STomasz Majchrzak mdname(mddev), max_disks);
13581532d9e8STomasz Majchrzak return -EINVAL;
13591532d9e8STomasz Majchrzak }
13601532d9e8STomasz Majchrzak
13613418d036SArtur Paszkiewicz ppl_conf = kzalloc(sizeof(struct ppl_conf), GFP_KERNEL);
13623418d036SArtur Paszkiewicz if (!ppl_conf)
13633418d036SArtur Paszkiewicz return -ENOMEM;
13643418d036SArtur Paszkiewicz
13653418d036SArtur Paszkiewicz ppl_conf->mddev = mddev;
13663418d036SArtur Paszkiewicz
13673418d036SArtur Paszkiewicz ppl_conf->io_kc = KMEM_CACHE(ppl_io_unit, 0);
13683418d036SArtur Paszkiewicz if (!ppl_conf->io_kc) {
1369fcd403afSArtur Paszkiewicz ret = -ENOMEM;
13703418d036SArtur Paszkiewicz goto err;
13713418d036SArtur Paszkiewicz }
13723418d036SArtur Paszkiewicz
1373afeee514SKent Overstreet ret = mempool_init(&ppl_conf->io_pool, conf->raid_disks, ppl_io_pool_alloc,
1374fcd403afSArtur Paszkiewicz ppl_io_pool_free, ppl_conf->io_kc);
1375afeee514SKent Overstreet if (ret)
13763418d036SArtur Paszkiewicz goto err;
13773418d036SArtur Paszkiewicz
1378afeee514SKent Overstreet ret = bioset_init(&ppl_conf->bs, conf->raid_disks, 0, BIOSET_NEED_BVECS);
1379afeee514SKent Overstreet if (ret)
13803418d036SArtur Paszkiewicz goto err;
13813418d036SArtur Paszkiewicz
1382afeee514SKent Overstreet ret = bioset_init(&ppl_conf->flush_bs, conf->raid_disks, 0, 0);
1383afeee514SKent Overstreet if (ret)
13841532d9e8STomasz Majchrzak goto err;
13851532d9e8STomasz Majchrzak
13863418d036SArtur Paszkiewicz ppl_conf->count = conf->raid_disks;
13873418d036SArtur Paszkiewicz ppl_conf->child_logs = kcalloc(ppl_conf->count, sizeof(struct ppl_log),
13883418d036SArtur Paszkiewicz GFP_KERNEL);
13893418d036SArtur Paszkiewicz if (!ppl_conf->child_logs) {
13903418d036SArtur Paszkiewicz ret = -ENOMEM;
13913418d036SArtur Paszkiewicz goto err;
13923418d036SArtur Paszkiewicz }
13933418d036SArtur Paszkiewicz
13943418d036SArtur Paszkiewicz atomic64_set(&ppl_conf->seq, 0);
139594568f64SArtur Paszkiewicz INIT_LIST_HEAD(&ppl_conf->no_mem_stripes);
139694568f64SArtur Paszkiewicz spin_lock_init(&ppl_conf->no_mem_stripes_lock);
13973418d036SArtur Paszkiewicz
13983418d036SArtur Paszkiewicz if (!mddev->external) {
13993418d036SArtur Paszkiewicz ppl_conf->signature = ~crc32c_le(~0, mddev->uuid, sizeof(mddev->uuid));
14003418d036SArtur Paszkiewicz ppl_conf->block_size = 512;
14013418d036SArtur Paszkiewicz } else {
14023418d036SArtur Paszkiewicz ppl_conf->block_size = queue_logical_block_size(mddev->queue);
14033418d036SArtur Paszkiewicz }
14043418d036SArtur Paszkiewicz
14053418d036SArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) {
14063418d036SArtur Paszkiewicz struct ppl_log *log = &ppl_conf->child_logs[i];
14074f4ee2bfSLogan Gunthorpe /* Array has not started so rcu dereference is safe */
14084f4ee2bfSLogan Gunthorpe struct md_rdev *rdev =
14094f4ee2bfSLogan Gunthorpe rcu_dereference_protected(conf->disks[i].rdev, 1);
14103418d036SArtur Paszkiewicz
14113418d036SArtur Paszkiewicz mutex_init(&log->io_mutex);
14123418d036SArtur Paszkiewicz spin_lock_init(&log->io_list_lock);
14133418d036SArtur Paszkiewicz INIT_LIST_HEAD(&log->io_list);
14143418d036SArtur Paszkiewicz
14153418d036SArtur Paszkiewicz log->ppl_conf = ppl_conf;
14163418d036SArtur Paszkiewicz log->rdev = rdev;
14173418d036SArtur Paszkiewicz
14183418d036SArtur Paszkiewicz if (rdev) {
14193418d036SArtur Paszkiewicz ret = ppl_validate_rdev(rdev);
14203418d036SArtur Paszkiewicz if (ret)
14213418d036SArtur Paszkiewicz goto err;
14223418d036SArtur Paszkiewicz
1423ddc08823SPawel Baldysiak ppl_init_child_log(log, rdev);
14243418d036SArtur Paszkiewicz }
14253418d036SArtur Paszkiewicz }
14263418d036SArtur Paszkiewicz
14274536bf9bSArtur Paszkiewicz /* load and possibly recover the logs from the member disks */
14284536bf9bSArtur Paszkiewicz ret = ppl_load(ppl_conf);
14294536bf9bSArtur Paszkiewicz
14304536bf9bSArtur Paszkiewicz if (ret) {
14314536bf9bSArtur Paszkiewicz goto err;
1432611426e2SArtur Paszkiewicz } else if (!mddev->pers && mddev->recovery_cp == 0 &&
14334536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries > 0 &&
14344536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count == 0) {
14354536bf9bSArtur Paszkiewicz /*
14364536bf9bSArtur Paszkiewicz * If we are starting a dirty array and the recovery succeeds
14374536bf9bSArtur Paszkiewicz * without any issues, set the array as clean.
14384536bf9bSArtur Paszkiewicz */
14394536bf9bSArtur Paszkiewicz mddev->recovery_cp = MaxSector;
14404536bf9bSArtur Paszkiewicz set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
1441ba903a3eSArtur Paszkiewicz } else if (mddev->pers && ppl_conf->mismatch_count > 0) {
1442ba903a3eSArtur Paszkiewicz /* no mismatch allowed when enabling PPL for a running array */
1443ba903a3eSArtur Paszkiewicz ret = -EINVAL;
1444ba903a3eSArtur Paszkiewicz goto err;
14454536bf9bSArtur Paszkiewicz }
14464536bf9bSArtur Paszkiewicz
14473418d036SArtur Paszkiewicz conf->log_private = ppl_conf;
1448845b9e22SArtur Paszkiewicz set_bit(MD_HAS_PPL, &ppl_conf->mddev->flags);
14493418d036SArtur Paszkiewicz
14503418d036SArtur Paszkiewicz return 0;
14513418d036SArtur Paszkiewicz err:
14523418d036SArtur Paszkiewicz __ppl_exit_log(ppl_conf);
14533418d036SArtur Paszkiewicz return ret;
14543418d036SArtur Paszkiewicz }
14556358c239SArtur Paszkiewicz
ppl_modify_log(struct r5conf * conf,struct md_rdev * rdev,bool add)14566358c239SArtur Paszkiewicz int ppl_modify_log(struct r5conf *conf, struct md_rdev *rdev, bool add)
14576358c239SArtur Paszkiewicz {
14586358c239SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private;
14596358c239SArtur Paszkiewicz struct ppl_log *log;
14606358c239SArtur Paszkiewicz int ret = 0;
14616358c239SArtur Paszkiewicz
14626358c239SArtur Paszkiewicz if (!rdev)
14636358c239SArtur Paszkiewicz return -EINVAL;
14646358c239SArtur Paszkiewicz
1465913cce5aSChristoph Hellwig pr_debug("%s: disk: %d operation: %s dev: %pg\n",
14666358c239SArtur Paszkiewicz __func__, rdev->raid_disk, add ? "add" : "remove",
1467913cce5aSChristoph Hellwig rdev->bdev);
14686358c239SArtur Paszkiewicz
14696358c239SArtur Paszkiewicz if (rdev->raid_disk < 0)
14706358c239SArtur Paszkiewicz return 0;
14716358c239SArtur Paszkiewicz
14726358c239SArtur Paszkiewicz if (rdev->raid_disk >= ppl_conf->count)
14736358c239SArtur Paszkiewicz return -ENODEV;
14746358c239SArtur Paszkiewicz
14756358c239SArtur Paszkiewicz log = &ppl_conf->child_logs[rdev->raid_disk];
14766358c239SArtur Paszkiewicz
14776358c239SArtur Paszkiewicz mutex_lock(&log->io_mutex);
14786358c239SArtur Paszkiewicz if (add) {
14796358c239SArtur Paszkiewicz ret = ppl_validate_rdev(rdev);
14806358c239SArtur Paszkiewicz if (!ret) {
14816358c239SArtur Paszkiewicz log->rdev = rdev;
14826358c239SArtur Paszkiewicz ret = ppl_write_empty_header(log);
1483ddc08823SPawel Baldysiak ppl_init_child_log(log, rdev);
14846358c239SArtur Paszkiewicz }
14856358c239SArtur Paszkiewicz } else {
14866358c239SArtur Paszkiewicz log->rdev = NULL;
14876358c239SArtur Paszkiewicz }
14886358c239SArtur Paszkiewicz mutex_unlock(&log->io_mutex);
14896358c239SArtur Paszkiewicz
14906358c239SArtur Paszkiewicz return ret;
14916358c239SArtur Paszkiewicz }
1492a596d086SMariusz Dabrowski
1493a596d086SMariusz Dabrowski static ssize_t
ppl_write_hint_show(struct mddev * mddev,char * buf)1494a596d086SMariusz Dabrowski ppl_write_hint_show(struct mddev *mddev, char *buf)
1495a596d086SMariusz Dabrowski {
1496c75e707fSChristoph Hellwig return sprintf(buf, "%d\n", 0);
1497a596d086SMariusz Dabrowski }
1498a596d086SMariusz Dabrowski
1499a596d086SMariusz Dabrowski static ssize_t
ppl_write_hint_store(struct mddev * mddev,const char * page,size_t len)1500a596d086SMariusz Dabrowski ppl_write_hint_store(struct mddev *mddev, const char *page, size_t len)
1501a596d086SMariusz Dabrowski {
1502a596d086SMariusz Dabrowski struct r5conf *conf;
1503a596d086SMariusz Dabrowski int err = 0;
1504a596d086SMariusz Dabrowski unsigned short new;
1505a596d086SMariusz Dabrowski
1506a596d086SMariusz Dabrowski if (len >= PAGE_SIZE)
1507a596d086SMariusz Dabrowski return -EINVAL;
1508a596d086SMariusz Dabrowski if (kstrtou16(page, 10, &new))
1509a596d086SMariusz Dabrowski return -EINVAL;
1510a596d086SMariusz Dabrowski
1511a596d086SMariusz Dabrowski err = mddev_lock(mddev);
1512a596d086SMariusz Dabrowski if (err)
1513a596d086SMariusz Dabrowski return err;
1514a596d086SMariusz Dabrowski
1515a596d086SMariusz Dabrowski conf = mddev->private;
1516c75e707fSChristoph Hellwig if (!conf)
1517a596d086SMariusz Dabrowski err = -ENODEV;
1518c75e707fSChristoph Hellwig else if (!raid5_has_ppl(conf) || !conf->log_private)
1519a596d086SMariusz Dabrowski err = -EINVAL;
1520a596d086SMariusz Dabrowski
1521a596d086SMariusz Dabrowski mddev_unlock(mddev);
1522a596d086SMariusz Dabrowski
1523a596d086SMariusz Dabrowski return err ?: len;
1524a596d086SMariusz Dabrowski }
1525a596d086SMariusz Dabrowski
1526a596d086SMariusz Dabrowski struct md_sysfs_entry
1527a596d086SMariusz Dabrowski ppl_write_hint = __ATTR(ppl_write_hint, S_IRUGO | S_IWUSR,
1528a596d086SMariusz Dabrowski ppl_write_hint_show,
1529a596d086SMariusz Dabrowski ppl_write_hint_store);
1530