![[BACK]](/icons/back.gif){kind=icon}
Return to rf_sstf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_sstf.c CVS log | Up to [local] / sys / dev / raidframe |
1.1 ! nbrk 1: /* $OpenBSD: rf_sstf.c,v 1.4 2002/12/16 07:01:05 tdeval Exp $ */
! 2: /* $NetBSD: rf_sstf.c,v 1.4 2000/01/08 23:45:05 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: Jim Zelenka
! 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: * sstf.c -- Prioritized shortest seek time first disk queueing code.
! 34: *
! 35: *****************************************************************************/
! 36:
! 37: #include "rf_alloclist.h"
! 38: #include "rf_stripelocks.h"
! 39: #include "rf_layout.h"
! 40: #include "rf_diskqueue.h"
! 41: #include "rf_sstf.h"
! 42: #include "rf_debugMem.h"
! 43: #include "rf_general.h"
! 44: #include "rf_options.h"
! 45: #include "rf_raid.h"
! 46: #include "rf_types.h"
! 47:
! 48: #define DIR_LEFT 1
! 49: #define DIR_RIGHT 2
! 50: #define DIR_EITHER 3
! 51:
! 52: #define SNUM_DIFF(_a_,_b_) \
! 53: (((_a_) > (_b_)) ? ((_a_) - (_b_)) : ((_b_) - (_a_)))
! 54:
! 55: #define QSUM(_sstfq_) \
! 56: (((_sstfq_)->lopri.qlen) + ((_sstfq_)->left.qlen) + \
! 57: ((_sstfq_)->right.qlen))
! 58:
! 59:
! 60: void rf_do_sstf_ord_q(RF_DiskQueueData_t **, RF_DiskQueueData_t **,
! 61: RF_DiskQueueData_t *);
! 62: void rf_do_dequeue(RF_SstfQ_t *, RF_DiskQueueData_t *);
! 63: RF_DiskQueueData_t *rf_closest_to_arm(RF_SstfQ_t *, RF_SectorNum_t,
! 64: int *, int);
! 65:
! 66:
! 67: void
! 68: rf_do_sstf_ord_q(RF_DiskQueueData_t **queuep, RF_DiskQueueData_t **tailp,
! 69: RF_DiskQueueData_t *req)
! 70: {
! 71: RF_DiskQueueData_t *r, *s;
! 72:
! 73: if (*queuep == NULL) {
! 74: *queuep = req;
! 75: *tailp = req;
! 76: req->next = NULL;
! 77: req->prev = NULL;
! 78: return;
! 79: }
! 80: if (req->sectorOffset <= (*queuep)->sectorOffset) {
! 81: req->next = *queuep;
! 82: req->prev = NULL;
! 83: (*queuep)->prev = req;
! 84: *queuep = req;
! 85: return;
! 86: }
! 87: if (req->sectorOffset > (*tailp)->sectorOffset) {
! 88: /* Optimization. */
! 89: r = NULL;
! 90: s = *tailp;
! 91: goto q_at_end;
! 92: }
! 93: for (s = NULL, r = *queuep; r; s = r, r = r->next) {
! 94: if (r->sectorOffset >= req->sectorOffset) {
! 95: /* Insert after s, before r. */
! 96: RF_ASSERT(s);
! 97: req->next = r;
! 98: r->prev = req;
! 99: s->next = req;
! 100: req->prev = s;
! 101: return;
! 102: }
! 103: }
! 104: q_at_end:
! 105: /* Insert after s, at end of queue. */
! 106: RF_ASSERT(r == NULL);
! 107: RF_ASSERT(s);
! 108: RF_ASSERT(s == (*tailp));
! 109: req->next = NULL;
! 110: req->prev = s;
! 111: s->next = req;
! 112: *tailp = req;
! 113: }
! 114:
! 115: /* For removing from head-of-queue. */
! 116: #define DO_HEAD_DEQ(_r_,_q_) \
! 117: do { \
! 118: _r_ = (_q_)->queue; \
! 119: RF_ASSERT((_r_) != NULL); \
! 120: (_q_)->queue = (_r_)->next; \
! 121: (_q_)->qlen--; \
! 122: if ((_q_)->qlen == 0) { \
! 123: RF_ASSERT((_r_) == (_q_)->qtail); \
! 124: RF_ASSERT((_q_)->queue == NULL); \
! 125: (_q_)->qtail = NULL; \
! 126: } else { \
! 127: RF_ASSERT((_q_)->queue->prev == (_r_)); \
! 128: (_q_)->queue->prev = NULL; \
! 129: } \
! 130: } while (0)
! 131:
! 132: /* For removing from end-of-queue. */
! 133: #define DO_TAIL_DEQ(_r_,_q_) \
! 134: do { \
! 135: _r_ = (_q_)->qtail; \
! 136: RF_ASSERT((_r_) != NULL); \
! 137: (_q_)->qtail = (_r_)->prev; \
! 138: (_q_)->qlen--; \
! 139: if ((_q_)->qlen == 0) { \
! 140: RF_ASSERT((_r_) == (_q_)->queue); \
! 141: RF_ASSERT((_q_)->qtail == NULL); \
! 142: (_q_)->queue = NULL; \
! 143: } else { \
! 144: RF_ASSERT((_q_)->qtail->next == (_r_)); \
! 145: (_q_)->qtail->next = NULL; \
! 146: } \
! 147: } while (0)
! 148:
! 149: #define DO_BEST_DEQ(_l_,_r_,_q_) \
! 150: do { \
! 151: if (SNUM_DIFF((_q_)->queue->sectorOffset,_l_) \
! 152: < SNUM_DIFF((_q_)->qtail->sectorOffset,_l_)) \
! 153: { \
! 154: DO_HEAD_DEQ(_r_,_q_); \
! 155: } else { \
! 156: DO_TAIL_DEQ(_r_,_q_); \
! 157: } \
! 158: } while (0)
! 159:
! 160: RF_DiskQueueData_t *
! 161: rf_closest_to_arm(RF_SstfQ_t *queue, RF_SectorNum_t arm_pos, int *dir,
! 162: int allow_reverse)
! 163: {
! 164: RF_SectorNum_t best_pos_l = 0, this_pos_l = 0, last_pos = 0;
! 165: RF_SectorNum_t best_pos_r = 0, this_pos_r = 0;
! 166: RF_DiskQueueData_t *r, *best_l, *best_r;
! 167:
! 168: best_r = best_l = NULL;
! 169: for (r = queue->queue; r; r = r->next) {
! 170: if (r->sectorOffset < arm_pos) {
! 171: if (best_l == NULL) {
! 172: best_l = r;
! 173: last_pos = best_pos_l = this_pos_l;
! 174: } else {
! 175: this_pos_l = arm_pos - r->sectorOffset;
! 176: if (this_pos_l < best_pos_l) {
! 177: best_l = r;
! 178: last_pos = best_pos_l = this_pos_l;
! 179: } else {
! 180: last_pos = this_pos_l;
! 181: }
! 182: }
! 183: } else {
! 184: if (best_r == NULL) {
! 185: best_r = r;
! 186: last_pos = best_pos_r = this_pos_r;
! 187: } else {
! 188: this_pos_r = r->sectorOffset - arm_pos;
! 189: if (this_pos_r < best_pos_r) {
! 190: best_r = r;
! 191: last_pos = best_pos_r = this_pos_r;
! 192: } else {
! 193: last_pos = this_pos_r;
! 194: }
! 195: if (this_pos_r > last_pos) {
! 196: /* Getting farther away. */
! 197: break;
! 198: }
! 199: }
! 200: }
! 201: }
! 202: if ((best_r == NULL) && (best_l == NULL))
! 203: return (NULL);
! 204: if ((*dir == DIR_RIGHT) && best_r)
! 205: return (best_r);
! 206: if ((*dir == DIR_LEFT) && best_l)
! 207: return (best_l);
! 208: if (*dir == DIR_EITHER) {
! 209: if (best_l == NULL)
! 210: return (best_r);
! 211: if (best_r == NULL)
! 212: return (best_l);
! 213: if (best_pos_r < best_pos_l)
! 214: return (best_r);
! 215: else
! 216: return (best_l);
! 217: }
! 218: /*
! 219: * Nothing in the direction we want to go. Reverse or
! 220: * reset the arm. We know we have an I/O in the other
! 221: * direction.
! 222: */
! 223: if (allow_reverse) {
! 224: if (*dir == DIR_RIGHT) {
! 225: *dir = DIR_LEFT;
! 226: return (best_l);
! 227: } else {
! 228: *dir = DIR_RIGHT;
! 229: return (best_r);
! 230: }
! 231: }
! 232: /*
! 233: * Reset (beginning of queue).
! 234: */
! 235: RF_ASSERT(*dir == DIR_RIGHT);
! 236: return (queue->queue);
! 237: }
! 238:
! 239: void *
! 240: rf_SstfCreate(RF_SectorCount_t sect_per_disk, RF_AllocListElem_t *cl_list,
! 241: RF_ShutdownList_t **listp)
! 242: {
! 243: RF_Sstf_t *sstfq;
! 244:
! 245: RF_CallocAndAdd(sstfq, 1, sizeof(RF_Sstf_t), (RF_Sstf_t *), cl_list);
! 246: sstfq->dir = DIR_EITHER;
! 247: sstfq->allow_reverse = 1;
! 248: return ((void *) sstfq);
! 249: }
! 250:
! 251: void *
! 252: rf_ScanCreate(RF_SectorCount_t sect_per_disk, RF_AllocListElem_t *cl_list,
! 253: RF_ShutdownList_t **listp)
! 254: {
! 255: RF_Sstf_t *scanq;
! 256:
! 257: RF_CallocAndAdd(scanq, 1, sizeof(RF_Sstf_t), (RF_Sstf_t *), cl_list);
! 258: scanq->dir = DIR_RIGHT;
! 259: scanq->allow_reverse = 1;
! 260: return ((void *) scanq);
! 261: }
! 262:
! 263: void *
! 264: rf_CscanCreate(RF_SectorCount_t sect_per_disk, RF_AllocListElem_t *cl_list,
! 265: RF_ShutdownList_t **listp)
! 266: {
! 267: RF_Sstf_t *cscanq;
! 268:
! 269: RF_CallocAndAdd(cscanq, 1, sizeof(RF_Sstf_t), (RF_Sstf_t *), cl_list);
! 270: cscanq->dir = DIR_RIGHT;
! 271: return ((void *) cscanq);
! 272: }
! 273:
! 274: void
! 275: rf_SstfEnqueue(void *qptr, RF_DiskQueueData_t *req, int priority)
! 276: {
! 277: RF_Sstf_t *sstfq;
! 278:
! 279: sstfq = (RF_Sstf_t *) qptr;
! 280:
! 281: if (priority == RF_IO_LOW_PRIORITY) {
! 282: if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
! 283: RF_DiskQueue_t *dq;
! 284: dq = (RF_DiskQueue_t *) req->queue;
! 285: printf("raid%d: ENQ lopri %d,%d queues are %d,%d,%d.\n",
! 286: req->raidPtr->raidid, dq->row, dq->col,
! 287: sstfq->left.qlen, sstfq->right.qlen,
! 288: sstfq->lopri.qlen);
! 289: }
! 290: rf_do_sstf_ord_q(&sstfq->lopri.queue, &sstfq->lopri.qtail, req);
! 291: sstfq->lopri.qlen++;
! 292: } else {
! 293: if (req->sectorOffset < sstfq->last_sector) {
! 294: rf_do_sstf_ord_q(&sstfq->left.queue,
! 295: &sstfq->left.qtail, req);
! 296: sstfq->left.qlen++;
! 297: } else {
! 298: rf_do_sstf_ord_q(&sstfq->right.queue,
! 299: &sstfq->right.qtail, req);
! 300: sstfq->right.qlen++;
! 301: }
! 302: }
! 303: }
! 304:
! 305: void
! 306: rf_do_dequeue(RF_SstfQ_t *queue, RF_DiskQueueData_t *req)
! 307: {
! 308: RF_DiskQueueData_t *req2;
! 309:
! 310: if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
! 311: printf("raid%d: rf_do_dequeue.\n", req->raidPtr->raidid);
! 312: }
! 313: if (req == queue->queue) {
! 314: DO_HEAD_DEQ(req2, queue);
! 315: RF_ASSERT(req2 == req);
! 316: } else
! 317: if (req == queue->qtail) {
! 318: DO_TAIL_DEQ(req2, queue);
! 319: RF_ASSERT(req2 == req);
! 320: } else {
! 321: /* Dequeue from middle of list. */
! 322: RF_ASSERT(req->next);
! 323: RF_ASSERT(req->prev);
! 324: queue->qlen--;
! 325: req->next->prev = req->prev;
! 326: req->prev->next = req->next;
! 327: req->next = req->prev = NULL;
! 328: }
! 329: }
! 330:
! 331: RF_DiskQueueData_t *
! 332: rf_SstfDequeue(void *qptr)
! 333: {
! 334: RF_DiskQueueData_t *req = NULL;
! 335: RF_Sstf_t *sstfq;
! 336:
! 337: sstfq = (RF_Sstf_t *) qptr;
! 338:
! 339: if (rf_sstfDebug) {
! 340: RF_DiskQueue_t *dq;
! 341: dq = (RF_DiskQueue_t *) req->queue;
! 342: RF_ASSERT(QSUM(sstfq) == dq->queueLength);
! 343: printf("raid%d: sstf: Dequeue %d,%d queues are %d,%d,%d.\n",
! 344: req->raidPtr->raidid, dq->row, dq->col,
! 345: sstfq->left.qlen, sstfq->right.qlen, sstfq->lopri.qlen);
! 346: }
! 347: if (sstfq->left.queue == NULL) {
! 348: RF_ASSERT(sstfq->left.qlen == 0);
! 349: if (sstfq->right.queue == NULL) {
! 350: RF_ASSERT(sstfq->right.qlen == 0);
! 351: if (sstfq->lopri.queue == NULL) {
! 352: RF_ASSERT(sstfq->lopri.qlen == 0);
! 353: return (NULL);
! 354: }
! 355: if (rf_sstfDebug) {
! 356: printf("raid%d: sstf: check for close lopri.\n",
! 357: req->raidPtr->raidid);
! 358: }
! 359: req = rf_closest_to_arm(&sstfq->lopri,
! 360: sstfq->last_sector, &sstfq->dir,
! 361: sstfq->allow_reverse);
! 362: if (rf_sstfDebug) {
! 363: printf("raid%d: sstf: rf_closest_to_arm said"
! 364: " %lx.\n", req->raidPtr->raidid,
! 365: (long) req);
! 366: }
! 367: if (req == NULL)
! 368: return (NULL);
! 369: rf_do_dequeue(&sstfq->lopri, req);
! 370: } else {
! 371: DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->right);
! 372: }
! 373: } else {
! 374: if (sstfq->right.queue == NULL) {
! 375: RF_ASSERT(sstfq->right.qlen == 0);
! 376: DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->left);
! 377: } else {
! 378: if (SNUM_DIFF(sstfq->last_sector,
! 379: sstfq->right.queue->sectorOffset) <
! 380: SNUM_DIFF(sstfq->last_sector,
! 381: sstfq->left.qtail->sectorOffset)) {
! 382: DO_HEAD_DEQ(req, &sstfq->right);
! 383: } else {
! 384: DO_TAIL_DEQ(req, &sstfq->left);
! 385: }
! 386: }
! 387: }
! 388: RF_ASSERT(req);
! 389: sstfq->last_sector = req->sectorOffset;
! 390: return (req);
! 391: }
! 392:
! 393: RF_DiskQueueData_t *
! 394: rf_ScanDequeue(void *qptr)
! 395: {
! 396: RF_DiskQueueData_t *req = NULL;
! 397: RF_Sstf_t *scanq;
! 398:
! 399: scanq = (RF_Sstf_t *) qptr;
! 400:
! 401: if (rf_scanDebug) {
! 402: RF_DiskQueue_t *dq;
! 403: dq = (RF_DiskQueue_t *) req->queue;
! 404: RF_ASSERT(QSUM(scanq) == dq->queueLength);
! 405: printf("raid%d: scan: Dequeue %d,%d queues are %d,%d,%d.\n",
! 406: req->raidPtr->raidid, dq->row, dq->col,
! 407: scanq->left.qlen, scanq->right.qlen, scanq->lopri.qlen);
! 408: }
! 409: if (scanq->left.queue == NULL) {
! 410: RF_ASSERT(scanq->left.qlen == 0);
! 411: if (scanq->right.queue == NULL) {
! 412: RF_ASSERT(scanq->right.qlen == 0);
! 413: if (scanq->lopri.queue == NULL) {
! 414: RF_ASSERT(scanq->lopri.qlen == 0);
! 415: return (NULL);
! 416: }
! 417: req = rf_closest_to_arm(&scanq->lopri,
! 418: scanq->last_sector, &scanq->dir,
! 419: scanq->allow_reverse);
! 420: if (req == NULL)
! 421: return (NULL);
! 422: rf_do_dequeue(&scanq->lopri, req);
! 423: } else {
! 424: scanq->dir = DIR_RIGHT;
! 425: DO_HEAD_DEQ(req, &scanq->right);
! 426: }
! 427: } else
! 428: if (scanq->right.queue == NULL) {
! 429: RF_ASSERT(scanq->right.qlen == 0);
! 430: RF_ASSERT(scanq->left.queue);
! 431: scanq->dir = DIR_LEFT;
! 432: DO_TAIL_DEQ(req, &scanq->left);
! 433: } else {
! 434: RF_ASSERT(scanq->right.queue);
! 435: RF_ASSERT(scanq->left.queue);
! 436: if (scanq->dir == DIR_RIGHT) {
! 437: DO_HEAD_DEQ(req, &scanq->right);
! 438: } else {
! 439: DO_TAIL_DEQ(req, &scanq->left);
! 440: }
! 441: }
! 442: RF_ASSERT(req);
! 443: scanq->last_sector = req->sectorOffset;
! 444: return (req);
! 445: }
! 446:
! 447: RF_DiskQueueData_t *
! 448: rf_CscanDequeue(void *qptr)
! 449: {
! 450: RF_DiskQueueData_t *req = NULL;
! 451: RF_Sstf_t *cscanq;
! 452:
! 453: cscanq = (RF_Sstf_t *) qptr;
! 454:
! 455: RF_ASSERT(cscanq->dir == DIR_RIGHT);
! 456: if (rf_cscanDebug) {
! 457: RF_DiskQueue_t *dq;
! 458: dq = (RF_DiskQueue_t *) req->queue;
! 459: RF_ASSERT(QSUM(cscanq) == dq->queueLength);
! 460: printf("raid%d: scan: Dequeue %d,%d queues are %d,%d,%d.\n",
! 461: req->raidPtr->raidid, dq->row, dq->col,
! 462: cscanq->left.qlen, cscanq->right.qlen,
! 463: cscanq->lopri.qlen);
! 464: }
! 465: if (cscanq->right.queue) {
! 466: DO_HEAD_DEQ(req, &cscanq->right);
! 467: } else {
! 468: RF_ASSERT(cscanq->right.qlen == 0);
! 469: if (cscanq->left.queue == NULL) {
! 470: RF_ASSERT(cscanq->left.qlen == 0);
! 471: if (cscanq->lopri.queue == NULL) {
! 472: RF_ASSERT(cscanq->lopri.qlen == 0);
! 473: return (NULL);
! 474: }
! 475: req = rf_closest_to_arm(&cscanq->lopri,
! 476: cscanq->last_sector, &cscanq->dir,
! 477: cscanq->allow_reverse);
! 478: if (req == NULL)
! 479: return (NULL);
! 480: rf_do_dequeue(&cscanq->lopri, req);
! 481: } else {
! 482: /*
! 483: * There's I/Os to the left of the arm. Swing
! 484: * on back (swap queues).
! 485: */
! 486: cscanq->right = cscanq->left;
! 487: cscanq->left.qlen = 0;
! 488: cscanq->left.queue = cscanq->left.qtail = NULL;
! 489: DO_HEAD_DEQ(req, &cscanq->right);
! 490: }
! 491: }
! 492: RF_ASSERT(req);
! 493: cscanq->last_sector = req->sectorOffset;
! 494: return (req);
! 495: }
! 496:
! 497: RF_DiskQueueData_t *
! 498: rf_SstfPeek(void *qptr)
! 499: {
! 500: RF_DiskQueueData_t *req;
! 501: RF_Sstf_t *sstfq;
! 502:
! 503: sstfq = (RF_Sstf_t *) qptr;
! 504:
! 505: if ((sstfq->left.queue == NULL) && (sstfq->right.queue == NULL)) {
! 506: req = rf_closest_to_arm(&sstfq->lopri, sstfq->last_sector,
! 507: &sstfq->dir, sstfq->allow_reverse);
! 508: } else {
! 509: if (sstfq->left.queue == NULL)
! 510: req = sstfq->right.queue;
! 511: else {
! 512: if (sstfq->right.queue == NULL)
! 513: req = sstfq->left.queue;
! 514: else {
! 515: if (SNUM_DIFF(sstfq->last_sector,
! 516: sstfq->right.queue->sectorOffset) <
! 517: SNUM_DIFF(sstfq->last_sector,
! 518: sstfq->left.qtail->sectorOffset)) {
! 519: req = sstfq->right.queue;
! 520: } else {
! 521: req = sstfq->left.qtail;
! 522: }
! 523: }
! 524: }
! 525: }
! 526: if (req == NULL) {
! 527: RF_ASSERT(QSUM(sstfq) == 0);
! 528: }
! 529: return (req);
! 530: }
! 531:
! 532: RF_DiskQueueData_t *
! 533: rf_ScanPeek(void *qptr)
! 534: {
! 535: RF_DiskQueueData_t *req;
! 536: RF_Sstf_t *scanq;
! 537: int dir;
! 538:
! 539: scanq = (RF_Sstf_t *) qptr;
! 540: dir = scanq->dir;
! 541:
! 542: if (scanq->left.queue == NULL) {
! 543: RF_ASSERT(scanq->left.qlen == 0);
! 544: if (scanq->right.queue == NULL) {
! 545: RF_ASSERT(scanq->right.qlen == 0);
! 546: if (scanq->lopri.queue == NULL) {
! 547: RF_ASSERT(scanq->lopri.qlen == 0);
! 548: return (NULL);
! 549: }
! 550: req = rf_closest_to_arm(&scanq->lopri,
! 551: scanq->last_sector, &dir, scanq->allow_reverse);
! 552: } else {
! 553: req = scanq->right.queue;
! 554: }
! 555: } else
! 556: if (scanq->right.queue == NULL) {
! 557: RF_ASSERT(scanq->right.qlen == 0);
! 558: RF_ASSERT(scanq->left.queue);
! 559: req = scanq->left.qtail;
! 560: } else {
! 561: RF_ASSERT(scanq->right.queue);
! 562: RF_ASSERT(scanq->left.queue);
! 563: if (scanq->dir == DIR_RIGHT) {
! 564: req = scanq->right.queue;
! 565: } else {
! 566: req = scanq->left.qtail;
! 567: }
! 568: }
! 569: if (req == NULL) {
! 570: RF_ASSERT(QSUM(scanq) == 0);
! 571: }
! 572: return (req);
! 573: }
! 574:
! 575: RF_DiskQueueData_t *
! 576: rf_CscanPeek(void *qptr)
! 577: {
! 578: RF_DiskQueueData_t *req;
! 579: RF_Sstf_t *cscanq;
! 580:
! 581: cscanq = (RF_Sstf_t *) qptr;
! 582:
! 583: RF_ASSERT(cscanq->dir == DIR_RIGHT);
! 584: if (cscanq->right.queue) {
! 585: req = cscanq->right.queue;
! 586: } else {
! 587: RF_ASSERT(cscanq->right.qlen == 0);
! 588: if (cscanq->left.queue == NULL) {
! 589: RF_ASSERT(cscanq->left.qlen == 0);
! 590: if (cscanq->lopri.queue == NULL) {
! 591: RF_ASSERT(cscanq->lopri.qlen == 0);
! 592: return (NULL);
! 593: }
! 594: req = rf_closest_to_arm(&cscanq->lopri,
! 595: cscanq->last_sector, &cscanq->dir,
! 596: cscanq->allow_reverse);
! 597: } else {
! 598: /*
! 599: * There's I/Os to the left of the arm. We'll end
! 600: * up swinging on back.
! 601: */
! 602: req = cscanq->left.queue;
! 603: }
! 604: }
! 605: if (req == NULL) {
! 606: RF_ASSERT(QSUM(cscanq) == 0);
! 607: }
! 608: return (req);
! 609: }
! 610:
! 611: int
! 612: rf_SstfPromote(void *qptr, RF_StripeNum_t parityStripeID,
! 613: RF_ReconUnitNum_t which_ru)
! 614: {
! 615: RF_DiskQueueData_t *r, *next;
! 616: RF_Sstf_t *sstfq;
! 617: int n;
! 618:
! 619: sstfq = (RF_Sstf_t *) qptr;
! 620:
! 621: n = 0;
! 622: if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
! 623: printf("raid%d: promote %ld %d queues are %d,%d,%d.\n",
! 624: r->raidPtr->raidid, (long) parityStripeID,
! 625: (int) which_ru, sstfq->left.qlen, sstfq->right.qlen,
! 626: sstfq->lopri.qlen);
! 627: }
! 628: for (r = sstfq->lopri.queue; r; r = next) {
! 629: next = r->next;
! 630: if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
! 631: printf("raid%d: check promote %lx.\n",
! 632: r->raidPtr->raidid, (long) r);
! 633: }
! 634: if ((r->parityStripeID == parityStripeID)
! 635: && (r->which_ru == which_ru)) {
! 636: rf_do_dequeue(&sstfq->lopri, r);
! 637: rf_SstfEnqueue(qptr, r, RF_IO_NORMAL_PRIORITY);
! 638: n++;
! 639: }
! 640: }
! 641: if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
! 642: printf("raid%d: promoted %d matching I/Os queues are"
! 643: " %d,%d,%d.\n", r->raidPtr->raidid, n, sstfq->left.qlen,
! 644: sstfq->right.qlen, sstfq->lopri.qlen);
! 645: }
! 646: return (n);
! 647: }