/* $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
[email protected]
* 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_ */
