LCOV - code coverage report
Current view: top level - drivers/md - raid1.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 7 7 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _RAID1_H
       2             : #define _RAID1_H
       3             : 
       4           2 : typedef struct mirror_info mirror_info_t;
       5           1 : 
       6             : struct mirror_info {
       7             :         mdk_rdev_t      *rdev;
       8             :         sector_t        head_position;
       9             : };
      10           1 : 
      11             : /*
      12             :  * memory pools need a pointer to the mddev, so they can force an unplug
      13             :  * when memory is tight, and a count of the number of drives that the
      14             :  * pool was allocated for, so they know how much to allocate and free.
      15             :  * mddev->raid_disks cannot be used, as it can change while a pool is active
      16             :  * These two datums are stored in a kmalloced struct.
      17             :  */
      18             : 
      19             : struct pool_info {
      20             :         mddev_t *mddev;
      21             :         int     raid_disks;
      22             : };
      23             : 
      24             : 
      25           2 : typedef struct r1bio_s r1bio_t;
      26           1 : 
      27             : struct r1_private_data_s {
      28             :         mddev_t                 *mddev;
      29             :         mirror_info_t           *mirrors;
      30             :         int                     raid_disks;
      31             :         int                     last_used;
      32             :         sector_t                next_seq_sect;
      33             :         spinlock_t              device_lock;
      34             : 
      35             :         struct list_head        retry_list;
      36             :         /* queue pending writes and submit them on unplug */
      37             :         struct bio_list         pending_bio_list;
      38             :         /* queue of writes that have been unplugged */
      39             :         struct bio_list         flushing_bio_list;
      40             : 
      41             :         /* for use when syncing mirrors: */
      42             : 
      43             :         spinlock_t              resync_lock;
      44             :         int                     nr_pending;
      45             :         int                     nr_waiting;
      46             :         int                     nr_queued;
      47             :         int                     barrier;
      48             :         sector_t                next_resync;
      49             :         int                     fullsync;  /* set to 1 if a full sync is needed,
      50             :                                             * (fresh device added).
      51             :                                             * Cleared when a sync completes.
      52             :                                             */
      53             : 
      54             :         wait_queue_head_t       wait_barrier;
      55             : 
      56             :         struct pool_info        *poolinfo;
      57             : 
      58             :         struct page             *tmppage;
      59             : 
      60             :         mempool_t *r1bio_pool;
      61             :         mempool_t *r1buf_pool;
      62             : 
      63             :         /* When taking over an array from a different personality, we store
      64             :          * the new thread here until we fully activate the array.
      65             :          */
      66             :         struct mdk_thread_s     *thread;
      67             : };
      68             : 
      69           1 : typedef struct r1_private_data_s conf_t;
      70           2 : 
      71             : /*
      72             :  * this is our 'private' RAID1 bio.
      73             :  *
      74             :  * it contains information about what kind of IO operations were started
      75             :  * for this RAID1 operation, and about their status:
      76             :  */
      77             : 
      78             : struct r1bio_s {
      79             :         atomic_t                remaining; /* 'have we finished' count,
      80             :                                             * used from IRQ handlers
      81             :                                             */
      82             :         atomic_t                behind_remaining; /* number of write-behind ios remaining
      83             :                                                  * in this BehindIO request
      84             :                                                  */
      85             :         sector_t                sector;
      86             :         int                     sectors;
      87             :         unsigned long           state;
      88             :         mddev_t                 *mddev;
      89             :         /*
      90             :          * original bio going to /dev/mdx
      91             :          */
      92             :         struct bio              *master_bio;
      93             :         /*
      94             :          * if the IO is in READ direction, then this is where we read
      95             :          */
      96             :         int                     read_disk;
      97             : 
      98             :         struct list_head        retry_list;
      99             :         struct bitmap_update    *bitmap_update;
     100             :         /*
     101             :          * if the IO is in WRITE direction, then multiple bios are used.
     102             :          * We choose the number when they are allocated.
     103             :          */
     104             :         struct bio              *bios[0];
     105             :         /* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
     106             : };
     107             : 
     108             : /* when we get a read error on a read-only array, we redirect to another
     109             :  * device without failing the first device, or trying to over-write to
     110             :  * correct the read error.  To keep track of bad blocks on a per-bio
     111             :  * level, we store IO_BLOCKED in the appropriate 'bios' pointer
     112             :  */
     113             : #define IO_BLOCKED ((struct bio*)1)
     114             : 
     115             : /* bits for r1bio.state */
     116             : #define R1BIO_Uptodate  0
     117             : #define R1BIO_IsSync    1
     118             : #define R1BIO_Degraded  2
     119             : #define R1BIO_BehindIO  3
     120             : #define R1BIO_Barrier   4
     121             : #define R1BIO_BarrierRetry 5
     122             : /* For write-behind requests, we call bi_end_io when
     123             :  * the last non-write-behind device completes, providing
     124             :  * any write was successful.  Otherwise we call when
     125             :  * any write-behind write succeeds, otherwise we call
     126             :  * with failure when last write completes (and all failed).
     127             :  * Record that bi_end_io was called with this flag...
     128             :  */
     129             : #define R1BIO_Returned 6
     130             : 
     131             : #endif

Generated by: LCOV version 1.10