![[BACK]](/icons/back.gif){kind=icon}
Return to rf_dag.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_dag.h CVS log | Up to [local] / sys / dev / raidframe |
1.1 ! nbrk 1: /* $OpenBSD: rf_dag.h,v 1.4 2002/12/16 07:01:03 tdeval Exp $ */
! 2: /* $NetBSD: rf_dag.h,v 1.3 1999/02/05 00:06:07 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: William V. Courtright II, 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: * *
! 33: * dag.h -- header file for DAG-related data structures *
! 34: * *
! 35: ****************************************************************************/
! 36:
! 37: #ifndef _RF__RF_DAG_H_
! 38: #define _RF__RF_DAG_H_
! 39:
! 40: #include "rf_types.h"
! 41: #include "rf_threadstuff.h"
! 42: #include "rf_alloclist.h"
! 43: #include "rf_stripelocks.h"
! 44: #include "rf_layout.h"
! 45: #include "rf_dagflags.h"
! 46: #include "rf_acctrace.h"
! 47: #include "rf_memchunk.h"
! 48:
! 49: #define RF_THREAD_CONTEXT 0 /* We were invoked from thread context. */
! 50: #define RF_INTR_CONTEXT 1 /* We were invoked from interrupt context. */
! 51: #define RF_MAX_ANTECEDENTS 20 /* Max num of antecedents a node may possess. */
! 52:
! 53: #include <sys/buf.h>
! 54:
! 55: struct RF_PropHeader_s { /* Structure for propagation of results. */
! 56: int resultNum; /* Bind result # resultNum. */
! 57: int paramNum; /* To parameter # paramNum. */
! 58: RF_PropHeader_t *next; /* Linked list for multiple
! 59: * results/params. */
! 60: };
! 61:
! 62: typedef enum RF_NodeStatus_e {
! 63: rf_bwd1, /*
! 64: * Node is ready for undo logging
! 65: * (backward error recovery only).
! 66: */
! 67: rf_bwd2, /*
! 68: * Node has completed undo logging
! 69: * (backward error recovery only).
! 70: */
! 71: rf_wait, /* Node is waiting to be executed. */
! 72: rf_fired, /* Node is currently executing its do function. */
! 73: rf_good, /*
! 74: * Node successfully completed execution
! 75: * of its do function.
! 76: */
! 77: rf_bad, /*
! 78: * Node failed to successfully execute
! 79: * its do function.
! 80: */
! 81: rf_skipped, /*
! 82: * Not used anymore, used to imply a node
! 83: * was not executed.
! 84: */
! 85: rf_recover, /* Node is currently executing its undo function. */
! 86: rf_panic, /*
! 87: * Node failed to successfully execute
! 88: * its undo function.
! 89: */
! 90: rf_undone /* Node successfully executed its undo function. */
! 91: } RF_NodeStatus_t;
! 92:
! 93: /*
! 94: * These were used to control skipping a node.
! 95: * Now, these are only used as comments.
! 96: */
! 97: typedef enum RF_AntecedentType_e {
! 98: rf_trueData,
! 99: rf_antiData,
! 100: rf_outputData,
! 101: rf_control
! 102: } RF_AntecedentType_t;
! 103: #define RF_DAG_PTRCACHESIZE 40
! 104: #define RF_DAG_PARAMCACHESIZE 12
! 105:
! 106: typedef RF_uint8 RF_DagNodeFlags_t;
! 107:
! 108: struct RF_DagNode_s {
! 109: RF_NodeStatus_t status; /* Current status of this node. */
! 110: int (*doFunc) (RF_DagNode_t *);
! 111: /* Normal function. */
! 112: int (*undoFunc) (RF_DagNode_t *);
! 113: /* Func to remove effect of doFunc. */
! 114: int (*wakeFunc) (RF_DagNode_t *, int status);
! 115: /*
! 116: * Func called when the node completes
! 117: * an I/O.
! 118: */
! 119: int numParams; /*
! 120: * Number of parameters required
! 121: * by *funcPtr.
! 122: */
! 123: int numResults; /*
! 124: * Number of results produced
! 125: * by *funcPtr.
! 126: */
! 127: int numAntecedents; /* Number of antecedents. */
! 128: int numAntDone; /*
! 129: * Number of antecedents that
! 130: * have finished.
! 131: */
! 132: int numSuccedents; /* Number of succedents. */
! 133: int numSuccFired; /*
! 134: * Incremented when a succedent
! 135: * is fired during forward execution.
! 136: */
! 137: int numSuccDone; /*
! 138: * Incremented when a succedent
! 139: * finishes during rollBackward.
! 140: */
! 141: int commitNode; /*
! 142: * Boolean flag - if true, this is
! 143: * a commit node.
! 144: */
! 145: RF_DagNode_t **succedents; /*
! 146: * Succedents, array size
! 147: * numSuccedents.
! 148: */
! 149: RF_DagNode_t **antecedents; /*
! 150: * Antecedents, array size
! 151: * numAntecedents.
! 152: */
! 153: RF_AntecedentType_t antType[RF_MAX_ANTECEDENTS];
! 154: /* Type of each antecedent. */
! 155: void **results; /*
! 156: * Array of results produced
! 157: * by *funcPtr.
! 158: */
! 159: RF_DagParam_t *params; /*
! 160: * Array of parameters required
! 161: * by *funcPtr.
! 162: */
! 163: RF_PropHeader_t **propList; /*
! 164: * Propagation list,
! 165: * size numSuccedents.
! 166: */
! 167: RF_DagHeader_t *dagHdr; /*
! 168: * Ptr to head of dag containing
! 169: * this node.
! 170: */
! 171: void *dagFuncData; /*
! 172: * Dag execution func uses this
! 173: * for whatever it wants.
! 174: */
! 175: RF_DagNode_t *next;
! 176: int nodeNum; /* Used by PrintDAG for debug only. */
! 177: int visited; /*
! 178: * Used to avoid re-visiting
! 179: * nodes on DAG walks.
! 180: */
! 181: /*
! 182: * ANY CODE THAT USES THIS FIELD MUST MAINTAIN THE PROPERTY THAT
! 183: * AFTER IT FINISHES, ALL VISITED FLAGS IN THE DAG ARE IDENTICAL.
! 184: */
! 185:
! 186: char *name; /* Debug only. */
! 187: RF_DagNodeFlags_t flags; /* See below. */
! 188: RF_DagNode_t *dag_ptrs[RF_DAG_PTRCACHESIZE];
! 189: /* Cache for performance. */
! 190: RF_DagParam_t dag_params[RF_DAG_PARAMCACHESIZE];
! 191: /* Cache for performance. */
! 192: };
! 193:
! 194: /*
! 195: * Bit values for flags field of RF_DagNode_t.
! 196: */
! 197: #define RF_DAGNODE_FLAG_NONE 0x00
! 198: #define RF_DAGNODE_FLAG_YIELD 0x01 /*
! 199: * In the kernel, yield the processor
! 200: * before firing this node.
! 201: */
! 202:
! 203: /*
! 204: * rf_enable - DAG ready for normal execution, no errors encountered.
! 205: * rf_rollForward - DAG encountered an error after commit point, rolling
! 206: * forward.
! 207: * rf_rollBackward - DAG encountered an error prior to commit point, rolling
! 208: * backward.
! 209: */
! 210: typedef enum RF_DagStatus_e {
! 211: rf_enable,
! 212: rf_rollForward,
! 213: rf_rollBackward
! 214: } RF_DagStatus_t;
! 215:
! 216: #define RF_MAX_HDR_SUCC 1
! 217:
! 218: #define RF_MAXCHUNKS 10
! 219:
! 220: struct RF_DagHeader_s {
! 221: RF_DagStatus_t status; /* Status of this DAG. */
! 222: int numSuccedents; /*
! 223: * DAG may be a tree,
! 224: * i.e. may have > 1 root.
! 225: */
! 226: int numCommitNodes; /*
! 227: * Number of commit nodes
! 228: * in graph.
! 229: */
! 230: int numCommits; /*
! 231: * Number of commit nodes
! 232: * that have been fired.
! 233: */
! 234: RF_DagNode_t *succedents[RF_MAX_HDR_SUCC]; /*
! 235: * Array of succedents,
! 236: * size numSuccedents.
! 237: */
! 238: RF_DagHeader_t *next; /*
! 239: * Ptr to allow a list
! 240: * of dags.
! 241: */
! 242: RF_AllocListElem_t *allocList; /*
! 243: * Ptr to list of ptrs
! 244: * to be freed prior to
! 245: * freeing DAG.
! 246: */
! 247: RF_AccessStripeMapHeader_t *asmList; /*
! 248: * List of access stripe maps
! 249: * to be freed.
! 250: */
! 251: int nodeNum; /*
! 252: * Used by PrintDAG for
! 253: * debug only.
! 254: */
! 255: int numNodesCompleted;
! 256: RF_AccTraceEntry_t *tracerec; /* Perf mon only. */
! 257:
! 258: void (*cbFunc) (void *); /*
! 259: * Function to call when
! 260: * the dag completes.
! 261: */
! 262: void *cbArg; /* Argument for cbFunc. */
! 263: char *creator; /*
! 264: * Name of function used
! 265: * to create this dag.
! 266: */
! 267:
! 268: RF_Raid_t *raidPtr; /*
! 269: * The descriptor for the
! 270: * RAID device this DAG
! 271: * is for.
! 272: */
! 273: void *bp; /*
! 274: * The bp for this I/O passed
! 275: * down from the file system.
! 276: * ignored outside kernel.
! 277: */
! 278:
! 279: RF_ChunkDesc_t *memChunk[RF_MAXCHUNKS]; /*
! 280: * Experimental- Chunks of
! 281: * memory to be retained upon
! 282: * DAG free for re-use.
! 283: */
! 284: int chunkIndex; /*
! 285: * The idea is to avoid calls
! 286: * to alloc and free.
! 287: */
! 288:
! 289: RF_ChunkDesc_t **xtraMemChunk; /*
! 290: * Escape hatch that allows
! 291: * SelectAlgorithm to merge
! 292: * memChunks from several dags.
! 293: */
! 294: int xtraChunkIndex; /*
! 295: * Number of ptrs to valid
! 296: * chunks.
! 297: */
! 298: int xtraChunkCnt; /*
! 299: * Number of ptrs to chunks
! 300: * allocated.
! 301: */
! 302: };
! 303:
! 304: struct RF_DagList_s {
! 305: /* Common info for a list of dags that will be fired sequentially. */
! 306: int numDags; /* Number of dags in the list. */
! 307: int numDagsFired; /*
! 308: * Number of dags in list that
! 309: * have initiated execution.
! 310: */
! 311: int numDagsDone; /*
! 312: * Number of dags in list that
! 313: * have completed execution.
! 314: */
! 315: RF_DagHeader_t *dags; /* List of dags. */
! 316: RF_RaidAccessDesc_t *desc; /* Ptr to descriptor for this access. */
! 317: RF_AccTraceEntry_t tracerec; /*
! 318: * Perf mon info for dags (not user
! 319: * info).
! 320: */
! 321: };
! 322:
! 323: /* Reset a node so that it can be fired again. */
! 324: #define RF_ResetNode(_n_) do { \
! 325: (_n_)->status = rf_wait; \
! 326: (_n_)->numAntDone = 0; \
! 327: (_n_)->numSuccFired = 0; \
! 328: (_n_)->numSuccDone = 0; \
! 329: (_n_)->next = NULL; \
! 330: } while (0)
! 331:
! 332: #define RF_ResetDagHeader(_h_) do { \
! 333: (_h_)->numNodesCompleted = 0; \
! 334: (_h_)->numCommits = 0; \
! 335: (_h_)->status = rf_enable; \
! 336: } while (0)
! 337:
! 338: /* Convenience macro for declaring a create dag function. */
! 339: #define RF_CREATE_DAG_FUNC_DECL(_name_) \
! 340: void _name_ (RF_Raid_t *, RF_AccessStripeMap_t *, RF_DagHeader_t *, \
! 341: void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *); \
! 342: void _name_ ( \
! 343: RF_Raid_t *raidPtr, \
! 344: RF_AccessStripeMap_t *asmap, \
! 345: RF_DagHeader_t *dag_h, \
! 346: void *bp, \
! 347: RF_RaidAccessFlags_t flags, \
! 348: RF_AllocListElem_t *allocList \
! 349: )
! 350:
! 351: #endif /* !_RF__RF_DAG_H_ */