Subversion Repositories HelenOS

Rev

Rev 2998 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2998 Rev 2999
1 
/*
 1 
/*
2 
 * Copyright (c) 2008 Jiri Svoboda
 2 
 * Copyright (c) 2008 Jiri Svoboda
3 
 * All rights reserved.
 3 
 * All rights reserved.
4 
 *
 4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
 5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions
 6 
 * modification, are permitted provided that the following conditions
7 
 * are met:
 7 
 * are met:
8 
 *
 8 
 *
9 
 * - Redistributions of source code must retain the above copyright
 9 
 * - Redistributions of source code must retain the above copyright
10 
 *   notice, this list of conditions and the following disclaimer.
 10 
 *   notice, this list of conditions and the following disclaimer.
11 
 * - Redistributions in binary form must reproduce the above copyright
 11 
 * - Redistributions in binary form must reproduce the above copyright
12 
 *   notice, this list of conditions and the following disclaimer in the
 12 
 *   notice, this list of conditions and the following disclaimer in the
13 
 *   documentation and/or other materials provided with the distribution.
 13 
 *   documentation and/or other materials provided with the distribution.
14 
 * - The name of the author may not be used to endorse or promote products
 14 
 * - The name of the author may not be used to endorse or promote products
15 
 *   derived from this software without specific prior written permission.
 15 
 *   derived from this software without specific prior written permission.
16 
 *
 16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
 27 
 */
28 
 
 28 
 
29 
/** @addtogroup rtld rtld
 29 
/** @addtogroup rtld rtld
30 
 * @brief
 30 
 * @brief
31 
 * @{
 31 
 * @{
32 
 */
 32 
 */
33 
/**
 33 
/**
34 
 * @file
 34 
 * @file
35 
 */
 35 
 */
36 
 
 36 
 
37 
#include <stdio.h>
 37 
#include <stdio.h>
38 
#include <stdlib.h>
 38 
#include <stdlib.h>
39 
#include <string.h>
 39 
#include <string.h>
40 
 
 40 
 
41 
#include <rtld.h>
 41 
#include <rtld.h>
42 
#include <symbol.h>
 42 
#include <symbol.h>
43 
#include <elf.h>
 43 
#include <elf.h>
44 
 
 44 
 
45 
/*
 45 
/*
46 
 * Hash tables are 32-bit (elf_word) even for 64-bit ELF files.
 46 
 * Hash tables are 32-bit (elf_word) even for 64-bit ELF files.
47 
 */
 47 
 */
48 
static elf_word elf_hash(const unsigned char *name)
 48 
static elf_word elf_hash(const unsigned char *name)
49 
{
 49 
{
50 
    elf_word h = 0, g;
 50 
    elf_word h = 0, g;
51 
 
 51 
 
52 
    while (*name) {
 52 
    while (*name) {
53 
        h = (h << 4) + *name++;
 53 
        h = (h << 4) + *name++;
54 
        g = h & 0xf0000000;
 54 
        g = h & 0xf0000000;
55 
        if (g != 0) h ^= g >> 24;
 55 
        if (g != 0) h ^= g >> 24;
56 
        h &= ~g;
 56 
        h &= ~g;
57 
    }
 57 
    }
58 
 
 58 
 
59 
    return h;
 59 
    return h;
60 
}
 60 
}
61 
 
 61 
 
62 
static elf_symbol_t *def_find_in_module(char *name, module_t *m)
 62 
static elf_symbol_t *def_find_in_module(char *name, module_t *m)
63 
{
 63 
{
64 
    elf_symbol_t *sym_table;
 64 
    elf_symbol_t *sym_table;
65 
    elf_symbol_t *s, *sym;
 65 
    elf_symbol_t *s, *sym;
66 
    elf_word nbucket;
 66 
    elf_word nbucket;
67 
    elf_word nchain;
 67 
    elf_word nchain;
68 
    elf_word i;
 68 
    elf_word i;
69 
    char *s_name;
 69 
    char *s_name;
70 
    elf_word bucket;
 70 
    elf_word bucket;
71 
 
 71 
 
72 
//  module_name = m->dyn.soname;
 72 
//  module_name = m->dyn.soname;
73 
//  printf("def_find_in_module('%s', %s)\n", name, module_name);
 73 
//  printf("def_find_in_module('%s', %s)\n", name, module_name);
74 
 
 74 
 
75 
    sym_table = m->dyn.sym_tab;
 75 
    sym_table = m->dyn.sym_tab;
76 
    nbucket = m->dyn.hash[0];
 76 
    nbucket = m->dyn.hash[0];
77 
    nchain = m->dyn.hash[1];
 77 
    nchain = m->dyn.hash[1];
78 
 
 78 
 
79 
    bucket = elf_hash((unsigned char *)name) % nbucket;
 79 
    bucket = elf_hash((unsigned char *)name) % nbucket;
80 
    i = m->dyn.hash[2 + bucket];
 80 
    i = m->dyn.hash[2 + bucket];
81 
 
 81 
 
82 
    sym = NULL;
 82 
    sym = NULL;
83 
    while (i != STN_UNDEF) {
 83 
    while (i != STN_UNDEF) {
84 
        s = &sym_table[i];
 84 
        s = &sym_table[i];
85 
        s_name = m->dyn.str_tab + s->st_name;
 85 
        s_name = m->dyn.str_tab + s->st_name;
86 
 
 86 
 
87 
        if (strcmp(name, s_name) == 0) {
 87 
        if (strcmp(name, s_name) == 0) {
88 
            sym = s;
 88 
            sym = s;
89 
            break;
 89 
            break;
90 
        }
 90 
        }
91 
 
 91 
 
92 
        i = m->dyn.hash[2 + nbucket + i];
 92 
        i = m->dyn.hash[2 + nbucket + i];
93 
    }
 93 
    }
94 
 
 94 
 
95 
    if (!sym)
 95 
    if (!sym)
96 
        return NULL;    /* Not found */
 96 
        return NULL;    /* Not found */
97 
 
 97 
 
98 
    if (sym->st_shndx == SHN_UNDEF) {
 98 
    if (sym->st_shndx == SHN_UNDEF) {
99 
        /* Not a definition */
 99 
        /* Not a definition */
100 
        return NULL;
 100 
        return NULL;
101 
    }
 101 
    }
102 
 
 102 
 
103 
    return sym; /* Found */
 103 
    return sym; /* Found */
104 
}
 104 
}
105 
 
 105 
 
- 
 
 106 
/** Find the definition of a symbol.
- 
 
 107 
 *
- 
 
 108 
 * By definition in System V ABI, if module origin has the flag DT_SYMBOLIC,
- 
 
 109 
 * origin is searched first. Otherwise, or if the symbol hasn't been found,
- 
 
 110 
 * the module dependency graph is searched breadth-first, beginning
- 
 
 111 
 * from the executable program.
106 
 
 112 
 *
- 
 
 113 
 * @param name      Name of the symbol to search for.
- 
 
 114 
 * @param origin    Module in which the dependency originates.
- 
 
 115 
 * @param mod       (output) Will be filled with a pointer to the module
- 
 
 116 
 *          that contains the symbol.
- 
 
 117 
 */
107 
elf_symbol_t *symbol_def_find(char *name, module_t **m)
 118 
elf_symbol_t *symbol_def_find(char *name, module_t *origin, module_t **mod)
108 
{
 119 
{
- 
 
 120 
    module_t *m;
109 
    elf_symbol_t *sym;
 121 
    elf_symbol_t *sym;
110 
 
 122 
 
111 
    sym = def_find_in_module(name, runtime_env.program);
 123 
    /* FIXME: support DT_SYMBOLIC */
112 
    if (sym != NULL) { *m = runtime_env.program; return sym; } 
 - 
 
113 
 
 - 
 
114 
    sym = def_find_in_module(name, runtime_env.libc);
 124 
    //m = origin;
115 
    if (sym != NULL) { *m = runtime_env.libc; return sym; }
 - 
 
116 
 
 125 
 
117 
    sym = def_find_in_module(name, &runtime_env.rtld);
 126 
    /* Start in the executable program */
118 
    if (sym != NULL) { *m = &runtime_env.rtld; return sym; }
 127 
    m = runtime_env.program;
119 
 
 128 
 
- 
 
 129 
    while (true) {
120 
    printf("symbol found nowhere\n");
 130 
        sym = def_find_in_module(name, m);
- 
 
 131 
        if (sym != NULL) {
121 
    *m = NULL;
 132 
            *mod = m;
122 
    return NULL;
 133 
            return sym;
- 
 
 134 
        }
- 
 
 135 
 
- 
 
 136 
        if (m->n_deps < 1) break;
- 
 
 137 
 
- 
 
 138 
        /* FIXME: support branching */
- 
 
 139 
        if (m->n_deps > 1) {
- 
 
 140 
            printf("error: BFS unimplemented\n");
- 
 
 141 
            exit(1);
- 
 
 142 
        }
- 
 
 143 
 
- 
 
 144 
        m = m->deps[0];
- 
 
 145 
    }
- 
 
 146 
 
- 
 
 147 
    printf("Error, symbol '%s' not found anywhere\n", name);
- 
 
 148 
    exit(1);
- 
 
 149 
    return NULL; /* Not found */
123 
}
 150 
}
124 
 
 151 
 
125 
uintptr_t symbol_get_addr(elf_symbol_t *sym, module_t *m)
 152 
uintptr_t symbol_get_addr(elf_symbol_t *sym, module_t *m)
126 
{
 153 
{
127 
    if (sym->st_shndx == SHN_ABS) {
 154 
    if (sym->st_shndx == SHN_ABS) {
128 
        /* Do not add bias to absolute symbols */
 155 
        /* Do not add bias to absolute symbols */
129 
        return sym->st_value;
 156 
        return sym->st_value;
130 
    } else {
 157 
    } else {
131 
        return sym->st_value + m->bias;
 158 
        return sym->st_value + m->bias;
132 
    }
 159 
    }
133 
}
 160 
}
134 
 
 161 
 
135 
/** @}
 162 
/** @}
136 
 */
 163 
 */
137 
 
 164