/* $NetBSD: rf_raid.h,v 1.53 2023/09/25 21:59:38 oster Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. * * Author: Mark Holland * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. */ /********************************************** * rf_raid.h -- main header file for RAID driver **********************************************/ #ifndef _RF__RF_RAID_H_ #define _RF__RF_RAID_H_ #include <dev/raidframe/raidframevar.h> #include "rf_archs.h" #include "rf_threadstuff.h" #include "rf_netbsd.h" #include <sys/disklabel.h> #include <sys/types.h> #include <sys/queue.h> #include "rf_alloclist.h" #include "rf_stripelocks.h" #include "rf_layout.h" #include "rf_disks.h" #include "rf_debugMem.h" #include "rf_diskqueue.h" #include "rf_reconstruct.h" #include "rf_acctrace.h" #include "rf_fifo.h" #if RF_INCLUDE_PARITYLOGGING > 0 #include "rf_paritylog.h" #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ #define RF_COMPONENT_LABEL_VERSION_1 1 #define RF_COMPONENT_LABEL_VERSION 2 #define RF_RAID_DIRTY 0 #define RF_RAID_CLEAN 1 /* * Each row in the array is a distinct parity group, so * each has its own status, which is one of the following. */ typedef enum RF_RowStatus_e { rf_rs_optimal, rf_rs_degraded, rf_rs_reconstructing, rf_rs_reconfigured } RF_RowStatus_t; struct RF_CumulativeStats_s { struct timeval start; /* the time when the stats were last started */ struct timeval stop; /* the time when the stats were last stopped */ long sum_io_us; /* sum of all user response times (us) */ long num_ios; /* total number of I/Os serviced */ long num_sect_moved; /* total number of sectors read or written */ }; struct RF_ThroughputStats_s { rf_declare_mutex2(mutex);/* a mutex used to lock the configuration * stuff */ struct timeval start; /* timer started when numOutstandingRequests * moves from 0 to 1 */ struct timeval stop; /* timer stopped when numOutstandingRequests * moves from 1 to 0 */ RF_uint64 sum_io_us; /* total time timer is enabled */ RF_uint64 num_ios; /* total number of ios processed by RAIDframe */ long num_out_ios; /* number of outstanding ios */ }; struct RF_Raid_s { /* This portion never changes, and can be accessed without locking */ /* an exception is Disks[][].status, which requires locking when it is * changed. XXX this is no longer true. numSpare and friends can * change now. */ u_int numCol; /* number of columns of disks, typically == # * of disks/rank */ u_int numSpare; /* number of spare disks */ int maxQueueDepth; /* max disk queue depth */ RF_SectorCount_t totalSectors; /* total number of sectors in the * array */ RF_SectorCount_t sectorsPerDisk; /* number of sectors on each * disk */ u_int logBytesPerSector; /* base-2 log of the number of bytes * in a sector */ u_int bytesPerSector; /* bytes in a sector */ RF_int32 sectorMask; /* mask of bytes-per-sector */ RF_RaidLayout_t Layout; /* all information related to layout */ RF_RaidDisk_t *Disks; /* all information related to physical disks */ RF_DiskQueue_t *Queues; /* all information related to disk queues */ u_int maxQueue; /* initialized queues in Queues array */ const RF_DiskQueueSW_t *qType;/* pointer to the DiskQueueSW used for the component queues. */ /* NOTE: This is an anchor point via which the queues can be * accessed, but the enqueue/dequeue routines in diskqueue.c use a * local copy of this pointer for the actual accesses. */ /* The remainder of the structure can change, and therefore requires * locking on reads and updates */ rf_declare_mutex2(mutex);/* mutex used to serialize access to * the fields below */ RF_RowStatus_t status; /* the status of each row in the array */ int valid; /* indicates successful configuration */ RF_LockTableEntry_t *lockTable; /* stripe-lock table */ RF_LockTableEntry_t *quiesceLock; /* quiesnce table */ int numFailures; /* total number of failures in the array */ int numNewFailures; /* number of *new* failures (that havn't caused a mod_counter update */ int parity_good; /* !0 if parity is known to be correct */ int serial_number; /* a "serial number" for this set */ int mod_counter; /* modification counter for component labels */ int clean; /* completely unused and should be removed */ int openings; /* Number of IO's which can be scheduled simultaneously (high-level - not a per-component limit)*/ int maxOutstanding; /* maxOutstanding requests (per-component) */ int autoconfigure; /* automatically configure this RAID set. 0 == no, 1 == yes */ int root_partition; /* Use this set as / 0 == no, 1 == yes*/ int last_unit; /* last unit number (e.g. 0 for /dev/raid0) of this component. Used for autoconfigure only. */ int config_order; /* 0 .. n. The order in which the component should be auto-configured. E.g. 0 is will done first, (and would become raid0). This may be in conflict with last_unit!!?! */ /* Not currently used. */ /* queue to gather up requests from KernelWakeupFunc() and let a kernel thread deal with calling rf_DiskIOComplete and any callback functions. */ TAILQ_HEAD(iodone_q,RF_DiskQueueData_s) iodone; /* and a lock/cv to protect it */ rf_declare_mutex2(iodone_lock); rf_declare_cond2(iodone_cv); RF_VoidPointerListElem_t *iobuf; /* I/O buffer free list */ int iobuf_count; /* count of I/O buffers on the freelist */ int numEmergencyBuffers; /* number of these buffers to pre-allocate */ RF_VoidPointerListElem_t *stripebuf; /* Full-stripe buffer free list */ int stripebuf_count; /* count of full-stripe buffers on the freelist */ int numEmergencyStripeBuffers; /* number of these buffers to pre-allocate */ /* * Cleanup stuff */ RF_ShutdownList_t *shutdownList; /* shutdown activities */ RF_AllocListElem_t *cleanupList; /* memory to be freed at * shutdown time */ /* * Recon stuff */ RF_HeadSepLimit_t headSepLimit; int numFloatingReconBufs; int reconInProgress; int forceRecon; rf_declare_cond2(waitForReconCond); /* goes with raidPtr->mutex */ RF_RaidReconDesc_t *reconDesc; /* reconstruction descriptor */ RF_ReconCtrl_t *reconControl; /* reconstruction control structure * pointers for each row in the array */ /* * Array-quiescence stuff */ rf_declare_mutex2(access_suspend_mutex); rf_declare_cond2(access_suspend_cv); RF_IoCount_t accesses_suspended; RF_IoCount_t accs_in_flight; int access_suspend_release; int waiting_for_quiescence; RF_CallbackFuncDesc_t *quiesce_wait_list; /* * Statistics */ RF_StripeCount_t parity_rewrite_stripes_done; int recon_in_progress; int parity_rewrite_in_progress; int changing_components; rf_declare_cond2(parity_rewrite_cv); rf_declare_cond2(changing_components_cv); /* * Engine thread control */ rf_declare_mutex2(node_queue_mutex); rf_declare_cond2(node_queue_cv); RF_DagNode_t *node_queue; RF_Thread_t parity_rewrite_thread; RF_Thread_t engine_thread; RF_Thread_t engine_helper_thread; RF_Thread_t recon_thread; int shutdown_engine; int shutdown_raidio; int dags_in_flight; /* debug */ /* * PSS (Parity Stripe Status) stuff */ long pssTableSize; /* * Reconstruction stuff */ int procsInBufWait; int numFullReconBuffers; #if RF_ACC_TRACE > 0 RF_AccTraceEntry_t *recon_tracerecs; #endif unsigned long accumXorTimeUs; /* * nAccOutstanding, waitShutdown protected by desc freelist lock * (This may seem strange, since that's a central serialization point * for a per-array piece of data, but otherwise, it'd be an extra * per-array lock, and that'd only be less efficient...) */ rf_declare_mutex2(rad_lock); rf_declare_cond2(outstandingCond); int waitShutdown; int nAccOutstanding; int *abortRecon; /* Abort background operations requested */ RF_DiskId_t **diskids; int raidid; void *softc; RF_AccTotals_t acc_totals; int keep_acc_totals; struct raidcinfo *raid_cinfo; /* array of component info */ int terminate_disk_queues; /* * XXX * * config-specific information should be moved * somewhere else, or at least hung off this * in some generic way */ #if RF_INCLUDE_CHAINDECLUSTER > 0 /* used by rf_compute_workload_shift */ RF_RowCol_t hist_diskreq[RF_MAXCOL]; #endif /* used by declustering */ int noRotate; #if RF_INCLUDE_PARITYLOGGING > 0 /* used by parity logging */ RF_SectorCount_t regionLogCapacity; RF_ParityLogQueue_t parityLogPool; /* pool of unused parity logs */ RF_RegionInfo_t *regionInfo; /* array of region state */ int numParityLogs; int numSectorsPerLog; int regionParityRange; int logsInUse; /* debugging */ RF_ParityLogDiskQueue_t parityLogDiskQueue; /* state of parity * logging disk work */ RF_RegionBufferQueue_t regionBufferPool; /* buffers for holding * region log */ RF_RegionBufferQueue_t parityBufferPool; /* buffers for holding * parity */ void *parityLogBufferHeap; /* pool of unused parity logs */ RF_Thread_t pLogDiskThreadHandle; #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ struct rf_paritymap *parity_map; struct RF_Pools_s pools; struct RF_PoolNames_s poolNames; }; struct raid_softc { struct dk_softc sc_dksc; int sc_unit; int sc_flags; /* flags */ int sc_cflags; /* configuration flags */ kmutex_t sc_mutex; /* interlock mutex */ kcondvar_t sc_cv; /* and the condvar */ uint64_t sc_size; /* size of the raid device */ char sc_xname[20]; /* XXX external name */ RF_Raid_t sc_r; LIST_ENTRY(raid_softc) sc_link; }; /* sc_flags */ #define RAIDF_INITED 0x01 /* unit has been initialized */ #define RAIDF_SHUTDOWN 0x02 /* unit is being shutdown */ #define RAIDF_DETACH 0x04 /* detach after final close */ #define RAIDF_WANTED 0x08 /* someone waiting to obtain a lock */ #define RAIDF_LOCKED 0x10 /* unit is locked */ #define RAIDF_UNIT_CHANGED 0x20 /* unit is being changed */ int rf_fail_disk(RF_Raid_t *, struct rf_recon_req *); int rf_inited(const struct raid_softc *); int rf_get_unit(const struct raid_softc *); RF_Raid_t *rf_get_raid(struct raid_softc *); int rf_construct(struct raid_softc *, RF_Config_t *); #endif /* !_RF__RF_RAID_H_ */
