![[BACK]](/icons/back.gif){kind=icon}
Return to rf_reconstruct.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_reconstruct.h CVS log | Up to [local] / sys / dev / raidframe |
1.1 nbrk 1: /* $OpenBSD: rf_reconstruct.h,v 1.5 2002/12/16 07:01:05 tdeval Exp $ */
2: /* $NetBSD: rf_reconstruct.h,v 1.5 2000/05/28 00:48:30 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_reconstruct.h -- Header file for reconstruction code.
33: ***********************************************************/
34:
35: #ifndef _RF__RF_RECONSTRUCT_H_
36: #define _RF__RF_RECONSTRUCT_H_
37:
38: #include "rf_types.h"
39: #include <sys/time.h>
40: #include "rf_reconmap.h"
41: #include "rf_psstatus.h"
42:
43: /* Reconstruction configuration information. */
44: struct RF_ReconConfig_s {
45: unsigned numFloatingReconBufs;
46: /*
47: * Number of floating recon
48: * bufs to use.
49: */
50: RF_HeadSepLimit_t headSepLimit; /*
51: * How far apart the heads are
52: * allowed to become, in parity
53: * stripes.
54: */
55: };
56:
57: /* A reconstruction buffer. */
58: struct RF_ReconBuffer_s {
59: RF_Raid_t *raidPtr; /*
60: * (void *) to avoid recursive
61: * includes.
62: */
63: caddr_t buffer; /* Points to the data. */
64: RF_StripeNum_t parityStripeID;/*
65: * The parity stripe that this
66: * data relates to.
67: */
68: int which_ru; /*
69: * Which reconstruction unit
70: * within the PSS.
71: */
72: RF_SectorNum_t failedDiskSectorOffset;
73: /*
74: * The offset into the failed
75: * disk.
76: */
77: RF_RowCol_t row, col; /*
78: * Which disk this buffer
79: * belongs to or is targeted at.
80: */
81: RF_StripeCount_t count; /*
82: * Counts the # of SUs
83: * installed so far.
84: */
85: int priority; /*
86: * Used to force high priority
87: * recon.
88: */
89: RF_RbufType_t type; /* FORCED or FLOATING. */
90: char *arrived; /*
91: * [x] = 1/0 if SU from disk x
92: * has/hasn't arrived.
93: */
94: RF_ReconBuffer_t *next; /*
95: * Used for buffer management.
96: */
97: void *arg; /*
98: * Generic field for general
99: * use.
100: */
101: RF_RowCol_t spRow, spCol; /*
102: * Spare disk to which this buf
103: * should be written.
104: */
105: /* If dist sparing off, always identifies the replacement disk */
106: RF_SectorNum_t spOffset; /*
107: * Offset into the spare disk.
108: */
109: /* If dist sparing off, identical to failedDiskSectorOffset */
110: RF_ReconParityStripeStatus_t *pssPtr; /*
111: * Debug pss associated with
112: * issue-pending write.
113: */
114: };
115:
116: /*
117: * A reconstruction event descriptor. The event types currently are:
118: * RF_REVENT_READDONE -- A read operation has completed.
119: * RF_REVENT_WRITEDONE -- A write operation has completed.
120: * RF_REVENT_BUFREADY -- The buffer manager has produced a
121: * full buffer.
122: * RF_REVENT_BLOCKCLEAR -- A reconstruction blockage has been cleared.
123: * RF_REVENT_BUFCLEAR -- The buffer manager has released a process
124: * blocked on submission.
125: * RF_REVENT_SKIP -- We need to skip the current RU and go on
126: * to the next one, typ. b/c we found recon
127: * forced.
128: * RF_REVENT_FORCEDREADONE -- A forced-reconstructoin read operation has
129: * completed.
130: */
131: typedef enum RF_Revent_e {
132: RF_REVENT_READDONE,
133: RF_REVENT_WRITEDONE,
134: RF_REVENT_BUFREADY,
135: RF_REVENT_BLOCKCLEAR,
136: RF_REVENT_BUFCLEAR,
137: RF_REVENT_HEADSEPCLEAR,
138: RF_REVENT_SKIP,
139: RF_REVENT_FORCEDREADDONE
140: } RF_Revent_t;
141:
142: struct RF_ReconEvent_s {
143: RF_Revent_t type; /* What kind of event has occurred. */
144: RF_RowCol_t col; /*
145: * Row ID is implicit in the queue in
146: * which the event is placed.
147: */
148: void *arg; /* A generic argument. */
149: RF_ReconEvent_t *next;
150: };
151:
152: /*
153: * Reconstruction control information maintained per-disk.
154: * (for surviving disks)
155: */
156: struct RF_PerDiskReconCtrl_s {
157: RF_ReconCtrl_t *reconCtrl;
158: RF_RowCol_t row, col; /*
159: * To make this structure
160: * self-identifying.
161: */
162: RF_StripeNum_t curPSID; /*
163: * The next parity stripe ID
164: * to check on this disk.
165: */
166: RF_HeadSepLimit_t headSepCounter;/*
167: * Counter used to control
168: * maximum head separation.
169: */
170: RF_SectorNum_t diskOffset; /*
171: * The offset into the
172: * indicated disk
173: * of the current PU.
174: */
175: RF_ReconUnitNum_t ru_count; /*
176: * This counts off the recon
177: * units within each parity
178: * unit.
179: */
180: RF_ReconBuffer_t *rbuf; /*
181: * The recon buffer assigned
182: * to this disk.
183: */
184: };
185:
186: /* Main reconstruction control structure. */
187: struct RF_ReconCtrl_s {
188: RF_RaidReconDesc_t *reconDesc;
189: RF_RowCol_t fcol; /* Which column has failed. */
190: RF_PerDiskReconCtrl_t *perDiskInfo; /*
191: * Information maintained
192: * per-disk.
193: */
194: RF_ReconMap_t *reconMap; /*
195: * Map of what has/has not
196: * been reconstructed.
197: */
198: RF_RowCol_t spareRow; /*
199: * Which of the spare disks
200: * we're using.
201: */
202: RF_RowCol_t spareCol;
203: RF_StripeNum_t lastPSID; /*
204: * The ID of the last
205: * parity stripe we want
206: * reconstructed.
207: */
208: int percentComplete;
209: /*
210: * Percentage completion of
211: * reconstruction.
212: */
213: int numRUsComplete;/*
214: * Number of Reconstruction
215: * Units done.
216: */
217: int numRUsTotal; /*
218: * Total number of
219: * Reconstruction Units.
220: */
221:
222: /* Reconstruction event queue. */
223: RF_ReconEvent_t *eventQueue; /*
224: * Queue of pending
225: * reconstruction events.
226: */
227: RF_DECLARE_MUTEX (eq_mutex); /*
228: * Mutex for locking event
229: * queue.
230: */
231: RF_DECLARE_COND (eq_cond); /*
232: * Condition variable for
233: * signalling recon events.
234: */
235: int eq_count; /* Debug only. */
236:
237: /* Reconstruction buffer management. */
238: RF_DECLARE_MUTEX (rb_mutex); /*
239: * Mutex for messing around
240: * with recon buffers.
241: */
242: RF_ReconBuffer_t *floatingRbufs; /*
243: * Available floating
244: * reconstruction buffers.
245: */
246: RF_ReconBuffer_t *committedRbufs;/*
247: * Recon buffers that have
248: * been committed to some
249: * waiting disk.
250: */
251: RF_ReconBuffer_t *fullBufferList;/*
252: * Full buffers waiting to be
253: * written out.
254: */
255: RF_ReconBuffer_t *priorityList; /*
256: * Full buffers that have been
257: * elevated to higher priority.
258: */
259: RF_CallbackDesc_t *bufferWaitList;/*
260: * Disks that are currently
261: * blocked waiting for buffers.
262: */
263:
264: /* Parity stripe status table. */
265: RF_PSStatusHeader_t *pssTable; /*
266: * Stores the reconstruction
267: * status of active parity
268: * stripes.
269: */
270:
271: /* Maximum-head separation control. */
272: RF_HeadSepLimit_t minHeadSepCounter;
273: /*
274: * The minimum hs counter over
275: * all disks.
276: */
277: RF_CallbackDesc_t *headSepCBList; /*
278: * List of callbacks to be
279: * done as minPSID advances.
280: */
281:
282: /* Performance monitoring. */
283: struct timeval starttime; /* Recon start time. */
284:
285: void (*continueFunc) (void *);
286: /*
287: * Function to call when io
288: * returns.
289: */
290: void *continueArg; /* Argument for Func. */
291: };
292:
293: /* The default priority for reconstruction accesses. */
294: #define RF_IO_RECON_PRIORITY RF_IO_LOW_PRIORITY
295:
296: int rf_ConfigureReconstruction(RF_ShutdownList_t **);
297: int rf_ReconstructFailedDisk(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
298: int rf_ReconstructFailedDiskBasic(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
299: int rf_ReconstructInPlace(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
300: int rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *);
301: int rf_ForceOrBlockRecon(RF_Raid_t *, RF_AccessStripeMap_t *,
302: void (*) (RF_Raid_t *, void *), void *);
303: int rf_UnblockRecon(RF_Raid_t *, RF_AccessStripeMap_t *);
304: int rf_RegisterReconDoneProc(RF_Raid_t *, void (*) (RF_Raid_t *, void *),
305: void *, RF_ReconDoneProc_t **);
306:
307: #endif /* !_RF__RF_RECONSTRUCT_H_ */