1 /* $OpenBSD: rf_diskqueue.h,v 1.5 2002/12/16 07:01:03 tdeval Exp $ */
2 /* $NetBSD: rf_diskqueue.h,v 1.5 2000/02/13 04:53:57 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_diskqueue.h -- Header file for disk queues.
34 *
35 * See comments in rf_diskqueue.c
36 *
37 *****************************************************************************/
38
39
40 #ifndef _RF__RF_DISKQUEUE_H_
41 #define _RF__RF_DISKQUEUE_H_
42
43 #include "rf_threadstuff.h"
44 #include "rf_acctrace.h"
45 #include "rf_alloclist.h"
46 #include "rf_types.h"
47 #include "rf_etimer.h"
48
49
50 #if defined(__NetBSD__)
51 #include "rf_netbsd.h"
52 #elif defined(__OpenBSD__)
53 #include "rf_openbsd.h"
54 #endif
55
56
57 #define RF_IO_NORMAL_PRIORITY 1
58 #define RF_IO_LOW_PRIORITY 0
59
60 /* The data held by a disk queue entry. */
61 struct RF_DiskQueueData_s {
62 RF_SectorNum_t sectorOffset; /* Sector offset into the disk. */
63 RF_SectorCount_t numSector; /* Number of sectors to read/write. */
64 RF_IoType_t type; /* Read/write/nop. */
65 caddr_t buf; /* Buffer pointer. */
66 RF_StripeNum_t parityStripeID;
67 /*
68 * The RAID parity stripe ID this
69 * access is for.
70 */
71 RF_ReconUnitNum_t which_ru; /* Which RU within this parity stripe */
72 int priority; /* The priority of this request. */
73 int (*CompleteFunc) (void *, int);
74 /*
75 * Function to be called upon
76 * completion.
77 */
78 int (*AuxFunc) (void *,...);
79 /*
80 * Function called upon completion
81 * of the first I/O of a Read_Op_Write
82 * pair.
83 */
84 void *argument; /*
85 * Argument to be passed to
86 * CompleteFunc.
87 */
88 RF_Raid_t *raidPtr; /* Needed for simulation. */
89 RF_AccTraceEntry_t *tracerec; /* Perf mon only. */
90 RF_Etimer_t qtime; /*
91 * Perf mon only - time request is
92 * in queue.
93 */
94 long entryTime;
95 RF_DiskQueueData_t *next;
96 RF_DiskQueueData_t *prev;
97 caddr_t buf2; /* For read-op-write. */
98 dev_t dev; /*
99 * The device number for in-kernel
100 * version.
101 */
102 RF_DiskQueue_t *queue; /*
103 * The disk queue to which this req
104 * is targeted.
105 */
106 RF_DiskQueueDataFlags_t flags; /* Flags controlling operation. */
107
108 struct proc *b_proc; /*
109 * The b_proc from the original bp
110 * passed into the driver for this I/O.
111 */
112 struct buf *bp; /* A bp to use to get this I/O done. */
113 };
114 #define RF_LOCK_DISK_QUEUE 0x01
115 #define RF_UNLOCK_DISK_QUEUE 0x02
116
117 /*
118 * Note: "Create" returns type-specific queue header pointer cast to (void *).
119 */
120 struct RF_DiskQueueSW_s {
121 RF_DiskQueueType_t queueType;
122 void *(*Create) (RF_SectorCount_t, RF_AllocListElem_t *,
123 RF_ShutdownList_t **);
124 /*
125 * Creation routine -- one call per
126 * queue in system.
127 */
128 void (*Enqueue) (void *, RF_DiskQueueData_t *, int);
129 /* Enqueue routine. */
130 RF_DiskQueueData_t *(*Dequeue) (void *);
131 /* Dequeue routine. */
132 RF_DiskQueueData_t *(*Peek) (void *);
133 /* Peek at head of queue. */
134
135 /*
136 * The rest are optional: they improve performance, but the driver
137 * will deal with it if they don't exist.
138 */
139 int (*Promote) (void *, RF_StripeNum_t, RF_ReconUnitNum_t);
140 /*
141 * Promotes priority of tagged
142 * accesses.
143 */
144 };
145
146 struct RF_DiskQueue_s {
147 RF_DiskQueueSW_t *qPtr; /* Access point to queue functions. */
148 void *qHdr; /* Queue header, of whatever type. */
149 RF_DECLARE_MUTEX(mutex); /* Mutex locking data structures. */
150 RF_DECLARE_COND(cond); /*
151 * Condition variable for
152 * synchronization.
153 */
154 long numOutstanding;
155 /*
156 * Number of I/Os currently
157 * outstanding on disk.
158 */
159 long maxOutstanding;
160 /*
161 * Max number of I/Os that can be
162 * outstanding on a disk.
163 * (in-kernel only)
164 */
165 int curPriority; /*
166 * The priority of accs all that are
167 * currently outstanding.
168 */
169 long queueLength; /* Number of requests in queue. */
170 RF_DiskQueueData_t *nextLockingOp;
171 /*
172 * A locking op that has arrived at
173 * the head of the queue & is waiting
174 * for drainage.
175 */
176 RF_DiskQueueData_t *unlockingOp;/*
177 * Used at user level to communicate
178 * unlocking op b/w user (or dag exec)
179 * & disk threads.
180 */
181 int numWaiting; /*
182 * Number of threads waiting on
183 * this variable.
184 * (user-level only)
185 */
186 RF_DiskQueueFlags_t flags; /* Terminate, locked. */
187 RF_Raid_t *raidPtr; /* Associated array. */
188 dev_t dev; /* Device number for kernel version. */
189 RF_SectorNum_t last_deq_sector;
190 /*
191 * Last sector number dequeued or
192 * dispatched.
193 */
194 int row, col; /* Debug only. */
195 struct raidcinfo *rf_cinfo; /* Disks component info... */
196 };
197
198 /* No new accs allowed until queue is explicitly unlocked. */
199 #define RF_DQ_LOCKED 0x02
200
201 /* Macros setting & returning information about queues and requests. */
202 #define RF_QUEUE_LOCKED(_q) ((_q)->flags & RF_DQ_LOCKED)
203 #define RF_QUEUE_EMPTY(_q) (((_q)->numOutstanding == 0) && \
204 ((_q)->nextLockingOp == NULL) && \
205 !RF_QUEUE_LOCKED(_q))
206 #define RF_QUEUE_FULL(_q) ((_q)->numOutstanding == \
207 (_q)->maxOutstanding)
208
209 #define RF_LOCK_QUEUE(_q) (_q)->flags |= RF_DQ_LOCKED
210 #define RF_UNLOCK_QUEUE(_q) (_q)->flags &= ~RF_DQ_LOCKED
211
212 #define RF_LOCK_QUEUE_MUTEX(_q_,_wh_) RF_LOCK_MUTEX((_q_)->mutex)
213 #define RF_UNLOCK_QUEUE_MUTEX(_q_,_wh_) RF_UNLOCK_MUTEX((_q_)->mutex)
214
215 #define RF_LOCKING_REQ(_r) ((_r)->flags & RF_LOCK_DISK_QUEUE)
216 #define RF_UNLOCKING_REQ(_r) ((_r)->flags & RF_UNLOCK_DISK_QUEUE)
217
218 /* Whether it is ok to dispatch a regular request. */
219 #define RF_OK_TO_DISPATCH(_q_,_r_) \
220 (RF_QUEUE_EMPTY(_q_) || \
221 ( !RF_QUEUE_FULL(_q_) && ((_r_)->priority >= (_q_)->curPriority)))
222
223 int rf_ConfigureDiskQueueSystem(RF_ShutdownList_t **);
224
225 void rf_TerminateDiskQueues(RF_Raid_t *);
226
227 int rf_ConfigureDiskQueues(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
228
229 void rf_DiskIOEnqueue(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
230
231 void rf_DiskIOComplete(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
232
233 int rf_DiskIOPromote(RF_DiskQueue_t *, RF_StripeNum_t, RF_ReconUnitNum_t);
234
235 RF_DiskQueueData_t *rf_CreateDiskQueueData(RF_IoType_t, RF_SectorNum_t,
236 RF_SectorCount_t, caddr_t, RF_StripeNum_t, RF_ReconUnitNum_t,
237 int (*) (void *, int), void *, RF_DiskQueueData_t *,
238 RF_AccTraceEntry_t *, void *, RF_DiskQueueDataFlags_t, void *);
239
240 RF_DiskQueueData_t *rf_CreateDiskQueueDataFull(RF_IoType_t, RF_SectorNum_t,
241 RF_SectorCount_t, caddr_t, RF_StripeNum_t, RF_ReconUnitNum_t,
242 int (*) (void *, int), void *, RF_DiskQueueData_t *,
243 RF_AccTraceEntry_t *, int, int (*) (void *,...), caddr_t, void *,
244 RF_DiskQueueDataFlags_t, void *);
245
246 void rf_FreeDiskQueueData(RF_DiskQueueData_t *);
247
248 int rf_ConfigureDiskQueue(RF_Raid_t *, RF_DiskQueue_t *, RF_RowCol_t,
249 RF_RowCol_t, RF_DiskQueueSW_t *, RF_SectorCount_t, dev_t, int,
250 RF_ShutdownList_t **, RF_AllocListElem_t *);
251
252 #endif /* ! _RF__RF_DISKQUEUE_H_ */