Commit 7fa30315 authored by David Howells's avatar David Howells Committed by Linus Torvalds
Browse files

aout: suppress A.OUT library support if !CONFIG_ARCH_SUPPORTS_AOUT 



Suppress A.OUT library support if CONFIG_ARCH_SUPPORTS_AOUT is not set.

Not all architectures support the A.OUT binfmt, so the ELF binfmt should not
be permitted to go looking for A.OUT libraries to load in such a case.  Not
only that, but under such conditions A.OUT core dumps are not produced either.

To make this work, this patch also does the following:

 (1) Makes the existence of the contents of linux/a.out.h contingent on
     CONFIG_ARCH_SUPPORTS_AOUT.

 (2) Renames dump_thread() to aout_dump_thread() as it's only called by A.OUT
     core dumping code.

 (3) Moves aout_dump_thread() into asm/a.out-core.h and makes it inline.  This
     is then included only where needed.  This means that this bit of arch
     code will be stored in the appropriate A.OUT binfmt module rather than
     the core kernel.

 (4) Drops A.OUT support for Blackfin (according to Mike Frysinger it's not
     needed) and FRV.

This patch depends on the previous patch to move STACK_TOP[_MAX] out of
asm/a.out.h and into asm/processor.h as they're required whether or not A.OUT
format is available.

[jdike@addtoit.com: uml: re-remove accidentally restored code]
Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: default avatarJeff Dike <jdike@linux.intel.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent b0b933c0

arch/alpha/kernel/process.c

+0 −62
Original line number Diff line number Diff line
@@ -317,68 +317,6 @@ copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 
	return 0;

}



/*

 * Fill in the user structure for an ECOFF core dump.

 */

void

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);

}

EXPORT_SYMBOL(dump_thread);



/*

 * Fill in the user structure for a ELF core dump.

 */

arch/arm/kernel/process.c

+0 −29
Original line number Diff line number Diff line
@@ -367,35 +367,6 @@ int dump_fpu (struct pt_regs *regs, struct user_fp *fp) 
}

EXPORT_SYMBOL(dump_fpu);



/*

 * fill in the user structure for a core dump..

 */

void dump_thread(struct pt_regs * regs, struct user * dump)

{

	struct task_struct *tsk = current;



	dump->magic = CMAGIC;

	dump->start_code = tsk->mm->start_code;

	dump->start_stack = regs->ARM_sp & ~(PAGE_SIZE - 1);



	dump->u_tsize = (tsk->mm->end_code - tsk->mm->start_code) >> PAGE_SHIFT;

	dump->u_dsize = (tsk->mm->brk - tsk->mm->start_data + PAGE_SIZE - 1) >> PAGE_SHIFT;

	dump->u_ssize = 0;



	dump->u_debugreg[0] = tsk->thread.debug.bp[0].address;

	dump->u_debugreg[1] = tsk->thread.debug.bp[1].address;

	dump->u_debugreg[2] = tsk->thread.debug.bp[0].insn.arm;

	dump->u_debugreg[3] = tsk->thread.debug.bp[1].insn.arm;

	dump->u_debugreg[4] = tsk->thread.debug.nsaved;



	if (dump->start_stack < 0x04000000)

		dump->u_ssize = (0x04000000 - dump->start_stack) >> PAGE_SHIFT;



	dump->regs = *regs;

	dump->u_fpvalid = dump_fpu (regs, &dump->u_fp);

}

EXPORT_SYMBOL(dump_thread);



/*

 * Shuffle the argument into the correct register before calling the

 * thread function.  r1 is the thread argument, r2 is the pointer to

arch/m68k/kernel/process.c

+0 −47
Original line number Diff line number Diff line
@@ -315,53 +315,6 @@ int dump_fpu (struct pt_regs *regs, struct user_m68kfp_struct *fpu) 
}

EXPORT_SYMBOL(dump_fpu);



/*

 * fill in the user structure for a core dump..

 */

void 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);

}

EXPORT_SYMBOL(dump_thread);



/*

 * sys_execve() executes a new program.

 */

arch/sparc/kernel/process.c

+0 −32
Original line number Diff line number Diff line
@@ -566,38 +566,6 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp, 
	return 0;

}



/*

 * fill in the user structure for a core dump..

 */

void dump_thread(struct pt_regs * regs, struct user * dump)

{

	unsigned long first_stack_page;



	dump->magic = SUNOS_CORE_MAGIC;

	dump->len = sizeof(struct user);

	dump->regs.psr = regs->psr;

	dump->regs.pc = regs->pc;

	dump->regs.npc = regs->npc;

	dump->regs.y = regs->y;

	/* fuck me plenty */

	memcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));

	dump->uexec = current->thread.core_exec;

	dump->u_tsize = (((unsigned long) current->mm->end_code) -

		((unsigned long) current->mm->start_code)) & ~(PAGE_SIZE - 1);

	dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1)));

	dump->u_dsize -= dump->u_tsize;

	dump->u_dsize &= ~(PAGE_SIZE - 1);

	first_stack_page = (regs->u_regs[UREG_FP] & ~(PAGE_SIZE - 1));

	dump->u_ssize = (TASK_SIZE - first_stack_page) & ~(PAGE_SIZE - 1);

	memcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->thread.float_regs[0], (sizeof(unsigned long) * 32));

	dump->fpu.fpstatus.fsr = current->thread.fsr;

	dump->fpu.fpstatus.flags = dump->fpu.fpstatus.extra = 0;

	dump->fpu.fpstatus.fpq_count = current->thread.fpqdepth;

	memcpy(&dump->fpu.fpstatus.fpq[0], &current->thread.fpqueue[0],

	       ((sizeof(unsigned long) * 2) * 16));

	dump->sigcode = 0;

}



/*

 * fill in the fpu structure for a core dump.

 */

arch/sparc/kernel/sparc_ksyms.c

+0 −2
Original line number Diff line number Diff line
@@ -214,8 +214,6 @@ EXPORT_SYMBOL(kunmap_atomic); 
EXPORT_SYMBOL(svr4_setcontext);

EXPORT_SYMBOL(svr4_getcontext);



EXPORT_SYMBOL(dump_thread);



/* prom symbols */

EXPORT_SYMBOL(idprom);

EXPORT_SYMBOL(prom_root_node);

CRA Git | Maintained and supported by SUSTech CRA and CCSE