13418d036SArtur Paszkiewicz /* 23418d036SArtur Paszkiewicz * Partial Parity Log for closing the RAID5 write hole 33418d036SArtur Paszkiewicz * Copyright (c) 2017, Intel Corporation. 43418d036SArtur Paszkiewicz * 53418d036SArtur Paszkiewicz * This program is free software; you can redistribute it and/or modify it 63418d036SArtur Paszkiewicz * under the terms and conditions of the GNU General Public License, 73418d036SArtur Paszkiewicz * version 2, as published by the Free Software Foundation. 83418d036SArtur Paszkiewicz * 93418d036SArtur Paszkiewicz * This program is distributed in the hope it will be useful, but WITHOUT 103418d036SArtur Paszkiewicz * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 113418d036SArtur Paszkiewicz * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 123418d036SArtur Paszkiewicz * more details. 133418d036SArtur Paszkiewicz */ 143418d036SArtur Paszkiewicz 153418d036SArtur Paszkiewicz #include <linux/kernel.h> 163418d036SArtur Paszkiewicz #include <linux/blkdev.h> 173418d036SArtur Paszkiewicz #include <linux/slab.h> 183418d036SArtur Paszkiewicz #include <linux/crc32c.h> 193418d036SArtur Paszkiewicz #include <linux/flex_array.h> 203418d036SArtur Paszkiewicz #include <linux/async_tx.h> 213418d036SArtur Paszkiewicz #include <linux/raid/md_p.h> 223418d036SArtur Paszkiewicz #include "md.h" 233418d036SArtur Paszkiewicz #include "raid5.h" 243418d036SArtur Paszkiewicz 253418d036SArtur Paszkiewicz /* 263418d036SArtur Paszkiewicz * PPL consists of a 4KB header (struct ppl_header) and at least 128KB for 273418d036SArtur Paszkiewicz * partial parity data. The header contains an array of entries 283418d036SArtur Paszkiewicz * (struct ppl_header_entry) which describe the logged write requests. 293418d036SArtur Paszkiewicz * Partial parity for the entries comes after the header, written in the same 303418d036SArtur Paszkiewicz * sequence as the entries: 313418d036SArtur Paszkiewicz * 323418d036SArtur Paszkiewicz * Header 333418d036SArtur Paszkiewicz * entry0 343418d036SArtur Paszkiewicz * ... 353418d036SArtur Paszkiewicz * entryN 363418d036SArtur Paszkiewicz * PP data 373418d036SArtur Paszkiewicz * PP for entry0 383418d036SArtur Paszkiewicz * ... 393418d036SArtur Paszkiewicz * PP for entryN 403418d036SArtur Paszkiewicz * 413418d036SArtur Paszkiewicz * An entry describes one or more consecutive stripe_heads, up to a full 423418d036SArtur Paszkiewicz * stripe. The modifed raid data chunks form an m-by-n matrix, where m is the 433418d036SArtur Paszkiewicz * number of stripe_heads in the entry and n is the number of modified data 443418d036SArtur Paszkiewicz * disks. Every stripe_head in the entry must write to the same data disks. 453418d036SArtur Paszkiewicz * An example of a valid case described by a single entry (writes to the first 463418d036SArtur Paszkiewicz * stripe of a 4 disk array, 16k chunk size): 473418d036SArtur Paszkiewicz * 483418d036SArtur Paszkiewicz * sh->sector dd0 dd1 dd2 ppl 493418d036SArtur Paszkiewicz * +-----+-----+-----+ 503418d036SArtur Paszkiewicz * 0 | --- | --- | --- | +----+ 513418d036SArtur Paszkiewicz * 8 | -W- | -W- | --- | | pp | data_sector = 8 523418d036SArtur Paszkiewicz * 16 | -W- | -W- | --- | | pp | data_size = 3 * 2 * 4k 533418d036SArtur Paszkiewicz * 24 | -W- | -W- | --- | | pp | pp_size = 3 * 4k 543418d036SArtur Paszkiewicz * +-----+-----+-----+ +----+ 553418d036SArtur Paszkiewicz * 563418d036SArtur Paszkiewicz * data_sector is the first raid sector of the modified data, data_size is the 573418d036SArtur Paszkiewicz * total size of modified data and pp_size is the size of partial parity for 583418d036SArtur Paszkiewicz * this entry. Entries for full stripe writes contain no partial parity 593418d036SArtur Paszkiewicz * (pp_size = 0), they only mark the stripes for which parity should be 603418d036SArtur Paszkiewicz * recalculated after an unclean shutdown. Every entry holds a checksum of its 613418d036SArtur Paszkiewicz * partial parity, the header also has a checksum of the header itself. 623418d036SArtur Paszkiewicz * 633418d036SArtur Paszkiewicz * A write request is always logged to the PPL instance stored on the parity 643418d036SArtur Paszkiewicz * disk of the corresponding stripe. For each member disk there is one ppl_log 653418d036SArtur Paszkiewicz * used to handle logging for this disk, independently from others. They are 663418d036SArtur Paszkiewicz * grouped in child_logs array in struct ppl_conf, which is assigned to 673418d036SArtur Paszkiewicz * r5conf->log_private. 683418d036SArtur Paszkiewicz * 693418d036SArtur Paszkiewicz * ppl_io_unit represents a full PPL write, header_page contains the ppl_header. 703418d036SArtur Paszkiewicz * PPL entries for logged stripes are added in ppl_log_stripe(). A stripe_head 713418d036SArtur Paszkiewicz * can be appended to the last entry if it meets the conditions for a valid 723418d036SArtur Paszkiewicz * entry described above, otherwise a new entry is added. Checksums of entries 733418d036SArtur Paszkiewicz * are calculated incrementally as stripes containing partial parity are being 743418d036SArtur Paszkiewicz * added. ppl_submit_iounit() calculates the checksum of the header and submits 753418d036SArtur Paszkiewicz * a bio containing the header page and partial parity pages (sh->ppl_page) for 763418d036SArtur Paszkiewicz * all stripes of the io_unit. When the PPL write completes, the stripes 773418d036SArtur Paszkiewicz * associated with the io_unit are released and raid5d starts writing their data 783418d036SArtur Paszkiewicz * and parity. When all stripes are written, the io_unit is freed and the next 793418d036SArtur Paszkiewicz * can be submitted. 803418d036SArtur Paszkiewicz * 813418d036SArtur Paszkiewicz * An io_unit is used to gather stripes until it is submitted or becomes full 823418d036SArtur Paszkiewicz * (if the maximum number of entries or size of PPL is reached). Another io_unit 833418d036SArtur Paszkiewicz * can't be submitted until the previous has completed (PPL and stripe 843418d036SArtur Paszkiewicz * data+parity is written). The log->io_list tracks all io_units of a log 853418d036SArtur Paszkiewicz * (for a single member disk). New io_units are added to the end of the list 863418d036SArtur Paszkiewicz * and the first io_unit is submitted, if it is not submitted already. 873418d036SArtur Paszkiewicz * The current io_unit accepting new stripes is always at the end of the list. 883418d036SArtur Paszkiewicz */ 893418d036SArtur Paszkiewicz 903418d036SArtur Paszkiewicz struct ppl_conf { 913418d036SArtur Paszkiewicz struct mddev *mddev; 923418d036SArtur Paszkiewicz 933418d036SArtur Paszkiewicz /* array of child logs, one for each raid disk */ 943418d036SArtur Paszkiewicz struct ppl_log *child_logs; 953418d036SArtur Paszkiewicz int count; 963418d036SArtur Paszkiewicz 973418d036SArtur Paszkiewicz int block_size; /* the logical block size used for data_sector 983418d036SArtur Paszkiewicz * in ppl_header_entry */ 993418d036SArtur Paszkiewicz u32 signature; /* raid array identifier */ 1003418d036SArtur Paszkiewicz atomic64_t seq; /* current log write sequence number */ 1013418d036SArtur Paszkiewicz 1023418d036SArtur Paszkiewicz struct kmem_cache *io_kc; 1033418d036SArtur Paszkiewicz mempool_t *io_pool; 1043418d036SArtur Paszkiewicz struct bio_set *bs; 1053418d036SArtur Paszkiewicz mempool_t *meta_pool; 1064536bf9bSArtur Paszkiewicz 1074536bf9bSArtur Paszkiewicz /* used only for recovery */ 1084536bf9bSArtur Paszkiewicz int recovered_entries; 1094536bf9bSArtur Paszkiewicz int mismatch_count; 11094568f64SArtur Paszkiewicz 11194568f64SArtur Paszkiewicz /* stripes to retry if failed to allocate io_unit */ 11294568f64SArtur Paszkiewicz struct list_head no_mem_stripes; 11394568f64SArtur Paszkiewicz spinlock_t no_mem_stripes_lock; 1143418d036SArtur Paszkiewicz }; 1153418d036SArtur Paszkiewicz 1163418d036SArtur Paszkiewicz struct ppl_log { 1173418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf; /* shared between all log instances */ 1183418d036SArtur Paszkiewicz 1193418d036SArtur Paszkiewicz struct md_rdev *rdev; /* array member disk associated with 1203418d036SArtur Paszkiewicz * this log instance */ 1213418d036SArtur Paszkiewicz struct mutex io_mutex; 1223418d036SArtur Paszkiewicz struct ppl_io_unit *current_io; /* current io_unit accepting new data 1233418d036SArtur Paszkiewicz * always at the end of io_list */ 1243418d036SArtur Paszkiewicz spinlock_t io_list_lock; 1253418d036SArtur Paszkiewicz struct list_head io_list; /* all io_units of this log */ 1263418d036SArtur Paszkiewicz }; 1273418d036SArtur Paszkiewicz 1283418d036SArtur Paszkiewicz #define PPL_IO_INLINE_BVECS 32 1293418d036SArtur Paszkiewicz 1303418d036SArtur Paszkiewicz struct ppl_io_unit { 1313418d036SArtur Paszkiewicz struct ppl_log *log; 1323418d036SArtur Paszkiewicz 1333418d036SArtur Paszkiewicz struct page *header_page; /* for ppl_header */ 1343418d036SArtur Paszkiewicz 1353418d036SArtur Paszkiewicz unsigned int entries_count; /* number of entries in ppl_header */ 1363418d036SArtur Paszkiewicz unsigned int pp_size; /* total size current of partial parity */ 1373418d036SArtur Paszkiewicz 1383418d036SArtur Paszkiewicz u64 seq; /* sequence number of this log write */ 1393418d036SArtur Paszkiewicz struct list_head log_sibling; /* log->io_list */ 1403418d036SArtur Paszkiewicz 1413418d036SArtur Paszkiewicz struct list_head stripe_list; /* stripes added to the io_unit */ 1423418d036SArtur Paszkiewicz atomic_t pending_stripes; /* how many stripes not written to raid */ 1433418d036SArtur Paszkiewicz 1443418d036SArtur Paszkiewicz bool submitted; /* true if write to log started */ 1453418d036SArtur Paszkiewicz 1463418d036SArtur Paszkiewicz /* inline bio and its biovec for submitting the iounit */ 1473418d036SArtur Paszkiewicz struct bio bio; 1483418d036SArtur Paszkiewicz struct bio_vec biovec[PPL_IO_INLINE_BVECS]; 1493418d036SArtur Paszkiewicz }; 1503418d036SArtur Paszkiewicz 1513418d036SArtur Paszkiewicz struct dma_async_tx_descriptor * 1523418d036SArtur Paszkiewicz ops_run_partial_parity(struct stripe_head *sh, struct raid5_percpu *percpu, 1533418d036SArtur Paszkiewicz struct dma_async_tx_descriptor *tx) 1543418d036SArtur Paszkiewicz { 1553418d036SArtur Paszkiewicz int disks = sh->disks; 1563418d036SArtur Paszkiewicz struct page **xor_srcs = flex_array_get(percpu->scribble, 0); 1573418d036SArtur Paszkiewicz int count = 0, pd_idx = sh->pd_idx, i; 1583418d036SArtur Paszkiewicz struct async_submit_ctl submit; 1593418d036SArtur Paszkiewicz 1603418d036SArtur Paszkiewicz pr_debug("%s: stripe %llu\n", __func__, (unsigned long long)sh->sector); 1613418d036SArtur Paszkiewicz 1623418d036SArtur Paszkiewicz /* 1633418d036SArtur Paszkiewicz * Partial parity is the XOR of stripe data chunks that are not changed 1643418d036SArtur Paszkiewicz * during the write request. Depending on available data 1653418d036SArtur Paszkiewicz * (read-modify-write vs. reconstruct-write case) we calculate it 1663418d036SArtur Paszkiewicz * differently. 1673418d036SArtur Paszkiewicz */ 1683418d036SArtur Paszkiewicz if (sh->reconstruct_state == reconstruct_state_prexor_drain_run) { 1693418d036SArtur Paszkiewicz /* rmw: xor old data and parity from updated disks */ 1703418d036SArtur Paszkiewicz for (i = disks; i--;) { 1713418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i]; 1723418d036SArtur Paszkiewicz if (test_bit(R5_Wantdrain, &dev->flags) || i == pd_idx) 1733418d036SArtur Paszkiewicz xor_srcs[count++] = dev->page; 1743418d036SArtur Paszkiewicz } 1753418d036SArtur Paszkiewicz } else if (sh->reconstruct_state == reconstruct_state_drain_run) { 1763418d036SArtur Paszkiewicz /* rcw: xor data from all not updated disks */ 1773418d036SArtur Paszkiewicz for (i = disks; i--;) { 1783418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i]; 1793418d036SArtur Paszkiewicz if (test_bit(R5_UPTODATE, &dev->flags)) 1803418d036SArtur Paszkiewicz xor_srcs[count++] = dev->page; 1813418d036SArtur Paszkiewicz } 1823418d036SArtur Paszkiewicz } else { 1833418d036SArtur Paszkiewicz return tx; 1843418d036SArtur Paszkiewicz } 1853418d036SArtur Paszkiewicz 1863418d036SArtur Paszkiewicz init_async_submit(&submit, ASYNC_TX_FENCE|ASYNC_TX_XOR_ZERO_DST, tx, 1873418d036SArtur Paszkiewicz NULL, sh, flex_array_get(percpu->scribble, 0) 1883418d036SArtur Paszkiewicz + sizeof(struct page *) * (sh->disks + 2)); 1893418d036SArtur Paszkiewicz 1903418d036SArtur Paszkiewicz if (count == 1) 1913418d036SArtur Paszkiewicz tx = async_memcpy(sh->ppl_page, xor_srcs[0], 0, 0, PAGE_SIZE, 1923418d036SArtur Paszkiewicz &submit); 1933418d036SArtur Paszkiewicz else 1943418d036SArtur Paszkiewicz tx = async_xor(sh->ppl_page, xor_srcs, 0, count, PAGE_SIZE, 1953418d036SArtur Paszkiewicz &submit); 1963418d036SArtur Paszkiewicz 1973418d036SArtur Paszkiewicz return tx; 1983418d036SArtur Paszkiewicz } 1993418d036SArtur Paszkiewicz 2003418d036SArtur Paszkiewicz static struct ppl_io_unit *ppl_new_iounit(struct ppl_log *log, 2013418d036SArtur Paszkiewicz struct stripe_head *sh) 2023418d036SArtur Paszkiewicz { 2033418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 2043418d036SArtur Paszkiewicz struct ppl_io_unit *io; 2053418d036SArtur Paszkiewicz struct ppl_header *pplhdr; 2063418d036SArtur Paszkiewicz 2073418d036SArtur Paszkiewicz io = mempool_alloc(ppl_conf->io_pool, GFP_ATOMIC); 2083418d036SArtur Paszkiewicz if (!io) 2093418d036SArtur Paszkiewicz return NULL; 2103418d036SArtur Paszkiewicz 2113418d036SArtur Paszkiewicz memset(io, 0, sizeof(*io)); 2123418d036SArtur Paszkiewicz io->log = log; 2133418d036SArtur Paszkiewicz INIT_LIST_HEAD(&io->log_sibling); 2143418d036SArtur Paszkiewicz INIT_LIST_HEAD(&io->stripe_list); 2153418d036SArtur Paszkiewicz atomic_set(&io->pending_stripes, 0); 2163418d036SArtur Paszkiewicz bio_init(&io->bio, io->biovec, PPL_IO_INLINE_BVECS); 2173418d036SArtur Paszkiewicz 2183418d036SArtur Paszkiewicz io->header_page = mempool_alloc(ppl_conf->meta_pool, GFP_NOIO); 2193418d036SArtur Paszkiewicz pplhdr = page_address(io->header_page); 2203418d036SArtur Paszkiewicz clear_page(pplhdr); 2213418d036SArtur Paszkiewicz memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED); 2223418d036SArtur Paszkiewicz pplhdr->signature = cpu_to_le32(ppl_conf->signature); 2233418d036SArtur Paszkiewicz 2243418d036SArtur Paszkiewicz io->seq = atomic64_add_return(1, &ppl_conf->seq); 2253418d036SArtur Paszkiewicz pplhdr->generation = cpu_to_le64(io->seq); 2263418d036SArtur Paszkiewicz 2273418d036SArtur Paszkiewicz return io; 2283418d036SArtur Paszkiewicz } 2293418d036SArtur Paszkiewicz 2303418d036SArtur Paszkiewicz static int ppl_log_stripe(struct ppl_log *log, struct stripe_head *sh) 2313418d036SArtur Paszkiewicz { 2323418d036SArtur Paszkiewicz struct ppl_io_unit *io = log->current_io; 2333418d036SArtur Paszkiewicz struct ppl_header_entry *e = NULL; 2343418d036SArtur Paszkiewicz struct ppl_header *pplhdr; 2353418d036SArtur Paszkiewicz int i; 2363418d036SArtur Paszkiewicz sector_t data_sector = 0; 2373418d036SArtur Paszkiewicz int data_disks = 0; 2383418d036SArtur Paszkiewicz unsigned int entry_space = (log->rdev->ppl.size << 9) - PPL_HEADER_SIZE; 2393418d036SArtur Paszkiewicz struct r5conf *conf = sh->raid_conf; 2403418d036SArtur Paszkiewicz 2413418d036SArtur Paszkiewicz pr_debug("%s: stripe: %llu\n", __func__, (unsigned long long)sh->sector); 2423418d036SArtur Paszkiewicz 2433418d036SArtur Paszkiewicz /* check if current io_unit is full */ 2443418d036SArtur Paszkiewicz if (io && (io->pp_size == entry_space || 2453418d036SArtur Paszkiewicz io->entries_count == PPL_HDR_MAX_ENTRIES)) { 2463418d036SArtur Paszkiewicz pr_debug("%s: add io_unit blocked by seq: %llu\n", 2473418d036SArtur Paszkiewicz __func__, io->seq); 2483418d036SArtur Paszkiewicz io = NULL; 2493418d036SArtur Paszkiewicz } 2503418d036SArtur Paszkiewicz 2513418d036SArtur Paszkiewicz /* add a new unit if there is none or the current is full */ 2523418d036SArtur Paszkiewicz if (!io) { 2533418d036SArtur Paszkiewicz io = ppl_new_iounit(log, sh); 2543418d036SArtur Paszkiewicz if (!io) 2553418d036SArtur Paszkiewicz return -ENOMEM; 2563418d036SArtur Paszkiewicz spin_lock_irq(&log->io_list_lock); 2573418d036SArtur Paszkiewicz list_add_tail(&io->log_sibling, &log->io_list); 2583418d036SArtur Paszkiewicz spin_unlock_irq(&log->io_list_lock); 2593418d036SArtur Paszkiewicz 2603418d036SArtur Paszkiewicz log->current_io = io; 2613418d036SArtur Paszkiewicz } 2623418d036SArtur Paszkiewicz 2633418d036SArtur Paszkiewicz for (i = 0; i < sh->disks; i++) { 2643418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i]; 2653418d036SArtur Paszkiewicz 2663418d036SArtur Paszkiewicz if (i != sh->pd_idx && test_bit(R5_Wantwrite, &dev->flags)) { 2673418d036SArtur Paszkiewicz if (!data_disks || dev->sector < data_sector) 2683418d036SArtur Paszkiewicz data_sector = dev->sector; 2693418d036SArtur Paszkiewicz data_disks++; 2703418d036SArtur Paszkiewicz } 2713418d036SArtur Paszkiewicz } 2723418d036SArtur Paszkiewicz BUG_ON(!data_disks); 2733418d036SArtur Paszkiewicz 2743418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu data_sector: %llu data_disks: %d\n", __func__, 2753418d036SArtur Paszkiewicz io->seq, (unsigned long long)data_sector, data_disks); 2763418d036SArtur Paszkiewicz 2773418d036SArtur Paszkiewicz pplhdr = page_address(io->header_page); 2783418d036SArtur Paszkiewicz 2793418d036SArtur Paszkiewicz if (io->entries_count > 0) { 2803418d036SArtur Paszkiewicz struct ppl_header_entry *last = 2813418d036SArtur Paszkiewicz &pplhdr->entries[io->entries_count - 1]; 2823418d036SArtur Paszkiewicz struct stripe_head *sh_last = list_last_entry( 2833418d036SArtur Paszkiewicz &io->stripe_list, struct stripe_head, log_list); 2843418d036SArtur Paszkiewicz u64 data_sector_last = le64_to_cpu(last->data_sector); 2853418d036SArtur Paszkiewicz u32 data_size_last = le32_to_cpu(last->data_size); 2863418d036SArtur Paszkiewicz 2873418d036SArtur Paszkiewicz /* 2883418d036SArtur Paszkiewicz * Check if we can append the stripe to the last entry. It must 2893418d036SArtur Paszkiewicz * be just after the last logged stripe and write to the same 2903418d036SArtur Paszkiewicz * disks. Use bit shift and logarithm to avoid 64-bit division. 2913418d036SArtur Paszkiewicz */ 2923418d036SArtur Paszkiewicz if ((sh->sector == sh_last->sector + STRIPE_SECTORS) && 2933418d036SArtur Paszkiewicz (data_sector >> ilog2(conf->chunk_sectors) == 2943418d036SArtur Paszkiewicz data_sector_last >> ilog2(conf->chunk_sectors)) && 2953418d036SArtur Paszkiewicz ((data_sector - data_sector_last) * data_disks == 2963418d036SArtur Paszkiewicz data_size_last >> 9)) 2973418d036SArtur Paszkiewicz e = last; 2983418d036SArtur Paszkiewicz } 2993418d036SArtur Paszkiewicz 3003418d036SArtur Paszkiewicz if (!e) { 3013418d036SArtur Paszkiewicz e = &pplhdr->entries[io->entries_count++]; 3023418d036SArtur Paszkiewicz e->data_sector = cpu_to_le64(data_sector); 3033418d036SArtur Paszkiewicz e->parity_disk = cpu_to_le32(sh->pd_idx); 3043418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(~0); 3053418d036SArtur Paszkiewicz } 3063418d036SArtur Paszkiewicz 3073418d036SArtur Paszkiewicz le32_add_cpu(&e->data_size, data_disks << PAGE_SHIFT); 3083418d036SArtur Paszkiewicz 3093418d036SArtur Paszkiewicz /* don't write any PP if full stripe write */ 3103418d036SArtur Paszkiewicz if (!test_bit(STRIPE_FULL_WRITE, &sh->state)) { 3113418d036SArtur Paszkiewicz le32_add_cpu(&e->pp_size, PAGE_SIZE); 3123418d036SArtur Paszkiewicz io->pp_size += PAGE_SIZE; 3133418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(crc32c_le(le32_to_cpu(e->checksum), 3143418d036SArtur Paszkiewicz page_address(sh->ppl_page), 3153418d036SArtur Paszkiewicz PAGE_SIZE)); 3163418d036SArtur Paszkiewicz } 3173418d036SArtur Paszkiewicz 3183418d036SArtur Paszkiewicz list_add_tail(&sh->log_list, &io->stripe_list); 3193418d036SArtur Paszkiewicz atomic_inc(&io->pending_stripes); 3203418d036SArtur Paszkiewicz sh->ppl_io = io; 3213418d036SArtur Paszkiewicz 3223418d036SArtur Paszkiewicz return 0; 3233418d036SArtur Paszkiewicz } 3243418d036SArtur Paszkiewicz 3253418d036SArtur Paszkiewicz int ppl_write_stripe(struct r5conf *conf, struct stripe_head *sh) 3263418d036SArtur Paszkiewicz { 3273418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 3283418d036SArtur Paszkiewicz struct ppl_io_unit *io = sh->ppl_io; 3293418d036SArtur Paszkiewicz struct ppl_log *log; 3303418d036SArtur Paszkiewicz 3313418d036SArtur Paszkiewicz if (io || test_bit(STRIPE_SYNCING, &sh->state) || 3323418d036SArtur Paszkiewicz !test_bit(R5_Wantwrite, &sh->dev[sh->pd_idx].flags) || 3333418d036SArtur Paszkiewicz !test_bit(R5_Insync, &sh->dev[sh->pd_idx].flags)) { 3343418d036SArtur Paszkiewicz clear_bit(STRIPE_LOG_TRAPPED, &sh->state); 3353418d036SArtur Paszkiewicz return -EAGAIN; 3363418d036SArtur Paszkiewicz } 3373418d036SArtur Paszkiewicz 3383418d036SArtur Paszkiewicz log = &ppl_conf->child_logs[sh->pd_idx]; 3393418d036SArtur Paszkiewicz 3403418d036SArtur Paszkiewicz mutex_lock(&log->io_mutex); 3413418d036SArtur Paszkiewicz 3423418d036SArtur Paszkiewicz if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) { 3433418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 3443418d036SArtur Paszkiewicz return -EAGAIN; 3453418d036SArtur Paszkiewicz } 3463418d036SArtur Paszkiewicz 3473418d036SArtur Paszkiewicz set_bit(STRIPE_LOG_TRAPPED, &sh->state); 3483418d036SArtur Paszkiewicz clear_bit(STRIPE_DELAYED, &sh->state); 3493418d036SArtur Paszkiewicz atomic_inc(&sh->count); 3503418d036SArtur Paszkiewicz 3513418d036SArtur Paszkiewicz if (ppl_log_stripe(log, sh)) { 35294568f64SArtur Paszkiewicz spin_lock_irq(&ppl_conf->no_mem_stripes_lock); 35394568f64SArtur Paszkiewicz list_add_tail(&sh->log_list, &ppl_conf->no_mem_stripes); 35494568f64SArtur Paszkiewicz spin_unlock_irq(&ppl_conf->no_mem_stripes_lock); 3553418d036SArtur Paszkiewicz } 3563418d036SArtur Paszkiewicz 3573418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 3583418d036SArtur Paszkiewicz 3593418d036SArtur Paszkiewicz return 0; 3603418d036SArtur Paszkiewicz } 3613418d036SArtur Paszkiewicz 3623418d036SArtur Paszkiewicz static void ppl_log_endio(struct bio *bio) 3633418d036SArtur Paszkiewicz { 3643418d036SArtur Paszkiewicz struct ppl_io_unit *io = bio->bi_private; 3653418d036SArtur Paszkiewicz struct ppl_log *log = io->log; 3663418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 3673418d036SArtur Paszkiewicz struct stripe_head *sh, *next; 3683418d036SArtur Paszkiewicz 3693418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu\n", __func__, io->seq); 3703418d036SArtur Paszkiewicz 3713418d036SArtur Paszkiewicz if (bio->bi_error) 3723418d036SArtur Paszkiewicz md_error(ppl_conf->mddev, log->rdev); 3733418d036SArtur Paszkiewicz 3743418d036SArtur Paszkiewicz mempool_free(io->header_page, ppl_conf->meta_pool); 3753418d036SArtur Paszkiewicz 3763418d036SArtur Paszkiewicz list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) { 3773418d036SArtur Paszkiewicz list_del_init(&sh->log_list); 3783418d036SArtur Paszkiewicz 3793418d036SArtur Paszkiewicz set_bit(STRIPE_HANDLE, &sh->state); 3803418d036SArtur Paszkiewicz raid5_release_stripe(sh); 3813418d036SArtur Paszkiewicz } 3823418d036SArtur Paszkiewicz } 3833418d036SArtur Paszkiewicz 3843418d036SArtur Paszkiewicz static void ppl_submit_iounit_bio(struct ppl_io_unit *io, struct bio *bio) 3853418d036SArtur Paszkiewicz { 3863418d036SArtur Paszkiewicz char b[BDEVNAME_SIZE]; 3873418d036SArtur Paszkiewicz 3883418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu size: %u sector: %llu dev: %s\n", 3893418d036SArtur Paszkiewicz __func__, io->seq, bio->bi_iter.bi_size, 3903418d036SArtur Paszkiewicz (unsigned long long)bio->bi_iter.bi_sector, 3913418d036SArtur Paszkiewicz bdevname(bio->bi_bdev, b)); 3923418d036SArtur Paszkiewicz 3933418d036SArtur Paszkiewicz submit_bio(bio); 3943418d036SArtur Paszkiewicz } 3953418d036SArtur Paszkiewicz 3963418d036SArtur Paszkiewicz static void ppl_submit_iounit(struct ppl_io_unit *io) 3973418d036SArtur Paszkiewicz { 3983418d036SArtur Paszkiewicz struct ppl_log *log = io->log; 3993418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 4003418d036SArtur Paszkiewicz struct ppl_header *pplhdr = page_address(io->header_page); 4013418d036SArtur Paszkiewicz struct bio *bio = &io->bio; 4023418d036SArtur Paszkiewicz struct stripe_head *sh; 4033418d036SArtur Paszkiewicz int i; 4043418d036SArtur Paszkiewicz 4056358c239SArtur Paszkiewicz bio->bi_private = io; 4066358c239SArtur Paszkiewicz 4076358c239SArtur Paszkiewicz if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) { 4086358c239SArtur Paszkiewicz ppl_log_endio(bio); 4096358c239SArtur Paszkiewicz return; 4106358c239SArtur Paszkiewicz } 4116358c239SArtur Paszkiewicz 4123418d036SArtur Paszkiewicz for (i = 0; i < io->entries_count; i++) { 4133418d036SArtur Paszkiewicz struct ppl_header_entry *e = &pplhdr->entries[i]; 4143418d036SArtur Paszkiewicz 4153418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu entry: %d data_sector: %llu pp_size: %u data_size: %u\n", 4163418d036SArtur Paszkiewicz __func__, io->seq, i, le64_to_cpu(e->data_sector), 4173418d036SArtur Paszkiewicz le32_to_cpu(e->pp_size), le32_to_cpu(e->data_size)); 4183418d036SArtur Paszkiewicz 4193418d036SArtur Paszkiewicz e->data_sector = cpu_to_le64(le64_to_cpu(e->data_sector) >> 4203418d036SArtur Paszkiewicz ilog2(ppl_conf->block_size >> 9)); 4213418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(~le32_to_cpu(e->checksum)); 4223418d036SArtur Paszkiewicz } 4233418d036SArtur Paszkiewicz 4243418d036SArtur Paszkiewicz pplhdr->entries_count = cpu_to_le32(io->entries_count); 4253418d036SArtur Paszkiewicz pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PPL_HEADER_SIZE)); 4263418d036SArtur Paszkiewicz 4273418d036SArtur Paszkiewicz bio->bi_end_io = ppl_log_endio; 4283418d036SArtur Paszkiewicz bio->bi_opf = REQ_OP_WRITE | REQ_FUA; 4293418d036SArtur Paszkiewicz bio->bi_bdev = log->rdev->bdev; 4303418d036SArtur Paszkiewicz bio->bi_iter.bi_sector = log->rdev->ppl.sector; 4313418d036SArtur Paszkiewicz bio_add_page(bio, io->header_page, PAGE_SIZE, 0); 4323418d036SArtur Paszkiewicz 4333418d036SArtur Paszkiewicz list_for_each_entry(sh, &io->stripe_list, log_list) { 4343418d036SArtur Paszkiewicz /* entries for full stripe writes have no partial parity */ 4353418d036SArtur Paszkiewicz if (test_bit(STRIPE_FULL_WRITE, &sh->state)) 4363418d036SArtur Paszkiewicz continue; 4373418d036SArtur Paszkiewicz 4383418d036SArtur Paszkiewicz if (!bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0)) { 4393418d036SArtur Paszkiewicz struct bio *prev = bio; 4403418d036SArtur Paszkiewicz 4413418d036SArtur Paszkiewicz bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_PAGES, 4423418d036SArtur Paszkiewicz ppl_conf->bs); 4433418d036SArtur Paszkiewicz bio->bi_opf = prev->bi_opf; 4443418d036SArtur Paszkiewicz bio->bi_bdev = prev->bi_bdev; 4453418d036SArtur Paszkiewicz bio->bi_iter.bi_sector = bio_end_sector(prev); 4463418d036SArtur Paszkiewicz bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0); 4473418d036SArtur Paszkiewicz 4483418d036SArtur Paszkiewicz bio_chain(bio, prev); 4493418d036SArtur Paszkiewicz ppl_submit_iounit_bio(io, prev); 4503418d036SArtur Paszkiewicz } 4513418d036SArtur Paszkiewicz } 4523418d036SArtur Paszkiewicz 4533418d036SArtur Paszkiewicz ppl_submit_iounit_bio(io, bio); 4543418d036SArtur Paszkiewicz } 4553418d036SArtur Paszkiewicz 4563418d036SArtur Paszkiewicz static void ppl_submit_current_io(struct ppl_log *log) 4573418d036SArtur Paszkiewicz { 4583418d036SArtur Paszkiewicz struct ppl_io_unit *io; 4593418d036SArtur Paszkiewicz 4603418d036SArtur Paszkiewicz spin_lock_irq(&log->io_list_lock); 4613418d036SArtur Paszkiewicz 4623418d036SArtur Paszkiewicz io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit, 4633418d036SArtur Paszkiewicz log_sibling); 4643418d036SArtur Paszkiewicz if (io && io->submitted) 4653418d036SArtur Paszkiewicz io = NULL; 4663418d036SArtur Paszkiewicz 4673418d036SArtur Paszkiewicz spin_unlock_irq(&log->io_list_lock); 4683418d036SArtur Paszkiewicz 4693418d036SArtur Paszkiewicz if (io) { 4703418d036SArtur Paszkiewicz io->submitted = true; 4713418d036SArtur Paszkiewicz 4723418d036SArtur Paszkiewicz if (io == log->current_io) 4733418d036SArtur Paszkiewicz log->current_io = NULL; 4743418d036SArtur Paszkiewicz 4753418d036SArtur Paszkiewicz ppl_submit_iounit(io); 4763418d036SArtur Paszkiewicz } 4773418d036SArtur Paszkiewicz } 4783418d036SArtur Paszkiewicz 4793418d036SArtur Paszkiewicz void ppl_write_stripe_run(struct r5conf *conf) 4803418d036SArtur Paszkiewicz { 4813418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 4823418d036SArtur Paszkiewicz struct ppl_log *log; 4833418d036SArtur Paszkiewicz int i; 4843418d036SArtur Paszkiewicz 4853418d036SArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) { 4863418d036SArtur Paszkiewicz log = &ppl_conf->child_logs[i]; 4873418d036SArtur Paszkiewicz 4883418d036SArtur Paszkiewicz mutex_lock(&log->io_mutex); 4893418d036SArtur Paszkiewicz ppl_submit_current_io(log); 4903418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 4913418d036SArtur Paszkiewicz } 4923418d036SArtur Paszkiewicz } 4933418d036SArtur Paszkiewicz 4943418d036SArtur Paszkiewicz static void ppl_io_unit_finished(struct ppl_io_unit *io) 4953418d036SArtur Paszkiewicz { 4963418d036SArtur Paszkiewicz struct ppl_log *log = io->log; 49794568f64SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 4983418d036SArtur Paszkiewicz unsigned long flags; 4993418d036SArtur Paszkiewicz 5003418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu\n", __func__, io->seq); 5013418d036SArtur Paszkiewicz 50294568f64SArtur Paszkiewicz local_irq_save(flags); 5033418d036SArtur Paszkiewicz 50494568f64SArtur Paszkiewicz spin_lock(&log->io_list_lock); 5053418d036SArtur Paszkiewicz list_del(&io->log_sibling); 50694568f64SArtur Paszkiewicz spin_unlock(&log->io_list_lock); 5073418d036SArtur Paszkiewicz 50894568f64SArtur Paszkiewicz mempool_free(io, ppl_conf->io_pool); 50994568f64SArtur Paszkiewicz 51094568f64SArtur Paszkiewicz spin_lock(&ppl_conf->no_mem_stripes_lock); 51194568f64SArtur Paszkiewicz if (!list_empty(&ppl_conf->no_mem_stripes)) { 51294568f64SArtur Paszkiewicz struct stripe_head *sh; 51394568f64SArtur Paszkiewicz 51494568f64SArtur Paszkiewicz sh = list_first_entry(&ppl_conf->no_mem_stripes, 51594568f64SArtur Paszkiewicz struct stripe_head, log_list); 5163418d036SArtur Paszkiewicz list_del_init(&sh->log_list); 5173418d036SArtur Paszkiewicz set_bit(STRIPE_HANDLE, &sh->state); 5183418d036SArtur Paszkiewicz raid5_release_stripe(sh); 5193418d036SArtur Paszkiewicz } 52094568f64SArtur Paszkiewicz spin_unlock(&ppl_conf->no_mem_stripes_lock); 5213418d036SArtur Paszkiewicz 52294568f64SArtur Paszkiewicz local_irq_restore(flags); 5233418d036SArtur Paszkiewicz } 5243418d036SArtur Paszkiewicz 5253418d036SArtur Paszkiewicz void ppl_stripe_write_finished(struct stripe_head *sh) 5263418d036SArtur Paszkiewicz { 5273418d036SArtur Paszkiewicz struct ppl_io_unit *io; 5283418d036SArtur Paszkiewicz 5293418d036SArtur Paszkiewicz io = sh->ppl_io; 5303418d036SArtur Paszkiewicz sh->ppl_io = NULL; 5313418d036SArtur Paszkiewicz 5323418d036SArtur Paszkiewicz if (io && atomic_dec_and_test(&io->pending_stripes)) 5333418d036SArtur Paszkiewicz ppl_io_unit_finished(io); 5343418d036SArtur Paszkiewicz } 5353418d036SArtur Paszkiewicz 5364536bf9bSArtur Paszkiewicz static void ppl_xor(int size, struct page *page1, struct page *page2) 5374536bf9bSArtur Paszkiewicz { 5384536bf9bSArtur Paszkiewicz struct async_submit_ctl submit; 5394536bf9bSArtur Paszkiewicz struct dma_async_tx_descriptor *tx; 5404536bf9bSArtur Paszkiewicz struct page *xor_srcs[] = { page1, page2 }; 5414536bf9bSArtur Paszkiewicz 5424536bf9bSArtur Paszkiewicz init_async_submit(&submit, ASYNC_TX_ACK|ASYNC_TX_XOR_DROP_DST, 5434536bf9bSArtur Paszkiewicz NULL, NULL, NULL, NULL); 5444536bf9bSArtur Paszkiewicz tx = async_xor(page1, xor_srcs, 0, 2, size, &submit); 5454536bf9bSArtur Paszkiewicz 5464536bf9bSArtur Paszkiewicz async_tx_quiesce(&tx); 5474536bf9bSArtur Paszkiewicz } 5484536bf9bSArtur Paszkiewicz 5494536bf9bSArtur Paszkiewicz /* 5504536bf9bSArtur Paszkiewicz * PPL recovery strategy: xor partial parity and data from all modified data 5514536bf9bSArtur Paszkiewicz * disks within a stripe and write the result as the new stripe parity. If all 5524536bf9bSArtur Paszkiewicz * stripe data disks are modified (full stripe write), no partial parity is 5534536bf9bSArtur Paszkiewicz * available, so just xor the data disks. 5544536bf9bSArtur Paszkiewicz * 5554536bf9bSArtur Paszkiewicz * Recovery of a PPL entry shall occur only if all modified data disks are 5564536bf9bSArtur Paszkiewicz * available and read from all of them succeeds. 5574536bf9bSArtur Paszkiewicz * 5584536bf9bSArtur Paszkiewicz * A PPL entry applies to a stripe, partial parity size for an entry is at most 5594536bf9bSArtur Paszkiewicz * the size of the chunk. Examples of possible cases for a single entry: 5604536bf9bSArtur Paszkiewicz * 5614536bf9bSArtur Paszkiewicz * case 0: single data disk write: 5624536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 5634536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 5644536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 5654536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | -> | data1 ^ pp | 5664536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | -> | data1 ^ pp | 5674536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 5684536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 5694536bf9bSArtur Paszkiewicz * pp_size = data_size 5704536bf9bSArtur Paszkiewicz * 5714536bf9bSArtur Paszkiewicz * case 1: more than one data disk write: 5724536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 5734536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 5744536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 5754536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp | 5764536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp | 5774536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 5784536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 5794536bf9bSArtur Paszkiewicz * pp_size = data_size / modified_data_disks 5804536bf9bSArtur Paszkiewicz * 5814536bf9bSArtur Paszkiewicz * case 2: write to all data disks (also full stripe write): 5824536bf9bSArtur Paszkiewicz * data0 data1 data2 parity 5834536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 5844536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | (no change) | 5854536bf9bSArtur Paszkiewicz * | -data- | -data- | -data- | --------> | xor all data | 5864536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | --------> | (no change) | 5874536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | (no change) | 5884536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 5894536bf9bSArtur Paszkiewicz * pp_size = 0 5904536bf9bSArtur Paszkiewicz * 5914536bf9bSArtur Paszkiewicz * The following cases are possible only in other implementations. The recovery 5924536bf9bSArtur Paszkiewicz * code can handle them, but they are not generated at runtime because they can 5934536bf9bSArtur Paszkiewicz * be reduced to cases 0, 1 and 2: 5944536bf9bSArtur Paszkiewicz * 5954536bf9bSArtur Paszkiewicz * case 3: 5964536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 5974536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 5984536bf9bSArtur Paszkiewicz * | ------ | -data- | -data- | | pp | | data1 ^ data2 ^ pp | 5994536bf9bSArtur Paszkiewicz * | ------ | -data- | -data- | | pp | -> | data1 ^ data2 ^ pp | 6004536bf9bSArtur Paszkiewicz * | -data- | -data- | -data- | | -- | -> | xor all data | 6014536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | | data0 ^ data1 ^ pp | 6024536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 6034536bf9bSArtur Paszkiewicz * pp_size = chunk_size 6044536bf9bSArtur Paszkiewicz * 6054536bf9bSArtur Paszkiewicz * case 4: 6064536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 6074536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 6084536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | | data1 ^ pp | 6094536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | -- | -> | (no change) | 6104536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | -- | -> | (no change) | 6114536bf9bSArtur Paszkiewicz * | -data- | ------ | ------ | | pp | | data0 ^ pp | 6124536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 6134536bf9bSArtur Paszkiewicz * pp_size = chunk_size 6144536bf9bSArtur Paszkiewicz */ 6154536bf9bSArtur Paszkiewicz static int ppl_recover_entry(struct ppl_log *log, struct ppl_header_entry *e, 6164536bf9bSArtur Paszkiewicz sector_t ppl_sector) 6174536bf9bSArtur Paszkiewicz { 6184536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 6194536bf9bSArtur Paszkiewicz struct mddev *mddev = ppl_conf->mddev; 6204536bf9bSArtur Paszkiewicz struct r5conf *conf = mddev->private; 6214536bf9bSArtur Paszkiewicz int block_size = ppl_conf->block_size; 6224536bf9bSArtur Paszkiewicz struct page *page1; 6234536bf9bSArtur Paszkiewicz struct page *page2; 6244536bf9bSArtur Paszkiewicz sector_t r_sector_first; 6254536bf9bSArtur Paszkiewicz sector_t r_sector_last; 6264536bf9bSArtur Paszkiewicz int strip_sectors; 6274536bf9bSArtur Paszkiewicz int data_disks; 6284536bf9bSArtur Paszkiewicz int i; 6294536bf9bSArtur Paszkiewicz int ret = 0; 6304536bf9bSArtur Paszkiewicz char b[BDEVNAME_SIZE]; 6314536bf9bSArtur Paszkiewicz unsigned int pp_size = le32_to_cpu(e->pp_size); 6324536bf9bSArtur Paszkiewicz unsigned int data_size = le32_to_cpu(e->data_size); 6334536bf9bSArtur Paszkiewicz 6344536bf9bSArtur Paszkiewicz page1 = alloc_page(GFP_KERNEL); 6354536bf9bSArtur Paszkiewicz page2 = alloc_page(GFP_KERNEL); 6364536bf9bSArtur Paszkiewicz 6374536bf9bSArtur Paszkiewicz if (!page1 || !page2) { 6384536bf9bSArtur Paszkiewicz ret = -ENOMEM; 6394536bf9bSArtur Paszkiewicz goto out; 6404536bf9bSArtur Paszkiewicz } 6414536bf9bSArtur Paszkiewicz 6424536bf9bSArtur Paszkiewicz r_sector_first = le64_to_cpu(e->data_sector) * (block_size >> 9); 6434536bf9bSArtur Paszkiewicz 6444536bf9bSArtur Paszkiewicz if ((pp_size >> 9) < conf->chunk_sectors) { 6454536bf9bSArtur Paszkiewicz if (pp_size > 0) { 6464536bf9bSArtur Paszkiewicz data_disks = data_size / pp_size; 6474536bf9bSArtur Paszkiewicz strip_sectors = pp_size >> 9; 6484536bf9bSArtur Paszkiewicz } else { 6494536bf9bSArtur Paszkiewicz data_disks = conf->raid_disks - conf->max_degraded; 6504536bf9bSArtur Paszkiewicz strip_sectors = (data_size >> 9) / data_disks; 6514536bf9bSArtur Paszkiewicz } 6524536bf9bSArtur Paszkiewicz r_sector_last = r_sector_first + 6534536bf9bSArtur Paszkiewicz (data_disks - 1) * conf->chunk_sectors + 6544536bf9bSArtur Paszkiewicz strip_sectors; 6554536bf9bSArtur Paszkiewicz } else { 6564536bf9bSArtur Paszkiewicz data_disks = conf->raid_disks - conf->max_degraded; 6574536bf9bSArtur Paszkiewicz strip_sectors = conf->chunk_sectors; 6584536bf9bSArtur Paszkiewicz r_sector_last = r_sector_first + (data_size >> 9); 6594536bf9bSArtur Paszkiewicz } 6604536bf9bSArtur Paszkiewicz 6614536bf9bSArtur Paszkiewicz pr_debug("%s: array sector first: %llu last: %llu\n", __func__, 6624536bf9bSArtur Paszkiewicz (unsigned long long)r_sector_first, 6634536bf9bSArtur Paszkiewicz (unsigned long long)r_sector_last); 6644536bf9bSArtur Paszkiewicz 6654536bf9bSArtur Paszkiewicz /* if start and end is 4k aligned, use a 4k block */ 6664536bf9bSArtur Paszkiewicz if (block_size == 512 && 6674536bf9bSArtur Paszkiewicz (r_sector_first & (STRIPE_SECTORS - 1)) == 0 && 6684536bf9bSArtur Paszkiewicz (r_sector_last & (STRIPE_SECTORS - 1)) == 0) 6694536bf9bSArtur Paszkiewicz block_size = STRIPE_SIZE; 6704536bf9bSArtur Paszkiewicz 6714536bf9bSArtur Paszkiewicz /* iterate through blocks in strip */ 6724536bf9bSArtur Paszkiewicz for (i = 0; i < strip_sectors; i += (block_size >> 9)) { 6734536bf9bSArtur Paszkiewicz bool update_parity = false; 6744536bf9bSArtur Paszkiewicz sector_t parity_sector; 6754536bf9bSArtur Paszkiewicz struct md_rdev *parity_rdev; 6764536bf9bSArtur Paszkiewicz struct stripe_head sh; 6774536bf9bSArtur Paszkiewicz int disk; 6784536bf9bSArtur Paszkiewicz int indent = 0; 6794536bf9bSArtur Paszkiewicz 6804536bf9bSArtur Paszkiewicz pr_debug("%s:%*s iter %d start\n", __func__, indent, "", i); 6814536bf9bSArtur Paszkiewicz indent += 2; 6824536bf9bSArtur Paszkiewicz 6834536bf9bSArtur Paszkiewicz memset(page_address(page1), 0, PAGE_SIZE); 6844536bf9bSArtur Paszkiewicz 6854536bf9bSArtur Paszkiewicz /* iterate through data member disks */ 6864536bf9bSArtur Paszkiewicz for (disk = 0; disk < data_disks; disk++) { 6874536bf9bSArtur Paszkiewicz int dd_idx; 6884536bf9bSArtur Paszkiewicz struct md_rdev *rdev; 6894536bf9bSArtur Paszkiewicz sector_t sector; 6904536bf9bSArtur Paszkiewicz sector_t r_sector = r_sector_first + i + 6914536bf9bSArtur Paszkiewicz (disk * conf->chunk_sectors); 6924536bf9bSArtur Paszkiewicz 6934536bf9bSArtur Paszkiewicz pr_debug("%s:%*s data member disk %d start\n", 6944536bf9bSArtur Paszkiewicz __func__, indent, "", disk); 6954536bf9bSArtur Paszkiewicz indent += 2; 6964536bf9bSArtur Paszkiewicz 6974536bf9bSArtur Paszkiewicz if (r_sector >= r_sector_last) { 6984536bf9bSArtur Paszkiewicz pr_debug("%s:%*s array sector %llu doesn't need parity update\n", 6994536bf9bSArtur Paszkiewicz __func__, indent, "", 7004536bf9bSArtur Paszkiewicz (unsigned long long)r_sector); 7014536bf9bSArtur Paszkiewicz indent -= 2; 7024536bf9bSArtur Paszkiewicz continue; 7034536bf9bSArtur Paszkiewicz } 7044536bf9bSArtur Paszkiewicz 7054536bf9bSArtur Paszkiewicz update_parity = true; 7064536bf9bSArtur Paszkiewicz 7074536bf9bSArtur Paszkiewicz /* map raid sector to member disk */ 7084536bf9bSArtur Paszkiewicz sector = raid5_compute_sector(conf, r_sector, 0, 7094536bf9bSArtur Paszkiewicz &dd_idx, NULL); 7104536bf9bSArtur Paszkiewicz pr_debug("%s:%*s processing array sector %llu => data member disk %d, sector %llu\n", 7114536bf9bSArtur Paszkiewicz __func__, indent, "", 7124536bf9bSArtur Paszkiewicz (unsigned long long)r_sector, dd_idx, 7134536bf9bSArtur Paszkiewicz (unsigned long long)sector); 7144536bf9bSArtur Paszkiewicz 7154536bf9bSArtur Paszkiewicz rdev = conf->disks[dd_idx].rdev; 7164536bf9bSArtur Paszkiewicz if (!rdev) { 7174536bf9bSArtur Paszkiewicz pr_debug("%s:%*s data member disk %d missing\n", 7184536bf9bSArtur Paszkiewicz __func__, indent, "", dd_idx); 7194536bf9bSArtur Paszkiewicz update_parity = false; 7204536bf9bSArtur Paszkiewicz break; 7214536bf9bSArtur Paszkiewicz } 7224536bf9bSArtur Paszkiewicz 7234536bf9bSArtur Paszkiewicz pr_debug("%s:%*s reading data member disk %s sector %llu\n", 7244536bf9bSArtur Paszkiewicz __func__, indent, "", bdevname(rdev->bdev, b), 7254536bf9bSArtur Paszkiewicz (unsigned long long)sector); 7264536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, sector, block_size, page2, 7274536bf9bSArtur Paszkiewicz REQ_OP_READ, 0, false)) { 7284536bf9bSArtur Paszkiewicz md_error(mddev, rdev); 7294536bf9bSArtur Paszkiewicz pr_debug("%s:%*s read failed!\n", __func__, 7304536bf9bSArtur Paszkiewicz indent, ""); 7314536bf9bSArtur Paszkiewicz ret = -EIO; 7324536bf9bSArtur Paszkiewicz goto out; 7334536bf9bSArtur Paszkiewicz } 7344536bf9bSArtur Paszkiewicz 7354536bf9bSArtur Paszkiewicz ppl_xor(block_size, page1, page2); 7364536bf9bSArtur Paszkiewicz 7374536bf9bSArtur Paszkiewicz indent -= 2; 7384536bf9bSArtur Paszkiewicz } 7394536bf9bSArtur Paszkiewicz 7404536bf9bSArtur Paszkiewicz if (!update_parity) 7414536bf9bSArtur Paszkiewicz continue; 7424536bf9bSArtur Paszkiewicz 7434536bf9bSArtur Paszkiewicz if (pp_size > 0) { 7444536bf9bSArtur Paszkiewicz pr_debug("%s:%*s reading pp disk sector %llu\n", 7454536bf9bSArtur Paszkiewicz __func__, indent, "", 7464536bf9bSArtur Paszkiewicz (unsigned long long)(ppl_sector + i)); 7474536bf9bSArtur Paszkiewicz if (!sync_page_io(log->rdev, 7484536bf9bSArtur Paszkiewicz ppl_sector - log->rdev->data_offset + i, 7494536bf9bSArtur Paszkiewicz block_size, page2, REQ_OP_READ, 0, 7504536bf9bSArtur Paszkiewicz false)) { 7514536bf9bSArtur Paszkiewicz pr_debug("%s:%*s read failed!\n", __func__, 7524536bf9bSArtur Paszkiewicz indent, ""); 7534536bf9bSArtur Paszkiewicz md_error(mddev, log->rdev); 7544536bf9bSArtur Paszkiewicz ret = -EIO; 7554536bf9bSArtur Paszkiewicz goto out; 7564536bf9bSArtur Paszkiewicz } 7574536bf9bSArtur Paszkiewicz 7584536bf9bSArtur Paszkiewicz ppl_xor(block_size, page1, page2); 7594536bf9bSArtur Paszkiewicz } 7604536bf9bSArtur Paszkiewicz 7614536bf9bSArtur Paszkiewicz /* map raid sector to parity disk */ 7624536bf9bSArtur Paszkiewicz parity_sector = raid5_compute_sector(conf, r_sector_first + i, 7634536bf9bSArtur Paszkiewicz 0, &disk, &sh); 7644536bf9bSArtur Paszkiewicz BUG_ON(sh.pd_idx != le32_to_cpu(e->parity_disk)); 7654536bf9bSArtur Paszkiewicz parity_rdev = conf->disks[sh.pd_idx].rdev; 7664536bf9bSArtur Paszkiewicz 7674536bf9bSArtur Paszkiewicz BUG_ON(parity_rdev->bdev->bd_dev != log->rdev->bdev->bd_dev); 7684536bf9bSArtur Paszkiewicz pr_debug("%s:%*s write parity at sector %llu, disk %s\n", 7694536bf9bSArtur Paszkiewicz __func__, indent, "", 7704536bf9bSArtur Paszkiewicz (unsigned long long)parity_sector, 7714536bf9bSArtur Paszkiewicz bdevname(parity_rdev->bdev, b)); 7724536bf9bSArtur Paszkiewicz if (!sync_page_io(parity_rdev, parity_sector, block_size, 7734536bf9bSArtur Paszkiewicz page1, REQ_OP_WRITE, 0, false)) { 7744536bf9bSArtur Paszkiewicz pr_debug("%s:%*s parity write error!\n", __func__, 7754536bf9bSArtur Paszkiewicz indent, ""); 7764536bf9bSArtur Paszkiewicz md_error(mddev, parity_rdev); 7774536bf9bSArtur Paszkiewicz ret = -EIO; 7784536bf9bSArtur Paszkiewicz goto out; 7794536bf9bSArtur Paszkiewicz } 7804536bf9bSArtur Paszkiewicz } 7814536bf9bSArtur Paszkiewicz out: 7824536bf9bSArtur Paszkiewicz if (page1) 7834536bf9bSArtur Paszkiewicz __free_page(page1); 7844536bf9bSArtur Paszkiewicz if (page2) 7854536bf9bSArtur Paszkiewicz __free_page(page2); 7864536bf9bSArtur Paszkiewicz return ret; 7874536bf9bSArtur Paszkiewicz } 7884536bf9bSArtur Paszkiewicz 7894536bf9bSArtur Paszkiewicz static int ppl_recover(struct ppl_log *log, struct ppl_header *pplhdr) 7904536bf9bSArtur Paszkiewicz { 7914536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 7924536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev; 7934536bf9bSArtur Paszkiewicz struct mddev *mddev = rdev->mddev; 7944536bf9bSArtur Paszkiewicz sector_t ppl_sector = rdev->ppl.sector + (PPL_HEADER_SIZE >> 9); 7954536bf9bSArtur Paszkiewicz struct page *page; 7964536bf9bSArtur Paszkiewicz int i; 7974536bf9bSArtur Paszkiewicz int ret = 0; 7984536bf9bSArtur Paszkiewicz 7994536bf9bSArtur Paszkiewicz page = alloc_page(GFP_KERNEL); 8004536bf9bSArtur Paszkiewicz if (!page) 8014536bf9bSArtur Paszkiewicz return -ENOMEM; 8024536bf9bSArtur Paszkiewicz 8034536bf9bSArtur Paszkiewicz /* iterate through all PPL entries saved */ 8044536bf9bSArtur Paszkiewicz for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++) { 8054536bf9bSArtur Paszkiewicz struct ppl_header_entry *e = &pplhdr->entries[i]; 8064536bf9bSArtur Paszkiewicz u32 pp_size = le32_to_cpu(e->pp_size); 8074536bf9bSArtur Paszkiewicz sector_t sector = ppl_sector; 8084536bf9bSArtur Paszkiewicz int ppl_entry_sectors = pp_size >> 9; 8094536bf9bSArtur Paszkiewicz u32 crc, crc_stored; 8104536bf9bSArtur Paszkiewicz 8114536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d entry: %d ppl_sector: %llu pp_size: %u\n", 8124536bf9bSArtur Paszkiewicz __func__, rdev->raid_disk, i, 8134536bf9bSArtur Paszkiewicz (unsigned long long)ppl_sector, pp_size); 8144536bf9bSArtur Paszkiewicz 8154536bf9bSArtur Paszkiewicz crc = ~0; 8164536bf9bSArtur Paszkiewicz crc_stored = le32_to_cpu(e->checksum); 8174536bf9bSArtur Paszkiewicz 8184536bf9bSArtur Paszkiewicz /* read parial parity for this entry and calculate its checksum */ 8194536bf9bSArtur Paszkiewicz while (pp_size) { 8204536bf9bSArtur Paszkiewicz int s = pp_size > PAGE_SIZE ? PAGE_SIZE : pp_size; 8214536bf9bSArtur Paszkiewicz 8224536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, sector - rdev->data_offset, 8234536bf9bSArtur Paszkiewicz s, page, REQ_OP_READ, 0, false)) { 8244536bf9bSArtur Paszkiewicz md_error(mddev, rdev); 8254536bf9bSArtur Paszkiewicz ret = -EIO; 8264536bf9bSArtur Paszkiewicz goto out; 8274536bf9bSArtur Paszkiewicz } 8284536bf9bSArtur Paszkiewicz 8294536bf9bSArtur Paszkiewicz crc = crc32c_le(crc, page_address(page), s); 8304536bf9bSArtur Paszkiewicz 8314536bf9bSArtur Paszkiewicz pp_size -= s; 8324536bf9bSArtur Paszkiewicz sector += s >> 9; 8334536bf9bSArtur Paszkiewicz } 8344536bf9bSArtur Paszkiewicz 8354536bf9bSArtur Paszkiewicz crc = ~crc; 8364536bf9bSArtur Paszkiewicz 8374536bf9bSArtur Paszkiewicz if (crc != crc_stored) { 8384536bf9bSArtur Paszkiewicz /* 8394536bf9bSArtur Paszkiewicz * Don't recover this entry if the checksum does not 8404536bf9bSArtur Paszkiewicz * match, but keep going and try to recover other 8414536bf9bSArtur Paszkiewicz * entries. 8424536bf9bSArtur Paszkiewicz */ 8434536bf9bSArtur Paszkiewicz pr_debug("%s: ppl entry crc does not match: stored: 0x%x calculated: 0x%x\n", 8444536bf9bSArtur Paszkiewicz __func__, crc_stored, crc); 8454536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count++; 8464536bf9bSArtur Paszkiewicz } else { 8474536bf9bSArtur Paszkiewicz ret = ppl_recover_entry(log, e, ppl_sector); 8484536bf9bSArtur Paszkiewicz if (ret) 8494536bf9bSArtur Paszkiewicz goto out; 8504536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries++; 8514536bf9bSArtur Paszkiewicz } 8524536bf9bSArtur Paszkiewicz 8534536bf9bSArtur Paszkiewicz ppl_sector += ppl_entry_sectors; 8544536bf9bSArtur Paszkiewicz } 8554536bf9bSArtur Paszkiewicz 8564536bf9bSArtur Paszkiewicz /* flush the disk cache after recovery if necessary */ 8574536bf9bSArtur Paszkiewicz ret = blkdev_issue_flush(rdev->bdev, GFP_KERNEL, NULL); 8584536bf9bSArtur Paszkiewicz out: 8594536bf9bSArtur Paszkiewicz __free_page(page); 8604536bf9bSArtur Paszkiewicz return ret; 8614536bf9bSArtur Paszkiewicz } 8624536bf9bSArtur Paszkiewicz 8634536bf9bSArtur Paszkiewicz static int ppl_write_empty_header(struct ppl_log *log) 8644536bf9bSArtur Paszkiewicz { 8654536bf9bSArtur Paszkiewicz struct page *page; 8664536bf9bSArtur Paszkiewicz struct ppl_header *pplhdr; 8674536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev; 8684536bf9bSArtur Paszkiewicz int ret = 0; 8694536bf9bSArtur Paszkiewicz 8704536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d ppl_sector: %llu\n", __func__, 8714536bf9bSArtur Paszkiewicz rdev->raid_disk, (unsigned long long)rdev->ppl.sector); 8724536bf9bSArtur Paszkiewicz 8734536bf9bSArtur Paszkiewicz page = alloc_page(GFP_NOIO | __GFP_ZERO); 8744536bf9bSArtur Paszkiewicz if (!page) 8754536bf9bSArtur Paszkiewicz return -ENOMEM; 8764536bf9bSArtur Paszkiewicz 8774536bf9bSArtur Paszkiewicz pplhdr = page_address(page); 8784536bf9bSArtur Paszkiewicz memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED); 8794536bf9bSArtur Paszkiewicz pplhdr->signature = cpu_to_le32(log->ppl_conf->signature); 8804536bf9bSArtur Paszkiewicz pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PAGE_SIZE)); 8814536bf9bSArtur Paszkiewicz 8824536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, rdev->ppl.sector - rdev->data_offset, 8834536bf9bSArtur Paszkiewicz PPL_HEADER_SIZE, page, REQ_OP_WRITE | REQ_FUA, 0, 8844536bf9bSArtur Paszkiewicz false)) { 8854536bf9bSArtur Paszkiewicz md_error(rdev->mddev, rdev); 8864536bf9bSArtur Paszkiewicz ret = -EIO; 8874536bf9bSArtur Paszkiewicz } 8884536bf9bSArtur Paszkiewicz 8894536bf9bSArtur Paszkiewicz __free_page(page); 8904536bf9bSArtur Paszkiewicz return ret; 8914536bf9bSArtur Paszkiewicz } 8924536bf9bSArtur Paszkiewicz 8934536bf9bSArtur Paszkiewicz static int ppl_load_distributed(struct ppl_log *log) 8944536bf9bSArtur Paszkiewicz { 8954536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 8964536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev; 8974536bf9bSArtur Paszkiewicz struct mddev *mddev = rdev->mddev; 8984536bf9bSArtur Paszkiewicz struct page *page; 8994536bf9bSArtur Paszkiewicz struct ppl_header *pplhdr; 9004536bf9bSArtur Paszkiewicz u32 crc, crc_stored; 9014536bf9bSArtur Paszkiewicz u32 signature; 9024536bf9bSArtur Paszkiewicz int ret = 0; 9034536bf9bSArtur Paszkiewicz 9044536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d\n", __func__, rdev->raid_disk); 9054536bf9bSArtur Paszkiewicz 9064536bf9bSArtur Paszkiewicz /* read PPL header */ 9074536bf9bSArtur Paszkiewicz page = alloc_page(GFP_KERNEL); 9084536bf9bSArtur Paszkiewicz if (!page) 9094536bf9bSArtur Paszkiewicz return -ENOMEM; 9104536bf9bSArtur Paszkiewicz 9114536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, rdev->ppl.sector - rdev->data_offset, 9124536bf9bSArtur Paszkiewicz PAGE_SIZE, page, REQ_OP_READ, 0, false)) { 9134536bf9bSArtur Paszkiewicz md_error(mddev, rdev); 9144536bf9bSArtur Paszkiewicz ret = -EIO; 9154536bf9bSArtur Paszkiewicz goto out; 9164536bf9bSArtur Paszkiewicz } 9174536bf9bSArtur Paszkiewicz pplhdr = page_address(page); 9184536bf9bSArtur Paszkiewicz 9194536bf9bSArtur Paszkiewicz /* check header validity */ 9204536bf9bSArtur Paszkiewicz crc_stored = le32_to_cpu(pplhdr->checksum); 9214536bf9bSArtur Paszkiewicz pplhdr->checksum = 0; 9224536bf9bSArtur Paszkiewicz crc = ~crc32c_le(~0, pplhdr, PAGE_SIZE); 9234536bf9bSArtur Paszkiewicz 9244536bf9bSArtur Paszkiewicz if (crc_stored != crc) { 9254536bf9bSArtur Paszkiewicz pr_debug("%s: ppl header crc does not match: stored: 0x%x calculated: 0x%x\n", 9264536bf9bSArtur Paszkiewicz __func__, crc_stored, crc); 9274536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count++; 9284536bf9bSArtur Paszkiewicz goto out; 9294536bf9bSArtur Paszkiewicz } 9304536bf9bSArtur Paszkiewicz 9314536bf9bSArtur Paszkiewicz signature = le32_to_cpu(pplhdr->signature); 9324536bf9bSArtur Paszkiewicz 9334536bf9bSArtur Paszkiewicz if (mddev->external) { 9344536bf9bSArtur Paszkiewicz /* 9354536bf9bSArtur Paszkiewicz * For external metadata the header signature is set and 9364536bf9bSArtur Paszkiewicz * validated in userspace. 9374536bf9bSArtur Paszkiewicz */ 9384536bf9bSArtur Paszkiewicz ppl_conf->signature = signature; 9394536bf9bSArtur Paszkiewicz } else if (ppl_conf->signature != signature) { 9404536bf9bSArtur Paszkiewicz pr_debug("%s: ppl header signature does not match: stored: 0x%x configured: 0x%x\n", 9414536bf9bSArtur Paszkiewicz __func__, signature, ppl_conf->signature); 9424536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count++; 9434536bf9bSArtur Paszkiewicz goto out; 9444536bf9bSArtur Paszkiewicz } 9454536bf9bSArtur Paszkiewicz 9464536bf9bSArtur Paszkiewicz /* attempt to recover from log if we are starting a dirty array */ 9474536bf9bSArtur Paszkiewicz if (!mddev->pers && mddev->recovery_cp != MaxSector) 9484536bf9bSArtur Paszkiewicz ret = ppl_recover(log, pplhdr); 9494536bf9bSArtur Paszkiewicz out: 9504536bf9bSArtur Paszkiewicz /* write empty header if we are starting the array */ 9514536bf9bSArtur Paszkiewicz if (!ret && !mddev->pers) 9524536bf9bSArtur Paszkiewicz ret = ppl_write_empty_header(log); 9534536bf9bSArtur Paszkiewicz 9544536bf9bSArtur Paszkiewicz __free_page(page); 9554536bf9bSArtur Paszkiewicz 9564536bf9bSArtur Paszkiewicz pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n", 9574536bf9bSArtur Paszkiewicz __func__, ret, ppl_conf->mismatch_count, 9584536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries); 9594536bf9bSArtur Paszkiewicz return ret; 9604536bf9bSArtur Paszkiewicz } 9614536bf9bSArtur Paszkiewicz 9624536bf9bSArtur Paszkiewicz static int ppl_load(struct ppl_conf *ppl_conf) 9634536bf9bSArtur Paszkiewicz { 9644536bf9bSArtur Paszkiewicz int ret = 0; 9654536bf9bSArtur Paszkiewicz u32 signature = 0; 9664536bf9bSArtur Paszkiewicz bool signature_set = false; 9674536bf9bSArtur Paszkiewicz int i; 9684536bf9bSArtur Paszkiewicz 9694536bf9bSArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) { 9704536bf9bSArtur Paszkiewicz struct ppl_log *log = &ppl_conf->child_logs[i]; 9714536bf9bSArtur Paszkiewicz 9724536bf9bSArtur Paszkiewicz /* skip missing drive */ 9734536bf9bSArtur Paszkiewicz if (!log->rdev) 9744536bf9bSArtur Paszkiewicz continue; 9754536bf9bSArtur Paszkiewicz 9764536bf9bSArtur Paszkiewicz ret = ppl_load_distributed(log); 9774536bf9bSArtur Paszkiewicz if (ret) 9784536bf9bSArtur Paszkiewicz break; 9794536bf9bSArtur Paszkiewicz 9804536bf9bSArtur Paszkiewicz /* 9814536bf9bSArtur Paszkiewicz * For external metadata we can't check if the signature is 9824536bf9bSArtur Paszkiewicz * correct on a single drive, but we can check if it is the same 9834536bf9bSArtur Paszkiewicz * on all drives. 9844536bf9bSArtur Paszkiewicz */ 9854536bf9bSArtur Paszkiewicz if (ppl_conf->mddev->external) { 9864536bf9bSArtur Paszkiewicz if (!signature_set) { 9874536bf9bSArtur Paszkiewicz signature = ppl_conf->signature; 9884536bf9bSArtur Paszkiewicz signature_set = true; 9894536bf9bSArtur Paszkiewicz } else if (signature != ppl_conf->signature) { 9904536bf9bSArtur Paszkiewicz pr_warn("md/raid:%s: PPL header signature does not match on all member drives\n", 9914536bf9bSArtur Paszkiewicz mdname(ppl_conf->mddev)); 9924536bf9bSArtur Paszkiewicz ret = -EINVAL; 9934536bf9bSArtur Paszkiewicz break; 9944536bf9bSArtur Paszkiewicz } 9954536bf9bSArtur Paszkiewicz } 9964536bf9bSArtur Paszkiewicz } 9974536bf9bSArtur Paszkiewicz 9984536bf9bSArtur Paszkiewicz pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n", 9994536bf9bSArtur Paszkiewicz __func__, ret, ppl_conf->mismatch_count, 10004536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries); 10014536bf9bSArtur Paszkiewicz return ret; 10024536bf9bSArtur Paszkiewicz } 10034536bf9bSArtur Paszkiewicz 10043418d036SArtur Paszkiewicz static void __ppl_exit_log(struct ppl_conf *ppl_conf) 10053418d036SArtur Paszkiewicz { 10063418d036SArtur Paszkiewicz clear_bit(MD_HAS_PPL, &ppl_conf->mddev->flags); 10073418d036SArtur Paszkiewicz 10083418d036SArtur Paszkiewicz kfree(ppl_conf->child_logs); 10093418d036SArtur Paszkiewicz 10103418d036SArtur Paszkiewicz mempool_destroy(ppl_conf->meta_pool); 10113418d036SArtur Paszkiewicz if (ppl_conf->bs) 10123418d036SArtur Paszkiewicz bioset_free(ppl_conf->bs); 10133418d036SArtur Paszkiewicz mempool_destroy(ppl_conf->io_pool); 10143418d036SArtur Paszkiewicz kmem_cache_destroy(ppl_conf->io_kc); 10153418d036SArtur Paszkiewicz 10163418d036SArtur Paszkiewicz kfree(ppl_conf); 10173418d036SArtur Paszkiewicz } 10183418d036SArtur Paszkiewicz 10193418d036SArtur Paszkiewicz void ppl_exit_log(struct r5conf *conf) 10203418d036SArtur Paszkiewicz { 10213418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 10223418d036SArtur Paszkiewicz 10233418d036SArtur Paszkiewicz if (ppl_conf) { 10243418d036SArtur Paszkiewicz __ppl_exit_log(ppl_conf); 10253418d036SArtur Paszkiewicz conf->log_private = NULL; 10263418d036SArtur Paszkiewicz } 10273418d036SArtur Paszkiewicz } 10283418d036SArtur Paszkiewicz 10293418d036SArtur Paszkiewicz static int ppl_validate_rdev(struct md_rdev *rdev) 10303418d036SArtur Paszkiewicz { 10313418d036SArtur Paszkiewicz char b[BDEVNAME_SIZE]; 10323418d036SArtur Paszkiewicz int ppl_data_sectors; 10333418d036SArtur Paszkiewicz int ppl_size_new; 10343418d036SArtur Paszkiewicz 10353418d036SArtur Paszkiewicz /* 10363418d036SArtur Paszkiewicz * The configured PPL size must be enough to store 10373418d036SArtur Paszkiewicz * the header and (at the very least) partial parity 10383418d036SArtur Paszkiewicz * for one stripe. Round it down to ensure the data 10393418d036SArtur Paszkiewicz * space is cleanly divisible by stripe size. 10403418d036SArtur Paszkiewicz */ 10413418d036SArtur Paszkiewicz ppl_data_sectors = rdev->ppl.size - (PPL_HEADER_SIZE >> 9); 10423418d036SArtur Paszkiewicz 10433418d036SArtur Paszkiewicz if (ppl_data_sectors > 0) 10443418d036SArtur Paszkiewicz ppl_data_sectors = rounddown(ppl_data_sectors, STRIPE_SECTORS); 10453418d036SArtur Paszkiewicz 10463418d036SArtur Paszkiewicz if (ppl_data_sectors <= 0) { 10473418d036SArtur Paszkiewicz pr_warn("md/raid:%s: PPL space too small on %s\n", 10483418d036SArtur Paszkiewicz mdname(rdev->mddev), bdevname(rdev->bdev, b)); 10493418d036SArtur Paszkiewicz return -ENOSPC; 10503418d036SArtur Paszkiewicz } 10513418d036SArtur Paszkiewicz 10523418d036SArtur Paszkiewicz ppl_size_new = ppl_data_sectors + (PPL_HEADER_SIZE >> 9); 10533418d036SArtur Paszkiewicz 10543418d036SArtur Paszkiewicz if ((rdev->ppl.sector < rdev->data_offset && 10553418d036SArtur Paszkiewicz rdev->ppl.sector + ppl_size_new > rdev->data_offset) || 10563418d036SArtur Paszkiewicz (rdev->ppl.sector >= rdev->data_offset && 10573418d036SArtur Paszkiewicz rdev->data_offset + rdev->sectors > rdev->ppl.sector)) { 10583418d036SArtur Paszkiewicz pr_warn("md/raid:%s: PPL space overlaps with data on %s\n", 10593418d036SArtur Paszkiewicz mdname(rdev->mddev), bdevname(rdev->bdev, b)); 10603418d036SArtur Paszkiewicz return -EINVAL; 10613418d036SArtur Paszkiewicz } 10623418d036SArtur Paszkiewicz 10633418d036SArtur Paszkiewicz if (!rdev->mddev->external && 10643418d036SArtur Paszkiewicz ((rdev->ppl.offset > 0 && rdev->ppl.offset < (rdev->sb_size >> 9)) || 10653418d036SArtur Paszkiewicz (rdev->ppl.offset <= 0 && rdev->ppl.offset + ppl_size_new > 0))) { 10663418d036SArtur Paszkiewicz pr_warn("md/raid:%s: PPL space overlaps with superblock on %s\n", 10673418d036SArtur Paszkiewicz mdname(rdev->mddev), bdevname(rdev->bdev, b)); 10683418d036SArtur Paszkiewicz return -EINVAL; 10693418d036SArtur Paszkiewicz } 10703418d036SArtur Paszkiewicz 10713418d036SArtur Paszkiewicz rdev->ppl.size = ppl_size_new; 10723418d036SArtur Paszkiewicz 10733418d036SArtur Paszkiewicz return 0; 10743418d036SArtur Paszkiewicz } 10753418d036SArtur Paszkiewicz 10763418d036SArtur Paszkiewicz int ppl_init_log(struct r5conf *conf) 10773418d036SArtur Paszkiewicz { 10783418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf; 10793418d036SArtur Paszkiewicz struct mddev *mddev = conf->mddev; 10803418d036SArtur Paszkiewicz int ret = 0; 10813418d036SArtur Paszkiewicz int i; 10820b408bafSDan Carpenter bool need_cache_flush = false; 10833418d036SArtur Paszkiewicz 10843418d036SArtur Paszkiewicz pr_debug("md/raid:%s: enabling distributed Partial Parity Log\n", 10853418d036SArtur Paszkiewicz mdname(conf->mddev)); 10863418d036SArtur Paszkiewicz 10873418d036SArtur Paszkiewicz if (PAGE_SIZE != 4096) 10883418d036SArtur Paszkiewicz return -EINVAL; 10893418d036SArtur Paszkiewicz 10903418d036SArtur Paszkiewicz if (mddev->level != 5) { 10913418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with raid level %d\n", 10923418d036SArtur Paszkiewicz mdname(mddev), mddev->level); 10933418d036SArtur Paszkiewicz return -EINVAL; 10943418d036SArtur Paszkiewicz } 10953418d036SArtur Paszkiewicz 10963418d036SArtur Paszkiewicz if (mddev->bitmap_info.file || mddev->bitmap_info.offset) { 10973418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with bitmap\n", 10983418d036SArtur Paszkiewicz mdname(mddev)); 10993418d036SArtur Paszkiewicz return -EINVAL; 11003418d036SArtur Paszkiewicz } 11013418d036SArtur Paszkiewicz 11023418d036SArtur Paszkiewicz if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) { 11033418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with journal\n", 11043418d036SArtur Paszkiewicz mdname(mddev)); 11053418d036SArtur Paszkiewicz return -EINVAL; 11063418d036SArtur Paszkiewicz } 11073418d036SArtur Paszkiewicz 11083418d036SArtur Paszkiewicz ppl_conf = kzalloc(sizeof(struct ppl_conf), GFP_KERNEL); 11093418d036SArtur Paszkiewicz if (!ppl_conf) 11103418d036SArtur Paszkiewicz return -ENOMEM; 11113418d036SArtur Paszkiewicz 11123418d036SArtur Paszkiewicz ppl_conf->mddev = mddev; 11133418d036SArtur Paszkiewicz 11143418d036SArtur Paszkiewicz ppl_conf->io_kc = KMEM_CACHE(ppl_io_unit, 0); 11153418d036SArtur Paszkiewicz if (!ppl_conf->io_kc) { 11163418d036SArtur Paszkiewicz ret = -EINVAL; 11173418d036SArtur Paszkiewicz goto err; 11183418d036SArtur Paszkiewicz } 11193418d036SArtur Paszkiewicz 11203418d036SArtur Paszkiewicz ppl_conf->io_pool = mempool_create_slab_pool(conf->raid_disks, ppl_conf->io_kc); 11213418d036SArtur Paszkiewicz if (!ppl_conf->io_pool) { 11223418d036SArtur Paszkiewicz ret = -EINVAL; 11233418d036SArtur Paszkiewicz goto err; 11243418d036SArtur Paszkiewicz } 11253418d036SArtur Paszkiewicz 11263418d036SArtur Paszkiewicz ppl_conf->bs = bioset_create(conf->raid_disks, 0); 11273418d036SArtur Paszkiewicz if (!ppl_conf->bs) { 11283418d036SArtur Paszkiewicz ret = -EINVAL; 11293418d036SArtur Paszkiewicz goto err; 11303418d036SArtur Paszkiewicz } 11313418d036SArtur Paszkiewicz 11323418d036SArtur Paszkiewicz ppl_conf->meta_pool = mempool_create_page_pool(conf->raid_disks, 0); 11333418d036SArtur Paszkiewicz if (!ppl_conf->meta_pool) { 11343418d036SArtur Paszkiewicz ret = -EINVAL; 11353418d036SArtur Paszkiewicz goto err; 11363418d036SArtur Paszkiewicz } 11373418d036SArtur Paszkiewicz 11383418d036SArtur Paszkiewicz ppl_conf->count = conf->raid_disks; 11393418d036SArtur Paszkiewicz ppl_conf->child_logs = kcalloc(ppl_conf->count, sizeof(struct ppl_log), 11403418d036SArtur Paszkiewicz GFP_KERNEL); 11413418d036SArtur Paszkiewicz if (!ppl_conf->child_logs) { 11423418d036SArtur Paszkiewicz ret = -ENOMEM; 11433418d036SArtur Paszkiewicz goto err; 11443418d036SArtur Paszkiewicz } 11453418d036SArtur Paszkiewicz 11463418d036SArtur Paszkiewicz atomic64_set(&ppl_conf->seq, 0); 114794568f64SArtur Paszkiewicz INIT_LIST_HEAD(&ppl_conf->no_mem_stripes); 114894568f64SArtur Paszkiewicz spin_lock_init(&ppl_conf->no_mem_stripes_lock); 11493418d036SArtur Paszkiewicz 11503418d036SArtur Paszkiewicz if (!mddev->external) { 11513418d036SArtur Paszkiewicz ppl_conf->signature = ~crc32c_le(~0, mddev->uuid, sizeof(mddev->uuid)); 11523418d036SArtur Paszkiewicz ppl_conf->block_size = 512; 11533418d036SArtur Paszkiewicz } else { 11543418d036SArtur Paszkiewicz ppl_conf->block_size = queue_logical_block_size(mddev->queue); 11553418d036SArtur Paszkiewicz } 11563418d036SArtur Paszkiewicz 11573418d036SArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) { 11583418d036SArtur Paszkiewicz struct ppl_log *log = &ppl_conf->child_logs[i]; 11593418d036SArtur Paszkiewicz struct md_rdev *rdev = conf->disks[i].rdev; 11603418d036SArtur Paszkiewicz 11613418d036SArtur Paszkiewicz mutex_init(&log->io_mutex); 11623418d036SArtur Paszkiewicz spin_lock_init(&log->io_list_lock); 11633418d036SArtur Paszkiewicz INIT_LIST_HEAD(&log->io_list); 11643418d036SArtur Paszkiewicz 11653418d036SArtur Paszkiewicz log->ppl_conf = ppl_conf; 11663418d036SArtur Paszkiewicz log->rdev = rdev; 11673418d036SArtur Paszkiewicz 11683418d036SArtur Paszkiewicz if (rdev) { 11693418d036SArtur Paszkiewicz struct request_queue *q; 11703418d036SArtur Paszkiewicz 11713418d036SArtur Paszkiewicz ret = ppl_validate_rdev(rdev); 11723418d036SArtur Paszkiewicz if (ret) 11733418d036SArtur Paszkiewicz goto err; 11743418d036SArtur Paszkiewicz 11753418d036SArtur Paszkiewicz q = bdev_get_queue(rdev->bdev); 11763418d036SArtur Paszkiewicz if (test_bit(QUEUE_FLAG_WC, &q->queue_flags)) 11773418d036SArtur Paszkiewicz need_cache_flush = true; 11783418d036SArtur Paszkiewicz } 11793418d036SArtur Paszkiewicz } 11803418d036SArtur Paszkiewicz 11813418d036SArtur Paszkiewicz if (need_cache_flush) 11823418d036SArtur Paszkiewicz pr_warn("md/raid:%s: Volatile write-back cache should be disabled on all member drives when using PPL!\n", 11833418d036SArtur Paszkiewicz mdname(mddev)); 11843418d036SArtur Paszkiewicz 11854536bf9bSArtur Paszkiewicz /* load and possibly recover the logs from the member disks */ 11864536bf9bSArtur Paszkiewicz ret = ppl_load(ppl_conf); 11874536bf9bSArtur Paszkiewicz 11884536bf9bSArtur Paszkiewicz if (ret) { 11894536bf9bSArtur Paszkiewicz goto err; 11904536bf9bSArtur Paszkiewicz } else if (!mddev->pers && 11914536bf9bSArtur Paszkiewicz mddev->recovery_cp == 0 && !mddev->degraded && 11924536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries > 0 && 11934536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count == 0) { 11944536bf9bSArtur Paszkiewicz /* 11954536bf9bSArtur Paszkiewicz * If we are starting a dirty array and the recovery succeeds 11964536bf9bSArtur Paszkiewicz * without any issues, set the array as clean. 11974536bf9bSArtur Paszkiewicz */ 11984536bf9bSArtur Paszkiewicz mddev->recovery_cp = MaxSector; 11994536bf9bSArtur Paszkiewicz set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 1200ba903a3eSArtur Paszkiewicz } else if (mddev->pers && ppl_conf->mismatch_count > 0) { 1201ba903a3eSArtur Paszkiewicz /* no mismatch allowed when enabling PPL for a running array */ 1202ba903a3eSArtur Paszkiewicz ret = -EINVAL; 1203ba903a3eSArtur Paszkiewicz goto err; 12044536bf9bSArtur Paszkiewicz } 12054536bf9bSArtur Paszkiewicz 12063418d036SArtur Paszkiewicz conf->log_private = ppl_conf; 12073418d036SArtur Paszkiewicz 12083418d036SArtur Paszkiewicz return 0; 12093418d036SArtur Paszkiewicz err: 12103418d036SArtur Paszkiewicz __ppl_exit_log(ppl_conf); 12113418d036SArtur Paszkiewicz return ret; 12123418d036SArtur Paszkiewicz } 12136358c239SArtur Paszkiewicz 12146358c239SArtur Paszkiewicz int ppl_modify_log(struct r5conf *conf, struct md_rdev *rdev, bool add) 12156358c239SArtur Paszkiewicz { 12166358c239SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 12176358c239SArtur Paszkiewicz struct ppl_log *log; 12186358c239SArtur Paszkiewicz int ret = 0; 12196358c239SArtur Paszkiewicz char b[BDEVNAME_SIZE]; 12206358c239SArtur Paszkiewicz 12216358c239SArtur Paszkiewicz if (!rdev) 12226358c239SArtur Paszkiewicz return -EINVAL; 12236358c239SArtur Paszkiewicz 12246358c239SArtur Paszkiewicz pr_debug("%s: disk: %d operation: %s dev: %s\n", 12256358c239SArtur Paszkiewicz __func__, rdev->raid_disk, add ? "add" : "remove", 12266358c239SArtur Paszkiewicz bdevname(rdev->bdev, b)); 12276358c239SArtur Paszkiewicz 12286358c239SArtur Paszkiewicz if (rdev->raid_disk < 0) 12296358c239SArtur Paszkiewicz return 0; 12306358c239SArtur Paszkiewicz 12316358c239SArtur Paszkiewicz if (rdev->raid_disk >= ppl_conf->count) 12326358c239SArtur Paszkiewicz return -ENODEV; 12336358c239SArtur Paszkiewicz 12346358c239SArtur Paszkiewicz log = &ppl_conf->child_logs[rdev->raid_disk]; 12356358c239SArtur Paszkiewicz 12366358c239SArtur Paszkiewicz mutex_lock(&log->io_mutex); 12376358c239SArtur Paszkiewicz if (add) { 12386358c239SArtur Paszkiewicz ret = ppl_validate_rdev(rdev); 12396358c239SArtur Paszkiewicz if (!ret) { 12406358c239SArtur Paszkiewicz log->rdev = rdev; 12416358c239SArtur Paszkiewicz ret = ppl_write_empty_header(log); 12426358c239SArtur Paszkiewicz } 12436358c239SArtur Paszkiewicz } else { 12446358c239SArtur Paszkiewicz log->rdev = NULL; 12456358c239SArtur Paszkiewicz } 12466358c239SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 12476358c239SArtur Paszkiewicz 12486358c239SArtur Paszkiewicz return ret; 12496358c239SArtur Paszkiewicz } 1250