X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/e2fac8b15b12a7979f72090454d850e612fc5b13..b0d623f7f2ae71ed96e60569f61f9a9a27016e80:/libkern/kernel_mach_header.c diff --git a/libkern/kernel_mach_header.c b/libkern/kernel_mach_header.c new file mode 100644 index 000000000..e0830d99d --- /dev/null +++ b/libkern/kernel_mach_header.c @@ -0,0 +1,363 @@ +/* + * Copyright (c) 2000-2008 Apple Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * 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 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ 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, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ +/* + * File: libkern/kernel_mach_header.c + * + * Functions for accessing mach-o headers. + * + * NOTE: This file supports only kernel mach headers at the present + * time; it's primary use is by kld, and all externally + * referenced routines at the present time operate against + * the kernel mach header _mh_execute_header, which is the + * header for the currently executing kernel. + * + */ + +#include +#include +#include +#include // from libsa + +/* + * return the last address (first avail) + * + * This routine operates against the currently executing kernel only + */ +vm_offset_t +getlastaddr(void) +{ + kernel_segment_command_t *sgp; + vm_offset_t last_addr = 0; + kernel_mach_header_t *header = &_mh_execute_header; + unsigned long i; + + sgp = (kernel_segment_command_t *) + ((uintptr_t)header + sizeof(kernel_mach_header_t)); + for (i = 0; i < header->ncmds; i++){ + if ( sgp->cmd == LC_SEGMENT_KERNEL) { + if (sgp->vmaddr + sgp->vmsize > last_addr) + last_addr = sgp->vmaddr + sgp->vmsize; + } + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + return last_addr; +} + +/* + * This routine returns the a pointer to the data for the named section in the + * named segment if it exist in the mach header passed to it. Also it returns + * the size of the section data indirectly through the pointer size. Otherwise + * it returns zero for the pointer and the size. + * + * This routine can operate against any kernel mach header. + */ +void * +getsectdatafromheader( + kernel_mach_header_t *mhp, + const char *segname, + const char *sectname, + unsigned long *size) +{ + const kernel_section_t *sp; + void *result; + + sp = getsectbynamefromheader(mhp, segname, sectname); + if(sp == (kernel_section_t *)0){ + *size = 0; + return((char *)0); + } + *size = sp->size; + result = (void *)sp->addr; + return result; +} + +/* + * This routine returns the a pointer to the data for the named segment + * if it exist in the mach header passed to it. Also it returns + * the size of the segment data indirectly through the pointer size. + * Otherwise it returns zero for the pointer and the size. + */ +void * +getsegdatafromheader( + kernel_mach_header_t *mhp, + const char *segname, + unsigned long *size) +{ + const kernel_segment_command_t *sc; + void *result; + + sc = getsegbynamefromheader(mhp, segname); + if(sc == (kernel_segment_command_t *)0){ + *size = 0; + return((char *)0); + } + *size = sc->vmsize; + result = (void *)sc->vmaddr; + return result; +} + +/* + * This routine returns the section structure for the named section in the + * named segment for the mach_header pointer passed to it if it exist. + * Otherwise it returns zero. + * + * This routine can operate against any kernel mach header. + */ +kernel_section_t * +getsectbynamefromheader( + kernel_mach_header_t *mhp, + const char *segname, + const char *sectname) +{ + kernel_segment_command_t *sgp; + kernel_section_t *sp; + unsigned long i, j; + + sgp = (kernel_segment_command_t *) + ((uintptr_t)mhp + sizeof(kernel_mach_header_t)); + for(i = 0; i < mhp->ncmds; i++){ + if(sgp->cmd == LC_SEGMENT_KERNEL) + if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0 || + mhp->filetype == MH_OBJECT){ + sp = (kernel_section_t *)((uintptr_t)sgp + + sizeof(kernel_segment_command_t)); + for(j = 0; j < sgp->nsects; j++){ + if(strncmp(sp->sectname, sectname, + sizeof(sp->sectname)) == 0 && + strncmp(sp->segname, segname, + sizeof(sp->segname)) == 0) + return(sp); + sp = (kernel_section_t *)((uintptr_t)sp + + sizeof(kernel_section_t)); + } + } + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + return((kernel_section_t *)NULL); +} + +/* + * This routine can operate against any kernel mach header. + */ +kernel_segment_command_t * +getsegbynamefromheader( + kernel_mach_header_t *header, + const char *seg_name) +{ + kernel_segment_command_t *sgp; + unsigned long i; + + sgp = (kernel_segment_command_t *) + ((uintptr_t)header + sizeof(kernel_mach_header_t)); + for (i = 0; i < header->ncmds; i++){ + if ( sgp->cmd == LC_SEGMENT_KERNEL + && !strncmp(sgp->segname, seg_name, sizeof(sgp->segname))) + return sgp; + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + return (kernel_segment_command_t *)NULL; +} + +/* + * Return the first segment_command in the header. + */ +kernel_segment_command_t * +firstseg(void) +{ + return firstsegfromheader(&_mh_execute_header); +} + +kernel_segment_command_t * +firstsegfromheader(kernel_mach_header_t *header) +{ + u_int i = 0; + kernel_segment_command_t *sgp = (kernel_segment_command_t *) + ((uintptr_t)header + sizeof(*header)); + + for (i = 0; i < header->ncmds; i++){ + if (sgp->cmd == LC_SEGMENT_KERNEL) + return sgp; + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + return (kernel_segment_command_t *)NULL; +} + +/* + * This routine operates against any kernel mach segment_command structure + * pointer and the provided kernel header, to obtain the sequentially next + * segment_command structure in that header. + */ +kernel_segment_command_t * +nextsegfromheader( + kernel_mach_header_t *header, + kernel_segment_command_t *seg) +{ + u_int i = 0; + kernel_segment_command_t *sgp = (kernel_segment_command_t *) + ((uintptr_t)header + sizeof(*header)); + + /* Find the index of the passed-in segment */ + for (i = 0; sgp != seg && i < header->ncmds; i++) { + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + + /* Increment to the next load command */ + i++; + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + + /* Return the next segment command, if any */ + for (; i < header->ncmds; i++) { + if (sgp->cmd == LC_SEGMENT_KERNEL) return sgp; + + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + + return (kernel_segment_command_t *)NULL; +} + + +/* + * Return the address of the named Mach-O segment from the currently + * executing kernel kernel, or NULL. + */ +kernel_segment_command_t * +getsegbyname(const char *seg_name) +{ + return(getsegbynamefromheader(&_mh_execute_header, seg_name)); +} + +/* + * This routine returns the a pointer the section structure of the named + * section in the named segment if it exists in the currently executing + * kernel, which it is presumed to be linked into. Otherwise it returns NULL. + */ +kernel_section_t * +getsectbyname( + const char *segname, + const char *sectname) +{ + return(getsectbynamefromheader( + (kernel_mach_header_t *)&_mh_execute_header, segname, sectname)); +} + +/* + * This routine can operate against any kernel segment_command structure to + * return the first kernel section immediately following that structure. If + * there are no sections associated with the segment_command structure, it + * returns NULL. + */ +kernel_section_t * +firstsect(kernel_segment_command_t *sgp) +{ + if (!sgp || sgp->nsects == 0) + return (kernel_section_t *)NULL; + + return (kernel_section_t *)(sgp+1); +} + +/* + * This routine can operate against any kernel segment_command structure and + * kernel section to return the next consecutive kernel section immediately + * following the kernel section provided. If there are no sections following + * the provided section, it returns NULL. + */ +kernel_section_t * +nextsect(kernel_segment_command_t *sgp, kernel_section_t *sp) +{ + kernel_section_t *fsp = firstsect(sgp); + + if (((uintptr_t)(sp - fsp) + 1) >= sgp->nsects) + return (kernel_section_t *)NULL; + + return sp+1; +} + +#ifdef MACH_KDB +/* + * This routine returns the section command for the symbol table in the + * named segment for the mach_header pointer passed to it if it exist. + * Otherwise it returns zero. + */ +static struct symtab_command * +getsectcmdsymtabfromheader( + kernel_mach_header_t *mhp) +{ + kernel_segment_command_t *sgp; + unsigned long i; + + sgp = (kernel_segment_command_t *) + ((uintptr_t)mhp + sizeof(kernel_mach_header_t)); + for(i = 0; i < mhp->ncmds; i++){ + if(sgp->cmd == LC_SYMTAB) + return((struct symtab_command *)sgp); + sgp = (kernel_segment_command_t *)((uintptr_t)sgp + sgp->cmdsize); + } + return((struct symtab_command *)NULL); +} + +boolean_t getsymtab(kernel_mach_header_t *header, + vm_offset_t *symtab, + int *nsyms, + vm_offset_t *strtab, + vm_size_t *strtabsize) +{ + kernel_segment_command_t *seglink_cmd; + struct symtab_command *symtab_cmd; + + seglink_cmd = NULL; + + if((header->magic != MH_MAGIC) + && (header->magic != MH_MAGIC_64)) { /* Check if this is a valid header format */ + return (FALSE); /* Bye y'all... */ + } + + seglink_cmd = getsegbynamefromheader(header,"__LINKEDIT"); + if (seglink_cmd == NULL) { + return(FALSE); + } + + symtab_cmd = NULL; + symtab_cmd = getsectcmdsymtabfromheader(header); + if (symtab_cmd == NULL) + return(FALSE); + + *nsyms = symtab_cmd->nsyms; + if(symtab_cmd->nsyms == 0) return (FALSE); /* No symbols */ + + *strtabsize = symtab_cmd->strsize; + if(symtab_cmd->strsize == 0) return (FALSE); /* Symbol length is 0 */ + + *symtab = seglink_cmd->vmaddr + symtab_cmd->symoff - + seglink_cmd->fileoff; + + *strtab = seglink_cmd->vmaddr + symtab_cmd->stroff - + seglink_cmd->fileoff; + + return(TRUE); +} +#endif