![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPEFLoader.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IONDRVSupport|
Return to IOPEFLoader.c CVS log | Up to [Apple XNU] / XNU / iokit / Families / IONDRVSupport |
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: * Copyright (c) 1997 Apple Computer, Inc.
24: *
25: *
26: * HISTORY
27: *
28: * From pieces of ProtoCFM, Alan Lillich.
29: *
30: * sdouglas 22 Oct 97 - first checked in.
31: * sdouglas 21 July 98 - start IOKit
32: */
33:
34:
35: #include <IOKit/IOLib.h>
36:
37: #include "IOPEFLibraries.h"
38: #include "IOPEFLoader.h"
39: #include "IOPEFInternals.h"
40:
41:
42:
43: #define LOG if(1) kprintf
44: #define INFO if(0) kprintf
45:
46: struct SectionVars {
47: LogicalAddress address;
48: ByteCount unpackedLength;
49: Boolean isPacked;
50: };
51: typedef struct SectionVars SectionVars;
52:
53: struct InstanceVars {
54: BytePtr pef; // container in memory
55: CFContHandlerRef cRef;
56: CFContHandlerProcs * cProcs;
57: ItemCount numSections;
58: SectionVars * sections;
59: };
60: typedef struct InstanceVars InstanceVars;
61:
62:
63: static OSStatus LocationToAddress( InstanceVars * inst,
64: CFContLogicalLocation * location, LogicalAddress * address );
65: static OSStatus SatisfyImports( InstanceVars * inst );
66: static OSStatus Instantiate( InstanceVars * inst );
67:
68:
69: #define PCFM_BlockCopy(src,dst,len) memcpy(dst,src,len)
70: #define PCFM_BlockClear(dst,len) memset(dst,0,len)
71: #define PCFM_MakeExecutable(addr,len) flush_dcache((vm_offset_t)addr, len, 0); \
72: invalidate_icache((vm_offset_t)addr, len, 0)
73:
74: extern OSStatus CallTVector(
75: void * p1, void * p2, void * p3, void * p4, void * p5, void * p6,
76: LogicalAddress entry );
77:
78: // �
79: // ===========================================================================================
80: // CFContHashName ()
81: // =================
82:
83:
84: CFContStringHash CFContHashName ( BytePtr nameText,
85: ByteCount nameLength )
86: {
87: BytePtr currChar = nameText;
88: SInt32 hashValue = 0; // ! Signed to match old published PEF algorithm.
89: ByteCount length = 0;
90: ByteCount limit;
91: CFContStringHash result;
92:
93: #define PseudoRotate(x) ( ( (x) << 1 ) - ( (x) >> (16) ) )
94:
95:
96: for ( limit = nameLength; limit > 0; limit -= 1 ) {
97: if ( *currChar == NULL ) break;
98: hashValue = (PseudoRotate ( hashValue )) ^ *currChar;
99: currChar += 1;
100: length += 1;
101: }
102:
103: result = (length << 16) | ((UInt16) ((hashValue ^ (hashValue >> 16)) & 0xFFFF));
104:
105: return result;
106:
107:
108: } // CFContHashName ()
109:
110:
111: // �
112: // ===========================================================================================
113: // PCFM_CompareBytes ()
114: // ====================
115:
116:
117: Boolean PCFM_CompareBytes ( const Byte * left,
118: const Byte * right,
119: ByteCount count )
120: {
121: // !!! Blechola! Switch to a standard routine ASAP!
122:
123: UInt32 * wLeft;
124: UInt32 * wRight;
125: UInt8 * bLeft;
126: UInt8 * bRight;
127:
128: ByteCount leftMiss = (UInt32)left & 0x00000003;
129: ByteCount rightMiss = (UInt32)right & 0x00000003;
130:
131:
132: bLeft = (UInt8 *) left;
133: bRight = (UInt8 *) right;
134:
135: if ( (leftMiss != 0) && (rightMiss != 0) ) {
136: ByteCount align = leftMiss;
137: if ( align > count ) align = count;
138: while ( align > 0 ) {
139: if ( *bLeft++ != *bRight++ ) goto NoMatch;
140: align -= 1;
141: count -= 1;
142: }
143: }
144:
145: wLeft = (UInt32 *) bLeft;
146: wRight = (UInt32 *) bRight;
147: while ( count >= 4 ) {
148: if ( *wLeft++ != *wRight++ ) goto NoMatch;
149: count -= 4;
150: }
151:
152: bLeft = (UInt8 *) wLeft;
153: bRight = (UInt8 *) wRight;
154: while ( count > 0 ) {
155: if ( *bLeft++ != *bRight++ ) goto NoMatch;
156: count -= 1;
157: }
158:
159: return true;
160:
161:
162: NoMatch:
163: return false;
164:
165:
166: } // PCFM_CompareBytes ()
167:
168: // ===========================================================================================
169:
170: LogicalAddress PCodeAllocateMem( ByteCount size );
171: void PCodeReleaseMem( LogicalAddress address );
172: extern void *kern_os_malloc(size_t size);
173: extern void kern_os_free(void * addr);
174:
175: LogicalAddress
176: PCodeAllocateMem( ByteCount size )
177: {
178: return( (LogicalAddress) kern_os_malloc( (size_t) size ));
179: }
180:
181: void
182: PCodeReleaseMem( LogicalAddress address )
183: {
184: kern_os_free( (void *) address );
185: }
186:
187: // ===========================================================================================
188:
189: OSStatus
190: PCodeOpen( LogicalAddress container, ByteCount containerSize, PCodeInstance * instance )
191: {
192: OSStatus err;
193: InstanceVars * inst;
194:
195: inst = PCodeAllocateMem( sizeof( InstanceVars));
196: *instance = inst;
197:
198: inst->pef = (BytePtr) container;
199: // procID, name, options
200: err = PEF_OpenContainer( container, container, containerSize, 0, 0, 0,
201: PCodeAllocateMem, PCodeReleaseMem,
202: &inst->cRef, &inst->cProcs );
203: if( err) LOG( "PEF_OpenContainer = %d\n", err );
204:
205: return( err);
206: }
207:
208:
209: OSStatus
210: PCodeInstantiate( PCodeInstance instance )
211: {
212: OSStatus err;
213: InstanceVars * inst = instance;
214: CFContLogicalLocation initLocation;
215: LogicalAddress tv;
216: CFragInitBlock initInfo;
217:
218: do {
219: err = Instantiate( inst );
220: if( err)
221: continue;
222:
223: // call INIT
224: err = PEF_GetAnonymousSymbolLocations( inst->cRef, NULL, &initLocation, NULL );
225: if( err)
226: continue;
227: err = LocationToAddress( inst, &initLocation, &tv );
228: if( err || (tv == NULL) )
229: continue;
230: bzero( &initInfo, sizeof( initInfo));
231: err = CallTVector( &initInfo, 0, 0, 0, 0, 0, tv );
232:
233: } while( false);
234:
235: return( err);
236: }
237:
238:
239: OSStatus
240: PCodeClose( PCodeInstance instance )
241: {
242: OSStatus err;
243: InstanceVars * inst = instance;
244:
245: err = PEF_CloseContainer( inst->cRef, 0 );
246: if( err) LOG( "PEF_CloseContainer = %d\n", err );
247:
248: return( err);
249: }
250:
251: OSStatus
252: PCodeFindExport( PCodeInstance instance, const char * symbolName, LogicalAddress * address, CFragSymbolClass * symbolClass )
253: {
254: CFContExportedSymbolInfo symInfo;
255: CFContHashedName hashName;
256: OSStatus err;
257: InstanceVars * inst = instance;
258:
259: hashName.nameHash = CFContHashName( (UInt8 *) symbolName, strlen( symbolName) );
260: hashName.nameText = (UInt8 *) symbolName;
261:
262: err = PEF_FindExportedSymbolInfo( inst->cRef, &hashName,
263: kCFContExportedSymbolInfoVersion, (void *) 0, &symInfo );
264: if( err) {
265: LOG( "PEF_FindExportedSymbolInfo = %d\n", err );
266: return( err);
267: }
268:
269: if( address);
270: err = LocationToAddress( inst, &symInfo.location, address );
271: if( symbolClass)
272: *symbolClass = symInfo.symbolClass;
273:
274: return( err);
275: }
276:
277: OSStatus
278: PCodeFindMain( PCodeInstance instance, LogicalAddress * mainAddress )
279: {
280: InstanceVars * inst = instance;
281: CFContLogicalLocation mainLocation;
282: OSStatus err;
283:
284: err = PEF_GetAnonymousSymbolLocations( inst->cRef, &mainLocation, NULL, NULL );
285:
286: if( err == noErr)
287: err = LocationToAddress( inst, &mainLocation, mainAddress );
288:
289: return( err);
290: }
291:
292:
293:
294: // ===========================================================================================
295:
296: static OSStatus
297: LocationToAddress( InstanceVars * inst, CFContLogicalLocation * location,
298: LogicalAddress * address )
299: {
300: BytePtr sectionBase;
301: OSStatus err = noErr;
302:
303: if ( location->section >= 0 ) {
304: sectionBase = (BytePtr) (inst->sections + location->section)->address;
305: *address = (LogicalAddress) (sectionBase + location->offset);
306:
307: } else if ( location->section == kCFContAbsoluteSectionIndex ) {
308: *address = (LogicalAddress) location->offset;
309:
310: } else if ( location->section == kCFContNoSectionIndex ) {
311: *address = (LogicalAddress) kUnresolvedCFragSymbolAddress;
312:
313: } else
314: err = cfragFragmentFormatErr;
315:
316: return( err);
317: }
318:
319:
320: static OSStatus
321: Instantiate( InstanceVars * inst )
322: {
323: CFContHandlerRef cRef;
324: ItemCount numSects, sectionIndex;
325: CFContSectionInfo sectionInfo;
326: CFContSectionInfo * section;
327: OSStatus err;
328:
329: cRef = inst->cRef;
330:
331: err = PEF_GetSectionCount( cRef, &numSects );
332: if( err) LOG( "PEF_GetSectionCount = %d\n", err );
333: INFO( "Num sects = %d\n", numSects );
334:
335: inst->numSections = numSects;
336: inst->sections = PCodeAllocateMem( numSects * sizeof( SectionVars ));
337:
338: for( sectionIndex = 0; sectionIndex < numSects; sectionIndex++ )
339: {
340: Boolean isPacked, isMappable;
341: Boolean needAlloc, needCopy, needClear;
342: LogicalAddress sectionAddress;
343: SectionVars * sectionVars;
344:
345: sectionVars = inst->sections + sectionIndex;
346: section = §ionInfo;
347:
348: err = PEF_GetSectionInfo( cRef, sectionIndex, kCFContSectionInfoVersion, section );
349: if( err) LOG( "PEF_GetSectionInfo = %d\n", err );
350:
351: #if 0
352: if ( sectionInfo.sharing == kCFContShareSectionInClosure ) goto SectionSharingError;
353: if ( (! (sectionInfo.access & kCFContMemWriteMask)) &&
354: (sectionInfo.options & kRelocatedCFContSectionMask) ) goto SectionOptionsError;
355: #endif
356:
357: isPacked = ((section->options & kPackedCFContSectionMask) != 0);
358: isMappable = (! isPacked) &&
359: (! (section->options & kRelocatedCFContSectionMask)) &&
360: (! (section->access & kCFContMemWriteMask));
361:
362: if ( ! isMappable ) {
363: // ----------------------------------------------------------------------------------
364: // Mappable really means "fully expanded in container", so sections that are not mappable
365: // need to be allocated. The loader will do the initialization copying. This is the
366: // standard case for packed PEF data sections.
367: needAlloc = true;
368: needCopy = (! isPacked);
369: needClear = (section->totalLength != section->unpackedLength);
370:
371: } else if ( ! (section->access & kCFContMemWriteMask) ) {
372: // -----------------------------------------------------------------------------------
373: // A "mappable" read only section. Make sure it is fully present, i.e. no zero filled
374: // extension. This is the standard case for code and literal sections.
375: if ( section->totalLength != section->unpackedLength ) {
376: err = cfragFragmentUsageErr; // !!! Needs error label & message.
377: // goto ERROR;
378: }
379: needAlloc = false;
380: needCopy = false;
381: needClear = false;
382:
383: } else {
384: // -----------------------------------------------------------------------------------
385: // A "mappable", writeable, don't use in place section. This is the standard case for
386: // unpacked data sections.
387: needAlloc = true;
388: needCopy = true;
389: needClear = (section->totalLength != section->unpackedLength);
390: }
391:
392: if ( needAlloc ) {
393: // *** Should honor the container's alignment specifications.
394: sectionAddress = PCodeAllocateMem( section->totalLength ); //, 4, allocMode );
395: } else {
396: sectionAddress = inst->pef + section->containerOffset;
397: }
398:
399: // --------------------------------------------------------------------------------------
400: // !!! The copy/clear code should be moved to the loader as part of the split of the
401: // !!! unpack/relocate operations. It isn't clear at this point if both the read and
402: // !!! write sides should be touched. What if the write side pushes out pages brought in
403: // !!! by the read side? We should also have better advice to say all bytes are changed.
404:
405: if ( needCopy ) {
406: BytePtr source = inst->pef + section->containerOffset;
407: BytePtr dest = sectionAddress;
408: ByteCount length = section->unpackedLength;
409:
410: PCFM_BlockCopy ( source, dest, length );
411: }
412:
413: if ( needClear ) {
414: BytePtr dest = (BytePtr) sectionAddress + section->unpackedLength;
415: ByteCount length = section->totalLength - section->unpackedLength;
416:
417: PCFM_BlockClear ( dest, length );
418: }
419:
420: // -------------------------------------------------------------------------------------
421: // If CFM was responsible for bringing the container into memory then we have to get the
422: // I&D caches in sync for the (read-only & use-in-place) code sections.
423:
424: if ( (section->access & kCFContMemExecuteMask) && (! (section->access & kCFContMemWriteMask)) && isMappable ) {
425: PCFM_MakeExecutable ( sectionAddress, section->unpackedLength );
426: }
427:
428: err = PEF_SetSectionAddress( cRef, sectionIndex, sectionAddress, sectionAddress );
429: if( err) LOG( "PEF_SetSectionAddress = %d\n", err );
430:
431: sectionVars->address = sectionAddress;
432: sectionVars->unpackedLength = section->unpackedLength;
433: sectionVars->isPacked = isPacked;
434: }
435:
436: // -------------------------------------------------------------------------------------
437:
438: err = SatisfyImports( inst );
439: if( err) LOG( "SatisfyImports = %d\n", err );
440:
441: // -------------------------------------------------------------------------------------
442:
443: for( sectionIndex = 0; sectionIndex < numSects; sectionIndex++ )
444: {
445: SectionVars * sectionVars;
446:
447: sectionVars = inst->sections + sectionIndex;
448:
449: INFO("Section[%d] ", sectionIndex );
450:
451: if ( sectionVars->isPacked ) {
452: INFO("unpacking...");
453: err = PEF_UnpackSection( cRef,
454: sectionIndex,
455: 0, // Unpack the whole section.
456: sectionVars->address,
457: sectionVars->unpackedLength );
458: if( err) LOG( "PEF_UnpackSection = %d\n", err );
459: }
460:
461: INFO("reloc...");
462: err = PEF_RelocateSection( cRef, sectionIndex );
463:
464: INFO(" address = 0x%08x\n", sectionVars->address );
465: }
466:
467: if( err) LOG( "Instantiate = %d\n", err );
468:
469: return( err);
470: }
471:
472: struct StubFunction {
473: LogicalAddress pc;
474: LogicalAddress toc;
475: char name[64];
476: };
477: typedef struct StubFunction StubFunction;
478:
479: OSStatus IONDRVUnimplementedVector( UInt32 p1, UInt32 p2, UInt32 p3, UInt32 p4 )
480: {
481: char * name = (char *) get_R2();
482:
483: LOG("-*- %s : %x, %x, %x\n", name, p1, p2, p3, p4);
484:
485: set_R2( (UInt32) name);
486:
487: return( -53);
488: }
489:
490: static OSStatus
491: SatisfyImports( InstanceVars * inst )
492: {
493: CFContImportedSymbolInfo symInfo;
494:
495: OSStatus err = 0;
496: CFContHandlerRef cRef;
497: ItemCount numLibs, numSyms, index, i;
498: struct CFLibInfo {
499: CFContImportedLibraryInfo info;
500: LibraryEntry * found;
501: };
502: struct CFLibInfo * libInfo;
503: struct CFLibInfo * curLib;
504: FunctionEntry * funcs;
505: TVector * symAddr;
506: StubFunction * stub;
507:
508: cRef = inst->cRef;
509: err = PEF_GetImportCounts( cRef, &numLibs, &numSyms );
510: if( err) LOG( "PEF_GetImportCounts = %d\n", err );
511:
512: libInfo = PCodeAllocateMem( numLibs * sizeof( struct CFLibInfo));
513: PCFM_BlockClear( libInfo, numLibs * sizeof( struct CFLibInfo));
514:
515: for( index = 0; index < numLibs; index++ )
516: {
517: curLib = libInfo + index;
518: err = PEF_GetImportedLibraryInfo( cRef, index, kCFContImportedLibraryInfoVersion, &curLib->info);
519: if( err) LOG( "PEF_GetImportCounts = %d\n", err );
520:
521: for( i = 0; i < IONumNDRVLibraries; i++ ) {
522: if( strcmp( (char *) curLib->info.libraryName.nameText,
523: IONDRVLibraries[ i ].name) == 0) {
524: curLib->found = &IONDRVLibraries[ i ];
525: break;
526: }
527: }
528: }
529:
530: for( index = 0; index < numSyms; index++ )
531: {
532: err = PEF_GetImportedSymbolInfo( cRef, index, kCFContImportedSymbolInfoVersion, &symInfo );
533: if( err) LOG( "PEF_GetImportedSymbolInfo = %d\n", err );
534:
535: curLib = libInfo + symInfo.libraryIndex;
536:
537: symAddr = NULL;
538: if( curLib->found) {
539: for( i = 0; i < curLib->found->numSyms; i++ ) {
540:
541: funcs = curLib->found->functions + i;
542: if( strcmp( (char *) symInfo.symbolName.nameText, funcs->name ) == 0) {
543: symAddr = (TVector *) &funcs->address;
544: break;
545: }
546: }
547: }
548:
549: if( symAddr == NULL) {
550:
551: LOG("Undefined %s:%s ", curLib->info.libraryName.nameText, symInfo.symbolName.nameText );
552:
553: stub = IOMalloc( sizeof( StubFunction));
554: symAddr = (TVector *) &stub->pc;
555: stub->pc = IONDRVUnimplementedVector;
556: stub->toc = &stub->name[0];
557: strncpy( stub->name, symInfo.symbolName.nameText, 60);
558: }
559:
560: err = PEF_SetImportedSymbolAddress( cRef, index, symAddr );
561: if( err) LOG( "PEF_SetImportedSymbolAddress = %d\n", err );
562: }
563:
564: PCodeReleaseMem( libInfo);
565:
566: return( err);
567: }
568:
569:
570:
571:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.