1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
/*
* Mach Operating System
* Copyright (c) 1991,1990,1989 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie Mellon
* the rights to redistribute these changes.
*/
/*
* Author: David B. Golub, Carnegie Mellon University
* Date: 7/89
*
* Block IO driven from generic kernel IO interface.
*/
#include <mach/kern_return.h>
#include <device/param.h>
#include <device/device_types.h>
#include <device/io_req.h>
#include <device/ds_routines.h>
io_return_t block_io(strat, max_count, ior)
void (*strat)();
void (*max_count)();
register io_req_t ior;
{
register kern_return_t rc;
boolean_t wait = FALSE;
/*
* Make sure the size is not too large by letting max_count
* change io_count. If we are doing a write, then io_alloc_size
* preserves the original io_count.
*/
(*max_count)(ior);
/*
* If reading, allocate memory. If writing, wire
* down the incoming memory.
*/
if (ior->io_op & IO_READ)
rc = device_read_alloc(ior, (vm_size_t)ior->io_count);
else
rc = device_write_get(ior, &wait);
if (rc != KERN_SUCCESS)
return (rc);
/*
* Queue the operation for the device.
*/
(*strat)(ior);
/*
* The io is now queued. Wait for it if needed.
*/
if (wait) {
iowait(ior);
return(D_SUCCESS);
}
return (D_IO_QUEUED);
}
/*
* 'standard' max_count routine. VM continuations mean that this
* code can cope with arbitrarily-sized write operations (they won't be
* atomic, but any caller that cares will do the op synchronously).
*/
#define MAX_PHYS (256 * 1024)
void minphys(ior)
register io_req_t ior;
{
if ((ior->io_op & (IO_WRITE | IO_READ | IO_OPEN)) == IO_WRITE)
return;
if (ior->io_count > MAX_PHYS)
ior->io_count = MAX_PHYS;
}
/*
* Dummy routine placed in device switch entries to indicate that
* block device may be mapped.
*/
vm_offset_t block_io_mmap()
{
return (0);
}
/*
* Disk sort routine.
*
* We order the disk request chain so that the disk head will sweep
* back and forth across the disk. The chain is divided into two
* pieces, with requests ordered in opposite directions. Assume that
* the first part of the chain holds increasing cylinder numbers.
* If a new request has a higher cylinder number than the head of
* the chain, the disk head has not yet reached it; the new request
* can go in the first part of the chain. If the new request has
* a lower cylinder number, the disk head has already passed it and
* must catch it on the way back; so the new request goes in the
* second (descending) part of the chain.
* When all of the requests in the ascending portion are filled,
* the descending chain becomes the first chain, and requests above
* the first now go in the second part of the chain (ascending).
*/
#define io_cylinder io_residual
/* Disk drivers put cylinder here */
#define h_head io_next
#define h_tail io_prev
/* IORs are chained here */
void disksort(head, ior)
io_req_t head; /* (sort of) */
io_req_t ior;
{
register int cylinder = ior->io_cylinder;
register io_req_t next, prev;
next = head->h_head;
if (next == 0) {
head->h_head = ior;
head->h_tail = ior;
ior->io_next = 0;
return;
}
do {
prev = next;
next = prev->io_next;
} while (next != 0 && prev->io_cylinder == next->io_cylinder);
if (next == 0) {
prev->io_next = ior;
head->h_tail = ior;
ior->io_next = 0;
return;
}
if (prev->io_cylinder < next->io_cylinder) {
/*
* Ascending list first.
*/
if (prev->io_cylinder <= cylinder) {
/*
* Insert in ascending list.
*/
while (next != 0 &&
next->io_cylinder <= cylinder &&
prev->io_cylinder <= next->io_cylinder)
{
prev = next;
next = prev->io_next;
}
}
else {
/*
* Insert in descending list
*/
do {
prev = next;
next = prev->io_next;
} while (next != 0 &&
prev->io_cylinder <= next->io_cylinder);
while (next != 0 &&
next->io_cylinder >= cylinder)
{
prev = next;
next = prev->io_next;
}
}
}
else {
/*
* Descending first.
*/
if (prev->io_cylinder >= cylinder) {
/*
* Insert in descending list.
*/
while (next != 0 &&
next->io_cylinder >= cylinder &&
prev->io_cylinder >= next->io_cylinder)
{
prev = next;
next = prev->io_next;
}
}
else {
/*
* Insert in ascending list
*/
do {
prev = next;
next = prev->io_next;
} while (next != 0 &&
prev->io_cylinder >= next->io_cylinder);
while (next != 0 &&
next->io_cylinder <= cylinder)
{
prev = next;
next = prev->io_next;
}
}
}
/*
* Insert between prev and next.
*/
prev->io_next = ior;
ior->io_next = next;
if (next == 0) {
/* At tail of list. */
head->h_tail = ior;
}
}
|
