![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOLogicalDisk.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver|
Return to IOLogicalDisk.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver |
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: /* Copyright (c) 1991 NeXT Computer, Inc. All rights reserved.
25: *
26: * IOLogicalDisk.m
27: *
28: * HISTORY
29: * 05-Mar-91 Doug Mitchell at NeXT
30: * Created.
31: */
32:
33: #import <driverkit/return.h>
34: #import <driverkit/IODisk.h>
35: #ifdef KERNEL
36: #import <kernserv/prototypes.h>
37: #import <mach/mach_interface.h>
38: #import <driverkit/kernelDiskMethods.h>
39: #else KERNEL
40: #import <mach/mach.h>
41: #import <bsd/libc.h>
42: #endif KERNEL
43: #import <driverkit/IOLogicalDisk.h>
44: #import <driverkit/Device_ddm.h>
45: #import <driverkit/generalFuncs.h>
46: #import <driverkit/SCSIDisk.h>
47:
48: @interface IOLogicalDisk(private)
49: - (IOReturn)_diskParamCommon :(u_int)logicalOffset
50: length : (u_int)bytesReq
51: deviceOffset : (unsigned *)deviceOffset
52: bytesToMove : (u_int *)bytesToMove;
53:
54: - (IOReturn)computePartition :(u_int)logicalOffset
55: length : (u_int)bytesReq
56: byteOffset : (unsigned long long *)byteOffset
57: bytesToMove : (u_int *)bytesToMove;
58:
59: /* This must be a class method since it's called by
60: * a class method in DiskPartition.
61: */
62:
63: + (IOReturn) reblock : (id)physicalDisk
64: : (BOOL)read
65: : (unsigned long long)offset /* bytes */
66: : (unsigned)length /* bytes */
67: : (unsigned char *)buffer
68: : (vm_task_t)client
69: : (void *)pending
70: : (unsigned)physsize; /* phys blocksize */
71: @end
72:
73: @implementation IOLogicalDisk
74:
75: /*
76: * Standard IODiskDeviceReadingAndWriting methods. We translate into raw device
77: * parameters and pass along to _physicalDisk.
78: */
79: #ifdef KERNEL
80:
81: - (IOReturn) readAt : (unsigned)offset
82: length : (unsigned)length
83: buffer : (unsigned char *)buffer
84: actualLength : (unsigned *)actualLength
85: client : (vm_task_t)client
86: {
87: IOReturn rtn;
88: unsigned bytesToMove;
89: unsigned long long byteposition;
90:
91: rtn = [self computePartition:offset
92: length : length
93: byteOffset : &byteposition
94: bytesToMove:&bytesToMove];
95:
96: if (rtn) {
97: return(rtn);
98: }
99:
100: /* If the request is aligned with the physical block size, we
101: * send it directly to the driver. If not, we have to use the
102: * (synchronous) reblocking IO function to handle size and/or
103: * alignment mismatches.
104: */
105:
106: if (byteposition % _physicalBlockSize || length % _physicalBlockSize) {
107:
108: return([[self class] commonReadWrite
109: : _physicalDisk
110: : YES /* it's a read */
111: : byteposition /* byte offset */
112: : (unsigned)bytesToMove /* bytes */
113: : (unsigned char *)buffer
114: : (vm_task_t)client
115: : (void *)NULL
116: : (u_int *)actualLength]);
117:
118: } else { /* neatly aligned */
119:
120: return([_physicalDisk readAt:(byteposition / _physicalBlockSize)
121: length:bytesToMove
122: buffer:buffer
123: actualLength:actualLength
124: client:client]);
125: }
126: }
127:
128: - (IOReturn) readAsyncAt : (unsigned)offset
129: length : (unsigned)length
130: buffer : (unsigned char *)buffer
131: pending : (void *)pending
132: client : (vm_task_t)client
133: {
134: IOReturn rtn;
135: unsigned bytesToMove;
136: unsigned long long byteposition;
137:
138: rtn = [self computePartition:offset
139: length : length
140: byteOffset : &byteposition
141: bytesToMove:&bytesToMove];
142:
143: if (rtn) {
144: return(rtn);
145: }
146:
147: /* If the request is aligned with the physical block size, we
148: * send it directly to the driver. If not, we have to use the
149: * (synchronous) reblocking IO function to handle size and/or
150: * alignment mismatches.
151: */
152:
153: if (byteposition % _physicalBlockSize || length % _physicalBlockSize) {
154:
155: return([[self class] commonReadWrite
156: : _physicalDisk
157: : YES
158: : byteposition /* byte offset */
159: : (unsigned)bytesToMove /* bytes */
160: : (unsigned char *)buffer
161: : (vm_task_t)client
162: : (void *)pending
163: : (u_int *)NULL]);
164:
165: } else { /* neatly aligned */
166: return([_physicalDisk readAsyncAt:(byteposition / _physicalBlockSize)
167: length:bytesToMove
168: buffer:buffer
169: pending:pending
170: client:client]);
171: }
172: }
173:
174: - (IOReturn) writeAt : (unsigned)offset
175: length : (unsigned)length
176: buffer : (unsigned char *)buffer
177: actualLength : (unsigned *)actualLength
178: client : (vm_task_t)client
179: {
180: unsigned deviceBlock;
181: IOReturn rtn;
182: unsigned bytesToMove;
183: unsigned long long byteposition;
184:
185: if ([self isWriteProtected]) {
186: return IO_R_NOT_WRITABLE;
187: }
188:
189: rtn = [self computePartition:offset
190: length : length
191: byteOffset : &byteposition
192: bytesToMove:&bytesToMove];
193:
194: if (rtn) {
195: return(rtn);
196: }
197:
198: /* If the request is aligned with the physical block size, we
199: * send it directly to the driver. If not, we have to use the
200: * (synchronous) reblocking IO function to handle size and/or
201: * alignment mismatches.
202: */
203:
204: if (byteposition % _physicalBlockSize || length % _physicalBlockSize) {
205:
206: return([[self class] commonReadWrite
207: : _physicalDisk
208: : NO /* it's a write */
209: : byteposition /* byte offset */
210: : (unsigned)bytesToMove /* bytes */
211: : (unsigned char *)buffer
212: : (vm_task_t)client
213: : (void *)NULL
214: : (u_int *)actualLength]);
215:
216: } else { /* neatly aligned */
217:
218: return([_physicalDisk writeAt:(byteposition / _physicalBlockSize)
219: length:bytesToMove
220: buffer:buffer
221: actualLength:actualLength
222: client:client]);
223: }
224: }
225:
226: - (IOReturn) writeAsyncAt : (unsigned)offset
227: length : (unsigned)length
228: buffer : (unsigned char *)buffer
229: pending : (void *)pending
230: client : (vm_task_t)client
231: {
232: unsigned deviceBlock;
233: IOReturn rtn;
234: unsigned bytesToMove;
235: unsigned long long byteposition;
236:
237: if ([self isWriteProtected]) {
238: return IO_R_NOT_WRITABLE;
239: }
240:
241: rtn = [self computePartition:offset
242: length : length
243: byteOffset : &byteposition
244: bytesToMove:&bytesToMove];
245:
246: if (rtn) {
247: return(rtn);
248: }
249:
250: /* If the request is aligned with the physical block size, we
251: * send it directly to the driver. If not, we have to use the
252: * (synchronous) reblocking IO function to handle size and/or
253: * alignment mismatches.
254: */
255:
256: if (byteposition % _physicalBlockSize || length % _physicalBlockSize) {
257:
258: return([[self class] commonReadWrite
259: : _physicalDisk
260: : NO
261: : byteposition /* byte offset */
262: : (unsigned)bytesToMove /* bytes */
263: : (unsigned char *)buffer
264: : (vm_task_t)client
265: : (void *)pending
266: : (u_int *)NULL]);
267:
268: } else { /* neatly aligned */
269:
270: return([_physicalDisk writeAsyncAt:(byteposition / _physicalBlockSize)
271: length:bytesToMove
272: buffer:buffer
273: pending:pending
274: client:client]);
275: }
276: }
277:
278: #else KERNEL
279:
280: //xxxxx These copies of the routines have not been updated for reblocking.
281: // They aren't used.
282:
283: - (IOReturn) readAt : (unsigned)offset
284: length : (unsigned)length
285: buffer : (unsigned char *)buffer
286: actualLength : (unsigned *)actualLength
287: {
288: unsigned deviceBlock;
289: IOReturn rtn;
290: unsigned bytesToMove;
291:
292: if(rtn = [self _diskParamCommon:offset
293: length : length
294: deviceOffset : &deviceBlock
295: bytesToMove:&bytesToMove])
296: return(rtn);
297: return([_physicalDisk readAt:deviceBlock
298: length:bytesToMove
299: buffer:buffer
300: actualLength:actualLength]);
301: }
302:
303: - (IOReturn) readAsyncAt : (unsigned)offset
304: length : (unsigned)length
305: buffer : (unsigned char *)buffer
306: pending : (void *)pending
307: {
308: unsigned deviceBlock;
309: IOReturn rtn;
310: unsigned bytesToMove;
311:
312: if(rtn = [self _diskParamCommon:offset
313: length : length
314: deviceOffset : &deviceBlock
315: bytesToMove:&bytesToMove])
316: return(rtn);
317: return([_physicalDisk readAsyncAt:deviceBlock
318: length:bytesToMove
319: buffer:buffer
320: pending:pending]);
321: }
322:
323: - (IOReturn) writeAt : (unsigned)offset
324: length : (unsigned)length
325: buffer : (unsigned char *)buffer
326: actualLength : (unsigned *)actualLength
327: {
328: unsigned deviceBlock;
329: IOReturn rtn;
330: unsigned bytesToMove;
331:
332: if ([self isWriteProtected])
333: return IO_R_NOT_WRITABLE;
334: if(rtn = [self _diskParamCommon:offset
335: length : length
336: deviceOffset : &deviceBlock
337: bytesToMove:&bytesToMove])
338: return(rtn);
339: return([_physicalDisk writeAt:deviceBlock
340: length:bytesToMove
341: buffer:buffer
342: actualLength:actualLength]);
343: }
344:
345: - (IOReturn) writeAsyncAt : (unsigned)offset
346: length : (unsigned)length
347: buffer : (unsigned char *)buffer
348: pending : (void *)pending
349: {
350: unsigned deviceBlock;
351: IOReturn rtn;
352: unsigned bytesToMove;
353:
354: if ([self isWriteProtected])
355: return IO_R_NOT_WRITABLE;
356: if(rtn = [self _diskParamCommon:offset
357: length : length
358: deviceOffset : &deviceBlock
359: bytesToMove:&bytesToMove])
360: return(rtn);
361: return([_physicalDisk writeAsyncAt:deviceBlock
362: length:bytesToMove
363: buffer:buffer
364: pending:pending]);
365: }
366:
367: #endif KERNEL
368:
369: - (IODiskReadyState)updateReadyState
370: {
371: return [_physicalDisk updateReadyState];
372: }
373:
374: /*
375: * Open a connection to physDevice. FIXME: when do we close??
376: */
377: - (IOReturn)connectToPhysicalDisk : physicalDisk
378: {
379: IOReturn rtn = IO_R_SUCCESS;
380:
381: xpr_disk("connectToPhysicalDiskice\n", 1,2,3,4,5);
382: _physicalDisk = physicalDisk;
383: [self setIsPhysical:0];
384:
385: /*
386: * Get some instance variables which must be the same as the
387: * physDevice's.
388: */
389: _physicalBlockSize = [physicalDisk blockSize];
390: [self setRemovable:[physicalDisk isRemovable]];
391: [self setFormattedInternal:[physicalDisk isFormatted]];
392: [self setWriteProtected:[physicalDisk isWriteProtected]];
393: [self setLogicalDisk:nil];
394: #ifdef KERNEL
395: [self setDevAndIdInfo:[physicalDisk devAndIdInfo]];
396: #endif KERNEL
397: return(rtn);
398: }
399:
400: - (void)setPartitionBase : (unsigned)partBase
401: {
402: _partitionBase = partBase;
403: }
404:
405:
406: /*
407: * Determine if this LogicalDisk (or any other LogicalDisks in the
408: * logicalDisk list) are currently open. Returns NO if none open, else
409: * YES.
410: */
411: - (BOOL)isOpen
412: {
413: if([self isInstanceOpen])
414: return(YES);
415: else if([self nextLogicalDisk])
416: return([[self nextLogicalDisk] isOpen]);
417: else
418: return(NO);
419: }
420:
421: /*
422: * Free self and any objects in logicalDisk chain.
423: */
424: - free
425: {
426: id nextLd;
427:
428: nextLd = [self nextLogicalDisk];
429: if(nextLd) {
430: [nextLd free];
431: }
432: return([super free]);
433: }
434:
435: - physicalDisk
436: {
437: return(_physicalDisk);
438: }
439:
440: - (unsigned)physicalBlockSize
441: {
442: return(_physicalBlockSize);
443: }
444:
445: - (void)setPhysicalBlockSize : (unsigned)size
446: {
447: _physicalBlockSize = size;
448: }
449:
450: /*
451: * Pass this on to _physicalDisk.
452: */
453: - (IOReturn)isDiskReady : (BOOL)prompt
454: {
455: return [_physicalDisk isDiskReady:prompt];
456: }
457:
458: /*
459: * Determine if any logical disks in the _logicalDisk chain except
460: * for self are open.
461: */
462: - (BOOL)isAnyOtherOpen
463: {
464: id logDisk = [_physicalDisk nextLogicalDisk];
465: while(logDisk) {
466: if((logDisk != self) && [logDisk isInstanceOpen]) {
467: return YES;
468: }
469: logDisk = [logDisk nextLogicalDisk];
470: }
471: return NO;
472: }
473:
474: - (BOOL)isInstanceOpen
475: {
476: return _instanceOpen;
477: }
478:
479: - (void)setInstanceOpen : (BOOL)isOpen
480: {
481: _instanceOpen = (isOpen ? YES : NO);
482: }
483:
484: /*-----------------------------------------*/
485:
486: /* Common read/write function; handles reblocking of misaligned requests. */
487:
488: + (IOReturn) commonReadWrite : (id)physicalDisk
489: : (BOOL)read
490: : (unsigned long long)byteposition
491: : (unsigned)length /* bytes */
492: : (unsigned char *)buffer
493: : (vm_task_t)client
494: : (void *)pending
495: : (u_int *)actualLength
496: {
497: IOReturn rtn = IO_R_SUCCESS;
498: unsigned long aligncount; /* bytes */
499: unsigned long integralblocks;
500: unsigned long integralbytes;
501: unsigned long transfer;
502: unsigned long originallength;
503: unsigned long physsize; /* physical blocksize */
504: // unsigned char *origbuf;
505: u_int tempactual;
506:
507: //origbuf = buffer;
508: originallength = length;
509: tempactual = 0;
510: physsize = [physicalDisk blockSize];
511:
512: /* If the beginning of the request is not properly aligned
513: * with the device block size, or it's less than a block,
514: * we have to reblock it here to get ourselves aligned.
515: */
516:
517: if ((byteposition % physsize) || (length < physsize)) {
518:
519: /* Compute the number of bytes needed
520: * to bring us into sync with the real size.
521: */
522: aligncount = physsize - (byteposition % physsize);
523: if (aligncount > length) { /* a short read of less than a real block */
524: aligncount = length;
525: }
526:
527: rtn = [[IOLogicalDisk class] reblock
528: : physicalDisk
529: : read /* read or write */
530: : byteposition /* start byte position */
531: : aligncount /* byte count */
532: : buffer
533: : client
534: : pending
535: : physsize];
536: length -= aligncount; /* update length (bytes) */
537: byteposition += aligncount; /* update start byte position */
538: buffer += aligncount; /* update buffer */
539: }
540:
541: /* Now we're aligned. Transfer any integral-block "middle" part
542: * of the request. The integer divide below excludes any "odd" bytes
543: * at the end of the request which aren't part of an integral number
544: * of device blocks.
545: */
546:
547: if (length > 0 && (rtn == IO_R_SUCCESS)) { /* there's more left to do */
548:
549: integralblocks = length / physsize; /* zero if no full blocks */
550:
551: if (integralblocks) { /* transfer this many aligned blocks */
552: integralbytes = integralblocks * physsize;
553:
554: if (read) {
555: rtn = [physicalDisk readAt:(byteposition / physsize)
556: length:integralbytes
557: buffer:buffer
558: actualLength:&tempactual
559: client:client];
560: } else {
561: rtn = [physicalDisk writeAt:(byteposition / physsize)
562: length:integralbytes
563: buffer:buffer
564: actualLength:&tempactual
565: client:client];
566: }
567:
568: length -= integralbytes; /* update length (bytes) */
569: byteposition += integralbytes; /* update start block */
570: buffer += integralbytes; /* update buffer */
571: }
572: }
573:
574: /* If there are any "odd" bytes at the end of the request,
575: * transfer these now via reblocking.
576: */
577:
578: if (length > 0 && (rtn == IO_R_SUCCESS)) { /* there's more to do */
579:
580: rtn = [[IOLogicalDisk class] reblock
581: : physicalDisk
582: : read
583: : byteposition
584: : length
585: : buffer
586: : client
587: : pending
588: : physsize];
589: }
590:
591: /* We only remember the actual length if the transfer succeeds. */
592:
593: if (rtn == IO_R_SUCCESS) {
594: tempactual = originallength;
595: }
596:
597: /* Since we've been doing sync IOs here, we have to force a
598: * completion if the caller's request was async. Done here,
599: * this is ugly, but we have little choice with the current design.
600: */
601:
602: if (pending) { /* async: force an I/O completion (ugly) */
603: [physicalDisk completeTransfer
604: : pending
605: withStatus : rtn
606: actualLength : tempactual];
607: } else { /* sync */
608: *actualLength = tempactual;
609: }
610:
611: return(rtn);
612: }
613: @end
614:
615: /*
616: * Generate device-specific parameters from logical parameters.
617: */
618: @implementation IOLogicalDisk(private)
619:
620: - (IOReturn)_diskParamCommon :(unsigned)logicalOffset
621: length : (unsigned)length
622: deviceOffset : (unsigned*)deviceOffset
623: bytesToMove : (unsigned *)bytesToMove
624: {
625: unsigned ratio = 0; // bogus compiler warning
626: int deviceBlocks;
627: int logicalBlocks;
628: unsigned block_size;
629: unsigned dev_size;
630: IOReturn rtn;
631: const char *name = [self name];
632:
633: /*
634: * Note we have to 'fault in' a possible non-present physical disk in
635: * order to get its physical parameters...
636: */
637: rtn = [_physicalDisk isDiskReady:YES];
638: switch(rtn) {
639: case IO_R_SUCCESS:
640: break;
641: case IO_R_NO_DISK:
642: xpr_err("%s diskParamCommon: disk not present\n",
643: name, 2,3,4,5);
644: return(rtn);
645: default:
646: IOLog("%s deviceRwCommon: bogus return from isDiskReady "
647: "(%s)\n",
648: name, [self stringFromReturn:rtn]);
649: return(rtn);
650: }
651:
652: block_size = [self blockSize];
653: dev_size = [self diskSize];
654:
655: if(length % block_size) {
656: IOLog("%s: Bytes requested not multiple of block size\n",
657: name);
658: return(IO_R_INVALID_ARG);
659: }
660: logicalBlocks = length / block_size;
661: if((logicalOffset + logicalBlocks) > dev_size) {
662: if(logicalOffset >= dev_size)
663: return(IO_R_INVALID_ARG);
664:
665: /*
666: * Truncate.
667: */
668: logicalBlocks = dev_size - logicalOffset;
669: }
670: ratio = block_size / _physicalBlockSize;
671: deviceBlocks = logicalBlocks * ratio;
672: *deviceOffset = (logicalOffset * ratio) + _partitionBase;
673: *bytesToMove = deviceBlocks * _physicalBlockSize;
674: return(IO_R_SUCCESS);
675: }
676:
677: - (IOReturn)computePartition :(unsigned)logicalOffset
678: length : (unsigned)length
679: byteOffset : (unsigned long long *)byteOffset
680: bytesToMove : (unsigned *)bytesToMove
681: {
682: unsigned physicalBlocksize;
683: unsigned logicalBlocksize;
684: IOReturn rtn;
685: const char *name = [self name];
686:
687: unsigned long long partbase;
688: unsigned long long partsize;
689: unsigned long long partend;
690: unsigned long long reqbase;
691:
692: /*
693: * Note we have to 'fault in' a possible non-present physical disk in
694: * order to get its physical parameters...
695: */
696: rtn = [_physicalDisk isDiskReady:YES];
697: switch(rtn) {
698: case IO_R_SUCCESS:
699: break;
700: case IO_R_NO_DISK:
701: xpr_err("%s diskParamCommon: disk not present\n",
702: name, 2,3,4,5);
703: return(rtn);
704: default:
705: IOLog("%s deviceRwCommon: bogus return from isDiskReady "
706: "(%s)\n",
707: name, [self stringFromReturn:rtn]);
708: return(rtn);
709: }
710:
711: /* We compute partition information here based on the notion of
712: * block size, but for better results these boundaries should
713: * have been set up in bytes from the start.
714: */
715: physicalBlocksize = [_physicalDisk blockSize];
716: logicalBlocksize = [self blockSize];
717:
718: /* If we don't (yet) know our logical block size, we have to
719: * default to the physical block size.
720: */
721: if (logicalBlocksize == 0) { /* we don't know (yet)*/
722: logicalBlocksize = physicalBlocksize;
723: }
724:
725: /* The partition base is usually in physical blocks, except when
726: * we are reblocking HFS on CD-ROM. In that case, all computations
727: * are done in 512-byte logical blocks.
728: *
729: * Is there a better way to detect that we're an HFS partition?
730: */
731: if (logicalBlocksize != physicalBlocksize &&
732: logicalBlocksize == 512) { /* must be HFS */
733: partbase = (unsigned long long)_partitionBase *
734: (unsigned long long)logicalBlocksize;
735: } else {
736: partbase = (unsigned long long)_partitionBase *
737: (unsigned long long)physicalBlocksize;
738: }
739: partsize = (unsigned long long)[self diskSize] *
740: (unsigned long long)logicalBlocksize;
741: partend = partbase + partsize;
742:
743: /* The caller's block offset is in units expressed by the
744: * partitioning scheme. NeXT labeled disks are usually 1024 bytes,
745: * HFS is always 512.)
746: */
747: reqbase = ((unsigned long long)logicalOffset *
748: (unsigned long long)logicalBlocksize) + partbase;
749:
750: if (reqbase < partbase || reqbase > partend) {
751: return(IO_R_INVALID_ARG);
752: }
753:
754: if ((reqbase + length) > partend) {
755: length = partend - reqbase; /* truncate the request */
756: }
757:
758: *byteOffset = reqbase;
759: *bytesToMove = length;
760: return(IO_R_SUCCESS);
761: }
762:
763: /* Copy data to (write) or from (read) a misaligned part of a physical block: */
764:
765: #define MAX_REBLOCK_SIZE 2048
766:
767: + (IOReturn) reblock : (id)physicalDisk
768: : (BOOL)read
769: : (unsigned long long)offset /* bytes */
770: : (unsigned)length /* bytes */
771: : (unsigned char *)buffer
772: : (vm_task_t)client
773: : (void *)pending
774: : (unsigned)physsize /* phys blocksize */
775: {
776: IOReturn rtn;
777: unsigned long physblock;
778: int bufoffset;
779: u_int tempactual;
780: id controller;
781: char *reblockbuf;
782: void *freePtr;
783: unsigned freeCnt;
784:
785: /* Allocate a buffer to hold the (larger) device block. This isn't
786: * efficient since we allocate and free the buffer each time through,
787: * but we're just trying to make the thing work for now.
788: */
789:
790: controller = [physicalDisk controller];
791: reblockbuf = (char *)[controller allocateBufferOfLength:MAX_REBLOCK_SIZE
792: actualStart:&freePtr
793: actualLength:&freeCnt];
794:
795: bzero(reblockbuf,MAX_REBLOCK_SIZE);
796:
797: /* Figure out which physical block we need, and load it: */
798:
799: physblock = offset / physsize;
800:
801: rtn = [physicalDisk readAt
802: :physblock
803: length:physsize
804: buffer:reblockbuf
805: actualLength:&tempactual
806: client:client];
807:
808: if (rtn != IO_R_SUCCESS) {
809: return(rtn);
810: }
811:
812: /* Now copy what the client wants, in the direction specified: */
813:
814: bufoffset = offset % physsize;
815:
816: if (read) {
817: bcopy(&reblockbuf[bufoffset],buffer,length); /* read : buf to client */
818: } else {
819: bcopy(buffer,&reblockbuf[bufoffset],length); /* write: client to buf */
820:
821: /* If writing, flush the buffer to the device: */
822: rtn = [physicalDisk writeAt:physblock
823: length:physsize
824: buffer:reblockbuf
825: actualLength:&tempactual
826: client:client];
827: }
828:
829: IOFree(freePtr,freeCnt);
830: return(IO_R_SUCCESS);
831: }
832:
833: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.