+++ /dev/null
-/*
- * Copyright (c) 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@
- */
-#include <string.h>
-
-#if !KERNEL
- #include <libkern/OSByteOrder.h>
-#endif
-
-#define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
-#include <AssertMacros.h>
-
-#include "kxld_array.h"
-#include "kxld_dict.h"
-#include "kxld_kext.h"
-#include "kxld_state.h"
-#include "kxld_sym.h"
-#include "kxld_symtab.h"
-#include "kxld_util.h"
-#include "kxld_vtable.h"
-
-#define LINK_STATE_MAGIC 0xF00DD00D
-#define CIGAM_ETATS_KNIL 0x0DD00DF0
-
-#define LINK_STATE_MAGIC_64 0xCAFEF00D
-#define CIGAM_ETATS_KNIL_64 0x0DF0FECA
-
-#define LINK_STATE_VERSION 1
-
-static kern_return_t init_string_index(KXLDDict *strings, KXLDArray *tmps,
- KXLDSymtabIterator *iter, const KXLDArray *vtables, u_int nsymentries,
- u_long *strsize);
-static kern_return_t add_string_to_index(KXLDDict *strings, const char *str,
- KXLDArray *tmps, u_int *tmpi, u_long *stroff);
-static kern_return_t create_link_state(u_char **_file, u_long *_filesize,
- const KXLDKext *kext, KXLDSymtabIterator *iter, const KXLDArray *vtables,
- KXLDDict *strings, u_int nsyms, u_int nsymentries, u_long strsize);
-static boolean_t state_is_32_bit(KXLDLinkStateHdr *state);
-
-#if KXLD_USER_OR_ILP32
-static kern_return_t get_symbols_32(KXLDState *state, KXLDDict *defined_symbols,
- KXLDDict *obsolete_symbols);
-static kern_return_t copy_symbols_32(u_char *file, u_long *data_offset,
- KXLDSymtabIterator *iter, const KXLDDict *strings);
-static kern_return_t copy_vtables_32(u_char *file, u_long *header_offset,
- u_long *data_offset, const KXLDArray *vtables, const KXLDDict *strings);
-#endif /* KXLD_USER_OR_ILP32*/
-#if KXLD_USER_OR_LP64
-static kern_return_t get_symbols_64(KXLDState *state, KXLDDict *defined_symbols,
- KXLDDict *obsolete_symbols);
-static kern_return_t copy_symbols_64(u_char *file, u_long *data_offset,
- KXLDSymtabIterator *iter, const KXLDDict *strings);
-static kern_return_t copy_vtables_64(u_char *file, u_long *header_offset,
- u_long *data_offset, const KXLDArray *vtables, const KXLDDict *strings);
-#endif /* KXLD_USER_OR_ILP64 */
-
-#if !KERNEL
-static boolean_t swap_link_state(u_char *state);
-static void swap_link_state_32(u_char *state);
-static void swap_link_state_64(u_char *state);
-static boolean_t unswap_link_state(u_char *state);
-static void unswap_link_state_32(u_char *state);
-static void unswap_link_state_64(u_char *state);
-static void swap_state_hdr(KXLDLinkStateHdr *state_hdr);
-static void swap_vtable_hdr(KXLDVTableHdr *vtable_hdr);
-static void swap_sym_entry_32(KXLDSymEntry32 *entry);
-static void swap_sym_entry_64(KXLDSymEntry64 *entry);
-#endif
-
-/*******************************************************************************
-*******************************************************************************/
-kern_return_t
-kxld_state_init_from_file(KXLDState *state, u_char *file,
- KXLDArray *section_order __unused)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) file;
-#if KXLD_USER_OR_OBJECT
- KXLDSectionName *dstname = NULL;
- KXLDSectionName *srcname = NULL;
-#endif
- KXLDVTableHdr *vhdr = NULL;
- KXLDVTable *vtable = NULL;
- u_int i = 0;
-
- check(state);
- check(file);
-
-#if !KERNEL
- /* Swap the link state file to host byte order for as long this kxld_state
- * object owns the file.
- */
- state->swap = swap_link_state(file);
-#endif
- require_action(hdr->magic == LINK_STATE_MAGIC ||
- hdr->magic == LINK_STATE_MAGIC_64,
- finish, rval=KERN_FAILURE);
-
- state->file = file;
-
-#if KXLD_USER_OR_OBJECT
- if (section_order && !section_order->nitems && hdr->nsects) {
- rval = kxld_array_init(section_order, sizeof(*dstname), hdr->nsects);
- require_noerr(rval, finish);
-
- srcname = (KXLDSectionName *) (file + hdr->sectoff);
- for (i = 0; i < hdr->nsects; ++i, ++srcname) {
- dstname = kxld_array_get_item(section_order, i);
- memcpy(dstname, srcname, sizeof(*srcname));
- }
- }
-#endif
-
- rval = kxld_array_init(&state->vtables, sizeof(*vtable), hdr->nvtables);
- require_noerr(rval, finish);
-
- vhdr = (KXLDVTableHdr *) (file + hdr->voff);
- for (i = 0; i < hdr->nvtables; ++i, ++vhdr) {
- vtable = kxld_array_get_item(&state->vtables, i);
- KXLD_3264_FUNC(kxld_is_32_bit(hdr->cputype), rval,
- kxld_vtable_init_from_link_state_32,
- kxld_vtable_init_from_link_state_64,
- vtable, file, vhdr);
- require_noerr(rval, finish);
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-void
-kxld_state_clear(KXLDState *state)
-{
- KXLDVTable *vtable = NULL;
- u_int i = 0;
-
- check(state);
-
-#if !KERNEL
- /* We use kxld_state objects to wrap the link state files. Whenever the
- * file is wrapped by a kxld_state object, the file is kept in host byte
- * order. Once we are done, we must return it to target byte order.
- */
- if (state->swap) (void)unswap_link_state(state->file);
-#endif
-
- state->file = NULL;
- state->swap = FALSE;
- for (i = 0; i < state->vtables.nitems; ++i) {
- vtable = kxld_array_get_item(&state->vtables, i);
- kxld_vtable_clear(vtable);
- }
- kxld_array_reset(&state->vtables);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-void
-kxld_state_deinit(KXLDState *state)
-{
- KXLDVTable *vtable = NULL;
- u_int i = 0;
-
- check(state);
-
-#if !KERNEL
- if (state->file && state->swap) (void)unswap_link_state(state->file);
-#endif
-
- for (i = 0; i < state->vtables.maxitems; ++i) {
- vtable = kxld_array_get_slot(&state->vtables, i);
- kxld_vtable_deinit(vtable);
- }
- kxld_array_deinit(&state->vtables);
- bzero(state, sizeof(*state));
-}
-
-/*******************************************************************************
-*******************************************************************************/
-u_int
-kxld_state_get_num_symbols(KXLDState *state)
-{
- KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
-
- return hdr->nsyms;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-kern_return_t
-kxld_state_get_symbols(KXLDState *state, KXLDDict *defined_symbols,
- KXLDDict *obsolete_symbols)
-{
- KXLDLinkStateHdr * hdr = (KXLDLinkStateHdr *) state->file;
- kern_return_t rval = KERN_FAILURE;
-
- check(state);
- check(defined_symbols);
- check(obsolete_symbols);
-
- require_action(hdr->magic == LINK_STATE_MAGIC ||
- hdr->magic == LINK_STATE_MAGIC_64,
- finish, rval=KERN_FAILURE);
-
- KXLD_3264_FUNC(state_is_32_bit(hdr), rval,
- get_symbols_32, get_symbols_64,
- state, defined_symbols, obsolete_symbols);
- require_noerr(rval, finish);
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-
-#if KXLD_USER_OR_ILP32
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-get_symbols_32(KXLDState *state, KXLDDict *defined_symbols,
- KXLDDict *obsolete_symbols)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
- KXLDSymEntry32 *entry = NULL;
- const char *name = NULL;
- u_int i = 0;
-
- entry = (KXLDSymEntry32 *) (state->file + hdr->symoff);
- for (i = 0; i < hdr->nsyms; ++i, ++entry) {
- name = (const char *) (state->file + entry->nameoff);
- rval = kxld_dict_insert(defined_symbols, name, &entry->addr);
- require_noerr(rval, finish);
-
- if (entry->flags & KXLD_SYM_OBSOLETE) {
- rval = kxld_dict_insert(obsolete_symbols, name, &entry->addr);
- require_noerr(rval, finish);
- }
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-#endif /* KXLD_USER_OR_ILP32 */
-
-#if KXLD_USER_OR_LP64
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-get_symbols_64(KXLDState *state, KXLDDict *defined_symbols,
- KXLDDict *obsolete_symbols)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
- KXLDSymEntry64 *entry = NULL;
- const char *name = NULL;
- u_int i = 0;
-
- entry = (KXLDSymEntry64 *) (state->file + hdr->symoff);
- for (i = 0; i < hdr->nsyms; ++i, ++entry) {
- name = (const char *) (state->file + entry->nameoff);
- rval = kxld_dict_insert(defined_symbols, name, &entry->addr);
- require_noerr(rval, finish);
-
- if (entry->flags & KXLD_SYM_OBSOLETE) {
- rval = kxld_dict_insert(obsolete_symbols, name, &entry->addr);
- require_noerr(rval, finish);
- }
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-#endif /* KXLD_USER_OR_LP64 */
-
-/*******************************************************************************
-*******************************************************************************/
-u_int
-kxld_state_get_num_vtables(KXLDState *state)
-{
- return state->vtables.nitems;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-kern_return_t
-kxld_state_get_vtables(KXLDState *state, KXLDDict *patched_vtables)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDVTable *vtable = NULL;
- u_int i = 0;
-
- check(state);
- check(patched_vtables);
-
- for (i = 0; i < state->vtables.nitems; ++i) {
- vtable = kxld_array_get_item(&state->vtables, i);
- rval = kxld_dict_insert(patched_vtables, vtable->name, vtable);
- require_noerr(rval, finish);
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-void
-kxld_state_get_cputype(const KXLDState *state, cpu_type_t *cputype,
- cpu_subtype_t *cpusubtype)
-{
- KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
-
- check(state);
- check(cputype);
- check(cpusubtype);
-
- *cputype = hdr->cputype;
- *cpusubtype = hdr->cpusubtype;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-kern_return_t
-kxld_state_export_kext_to_file(KXLDKext *kext, u_char **file, u_long *filesize,
- KXLDDict *strings, KXLDArray *tmps)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDSymtabIterator iter;
- const KXLDSymtab *symtab = NULL;
- const KXLDArray *vtables = NULL;
- const KXLDVTable *vtable = NULL;
- u_int nsyms = 0;
- u_int nsymentries = 0;
- u_int i = 0;
- u_long strsize = 0;
-
- check(kext);
- check(file);
- check(tmps);
-
- bzero(&iter, sizeof(iter));
-
- /* Get the vtables and symbol tables from the kext */
-
- kxld_kext_get_vtables(kext, &vtables);
- symtab = kxld_kext_get_symtab(kext);
- require_action(symtab, finish, rval=KERN_FAILURE);
-
- /* Count the number of symentries we'll need in the linkstate */
-
- kxld_symtab_iterator_init(&iter, symtab, kxld_sym_is_exported, FALSE);
-
- nsyms = kxld_symtab_iterator_get_num_remaining(&iter);
- nsymentries = nsyms;
- for (i = 0; i < vtables->nitems; ++i) {
- vtable = kxld_array_get_item(vtables, i);
- nsymentries += vtable->entries.nitems;
- }
-
- /* Initialize the string index */
-
- rval = init_string_index(strings, tmps, &iter, vtables, nsymentries,
- &strsize);
- require_noerr(rval, finish);
-
- /* Create the linkstate file */
-
- rval = create_link_state(file, filesize, kext, &iter, vtables,
- strings, nsyms, nsymentries, strsize);
- require_noerr(rval, finish);
-
- /* Swap if necessary */
-
-#if !KERNEL
- if (kxld_kext_target_needs_swap(kext)) unswap_link_state(*file);
-#endif /* !KERNEL */
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-init_string_index(KXLDDict *strings, KXLDArray *tmps, KXLDSymtabIterator *iter,
- const KXLDArray *vtables, u_int nsymentries, u_long *_strsize)
-{
- kern_return_t rval = KERN_SUCCESS;
- const KXLDSym *sym = NULL;
- const KXLDVTable *vtable = NULL;
- const KXLDVTableEntry *ventry = NULL;
- u_long strsize = 0;
- u_int tmpi = 0;
- u_int i = 0;
- u_int j = 0;
-
- check(strings);
- check(tmps);
- check(iter);
- check(vtables);
- check(_strsize);
-
- *_strsize = 0;
-
- /* Initialize the string dictionary and string offset array */
-
- rval = kxld_dict_init(strings, kxld_dict_string_hash, kxld_dict_string_cmp,
- nsymentries);
- require_noerr(rval, finish);
-
- rval = kxld_array_init(tmps, sizeof(u_long), nsymentries);
- require_noerr(rval, finish);
-
- /* Add all of the strings from the symbol table to the dictionary */
-
- kxld_symtab_iterator_reset(iter);
- while ((sym = kxld_symtab_iterator_get_next(iter))) {
- rval = add_string_to_index(strings, sym->name, tmps, &tmpi, &strsize);
- require_noerr(rval, finish);
- }
-
- /* Add all of the strings from the vtables entries to the dictionary */
-
- for (i = 0; i < vtables->nitems; ++i) {
- vtable = kxld_array_get_item(vtables, i);
- rval = add_string_to_index(strings, vtable->name, tmps, &tmpi, &strsize);
- require_noerr(rval, finish);
-
- for (j = 0; j < vtable->entries.nitems; ++j) {
- ventry = kxld_array_get_item(&vtable->entries, j);
- if (ventry->patched.name) {
- rval = add_string_to_index(strings, ventry->patched.name, tmps,
- &tmpi, &strsize);
- require_noerr(rval, finish);
- }
- }
- }
-
- *_strsize = strsize;
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-add_string_to_index(KXLDDict *strings, const char *str, KXLDArray *tmps,
- u_int *tmpi, u_long *stroff)
-{
- kern_return_t rval = KERN_FAILURE;
- u_long *tmpp = NULL;
-
- if (!kxld_dict_find(strings, str)) {
- tmpp = kxld_array_get_item(tmps, (*tmpi)++);
- *tmpp = *stroff;
-
- rval = kxld_dict_insert(strings, str, tmpp);
- require_noerr(rval, finish);
-
- *stroff += strlen(str) + 1;
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static boolean_t
-state_is_32_bit(KXLDLinkStateHdr *state)
-{
- return kxld_is_32_bit(state->cputype);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-create_link_state(u_char **_file, u_long *_filesize, const KXLDKext *kext,
- KXLDSymtabIterator *iter, const KXLDArray *vtables, KXLDDict *strings,
- u_int nsyms, u_int nsymentries, u_long strsize)
-{
- kern_return_t rval = KERN_SUCCESS;
- u_char *file = NULL;
- KXLDLinkStateHdr *hdr = NULL;
- KXLDDictIterator striter;
-#if KXLD_USER_OR_OBJECT
- KXLDSectionName *dstsectname = NULL;
- KXLDSectionName *srcsectname = NULL;
- const KXLDArray *section_order = NULL;
- u_int i = 0;
-#endif
- const char *name = NULL;
- char *dstname = NULL;
- u_long *stridx = 0;
- u_long hsize = 0;
- u_long dsize = 0;
- u_long filesize = 0;
- u_long hoff = 0;
- u_long doff = 0;
- u_long stroff = 0;
-
- check(_file);
- check(iter);
- check(vtables);
- check(strings);
-
- *_file = NULL;
- *_filesize = 0;
-
-#if KXLD_USER_OR_OBJECT
- section_order = kxld_kext_get_section_order(kext);
-#endif
-
- /* Calculate header and data size */
-
- hsize = sizeof(KXLDLinkStateHdr);
- hsize += vtables->nitems * sizeof(KXLDVTableHdr);
-#if KXLD_USER_OR_OBJECT
- if (section_order) {
- hsize += section_order->nitems * sizeof(KXLDSectionName);
- }
-#endif
-
- if (kxld_kext_is_32_bit(kext)) {
- dsize = nsymentries * sizeof(KXLDSymEntry32);
- } else {
- dsize = nsymentries * sizeof(KXLDSymEntry64);
- }
-
- filesize = hsize + dsize + strsize;
-
- hoff = 0;
- doff = hsize;
- stroff = hsize + dsize;
-
- /* Allocate the link state */
-
- file = kxld_alloc_pageable(filesize);
- require_action(file, finish, rval=KERN_RESOURCE_SHORTAGE);
-
- /* Initialize link state header */
-
- hdr = (KXLDLinkStateHdr *) file;
- hoff += sizeof(*hdr);
-
- if (state_is_32_bit(hdr)) {
- hdr->magic = LINK_STATE_MAGIC;
- } else {
- hdr->magic = LINK_STATE_MAGIC_64;
- }
- hdr->version = LINK_STATE_VERSION;
- kxld_kext_get_cputype(kext, &hdr->cputype, &hdr->cpusubtype);
- hdr->nsects = 0;
- hdr->nvtables = vtables->nitems;
- hdr->nsyms = nsyms;
-
-#if KXLD_USER_OR_OBJECT
- if (section_order) {
- hdr->nsects = section_order->nitems;
- hdr->sectoff = (uint32_t) hoff;
-
- dstsectname = (KXLDSectionName *) (file + hoff);
- hoff += section_order->nitems * sizeof(*dstsectname);
-
- for (i = 0; i < section_order->nitems; ++i, ++dstsectname) {
- srcsectname = kxld_array_get_item(section_order, i);
- memcpy(dstsectname, srcsectname, sizeof(*srcsectname));
- }
- }
-#endif
-
- hdr->voff = (uint32_t) hoff;
- hdr->symoff = (uint32_t) doff;
-
- /* Copy strings */
-
- kxld_dict_iterator_init(&striter, strings);
- kxld_dict_iterator_get_next(&striter, (const void **) &name, (void **) &stridx);
- while (name) {
- *stridx += stroff;
- dstname = (char *) (file + *stridx);
- strlcpy(dstname, name, filesize - *stridx);
- kxld_dict_iterator_get_next(&striter, (const void **) &name, (void **) &stridx);
- }
-
- /* Copy symbols */
-
- KXLD_3264_FUNC(state_is_32_bit(hdr), rval,
- copy_symbols_32, copy_symbols_64,
- file, &doff, iter, strings);
- require_noerr(rval, finish);
-
- /* Copy vtables */
-
- KXLD_3264_FUNC(state_is_32_bit(hdr), rval,
- copy_vtables_32, copy_vtables_64,
- file, &hoff, &doff, vtables, strings);
- require_noerr(rval, finish);
-
- *_file = file;
- *_filesize = filesize;
- file = NULL;
- rval = KERN_SUCCESS;
-
-finish:
-
- if (file) {
- kxld_page_free(file, filesize);
- file = NULL;
- }
-
- return rval;
-}
-
-#if KXLD_USER_OR_ILP32
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-copy_symbols_32(u_char *file, u_long *data_offset, KXLDSymtabIterator *iter,
- const KXLDDict *strings)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDSymEntry32 *symentry = NULL;
- const KXLDSym *sym = NULL;
- u_long *stridx = 0;
-
- kxld_symtab_iterator_reset(iter);
- while ((sym = kxld_symtab_iterator_get_next(iter))) {
- symentry = (KXLDSymEntry32 *) (file + *data_offset);
- stridx = kxld_dict_find(strings, sym->name);
- require_action(stridx, finish, rval=KERN_FAILURE);
-
- /* Initialize the symentry */
-
- symentry->nameoff = (uint32_t) *stridx;
- if (sym->predicates.is_thumb) {
- symentry->addr = (uint32_t) sym->link_addr | 1;
- } else {
- symentry->addr = (uint32_t) sym->link_addr;
- }
- symentry->flags = 0;
-
- /* Set any flags */
-
- symentry->flags |= (kxld_sym_is_obsolete(sym)) ? KXLD_SYM_OBSOLETE : 0;
-
- *data_offset += sizeof(*symentry);
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-#endif /* KXLD_USER_OR_ILP32 */
-
-#if KXLD_USER_OR_LP64
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-copy_symbols_64(u_char *file, u_long *data_offset, KXLDSymtabIterator *iter,
- const KXLDDict *strings)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDSymEntry64 *symentry = NULL;
- const KXLDSym *sym = NULL;
- u_long *stridx = 0;
-
- kxld_symtab_iterator_reset(iter);
- while ((sym = kxld_symtab_iterator_get_next(iter))) {
- symentry = (KXLDSymEntry64 *) (file + *data_offset);
- stridx = kxld_dict_find(strings, sym->name);
- require_action(stridx, finish, rval=KERN_FAILURE);
-
- /* Initialize the symentry */
-
- symentry->nameoff = (uint32_t) *stridx;
- symentry->addr = (uint64_t) sym->link_addr;
- symentry->flags = 0;
-
- /* Set any flags */
-
- symentry->flags |= (kxld_sym_is_obsolete(sym)) ? KXLD_SYM_OBSOLETE : 0;
-
- *data_offset += sizeof(*symentry);
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-#endif /* KXLD_USER_OR_LP64 */
-
-#if KXLD_USER_OR_ILP32
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-copy_vtables_32(u_char *file, u_long *header_offset, u_long *data_offset,
- const KXLDArray *vtables, const KXLDDict *strings)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDVTable *vtable = NULL;
- KXLDVTableHdr *vhdr = NULL;
- KXLDVTableEntry *ventry = NULL;
- KXLDSymEntry32 *symentry = NULL;
- u_long *stridx = 0;
- u_int i = 0;
- u_int j = 0;
-
- for (i = 0; i < vtables->nitems; ++i) {
- vtable = kxld_array_get_item(vtables, i);
- stridx = kxld_dict_find(strings, vtable->name);
- require_action(stridx, finish, rval=KERN_FAILURE);
-
- vhdr = (KXLDVTableHdr *) (file + *header_offset);
- vhdr->nameoff = (uint32_t) *stridx;
- vhdr->nentries = vtable->entries.nitems;
- vhdr->vtableoff = (uint32_t) (*data_offset);
-
- *header_offset += sizeof(*vhdr);
-
- for(j = 0; j < vtable->entries.nitems; ++j) {
-
- ventry = kxld_array_get_item(&vtable->entries, j);
- symentry = (KXLDSymEntry32 *) (file + *data_offset);
-
- if (ventry->patched.name) {
- stridx = kxld_dict_find(strings, ventry->patched.name);
- require_action(stridx, finish, rval=KERN_FAILURE);
-
- symentry->nameoff = (uint32_t) *stridx;
- symentry->addr = (uint32_t) ventry->patched.addr;
- } else {
- symentry->nameoff = 0;
- symentry->addr = 0;
- }
-
- *data_offset += sizeof(*symentry);
- }
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-#endif /* KXLD_USER_OR_ILP32 */
-
-#if KXLD_USER_OR_LP64
-/*******************************************************************************
-*******************************************************************************/
-static kern_return_t
-copy_vtables_64(u_char *file, u_long *header_offset, u_long *data_offset,
- const KXLDArray *vtables, const KXLDDict *strings)
-{
- kern_return_t rval = KERN_FAILURE;
- KXLDVTable *vtable = NULL;
- KXLDVTableHdr *vhdr = NULL;
- KXLDVTableEntry *ventry = NULL;
- KXLDSymEntry64 *symentry = NULL;
- u_long *stridx = 0;
- u_int i = 0;
- u_int j = 0;
-
- for (i = 0; i < vtables->nitems; ++i) {
- vtable = kxld_array_get_item(vtables, i);
- stridx = kxld_dict_find(strings, vtable->name);
- require_action(stridx, finish, rval=KERN_FAILURE);
-
- vhdr = (KXLDVTableHdr *) (file + *header_offset);
- vhdr->nameoff = (uint32_t) *stridx;
- vhdr->nentries = vtable->entries.nitems;
- vhdr->vtableoff = (uint32_t) (*data_offset);
-
- *header_offset += sizeof(*vhdr);
-
- for(j = 0; j < vtable->entries.nitems; ++j) {
-
- ventry = kxld_array_get_item(&vtable->entries, j);
- symentry = (KXLDSymEntry64 *) (file + *data_offset);
-
- if (ventry->patched.name) {
- stridx = kxld_dict_find(strings, ventry->patched.name);
- require_action(stridx, finish, rval=KERN_FAILURE);
-
- symentry->nameoff = (uint32_t) *stridx;
- symentry->addr = (uint64_t) ventry->patched.addr;
- } else {
- symentry->nameoff = 0;
- symentry->addr = 0;
- }
-
- *data_offset += sizeof(*symentry);
- }
- }
-
- rval = KERN_SUCCESS;
-
-finish:
- return rval;
-}
-#endif /* KXLD_USER_OR_LP64 */
-
-#if !KERNEL
-/*******************************************************************************
-*******************************************************************************/
-static boolean_t
-swap_link_state(u_char *state)
-{
- KXLDLinkStateHdr *state_hdr = (KXLDLinkStateHdr *) state;
-
- if (state_hdr->magic == CIGAM_ETATS_KNIL) {
- swap_link_state_32(state);
- return TRUE;
- } else if (state_hdr->magic == CIGAM_ETATS_KNIL_64) {
- swap_link_state_64(state);
- return TRUE;
- }
-
- return FALSE;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-swap_link_state_32(u_char *state)
-{
- KXLDLinkStateHdr *state_hdr = NULL;
- KXLDVTableHdr *vtable_hdr = NULL;
- KXLDSymEntry32 *entry = NULL;
- u_int i = 0;
- u_int j = 0;
-
- state_hdr = (KXLDLinkStateHdr *) state;
-
- if (state_hdr->magic != CIGAM_ETATS_KNIL) return;
-
- /* Swap the header */
- swap_state_hdr(state_hdr);
-
- /* Swap the symbols */
- entry = (KXLDSymEntry32 *) (state + state_hdr->symoff);
- for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
- swap_sym_entry_32(entry);
- }
-
- /* Swap the vtable headers and entries */
- vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
- for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
- swap_vtable_hdr(vtable_hdr);
-
- entry = (KXLDSymEntry32 *) (state + vtable_hdr->vtableoff);
- for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
- swap_sym_entry_32(entry);
- }
- }
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-swap_link_state_64(u_char *state)
-{
- KXLDLinkStateHdr *state_hdr = NULL;
- KXLDVTableHdr *vtable_hdr = NULL;
- KXLDSymEntry64 *entry = NULL;
- u_int i = 0;
- u_int j = 0;
-
- state_hdr = (KXLDLinkStateHdr *) state;
-
- if (state_hdr->magic != CIGAM_ETATS_KNIL_64) return;
-
- /* Swap the header */
- swap_state_hdr(state_hdr);
-
- /* Swap the symbols */
- entry = (KXLDSymEntry64 *) (state + state_hdr->symoff);
- for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
- swap_sym_entry_64(entry);
- }
-
- /* Swap the vtable headers and entries */
- vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
- for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
- swap_vtable_hdr(vtable_hdr);
-
- entry = (KXLDSymEntry64 *) (state + vtable_hdr->vtableoff);
- for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
- swap_sym_entry_64(entry);
- }
- }
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static boolean_t
-unswap_link_state(u_char *state)
-{
- KXLDLinkStateHdr *state_hdr = (KXLDLinkStateHdr *) state;
-
- if (state_hdr->magic == LINK_STATE_MAGIC) {
- unswap_link_state_32(state);
- return TRUE;
- } else if (state_hdr->magic == LINK_STATE_MAGIC_64) {
- unswap_link_state_64(state);
- return TRUE;
- }
-
- return FALSE;
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-unswap_link_state_32(u_char *state)
-{
- KXLDLinkStateHdr *state_hdr = NULL;
- KXLDVTableHdr *vtable_hdr = NULL;
- KXLDSymEntry32 *entry = NULL;
- u_int i = 0;
- u_int j = 0;
-
- state_hdr = (KXLDLinkStateHdr *) state;
-
- if (state_hdr->magic != LINK_STATE_MAGIC) return;
-
- /* Unswap the vtables and their headers */
- vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
- for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
- entry = (KXLDSymEntry32 *) (state + vtable_hdr->vtableoff);
- for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
- swap_sym_entry_32(entry);
- }
-
- swap_vtable_hdr(vtable_hdr);
- }
-
- /* Unswap the symbols themselves */
- entry = (KXLDSymEntry32 *) (state + state_hdr->symoff);
- for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
- swap_sym_entry_32(entry);
- }
-
- /* Unswap the header */
- swap_state_hdr(state_hdr);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-unswap_link_state_64(u_char *state)
-{
- KXLDLinkStateHdr *state_hdr = NULL;
- KXLDVTableHdr *vtable_hdr = NULL;
- KXLDSymEntry64 *entry = NULL;
- u_int i = 0;
- u_int j = 0;
-
- state_hdr = (KXLDLinkStateHdr *) state;
-
- if (state_hdr->magic != LINK_STATE_MAGIC_64) return;
-
- /* Unswap the vtables and their headers */
- vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
- for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
- entry = (KXLDSymEntry64 *) (state + vtable_hdr->vtableoff);
- for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
- swap_sym_entry_64(entry);
- }
-
- swap_vtable_hdr(vtable_hdr);
- }
-
- /* Unswap the symbols themselves */
- entry = (KXLDSymEntry64 *) (state + state_hdr->symoff);
- for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
- swap_sym_entry_64(entry);
- }
-
- /* Unswap the header */
- swap_state_hdr(state_hdr);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-swap_state_hdr(KXLDLinkStateHdr *state_hdr)
-{
- state_hdr->magic = OSSwapInt32(state_hdr->magic);
- state_hdr->version = OSSwapInt32(state_hdr->version);
- state_hdr->cputype = OSSwapInt32(state_hdr->cputype);
- state_hdr->cpusubtype = OSSwapInt32(state_hdr->cpusubtype);
- state_hdr->nsects = OSSwapInt32(state_hdr->nsects);
- state_hdr->sectoff = OSSwapInt32(state_hdr->sectoff);
- state_hdr->nvtables = OSSwapInt32(state_hdr->nvtables);
- state_hdr->voff = OSSwapInt32(state_hdr->voff);
- state_hdr->nsyms = OSSwapInt32(state_hdr->nsyms);
- state_hdr->symoff = OSSwapInt32(state_hdr->symoff);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-swap_vtable_hdr(KXLDVTableHdr *vtable_hdr)
-{
- vtable_hdr->nameoff = OSSwapInt32(vtable_hdr->nameoff);
- vtable_hdr->vtableoff = OSSwapInt32(vtable_hdr->vtableoff);
- vtable_hdr->nentries = OSSwapInt32(vtable_hdr->nentries);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-swap_sym_entry_32(KXLDSymEntry32 *entry)
-{
- entry->nameoff = OSSwapInt32(entry->nameoff);
- entry->addr = OSSwapInt32(entry->addr);
-}
-
-/*******************************************************************************
-*******************************************************************************/
-static void
-swap_sym_entry_64(KXLDSymEntry64 *entry)
-{
- entry->nameoff = OSSwapInt32(entry->nameoff);
- entry->addr = OSSwapInt64(entry->addr);
-}
-#endif /* !KERNEL */
-
projects / apple / xnu.git / blobdiff