![[BACK]](/icons/back.gif){kind=icon}
Return to rf_raid.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_raid.h CVS log | Up to [local] / sys / dev / raidframe |
1.1 ! nbrk 1: /* $OpenBSD: rf_raid.h,v 1.8 2007/04/10 17:47:55 miod Exp $ */
! 2: /* $NetBSD: rf_raid.h,v 1.12 2000/02/24 17:12:10 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: Mark Holland
! 9: *
! 10: * Permission to use, copy, modify and distribute this software and
! 11: * its documentation is hereby granted, provided that both the copyright
! 12: * notice and this permission notice appear in all copies of the
! 13: * software, derivative works or modified versions, and any portions
! 14: * thereof, and that both notices appear in supporting documentation.
! 15: *
! 16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
! 18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 19: *
! 20: * Carnegie Mellon requests users of this software to return to
! 21: *
! 22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 23: * School of Computer Science
! 24: * Carnegie Mellon University
! 25: * Pittsburgh PA 15213-3890
! 26: *
! 27: * any improvements or extensions that they make and grant Carnegie the
! 28: * rights to redistribute these changes.
! 29: */
! 30:
! 31: /*************************************************
! 32: * rf_raid.h -- Main header file for RAID driver.
! 33: *************************************************/
! 34:
! 35:
! 36: #ifndef _RF__RF_RAID_H_
! 37: #define _RF__RF_RAID_H_
! 38:
! 39: #include "rf_archs.h"
! 40: #include "rf_types.h"
! 41: #include "rf_threadstuff.h"
! 42:
! 43: #if defined(__NetBSD__)
! 44: #include "rf_netbsd.h"
! 45: #elif defined(__OpenBSD__)
! 46: #include "rf_openbsd.h"
! 47: #endif
! 48:
! 49: #include <sys/disklabel.h>
! 50: #include <sys/types.h>
! 51:
! 52: #include "rf_alloclist.h"
! 53: #include "rf_stripelocks.h"
! 54: #include "rf_layout.h"
! 55: #include "rf_disks.h"
! 56: #include "rf_debugMem.h"
! 57: #include "rf_diskqueue.h"
! 58: #include "rf_reconstruct.h"
! 59: #include "rf_acctrace.h"
! 60:
! 61: #if RF_INCLUDE_PARITYLOGGING > 0
! 62: #include "rf_paritylog.h"
! 63: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
! 64:
! 65: #define RF_MAX_DISKS 128 /* Max disks per array. */
! 66: #define RF_DEV2RAIDID(_dev) (DISKUNIT(_dev))
! 67:
! 68: #define RF_COMPONENT_LABEL_VERSION_1 1
! 69: #define RF_COMPONENT_LABEL_VERSION 2
! 70: #define RF_RAID_DIRTY 0
! 71: #define RF_RAID_CLEAN 1
! 72:
! 73: /*
! 74: * Each row in the array is a distinct parity group, so
! 75: * each has its own status, which is one of the following.
! 76: */
! 77: typedef enum RF_RowStatus_e {
! 78: rf_rs_optimal,
! 79: rf_rs_degraded,
! 80: rf_rs_reconstructing,
! 81: rf_rs_reconfigured
! 82: } RF_RowStatus_t;
! 83:
! 84: struct RF_CumulativeStats_s {
! 85: struct timeval start; /*
! 86: * The time when the stats were
! 87: * last started.
! 88: */
! 89: struct timeval stop; /*
! 90: * The time when the stats were
! 91: * last stopped.
! 92: */
! 93: long sum_io_us; /*
! 94: * Sum of all user response
! 95: * times (us).
! 96: */
! 97: long num_ios; /*
! 98: * Total number of I/Os
! 99: * serviced.
! 100: */
! 101: long num_sect_moved; /*
! 102: * Total number of sectors read
! 103: * or written.
! 104: */
! 105: };
! 106:
! 107: struct RF_ThroughputStats_s {
! 108: RF_DECLARE_MUTEX (mutex); /*
! 109: * A mutex used to lock the
! 110: * configuration stuff.
! 111: */
! 112: struct timeval start; /*
! 113: * Timer started when
! 114: * numOutstandingRequests
! 115: * moves from 0 to 1.
! 116: */
! 117: struct timeval stop; /*
! 118: * Timer stopped when
! 119: * numOutstandingRequests
! 120: * moves from 1 to 0.
! 121: */
! 122: RF_uint64 sum_io_us; /*
! 123: * Total time timer is enabled.
! 124: */
! 125: RF_uint64 num_ios; /*
! 126: * Total number of I/Os
! 127: * processed by RAIDframe.
! 128: */
! 129: long num_out_ios; /*
! 130: * Number of outstanding I/Os.
! 131: */
! 132: };
! 133:
! 134: struct RF_Raid_s {
! 135: /* This portion never changes, and can be accessed without locking */
! 136: /*
! 137: * An exception is Disks[][].status, which requires locking when it is
! 138: * changed. XXX This is no longer true. numSpare and friends can
! 139: * change now.
! 140: */
! 141: u_int numRow; /*
! 142: * Number of rows of disks,
! 143: * typically == # of ranks.
! 144: */
! 145: u_int numCol; /*
! 146: * Number of columns of disks,
! 147: * typically == # of disks/rank.
! 148: */
! 149: u_int numSpare; /* Number of spare disks. */
! 150: int maxQueueDepth;/* Max disk queue depth. */
! 151: RF_SectorCount_t totalSectors; /*
! 152: * Total number of sectors
! 153: * in the array.
! 154: */
! 155: RF_SectorCount_t sectorsPerDisk;
! 156: /*
! 157: * Number of sectors on each
! 158: * disk.
! 159: */
! 160: u_int logBytesPerSector;
! 161: /*
! 162: * Base-2 log of the number
! 163: * of bytes in a sector.
! 164: */
! 165: u_int bytesPerSector;
! 166: /* Bytes in a sector. */
! 167: RF_int32 sectorMask; /* Mask of bytes-per-sector. */
! 168:
! 169: RF_RaidLayout_t Layout; /*
! 170: * All information related to
! 171: * layout.
! 172: */
! 173: RF_RaidDisk_t **Disks; /*
! 174: * All information related to
! 175: * physical disks.
! 176: */
! 177: RF_DiskQueue_t **Queues; /*
! 178: * All information related to
! 179: * disk queues.
! 180: */
! 181: RF_DiskQueueSW_t *qType; /*
! 182: * Pointer to the DiskQueueSW
! 183: * used for the component
! 184: * queues.
! 185: */
! 186: /*
! 187: * NOTE: This is an anchor point via which the queues can be
! 188: * accessed, but the enqueue/dequeue routines in diskqueue.c use a
! 189: * local copy of this pointer for the actual accesses.
! 190: */
! 191: /*
! 192: * The remainder of the structure can change, and therefore requires
! 193: * locking on reads and updates.
! 194: */
! 195: RF_DECLARE_MUTEX (mutex); /*
! 196: * Mutex used to serialize
! 197: * access to the fields below.
! 198: */
! 199: RF_RowStatus_t *status; /*
! 200: * The status of each row in
! 201: * the array.
! 202: */
! 203: int valid; /*
! 204: * Indicates successful
! 205: * configuration.
! 206: */
! 207: RF_LockTableEntry_t *lockTable; /* Stripe-lock table. */
! 208: RF_LockTableEntry_t *quiesceLock; /* Quiescence table. */
! 209: int numFailures; /*
! 210: * Total number of failures
! 211: * in the array.
! 212: */
! 213: int numNewFailures;
! 214: /*
! 215: * Number of *new* failures
! 216: * (that haven't caused a
! 217: * mod_counter update).
! 218: */
! 219:
! 220: int parity_good; /*
! 221: * !0 if parity is known to be
! 222: * correct.
! 223: */
! 224: int serial_number;/*
! 225: * A "serial number" for this
! 226: * set.
! 227: */
! 228: int mod_counter; /*
! 229: * Modification counter for
! 230: * component labels.
! 231: */
! 232: int clean; /*
! 233: * The clean bit for this array.
! 234: */
! 235:
! 236: int openings; /*
! 237: * Number of I/Os that can be
! 238: * scheduled simultaneously
! 239: * (high-level - not a
! 240: * per-component limit).
! 241: */
! 242:
! 243: int maxOutstanding;
! 244: /*
! 245: * maxOutstanding requests
! 246: * (per-component).
! 247: */
! 248: int autoconfigure;
! 249: /*
! 250: * Automatically configure
! 251: * this RAID set.
! 252: * 0 == no, 1 == yes
! 253: */
! 254: int root_partition;
! 255: /*
! 256: * Use this set as
! 257: * 0 == no, 1 == yes.
! 258: */
! 259: int last_unit; /*
! 260: * Last unit number (e.g. 0
! 261: * for /dev/raid0) of this
! 262: * component. Used for
! 263: * autoconfigure only.
! 264: */
! 265: int config_order; /*
! 266: * 0 .. n. The order in which
! 267: * the component should be
! 268: * auto-configured.
! 269: * E.g. 0 is will done first,
! 270: * (and would become raid0).
! 271: * This may be in conflict
! 272: * with last_unit !!?!
! 273: */
! 274: /* Not currently used. */
! 275:
! 276: /*
! 277: * Cleanup stuff.
! 278: */
! 279: RF_ShutdownList_t *shutdownList; /* Shutdown activities. */
! 280: RF_AllocListElem_t *cleanupList; /*
! 281: * Memory to be freed at
! 282: * shutdown time.
! 283: */
! 284:
! 285: /*
! 286: * Recon stuff.
! 287: */
! 288: RF_HeadSepLimit_t headSepLimit;
! 289: int numFloatingReconBufs;
! 290: int reconInProgress;
! 291: RF_DECLARE_COND (waitForReconCond);
! 292: RF_RaidReconDesc_t *reconDesc; /* Reconstruction descriptor. */
! 293: RF_ReconCtrl_t **reconControl; /*
! 294: * Reconstruction control
! 295: * structure pointers for each
! 296: * row in the array.
! 297: */
! 298:
! 299: /*
! 300: * Array-quiescence stuff.
! 301: */
! 302: RF_DECLARE_MUTEX (access_suspend_mutex);
! 303: RF_DECLARE_COND (quiescent_cond);
! 304: RF_IoCount_t accesses_suspended;
! 305: RF_IoCount_t accs_in_flight;
! 306: int access_suspend_release;
! 307: int waiting_for_quiescence;
! 308: RF_CallbackDesc_t *quiesce_wait_list;
! 309:
! 310: /*
! 311: * Statistics.
! 312: */
! 313: #if !defined(_KERNEL) && !defined(SIMULATE)
! 314: RF_ThroughputStats_t throughputstats;
! 315: #endif /* !_KERNEL && !SIMULATE */
! 316: RF_CumulativeStats_t userstats;
! 317: int parity_rewrite_stripes_done;
! 318: int recon_stripes_done;
! 319: int copyback_stripes_done;
! 320:
! 321: int recon_in_progress;
! 322: int parity_rewrite_in_progress;
! 323: int copyback_in_progress;
! 324:
! 325: /*
! 326: * Engine thread control.
! 327: */
! 328: RF_DECLARE_MUTEX (node_queue_mutex);
! 329: RF_DECLARE_COND (node_queue_cond);
! 330: RF_DagNode_t *node_queue;
! 331: RF_Thread_t parity_rewrite_thread;
! 332: RF_Thread_t copyback_thread;
! 333: RF_Thread_t engine_thread;
! 334: RF_Thread_t recon_thread;
! 335: RF_ThreadGroup_t engine_tg;
! 336: int shutdown_engine;
! 337: int dags_in_flight; /* Debug. */
! 338:
! 339: /*
! 340: * PSS (Parity Stripe Status) stuff.
! 341: */
! 342: RF_FreeList_t *pss_freelist;
! 343: long pssTableSize;
! 344:
! 345: /*
! 346: * Reconstruction stuff.
! 347: */
! 348: int procsInBufWait;
! 349: int numFullReconBuffers;
! 350: RF_AccTraceEntry_t *recon_tracerecs;
! 351: unsigned long accumXorTimeUs;
! 352: RF_ReconDoneProc_t *recon_done_procs;
! 353: RF_DECLARE_MUTEX (recon_done_proc_mutex);
! 354: /*
! 355: * nAccOutstanding, waitShutdown protected by desc freelist lock
! 356: * (This may seem strange, since that's a central serialization point
! 357: * for a per-array piece of data, but otherwise, it'd be an extra
! 358: * per-array lock, and that'd only be less efficient...)
! 359: */
! 360: RF_DECLARE_COND (outstandingCond);
! 361: int waitShutdown;
! 362: int nAccOutstanding;
! 363:
! 364: RF_DiskId_t **diskids;
! 365: RF_DiskId_t *sparediskids;
! 366:
! 367: int raidid;
! 368: RF_AccTotals_t acc_totals;
! 369: int keep_acc_totals;
! 370:
! 371: struct raidcinfo **raid_cinfo; /* Array of component info. */
! 372:
! 373: int terminate_disk_queues;
! 374:
! 375: /*
! 376: * XXX
! 377: *
! 378: * Config-specific information should be moved
! 379: * somewhere else, or at least hung off this
! 380: * in some generic way.
! 381: */
! 382:
! 383: /* Used by rf_compute_workload_shift. */
! 384: RF_RowCol_t hist_diskreq[RF_MAXROW][RF_MAXCOL];
! 385:
! 386: /* Used by declustering. */
! 387: int noRotate;
! 388:
! 389: #if RF_INCLUDE_PARITYLOGGING > 0
! 390: /* used by parity logging */
! 391: RF_SectorCount_t regionLogCapacity;
! 392: RF_ParityLogQueue_t parityLogPool;/*
! 393: * Pool of unused parity logs.
! 394: */
! 395: RF_RegionInfo_t *regionInfo; /* Array of region state. */
! 396: int numParityLogs;
! 397: int numSectorsPerLog;
! 398: int regionParityRange;
! 399: int logsInUse; /* Debugging. */
! 400: RF_ParityLogDiskQueue_t parityLogDiskQueue;
! 401: /*
! 402: * State of parity logging
! 403: * disk work.
! 404: */
! 405: RF_RegionBufferQueue_t regionBufferPool;
! 406: /*
! 407: * buffers for holding region
! 408: * log.
! 409: */
! 410: RF_RegionBufferQueue_t parityBufferPool;
! 411: /*
! 412: * Buffers for holding parity.
! 413: */
! 414: caddr_t parityLogBufferHeap;
! 415: /*
! 416: * Pool of unused parity logs.
! 417: */
! 418: RF_Thread_t pLogDiskThreadHandle;
! 419:
! 420: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
! 421: };
! 422:
! 423: #endif /* !_RF__RF_RAID_H_ */