![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOStub.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / Examples / IOStub|
Return to IOStub.m CVS log | Up to [Apple Darwin 0.x] / driverkit / Examples / IOStub |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /* IOStub.m 1.0 01/29/91 (c) 1991 NeXT
25: *
26: * IOStub.m - Implementation for trivial I/O device subclass.
27: *
28: * HISTORY
29: * 29-Jan-91 Doug Mitchell at NeXT
30: * Created.
31: */
32:
33: #import <bsd/sys/types.h>
34: #import <mach/mach.h>
35: #import <mach/vm_param.h>
36: #import <mach/mach_error.h>
37: #import <bsd/libc.h>
38: #import <driverkit/return.h>
39: #import <driverkit/IODevice.h>
40: #import "IOStub.h"
41: #import "IOStubThread.h"
42: #import "IOStubDevice.h"
43: #import "IOStubUxpr.h"
44: #import <machkit/NXLock.h>
45:
46: @implementation IOStub
47:
48: /*
49: * Initialize current instance. Returns non-zero on error.
50: */
51: - initStub : (int)unitNum
52: {
53: int data_size;
54: int i;
55: char *cp;
56: kern_return_t krtn;
57: u_int block_size, dev_size;
58:
59: xpr_stub("IOStub : init: unitNum %d\n", unitNum, 2,3,4,5);
60:
61:
62: [self setUnit:unitNum];
63: if(unitNum == 0) {
64: /*
65: * read/write.
66: */
67: block_size = 0x20;
68: dev_size = 0x1000;
69: [self setName : "IOStub0"];
70: [self setWriteProtected:NO];
71: }
72: else {
73: /*
74: * Make this one read-only, non-queuing.
75: */
76: block_size = 0x40;
77: dev_size = 0x800;
78: [self setName : "IOStub1"];
79: [self setWriteProtected:YES];
80: }
81: [self setDeviceKind:"Stub Device"];
82: [self setLocation:NULL];
83: [self setDiskSize:dev_size];
84: [self setBlockSize:block_size];
85: [self setFormattedInternal:1];
86:
87: /*
88: * allocate and initialize data for writing and reading.
89: */
90: data_size = block_size * dev_size;
91: krtn = vm_allocate(task_self(),
92: (vm_address_t *)&stub_data,
93: (vm_size_t)round_page(data_size),
94: YES);
95: if(krtn != KERN_SUCCESS) {
96: mach_error("***IOStub init: vm_allocate", krtn);
97: return(self);
98: }
99:
100: /*
101: * initial data: incrementing bytes for unit 0, decrementing
102: * bytes for others.
103: */
104: cp = (char *)stub_data;
105: for(i=0; i<data_size; i++) {
106: if(unitNum)
107: *cp++ = 0 - (char)i;
108: else
109: *cp++ = i;
110: }
111:
112: /*
113: * Set up our instance's IOQueue.
114: */
115: ioQLock = [NXConditionLock alloc];
116: [ioQLock initWith:NO_WORK_AVAILABLE];
117: queue_init(&ioQueue);
118:
119: /*
120: * Start up an I/O thread to perform the actual work of this device.
121: */
122: IOForkThread((IOThreadFunc)IOStub_thread, self);
123:
124: [self registerDevice];
125:
126: /*
127: * Let superclass take care of initializing inherited instance
128: * variables.
129: */
130: [super init];
131: return self;
132: }
133:
134: /*
135: * Free resources consumed by this instance.
136: */
137: - free
138: {
139: int data_size;
140: kern_return_t krtn;
141: u_int block_size, dev_size;
142: IOBuf_t *IOBuf;
143:
144: /*
145: * Kill the I/O thread.
146: */
147: IOBuf = IOMalloc(sizeof(*IOBuf));
148: IOBuf->cmd = STUB_ABORT;
149: IOBuf->pending = 0;
150: IOBuf->waitLock = [NXConditionLock alloc];
151: [IOBuf->waitLock initWith:NO];
152: [self enqueueIoBuf:IOBuf];
153:
154: /*
155: * Wait for I/O complete.
156: */
157: [IOBuf->waitLock lockWhen:YES];
158: [IOBuf->waitLock unlock];
159: [IOBuf->waitLock free];
160: IOFree(IOBuf, sizeof(IOBuf_t));
161:
162: /*
163: * Free up our VM.
164: */
165: block_size = [self blockSize];
166: dev_size = [self diskSize];
167: data_size = block_size * dev_size;
168: krtn = vm_deallocate(task_self(),
169: (vm_address_t)stub_data,
170: (vm_size_t)round_page(data_size));
171: if(krtn != KERN_SUCCESS) {
172: mach_error("***IOStub free: vm_deallocate", krtn);
173: }
174: return([super free]);
175: }
176:
177: /*
178: * These override the superclass's methods which are no-op stubs.
179: */
180:
181: - (int)deviceOpen:(u_int)intentions
182: {
183: xpr_stub("IOStub deviceOpen: unit %d\n", [self unit], 2,3,4,5);
184: return(IO_R_SUCCESS);
185: }
186:
187: - (void)deviceClose
188: {
189: xpr_stub("IOStub deviceClose: unit %d\n", [self unit], 2,3,4,5);
190: }
191:
192: /*
193: * These are the exported I/O methods, from the
194: * IODiskDeviceReadingAndWriting category. Their main task is:
195: *
196: * -- verify valid input parameters.
197: * -- set up and enqueue an IOBuf for servicing by the I/O thread.
198: * -- Wait for I/O complete if synchronous request.
199: */
200:
201: - (IOReturn) readAt : (unsigned)offset
202: length : (unsigned)length
203: buffer : (unsigned char *)buffer
204: actualLength : (unsigned *)actualLength
205: {
206: IOReturn mrtn;
207: char *source;
208: IOBuf_t *IOBuf;
209: u_int block_size;
210: u_int dev_size;
211:
212: xpr_stub("IOStub read: unit %d offset 0x%x length 0x%x\n",
213: [self unit], offset, length, 4,5);
214:
215: block_size = [self blockSize];
216: dev_size = [self diskSize];
217:
218: /*
219: * Verify legal parameters.
220: */
221: source = stub_data + offset * block_size;
222: if((source + length) > (stub_data + (block_size * dev_size))) {
223:
224: xpr_stub("IOStub read: invalid offset/byte count\n",
225: 1,2,3,4,5);
226: return(IO_R_INVALID_ARG);
227: }
228:
229: /*
230: * OK, queue up an IOBuf.
231: */
232: IOBuf = IOMalloc(sizeof(*IOBuf));
233: IOBuf->cmd = STUB_READ;
234: IOBuf->offset = offset;
235: IOBuf->bytesReq = length;
236: IOBuf->buf = buffer;
237: IOBuf->bytesXfr = actualLength;
238: IOBuf->status = IO_R_INVALID;
239: IOBuf->pending = 0;
240: IOBuf->waitLock = [NXConditionLock alloc];
241: [IOBuf->waitLock initWith:NO];
242: IOBuf->dirRead = 1;
243: [self enqueueIoBuf:IOBuf];
244:
245: /*
246: * Wait for I/O complete.
247: */
248: [IOBuf->waitLock lockWhen:YES];
249: [IOBuf->waitLock unlock];
250: xpr_stub("stub read: DONE\n", 1,2,3,4,5);
251: mrtn = IOBuf->status;
252: [IOBuf->waitLock free];
253: IOFree(IOBuf, sizeof(*IOBuf));
254: return(mrtn);
255: }
256:
257: - (IOReturn) readAsyncAt : (unsigned)offset
258: length : (unsigned)length
259: buffer : (unsigned char *)buffer
260: pending : (void *)pending
261: {
262: char *source;
263: IOBuf_t *IOBuf;
264: unsigned block_size;
265: unsigned dev_size;
266:
267: xpr_stub("IOStub readAsync: unit %d offset 0x%x length 0x%x\n",
268: [self unit], offset, length, 4,5);
269:
270: block_size = [self blockSize];
271: dev_size = [self diskSize];
272:
273: /*
274: * Verify legal parameters.
275: */
276: source = stub_data + offset * block_size;
277: if((source + length) > (stub_data + (block_size * dev_size))) {
278:
279: xpr_stub("IOStub read: invalid offset/byte count\n",
280: 1,2,3,4,5);
281: return(IO_R_INVALID_ARG);
282: }
283:
284: /*
285: * Just queue up an IOBuf.
286: */
287: IOBuf = IOMalloc(sizeof(*IOBuf));
288: IOBuf->cmd = STUB_READ;
289: IOBuf->offset = offset;
290: IOBuf->bytesReq = length;
291: IOBuf->buf = buffer;
292: IOBuf->status = IO_R_INVALID; /* must be filled in by
293: * I/O thread */
294: IOBuf->pending = pending;
295: IOBuf->dirRead = 1;
296: [self enqueueIoBuf:IOBuf];
297:
298: xpr_stub("stub readAsync: DONE\n", 1,2,3,4,5);
299: return(IO_R_SUCCESS);
300: }
301:
302: - (IOReturn) writeAt : (unsigned)offset
303: length : (unsigned)length
304: buffer : (unsigned char *)buffer
305: actualLength : (unsigned *)actualLength
306: {
307: IOReturn mrtn;
308: char *dest;
309: IOBuf_t *IOBuf;
310: unsigned block_size;
311: unsigned dev_size;
312:
313: xpr_stub("IOStub write: unit %d offset 0x%x length 0x%x\n",
314: [self unit], offset, length, 4,5);
315:
316: block_size = [self blockSize];
317: dev_size = [self diskSize];
318:
319: /*
320: * Verify legal parameters.
321: */
322: if([self isWriteProtected]) {
323: return IO_R_NOT_WRITABLE;
324: }
325: dest = stub_data + offset * block_size;
326: if((dest + length) > (stub_data + (block_size * dev_size))) {
327:
328: xpr_stub("IOStub dest: invalid offset/byte count\n",
329: 1,2,3,4,5);
330: return(IO_R_INVALID_ARG);
331: }
332:
333: /*
334: * OK, queue up an IOBuf.
335: */
336: IOBuf = IOMalloc(sizeof(*IOBuf));
337: IOBuf->cmd = STUB_WRITE;
338: IOBuf->offset = offset;
339: IOBuf->bytesReq = length;
340: IOBuf->buf = buffer;
341: IOBuf->bytesXfr = actualLength;
342: IOBuf->status = IO_R_INVALID;
343: IOBuf->pending = 0;
344: IOBuf->waitLock = [NXConditionLock alloc];
345: [IOBuf->waitLock initWith:NO];
346: IOBuf->dirRead = 0;
347: [self enqueueIoBuf:IOBuf];
348:
349: /*
350: * Wait for I/O complete.
351: */
352: [IOBuf->waitLock lockWhen:YES];
353: [IOBuf->waitLock unlock];
354: xpr_stub("stub write: DONE\n", 1,2,3,4,5);
355: mrtn = IOBuf->status;
356: [IOBuf->waitLock free];
357: IOFree(IOBuf, sizeof(*IOBuf));
358: return(mrtn);
359: }
360:
361: - (IOReturn) writeAsyncAt : (unsigned)offset
362: length : (unsigned)length
363: buffer : (unsigned char *)buffer
364: pending : (void *)pending;
365: {
366: char *source;
367: IOBuf_t *IOBuf;
368: unsigned block_size;
369: unsigned dev_size;
370:
371: xpr_stub("IOStub writeAsync: unit %d offset 0x%x length 0x%x\n",
372: [self unit], offset, length, 4,5);
373:
374: block_size = [self blockSize];
375: dev_size = [self diskSize];
376:
377: /*
378: * Verify legal parameters.
379: */
380: if([self isWriteProtected]) {
381: return IO_R_NOT_WRITABLE;
382: }
383: source = stub_data + offset * block_size;
384: if((source + length) > (stub_data + (block_size * dev_size))) {
385:
386: xpr_stub("IOStub write: invalid offset/byte count\n",
387: 1,2,3,4,5);
388: return(IO_R_INVALID_ARG);
389: }
390:
391: /*
392: * Just queue up an IOBuf.
393: */
394: IOBuf = IOMalloc(sizeof(*IOBuf));
395: IOBuf->cmd = STUB_WRITE;
396: IOBuf->offset = offset;
397: IOBuf->bytesReq = length;
398: IOBuf->buf = buffer;
399: IOBuf->status = IO_R_INVALID; /* must be filled in by
400: * I/O thread */
401: IOBuf->pending = pending;
402: IOBuf->dirRead = 0;
403: [self enqueueIoBuf:IOBuf];
404:
405: xpr_stub("stub writeAsync: DONE\n", 1,2,3,4,5);
406: return(IO_R_SUCCESS);
407: }
408:
409: /*
410: * Distributed Objects R/W protocol.
411: */
412: - (IOReturn) readAt : (unsigned)offset // in blocks
413: length : (unsigned)length // in bytes
414: data : (out IOData **)data
415: actualLength : (out unsigned *)actualLength
416: {
417: IOReturn rtn;
418: IOData *ldata = [[IOData alloc] initWithSize:length];
419:
420: /*
421: * FIXME - when freeFlag is set to YES (which is what we really
422: * want), this method crashes with the following error messages
423: * when run with the DiskTest app:
424: *
425: * finishEncoding: send error -101:invalid memory
426: * uncaught exception : 11001
427: * objc: FREED(id): message free sent to freed object=0x9c01c
428: *
429: * When run with the test programs in ../tests, everything works
430: * OK...
431: *
432: * When we set freeFlag to NO, everything works, but the IOStub
433: * server leaks memory.
434: *
435: * Update 15-Oct-92 - this error only happens when moving at least
436: * one entire page of data. Moving less than a page is OK.
437: */
438: [ldata setFreeFlag:YES];
439: rtn = [self readAt:offset
440: length:length
441: buffer:[ldata data]
442: actualLength:actualLength];
443: if(*actualLength) {
444: *data = ldata;
445: }
446:
447: /*
448: * FIXME - when does the IOData get deallocated??
449: */
450: return rtn;
451: }
452:
453: /*
454: * DiskRwDistributed protocol.
455: */
456: - (IOData *)rreadAt : (unsigned)offset
457: length : (unsigned)length
458: rtn : (out IOReturn *)rtn
459: actualLength : (out unsigned *)actualLength
460: {
461: IOReturn lrtn;
462: IOData *ldata = [[IOData alloc] initWithSize:length];
463:
464: [ldata setFreeFlag:YES];
465: lrtn = [self readAt:offset
466: length:length
467: buffer:[ldata data]
468: actualLength:actualLength];
469: *rtn = lrtn;
470: return ldata;
471: }
472:
473: - (IOReturn) readAsyncAt : (unsigned)offset
474: length : (unsigned)length
475: ioKey : (unsigned)ioKey
476: caller : (id)caller
477: {
478: /* TBD */
479: return IO_R_UNSUPPORTED;
480: }
481:
482:
483: - (IOReturn) writeAt : (unsigned)offset // in blocks
484: length : (unsigned)length // in bytes
485: data : (in IOData *)data
486: actualLength : (out unsigned *)actualLength
487: {
488: IOReturn rtn;
489:
490: if([data size] < length) {
491: IOLog("%s writeAt: insufficient memory in IOData\n",
492: [self name]);
493: }
494: rtn = [self writeAt:offset
495: length:length
496: buffer:[data data]
497: actualLength:actualLength];
498: [data free];
499: return rtn;
500: }
501:
502: - (IOReturn)writeAsyncAt : (unsigned)offset // in blocks
503: length : (unsigned)length // in bytes
504: data : (in IOData *)data
505: ioKey : (unsigned)ioKey
506: caller : (id)caller
507: {
508: return IO_R_UNSUPPORTED;
509: }
510: @end
511:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.