Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/raidframe/rf_dagutils.h

121 lines
4.1 KiB
C
Raw Normal View History

merge ktrace-lwp.
2005-12-11 15:16:03 +03:00
/* $NetBSD: rf_dagutils.h,v 1.20 2005/12/11 12:23:37 christos Exp $ */
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Mark Holland, William V. Courtright II
*
* 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_dagutils.h -- header file for utility routines for manipulating DAGs
*
*************************************************************************/
Step 2 of the disentanglement. We now look to <dev/raidframe/*> for the stuff that used to live in rf_types.h, rf_raidframe.h, rf_layout.h, rf_netbsd.h, rf_raid.h, rf_decluster,h, and a few other places. Believe it or not, when this is all done, things will be cleaner. No functional changes to RAIDframe.
2001-10-04 19:58:51 +04:00
#include <dev/raidframe/raidframevar.h>
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
#include "rf_dagfuncs.h"
#include "rf_general.h"
#ifndef _RF__RF_DAGUTILS_H_
#define _RF__RF_DAGUTILS_H_
struct RF_RedFuncs_s {
Phase 2 of the RAIDframe cleanup. The source is now closer to KNF and is much easier to read. No functionality changes.
1999-02-05 03:06:06 +03:00
int (*regular) (RF_DagNode_t *);
- avoid variable shadowing - add a lot of const - remove parameters from functin declarations
2005-05-30 02:03:09 +04:00
const char *RegularName;
Phase 2 of the RAIDframe cleanup. The source is now closer to KNF and is much easier to read. No functionality changes.
1999-02-05 03:06:06 +03:00
int (*simple) (RF_DagNode_t *);
- avoid variable shadowing - add a lot of const - remove parameters from functin declarations
2005-05-30 02:03:09 +04:00
const char *SimpleName;
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
};
Stripe functions are now handled by a linked-list instead of a runtime-variable array. Fix a bug where stripeFuncs was being freed, and then being used after (in the case of numStripesBailed > 0).
2004-02-29 04:24:34 +03:00
typedef struct RF_FuncList_s {
RF_VoidFuncPtr fp;
struct RF_FuncList_s *next;
} RF_FuncList_t;
constify some
2003-02-09 13:04:32 +03:00
extern const RF_RedFuncs_t rf_xorFuncs;
extern const RF_RedFuncs_t rf_xorRecoveryFuncs;
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
Cleanup function prototypes.
2004-03-20 19:48:05 +03:00
void rf_InitNode(RF_DagNode_t *, RF_NodeStatus_t, int,
- avoid variable shadowing - add a lot of const - remove parameters from functin declarations
2005-05-30 02:03:09 +04:00
int (*) (RF_DagNode_t *),
int (*) (RF_DagNode_t *),
int (*) (RF_DagNode_t *, int),
nuke trailing whitespace
2005-02-27 03:26:58 +03:00
int, int, int, int, RF_DagHeader_t *,
- avoid variable shadowing - add a lot of const - remove parameters from functin declarations
2005-05-30 02:03:09 +04:00
const char *, RF_AllocListElem_t *);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
Cleanup function prototypes.
2004-03-20 19:48:05 +03:00
void rf_FreeDAG(RF_DagHeader_t *);
int rf_ConfigureDAGs(RF_ShutdownList_t **);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
Minor cleanup/reformatting.
2002-09-21 18:47:07 +04:00
RF_DagHeader_t *rf_AllocDAGHeader(void);
void rf_FreeDAGHeader(RF_DagHeader_t * dh);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
- Introduce a 'dagnode' pool. Initialize it and allow for cleanup. Provide rf_AllocDAGNode() and rf_FreeDAGNode() to handle allocation/freeing. - Introduce a "nodes" linked list of RF_DagNode_t's into the DAG header. Initialize nodes in InitHdrNode(). Arrange for nodes cleanup in rf_FreeDAG(). - Add a "list_next" to RF_DagNode_t to keep track of nodes on the above "nodes" list. (This is distinct from the "next" field of RF_DagNode_t, which keeps track of the firing order of nodes.) "list_next" gets used in the cleanup routines, and in traversing through a set of nodes that belong to a particular set of nodes (e.g. those belonging to xorNodes for a given DAG). - use rf_AllocDAGNode() instead of mallocs of variable-sized arrays of RF_DagNode_t's. Mostly mechanical changes to convert the DAG construction from "access nodes via an array index" to "access nodes via a 'nextnode' pointer". - rework a couple of tricky spots where assumptions about the node order was being abused. - performance remains consistent with performance before these changes. [Thanks to Simon Burge (simonb at you.know.where) for looking over the mechanical changes to make sure I didn't biff anything.]
2004-03-18 19:40:05 +03:00
RF_DagNode_t *rf_AllocDAGNode(void);
void rf_FreeDAGNode(RF_DagNode_t *);
Use a dynamically allocated linked list of dagLists instead of using a dynamically allocated variable-sized array (dagArray). Convert code to use the new linked list stuff instead of the array stuff (the ratio of one dagList per stripe still applies). The big advantage is in being able to more efficiently allocate the dagLists on-the-fly, and not have to know the size(s) of the array beforehand.
2004-02-27 05:55:17 +03:00
RF_DagList_t *rf_AllocDAGList(void);
void rf_FreeDAGList(RF_DagList_t *);
Introduce a dual-purpose pool for providing pointer and param "caches" for RF_DagNode_t's. Scale the structure size based on RF_MAXCOL. Use the new allocation method in InitNode(). Note that we can't get rid of the mallocs in there until we can prove that this new allocation method is a strict upper bound. Unless someone tries running a RAID set with 40 components, the mallocs here shouldn't shouldn't be an issue. (and if someone does make a set with 40 components they will run into other issues with other constants long before then)
2004-03-19 20:01:26 +03:00
void *rf_AllocDAGPCache(void);
void rf_FreeDAGPCache(void *);
Stripe functions are now handled by a linked-list instead of a runtime-variable array. Fix a bug where stripeFuncs was being freed, and then being used after (in the case of numStripesBailed > 0).
2004-02-29 04:24:34 +03:00
RF_FuncList_t *rf_AllocFuncList(void);
void rf_FreeFuncList(RF_FuncList_t *);
These changes complete the effective removal of malloc() from all write paths within RAIDframe. They also resolve the "panics with RAID 5 sets with more than 3 components" issue which was present (briefly) in the commits which were previously supposed to address the malloc() issue. With this new code the 5-component RAID 5 set panics are now gone. It is also now also possible to swap to RAID 5. The changes made are: 1) Introduce rf_AllocStripeBuffer() and rf_FreeStripeBuffer() to allocate/free one stripe's worth of space. rf_AllocStripeBuffer() is used in rf_MapUnaccessedPortionOfStripe() where it is not sufficient to allocate memory using just rf_AllocBuffer(). rf_FreeStripeBuffer() is called from rf_FreeRaidAccDesc(), well after the DAG is finished. 2) Add a set of emergency "stripe buffers" to struct RF_Raid_s. Arrange for their initialization in rf_Configure(). In low-memory situations these buffers will be returned by rf_AllocStripeBuffer() and re-populated by rf_FreeStripeBuffer(). 3) Move RF_VoidPointerListElem_t *iobufs from the dagHeader into into struct RF_RaidAccessDesc_s. This is more consistent with the original code, and will not result in items being freed "too early". 4) Add a RF_RaidAccessDesc_t *desc to RF_DagHeader_s so that we have a way to find desc->iobufs. 5) Arrange for desc in the DagHeader to be initialized in InitHdrNode(). 6) Don't cleanup iobufs in rf_FreeDAG() -- the freeing is now delayed until rf_FreeRaidAccDesc() (which is how the original code handled the allocList, and for which there seem to be some subtle, undocumented assumptions). 7) Rename rf_AllocBuffer2() to be rf_AllocBuffer() and remove the former rf_AllocBuffer(). Fix all callers of rf_AllocBuffer(). (This was how it was *supposed* to be after the last time these changes were made, before they were backed out). 8) Remove RF_IOBufHeader and all references to it. 9) Remove desc->cleanupList and all references to it. Fixes PR#20191
2004-04-10 03:10:16 +04:00
void *rf_AllocBuffer(RF_Raid_t *, RF_DagHeader_t *, int);
For each RAID set, pre-allocate a number of "emergency buffers" to be used in the event that we can't malloc a buffer of the appropriate size in the traditional way. rf_AllocIOBuffer() and rf_FreeIOBuffer() deal with allocating/freeing these structures. These buffers are stored in a list on the 'iobuf' list. iobuf_count keeps track of how many buffers are available, and numEmergencyBuffers is the effective "high-water" mark for the freelist. The buffers allocated by rf_AllocIOBuffer() are stripe-unit sized, which is the maximum size requested by any of the callers. Add an iobufs entry to RF_DagHeader_s. Use it for keeping track of buffers that get allocated from the free-list. Add a "generic list" pool (VoidPointerListElement Pool) for elements used to maintain a list of allocated memory. [It is somewhat less than ideal to add another little pool to handle this...] Teach rf_AllocBuffer() to use the new rf_AllocIOBuffer(). Modify other Mallocs to use rf_AllocIOBuffer(), and to update dag_h->iobufs as appropriate. Update rf_FreeDAG() to handle cleanup of dag_h->iobufs. While here, add some missing pool_destroy() calls for a number of pools. With these changes, it should (in theory) be possible to swap on RAID 5 sets again. That said, I've not had any success there yet -- but the last issue I saw at least wasn't in RAIDframe. :-} [There is room for this code to become a bit more consise, but I wanted to do a checkpoint here with something known to work :) ]
2004-03-20 07:22:05 +03:00
void *rf_AllocIOBuffer(RF_Raid_t *, int);
These changes complete the effective removal of malloc() from all write paths within RAIDframe. They also resolve the "panics with RAID 5 sets with more than 3 components" issue which was present (briefly) in the commits which were previously supposed to address the malloc() issue. With this new code the 5-component RAID 5 set panics are now gone. It is also now also possible to swap to RAID 5. The changes made are: 1) Introduce rf_AllocStripeBuffer() and rf_FreeStripeBuffer() to allocate/free one stripe's worth of space. rf_AllocStripeBuffer() is used in rf_MapUnaccessedPortionOfStripe() where it is not sufficient to allocate memory using just rf_AllocBuffer(). rf_FreeStripeBuffer() is called from rf_FreeRaidAccDesc(), well after the DAG is finished. 2) Add a set of emergency "stripe buffers" to struct RF_Raid_s. Arrange for their initialization in rf_Configure(). In low-memory situations these buffers will be returned by rf_AllocStripeBuffer() and re-populated by rf_FreeStripeBuffer(). 3) Move RF_VoidPointerListElem_t *iobufs from the dagHeader into into struct RF_RaidAccessDesc_s. This is more consistent with the original code, and will not result in items being freed "too early". 4) Add a RF_RaidAccessDesc_t *desc to RF_DagHeader_s so that we have a way to find desc->iobufs. 5) Arrange for desc in the DagHeader to be initialized in InitHdrNode(). 6) Don't cleanup iobufs in rf_FreeDAG() -- the freeing is now delayed until rf_FreeRaidAccDesc() (which is how the original code handled the allocList, and for which there seem to be some subtle, undocumented assumptions). 7) Rename rf_AllocBuffer2() to be rf_AllocBuffer() and remove the former rf_AllocBuffer(). Fix all callers of rf_AllocBuffer(). (This was how it was *supposed* to be after the last time these changes were made, before they were backed out). 8) Remove RF_IOBufHeader and all references to it. 9) Remove desc->cleanupList and all references to it. Fixes PR#20191
2004-04-10 03:10:16 +04:00
void rf_FreeIOBuffer(RF_Raid_t *, RF_VoidPointerListElem_t *);
void *rf_AllocStripeBuffer(RF_Raid_t *, RF_DagHeader_t *, int);
void rf_FreeStripeBuffer(RF_Raid_t *, RF_VoidPointerListElem_t *);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
Cleanup function prototypes.
2004-03-20 19:48:05 +03:00
char *rf_NodeStatusString(RF_DagNode_t *);
void rf_PrintNodeInfoString(RF_DagNode_t *);
int rf_AssignNodeNums(RF_DagHeader_t *);
int rf_RecurAssignNodeNums(RF_DagNode_t *, int, int);
void rf_ResetDAGHeaderPointers(RF_DagHeader_t *, RF_DagHeader_t *);
void rf_RecurResetDAGHeaderPointers(RF_DagNode_t *, RF_DagHeader_t *);
void rf_PrintDAGList(RF_DagHeader_t *);
int rf_ValidateDAG(RF_DagHeader_t *);
void rf_redirect_asm(RF_Raid_t *, RF_AccessStripeMap_t *);
void rf_MapUnaccessedPortionOfStripe(RF_Raid_t *, RF_RaidLayout_t *,
RF_AccessStripeMap_t *, RF_DagHeader_t *,
RF_AccessStripeMapHeader_t **, int *,
char **, char **, RF_AllocListElem_t *);
int rf_PDAOverlap(RF_RaidLayout_t *, RF_PhysDiskAddr_t *, RF_PhysDiskAddr_t *);
void rf_GenerateFailedAccessASMs(RF_Raid_t *, RF_AccessStripeMap_t *,
nuke trailing whitespace
2005-02-27 03:26:58 +03:00
RF_PhysDiskAddr_t *, RF_DagHeader_t *,
Cleanup function prototypes.
2004-03-20 19:48:05 +03:00
RF_AccessStripeMapHeader_t **,
int *, char **, char *, RF_AllocListElem_t *);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
/* flags used by RangeRestrictPDA */
#define RF_RESTRICT_NOBUFFER 0
#define RF_RESTRICT_DOBUFFER 1
nuke trailing whitespace
2005-02-27 03:26:58 +03:00
void rf_RangeRestrictPDA(RF_Raid_t *, RF_PhysDiskAddr_t *,
Cleanup function prototypes.
2004-03-20 19:48:05 +03:00
RF_PhysDiskAddr_t *, int, int);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
Cleanup function prototypes.
2004-03-20 19:48:05 +03:00
int rf_compute_workload_shift(RF_Raid_t *, RF_PhysDiskAddr_t *);
void rf_SelectMirrorDiskIdle(RF_DagNode_t *);
void rf_SelectMirrorDiskPartition(RF_DagNode_t *);
RAIDframe, version 1.1, from the Parallel Data Laboratory at Carnegie Mellon University. Full RAID implementation, including levels 0, 1, 4, 5, 6, parity logging, and a few other goodies. Ported to NetBSD by Greg Oster.
1998-11-13 07:20:26 +03:00
Phase 2 of the RAIDframe cleanup. The source is now closer to KNF and is much easier to read. No functionality changes.
1999-02-05 03:06:06 +03:00
#endif /* !_RF__RF_DAGUTILS_H_ */