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