--- /dev/null
+/*
+ * Copyright (c) 2001 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
+ * Reserved. This file contains Original Code and/or Modifications of
+ * Original Code as defined in and that are subject to the Apple Public
+ * Source License Version 1.0 (the 'License'). You may not use this file
+ * except in compliance with the License. Please obtain a copy of the
+ * License at http://www.apple.com/publicsource and read it before using
+ * this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
+ * License for the specific language governing rights and limitations
+ * under the License."
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+/*
+ * History:
+ * 2001-05-30 gvdl Initial implementation of the vtable patcher.
+ */
+// 45678901234567890123456789012345678901234567890123456789012345678901234567890
+
+#include <mach-o/fat.h>
+#include <mach-o/loader.h>
+#include <mach-o/nlist.h>
+#include <mach-o/reloc.h>
+
+#if KERNEL
+
+#include <stdarg.h>
+#include <string.h>
+
+#include <sys/systm.h>
+
+#include <libkern/OSTypes.h>
+
+#include <libsa/stdlib.h>
+#include <libsa/mach/mach.h>
+
+#include "mach_loader.h"
+
+#include <vm/vm_kern.h>
+
+enum { false = 0, true = 1 };
+
+#define vm_page_size page_size
+
+extern load_return_t fatfile_getarch(
+ void * vp, // normally a (struct vnode *)
+ vm_offset_t data_ptr,
+ struct fat_arch * archret);
+
+__private_extern__ char *strstr(const char *in, const char *str);
+
+#else /* !KERNEL */
+
+#include <unistd.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/errno.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/vm.h>
+
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+
+#include <mach-o/arch.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#define PAGE_SIZE vm_page_size
+#define PAGE_MASK (PAGE_SIZE - 1)
+
+#endif /* KERNEL */
+
+#include "kld_patch.h"
+#include "c++rem3.h"
+
+#if 0
+#define DIE() do { for (;;) ; } while(0)
+
+#if KERNEL
+# define LOG_DELAY() /* IODelay(200000) */
+# define DEBUG_LOG(x) do { IOLog x; LOG_DELAY(); } while(0)
+#else
+# define LOG_DELAY()
+# define DEBUG_LOG(x) do { printf x; } while(0)
+#endif
+
+#else
+
+#define DIE()
+#define LOG_DELAY()
+#define DEBUG_LOG(x)
+
+#endif
+
+// OSObject symbol prefixes and suffixes
+#define kCPPSymbolPrefix "_Z"
+#define kVTablePrefix "_" kCPPSymbolPrefix "TV"
+#define kOSObjPrefix "_" kCPPSymbolPrefix "N"
+#define kReservedNamePrefix "_RESERVED"
+#define k29SuperClassSuffix "superClass"
+#define k31SuperClassSuffix "10superClassE"
+#define kGMetaSuffix "10gMetaClassE"
+#define kLinkEditSegName SEG_LINKEDIT
+
+// GCC 2.95 drops 2 leading constants in the vtable
+#define kVTablePreambleLen 2
+
+// Last address that I'm willing to try find vm in
+#define kTopAddr ((unsigned char *) (1024 * 1024 * 1024))
+
+// Size in bytes that Data Ref object's get increased in size
+// Must be a power of 2
+#define kDataCapacityIncrement 128
+
+// My usual set of helper macros. I personally find these macros
+// easier to read in the code rather than an explicit error condition
+// check. If I don't make it easy then I may get lazy ond not check
+// everything. I'm sorry if you find this code harder to read.
+
+// break_if will evaluate the expression and if it is true
+// then it will print the msg, which is enclosed in parens
+// and then break. Usually used in loops are do { } while (0)
+#define break_if(expr, msg) \
+ if (expr) { \
+ errprintf msg; \
+ break; \
+ }
+
+// return_if will evaluate expr and if true it will log the
+// msg, which is enclosed in parens, and then it will return
+// with the return code of ret.
+#define return_if(expr, ret, msg) do { \
+ if (expr) { \
+ errprintf msg; \
+ return ret; \
+ } \
+} while (0)
+
+#ifndef MIN
+#define MIN(a,b) (((a)<(b))?(a):(b))
+#endif /* MIN */
+#ifndef MAX
+#define MAX(a,b) (((a)>(b))?(a):(b))
+#endif /* MAX */
+
+typedef struct Data {
+ unsigned long fLength, fCapacity;
+ unsigned char *fData;
+} Data, *DataRef;
+
+struct sectionRecord {
+ const struct section *fSection;
+ DataRef fRelocCache;
+};
+
+enum patchState {
+ kSymbolIdentical,
+ kSymbolLocal,
+ kSymbolPadUpdate,
+ kSymbolSuperUpdate,
+ kSymbolMismatch
+};
+
+struct patchRecord {
+ struct nlist *fSymbol;
+ enum patchState fType;
+};
+
+struct relocRecord {
+ void *fValue;
+ const struct nlist *fSymbol;
+ struct relocation_info *fRInfo;
+ void *reserved;
+};
+
+struct metaClassRecord {
+ char *fSuperName;
+ struct fileRecord *fFile;
+ const struct nlist *fVTableSym;
+ struct patchRecord *fPatchedVTable;
+ char fClassName[1];
+};
+
+struct fileRecord {
+ size_t fMapSize, fMachOSize;
+ unsigned char *fMap, *fMachO, *fPadEnd;
+ DataRef fClassList;
+ DataRef fSectData;
+ DataRef fNewSymbols, fNewStringBlocks;
+ DataRef fSym2Strings;
+ struct symtab_command *fSymtab;
+ struct sectionRecord *fSections;
+ struct segment_command *fLinkEditSeg;
+ const char **fSymbToStringTable;
+ char *fStringBase;
+ struct nlist *fSymbolBase;
+ const struct nlist *fLocalSyms;
+ unsigned int fNSects;
+ int fNLocal;
+ Boolean fIsKernel, fNoKernelExecutable, fIsKmem;
+ Boolean fImageDirty, fSymbolsDirty;
+ Boolean fRemangled, fFoundOSObject;
+ const char fPath[1];
+};
+
+static DataRef sFilesTable;
+static struct fileRecord *sKernelFile;
+
+static DataRef sMergedFiles;
+static DataRef sMergeMetaClasses;
+static Boolean sMergedKernel;
+
+static void errprintf(const char *fmt, ...)
+{
+ extern void kld_error_vprintf(const char *format, va_list ap);
+
+ va_list ap;
+
+ va_start(ap, fmt);
+ kld_error_vprintf(fmt, ap);
+ va_end(ap);
+
+DIE();
+}
+
+static __inline__ unsigned long DataGetLength(DataRef data)
+{
+ return data->fLength;
+}
+
+static __inline__ unsigned char *DataGetPtr(DataRef data)
+{
+ return data->fData;
+}
+
+static __inline__ unsigned char *DataGetEndPtr(DataRef data)
+{
+ return data->fData + data->fLength;
+}
+
+static __inline__ unsigned long DataRemaining(DataRef data)
+{
+ return data->fCapacity - data->fLength;
+}
+
+static __inline__ Boolean DataContainsAddr(DataRef data, void *vAddr)
+{
+ vm_offset_t offset = (vm_address_t) vAddr;
+
+ if (!data)
+ return false;
+
+ offset = (vm_address_t) vAddr - (vm_address_t) data->fData;
+ return (offset < data->fLength);
+}
+
+static Boolean DataEnsureCapacity(DataRef data, unsigned long capacity)
+{
+ // Don't bother to ever shrink a data object.
+ if (capacity > data->fCapacity) {
+ unsigned char *newData;
+
+ capacity += kDataCapacityIncrement - 1;
+ capacity &= ~(kDataCapacityIncrement - 1);
+ newData = (unsigned char *) realloc(data->fData, capacity);
+ if (!newData)
+ return false;
+
+ bzero(newData + data->fCapacity, capacity - data->fCapacity);
+ data->fData = newData;
+ data->fCapacity = capacity;
+ }
+
+ return true;
+}
+
+static __inline__ Boolean DataSetLength(DataRef data, unsigned long length)
+{
+ if (DataEnsureCapacity(data, length)) {
+ data->fLength = length;
+ return true;
+ }
+ else
+ return false;
+}
+
+static __inline__ Boolean DataAddLength(DataRef data, unsigned long length)
+{
+ return DataSetLength(data, data->fLength + length);
+}
+
+static __inline__ Boolean
+DataAppendBytes(DataRef data, const void *addr, unsigned int len)
+{
+ unsigned long size = DataGetLength(data);
+
+ if (!DataAddLength(data, len))
+ return false;
+
+ bcopy(addr, DataGetPtr(data) + size, len);
+ return true;
+}
+
+static __inline__ Boolean DataAppendData(DataRef dst, DataRef src)
+{
+ return DataAppendBytes(dst, DataGetPtr(src), DataGetLength(src));
+}
+
+static DataRef DataCreate(unsigned long capacity)
+{
+ DataRef data = (DataRef) malloc(sizeof(Data));
+
+ if (data) {
+ if (!capacity)
+ data->fCapacity = kDataCapacityIncrement;
+ else {
+ data->fCapacity = capacity + kDataCapacityIncrement - 1;
+ data->fCapacity &= ~(kDataCapacityIncrement - 1);
+ }
+
+ data->fData = (unsigned char *) malloc(data->fCapacity);
+ if (!data->fData) {
+ free(data);
+ return NULL;
+ }
+
+ bzero(data->fData, data->fCapacity);
+ data->fLength = 0;
+ }
+ return data;
+}
+
+static void DataRelease(DataRef data)
+{
+ if (data) {
+ if (data->fData)
+ free(data->fData);
+ data->fData = 0;
+ free(data);
+ }
+}
+
+static __inline__ const char *
+symNameByIndex(const struct fileRecord *file, unsigned int symInd)
+{
+ return file->fSymbToStringTable[symInd];
+}
+
+static __inline__ const char *
+symbolname(const struct fileRecord *file, const struct nlist *sym)
+{
+ unsigned int index;
+
+ index = sym - file->fSymbolBase;
+ if (index < file->fSymtab->nsyms)
+ return symNameByIndex(file, index);
+
+ if (-1 == sym->n_un.n_strx)
+ return (const char *) sym->n_value;
+
+ // If the preceding tests fail then we have a getNewSymbol patch and
+ // the file it refers to has already been patched as the n_strx is set
+ // to -1 temporarily while we are still processing a file.
+ // Once we have finished with a file then we repair the 'strx' offset
+ // to be valid for the repaired file's string table.
+ return file->fStringBase + sym->n_un.n_strx;
+}
+
+static struct fileRecord *
+getFile(const char *path)
+{
+ if (sFilesTable) {
+ int i, nfiles;
+ struct fileRecord **files;
+
+ // Check to see if we have already merged this file
+ nfiles = DataGetLength(sFilesTable) / sizeof(struct fileRecord *);
+ files = (struct fileRecord **) DataGetPtr(sFilesTable);
+ for (i = 0; i < nfiles; i++) {
+ if (!strcmp(path, files[i]->fPath))
+ return files[i];
+ }
+ }
+
+ return NULL;
+}
+
+static struct fileRecord *
+addFile(struct fileRecord *file, const char *path)
+{
+ struct fileRecord *newFile;
+
+ if (!sFilesTable) {
+ sFilesTable = DataCreate(0);
+ if (!sFilesTable)
+ return NULL;
+ }
+
+ newFile = (struct fileRecord *)
+ malloc(sizeof(struct fileRecord) + strlen(path));
+ if (!newFile)
+ return NULL;
+
+ if (!DataAppendBytes(sFilesTable, &newFile, sizeof(newFile))) {
+ free(newFile);
+ return NULL;
+ }
+
+ bcopy(file, newFile, sizeof(struct fileRecord) - 1);
+ strcpy((char *) newFile->fPath, path);
+
+ return newFile;
+}
+
+// @@@ gvdl: need to clean up the sMergeMetaClasses
+// @@@ gvdl: I had better fix the object file up again
+static void unmapFile(struct fileRecord *file)
+{
+ if (file->fSectData) {
+ struct sectionRecord *section;
+ unsigned int i, nsect;
+
+ nsect = file->fNSects;
+ section = file->fSections;
+ for (i = 0; i < nsect; i++, section++) {
+ if (section->fRelocCache) {
+ DataRelease(section->fRelocCache);
+ section->fRelocCache = 0;
+ }
+ }
+
+ DataRelease(file->fSectData);
+ file->fSectData = 0;
+ file->fSections = 0;
+ file->fNSects = 0;
+ }
+
+ if (file->fSym2Strings) {
+ DataRelease(file->fSym2Strings);
+ file->fSym2Strings = 0;
+ }
+
+ if (file->fMap) {
+#if KERNEL
+ if (file->fIsKmem)
+ kmem_free(kernel_map, (vm_address_t) file->fMap, file->fMapSize);
+#else /* !KERNEL */
+ if (file->fPadEnd) {
+ vm_address_t padVM;
+ vm_size_t padSize;
+
+ padVM = round_page((vm_address_t) file->fMap + file->fMapSize);
+ padSize = (vm_size_t) ((vm_address_t) file->fPadEnd - padVM);
+ (void) vm_deallocate(mach_task_self(), padVM, padSize);
+ file->fPadEnd = 0;
+ }
+
+ (void) munmap((caddr_t) file->fMap, file->fMapSize);
+#endif /* !KERNEL */
+ file->fMap = 0;
+ }
+}
+
+static void removeFile(struct fileRecord *file)
+{
+ if (file->fClassList) {
+ DataRelease(file->fClassList);
+ file->fClassList = 0;
+ }
+
+ unmapFile(file);
+
+ free(file);
+}
+
+#if !KERNEL
+static Boolean
+mapObjectFile(struct fileRecord *file, const char *pathName)
+{
+ Boolean result = false;
+ static unsigned char *sFileMapBaseAddr = 0;
+
+ int fd = 0;
+
+ if (!sFileMapBaseAddr) {
+ kern_return_t ret;
+ vm_address_t probeAddr;
+
+ // If we don't already have a base addr find any random chunk
+ // of 32 meg of VM and to use the 16 meg boundrary as a base.
+ ret = vm_allocate(mach_task_self(), &probeAddr,
+ 32 * 1024 * 1024, VM_FLAGS_ANYWHERE);
+ return_if(KERN_SUCCESS != ret, false,
+ ("Unable to allocate base memory %s\n", mach_error_string(ret)));
+ (void) vm_deallocate(mach_task_self(), probeAddr, 32 * 1024 * 1024);
+
+ // Now round to the next 16 Meg boundrary
+ probeAddr = (probeAddr + (16 * 1024 * 1024 - 1))
+ & ~(16 * 1024 * 1024 - 1);
+ sFileMapBaseAddr = (unsigned char *) probeAddr;
+ }
+
+ fd = open(pathName, O_RDONLY, 0);
+ return_if(fd == -1, false, ("Can't open %s for reading - %s\n",
+ pathName, strerror(errno)));
+
+ do {
+ kern_return_t ret;
+ struct stat sb;
+ int retaddr = -1;
+
+ break_if(fstat(fd, &sb) == -1,
+ ("Can't stat %s - %s\n", file->fPath, strerror(errno)));
+
+ file->fMapSize = sb.st_size;
+ file->fMap = sFileMapBaseAddr;
+ ret = KERN_SUCCESS;
+ while (file->fMap < kTopAddr) {
+ vm_address_t padVM;
+ vm_address_t padVMEnd;
+ vm_size_t padSize;
+
+ padVM = round_page((vm_address_t) file->fMap + file->fMapSize);
+ retaddr = (int) mmap(file->fMap, file->fMapSize,
+ PROT_READ|PROT_WRITE,
+ MAP_FIXED|MAP_FILE|MAP_PRIVATE,
+ fd, 0);
+ if (-1 == retaddr) {
+ break_if(ENOMEM != errno,
+ ("mmap failed %d - %s\n", errno, strerror(errno)));
+
+ file->fMap = (unsigned char *) padVM;
+ continue;
+ }
+
+
+ // Round up padVM to the next page after the file and assign at
+ // least another fMapSize more room rounded up to the next page
+ // boundary.
+ padVMEnd = round_page(padVM + file->fMapSize);
+ padSize = padVMEnd - padVM;
+ ret = vm_allocate(
+ mach_task_self(), &padVM, padSize, VM_FLAGS_FIXED);
+ if (KERN_SUCCESS == ret) {
+ file->fPadEnd = (unsigned char *) padVMEnd;
+ break;
+ }
+ else {
+ munmap(file->fMap, file->fMapSize);
+ break_if(KERN_INVALID_ADDRESS != ret,
+ ("Unable to allocate pad vm for %s - %s\n",
+ pathName, mach_error_string(ret)));
+
+ file->fMap = (unsigned char *) padVMEnd;
+ continue; // try again wherever the vm system wants
+ }
+ }
+
+ if (-1 == retaddr || KERN_SUCCESS != ret)
+ break;
+
+ break_if(file->fMap >= kTopAddr,
+ ("Unable to map memory %s\n", file->fPath));
+
+ sFileMapBaseAddr = file->fPadEnd;
+ result = true;
+ } while(0);
+
+ close(fd);
+ return result;
+}
+#endif /* !KERNEL */
+
+static Boolean findBestArch(struct fileRecord *file, const char *pathName)
+{
+ unsigned long magic;
+ struct fat_header *fat;
+
+
+ file->fMachOSize = file->fMapSize;
+ file->fMachO = file->fMap;
+ magic = ((const struct mach_header *) file->fMachO)->magic;
+ fat = (struct fat_header *) file->fMachO;
+
+ // Try to figure out what type of file this is
+ return_if(file->fMapSize < sizeof(unsigned long), false,
+ ("%s isn't a valid object file - no magic\n", pathName));
+
+#if KERNEL
+
+ // CIGAM is byte-swapped MAGIC
+ if (magic == FAT_MAGIC || magic == FAT_CIGAM) {
+
+ load_return_t load_return;
+ struct fat_arch fatinfo;
+
+ load_return = fatfile_getarch(NULL, (vm_address_t) fat, &fatinfo);
+ return_if(load_return != LOAD_SUCCESS, false,
+ ("Extension \"%s\": has no code for this computer\n", pathName));
+
+ file->fMachO = file->fMap + fatinfo.offset;
+ file->fMachOSize = fatinfo.size;
+ magic = ((const struct mach_header *) file->fMachO)->magic;
+ }
+
+#else /* !KERNEL */
+
+ // Do we need to in-place swap the endianness of the fat header?
+ if (magic == FAT_CIGAM) {
+ unsigned long i;
+ struct fat_arch *arch;
+
+ fat->nfat_arch = NXSwapBigLongToHost(fat->nfat_arch);
+ return_if(file->fMapSize < sizeof(struct fat_header)
+ + fat->nfat_arch * sizeof(struct fat_arch),
+ false, ("%s is too fat\n", file->fPath));
+
+ arch = (struct fat_arch *) &fat[1];
+ for (i = 0; i < fat->nfat_arch; i++) {
+ arch[i].cputype = NXSwapBigLongToHost(arch[i].cputype);
+ arch[i].cpusubtype = NXSwapBigLongToHost(arch[i].cpusubtype);
+ arch[i].offset = NXSwapBigLongToHost(arch[i].offset);
+ arch[i].size = NXSwapBigLongToHost(arch[i].size);
+ arch[i].align = NXSwapBigLongToHost(arch[i].align);
+ }
+
+ magic = NXSwapBigLongToHost(fat->magic);
+ }
+
+ // Now see if we can find any valid architectures
+ if (magic == FAT_MAGIC) {
+ const NXArchInfo *myArch;
+ unsigned long fatsize;
+ struct fat_arch *arch;
+
+ fatsize = sizeof(struct fat_header)
+ + fat->nfat_arch * sizeof(struct fat_arch);
+ return_if(file->fMapSize < fatsize,
+ false, ("%s isn't a valid fat file\n", pathName));
+
+ myArch = NXGetLocalArchInfo();
+ arch = NXFindBestFatArch(myArch->cputype, myArch->cpusubtype,
+ (struct fat_arch *) &fat[1], fat->nfat_arch);
+ return_if(!arch,
+ false, ("%s hasn't got arch for %s\n", pathName, myArch->name));
+ return_if(arch->offset + arch->size > file->fMapSize,
+ false, ("%s's %s arch is incomplete\n", pathName, myArch->name));
+ file->fMachO = file->fMap + arch->offset;
+ file->fMachOSize = arch->size;
+ magic = ((const struct mach_header *) file->fMachO)->magic;
+ }
+
+#endif /* KERNEL */
+
+ return_if(magic != MH_MAGIC,
+ false, ("%s isn't a valid mach-o\n", pathName));
+
+ return true;
+}
+
+static Boolean
+parseSegments(struct fileRecord *file, struct segment_command *seg)
+{
+ struct sectionRecord *sections;
+ int i, nsects = seg->nsects;
+ const struct segmentMap {
+ struct segment_command seg;
+ const struct section sect[1];
+ } *segMap;
+
+ if (!file->fSectData) {
+ file->fSectData = DataCreate(0);
+ if (!file->fSectData)
+ return false;
+ }
+
+ // Increase length of section DataRef and cache data pointer
+ if (!DataAddLength(file->fSectData, nsects * sizeof(struct sectionRecord)))
+ return false;
+ file->fSections = (struct sectionRecord *) DataGetPtr(file->fSectData);
+
+ // Initialise the new sections
+ sections = &file->fSections[file->fNSects];
+ file->fNSects += nsects;
+ for (i = 0, segMap = (struct segmentMap *) seg; i < nsects; i++)
+ sections[i].fSection = &segMap->sect[i];
+
+ return true;
+}
+
+static Boolean
+remangleExternSymbols(struct fileRecord *file, const char *pathName)
+{
+ const struct nlist *sym;
+ int i, nsyms, len;
+ DataRef strings = NULL;
+
+ DEBUG_LOG(("Remangling %s\n", pathName));
+
+ file->fNewStringBlocks = DataCreate(0);
+ return_if(!file->fNewStringBlocks, false,
+ ("Unable to allocate new string table for %s\n", pathName));
+
+ nsyms = file->fSymtab->nsyms;
+ for (i = 0, sym = file->fSymbolBase; i < nsyms; i++, sym++) {
+ Rem3Return ret;
+ const char *symname;
+ char *newname;
+ unsigned char n_type = sym->n_type;
+
+ // Not an external symbol or it is a stab in any case don't bother
+ if ((n_type ^ N_EXT) & (N_STAB | N_EXT))
+ continue;
+
+ symname = symNameByIndex(file, i);
+
+tryRemangleAgain:
+ if (!strings) {
+ strings = DataCreate(16 * 1024); // Arbitrary block size
+ return_if(!strings, false,
+ ("Unable to allocate new string block for %s\n", pathName));
+ }
+
+ len = DataRemaining(strings);
+ newname = DataGetEndPtr(strings);
+ ret = rem3_remangle_name(newname, &len, symname);
+ switch (ret) {
+ case kR3InternalNotRemangled:
+ errprintf("Remangler fails on %s in %s\n", symname, pathName);
+ /* No break */
+ case kR3NotRemangled:
+ break;
+
+ case kR3Remangled:
+ file->fSymbToStringTable[i] = newname;
+ file->fRemangled = file->fSymbolsDirty = true;
+ DataAddLength(strings, len + 1); // returns strlen
+ break;
+
+ case kR3BufferTooSmallRemangled:
+ return_if(!DataAppendBytes
+ (file->fNewStringBlocks, &strings, sizeof(strings)),
+ false, ("Unable to allocate string table for %s\n", pathName));
+ strings = NULL;
+ goto tryRemangleAgain;
+
+ case kR3BadArgument:
+ default:
+ return_if(true, false,
+ ("Internal error - remangle of %s\n", pathName));
+ }
+ }
+
+ if (strings) {
+ return_if(!DataAppendBytes
+ (file->fNewStringBlocks, &strings, sizeof(strings)),
+ false, ("Unable to allocate string table for %s\n", pathName));
+ }
+
+ return true;
+}
+
+static Boolean parseSymtab(struct fileRecord *file, const char *pathName)
+{
+ const struct nlist *sym;
+ unsigned int i, firstlocal, nsyms;
+ unsigned long strsize;
+ const char *strbase;
+ Boolean foundOSObject, found295CPP;
+
+ // we found a link edit segment so recompute the bases
+ if (file->fLinkEditSeg) {
+ struct segment_command *link = file->fLinkEditSeg;
+
+ file->fSymbolBase = (struct nlist *)
+ (link->vmaddr + (file->fSymtab->symoff - link->fileoff));
+ file->fStringBase = (char *)
+ (link->vmaddr + (file->fSymtab->stroff - link->fileoff));
+ return_if( ( (caddr_t) file->fStringBase + file->fSymtab->strsize
+ > (caddr_t) link->vmaddr + link->vmsize ), false,
+ ("%s isn't a valid mach-o le, bad symbols\n", pathName));
+ }
+ else {
+ file->fSymbolBase = (struct nlist *)
+ (file->fMachO + file->fSymtab->symoff);
+ file->fStringBase = (char *)
+ (file->fMachO + file->fSymtab->stroff);
+ return_if( ( file->fSymtab->stroff + file->fSymtab->strsize
+ > file->fMachOSize ), false,
+ ("%s isn't a valid mach-o, bad symbols\n", pathName));
+ }
+
+ nsyms = file->fSymtab->nsyms;
+
+ // If this file the kernel and do we have an executable image
+ file->fNoKernelExecutable = (vm_page_size == file->fSymtab->symoff)
+ && (file->fSections[0].fSection->size == 0);
+
+ // Generate a table of pointers to strings indexed by the symbol number
+
+ file->fSym2Strings = DataCreate(nsyms * sizeof(const char *));
+ DataSetLength(file->fSym2Strings, nsyms * sizeof(const char *));
+ return_if(!file->fSym2Strings, false,
+ ("Unable to allocate memory - symbol string trans\n", pathName));
+ file->fSymbToStringTable = (const char **) DataGetPtr(file->fSym2Strings);
+
+ // Search for the first non-stab symbol in table
+ strsize = file->fSymtab->strsize;
+ strbase = file->fStringBase;
+ firstlocal = 0;
+ found295CPP = foundOSObject = false;
+ for (i = 0, sym = file->fSymbolBase; i < nsyms; i++, sym++) {
+ long strx = sym->n_un.n_strx;
+ const char *symname = strbase + strx;
+ unsigned char n_type;
+
+ return_if(((unsigned long) strx > strsize), false,
+ ("%s has an illegal string offset in symbol %d\n", pathName, i));
+
+ // Load up lookup symbol look table with sym names
+ file->fSymbToStringTable[i] = symname;
+
+ n_type = sym->n_type & (N_TYPE | N_EXT);
+
+ // Find the first exported symbol
+ if ( !firstlocal && (n_type & N_EXT) ) {
+ firstlocal = i;
+ file->fLocalSyms = sym;
+ }
+
+ // Find the a OSObject based subclass by searching for symbols
+ // that have a suffix of '10superClassE'
+ symname++; // Skip leading '_'
+
+ if (!foundOSObject
+ && (n_type == (N_SECT | N_EXT) || n_type == (N_ABS | N_EXT))
+ && strx) {
+ const char *suffix, *endSym;
+
+ endSym = symname + strlen(symname);
+
+ // Find out if this symbol has the superclass suffix.
+ if (symname[0] == kCPPSymbolPrefix[0]
+ && symname[1] == kCPPSymbolPrefix[1]) {
+
+ suffix = endSym - sizeof(k31SuperClassSuffix) + 1;
+
+ // Check for a gcc3 OSObject subclass
+ if (suffix > symname
+ && !strcmp(suffix, k31SuperClassSuffix))
+ foundOSObject = true;
+ }
+ else {
+ suffix = endSym - sizeof(k29SuperClassSuffix);
+
+ // Check for a gcc295 OSObject subclass
+ if (suffix > symname
+ && ('.' == *suffix || '$' == *suffix)
+ && !strcmp(suffix+1, k29SuperClassSuffix)) {
+ found295CPP = foundOSObject = true;
+ }
+ else if (!found295CPP) {
+ // Finally just check if we need to remangle
+ symname++; // skip leading '__'
+ while (*symname) {
+ if ('_' == *symname++ && '_' == *symname++) {
+ found295CPP = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+ else if (sym->n_type == (N_EXT | N_UNDF)) {
+ if ( !file->fNLocal) // Find the last local symbol
+ file->fNLocal = i - firstlocal;
+ if (!found295CPP) {
+ symname++; // Skip possible second '_' at start.
+ while (*symname) {
+ if ('_' == *symname++ && '_' == *symname++) {
+ found295CPP = true;
+ break;
+ }
+ }
+ }
+ }
+ // Note symname is trashed at this point
+ }
+ return_if(i < nsyms, false,
+ ("%s isn't a valid mach-o, bad symbol strings\n", pathName));
+
+ return_if(!file->fLocalSyms, false, ("%s has no symbols?\n", pathName));
+
+ // If we don't have any undefined symbols then all symbols
+ // must be local so just compute it now if necessary.
+ if ( !file->fNLocal )
+ file->fNLocal = i - firstlocal;
+
+ file->fFoundOSObject = foundOSObject;
+
+ if (found295CPP && !remangleExternSymbols(file, pathName))
+ return false;
+
+ return true;
+}
+
+// @@@ gvdl: These functions need to be hashed they are
+// going to be way too slow for production code.
+static const struct nlist *
+findSymbolByAddress(const struct fileRecord *file, void *entry)
+{
+ // not quite so dumb linear search of all symbols
+ const struct nlist *sym;
+ int i, nsyms;
+
+ // First try to find the symbol in the most likely place which is the
+ // extern symbols
+ sym = file->fLocalSyms;
+ for (i = 0, nsyms = file->fNLocal; i < nsyms; i++, sym++) {
+ if (sym->n_value == (unsigned long) entry && !(sym->n_type & N_STAB) )
+ return sym;
+ }
+
+ // Didn't find it in the external symbols so try to local symbols before
+ // giving up.
+ sym = file->fSymbolBase;
+ for (i = 0, nsyms = file->fSymtab->nsyms; i < nsyms; i++, sym++) {
+ if ( (sym->n_type & N_EXT) )
+ return NULL;
+ if ( sym->n_value == (unsigned long) entry && !(sym->n_type & N_STAB) )
+ return sym;
+ }
+
+ return NULL;
+}
+
+struct searchContext {
+ const char *fSymname;
+ const struct fileRecord *fFile;
+};
+
+static int symbolSearch(const void *vKey, const void *vSym)
+{
+ const struct searchContext *key = (const struct searchContext *) vKey;
+ const struct nlist *sym = (const struct nlist *) vSym;
+
+ return strcmp(key->fSymname + 1, symbolname(key->fFile, sym) + 1);
+}
+
+static const struct nlist *
+findSymbolByName(struct fileRecord *file, const char *symname)
+{
+ if (file->fRemangled) {
+ // @@@ gvdl: Performance problem
+ // Linear search as we don't sort after remangling
+ const struct nlist *sym;
+ int i = file->fLocalSyms - file->fSymbolBase;
+ int nLocal = file->fNLocal + i;
+
+ for (sym = file->fLocalSyms; i < nLocal; i++, sym++)
+ if (!strcmp(symNameByIndex(file, i) + 1, symname + 1))
+ return sym;
+ return NULL;
+ }
+ else {
+ struct searchContext context;
+
+ context.fSymname = symname;
+ context.fFile = file;
+ return (struct nlist *)
+ bsearch(&context,
+ file->fLocalSyms, file->fNLocal, sizeof(struct nlist),
+ symbolSearch);
+ }
+}
+
+static Boolean
+relocateSection(const struct fileRecord *file, struct sectionRecord *sectionRec)
+{
+ const struct nlist *symbol;
+ const struct section *section;
+ struct relocRecord *rec;
+ struct relocation_info *rinfo;
+ unsigned long i;
+ unsigned long r_address, r_symbolnum, r_length;
+ enum reloc_type_generic r_type;
+ UInt8 *sectionBase;
+ void **entry;
+
+ sectionRec->fRelocCache = DataCreate(
+ sectionRec->fSection->nreloc * sizeof(struct relocRecord));
+ if (!sectionRec->fRelocCache)
+ return false;
+
+ section = sectionRec->fSection;
+ sectionBase = file->fMachO + section->offset;
+
+ rec = (struct relocRecord *) DataGetPtr(sectionRec->fRelocCache);
+ rinfo = (struct relocation_info *) (file->fMachO + section->reloff);
+ for (i = 0; i < section->nreloc; i++, rec++, rinfo++) {
+
+ // Totally uninterested in scattered relocation entries
+ if ( (rinfo->r_address & R_SCATTERED) )
+ continue;
+
+ r_address = rinfo->r_address;
+ entry = (void **) (sectionBase + r_address);
+
+ /*
+ * The r_address field is really an offset into the contents of the
+ * section and must reference something inside the section (Note
+ * that this is not the case for PPC_RELOC_PAIR entries but this
+ * can't be one with the above checks).
+ */
+ return_if(r_address >= section->size, false,
+ ("Invalid relocation entry in %s - not in section\n", file->fPath));
+
+ // If we don't have a VANILLA entry or the Vanilla entry isn't
+ // a 'long' then ignore the entry and try the next.
+ r_type = (enum reloc_type_generic) rinfo->r_type;
+ r_length = rinfo->r_length;
+ if (r_type != GENERIC_RELOC_VANILLA || r_length != 2)
+ continue;
+
+ r_symbolnum = rinfo->r_symbolnum;
+
+ /*
+ * If rinfo->r_extern is set this relocation entry is an external entry
+ * else it is a local entry.
+ */
+ if (rinfo->r_extern) {
+ /*
+ * This is an external relocation entry.
+ * r_symbolnum is an index into the input file's symbol table
+ * of the symbol being refered to. The symbol must be
+ * undefined to be used in an external relocation entry.
+ */
+ return_if(r_symbolnum >= file->fSymtab->nsyms, false,
+ ("Invalid relocation entry in %s - no symbol\n", file->fPath));
+
+ /*
+ * If this is an indirect symbol resolve indirection (all chains
+ * of indirect symbols have been resolved so that they point at
+ * a symbol that is not an indirect symbol).
+ */
+ symbol = file->fSymbolBase;
+ if ((symbol[r_symbolnum].n_type & N_TYPE) == N_INDR)
+ r_symbolnum = symbol[r_symbolnum].n_value;
+ symbol = &symbol[r_symbolnum];
+
+ return_if(symbol->n_type != (N_EXT | N_UNDF), false,
+ ("Invalid relocation entry in %s - extern\n", file->fPath));
+ }
+ else {
+ /*
+ * If the symbol is not in any section then it can't be a
+ * pointer to a local segment and I don't care about it.
+ */
+ if (r_symbolnum == R_ABS)
+ continue;
+
+ // Note segment references are offset by 1 from 0.
+ return_if(r_symbolnum > file->fNSects, false,
+ ("Invalid relocation entry in %s - local\n", file->fPath));
+
+ // Find the symbol, if any, that backs this entry
+ symbol = findSymbolByAddress(file, *entry);
+ }
+
+ rec->fValue = *entry; // Save the previous value
+ rec->fRInfo = rinfo; // Save a pointer to the reloc
+ rec->fSymbol = symbol; // Record the current symbol
+
+ *entry = (void *) rec; // Save pointer to record in object image
+ }
+
+ DataSetLength(sectionRec->fRelocCache, i * sizeof(struct relocRecord));
+ ((struct fileRecord *) file)->fImageDirty = true;
+
+ return true;
+}
+
+static const struct nlist *
+findSymbolRefAtLocation(const struct fileRecord *file,
+ struct sectionRecord *sctn, void **loc)
+{
+ if (file->fIsKernel) {
+ if (*loc)
+ return findSymbolByAddress(file, *loc);
+ }
+ else if (sctn->fRelocCache || relocateSection(file, sctn)) {
+ struct relocRecord *reloc = (struct relocRecord *) *loc;
+
+ if (DataContainsAddr(sctn->fRelocCache, reloc))
+ return reloc->fSymbol;
+ }
+
+ return NULL;
+}
+
+static Boolean
+addClass(struct fileRecord *file,
+ struct metaClassRecord *inClass,
+ const char *cname)
+{
+ Boolean result = false;
+ struct metaClassRecord *newClass = NULL;
+ struct metaClassRecord **fileClasses = NULL;
+ int len;
+
+ if (!file->fClassList) {
+ file->fClassList = DataCreate(0);
+ if (!file->fClassList)
+ return false;
+ }
+
+ do {
+ // Attempt to allocate all necessary resource first
+ len = strlen(cname) + 1
+ + (int) (&((struct metaClassRecord *) 0)->fClassName);
+ newClass = (struct metaClassRecord *) malloc(len);
+ if (!newClass)
+ break;
+
+ if (!DataAddLength(file->fClassList, sizeof(struct metaClassRecord *)))
+ break;
+ fileClasses = (struct metaClassRecord **)
+ (DataGetPtr(file->fClassList) + DataGetLength(file->fClassList));
+
+ // Copy the meta Class structure and string name into newClass and
+ // insert object at end of the file->fClassList and sMergeMetaClasses
+ *newClass = *inClass;
+ strcpy(newClass->fClassName, cname);
+ fileClasses[-1] = newClass;
+
+ return true;
+ } while (0);
+
+ if (fileClasses)
+ DataAddLength(file->fClassList, -sizeof(struct metaClassRecord *));
+
+ if (newClass)
+ free(newClass);
+
+ return result;
+}
+
+static struct metaClassRecord *getClass(DataRef classList, const char *cname)
+{
+ if (classList) {
+ int i, nclass;
+ struct metaClassRecord **classes, *thisClass;
+
+ nclass = DataGetLength(classList) / sizeof(struct metaClassRecord *);
+ classes = (struct metaClassRecord **) DataGetPtr(classList);
+ for (i = 0; i < nclass; i++) {
+ thisClass = classes[i];
+ if (!strcmp(thisClass->fClassName, cname))
+ return thisClass;
+ }
+ }
+
+ return NULL;
+}
+
+// Add the class 'cname' to the list of known OSObject based classes
+// Note 'sym' is the <cname>10superClassE symbol.
+static Boolean
+recordClass(struct fileRecord *file, const char *cname, const struct nlist *sym)
+{
+ Boolean result = false;
+ char *supername = NULL;
+ const char *classname = NULL;
+ struct metaClassRecord newClass;
+ char strbuffer[1024];
+
+ // Only do the work to find the super class if we are
+ // not currently working on the kernel. The kernel is the end
+ // of all superclass chains by definition as the kernel must be binary
+ // compatible with itself.
+ if (!file->fIsKernel) {
+ const char *suffix;
+ const struct nlist *supersym;
+ const struct section *section;
+ struct sectionRecord *sectionRec;
+ unsigned char sectind = sym->n_sect;
+ const char *superstr;
+ void **location;
+ int snamelen;
+
+ // We can't resolve anything that isn't in a real section
+ // Note that the sectind is starts at one to make room for the
+ // NO_SECT flag but the fNSects field isn't offset so we have a
+ // '>' test. Which means this isn't an OSObject based class
+ if (sectind == NO_SECT || sectind > file->fNSects) {
+ result = true;
+ goto finish;
+ }
+ sectionRec = file->fSections + sectind - 1;
+ section = sectionRec->fSection;
+ location = (void **) ( file->fMachO + section->offset
+ + sym->n_value - section->addr );
+
+ supersym = findSymbolRefAtLocation(file, sectionRec, location);
+ if (!supersym) {
+ result = true; // No superclass symbol then it isn't an OSObject.
+ goto finish;
+ }
+
+ // Find string in file and skip leading '_' and then find the suffix
+ superstr = symbolname(file, supersym) + 1;
+ suffix = superstr + strlen(superstr) - sizeof(kGMetaSuffix) + 1;
+ if (suffix <= superstr || strcmp(suffix, kGMetaSuffix)) {
+ result = true; // Not an OSObject superclass so ignore it..
+ goto finish;
+ }
+
+ // Got a candidate so hand it over for class processing.
+ snamelen = suffix - superstr - sizeof(kOSObjPrefix) + 2;
+ supername = (char *) malloc(snamelen + 1);
+ bcopy(superstr + sizeof(kOSObjPrefix) - 2, supername, snamelen);
+ supername[snamelen] = '\0';
+ }
+
+ do {
+ break_if(getClass(file->fClassList, cname),
+ ("Duplicate class %s in %s\n", cname, file->fPath));
+
+ snprintf(strbuffer, sizeof(strbuffer), "%s%s", kVTablePrefix, cname);
+ newClass.fVTableSym = findSymbolByName(file, strbuffer);
+ break_if(!newClass.fVTableSym,
+ ("Can't find vtable %s in %s\n", cname, file->fPath));
+
+ newClass.fFile = file;
+ newClass.fSuperName = supername;
+ newClass.fPatchedVTable = NULL;
+
+ // Can't use cname as it may be a stack variable
+ // However the vtable's string has the class name as a suffix
+ // so why don't we use that rather than mallocing a string.
+ classname = symbolname(file, newClass.fVTableSym)
+ + sizeof(kVTablePrefix) - 1;
+ break_if(!addClass(file, &newClass, classname),
+ ("recordClass - no memory?\n"));
+
+ supername = NULL;
+ result = true;
+ } while (0);
+
+finish:
+ if (supername)
+ free(supername);
+
+ return result;
+}
+
+
+static Boolean getMetaClassGraph(struct fileRecord *file)
+{
+ const struct nlist *sym;
+ int i, nsyms;
+
+ // Search the symbol table for the local symbols that are generated
+ // by the metaclass system. There are three metaclass variables
+ // that are relevant.
+ //
+ // <ClassName>.metaClass A pointer to the meta class structure.
+ // <ClassName>.superClass A pointer to the super class's meta class.
+ // <ClassName>.gMetaClass The meta class structure itself.
+ // ___vt<ClassName> The VTable for the class <ClassName>.
+ //
+ // In this code I'm going to search for any symbols that
+ // ends in k31SuperClassSuffix as this indicates this class is a conforming
+ // OSObject subclass and will need to be patched, and it also
+ // contains a pointer to the super class's meta class structure.
+ sym = file->fLocalSyms;
+ for (i = 0, nsyms = file->fNLocal; i < nsyms; i++, sym++) {
+ const char *symname;
+ const char *suffix;
+ char classname[1024];
+ unsigned char n_type = sym->n_type & (N_TYPE | N_EXT);
+ int cnamelen;
+
+ // Check that the symbols is a global and that it has a name.
+ if (((N_SECT | N_EXT) != n_type && (N_ABS | N_EXT) != n_type)
+ || !sym->n_un.n_strx)
+ continue;
+
+ // Only search from the last *sep* in the symbol.
+ // but skip the leading '_' in all symbols first.
+ symname = symbolname(file, sym) + 1;
+ if (symname[0] != kCPPSymbolPrefix[0]
+ || symname[1] != kCPPSymbolPrefix[1])
+ continue;
+
+ suffix = symname + strlen(symname) - sizeof(k31SuperClassSuffix) + 1;
+ if (suffix <= symname || strcmp(suffix, k31SuperClassSuffix))
+ continue;
+
+ // Got a candidate so hand it over for class processing.
+ cnamelen = suffix - symname - sizeof(kOSObjPrefix) + 2;
+ return_if(cnamelen + 1 >= (int) sizeof(classname),
+ false, ("Symbol %s is too long", symname));
+
+ bcopy(symname + sizeof(kOSObjPrefix) - 2, classname, cnamelen);
+ classname[cnamelen] = '\0';
+ if (!recordClass(file, classname, sym))
+ return false;
+ }
+
+ return_if(!file->fClassList, false, ("Internal error, "
+ "getMetaClassGraph(%s) found no classes", file->fPath));
+
+ DEBUG_LOG(("Found %ld classes in %p for %s\n",
+ DataGetLength(file->fClassList)/sizeof(void*),
+ file->fClassList, file->fPath));
+
+ return true;
+}
+
+static Boolean mergeOSObjectsForFile(const struct fileRecord *file)
+{
+ int i, nmerged;
+ Boolean foundDuplicates = false;
+
+ DEBUG_LOG(("Merging file %s\n", file->fPath)); // @@@ gvdl:
+
+ if (!file->fClassList)
+ return true;
+
+ if (!sMergedFiles) {
+ sMergedFiles = DataCreate(0);
+ return_if(!sMergedFiles, false,
+ ("Unable to allocate memory metaclass list\n", file->fPath));
+ }
+
+ // Check to see if we have already merged this file
+ nmerged = DataGetLength(sMergedFiles) / sizeof(struct fileRecord *);
+ for (i = 0; i < nmerged; i++) {
+ if (file == ((void **) DataGetPtr(sMergedFiles))[i])
+ return true;
+ }
+
+ if (!sMergeMetaClasses) {
+ sMergeMetaClasses = DataCreate(0);
+ return_if(!sMergeMetaClasses, false,
+ ("Unable to allocate memory metaclass list\n", file->fPath));
+ }
+ else { /* perform a duplicate check */
+ int i, j, cnt1, cnt2;
+ struct metaClassRecord **list1, **list2;
+
+ list1 = (struct metaClassRecord **) DataGetPtr(file->fClassList);
+ cnt1 = DataGetLength(file->fClassList) / sizeof(*list1);
+ list2 = (struct metaClassRecord **) DataGetPtr(sMergeMetaClasses);
+ cnt2 = DataGetLength(sMergeMetaClasses) / sizeof(*list2);
+
+ for (i = 0; i < cnt1; i++) {
+ for (j = 0; j < cnt2; j++) {
+ if (!strcmp(list1[i]->fClassName, list2[j]->fClassName)) {
+ errprintf("duplicate class %s in %s & %s\n",
+ list1[i]->fClassName,
+ file->fPath, list2[j]->fFile->fPath);
+ }
+ }
+ }
+ }
+ if (foundDuplicates)
+ return false;
+
+ return_if(!DataAppendBytes(sMergedFiles, &file, sizeof(file)), false,
+ ("Unable to allocate memory to merge %s\n", file->fPath));
+
+ return_if(!DataAppendData(sMergeMetaClasses, file->fClassList), false,
+ ("Unable to allocate memory to merge %s\n", file->fPath));
+
+ if (file == sKernelFile)
+ sMergedKernel = true;
+
+ return true;
+}
+
+// Returns a pointer to the base of the section offset by the sections
+// base address. The offset is so that we can add nlist::n_values directly
+// to this address and get a valid pointer in our memory.
+static unsigned char *
+getSectionForSymbol(const struct fileRecord *file, const struct nlist *symb,
+ void ***endP)
+{
+ const struct section *section;
+ unsigned char sectind;
+ unsigned char *base;
+
+ sectind = symb->n_sect; // Default to symbols section
+ if ((symb->n_type & N_TYPE) == N_ABS && file->fIsKernel) {
+ // Absolute symbol so we have to iterate over our sections
+ for (sectind = 1; sectind <= file->fNSects; sectind++) {
+ unsigned long start, end;
+
+ section = file->fSections[sectind - 1].fSection;
+ start = section->addr;
+ end = start + section->size;
+ if (start <= symb->n_value && symb->n_value < end) {
+ // Found the relevant section
+ break;
+ }
+ }
+ }
+
+ // Is the vtable in a valid section?
+ return_if(sectind == NO_SECT || sectind > file->fNSects,
+ (unsigned char *) -1,
+ ("%s isn't a valid kext, bad section reference\n", file->fPath));
+
+ section = file->fSections[sectind - 1].fSection;
+
+ // for when we start walking the vtable so compute offset's now.
+ base = file->fMachO + section->offset;
+ *endP = (void **) (base + section->size);
+
+ return base - section->addr; // return with addr offset
+}
+
+static Boolean resolveKernelVTable(struct metaClassRecord *metaClass)
+{
+ const struct fileRecord *file;
+ struct patchRecord *patchedVTable;
+ void **curEntry, **vtableEntries, **endSection;
+ unsigned char *sectionBase;
+ struct patchRecord *curPatch;
+ int classSize;
+
+ // Should never occur but it doesn't cost us anything to check.
+ if (metaClass->fPatchedVTable)
+ return true;
+
+ DEBUG_LOG(("Kernel vtable %s\n", metaClass->fClassName)); // @@@ gvdl:
+
+ // Do we have a valid vtable to patch?
+ return_if(!metaClass->fVTableSym,
+ false, ("Internal error - no class vtable symbol?\n"));
+
+ file = metaClass->fFile;
+
+ // If the metaClass we are being to ask is in the kernel then we
+ // need to do a quick scan to grab the fPatchList in a reliable format
+ // however we don't need to check the superclass in the kernel
+ // as the kernel vtables are always correct wrt themselves.
+ // Note this ends the superclass chain recursion.
+ return_if(!file->fIsKernel,
+ false, ("Internal error - resolveKernelVTable not kernel\n"));
+
+ if (file->fNoKernelExecutable) {
+ // Oh dear attempt to map the kernel's VM into my memory space
+ return_if(file->fNoKernelExecutable, false,
+ ("Internal error - fNoKernelExecutable not implemented yet\n"));
+ }
+
+ // We are going to need the base and the end
+ sectionBase = getSectionForSymbol(file, metaClass->fVTableSym, &endSection);
+ if (-1 == (long) sectionBase)
+ return false;
+
+ vtableEntries = (void **) (sectionBase + metaClass->fVTableSym->n_value);
+ curEntry = vtableEntries + kVTablePreambleLen;
+ for (classSize = 0; curEntry < endSection && *curEntry; classSize++)
+ curEntry++;
+
+ return_if(*curEntry, false, ("Bad kernel image, short section\n"));
+
+ patchedVTable = (struct patchRecord *)
+ malloc((classSize + 1) * sizeof(struct patchRecord));
+ return_if(!patchedVTable, false, ("resolveKernelVTable - no memory\n"));
+
+ // Copy the vtable of this class into the patch table
+ curPatch = patchedVTable;
+ curEntry = vtableEntries + kVTablePreambleLen;
+ for (; *curEntry; curEntry++, curPatch++) {
+ curPatch->fSymbol = (struct nlist *)
+ findSymbolByAddress(file, *curEntry);
+ curPatch->fType = kSymbolLocal;
+ }
+
+ // Tag the end of the patch vtable
+ curPatch->fSymbol = NULL;
+ metaClass->fPatchedVTable = patchedVTable;
+
+ return true;
+}
+
+static const char *addNewString(struct fileRecord *file,
+ const char *strname, int namelen)
+{
+ DataRef strings = 0;
+ const char *newStr;
+
+ namelen++; // Include terminating '\0';
+
+ // Make sure we have a string table as well for this symbol
+ if (file->fNewStringBlocks) {
+ DataRef *blockTable = (DataRef *) DataGetPtr(file->fNewStringBlocks);
+ int index = DataGetLength(file->fNewStringBlocks) / sizeof(DataRef*);
+ strings = blockTable[index - 1];
+ if (DataRemaining(strings) < namelen)
+ strings = 0;
+ }
+ else
+ {
+ file->fNewStringBlocks = DataCreate(0);
+ return_if(!file->fNewStringBlocks, NULL,
+ ("Unable to allocate new string table %s\n", file->fPath));
+ }
+
+ if (!strings) {
+ int size = (namelen + 1023) & ~1023;
+ if (size < 16 * 1024)
+ size = 16 * 1024;
+ strings = DataCreate(size);
+ return_if(!strings, NULL,
+ ("Unable to allocate new string block %s\n", file->fPath));
+ return_if(
+ !DataAppendBytes(file->fNewStringBlocks, &strings, sizeof(strings)),
+ false, ("Unable to allocate string table for %s\n", file->fPath));
+ }
+
+ newStr = DataGetEndPtr(strings);
+ DataAppendBytes(strings, strname, namelen);
+ return newStr;
+}
+
+// reloc->fPatch must contain a valid pointer
+static struct nlist *
+getNewSymbol(struct fileRecord *file,
+ const struct relocRecord *reloc, const char *supername)
+{
+ unsigned int size, i;
+ struct nlist **sym;
+ struct nlist *msym;
+ struct relocation_info *rinfo;
+ const char *newStr;
+
+ if (!file->fNewSymbols) {
+ file->fNewSymbols = DataCreate(0);
+ return_if(!file->fNewSymbols, NULL,
+ ("Unable to allocate new symbol table for %s\n", file->fPath));
+ }
+
+ rinfo = (struct relocation_info *) reloc->fRInfo;
+ size = DataGetLength(file->fNewSymbols) / sizeof(struct nlist *);
+ sym = (struct nlist **) DataGetPtr(file->fNewSymbols);
+ for (i = 0; i < size; i++, sym++) {
+ int symnum = i + file->fSymtab->nsyms;
+ newStr = symNameByIndex(file, symnum);
+ if (!strcmp(newStr, supername)) {
+ rinfo->r_symbolnum = symnum;
+ file->fSymbolsDirty = true;
+ return *sym;
+ }
+ }
+
+ // Assert that this is a vaild symbol. I need this condition to be true
+ // for the later code to make non-zero. So the first time through I'd
+ // better make sure that it is 0.
+ return_if(reloc->fSymbol->n_sect, NULL,
+ ("Undefined symbol entry with non-zero section %s:%s\n",
+ file->fPath, symbolname(file, reloc->fSymbol)));
+
+ // If we are here we didn't find the symbol so create a new one now
+ msym = (struct nlist *) malloc(sizeof(struct nlist));
+ return_if(!msym,
+ NULL, ("Unable to create symbol table entry for %s", file->fPath));
+ return_if(!DataAppendBytes(file->fNewSymbols, &msym, sizeof(msym)),
+ NULL, ("Unable to grow symbol table for %s\n", file->fPath));
+
+ newStr = addNewString(file, supername, strlen(supername));
+ if (!newStr)
+ return NULL;
+ // If we are here we didn't find the symbol so create a new one now
+ return_if(!DataAppendBytes(file->fSym2Strings, &newStr, sizeof(newStr)),
+ NULL, ("Unable to grow symbol table for %s\n", file->fPath));
+ file->fSymbToStringTable = (const char **) DataGetPtr(file->fSym2Strings);
+
+ // Offset the string index by the original string table size
+ // and negate the address to indicate that this is a 'new' symbol
+ msym->n_un.n_strx = -1;
+ msym->n_type = (N_EXT | N_UNDF);
+ msym->n_sect = NO_SECT;
+ msym->n_desc = 0;
+ msym->n_value = (unsigned long) newStr;
+
+ // Mark the old symbol as being potentially deletable I can use the
+ // n_sect field as the input symbol must be of type N_UNDF which means
+ // that the n_sect field must be set to NO_SECT otherwise it is an
+ // in valid input file.
+ ((struct nlist *) reloc->fSymbol)->n_un.n_strx
+ = -reloc->fSymbol->n_un.n_strx;
+ ((struct nlist *) reloc->fSymbol)->n_sect = (unsigned char) -1;
+
+ rinfo->r_symbolnum = i + file->fSymtab->nsyms;
+ file->fSymbolsDirty = true;
+ return msym;
+}
+
+static struct nlist *
+fixOldSymbol(struct fileRecord *file,
+ const struct relocRecord *reloc, const char *supername)
+{
+ unsigned int namelen;
+ struct nlist *sym = (struct nlist *) reloc->fSymbol;
+ const char *oldname = symbolname(file, sym);
+
+ // assert(sym->n_un.n_strx >= 0);
+
+ namelen = strlen(supername);
+
+ sym->n_un.n_strx = -sym->n_un.n_strx;
+ if (oldname && namelen < strlen(oldname))
+ {
+ // Overwrite old string in string table
+ strcpy((char *) oldname, supername);
+ file->fSymbolsDirty = true;
+ return sym;
+ }
+
+ oldname = addNewString(file, supername, namelen);
+ if (!oldname)
+ return NULL;
+
+ file->fSymbToStringTable[sym - file->fSymbolBase] = oldname;
+ file->fSymbolsDirty = true;
+ return sym;
+}
+
+static enum patchState
+symbolCompare(const struct fileRecord *file,
+ const struct nlist *classsym,
+ const char *supername)
+{
+ const char *classname;
+
+
+ // Check to see if the target function is locally defined
+ // if it is then we can assume this is a local vtable override
+ if ((classsym->n_type & N_TYPE) != N_UNDF)
+ return kSymbolLocal;
+
+ // Check to see if both symbols point to the same symbol name
+ // if so then we are still identical.
+ classname = symbolname(file, classsym);
+ if (!strcmp(classname, supername))
+ return kSymbolIdentical;
+
+ // We know that the target's vtable entry is different from the
+ // superclass' vtable entry. This means that we will have to apply a
+ // patch to the current entry, however before returning lets check to
+ // see if we have a _RESERVEDnnn field 'cause we can use this as a
+ // registration point that must align between vtables.
+ if (strstr(supername, kReservedNamePrefix))
+ return kSymbolMismatch;
+
+ // OK, we have a superclass difference where the superclass doesn't
+ // reference a pad function so assume that the superclass is correct.
+ if (strstr(classname, kReservedNamePrefix))
+ return kSymbolPadUpdate;
+ else
+ return kSymbolSuperUpdate;
+}
+
+static Boolean patchVTable(struct metaClassRecord *metaClass)
+{
+ struct metaClassRecord *super = NULL;
+ struct fileRecord *file;
+ struct patchRecord *patchedVTable;
+ struct relocRecord **curReloc, **vtableRelocs, **endSection;
+ unsigned char *sectionBase;
+ int classSize;
+
+ // Should never occur but it doesn't cost us anything to check.
+ if (metaClass->fPatchedVTable)
+ return true;
+
+ // Do we have a valid vtable to patch?
+ return_if(!metaClass->fVTableSym,
+ false, ("Internal error - no class vtable symbol?\n"));
+
+ file = metaClass->fFile;
+
+ // If the metaClass we are being to ask is in the kernel then we
+ // need to do a quick scan to grab the fPatchList in a reliable format
+ // however we don't need to check the superclass in the kernel
+ // as the kernel vtables are always correct wrt themselves.
+ // Note this ends the superclass chain recursion.
+ return_if(file->fIsKernel,
+ false, ("Internal error - patchVTable shouldn't used for kernel\n"));
+
+ if (!metaClass->fSuperName)
+ return false;
+
+ // The class isn't in the kernel so make sure that the super class
+ // is patched before patching ouselves.
+ super = getClass(sMergeMetaClasses, metaClass->fSuperName);
+ return_if(!super, false, ("Can't find superclass for %s : %s\n",
+ metaClass->fClassName, metaClass->fSuperName));
+
+ // Superclass recursion if necessary
+ if (!super->fPatchedVTable) {
+ Boolean res;
+
+ if (super->fFile->fIsKernel)
+ res = resolveKernelVTable(super);
+ else
+ res = patchVTable(super);
+ if (!res)
+ return false;
+ }
+
+ DEBUG_LOG(("Patching %s\n", metaClass->fClassName)); // @@@ gvdl:
+
+ // We are going to need the base and the end
+
+ sectionBase = getSectionForSymbol(file,
+ metaClass->fVTableSym, (void ***) &endSection);
+ if (-1 == (long) sectionBase)
+ return false;
+
+ vtableRelocs = (struct relocRecord **)
+ (sectionBase + metaClass->fVTableSym->n_value);
+ curReloc = vtableRelocs + kVTablePreambleLen;
+ for (classSize = 0; curReloc < endSection && *curReloc; classSize++)
+ curReloc++;
+
+ return_if(*curReloc, false,
+ ("%s isn't a valid kext, short section\n", file->fPath));
+
+ patchedVTable = (struct patchRecord *)
+ malloc((classSize + 1) * sizeof(struct patchRecord));
+ return_if(!patchedVTable, false, ("patchedVTable - no memory\n"));
+
+ do {
+ struct patchRecord *curPatch;
+ struct nlist *symbol;
+
+ curPatch = patchedVTable;
+ curReloc = vtableRelocs + kVTablePreambleLen;
+
+ // Grab the super table patches if necessary
+ // Can't be patching a kernel table as we don't walk super
+ // class chains in the kernel symbol space.
+ if (super && super->fPatchedVTable) {
+ const struct patchRecord *spp;
+
+ spp = super->fPatchedVTable;
+
+ for ( ; spp->fSymbol; curReloc++, spp++, curPatch++) {
+ const char *supername =
+ symbolname(super->fFile, spp->fSymbol);
+
+ symbol = (struct nlist *) (*curReloc)->fSymbol;
+
+ curPatch->fType = symbolCompare(file, symbol, supername);
+ switch (curPatch->fType) {
+ case kSymbolIdentical:
+ case kSymbolLocal:
+ break;
+
+ case kSymbolSuperUpdate:
+ symbol = getNewSymbol(file, (*curReloc), supername);
+ break;
+
+ case kSymbolPadUpdate:
+ symbol = fixOldSymbol(file, (*curReloc), supername);
+ break;
+
+ case kSymbolMismatch:
+ errprintf("%s is not compatible with its superclass, "
+ "%s superclass changed?\n",
+ metaClass->fClassName, super->fClassName);
+ goto abortPatch;
+
+ default:
+ errprintf("Internal error - unknown patch type\n");
+ goto abortPatch;
+ }
+ if (symbol) {
+ curPatch->fSymbol = symbol;
+ (*curReloc)->fSymbol = symbol;
+ }
+ else
+ goto abortPatch;
+ }
+ }
+
+ // Copy the remainder of this class' vtable into the patch table
+ for (; *curReloc; curReloc++, curPatch++) {
+ // Local reloc symbols
+ curPatch->fType = kSymbolLocal;
+ curPatch->fSymbol = (struct nlist *) (*curReloc)->fSymbol;
+ }
+
+ // Tag the end of the patch vtable
+ curPatch->fSymbol = NULL;
+
+ metaClass->fPatchedVTable = patchedVTable;
+ return true;
+ } while(0);
+
+abortPatch:
+ if (patchedVTable)
+ free(patchedVTable);
+
+ return false;
+}
+
+static Boolean growImage(struct fileRecord *file, vm_size_t delta)
+{
+#if !KERNEL
+ file->fMachOSize += delta;
+ return (file->fMachO + file->fMachOSize <= file->fPadEnd);
+#else /* KERNEL */
+ vm_address_t startMachO, endMachO, endMap;
+ vm_offset_t newMachO;
+ vm_size_t newsize;
+ unsigned long i, last = 0;
+ struct metaClassRecord **classes = NULL;
+ struct sectionRecord *section;
+ kern_return_t ret;
+
+ startMachO = (vm_address_t) file->fMachO;
+ endMachO = startMachO + file->fMachOSize + delta;
+ endMap = (vm_address_t) file->fMap + file->fMapSize;
+
+ // Do we have room in the current mapped image
+ if (endMachO < round_page(endMap)) {
+ file->fMachOSize += delta;
+ return true;
+ }
+
+ newsize = endMachO - startMachO;
+ if (newsize < round_page(file->fMapSize)) {
+ DEBUG_LOG(("Growing image %s by moving\n", file->fPath));
+
+ // We have room in the map if we shift the macho image within the
+ // current map. We will have to patch up pointers into the object.
+ newMachO = (vm_offset_t) file->fMap;
+ bcopy((char *) startMachO, (char *) newMachO, file->fMachOSize);
+ }
+ else if (file->fIsKmem) {
+ // kmem_alloced mapping so we can try a kmem_realloc
+ ret = kmem_realloc(kernel_map,
+ (vm_address_t) file->fMap,
+ (vm_size_t) file->fMapSize,
+ &newMachO,
+ newsize);
+ if (KERN_SUCCESS != ret)
+ return false;
+
+ // If the mapping didn't move then just return
+ if ((vm_address_t) file->fMap == newMachO) {
+ file->fMachOSize = file->fMapSize = newsize;
+ return true;
+ }
+
+ DEBUG_LOG(("Growing image %s by reallocing\n", file->fPath));
+ // We have relocated the kmem image so we are going to have to
+ // move all of the pointers into the image around.
+ }
+ else {
+ DEBUG_LOG(("Growing image %s by allocating\n", file->fPath));
+ // The image doesn't have room for us and I can't kmem_realloc
+ // then I just have to bite the bullet and copy the object code
+ // into a bigger memory segment
+ ret = kmem_alloc(kernel_map, &newMachO, newsize);
+
+ if (KERN_SUCCESS != ret)
+ return false;
+ bcopy((char *) startMachO, (void *) newMachO, file->fMachOSize);
+ file->fIsKmem = true;
+ }
+
+
+ file->fMap = file->fMachO = (unsigned char *) newMachO;
+ file->fMapSize = newsize;
+ file->fMachOSize += delta; // Increment the image size
+
+ // If we are here then we have shifted the object image in memory
+ // I really should change all of my pointers into the image to machO offsets
+ // but I have run out of time. So I'm going to very quickly go over the
+ // cached data structures and add adjustments to the addresses that are
+ // affected. I wonder how long it will take me to get them all.
+ //
+ // For every pointer into the MachO I need to add an adjustment satisfying
+ // the following simultanous equations
+ // addr_old = macho_old + fixed_offset
+ // addr_new = macho_new + fixed_offset therefore:
+ // addr_new = addr_old + (macho_new - macho_old)
+#define REBASE(addr, delta) ( ((vm_address_t) (addr)) += (delta) )
+ delta = newMachO - startMachO;
+
+ // Rebase the cached-in object 'struct symtab_command' pointer
+ REBASE(file->fSymtab, delta);
+
+ // Rebase the cached-in object 'struct nlist' pointer for all symbols
+ REBASE(file->fSymbolBase, delta);
+
+ // Rebase the cached-in object 'struct nlist' pointer for local symbols
+ REBASE(file->fLocalSyms, delta);
+
+ // Rebase the cached-in object 'char' pointer for the string table
+ REBASE(file->fStringBase, delta);
+
+ // Ok now we have to go over all of the relocs one last time
+ // to clean up the pad updates which had their string index negated
+ // to indicate that we have finished with them.
+ section = file->fSections;
+ for (i = 0, last = file->fNSects; i < last; i++, section++)
+ REBASE(section->fSection, delta);
+
+ // We only ever grow images that contain class lists so dont bother
+ // the check if file->fClassList is non-zero 'cause it can't be
+ // assert(file->fClassList);
+ last = DataGetLength(file->fClassList)
+ / sizeof(struct metaClassRecord *);
+ classes = (struct metaClassRecord **) DataGetPtr(file->fClassList);
+ for (i = 0; i < last; i++) {
+ struct patchRecord *patch;
+
+ for (patch = classes[i]->fPatchedVTable; patch->fSymbol; patch++) {
+ vm_address_t symAddr = (vm_address_t) patch->fSymbol;
+
+ // Only need to rebase if the symbol is part of the image
+ // If this is a new symbol then it was independantly allocated
+ if (symAddr >= startMachO && symAddr < endMachO)
+ REBASE(patch->fSymbol, delta);
+ }
+ }
+
+ // Finally rebase all of the string table pointers
+ last = file->fSymtab->nsyms;
+ for (i = 0; i < last; i++)
+ REBASE(file->fSymbToStringTable[i], delta);
+
+#undef REBASE
+
+ return true;
+
+#endif /* KERNEL */
+}
+
+static Boolean
+prepareFileForLink(struct fileRecord *file)
+{
+ unsigned long i, last, numnewsyms, newsymsize, newstrsize;
+ struct sectionRecord *section;
+ struct nlist **symp, *sym;
+ DataRef newStrings, *stringBlocks;
+
+ // If we didn't even do a pseudo 'relocate' and dirty the image
+ // then we can just return now.
+ if (!file->fImageDirty)
+ return true;
+
+DEBUG_LOG(("Linking 2 %s\n", file->fPath)); // @@@ gvdl:
+
+ // We have to go over all of the relocs to repair the damage
+ // that we have done to the image when we did our 'relocation'
+ section = file->fSections;
+ for (i = 0, last = file->fNSects; i < last; i++, section++) {
+ unsigned char *sectionBase;
+ struct relocRecord *rec;
+ unsigned long j, nreloc;
+
+ if (section->fRelocCache) {
+ sectionBase = file->fMachO + section->fSection->offset;
+ nreloc = section->fSection->nreloc;
+ rec = (struct relocRecord *) DataGetPtr(section->fRelocCache);
+
+ // We will need to repair the reloc list
+ for (j = 0; j < nreloc; j++, rec++) {
+ void **entry;
+ struct nlist *sym;
+
+ // Repair Damage to object image
+ entry = (void **) (sectionBase + rec->fRInfo->r_address);
+ *entry = rec->fValue;
+
+ // Check if the symbol that this relocation entry points
+ // to is marked as erasable
+ sym = (struct nlist *) rec->fSymbol;
+ if (sym && sym->n_type == (N_EXT | N_UNDF)
+ && sym->n_sect == (unsigned char) -1) {
+ // It is in use so we better clear the mark
+ sym->n_un.n_strx = -sym->n_un.n_strx;
+ sym->n_sect = NO_SECT;
+ }
+ }
+
+ // Clean up the fRelocCache we don't need it any more.
+ DataRelease(section->fRelocCache);
+ section->fRelocCache = 0;
+ }
+ }
+ file->fImageDirty = false; // Image is clean
+
+ // If we didn't dirty the symbol table then just return
+ if (!file->fSymbolsDirty)
+ return true;
+
+ // calculate total file size increase and check against padding
+ if (file->fNewSymbols) {
+ numnewsyms = DataGetLength(file->fNewSymbols);
+ symp = (struct nlist **) DataGetPtr(file->fNewSymbols);
+ }
+ else {
+ numnewsyms = 0;
+ symp = 0;
+ }
+ numnewsyms /= sizeof(struct nlist *);
+ file->fSymtab->nsyms += numnewsyms;
+
+ // old sting size + 30% rounded up to nearest page
+ newstrsize = file->fSymtab->strsize * 21 / 16;
+ newstrsize = (newstrsize + PAGE_MASK) & ~PAGE_MASK;
+ newStrings = DataCreate(newstrsize);
+ return_if(!newStrings, false,
+ ("Unable to allocate a copy aside buffer, no memory\n"));
+
+ newsymsize = numnewsyms * sizeof(struct nlist);
+ file->fStringBase += newsymsize;
+ file->fSymtab->stroff += newsymsize;
+
+ last = file->fSymtab->nsyms - numnewsyms;
+ newstrsize = 0;
+ DataAppendBytes(newStrings, &newstrsize, 4); // Leading nuls
+ sym = file->fSymbolBase;
+
+ // Pre-compute an already offset new symbol pointer. The offset is the
+ // orignal symbol table.
+ symp -= last;
+ for (i = 0; i < file->fSymtab->nsyms; i++, sym++) {
+ const char *str = symNameByIndex(file, i);
+ int len = strlen(str) + 1;
+ unsigned int strx;
+
+ // Rebase sym in the new symbol region
+ if (i >= last)
+ sym = symp[i];
+
+ if (sym->n_un.n_strx < 0 && sym->n_type == (N_EXT | N_UNDF)
+ && (unsigned char) -1 == sym->n_sect) {
+ // after patching we find that this symbol is no longer in
+ // use. So invalidate it by converting it into an N_ABS
+ // symbol, remove the external bit and null out the name.
+ bzero(sym, sizeof(*sym));
+ sym->n_type = N_ABS;
+ }
+ else {
+ // Repair the symbol for the getNewSymbol case.
+ if (-1 == sym->n_un.n_strx)
+ sym->n_value = 0;
+
+ // Record the offset of the string in the new table
+ strx = DataGetLength(newStrings);
+ return_if(!DataAppendBytes(newStrings, str, len), false,
+ ("Unable to append string, no memory\n"));
+
+ sym->n_un.n_strx = strx;
+ file->fSymbToStringTable[i] = file->fStringBase + strx;
+ }
+ }
+
+ // Don't need the new strings any more
+ last = DataGetLength(file->fNewStringBlocks) / sizeof(DataRef);
+ stringBlocks = (DataRef *) DataGetPtr(file->fNewStringBlocks);
+ for (i = 0; i < last; i++)
+ DataRelease(stringBlocks[i]);
+
+ DataRelease(file->fNewStringBlocks);
+ file->fNewStringBlocks = 0;
+
+ newstrsize = DataGetLength(newStrings);
+ newstrsize = (newstrsize + 3) & ~3; // Round to nearest word
+ return_if(
+ !growImage(file, newsymsize + newstrsize - file->fSymtab->strsize),
+ false, ("Unable to patch the extension, no memory\n", file->fPath));
+
+ // Push out the new symbol table if necessary
+ if (numnewsyms) {
+ caddr_t base;
+
+ // Append the new symbols to the original symbol table.
+ base = (caddr_t) file->fSymbolBase
+ + (file->fSymtab->nsyms - numnewsyms) * sizeof(struct nlist);
+ symp = (struct nlist **) DataGetPtr(file->fNewSymbols);
+ for (i = 0; i < numnewsyms; i++, base += sizeof(struct nlist), symp++)
+ bcopy(*symp, base, sizeof(struct nlist));
+
+ DataRelease(file->fNewSymbols);
+ file->fNewSymbols = 0;
+ }
+
+ // Push out the new string table if necessary
+ if (newStrings) {
+ unsigned long *base = (unsigned long *) file->fStringBase;
+ unsigned long actuallen = DataGetLength(newStrings);
+
+ // Set the last word in string table to zero before copying data
+ base[(newstrsize / sizeof(unsigned long)) - 1] = 0;
+
+ // Now copy the new strings back to the end of the file
+ bcopy((caddr_t) DataGetPtr(newStrings), file->fStringBase, actuallen);
+
+ file->fSymtab->strsize = newstrsize;
+
+ DataRelease(newStrings);
+ }
+
+ file->fSymbolsDirty = false;
+
+ return true;
+}
+
+Boolean
+#if KERNEL
+kld_file_map(const char *pathName,
+ unsigned char *map,
+ size_t mapSize,
+ Boolean isKmem)
+#else
+kld_file_map(const char *pathName)
+#endif /* KERNEL */
+{
+ struct fileRecord file, *fp = 0;
+
+ // Already done no need to repeat
+ fp = getFile(pathName);
+ if (fp)
+ return true;
+
+ bzero(&file, sizeof(file));
+
+#if KERNEL
+ file.fMap = map;
+ file.fMapSize = mapSize;
+ file.fIsKmem = isKmem;
+#else
+ if (!mapObjectFile(&file, pathName))
+ return false;
+#endif /* KERNEL */
+
+ do {
+ const struct machOMapping {
+ struct mach_header h;
+ struct load_command c[1];
+ } *machO;
+ const struct load_command *cmd;
+ int i;
+
+ if (!findBestArch(&file, pathName))
+ break;
+
+ machO = (const struct machOMapping *) file.fMachO;
+ if (file.fMachOSize < machO->h.sizeofcmds)
+ break;
+
+ file.fIsKernel = (MH_EXECUTE == machO->h.filetype);
+
+ // If the file type is MH_EXECUTE then this must be a kernel
+ // as all Kernel extensions must be of type MH_OBJECT
+ for (i = 0, cmd = &machO->c[0]; i < machO->h.ncmds; i++) {
+ if (cmd->cmd == LC_SYMTAB)
+ file.fSymtab = (struct symtab_command *) cmd;
+ else if (cmd->cmd == LC_SEGMENT) {
+ struct segment_command *seg = (struct segment_command *) cmd;
+ int nsects = seg->nsects;
+
+ if (nsects)
+ return_if(!parseSegments(&file, seg),
+ false, ("%s isn't a valid mach-o, bad segment",
+ pathName));
+ else if (file.fIsKernel) {
+#if KERNEL
+ // We don't need to look for the LinkEdit segment unless
+ // we are running in the kernel environment.
+ if (!strcmp(kLinkEditSegName, seg->segname))
+ file.fLinkEditSeg = seg;
+#endif
+ }
+ }
+
+ cmd = (struct load_command *) ((UInt8 *) cmd + cmd->cmdsize);
+ }
+ break_if(!file.fSymtab,
+ ("%s isn't a valid mach-o, no symbols\n", pathName));
+
+ if (!parseSymtab(&file, pathName))
+ break;
+
+ fp = addFile(&file, pathName);
+ if (!fp)
+ break;
+
+ if (file.fFoundOSObject && !getMetaClassGraph(fp))
+ break;
+
+ if (file.fIsKernel)
+ sKernelFile = fp;
+
+#if KERNEL
+ // Automatically load the kernel's link edit segment if we are
+ // attempting to load a driver.
+ if (!sKernelFile) {
+ extern struct mach_header _mh_execute_header;
+ extern struct segment_command *getsegbyname(char *seg_name);
+
+ struct segment_command *sg;
+ size_t kernelSize;
+ Boolean ret;
+
+ sg = (struct segment_command *) getsegbyname(kLinkEditSegName);
+ break_if(!sg, ("Can't find kernel link edit segment\n"));
+
+ kernelSize = sg->vmaddr + sg->vmsize - (size_t) &_mh_execute_header;
+ ret = kld_file_map(kld_basefile_name,
+ (unsigned char *) &_mh_execute_header, kernelSize,
+ /* isKmem */ false);
+ break_if(!ret, ("kld can't map kernel file"));
+ }
+#endif /* KERNEL */
+
+ return true;
+ } while(0);
+
+ // Failure path, then clean up
+ if (fp)
+ // @@@ gvdl: for the time being leak the file ref in the file table
+ removeFile(fp);
+ else
+ unmapFile(&file);
+
+ return false;
+}
+
+void *kld_file_getaddr(const char *pathName, long *size)
+{
+ struct fileRecord *file = getFile(pathName);
+
+ if (!file)
+ return 0;
+
+ if (size)
+ *size = file->fMachOSize;
+
+ return file->fMachO;
+}
+
+void *kld_file_lookupsymbol(const char *pathName, const char *symname)
+{
+ struct fileRecord *file = getFile(pathName);
+ const struct nlist *sym;
+ const struct section *section;
+ unsigned char *sectionBase;
+ unsigned char sectind;
+
+ return_if(!file,
+ NULL, ("Unknown file %s\n", pathName));
+
+ sym = findSymbolByName(file, symname);
+
+ // May be a non-extern symbol so look for it there
+ if (!sym) {
+ unsigned int i, nsyms;
+
+ sym = file->fSymbolBase;
+ for (i = 0, nsyms = file->fSymtab->nsyms; i < nsyms; i++, sym++) {
+ if ( (sym->n_type & N_EXT) ) {
+ sym = 0;
+ break; // Terminate search when we hit an extern
+ }
+ if ( (sym->n_type & N_STAB) )
+ continue;
+ if ( !strcmp(symname, symNameByIndex(file, i)) )
+ break;
+ }
+ }
+
+ return_if(!sym,
+ NULL, ("Unknown symbol %s in %s\n", symname, pathName));
+
+ // Is the vtable in a valid section?
+ sectind = sym->n_sect;
+ return_if(sectind == NO_SECT || sectind > file->fNSects, NULL,
+ ("Malformed object file, invalid section reference for %s in %s\n",
+ symname, pathName));
+
+ section = file->fSections[sectind - 1].fSection;
+ sectionBase = file->fMachO + section->offset - section->addr;
+
+ return (void *) (sectionBase + sym->n_value);
+}
+
+Boolean kld_file_merge_OSObjects(const char *pathName)
+{
+ struct fileRecord *file = getFile(pathName);
+
+ return_if(!file,
+ false, ("Internal error - unable to find file %s\n", pathName));
+
+ return mergeOSObjectsForFile(file);
+}
+
+Boolean kld_file_patch_OSObjects(const char *pathName)
+{
+ struct fileRecord *file = getFile(pathName);
+ struct metaClassRecord **classes;
+ unsigned long i, last;
+
+ return_if(!file,
+ false, ("Internal error - unable to find file %s\n", pathName));
+
+ DEBUG_LOG(("Patch file %s\n", pathName)); // @@@ gvdl:
+
+ // If we don't have any classes we can return now.
+ if (!file->fClassList)
+ return true;
+
+ // If we haven't alread merged the kernel then do it now
+ if (!sMergedKernel && sKernelFile)
+ mergeOSObjectsForFile(sKernelFile);
+ return_if(!sMergedKernel, false, ("Internal error no kernel?\n"));
+
+ if (!mergeOSObjectsForFile(file))
+ return false;
+
+ // Patch all of the classes in this executable
+ last = DataGetLength(file->fClassList) / sizeof(void *);
+ classes = (struct metaClassRecord **) DataGetPtr(file->fClassList);
+ for (i = 0; i < last; i++) {
+ if (!patchVTable(classes[i]))
+ return false;
+ }
+
+ return true;
+}
+
+Boolean kld_file_prepare_for_link()
+{
+ if (sMergedFiles) {
+ unsigned long i, nmerged = 0;
+ struct fileRecord **files;
+
+ // Check to see if we have already merged this file
+ nmerged = DataGetLength(sMergedFiles) / sizeof(struct fileRecord *);
+ files = (struct fileRecord **) DataGetPtr(sMergedFiles);
+ for (i = 0; i < nmerged; i++) {
+ if (!prepareFileForLink(files[i]))
+ return false;
+ }
+ }
+
+ // Clear down the meta class table and merged file lists
+ DataRelease(sMergeMetaClasses);
+ DataRelease(sMergedFiles);
+ sMergedFiles = sMergeMetaClasses = NULL;
+ sMergedKernel = false;
+
+ return true;
+}
+
+void kld_file_cleanup_all_resources()
+{
+ unsigned long i, nfiles;
+
+#if KERNEL // @@@ gvdl:
+ // Debugger("kld_file_cleanup_all_resources");
+#endif
+
+ if (!sFilesTable || !(nfiles = DataGetLength(sFilesTable)))
+ return; // Nothing to do just return now
+
+ nfiles /= sizeof(struct fileRecord *);
+ for (i = 0; i < nfiles; i++)
+ removeFile(((void **) DataGetPtr(sFilesTable))[i]);
+
+ DataRelease(sFilesTable);
+ sFilesTable = NULL;
+
+ // Don't really have to clean up anything more as the whole
+ // malloc engine is going to be released and I couldn't be bothered.
+}
+
+
+#if !KERNEL
+#if 0
+static const struct fileRecord *sortFile;
+static int symCompare(const void *vSym1, const void *vSym2)
+{
+ const struct nlist *sym1 = vSym1;
+ const struct nlist *sym2 = vSym2;
+
+ {
+ unsigned int ind1, ind2;
+
+ ind1 = sym1->n_type & N_TYPE;
+ ind2 = sym2->n_type & N_TYPE;
+ if (ind1 != ind2) {
+ // if sym1 is undefined then sym1 must come later than sym2
+ if (ind1 == N_UNDF)
+ return 1;
+ // if sym2 is undefined then sym1 must come earlier than sym2
+ if (ind2 == N_UNDF)
+ return -1;
+ /* drop out if neither are undefined */
+ }
+ }
+
+ {
+ const struct fileRecord *file = sortFile;
+ const char *name1, *name2;
+
+ name1 = file->fStringBase + sym1->n_un.n_strx;
+ name2 = file->fStringBase + sym2->n_un.n_strx;
+ return strcmp(name1, name2);
+ }
+}
+#endif /* 0 */
+
+Boolean kld_file_debug_dump(const char *pathName, const char *outName)
+{
+ const struct fileRecord *file = getFile(pathName);
+ int fd;
+ Boolean ret = false;
+
+ return_if(!file, false, ("Unknown file %s for dumping\n", pathName));
+
+ fd = open(outName, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+ return_if(-1 == fd, false, ("Can't create output file %s - %s(%d)\n",
+ outName, strerror(errno), errno));
+
+ do {
+#if 0
+ // Sorting doesn't work until I fix the relocs too?
+
+ // sort the symbol table appropriately
+ unsigned int nsyms = file->fSymtab->nsyms
+ - (file->fLocalSyms - file->fSymbolBase);
+ sortFile = file;
+ heapsort((void *) file->fLocalSyms, nsyms, sizeof(struct nlist),
+ symCompare);
+#endif
+
+ break_if(-1 == write(fd, file->fMachO, file->fMachOSize),
+ ("Can't dump output file %s - %s(%d)\n",
+ outName, strerror(errno), errno));
+ ret = true;
+ } while(0);
+
+ close(fd);
+
+ return ret;
+}
+
+#endif /* !KERNEL */
+
projects / apple / system_cmds.git / blobdiff