home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / raid / raid5.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  11.0 KB  |  276 lines
  1. #ifndef _RAID5_H
  2. #define _RAID5_H
  3.  
  4. #include <linux/raid/md.h>
  5. #include <linux/raid/xor.h>
  6.  
  7. /*
  8.  *
  9.  * Each stripe contains one buffer per disc.  Each buffer can be in
  10.  * one of a number of states stored in "flags".  Changes between
  11.  * these states happen *almost* exclusively under a per-stripe
  12.  * spinlock.  Some very specific changes can happen in bi_end_io, and
  13.  * these are not protected by the spin lock.
  14.  *
  15.  * The flag bits that are used to represent these states are:
  16.  *   R5_UPTODATE and R5_LOCKED
  17.  *
  18.  * State Empty == !UPTODATE, !LOCK
  19.  *        We have no data, and there is no active request
  20.  * State Want == !UPTODATE, LOCK
  21.  *        A read request is being submitted for this block
  22.  * State Dirty == UPTODATE, LOCK
  23.  *        Some new data is in this buffer, and it is being written out
  24.  * State Clean == UPTODATE, !LOCK
  25.  *        We have valid data which is the same as on disc
  26.  *
  27.  * The possible state transitions are:
  28.  *
  29.  *  Empty -> Want   - on read or write to get old data for  parity calc
  30.  *  Empty -> Dirty  - on compute_parity to satisfy write/sync request.(RECONSTRUCT_WRITE)
  31.  *  Empty -> Clean  - on compute_block when computing a block for failed drive
  32.  *  Want  -> Empty  - on failed read
  33.  *  Want  -> Clean  - on successful completion of read request
  34.  *  Dirty -> Clean  - on successful completion of write request
  35.  *  Dirty -> Clean  - on failed write
  36.  *  Clean -> Dirty  - on compute_parity to satisfy write/sync (RECONSTRUCT or RMW)
  37.  *
  38.  * The Want->Empty, Want->Clean, Dirty->Clean, transitions
  39.  * all happen in b_end_io at interrupt time.
  40.  * Each sets the Uptodate bit before releasing the Lock bit.
  41.  * This leaves one multi-stage transition:
  42.  *    Want->Dirty->Clean
  43.  * This is safe because thinking that a Clean buffer is actually dirty
  44.  * will at worst delay some action, and the stripe will be scheduled
  45.  * for attention after the transition is complete.
  46.  *
  47.  * There is one possibility that is not covered by these states.  That
  48.  * is if one drive has failed and there is a spare being rebuilt.  We
  49.  * can't distinguish between a clean block that has been generated
  50.  * from parity calculations, and a clean block that has been
  51.  * successfully written to the spare ( or to parity when resyncing).
  52.  * To distingush these states we have a stripe bit STRIPE_INSYNC that
  53.  * is set whenever a write is scheduled to the spare, or to the parity
  54.  * disc if there is no spare.  A sync request clears this bit, and
  55.  * when we find it set with no buffers locked, we know the sync is
  56.  * complete.
  57.  *
  58.  * Buffers for the md device that arrive via make_request are attached
  59.  * to the appropriate stripe in one of two lists linked on b_reqnext.
  60.  * One list (bh_read) for read requests, one (bh_write) for write.
  61.  * There should never be more than one buffer on the two lists
  62.  * together, but we are not guaranteed of that so we allow for more.
  63.  *
  64.  * If a buffer is on the read list when the associated cache buffer is
  65.  * Uptodate, the data is copied into the read buffer and it's b_end_io
  66.  * routine is called.  This may happen in the end_request routine only
  67.  * if the buffer has just successfully been read.  end_request should
  68.  * remove the buffers from the list and then set the Uptodate bit on
  69.  * the buffer.  Other threads may do this only if they first check
  70.  * that the Uptodate bit is set.  Once they have checked that they may
  71.  * take buffers off the read queue.
  72.  *
  73.  * When a buffer on the write list is committed for write it is copied
  74.  * into the cache buffer, which is then marked dirty, and moved onto a
  75.  * third list, the written list (bh_written).  Once both the parity
  76.  * block and the cached buffer are successfully written, any buffer on
  77.  * a written list can be returned with b_end_io.
  78.  *
  79.  * The write list and read list both act as fifos.  The read list is
  80.  * protected by the device_lock.  The write and written lists are
  81.  * protected by the stripe lock.  The device_lock, which can be
  82.  * claimed while the stipe lock is held, is only for list
  83.  * manipulations and will only be held for a very short time.  It can
  84.  * be claimed from interrupts.
  85.  *
  86.  *
  87.  * Stripes in the stripe cache can be on one of two lists (or on
  88.  * neither).  The "inactive_list" contains stripes which are not
  89.  * currently being used for any request.  They can freely be reused
  90.  * for another stripe.  The "handle_list" contains stripes that need
  91.  * to be handled in some way.  Both of these are fifo queues.  Each
  92.  * stripe is also (potentially) linked to a hash bucket in the hash
  93.  * table so that it can be found by sector number.  Stripes that are
  94.  * not hashed must be on the inactive_list, and will normally be at
  95.  * the front.  All stripes start life this way.
  96.  *
  97.  * The inactive_list, handle_list and hash bucket lists are all protected by the
  98.  * device_lock.
  99.  *  - stripes on the inactive_list never have their stripe_lock held.
  100.  *  - stripes have a reference counter. If count==0, they are on a list.
  101.  *  - If a stripe might need handling, STRIPE_HANDLE is set.
  102.  *  - When refcount reaches zero, then if STRIPE_HANDLE it is put on
  103.  *    handle_list else inactive_list
  104.  *
  105.  * This, combined with the fact that STRIPE_HANDLE is only ever
  106.  * cleared while a stripe has a non-zero count means that if the
  107.  * refcount is 0 and STRIPE_HANDLE is set, then it is on the
  108.  * handle_list and if recount is 0 and STRIPE_HANDLE is not set, then
  109.  * the stripe is on inactive_list.
  110.  *
  111.  * The possible transitions are:
  112.  *  activate an unhashed/inactive stripe (get_active_stripe())
  113.  *     lockdev check-hash unlink-stripe cnt++ clean-stripe hash-stripe unlockdev
  114.  *  activate a hashed, possibly active stripe (get_active_stripe())
  115.  *     lockdev check-hash if(!cnt++)unlink-stripe unlockdev
  116.  *  attach a request to an active stripe (add_stripe_bh())
  117.  *     lockdev attach-buffer unlockdev
  118.  *  handle a stripe (handle_stripe())
  119.  *     lockstripe clrSTRIPE_HANDLE ... (lockdev check-buffers unlockdev) .. change-state .. record io needed unlockstripe schedule io
  120.  *  release an active stripe (release_stripe())
  121.  *     lockdev if (!--cnt) { if  STRIPE_HANDLE, add to handle_list else add to inactive-list } unlockdev
  122.  *
  123.  * The refcount counts each thread that have activated the stripe,
  124.  * plus raid5d if it is handling it, plus one for each active request
  125.  * on a cached buffer.
  126.  */
  127.  
  128. struct stripe_head {
  129.     struct hlist_node    hash;
  130.     struct list_head    lru;            /* inactive_list or handle_list */
  131.     struct raid5_private_data    *raid_conf;
  132.     sector_t        sector;            /* sector of this row */
  133.     int            pd_idx;            /* parity disk index */
  134.     unsigned long        state;            /* state flags */
  135.     atomic_t        count;            /* nr of active thread/requests */
  136.     spinlock_t        lock;
  137.     int            bm_seq;    /* sequence number for bitmap flushes */
  138.     int            disks;            /* disks in stripe */
  139.     struct r5dev {
  140.         struct bio    req;
  141.         struct bio_vec    vec;
  142.         struct page    *page;
  143.         struct bio    *toread, *towrite, *written;
  144.         sector_t    sector;            /* sector of this page */
  145.         unsigned long    flags;
  146.     } dev[1]; /* allocated with extra space depending of RAID geometry */
  147. };
  148. /* Flags */
  149. #define    R5_UPTODATE    0    /* page contains current data */
  150. #define    R5_LOCKED    1    /* IO has been submitted on "req" */
  151. #define    R5_OVERWRITE    2    /* towrite covers whole page */
  152. /* and some that are internal to handle_stripe */
  153. #define    R5_Insync    3    /* rdev && rdev->in_sync at start */
  154. #define    R5_Wantread    4    /* want to schedule a read */
  155. #define    R5_Wantwrite    5
  156. #define    R5_Overlap    7    /* There is a pending overlapping request on this block */
  157. #define    R5_ReadError    8    /* seen a read error here recently */
  158. #define    R5_ReWrite    9    /* have tried to over-write the readerror */
  159.  
  160. #define    R5_Expanded    10    /* This block now has post-expand data */
  161. /*
  162.  * Write method
  163.  */
  164. #define RECONSTRUCT_WRITE    1
  165. #define READ_MODIFY_WRITE    2
  166. /* not a write method, but a compute_parity mode */
  167. #define    CHECK_PARITY        3
  168.  
  169. /*
  170.  * Stripe state
  171.  */
  172. #define STRIPE_HANDLE        2
  173. #define    STRIPE_SYNCING        3
  174. #define    STRIPE_INSYNC        4
  175. #define    STRIPE_PREREAD_ACTIVE    5
  176. #define    STRIPE_DELAYED        6
  177. #define    STRIPE_DEGRADED        7
  178. #define    STRIPE_BIT_DELAY    8
  179. #define    STRIPE_EXPANDING    9
  180. #define    STRIPE_EXPAND_SOURCE    10
  181. #define    STRIPE_EXPAND_READY    11
  182. /*
  183.  * Plugging:
  184.  *
  185.  * To improve write throughput, we need to delay the handling of some
  186.  * stripes until there has been a chance that several write requests
  187.  * for the one stripe have all been collected.
  188.  * In particular, any write request that would require pre-reading
  189.  * is put on a "delayed" queue until there are no stripes currently
  190.  * in a pre-read phase.  Further, if the "delayed" queue is empty when
  191.  * a stripe is put on it then we "plug" the queue and do not process it
  192.  * until an unplug call is made. (the unplug_io_fn() is called).
  193.  *
  194.  * When preread is initiated on a stripe, we set PREREAD_ACTIVE and add
  195.  * it to the count of prereading stripes.
  196.  * When write is initiated, or the stripe refcnt == 0 (just in case) we
  197.  * clear the PREREAD_ACTIVE flag and decrement the count
  198.  * Whenever the delayed queue is empty and the device is not plugged, we
  199.  * move any strips from delayed to handle and clear the DELAYED flag and set PREREAD_ACTIVE.
  200.  * In stripe_handle, if we find pre-reading is necessary, we do it if
  201.  * PREREAD_ACTIVE is set, else we set DELAYED which will send it to the delayed queue.
  202.  * HANDLE gets cleared if stripe_handle leave nothing locked.
  203.  */
  204.  
  205.  
  206. struct disk_info {
  207.     mdk_rdev_t    *rdev;
  208. };
  209.  
  210. struct raid5_private_data {
  211.     struct hlist_head    *stripe_hashtbl;
  212.     mddev_t            *mddev;
  213.     struct disk_info    *spare;
  214.     int            chunk_size, level, algorithm;
  215.     int            raid_disks, working_disks, failed_disks;
  216.     int            max_nr_stripes;
  217.  
  218.     /* used during an expand */
  219.     sector_t        expand_progress;    /* MaxSector when no expand happening */
  220.     sector_t        expand_lo; /* from here up to expand_progress it out-of-bounds
  221.                         * as we haven't flushed the metadata yet
  222.                         */
  223.     int            previous_raid_disks;
  224.  
  225.     struct list_head    handle_list; /* stripes needing handling */
  226.     struct list_head    delayed_list; /* stripes that have plugged requests */
  227.     struct list_head    bitmap_list; /* stripes delaying awaiting bitmap update */
  228.     atomic_t        preread_active_stripes; /* stripes with scheduled io */
  229.  
  230.     atomic_t        reshape_stripes; /* stripes with pending writes for reshape */
  231.     /* unfortunately we need two cache names as we temporarily have
  232.      * two caches.
  233.      */
  234.     int            active_name;
  235.     char            cache_name[2][20];
  236.     kmem_cache_t        *slab_cache; /* for allocating stripes */
  237.  
  238.     int            seq_flush, seq_write;
  239.     int            quiesce;
  240.  
  241.     int            fullsync;  /* set to 1 if a full sync is needed,
  242.                         * (fresh device added).
  243.                         * Cleared when a sync completes.
  244.                         */
  245.  
  246.     struct page         *spare_page; /* Used when checking P/Q in raid6 */
  247.  
  248.     /*
  249.      * Free stripes pool
  250.      */
  251.     atomic_t        active_stripes;
  252.     struct list_head    inactive_list;
  253.     wait_queue_head_t    wait_for_stripe;
  254.     wait_queue_head_t    wait_for_overlap;
  255.     int            inactive_blocked;    /* release of inactive stripes blocked,
  256.                              * waiting for 25% to be free
  257.                              */
  258.     int            pool_size; /* number of disks in stripeheads in pool */
  259.     spinlock_t        device_lock;
  260.     struct disk_info    *disks;
  261. };
  262.  
  263. typedef struct raid5_private_data raid5_conf_t;
  264.  
  265. #define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private)
  266.  
  267. /*
  268.  * Our supported algorithms
  269.  */
  270. #define ALGORITHM_LEFT_ASYMMETRIC    0
  271. #define ALGORITHM_RIGHT_ASYMMETRIC    1
  272. #define ALGORITHM_LEFT_SYMMETRIC    2
  273. #define ALGORITHM_RIGHT_SYMMETRIC    3
  274.  
  275. #endif
  276.