![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOMedia.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 IOMedia.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: #include <machine/limits.h> // (ULONG_MAX, ...)
24: #include <IOKit/IODeviceTreeSupport.h> // (gIODTPlane, ...)
25: #include <IOKit/storage/IOMedia.h>
26:
27: #define super IOStorage
28: OSDefineMetaClassAndStructors(IOMedia, IOStorage)
29:
30: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
31:
32: bool IOMedia::init(UInt64 base,
33: UInt64 size,
34: UInt64 preferredBlockSize,
35: bool isEjectable,
36: bool isWhole,
37: bool isWritable,
38: const char * contentHint = 0,
39: OSDictionary * properties = 0)
40: {
41: //
42: // Initialize this object's minimal state.
43: //
44:
45: if (super::init(properties) == false) return false;
46:
47: _mediaBase = base;
48: _mediaSize = size;
49: _isEjectable = isEjectable;
50: _isWhole = isWhole;
51: _isWritable = isWritable;
52: _openLevel = kAccessNone;
53: _openReaders = OSSet::withCapacity(1);
54: _openReaderWriter = 0;
55: _preferredBlockSize = preferredBlockSize;
56:
57: if (_openReaders == 0) return false;
58:
59: //
60: // Create the standard media registry properties.
61: //
62:
63: setProperty(kIOMediaContent, contentHint ? contentHint : "");
64: setProperty(kIOMediaContentHint, contentHint ? contentHint : "");
65: setProperty(kIOMediaEjectable, isEjectable);
66: setProperty(kIOMediaLeaf, true);
67: setProperty(kIOMediaSize, size, 64);
68: setProperty(kIOMediaWhole, isWhole);
69: setProperty(kIOMediaWritable, isWritable);
70:
71: return true;
72: }
73:
74: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
75:
76: void IOMedia::free(void)
77: {
78: //
79: // Free all of this object's outstanding resources.
80: //
81:
82: if (_openReaders) _openReaders->release();
83:
84: super::free();
85: }
86:
87: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
88:
89: bool IOMedia::attachToChild(IORegistryEntry * client,
90: const IORegistryPlane * plane)
91: {
92: //
93: // This method is called for each client interested in the services we
94: // provide. The superclass links us as a parent to this client in the
95: // I/O Kit registry on success.
96: //
97:
98: OSString * s;
99:
100: // Ask our superclass' opinion.
101:
102: if (super::attachToChild(client, plane) == false) return false;
103:
104: //
105: // Determine whether the client is a storage object, which we consider
106: // to be a consumer of this storage object's content and a producer of
107: // new content. A storage object need not be an IOStorage subclass, so
108: // long as it identifies itself with a match category of "IOStorage".
109: //
110: // If the client is indeed a storage object, we reset the media's Leaf
111: // property to false and replace the media's Content property with the
112: // client's Content Mask property, if any.
113: //
114:
115: s = OSDynamicCast(OSString, client->getProperty(gIOMatchCategoryKey));
116:
117: if (s && !strcmp(s->getCStringNoCopy(), kIOStorageCategory))
118: {
119: setProperty(kIOMediaLeaf, false);
120:
121: s = OSDynamicCast(OSString, client->getProperty(kIOMediaContentMask));
122: if (s) setProperty(kIOMediaContent, s->getCStringNoCopy());
123: }
124:
125: return true;
126: }
127:
128: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
129:
130: void IOMedia::detachFromChild(IORegistryEntry * client,
131: const IORegistryPlane * plane)
132: {
133: //
134: // This method is called for each client that loses interest in the
135: // services we provide. The superclass unlinks us from this client
136: // in the I/O Kit registry on success.
137: //
138: // Note that this method is called at a nondeterministic time after
139: // our client is terminated, which means another client may already
140: // have arrived and attached in the meantime. This is not an issue
141: // should the termination be issued synchrnously, however, which we
142: // take advantage of when this media needs to eliminate one of its
143: // clients. If the termination was issued on this media or farther
144: // below in the hierarchy, we don't really care that the properties
145: // would not be consistent since this media object is going to die
146: // anyway.
147: //
148:
149: OSString * s;
150:
151: //
152: // Determine whether the client is a storage object, which we consider
153: // to be a consumer of this storage object's content and a producer of
154: // new content. A storage object need not be an IOStorage subclass, so
155: // long as it identifies itself with a match category of "IOStorage".
156: //
157: // If the client is indeed a storage object, we reset the media's Leaf
158: // property to true and reset the media's Content property to the hint
159: // we obtained when this media was initialized.
160: //
161:
162: s = OSDynamicCast(OSString, client->getProperty(gIOMatchCategoryKey));
163:
164: if (s && !strcmp(s->getCStringNoCopy(), kIOStorageCategory))
165: {
166: setProperty(kIOMediaContent, getContentHint());
167: setProperty(kIOMediaLeaf, true);
168: }
169:
170: // Pass the call onto our superclass.
171:
172: super::detachFromChild(client, plane);
173: }
174:
175: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
176:
177: bool IOMedia::handleOpen(IOService * client,
178: IOOptionBits options,
179: void * argument)
180: {
181: //
182: // The handleOpen method grants or denies permission to access this object
183: // to an interested client. The argument is an IOStorageAccess value that
184: // specifies the level of access desired -- reader or reader-writer.
185: //
186: // This method can be invoked to upgrade or downgrade the access level for
187: // an existing client as well. The previous access level will prevail for
188: // upgrades that fail, of course. A downgrade should never fail. If the
189: // new access level should be the same as the old for a given client, this
190: // method will do nothing and return success. In all cases, one, singular
191: // close-per-client is expected for all opens-per-client received.
192: //
193: // This method will work even when the media is in the terminated state.
194: //
195: // We are guaranteed that no other opens or closes will be processed until
196: // we make our decision, change our state, and return from this method.
197: //
198:
199: IOStorageAccess access = (IOStorageAccess) (int) argument;
200: IOStorageAccess level;
201:
202: assert(client);
203:
204: //
205: // Chart our course of action.
206: //
207:
208: switch (access)
209: {
210: case kAccessReader:
211: {
212: if (_openReaders->containsObject(client)) // (access: no change)
213: return true;
214: else if (_openReaderWriter == client) // (access: downgrade)
215: level = kAccessReader;
216: else // (access: new reader)
217: level = _openReaderWriter ? kAccessReaderWriter : kAccessReader;
218: break;
219: }
220: case kAccessReaderWriter:
221: {
222: if (_openReaders->containsObject(client)) // (access: upgrade)
223: level = kAccessReaderWriter;
224: else if (_openReaderWriter == client) // (access: no change)
225: return true;
226: else // (access: new writer)
227: level = kAccessReaderWriter;
228:
229: if (_isWritable == false) // (is this media object writable?)
230: return false;
231:
232: if (_openReaderWriter) // (does a reader-writer already exist?)
233: return false;
234:
235: break;
236: }
237: default:
238: {
239: assert(0);
240: return false;
241: }
242: }
243:
244: //
245: // If we are in the terminated state, we only accept downgrades.
246: //
247:
248: if (isInactive() && _openReaderWriter != client) // (dead? not a downgrade?)
249: return false;
250:
251: //
252: // Determine whether the storage objects above us can be torn down, should
253: // this be a new reader-writer open or an upgrade into a reader-writer (if
254: // the client issuing the open is not a storage object itself, of course).
255: //
256:
257: if (access == kAccessReaderWriter) // (a new reader-writer or an upgrade?)
258: {
259: const OSSymbol * category = OSSymbol::withCString(kIOStorageCategory);
260:
261: if (category)
262: {
263: IOService * storageObject = getClientWithCategory(category);
264: category->release();
265:
266: if (storageObject && storageObject != client)
267: {
268: if (storageObject->terminate(kIOServiceSynchronous) == false)
269: return false;
270: }
271: }
272: }
273:
274: //
275: // Determine whether the storage objects below us accept this open at this
276: // multiplexed level of access -- new opens, upgrades, and downgrades (and
277: // no changes in access) all enter through the same open api.
278: //
279:
280: if (_openLevel != level) // (has open level changed?)
281: {
282: IOStorage * provider = OSDynamicCast(IOStorage, getProvider());
283:
284: if (provider && provider->open(this, options, level) == false)
285: {
286: //
287: // We were unable to open the storage objects below us. We must
288: // recover from the terminate we issued above before bailing out,
289: // if applicable, by re-registering the media object for matching.
290: //
291:
292: if (access == kAccessReaderWriter)
293: registerService(kIOServiceSynchronous); // (re-register media)
294:
295: return false;
296: }
297: }
298:
299: //
300: // Process the open.
301: //
302: // We make sure our open state is consistent before calling registerService
303: // (if applicable) since this method can be called again on the same thread
304: // (the lock protecting handleOpen is recursive, so access would be given).
305: //
306:
307: _openLevel = level;
308:
309: if (access == kAccessReader)
310: {
311: _openReaders->setObject(client);
312:
313: if (_openReaderWriter == client) // (for a downgrade)
314: {
315: _openReaderWriter = 0;
316: registerService(kIOServiceSynchronous); // (re-register media)
317: }
318: }
319: else // (access == kAccessReaderWriter)
320: {
321: _openReaderWriter = client;
322:
323: _openReaders->removeObject(client); // (for an upgrade)
324: }
325:
326: return true;
327: }
328:
329: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
330:
331: bool IOMedia::handleIsOpen(const IOService * client) const
332: {
333: //
334: // The handleIsOpen method determines whether the specified client, or any
335: // client if none is specificed, presently has an open on this object.
336: //
337: // This method will work even when the media is in the terminated state.
338: //
339: // We are guaranteed that no other opens or closes will be processed until
340: // we return from this method.
341: //
342:
343: if (client == 0) return (_openLevel != kAccessNone);
344:
345: return ( _openReaderWriter == client ||
346: _openReaders->containsObject(client) );
347: }
348:
349: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
350:
351: void IOMedia::handleClose(IOService * client, IOOptionBits options)
352: {
353: //
354: // A client is informing us that it is giving up access to our contents.
355: //
356: // This method will work even when the media is in the terminated state.
357: //
358: // We are guaranteed that no other opens or closes will be processed until
359: // we change our state and return from this method.
360: //
361:
362: assert(client);
363:
364: //
365: // Process the close.
366: //
367:
368: bool reregister = (_openReaderWriter == client) && (isInactive() == false);
369:
370: if (_openReaderWriter == client) // (is the client a reader-writer?)
371: {
372: _openReaderWriter = 0;
373: }
374: else if (_openReaders->containsObject(client)) // (is the client a reader?)
375: {
376: _openReaders->removeObject(client);
377: }
378: else // (is the client is an imposter?)
379: {
380: assert(0);
381: return;
382: }
383:
384: //
385: // Reevaluate the open we have on the level below us. If no opens remain,
386: // we close, or if no reader-writer remains, but readers do, we downgrade.
387: //
388:
389: IOStorageAccess level;
390:
391: if (_openReaderWriter) level = kAccessReaderWriter;
392: else if (_openReaders->getCount()) level = kAccessReader;
393: else level = kAccessNone;
394:
395: if (_openLevel != level) // (has open level changed?)
396: {
397: IOStorage * provider = OSDynamicCast(IOStorage, getProvider());
398:
399: assert(level != kAccessReaderWriter);
400:
401: if (provider)
402: {
403: if (level == kAccessNone) // (is a close in order?)
404: {
405: provider->close(this, options);
406: }
407: else // (is a downgrade in order?)
408: {
409: bool success;
410: success = provider->open(this, 0, level);
411: assert(success); // (should never fail, unless avoided deadlock)
412: }
413: }
414:
415: _openLevel = level; // (set new open level)
416: }
417:
418: //
419: // If the reader-writer just closeed, re-register the media so that I/O Kit
420: // will attempt to match storage objects that may now be interested in this
421: // media.
422: //
423: // We make sure our open state is consistent before calling registerService
424: // (if applicable) since this method can be called again on the same thread
425: // (the lock protecting handleClose is recursive, so access would be given).
426: //
427:
428: if (reregister)
429: registerService(kIOServiceSynchronous); // (re-register media)
430: }
431:
432: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
433:
434: void IOMedia::read(IOService * /* client */,
435: UInt64 byteStart,
436: IOMemoryDescriptor * buffer,
437: IOStorageCompletion completion)
438: {
439: //
440: // Read data from the storage object at the specified byte offset into the
441: // specified buffer, asynchronously. When the read completes, the caller
442: // will be notified via the specified completion action.
443: //
444: // The buffer will be retained for the duration of the read.
445: //
446: // This method will work even when the media is in the terminated state.
447: //
448:
449: if (isInactive())
450: {
451: complete(completion, kIOReturnNoMedia);
452: return;
453: }
454:
455: if (_openLevel == kAccessNone) // (instantaneous value, no lock)
456: {
457: complete(completion, kIOReturnNotOpen);
458: return;
459: }
460:
461: if (_mediaSize == 0 || _preferredBlockSize == 0)
462: {
463: complete(completion, kIOReturnUnformattedMedia);
464: return;
465: }
466:
467: if (_mediaSize < byteStart + buffer->getLength())
468: {
469: complete(completion, kIOReturnBadArgument);
470: return;
471: }
472:
473: byteStart += _mediaBase;
474: getProvider()->read(this, byteStart, buffer, completion);
475: }
476:
477: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
478:
479: void IOMedia::write(IOService * client,
480: UInt64 byteStart,
481: IOMemoryDescriptor * buffer,
482: IOStorageCompletion completion)
483: {
484: //
485: // Write data into the storage object at the specified byte offset from the
486: // specified buffer, asynchronously. When the write completes, the caller
487: // will be notified via the specified completion action.
488: //
489: // The buffer will be retained for the duration of the write.
490: //
491: // This method will work even when the media is in the terminated state.
492: //
493:
494: if (isInactive())
495: {
496: complete(completion, kIOReturnNoMedia);
497: return;
498: }
499:
500: if (_openLevel == kAccessNone) // (instantaneous value, no lock)
501: {
502: complete(completion, kIOReturnNotOpen);
503: return;
504: }
505:
506: if (_openReaderWriter != client) // (instantaneous value, no lock)
507: {
508: ///m:2425148:workaround:commented:start
509: // complete(completion, kIOReturnNotPrivileged);
510: // return;
511: ///m:2425148:workaround:commented:stop
512: }
513:
514: if (_isWritable == 0)
515: {
516: complete(completion, kIOReturnLockedWrite);
517: return;
518: }
519:
520: if (_mediaSize == 0 || _preferredBlockSize == 0)
521: {
522: complete(completion, kIOReturnUnformattedMedia);
523: return;
524: }
525:
526: if (_mediaSize < byteStart + buffer->getLength())
527: {
528: complete(completion, kIOReturnBadArgument);
529: return;
530: }
531:
532: byteStart += _mediaBase;
533: getProvider()->write(this, byteStart, buffer, completion);
534: }
535:
536: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
537:
538: UInt64 IOMedia::getPreferredBlockSize() const
539: {
540: //
541: // Ask the media object for its natural block size. This information
542: // is useful to clients that want to optimize access to the media.
543: //
544:
545: return _preferredBlockSize;
546: }
547:
548: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
549:
550: UInt64 IOMedia::getSize() const
551: {
552: //
553: // Ask the media object for its total length in bytes.
554: //
555:
556: return _mediaSize;
557: }
558:
559: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
560:
561: UInt64 IOMedia::getBase() const
562: {
563: //
564: // Ask the media object for its byte offset relative to its provider media
565: // object below it in the storage hierarchy.
566: //
567:
568: return _mediaBase;
569: }
570:
571: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
572:
573: bool IOMedia::isEjectable() const
574: {
575: //
576: // Ask the media object whether it is ejectable.
577: //
578:
579: return _isEjectable;
580: }
581:
582: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
583:
584: bool IOMedia::isFormatted() const
585: {
586: //
587: // Ask the media object whether it is formatted.
588: //
589:
590: return (_mediaSize && _preferredBlockSize);
591: }
592:
593: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
594:
595: bool IOMedia::isWritable() const
596: {
597: //
598: // Ask the media object whether it is writable.
599: //
600:
601: return _isWritable;
602: }
603:
604: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
605:
606: bool IOMedia::isWhole() const
607: {
608: //
609: // Ask the media object whether it represents the whole disk.
610: //
611:
612: return _isWhole;
613: }
614:
615: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
616:
617: const char * IOMedia::getContent() const
618: {
619: //
620: // Ask the media object for a description of its contents. The description
621: // is the same as the hint at the time of the object's creation, but it is
622: // possible that the description be overrided by a client (which has probed
623: // the media and identified the content correctly) of the media object. It
624: // is more accurate than the hint for this reason. The string is formed in
625: // the likeness of Apple's "Apple_HFS" strings.
626: //
627: // The content description can be overrided by any client that matches onto
628: // this media object with a match category of kIOStorageCategory. The media
629: // object checks for a kIOMediaContentMask property in the client, and if it
630: // finds one, it copies it into kIOMediaContent property.
631: // property with it.
632: //
633:
634: OSString * string;
635:
636: string = OSDynamicCast(OSString, getProperty(kIOMediaContent));
637: if (string == 0) return "";
638: return string->getCStringNoCopy();
639: }
640:
641: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
642:
643: const char * IOMedia::getContentHint() const
644: {
645: //
646: // Ask the media object for a hint of its contents. The hint is set at the
647: // time of the object's creation, should the creator have a clue as to what
648: // it may contain. The hint string does not change for the lifetime of the
649: // object and is also formed in the likeness of Apple's "Apple_HFS" strings.
650: //
651:
652: OSString * string;
653:
654: string = OSDynamicCast(OSString, getProperty(kIOMediaContentHint));
655: if (string == 0) return "";
656: return string->getCStringNoCopy();
657: }
658:
659: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
660:
661: IOService * IOMedia::matchLocation(IOService * client)
662: {
663: //
664: // I/O Kit is in the process of searching for a candidate object that wishes
665: // to match against an IOLocation={x} dictionary of properties. This is the
666: // method called to determine whether this object wants to be the candidate.
667: //
668: // The matchLocation method should return "this" if it decides to match with
669: // the IOLocation={x} dictionary, otherwise it should call the superclass to
670: // continue with the search and skip this object as a candidate.
671: //
672: // If this object chooses to match, the dictionary {x} will be passed to the
673: // standard (passive) matching method matchPropertyTable for comparison.
674: //
675:
676: if (isWhole() == false)
677: {
678: // We elect to be the candidate object for the IOLocation={x} dictionary
679: // only if we are a non-whole media; whole medias have no "location" per
680: // se.
681:
682: assert(getLocation() && strcmp(getLocation(), ""));
683: return this; // ("please compare us")
684: }
685:
686: return super::matchLocation(client); // ("please skip over us")
687: }
688:
689: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
690:
691: bool IOMedia::matchPropertyTable(OSDictionary * table)
692: {
693: //
694: // Compare the properties in the supplied table to this object's properties.
695: //
696:
697: OSString * string;
698:
699: // Ask our superclass' opinion.
700:
701: if (super::matchPropertyTable(table) == false) return false;
702:
703: // Determine whether the "IOPath Extension" property is in the comparison
704: // dictionary. If it is, we compare this media's location against it.
705:
706: string = OSDynamicCast(OSString, table->getObject("IOPath Extension"));
707:
708: if (string) // (does "IOPath Extension" exist?)
709: {
710: const char * location = getLocation();
711:
712: if (location == 0 && isWhole() == false) return false;
713:
714: UInt32 value1 = location ? strtoul(location, 0, 10) : 0;
715: UInt32 value2 = strtoul(string->getCStringNoCopy(), 0, 10);
716:
717: if (value1 == ULONG_MAX || value2 == ULONG_MAX) return false;
718: if (value1 != value2) return false;
719: }
720:
721: // Ensure the "IOProviderClass" property is present in the comparison
722: // dictionary, and that the given class name belongs to this object's
723: // inheritance chain.
724:
725: string = OSDynamicCast(OSString, table->getObject(gIOProviderClassKey));
726:
727: if (string == 0 || metaCast(string) == 0) return false;
728:
729: // We return success if the following expression is true -- individual
730: // comparisions evaluate to truth if the named property is not present
731: // in the supplied table.
732:
733: return compareProperty(table, kIOMediaContent) &&
734: compareProperty(table, kIOMediaContentHint) &&
735: compareProperty(table, kIOMediaEjectable) &&
736: compareProperty(table, kIOMediaLeaf) &&
737: compareProperty(table, kIOMediaSize) &&
738: compareProperty(table, kIOMediaWhole) &&
739: compareProperty(table, kIOMediaWritable) ;
740: }
741:
742: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
743:
744: bool IOMedia::getPath( char * path,
745: int * length,
746: const IORegistryPlane * plane ) const
747: {
748: //
749: // Obtain a path to this service object.
750: //
751: // This method will work even when the media is in the terminated state.
752: //
753:
754: IOMedia * media;
755: IOService * next;
756: OSNumber * number;
757: bool success = false;
758: int unit = -1, partition = 0;
759: int len, maxlen;
760:
761: if ( isInactive() ) return false;
762:
763: if ( (plane == gIODTPlane) && length )
764: {
765: maxlen = *length;
766:
767: for (next = (IOService *) this; next; next = next->getProvider())
768: {
769: *length = maxlen;
770: media = OSDynamicCast(IOMedia, next);
771:
772: if ( media && media->isWhole() == false && media->getLocation() )
773: partition = strtoul(media->getLocation(), 0, 10);
774: else if ( (number = (OSNumber *) next->getProperty("IOUnit")) )
775: unit = number->unsigned32BitValue();
776: else if( !media && next->getPath( path, length, plane ))
777: break;
778: }
779:
780: if (next && (unit != -1) && (partition != -1)) {
781: // add the @unit:partition
782: len = *length;
783: maxlen -= len;
784: success = (maxlen > 20);
785: if( success ) {
786: len += sprintf( path + len, "/@%x:%d", unit, partition );
787: *length = len;
788: }
789: }
790:
791: }
792: else
793: {
794: success = super::getPath(path, length, plane);
795: }
796:
797: return success;
798: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.