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