Annotation of sys/dev/raidframe/rf_driver.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_driver.c,v 1.11 2002/12/16 07:01:03 tdeval Exp $ */
2: /* $NetBSD: rf_driver.c,v 1.37 2000/06/04 02:05:13 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Greg Oster
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: /*
41: * Copyright (c) 1995 Carnegie-Mellon University.
42: * All rights reserved.
43: *
44: * Author: Mark Holland, Khalil Amiri, Claudson Bornstein,
45: * William V. Courtright II, Robby Findler, Daniel Stodolsky,
46: * Rachad Youssef, Jim Zelenka
47: *
48: * Permission to use, copy, modify and distribute this software and
49: * its documentation is hereby granted, provided that both the copyright
50: * notice and this permission notice appear in all copies of the
51: * software, derivative works or modified versions, and any portions
52: * thereof, and that both notices appear in supporting documentation.
53: *
54: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
55: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
56: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
57: *
58: * Carnegie Mellon requests users of this software to return to
59: *
60: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
61: * School of Computer Science
62: * Carnegie Mellon University
63: * Pittsburgh PA 15213-3890
64: *
65: * any improvements or extensions that they make and grant Carnegie the
66: * rights to redistribute these changes.
67: */
68:
69: /*****************************************************************************
70: *
71: * rf_driver.c -- Main setup, teardown, and access routines for the RAID
72: * driver
73: *
74: * All routines are prefixed with rf_ (RAIDframe), to avoid conficts.
75: *
76: *****************************************************************************/
77:
78: #include <sys/types.h>
79: #include <sys/param.h>
80: #include <sys/systm.h>
81: #include <sys/ioctl.h>
82: #include <sys/fcntl.h>
83: #ifdef __NetBSD__
84: #include <sys/vnode.h>
85: #endif
86:
87:
88: #include "rf_archs.h"
89: #include "rf_threadstuff.h"
90:
91:
92: #include <sys/errno.h>
93:
94: #include "rf_raid.h"
95: #include "rf_dag.h"
96: #include "rf_aselect.h"
97: #include "rf_diskqueue.h"
98: #include "rf_parityscan.h"
99: #include "rf_alloclist.h"
100: #include "rf_dagutils.h"
101: #include "rf_utils.h"
102: #include "rf_etimer.h"
103: #include "rf_acctrace.h"
104: #include "rf_configure.h"
105: #include "rf_general.h"
106: #include "rf_desc.h"
107: #include "rf_states.h"
108: #include "rf_freelist.h"
109: #include "rf_decluster.h"
110: #include "rf_map.h"
111: #include "rf_revent.h"
112: #include "rf_callback.h"
113: #include "rf_engine.h"
114: #include "rf_memchunk.h"
115: #include "rf_mcpair.h"
116: #include "rf_nwayxor.h"
117: #include "rf_debugprint.h"
118: #include "rf_copyback.h"
119: #include "rf_driver.h"
120: #include "rf_options.h"
121: #include "rf_shutdown.h"
122: #include "rf_kintf.h"
123:
124: #include <sys/buf.h>
125:
126: /* rad == RF_RaidAccessDesc_t */
127: static RF_FreeList_t *rf_rad_freelist;
128: #define RF_MAX_FREE_RAD 128
129: #define RF_RAD_INC 16
130: #define RF_RAD_INITIAL 32
131:
132: /* Debug variables. */
133: char rf_panicbuf[2048]; /*
134: * A buffer to hold an error msg when we panic.
135: */
136:
137: /* Main configuration routines. */
138: static int raidframe_booted = 0;
139:
140: void rf_ConfigureDebug(RF_Config_t *);
141: void rf_set_debug_option(char *, long);
142: void rf_UnconfigureArray(void);
143: int rf_init_rad(RF_RaidAccessDesc_t *);
144: void rf_clean_rad(RF_RaidAccessDesc_t *);
145: void rf_ShutdownRDFreeList(void *);
146: int rf_ConfigureRDFreeList(RF_ShutdownList_t **);
147:
148: RF_DECLARE_MUTEX(rf_printf_mutex); /*
149: * Debug only: Avoids interleaved
150: * printfs by different stripes.
151: */
152:
153: #define SIGNAL_QUIESCENT_COND(_raid_) wakeup(&((_raid_)->accesses_suspended))
154: #define WAIT_FOR_QUIESCENCE(_raid_) \
155: tsleep(&((_raid_)->accesses_suspended), PRIBIO, "RAIDframe quiesce", 0);
156:
157: #define IO_BUF_ERR(bp, err) \
158: do { \
159: bp->b_flags |= B_ERROR; \
160: bp->b_resid = bp->b_bcount; \
161: bp->b_error = err; \
162: biodone(bp); \
163: } while (0)
164:
165: static int configureCount = 0; /* Number of active configurations. */
166: static int isconfigged = 0; /*
167: * Is basic RAIDframe (non per-array)
168: * stuff configured ?
169: */
170: RF_DECLARE_STATIC_MUTEX(configureMutex); /*
171: * Used to lock the
172: * configuration stuff.
173: */
174: static RF_ShutdownList_t *globalShutdown; /* Non array-specific stuff. */
175: int rf_ConfigureRDFreeList(RF_ShutdownList_t **);
176:
177:
178: /* Called at system boot time. */
179: int
180: rf_BootRaidframe(void)
181: {
182: int rc;
183:
184: if (raidframe_booted)
185: return (EBUSY);
186: raidframe_booted = 1;
187:
188: rc = rf_mutex_init(&configureMutex);
189: if (rc) {
190: RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
191: __FILE__, __LINE__, rc);
192: RF_PANIC();
193: }
194: configureCount = 0;
195: isconfigged = 0;
196: globalShutdown = NULL;
197: return (0);
198: }
199:
200:
201: /*
202: * This function is really just for debugging user-level stuff: It
203: * frees up all memory, other RAIDframe resources that might otherwise
204: * be kept around. This is used with systems like "sentinel" to detect
205: * memory leaks.
206: */
207: int
208: rf_UnbootRaidframe(void)
209: {
210: int rc;
211:
212: RF_LOCK_MUTEX(configureMutex);
213: if (configureCount) {
214: RF_UNLOCK_MUTEX(configureMutex);
215: return (EBUSY);
216: }
217: raidframe_booted = 0;
218: RF_UNLOCK_MUTEX(configureMutex);
219: rc = rf_mutex_destroy(&configureMutex);
220: if (rc) {
221: RF_ERRORMSG3("Unable to destroy mutex file %s line %d"
222: " rc=%d.\n", __FILE__, __LINE__, rc);
223: RF_PANIC();
224: }
225: return (0);
226: }
227:
228:
229: /*
230: * Called whenever an array is shutdown.
231: */
232: void
233: rf_UnconfigureArray(void)
234: {
235: int rc;
236:
237: RF_LOCK_MUTEX(configureMutex);
238: if (--configureCount == 0) { /*
239: * If no active configurations, shut
240: * everything down.
241: */
242: isconfigged = 0;
243:
244: rc = rf_ShutdownList(&globalShutdown);
245: if (rc) {
246: RF_ERRORMSG1("RAIDFRAME: unable to do global shutdown,"
247: " rc=%d.\n", rc);
248: }
249:
250: /*
251: * We must wait until now, because the AllocList module
252: * uses the DebugMem module.
253: */
254: if (rf_memDebug)
255: rf_print_unfreed();
256: }
257: RF_UNLOCK_MUTEX(configureMutex);
258: }
259:
260:
261: /*
262: * Called to shut down an array.
263: */
264: int
265: rf_Shutdown(RF_Raid_t *raidPtr)
266: {
267: if (!raidPtr->valid) {
268: RF_ERRORMSG("Attempt to shut down unconfigured RAIDframe"
269: " driver. Aborting shutdown.\n");
270: return (EINVAL);
271: }
272: /*
273: * Wait for outstanding IOs to land.
274: * As described in rf_raid.h, we use the rad_freelist lock
275: * to protect the per-array info about outstanding descs,
276: * since we need to do freelist locking anyway, and this
277: * cuts down on the amount of serialization we've got going
278: * on.
279: */
280: RF_FREELIST_DO_LOCK(rf_rad_freelist);
281: if (raidPtr->waitShutdown) {
282: RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
283: return (EBUSY);
284: }
285: raidPtr->waitShutdown = 1;
286: while (raidPtr->nAccOutstanding) {
287: RF_WAIT_COND(raidPtr->outstandingCond, RF_FREELIST_MUTEX_OF(rf_rad_freelist));
288: }
289: RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
290:
291: /* Wait for any parity re-writes to stop... */
292: while (raidPtr->parity_rewrite_in_progress) {
293: printf("Waiting for parity re-write to exit...\n");
294: tsleep(&raidPtr->parity_rewrite_in_progress, PRIBIO,
295: "rfprwshutdown", 0);
296: }
297:
298: raidPtr->valid = 0;
299:
300: rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE);
301:
302: rf_UnconfigureVnodes(raidPtr);
303:
304: rf_ShutdownList(&raidPtr->shutdownList);
305:
306: rf_UnconfigureArray();
307:
308: return (0);
309: }
310:
311: #define DO_INIT_CONFIGURE(f) \
312: do { \
313: rc = f (&globalShutdown); \
314: if (rc) { \
315: RF_ERRORMSG2("RAIDFRAME: failed %s with %d.\n", \
316: RF_STRING(f), rc); \
317: rf_ShutdownList(&globalShutdown); \
318: configureCount--; \
319: RF_UNLOCK_MUTEX(configureMutex); \
320: return(rc); \
321: } \
322: } while (0)
323:
324: #define DO_RAID_FAIL() \
325: do { \
326: rf_UnconfigureVnodes(raidPtr); \
327: rf_ShutdownList(&raidPtr->shutdownList); \
328: rf_UnconfigureArray(); \
329: } while (0)
330:
331: #define DO_RAID_INIT_CONFIGURE(f) \
332: do { \
333: rc = (f)(&raidPtr->shutdownList, raidPtr, cfgPtr); \
334: if (rc) { \
335: RF_ERRORMSG2("RAIDFRAME: failed %s with %d.\n", \
336: RF_STRING(f), rc); \
337: DO_RAID_FAIL(); \
338: return(rc); \
339: } \
340: } while (0)
341:
342: #define DO_RAID_MUTEX(_m_) \
343: do { \
344: rc = rf_create_managed_mutex(&raidPtr->shutdownList, (_m_)); \
345: if (rc) { \
346: RF_ERRORMSG3("Unable to init mutex file %s line %d" \
347: " rc=%d.\n", __FILE__, __LINE__, rc); \
348: DO_RAID_FAIL(); \
349: return(rc); \
350: } \
351: } while (0)
352:
353: #define DO_RAID_COND(_c_) \
354: do { \
355: rc = rf_create_managed_cond(&raidPtr->shutdownList, (_c_)); \
356: if (rc) { \
357: RF_ERRORMSG3("Unable to init cond file %s line %d" \
358: " rc=%d.\n", __FILE__, __LINE__, rc); \
359: DO_RAID_FAIL(); \
360: return(rc); \
361: } \
362: } while (0)
363:
364: int
365: rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac)
366: {
367: RF_RowCol_t row, col;
368: int i, rc;
369:
370: /*
371: * XXX This check can probably be removed now, since
372: * RAIDFRAME_CONFIGURE now checks to make sure that the
373: * RAID set is not already valid.
374: */
375: if (raidPtr->valid) {
376: RF_ERRORMSG("RAIDframe configuration not shut down."
377: " Aborting configure.\n");
378: return (EINVAL);
379: }
380: RF_LOCK_MUTEX(configureMutex);
381: configureCount++;
382: if (isconfigged == 0) {
383: rc = rf_create_managed_mutex(&globalShutdown, &rf_printf_mutex);
384: if (rc) {
385: RF_ERRORMSG3("Unable to init mutex file %s line %d"
386: " rc=%d.\n", __FILE__, __LINE__, rc);
387: rf_ShutdownList(&globalShutdown);
388: return (rc);
389: }
390: /* Initialize globals. */
391: #ifdef RAIDDEBUG
392: printf("RAIDFRAME: protectedSectors is %ld.\n",
393: rf_protectedSectors);
394: #endif /* RAIDDEBUG */
395:
396: rf_clear_debug_print_buffer();
397:
398: DO_INIT_CONFIGURE(rf_ConfigureAllocList);
399:
400: /*
401: * Yes, this does make debugging general to the whole
402: * system instead of being array specific. Bummer, drag.
403: */
404: rf_ConfigureDebug(cfgPtr);
405: DO_INIT_CONFIGURE(rf_ConfigureDebugMem);
406: DO_INIT_CONFIGURE(rf_ConfigureAccessTrace);
407: DO_INIT_CONFIGURE(rf_ConfigureMapModule);
408: DO_INIT_CONFIGURE(rf_ConfigureReconEvent);
409: DO_INIT_CONFIGURE(rf_ConfigureCallback);
410: DO_INIT_CONFIGURE(rf_ConfigureMemChunk);
411: DO_INIT_CONFIGURE(rf_ConfigureRDFreeList);
412: DO_INIT_CONFIGURE(rf_ConfigureNWayXor);
413: DO_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList);
414: DO_INIT_CONFIGURE(rf_ConfigureMCPair);
415: DO_INIT_CONFIGURE(rf_ConfigureDAGs);
416: DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs);
417: DO_INIT_CONFIGURE(rf_ConfigureDebugPrint);
418: DO_INIT_CONFIGURE(rf_ConfigureReconstruction);
419: DO_INIT_CONFIGURE(rf_ConfigureCopyback);
420: DO_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem);
421: isconfigged = 1;
422: }
423: RF_UNLOCK_MUTEX(configureMutex);
424:
425: DO_RAID_MUTEX(&raidPtr->mutex);
426: /*
427: * Set up the cleanup list. Do this after ConfigureDebug so that
428: * value of memDebug will be set.
429: */
430:
431: rf_MakeAllocList(raidPtr->cleanupList);
432: if (raidPtr->cleanupList == NULL) {
433: DO_RAID_FAIL();
434: return (ENOMEM);
435: }
436: rc = rf_ShutdownCreate(&raidPtr->shutdownList,
437: (void (*) (void *)) rf_FreeAllocList, raidPtr->cleanupList);
438: if (rc) {
439: RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
440: " rc=%d.\n", __FILE__, __LINE__, rc);
441: DO_RAID_FAIL();
442: return (rc);
443: }
444: raidPtr->numRow = cfgPtr->numRow;
445: raidPtr->numCol = cfgPtr->numCol;
446: raidPtr->numSpare = cfgPtr->numSpare;
447:
448: /*
449: * XXX We don't even pretend to support more than one row in the
450: * kernel...
451: */
452: if (raidPtr->numRow != 1) {
453: RF_ERRORMSG("Only one row supported in kernel.\n");
454: DO_RAID_FAIL();
455: return (EINVAL);
456: }
457: RF_CallocAndAdd(raidPtr->status, raidPtr->numRow,
458: sizeof(RF_RowStatus_t), (RF_RowStatus_t *), raidPtr->cleanupList);
459: if (raidPtr->status == NULL) {
460: DO_RAID_FAIL();
461: return (ENOMEM);
462: }
463: RF_CallocAndAdd(raidPtr->reconControl, raidPtr->numRow,
464: sizeof(RF_ReconCtrl_t *), (RF_ReconCtrl_t **), raidPtr->cleanupList);
465: if (raidPtr->reconControl == NULL) {
466: DO_RAID_FAIL();
467: return (ENOMEM);
468: }
469: for (i = 0; i < raidPtr->numRow; i++) {
470: raidPtr->status[i] = rf_rs_optimal;
471: raidPtr->reconControl[i] = NULL;
472: }
473:
474: DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine);
475: DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks);
476:
477: DO_RAID_COND(&raidPtr->outstandingCond);
478:
479: raidPtr->nAccOutstanding = 0;
480: raidPtr->waitShutdown = 0;
481:
482: DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
483: DO_RAID_COND(&raidPtr->quiescent_cond);
484:
485: DO_RAID_COND(&raidPtr->waitForReconCond);
486:
487: DO_RAID_MUTEX(&raidPtr->recon_done_proc_mutex);
488:
489: if (ac != NULL) {
490: /*
491: * We have an AutoConfig structure... Don't do the
492: * normal disk configuration... call the auto config
493: * stuff.
494: */
495: rf_AutoConfigureDisks(raidPtr, cfgPtr, ac);
496: } else {
497: DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks);
498: DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks);
499: }
500: /*
501: * Do this after ConfigureDisks & ConfigureSpareDisks to be sure
502: * devno is set.
503: */
504: DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues);
505:
506: DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout);
507:
508: DO_RAID_INIT_CONFIGURE(rf_ConfigurePSStatus);
509:
510: for (row = 0; row < raidPtr->numRow; row++) {
511: for (col = 0; col < raidPtr->numCol; col++) {
512: /*
513: * XXX Better distribution.
514: */
515: raidPtr->hist_diskreq[row][col] = 0;
516: }
517: }
518:
519: raidPtr->numNewFailures = 0;
520: raidPtr->copyback_in_progress = 0;
521: raidPtr->parity_rewrite_in_progress = 0;
522: raidPtr->recon_in_progress = 0;
523: raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs;
524:
525: /*
526: * Autoconfigure and root_partition will actually get filled in
527: * after the config is done.
528: */
529: raidPtr->autoconfigure = 0;
530: raidPtr->root_partition = 0;
531: raidPtr->last_unit = raidPtr->raidid;
532: raidPtr->config_order = 0;
533:
534: if (rf_keepAccTotals) {
535: raidPtr->keep_acc_totals = 1;
536: }
537: rf_StartUserStats(raidPtr);
538:
539: raidPtr->valid = 1;
540: return (0);
541: }
542:
543: int
544: rf_init_rad(RF_RaidAccessDesc_t *desc)
545: {
546: int rc;
547:
548: rc = rf_mutex_init(&desc->mutex);
549: if (rc) {
550: RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n", __FILE__,
551: __LINE__, rc);
552: return (rc);
553: }
554: rc = rf_cond_init(&desc->cond);
555: if (rc) {
556: RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d.\n", __FILE__,
557: __LINE__, rc);
558: rf_mutex_destroy(&desc->mutex);
559: return (rc);
560: }
561: return (0);
562: }
563:
564: void
565: rf_clean_rad(RF_RaidAccessDesc_t *desc)
566: {
567: rf_mutex_destroy(&desc->mutex);
568: rf_cond_destroy(&desc->cond);
569: }
570:
571: void
572: rf_ShutdownRDFreeList(void *ignored)
573: {
574: RF_FREELIST_DESTROY_CLEAN(rf_rad_freelist, next,
575: (RF_RaidAccessDesc_t *), rf_clean_rad);
576: }
577:
578: int
579: rf_ConfigureRDFreeList(RF_ShutdownList_t **listp)
580: {
581: int rc;
582:
583: RF_FREELIST_CREATE(rf_rad_freelist, RF_MAX_FREE_RAD,
584: RF_RAD_INC, sizeof(RF_RaidAccessDesc_t));
585: if (rf_rad_freelist == NULL) {
586: return (ENOMEM);
587: }
588: rc = rf_ShutdownCreate(listp, rf_ShutdownRDFreeList, NULL);
589: if (rc) {
590: RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d.\n", __FILE__,
591: __LINE__, rc);
592: rf_ShutdownRDFreeList(NULL);
593: return (rc);
594: }
595: RF_FREELIST_PRIME_INIT(rf_rad_freelist, RF_RAD_INITIAL, next,
596: (RF_RaidAccessDesc_t *), rf_init_rad);
597: return (0);
598: }
599:
600: RF_RaidAccessDesc_t *
601: rf_AllocRaidAccDesc(
602: RF_Raid_t *raidPtr,
603: RF_IoType_t type,
604: RF_RaidAddr_t raidAddress,
605: RF_SectorCount_t numBlocks,
606: caddr_t bufPtr,
607: void *bp,
608: RF_DagHeader_t **paramDAG,
609: RF_AccessStripeMapHeader_t **paramASM,
610: RF_RaidAccessFlags_t flags,
611: void (*cbF) (struct buf *),
612: void *cbA,
613: RF_AccessState_t *states
614: )
615: {
616: RF_RaidAccessDesc_t *desc;
617:
618: RF_FREELIST_GET_INIT_NOUNLOCK(rf_rad_freelist, desc, next,
619: (RF_RaidAccessDesc_t *), rf_init_rad);
620: if (raidPtr->waitShutdown) {
621: /*
622: * Actually, we're shutting the array down. Free the desc
623: * and return NULL.
624: */
625: RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
626: RF_FREELIST_FREE_CLEAN(rf_rad_freelist, desc, next,
627: rf_clean_rad);
628: return (NULL);
629: }
630: raidPtr->nAccOutstanding++;
631: RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
632:
633: desc->raidPtr = (void *) raidPtr;
634: desc->type = type;
635: desc->raidAddress = raidAddress;
636: desc->numBlocks = numBlocks;
637: desc->bufPtr = bufPtr;
638: desc->bp = bp;
639: desc->paramDAG = paramDAG;
640: desc->paramASM = paramASM;
641: desc->flags = flags;
642: desc->states = states;
643: desc->state = 0;
644:
645: desc->status = 0;
646: bzero((char *) &desc->tracerec, sizeof(RF_AccTraceEntry_t));
647: desc->callbackFunc = (void (*) (RF_CBParam_t)) cbF; /* XXX */
648: desc->callbackArg = cbA;
649: desc->next = NULL;
650: desc->head = desc;
651: desc->numPending = 0;
652: desc->cleanupList = NULL;
653: rf_MakeAllocList(desc->cleanupList);
654: return (desc);
655: }
656:
657: void
658: rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc)
659: {
660: RF_Raid_t *raidPtr = desc->raidPtr;
661:
662: RF_ASSERT(desc);
663:
664: rf_FreeAllocList(desc->cleanupList);
665: RF_FREELIST_FREE_CLEAN_NOUNLOCK(rf_rad_freelist, desc, next, rf_clean_rad);
666: raidPtr->nAccOutstanding--;
667: if (raidPtr->waitShutdown) {
668: RF_SIGNAL_COND(raidPtr->outstandingCond);
669: }
670: RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
671: }
672:
673:
674: /********************************************************************
675: * Main routine for performing an access.
676: * Accesses are retried until a DAG can not be selected. This occurs
677: * when either the DAG library is incomplete or there are too many
678: * failures in a parity group.
679: ********************************************************************/
680: int
681: rf_DoAccess(
682: RF_Raid_t *raidPtr,
683: RF_IoType_t type, /* Should be read or write. */
684: int async_flag, /*
685: * Should be RF_TRUE
686: * or RF_FALSE.
687: */
688: RF_RaidAddr_t raidAddress,
689: RF_SectorCount_t numBlocks,
690: caddr_t bufPtr,
691: void *bp_in, /*
692: * It's a buf pointer.
693: * void * to facilitate
694: * ignoring it outside
695: * the kernel.
696: */
697: RF_DagHeader_t **paramDAG,
698: RF_AccessStripeMapHeader_t **paramASM,
699: RF_RaidAccessFlags_t flags,
700: RF_RaidAccessDesc_t **paramDesc,
701: void (*cbF) (struct buf *),
702: void *cbA
703: )
704: {
705: RF_RaidAccessDesc_t *desc;
706: caddr_t lbufPtr = bufPtr;
707: struct buf *bp = (struct buf *) bp_in;
708:
709: raidAddress += rf_raidSectorOffset;
710:
711: if (!raidPtr->valid) {
712: RF_ERRORMSG("RAIDframe driver not successfully configured."
713: " Rejecting access.\n");
714: IO_BUF_ERR(bp, EINVAL);
715: return (EINVAL);
716: }
717:
718: if (rf_accessDebug) {
719:
720: printf("logBytes is: %d %d %d.\n", raidPtr->raidid,
721: raidPtr->logBytesPerSector,
722: (int) rf_RaidAddressToByte(raidPtr, numBlocks));
723: printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx.\n", raidPtr->raidid,
724: (type == RF_IO_TYPE_READ) ? "READ" : "WRITE", (int) raidAddress,
725: (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress),
726: (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1),
727: (int) numBlocks,
728: (int) rf_RaidAddressToByte(raidPtr, numBlocks),
729: (long) bufPtr);
730: }
731: if (raidAddress + numBlocks > raidPtr->totalSectors) {
732:
733: printf("DoAccess: raid addr %lu too large to access %lu sectors. Max legal addr is %lu.\n",
734: (u_long) raidAddress, (u_long) numBlocks, (u_long) raidPtr->totalSectors);
735:
736: IO_BUF_ERR(bp, ENOSPC);
737: return (ENOSPC);
738: }
739: desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress,
740: numBlocks, lbufPtr, bp, paramDAG, paramASM,
741: flags, cbF, cbA, raidPtr->Layout.map->states);
742:
743: if (desc == NULL) {
744: return (ENOMEM);
745: }
746: RF_ETIMER_START(desc->tracerec.tot_timer);
747:
748: desc->async_flag = async_flag;
749:
750: rf_ContinueRaidAccess(desc);
751:
752: return (0);
753: }
754:
755:
756: /* Force the array into reconfigured mode without doing reconstruction. */
757: int
758: rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int row, int col)
759: {
760: if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
761: printf("Can't set reconfigured mode in dedicated-spare"
762: " array.\n");
763: RF_PANIC();
764: }
765: RF_LOCK_MUTEX(raidPtr->mutex);
766: raidPtr->numFailures++;
767: raidPtr->Disks[row][col].status = rf_ds_dist_spared;
768: raidPtr->status[row] = rf_rs_reconfigured;
769: rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
770: /*
771: * Install spare table only if declustering + distributed sparing
772: * architecture.
773: */
774: if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED)
775: rf_InstallSpareTable(raidPtr, row, col);
776: RF_UNLOCK_MUTEX(raidPtr->mutex);
777: return (0);
778: }
779:
780: extern int fail_row, fail_col, fail_time;
781: extern int delayed_recon;
782:
783: int
784: rf_FailDisk(RF_Raid_t *raidPtr, int frow, int fcol, int initRecon)
785: {
786: printf("raid%d: Failing disk r%d c%d.\n", raidPtr->raidid, frow, fcol);
787: RF_LOCK_MUTEX(raidPtr->mutex);
788: raidPtr->numFailures++;
789: raidPtr->Disks[frow][fcol].status = rf_ds_failed;
790: raidPtr->status[frow] = rf_rs_degraded;
791: rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
792: RF_UNLOCK_MUTEX(raidPtr->mutex);
793: if (initRecon)
794: rf_ReconstructFailedDisk(raidPtr, frow, fcol);
795: return (0);
796: }
797:
798:
799: /*
800: * Releases a thread that is waiting for the array to become quiesced.
801: * access_suspend_mutex should be locked upon calling this.
802: */
803: void
804: rf_SignalQuiescenceLock(RF_Raid_t *raidPtr, RF_RaidReconDesc_t *reconDesc)
805: {
806: if (rf_quiesceDebug) {
807: printf("raid%d: Signalling quiescence lock.\n",
808: raidPtr->raidid);
809: }
810: raidPtr->access_suspend_release = 1;
811:
812: if (raidPtr->waiting_for_quiescence) {
813: SIGNAL_QUIESCENT_COND(raidPtr);
814: }
815: }
816:
817:
818: /*
819: * Suspends all new requests to the array. No effect on accesses that are
820: * in flight.
821: */
822: int
823: rf_SuspendNewRequestsAndWait(RF_Raid_t *raidPtr)
824: {
825: if (rf_quiesceDebug)
826: printf("Suspending new reqs.\n");
827:
828: RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
829: raidPtr->accesses_suspended++;
830: raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1;
831:
832: if (raidPtr->waiting_for_quiescence) {
833: raidPtr->access_suspend_release = 0;
834: while (!raidPtr->access_suspend_release) {
835: printf("Suspending: Waiting for Quiescence.\n");
836: WAIT_FOR_QUIESCENCE(raidPtr);
837: raidPtr->waiting_for_quiescence = 0;
838: }
839: }
840: printf("Quiescence reached...\n");
841:
842: RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
843: return (raidPtr->waiting_for_quiescence);
844: }
845:
846:
847: /* Wake up everyone waiting for quiescence to be released. */
848: void
849: rf_ResumeNewRequests(RF_Raid_t *raidPtr)
850: {
851: RF_CallbackDesc_t *t, *cb;
852:
853: if (rf_quiesceDebug)
854: printf("Resuming new reqs.\n");
855:
856: RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
857: raidPtr->accesses_suspended--;
858: if (raidPtr->accesses_suspended == 0)
859: cb = raidPtr->quiesce_wait_list;
860: else
861: cb = NULL;
862: raidPtr->quiesce_wait_list = NULL;
863: RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
864:
865: while (cb) {
866: t = cb;
867: cb = cb->next;
868: (t->callbackFunc) (t->callbackArg);
869: rf_FreeCallbackDesc(t);
870: }
871: }
872:
873:
874: /*****************************************************************************
875: *
876: * Debug routines.
877: *
878: *****************************************************************************/
879:
880: void
881: rf_set_debug_option(char *name, long val)
882: {
883: RF_DebugName_t *p;
884:
885: for (p = rf_debugNames; p->name; p++) {
886: if (!strcmp(p->name, name)) {
887: *(p->ptr) = val;
888: printf("[Set debug variable %s to %ld]\n", name, val);
889: return;
890: }
891: }
892: RF_ERRORMSG1("Unknown debug string \"%s\"\n", name);
893: }
894:
895:
896: /* Would like to use sscanf here, but apparently not available in kernel. */
897: /*ARGSUSED*/
898: void
899: rf_ConfigureDebug(RF_Config_t *cfgPtr)
900: {
901: char *val_p, *name_p, *white_p;
902: long val;
903: int i;
904:
905: rf_ResetDebugOptions();
906: for (i = 0; cfgPtr->debugVars[i][0] && i < RF_MAXDBGV; i++) {
907: name_p = rf_find_non_white(&cfgPtr->debugVars[i][0]);
908: white_p = rf_find_white(name_p); /*
909: * Skip to start of 2nd
910: * word.
911: */
912: val_p = rf_find_non_white(white_p);
913: if (*val_p == '0' && *(val_p + 1) == 'x')
914: val = rf_htoi(val_p + 2);
915: else
916: val = rf_atoi(val_p);
917: *white_p = '\0';
918: rf_set_debug_option(name_p, val);
919: }
920: }
921:
922:
923: /* Performance monitoring stuff. */
924:
925: #if !defined(_KERNEL) && !defined(SIMULATE)
926:
927: /*
928: * Throughput stats currently only used in user-level RAIDframe.
929: */
930:
931: int
932: rf_InitThroughputStats(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
933: RF_Config_t *cfgPtr)
934: {
935: int rc;
936:
937: /* These used by user-level RAIDframe only. */
938: rc = rf_create_managed_mutex(listp, &raidPtr->throughputstats.mutex);
939: if (rc) {
940: RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
941: __FILE__, __LINE__, rc);
942: return (rc);
943: }
944: raidPtr->throughputstats.sum_io_us = 0;
945: raidPtr->throughputstats.num_ios = 0;
946: raidPtr->throughputstats.num_out_ios = 0;
947: return (0);
948: }
949:
950: void
951: rf_StartThroughputStats(RF_Raid_t *raidPtr)
952: {
953: RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
954: raidPtr->throughputstats.num_ios++;
955: raidPtr->throughputstats.num_out_ios++;
956: if (raidPtr->throughputstats.num_out_ios == 1)
957: RF_GETTIME(raidPtr->throughputstats.start);
958: RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
959: }
960:
961: void
962: rf_StopThroughputStats(RF_Raid_t *raidPtr)
963: {
964: struct timeval diff;
965:
966: RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
967: raidPtr->throughputstats.num_out_ios--;
968: if (raidPtr->throughputstats.num_out_ios == 0) {
969: RF_GETTIME(raidPtr->throughputstats.stop);
970: RF_TIMEVAL_DIFF(&raidPtr->throughputstats.start,
971: &raidPtr->throughputstats.stop, &diff);
972: raidPtr->throughputstats.sum_io_us += RF_TIMEVAL_TO_US(diff);
973: }
974: RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
975: }
976:
977: void
978: rf_PrintThroughputStats(RF_Raid_t *raidPtr)
979: {
980: RF_ASSERT(raidPtr->throughputstats.num_out_ios == 0);
981: if (raidPtr->throughputstats.sum_io_us != 0) {
982: printf("[Througphut: %8.2f IOs/second]\n",
983: raidPtr->throughputstats.num_ios /
984: (raidPtr->throughputstats.sum_io_us / 1000000.0));
985: }
986: }
987:
988: #endif /* !_KERNEL && !SIMULATE */
989:
990: void
991: rf_StartUserStats(RF_Raid_t *raidPtr)
992: {
993: RF_GETTIME(raidPtr->userstats.start);
994: raidPtr->userstats.sum_io_us = 0;
995: raidPtr->userstats.num_ios = 0;
996: raidPtr->userstats.num_sect_moved = 0;
997: }
998:
999: void
1000: rf_StopUserStats(RF_Raid_t *raidPtr)
1001: {
1002: RF_GETTIME(raidPtr->userstats.stop);
1003: }
1004:
1005: void
1006: rf_UpdateUserStats(
1007: RF_Raid_t *raidPtr,
1008: int rt, /* Response time in us. */
1009: int numsect /* Number of sectors for this access. */
1010: )
1011: {
1012: raidPtr->userstats.sum_io_us += rt;
1013: raidPtr->userstats.num_ios++;
1014: raidPtr->userstats.num_sect_moved += numsect;
1015: }
1016:
1017: void
1018: rf_PrintUserStats(RF_Raid_t *raidPtr)
1019: {
1020: long elapsed_us, mbs, mbs_frac;
1021: struct timeval diff;
1022:
1023: RF_TIMEVAL_DIFF(&raidPtr->userstats.start, &raidPtr->userstats.stop,
1024: &diff);
1025: elapsed_us = RF_TIMEVAL_TO_US(diff);
1026:
1027: /* 2000 sectors per megabyte, 10000000 microseconds per second. */
1028: if (elapsed_us)
1029: mbs = (raidPtr->userstats.num_sect_moved / 2000) /
1030: (elapsed_us / 1000000);
1031: else
1032: mbs = 0;
1033:
1034: /* This computes only the first digit of the fractional mb/s moved. */
1035: if (elapsed_us) {
1036: mbs_frac = ((raidPtr->userstats.num_sect_moved / 200) /
1037: (elapsed_us / 1000000)) - (mbs * 10);
1038: } else {
1039: mbs_frac = 0;
1040: }
1041:
1042: printf("Number of I/Os: %ld\n",
1043: raidPtr->userstats.num_ios);
1044: printf("Elapsed time (us): %ld\n",
1045: elapsed_us);
1046: printf("User I/Os per second: %ld\n",
1047: RF_DB0_CHECK(raidPtr->userstats.num_ios, (elapsed_us / 1000000)));
1048: printf("Average user response time: %ld us\n",
1049: RF_DB0_CHECK(raidPtr->userstats.sum_io_us,
1050: raidPtr->userstats.num_ios));
1051: printf("Total sectors moved: %ld\n",
1052: raidPtr->userstats.num_sect_moved);
1053: printf("Average access size (sect): %ld\n",
1054: RF_DB0_CHECK(raidPtr->userstats.num_sect_moved,
1055: raidPtr->userstats.num_ios));
1056: printf("Achieved data rate: %ld.%ld MB/sec\n",
1057: mbs, mbs_frac);
1058: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_driver.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe