binfmt_flat.c 27.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/****************************************************************************/
/*
 *  linux/fs/binfmt_flat.c
 *
 *	Copyright (C) 2000-2003 David McCullough <davidm@snapgear.com>
 *	Copyright (C) 2002 Greg Ungerer <gerg@snapgear.com>
 *	Copyright (C) 2002 SnapGear, by Paul Dale <pauli@snapgear.com>
 *	Copyright (C) 2000, 2001 Lineo, by David McCullough <davidm@lineo.com>
 *  based heavily on:
 *
 *  linux/fs/binfmt_aout.c:
 *      Copyright (C) 1991, 1992, 1996  Linus Torvalds
 *  linux/fs/binfmt_flat.c for 2.0 kernel
 *	    Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com>
 *	JAN/99 -- coded full program relocation (gerg@snapgear.com)
 */

18 19
#define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/ptrace.h>
#include <linux/user.h>
#include <linux/slab.h>
#include <linux/binfmts.h>
#include <linux/personality.h>
#include <linux/init.h>
#include <linux/flat.h>
Nicolas Pitre's avatar
Nicolas Pitre committed
36
#include <linux/uaccess.h>
37
#include <linux/vmalloc.h>
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40 41

#include <asm/byteorder.h>
#include <asm/unaligned.h>
#include <asm/cacheflush.h>
42
#include <asm/page.h>
Linus Torvalds's avatar
Linus Torvalds committed
43 44 45

/****************************************************************************/

46
/*
47 48 49 50 51 52 53 54 55 56 57
 * User data (data section and bss) needs to be aligned.
 * We pick 0x20 here because it is the max value elf2flt has always
 * used in producing FLAT files, and because it seems to be large
 * enough to make all the gcc alignment related tests happy.
 */
#define FLAT_DATA_ALIGN	(0x20)

/*
 * User data (stack) also needs to be aligned.
 * Here we can be a bit looser than the data sections since this
 * needs to only meet arch ABI requirements.
58
 */
59
#define FLAT_STACK_ALIGN	max_t(unsigned long, sizeof(void *), ARCH_SLAB_MINALIGN)
60

Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65 66 67 68 69 70 71
#define RELOC_FAILED 0xff00ff01		/* Relocation incorrect somewhere */
#define UNLOADED_LIB 0x7ff000ff		/* Placeholder for unused library */

struct lib_info {
	struct {
		unsigned long start_code;		/* Start of text segment */
		unsigned long start_data;		/* Start of data segment */
		unsigned long start_brk;		/* End of data segment */
		unsigned long text_len;			/* Length of text segment */
		unsigned long entry;			/* Start address for this module */
		unsigned long build_date;		/* When this one was compiled */
Nicolas Pitre's avatar
Nicolas Pitre committed
72
		bool loaded;				/* Has this library been loaded? */
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78 79
	} lib_list[MAX_SHARED_LIBS];
};

#ifdef CONFIG_BINFMT_SHARED_FLAT
static int load_flat_shared_library(int id, struct lib_info *p);
#endif

80
static int load_flat_binary(struct linux_binprm *);
81
static int flat_core_dump(struct coredump_params *cprm);
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84 85 86 87 88 89 90 91 92 93 94 95

static struct linux_binfmt flat_format = {
	.module		= THIS_MODULE,
	.load_binary	= load_flat_binary,
	.core_dump	= flat_core_dump,
	.min_coredump	= PAGE_SIZE
};

/****************************************************************************/
/*
 * Routine writes a core dump image in the current directory.
 * Currently only a stub-function.
 */

96
static int flat_core_dump(struct coredump_params *cprm)
Linus Torvalds's avatar
Linus Torvalds committed
97
{
98 99
	pr_warn("Process %s:%d received signr %d and should have core dumped\n",
		current->comm, current->pid, cprm->siginfo->si_signo);
Nicolas Pitre's avatar
Nicolas Pitre committed
100
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104 105 106
}

/****************************************************************************/
/*
 * create_flat_tables() parses the env- and arg-strings in new user
 * memory and creates the pointer tables from them, and puts their
107
 * addresses on the "stack", recording the new stack pointer value.
Linus Torvalds's avatar
Linus Torvalds committed
108 109
 */

110
static int create_flat_tables(struct linux_binprm *bprm, unsigned long arg_start)
Linus Torvalds's avatar
Linus Torvalds committed
111
{
112 113 114
	char __user *p;
	unsigned long __user *sp;
	long i, len;
Linus Torvalds's avatar
Linus Torvalds committed
115

116 117 118 119 120 121 122 123 124 125 126 127
	p = (char __user *)arg_start;
	sp = (unsigned long __user *)current->mm->start_stack;

	sp -= bprm->envc + 1;
	sp -= bprm->argc + 1;
	sp -= flat_argvp_envp_on_stack() ? 2 : 0;
	sp -= 1;  /* &argc */

	current->mm->start_stack = (unsigned long)sp & -FLAT_STACK_ALIGN;
	sp = (unsigned long __user *)current->mm->start_stack;

	__put_user(bprm->argc, sp++);
Linus Torvalds's avatar
Linus Torvalds committed
128
	if (flat_argvp_envp_on_stack()) {
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
		unsigned long argv, envp;
		argv = (unsigned long)(sp + 2);
		envp = (unsigned long)(sp + 2 + bprm->argc + 1);
		__put_user(argv, sp++);
		__put_user(envp, sp++);
	}

	current->mm->arg_start = (unsigned long)p;
	for (i = bprm->argc; i > 0; i--) {
		__put_user((unsigned long)p, sp++);
		len = strnlen_user(p, MAX_ARG_STRLEN);
		if (!len || len > MAX_ARG_STRLEN)
			return -EINVAL;
		p += len;
	}
	__put_user(0, sp++);
	current->mm->arg_end = (unsigned long)p;

	current->mm->env_start = (unsigned long) p;
	for (i = bprm->envc; i > 0; i--) {
		__put_user((unsigned long)p, sp++);
		len = strnlen_user(p, MAX_ARG_STRLEN);
		if (!len || len > MAX_ARG_STRLEN)
			return -EINVAL;
		p += len;
	}
	__put_user(0, sp++);
	current->mm->env_end = (unsigned long)p;

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
}

/****************************************************************************/

#ifdef CONFIG_BINFMT_ZFLAT

#include <linux/zlib.h>

#define LBUFSIZE	4000

/* gzip flag byte */
#define ASCII_FLAG   0x01 /* bit 0 set: file probably ASCII text */
#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
#define COMMENT      0x10 /* bit 4 set: file comment present */
#define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
#define RESERVED     0xC0 /* bit 6,7:   reserved */

static int decompress_exec(
	struct linux_binprm *bprm,
	unsigned long offset,
	char *dst,
	long len,
	int fd)
{
	unsigned char *buf;
	z_stream strm;
	loff_t fpos;
	int ret, retval;

190
	pr_debug("decompress_exec(offset=%lx,buf=%p,len=%lx)\n", offset, dst, len);
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194

	memset(&strm, 0, sizeof(strm));
	strm.workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
	if (strm.workspace == NULL) {
195
		pr_debug("no memory for decompress workspace\n");
Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199
		return -ENOMEM;
	}
	buf = kmalloc(LBUFSIZE, GFP_KERNEL);
	if (buf == NULL) {
200
		pr_debug("no memory for read buffer\n");
Linus Torvalds's avatar
Linus Torvalds committed
201 202 203 204 205 206
		retval = -ENOMEM;
		goto out_free;
	}

	/* Read in first chunk of data and parse gzip header. */
	fpos = offset;
Al Viro's avatar
Al Viro committed
207
	ret = kernel_read(bprm->file, offset, buf, LBUFSIZE);
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211

	strm.next_in = buf;
	strm.avail_in = ret;
	strm.total_in = 0;
Al Viro's avatar
Al Viro committed
212
	fpos += ret;
Linus Torvalds's avatar
Linus Torvalds committed
213 214 215 216 217

	retval = -ENOEXEC;

	/* Check minimum size -- gzip header */
	if (ret < 10) {
218
		pr_debug("file too small?\n");
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223
		goto out_free_buf;
	}

	/* Check gzip magic number */
	if ((buf[0] != 037) || ((buf[1] != 0213) && (buf[1] != 0236))) {
224
		pr_debug("unknown compression magic?\n");
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229
		goto out_free_buf;
	}

	/* Check gzip method */
	if (buf[2] != 8) {
230
		pr_debug("unknown compression method?\n");
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234 235
		goto out_free_buf;
	}
	/* Check gzip flags */
	if ((buf[3] & ENCRYPTED) || (buf[3] & CONTINUATION) ||
	    (buf[3] & RESERVED)) {
236
		pr_debug("unknown flags?\n");
Linus Torvalds's avatar
Linus Torvalds committed
237 238 239 240 241 242
		goto out_free_buf;
	}

	ret = 10;
	if (buf[3] & EXTRA_FIELD) {
		ret += 2 + buf[10] + (buf[11] << 8);
Nicolas Pitre's avatar
Nicolas Pitre committed
243
		if (unlikely(ret >= LBUFSIZE)) {
244
			pr_debug("buffer overflow (EXTRA)?\n");
Linus Torvalds's avatar
Linus Torvalds committed
245 246 247 248
			goto out_free_buf;
		}
	}
	if (buf[3] & ORIG_NAME) {
249
		while (ret < LBUFSIZE && buf[ret++] != 0)
Linus Torvalds's avatar
Linus Torvalds committed
250
			;
Nicolas Pitre's avatar
Nicolas Pitre committed
251
		if (unlikely(ret == LBUFSIZE)) {
252
			pr_debug("buffer overflow (ORIG_NAME)?\n");
Linus Torvalds's avatar
Linus Torvalds committed
253 254 255 256
			goto out_free_buf;
		}
	}
	if (buf[3] & COMMENT) {
257
		while (ret < LBUFSIZE && buf[ret++] != 0)
Linus Torvalds's avatar
Linus Torvalds committed
258
			;
Nicolas Pitre's avatar
Nicolas Pitre committed
259
		if (unlikely(ret == LBUFSIZE)) {
260
			pr_debug("buffer overflow (COMMENT)?\n");
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263 264 265 266 267 268 269 270 271 272
			goto out_free_buf;
		}
	}

	strm.next_in += ret;
	strm.avail_in -= ret;

	strm.next_out = dst;
	strm.avail_out = len;
	strm.total_out = 0;

	if (zlib_inflateInit2(&strm, -MAX_WBITS) != Z_OK) {
273
		pr_debug("zlib init failed?\n");
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277
		goto out_free_buf;
	}

	while ((ret = zlib_inflate(&strm, Z_NO_FLUSH)) == Z_OK) {
Al Viro's avatar
Al Viro committed
278
		ret = kernel_read(bprm->file, fpos, buf, LBUFSIZE);
Linus Torvalds's avatar
Linus Torvalds committed
279 280 281 282 283 284 285
		if (ret <= 0)
			break;
		len -= ret;

		strm.next_in = buf;
		strm.avail_in = ret;
		strm.total_in = 0;
Al Viro's avatar
Al Viro committed
286
		fpos += ret;
Linus Torvalds's avatar
Linus Torvalds committed
287 288 289
	}

	if (ret < 0) {
290
		pr_debug("decompression failed (%d), %s\n",
Linus Torvalds's avatar
Linus Torvalds committed
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
			ret, strm.msg);
		goto out_zlib;
	}

	retval = 0;
out_zlib:
	zlib_inflateEnd(&strm);
out_free_buf:
	kfree(buf);
out_free:
	kfree(strm.workspace);
	return retval;
}

#endif /* CONFIG_BINFMT_ZFLAT */

/****************************************************************************/

static unsigned long
calc_reloc(unsigned long r, struct lib_info *p, int curid, int internalp)
{
	unsigned long addr;
	int id;
	unsigned long start_brk;
	unsigned long start_data;
	unsigned long text_len;
	unsigned long start_code;

#ifdef CONFIG_BINFMT_SHARED_FLAT
	if (r == 0)
		id = curid;	/* Relocs of 0 are always self referring */
	else {
		id = (r >> 24) & 0xff;	/* Find ID for this reloc */
		r &= 0x00ffffff;	/* Trim ID off here */
	}
	if (id >= MAX_SHARED_LIBS) {
327
		pr_err("reference 0x%lx to shared library %d", r, id);
Linus Torvalds's avatar
Linus Torvalds committed
328 329 330 331
		goto failed;
	}
	if (curid != id) {
		if (internalp) {
332 333
			pr_err("reloc address 0x%lx not in same module "
			       "(%d != %d)", r, curid, id);
Linus Torvalds's avatar
Linus Torvalds committed
334
			goto failed;
Nicolas Pitre's avatar
Nicolas Pitre committed
335 336
		} else if (!p->lib_list[id].loaded &&
			   load_flat_shared_library(id, p) < 0) {
337
			pr_err("failed to load library %d", id);
Linus Torvalds's avatar
Linus Torvalds committed
338 339 340 341 342
			goto failed;
		}
		/* Check versioning information (i.e. time stamps) */
		if (p->lib_list[id].build_date && p->lib_list[curid].build_date &&
				p->lib_list[curid].build_date < p->lib_list[id].build_date) {
343
			pr_err("library %d is younger than %d", id, curid);
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346 347 348 349 350 351 352 353 354 355 356
			goto failed;
		}
	}
#else
	id = 0;
#endif

	start_brk = p->lib_list[id].start_brk;
	start_data = p->lib_list[id].start_data;
	start_code = p->lib_list[id].start_code;
	text_len = p->lib_list[id].text_len;

	if (!flat_reloc_valid(r, start_brk - start_data + text_len)) {
357
		pr_err("reloc outside program 0x%lx (0 - 0x%lx/0x%lx)",
Nicolas Pitre's avatar
Nicolas Pitre committed
358
		       r, start_brk-start_data+text_len, text_len);
Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363 364 365 366 367
		goto failed;
	}

	if (r < text_len)			/* In text segment */
		addr = r + start_code;
	else					/* In data segment */
		addr = r - text_len + start_data;

	/* Range checked already above so doing the range tests is redundant...*/
Nicolas Pitre's avatar
Nicolas Pitre committed
368
	return addr;
Linus Torvalds's avatar
Linus Torvalds committed
369 370

failed:
371
	pr_cont(", killing %s!\n", current->comm);
Linus Torvalds's avatar
Linus Torvalds committed
372 373 374 375 376 377 378
	send_sig(SIGSEGV, current, 0);

	return RELOC_FAILED;
}

/****************************************************************************/

379
static void old_reloc(unsigned long rl)
Linus Torvalds's avatar
Linus Torvalds committed
380
{
Nicolas Pitre's avatar
Nicolas Pitre committed
381
	static const char *segment[] = { "TEXT", "DATA", "BSS", "*UNKNOWN*" };
Linus Torvalds's avatar
Linus Torvalds committed
382
	flat_v2_reloc_t	r;
383 384
	unsigned long __user *ptr;
	unsigned long val;
Nicolas Pitre's avatar
Nicolas Pitre committed
385

Linus Torvalds's avatar
Linus Torvalds committed
386 387
	r.value = rl;
#if defined(CONFIG_COLDFIRE)
388
	ptr = (unsigned long __user *)(current->mm->start_code + r.reloc.offset);
Linus Torvalds's avatar
Linus Torvalds committed
389
#else
390
	ptr = (unsigned long __user *)(current->mm->start_data + r.reloc.offset);
Linus Torvalds's avatar
Linus Torvalds committed
391
#endif
392
	get_user(val, ptr);
Linus Torvalds's avatar
Linus Torvalds committed
393

394 395
	pr_debug("Relocation of variable at DATASEG+%x "
		 "(address %p, currently %lx) into segment %s\n",
396
		 r.reloc.offset, ptr, val, segment[r.reloc.type]);
Nicolas Pitre's avatar
Nicolas Pitre committed
397

Linus Torvalds's avatar
Linus Torvalds committed
398 399
	switch (r.reloc.type) {
	case OLD_FLAT_RELOC_TYPE_TEXT:
400
		val += current->mm->start_code;
Linus Torvalds's avatar
Linus Torvalds committed
401 402
		break;
	case OLD_FLAT_RELOC_TYPE_DATA:
403
		val += current->mm->start_data;
Linus Torvalds's avatar
Linus Torvalds committed
404 405
		break;
	case OLD_FLAT_RELOC_TYPE_BSS:
406
		val += current->mm->end_data;
Linus Torvalds's avatar
Linus Torvalds committed
407 408
		break;
	default:
409
		pr_err("Unknown relocation type=%x\n", r.reloc.type);
Linus Torvalds's avatar
Linus Torvalds committed
410 411
		break;
	}
412
	put_user(val, ptr);
Linus Torvalds's avatar
Linus Torvalds committed
413

414
	pr_debug("Relocation became %lx\n", val);
Nicolas Pitre's avatar
Nicolas Pitre committed
415
}
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418

/****************************************************************************/

Nicolas Pitre's avatar
Nicolas Pitre committed
419
static int load_flat_file(struct linux_binprm *bprm,
Linus Torvalds's avatar
Linus Torvalds committed
420 421
		struct lib_info *libinfo, int id, unsigned long *extra_stack)
{
Nicolas Pitre's avatar
Nicolas Pitre committed
422 423 424 425
	struct flat_hdr *hdr;
	unsigned long textpos, datapos, realdatastart;
	unsigned long text_len, data_len, bss_len, stack_len, full_data, flags;
	unsigned long len, memp, memp_size, extra, rlim;
426
	unsigned long __user *reloc, *rp;
Linus Torvalds's avatar
Linus Torvalds committed
427
	struct inode *inode;
Nicolas Pitre's avatar
Nicolas Pitre committed
428
	int i, rev, relocs;
Linus Torvalds's avatar
Linus Torvalds committed
429 430
	loff_t fpos;
	unsigned long start_code, end_code;
Nicolas Pitre's avatar
Nicolas Pitre committed
431
	ssize_t result;
432
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
433 434

	hdr = ((struct flat_hdr *) bprm->buf);		/* exec-header */
Al Viro's avatar
Al Viro committed
435
	inode = file_inode(bprm->file);
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442 443 444 445 446 447

	text_len  = ntohl(hdr->data_start);
	data_len  = ntohl(hdr->data_end) - ntohl(hdr->data_start);
	bss_len   = ntohl(hdr->bss_end) - ntohl(hdr->data_end);
	stack_len = ntohl(hdr->stack_size);
	if (extra_stack) {
		stack_len += *extra_stack;
		*extra_stack = stack_len;
	}
	relocs    = ntohl(hdr->reloc_count);
	flags     = ntohl(hdr->flags);
	rev       = ntohl(hdr->rev);
Al Viro's avatar
Al Viro committed
448
	full_data = data_len + relocs * sizeof(unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
449

450
	if (strncmp(hdr->magic, "bFLT", 4)) {
Linus Torvalds's avatar
Linus Torvalds committed
451
		/*
452 453 454 455
		 * Previously, here was a printk to tell people
		 *   "BINFMT_FLAT: bad header magic".
		 * But for the kernel which also use ELF FD-PIC format, this
		 * error message is confusing.
Linus Torvalds's avatar
Linus Torvalds committed
456 457
		 * because a lot of people do not manage to produce good
		 */
458 459
		ret = -ENOEXEC;
		goto err;
460 461 462
	}

	if (flags & FLAT_FLAG_KTRACE)
463
		pr_info("Loading file: %s\n", bprm->filename);
464 465

	if (rev != FLAT_VERSION && rev != OLD_FLAT_VERSION) {
466 467
		pr_err("bad flat file version 0x%x (supported 0x%lx and 0x%lx)\n",
		       rev, FLAT_VERSION, OLD_FLAT_VERSION);
468 469
		ret = -ENOEXEC;
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
470
	}
Nicolas Pitre's avatar
Nicolas Pitre committed
471

Linus Torvalds's avatar
Linus Torvalds committed
472 473
	/* Don't allow old format executables to use shared libraries */
	if (rev == OLD_FLAT_VERSION && id != 0) {
474 475
		pr_err("shared libraries are not available before rev 0x%lx\n",
		       FLAT_VERSION);
476 477
		ret = -ENOEXEC;
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
478 479
	}

480 481 482 483 484 485 486 487 488 489 490
	/*
	 * Make sure the header params are sane.
	 * 28 bits (256 MB) is way more than reasonable in this case.
	 * If some top bits are set we have probable binary corruption.
	*/
	if ((text_len | data_len | bss_len | stack_len | full_data) >> 28) {
		pr_err("bad header\n");
		ret = -ENOEXEC;
		goto err;
	}

Linus Torvalds's avatar
Linus Torvalds committed
491 492 493 494 495 496 497 498 499
	/*
	 * fix up the flags for the older format,  there were all kinds
	 * of endian hacks,  this only works for the simple cases
	 */
	if (rev == OLD_FLAT_VERSION && flat_old_ram_flag(flags))
		flags = FLAT_FLAG_RAM;

#ifndef CONFIG_BINFMT_ZFLAT
	if (flags & (FLAT_FLAG_GZIP|FLAT_FLAG_GZDATA)) {
500
		pr_err("Support for ZFLAT executables is not enabled.\n");
501 502
		ret = -ENOEXEC;
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
503 504 505 506 507 508 509 510
	}
#endif

	/*
	 * Check initial limits. This avoids letting people circumvent
	 * size limits imposed on them by creating programs with large
	 * arrays in the data or bss.
	 */
Jiri Slaby's avatar
Jiri Slaby committed
511
	rlim = rlimit(RLIMIT_DATA);
Linus Torvalds's avatar
Linus Torvalds committed
512 513
	if (rlim >= RLIM_INFINITY)
		rlim = ~0;
514 515 516 517 518
	if (data_len + bss_len > rlim) {
		ret = -ENOMEM;
		goto err;
	}

Linus Torvalds's avatar
Linus Torvalds committed
519 520
	/* Flush all traces of the currently running executable */
	if (id == 0) {
Nicolas Pitre's avatar
Nicolas Pitre committed
521 522
		ret = flush_old_exec(bprm);
		if (ret)
523
			goto err;
Linus Torvalds's avatar
Linus Torvalds committed
524 525

		/* OK, This is the point of no return */
526
		set_personality(PER_LINUX_32BIT);
527
		setup_new_exec(bprm);
Linus Torvalds's avatar
Linus Torvalds committed
528 529 530 531 532
	}

	/*
	 * calculate the extra space we need to map in
	 */
Andrew Morton's avatar
Andrew Morton committed
533 534
	extra = max_t(unsigned long, bss_len + stack_len,
			relocs * sizeof(unsigned long));
Linus Torvalds's avatar
Linus Torvalds committed
535 536 537 538 539 540

	/*
	 * there are a couple of cases here,  the separate code/data
	 * case,  and then the fully copied to RAM case which lumps
	 * it all together.
	 */
541
	if (!IS_ENABLED(CONFIG_MMU) && !(flags & (FLAT_FLAG_RAM|FLAT_FLAG_GZIP))) {
Linus Torvalds's avatar
Linus Torvalds committed
542 543 544 545
		/*
		 * this should give us a ROM ptr,  but if it doesn't we don't
		 * really care
		 */
546
		pr_debug("ROM mapping of file (we hope)\n");
Linus Torvalds's avatar
Linus Torvalds committed
547

548
		textpos = vm_mmap(bprm->file, 0, text_len, PROT_READ|PROT_EXEC,
Matt Helsley's avatar
Matt Helsley committed
549
				  MAP_PRIVATE|MAP_EXECUTABLE, 0);
550
		if (!textpos || IS_ERR_VALUE(textpos)) {
551
			ret = textpos;
Nicolas Pitre's avatar
Nicolas Pitre committed
552 553
			if (!textpos)
				ret = -ENOMEM;
554
			pr_err("Unable to mmap process text, errno %d\n", ret);
555
			goto err;
Linus Torvalds's avatar
Linus Torvalds committed
556 557
		}

558
		len = data_len + extra + MAX_SHARED_LIBS * sizeof(unsigned long);
559
		len = PAGE_ALIGN(len);
Nicolas Pitre's avatar
Nicolas Pitre committed
560
		realdatastart = vm_mmap(NULL, 0, len,
561
			PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE, 0);
Linus Torvalds's avatar
Linus Torvalds committed
562

563
		if (realdatastart == 0 || IS_ERR_VALUE(realdatastart)) {
Nicolas Pitre's avatar
Nicolas Pitre committed
564
			ret = realdatastart;
Linus Torvalds's avatar
Linus Torvalds committed
565
			if (!realdatastart)
Nicolas Pitre's avatar
Nicolas Pitre committed
566
				ret = -ENOMEM;
567
			pr_err("Unable to allocate RAM for process data, "
Nicolas Pitre's avatar
Nicolas Pitre committed
568
			       "errno %d\n", ret);
569
			vm_munmap(textpos, text_len);
570
			goto err;
Linus Torvalds's avatar
Linus Torvalds committed
571
		}
572 573 574
		datapos = ALIGN(realdatastart +
				MAX_SHARED_LIBS * sizeof(unsigned long),
				FLAT_DATA_ALIGN);
Linus Torvalds's avatar
Linus Torvalds committed
575

576 577
		pr_debug("Allocated data+bss+stack (%ld bytes): %lx\n",
			 data_len + bss_len + stack_len, datapos);
Linus Torvalds's avatar
Linus Torvalds committed
578 579 580 581

		fpos = ntohl(hdr->data_start);
#ifdef CONFIG_BINFMT_ZFLAT
		if (flags & FLAT_FLAG_GZDATA) {
Nicolas Pitre's avatar
Nicolas Pitre committed
582
			result = decompress_exec(bprm, fpos, (char *)datapos,
Al Viro's avatar
Al Viro committed
583
						 full_data, 0);
Linus Torvalds's avatar
Linus Torvalds committed
584 585 586
		} else
#endif
		{
Al Viro's avatar
Al Viro committed
587 588
			result = read_code(bprm->file, datapos, fpos,
					full_data);
Linus Torvalds's avatar
Linus Torvalds committed
589
		}
590
		if (IS_ERR_VALUE(result)) {
Nicolas Pitre's avatar
Nicolas Pitre committed
591
			ret = result;
592
			pr_err("Unable to read data+bss, errno %d\n", ret);
593 594
			vm_munmap(textpos, text_len);
			vm_munmap(realdatastart, len);
595
			goto err;
Linus Torvalds's avatar
Linus Torvalds committed
596 597
		}

598
		reloc = (unsigned long __user *)
Nicolas Pitre's avatar
Nicolas Pitre committed
599
			(datapos + (ntohl(hdr->reloc_start) - text_len));
Linus Torvalds's avatar
Linus Torvalds committed
600
		memp = realdatastart;
601
		memp_size = len;
Linus Torvalds's avatar
Linus Torvalds committed
602 603
	} else {

604
		len = text_len + data_len + extra + MAX_SHARED_LIBS * sizeof(unsigned long);
605
		len = PAGE_ALIGN(len);
Nicolas Pitre's avatar
Nicolas Pitre committed
606
		textpos = vm_mmap(NULL, 0, len,
607 608
			PROT_READ | PROT_EXEC | PROT_WRITE, MAP_PRIVATE, 0);

609
		if (!textpos || IS_ERR_VALUE(textpos)) {
610
			ret = textpos;
Nicolas Pitre's avatar
Nicolas Pitre committed
611 612
			if (!textpos)
				ret = -ENOMEM;
613
			pr_err("Unable to allocate RAM for process text/data, "
Nicolas Pitre's avatar
Nicolas Pitre committed
614
			       "errno %d\n", ret);
615
			goto err;
Linus Torvalds's avatar
Linus Torvalds committed
616 617 618
		}

		realdatastart = textpos + ntohl(hdr->data_start);
619 620 621 622
		datapos = ALIGN(realdatastart +
				MAX_SHARED_LIBS * sizeof(unsigned long),
				FLAT_DATA_ALIGN);

623
		reloc = (unsigned long __user *)
624
			(datapos + (ntohl(hdr->reloc_start) - text_len));
Linus Torvalds's avatar
Linus Torvalds committed
625
		memp = textpos;
626
		memp_size = len;
Linus Torvalds's avatar
Linus Torvalds committed
627 628 629 630 631
#ifdef CONFIG_BINFMT_ZFLAT
		/*
		 * load it all in and treat it like a RAM load from now on
		 */
		if (flags & FLAT_FLAG_GZIP) {
632
#ifndef CONFIG_MMU
Nicolas Pitre's avatar
Nicolas Pitre committed
633 634
			result = decompress_exec(bprm, sizeof(struct flat_hdr),
					 (((char *)textpos) + sizeof(struct flat_hdr)),
Al Viro's avatar
Al Viro committed
635
					 (text_len + full_data
Nicolas Pitre's avatar
Nicolas Pitre committed
636
						  - sizeof(struct flat_hdr)),
Linus Torvalds's avatar
Linus Torvalds committed
637 638
					 0);
			memmove((void *) datapos, (void *) realdatastart,
Al Viro's avatar
Al Viro committed
639
					full_data);
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
#else
			/*
			 * This is used on MMU systems mainly for testing.
			 * Let's use a kernel buffer to simplify things.
			 */
			long unz_text_len = text_len - sizeof(struct flat_hdr);
			long unz_len = unz_text_len + full_data;
			char *unz_data = vmalloc(unz_len);
			if (!unz_data) {
				result = -ENOMEM;
			} else {
				result = decompress_exec(bprm, sizeof(struct flat_hdr),
							 unz_data, unz_len, 0);
				if (result == 0 &&
				    (copy_to_user((void __user *)textpos + sizeof(struct flat_hdr),
						  unz_data, unz_text_len) ||
				     copy_to_user((void __user *)datapos,
						  unz_data + unz_text_len, full_data)))
					result = -EFAULT;
				vfree(unz_data);
			}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
662
		} else if (flags & FLAT_FLAG_GZDATA) {
Al Viro's avatar
Al Viro committed
663
			result = read_code(bprm->file, textpos, 0, text_len);
664 665
			if (!IS_ERR_VALUE(result)) {
#ifndef CONFIG_MMU
Linus Torvalds's avatar
Linus Torvalds committed
666
				result = decompress_exec(bprm, text_len, (char *) datapos,
Al Viro's avatar
Al Viro committed
667
						 full_data, 0);
668 669 670 671 672 673 674 675 676 677 678 679 680
#else
				char *unz_data = vmalloc(full_data);
				if (!unz_data) {
					result = -ENOMEM;
				} else {
					result = decompress_exec(bprm, text_len,
						       unz_data, full_data, 0);
					if (result == 0 &&
					    copy_to_user((void __user *)datapos,
							 unz_data, full_data))
						result = -EFAULT;
					vfree(unz_data);
				}
Linus Torvalds's avatar
Linus Torvalds committed
681
#endif
682 683 684
			}
		} else
#endif /* CONFIG_BINFMT_ZFLAT */
Linus Torvalds's avatar
Linus Torvalds committed
685
		{
Al Viro's avatar
Al Viro committed
686 687 688 689 690
			result = read_code(bprm->file, textpos, 0, text_len);
			if (!IS_ERR_VALUE(result))
				result = read_code(bprm->file, datapos,
						   ntohl(hdr->data_start),
						   full_data);
Linus Torvalds's avatar
Linus Torvalds committed
691
		}
692
		if (IS_ERR_VALUE(result)) {
Nicolas Pitre's avatar
Nicolas Pitre committed
693
			ret = result;
694
			pr_err("Unable to read code+data+bss, errno %d\n", ret);
695
			vm_munmap(textpos, text_len + data_len + extra +
Linus Torvalds's avatar
Linus Torvalds committed
696
				MAX_SHARED_LIBS * sizeof(unsigned long));
697
			goto err;
Linus Torvalds's avatar
Linus Torvalds committed
698 699 700
		}
	}

Nicolas Pitre's avatar
Nicolas Pitre committed
701 702 703
	start_code = textpos + sizeof(struct flat_hdr);
	end_code = textpos + text_len;
	text_len -= sizeof(struct flat_hdr); /* the real code len */
Linus Torvalds's avatar
Linus Torvalds committed
704 705 706 707 708 709 710 711 712 713 714

	/* The main program needs a little extra setup in the task structure */
	if (id == 0) {
		current->mm->start_code = start_code;
		current->mm->end_code = end_code;
		current->mm->start_data = datapos;
		current->mm->end_data = datapos + data_len;
		/*
		 * set up the brk stuff, uses any slack left in data/bss/stack
		 * allocation.  We put the brk after the bss (between the bss
		 * and stack) like other platforms.
715 716
		 * Userspace code relies on the stack pointer starting out at
		 * an address right at the end of a page.
Linus Torvalds's avatar
Linus Torvalds committed
717 718 719
		 */
		current->mm->start_brk = datapos + data_len + bss_len;
		current->mm->brk = (current->mm->start_brk + 3) & ~3;
720
#ifndef CONFIG_MMU
721
		current->mm->context.end_brk = memp + memp_size - stack_len;
722
#endif
Linus Torvalds's avatar
Linus Torvalds committed
723 724
	}

Nicolas Pitre's avatar
Nicolas Pitre committed
725
	if (flags & FLAT_FLAG_KTRACE) {
726 727 728 729 730 731
		pr_info("Mapping is %lx, Entry point is %x, data_start is %x\n",
			textpos, 0x00ffffff&ntohl(hdr->entry), ntohl(hdr->data_start));
		pr_info("%s %s: TEXT=%lx-%lx DATA=%lx-%lx BSS=%lx-%lx\n",
			id ? "Lib" : "Load", bprm->filename,
			start_code, end_code, datapos, datapos + data_len,
			datapos + data_len, (datapos + data_len + bss_len + 3) & ~3);
Nicolas Pitre's avatar
Nicolas Pitre committed
732
	}
Linus Torvalds's avatar
Linus Torvalds committed
733 734 735 736 737 738 739 740 741

	/* Store the current module values into the global library structure */
	libinfo->lib_list[id].start_code = start_code;
	libinfo->lib_list[id].start_data = datapos;
	libinfo->lib_list[id].start_brk = datapos + data_len + bss_len;
	libinfo->lib_list[id].text_len = text_len;
	libinfo->lib_list[id].loaded = 1;
	libinfo->lib_list[id].entry = (0x00ffffff & ntohl(hdr->entry)) + textpos;
	libinfo->lib_list[id].build_date = ntohl(hdr->build_date);
Nicolas Pitre's avatar
Nicolas Pitre committed
742

Linus Torvalds's avatar
Linus Torvalds committed
743 744 745 746 747
	/*
	 * We just load the allocations into some temporary memory to
	 * help simplify all this mumbo jumbo
	 *
	 * We've got two different sections of relocation entries.
Lucas De Marchi's avatar
Lucas De Marchi committed
748
	 * The first is the GOT which resides at the beginning of the data segment
Linus Torvalds's avatar
Linus Torvalds committed
749 750 751 752 753 754 755
	 * and is terminated with a -1.  This one can be relocated in place.
	 * The second is the extra relocation entries tacked after the image's
	 * data segment. These require a little more processing as the entry is
	 * really an offset into the image which contains an offset into the
	 * image.
	 */
	if (flags & FLAT_FLAG_GOTPIC) {
756 757 758 759 760 761 762 763
		for (rp = (unsigned long __user *)datapos; ; rp++) {
			unsigned long addr, rp_val;
			if (get_user(rp_val, rp))
				return -EFAULT;
			if (rp_val == 0xffffffff)
				break;
			if (rp_val) {
				addr = calc_reloc(rp_val, libinfo, id, 0);
764 765
				if (addr == RELOC_FAILED) {
					ret = -ENOEXEC;
766
					goto err;
767
				}
768 769
				if (put_user(addr, rp))
					return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
			}
		}
	}

	/*
	 * Now run through the relocation entries.
	 * We've got to be careful here as C++ produces relocatable zero
	 * entries in the constructor and destructor tables which are then
	 * tested for being not zero (which will always occur unless we're
	 * based from address zero).  This causes an endless loop as __start
	 * is at zero.  The solution used is to not relocate zero addresses.
	 * This has the negative side effect of not allowing a global data
	 * reference to be statically initialised to _stext (I've moved
	 * __start to address 4 so that is okay).
	 */
	if (rev > OLD_FLAT_VERSION) {
786
		unsigned long __maybe_unused persistent = 0;
Nicolas Pitre's avatar
Nicolas Pitre committed
787
		for (i = 0; i < relocs; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
788 789
			unsigned long addr, relval;

Nicolas Pitre's avatar
Nicolas Pitre committed
790 791 792 793 794
			/*
			 * Get the address of the pointer to be
			 * relocated (of course, the address has to be
			 * relocated first).
			 */
795 796 797
			if (get_user(relval, reloc + i))
				return -EFAULT;
			relval = ntohl(relval);
Nicolas Pitre's avatar
Nicolas Pitre committed
798
			if (flat_set_persistent(relval, &persistent))
799
				continue;
Linus Torvalds's avatar
Linus Torvalds committed
800
			addr = flat_get_relocate_addr(relval);
801 802
			rp = (unsigned long __user *)calc_reloc(addr, libinfo, id, 1);
			if (rp == (unsigned long __user *)RELOC_FAILED) {
803
				ret = -ENOEXEC;
804
				goto err;
805
			}
Linus Torvalds's avatar
Linus Torvalds committed
806 807

			/* Get the pointer's value.  */
808 809
			addr = flat_get_addr_from_rp(rp, relval, flags,
							&persistent);
Linus Torvalds's avatar
Linus Torvalds committed
810 811 812 813 814 815 816 817
			if (addr != 0) {
				/*
				 * Do the relocation.  PIC relocs in the data section are
				 * already in target order
				 */
				if ((flags & FLAT_FLAG_GOTPIC) == 0)
					addr = ntohl(addr);
				addr = calc_reloc(addr, libinfo, id, 0);
818 819
				if (addr == RELOC_FAILED) {
					ret = -ENOEXEC;
820
					goto err;
821
				}
Linus Torvalds's avatar
Linus Torvalds committed
822 823 824 825 826 827

				/* Write back the relocated pointer.  */
				flat_put_addr_at_rp(rp, addr, relval);
			}
		}
	} else {
828 829 830 831 832 833 834
		for (i = 0; i < relocs; i++) {
			unsigned long relval;
			if (get_user(relval, reloc + i))
				return -EFAULT;
			relval = ntohl(relval);
			old_reloc(relval);
		}
Linus Torvalds's avatar
Linus Torvalds committed
835
	}
Nicolas Pitre's avatar
Nicolas Pitre committed
836

Linus Torvalds's avatar
Linus Torvalds committed
837 838 839
	flush_icache_range(start_code, end_code);

	/* zero the BSS,  BRK and stack areas */
840 841 842 843 844
	if (clear_user((void __user *)(datapos + data_len), bss_len +
		       (memp + memp_size - stack_len -		/* end brk */
		       libinfo->lib_list[id].start_brk) +	/* start brk */
		       stack_len))
		return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
845 846

	return 0;
847 848
err:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
}


/****************************************************************************/
#ifdef CONFIG_BINFMT_SHARED_FLAT

/*
 * Load a shared library into memory.  The library gets its own data
 * segment (including bss) but not argv/argc/environ.
 */

static int load_flat_shared_library(int id, struct lib_info *libs)
{
	struct linux_binprm bprm;
	int res;
	char buf[16];

866 867
	memset(&bprm, 0, sizeof(bprm));

Linus Torvalds's avatar
Linus Torvalds committed
868 869 870 871 872 873 874 875 876 877
	/* Create the file name */
	sprintf(buf, "/lib/lib%d.so", id);

	/* Open the file up */
	bprm.filename = buf;
	bprm.file = open_exec(bprm.filename);
	res = PTR_ERR(bprm.file);
	if (IS_ERR(bprm.file))
		return res;

878 879 880 881 882
	bprm.cred = prepare_exec_creds();
	res = -ENOMEM;
	if (!bprm.cred)
		goto out;

883 884 885 886 887 888
	/* We don't really care about recalculating credentials at this point
	 * as we're past the point of no return and are dealing with shared
	 * libraries.
	 */
	bprm.cred_prepared = 1;

Linus Torvalds's avatar
Linus Torvalds committed
889 890
	res = prepare_binprm(&bprm);

891
	if (!res)
Linus Torvalds's avatar
Linus Torvalds committed
892
		res = load_flat_file(&bprm, libs, id, NULL);
893 894 895 896 897 898 899

	abort_creds(bprm.cred);

out:
	allow_write_access(bprm.file);
	fput(bprm.file);

Nicolas Pitre's avatar
Nicolas Pitre committed
900
	return res;
Linus Torvalds's avatar
Linus Torvalds committed
901 902 903 904 905 906 907 908 909 910
}

#endif /* CONFIG_BINFMT_SHARED_FLAT */
/****************************************************************************/

/*
 * These are the functions used to load flat style executables and shared
 * libraries.  There is no binary dependent code anywhere else.
 */

Nicolas Pitre's avatar
Nicolas Pitre committed
911
static int load_flat_binary(struct linux_binprm *bprm)
Linus Torvalds's avatar
Linus Torvalds committed
912 913
{
	struct lib_info libinfo;
914
	struct pt_regs *regs = current_pt_regs();
915
	unsigned long stack_len = 0;
Linus Torvalds's avatar
Linus Torvalds committed
916 917 918 919 920
	unsigned long start_addr;
	int res;
	int i, j;

	memset(&libinfo, 0, sizeof(libinfo));
Nicolas Pitre's avatar
Nicolas Pitre committed
921

Linus Torvalds's avatar
Linus Torvalds committed
922 923 924 925 926 927 928
	/*
	 * We have to add the size of our arguments to our stack size
	 * otherwise it's too easy for users to create stack overflows
	 * by passing in a huge argument list.  And yes,  we have to be
	 * pedantic and include space for the argv/envp array as it may have
	 * a lot of entries.
	 */
929 930 931
#ifndef CONFIG_MMU
	stack_len += PAGE_SIZE * MAX_ARG_PAGES - bprm->p; /* the strings */
#endif
932 933 934
	stack_len += (bprm->argc + 1) * sizeof(char *);   /* the argv array */
	stack_len += (bprm->envc + 1) * sizeof(char *);   /* the envp array */
	stack_len = ALIGN(stack_len, FLAT_STACK_ALIGN);
Nicolas Pitre's avatar
Nicolas Pitre committed
935

Linus Torvalds's avatar
Linus Torvalds committed
936
	res = load_flat_file(bprm, &libinfo, 0, &stack_len);
937
	if (res < 0)
Linus Torvalds's avatar
Linus Torvalds committed
938
		return res;
Nicolas Pitre's avatar
Nicolas Pitre committed
939

Linus Torvalds's avatar
Linus Torvalds committed
940
	/* Update data segment pointers for all libraries */
941 942 943 944 945 946 947 948 949 950 951 952 953
	for (i = 0; i < MAX_SHARED_LIBS; i++) {
		if (!libinfo.lib_list[i].loaded)
			continue;
		for (j = 0; j < MAX_SHARED_LIBS; j++) {
			unsigned long val = libinfo.lib_list[j].loaded ?
				libinfo.lib_list[j].start_data : UNLOADED_LIB;
			unsigned long __user *p = (unsigned long __user *)
				libinfo.lib_list[i].start_data;
			p -= j + 1;
			if (put_user(val, p))
				return -EFAULT;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
954

955
	install_exec_creds(bprm);
Linus Torvalds's avatar
Linus Torvalds committed
956 957 958

	set_binfmt(&flat_format);

959 960 961 962 963
#ifdef CONFIG_MMU
	res = setup_arg_pages(bprm, STACK_TOP, EXSTACK_DEFAULT);
	if (!res)
		res = create_flat_tables(bprm, bprm->p);
#else
964 965 966 967
	/* Stash our initial stack pointer into the mm structure */
	current->mm->start_stack =
		((current->mm->context.end_brk + stack_len + 3) & ~3) - 4;
	pr_debug("sp=%lx\n", current->mm->start_stack);
Linus Torvalds's avatar
Linus Torvalds committed
968

969
	/* copy the arg pages onto the stack */
970 971 972
	res = transfer_args_to_stack(bprm, &current->mm->start_stack);
	if (!res)
		res = create_flat_tables(bprm, current->mm->start_stack);
973
#endif
974 975
	if (res)
		return res;
Linus Torvalds's avatar
Linus Torvalds committed
976 977 978 979 980 981 982 983

	/* Fake some return addresses to ensure the call chain will
	 * initialise library in order for us.  We are required to call
	 * lib 1 first, then 2, ... and finally the main program (id 0).
	 */
	start_addr = libinfo.lib_list[0].entry;

#ifdef CONFIG_BINFMT_SHARED_FLAT
Nicolas Pitre's avatar
Nicolas Pitre committed
984
	for (i = MAX_SHARED_LIBS-1; i > 0; i--) {
Linus Torvalds's avatar
Linus Torvalds committed
985 986
		if (libinfo.lib_list[i].loaded) {
			/* Push previos first to call address */
987 988 989 990
			unsigned long __user *sp;
			current->mm->start_stack -= sizeof(unsigned long);
			sp = (unsigned long __user *)current->mm->start_stack;
			__put_user(start_addr, sp);
Linus Torvalds's avatar
Linus Torvalds committed
991 992 993 994
			start_addr = libinfo.lib_list[i].entry;
		}
	}
#endif
Nicolas Pitre's avatar
Nicolas Pitre committed
995

996 997 998
#ifdef FLAT_PLAT_INIT
	FLAT_PLAT_INIT(regs);
#endif
Nicolas Pitre's avatar
Nicolas Pitre committed
999

1000 1001
	pr_debug("start_thread(regs=0x%p, entry=0x%lx, start_stack=0x%lx)\n",
		 regs, start_addr, current->mm->start_stack);
Linus Torvalds's avatar
Linus Torvalds committed
1002 1003 1004 1005 1006 1007 1008 1009 1010
	start_thread(regs, start_addr, current->mm->start_stack);

	return 0;
}

/****************************************************************************/

static int __init init_flat_binfmt(void)
{
Al Viro's avatar
Al Viro committed
1011 1012
	register_binfmt(&flat_format);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1013 1014 1015 1016
}
core_initcall(init_flat_binfmt);

/****************************************************************************/