![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IONeXTPartitionScheme.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOStorage|
Return to IONeXTPartitionScheme.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOStorage |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22:
23: //
24: // Notes:
25: // -----
26: // o the on-disk label structure is packed for M68xxx and has big endian fields
27: //
28: // o the on-disk label is stored four times in succession, each label taking up
29: // round(sizeof(disk_label_t), drive's hard block size) bytes; CD's suffer of
30: // the mastering-with-a-different-hard-block-size problem, however we presume
31: // that all CDs produced that exhibit this problem have a valid first label
32: // at relative byte zero, and hence the next label increment is irrelevant.
33: //
34: // o the dl_label_blkno block value is absolute with respect to the whole disk,
35: // and the implicit block size is the drive's hard block size (eg. hard drive
36: // is typically 512 bytes, CD is typically 2048 bytes)
37: //
38: // o the dl_dt.d_front block value is relative to the containing partition's
39: // boundary (ie. relative to the very first label's dl_label_blkno value),
40: // and the implicit block size is dl_dt.d_secsize bytes (eg. hd=1024, cd=2048)
41: //
42: // o the dl_dt.d_partitions[].p_base block value is absolute with respect to the
43: // whole disk, and the implicit block size is dl_dt.d_secsize bytes; an offset
44: // of dl_dt.d_front is not factored into the p_base value, but should be in
45: // order to calculate the actual start position of the partition on the disk
46: //
47: // o the dl_dt.d_partitions[].p_size block value's implicit block size is
48: // dl_dt.d_secsize bytes
49: //
50: // Policies:
51: // --------
52: // o the NeXT partition scheme accepts probes only on "whole" media objects
53: // and non-whole media objects with a content hint of 'Apple_Rhapsody_UFS'
54: //
55: // o the first two out of the four possible on-disk labels are read while the
56: // last two are ignored -- this is done in the spirit of minimizing reads;
57: // we forfeit some redundancy, however that is acceptable; the second label
58: // MUST be checked due to the fact that i386 machines commonly have the 1st
59: // label missing (due to the FDISK boot structure), but the second is valid
60: //
61: // o the default probe score of the NeXT partition scheme is 1000
62: //
63: // o the eigth partition is always skipped -- this is due to the many varying
64: // preconceptions associated with the 8th partition in unix land: we just
65: // ignore it altogether (+ permits us a significant coding simplification)
66: //
67: // o the checksum for each NeXT label is not validated -- this is done in the
68: // spirit of minimizing reads and perhaps a bit of laziness
69: //
70:
71: #include <IOKit/assert.h>
72: #include <IOKit/IOLib.h>
73: #include <IOKit/storage/IONeXTPartitionScheme.h>
74: #include <libkern/OSByteOrder.h>
75:
76: #define super IOPartitionScheme
77: OSDefineMetaClassAndStructors(IONeXTPartitionScheme, IOPartitionScheme);
78:
79: #define kMinimumBlockSize 512
80:
81: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
82: // NeXT Partition Types
83:
84: static struct { char * type; char * name; } partitionTypes[] =
85: {
86: { "4.4BSD", "Apple_UFS" },
87: // { "4.1BSD", ... }, // V7 with 1K blocks (4.1, 2.9)
88: // { "4.2BSD", ... }, // 4.2BSD fast file system
89: // { "4.4LFS", ... }, // 4.4BSD log-structured file system
90: { 0, 0 }
91: };
92:
93: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
94:
95: bool IONeXTPartitionScheme::init(OSDictionary * properties = 0)
96: {
97: //
98: // Initialize this object's minimal state.
99: //
100:
101: if (super::init(properties) == false) return false;
102:
103: _absoluteBase = 0;
104: _buffer = 0;
105: _bufferSize = 0;
106:
107: // Validate the compiled size of our important fixed-size structures.
108:
109: assert(sizeof(disktab_t) == 514);
110: assert(sizeof(partition_t) == 46);
111: assert(sizeof(disk_label_t) == 7240);
112:
113: return true;
114: }
115:
116: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
117:
118: void IONeXTPartitionScheme::free()
119: {
120: //
121: // Free all of this object's outstanding resources.
122: //
123:
124: if (_buffer) _buffer->release();
125:
126: super::free();
127: }
128:
129: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
130:
131: IOService * IONeXTPartitionScheme::probe(IOService * provider, SInt32 * score)
132: {
133: //
134: // Determine whether the provider media contains an NeXT partition map. If
135: // it does, we return "this" to indicate success, otherwise we return zero.
136: //
137:
138: IOMedia * media = (IOMedia *) provider;
139:
140: // State our assumptions.
141:
142: assert(OSDynamicCast(IOMedia, provider));
143:
144: // Ask superclass' opinion about this probe.
145:
146: if (super::probe(provider, score) == 0) return 0;
147:
148: // Determine whether this media object is unformatted.
149:
150: if (media->isFormatted() == false) return 0;
151:
152: // Determine whether this media's block size is below our assumed minimum.
153:
154: if (media->getPreferredBlockSize() < kMinimumBlockSize) return 0;
155:
156: // Determine whether we can rule out the media object as a NeXT partition
157: // map container without reading actual data from the media. We rule out
158: // all non-whole media objects without an 'Apple_Rhapsody_UFS' hint.
159:
160: if ( media->isWhole() == false )
161: {
162: if ( strcmp(media->getContentHint(), "Apple_Rhapsody_UFS") ) return 0;
163: }
164:
165: // Compute this partition's absolute offset with respect to the whole
166: // media, since the disk_label structure requires this information --
167: // we go down the service hierarchy until we reach the whole media
168: // object (or run off the end :-).
169:
170: for (IOService * service = media; service; service = service->getProvider())
171: {
172: if ( OSDynamicCast(IOMedia, service) ) // (is this a media object?)
173: {
174: _absoluteBase += ((IOMedia *)service)->getBase();
175: if (((IOMedia *)service)->isWhole()) break;
176: }
177: }
178:
179: // Allocate a buffer large enough to hold one media block.
180:
181: _bufferSize = media->getPreferredBlockSize();
182: _buffer = IOBufferMemoryDescriptor::withCapacity(_bufferSize,
183: kIODirectionIn);
184:
185: if (_buffer == 0) return 0;
186:
187: // Search for a valid NeXT label on the provider media.
188:
189: return identify(media) ? this : 0;
190: }
191:
192: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
193:
194: bool IONeXTPartitionScheme::start(IOService * provider)
195: {
196: //
197: // This method is called once we have been attached to the media object. We
198: // generate the new media objects that will represent our partitions here.
199: //
200:
201: disk_label_t * label;
202: IOMedia * media = (IOMedia *) provider;
203: bool success = false;
204:
205: // State our assumptions.
206:
207: assert(_buffer);
208: assert(_bufferSize >= kMinimumBlockSize);
209:
210: // Ask our superclass' opinion.
211:
212: if ( !super::start(provider) ) return false;
213:
214: // The block size we calculate for the partitions is important to
215: // BSD and its filesystems -- if we get it wrong, the filesystem
216: // will end up reading and writing the wrong blocks. We use the
217: // NeXT label's sector size, NOT the partition's fragment size or
218: // it won't work (speaking out of experience). Period.
219:
220: label = (disk_label_t *) _buffer->getBytesNoCopy();
221:
222: UInt64 fsBlockSize = OSSwapBigToHostInt32(label->dl_secsize);
223:
224: if (fsBlockSize % media->getPreferredBlockSize())
225: {
226: IOLog("%s on %s: Bad block size is defined.\n",
227: getName(), media->getName());
228: return false;
229: }
230:
231: // Scan through all the partition entries.
232: //
233: // Due to the different preconceptions associated with the eigth partition,
234: // our policy is to ignore the eigth partition altogether. This also makes
235: // for a cool coding simplification -- since the first 7 partition entries
236: // completely fit in the first 512-byte block, a read of the next block and
237: // caching useful global information from the first block is not necessary
238: // just to parse the eigth partition entry.
239:
240: assert( kMinimumBlockSize >= ( (UInt8 *) &(label->dl_part[NPART-1]) -
241: (UInt8 *) label) );
242:
243: for ( unsigned index = 0; index < NPART - 1; index++ )
244: {
245: // Skip all null partition entries (have base of -1 and size of -1).
246:
247: if ( (SInt32) OSSwapBigToHostInt32(label->dl_part[index].p_base) < 0 ||
248: (SInt32) OSSwapBigToHostInt32(label->dl_part[index].p_size) <= 0 )
249: continue; // (skip)
250:
251: // Compute the absolute position and size of the new partition.
252:
253: UInt64 base;
254: UInt64 size;
255:
256: base = ( (UInt64) OSSwapBigToHostInt32(label->dl_part[index].p_base) +
257: (UInt64) OSSwapBigToHostInt16(label->dl_front) ) *
258: (UInt64) OSSwapBigToHostInt32(label->dl_secsize);
259: size = (UInt64) OSSwapBigToHostInt32(label->dl_part[index].p_size) *
260: (UInt64) OSSwapBigToHostInt32(label->dl_secsize);
261:
262: // Look up a name and a type for this partition.
263:
264: const char * aName = "Untitled";
265: const char * aHint = 0;
266:
267: if ( label->dl_part[index].p_mountpt[0] )
268: aName = label->dl_part[index].p_mountpt;
269: else if ( label->dl_label[0] )
270: aName = label->dl_label;
271:
272: for (unsigned n = 0; partitionTypes[n].type; n++)
273: {
274: if ( !strcmp(label->dl_part[index].p_type, partitionTypes[n].type) )
275: {
276: aHint = partitionTypes[n].name;
277: break;
278: }
279: }
280:
281: if (aHint == 0) aHint = label->dl_part[index].p_type;
282:
283: // Ensure the partition definition does not leave the confines of the
284: // containing media (especially that base is an absolute position).
285:
286: if ( base < _absoluteBase ||
287: base - _absoluteBase + size > media->getSize() )
288: {
289: IOLog("%s on %s: \"%s\" (partition %d) exceeds confines of "
290: "containing media.\n",
291: getName(), media->getName(), aName, index+1);
292: continue; // (skip)
293: }
294:
295: // The partition base may be unaligned with respect the whole media's
296: // block boundaries. We warn the user in this event since every read
297: // or write is going to cause deblocking.
298:
299: if ( (_absoluteBase + base) % media->getPreferredBlockSize() )
300: {
301: IOLog("%s on %s: Access to \"%s\" (partition %d) may be slow due "
302: "to a misaligned block boundary.\n",
303: getName(), media->getName(), aName, index + 1);
304: }
305:
306: // Create the new media object.
307:
308: IOMedia * newMedia = new IOMedia;
309:
310: if ( !newMedia ||
311: !newMedia->init( // base (bytes; relative to provider media)
312: base - _absoluteBase,
313: // size (bytes)
314: size,
315: // natural block size (bytes)
316: fsBlockSize,
317: // is ejectable
318: media->isEjectable(),
319: // is whole
320: false,
321: // is writable
322: media->isWritable(),
323: // content hint
324: aHint ) ||
325: !newMedia->attach(this) )
326: {
327: IOLog("%s on %s: Unable to create media object for \"%s\" "
328: "(partition %d).\n",
329: getName(), media->getName(), aName, index + 1);
330:
331: if (newMedia) newMedia->release();
332: continue; // (skip)
333: }
334:
335: newMedia->setName(aName);
336:
337: // Set a location value (the partition number) for this partition.
338:
339: char location[12];
340: sprintf(location, "%d", index + 1);
341: newMedia->setLocation(location);
342:
343: // Create the "Partition ID" key.
344:
345: newMedia->setProperty(kIOMediaPartitionID, index + 1, 32);
346:
347: // Register the media object with the matching system.
348:
349: newMedia->registerService();
350:
351: // Release our retain on the new media object (in registry).
352:
353: newMedia->release();
354:
355: success = true;
356: } // (for all partition entries)
357:
358: // Release our buffer now that we no longer need it.
359:
360: _buffer->release();
361:
362: _buffer = 0;
363: _bufferSize = 0;
364:
365: // Return success if we found at least one partition.
366:
367: return success;
368: }
369:
370: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
371:
372: bool IONeXTPartitionScheme::identify(IOMedia * media)
373: {
374: //
375: // Searches for the existence of a NeXT partition map on the given media.
376: //
377:
378: UInt32 labelIncrement; // (in bytes)
379: bool success = false;
380:
381: // State our assumptions.
382:
383: assert(_buffer);
384: assert(_bufferSize >= kMinimumBlockSize);
385:
386: // Open the media object for access.
387:
388: if ( media->open(this, 0, kAccessReader) == false ) return false;
389:
390: // Search through the four (NLABELS) possible label positions.
391: //
392: // In the spirit of minimizing reads, however, we cheat and only check the
393: // first two of the four possible label positions. Note that it is common
394: // on i386 machines that the first label is non-existent, while the second
395: // is valid, hence why we check the first TWO labels.
396:
397: labelIncrement=IORound(sizeof(disk_label_t),media->getPreferredBlockSize());
398:
399: for (unsigned index = 0; index < 2; index++) // ("2" was "NLABELS")
400: {
401: // Read the appropriate block into our buffer.
402:
403: _buffer->setDirection(kIODirectionIn); // (a read)
404: _buffer->setLength(_bufferSize); // (transfer one full block)
405:
406: if ( media->read( /* client */ this,
407: /* byteStart */ labelIncrement * index,
408: /* buffer */ _buffer ) == kIOReturnSuccess )
409: {
410: // Determine whether this buffer contains a valid NeXT label. We
411: // validate the version signature and the label's block position.
412:
413: disk_label_t * label = (disk_label_t *) _buffer->getBytesNoCopy();
414:
415: if ( OSSwapBigToHostInt32(label->dl_version) == DL_V3 ||
416: OSSwapBigToHostInt32(label->dl_version) == DL_V2 ||
417: OSSwapBigToHostInt32(label->dl_version) == DL_V1 )
418: {
419: if ( OSSwapBigToHostInt32(label->dl_label_blkno) ==
420: (UInt32) ( (_absoluteBase + labelIncrement * index) /
421: media->getPreferredBlockSize() ) )
422: {
423: success = true; // (valid version and block position)
424: break;
425: }
426: }
427: }
428: }
429:
430: // Close the media object we opened earlier.
431:
432: media->close(this);
433:
434: return success;
435: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.