1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2012 Fusion-io All rights reserved. 4 * Copyright (C) 2012 Intel Corp. All rights reserved. 5 */ 6 7 #ifndef BTRFS_RAID56_H 8 #define BTRFS_RAID56_H 9 10 #include <linux/workqueue.h> 11 #include "volumes.h" 12 13 enum btrfs_rbio_ops { 14 BTRFS_RBIO_WRITE, 15 BTRFS_RBIO_READ_REBUILD, 16 BTRFS_RBIO_PARITY_SCRUB, 17 }; 18 19 struct btrfs_raid_bio { 20 struct btrfs_io_context *bioc; 21 22 /* 23 * While we're doing RMW on a stripe we put it into a hash table so we 24 * can lock the stripe and merge more rbios into it. 25 */ 26 struct list_head hash_list; 27 28 /* LRU list for the stripe cache */ 29 struct list_head stripe_cache; 30 31 /* For scheduling work in the helper threads */ 32 struct work_struct work; 33 34 /* 35 * bio_list and bio_list_lock are used to add more bios into the stripe 36 * in hopes of avoiding the full RMW 37 */ 38 struct bio_list bio_list; 39 spinlock_t bio_list_lock; 40 41 /* 42 * Also protected by the bio_list_lock, the plug list is used by the 43 * plugging code to collect partial bios while plugged. The stripe 44 * locking code also uses it to hand off the stripe lock to the next 45 * pending IO. 46 */ 47 struct list_head plug_list; 48 49 /* Flags that tell us if it is safe to merge with this bio. */ 50 unsigned long flags; 51 52 /* 53 * Set if we're doing a parity rebuild for a read from higher up, which 54 * is handled differently from a parity rebuild as part of RMW. 55 */ 56 enum btrfs_rbio_ops operation; 57 58 /* How many pages there are for the full stripe including P/Q */ 59 u16 nr_pages; 60 61 /* How many sectors there are for the full stripe including P/Q */ 62 u16 nr_sectors; 63 64 /* Number of data stripes (no p/q) */ 65 u8 nr_data; 66 67 /* Number of all stripes (including P/Q) */ 68 u8 real_stripes; 69 70 /* How many pages there are for each stripe */ 71 u8 stripe_npages; 72 73 /* How many sectors there are for each stripe */ 74 u8 stripe_nsectors; 75 76 /* Stripe number that we're scrubbing */ 77 u8 scrubp; 78 79 /* 80 * Size of all the bios in the bio_list. This helps us decide if the 81 * rbio maps to a full stripe or not. 82 */ 83 int bio_list_bytes; 84 85 refcount_t refs; 86 87 atomic_t stripes_pending; 88 89 wait_queue_head_t io_wait; 90 91 /* Bitmap to record which horizontal stripe has data */ 92 unsigned long dbitmap; 93 94 /* Allocated with stripe_nsectors-many bits for finish_*() calls */ 95 unsigned long finish_pbitmap; 96 97 /* 98 * These are two arrays of pointers. We allocate the rbio big enough 99 * to hold them both and setup their locations when the rbio is 100 * allocated. 101 */ 102 103 /* 104 * Pointers to pages that we allocated for reading/writing stripes 105 * directly from the disk (including P/Q). 106 */ 107 struct page **stripe_pages; 108 109 /* Pointers to the sectors in the bio_list, for faster lookup */ 110 struct sector_ptr *bio_sectors; 111 112 /* 113 * For subpage support, we need to map each sector to above 114 * stripe_pages. 115 */ 116 struct sector_ptr *stripe_sectors; 117 118 /* Allocated with real_stripes-many pointers for finish_*() calls */ 119 void **finish_pointers; 120 121 /* 122 * The bitmap recording where IO errors happened. 123 * Each bit is corresponding to one sector in either bio_sectors[] or 124 * stripe_sectors[] array. 125 * 126 * The reason we don't use another bit in sector_ptr is, we have two 127 * arrays of sectors, and a lot of IO can use sectors in both arrays. 128 * Thus making it much harder to iterate. 129 */ 130 unsigned long *error_bitmap; 131 132 /* 133 * Checksum buffer if the rbio is for data. The buffer should cover 134 * all data sectors (excluding P/Q sectors). 135 */ 136 u8 *csum_buf; 137 138 /* 139 * Each bit represents if the corresponding sector has data csum found. 140 * Should only cover data sectors (excluding P/Q sectors). 141 */ 142 unsigned long *csum_bitmap; 143 }; 144 145 /* 146 * For trace event usage only. Records useful debug info for each bio submitted 147 * by RAID56 to each physical device. 148 * 149 * No matter signed or not, (-1) is always the one indicating we can not grab 150 * the proper stripe number. 151 */ 152 struct raid56_bio_trace_info { 153 u64 devid; 154 155 /* The offset inside the stripe. (<= STRIPE_LEN) */ 156 u32 offset; 157 158 /* 159 * Stripe number. 160 * 0 is the first data stripe, and nr_data for P stripe, 161 * nr_data + 1 for Q stripe. 162 * >= real_stripes for 163 */ 164 u8 stripe_nr; 165 }; 166 167 static inline int nr_data_stripes(const struct btrfs_chunk_map *map) 168 { 169 return map->num_stripes - btrfs_nr_parity_stripes(map->type); 170 } 171 172 static inline int nr_bioc_data_stripes(const struct btrfs_io_context *bioc) 173 { 174 return bioc->num_stripes - btrfs_nr_parity_stripes(bioc->map_type); 175 } 176 177 #define RAID5_P_STRIPE ((u64)-2) 178 #define RAID6_Q_STRIPE ((u64)-1) 179 180 #define is_parity_stripe(x) (((x) == RAID5_P_STRIPE) || \ 181 ((x) == RAID6_Q_STRIPE)) 182 183 struct btrfs_device; 184 185 void raid56_parity_recover(struct bio *bio, struct btrfs_io_context *bioc, 186 int mirror_num); 187 void raid56_parity_write(struct bio *bio, struct btrfs_io_context *bioc); 188 189 struct btrfs_raid_bio *raid56_parity_alloc_scrub_rbio(struct bio *bio, 190 struct btrfs_io_context *bioc, 191 struct btrfs_device *scrub_dev, 192 unsigned long *dbitmap, int stripe_nsectors); 193 void raid56_parity_submit_scrub_rbio(struct btrfs_raid_bio *rbio); 194 195 void raid56_parity_cache_data_pages(struct btrfs_raid_bio *rbio, 196 struct page **data_pages, u64 data_logical); 197 198 int btrfs_alloc_stripe_hash_table(struct btrfs_fs_info *info); 199 void btrfs_free_stripe_hash_table(struct btrfs_fs_info *info); 200 201 #endif 202