a.out: remove core dumping support
We're (finally) phasing out a.out support for good. As Borislav Petkov points out, we've supported ELF binaries for about 25 years by now, and coredumping in particular has bitrotted over the years. None of the tool chains even support generating a.out binaries any more, and the plan is to deprecate a.out support entirely for the kernel. But I want to start with just removing the core dumping code, because I can still imagine that somebody actually might want to support a.out as a simpler biinary format. Particularly if you generate some random binaries on the fly, ELF is a much more complicated format (admittedly ELF also does have a lot of toolchain support, mitigating that complexity a lot and you really should have moved over in the last 25 years). So it's at least somewhat possible that somebody out there has some workflow that still involves generating and running a.out executables. In contrast, it's very unlikely that anybody depends on debugging any legacy a.out core files. But regardless, I want this phase-out to be done in two steps, so that we can resurrect a.out support (if needed) without having to resurrect the core file dumping that is almost certainly not needed. Jann Horn pointed to the <asm/a.out-core.h> file that my first trivial cut at this had missed. And Alan Cox points out that the a.out binary loader _could_ be done in user space if somebody wants to, but we might keep just the loader in the kernel if somebody really wants it, since the loader isn't that big and has no really odd special cases like the core dumping does. Acked-by: Borislav Petkov <bp@alien8.de> Cc: Alan Cox <gnomes@lxorguk.ukuu.org.uk> Cc: Jann Horn <jannh@google.com> Cc: Richard Weinberger <richard@nod.at> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Linus Torvalds
parent
63bdf4284c
commit
08300f4402
|
|
@ -1,81 +0,0 @@
|
|||
/* a.out coredump register dumper
|
||||
*
|
||||
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
||||
* Written by David Howells (dhowells@redhat.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public Licence
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the Licence, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#ifndef _ASM_A_OUT_CORE_H
|
||||
#define _ASM_A_OUT_CORE_H
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
#include <linux/user.h>
|
||||
#include <linux/mm_types.h>
|
||||
|
||||
/*
|
||||
* Fill in the user structure for an ECOFF core dump.
|
||||
*/
|
||||
static inline void aout_dump_thread(struct pt_regs *pt, struct user *dump)
|
||||
{
|
||||
/* switch stack follows right below pt_regs: */
|
||||
struct switch_stack * sw = ((struct switch_stack *) pt) - 1;
|
||||
|
||||
dump->magic = CMAGIC;
|
||||
dump->start_code = current->mm->start_code;
|
||||
dump->start_data = current->mm->start_data;
|
||||
dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
|
||||
dump->u_tsize = ((current->mm->end_code - dump->start_code)
|
||||
>> PAGE_SHIFT);
|
||||
dump->u_dsize = ((current->mm->brk + PAGE_SIZE-1 - dump->start_data)
|
||||
>> PAGE_SHIFT);
|
||||
dump->u_ssize = (current->mm->start_stack - dump->start_stack
|
||||
+ PAGE_SIZE-1) >> PAGE_SHIFT;
|
||||
|
||||
/*
|
||||
* We store the registers in an order/format that is
|
||||
* compatible with DEC Unix/OSF/1 as this makes life easier
|
||||
* for gdb.
|
||||
*/
|
||||
dump->regs[EF_V0] = pt->r0;
|
||||
dump->regs[EF_T0] = pt->r1;
|
||||
dump->regs[EF_T1] = pt->r2;
|
||||
dump->regs[EF_T2] = pt->r3;
|
||||
dump->regs[EF_T3] = pt->r4;
|
||||
dump->regs[EF_T4] = pt->r5;
|
||||
dump->regs[EF_T5] = pt->r6;
|
||||
dump->regs[EF_T6] = pt->r7;
|
||||
dump->regs[EF_T7] = pt->r8;
|
||||
dump->regs[EF_S0] = sw->r9;
|
||||
dump->regs[EF_S1] = sw->r10;
|
||||
dump->regs[EF_S2] = sw->r11;
|
||||
dump->regs[EF_S3] = sw->r12;
|
||||
dump->regs[EF_S4] = sw->r13;
|
||||
dump->regs[EF_S5] = sw->r14;
|
||||
dump->regs[EF_S6] = sw->r15;
|
||||
dump->regs[EF_A3] = pt->r19;
|
||||
dump->regs[EF_A4] = pt->r20;
|
||||
dump->regs[EF_A5] = pt->r21;
|
||||
dump->regs[EF_T8] = pt->r22;
|
||||
dump->regs[EF_T9] = pt->r23;
|
||||
dump->regs[EF_T10] = pt->r24;
|
||||
dump->regs[EF_T11] = pt->r25;
|
||||
dump->regs[EF_RA] = pt->r26;
|
||||
dump->regs[EF_T12] = pt->r27;
|
||||
dump->regs[EF_AT] = pt->r28;
|
||||
dump->regs[EF_SP] = rdusp();
|
||||
dump->regs[EF_PS] = pt->ps;
|
||||
dump->regs[EF_PC] = pt->pc;
|
||||
dump->regs[EF_GP] = pt->gp;
|
||||
dump->regs[EF_A0] = pt->r16;
|
||||
dump->regs[EF_A1] = pt->r17;
|
||||
dump->regs[EF_A2] = pt->r18;
|
||||
memcpy((char *)dump->regs + EF_SIZE, sw->fp, 32 * 8);
|
||||
}
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
#endif /* _ASM_A_OUT_CORE_H */
|
||||
|
|
@ -1,68 +0,0 @@
|
|||
/* a.out coredump register dumper
|
||||
*
|
||||
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
||||
* Written by David Howells (dhowells@redhat.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public Licence
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the Licence, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#ifndef _ASM_A_OUT_CORE_H
|
||||
#define _ASM_A_OUT_CORE_H
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
#include <linux/user.h>
|
||||
#include <linux/elfcore.h>
|
||||
#include <linux/mm_types.h>
|
||||
|
||||
/*
|
||||
* fill in the user structure for an a.out core dump
|
||||
*/
|
||||
static inline void aout_dump_thread(struct pt_regs *regs, struct user *dump)
|
||||
{
|
||||
struct switch_stack *sw;
|
||||
|
||||
/* changed the size calculations - should hopefully work better. lbt */
|
||||
dump->magic = CMAGIC;
|
||||
dump->start_code = 0;
|
||||
dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
|
||||
dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
|
||||
dump->u_dsize = ((unsigned long) (current->mm->brk +
|
||||
(PAGE_SIZE-1))) >> PAGE_SHIFT;
|
||||
dump->u_dsize -= dump->u_tsize;
|
||||
dump->u_ssize = 0;
|
||||
|
||||
if (dump->start_stack < TASK_SIZE)
|
||||
dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
|
||||
|
||||
dump->u_ar0 = offsetof(struct user, regs);
|
||||
sw = ((struct switch_stack *)regs) - 1;
|
||||
dump->regs.d1 = regs->d1;
|
||||
dump->regs.d2 = regs->d2;
|
||||
dump->regs.d3 = regs->d3;
|
||||
dump->regs.d4 = regs->d4;
|
||||
dump->regs.d5 = regs->d5;
|
||||
dump->regs.d6 = sw->d6;
|
||||
dump->regs.d7 = sw->d7;
|
||||
dump->regs.a0 = regs->a0;
|
||||
dump->regs.a1 = regs->a1;
|
||||
dump->regs.a2 = regs->a2;
|
||||
dump->regs.a3 = sw->a3;
|
||||
dump->regs.a4 = sw->a4;
|
||||
dump->regs.a5 = sw->a5;
|
||||
dump->regs.a6 = sw->a6;
|
||||
dump->regs.d0 = regs->d0;
|
||||
dump->regs.orig_d0 = regs->orig_d0;
|
||||
dump->regs.stkadj = regs->stkadj;
|
||||
dump->regs.sr = regs->sr;
|
||||
dump->regs.pc = regs->pc;
|
||||
dump->regs.fmtvec = (regs->format << 12) | regs->vector;
|
||||
/* dump floating point stuff */
|
||||
dump->u_fpvalid = dump_fpu (regs, &dump->m68kfp);
|
||||
}
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
#endif /* _ASM_A_OUT_CORE_H */
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
/* a.out coredump register dumper
|
||||
*
|
||||
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
||||
* Written by David Howells (dhowells@redhat.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public Licence
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the Licence, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#ifndef __UM_A_OUT_CORE_H
|
||||
#define __UM_A_OUT_CORE_H
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
#include <linux/user.h>
|
||||
|
||||
/*
|
||||
* fill in the user structure for an a.out core dump
|
||||
*/
|
||||
static inline void aout_dump_thread(struct pt_regs *regs, struct user *u)
|
||||
{
|
||||
}
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
#endif /* __UM_A_OUT_CORE_H */
|
||||
|
|
@ -39,82 +39,10 @@
|
|||
static int load_aout_binary(struct linux_binprm *);
|
||||
static int load_aout_library(struct file *);
|
||||
|
||||
#ifdef CONFIG_COREDUMP
|
||||
static int aout_core_dump(struct coredump_params *);
|
||||
|
||||
static unsigned long get_dr(int n)
|
||||
{
|
||||
struct perf_event *bp = current->thread.ptrace_bps[n];
|
||||
return bp ? bp->hw.info.address : 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* fill in the user structure for a core dump..
|
||||
*/
|
||||
static void fill_dump(struct pt_regs *regs, struct user32 *dump)
|
||||
{
|
||||
u32 fs, gs;
|
||||
memset(dump, 0, sizeof(*dump));
|
||||
|
||||
/* changed the size calculations - should hopefully work better. lbt */
|
||||
dump->magic = CMAGIC;
|
||||
dump->start_code = 0;
|
||||
dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);
|
||||
dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
|
||||
dump->u_dsize = ((unsigned long)
|
||||
(current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
|
||||
dump->u_dsize -= dump->u_tsize;
|
||||
dump->u_debugreg[0] = get_dr(0);
|
||||
dump->u_debugreg[1] = get_dr(1);
|
||||
dump->u_debugreg[2] = get_dr(2);
|
||||
dump->u_debugreg[3] = get_dr(3);
|
||||
dump->u_debugreg[6] = current->thread.debugreg6;
|
||||
dump->u_debugreg[7] = current->thread.ptrace_dr7;
|
||||
|
||||
if (dump->start_stack < 0xc0000000) {
|
||||
unsigned long tmp;
|
||||
|
||||
tmp = (unsigned long) (0xc0000000 - dump->start_stack);
|
||||
dump->u_ssize = tmp >> PAGE_SHIFT;
|
||||
}
|
||||
|
||||
dump->regs.ebx = regs->bx;
|
||||
dump->regs.ecx = regs->cx;
|
||||
dump->regs.edx = regs->dx;
|
||||
dump->regs.esi = regs->si;
|
||||
dump->regs.edi = regs->di;
|
||||
dump->regs.ebp = regs->bp;
|
||||
dump->regs.eax = regs->ax;
|
||||
dump->regs.ds = current->thread.ds;
|
||||
dump->regs.es = current->thread.es;
|
||||
savesegment(fs, fs);
|
||||
dump->regs.fs = fs;
|
||||
savesegment(gs, gs);
|
||||
dump->regs.gs = gs;
|
||||
dump->regs.orig_eax = regs->orig_ax;
|
||||
dump->regs.eip = regs->ip;
|
||||
dump->regs.cs = regs->cs;
|
||||
dump->regs.eflags = regs->flags;
|
||||
dump->regs.esp = regs->sp;
|
||||
dump->regs.ss = regs->ss;
|
||||
|
||||
#if 1 /* FIXME */
|
||||
dump->u_fpvalid = 0;
|
||||
#else
|
||||
dump->u_fpvalid = dump_fpu(regs, &dump->i387);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static struct linux_binfmt aout_format = {
|
||||
.module = THIS_MODULE,
|
||||
.load_binary = load_aout_binary,
|
||||
.load_shlib = load_aout_library,
|
||||
#ifdef CONFIG_COREDUMP
|
||||
.core_dump = aout_core_dump,
|
||||
#endif
|
||||
.min_coredump = PAGE_SIZE
|
||||
};
|
||||
|
||||
static int set_brk(unsigned long start, unsigned long end)
|
||||
|
|
@ -126,93 +54,6 @@ static int set_brk(unsigned long start, unsigned long end)
|
|||
return vm_brk(start, end - start);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COREDUMP
|
||||
/*
|
||||
* These are the only things you should do on a core-file: use only these
|
||||
* macros to write out all the necessary info.
|
||||
*/
|
||||
|
||||
#include <linux/coredump.h>
|
||||
|
||||
#define START_DATA(u) (u.u_tsize << PAGE_SHIFT)
|
||||
#define START_STACK(u) (u.start_stack)
|
||||
|
||||
/*
|
||||
* Routine writes a core dump image in the current directory.
|
||||
* Currently only a stub-function.
|
||||
*
|
||||
* Note that setuid/setgid files won't make a core-dump if the uid/gid
|
||||
* changed due to the set[u|g]id. It's enforced by the "current->mm->dumpable"
|
||||
* field, which also makes sure the core-dumps won't be recursive if the
|
||||
* dumping of the process results in another error..
|
||||
*/
|
||||
|
||||
static int aout_core_dump(struct coredump_params *cprm)
|
||||
{
|
||||
mm_segment_t fs;
|
||||
int has_dumped = 0;
|
||||
unsigned long dump_start, dump_size;
|
||||
struct user32 dump;
|
||||
|
||||
fs = get_fs();
|
||||
set_fs(KERNEL_DS);
|
||||
has_dumped = 1;
|
||||
|
||||
fill_dump(cprm->regs, &dump);
|
||||
|
||||
strncpy(dump.u_comm, current->comm, sizeof(current->comm));
|
||||
dump.u_ar0 = offsetof(struct user32, regs);
|
||||
dump.signal = cprm->siginfo->si_signo;
|
||||
|
||||
/*
|
||||
* If the size of the dump file exceeds the rlimit, then see
|
||||
* what would happen if we wrote the stack, but not the data
|
||||
* area.
|
||||
*/
|
||||
if ((dump.u_dsize + dump.u_ssize + 1) * PAGE_SIZE > cprm->limit)
|
||||
dump.u_dsize = 0;
|
||||
|
||||
/* Make sure we have enough room to write the stack and data areas. */
|
||||
if ((dump.u_ssize + 1) * PAGE_SIZE > cprm->limit)
|
||||
dump.u_ssize = 0;
|
||||
|
||||
/* make sure we actually have a data and stack area to dump */
|
||||
set_fs(USER_DS);
|
||||
if (!access_ok((void *) (unsigned long)START_DATA(dump),
|
||||
dump.u_dsize << PAGE_SHIFT))
|
||||
dump.u_dsize = 0;
|
||||
if (!access_ok((void *) (unsigned long)START_STACK(dump),
|
||||
dump.u_ssize << PAGE_SHIFT))
|
||||
dump.u_ssize = 0;
|
||||
|
||||
set_fs(KERNEL_DS);
|
||||
/* struct user */
|
||||
if (!dump_emit(cprm, &dump, sizeof(dump)))
|
||||
goto end_coredump;
|
||||
/* Now dump all of the user data. Include malloced stuff as well */
|
||||
if (!dump_skip(cprm, PAGE_SIZE - sizeof(dump)))
|
||||
goto end_coredump;
|
||||
/* now we start writing out the user space info */
|
||||
set_fs(USER_DS);
|
||||
/* Dump the data area */
|
||||
if (dump.u_dsize != 0) {
|
||||
dump_start = START_DATA(dump);
|
||||
dump_size = dump.u_dsize << PAGE_SHIFT;
|
||||
if (!dump_emit(cprm, (void *)dump_start, dump_size))
|
||||
goto end_coredump;
|
||||
}
|
||||
/* Now prepare to dump the stack area */
|
||||
if (dump.u_ssize != 0) {
|
||||
dump_start = START_STACK(dump);
|
||||
dump_size = dump.u_ssize << PAGE_SHIFT;
|
||||
if (!dump_emit(cprm, (void *)dump_start, dump_size))
|
||||
goto end_coredump;
|
||||
}
|
||||
end_coredump:
|
||||
set_fs(fs);
|
||||
return has_dumped;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* create_aout_tables() parses the env- and arg-strings in new user
|
||||
|
|
|
|||
|
|
@ -1,67 +0,0 @@
|
|||
/* a.out coredump register dumper
|
||||
*
|
||||
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
||||
* Written by David Howells (dhowells@redhat.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public Licence
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the Licence, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#ifndef _ASM_X86_A_OUT_CORE_H
|
||||
#define _ASM_X86_A_OUT_CORE_H
|
||||
|
||||
#ifdef __KERNEL__
|
||||
#ifdef CONFIG_X86_32
|
||||
|
||||
#include <linux/user.h>
|
||||
#include <linux/elfcore.h>
|
||||
#include <linux/mm_types.h>
|
||||
|
||||
#include <asm/debugreg.h>
|
||||
|
||||
/*
|
||||
* fill in the user structure for an a.out core dump
|
||||
*/
|
||||
static inline void aout_dump_thread(struct pt_regs *regs, struct user *dump)
|
||||
{
|
||||
/* changed the size calculations - should hopefully work better. lbt */
|
||||
dump->magic = CMAGIC;
|
||||
dump->start_code = 0;
|
||||
dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);
|
||||
dump->u_tsize = ((unsigned long)current->mm->end_code) >> PAGE_SHIFT;
|
||||
dump->u_dsize = ((unsigned long)(current->mm->brk + (PAGE_SIZE - 1)))
|
||||
>> PAGE_SHIFT;
|
||||
dump->u_dsize -= dump->u_tsize;
|
||||
dump->u_ssize = 0;
|
||||
aout_dump_debugregs(dump);
|
||||
|
||||
if (dump->start_stack < TASK_SIZE)
|
||||
dump->u_ssize = ((unsigned long)(TASK_SIZE - dump->start_stack))
|
||||
>> PAGE_SHIFT;
|
||||
|
||||
dump->regs.bx = regs->bx;
|
||||
dump->regs.cx = regs->cx;
|
||||
dump->regs.dx = regs->dx;
|
||||
dump->regs.si = regs->si;
|
||||
dump->regs.di = regs->di;
|
||||
dump->regs.bp = regs->bp;
|
||||
dump->regs.ax = regs->ax;
|
||||
dump->regs.ds = (u16)regs->ds;
|
||||
dump->regs.es = (u16)regs->es;
|
||||
dump->regs.fs = (u16)regs->fs;
|
||||
dump->regs.gs = get_user_gs(regs);
|
||||
dump->regs.orig_ax = regs->orig_ax;
|
||||
dump->regs.ip = regs->ip;
|
||||
dump->regs.cs = (u16)regs->cs;
|
||||
dump->regs.flags = regs->flags;
|
||||
dump->regs.sp = regs->sp;
|
||||
dump->regs.ss = (u16)regs->ss;
|
||||
|
||||
dump->u_fpvalid = dump_fpu(regs, &dump->i387);
|
||||
}
|
||||
|
||||
#endif /* CONFIG_X86_32 */
|
||||
#endif /* __KERNEL__ */
|
||||
#endif /* _ASM_X86_A_OUT_CORE_H */
|
||||
|
|
@ -29,97 +29,14 @@
|
|||
|
||||
#include <linux/uaccess.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm/a.out-core.h>
|
||||
|
||||
static int load_aout_binary(struct linux_binprm *);
|
||||
static int load_aout_library(struct file*);
|
||||
|
||||
#ifdef CONFIG_COREDUMP
|
||||
/*
|
||||
* Routine writes a core dump image in the current directory.
|
||||
* Currently only a stub-function.
|
||||
*
|
||||
* Note that setuid/setgid files won't make a core-dump if the uid/gid
|
||||
* changed due to the set[u|g]id. It's enforced by the "current->mm->dumpable"
|
||||
* field, which also makes sure the core-dumps won't be recursive if the
|
||||
* dumping of the process results in another error..
|
||||
*/
|
||||
static int aout_core_dump(struct coredump_params *cprm)
|
||||
{
|
||||
mm_segment_t fs;
|
||||
int has_dumped = 0;
|
||||
void __user *dump_start;
|
||||
int dump_size;
|
||||
struct user dump;
|
||||
#ifdef __alpha__
|
||||
# define START_DATA(u) ((void __user *)u.start_data)
|
||||
#else
|
||||
# define START_DATA(u) ((void __user *)((u.u_tsize << PAGE_SHIFT) + \
|
||||
u.start_code))
|
||||
#endif
|
||||
# define START_STACK(u) ((void __user *)u.start_stack)
|
||||
|
||||
fs = get_fs();
|
||||
set_fs(KERNEL_DS);
|
||||
has_dumped = 1;
|
||||
strncpy(dump.u_comm, current->comm, sizeof(dump.u_comm));
|
||||
dump.u_ar0 = offsetof(struct user, regs);
|
||||
dump.signal = cprm->siginfo->si_signo;
|
||||
aout_dump_thread(cprm->regs, &dump);
|
||||
|
||||
/* If the size of the dump file exceeds the rlimit, then see what would happen
|
||||
if we wrote the stack, but not the data area. */
|
||||
if ((dump.u_dsize + dump.u_ssize+1) * PAGE_SIZE > cprm->limit)
|
||||
dump.u_dsize = 0;
|
||||
|
||||
/* Make sure we have enough room to write the stack and data areas. */
|
||||
if ((dump.u_ssize + 1) * PAGE_SIZE > cprm->limit)
|
||||
dump.u_ssize = 0;
|
||||
|
||||
/* make sure we actually have a data and stack area to dump */
|
||||
set_fs(USER_DS);
|
||||
if (!access_ok(START_DATA(dump), dump.u_dsize << PAGE_SHIFT))
|
||||
dump.u_dsize = 0;
|
||||
if (!access_ok(START_STACK(dump), dump.u_ssize << PAGE_SHIFT))
|
||||
dump.u_ssize = 0;
|
||||
|
||||
set_fs(KERNEL_DS);
|
||||
/* struct user */
|
||||
if (!dump_emit(cprm, &dump, sizeof(dump)))
|
||||
goto end_coredump;
|
||||
/* Now dump all of the user data. Include malloced stuff as well */
|
||||
if (!dump_skip(cprm, PAGE_SIZE - sizeof(dump)))
|
||||
goto end_coredump;
|
||||
/* now we start writing out the user space info */
|
||||
set_fs(USER_DS);
|
||||
/* Dump the data area */
|
||||
if (dump.u_dsize != 0) {
|
||||
dump_start = START_DATA(dump);
|
||||
dump_size = dump.u_dsize << PAGE_SHIFT;
|
||||
if (!dump_emit(cprm, dump_start, dump_size))
|
||||
goto end_coredump;
|
||||
}
|
||||
/* Now prepare to dump the stack area */
|
||||
if (dump.u_ssize != 0) {
|
||||
dump_start = START_STACK(dump);
|
||||
dump_size = dump.u_ssize << PAGE_SHIFT;
|
||||
if (!dump_emit(cprm, dump_start, dump_size))
|
||||
goto end_coredump;
|
||||
}
|
||||
end_coredump:
|
||||
set_fs(fs);
|
||||
return has_dumped;
|
||||
}
|
||||
#else
|
||||
#define aout_core_dump NULL
|
||||
#endif
|
||||
|
||||
static struct linux_binfmt aout_format = {
|
||||
.module = THIS_MODULE,
|
||||
.load_binary = load_aout_binary,
|
||||
.load_shlib = load_aout_library,
|
||||
.core_dump = aout_core_dump,
|
||||
.min_coredump = PAGE_SIZE
|
||||
};
|
||||
|
||||
#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
|
||||
|
|
|
|||
Loading…
Reference in New Issue