Line data    Source code

       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           0 : static inline int nr_data_stripes(const struct map_lookup *map)
     169             : {
     170           0 :         return map->num_stripes - btrfs_nr_parity_stripes(map->type);
     171             : }
     172             : 
     173           0 : static inline int nr_bioc_data_stripes(const struct btrfs_io_context *bioc)
     174             : {
     175           0 :         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             : void raid56_parity_cache_data_pages(struct btrfs_raid_bio *rbio,
     197             :                                     struct page **data_pages, u64 data_logical);
     198             : 
     199             : int btrfs_alloc_stripe_hash_table(struct btrfs_fs_info *info);
     200             : void btrfs_free_stripe_hash_table(struct btrfs_fs_info *info);
     201             : 
     202             : #endif