sys/dev/raidframe/rf_raid.h

   1 /*      $NetBSD: rf_raid.h,v 1.37 2007/09/16 02:13:35 oster Exp $       */
   2 /*
   3  * Copyright (c) 1995 Carnegie-Mellon University.
   4  * All rights reserved.
   5  *
   6  * Author: Mark Holland
   7  *
   8  * Permission to use, copy, modify and distribute this software and
   9  * its documentation is hereby granted, provided that both the copyright
  10  * notice and this permission notice appear in all copies of the
  11  * software, derivative works or modified versions, and any portions
  12  * thereof, and that both notices appear in supporting documentation.
  13  *
  14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  16  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  17  *
  18  * Carnegie Mellon requests users of this software to return to
  19  *
  20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  21  *  School of Computer Science
  22  *  Carnegie Mellon University
  23  *  Pittsburgh PA 15213-3890
  24  *
  25  * any improvements or extensions that they make and grant Carnegie the
  26  * rights to redistribute these changes.
  27  */
  28
  29 /**********************************************
  30  * rf_raid.h -- main header file for RAID driver
  31  **********************************************/
  32
  33
  34 #ifndef _RF__RF_RAID_H_
  35 #define _RF__RF_RAID_H_
  36
  37 #include <dev/raidframe/raidframevar.h>
  38 #include "rf_archs.h"
  39 #include "rf_threadstuff.h"
  40
  41 #include "rf_netbsd.h"
  42
  43 #include <sys/disklabel.h>
  44 #include <sys/types.h>
  45 #include <sys/queue.h>
  46
  47 #include "rf_alloclist.h"
  48 #include "rf_stripelocks.h"
  49 #include "rf_layout.h"
  50 #include "rf_disks.h"
  51 #include "rf_debugMem.h"
  52 #include "rf_diskqueue.h"
  53 #include "rf_reconstruct.h"
  54 #include "rf_acctrace.h"
  55 #include "rf_fifo.h"
  56
  57 #if RF_INCLUDE_PARITYLOGGING > 0
  58 #include "rf_paritylog.h"
  59 #endif                          /* RF_INCLUDE_PARITYLOGGING > 0 */
  60
  61 #define RF_COMPONENT_LABEL_VERSION_1 1
  62 #define RF_COMPONENT_LABEL_VERSION 2
  63 #define RF_RAID_DIRTY 0
  64 #define RF_RAID_CLEAN 1
  65
  66
  67 /*
  68  * Each row in the array is a distinct parity group, so
  69  * each has it's own status, which is one of the following.
  70  */
  71 typedef enum RF_RowStatus_e {
  72         rf_rs_optimal,
  73         rf_rs_degraded,
  74         rf_rs_reconstructing,
  75         rf_rs_reconfigured
  76 }       RF_RowStatus_t;
  77
  78 struct RF_CumulativeStats_s {
  79         struct timeval start;   /* the time when the stats were last started */
  80         struct timeval stop;    /* the time when the stats were last stopped */
  81         long    sum_io_us;      /* sum of all user response times (us) */
  82         long    num_ios;        /* total number of I/Os serviced */
  83         long    num_sect_moved; /* total number of sectors read or written */
  84 };
  85
  86 struct RF_ThroughputStats_s {
  87         RF_DECLARE_MUTEX(mutex) /* a mutex used to lock the configuration
  88                                  * stuff */
  89         struct timeval start;   /* timer started when numOutstandingRequests
  90                                  * moves from 0 to 1 */
  91         struct timeval stop;    /* timer stopped when numOutstandingRequests
  92                                  * moves from 1 to 0 */
  93         RF_uint64 sum_io_us;    /* total time timer is enabled */
  94         RF_uint64 num_ios;      /* total number of ios processed by RAIDframe */
  95         long    num_out_ios;    /* number of outstanding ios */
  96 };
  97
  98 struct RF_Raid_s {
  99         /* This portion never changes, and can be accessed without locking */
 100         /* an exception is Disks[][].status, which requires locking when it is
 101          * changed.  XXX this is no longer true.  numSpare and friends can
 102          * change now.
 103          */
 104         u_int   numCol;         /* number of columns of disks, typically == #
 105                                  * of disks/rank */
 106         u_int   numSpare;       /* number of spare disks */
 107         int     maxQueueDepth;  /* max disk queue depth */
 108         RF_SectorCount_t totalSectors;  /* total number of sectors in the
 109                                          * array */
 110         RF_SectorCount_t sectorsPerDisk;        /* number of sectors on each
 111                                                  * disk */
 112         u_int   logBytesPerSector;      /* base-2 log of the number of bytes
 113                                          * in a sector */
 114         u_int   bytesPerSector; /* bytes in a sector */
 115         RF_int32 sectorMask;    /* mask of bytes-per-sector */
 116
 117         RF_RaidLayout_t Layout; /* all information related to layout */
 118         RF_RaidDisk_t *Disks;   /* all information related to physical disks */
 119         RF_DiskQueue_t *Queues;/* all information related to disk queues */
 120         const RF_DiskQueueSW_t *qType;/* pointer to the DiskQueueSW used for the
 121                                          component queues. */
 122         /* NOTE:  This is an anchor point via which the queues can be
 123          * accessed, but the enqueue/dequeue routines in diskqueue.c use a
 124          * local copy of this pointer for the actual accesses. */
 125         /* The remainder of the structure can change, and therefore requires
 126          * locking on reads and updates */
 127         RF_DECLARE_MUTEX(mutex) /* mutex used to serialize access to
 128                                  * the fields below */
 129         RF_RowStatus_t status;  /* the status of each row in the array */
 130         int     valid;          /* indicates successful configuration */
 131         RF_LockTableEntry_t *lockTable; /* stripe-lock table */
 132         RF_LockTableEntry_t *quiesceLock;       /* quiesnce table */
 133         int     numFailures;    /* total number of failures in the array */
 134         int     numNewFailures; /* number of *new* failures (that havn't
 135                                    caused a mod_counter update */
 136
 137         int     parity_good;    /* !0 if parity is known to be correct */
 138         int     serial_number;  /* a "serial number" for this set */
 139         int     mod_counter;    /* modification counter for component labels */
 140         int     clean;          /* completely unused and should be removed */
 141
 142         int     openings;       /* Number of IO's which can be scheduled
 143                                    simultaneously (high-level - not a
 144                                    per-component limit)*/
 145
 146         int maxOutstanding;   /* maxOutstanding requests (per-component) */
 147         int autoconfigure;    /* automatically configure this RAID set.
 148                                  0 == no, 1 == yes */
 149         int root_partition;   /* Use this set as /
 150                                  0 == no, 1 == yes*/
 151         int last_unit;        /* last unit number (e.g. 0 for /dev/raid0)
 152                                  of this component.  Used for autoconfigure
 153                                  only. */
 154         int config_order;     /* 0 .. n.  The order in which the component
 155                                  should be auto-configured.  E.g. 0 is will
 156                                  done first, (and would become raid0).
 157                                  This may be in conflict with last_unit!!?! */
 158                               /* Not currently used. */
 159
 160         /* queue to gather up requests from KernelWakeupFunc() and let
 161            a kernel thread deal with calling rf_DiskIOComplete and any
 162            callback functions. */
 163         TAILQ_HEAD(iodone_q,RF_DiskQueueData_s) iodone;
 164         /* and a lock to protect it */
 165         struct simplelock iodone_lock;
 166
 167
 168         RF_VoidPointerListElem_t *iobuf;       /* I/O buffer free list */
 169         int iobuf_count;             /* count of I/O buffers on the freelist */
 170         int numEmergencyBuffers;     /* number of these buffers to pre-allocate */
 171
 172         RF_VoidPointerListElem_t *stripebuf;   /* Full-stripe buffer free list */
 173         int stripebuf_count;           /* count of full-stripe buffers on the freelist */
 174         int numEmergencyStripeBuffers; /* number of these buffers to pre-allocate */
 175
 176         /*
 177          * Cleanup stuff
 178          */
 179         RF_ShutdownList_t *shutdownList;        /* shutdown activities */
 180         RF_AllocListElem_t *cleanupList;        /* memory to be freed at
 181                                                  * shutdown time */
 182
 183         /*
 184          * Recon stuff
 185          */
 186         RF_HeadSepLimit_t headSepLimit;
 187         int     numFloatingReconBufs;
 188         int     reconInProgress;
 189         RF_DECLARE_COND(waitForReconCond)
 190         RF_RaidReconDesc_t *reconDesc;  /* reconstruction descriptor */
 191         RF_ReconCtrl_t *reconControl;   /* reconstruction control structure
 192                                          * pointers for each row in the array */
 193
 194         /*
 195          * Array-quiescence stuff
 196          */
 197         RF_DECLARE_MUTEX(access_suspend_mutex)
 198         RF_IoCount_t accesses_suspended;
 199         RF_IoCount_t accs_in_flight;
 200         int     access_suspend_release;
 201         int     waiting_for_quiescence;
 202         RF_CallbackDesc_t *quiesce_wait_list;
 203
 204         /*
 205          * Statistics
 206          */
 207         RF_StripeCount_t     parity_rewrite_stripes_done;
 208         RF_StripeCount_t     copyback_stripes_done;
 209
 210         int     recon_in_progress;
 211         int     parity_rewrite_in_progress;
 212         int     copyback_in_progress;
 213         int     adding_hot_spare;
 214
 215         /*
 216          * Engine thread control
 217          */
 218         RF_DECLARE_MUTEX(node_queue_mutex)
 219         RF_DagNode_t *node_queue;
 220         RF_Thread_t parity_rewrite_thread;
 221         RF_Thread_t copyback_thread;
 222         RF_Thread_t engine_thread;
 223         RF_Thread_t engine_helper_thread;
 224         RF_Thread_t recon_thread;
 225         int     shutdown_engine;
 226         int     shutdown_raidio;
 227         int     dags_in_flight; /* debug */
 228
 229         /*
 230          * PSS (Parity Stripe Status) stuff
 231          */
 232         long    pssTableSize;
 233
 234         /*
 235          * Reconstruction stuff
 236          */
 237         int     procsInBufWait;
 238         int     numFullReconBuffers;
 239 #if RF_ACC_TRACE > 0
 240         RF_AccTraceEntry_t *recon_tracerecs;
 241 #endif
 242         unsigned long accumXorTimeUs;
 243
 244         /*
 245          * nAccOutstanding, waitShutdown protected by desc freelist lock
 246          * (This may seem strange, since that's a central serialization point
 247          * for a per-array piece of data, but otherwise, it'd be an extra
 248          * per-array lock, and that'd only be less efficient...)
 249          */
 250         RF_DECLARE_COND(outstandingCond)
 251         int     waitShutdown;
 252         int     nAccOutstanding;
 253
 254         RF_DiskId_t **diskids;
 255
 256         int     raidid;
 257         RF_AccTotals_t acc_totals;
 258         int     keep_acc_totals;
 259
 260         struct raidcinfo *raid_cinfo;   /* array of component info */
 261
 262         int     terminate_disk_queues;
 263
 264         /*
 265          * XXX
 266          *
 267          * config-specific information should be moved
 268          * somewhere else, or at least hung off this
 269          * in some generic way
 270          */
 271 #if RF_INCLUDE_CHAINDECLUSTER > 0
 272
 273         /* used by rf_compute_workload_shift */
 274         RF_RowCol_t hist_diskreq[RF_MAXCOL];
 275 #endif
 276         /* used by declustering */
 277         int     noRotate;
 278
 279 #if RF_INCLUDE_PARITYLOGGING > 0
 280         /* used by parity logging */
 281         RF_SectorCount_t regionLogCapacity;
 282         RF_ParityLogQueue_t parityLogPool;      /* pool of unused parity logs */
 283         RF_RegionInfo_t *regionInfo;    /* array of region state */
 284         int     numParityLogs;
 285         int     numSectorsPerLog;
 286         int     regionParityRange;
 287         int     logsInUse;      /* debugging */
 288         RF_ParityLogDiskQueue_t parityLogDiskQueue;     /* state of parity
 289                                                          * logging disk work */
 290         RF_RegionBufferQueue_t regionBufferPool;        /* buffers for holding
 291                                                          * region log */
 292         RF_RegionBufferQueue_t parityBufferPool;        /* buffers for holding
 293                                                          * parity */
 294         void *parityLogBufferHeap;      /* pool of unused parity logs */
 295         RF_Thread_t pLogDiskThreadHandle;
 296
 297 #endif                          /* RF_INCLUDE_PARITYLOGGING > 0 */
 298         struct rf_paritymap *parity_map;
 299 };
 300 #endif                          /* !_RF__RF_RAID_H_ */