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" 24a596d086SMariusz Dabrowski #include "raid5-log.h" 253418d036SArtur Paszkiewicz 263418d036SArtur Paszkiewicz /* 273418d036SArtur Paszkiewicz * PPL consists of a 4KB header (struct ppl_header) and at least 128KB for 283418d036SArtur Paszkiewicz * partial parity data. The header contains an array of entries 293418d036SArtur Paszkiewicz * (struct ppl_header_entry) which describe the logged write requests. 303418d036SArtur Paszkiewicz * Partial parity for the entries comes after the header, written in the same 313418d036SArtur Paszkiewicz * sequence as the entries: 323418d036SArtur Paszkiewicz * 333418d036SArtur Paszkiewicz * Header 343418d036SArtur Paszkiewicz * entry0 353418d036SArtur Paszkiewicz * ... 363418d036SArtur Paszkiewicz * entryN 373418d036SArtur Paszkiewicz * PP data 383418d036SArtur Paszkiewicz * PP for entry0 393418d036SArtur Paszkiewicz * ... 403418d036SArtur Paszkiewicz * PP for entryN 413418d036SArtur Paszkiewicz * 423418d036SArtur Paszkiewicz * An entry describes one or more consecutive stripe_heads, up to a full 433418d036SArtur Paszkiewicz * stripe. The modifed raid data chunks form an m-by-n matrix, where m is the 443418d036SArtur Paszkiewicz * number of stripe_heads in the entry and n is the number of modified data 453418d036SArtur Paszkiewicz * disks. Every stripe_head in the entry must write to the same data disks. 463418d036SArtur Paszkiewicz * An example of a valid case described by a single entry (writes to the first 473418d036SArtur Paszkiewicz * stripe of a 4 disk array, 16k chunk size): 483418d036SArtur Paszkiewicz * 493418d036SArtur Paszkiewicz * sh->sector dd0 dd1 dd2 ppl 503418d036SArtur Paszkiewicz * +-----+-----+-----+ 513418d036SArtur Paszkiewicz * 0 | --- | --- | --- | +----+ 523418d036SArtur Paszkiewicz * 8 | -W- | -W- | --- | | pp | data_sector = 8 533418d036SArtur Paszkiewicz * 16 | -W- | -W- | --- | | pp | data_size = 3 * 2 * 4k 543418d036SArtur Paszkiewicz * 24 | -W- | -W- | --- | | pp | pp_size = 3 * 4k 553418d036SArtur Paszkiewicz * +-----+-----+-----+ +----+ 563418d036SArtur Paszkiewicz * 573418d036SArtur Paszkiewicz * data_sector is the first raid sector of the modified data, data_size is the 583418d036SArtur Paszkiewicz * total size of modified data and pp_size is the size of partial parity for 593418d036SArtur Paszkiewicz * this entry. Entries for full stripe writes contain no partial parity 603418d036SArtur Paszkiewicz * (pp_size = 0), they only mark the stripes for which parity should be 613418d036SArtur Paszkiewicz * recalculated after an unclean shutdown. Every entry holds a checksum of its 623418d036SArtur Paszkiewicz * partial parity, the header also has a checksum of the header itself. 633418d036SArtur Paszkiewicz * 643418d036SArtur Paszkiewicz * A write request is always logged to the PPL instance stored on the parity 653418d036SArtur Paszkiewicz * disk of the corresponding stripe. For each member disk there is one ppl_log 663418d036SArtur Paszkiewicz * used to handle logging for this disk, independently from others. They are 673418d036SArtur Paszkiewicz * grouped in child_logs array in struct ppl_conf, which is assigned to 683418d036SArtur Paszkiewicz * r5conf->log_private. 693418d036SArtur Paszkiewicz * 703418d036SArtur Paszkiewicz * ppl_io_unit represents a full PPL write, header_page contains the ppl_header. 713418d036SArtur Paszkiewicz * PPL entries for logged stripes are added in ppl_log_stripe(). A stripe_head 723418d036SArtur Paszkiewicz * can be appended to the last entry if it meets the conditions for a valid 733418d036SArtur Paszkiewicz * entry described above, otherwise a new entry is added. Checksums of entries 743418d036SArtur Paszkiewicz * are calculated incrementally as stripes containing partial parity are being 753418d036SArtur Paszkiewicz * added. ppl_submit_iounit() calculates the checksum of the header and submits 763418d036SArtur Paszkiewicz * a bio containing the header page and partial parity pages (sh->ppl_page) for 773418d036SArtur Paszkiewicz * all stripes of the io_unit. When the PPL write completes, the stripes 783418d036SArtur Paszkiewicz * associated with the io_unit are released and raid5d starts writing their data 793418d036SArtur Paszkiewicz * and parity. When all stripes are written, the io_unit is freed and the next 803418d036SArtur Paszkiewicz * can be submitted. 813418d036SArtur Paszkiewicz * 823418d036SArtur Paszkiewicz * An io_unit is used to gather stripes until it is submitted or becomes full 833418d036SArtur Paszkiewicz * (if the maximum number of entries or size of PPL is reached). Another io_unit 843418d036SArtur Paszkiewicz * can't be submitted until the previous has completed (PPL and stripe 853418d036SArtur Paszkiewicz * data+parity is written). The log->io_list tracks all io_units of a log 863418d036SArtur Paszkiewicz * (for a single member disk). New io_units are added to the end of the list 873418d036SArtur Paszkiewicz * and the first io_unit is submitted, if it is not submitted already. 883418d036SArtur Paszkiewicz * The current io_unit accepting new stripes is always at the end of the list. 891532d9e8STomasz Majchrzak * 901532d9e8STomasz Majchrzak * If write-back cache is enabled for any of the disks in the array, its data 911532d9e8STomasz Majchrzak * must be flushed before next io_unit is submitted. 923418d036SArtur Paszkiewicz */ 933418d036SArtur Paszkiewicz 94ddc08823SPawel Baldysiak #define PPL_SPACE_SIZE (128 * 1024) 95ddc08823SPawel Baldysiak 963418d036SArtur Paszkiewicz struct ppl_conf { 973418d036SArtur Paszkiewicz struct mddev *mddev; 983418d036SArtur Paszkiewicz 993418d036SArtur Paszkiewicz /* array of child logs, one for each raid disk */ 1003418d036SArtur Paszkiewicz struct ppl_log *child_logs; 1013418d036SArtur Paszkiewicz int count; 1023418d036SArtur Paszkiewicz 1033418d036SArtur Paszkiewicz int block_size; /* the logical block size used for data_sector 1043418d036SArtur Paszkiewicz * in ppl_header_entry */ 1053418d036SArtur Paszkiewicz u32 signature; /* raid array identifier */ 1063418d036SArtur Paszkiewicz atomic64_t seq; /* current log write sequence number */ 1073418d036SArtur Paszkiewicz 1083418d036SArtur Paszkiewicz struct kmem_cache *io_kc; 109afeee514SKent Overstreet mempool_t io_pool; 110afeee514SKent Overstreet struct bio_set bs; 111afeee514SKent Overstreet struct bio_set flush_bs; 1124536bf9bSArtur Paszkiewicz 1134536bf9bSArtur Paszkiewicz /* used only for recovery */ 1144536bf9bSArtur Paszkiewicz int recovered_entries; 1154536bf9bSArtur Paszkiewicz int mismatch_count; 11694568f64SArtur Paszkiewicz 11794568f64SArtur Paszkiewicz /* stripes to retry if failed to allocate io_unit */ 11894568f64SArtur Paszkiewicz struct list_head no_mem_stripes; 11994568f64SArtur Paszkiewicz spinlock_t no_mem_stripes_lock; 120a596d086SMariusz Dabrowski 121a596d086SMariusz Dabrowski unsigned short write_hint; 1223418d036SArtur Paszkiewicz }; 1233418d036SArtur Paszkiewicz 1243418d036SArtur Paszkiewicz struct ppl_log { 1253418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf; /* shared between all log instances */ 1263418d036SArtur Paszkiewicz 1273418d036SArtur Paszkiewicz struct md_rdev *rdev; /* array member disk associated with 1283418d036SArtur Paszkiewicz * this log instance */ 1293418d036SArtur Paszkiewicz struct mutex io_mutex; 1303418d036SArtur Paszkiewicz struct ppl_io_unit *current_io; /* current io_unit accepting new data 1313418d036SArtur Paszkiewicz * always at the end of io_list */ 1323418d036SArtur Paszkiewicz spinlock_t io_list_lock; 1333418d036SArtur Paszkiewicz struct list_head io_list; /* all io_units of this log */ 134ddc08823SPawel Baldysiak 135ddc08823SPawel Baldysiak sector_t next_io_sector; 136ddc08823SPawel Baldysiak unsigned int entry_space; 137ddc08823SPawel Baldysiak bool use_multippl; 1381532d9e8STomasz Majchrzak bool wb_cache_on; 1391532d9e8STomasz Majchrzak unsigned long disk_flush_bitmap; 1403418d036SArtur Paszkiewicz }; 1413418d036SArtur Paszkiewicz 1423418d036SArtur Paszkiewicz #define PPL_IO_INLINE_BVECS 32 1433418d036SArtur Paszkiewicz 1443418d036SArtur Paszkiewicz struct ppl_io_unit { 1453418d036SArtur Paszkiewicz struct ppl_log *log; 1463418d036SArtur Paszkiewicz 1473418d036SArtur Paszkiewicz struct page *header_page; /* for ppl_header */ 1483418d036SArtur Paszkiewicz 1493418d036SArtur Paszkiewicz unsigned int entries_count; /* number of entries in ppl_header */ 1503418d036SArtur Paszkiewicz unsigned int pp_size; /* total size current of partial parity */ 1513418d036SArtur Paszkiewicz 1523418d036SArtur Paszkiewicz u64 seq; /* sequence number of this log write */ 1533418d036SArtur Paszkiewicz struct list_head log_sibling; /* log->io_list */ 1543418d036SArtur Paszkiewicz 1553418d036SArtur Paszkiewicz struct list_head stripe_list; /* stripes added to the io_unit */ 1563418d036SArtur Paszkiewicz atomic_t pending_stripes; /* how many stripes not written to raid */ 1571532d9e8STomasz Majchrzak atomic_t pending_flushes; /* how many disk flushes are in progress */ 1583418d036SArtur Paszkiewicz 1593418d036SArtur Paszkiewicz bool submitted; /* true if write to log started */ 1603418d036SArtur Paszkiewicz 1613418d036SArtur Paszkiewicz /* inline bio and its biovec for submitting the iounit */ 1623418d036SArtur Paszkiewicz struct bio bio; 1633418d036SArtur Paszkiewicz struct bio_vec biovec[PPL_IO_INLINE_BVECS]; 1643418d036SArtur Paszkiewicz }; 1653418d036SArtur Paszkiewicz 1663418d036SArtur Paszkiewicz struct dma_async_tx_descriptor * 1673418d036SArtur Paszkiewicz ops_run_partial_parity(struct stripe_head *sh, struct raid5_percpu *percpu, 1683418d036SArtur Paszkiewicz struct dma_async_tx_descriptor *tx) 1693418d036SArtur Paszkiewicz { 1703418d036SArtur Paszkiewicz int disks = sh->disks; 171ae1713e2SArtur Paszkiewicz struct page **srcs = flex_array_get(percpu->scribble, 0); 1723418d036SArtur Paszkiewicz int count = 0, pd_idx = sh->pd_idx, i; 1733418d036SArtur Paszkiewicz struct async_submit_ctl submit; 1743418d036SArtur Paszkiewicz 1753418d036SArtur Paszkiewicz pr_debug("%s: stripe %llu\n", __func__, (unsigned long long)sh->sector); 1763418d036SArtur Paszkiewicz 1773418d036SArtur Paszkiewicz /* 1783418d036SArtur Paszkiewicz * Partial parity is the XOR of stripe data chunks that are not changed 1793418d036SArtur Paszkiewicz * during the write request. Depending on available data 1803418d036SArtur Paszkiewicz * (read-modify-write vs. reconstruct-write case) we calculate it 1813418d036SArtur Paszkiewicz * differently. 1823418d036SArtur Paszkiewicz */ 1833418d036SArtur Paszkiewicz if (sh->reconstruct_state == reconstruct_state_prexor_drain_run) { 184ae1713e2SArtur Paszkiewicz /* 185ae1713e2SArtur Paszkiewicz * rmw: xor old data and parity from updated disks 186ae1713e2SArtur Paszkiewicz * This is calculated earlier by ops_run_prexor5() so just copy 187ae1713e2SArtur Paszkiewicz * the parity dev page. 188ae1713e2SArtur Paszkiewicz */ 189ae1713e2SArtur Paszkiewicz srcs[count++] = sh->dev[pd_idx].page; 1903418d036SArtur Paszkiewicz } else if (sh->reconstruct_state == reconstruct_state_drain_run) { 1913418d036SArtur Paszkiewicz /* rcw: xor data from all not updated disks */ 1923418d036SArtur Paszkiewicz for (i = disks; i--;) { 1933418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i]; 1943418d036SArtur Paszkiewicz if (test_bit(R5_UPTODATE, &dev->flags)) 195ae1713e2SArtur Paszkiewicz srcs[count++] = dev->page; 1963418d036SArtur Paszkiewicz } 1973418d036SArtur Paszkiewicz } else { 1983418d036SArtur Paszkiewicz return tx; 1993418d036SArtur Paszkiewicz } 2003418d036SArtur Paszkiewicz 2013418d036SArtur Paszkiewicz init_async_submit(&submit, ASYNC_TX_FENCE|ASYNC_TX_XOR_ZERO_DST, tx, 2023418d036SArtur Paszkiewicz NULL, sh, flex_array_get(percpu->scribble, 0) 2033418d036SArtur Paszkiewicz + sizeof(struct page *) * (sh->disks + 2)); 2043418d036SArtur Paszkiewicz 2053418d036SArtur Paszkiewicz if (count == 1) 206ae1713e2SArtur Paszkiewicz tx = async_memcpy(sh->ppl_page, srcs[0], 0, 0, PAGE_SIZE, 2073418d036SArtur Paszkiewicz &submit); 2083418d036SArtur Paszkiewicz else 209ae1713e2SArtur Paszkiewicz tx = async_xor(sh->ppl_page, srcs, 0, count, PAGE_SIZE, 2103418d036SArtur Paszkiewicz &submit); 2113418d036SArtur Paszkiewicz 2123418d036SArtur Paszkiewicz return tx; 2133418d036SArtur Paszkiewicz } 2143418d036SArtur Paszkiewicz 215fcd403afSArtur Paszkiewicz static void *ppl_io_pool_alloc(gfp_t gfp_mask, void *pool_data) 216fcd403afSArtur Paszkiewicz { 217fcd403afSArtur Paszkiewicz struct kmem_cache *kc = pool_data; 218fcd403afSArtur Paszkiewicz struct ppl_io_unit *io; 219fcd403afSArtur Paszkiewicz 220fcd403afSArtur Paszkiewicz io = kmem_cache_alloc(kc, gfp_mask); 221fcd403afSArtur Paszkiewicz if (!io) 222fcd403afSArtur Paszkiewicz return NULL; 223fcd403afSArtur Paszkiewicz 224fcd403afSArtur Paszkiewicz io->header_page = alloc_page(gfp_mask); 225fcd403afSArtur Paszkiewicz if (!io->header_page) { 226fcd403afSArtur Paszkiewicz kmem_cache_free(kc, io); 227fcd403afSArtur Paszkiewicz return NULL; 228fcd403afSArtur Paszkiewicz } 229fcd403afSArtur Paszkiewicz 230fcd403afSArtur Paszkiewicz return io; 231fcd403afSArtur Paszkiewicz } 232fcd403afSArtur Paszkiewicz 233fcd403afSArtur Paszkiewicz static void ppl_io_pool_free(void *element, void *pool_data) 234fcd403afSArtur Paszkiewicz { 235fcd403afSArtur Paszkiewicz struct kmem_cache *kc = pool_data; 236fcd403afSArtur Paszkiewicz struct ppl_io_unit *io = element; 237fcd403afSArtur Paszkiewicz 238fcd403afSArtur Paszkiewicz __free_page(io->header_page); 239fcd403afSArtur Paszkiewicz kmem_cache_free(kc, io); 240fcd403afSArtur Paszkiewicz } 241fcd403afSArtur Paszkiewicz 2423418d036SArtur Paszkiewicz static struct ppl_io_unit *ppl_new_iounit(struct ppl_log *log, 2433418d036SArtur Paszkiewicz struct stripe_head *sh) 2443418d036SArtur Paszkiewicz { 2453418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 2463418d036SArtur Paszkiewicz struct ppl_io_unit *io; 2473418d036SArtur Paszkiewicz struct ppl_header *pplhdr; 248fcd403afSArtur Paszkiewicz struct page *header_page; 2493418d036SArtur Paszkiewicz 250afeee514SKent Overstreet io = mempool_alloc(&ppl_conf->io_pool, GFP_NOWAIT); 2513418d036SArtur Paszkiewicz if (!io) 2523418d036SArtur Paszkiewicz return NULL; 2533418d036SArtur Paszkiewicz 254fcd403afSArtur Paszkiewicz header_page = io->header_page; 2553418d036SArtur Paszkiewicz memset(io, 0, sizeof(*io)); 256fcd403afSArtur Paszkiewicz io->header_page = header_page; 257fcd403afSArtur Paszkiewicz 2583418d036SArtur Paszkiewicz io->log = log; 2593418d036SArtur Paszkiewicz INIT_LIST_HEAD(&io->log_sibling); 2603418d036SArtur Paszkiewicz INIT_LIST_HEAD(&io->stripe_list); 2613418d036SArtur Paszkiewicz atomic_set(&io->pending_stripes, 0); 2621532d9e8STomasz Majchrzak atomic_set(&io->pending_flushes, 0); 2633418d036SArtur Paszkiewicz bio_init(&io->bio, io->biovec, PPL_IO_INLINE_BVECS); 2643418d036SArtur Paszkiewicz 2653418d036SArtur Paszkiewicz pplhdr = page_address(io->header_page); 2663418d036SArtur Paszkiewicz clear_page(pplhdr); 2673418d036SArtur Paszkiewicz memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED); 2683418d036SArtur Paszkiewicz pplhdr->signature = cpu_to_le32(ppl_conf->signature); 2693418d036SArtur Paszkiewicz 2703418d036SArtur Paszkiewicz io->seq = atomic64_add_return(1, &ppl_conf->seq); 2713418d036SArtur Paszkiewicz pplhdr->generation = cpu_to_le64(io->seq); 2723418d036SArtur Paszkiewicz 2733418d036SArtur Paszkiewicz return io; 2743418d036SArtur Paszkiewicz } 2753418d036SArtur Paszkiewicz 2763418d036SArtur Paszkiewicz static int ppl_log_stripe(struct ppl_log *log, struct stripe_head *sh) 2773418d036SArtur Paszkiewicz { 2783418d036SArtur Paszkiewicz struct ppl_io_unit *io = log->current_io; 2793418d036SArtur Paszkiewicz struct ppl_header_entry *e = NULL; 2803418d036SArtur Paszkiewicz struct ppl_header *pplhdr; 2813418d036SArtur Paszkiewicz int i; 2823418d036SArtur Paszkiewicz sector_t data_sector = 0; 2833418d036SArtur Paszkiewicz int data_disks = 0; 2843418d036SArtur Paszkiewicz struct r5conf *conf = sh->raid_conf; 2853418d036SArtur Paszkiewicz 2863418d036SArtur Paszkiewicz pr_debug("%s: stripe: %llu\n", __func__, (unsigned long long)sh->sector); 2873418d036SArtur Paszkiewicz 2883418d036SArtur Paszkiewicz /* check if current io_unit is full */ 289ddc08823SPawel Baldysiak if (io && (io->pp_size == log->entry_space || 2903418d036SArtur Paszkiewicz io->entries_count == PPL_HDR_MAX_ENTRIES)) { 2913418d036SArtur Paszkiewicz pr_debug("%s: add io_unit blocked by seq: %llu\n", 2923418d036SArtur Paszkiewicz __func__, io->seq); 2933418d036SArtur Paszkiewicz io = NULL; 2943418d036SArtur Paszkiewicz } 2953418d036SArtur Paszkiewicz 2963418d036SArtur Paszkiewicz /* add a new unit if there is none or the current is full */ 2973418d036SArtur Paszkiewicz if (!io) { 2983418d036SArtur Paszkiewicz io = ppl_new_iounit(log, sh); 2993418d036SArtur Paszkiewicz if (!io) 3003418d036SArtur Paszkiewicz return -ENOMEM; 3013418d036SArtur Paszkiewicz spin_lock_irq(&log->io_list_lock); 3023418d036SArtur Paszkiewicz list_add_tail(&io->log_sibling, &log->io_list); 3033418d036SArtur Paszkiewicz spin_unlock_irq(&log->io_list_lock); 3043418d036SArtur Paszkiewicz 3053418d036SArtur Paszkiewicz log->current_io = io; 3063418d036SArtur Paszkiewicz } 3073418d036SArtur Paszkiewicz 3083418d036SArtur Paszkiewicz for (i = 0; i < sh->disks; i++) { 3093418d036SArtur Paszkiewicz struct r5dev *dev = &sh->dev[i]; 3103418d036SArtur Paszkiewicz 3113418d036SArtur Paszkiewicz if (i != sh->pd_idx && test_bit(R5_Wantwrite, &dev->flags)) { 3123418d036SArtur Paszkiewicz if (!data_disks || dev->sector < data_sector) 3133418d036SArtur Paszkiewicz data_sector = dev->sector; 3143418d036SArtur Paszkiewicz data_disks++; 3153418d036SArtur Paszkiewicz } 3163418d036SArtur Paszkiewicz } 3173418d036SArtur Paszkiewicz BUG_ON(!data_disks); 3183418d036SArtur Paszkiewicz 3193418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu data_sector: %llu data_disks: %d\n", __func__, 3203418d036SArtur Paszkiewicz io->seq, (unsigned long long)data_sector, data_disks); 3213418d036SArtur Paszkiewicz 3223418d036SArtur Paszkiewicz pplhdr = page_address(io->header_page); 3233418d036SArtur Paszkiewicz 3243418d036SArtur Paszkiewicz if (io->entries_count > 0) { 3253418d036SArtur Paszkiewicz struct ppl_header_entry *last = 3263418d036SArtur Paszkiewicz &pplhdr->entries[io->entries_count - 1]; 3273418d036SArtur Paszkiewicz struct stripe_head *sh_last = list_last_entry( 3283418d036SArtur Paszkiewicz &io->stripe_list, struct stripe_head, log_list); 3293418d036SArtur Paszkiewicz u64 data_sector_last = le64_to_cpu(last->data_sector); 3303418d036SArtur Paszkiewicz u32 data_size_last = le32_to_cpu(last->data_size); 3313418d036SArtur Paszkiewicz 3323418d036SArtur Paszkiewicz /* 3333418d036SArtur Paszkiewicz * Check if we can append the stripe to the last entry. It must 3343418d036SArtur Paszkiewicz * be just after the last logged stripe and write to the same 3353418d036SArtur Paszkiewicz * disks. Use bit shift and logarithm to avoid 64-bit division. 3363418d036SArtur Paszkiewicz */ 3373418d036SArtur Paszkiewicz if ((sh->sector == sh_last->sector + STRIPE_SECTORS) && 3383418d036SArtur Paszkiewicz (data_sector >> ilog2(conf->chunk_sectors) == 3393418d036SArtur Paszkiewicz data_sector_last >> ilog2(conf->chunk_sectors)) && 3403418d036SArtur Paszkiewicz ((data_sector - data_sector_last) * data_disks == 3413418d036SArtur Paszkiewicz data_size_last >> 9)) 3423418d036SArtur Paszkiewicz e = last; 3433418d036SArtur Paszkiewicz } 3443418d036SArtur Paszkiewicz 3453418d036SArtur Paszkiewicz if (!e) { 3463418d036SArtur Paszkiewicz e = &pplhdr->entries[io->entries_count++]; 3473418d036SArtur Paszkiewicz e->data_sector = cpu_to_le64(data_sector); 3483418d036SArtur Paszkiewicz e->parity_disk = cpu_to_le32(sh->pd_idx); 3493418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(~0); 3503418d036SArtur Paszkiewicz } 3513418d036SArtur Paszkiewicz 3523418d036SArtur Paszkiewicz le32_add_cpu(&e->data_size, data_disks << PAGE_SHIFT); 3533418d036SArtur Paszkiewicz 3543418d036SArtur Paszkiewicz /* don't write any PP if full stripe write */ 3553418d036SArtur Paszkiewicz if (!test_bit(STRIPE_FULL_WRITE, &sh->state)) { 3563418d036SArtur Paszkiewicz le32_add_cpu(&e->pp_size, PAGE_SIZE); 3573418d036SArtur Paszkiewicz io->pp_size += PAGE_SIZE; 3583418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(crc32c_le(le32_to_cpu(e->checksum), 3593418d036SArtur Paszkiewicz page_address(sh->ppl_page), 3603418d036SArtur Paszkiewicz PAGE_SIZE)); 3613418d036SArtur Paszkiewicz } 3623418d036SArtur Paszkiewicz 3633418d036SArtur Paszkiewicz list_add_tail(&sh->log_list, &io->stripe_list); 3643418d036SArtur Paszkiewicz atomic_inc(&io->pending_stripes); 3653418d036SArtur Paszkiewicz sh->ppl_io = io; 3663418d036SArtur Paszkiewicz 3673418d036SArtur Paszkiewicz return 0; 3683418d036SArtur Paszkiewicz } 3693418d036SArtur Paszkiewicz 3703418d036SArtur Paszkiewicz int ppl_write_stripe(struct r5conf *conf, struct stripe_head *sh) 3713418d036SArtur Paszkiewicz { 3723418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 3733418d036SArtur Paszkiewicz struct ppl_io_unit *io = sh->ppl_io; 3743418d036SArtur Paszkiewicz struct ppl_log *log; 3753418d036SArtur Paszkiewicz 376845b9e22SArtur Paszkiewicz if (io || test_bit(STRIPE_SYNCING, &sh->state) || !sh->ppl_page || 3773418d036SArtur Paszkiewicz !test_bit(R5_Wantwrite, &sh->dev[sh->pd_idx].flags) || 3783418d036SArtur Paszkiewicz !test_bit(R5_Insync, &sh->dev[sh->pd_idx].flags)) { 3793418d036SArtur Paszkiewicz clear_bit(STRIPE_LOG_TRAPPED, &sh->state); 3803418d036SArtur Paszkiewicz return -EAGAIN; 3813418d036SArtur Paszkiewicz } 3823418d036SArtur Paszkiewicz 3833418d036SArtur Paszkiewicz log = &ppl_conf->child_logs[sh->pd_idx]; 3843418d036SArtur Paszkiewicz 3853418d036SArtur Paszkiewicz mutex_lock(&log->io_mutex); 3863418d036SArtur Paszkiewicz 3873418d036SArtur Paszkiewicz if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) { 3883418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 3893418d036SArtur Paszkiewicz return -EAGAIN; 3903418d036SArtur Paszkiewicz } 3913418d036SArtur Paszkiewicz 3923418d036SArtur Paszkiewicz set_bit(STRIPE_LOG_TRAPPED, &sh->state); 3933418d036SArtur Paszkiewicz clear_bit(STRIPE_DELAYED, &sh->state); 3943418d036SArtur Paszkiewicz atomic_inc(&sh->count); 3953418d036SArtur Paszkiewicz 3963418d036SArtur Paszkiewicz if (ppl_log_stripe(log, sh)) { 39794568f64SArtur Paszkiewicz spin_lock_irq(&ppl_conf->no_mem_stripes_lock); 39894568f64SArtur Paszkiewicz list_add_tail(&sh->log_list, &ppl_conf->no_mem_stripes); 39994568f64SArtur Paszkiewicz spin_unlock_irq(&ppl_conf->no_mem_stripes_lock); 4003418d036SArtur Paszkiewicz } 4013418d036SArtur Paszkiewicz 4023418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 4033418d036SArtur Paszkiewicz 4043418d036SArtur Paszkiewicz return 0; 4053418d036SArtur Paszkiewicz } 4063418d036SArtur Paszkiewicz 4073418d036SArtur Paszkiewicz static void ppl_log_endio(struct bio *bio) 4083418d036SArtur Paszkiewicz { 4093418d036SArtur Paszkiewicz struct ppl_io_unit *io = bio->bi_private; 4103418d036SArtur Paszkiewicz struct ppl_log *log = io->log; 4113418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 4123418d036SArtur Paszkiewicz struct stripe_head *sh, *next; 4133418d036SArtur Paszkiewicz 4143418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu\n", __func__, io->seq); 4153418d036SArtur Paszkiewicz 4164e4cbee9SChristoph Hellwig if (bio->bi_status) 4173418d036SArtur Paszkiewicz md_error(ppl_conf->mddev, log->rdev); 4183418d036SArtur Paszkiewicz 4193418d036SArtur Paszkiewicz list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) { 4203418d036SArtur Paszkiewicz list_del_init(&sh->log_list); 4213418d036SArtur Paszkiewicz 4223418d036SArtur Paszkiewicz set_bit(STRIPE_HANDLE, &sh->state); 4233418d036SArtur Paszkiewicz raid5_release_stripe(sh); 4243418d036SArtur Paszkiewicz } 4253418d036SArtur Paszkiewicz } 4263418d036SArtur Paszkiewicz 4273418d036SArtur Paszkiewicz static void ppl_submit_iounit_bio(struct ppl_io_unit *io, struct bio *bio) 4283418d036SArtur Paszkiewicz { 4293418d036SArtur Paszkiewicz char b[BDEVNAME_SIZE]; 4303418d036SArtur Paszkiewicz 4313418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu size: %u sector: %llu dev: %s\n", 4323418d036SArtur Paszkiewicz __func__, io->seq, bio->bi_iter.bi_size, 4333418d036SArtur Paszkiewicz (unsigned long long)bio->bi_iter.bi_sector, 43474d46992SChristoph Hellwig bio_devname(bio, b)); 4353418d036SArtur Paszkiewicz 4363418d036SArtur Paszkiewicz submit_bio(bio); 4373418d036SArtur Paszkiewicz } 4383418d036SArtur Paszkiewicz 4393418d036SArtur Paszkiewicz static void ppl_submit_iounit(struct ppl_io_unit *io) 4403418d036SArtur Paszkiewicz { 4413418d036SArtur Paszkiewicz struct ppl_log *log = io->log; 4423418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 4433418d036SArtur Paszkiewicz struct ppl_header *pplhdr = page_address(io->header_page); 4443418d036SArtur Paszkiewicz struct bio *bio = &io->bio; 4453418d036SArtur Paszkiewicz struct stripe_head *sh; 4463418d036SArtur Paszkiewicz int i; 4473418d036SArtur Paszkiewicz 4486358c239SArtur Paszkiewicz bio->bi_private = io; 4496358c239SArtur Paszkiewicz 4506358c239SArtur Paszkiewicz if (!log->rdev || test_bit(Faulty, &log->rdev->flags)) { 4516358c239SArtur Paszkiewicz ppl_log_endio(bio); 4526358c239SArtur Paszkiewicz return; 4536358c239SArtur Paszkiewicz } 4546358c239SArtur Paszkiewicz 4553418d036SArtur Paszkiewicz for (i = 0; i < io->entries_count; i++) { 4563418d036SArtur Paszkiewicz struct ppl_header_entry *e = &pplhdr->entries[i]; 4573418d036SArtur Paszkiewicz 4583418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu entry: %d data_sector: %llu pp_size: %u data_size: %u\n", 4593418d036SArtur Paszkiewicz __func__, io->seq, i, le64_to_cpu(e->data_sector), 4603418d036SArtur Paszkiewicz le32_to_cpu(e->pp_size), le32_to_cpu(e->data_size)); 4613418d036SArtur Paszkiewicz 4623418d036SArtur Paszkiewicz e->data_sector = cpu_to_le64(le64_to_cpu(e->data_sector) >> 4633418d036SArtur Paszkiewicz ilog2(ppl_conf->block_size >> 9)); 4643418d036SArtur Paszkiewicz e->checksum = cpu_to_le32(~le32_to_cpu(e->checksum)); 4653418d036SArtur Paszkiewicz } 4663418d036SArtur Paszkiewicz 4673418d036SArtur Paszkiewicz pplhdr->entries_count = cpu_to_le32(io->entries_count); 4683418d036SArtur Paszkiewicz pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PPL_HEADER_SIZE)); 4693418d036SArtur Paszkiewicz 470ddc08823SPawel Baldysiak /* Rewind the buffer if current PPL is larger then remaining space */ 471ddc08823SPawel Baldysiak if (log->use_multippl && 472ddc08823SPawel Baldysiak log->rdev->ppl.sector + log->rdev->ppl.size - log->next_io_sector < 473ddc08823SPawel Baldysiak (PPL_HEADER_SIZE + io->pp_size) >> 9) 474ddc08823SPawel Baldysiak log->next_io_sector = log->rdev->ppl.sector; 475ddc08823SPawel Baldysiak 476ddc08823SPawel Baldysiak 4773418d036SArtur Paszkiewicz bio->bi_end_io = ppl_log_endio; 4783418d036SArtur Paszkiewicz bio->bi_opf = REQ_OP_WRITE | REQ_FUA; 47974d46992SChristoph Hellwig bio_set_dev(bio, log->rdev->bdev); 480ddc08823SPawel Baldysiak bio->bi_iter.bi_sector = log->next_io_sector; 4813418d036SArtur Paszkiewicz bio_add_page(bio, io->header_page, PAGE_SIZE, 0); 482a596d086SMariusz Dabrowski bio->bi_write_hint = ppl_conf->write_hint; 4833418d036SArtur Paszkiewicz 484ddc08823SPawel Baldysiak pr_debug("%s: log->current_io_sector: %llu\n", __func__, 485ddc08823SPawel Baldysiak (unsigned long long)log->next_io_sector); 486ddc08823SPawel Baldysiak 487ddc08823SPawel Baldysiak if (log->use_multippl) 488ddc08823SPawel Baldysiak log->next_io_sector += (PPL_HEADER_SIZE + io->pp_size) >> 9; 489ddc08823SPawel Baldysiak 4901532d9e8STomasz Majchrzak WARN_ON(log->disk_flush_bitmap != 0); 4911532d9e8STomasz Majchrzak 4923418d036SArtur Paszkiewicz list_for_each_entry(sh, &io->stripe_list, log_list) { 4931532d9e8STomasz Majchrzak for (i = 0; i < sh->disks; i++) { 4941532d9e8STomasz Majchrzak struct r5dev *dev = &sh->dev[i]; 4951532d9e8STomasz Majchrzak 4961532d9e8STomasz Majchrzak if ((ppl_conf->child_logs[i].wb_cache_on) && 4971532d9e8STomasz Majchrzak (test_bit(R5_Wantwrite, &dev->flags))) { 4981532d9e8STomasz Majchrzak set_bit(i, &log->disk_flush_bitmap); 4991532d9e8STomasz Majchrzak } 5001532d9e8STomasz Majchrzak } 5011532d9e8STomasz Majchrzak 5023418d036SArtur Paszkiewicz /* entries for full stripe writes have no partial parity */ 5033418d036SArtur Paszkiewicz if (test_bit(STRIPE_FULL_WRITE, &sh->state)) 5043418d036SArtur Paszkiewicz continue; 5053418d036SArtur Paszkiewicz 5063418d036SArtur Paszkiewicz if (!bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0)) { 5073418d036SArtur Paszkiewicz struct bio *prev = bio; 5083418d036SArtur Paszkiewicz 5093418d036SArtur Paszkiewicz bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_PAGES, 510afeee514SKent Overstreet &ppl_conf->bs); 5113418d036SArtur Paszkiewicz bio->bi_opf = prev->bi_opf; 512a596d086SMariusz Dabrowski bio->bi_write_hint = prev->bi_write_hint; 51374d46992SChristoph Hellwig bio_copy_dev(bio, prev); 5143418d036SArtur Paszkiewicz bio->bi_iter.bi_sector = bio_end_sector(prev); 5153418d036SArtur Paszkiewicz bio_add_page(bio, sh->ppl_page, PAGE_SIZE, 0); 5163418d036SArtur Paszkiewicz 5173418d036SArtur Paszkiewicz bio_chain(bio, prev); 5183418d036SArtur Paszkiewicz ppl_submit_iounit_bio(io, prev); 5193418d036SArtur Paszkiewicz } 5203418d036SArtur Paszkiewicz } 5213418d036SArtur Paszkiewicz 5223418d036SArtur Paszkiewicz ppl_submit_iounit_bio(io, bio); 5233418d036SArtur Paszkiewicz } 5243418d036SArtur Paszkiewicz 5253418d036SArtur Paszkiewicz static void ppl_submit_current_io(struct ppl_log *log) 5263418d036SArtur Paszkiewicz { 5273418d036SArtur Paszkiewicz struct ppl_io_unit *io; 5283418d036SArtur Paszkiewicz 5293418d036SArtur Paszkiewicz spin_lock_irq(&log->io_list_lock); 5303418d036SArtur Paszkiewicz 5313418d036SArtur Paszkiewicz io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit, 5323418d036SArtur Paszkiewicz log_sibling); 5333418d036SArtur Paszkiewicz if (io && io->submitted) 5343418d036SArtur Paszkiewicz io = NULL; 5353418d036SArtur Paszkiewicz 5363418d036SArtur Paszkiewicz spin_unlock_irq(&log->io_list_lock); 5373418d036SArtur Paszkiewicz 5383418d036SArtur Paszkiewicz if (io) { 5393418d036SArtur Paszkiewicz io->submitted = true; 5403418d036SArtur Paszkiewicz 5413418d036SArtur Paszkiewicz if (io == log->current_io) 5423418d036SArtur Paszkiewicz log->current_io = NULL; 5433418d036SArtur Paszkiewicz 5443418d036SArtur Paszkiewicz ppl_submit_iounit(io); 5453418d036SArtur Paszkiewicz } 5463418d036SArtur Paszkiewicz } 5473418d036SArtur Paszkiewicz 5483418d036SArtur Paszkiewicz void ppl_write_stripe_run(struct r5conf *conf) 5493418d036SArtur Paszkiewicz { 5503418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 5513418d036SArtur Paszkiewicz struct ppl_log *log; 5523418d036SArtur Paszkiewicz int i; 5533418d036SArtur Paszkiewicz 5543418d036SArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) { 5553418d036SArtur Paszkiewicz log = &ppl_conf->child_logs[i]; 5563418d036SArtur Paszkiewicz 5573418d036SArtur Paszkiewicz mutex_lock(&log->io_mutex); 5583418d036SArtur Paszkiewicz ppl_submit_current_io(log); 5593418d036SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 5603418d036SArtur Paszkiewicz } 5613418d036SArtur Paszkiewicz } 5623418d036SArtur Paszkiewicz 5633418d036SArtur Paszkiewicz static void ppl_io_unit_finished(struct ppl_io_unit *io) 5643418d036SArtur Paszkiewicz { 5653418d036SArtur Paszkiewicz struct ppl_log *log = io->log; 56694568f64SArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 5671532d9e8STomasz Majchrzak struct r5conf *conf = ppl_conf->mddev->private; 5683418d036SArtur Paszkiewicz unsigned long flags; 5693418d036SArtur Paszkiewicz 5703418d036SArtur Paszkiewicz pr_debug("%s: seq: %llu\n", __func__, io->seq); 5713418d036SArtur Paszkiewicz 57294568f64SArtur Paszkiewicz local_irq_save(flags); 5733418d036SArtur Paszkiewicz 57494568f64SArtur Paszkiewicz spin_lock(&log->io_list_lock); 5753418d036SArtur Paszkiewicz list_del(&io->log_sibling); 57694568f64SArtur Paszkiewicz spin_unlock(&log->io_list_lock); 5773418d036SArtur Paszkiewicz 578afeee514SKent Overstreet mempool_free(io, &ppl_conf->io_pool); 57994568f64SArtur Paszkiewicz 58094568f64SArtur Paszkiewicz spin_lock(&ppl_conf->no_mem_stripes_lock); 58194568f64SArtur Paszkiewicz if (!list_empty(&ppl_conf->no_mem_stripes)) { 58294568f64SArtur Paszkiewicz struct stripe_head *sh; 58394568f64SArtur Paszkiewicz 58494568f64SArtur Paszkiewicz sh = list_first_entry(&ppl_conf->no_mem_stripes, 58594568f64SArtur Paszkiewicz struct stripe_head, log_list); 5863418d036SArtur Paszkiewicz list_del_init(&sh->log_list); 5873418d036SArtur Paszkiewicz set_bit(STRIPE_HANDLE, &sh->state); 5883418d036SArtur Paszkiewicz raid5_release_stripe(sh); 5893418d036SArtur Paszkiewicz } 59094568f64SArtur Paszkiewicz spin_unlock(&ppl_conf->no_mem_stripes_lock); 5913418d036SArtur Paszkiewicz 59294568f64SArtur Paszkiewicz local_irq_restore(flags); 5931532d9e8STomasz Majchrzak 5941532d9e8STomasz Majchrzak wake_up(&conf->wait_for_quiescent); 5951532d9e8STomasz Majchrzak } 5961532d9e8STomasz Majchrzak 5971532d9e8STomasz Majchrzak static void ppl_flush_endio(struct bio *bio) 5981532d9e8STomasz Majchrzak { 5991532d9e8STomasz Majchrzak struct ppl_io_unit *io = bio->bi_private; 6001532d9e8STomasz Majchrzak struct ppl_log *log = io->log; 6011532d9e8STomasz Majchrzak struct ppl_conf *ppl_conf = log->ppl_conf; 6021532d9e8STomasz Majchrzak struct r5conf *conf = ppl_conf->mddev->private; 6031532d9e8STomasz Majchrzak char b[BDEVNAME_SIZE]; 6041532d9e8STomasz Majchrzak 6051532d9e8STomasz Majchrzak pr_debug("%s: dev: %s\n", __func__, bio_devname(bio, b)); 6061532d9e8STomasz Majchrzak 6071532d9e8STomasz Majchrzak if (bio->bi_status) { 6081532d9e8STomasz Majchrzak struct md_rdev *rdev; 6091532d9e8STomasz Majchrzak 6101532d9e8STomasz Majchrzak rcu_read_lock(); 6111532d9e8STomasz Majchrzak rdev = md_find_rdev_rcu(conf->mddev, bio_dev(bio)); 6121532d9e8STomasz Majchrzak if (rdev) 6131532d9e8STomasz Majchrzak md_error(rdev->mddev, rdev); 6141532d9e8STomasz Majchrzak rcu_read_unlock(); 6151532d9e8STomasz Majchrzak } 6161532d9e8STomasz Majchrzak 6171532d9e8STomasz Majchrzak bio_put(bio); 6181532d9e8STomasz Majchrzak 6191532d9e8STomasz Majchrzak if (atomic_dec_and_test(&io->pending_flushes)) { 6201532d9e8STomasz Majchrzak ppl_io_unit_finished(io); 6211532d9e8STomasz Majchrzak md_wakeup_thread(conf->mddev->thread); 6221532d9e8STomasz Majchrzak } 6231532d9e8STomasz Majchrzak } 6241532d9e8STomasz Majchrzak 6251532d9e8STomasz Majchrzak static void ppl_do_flush(struct ppl_io_unit *io) 6261532d9e8STomasz Majchrzak { 6271532d9e8STomasz Majchrzak struct ppl_log *log = io->log; 6281532d9e8STomasz Majchrzak struct ppl_conf *ppl_conf = log->ppl_conf; 6291532d9e8STomasz Majchrzak struct r5conf *conf = ppl_conf->mddev->private; 6301532d9e8STomasz Majchrzak int raid_disks = conf->raid_disks; 6311532d9e8STomasz Majchrzak int flushed_disks = 0; 6321532d9e8STomasz Majchrzak int i; 6331532d9e8STomasz Majchrzak 6341532d9e8STomasz Majchrzak atomic_set(&io->pending_flushes, raid_disks); 6351532d9e8STomasz Majchrzak 6361532d9e8STomasz Majchrzak for_each_set_bit(i, &log->disk_flush_bitmap, raid_disks) { 6371532d9e8STomasz Majchrzak struct md_rdev *rdev; 6381532d9e8STomasz Majchrzak struct block_device *bdev = NULL; 6391532d9e8STomasz Majchrzak 6401532d9e8STomasz Majchrzak rcu_read_lock(); 6411532d9e8STomasz Majchrzak rdev = rcu_dereference(conf->disks[i].rdev); 6421532d9e8STomasz Majchrzak if (rdev && !test_bit(Faulty, &rdev->flags)) 6431532d9e8STomasz Majchrzak bdev = rdev->bdev; 6441532d9e8STomasz Majchrzak rcu_read_unlock(); 6451532d9e8STomasz Majchrzak 6461532d9e8STomasz Majchrzak if (bdev) { 6471532d9e8STomasz Majchrzak struct bio *bio; 6481532d9e8STomasz Majchrzak char b[BDEVNAME_SIZE]; 6491532d9e8STomasz Majchrzak 650afeee514SKent Overstreet bio = bio_alloc_bioset(GFP_NOIO, 0, &ppl_conf->flush_bs); 6511532d9e8STomasz Majchrzak bio_set_dev(bio, bdev); 6521532d9e8STomasz Majchrzak bio->bi_private = io; 6531532d9e8STomasz Majchrzak bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; 6541532d9e8STomasz Majchrzak bio->bi_end_io = ppl_flush_endio; 6551532d9e8STomasz Majchrzak 6561532d9e8STomasz Majchrzak pr_debug("%s: dev: %s\n", __func__, 6571532d9e8STomasz Majchrzak bio_devname(bio, b)); 6581532d9e8STomasz Majchrzak 6591532d9e8STomasz Majchrzak submit_bio(bio); 6601532d9e8STomasz Majchrzak flushed_disks++; 6611532d9e8STomasz Majchrzak } 6621532d9e8STomasz Majchrzak } 6631532d9e8STomasz Majchrzak 6641532d9e8STomasz Majchrzak log->disk_flush_bitmap = 0; 6651532d9e8STomasz Majchrzak 6661532d9e8STomasz Majchrzak for (i = flushed_disks ; i < raid_disks; i++) { 6671532d9e8STomasz Majchrzak if (atomic_dec_and_test(&io->pending_flushes)) 6681532d9e8STomasz Majchrzak ppl_io_unit_finished(io); 6691532d9e8STomasz Majchrzak } 6701532d9e8STomasz Majchrzak } 6711532d9e8STomasz Majchrzak 6721532d9e8STomasz Majchrzak static inline bool ppl_no_io_unit_submitted(struct r5conf *conf, 6731532d9e8STomasz Majchrzak struct ppl_log *log) 6741532d9e8STomasz Majchrzak { 6751532d9e8STomasz Majchrzak struct ppl_io_unit *io; 6761532d9e8STomasz Majchrzak 6771532d9e8STomasz Majchrzak io = list_first_entry_or_null(&log->io_list, struct ppl_io_unit, 6781532d9e8STomasz Majchrzak log_sibling); 6791532d9e8STomasz Majchrzak 6801532d9e8STomasz Majchrzak return !io || !io->submitted; 6811532d9e8STomasz Majchrzak } 6821532d9e8STomasz Majchrzak 6831532d9e8STomasz Majchrzak void ppl_quiesce(struct r5conf *conf, int quiesce) 6841532d9e8STomasz Majchrzak { 6851532d9e8STomasz Majchrzak struct ppl_conf *ppl_conf = conf->log_private; 6861532d9e8STomasz Majchrzak int i; 6871532d9e8STomasz Majchrzak 6881532d9e8STomasz Majchrzak if (quiesce) { 6891532d9e8STomasz Majchrzak for (i = 0; i < ppl_conf->count; i++) { 6901532d9e8STomasz Majchrzak struct ppl_log *log = &ppl_conf->child_logs[i]; 6911532d9e8STomasz Majchrzak 6921532d9e8STomasz Majchrzak spin_lock_irq(&log->io_list_lock); 6931532d9e8STomasz Majchrzak wait_event_lock_irq(conf->wait_for_quiescent, 6941532d9e8STomasz Majchrzak ppl_no_io_unit_submitted(conf, log), 6951532d9e8STomasz Majchrzak log->io_list_lock); 6961532d9e8STomasz Majchrzak spin_unlock_irq(&log->io_list_lock); 6971532d9e8STomasz Majchrzak } 6981532d9e8STomasz Majchrzak } 6993418d036SArtur Paszkiewicz } 7003418d036SArtur Paszkiewicz 701f4bc0c81SArtur Paszkiewicz int ppl_handle_flush_request(struct r5l_log *log, struct bio *bio) 702f4bc0c81SArtur Paszkiewicz { 703f4bc0c81SArtur Paszkiewicz if (bio->bi_iter.bi_size == 0) { 704f4bc0c81SArtur Paszkiewicz bio_endio(bio); 705f4bc0c81SArtur Paszkiewicz return 0; 706f4bc0c81SArtur Paszkiewicz } 707f4bc0c81SArtur Paszkiewicz bio->bi_opf &= ~REQ_PREFLUSH; 708f4bc0c81SArtur Paszkiewicz return -EAGAIN; 709f4bc0c81SArtur Paszkiewicz } 710f4bc0c81SArtur Paszkiewicz 7113418d036SArtur Paszkiewicz void ppl_stripe_write_finished(struct stripe_head *sh) 7123418d036SArtur Paszkiewicz { 7133418d036SArtur Paszkiewicz struct ppl_io_unit *io; 7143418d036SArtur Paszkiewicz 7153418d036SArtur Paszkiewicz io = sh->ppl_io; 7163418d036SArtur Paszkiewicz sh->ppl_io = NULL; 7173418d036SArtur Paszkiewicz 7181532d9e8STomasz Majchrzak if (io && atomic_dec_and_test(&io->pending_stripes)) { 7191532d9e8STomasz Majchrzak if (io->log->disk_flush_bitmap) 7201532d9e8STomasz Majchrzak ppl_do_flush(io); 7211532d9e8STomasz Majchrzak else 7223418d036SArtur Paszkiewicz ppl_io_unit_finished(io); 7233418d036SArtur Paszkiewicz } 7241532d9e8STomasz Majchrzak } 7253418d036SArtur Paszkiewicz 7264536bf9bSArtur Paszkiewicz static void ppl_xor(int size, struct page *page1, struct page *page2) 7274536bf9bSArtur Paszkiewicz { 7284536bf9bSArtur Paszkiewicz struct async_submit_ctl submit; 7294536bf9bSArtur Paszkiewicz struct dma_async_tx_descriptor *tx; 7304536bf9bSArtur Paszkiewicz struct page *xor_srcs[] = { page1, page2 }; 7314536bf9bSArtur Paszkiewicz 7324536bf9bSArtur Paszkiewicz init_async_submit(&submit, ASYNC_TX_ACK|ASYNC_TX_XOR_DROP_DST, 7334536bf9bSArtur Paszkiewicz NULL, NULL, NULL, NULL); 7344536bf9bSArtur Paszkiewicz tx = async_xor(page1, xor_srcs, 0, 2, size, &submit); 7354536bf9bSArtur Paszkiewicz 7364536bf9bSArtur Paszkiewicz async_tx_quiesce(&tx); 7374536bf9bSArtur Paszkiewicz } 7384536bf9bSArtur Paszkiewicz 7394536bf9bSArtur Paszkiewicz /* 7404536bf9bSArtur Paszkiewicz * PPL recovery strategy: xor partial parity and data from all modified data 7414536bf9bSArtur Paszkiewicz * disks within a stripe and write the result as the new stripe parity. If all 7424536bf9bSArtur Paszkiewicz * stripe data disks are modified (full stripe write), no partial parity is 7434536bf9bSArtur Paszkiewicz * available, so just xor the data disks. 7444536bf9bSArtur Paszkiewicz * 7454536bf9bSArtur Paszkiewicz * Recovery of a PPL entry shall occur only if all modified data disks are 7464536bf9bSArtur Paszkiewicz * available and read from all of them succeeds. 7474536bf9bSArtur Paszkiewicz * 7484536bf9bSArtur Paszkiewicz * A PPL entry applies to a stripe, partial parity size for an entry is at most 7494536bf9bSArtur Paszkiewicz * the size of the chunk. Examples of possible cases for a single entry: 7504536bf9bSArtur Paszkiewicz * 7514536bf9bSArtur Paszkiewicz * case 0: single data disk write: 7524536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 7534536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 7544536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 7554536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | -> | data1 ^ pp | 7564536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | -> | data1 ^ pp | 7574536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 7584536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 7594536bf9bSArtur Paszkiewicz * pp_size = data_size 7604536bf9bSArtur Paszkiewicz * 7614536bf9bSArtur Paszkiewicz * case 1: more than one data disk write: 7624536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 7634536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 7644536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 7654536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp | 7664536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | -> | data0 ^ data1 ^ pp | 7674536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | +----+ | (no change) | 7684536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 7694536bf9bSArtur Paszkiewicz * pp_size = data_size / modified_data_disks 7704536bf9bSArtur Paszkiewicz * 7714536bf9bSArtur Paszkiewicz * case 2: write to all data disks (also full stripe write): 7724536bf9bSArtur Paszkiewicz * data0 data1 data2 parity 7734536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 7744536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | (no change) | 7754536bf9bSArtur Paszkiewicz * | -data- | -data- | -data- | --------> | xor all data | 7764536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | --------> | (no change) | 7774536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | (no change) | 7784536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +--------------------+ 7794536bf9bSArtur Paszkiewicz * pp_size = 0 7804536bf9bSArtur Paszkiewicz * 7814536bf9bSArtur Paszkiewicz * The following cases are possible only in other implementations. The recovery 7824536bf9bSArtur Paszkiewicz * code can handle them, but they are not generated at runtime because they can 7834536bf9bSArtur Paszkiewicz * be reduced to cases 0, 1 and 2: 7844536bf9bSArtur Paszkiewicz * 7854536bf9bSArtur Paszkiewicz * case 3: 7864536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 7874536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 7884536bf9bSArtur Paszkiewicz * | ------ | -data- | -data- | | pp | | data1 ^ data2 ^ pp | 7894536bf9bSArtur Paszkiewicz * | ------ | -data- | -data- | | pp | -> | data1 ^ data2 ^ pp | 7904536bf9bSArtur Paszkiewicz * | -data- | -data- | -data- | | -- | -> | xor all data | 7914536bf9bSArtur Paszkiewicz * | -data- | -data- | ------ | | pp | | data0 ^ data1 ^ pp | 7924536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 7934536bf9bSArtur Paszkiewicz * pp_size = chunk_size 7944536bf9bSArtur Paszkiewicz * 7954536bf9bSArtur Paszkiewicz * case 4: 7964536bf9bSArtur Paszkiewicz * data0 data1 data2 ppl parity 7974536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 7984536bf9bSArtur Paszkiewicz * | ------ | -data- | ------ | | pp | | data1 ^ pp | 7994536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | -- | -> | (no change) | 8004536bf9bSArtur Paszkiewicz * | ------ | ------ | ------ | | -- | -> | (no change) | 8014536bf9bSArtur Paszkiewicz * | -data- | ------ | ------ | | pp | | data0 ^ pp | 8024536bf9bSArtur Paszkiewicz * +--------+--------+--------+ +----+ +--------------------+ 8034536bf9bSArtur Paszkiewicz * pp_size = chunk_size 8044536bf9bSArtur Paszkiewicz */ 8054536bf9bSArtur Paszkiewicz static int ppl_recover_entry(struct ppl_log *log, struct ppl_header_entry *e, 8064536bf9bSArtur Paszkiewicz sector_t ppl_sector) 8074536bf9bSArtur Paszkiewicz { 8084536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 8094536bf9bSArtur Paszkiewicz struct mddev *mddev = ppl_conf->mddev; 8104536bf9bSArtur Paszkiewicz struct r5conf *conf = mddev->private; 8114536bf9bSArtur Paszkiewicz int block_size = ppl_conf->block_size; 8124536bf9bSArtur Paszkiewicz struct page *page1; 8134536bf9bSArtur Paszkiewicz struct page *page2; 8144536bf9bSArtur Paszkiewicz sector_t r_sector_first; 8154536bf9bSArtur Paszkiewicz sector_t r_sector_last; 8164536bf9bSArtur Paszkiewicz int strip_sectors; 8174536bf9bSArtur Paszkiewicz int data_disks; 8184536bf9bSArtur Paszkiewicz int i; 8194536bf9bSArtur Paszkiewicz int ret = 0; 8204536bf9bSArtur Paszkiewicz char b[BDEVNAME_SIZE]; 8214536bf9bSArtur Paszkiewicz unsigned int pp_size = le32_to_cpu(e->pp_size); 8224536bf9bSArtur Paszkiewicz unsigned int data_size = le32_to_cpu(e->data_size); 8234536bf9bSArtur Paszkiewicz 8244536bf9bSArtur Paszkiewicz page1 = alloc_page(GFP_KERNEL); 8254536bf9bSArtur Paszkiewicz page2 = alloc_page(GFP_KERNEL); 8264536bf9bSArtur Paszkiewicz 8274536bf9bSArtur Paszkiewicz if (!page1 || !page2) { 8284536bf9bSArtur Paszkiewicz ret = -ENOMEM; 8294536bf9bSArtur Paszkiewicz goto out; 8304536bf9bSArtur Paszkiewicz } 8314536bf9bSArtur Paszkiewicz 8324536bf9bSArtur Paszkiewicz r_sector_first = le64_to_cpu(e->data_sector) * (block_size >> 9); 8334536bf9bSArtur Paszkiewicz 8344536bf9bSArtur Paszkiewicz if ((pp_size >> 9) < conf->chunk_sectors) { 8354536bf9bSArtur Paszkiewicz if (pp_size > 0) { 8364536bf9bSArtur Paszkiewicz data_disks = data_size / pp_size; 8374536bf9bSArtur Paszkiewicz strip_sectors = pp_size >> 9; 8384536bf9bSArtur Paszkiewicz } else { 8394536bf9bSArtur Paszkiewicz data_disks = conf->raid_disks - conf->max_degraded; 8404536bf9bSArtur Paszkiewicz strip_sectors = (data_size >> 9) / data_disks; 8414536bf9bSArtur Paszkiewicz } 8424536bf9bSArtur Paszkiewicz r_sector_last = r_sector_first + 8434536bf9bSArtur Paszkiewicz (data_disks - 1) * conf->chunk_sectors + 8444536bf9bSArtur Paszkiewicz strip_sectors; 8454536bf9bSArtur Paszkiewicz } else { 8464536bf9bSArtur Paszkiewicz data_disks = conf->raid_disks - conf->max_degraded; 8474536bf9bSArtur Paszkiewicz strip_sectors = conf->chunk_sectors; 8484536bf9bSArtur Paszkiewicz r_sector_last = r_sector_first + (data_size >> 9); 8494536bf9bSArtur Paszkiewicz } 8504536bf9bSArtur Paszkiewicz 8514536bf9bSArtur Paszkiewicz pr_debug("%s: array sector first: %llu last: %llu\n", __func__, 8524536bf9bSArtur Paszkiewicz (unsigned long long)r_sector_first, 8534536bf9bSArtur Paszkiewicz (unsigned long long)r_sector_last); 8544536bf9bSArtur Paszkiewicz 8554536bf9bSArtur Paszkiewicz /* if start and end is 4k aligned, use a 4k block */ 8564536bf9bSArtur Paszkiewicz if (block_size == 512 && 8574536bf9bSArtur Paszkiewicz (r_sector_first & (STRIPE_SECTORS - 1)) == 0 && 8584536bf9bSArtur Paszkiewicz (r_sector_last & (STRIPE_SECTORS - 1)) == 0) 8594536bf9bSArtur Paszkiewicz block_size = STRIPE_SIZE; 8604536bf9bSArtur Paszkiewicz 8614536bf9bSArtur Paszkiewicz /* iterate through blocks in strip */ 8624536bf9bSArtur Paszkiewicz for (i = 0; i < strip_sectors; i += (block_size >> 9)) { 8634536bf9bSArtur Paszkiewicz bool update_parity = false; 8644536bf9bSArtur Paszkiewicz sector_t parity_sector; 8654536bf9bSArtur Paszkiewicz struct md_rdev *parity_rdev; 8664536bf9bSArtur Paszkiewicz struct stripe_head sh; 8674536bf9bSArtur Paszkiewicz int disk; 8684536bf9bSArtur Paszkiewicz int indent = 0; 8694536bf9bSArtur Paszkiewicz 8704536bf9bSArtur Paszkiewicz pr_debug("%s:%*s iter %d start\n", __func__, indent, "", i); 8714536bf9bSArtur Paszkiewicz indent += 2; 8724536bf9bSArtur Paszkiewicz 8734536bf9bSArtur Paszkiewicz memset(page_address(page1), 0, PAGE_SIZE); 8744536bf9bSArtur Paszkiewicz 8754536bf9bSArtur Paszkiewicz /* iterate through data member disks */ 8764536bf9bSArtur Paszkiewicz for (disk = 0; disk < data_disks; disk++) { 8774536bf9bSArtur Paszkiewicz int dd_idx; 8784536bf9bSArtur Paszkiewicz struct md_rdev *rdev; 8794536bf9bSArtur Paszkiewicz sector_t sector; 8804536bf9bSArtur Paszkiewicz sector_t r_sector = r_sector_first + i + 8814536bf9bSArtur Paszkiewicz (disk * conf->chunk_sectors); 8824536bf9bSArtur Paszkiewicz 8834536bf9bSArtur Paszkiewicz pr_debug("%s:%*s data member disk %d start\n", 8844536bf9bSArtur Paszkiewicz __func__, indent, "", disk); 8854536bf9bSArtur Paszkiewicz indent += 2; 8864536bf9bSArtur Paszkiewicz 8874536bf9bSArtur Paszkiewicz if (r_sector >= r_sector_last) { 8884536bf9bSArtur Paszkiewicz pr_debug("%s:%*s array sector %llu doesn't need parity update\n", 8894536bf9bSArtur Paszkiewicz __func__, indent, "", 8904536bf9bSArtur Paszkiewicz (unsigned long long)r_sector); 8914536bf9bSArtur Paszkiewicz indent -= 2; 8924536bf9bSArtur Paszkiewicz continue; 8934536bf9bSArtur Paszkiewicz } 8944536bf9bSArtur Paszkiewicz 8954536bf9bSArtur Paszkiewicz update_parity = true; 8964536bf9bSArtur Paszkiewicz 8974536bf9bSArtur Paszkiewicz /* map raid sector to member disk */ 8984536bf9bSArtur Paszkiewicz sector = raid5_compute_sector(conf, r_sector, 0, 8994536bf9bSArtur Paszkiewicz &dd_idx, NULL); 9004536bf9bSArtur Paszkiewicz pr_debug("%s:%*s processing array sector %llu => data member disk %d, sector %llu\n", 9014536bf9bSArtur Paszkiewicz __func__, indent, "", 9024536bf9bSArtur Paszkiewicz (unsigned long long)r_sector, dd_idx, 9034536bf9bSArtur Paszkiewicz (unsigned long long)sector); 9044536bf9bSArtur Paszkiewicz 9054536bf9bSArtur Paszkiewicz rdev = conf->disks[dd_idx].rdev; 90607719ff7SArtur Paszkiewicz if (!rdev || (!test_bit(In_sync, &rdev->flags) && 90707719ff7SArtur Paszkiewicz sector >= rdev->recovery_offset)) { 9084536bf9bSArtur Paszkiewicz pr_debug("%s:%*s data member disk %d missing\n", 9094536bf9bSArtur Paszkiewicz __func__, indent, "", dd_idx); 9104536bf9bSArtur Paszkiewicz update_parity = false; 9114536bf9bSArtur Paszkiewicz break; 9124536bf9bSArtur Paszkiewicz } 9134536bf9bSArtur Paszkiewicz 9144536bf9bSArtur Paszkiewicz pr_debug("%s:%*s reading data member disk %s sector %llu\n", 9154536bf9bSArtur Paszkiewicz __func__, indent, "", bdevname(rdev->bdev, b), 9164536bf9bSArtur Paszkiewicz (unsigned long long)sector); 9174536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, sector, block_size, page2, 9184536bf9bSArtur Paszkiewicz REQ_OP_READ, 0, false)) { 9194536bf9bSArtur Paszkiewicz md_error(mddev, rdev); 9204536bf9bSArtur Paszkiewicz pr_debug("%s:%*s read failed!\n", __func__, 9214536bf9bSArtur Paszkiewicz indent, ""); 9224536bf9bSArtur Paszkiewicz ret = -EIO; 9234536bf9bSArtur Paszkiewicz goto out; 9244536bf9bSArtur Paszkiewicz } 9254536bf9bSArtur Paszkiewicz 9264536bf9bSArtur Paszkiewicz ppl_xor(block_size, page1, page2); 9274536bf9bSArtur Paszkiewicz 9284536bf9bSArtur Paszkiewicz indent -= 2; 9294536bf9bSArtur Paszkiewicz } 9304536bf9bSArtur Paszkiewicz 9314536bf9bSArtur Paszkiewicz if (!update_parity) 9324536bf9bSArtur Paszkiewicz continue; 9334536bf9bSArtur Paszkiewicz 9344536bf9bSArtur Paszkiewicz if (pp_size > 0) { 9354536bf9bSArtur Paszkiewicz pr_debug("%s:%*s reading pp disk sector %llu\n", 9364536bf9bSArtur Paszkiewicz __func__, indent, "", 9374536bf9bSArtur Paszkiewicz (unsigned long long)(ppl_sector + i)); 9384536bf9bSArtur Paszkiewicz if (!sync_page_io(log->rdev, 9394536bf9bSArtur Paszkiewicz ppl_sector - log->rdev->data_offset + i, 9404536bf9bSArtur Paszkiewicz block_size, page2, REQ_OP_READ, 0, 9414536bf9bSArtur Paszkiewicz false)) { 9424536bf9bSArtur Paszkiewicz pr_debug("%s:%*s read failed!\n", __func__, 9434536bf9bSArtur Paszkiewicz indent, ""); 9444536bf9bSArtur Paszkiewicz md_error(mddev, log->rdev); 9454536bf9bSArtur Paszkiewicz ret = -EIO; 9464536bf9bSArtur Paszkiewicz goto out; 9474536bf9bSArtur Paszkiewicz } 9484536bf9bSArtur Paszkiewicz 9494536bf9bSArtur Paszkiewicz ppl_xor(block_size, page1, page2); 9504536bf9bSArtur Paszkiewicz } 9514536bf9bSArtur Paszkiewicz 9524536bf9bSArtur Paszkiewicz /* map raid sector to parity disk */ 9534536bf9bSArtur Paszkiewicz parity_sector = raid5_compute_sector(conf, r_sector_first + i, 9544536bf9bSArtur Paszkiewicz 0, &disk, &sh); 9554536bf9bSArtur Paszkiewicz BUG_ON(sh.pd_idx != le32_to_cpu(e->parity_disk)); 9564536bf9bSArtur Paszkiewicz parity_rdev = conf->disks[sh.pd_idx].rdev; 9574536bf9bSArtur Paszkiewicz 9584536bf9bSArtur Paszkiewicz BUG_ON(parity_rdev->bdev->bd_dev != log->rdev->bdev->bd_dev); 9594536bf9bSArtur Paszkiewicz pr_debug("%s:%*s write parity at sector %llu, disk %s\n", 9604536bf9bSArtur Paszkiewicz __func__, indent, "", 9614536bf9bSArtur Paszkiewicz (unsigned long long)parity_sector, 9624536bf9bSArtur Paszkiewicz bdevname(parity_rdev->bdev, b)); 9634536bf9bSArtur Paszkiewicz if (!sync_page_io(parity_rdev, parity_sector, block_size, 9644536bf9bSArtur Paszkiewicz page1, REQ_OP_WRITE, 0, false)) { 9654536bf9bSArtur Paszkiewicz pr_debug("%s:%*s parity write error!\n", __func__, 9664536bf9bSArtur Paszkiewicz indent, ""); 9674536bf9bSArtur Paszkiewicz md_error(mddev, parity_rdev); 9684536bf9bSArtur Paszkiewicz ret = -EIO; 9694536bf9bSArtur Paszkiewicz goto out; 9704536bf9bSArtur Paszkiewicz } 9714536bf9bSArtur Paszkiewicz } 9724536bf9bSArtur Paszkiewicz out: 9734536bf9bSArtur Paszkiewicz if (page1) 9744536bf9bSArtur Paszkiewicz __free_page(page1); 9754536bf9bSArtur Paszkiewicz if (page2) 9764536bf9bSArtur Paszkiewicz __free_page(page2); 9774536bf9bSArtur Paszkiewicz return ret; 9784536bf9bSArtur Paszkiewicz } 9794536bf9bSArtur Paszkiewicz 980675dc2ccSPawel Baldysiak static int ppl_recover(struct ppl_log *log, struct ppl_header *pplhdr, 981675dc2ccSPawel Baldysiak sector_t offset) 9824536bf9bSArtur Paszkiewicz { 9834536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 9844536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev; 9854536bf9bSArtur Paszkiewicz struct mddev *mddev = rdev->mddev; 986675dc2ccSPawel Baldysiak sector_t ppl_sector = rdev->ppl.sector + offset + 987675dc2ccSPawel Baldysiak (PPL_HEADER_SIZE >> 9); 9884536bf9bSArtur Paszkiewicz struct page *page; 9894536bf9bSArtur Paszkiewicz int i; 9904536bf9bSArtur Paszkiewicz int ret = 0; 9914536bf9bSArtur Paszkiewicz 9924536bf9bSArtur Paszkiewicz page = alloc_page(GFP_KERNEL); 9934536bf9bSArtur Paszkiewicz if (!page) 9944536bf9bSArtur Paszkiewicz return -ENOMEM; 9954536bf9bSArtur Paszkiewicz 9964536bf9bSArtur Paszkiewicz /* iterate through all PPL entries saved */ 9974536bf9bSArtur Paszkiewicz for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++) { 9984536bf9bSArtur Paszkiewicz struct ppl_header_entry *e = &pplhdr->entries[i]; 9994536bf9bSArtur Paszkiewicz u32 pp_size = le32_to_cpu(e->pp_size); 10004536bf9bSArtur Paszkiewicz sector_t sector = ppl_sector; 10014536bf9bSArtur Paszkiewicz int ppl_entry_sectors = pp_size >> 9; 10024536bf9bSArtur Paszkiewicz u32 crc, crc_stored; 10034536bf9bSArtur Paszkiewicz 10044536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d entry: %d ppl_sector: %llu pp_size: %u\n", 10054536bf9bSArtur Paszkiewicz __func__, rdev->raid_disk, i, 10064536bf9bSArtur Paszkiewicz (unsigned long long)ppl_sector, pp_size); 10074536bf9bSArtur Paszkiewicz 10084536bf9bSArtur Paszkiewicz crc = ~0; 10094536bf9bSArtur Paszkiewicz crc_stored = le32_to_cpu(e->checksum); 10104536bf9bSArtur Paszkiewicz 10114536bf9bSArtur Paszkiewicz /* read parial parity for this entry and calculate its checksum */ 10124536bf9bSArtur Paszkiewicz while (pp_size) { 10134536bf9bSArtur Paszkiewicz int s = pp_size > PAGE_SIZE ? PAGE_SIZE : pp_size; 10144536bf9bSArtur Paszkiewicz 10154536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, sector - rdev->data_offset, 10164536bf9bSArtur Paszkiewicz s, page, REQ_OP_READ, 0, false)) { 10174536bf9bSArtur Paszkiewicz md_error(mddev, rdev); 10184536bf9bSArtur Paszkiewicz ret = -EIO; 10194536bf9bSArtur Paszkiewicz goto out; 10204536bf9bSArtur Paszkiewicz } 10214536bf9bSArtur Paszkiewicz 10224536bf9bSArtur Paszkiewicz crc = crc32c_le(crc, page_address(page), s); 10234536bf9bSArtur Paszkiewicz 10244536bf9bSArtur Paszkiewicz pp_size -= s; 10254536bf9bSArtur Paszkiewicz sector += s >> 9; 10264536bf9bSArtur Paszkiewicz } 10274536bf9bSArtur Paszkiewicz 10284536bf9bSArtur Paszkiewicz crc = ~crc; 10294536bf9bSArtur Paszkiewicz 10304536bf9bSArtur Paszkiewicz if (crc != crc_stored) { 10314536bf9bSArtur Paszkiewicz /* 10324536bf9bSArtur Paszkiewicz * Don't recover this entry if the checksum does not 10334536bf9bSArtur Paszkiewicz * match, but keep going and try to recover other 10344536bf9bSArtur Paszkiewicz * entries. 10354536bf9bSArtur Paszkiewicz */ 10364536bf9bSArtur Paszkiewicz pr_debug("%s: ppl entry crc does not match: stored: 0x%x calculated: 0x%x\n", 10374536bf9bSArtur Paszkiewicz __func__, crc_stored, crc); 10384536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count++; 10394536bf9bSArtur Paszkiewicz } else { 10404536bf9bSArtur Paszkiewicz ret = ppl_recover_entry(log, e, ppl_sector); 10414536bf9bSArtur Paszkiewicz if (ret) 10424536bf9bSArtur Paszkiewicz goto out; 10434536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries++; 10444536bf9bSArtur Paszkiewicz } 10454536bf9bSArtur Paszkiewicz 10464536bf9bSArtur Paszkiewicz ppl_sector += ppl_entry_sectors; 10474536bf9bSArtur Paszkiewicz } 10484536bf9bSArtur Paszkiewicz 10494536bf9bSArtur Paszkiewicz /* flush the disk cache after recovery if necessary */ 10504536bf9bSArtur Paszkiewicz ret = blkdev_issue_flush(rdev->bdev, GFP_KERNEL, NULL); 10514536bf9bSArtur Paszkiewicz out: 10524536bf9bSArtur Paszkiewicz __free_page(page); 10534536bf9bSArtur Paszkiewicz return ret; 10544536bf9bSArtur Paszkiewicz } 10554536bf9bSArtur Paszkiewicz 10564536bf9bSArtur Paszkiewicz static int ppl_write_empty_header(struct ppl_log *log) 10574536bf9bSArtur Paszkiewicz { 10584536bf9bSArtur Paszkiewicz struct page *page; 10594536bf9bSArtur Paszkiewicz struct ppl_header *pplhdr; 10604536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev; 10614536bf9bSArtur Paszkiewicz int ret = 0; 10624536bf9bSArtur Paszkiewicz 10634536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d ppl_sector: %llu\n", __func__, 10644536bf9bSArtur Paszkiewicz rdev->raid_disk, (unsigned long long)rdev->ppl.sector); 10654536bf9bSArtur Paszkiewicz 10664536bf9bSArtur Paszkiewicz page = alloc_page(GFP_NOIO | __GFP_ZERO); 10674536bf9bSArtur Paszkiewicz if (!page) 10684536bf9bSArtur Paszkiewicz return -ENOMEM; 10694536bf9bSArtur Paszkiewicz 10704536bf9bSArtur Paszkiewicz pplhdr = page_address(page); 1071675dc2ccSPawel Baldysiak /* zero out PPL space to avoid collision with old PPLs */ 1072675dc2ccSPawel Baldysiak blkdev_issue_zeroout(rdev->bdev, rdev->ppl.sector, 1073675dc2ccSPawel Baldysiak log->rdev->ppl.size, GFP_NOIO, 0); 10744536bf9bSArtur Paszkiewicz memset(pplhdr->reserved, 0xff, PPL_HDR_RESERVED); 10754536bf9bSArtur Paszkiewicz pplhdr->signature = cpu_to_le32(log->ppl_conf->signature); 10764536bf9bSArtur Paszkiewicz pplhdr->checksum = cpu_to_le32(~crc32c_le(~0, pplhdr, PAGE_SIZE)); 10774536bf9bSArtur Paszkiewicz 10784536bf9bSArtur Paszkiewicz if (!sync_page_io(rdev, rdev->ppl.sector - rdev->data_offset, 10795a8948f8SJan Kara PPL_HEADER_SIZE, page, REQ_OP_WRITE | REQ_SYNC | 10805a8948f8SJan Kara REQ_FUA, 0, false)) { 10814536bf9bSArtur Paszkiewicz md_error(rdev->mddev, rdev); 10824536bf9bSArtur Paszkiewicz ret = -EIO; 10834536bf9bSArtur Paszkiewicz } 10844536bf9bSArtur Paszkiewicz 10854536bf9bSArtur Paszkiewicz __free_page(page); 10864536bf9bSArtur Paszkiewicz return ret; 10874536bf9bSArtur Paszkiewicz } 10884536bf9bSArtur Paszkiewicz 10894536bf9bSArtur Paszkiewicz static int ppl_load_distributed(struct ppl_log *log) 10904536bf9bSArtur Paszkiewicz { 10914536bf9bSArtur Paszkiewicz struct ppl_conf *ppl_conf = log->ppl_conf; 10924536bf9bSArtur Paszkiewicz struct md_rdev *rdev = log->rdev; 10934536bf9bSArtur Paszkiewicz struct mddev *mddev = rdev->mddev; 1094675dc2ccSPawel Baldysiak struct page *page, *page2, *tmp; 1095675dc2ccSPawel Baldysiak struct ppl_header *pplhdr = NULL, *prev_pplhdr = NULL; 10964536bf9bSArtur Paszkiewicz u32 crc, crc_stored; 10974536bf9bSArtur Paszkiewicz u32 signature; 1098675dc2ccSPawel Baldysiak int ret = 0, i; 1099675dc2ccSPawel Baldysiak sector_t pplhdr_offset = 0, prev_pplhdr_offset = 0; 11004536bf9bSArtur Paszkiewicz 11014536bf9bSArtur Paszkiewicz pr_debug("%s: disk: %d\n", __func__, rdev->raid_disk); 1102675dc2ccSPawel Baldysiak /* read PPL headers, find the recent one */ 11034536bf9bSArtur Paszkiewicz page = alloc_page(GFP_KERNEL); 11044536bf9bSArtur Paszkiewicz if (!page) 11054536bf9bSArtur Paszkiewicz return -ENOMEM; 11064536bf9bSArtur Paszkiewicz 1107675dc2ccSPawel Baldysiak page2 = alloc_page(GFP_KERNEL); 1108675dc2ccSPawel Baldysiak if (!page2) { 1109675dc2ccSPawel Baldysiak __free_page(page); 1110675dc2ccSPawel Baldysiak return -ENOMEM; 1111675dc2ccSPawel Baldysiak } 1112675dc2ccSPawel Baldysiak 1113675dc2ccSPawel Baldysiak /* searching ppl area for latest ppl */ 1114675dc2ccSPawel Baldysiak while (pplhdr_offset < rdev->ppl.size - (PPL_HEADER_SIZE >> 9)) { 1115675dc2ccSPawel Baldysiak if (!sync_page_io(rdev, 1116675dc2ccSPawel Baldysiak rdev->ppl.sector - rdev->data_offset + 1117675dc2ccSPawel Baldysiak pplhdr_offset, PAGE_SIZE, page, REQ_OP_READ, 1118675dc2ccSPawel Baldysiak 0, false)) { 11194536bf9bSArtur Paszkiewicz md_error(mddev, rdev); 11204536bf9bSArtur Paszkiewicz ret = -EIO; 1121675dc2ccSPawel Baldysiak /* if not able to read - don't recover any PPL */ 1122675dc2ccSPawel Baldysiak pplhdr = NULL; 1123675dc2ccSPawel Baldysiak break; 11244536bf9bSArtur Paszkiewicz } 11254536bf9bSArtur Paszkiewicz pplhdr = page_address(page); 11264536bf9bSArtur Paszkiewicz 11274536bf9bSArtur Paszkiewicz /* check header validity */ 11284536bf9bSArtur Paszkiewicz crc_stored = le32_to_cpu(pplhdr->checksum); 11294536bf9bSArtur Paszkiewicz pplhdr->checksum = 0; 11304536bf9bSArtur Paszkiewicz crc = ~crc32c_le(~0, pplhdr, PAGE_SIZE); 11314536bf9bSArtur Paszkiewicz 11324536bf9bSArtur Paszkiewicz if (crc_stored != crc) { 1133675dc2ccSPawel Baldysiak pr_debug("%s: ppl header crc does not match: stored: 0x%x calculated: 0x%x (offset: %llu)\n", 1134675dc2ccSPawel Baldysiak __func__, crc_stored, crc, 1135675dc2ccSPawel Baldysiak (unsigned long long)pplhdr_offset); 1136675dc2ccSPawel Baldysiak pplhdr = prev_pplhdr; 1137675dc2ccSPawel Baldysiak pplhdr_offset = prev_pplhdr_offset; 1138675dc2ccSPawel Baldysiak break; 11394536bf9bSArtur Paszkiewicz } 11404536bf9bSArtur Paszkiewicz 11414536bf9bSArtur Paszkiewicz signature = le32_to_cpu(pplhdr->signature); 11424536bf9bSArtur Paszkiewicz 11434536bf9bSArtur Paszkiewicz if (mddev->external) { 11444536bf9bSArtur Paszkiewicz /* 11454536bf9bSArtur Paszkiewicz * For external metadata the header signature is set and 11464536bf9bSArtur Paszkiewicz * validated in userspace. 11474536bf9bSArtur Paszkiewicz */ 11484536bf9bSArtur Paszkiewicz ppl_conf->signature = signature; 11494536bf9bSArtur Paszkiewicz } else if (ppl_conf->signature != signature) { 1150675dc2ccSPawel Baldysiak pr_debug("%s: ppl header signature does not match: stored: 0x%x configured: 0x%x (offset: %llu)\n", 1151675dc2ccSPawel Baldysiak __func__, signature, ppl_conf->signature, 1152675dc2ccSPawel Baldysiak (unsigned long long)pplhdr_offset); 1153675dc2ccSPawel Baldysiak pplhdr = prev_pplhdr; 1154675dc2ccSPawel Baldysiak pplhdr_offset = prev_pplhdr_offset; 1155675dc2ccSPawel Baldysiak break; 11564536bf9bSArtur Paszkiewicz } 11574536bf9bSArtur Paszkiewicz 1158675dc2ccSPawel Baldysiak if (prev_pplhdr && le64_to_cpu(prev_pplhdr->generation) > 1159675dc2ccSPawel Baldysiak le64_to_cpu(pplhdr->generation)) { 1160675dc2ccSPawel Baldysiak /* previous was newest */ 1161675dc2ccSPawel Baldysiak pplhdr = prev_pplhdr; 1162675dc2ccSPawel Baldysiak pplhdr_offset = prev_pplhdr_offset; 1163675dc2ccSPawel Baldysiak break; 1164675dc2ccSPawel Baldysiak } 1165675dc2ccSPawel Baldysiak 1166675dc2ccSPawel Baldysiak prev_pplhdr_offset = pplhdr_offset; 1167675dc2ccSPawel Baldysiak prev_pplhdr = pplhdr; 1168675dc2ccSPawel Baldysiak 1169675dc2ccSPawel Baldysiak tmp = page; 1170675dc2ccSPawel Baldysiak page = page2; 1171675dc2ccSPawel Baldysiak page2 = tmp; 1172675dc2ccSPawel Baldysiak 1173675dc2ccSPawel Baldysiak /* calculate next potential ppl offset */ 1174675dc2ccSPawel Baldysiak for (i = 0; i < le32_to_cpu(pplhdr->entries_count); i++) 1175675dc2ccSPawel Baldysiak pplhdr_offset += 1176675dc2ccSPawel Baldysiak le32_to_cpu(pplhdr->entries[i].pp_size) >> 9; 1177675dc2ccSPawel Baldysiak pplhdr_offset += PPL_HEADER_SIZE >> 9; 1178675dc2ccSPawel Baldysiak } 1179675dc2ccSPawel Baldysiak 1180675dc2ccSPawel Baldysiak /* no valid ppl found */ 1181675dc2ccSPawel Baldysiak if (!pplhdr) 1182675dc2ccSPawel Baldysiak ppl_conf->mismatch_count++; 1183675dc2ccSPawel Baldysiak else 1184675dc2ccSPawel Baldysiak pr_debug("%s: latest PPL found at offset: %llu, with generation: %llu\n", 1185675dc2ccSPawel Baldysiak __func__, (unsigned long long)pplhdr_offset, 1186675dc2ccSPawel Baldysiak le64_to_cpu(pplhdr->generation)); 1187675dc2ccSPawel Baldysiak 11884536bf9bSArtur Paszkiewicz /* attempt to recover from log if we are starting a dirty array */ 1189675dc2ccSPawel Baldysiak if (pplhdr && !mddev->pers && mddev->recovery_cp != MaxSector) 1190675dc2ccSPawel Baldysiak ret = ppl_recover(log, pplhdr, pplhdr_offset); 1191675dc2ccSPawel Baldysiak 11924536bf9bSArtur Paszkiewicz /* write empty header if we are starting the array */ 11934536bf9bSArtur Paszkiewicz if (!ret && !mddev->pers) 11944536bf9bSArtur Paszkiewicz ret = ppl_write_empty_header(log); 11954536bf9bSArtur Paszkiewicz 11964536bf9bSArtur Paszkiewicz __free_page(page); 1197675dc2ccSPawel Baldysiak __free_page(page2); 11984536bf9bSArtur Paszkiewicz 11994536bf9bSArtur Paszkiewicz pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n", 12004536bf9bSArtur Paszkiewicz __func__, ret, ppl_conf->mismatch_count, 12014536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries); 12024536bf9bSArtur Paszkiewicz return ret; 12034536bf9bSArtur Paszkiewicz } 12044536bf9bSArtur Paszkiewicz 12054536bf9bSArtur Paszkiewicz static int ppl_load(struct ppl_conf *ppl_conf) 12064536bf9bSArtur Paszkiewicz { 12074536bf9bSArtur Paszkiewicz int ret = 0; 12084536bf9bSArtur Paszkiewicz u32 signature = 0; 12094536bf9bSArtur Paszkiewicz bool signature_set = false; 12104536bf9bSArtur Paszkiewicz int i; 12114536bf9bSArtur Paszkiewicz 12124536bf9bSArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) { 12134536bf9bSArtur Paszkiewicz struct ppl_log *log = &ppl_conf->child_logs[i]; 12144536bf9bSArtur Paszkiewicz 12154536bf9bSArtur Paszkiewicz /* skip missing drive */ 12164536bf9bSArtur Paszkiewicz if (!log->rdev) 12174536bf9bSArtur Paszkiewicz continue; 12184536bf9bSArtur Paszkiewicz 12194536bf9bSArtur Paszkiewicz ret = ppl_load_distributed(log); 12204536bf9bSArtur Paszkiewicz if (ret) 12214536bf9bSArtur Paszkiewicz break; 12224536bf9bSArtur Paszkiewicz 12234536bf9bSArtur Paszkiewicz /* 12244536bf9bSArtur Paszkiewicz * For external metadata we can't check if the signature is 12254536bf9bSArtur Paszkiewicz * correct on a single drive, but we can check if it is the same 12264536bf9bSArtur Paszkiewicz * on all drives. 12274536bf9bSArtur Paszkiewicz */ 12284536bf9bSArtur Paszkiewicz if (ppl_conf->mddev->external) { 12294536bf9bSArtur Paszkiewicz if (!signature_set) { 12304536bf9bSArtur Paszkiewicz signature = ppl_conf->signature; 12314536bf9bSArtur Paszkiewicz signature_set = true; 12324536bf9bSArtur Paszkiewicz } else if (signature != ppl_conf->signature) { 12334536bf9bSArtur Paszkiewicz pr_warn("md/raid:%s: PPL header signature does not match on all member drives\n", 12344536bf9bSArtur Paszkiewicz mdname(ppl_conf->mddev)); 12354536bf9bSArtur Paszkiewicz ret = -EINVAL; 12364536bf9bSArtur Paszkiewicz break; 12374536bf9bSArtur Paszkiewicz } 12384536bf9bSArtur Paszkiewicz } 12394536bf9bSArtur Paszkiewicz } 12404536bf9bSArtur Paszkiewicz 12414536bf9bSArtur Paszkiewicz pr_debug("%s: return: %d mismatch_count: %d recovered_entries: %d\n", 12424536bf9bSArtur Paszkiewicz __func__, ret, ppl_conf->mismatch_count, 12434536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries); 12444536bf9bSArtur Paszkiewicz return ret; 12454536bf9bSArtur Paszkiewicz } 12464536bf9bSArtur Paszkiewicz 12473418d036SArtur Paszkiewicz static void __ppl_exit_log(struct ppl_conf *ppl_conf) 12483418d036SArtur Paszkiewicz { 12493418d036SArtur Paszkiewicz clear_bit(MD_HAS_PPL, &ppl_conf->mddev->flags); 1250ddc08823SPawel Baldysiak clear_bit(MD_HAS_MULTIPLE_PPLS, &ppl_conf->mddev->flags); 12513418d036SArtur Paszkiewicz 12523418d036SArtur Paszkiewicz kfree(ppl_conf->child_logs); 12533418d036SArtur Paszkiewicz 1254afeee514SKent Overstreet bioset_exit(&ppl_conf->bs); 1255afeee514SKent Overstreet bioset_exit(&ppl_conf->flush_bs); 1256afeee514SKent Overstreet mempool_exit(&ppl_conf->io_pool); 12573418d036SArtur Paszkiewicz kmem_cache_destroy(ppl_conf->io_kc); 12583418d036SArtur Paszkiewicz 12593418d036SArtur Paszkiewicz kfree(ppl_conf); 12603418d036SArtur Paszkiewicz } 12613418d036SArtur Paszkiewicz 12623418d036SArtur Paszkiewicz void ppl_exit_log(struct r5conf *conf) 12633418d036SArtur Paszkiewicz { 12643418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 12653418d036SArtur Paszkiewicz 12663418d036SArtur Paszkiewicz if (ppl_conf) { 12673418d036SArtur Paszkiewicz __ppl_exit_log(ppl_conf); 12683418d036SArtur Paszkiewicz conf->log_private = NULL; 12693418d036SArtur Paszkiewicz } 12703418d036SArtur Paszkiewicz } 12713418d036SArtur Paszkiewicz 12723418d036SArtur Paszkiewicz static int ppl_validate_rdev(struct md_rdev *rdev) 12733418d036SArtur Paszkiewicz { 12743418d036SArtur Paszkiewicz char b[BDEVNAME_SIZE]; 12753418d036SArtur Paszkiewicz int ppl_data_sectors; 12763418d036SArtur Paszkiewicz int ppl_size_new; 12773418d036SArtur Paszkiewicz 12783418d036SArtur Paszkiewicz /* 12793418d036SArtur Paszkiewicz * The configured PPL size must be enough to store 12803418d036SArtur Paszkiewicz * the header and (at the very least) partial parity 12813418d036SArtur Paszkiewicz * for one stripe. Round it down to ensure the data 12823418d036SArtur Paszkiewicz * space is cleanly divisible by stripe size. 12833418d036SArtur Paszkiewicz */ 12843418d036SArtur Paszkiewicz ppl_data_sectors = rdev->ppl.size - (PPL_HEADER_SIZE >> 9); 12853418d036SArtur Paszkiewicz 12863418d036SArtur Paszkiewicz if (ppl_data_sectors > 0) 12873418d036SArtur Paszkiewicz ppl_data_sectors = rounddown(ppl_data_sectors, STRIPE_SECTORS); 12883418d036SArtur Paszkiewicz 12893418d036SArtur Paszkiewicz if (ppl_data_sectors <= 0) { 12903418d036SArtur Paszkiewicz pr_warn("md/raid:%s: PPL space too small on %s\n", 12913418d036SArtur Paszkiewicz mdname(rdev->mddev), bdevname(rdev->bdev, b)); 12923418d036SArtur Paszkiewicz return -ENOSPC; 12933418d036SArtur Paszkiewicz } 12943418d036SArtur Paszkiewicz 12953418d036SArtur Paszkiewicz ppl_size_new = ppl_data_sectors + (PPL_HEADER_SIZE >> 9); 12963418d036SArtur Paszkiewicz 12973418d036SArtur Paszkiewicz if ((rdev->ppl.sector < rdev->data_offset && 12983418d036SArtur Paszkiewicz rdev->ppl.sector + ppl_size_new > rdev->data_offset) || 12993418d036SArtur Paszkiewicz (rdev->ppl.sector >= rdev->data_offset && 13003418d036SArtur Paszkiewicz rdev->data_offset + rdev->sectors > rdev->ppl.sector)) { 13013418d036SArtur Paszkiewicz pr_warn("md/raid:%s: PPL space overlaps with data on %s\n", 13023418d036SArtur Paszkiewicz mdname(rdev->mddev), bdevname(rdev->bdev, b)); 13033418d036SArtur Paszkiewicz return -EINVAL; 13043418d036SArtur Paszkiewicz } 13053418d036SArtur Paszkiewicz 13063418d036SArtur Paszkiewicz if (!rdev->mddev->external && 13073418d036SArtur Paszkiewicz ((rdev->ppl.offset > 0 && rdev->ppl.offset < (rdev->sb_size >> 9)) || 13083418d036SArtur Paszkiewicz (rdev->ppl.offset <= 0 && rdev->ppl.offset + ppl_size_new > 0))) { 13093418d036SArtur Paszkiewicz pr_warn("md/raid:%s: PPL space overlaps with superblock on %s\n", 13103418d036SArtur Paszkiewicz mdname(rdev->mddev), bdevname(rdev->bdev, b)); 13113418d036SArtur Paszkiewicz return -EINVAL; 13123418d036SArtur Paszkiewicz } 13133418d036SArtur Paszkiewicz 13143418d036SArtur Paszkiewicz rdev->ppl.size = ppl_size_new; 13153418d036SArtur Paszkiewicz 13163418d036SArtur Paszkiewicz return 0; 13173418d036SArtur Paszkiewicz } 13183418d036SArtur Paszkiewicz 1319ddc08823SPawel Baldysiak static void ppl_init_child_log(struct ppl_log *log, struct md_rdev *rdev) 1320ddc08823SPawel Baldysiak { 13211532d9e8STomasz Majchrzak struct request_queue *q; 13221532d9e8STomasz Majchrzak 1323ddc08823SPawel Baldysiak if ((rdev->ppl.size << 9) >= (PPL_SPACE_SIZE + 1324ddc08823SPawel Baldysiak PPL_HEADER_SIZE) * 2) { 1325ddc08823SPawel Baldysiak log->use_multippl = true; 1326ddc08823SPawel Baldysiak set_bit(MD_HAS_MULTIPLE_PPLS, 1327ddc08823SPawel Baldysiak &log->ppl_conf->mddev->flags); 1328ddc08823SPawel Baldysiak log->entry_space = PPL_SPACE_SIZE; 1329ddc08823SPawel Baldysiak } else { 1330ddc08823SPawel Baldysiak log->use_multippl = false; 1331ddc08823SPawel Baldysiak log->entry_space = (log->rdev->ppl.size << 9) - 1332ddc08823SPawel Baldysiak PPL_HEADER_SIZE; 1333ddc08823SPawel Baldysiak } 1334ddc08823SPawel Baldysiak log->next_io_sector = rdev->ppl.sector; 13351532d9e8STomasz Majchrzak 13361532d9e8STomasz Majchrzak q = bdev_get_queue(rdev->bdev); 13371532d9e8STomasz Majchrzak if (test_bit(QUEUE_FLAG_WC, &q->queue_flags)) 13381532d9e8STomasz Majchrzak log->wb_cache_on = true; 1339ddc08823SPawel Baldysiak } 1340ddc08823SPawel Baldysiak 13413418d036SArtur Paszkiewicz int ppl_init_log(struct r5conf *conf) 13423418d036SArtur Paszkiewicz { 13433418d036SArtur Paszkiewicz struct ppl_conf *ppl_conf; 13443418d036SArtur Paszkiewicz struct mddev *mddev = conf->mddev; 13453418d036SArtur Paszkiewicz int ret = 0; 13461532d9e8STomasz Majchrzak int max_disks; 13473418d036SArtur Paszkiewicz int i; 13483418d036SArtur Paszkiewicz 13493418d036SArtur Paszkiewicz pr_debug("md/raid:%s: enabling distributed Partial Parity Log\n", 13503418d036SArtur Paszkiewicz mdname(conf->mddev)); 13513418d036SArtur Paszkiewicz 13523418d036SArtur Paszkiewicz if (PAGE_SIZE != 4096) 13533418d036SArtur Paszkiewicz return -EINVAL; 13543418d036SArtur Paszkiewicz 13553418d036SArtur Paszkiewicz if (mddev->level != 5) { 13563418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with raid level %d\n", 13573418d036SArtur Paszkiewicz mdname(mddev), mddev->level); 13583418d036SArtur Paszkiewicz return -EINVAL; 13593418d036SArtur Paszkiewicz } 13603418d036SArtur Paszkiewicz 13613418d036SArtur Paszkiewicz if (mddev->bitmap_info.file || mddev->bitmap_info.offset) { 13623418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with bitmap\n", 13633418d036SArtur Paszkiewicz mdname(mddev)); 13643418d036SArtur Paszkiewicz return -EINVAL; 13653418d036SArtur Paszkiewicz } 13663418d036SArtur Paszkiewicz 13673418d036SArtur Paszkiewicz if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) { 13683418d036SArtur Paszkiewicz pr_warn("md/raid:%s PPL is not compatible with journal\n", 13693418d036SArtur Paszkiewicz mdname(mddev)); 13703418d036SArtur Paszkiewicz return -EINVAL; 13713418d036SArtur Paszkiewicz } 13723418d036SArtur Paszkiewicz 13731532d9e8STomasz Majchrzak max_disks = FIELD_SIZEOF(struct ppl_log, disk_flush_bitmap) * 13741532d9e8STomasz Majchrzak BITS_PER_BYTE; 13751532d9e8STomasz Majchrzak if (conf->raid_disks > max_disks) { 13761532d9e8STomasz Majchrzak pr_warn("md/raid:%s PPL doesn't support over %d disks in the array\n", 13771532d9e8STomasz Majchrzak mdname(mddev), max_disks); 13781532d9e8STomasz Majchrzak return -EINVAL; 13791532d9e8STomasz Majchrzak } 13801532d9e8STomasz Majchrzak 13813418d036SArtur Paszkiewicz ppl_conf = kzalloc(sizeof(struct ppl_conf), GFP_KERNEL); 13823418d036SArtur Paszkiewicz if (!ppl_conf) 13833418d036SArtur Paszkiewicz return -ENOMEM; 13843418d036SArtur Paszkiewicz 13853418d036SArtur Paszkiewicz ppl_conf->mddev = mddev; 13863418d036SArtur Paszkiewicz 13873418d036SArtur Paszkiewicz ppl_conf->io_kc = KMEM_CACHE(ppl_io_unit, 0); 13883418d036SArtur Paszkiewicz if (!ppl_conf->io_kc) { 1389fcd403afSArtur Paszkiewicz ret = -ENOMEM; 13903418d036SArtur Paszkiewicz goto err; 13913418d036SArtur Paszkiewicz } 13923418d036SArtur Paszkiewicz 1393afeee514SKent Overstreet ret = mempool_init(&ppl_conf->io_pool, conf->raid_disks, ppl_io_pool_alloc, 1394fcd403afSArtur Paszkiewicz ppl_io_pool_free, ppl_conf->io_kc); 1395afeee514SKent Overstreet if (ret) 13963418d036SArtur Paszkiewicz goto err; 13973418d036SArtur Paszkiewicz 1398afeee514SKent Overstreet ret = bioset_init(&ppl_conf->bs, conf->raid_disks, 0, BIOSET_NEED_BVECS); 1399afeee514SKent Overstreet if (ret) 14003418d036SArtur Paszkiewicz goto err; 14013418d036SArtur Paszkiewicz 1402afeee514SKent Overstreet ret = bioset_init(&ppl_conf->flush_bs, conf->raid_disks, 0, 0); 1403afeee514SKent Overstreet if (ret) 14041532d9e8STomasz Majchrzak goto err; 14051532d9e8STomasz Majchrzak 14063418d036SArtur Paszkiewicz ppl_conf->count = conf->raid_disks; 14073418d036SArtur Paszkiewicz ppl_conf->child_logs = kcalloc(ppl_conf->count, sizeof(struct ppl_log), 14083418d036SArtur Paszkiewicz GFP_KERNEL); 14093418d036SArtur Paszkiewicz if (!ppl_conf->child_logs) { 14103418d036SArtur Paszkiewicz ret = -ENOMEM; 14113418d036SArtur Paszkiewicz goto err; 14123418d036SArtur Paszkiewicz } 14133418d036SArtur Paszkiewicz 14143418d036SArtur Paszkiewicz atomic64_set(&ppl_conf->seq, 0); 141594568f64SArtur Paszkiewicz INIT_LIST_HEAD(&ppl_conf->no_mem_stripes); 141694568f64SArtur Paszkiewicz spin_lock_init(&ppl_conf->no_mem_stripes_lock); 1417a596d086SMariusz Dabrowski ppl_conf->write_hint = RWF_WRITE_LIFE_NOT_SET; 14183418d036SArtur Paszkiewicz 14193418d036SArtur Paszkiewicz if (!mddev->external) { 14203418d036SArtur Paszkiewicz ppl_conf->signature = ~crc32c_le(~0, mddev->uuid, sizeof(mddev->uuid)); 14213418d036SArtur Paszkiewicz ppl_conf->block_size = 512; 14223418d036SArtur Paszkiewicz } else { 14233418d036SArtur Paszkiewicz ppl_conf->block_size = queue_logical_block_size(mddev->queue); 14243418d036SArtur Paszkiewicz } 14253418d036SArtur Paszkiewicz 14263418d036SArtur Paszkiewicz for (i = 0; i < ppl_conf->count; i++) { 14273418d036SArtur Paszkiewicz struct ppl_log *log = &ppl_conf->child_logs[i]; 14283418d036SArtur Paszkiewicz struct md_rdev *rdev = conf->disks[i].rdev; 14293418d036SArtur Paszkiewicz 14303418d036SArtur Paszkiewicz mutex_init(&log->io_mutex); 14313418d036SArtur Paszkiewicz spin_lock_init(&log->io_list_lock); 14323418d036SArtur Paszkiewicz INIT_LIST_HEAD(&log->io_list); 14333418d036SArtur Paszkiewicz 14343418d036SArtur Paszkiewicz log->ppl_conf = ppl_conf; 14353418d036SArtur Paszkiewicz log->rdev = rdev; 14363418d036SArtur Paszkiewicz 14373418d036SArtur Paszkiewicz if (rdev) { 14383418d036SArtur Paszkiewicz ret = ppl_validate_rdev(rdev); 14393418d036SArtur Paszkiewicz if (ret) 14403418d036SArtur Paszkiewicz goto err; 14413418d036SArtur Paszkiewicz 1442ddc08823SPawel Baldysiak ppl_init_child_log(log, rdev); 14433418d036SArtur Paszkiewicz } 14443418d036SArtur Paszkiewicz } 14453418d036SArtur Paszkiewicz 14464536bf9bSArtur Paszkiewicz /* load and possibly recover the logs from the member disks */ 14474536bf9bSArtur Paszkiewicz ret = ppl_load(ppl_conf); 14484536bf9bSArtur Paszkiewicz 14494536bf9bSArtur Paszkiewicz if (ret) { 14504536bf9bSArtur Paszkiewicz goto err; 1451611426e2SArtur Paszkiewicz } else if (!mddev->pers && mddev->recovery_cp == 0 && 14524536bf9bSArtur Paszkiewicz ppl_conf->recovered_entries > 0 && 14534536bf9bSArtur Paszkiewicz ppl_conf->mismatch_count == 0) { 14544536bf9bSArtur Paszkiewicz /* 14554536bf9bSArtur Paszkiewicz * If we are starting a dirty array and the recovery succeeds 14564536bf9bSArtur Paszkiewicz * without any issues, set the array as clean. 14574536bf9bSArtur Paszkiewicz */ 14584536bf9bSArtur Paszkiewicz mddev->recovery_cp = MaxSector; 14594536bf9bSArtur Paszkiewicz set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 1460ba903a3eSArtur Paszkiewicz } else if (mddev->pers && ppl_conf->mismatch_count > 0) { 1461ba903a3eSArtur Paszkiewicz /* no mismatch allowed when enabling PPL for a running array */ 1462ba903a3eSArtur Paszkiewicz ret = -EINVAL; 1463ba903a3eSArtur Paszkiewicz goto err; 14644536bf9bSArtur Paszkiewicz } 14654536bf9bSArtur Paszkiewicz 14663418d036SArtur Paszkiewicz conf->log_private = ppl_conf; 1467845b9e22SArtur Paszkiewicz set_bit(MD_HAS_PPL, &ppl_conf->mddev->flags); 14683418d036SArtur Paszkiewicz 14693418d036SArtur Paszkiewicz return 0; 14703418d036SArtur Paszkiewicz err: 14713418d036SArtur Paszkiewicz __ppl_exit_log(ppl_conf); 14723418d036SArtur Paszkiewicz return ret; 14733418d036SArtur Paszkiewicz } 14746358c239SArtur Paszkiewicz 14756358c239SArtur Paszkiewicz int ppl_modify_log(struct r5conf *conf, struct md_rdev *rdev, bool add) 14766358c239SArtur Paszkiewicz { 14776358c239SArtur Paszkiewicz struct ppl_conf *ppl_conf = conf->log_private; 14786358c239SArtur Paszkiewicz struct ppl_log *log; 14796358c239SArtur Paszkiewicz int ret = 0; 14806358c239SArtur Paszkiewicz char b[BDEVNAME_SIZE]; 14816358c239SArtur Paszkiewicz 14826358c239SArtur Paszkiewicz if (!rdev) 14836358c239SArtur Paszkiewicz return -EINVAL; 14846358c239SArtur Paszkiewicz 14856358c239SArtur Paszkiewicz pr_debug("%s: disk: %d operation: %s dev: %s\n", 14866358c239SArtur Paszkiewicz __func__, rdev->raid_disk, add ? "add" : "remove", 14876358c239SArtur Paszkiewicz bdevname(rdev->bdev, b)); 14886358c239SArtur Paszkiewicz 14896358c239SArtur Paszkiewicz if (rdev->raid_disk < 0) 14906358c239SArtur Paszkiewicz return 0; 14916358c239SArtur Paszkiewicz 14926358c239SArtur Paszkiewicz if (rdev->raid_disk >= ppl_conf->count) 14936358c239SArtur Paszkiewicz return -ENODEV; 14946358c239SArtur Paszkiewicz 14956358c239SArtur Paszkiewicz log = &ppl_conf->child_logs[rdev->raid_disk]; 14966358c239SArtur Paszkiewicz 14976358c239SArtur Paszkiewicz mutex_lock(&log->io_mutex); 14986358c239SArtur Paszkiewicz if (add) { 14996358c239SArtur Paszkiewicz ret = ppl_validate_rdev(rdev); 15006358c239SArtur Paszkiewicz if (!ret) { 15016358c239SArtur Paszkiewicz log->rdev = rdev; 15026358c239SArtur Paszkiewicz ret = ppl_write_empty_header(log); 1503ddc08823SPawel Baldysiak ppl_init_child_log(log, rdev); 15046358c239SArtur Paszkiewicz } 15056358c239SArtur Paszkiewicz } else { 15066358c239SArtur Paszkiewicz log->rdev = NULL; 15076358c239SArtur Paszkiewicz } 15086358c239SArtur Paszkiewicz mutex_unlock(&log->io_mutex); 15096358c239SArtur Paszkiewicz 15106358c239SArtur Paszkiewicz return ret; 15116358c239SArtur Paszkiewicz } 1512a596d086SMariusz Dabrowski 1513a596d086SMariusz Dabrowski static ssize_t 1514a596d086SMariusz Dabrowski ppl_write_hint_show(struct mddev *mddev, char *buf) 1515a596d086SMariusz Dabrowski { 1516a596d086SMariusz Dabrowski size_t ret = 0; 1517a596d086SMariusz Dabrowski struct r5conf *conf; 1518a596d086SMariusz Dabrowski struct ppl_conf *ppl_conf = NULL; 1519a596d086SMariusz Dabrowski 1520a596d086SMariusz Dabrowski spin_lock(&mddev->lock); 1521a596d086SMariusz Dabrowski conf = mddev->private; 1522a596d086SMariusz Dabrowski if (conf && raid5_has_ppl(conf)) 1523a596d086SMariusz Dabrowski ppl_conf = conf->log_private; 1524a596d086SMariusz Dabrowski ret = sprintf(buf, "%d\n", ppl_conf ? ppl_conf->write_hint : 0); 1525a596d086SMariusz Dabrowski spin_unlock(&mddev->lock); 1526a596d086SMariusz Dabrowski 1527a596d086SMariusz Dabrowski return ret; 1528a596d086SMariusz Dabrowski } 1529a596d086SMariusz Dabrowski 1530a596d086SMariusz Dabrowski static ssize_t 1531a596d086SMariusz Dabrowski ppl_write_hint_store(struct mddev *mddev, const char *page, size_t len) 1532a596d086SMariusz Dabrowski { 1533a596d086SMariusz Dabrowski struct r5conf *conf; 1534a596d086SMariusz Dabrowski struct ppl_conf *ppl_conf; 1535a596d086SMariusz Dabrowski int err = 0; 1536a596d086SMariusz Dabrowski unsigned short new; 1537a596d086SMariusz Dabrowski 1538a596d086SMariusz Dabrowski if (len >= PAGE_SIZE) 1539a596d086SMariusz Dabrowski return -EINVAL; 1540a596d086SMariusz Dabrowski if (kstrtou16(page, 10, &new)) 1541a596d086SMariusz Dabrowski return -EINVAL; 1542a596d086SMariusz Dabrowski 1543a596d086SMariusz Dabrowski err = mddev_lock(mddev); 1544a596d086SMariusz Dabrowski if (err) 1545a596d086SMariusz Dabrowski return err; 1546a596d086SMariusz Dabrowski 1547a596d086SMariusz Dabrowski conf = mddev->private; 1548a596d086SMariusz Dabrowski if (!conf) { 1549a596d086SMariusz Dabrowski err = -ENODEV; 1550a596d086SMariusz Dabrowski } else if (raid5_has_ppl(conf)) { 1551a596d086SMariusz Dabrowski ppl_conf = conf->log_private; 1552a596d086SMariusz Dabrowski if (!ppl_conf) 1553a596d086SMariusz Dabrowski err = -EINVAL; 1554a596d086SMariusz Dabrowski else 1555a596d086SMariusz Dabrowski ppl_conf->write_hint = new; 1556a596d086SMariusz Dabrowski } else { 1557a596d086SMariusz Dabrowski err = -EINVAL; 1558a596d086SMariusz Dabrowski } 1559a596d086SMariusz Dabrowski 1560a596d086SMariusz Dabrowski mddev_unlock(mddev); 1561a596d086SMariusz Dabrowski 1562a596d086SMariusz Dabrowski return err ?: len; 1563a596d086SMariusz Dabrowski } 1564a596d086SMariusz Dabrowski 1565a596d086SMariusz Dabrowski struct md_sysfs_entry 1566a596d086SMariusz Dabrowski ppl_write_hint = __ATTR(ppl_write_hint, S_IRUGO | S_IWUSR, 1567a596d086SMariusz Dabrowski ppl_write_hint_show, 1568a596d086SMariusz Dabrowski ppl_write_hint_store); 1569