Chameleon

Chameleon Svn Source Tree

Root/branches/azimutz/Chazi/i386/boot2/drivers.c

1/*␊
2 * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * Portions Copyright (c) 1999-2003 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 2.0 (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 * drivers.c - Driver Loading Functions.␊
26 *␊
27 * Copyright (c) 2000 Apple Computer, Inc.␊
28 *␊
29 * DRI: Josh de Cesare␊
30 */␊
31␊
32#include <mach-o/fat.h>␊
33#include <libkern/OSByteOrder.h>␊
34#include <mach/machine.h>␊
35␊
36//#include "bootstruct.h"␊
37//#include "ramdisk.h"␊
38#include "boot.h"␊
39#include "sl.h"␊
40#include "xml.h"␊
41#include "modules.h"␊
42␊
43struct Module { ␊
44 struct Module *nextModule;␊
45 long willLoad;␊
46 TagPtr dict;␊
47 char *plistAddr;␊
48 long plistLength;␊
49 char *executablePath;␊
50 char *bundlePath;␊
51 long bundlePathLength;␊
52};␊
53typedef struct Module Module, *ModulePtr;␊
54␊
55struct DriverInfo {␊
56 char *plistAddr;␊
57 long plistLength;␊
58 void *executableAddr;␊
59 long executableLength;␊
60 void *bundlePathAddr;␊
61 long bundlePathLength;␊
62};␊
63typedef struct DriverInfo DriverInfo, *DriverInfoPtr;␊
64␊
65#define kDriverPackageSignature1 'MKXT'␊
66#define kDriverPackageSignature2 'MOSX'␊
67␊
68struct DriversPackage {␊
69 unsigned long signature1;␊
70 unsigned long signature2;␊
71 unsigned long length;␊
72 unsigned long alder32;␊
73 unsigned long version;␊
74 unsigned long numDrivers;␊
75 unsigned long reserved1;␊
76 unsigned long reserved2;␊
77};␊
78typedef struct DriversPackage DriversPackage;␊
79␊
80enum {␊
81 kCFBundleType2,␊
82 kCFBundleType3␊
83};␊
84␊
85long (*LoadExtraDrivers_p)(FileLoadDrivers_t FileLoadDrivers_p);␊
86␊
87static unsigned long Alder32( unsigned char * buffer, long length );␊
88␊
89static long FileLoadDrivers(char *dirSpec, long plugin);␊
90static long NetLoadDrivers(char *dirSpec);␊
91static long LoadDriverMKext(char *fileSpec);␊
92static long LoadDriverPList(char *dirSpec, char *name, long bundleType);␊
93static long LoadMatchedModules(void);␊
94static long MatchPersonalities(void);␊
95static long MatchLibraries(void);␊
96#ifdef NOTDEF␊
97static ModulePtr FindModule(char *name);␊
98static void ThinFatFile(void **loadAddrP, unsigned long *lengthP);␊
99#endif␊
100static long ParseXML(char *buffer, ModulePtr *module, TagPtr *personalities);␊
101static long InitDriverSupport(void);␊
102␊
103static ModulePtr gModuleHead, gModuleTail;␊
104static TagPtr gPersonalityHead, gPersonalityTail;␊
105static char * gExtensionsSpec;␊
106static char * gDriverSpec;␊
107static char * gFileSpec;␊
108static char * gTempSpec;␊
109static char * gFileName;␊
110␊
111static unsigned long␊
112Alder32( unsigned char * buffer, long length )␊
113{␊
114 long cnt;␊
115 unsigned long result, lowHalf, highHalf;␊
116 ␊
117 lowHalf = 1;␊
118 highHalf = 0;␊
119 ␊
120␉for ( cnt = 0; cnt < length; cnt++ )␊
121 {␊
122 if ((cnt % 5000) == 0)␊
123 {␊
124 lowHalf %= 65521L;␊
125 highHalf %= 65521L;␊
126 }␊
127 ␊
128 lowHalf += buffer[cnt];␊
129 highHalf += lowHalf;␊
130 }␊
131␊
132␉lowHalf %= 65521L;␊
133␉highHalf %= 65521L;␊
134 ␊
135␉result = (highHalf << 16) | lowHalf;␊
136 ␊
137␉return result;␊
138}␊
139␊
140␊
141//==========================================================================␊
142// InitDriverSupport␊
143␊
144static long␊
145InitDriverSupport( void )␊
146{␊
147 gExtensionsSpec = malloc( 4096 );␊
148 gDriverSpec = malloc( 4096 );␊
149 gFileSpec = malloc( 4096 );␊
150 gTempSpec = malloc( 4096 );␊
151 gFileName = malloc( 4096 );␊
152␊
153 if ( !gExtensionsSpec || !gDriverSpec || !gFileSpec || !gTempSpec || !gFileName )␊
154 stop("InitDriverSupport error");␊
155␊
156 return 0;␊
157}␊
158␊
159//==========================================================================␊
160// LoadDrivers␊
161␊
162long LoadDrivers( char * dirSpec )␊
163{␊
164␉char␉␉dirSpecExtra[128];␊
165␉const char *override_pathfolder = NULL; // full path to a folder.␊
166␉int␉␉␉fd = 0, len = 0;␊
167␉␊
168␉if ( InitDriverSupport() != 0 )␊
169␉␉return 0;␊
170␉␊
171␉// Load extra drivers if a hook has been installed.␊
172␉if (LoadExtraDrivers_p != NULL)␊
173␉{␊
174␉␉(*LoadExtraDrivers_p)(&FileLoadDrivers);␊
175␉}␊
176␉␊
177␉if ( gBootFileType == kNetworkDeviceType )␊
178␉{␊
179␉␉if (NetLoadDrivers(dirSpec) != 0)␊
180␉␉{␊
181␉␉␉error("Could not load drivers from the network\n");␊
182␉␉␉return -1;␊
183␉␉}␊
184␉}␊
185␉else if ( gBootFileType == kBlockDeviceType )␊
186␉{␊
187␉␉// Take in account user overriding. - does this still work ???␊
188␉␉if (getValueForKey(kAltExtensionsKey, &override_pathfolder, &len, &bootInfo->bootConfig))␊
189␉␉{␊
190␉␉␉// Specify a path to a folder, ending with / e.g. kext=/Extra/testkext/␊
191␉␉␉strcpy(dirSpecExtra, override_pathfolder);␊
192␉␉␉fd = FileLoadDrivers(dirSpecExtra, 0);␊
193␉␉␉if (fd >= 0) goto success_fd;␊
194␉␉}␊
195␉␉␊
196␉␉// No need to specify (gRAMDiskVolume && !gRAMDiskBTAliased).␊
197␉␉// First try to load Extra extensions from a ramdisk if isn't aliased as bt(0,0).␊
198␉␉strcpy(dirSpecExtra, "rd(0,0)/"); // check it's "root".␊
199␉␉fd = FileLoadDrivers(dirSpecExtra, 0);␊
200␉␉if (fd >= 0) goto success_fd;␊
201␉␉␊
202␉␉// Also no need to specify (gRAMDiskVolume && gRAMDiskBTAliased); checking paths on a␊
203␉␉// ramdisk aliased as bt(0,0) (rdbt), is the same as checking paths on booter volume. ␊
204␉␉// In this case the following two will point to the ramdisk.␊
205␉␉␊
206␉␉// Check booter volume/rdbt Extra for specific OS files, on specific OS folders.␊
207␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/%s/", &gMacOSVersion);␊
208␉␉fd = FileLoadDrivers(dirSpecExtra, 0);␊
209␉␉if (fd >= 0) goto success_fd;␊
210␉␉␊
211␉␉// Removed /Extra path from search algo. If needed can be specified with override key!␊
212␉␉␊
213␉␉// Check booter volume/rdbt Extra in case we don't keep specific OS folders.␊
214␉␉strcpy(dirSpecExtra, "bt(0,0)/Extra/");␊
215␉␉fd = FileLoadDrivers(dirSpecExtra, 0);␊
216␉␉if (fd >= 0) goto success_fd;␊
217␉␉␊
218␉␉// Also try to load Extensions from boot helper partitions.␊
219␉␉if (gBootVolume->flags & kBVFlagBooter)␊
220␉␉{␊
221␉␉␉strcpy(dirSpecExtra, "/com.apple.boot.P/System/Library/");␊
222␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
223␉␉␉{␊
224␉␉␉␉strcpy(dirSpecExtra, "/com.apple.boot.R/System/Library/");␊
225␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
226␉␉␉␉{␊
227␉␉␉␉␉strcpy(dirSpecExtra, "/com.apple.boot.S/System/Library/");␊
228␉␉␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
229␉␉␉␉}␊
230␉␉␉}␊
231␉␉}␊
232␉␉␊
233success_fd:␊
234␉␉// if user initialized gMKextName ("MKext Cache" flag)...␊
235␉␉if (gMKextName[0] != '\0')␊
236␉␉{␊
237␉␉␉verbose("LoadDrivers: Loading from [%s]\n", gMKextName);␊
238␉␉␉if ( LoadDriverMKext(gMKextName) != 0 )␊
239␉␉␉{␊
240␉␉␉␉error("Could not load %s\n", gMKextName);␊
241␉␉␉␉return -1;␊
242␉␉␉}␊
243␉␉}␊
244␉␉else // else load kext cache from default paths.␊
245␉␉{␊
246␉␉␉strcpy(gExtensionsSpec, dirSpec); // = "/"␊
247␉␉␉strcat(gExtensionsSpec, "System/Library/"); // "/" + "System/Library/"␊
248␉␉␉FileLoadDrivers(gExtensionsSpec, 0); // "/System/Library/" - legacy path␊
249␉␉}␊
250␉}␊
251␉else␊
252␉{␊
253␉␉return 0;␊
254␉}␊
255␉␊
256␉MatchPersonalities();␊
257␉␊
258␉MatchLibraries();␊
259␉␊
260␉LoadMatchedModules();␊
261␉␊
262␉return 0;␊
263}␊
264␊
265//==========================================================================␊
266// FileLoadMKext␊
267␊
268static long␊
269FileLoadMKext( const char * dirSpec, const char * extDirSpec )␊
270{␊
271␉long␉ret, flags, time, time2;␊
272␉char␉altDirSpec[512];␊
273␉␊
274␉sprintf (altDirSpec, "%s%s", dirSpec, extDirSpec);␊
275␉ret = GetFileInfo(altDirSpec, "Extensions.mkext", &flags, &time);␊
276␉msglog("(%s) Extensions.mkext time = %d\n", __FUNCTION__, time);␊
277␉␊
278␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeFlat))␊
279␉{␊
280␉␉ret = GetFileInfo(dirSpec, "Extensions", &flags, &time2);␊
281␉␉//Azi: hum... finaly got it :P␊
282␉␉verbose("(%s) Extensions time +1 = %d\n", __FUNCTION__, time2 + 1);␊
283␉␉␊
284␉␉if ((ret != 0)␊
285␉␉␉|| ((flags & kFileTypeMask) != kFileTypeDirectory)␊
286␉␉␉|| (((gBootMode & kBootModeSafe) == 0) && (time == (time2 + 1))))␊
287␉␉{␊
288␉␉␉sprintf(gDriverSpec, "%sExtensions.mkext", altDirSpec);␊
289␉␉␉//Azi: hum... finaly got it :P␊
290␉␉␉msglog("LoadDrivers: Loading from [%s]\n", gDriverSpec);␊
291␉␉␉␊
292␉␉␉if (LoadDriverMKext(gDriverSpec) == 0)␊
293␉␉␉␉return 0;␊
294␉␉}␊
295␉}␊
296␉return -1;␊
297}␊
298␊
299//==========================================================================␊
300// FileLoadDrivers␊
301␊
302static long␊
303FileLoadDrivers( char * dirSpec, long plugin )␊
304{␊
305 long ret, length, flags, time, bundleType;␊
306 long long␉ index;␊
307 long result = -1;␊
308 const char * name;␊
309 ␊
310 if ( !plugin )␊
311 {␊
312 // First try 10.6's path for loading Extensions.mkext.␊
313 if (FileLoadMKext(dirSpec, "Caches/com.apple.kext.caches/Startup/") == 0)␊
314␉␉␉return 0; // "bt(0,0)/Extra/10.6/"␊
315␊
316 // Next try the legacy path.␊
317 else if (FileLoadMKext(dirSpec, "") == 0)␊
318 return 0;␊
319␊
320 strcat(dirSpec, "Extensions");␊
321 }␊
322␊
323 index = 0;␊
324 while (1) {␊
325␉␉␊
326 ret = GetDirEntry(dirSpec, &index, &name, &flags, &time);␊
327 if (ret == -1) break;␊
328␊
329 // Make sure this is a directory.␊
330 if ((flags & kFileTypeMask) != kFileTypeDirectory) continue;␊
331 ␊
332 // Make sure this is a kext.␊
333 length = strlen(name);␊
334 if (strcmp(name + length - 5, ".kext")) continue;␊
335␊
336 // Save the file name.␊
337 strcpy(gFileName, name);␊
338 ␊
339 // Determine the bundle type.␊
340 sprintf(gTempSpec, "%s/%s", dirSpec, gFileName);␊
341 ret = GetFileInfo(gTempSpec, "Contents", &flags, &time);␊
342 if (ret == 0) bundleType = kCFBundleType2;␊
343 else bundleType = kCFBundleType3;␊
344␊
345 if (!plugin)␊
346 sprintf(gDriverSpec, "%s/%s/%sPlugIns", dirSpec, gFileName,␊
347 (bundleType == kCFBundleType2) ? "Contents/" : "");␊
348␊
349 ret = LoadDriverPList(dirSpec, gFileName, bundleType);␊
350␊
351 if (result != 0)␊
352 result = ret;␊
353␊
354 if (!plugin) ␊
355 FileLoadDrivers(gDriverSpec, 1);␊
356 }␊
357␊
358 return result;␊
359}␊
360␊
361//==========================================================================␊
362// ␊
363␊
364static long␊
365NetLoadDrivers( char * dirSpec )␊
366{␊
367 long tries;␊
368␊
369#if NODEF␊
370 long cnt;␊
371␊
372 // Get the name of the kernel␊
373 cnt = strlen(gBootFile);␊
374 while (cnt--) {␊
375 if ((gBootFile[cnt] == '\\') || (gBootFile[cnt] == ',')) {␊
376 cnt++;␊
377 break;␊
378 }␊
379 }␊
380#endif␊
381␊
382 // INTEL modification␊
383 sprintf(gDriverSpec, "%s%s.mkext", dirSpec, bootInfo->bootFile);␊
384 ␊
385 verbose("NetLoadDrivers: Loading from [%s]\n", gDriverSpec);␊
386 ␊
387 tries = 3;␊
388 while (tries--)␊
389 {␊
390 if (LoadDriverMKext(gDriverSpec) == 0) break;␊
391 }␊
392 if (tries == -1) return -1;␊
393␊
394 return 0;␊
395}␊
396␊
397//==========================================================================␊
398// loadDriverMKext␊
399␊
400static long␊
401LoadDriverMKext( char * fileSpec )␊
402{␊
403 unsigned long driversAddr, driversLength;␊
404 long length;␊
405 char segName[32];␊
406 DriversPackage * package;␊
407␊
408#define GetPackageElement(e) OSSwapBigToHostInt32(package->e)␊
409␊
410 // Load the MKext.␊
411 length = LoadThinFatFile(fileSpec, (void **)&package);␊
412 if (length < sizeof (DriversPackage)) return -1;␊
413␊
414␉// call hook to notify modules that the mkext has been loaded␊
415␉execute_hook("LoadDriverMKext", (void*)fileSpec, (void*)package, (void*) &length, NULL);␊
416␊
417␉␊
418 // Verify the MKext.␊
419 if (( GetPackageElement(signature1) != kDriverPackageSignature1) ||␊
420 ( GetPackageElement(signature2) != kDriverPackageSignature2) ||␊
421 ( GetPackageElement(length) > kLoadSize ) ||␊
422 ( GetPackageElement(alder32) !=␊
423 Alder32((unsigned char *)&package->version, GetPackageElement(length) - 0x10) ) )␊
424 {␊
425 return -1;␊
426 }␊
427␊
428 // Make space for the MKext.␊
429 driversLength = GetPackageElement(length);␊
430 driversAddr = AllocateKernelMemory(driversLength);␊
431␊
432 // Copy the MKext.␊
433 memcpy((void *)driversAddr, (void *)package, driversLength);␊
434␊
435 // Add the MKext to the memory map.␊
436 sprintf(segName, "DriversPackage-%lx", driversAddr);␊
437 AllocateMemoryRange(segName, driversAddr, driversLength,␊
438 kBootDriverTypeMKEXT);␊
439␊
440 return 0;␊
441}␊
442␊
443//==========================================================================␊
444// LoadDriverPList␊
445␊
446static long␊
447LoadDriverPList( char * dirSpec, char * name, long bundleType )␊
448{␊
449 long length, executablePathLength, bundlePathLength;␊
450 ModulePtr module;␊
451 TagPtr personalities;␊
452 char * buffer = 0;␊
453 char * tmpExecutablePath = 0;␊
454 char * tmpBundlePath = 0;␊
455 long ret = -1;␊
456␊
457 do {␊
458 // Save the driver path.␊
459 ␊
460 sprintf(gFileSpec, "%s/%s/%s", dirSpec, name,␊
461 (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
462 executablePathLength = strlen(gFileSpec) + 1;␊
463␊
464 tmpExecutablePath = malloc(executablePathLength);␊
465 if (tmpExecutablePath == 0) break;␊
466␊
467 strcpy(tmpExecutablePath, gFileSpec);␊
468 ␊
469 sprintf(gFileSpec, "%s/%s", dirSpec, name);␊
470 bundlePathLength = strlen(gFileSpec) + 1;␊
471␊
472 tmpBundlePath = malloc(bundlePathLength);␊
473 if (tmpBundlePath == 0) break;␊
474␊
475 strcpy(tmpBundlePath, gFileSpec);␊
476␊
477 // Construct the file spec to the plist, then load it.␊
478␊
479 sprintf(gFileSpec, "%s/%s/%sInfo.plist", dirSpec, name,␊
480 (bundleType == kCFBundleType2) ? "Contents/" : "");␊
481␊
482 length = LoadFile(gFileSpec);␊
483 if (length == -1) break;␊
484␊
485 length = length + 1;␊
486 buffer = malloc(length);␊
487 if (buffer == 0) break;␊
488␊
489 strlcpy(buffer, (char *)kLoadAddr, length);␊
490␊
491 // Parse the plist.␊
492␊
493 ret = ParseXML(buffer, &module, &personalities);␊
494 if (ret != 0) { break; }␊
495␊
496 // Allocate memory for the driver path and the plist.␊
497␊
498 module->executablePath = tmpExecutablePath;␊
499 module->bundlePath = tmpBundlePath;␊
500 module->bundlePathLength = bundlePathLength;␊
501 module->plistAddr = malloc(length);␊
502 ␊
503 if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0))␊
504 break;␊
505␊
506 // Save the driver path in the module.␊
507 //strcpy(module->driverPath, tmpDriverPath);␊
508 tmpExecutablePath = 0;␊
509 tmpBundlePath = 0;␊
510␊
511 // Add the plist to the module.␊
512␊
513 strlcpy(module->plistAddr, (char *)kLoadAddr, length);␊
514 module->plistLength = length;␊
515 ␊
516 // Add the module to the end of the module list.␊
517 ␊
518 if (gModuleHead == 0)␊
519 gModuleHead = module;␊
520 else␊
521 gModuleTail->nextModule = module;␊
522 gModuleTail = module;␊
523 ␊
524 // Add the persionalities to the personality list.␊
525 ␊
526 if (personalities) personalities = personalities->tag;␊
527 while (personalities != 0)␊
528 {␊
529 if (gPersonalityHead == 0)␊
530 gPersonalityHead = personalities->tag;␊
531 else␊
532 gPersonalityTail->tagNext = personalities->tag;␊
533 ␊
534 gPersonalityTail = personalities->tag;␊
535 personalities = personalities->tagNext;␊
536 }␊
537 ␊
538 ret = 0;␊
539 }␊
540 while (0);␊
541 ␊
542 if ( buffer ) free( buffer );␊
543 if ( tmpExecutablePath ) free( tmpExecutablePath );␊
544 if ( tmpBundlePath ) free( tmpBundlePath );␊
545␊
546 return ret;␊
547}␊
548␊
549␊
550//==========================================================================␊
551// LoadMatchedModules␊
552␊
553static long␊
554LoadMatchedModules( void )␊
555{␊
556 TagPtr prop;␊
557 ModulePtr module;␊
558 char *fileName, segName[32];␊
559 DriverInfoPtr driver;␊
560 long length, driverAddr, driverLength;␊
561 void *executableAddr = 0;␊
562␊
563 ␊
564 module = gModuleHead;␊
565␊
566 while (module != 0)␊
567 {␊
568 if (module->willLoad)␊
569 {␊
570 prop = XMLGetProperty(module->dict, kPropCFBundleExecutable);␊
571␊
572 if (prop != 0)␊
573 {␊
574 fileName = prop->string;␊
575 sprintf(gFileSpec, "%s%s", module->executablePath, fileName);␊
576 length = LoadThinFatFile(gFileSpec, &executableAddr);␊
577␉␉␉␉if (length == 0)␊
578␉␉␉␉{␊
579␉␉␉␉␉length = LoadFile(gFileSpec);␊
580␉␉␉␉␉executableAddr = (void *)kLoadAddr;␊
581␉␉␉␉}␊
582 //printf("%s length = %d addr = 0x%x\n", gFileSpec, length, driverModuleAddr); getc();␊
583 }␊
584 else␊
585 length = 0;␊
586␊
587 if (length != -1)␊
588 {␊
589␉␉//driverModuleAddr = (void *)kLoadAddr;␊
590 //if (length != 0)␊
591 //{␊
592␉␉// ThinFatFile(&driverModuleAddr, &length);␊
593␉␉//}␊
594␊
595 // Make make in the image area.␊
596 driverLength = sizeof(DriverInfo) + module->plistLength + length + module->bundlePathLength;␊
597 driverAddr = AllocateKernelMemory(driverLength);␊
598␊
599 // Set up the DriverInfo.␊
600 driver = (DriverInfoPtr)driverAddr;␊
601 driver->plistAddr = (char *)(driverAddr + sizeof(DriverInfo));␊
602 driver->plistLength = module->plistLength;␊
603 if (length != 0)␊
604 {␊
605 driver->executableAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
606␉␉␉␉␉ module->plistLength);␊
607 driver->executableLength = length;␊
608 }␊
609 else␊
610 {␊
611 driver->executableAddr = 0;␊
612 driver->executableLength = 0;␊
613 }␊
614 driver->bundlePathAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
615␉␉␉␉ module->plistLength + driver->executableLength);␊
616 driver->bundlePathLength = module->bundlePathLength;␊
617␊
618 // Save the plist, module and bundle.␊
619 strcpy(driver->plistAddr, module->plistAddr);␊
620 if (length != 0)␊
621 {␊
622 memcpy(driver->executableAddr, executableAddr, length);␊
623 }␊
624 strcpy(driver->bundlePathAddr, module->bundlePath);␊
625␊
626 // Add an entry to the memory map.␊
627 sprintf(segName, "Driver-%lx", (unsigned long)driver);␊
628 AllocateMemoryRange(segName, driverAddr, driverLength,␊
629 kBootDriverTypeKEXT);␊
630 }␊
631 }␊
632 module = module->nextModule;␊
633 }␊
634␊
635 return 0;␊
636}␊
637␊
638//==========================================================================␊
639// MatchPersonalities␊
640␊
641static long␊
642MatchPersonalities( void )␊
643{␊
644 /* IONameMatch support not implemented */␊
645 return 0;␊
646}␊
647␊
648//==========================================================================␊
649// MatchLibraries␊
650␊
651static long␊
652MatchLibraries( void )␊
653{␊
654 TagPtr prop, prop2;␊
655 ModulePtr module, module2;␊
656 long done;␊
657␊
658 do {␊
659 done = 1;␊
660 module = gModuleHead;␊
661 ␊
662 while (module != 0)␊
663 {␊
664 if (module->willLoad == 1)␊
665 {␊
666 prop = XMLGetProperty(module->dict, kPropOSBundleLibraries);␊
667 if (prop != 0)␊
668 {␊
669 prop = prop->tag;␊
670 while (prop != 0)␊
671 {␊
672 module2 = gModuleHead;␊
673 while (module2 != 0)␊
674 {␊
675 prop2 = XMLGetProperty(module2->dict, kPropCFBundleIdentifier);␊
676 if ((prop2 != 0) && (!strcmp(prop->string, prop2->string)))␊
677 {␊
678 if (module2->willLoad == 0) module2->willLoad = 1;␊
679 break;␊
680 }␊
681 module2 = module2->nextModule;␊
682 }␊
683 prop = prop->tagNext;␊
684 }␊
685 }␊
686 module->willLoad = 2;␊
687 done = 0;␊
688 }␊
689 module = module->nextModule;␊
690 }␊
691 }␊
692 while (!done);␊
693␊
694 return 0;␊
695}␊
696␊
697␊
698//==========================================================================␊
699// FindModule␊
700␊
701#if NOTDEF␊
702static ModulePtr␊
703FindModule( char * name )␊
704{␊
705 ModulePtr module;␊
706 TagPtr prop;␊
707 ␊
708 module = gModuleHead;␊
709 ␊
710 while (module != 0)␊
711 {␊
712 prop = GetProperty(module->dict, kPropCFBundleIdentifier);␊
713 if ((prop != 0) && !strcmp(name, prop->string)) break;␊
714 module = module->nextModule;␊
715 }␊
716 ␊
717 return module;␊
718}␊
719#endif /* NOTDEF */␊
720␊
721//==========================================================================␊
722// ParseXML␊
723␊
724static long␊
725ParseXML( char * buffer, ModulePtr * module, TagPtr * personalities )␊
726{␊
727␉long length, pos;␊
728␉TagPtr moduleDict, required;␊
729␉ModulePtr tmpModule;␊
730 ␊
731 pos = 0;␊
732 ␊
733 while (1)␊
734 {␊
735 length = XMLParseNextTag(buffer + pos, &moduleDict);␊
736 if (length == -1) break;␊
737 ␊
738 pos += length;␊
739 ␊
740 if (moduleDict == 0) continue;␊
741 if (moduleDict->type == kTagTypeDict) break;␊
742 ␊
743 XMLFreeTag(moduleDict);␊
744 }␊
745 ␊
746 if (length == -1) return -1;␊
747␊
748 required = XMLGetProperty(moduleDict, kPropOSBundleRequired);␊
749 if ( (required == 0) ||␊
750 (required->type != kTagTypeString) ||␊
751 !strcmp(required->string, "Safe Boot"))␊
752 {␊
753 XMLFreeTag(moduleDict);␊
754 return -2;␊
755 }␊
756␊
757 tmpModule = malloc(sizeof(Module));␊
758 if (tmpModule == 0)␊
759 {␊
760 XMLFreeTag(moduleDict);␊
761 return -1;␊
762 }␊
763 tmpModule->dict = moduleDict;␊
764 ␊
765 // For now, load any module that has OSBundleRequired != "Safe Boot".␊
766␊
767 tmpModule->willLoad = 1;␊
768␊
769 *module = tmpModule;␊
770 ␊
771 // Get the personalities.␊
772␊
773 *personalities = XMLGetProperty(moduleDict, kPropIOKitPersonalities);␊
774 ␊
775 return 0;␊
776}␊
777␊
778#if NOTDEF␊
779static char gPlatformName[64];␊
780#endif␊
781␊
782long ␊
783DecodeKernel(void *binary, entry_t *rentry, char **raddr, int *rsize)␊
784{␊
785 long ret;␊
786 compressed_kernel_header * kernel_header = (compressed_kernel_header *) binary;␊
787 u_int32_t uncompressed_size, size;␊
788 void *buffer;␊
789␉unsigned long len;␊
790 ␊
791#if 0␊
792 printf("kernel header:\n");␊
793 printf("signature: 0x%x\n", kernel_header->signature);␊
794 printf("compress_type: 0x%x\n", kernel_header->compress_type);␊
795 printf("adler32: 0x%x\n", kernel_header->adler32);␊
796 printf("uncompressed_size: 0x%x\n", kernel_header->uncompressed_size);␊
797 printf("compressed_size: 0x%x\n", kernel_header->compressed_size);␊
798 getc();␊
799#endif␊
800␊
801 if (kernel_header->signature == OSSwapBigToHostConstInt32('comp')) {␊
802 if (kernel_header->compress_type != OSSwapBigToHostConstInt32('lzss')) {␊
803 error("kernel compression is bad\n");␊
804 return -1;␊
805 }␊
806#if NOTDEF␊
807 if (kernel_header->platform_name[0] && strcmp(gPlatformName, kernel_header->platform_name))␊
808 return -1;␊
809 if (kernel_header->root_path[0] && strcmp(gBootFile, kernel_header->root_path))␊
810 return -1;␊
811#endif␊
812 ␊
813 uncompressed_size = OSSwapBigToHostInt32(kernel_header->uncompressed_size);␊
814 binary = buffer = malloc(uncompressed_size);␊
815 ␊
816 size = decompress_lzss((u_int8_t *) binary, &kernel_header->data[0],␊
817 OSSwapBigToHostInt32(kernel_header->compressed_size));␊
818 if (uncompressed_size != size) {␊
819 error("size mismatch from lzss: %x\n", size);␊
820 return -1;␊
821 }␊
822 if (OSSwapBigToHostInt32(kernel_header->adler32) !=␊
823 Alder32(binary, uncompressed_size)) {␊
824 printf("adler mismatch\n");␊
825 return -1;␊
826 }␊
827 }␊
828 ␊
829 ret = ThinFatFile(&binary, &len);␊
830 if (ret == 0 && len == 0 && archCpuType==CPU_TYPE_X86_64)␊
831 {␊
832␉ archCpuType=CPU_TYPE_I386;␊
833␉ ret = ThinFatFile(&binary, &len);␊
834 }␊
835 ␊
836 ret = DecodeMachO(binary, rentry, raddr, rsize);␊
837␉␊
838 if (ret<0 && archCpuType==CPU_TYPE_X86_64)␊
839 {␊
840␉ archCpuType=CPU_TYPE_I386;␊
841␉ ret = DecodeMachO(binary, rentry, raddr, rsize);␊
842 }␊
843 ␊
844 return ret;␊
845}␊
846

Archive Download this file

Revision: 977