Annotation of sys/dev/raidframe/rf_dagfuncs.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_dagfuncs.c,v 1.7 2004/09/20 17:51:07 miod Exp $ */
2: /* $NetBSD: rf_dagfuncs.c,v 1.6 2000/03/30 12:45:40 augustss Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Mark Holland, William V. Courtright II
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: * dagfuncs.c -- DAG node execution routines.
33: *
34: * Rules:
35: * 1. Every DAG execution function must eventually cause node->status to
36: * get set to "good" or "bad", and "FinishNode" to be called. In the
37: * case of nodes that complete immediately (xor, NullNodeFunc, etc),
38: * the node execution function can do these two things directly. In
39: * the case of nodes that have to wait for some event (a disk read to
40: * complete, a lock to be released, etc) to occur before they can
41: * complete, this is typically achieved by having whatever module
42: * is doing the operation call GenericWakeupFunc upon completion.
43: * 2. DAG execution functions should check the status in the DAG header
44: * and NOP out their operations if the status is not "enable". However,
45: * execution functions that release resources must be sure to release
46: * them even when they NOP out the function that would use them.
47: * Functions that acquire resources should go ahead and acquire them
48: * even when they NOP, so that a downstream release node will not have
49: * to check to find out whether or not the acquire was suppressed.
50: */
51:
52: #include <sys/ioctl.h>
53: #include <sys/param.h>
54:
55: #include "rf_archs.h"
56: #include "rf_raid.h"
57: #include "rf_dag.h"
58: #include "rf_layout.h"
59: #include "rf_etimer.h"
60: #include "rf_acctrace.h"
61: #include "rf_diskqueue.h"
62: #include "rf_dagfuncs.h"
63: #include "rf_general.h"
64: #include "rf_engine.h"
65: #include "rf_dagutils.h"
66:
67: #include "rf_kintf.h"
68:
69: #if RF_INCLUDE_PARITYLOGGING > 0
70: #include "rf_paritylog.h"
71: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
72:
73: int (*rf_DiskReadFunc) (RF_DagNode_t *);
74: int (*rf_DiskWriteFunc) (RF_DagNode_t *);
75: int (*rf_DiskReadUndoFunc) (RF_DagNode_t *);
76: int (*rf_DiskWriteUndoFunc) (RF_DagNode_t *);
77: int (*rf_DiskUnlockFunc) (RF_DagNode_t *);
78: int (*rf_DiskUnlockUndoFunc) (RF_DagNode_t *);
79: int (*rf_RegularXorUndoFunc) (RF_DagNode_t *);
80: int (*rf_SimpleXorUndoFunc) (RF_DagNode_t *);
81: int (*rf_RecoveryXorUndoFunc) (RF_DagNode_t *);
82:
83: /*****************************************************************************
84: * Main (only) configuration routine for this module.
85: *****************************************************************************/
86: int
87: rf_ConfigureDAGFuncs(RF_ShutdownList_t **listp)
88: {
89: RF_ASSERT(((sizeof(long) == 8) && RF_LONGSHIFT == 3) ||
90: ((sizeof(long) == 4) && RF_LONGSHIFT == 2));
91: rf_DiskReadFunc = rf_DiskReadFuncForThreads;
92: rf_DiskReadUndoFunc = rf_DiskUndoFunc;
93: rf_DiskWriteFunc = rf_DiskWriteFuncForThreads;
94: rf_DiskWriteUndoFunc = rf_DiskUndoFunc;
95: rf_DiskUnlockFunc = rf_DiskUnlockFuncForThreads;
96: rf_DiskUnlockUndoFunc = rf_NullNodeUndoFunc;
97: rf_RegularXorUndoFunc = rf_NullNodeUndoFunc;
98: rf_SimpleXorUndoFunc = rf_NullNodeUndoFunc;
99: rf_RecoveryXorUndoFunc = rf_NullNodeUndoFunc;
100: return (0);
101: }
102:
103:
104: /*****************************************************************************
105: * The execution function associated with a terminate node.
106: *****************************************************************************/
107: int
108: rf_TerminateFunc(RF_DagNode_t *node)
109: {
110: RF_ASSERT(node->dagHdr->numCommits == node->dagHdr->numCommitNodes);
111: node->status = rf_good;
112: return (rf_FinishNode(node, RF_THREAD_CONTEXT));
113: }
114:
115: int
116: rf_TerminateUndoFunc(RF_DagNode_t *node)
117: {
118: return (0);
119: }
120:
121:
122: /*****************************************************************************
123: * Execution functions associated with a mirror node.
124: *
125: * parameters:
126: *
127: * 0 - Physical disk address of data.
128: * 1 - Buffer for holding read data.
129: * 2 - Parity stripe ID.
130: * 3 - Flags.
131: * 4 - Physical disk address of mirror (parity).
132: *
133: *****************************************************************************/
134:
135: int
136: rf_DiskReadMirrorIdleFunc(RF_DagNode_t *node)
137: {
138: /*
139: * Select the mirror copy with the shortest queue and fill in node
140: * parameters with physical disk address.
141: */
142:
143: rf_SelectMirrorDiskIdle(node);
144: return (rf_DiskReadFunc(node));
145: }
146:
147: int
148: rf_DiskReadMirrorPartitionFunc(RF_DagNode_t *node)
149: {
150: /*
151: * Select the mirror copy with the shortest queue and fill in node
152: * parameters with physical disk address.
153: */
154:
155: rf_SelectMirrorDiskPartition(node);
156: return (rf_DiskReadFunc(node));
157: }
158:
159: int
160: rf_DiskReadMirrorUndoFunc(RF_DagNode_t *node)
161: {
162: return (0);
163: }
164:
165:
166:
167: #if RF_INCLUDE_PARITYLOGGING > 0
168: /*****************************************************************************
169: * The execution function associated with a parity log update node.
170: *****************************************************************************/
171: int
172: rf_ParityLogUpdateFunc(RF_DagNode_t *node)
173: {
174: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
175: caddr_t buf = (caddr_t) node->params[1].p;
176: RF_ParityLogData_t *logData;
177: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
178: RF_Etimer_t timer;
179:
180: if (node->dagHdr->status == rf_enable) {
181: RF_ETIMER_START(timer);
182: logData = rf_CreateParityLogData(RF_UPDATE, pda, buf,
183: (RF_Raid_t *) (node->dagHdr->raidPtr),
184: node->wakeFunc, (void *) node,
185: node->dagHdr->tracerec, timer);
186: if (logData)
187: rf_ParityLogAppend(logData, RF_FALSE, NULL, RF_FALSE);
188: else {
189: RF_ETIMER_STOP(timer);
190: RF_ETIMER_EVAL(timer);
191: tracerec->plog_us += RF_ETIMER_VAL_US(timer);
192: (node->wakeFunc) (node, ENOMEM);
193: }
194: }
195: return (0);
196: }
197:
198:
199: /*****************************************************************************
200: * The execution function associated with a parity log overwrite node.
201: *****************************************************************************/
202: int
203: rf_ParityLogOverwriteFunc(RF_DagNode_t *node)
204: {
205: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
206: caddr_t buf = (caddr_t) node->params[1].p;
207: RF_ParityLogData_t *logData;
208: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
209: RF_Etimer_t timer;
210:
211: if (node->dagHdr->status == rf_enable) {
212: RF_ETIMER_START(timer);
213: logData = rf_CreateParityLogData(RF_OVERWRITE, pda, buf,
214: (RF_Raid_t *) (node->dagHdr->raidPtr), node->wakeFunc,
215: (void *) node, node->dagHdr->tracerec, timer);
216: if (logData)
217: rf_ParityLogAppend(logData, RF_FALSE, NULL, RF_FALSE);
218: else {
219: RF_ETIMER_STOP(timer);
220: RF_ETIMER_EVAL(timer);
221: tracerec->plog_us += RF_ETIMER_VAL_US(timer);
222: (node->wakeFunc) (node, ENOMEM);
223: }
224: }
225: return (0);
226: }
227: #else /* RF_INCLUDE_PARITYLOGGING > 0 */
228:
229: int
230: rf_ParityLogUpdateFunc(RF_DagNode_t *node)
231: {
232: return (0);
233: }
234:
235: int
236: rf_ParityLogOverwriteFunc(RF_DagNode_t *node)
237: {
238: return (0);
239: }
240: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
241:
242: int
243: rf_ParityLogUpdateUndoFunc(RF_DagNode_t *node)
244: {
245: return (0);
246: }
247:
248: int
249: rf_ParityLogOverwriteUndoFunc(RF_DagNode_t *node)
250: {
251: return (0);
252: }
253:
254: /*****************************************************************************
255: * The execution function associated with a NOP node.
256: *****************************************************************************/
257: int
258: rf_NullNodeFunc(RF_DagNode_t *node)
259: {
260: node->status = rf_good;
261: return (rf_FinishNode(node, RF_THREAD_CONTEXT));
262: }
263:
264: int
265: rf_NullNodeUndoFunc(RF_DagNode_t *node)
266: {
267: node->status = rf_undone;
268: return (rf_FinishNode(node, RF_THREAD_CONTEXT));
269: }
270:
271:
272: /*****************************************************************************
273: * The execution function associated with a disk-read node.
274: *****************************************************************************/
275: int
276: rf_DiskReadFuncForThreads(RF_DagNode_t *node)
277: {
278: RF_DiskQueueData_t *req;
279: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
280: caddr_t buf = (caddr_t) node->params[1].p;
281: RF_StripeNum_t parityStripeID = (RF_StripeNum_t) node->params[2].v;
282: unsigned priority = RF_EXTRACT_PRIORITY(node->params[3].v);
283: unsigned lock = RF_EXTRACT_LOCK_FLAG(node->params[3].v);
284: unsigned unlock = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v);
285: unsigned which_ru = RF_EXTRACT_RU(node->params[3].v);
286: RF_DiskQueueDataFlags_t flags = 0;
287: RF_IoType_t iotype = (node->dagHdr->status == rf_enable) ?
288: RF_IO_TYPE_READ : RF_IO_TYPE_NOP;
289: RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
290: void *b_proc = NULL;
291:
292: if (node->dagHdr->bp)
293: b_proc = (void *) ((struct buf *) node->dagHdr->bp)->b_proc;
294:
295: RF_ASSERT(!(lock && unlock));
296: flags |= (lock) ? RF_LOCK_DISK_QUEUE : 0;
297: flags |= (unlock) ? RF_UNLOCK_DISK_QUEUE : 0;
298:
299: req = rf_CreateDiskQueueData(iotype, pda->startSector, pda->numSector,
300: buf, parityStripeID, which_ru,
301: (int (*) (void *, int)) node->wakeFunc,
302: node, NULL, node->dagHdr->tracerec,
303: (void *) (node->dagHdr->raidPtr), flags, b_proc);
304: if (!req) {
305: (node->wakeFunc) (node, ENOMEM);
306: } else {
307: node->dagFuncData = (void *) req;
308: rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, priority);
309: }
310: return (0);
311: }
312:
313:
314: /*****************************************************************************
315: * the execution function associated with a disk-write node
316: *****************************************************************************/
317: int
318: rf_DiskWriteFuncForThreads(RF_DagNode_t *node)
319: {
320: RF_DiskQueueData_t *req;
321: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
322: caddr_t buf = (caddr_t) node->params[1].p;
323: RF_StripeNum_t parityStripeID = (RF_StripeNum_t) node->params[2].v;
324: unsigned priority = RF_EXTRACT_PRIORITY(node->params[3].v);
325: unsigned lock = RF_EXTRACT_LOCK_FLAG(node->params[3].v);
326: unsigned unlock = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v);
327: unsigned which_ru = RF_EXTRACT_RU(node->params[3].v);
328: RF_DiskQueueDataFlags_t flags = 0;
329: RF_IoType_t iotype = (node->dagHdr->status == rf_enable) ?
330: RF_IO_TYPE_WRITE : RF_IO_TYPE_NOP;
331: RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
332: void *b_proc = NULL;
333:
334: if (node->dagHdr->bp)
335: b_proc = (void *) ((struct buf *) node->dagHdr->bp)->b_proc;
336:
337: /* Normal processing (rollaway or forward recovery) begins here. */
338: RF_ASSERT(!(lock && unlock));
339: flags |= (lock) ? RF_LOCK_DISK_QUEUE : 0;
340: flags |= (unlock) ? RF_UNLOCK_DISK_QUEUE : 0;
341: req = rf_CreateDiskQueueData(iotype, pda->startSector, pda->numSector,
342: buf, parityStripeID, which_ru,
343: (int (*) (void *, int)) node->wakeFunc, (void *) node, NULL,
344: node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
345: flags, b_proc);
346:
347: if (!req) {
348: (node->wakeFunc) (node, ENOMEM);
349: } else {
350: node->dagFuncData = (void *) req;
351: rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, priority);
352: }
353:
354: return (0);
355: }
356: /*****************************************************************************
357: * The undo function for disk nodes.
358: * Note: This is not a proper undo of a write node, only locks are released.
359: * old data is not restored to disk !
360: *****************************************************************************/
361: int
362: rf_DiskUndoFunc(RF_DagNode_t *node)
363: {
364: RF_DiskQueueData_t *req;
365: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
366: RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
367:
368: req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP, 0L, 0, NULL, 0L, 0,
369: (int (*) (void *, int)) node->wakeFunc, (void *) node,
370: NULL, node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
371: RF_UNLOCK_DISK_QUEUE, NULL);
372: if (!req)
373: (node->wakeFunc) (node, ENOMEM);
374: else {
375: node->dagFuncData = (void *) req;
376: rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req,
377: RF_IO_NORMAL_PRIORITY);
378: }
379:
380: return (0);
381: }
382:
383: /*****************************************************************************
384: * The execution function associated with an "unlock disk queue" node.
385: *****************************************************************************/
386: int
387: rf_DiskUnlockFuncForThreads(RF_DagNode_t *node)
388: {
389: RF_DiskQueueData_t *req;
390: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
391: RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
392:
393: req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP, 0L, 0, NULL, 0L, 0,
394: (int (*) (void *, int)) node->wakeFunc, (void *) node,
395: NULL, node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
396: RF_UNLOCK_DISK_QUEUE, NULL);
397: if (!req)
398: (node->wakeFunc) (node, ENOMEM);
399: else {
400: node->dagFuncData = (void *) req;
401: rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req,
402: RF_IO_NORMAL_PRIORITY);
403: }
404:
405: return (0);
406: }
407:
408: /*****************************************************************************
409: * Callback routine for DiskRead and DiskWrite nodes. When the disk op
410: * completes, the routine is called to set the node status and inform
411: * the execution engine that the node has fired.
412: *****************************************************************************/
413: int
414: rf_GenericWakeupFunc(RF_DagNode_t *node, int status)
415: {
416: switch (node->status) {
417: case rf_bwd1:
418: node->status = rf_bwd2;
419: if (node->dagFuncData)
420: rf_FreeDiskQueueData((RF_DiskQueueData_t *)
421: node->dagFuncData);
422: return (rf_DiskWriteFuncForThreads(node));
423: break;
424: case rf_fired:
425: if (status)
426: node->status = rf_bad;
427: else
428: node->status = rf_good;
429: break;
430: case rf_recover:
431: /* Probably should never reach this case. */
432: if (status)
433: node->status = rf_panic;
434: else
435: node->status = rf_undone;
436: break;
437: default:
438: printf("rf_GenericWakeupFunc:");
439: printf("node->status is %d,", node->status);
440: printf("status is %d \n", status);
441: RF_PANIC();
442: break;
443: }
444: if (node->dagFuncData)
445: rf_FreeDiskQueueData((RF_DiskQueueData_t *) node->dagFuncData);
446: return (rf_FinishNode(node, RF_INTR_CONTEXT));
447: }
448:
449:
450: /*****************************************************************************
451: * There are three distinct types of xor nodes.
452: *
453: * A "regular xor" is used in the fault-free case where the access spans
454: * a complete stripe unit. It assumes that the result buffer is one full
455: * stripe unit in size, and uses the stripe-unit-offset values that it
456: * computes from the PDAs to determine where within the stripe unit to
457: * XOR each argument buffer.
458: *
459: * A "simple xor" is used in the fault-free case where the access touches
460: * only a portion of one (or two, in some cases) stripe unit(s). It assumes
461: * that all the argument buffers are of the same size and have the same
462: * stripe unit offset.
463: *
464: * A "recovery xor" is used in the degraded-mode case. It's similar to
465: * the regular xor function except that it takes the failed PDA as an
466: * additional parameter, and uses it to determine what portions of the
467: * argument buffers need to be xor'd into the result buffer, and where
468: * in the result buffer they should go.
469: *****************************************************************************/
470:
471: /*
472: * Xor the params together and store the result in the result field.
473: * Assume the result field points to a buffer that is the size of one SU,
474: * and use the pda params to determine where within the buffer to XOR
475: * the input buffers.
476: */
477: int
478: rf_RegularXorFunc(RF_DagNode_t *node)
479: {
480: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
481: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
482: RF_Etimer_t timer;
483: int i, retcode;
484:
485: retcode = 0;
486: if (node->dagHdr->status == rf_enable) {
487: /* Don't do the XOR if the input is the same as the output. */
488: RF_ETIMER_START(timer);
489: for (i = 0; i < node->numParams - 1; i += 2)
490: if (node->params[i + 1].p != node->results[0]) {
491: retcode = rf_XorIntoBuffer(raidPtr,
492: (RF_PhysDiskAddr_t *) node->params[i].p,
493: (char *) node->params[i + 1].p,
494: (char *) node->results[0],
495: node->dagHdr->bp);
496: }
497: RF_ETIMER_STOP(timer);
498: RF_ETIMER_EVAL(timer);
499: tracerec->xor_us += RF_ETIMER_VAL_US(timer);
500: }
501: /* Call wake func explicitly since no I/O in this node. */
502: return (rf_GenericWakeupFunc(node, retcode));
503: }
504:
505: /* Xor the inputs into the result buffer, ignoring placement issues. */
506: int
507: rf_SimpleXorFunc(RF_DagNode_t *node)
508: {
509: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
510: int i, retcode = 0;
511: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
512: RF_Etimer_t timer;
513:
514: if (node->dagHdr->status == rf_enable) {
515: RF_ETIMER_START(timer);
516: /* Don't do the XOR if the input is the same as the output. */
517: for (i = 0; i < node->numParams - 1; i += 2)
518: if (node->params[i + 1].p != node->results[0]) {
519: retcode = rf_bxor((char *)
520: node->params[i + 1].p,
521: (char *) node->results[0],
522: rf_RaidAddressToByte(raidPtr,
523: ((RF_PhysDiskAddr_t *)
524: node->params[i].p)->numSector),
525: (struct buf *) node->dagHdr->bp);
526: }
527: RF_ETIMER_STOP(timer);
528: RF_ETIMER_EVAL(timer);
529: tracerec->xor_us += RF_ETIMER_VAL_US(timer);
530: }
531: /* Call wake func explicitly since no I/O in this node. */
532: return (rf_GenericWakeupFunc(node, retcode));
533: }
534:
535: /*
536: * This xor is used by the degraded-mode dag functions to recover lost data.
537: * The second-to-last parameter is the PDA for the failed portion of the access.
538: * The code here looks at this PDA and assumes that the xor target buffer is
539: * equal in size to the number of sectors in the failed PDA. It then uses
540: * the other PDAs in the parameter list to determine where within the target
541: * buffer the corresponding data should be xored.
542: */
543: int
544: rf_RecoveryXorFunc(RF_DagNode_t *node)
545: {
546: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
547: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
548: RF_PhysDiskAddr_t *failedPDA =
549: (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
550: int i, retcode = 0;
551: RF_PhysDiskAddr_t *pda;
552: int suoffset, failedSUOffset =
553: rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
554: char *srcbuf, *destbuf;
555: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
556: RF_Etimer_t timer;
557:
558: if (node->dagHdr->status == rf_enable) {
559: RF_ETIMER_START(timer);
560: for (i = 0; i < node->numParams - 2; i += 2)
561: if (node->params[i + 1].p != node->results[0]) {
562: pda = (RF_PhysDiskAddr_t *) node->params[i].p;
563: srcbuf = (char *) node->params[i + 1].p;
564: suoffset = rf_StripeUnitOffset(layoutPtr,
565: pda->startSector);
566: destbuf = ((char *) node->results[0]) +
567: rf_RaidAddressToByte(raidPtr,
568: suoffset - failedSUOffset);
569: retcode = rf_bxor(srcbuf, destbuf,
570: rf_RaidAddressToByte(raidPtr,
571: pda->numSector), node->dagHdr->bp);
572: }
573: RF_ETIMER_STOP(timer);
574: RF_ETIMER_EVAL(timer);
575: tracerec->xor_us += RF_ETIMER_VAL_US(timer);
576: }
577: return (rf_GenericWakeupFunc(node, retcode));
578: }
579:
580:
581: /*****************************************************************************
582: * The next three functions are utilities used by the above xor-execution
583: * functions.
584: *****************************************************************************/
585:
586: /*
587: * This is just a glorified buffer xor. Targbuf points to a buffer that is
588: * one full stripe unit in size. srcbuf points to a buffer that may be less
589: * than 1 SU, but never more. When the access described by pda is one SU in
590: * size (which by implication means it's SU-aligned), all that happens is
591: * (targbuf) <- (srcbuf ^ targbuf). When the access is less than one SU in
592: * size the XOR occurs on only the portion of targbuf identified in the pda.
593: */
594:
595: int
596: rf_XorIntoBuffer(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, char *srcbuf,
597: char *targbuf, void *bp)
598: {
599: char *targptr;
600: int sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
601: int SUOffset = pda->startSector % sectPerSU;
602: int length, retcode = 0;
603:
604: RF_ASSERT(pda->numSector <= sectPerSU);
605:
606: targptr = targbuf + rf_RaidAddressToByte(raidPtr, SUOffset);
607: length = rf_RaidAddressToByte(raidPtr, pda->numSector);
608: retcode = rf_bxor(srcbuf, targptr, length, bp);
609: return (retcode);
610: }
611:
612: /*
613: * It really should be the case that the buffer pointers (returned by malloc)
614: * are aligned to the natural word size of the machine, so this is the only
615: * case we optimize for. The length should always be a multiple of the sector
616: * size, so there should be no problem with leftover bytes at the end.
617: */
618: int
619: rf_bxor(char *src, char *dest, int len, void *bp)
620: {
621: unsigned mask = sizeof(long) - 1, retcode = 0;
622:
623: if (!(((unsigned long) src) & mask) &&
624: !(((unsigned long) dest) & mask) && !(len & mask)) {
625: retcode = rf_longword_bxor((unsigned long *) src,
626: (unsigned long *) dest, len >> RF_LONGSHIFT, bp);
627: } else {
628: RF_ASSERT(0);
629: }
630: return (retcode);
631: }
632:
633: /* Map a user buffer into kernel space, if necessary. */
634: #define REMAP_VA(_bp,x,y) (y) = (x)
635:
636: /*
637: * When XORing in kernel mode, we need to map each user page to kernel
638: * space before we can access it.
639: * We don't want to assume anything about which input buffers are in
640: * kernel/user space, nor about their alignment, so in each loop we
641: * compute the maximum number of bytes that we can xor without crossing
642: * any page boundaries, and do only this many bytes before the next remap.
643: */
644: int
645: rf_longword_bxor(unsigned long *src, unsigned long *dest, int len, void *bp)
646: {
647: unsigned long *end = src + len; /* len in longwords. */
648: unsigned long d0, d1, d2, d3, s0, s1, s2, s3; /* temps */
649: unsigned long *pg_src, *pg_dest; /* Per-page source/dest pointers. */
650: int longs_this_time; /* # longwords to xor in the current iteration. */
651:
652: REMAP_VA(bp, src, pg_src);
653: REMAP_VA(bp, dest, pg_dest);
654: if (!pg_src || !pg_dest)
655: return (EFAULT);
656:
657: while (len >= 4) {
658: longs_this_time = RF_MIN(len, RF_MIN(RF_BLIP(pg_src),
659: RF_BLIP(pg_dest)) >> RF_LONGSHIFT);
660: src += longs_this_time;
661: dest += longs_this_time;
662: len -= longs_this_time;
663: while (longs_this_time >= 4) {
664: d0 = pg_dest[0];
665: d1 = pg_dest[1];
666: d2 = pg_dest[2];
667: d3 = pg_dest[3];
668: s0 = pg_src[0];
669: s1 = pg_src[1];
670: s2 = pg_src[2];
671: s3 = pg_src[3];
672: pg_dest[0] = d0 ^ s0;
673: pg_dest[1] = d1 ^ s1;
674: pg_dest[2] = d2 ^ s2;
675: pg_dest[3] = d3 ^ s3;
676: pg_src += 4;
677: pg_dest += 4;
678: longs_this_time -= 4;
679: }
680: while (longs_this_time > 0) {
681: /* Cannot cross any page boundaries here. */
682: *pg_dest++ ^= *pg_src++;
683: longs_this_time--;
684: }
685:
686: /*
687: * Either we're done, or we've reached a page boundary on one
688: * (or possibly both) of the pointers.
689: */
690: if (len) {
691: if (RF_PAGE_ALIGNED(src))
692: REMAP_VA(bp, src, pg_src);
693: if (RF_PAGE_ALIGNED(dest))
694: REMAP_VA(bp, dest, pg_dest);
695: if (!pg_src || !pg_dest)
696: return (EFAULT);
697: }
698: }
699: while (src < end) {
700: *pg_dest++ ^= *pg_src++;
701: src++;
702: dest++;
703: len--;
704: if (RF_PAGE_ALIGNED(src))
705: REMAP_VA(bp, src, pg_src);
706: if (RF_PAGE_ALIGNED(dest))
707: REMAP_VA(bp, dest, pg_dest);
708: }
709: RF_ASSERT(len == 0);
710: return (0);
711: }
712:
713:
714: /*
715: * dst = a ^ b ^ c;
716: * a may equal dst
717: * see comment above longword_bxor
718: */
719: int
720: rf_longword_bxor3(unsigned long *dst, unsigned long *a, unsigned long *b,
721: unsigned long *c, int len, void *bp)
722: {
723: unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
724: /* Per-page source/dest pointers. */
725: unsigned long *pg_a, *pg_b, *pg_c, *pg_dst;
726: int longs_this_time; /* # longs to xor in the current iteration */
727: char dst_is_a = 0;
728:
729: /* Note: The length (len) is in longwords. */
730:
731: REMAP_VA(bp, a, pg_a);
732: REMAP_VA(bp, b, pg_b);
733: REMAP_VA(bp, c, pg_c);
734: if (a == dst) {
735: pg_dst = pg_a;
736: dst_is_a = 1;
737: } else {
738: REMAP_VA(bp, dst, pg_dst);
739: }
740:
741: /* Align dest to cache line. Can't cross a pg boundary on dst here. */
742: while ((((unsigned long) pg_dst) & 0x1f)) {
743: *pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
744: dst++;
745: a++;
746: b++;
747: c++;
748: if (RF_PAGE_ALIGNED(a)) {
749: REMAP_VA(bp, a, pg_a);
750: if (!pg_a)
751: return (EFAULT);
752: }
753: if (RF_PAGE_ALIGNED(b)) {
754: REMAP_VA(bp, a, pg_b);
755: if (!pg_b)
756: return (EFAULT);
757: }
758: if (RF_PAGE_ALIGNED(c)) {
759: REMAP_VA(bp, a, pg_c);
760: if (!pg_c)
761: return (EFAULT);
762: }
763: len--;
764: }
765:
766: while (len > 4) {
767: longs_this_time = RF_MIN(len, RF_MIN(RF_BLIP(a),
768: RF_MIN(RF_BLIP(b), RF_MIN(RF_BLIP(c), RF_BLIP(dst)))) >>
769: RF_LONGSHIFT);
770: a += longs_this_time;
771: b += longs_this_time;
772: c += longs_this_time;
773: dst += longs_this_time;
774: len -= longs_this_time;
775: while (longs_this_time >= 4) {
776: a0 = pg_a[0];
777: longs_this_time -= 4;
778:
779: a1 = pg_a[1];
780: a2 = pg_a[2];
781:
782: a3 = pg_a[3];
783: pg_a += 4;
784:
785: b0 = pg_b[0];
786: b1 = pg_b[1];
787:
788: b2 = pg_b[2];
789: b3 = pg_b[3];
790: /* Start dual issue. */
791: a0 ^= b0;
792: b0 = pg_c[0];
793:
794: pg_b += 4;
795: a1 ^= b1;
796:
797: a2 ^= b2;
798: a3 ^= b3;
799:
800: b1 = pg_c[1];
801: a0 ^= b0;
802:
803: b2 = pg_c[2];
804: a1 ^= b1;
805:
806: b3 = pg_c[3];
807: a2 ^= b2;
808:
809: pg_dst[0] = a0;
810: a3 ^= b3;
811: pg_dst[1] = a1;
812: pg_c += 4;
813: pg_dst[2] = a2;
814: pg_dst[3] = a3;
815: pg_dst += 4;
816: }
817: while (longs_this_time > 0) {
818: /* Cannot cross any page boundaries here. */
819: *pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
820: longs_this_time--;
821: }
822:
823: if (len) {
824: if (RF_PAGE_ALIGNED(a)) {
825: REMAP_VA(bp, a, pg_a);
826: if (!pg_a)
827: return (EFAULT);
828: if (dst_is_a)
829: pg_dst = pg_a;
830: }
831: if (RF_PAGE_ALIGNED(b)) {
832: REMAP_VA(bp, b, pg_b);
833: if (!pg_b)
834: return (EFAULT);
835: }
836: if (RF_PAGE_ALIGNED(c)) {
837: REMAP_VA(bp, c, pg_c);
838: if (!pg_c)
839: return (EFAULT);
840: }
841: if (!dst_is_a)
842: if (RF_PAGE_ALIGNED(dst)) {
843: REMAP_VA(bp, dst, pg_dst);
844: if (!pg_dst)
845: return (EFAULT);
846: }
847: }
848: }
849: while (len) {
850: *pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
851: dst++;
852: a++;
853: b++;
854: c++;
855: if (RF_PAGE_ALIGNED(a)) {
856: REMAP_VA(bp, a, pg_a);
857: if (!pg_a)
858: return (EFAULT);
859: if (dst_is_a)
860: pg_dst = pg_a;
861: }
862: if (RF_PAGE_ALIGNED(b)) {
863: REMAP_VA(bp, b, pg_b);
864: if (!pg_b)
865: return (EFAULT);
866: }
867: if (RF_PAGE_ALIGNED(c)) {
868: REMAP_VA(bp, c, pg_c);
869: if (!pg_c)
870: return (EFAULT);
871: }
872: if (!dst_is_a)
873: if (RF_PAGE_ALIGNED(dst)) {
874: REMAP_VA(bp, dst, pg_dst);
875: if (!pg_dst)
876: return (EFAULT);
877: }
878: len--;
879: }
880: return (0);
881: }
882:
883: int
884: rf_bxor3(unsigned char *dst, unsigned char *a, unsigned char *b,
885: unsigned char *c, unsigned long len, void *bp)
886: {
887: RF_ASSERT(((RF_UL(dst) | RF_UL(a) | RF_UL(b) | RF_UL(c) | len) & 0x7)
888: == 0);
889:
890: return (rf_longword_bxor3((unsigned long *) dst, (unsigned long *) a,
891: (unsigned long *) b, (unsigned long *) c, len >> RF_LONGSHIFT,
892: bp));
893: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_dagfuncs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe