1 /* $OpenBSD: library_mquery.c,v 1.34 2006/05/10 03:26:50 deraadt Exp $ */
2
3 /*
4 * Copyright (c) 2002 Dale Rahn
5 * Copyright (c) 1998 Per Fogelstrom, Opsycon AB
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
17 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 */
29
30 #define _DYN_LOADER
31
32 #include <sys/param.h>
33 #include <fcntl.h>
34 #include <sys/mman.h>
35 #include "dl_prebind.h"
36
37 #include "syscall.h"
38 #include "archdep.h"
39 #include "resolve.h"
40
41 #define PFLAGS(X) ((((X) & PF_R) ? PROT_READ : 0) | \
42 (((X) & PF_W) ? PROT_WRITE : 0) | \
43 (((X) & PF_X) ? PROT_EXEC : 0))
44
45 void
_dl_load_list_free(struct load_list * load_list)46 _dl_load_list_free(struct load_list *load_list)
47 {
48 struct load_list *next;
49 int align = _dl_pagesz - 1;
50
51 while (load_list != NULL) {
52 if (load_list->start != NULL)
53 _dl_munmap(load_list->start,
54 ((load_list->size) + align) & ~align);
55 next = load_list->next;
56 _dl_free(load_list);
57 load_list = next;
58 }
59 }
60
61
62 void
_dl_unload_shlib(elf_object_t * object)63 _dl_unload_shlib(elf_object_t *object)
64 {
65 struct dep_node *n;
66
67 DL_DEB(("unload_shlib called on %s\n", object->load_name));
68 if (OBJECT_REF_CNT(object) == 0 &&
69 (object->status & STAT_UNLOADED) == 0) {
70 object->status |= STAT_UNLOADED;
71 TAILQ_FOREACH(n, &object->child_list, next_sib)
72 _dl_unload_shlib(n->data);
73 TAILQ_FOREACH(n, &object->grpref_list, next_sib)
74 _dl_unload_shlib(n->data);
75 DL_DEB(("unload_shlib unloading on %s\n", object->load_name));
76 _dl_load_list_free(object->load_list);
77 _dl_remove_object(object);
78 }
79 }
80
81
82 elf_object_t *
_dl_tryload_shlib(const char * libname,int type,int flags)83 _dl_tryload_shlib(const char *libname, int type, int flags)
84 {
85 int libfile, i, align = _dl_pagesz - 1, off, size;
86 struct load_list *ld, *lowld = NULL;
87 elf_object_t *object;
88 Elf_Dyn *dynp = 0;
89 Elf_Ehdr *ehdr;
90 Elf_Phdr *phdp;
91 Elf_Addr load_end = 0;
92 struct stat sb;
93 void *prebind_data;
94 char hbuf[4096];
95
96 #define ROUND_PG(x) (((x) + align) & ~(align))
97 #define TRUNC_PG(x) ((x) & ~(align))
98
99 object = _dl_lookup_object(libname);
100 if (object) {
101 object->obj_flags |= flags & RTLD_GLOBAL;
102 if (_dl_loading_object == NULL)
103 _dl_loading_object = object;
104 if (object->load_object != _dl_objects &&
105 object->load_object != _dl_loading_object) {
106 _dl_link_grpref(object->load_object, _dl_loading_object);
107 }
108 return(object); /* Already loaded */
109 }
110
111 libfile = _dl_open(libname, O_RDONLY);
112 if (libfile < 0) {
113 _dl_errno = DL_CANT_OPEN;
114 return(0);
115 }
116
117 if ( _dl_fstat(libfile, &sb) < 0) {
118 _dl_errno = DL_CANT_OPEN;
119 return(0);
120 }
121
122 for (object = _dl_objects; object != NULL; object = object->next) {
123 if (object->dev == sb.st_dev &&
124 object->inode == sb.st_ino) {
125 object->obj_flags |= flags & RTLD_GLOBAL;
126 _dl_close(libfile);
127 if (_dl_loading_object == NULL)
128 _dl_loading_object = object;
129 if (object->load_object != _dl_objects &&
130 object->load_object != _dl_loading_object) {
131 _dl_link_grpref(object->load_object,
132 _dl_loading_object);
133 }
134 return(object);
135 }
136 }
137
138 _dl_read(libfile, hbuf, sizeof(hbuf));
139 ehdr = (Elf_Ehdr *)hbuf;
140 if (ehdr->e_ident[0] != ELFMAG0 || ehdr->e_ident[1] != ELFMAG1 ||
141 ehdr->e_ident[2] != ELFMAG2 || ehdr->e_ident[3] != ELFMAG3 ||
142 ehdr->e_type != ET_DYN || ehdr->e_machine != MACHID) {
143 _dl_close(libfile);
144 _dl_errno = DL_NOT_ELF;
145 return(0);
146 }
147
148 /* Insertion sort */
149 #define LDLIST_INSERT(ld) do { \
150 struct load_list **_ld; \
151 for (_ld = &lowld; *_ld != NULL; _ld = &(*_ld)->next) \
152 if ((*_ld)->moff > ld->moff) \
153 break; \
154 ld->next = *_ld; \
155 *_ld = ld; \
156 } while (0)
157 /*
158 * Alright, we might have a winner!
159 * Figure out how much VM space we need and set up the load
160 * list that we'll use to find free VM space.
161 */
162 phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
163 for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
164 switch (phdp->p_type) {
165 case PT_LOAD:
166 off = (phdp->p_vaddr & align);
167 size = off + phdp->p_filesz;
168
169 ld = _dl_malloc(sizeof(struct load_list));
170 ld->start = NULL;
171 ld->size = size;
172 ld->moff = TRUNC_PG(phdp->p_vaddr);
173 ld->foff = TRUNC_PG(phdp->p_offset);
174 ld->prot = PFLAGS(phdp->p_flags);
175 LDLIST_INSERT(ld);
176
177 if ((ld->prot & PROT_WRITE) == 0 ||
178 ROUND_PG(size) == ROUND_PG(off + phdp->p_memsz))
179 break;
180 /* This phdr has a zfod section */
181 ld = _dl_malloc(sizeof(struct load_list));
182 ld->start = NULL;
183 ld->size = ROUND_PG(off + phdp->p_memsz) -
184 ROUND_PG(size);
185 ld->moff = TRUNC_PG(phdp->p_vaddr) +
186 ROUND_PG(size);
187 ld->foff = -1;
188 ld->prot = PFLAGS(phdp->p_flags);
189 LDLIST_INSERT(ld);
190 break;
191 case PT_DYNAMIC:
192 dynp = (Elf_Dyn *)phdp->p_vaddr;
193 break;
194 default:
195 break;
196 }
197 }
198
199 #define LOFF ((Elf_Addr)lowld->start - lowld->moff)
200
201 retry:
202 for (ld = lowld; ld != NULL; ld = ld->next) {
203 off_t foff;
204 int fd, flags;
205
206 /*
207 * We don't want to provide the fd/off hint for anything
208 * but the first mapping, all other might have
209 * cache-incoherent aliases and will cause this code to
210 * loop forever.
211 */
212 if (ld == lowld) {
213 fd = libfile;
214 foff = ld->foff;
215 flags = 0;
216 } else {
217 fd = -1;
218 foff = 0;
219 flags = MAP_FIXED;
220 }
221
222 ld->start = (void *)(LOFF + ld->moff);
223
224 /*
225 * Magic here.
226 * The first mquery is done with MAP_FIXED to see if
227 * the mapping we want is free. If it's not, we redo the
228 * mquery without MAP_FIXED to get the next free mapping,
229 * adjust the base mapping address to match this free mapping
230 * and restart the process again.
231 */
232 ld->start = _dl_mquery(ld->start, ROUND_PG(ld->size), ld->prot,
233 flags, fd, foff);
234 if (_dl_check_error(ld->start)) {
235 ld->start = (void *)(LOFF + ld->moff);
236 ld->start = _dl_mquery(ld->start, ROUND_PG(ld->size),
237 ld->prot, flags & ~MAP_FIXED, fd, foff);
238 if (_dl_check_error(ld->start))
239 goto fail;
240 }
241
242 if (ld->start != (void *)(LOFF + ld->moff)) {
243 lowld->start = ld->start - ld->moff + lowld->moff;
244 goto retry;
245 }
246 /*
247 * XXX - we need some kind of boundary condition here,
248 * or fix mquery to not run into the stack
249 */
250 }
251
252 for (ld = lowld; ld != NULL; ld = ld->next) {
253 int fd, flags;
254 off_t foff;
255 void *res;
256
257 if (ld->foff < 0) {
258 fd = -1;
259 foff = 0;
260 flags = MAP_FIXED|MAP_PRIVATE|MAP_ANON;
261 } else {
262 fd = libfile;
263 foff = ld->foff;
264 flags = MAP_FIXED|MAP_PRIVATE;
265 }
266 res = _dl_mmap(ld->start, ROUND_PG(ld->size), ld->prot, flags,
267 fd, foff);
268 if (_dl_check_error((long)res))
269 goto fail;
270 /* Zero out everything past the EOF */
271 if ((ld->prot & PROT_WRITE) != 0 && (ld->size & align) != 0)
272 _dl_memset((char *)ld->start + ld->size, 0,
273 _dl_pagesz - (ld->size & align));
274 load_end = (Elf_Addr)ld->start + ROUND_PG(ld->size);
275 }
276
277 prebind_data = prebind_load_fd(libfile, libname);
278
279 _dl_close(libfile);
280
281 dynp = (Elf_Dyn *)((unsigned long)dynp + LOFF);
282 object = _dl_finalize_object(libname, dynp, 0, type,
283 (Elf_Addr)lowld->start, LOFF);
284 if (object) {
285 object->prebind_data = prebind_data;
286 object->load_size = (Elf_Addr)load_end - (Elf_Addr)lowld->start;
287 object->load_list = lowld;
288 /* set inode, dev from stat info */
289 object->dev = sb.st_dev;
290 object->inode = sb.st_ino;
291 object->obj_flags |= flags;
292
293 } else {
294 /* XXX no point. object is never returned NULL */
295 _dl_load_list_free(lowld);
296 }
297 return(object);
298 fail:
299 _dl_printf("%s: rtld mmap failed mapping %s.\n",
300 _dl_progname, libname);
301 _dl_close(libfile);
302 _dl_errno = DL_CANT_MMAP;
303 _dl_load_list_free(lowld);
304 return(0);
305 }
306