dynlink.c 21.2 KB
Newer Older
R
Rich Felker 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <elf.h>
#include <sys/mman.h>
#include <limits.h>
#include <stdint.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <limits.h>
#include <elf.h>
R
Rich Felker 已提交
15
#include <setjmp.h>
16
#include <pthread.h>
R
Rich Felker 已提交
17
#include <ctype.h>
18
#include <dlfcn.h>
R
Rich Felker 已提交
19

R
Rich Felker 已提交
20
static int errflag;
21
static char errbuf[128];
R
Rich Felker 已提交
22

23
#ifdef SHARED
R
Rich Felker 已提交
24

R
Rich Felker 已提交
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
#include "reloc.h"

#if ULONG_MAX == 0xffffffff
typedef Elf32_Ehdr Ehdr;
typedef Elf32_Phdr Phdr;
typedef Elf32_Sym Sym;
#define R_TYPE(x) ((x)&255)
#define R_SYM(x) ((x)>>8)
#else
typedef Elf64_Ehdr Ehdr;
typedef Elf64_Phdr Phdr;
typedef Elf64_Sym Sym;
#define R_TYPE(x) ((x)&0xffffffff)
#define R_SYM(x) ((x)>>32)
#endif

41 42 43 44 45 46 47 48 49 50 51 52
struct debug {
	int ver;
	void *head;
	void (*bp)(void);
	int state;
	void *base;
};

struct dso {
	unsigned char *base;
	char *name;
	size_t *dynv;
R
Rich Felker 已提交
53
	struct dso *next, *prev;
54

R
Rich Felker 已提交
55 56
	int refcnt;
	Sym *syms;
57
	uint32_t *hashtab;
R
Rich Felker 已提交
58 59 60 61 62
	char *strings;
	unsigned char *map;
	size_t map_len;
	dev_t dev;
	ino_t ino;
63
	signed char global;
64 65
	char relocated;
	char constructed;
66
	struct dso **deps;
67
	char *shortname;
R
Rich Felker 已提交
68
	char buf[];
R
Rich Felker 已提交
69 70
};

71
void __init_ssp(size_t *);
72

R
Rich Felker 已提交
73
static struct dso *head, *tail, *libc;
74
static char *env_path, *sys_path, *r_path;
75
static int rtld_used;
76
static int ssp_used;
R
Rich Felker 已提交
77
static int runtime;
78
static int ldd_mode;
R
Rich Felker 已提交
79
static jmp_buf rtld_fail;
80
static pthread_rwlock_t lock;
81 82 83
static struct debug debug;

struct debug *_dl_debug_addr = &debug;
R
Rich Felker 已提交
84

R
Rich Felker 已提交
85
#define AUX_CNT 24
R
Rich Felker 已提交
86 87 88 89 90 91 92 93 94 95 96
#define DYN_CNT 34

static void decode_vec(size_t *v, size_t *a, size_t cnt)
{
	memset(a, 0, cnt*sizeof(size_t));
	for (; v[0]; v+=2) if (v[0]<cnt) {
		a[0] |= 1ULL<<v[0];
		a[v[0]] = v[1];
	}
}

97
static uint32_t hash(const char *s0)
R
Rich Felker 已提交
98
{
99
	const unsigned char *s = (void *)s0;
R
Rich Felker 已提交
100 101 102 103 104 105 106 107
	uint_fast32_t h = 0;
	while (*s) {
		h = 16*h + *s++;
		h ^= h>>24 & 0xf0;
	}
	return h & 0xfffffff;
}

R
Rich Felker 已提交
108
static Sym *lookup(const char *s, uint32_t h, struct dso *dso)
R
Rich Felker 已提交
109 110
{
	size_t i;
R
Rich Felker 已提交
111 112 113
	Sym *syms = dso->syms;
	uint32_t *hashtab = dso->hashtab;
	char *strings = dso->strings;
R
Rich Felker 已提交
114 115 116 117 118 119 120 121
	for (i=hashtab[2+h%hashtab[0]]; i; i=hashtab[2+hashtab[0]+i]) {
		if (!strcmp(s, strings+syms[i].st_name))
			return syms+i;
	}
	return 0;
}

#define OK_TYPES (1<<STT_NOTYPE | 1<<STT_OBJECT | 1<<STT_FUNC | 1<<STT_COMMON)
122
#define OK_BINDS (1<<STB_GLOBAL | 1<<STB_WEAK)
R
Rich Felker 已提交
123 124 125 126

static void *find_sym(struct dso *dso, const char *s, int need_def)
{
	uint32_t h = hash(s);
127
	void *def = 0;
128 129
	if (h==0x6b366be && !strcmp(s, "dlopen")) rtld_used = 1;
	if (h==0x6b3afd && !strcmp(s, "dlsym")) rtld_used = 1;
130
	if (h==0x595a4cc && !strcmp(s, "__stack_chk_fail")) ssp_used = 1;
R
Rich Felker 已提交
131
	for (; dso; dso=dso->next) {
132 133
		Sym *sym;
		if (!dso->global) continue;
R
Rich Felker 已提交
134
		sym = lookup(s, h, dso);
R
Rich Felker 已提交
135
		if (sym && (!need_def || sym->st_shndx) && sym->st_value
136 137
		 && (1<<(sym->st_info&0xf) & OK_TYPES)
		 && (1<<(sym->st_info>>4) & OK_BINDS)) {
138
			if (def && sym->st_info>>4 == STB_WEAK) continue;
139 140 141
			def = dso->base + sym->st_value;
			if (sym->st_info>>4 == STB_GLOBAL) break;
		}
R
Rich Felker 已提交
142
	}
143
	return def;
R
Rich Felker 已提交
144 145
}

146
static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stride)
R
Rich Felker 已提交
147
{
148 149 150
	unsigned char *base = dso->base;
	Sym *syms = dso->syms;
	char *strings = dso->strings;
R
Rich Felker 已提交
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
	Sym *sym;
	const char *name;
	size_t sym_val, sym_size;
	size_t *reloc_addr;
	void *ctx;
	int type;
	int sym_index;

	for (; rel_size; rel+=stride, rel_size-=stride*sizeof(size_t)) {
		reloc_addr = (void *)(base + rel[0]);
		type = R_TYPE(rel[1]);
		sym_index = R_SYM(rel[1]);
		if (sym_index) {
			sym = syms + sym_index;
			name = strings + sym->st_name;
166
			ctx = IS_COPY(type) ? head->next : head;
167
			sym_val = (size_t)find_sym(ctx, name, IS_PLT(type));
R
Rich Felker 已提交
168
			if (!sym_val && sym->st_info>>4 != STB_WEAK) {
169 170
				snprintf(errbuf, sizeof errbuf,
					"Error relocating %s: %s: symbol not found",
171
					dso->name, name);
R
Rich Felker 已提交
172
				if (runtime) longjmp(rtld_fail, 1);
173
				dprintf(2, "%s\n", errbuf);
R
Rich Felker 已提交
174 175
				_exit(127);
			}
R
Rich Felker 已提交
176 177 178 179 180 181
			sym_size = sym->st_size;
		}
		do_single_reloc(reloc_addr, type, sym_val, sym_size, base, rel[2]);
	}
}

182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
/* A huge hack: to make up for the wastefulness of shared libraries
 * needing at least a page of dirty memory even if they have no global
 * data, we reclaim the gaps at the beginning and end of writable maps
 * and "donate" them to the heap by setting up minimal malloc
 * structures and then freeing them. */

static void reclaim(unsigned char *base, size_t start, size_t end)
{
	size_t *a, *z;
	start = start + 6*sizeof(size_t)-1 & -4*sizeof(size_t);
	end = (end & -4*sizeof(size_t)) - 2*sizeof(size_t);
	if (start>end || end-start < 4*sizeof(size_t)) return;
	a = (size_t *)(base + start);
	z = (size_t *)(base + end);
	a[-2] = 1;
	a[-1] = z[0] = end-start + 2*sizeof(size_t) | 1;
	z[1] = 1;
	free(a);
}

static void reclaim_gaps(unsigned char *base, Phdr *ph, size_t phent, size_t phcnt)
{
	for (; phcnt--; ph=(void *)((char *)ph+phent)) {
		if (ph->p_type!=PT_LOAD) continue;
		if ((ph->p_flags&(PF_R|PF_W))!=(PF_R|PF_W)) continue;
		reclaim(base, ph->p_vaddr & -PAGE_SIZE, ph->p_vaddr);
		reclaim(base, ph->p_vaddr+ph->p_memsz,
			ph->p_vaddr+ph->p_memsz+PAGE_SIZE-1 & -PAGE_SIZE);
	}
}

R
Rich Felker 已提交
213 214
static void *map_library(int fd, size_t *lenp, unsigned char **basep, size_t *dynp)
{
215
	Ehdr buf[(896+sizeof(Ehdr))/sizeof(Ehdr)];
R
Rich Felker 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228
	size_t phsize;
	size_t addr_min=SIZE_MAX, addr_max=0, map_len;
	size_t this_min, this_max;
	off_t off_start;
	Ehdr *eh;
	Phdr *ph;
	unsigned prot;
	unsigned char *map, *base;
	size_t dyn;
	size_t i;

	ssize_t l = read(fd, buf, sizeof buf);
	if (l<sizeof *eh) return 0;
229
	eh = buf;
R
Rich Felker 已提交
230 231 232
	phsize = eh->e_phentsize * eh->e_phnum;
	if (phsize + sizeof *eh > l) return 0;
	if (eh->e_phoff + phsize > l) {
233
		l = pread(fd, buf+1, phsize, eh->e_phoff);
R
Rich Felker 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
		if (l != phsize) return 0;
		eh->e_phoff = sizeof *eh;
	}
	ph = (void *)((char *)buf + eh->e_phoff);
	for (i=eh->e_phnum; i; i--, ph=(void *)((char *)ph+eh->e_phentsize)) {
		if (ph->p_type == PT_DYNAMIC)
			dyn = ph->p_vaddr;
		if (ph->p_type != PT_LOAD) continue;
		if (ph->p_vaddr < addr_min) {
			addr_min = ph->p_vaddr;
			off_start = ph->p_offset;
			prot = (((ph->p_flags&PF_R) ? PROT_READ : 0) |
				((ph->p_flags&PF_W) ? PROT_WRITE: 0) |
				((ph->p_flags&PF_X) ? PROT_EXEC : 0));
		}
		if (ph->p_vaddr+ph->p_memsz > addr_max) {
			addr_max = ph->p_vaddr+ph->p_memsz;
		}
	}
	if (!dyn) return 0;
	addr_max += PAGE_SIZE-1;
	addr_max &= -PAGE_SIZE;
	addr_min &= -PAGE_SIZE;
	off_start &= -PAGE_SIZE;
	map_len = addr_max - addr_min + off_start;
	/* The first time, we map too much, possibly even more than
	 * the length of the file. This is okay because we will not
	 * use the invalid part; we just need to reserve the right
	 * amount of virtual address space to map over later. */
263
	map = mmap((void *)addr_min, map_len, prot, MAP_PRIVATE, fd, off_start);
R
Rich Felker 已提交
264 265 266 267 268 269 270 271 272 273 274 275 276
	if (map==MAP_FAILED) return 0;
	base = map - addr_min;
	ph = (void *)((char *)buf + eh->e_phoff);
	for (i=eh->e_phnum; i; i--, ph=(void *)((char *)ph+eh->e_phentsize)) {
		if (ph->p_type != PT_LOAD) continue;
		/* Reuse the existing mapping for the lowest-address LOAD */
		if ((ph->p_vaddr & -PAGE_SIZE) == addr_min) continue;
		this_min = ph->p_vaddr & -PAGE_SIZE;
		this_max = ph->p_vaddr+ph->p_memsz+PAGE_SIZE-1 & -PAGE_SIZE;
		off_start = ph->p_offset & -PAGE_SIZE;
		prot = (((ph->p_flags&PF_R) ? PROT_READ : 0) |
			((ph->p_flags&PF_W) ? PROT_WRITE: 0) |
			((ph->p_flags&PF_X) ? PROT_EXEC : 0));
277 278
		if (mmap(base+this_min, this_max-this_min, prot, MAP_PRIVATE|MAP_FIXED, fd, off_start) == MAP_FAILED)
			goto error;
R
Rich Felker 已提交
279 280 281 282
		if (ph->p_memsz > ph->p_filesz) {
			size_t brk = (size_t)base+ph->p_vaddr+ph->p_filesz;
			size_t pgbrk = brk+PAGE_SIZE-1 & -PAGE_SIZE;
			memset((void *)brk, 0, pgbrk-brk & PAGE_SIZE-1);
283 284
			if (pgbrk-(size_t)base < this_max && mmap((void *)pgbrk, (size_t)base+this_max-pgbrk, prot, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) == MAP_FAILED)
				goto error;
R
Rich Felker 已提交
285 286
		}
	}
R
Rich Felker 已提交
287 288
	for (i=0; ((size_t *)(base+dyn))[i]; i+=2)
		if (((size_t *)(base+dyn))[i]==DT_TEXTREL) {
289 290
			if (mprotect(map, map_len, PROT_READ|PROT_WRITE|PROT_EXEC) < 0)
				goto error;
R
Rich Felker 已提交
291 292
			break;
		}
293 294
	if (!runtime) reclaim_gaps(base, (void *)((char *)buf + eh->e_phoff),
		eh->e_phentsize, eh->e_phnum);
R
Rich Felker 已提交
295 296 297 298
	*lenp = map_len;
	*basep = base;
	*dynp = dyn;
	return map;
299 300 301
error:
	munmap(map, map_len);
	return 0;
R
Rich Felker 已提交
302 303
}

304
static int path_open(const char *name, const char *search, char *buf, size_t buf_size)
305
{
306
	const char *s=search, *z;
307
	int l, fd;
308 309 310
	for (;;) {
		while (*s==':') s++;
		if (!*s) return -1;
311 312
		z = strchr(s, ':');
		l = z ? z-s : strlen(s);
313
		snprintf(buf, buf_size, "%.*s/%s", l, s, name);
314
		if ((fd = open(buf, O_RDONLY))>=0) return fd;
315
		s += l;
316 317 318
	}
}

319 320 321 322 323 324 325 326 327
static void decode_dyn(struct dso *p)
{
	size_t dyn[DYN_CNT] = {0};
	decode_vec(p->dynv, dyn, DYN_CNT);
	p->syms = (void *)(p->base + dyn[DT_SYMTAB]);
	p->hashtab = (void *)(p->base + dyn[DT_HASH]);
	p->strings = (void *)(p->base + dyn[DT_STRTAB]);
}

R
Rich Felker 已提交
328 329
static struct dso *load_library(const char *name)
{
330
	char buf[2*NAME_MAX+2];
331
	const char *pathname;
R
Rich Felker 已提交
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
	unsigned char *base, *map;
	size_t dyno, map_len;
	struct dso *p;
	int fd;
	struct stat st;

	/* Catch and block attempts to reload the implementation itself */
	if (name[0]=='l' && name[1]=='i' && name[2]=='b') {
		static const char *rp, reserved[] =
			"c\0pthread\0rt\0m\0dl\0util\0xnet\0";
		char *z = strchr(name, '.');
		if (z) {
			size_t l = z-name;
			for (rp=reserved; *rp && memcmp(name+3, rp, l-3); rp+=strlen(rp)+1);
			if (*rp) {
				if (!libc->prev) {
					tail->next = libc;
					libc->prev = tail;
350
					tail = libc->next ? libc->next : libc;
R
Rich Felker 已提交
351 352 353 354 355
				}
				return libc;
			}
		}
	}
356
	if (strchr(name, '/')) {
357
		pathname = name;
R
Rich Felker 已提交
358 359
		fd = open(name, O_RDONLY);
	} else {
360 361 362 363 364 365 366
		/* Search for the name to see if it's already loaded */
		for (p=head->next; p; p=p->next) {
			if (p->shortname && !strcmp(p->shortname, name)) {
				p->refcnt++;
				return p;
			}
		}
367
		if (strlen(name) > NAME_MAX) return 0;
368
		fd = -1;
369 370
		if (r_path) fd = path_open(name, r_path, buf, sizeof buf);
		if (fd < 0 && env_path) fd = path_open(name, env_path, buf, sizeof buf);
371 372 373 374 375 376 377 378 379
		if (fd < 0) {
			if (!sys_path) {
				FILE *f = fopen(ETC_LDSO_PATH, "r");
				if (f) {
					if (getline(&sys_path, (size_t[1]){0}, f) > 0)
						sys_path[strlen(sys_path)-1]=0;
					fclose(f);
				}
			}
380 381
			if (sys_path) fd = path_open(name, sys_path, buf, sizeof buf);
			else fd = path_open(name, "/lib:/usr/local/lib:/usr/lib", buf, sizeof buf);
R
Rich Felker 已提交
382
		}
383
		pathname = buf;
R
Rich Felker 已提交
384 385 386 387 388 389 390 391
	}
	if (fd < 0) return 0;
	if (fstat(fd, &st) < 0) {
		close(fd);
		return 0;
	}
	for (p=head->next; p; p=p->next) {
		if (p->dev == st.st_dev && p->ino == st.st_ino) {
392 393 394 395
			/* If this library was previously loaded with a
			 * pathname but a search found the same inode,
			 * setup its shortname so it can be found by name. */
			if (!p->shortname) p->shortname = strrchr(p->name, '/')+1;
R
Rich Felker 已提交
396 397 398 399 400 401 402 403
			close(fd);
			p->refcnt++;
			return p;
		}
	}
	map = map_library(fd, &map_len, &base, &dyno);
	close(fd);
	if (!map) return 0;
404
	p = calloc(1, sizeof *p + strlen(pathname) + 1);
R
Rich Felker 已提交
405 406 407 408 409 410 411 412 413
	if (!p) {
		munmap(map, map_len);
		return 0;
	}

	p->map = map;
	p->map_len = map_len;
	p->base = base;
	p->dynv = (void *)(base + dyno);
414
	decode_dyn(p);
R
Rich Felker 已提交
415 416 417 418

	p->dev = st.st_dev;
	p->ino = st.st_ino;
	p->refcnt = 1;
R
Rich Felker 已提交
419
	p->name = p->buf;
420 421 422
	strcpy(p->name, pathname);
	/* Add a shortname only if name arg was not an explicit pathname. */
	if (pathname != name) p->shortname = strrchr(p->name, '/')+1;
R
Rich Felker 已提交
423 424 425 426 427

	tail->next = p;
	p->prev = tail;
	tail = p;

428
	if (ldd_mode) dprintf(1, "\t%s => %s (%p)\n", name, pathname, base);
429

R
Rich Felker 已提交
430 431 432 433 434
	return p;
}

static void load_deps(struct dso *p)
{
435 436
	size_t i, ndeps=0;
	struct dso ***deps = &p->deps, **tmp, *dep;
R
Rich Felker 已提交
437
	for (; p; p=p->next) {
438 439 440 441
		for (i=0; p->dynv[i]; i+=2) {
			if (p->dynv[i] != DT_RPATH) continue;
			r_path = (void *)(p->strings + p->dynv[i+1]);
		}
R
Rich Felker 已提交
442 443
		for (i=0; p->dynv[i]; i+=2) {
			if (p->dynv[i] != DT_NEEDED) continue;
444 445
			dep = load_library(p->strings + p->dynv[i+1]);
			if (!dep) {
446 447
				snprintf(errbuf, sizeof errbuf,
					"Error loading shared library %s: %m (needed by %s)",
R
Rich Felker 已提交
448
					p->strings + p->dynv[i+1], p->name);
449 450
				if (runtime) longjmp(rtld_fail, 1);
				dprintf(2, "%s\n", errbuf);
R
Rich Felker 已提交
451 452
				_exit(127);
			}
453 454 455 456 457 458 459
			if (runtime) {
				tmp = realloc(*deps, sizeof(*tmp)*(ndeps+2));
				if (!tmp) longjmp(rtld_fail, 1);
				tmp[ndeps++] = dep;
				tmp[ndeps] = 0;
				*deps = tmp;
			}
R
Rich Felker 已提交
460
		}
461
		r_path = 0;
R
Rich Felker 已提交
462 463 464
	}
}

R
Rich Felker 已提交
465 466 467 468 469 470 471 472 473 474 475 476 477 478
static void load_preload(char *s)
{
	int tmp;
	char *z;
	for (z=s; *z; s=z) {
		for (   ; *s && isspace(*s); s++);
		for (z=s; *z && !isspace(*z); z++);
		tmp = *z;
		*z = 0;
		load_library(s);
		*z = tmp;
	}
}

479 480 481 482 483
static void make_global(struct dso *p)
{
	for (; p; p=p->next) p->global = 1;
}

R
Rich Felker 已提交
484 485 486 487 488 489
static void reloc_all(struct dso *p)
{
	size_t dyn[DYN_CNT] = {0};
	for (; p; p=p->next) {
		if (p->relocated) continue;
		decode_vec(p->dynv, dyn, DYN_CNT);
R
Rich Felker 已提交
490 491 492
#ifdef NEED_ARCH_RELOCS
		do_arch_relocs(p, head);
#endif
493 494 495 496
		do_relocs(p, (void *)(p->base+dyn[DT_JMPREL]), dyn[DT_PLTRELSZ],
			2+(dyn[DT_PLTREL]==DT_RELA));
		do_relocs(p, (void *)(p->base+dyn[DT_REL]), dyn[DT_RELSZ], 2);
		do_relocs(p, (void *)(p->base+dyn[DT_RELA]), dyn[DT_RELASZ], 3);
497
		p->relocated = 1;
R
Rich Felker 已提交
498 499 500
	}
}

501 502 503 504 505 506 507 508 509 510
static void free_all(struct dso *p)
{
	struct dso *n;
	while (p) {
		n = p->next;
		if (p->map) free(p);
		p = n;
	}
}

511 512 513 514 515 516 517 518
static size_t find_dyn(Phdr *ph, size_t cnt, size_t stride)
{
	for (; cnt--; ph = (void *)((char *)ph + stride))
		if (ph->p_type == PT_DYNAMIC)
			return ph->p_vaddr;
	return 0;
}

519 520 521 522 523 524 525 526 527 528 529 530 531 532
static void do_init_fini(struct dso *p)
{
	size_t dyn[DYN_CNT] = {0};
	for (; p; p=p->prev) {
		if (p->constructed) return;
		decode_vec(p->dynv, dyn, DYN_CNT);
		if (dyn[0] & (1<<DT_FINI))
			atexit((void (*)(void))(p->base + dyn[DT_FINI]));
		if (dyn[0] & (1<<DT_INIT))
			((void (*)(void))(p->base + dyn[DT_INIT]))();
		p->constructed = 1;
	}
}

533 534 535 536
void _dl_debug_state(void)
{
}

537
void *__dynlink(int argc, char **argv)
R
Rich Felker 已提交
538 539 540 541
{
	size_t *auxv, aux[AUX_CNT] = {0};
	size_t i;
	Phdr *phdr;
542
	Ehdr *ehdr;
543
	static struct dso builtin_dsos[3];
R
Rich Felker 已提交
544 545
	struct dso *const app = builtin_dsos+0;
	struct dso *const lib = builtin_dsos+1;
546
	struct dso *const vdso = builtin_dsos+2;
R
Rich Felker 已提交
547
	char *env_preload=0;
R
Rich Felker 已提交
548 549

	/* Find aux vector just past environ[] */
550 551 552
	for (i=argc+1; argv[i]; i++)
		if (!memcmp(argv[i], "LD_LIBRARY_PATH=", 16))
			env_path = argv[i]+16;
R
Rich Felker 已提交
553 554
		else if (!memcmp(argv[i], "LD_PRELOAD=", 11))
			env_preload = argv[i]+11;
R
Rich Felker 已提交
555 556 557 558
	auxv = (void *)(argv+i+1);

	decode_vec(auxv, aux, AUX_CNT);

559 560
	/* Only trust user/env if kernel says we're not suid/sgid */
	if ((aux[0]&0x7800)!=0x7800 || aux[AT_UID]!=aux[AT_EUID]
R
Rich Felker 已提交
561
	  || aux[AT_GID]!=aux[AT_EGID] || aux[AT_SECURE]) {
562
		env_path = 0;
R
Rich Felker 已提交
563
		env_preload = 0;
564 565
	}

566 567 568 569 570 571 572 573 574
	/* If the dynamic linker was invoked as a program itself, AT_BASE
	 * will not be set. In that case, we assume the base address is
	 * the start of the page containing the PHDRs; I don't know any
	 * better approach... */
	if (!aux[AT_BASE]) {
		aux[AT_BASE] = aux[AT_PHDR] & -PAGE_SIZE;
		aux[AT_PHDR] = aux[AT_PHENT] = aux[AT_PHNUM] = 0;
	}

575 576 577
	/* The dynamic linker load address is passed by the kernel
	 * in the AUX vector, so this is easy. */
	lib->base = (void *)aux[AT_BASE];
578
	lib->name = lib->shortname = "libc.so";
579 580 581 582 583 584 585
	lib->global = 1;
	ehdr = (void *)lib->base;
	lib->dynv = (void *)(lib->base + find_dyn(
		(void *)(aux[AT_BASE]+ehdr->e_phoff),
		ehdr->e_phnum, ehdr->e_phentsize));
	decode_dyn(lib);

586
	if (aux[AT_PHDR]) {
587
		size_t interp_off = 0;
588 589 590 591 592
		/* Find load address of the main program, via AT_PHDR vs PT_PHDR. */
		phdr = (void *)aux[AT_PHDR];
		for (i=aux[AT_PHNUM]; i; i--, phdr=(void *)((char *)phdr + aux[AT_PHENT])) {
			if (phdr->p_type == PT_PHDR)
				app->base = (void *)(aux[AT_PHDR] - phdr->p_vaddr);
593 594
			else if (phdr->p_type == PT_INTERP)
				interp_off = (size_t)phdr->p_vaddr;
595
		}
596
		if (interp_off) lib->name = (char *)app->base + interp_off;
597
		app->name = argv[0];
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
		app->dynv = (void *)(app->base + find_dyn(
			(void *)aux[AT_PHDR], aux[AT_PHNUM], aux[AT_PHENT]));
	} else {
		int fd;
		char *ldname = argv[0];
		size_t dyno, l = strlen(ldname);
		if (l >= 3 && !strcmp(ldname+l-3, "ldd")) ldd_mode = 1;
		*argv++ = (void *)-1;
		if (argv[0] && !strcmp(argv[0], "--")) *argv++ = (void *)-1;
		if (!argv[0]) {
			dprintf(2, "musl libc/dynamic program loader\n");
			dprintf(2, "usage: %s pathname%s\n", ldname,
				ldd_mode ? "" : " [args]");
			_exit(1);
		}
		fd = open(argv[0], O_RDONLY);
		if (fd < 0) {
			dprintf(2, "%s: cannot load %s: %s\n", ldname, argv[0], strerror(errno));
			_exit(1);
		}
		runtime = 1;
		ehdr = (void *)map_library(fd, &app->map_len, &app->base, &dyno);
		if (!ehdr) {
			dprintf(2, "%s: %s: Not a valid dynamic program\n", ldname, argv[0]);
			_exit(1);
		}
		runtime = 0;
		close(fd);
626
		lib->name = ldname;
627
		app->name = argv[0];
628 629
		app->dynv = (void *)(app->base + dyno);
		aux[AT_ENTRY] = ehdr->e_entry;
630
	}
631
	app->global = 1;
632
	app->constructed = 1;
633 634 635
	decode_dyn(app);

	/* Attach to vdso, if provided by the kernel */
636
	for (i=0; auxv[i]; i+=2) {
637 638
		size_t vdso_base = auxv[i+1];
		if (auxv[i] != AT_SYSINFO_EHDR) continue;
639 640 641 642 643 644 645 646
		ehdr = (void *)vdso_base;
		phdr = (void *)(vdso_base + ehdr->e_phoff);
		for (i=ehdr->e_phnum; i; i--, phdr=(void *)((char *)phdr + ehdr->e_phentsize)) {
			if (phdr->p_type == PT_DYNAMIC)
				vdso->dynv = (void *)(vdso_base + phdr->p_offset);
			if (phdr->p_type == PT_LOAD)
				vdso->base = (void *)(vdso_base - phdr->p_vaddr + phdr->p_offset);
		}
647
		vdso->name = vdso->shortname = "linux-gate.so.1";
648
		vdso->global = 1;
649
		decode_dyn(vdso);
650 651
		vdso->prev = lib;
		lib->next = vdso;
652
		break;
653 654
	}

655 656 657 658 659 660 661 662 663
	/* Initial dso chain consists only of the app. We temporarily
	 * append the dynamic linker/libc so we can relocate it, then
	 * restore the initial chain in preparation for loading third
	 * party libraries (preload/needed). */
	head = tail = app;
	libc = lib;
	app->next = lib;
	reloc_all(lib);
	app->next = 0;
R
Rich Felker 已提交
664

665
	/* PAST THIS POINT, ALL LIBC INTERFACES ARE FULLY USABLE. */
R
Rich Felker 已提交
666

667
	/* Donate unused parts of app and library mapping to malloc */
R
Rich Felker 已提交
668 669 670
	reclaim_gaps(app->base, (void *)aux[AT_PHDR], aux[AT_PHENT], aux[AT_PHNUM]);
	ehdr = (void *)lib->base;
	reclaim_gaps(lib->base, (void *)(lib->base+ehdr->e_phoff),
671 672
		ehdr->e_phentsize, ehdr->e_phnum);

673
	/* Load preload/needed libraries, add their symbols to the global
674 675 676
	 * namespace, and perform all remaining relocations. The main
	 * program must be relocated LAST since it may contain copy
	 * relocations which depend on libraries' relocations. */
R
Rich Felker 已提交
677
	if (env_preload) load_preload(env_preload);
678 679
	load_deps(app);
	make_global(app);
680
	reloc_all(app->next);
681 682
	reloc_all(app);

683 684
	if (ldd_mode) _exit(0);

685 686 687 688
	/* Switch to runtime mode: any further failures in the dynamic
	 * linker are a reportable failure rather than a fatal startup
	 * error. If the dynamic loader (dlopen) will not be used, free
	 * all memory used by the dynamic linker. */
R
Rich Felker 已提交
689
	runtime = 1;
690

691 692 693 694 695 696 697 698 699 700
	for (i=0; app->dynv[i]; i+=2)
		if (app->dynv[i]==DT_DEBUG)
			app->dynv[i+1] = (size_t)&debug;
	debug.ver = 1;
	debug.bp = _dl_debug_state;
	debug.head = head;
	debug.base = lib->base;
	debug.state = 0;
	_dl_debug_state();

701 702
	if (ssp_used) __init_ssp(auxv);

703 704
	do_init_fini(tail);

R
Rich Felker 已提交
705
	if (!rtld_used) {
706 707
		free_all(head);
		free(sys_path);
R
Rich Felker 已提交
708
		reclaim((void *)builtin_dsos, 0, sizeof builtin_dsos);
709
	}
710

R
Rich Felker 已提交
711 712 713
	errno = 0;
	return (void *)aux[AT_ENTRY];
}
714 715 716

void *dlopen(const char *file, int mode)
{
717
	struct dso *volatile p, *orig_tail = tail, *next;
718
	size_t i;
719
	int cs;
720 721 722

	if (!file) return head;

723
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
724 725 726 727
	pthread_rwlock_wrlock(&lock);

	if (setjmp(rtld_fail)) {
		/* Clean up anything new that was (partially) loaded */
728 729 730
		if (p->deps) for (i=0; p->deps[i]; i++)
			if (p->deps[i]->global < 0)
				p->deps[i]->global = 0;
731 732 733 734 735 736 737 738
		for (p=orig_tail->next; p; p=next) {
			next = p->next;
			munmap(p->map, p->map_len);
			free(p->deps);
			free(p);
		}
		tail = orig_tail;
		tail->next = 0;
739
		p = 0;
740 741
		errflag = 1;
		goto end;
R
Rich Felker 已提交
742 743 744
	} else p = load_library(file);

	if (!p) {
745 746
		snprintf(errbuf, sizeof errbuf,
			"Error loading shared library %s: %m", file);
R
Rich Felker 已提交
747
		errflag = 1;
748
		goto end;
749 750 751 752 753
	}

	/* First load handling */
	if (!p->deps) {
		load_deps(p);
R
Rich Felker 已提交
754
		if (p->deps) for (i=0; p->deps[i]; i++)
755 756 757
			if (!p->deps[i]->global)
				p->deps[i]->global = -1;
		if (!p->global) p->global = -1;
758
		reloc_all(p);
R
Rich Felker 已提交
759
		if (p->deps) for (i=0; p->deps[i]; i++)
760 761 762
			if (p->deps[i]->global < 0)
				p->deps[i]->global = 0;
		if (p->global < 0) p->global = 0;
763 764 765
	}

	if (mode & RTLD_GLOBAL) {
R
Rich Felker 已提交
766
		if (p->deps) for (i=0; p->deps[i]; i++)
767 768 769 770
			p->deps[i]->global = 1;
		p->global = 1;
	}

771 772
	_dl_debug_state();

773
	do_init_fini(tail);
774
end:
775
	pthread_rwlock_unlock(&lock);
776
	pthread_setcancelstate(cs, 0);
777 778 779
	return p;
}

R
Rich Felker 已提交
780
static void *do_dlsym(struct dso *p, const char *s, void *ra)
781 782 783 784
{
	size_t i;
	uint32_t h;
	Sym *sym;
R
Rich Felker 已提交
785 786 787
	if (p == RTLD_NEXT) {
		for (p=head; p && (unsigned char *)ra-p->map>p->map_len; p=p->next);
		if (!p) p=head;
R
Rich Felker 已提交
788 789 790
		void *res = find_sym(p->next, s, 0);
		if (!res) goto failed;
		return res;
R
Rich Felker 已提交
791
	}
R
Rich Felker 已提交
792 793
	if (p == head || p == RTLD_DEFAULT) {
		void *res = find_sym(head, s, 0);
794
		if (!res) goto failed;
R
Rich Felker 已提交
795 796
		return res;
	}
797
	h = hash(s);
R
Rich Felker 已提交
798
	sym = lookup(s, h, p);
799 800 801
	if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
		return p->base + sym->st_value;
	if (p->deps) for (i=0; p->deps[i]; i++) {
R
Rich Felker 已提交
802
		sym = lookup(s, h, p);
803 804 805
		if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
			return p->deps[i]->base + sym->st_value;
	}
806
failed:
R
Rich Felker 已提交
807
	errflag = 1;
808
	snprintf(errbuf, sizeof errbuf, "Symbol not found: %s", s);
809 810 811
	return 0;
}

R
Rich Felker 已提交
812
void *__dlsym(void *p, const char *s, void *ra)
813 814 815
{
	void *res;
	pthread_rwlock_rdlock(&lock);
R
Rich Felker 已提交
816
	res = do_dlsym(p, s, ra);
817 818 819
	pthread_rwlock_unlock(&lock);
	return res;
}
820 821 822 823 824 825 826 827 828 829
#else
void *dlopen(const char *file, int mode)
{
	return 0;
}
void *__dlsym(void *p, const char *s, void *ra)
{
	return 0;
}
#endif
830 831 832

char *dlerror()
{
R
Rich Felker 已提交
833 834
	if (!errflag) return 0;
	errflag = 0;
835
	return errbuf;
836 837 838 839 840 841
}

int dlclose(void *p)
{
	return 0;
}