![[BACK]](/icons/back.gif){kind=icon}
Return to rf_fifo.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_fifo.c CVS log | Up to [local] / sys / dev / raidframe |
1.1 nbrk 1: /* $OpenBSD: rf_fifo.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $ */
2: /* $NetBSD: rf_fifo.c,v 1.5 2000/03/04 03:27:13 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: *
33: * rf_fifo.c -- prioritized fifo queue code.
34: * There are only two priority levels: hi and lo.
35: *
36: * Aug 4, 1994, adapted from raidSim version (MCH)
37: *
38: ***************************************************/
39:
40: #include "rf_types.h"
41: #include "rf_alloclist.h"
42: #include "rf_stripelocks.h"
43: #include "rf_layout.h"
44: #include "rf_diskqueue.h"
45: #include "rf_fifo.h"
46: #include "rf_debugMem.h"
47: #include "rf_general.h"
48: #include "rf_options.h"
49: #include "rf_raid.h"
50: #include "rf_types.h"
51:
52: /* Just malloc a header, zero it (via calloc), and return it. */
53: /*ARGSUSED*/
54: void *
55: rf_FifoCreate(RF_SectorCount_t sectPerDisk, RF_AllocListElem_t *clList,
56: RF_ShutdownList_t **listp)
57: {
58: RF_FifoHeader_t *q;
59:
60: RF_CallocAndAdd(q, 1, sizeof(RF_FifoHeader_t), (RF_FifoHeader_t *),
61: clList);
62: q->hq_count = q->lq_count = 0;
63: return ((void *) q);
64: }
65:
66: void
67: rf_FifoEnqueue(void *q_in, RF_DiskQueueData_t *elem, int priority)
68: {
69: RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
70:
71: RF_ASSERT(priority == RF_IO_NORMAL_PRIORITY ||
72: priority == RF_IO_LOW_PRIORITY);
73:
74: elem->next = NULL;
75: if (priority == RF_IO_NORMAL_PRIORITY) {
76: if (!q->hq_tail) {
77: RF_ASSERT(q->hq_count == 0 && q->hq_head == NULL);
78: q->hq_head = q->hq_tail = elem;
79: } else {
80: RF_ASSERT(q->hq_count != 0 && q->hq_head != NULL);
81: q->hq_tail->next = elem;
82: q->hq_tail = elem;
83: }
84: q->hq_count++;
85: } else {
86: RF_ASSERT(elem->next == NULL);
87: if (rf_fifoDebug) {
88: printf("raid%d: fifo: ENQ lopri\n",
89: elem->raidPtr->raidid);
90: }
91: if (!q->lq_tail) {
92: RF_ASSERT(q->lq_count == 0 && q->lq_head == NULL);
93: q->lq_head = q->lq_tail = elem;
94: } else {
95: RF_ASSERT(q->lq_count != 0 && q->lq_head != NULL);
96: q->lq_tail->next = elem;
97: q->lq_tail = elem;
98: }
99: q->lq_count++;
100: }
101: if ((q->hq_count + q->lq_count) != elem->queue->queueLength) {
102: printf("Queue lengths differ ! : %d %d %d\n",
103: q->hq_count, q->lq_count, (int) elem->queue->queueLength);
104: printf("%d %d %d %d\n",
105: (int) elem->queue->numOutstanding,
106: (int) elem->queue->maxOutstanding,
107: (int) elem->queue->row,
108: (int) elem->queue->col);
109: }
110: RF_ASSERT((q->hq_count + q->lq_count) == elem->queue->queueLength);
111: }
112:
113: RF_DiskQueueData_t *
114: rf_FifoDequeue(void *q_in)
115: {
116: RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
117: RF_DiskQueueData_t *nd;
118:
119: RF_ASSERT(q);
120: if (q->hq_head) {
121: RF_ASSERT(q->hq_count != 0 && q->hq_tail != NULL);
122: nd = q->hq_head;
123: q->hq_head = q->hq_head->next;
124: if (!q->hq_head)
125: q->hq_tail = NULL;
126: nd->next = NULL;
127: q->hq_count--;
128: } else
129: if (q->lq_head) {
130: RF_ASSERT(q->lq_count != 0 && q->lq_tail != NULL);
131: nd = q->lq_head;
132: q->lq_head = q->lq_head->next;
133: if (!q->lq_head)
134: q->lq_tail = NULL;
135: nd->next = NULL;
136: q->lq_count--;
137: if (rf_fifoDebug) {
138: printf("raid%d: fifo: DEQ lopri %lx\n",
139: nd->raidPtr->raidid, (long) nd);
140: }
141: } else {
142: RF_ASSERT(q->hq_count == 0 && q->lq_count == 0 &&
143: q->hq_tail == NULL && q->lq_tail == NULL);
144: nd = NULL;
145: }
146: return (nd);
147: }
148:
149: /*
150: * Return ptr to item at head of queue. Used to examine request
151: * info without actually dequeueing the request.
152: */
153: RF_DiskQueueData_t *
154: rf_FifoPeek(void *q_in)
155: {
156: RF_DiskQueueData_t *headElement = NULL;
157: RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
158:
159: RF_ASSERT(q);
160: if (q->hq_head)
161: headElement = q->hq_head;
162: else
163: if (q->lq_head)
164: headElement = q->lq_head;
165: return (headElement);
166: }
167:
168: /*
169: * We sometimes need to promote a low priority access to a regular priority
170: * access. Currently, this is only used when the user wants to write a stripe
171: * that is currently under reconstruction.
172: * This routine will promote all accesses tagged with the indicated
173: * parityStripeID from the low priority queue to the end of the normal
174: * priority queue.
175: * We assume the queue is locked upon entry.
176: */
177: int
178: rf_FifoPromote(void *q_in, RF_StripeNum_t parityStripeID,
179: RF_ReconUnitNum_t which_ru)
180: {
181: RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
182: /* lp = lo-pri queue pointer, pt = trailer */
183: RF_DiskQueueData_t *lp = q->lq_head, *pt = NULL;
184: int retval = 0;
185:
186: while (lp) {
187:
188: /*
189: * Search for the indicated parity stripe in the low-pri queue.
190: */
191: if (lp->parityStripeID == parityStripeID &&
192: lp->which_ru == which_ru) {
193: /* printf("FifoPromote: promoting access for psid
194: * %ld\n", parityStripeID); */
195: if (pt)
196: /* Delete an entry other than the first. */
197: pt->next = lp->next;
198: else
199: /* Delete the head entry. */
200: q->lq_head = lp->next;
201:
202: if (!q->lq_head)
203: /* We deleted the only entry. */
204: q->lq_tail = NULL;
205: else
206: if (lp == q->lq_tail)
207: /* We deleted the tail entry. */
208: q->lq_tail = pt;
209:
210: lp->next = NULL;
211: q->lq_count--;
212:
213: if (q->hq_tail) {
214: q->hq_tail->next = lp;
215: q->hq_tail = lp;
216: }
217: /* Append to hi-priority queue. */
218: else {
219: q->hq_head = q->hq_tail = lp;
220: }
221: q->hq_count++;
222:
223: /* Deal with this later, if ever. */
224: /* UpdateShortestSeekFinishTimeForced(lp->requestPtr,
225: * lp->diskState); */
226:
227: /* Reset low-pri pointer and continue. */
228: lp = (pt) ? pt->next : q->lq_head;
229: retval++;
230:
231: } else {
232: pt = lp;
233: lp = lp->next;
234: }
235: }
236:
237: /*
238: * Sanity check. Delete this if you ever put more than one entry in
239: * the low-pri queue.
240: */
241: RF_ASSERT(retval == 0 || retval == 1);
242: return (retval);
243: }