Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 19f9a34f87c48bbd270d617d1c986d0c23866a1a

Authored by Paul Mundt 2006-09-27 17:33:49 +0800

Exists in master and in 7 other branches

sh: Initial vsyscall page support.

This implements initial support for the vsyscall page on SH.
At the moment we leave it configurable due to having nommu
to support from the same code base. We hook it up for the
signal trampoline return at present, with more to be added
later, once uClibc catches up.

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

Showing 19 changed files with 473 additions and 17 deletions Inline Diff

arch/sh/kernel/Makefile
arch/sh/kernel/process.c
arch/sh/kernel/signal.c
arch/sh/kernel/vsyscall/Makefile
arch/sh/kernel/vsyscall/vsyscall-note.S
arch/sh/kernel/vsyscall/vsyscall-sigreturn.S
arch/sh/kernel/vsyscall/vsyscall-syscall.S
arch/sh/kernel/vsyscall/vsyscall-trapa.S
arch/sh/kernel/vsyscall/vsyscall.c
arch/sh/kernel/vsyscall/vsyscall.lds.S
arch/sh/mm/Kconfig
arch/sh/mm/init.c
arch/sh/mm/tlb-flush.c
include/asm-sh/auxvec.h
include/asm-sh/elf.h
include/asm-sh/mmu.h
include/asm-sh/mmu_context.h
include/asm-sh/page.h
include/asm-sh/processor.h

arch/sh/kernel/Makefile

Diff comments View file @ 19f9a34

 #
 # Makefile for the Linux/SuperH kernel.
 #
 extra-y	:= head.o init_task.o vmlinux.lds
 obj-y	:= process.o signal.o entry.o traps.o irq.o \
 	ptrace.o setup.o time.o sys_sh.o semaphore.o \
 	io.o io_generic.o sh_ksyms.o syscalls.o
 obj-y				+= cpu/ timers/
+obj-$(CONFIG_VSYSCALL)		+= vsyscall/
 obj-$(CONFIG_SMP)		+= smp.o
 obj-$(CONFIG_CF_ENABLER)	+= cf-enabler.o
 obj-$(CONFIG_SH_STANDARD_BIOS)	+= sh_bios.o
 obj-$(CONFIG_SH_KGDB)		+= kgdb_stub.o kgdb_jmp.o
 obj-$(CONFIG_SH_CPU_FREQ)	+= cpufreq.o
 obj-$(CONFIG_MODULES)		+= module.o
 obj-$(CONFIG_EARLY_PRINTK)	+= early_printk.o
 obj-$(CONFIG_KEXEC)		+= machine_kexec.o relocate_kernel.o
 obj-$(CONFIG_APM)		+= apm.o
 obj-$(CONFIG_PM)		+= pm.o

arch/sh/kernel/process.c

Diff comments View file @ 19f9a34

1	/* $Id: process.c,v 1.28 2004/05/05 16:54:23 lethal Exp $	1	/* $Id: process.c,v 1.28 2004/05/05 16:54:23 lethal Exp $
2	*	2	*
3	* linux/arch/sh/kernel/process.c	3	* linux/arch/sh/kernel/process.c
4	*	4	*
5	* Copyright (C) 1995 Linus Torvalds	5	* Copyright (C) 1995 Linus Torvalds
6	*	6	*
7	* SuperH version: Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima	7	* SuperH version: Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima
8	*/	8	*/
9		9
10	/*	10	/*
11	* This file handles the architecture-dependent parts of process handling..	11	* This file handles the architecture-dependent parts of process handling..
12	*/	12	*/
13		13
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/unistd.h>	15	#include <linux/unistd.h>
16	#include <linux/mm.h>	16	#include <linux/mm.h>
17	#include <linux/elfcore.h>	17	#include <linux/elfcore.h>
18	#include <linux/a.out.h>	18	#include <linux/a.out.h>
19	#include <linux/slab.h>	19	#include <linux/slab.h>
20	#include <linux/pm.h>	20	#include <linux/pm.h>
21	#include <linux/ptrace.h>	21	#include <linux/ptrace.h>
22	#include <linux/kallsyms.h>	22	#include <linux/kallsyms.h>
23	#include <linux/kexec.h>	23	#include <linux/kexec.h>
24		24
25	#include <asm/io.h>	25	#include <asm/io.h>
26	#include <asm/uaccess.h>	26	#include <asm/uaccess.h>
27	#include <asm/mmu_context.h>	27	#include <asm/mmu_context.h>
28	#include <asm/elf.h>	28	#include <asm/elf.h>
29	#include <asm/ubc.h>	29	#include <asm/ubc.h>
30		30
31	static int hlt_counter=0;	31	static int hlt_counter=0;
32		32
33	int ubc_usercnt = 0;	33	int ubc_usercnt = 0;
34		34
35	#define HARD_IDLE_TIMEOUT (HZ / 3)	35	#define HARD_IDLE_TIMEOUT (HZ / 3)
36		36
37	void (*pm_idle)(void);	37	void (*pm_idle)(void);
38		38
39	void (*pm_power_off)(void);	39	void (*pm_power_off)(void);
40	EXPORT_SYMBOL(pm_power_off);	40	EXPORT_SYMBOL(pm_power_off);
41		41
42	void disable_hlt(void)	42	void disable_hlt(void)
43	{	43	{
44	hlt_counter++;	44	hlt_counter++;
45	}	45	}
46		46
47	EXPORT_SYMBOL(disable_hlt);	47	EXPORT_SYMBOL(disable_hlt);
48		48
49	void enable_hlt(void)	49	void enable_hlt(void)
50	{	50	{
51	hlt_counter--;	51	hlt_counter--;
52	}	52	}
53		53
54	EXPORT_SYMBOL(enable_hlt);	54	EXPORT_SYMBOL(enable_hlt);
55		55
56	void default_idle(void)	56	void default_idle(void)
57	{	57	{
58	if (!hlt_counter)	58	if (!hlt_counter)
59	cpu_sleep();	59	cpu_sleep();
60	else	60	else
61	cpu_relax();	61	cpu_relax();
62	}	62	}
63		63
64	void cpu_idle(void)	64	void cpu_idle(void)
65	{	65	{
66	/* endless idle loop with no priority at all */	66	/* endless idle loop with no priority at all */
67	while (1) {	67	while (1) {
68	void (*idle)(void) = pm_idle;	68	void (*idle)(void) = pm_idle;
69		69
70	if (!idle)	70	if (!idle)
71	idle = default_idle;	71	idle = default_idle;
72		72
73	while (!need_resched())	73	while (!need_resched())
74	idle();	74	idle();
75		75
76	preempt_enable_no_resched();	76	preempt_enable_no_resched();
77	schedule();	77	schedule();
78	preempt_disable();	78	preempt_disable();
79	}	79	}
80	}	80	}
81		81
82	void machine_restart(char * __unused)	82	void machine_restart(char * __unused)
83	{	83	{
84	/* SR.BL=1 and invoke address error to let CPU reset (manual reset) */	84	/* SR.BL=1 and invoke address error to let CPU reset (manual reset) */
85	asm volatile("ldc %0, sr\n\t"	85	asm volatile("ldc %0, sr\n\t"
86	"mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));	86	"mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));
87	}	87	}
88		88
89	void machine_halt(void)	89	void machine_halt(void)
90	{	90	{
91	local_irq_disable();	91	local_irq_disable();
92		92
93	while (1)	93	while (1)
94	cpu_sleep();	94	cpu_sleep();
95	}	95	}
96		96
97	void machine_power_off(void)	97	void machine_power_off(void)
98	{	98	{
99	if (pm_power_off)	99	if (pm_power_off)
100	pm_power_off();	100	pm_power_off();
101	}	101	}
102		102
103	void show_regs(struct pt_regs * regs)	103	void show_regs(struct pt_regs * regs)
104	{	104	{
105	printk("\n");	105	printk("\n");
106	printk("Pid : %d, Comm: %20s\n", current->pid, current->comm);	106	printk("Pid : %d, Comm: %20s\n", current->pid, current->comm);
107	print_symbol("PC is at %s\n", regs->pc);	107	print_symbol("PC is at %s\n", regs->pc);
108	printk("PC : %08lx SP : %08lx SR : %08lx ",	108	printk("PC : %08lx SP : %08lx SR : %08lx ",
109	regs->pc, regs->regs[15], regs->sr);	109	regs->pc, regs->regs[15], regs->sr);
110	#ifdef CONFIG_MMU	110	#ifdef CONFIG_MMU
111	printk("TEA : %08x ", ctrl_inl(MMU_TEA));	111	printk("TEA : %08x ", ctrl_inl(MMU_TEA));
112	#else	112	#else
113	printk(" ");	113	printk(" ");
114	#endif	114	#endif
115	printk("%s\n", print_tainted());	115	printk("%s\n", print_tainted());
116		116
117	printk("R0 : %08lx R1 : %08lx R2 : %08lx R3 : %08lx\n",	117	printk("R0 : %08lx R1 : %08lx R2 : %08lx R3 : %08lx\n",
118	regs->regs[0],regs->regs[1],	118	regs->regs[0],regs->regs[1],
119	regs->regs[2],regs->regs[3]);	119	regs->regs[2],regs->regs[3]);
120	printk("R4 : %08lx R5 : %08lx R6 : %08lx R7 : %08lx\n",	120	printk("R4 : %08lx R5 : %08lx R6 : %08lx R7 : %08lx\n",
121	regs->regs[4],regs->regs[5],	121	regs->regs[4],regs->regs[5],
122	regs->regs[6],regs->regs[7]);	122	regs->regs[6],regs->regs[7]);
123	printk("R8 : %08lx R9 : %08lx R10 : %08lx R11 : %08lx\n",	123	printk("R8 : %08lx R9 : %08lx R10 : %08lx R11 : %08lx\n",
124	regs->regs[8],regs->regs[9],	124	regs->regs[8],regs->regs[9],
125	regs->regs[10],regs->regs[11]);	125	regs->regs[10],regs->regs[11]);
126	printk("R12 : %08lx R13 : %08lx R14 : %08lx\n",	126	printk("R12 : %08lx R13 : %08lx R14 : %08lx\n",
127	regs->regs[12],regs->regs[13],	127	regs->regs[12],regs->regs[13],
128	regs->regs[14]);	128	regs->regs[14]);
129	printk("MACH: %08lx MACL: %08lx GBR : %08lx PR : %08lx\n",	129	printk("MACH: %08lx MACL: %08lx GBR : %08lx PR : %08lx\n",
130	regs->mach, regs->macl, regs->gbr, regs->pr);	130	regs->mach, regs->macl, regs->gbr, regs->pr);
131		131
132	/*	132	/*
133	* If we're in kernel mode, dump the stack too..	133	* If we're in kernel mode, dump the stack too..
134	*/	134	*/
135	if (!user_mode(regs)) {	135	if (!user_mode(regs)) {
136	extern void show_task(unsigned long *sp);	136	extern void show_task(unsigned long *sp);
137	unsigned long sp = regs->regs[15];	137	unsigned long sp = regs->regs[15];
138		138
139	show_task((unsigned long *)sp);	139	show_task((unsigned long *)sp);
140	}	140	}
141	}	141	}
142		142
143	/*	143	/*
144	* Create a kernel thread	144	* Create a kernel thread
145	*/	145	*/
146		146
147	/*	147	/*
148	* This is the mechanism for creating a new kernel thread.	148	* This is the mechanism for creating a new kernel thread.
149	*	149	*
150	*/	150	*/
151	extern void kernel_thread_helper(void);	151	extern void kernel_thread_helper(void);
152	__asm__(".align 5\n"	152	__asm__(".align 5\n"
153	"kernel_thread_helper:\n\t"	153	"kernel_thread_helper:\n\t"
154	"jsr @r5\n\t"	154	"jsr @r5\n\t"
155	" nop\n\t"	155	" nop\n\t"
156	"mov.l 1f, r1\n\t"	156	"mov.l 1f, r1\n\t"
157	"jsr @r1\n\t"	157	"jsr @r1\n\t"
158	" mov r0, r4\n\t"	158	" mov r0, r4\n\t"
159	".align 2\n\t"	159	".align 2\n\t"
160	"1:.long do_exit");	160	"1:.long do_exit");
161		161
162	int kernel_thread(int (fn)(void ), void * arg, unsigned long flags)	162	int kernel_thread(int (fn)(void ), void * arg, unsigned long flags)
163	{ /* Don't use this in BL=1(cli). Or else, CPU resets! */	163	{ /* Don't use this in BL=1(cli). Or else, CPU resets! */
164	struct pt_regs regs;	164	struct pt_regs regs;
165		165
166	memset(&regs, 0, sizeof(regs));	166	memset(&regs, 0, sizeof(regs));
167	regs.regs[4] = (unsigned long) arg;	167	regs.regs[4] = (unsigned long) arg;
168	regs.regs[5] = (unsigned long) fn;	168	regs.regs[5] = (unsigned long) fn;
169		169
170	regs.pc = (unsigned long) kernel_thread_helper;	170	regs.pc = (unsigned long) kernel_thread_helper;
171	regs.sr = (1 << 30);	171	regs.sr = (1 << 30);
172		172
173	/* Ok, create the new process.. */	173	/* Ok, create the new process.. */
174	return do_fork(flags \| CLONE_VM \| CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);	174	return do_fork(flags \| CLONE_VM \| CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
175	}	175	}
176		176
177	/*	177	/*
178	* Free current thread data structures etc..	178	* Free current thread data structures etc..
179	*/	179	*/
180	void exit_thread(void)	180	void exit_thread(void)
181	{	181	{
182	if (current->thread.ubc_pc) {	182	if (current->thread.ubc_pc) {
183	current->thread.ubc_pc = 0;	183	current->thread.ubc_pc = 0;
184	ubc_usercnt -= 1;	184	ubc_usercnt -= 1;
185	}	185	}
186	}	186	}
187		187
188	void flush_thread(void)	188	void flush_thread(void)
189	{	189	{
190	#if defined(CONFIG_SH_FPU)	190	#if defined(CONFIG_SH_FPU)
191	struct task_struct *tsk = current;	191	struct task_struct *tsk = current;
192	/* Forget lazy FPU state */	192	/* Forget lazy FPU state */
193	clear_fpu(tsk, task_pt_regs(tsk));	193	clear_fpu(tsk, task_pt_regs(tsk));
194	clear_used_math();	194	clear_used_math();
195	#endif	195	#endif
196	}	196	}
197		197
198	void release_thread(struct task_struct *dead_task)	198	void release_thread(struct task_struct *dead_task)
199	{	199	{
200	/* do nothing */	200	/* do nothing */
201	}	201	}
202		202
203	/* Fill in the fpu structure for a core dump.. */	203	/* Fill in the fpu structure for a core dump.. */
204	int dump_fpu(struct pt_regs regs, elf_fpregset_t fpu)	204	int dump_fpu(struct pt_regs regs, elf_fpregset_t fpu)
205	{	205	{
206	int fpvalid = 0;	206	int fpvalid = 0;
207		207
208	#if defined(CONFIG_SH_FPU)	208	#if defined(CONFIG_SH_FPU)
209	struct task_struct *tsk = current;	209	struct task_struct *tsk = current;
210		210
211	fpvalid = !!tsk_used_math(tsk);	211	fpvalid = !!tsk_used_math(tsk);
212	if (fpvalid) {	212	if (fpvalid) {
213	unlazy_fpu(tsk, regs);	213	unlazy_fpu(tsk, regs);
214	memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));	214	memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
215	}	215	}
216	#endif	216	#endif
217		217
218	return fpvalid;	218	return fpvalid;
219	}	219	}
220		220
221	/*	221	/*
222	* Capture the user space registers if the task is not running (in user space)	222	* Capture the user space registers if the task is not running (in user space)
223	*/	223	*/
224	int dump_task_regs(struct task_struct tsk, elf_gregset_t regs)	224	int dump_task_regs(struct task_struct tsk, elf_gregset_t regs)
225	{	225	{
226	struct pt_regs ptregs;	226	struct pt_regs ptregs;
227		227
228	ptregs = *task_pt_regs(tsk);	228	ptregs = *task_pt_regs(tsk);
229	elf_core_copy_regs(regs, &ptregs);	229	elf_core_copy_regs(regs, &ptregs);
230		230
231	return 1;	231	return 1;
232	}	232	}
233		233
234	int	234	int
235	dump_task_fpu (struct task_struct tsk, elf_fpregset_t fpu)	235	dump_task_fpu (struct task_struct tsk, elf_fpregset_t fpu)
236	{	236	{
237	int fpvalid = 0;	237	int fpvalid = 0;
238		238
239	#if defined(CONFIG_SH_FPU)	239	#if defined(CONFIG_SH_FPU)
240	fpvalid = !!tsk_used_math(tsk);	240	fpvalid = !!tsk_used_math(tsk);
241	if (fpvalid) {	241	if (fpvalid) {
242	unlazy_fpu(tsk, task_pt_regs(tsk));	242	unlazy_fpu(tsk, task_pt_regs(tsk));
243	memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));	243	memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
244	}	244	}
245	#endif	245	#endif
246		246
247	return fpvalid;	247	return fpvalid;
248	}	248	}
249		249
250	asmlinkage void ret_from_fork(void);	250	asmlinkage void ret_from_fork(void);
251		251
252	int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,	252	int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
253	unsigned long unused,	253	unsigned long unused,
254	struct task_struct p, struct pt_regs regs)	254	struct task_struct p, struct pt_regs regs)
255	{	255	{
256	struct thread_info *ti = task_thread_info(p);	256	struct thread_info *ti = task_thread_info(p);
257	struct pt_regs *childregs;	257	struct pt_regs *childregs;
258	#if defined(CONFIG_SH_FPU)	258	#if defined(CONFIG_SH_FPU)
259	struct task_struct *tsk = current;	259	struct task_struct *tsk = current;
260		260
261	unlazy_fpu(tsk, regs);	261	unlazy_fpu(tsk, regs);
262	p->thread.fpu = tsk->thread.fpu;	262	p->thread.fpu = tsk->thread.fpu;
263	copy_to_stopped_child_used_math(p);	263	copy_to_stopped_child_used_math(p);
264	#endif	264	#endif
265		265
266	childregs = task_pt_regs(p);	266	childregs = task_pt_regs(p);
267	childregs = regs;	267	childregs = regs;
268		268
269	if (user_mode(regs)) {	269	if (user_mode(regs)) {
270	childregs->regs[15] = usp;	270	childregs->regs[15] = usp;
271	ti->addr_limit = USER_DS;	271	ti->addr_limit = USER_DS;
272	} else {	272	} else {
273	childregs->regs[15] = (unsigned long)task_stack_page(p) + THREAD_SIZE;	273	childregs->regs[15] = (unsigned long)task_stack_page(p) + THREAD_SIZE;
274	ti->addr_limit = KERNEL_DS;	274	ti->addr_limit = KERNEL_DS;
275	}	275	}
276	if (clone_flags & CLONE_SETTLS) {	276	if (clone_flags & CLONE_SETTLS) {
277	childregs->gbr = childregs->regs[0];	277	childregs->gbr = childregs->regs[0];
278	}	278	}
279	childregs->regs[0] = 0; /* Set return value for child */	279	childregs->regs[0] = 0; /* Set return value for child */
280		280
281	p->thread.sp = (unsigned long) childregs;	281	p->thread.sp = (unsigned long) childregs;
282	p->thread.pc = (unsigned long) ret_from_fork;	282	p->thread.pc = (unsigned long) ret_from_fork;
283		283
284	p->thread.ubc_pc = 0;	284	p->thread.ubc_pc = 0;
285		285
286	return 0;	286	return 0;
287	}	287	}
288		288
289	/* Tracing by user break controller. */	289	/* Tracing by user break controller. */
290	static void	290	static void
291	ubc_set_tracing(int asid, unsigned long pc)	291	ubc_set_tracing(int asid, unsigned long pc)
292	{	292	{
293	ctrl_outl(pc, UBC_BARA);	293	ctrl_outl(pc, UBC_BARA);
294		294
295	#ifdef CONFIG_MMU	295	#ifdef CONFIG_MMU
296	/* We don't have any ASID settings for the SH-2! */	296	/* We don't have any ASID settings for the SH-2! */
297	if (cpu_data->type != CPU_SH7604)	297	if (cpu_data->type != CPU_SH7604)
298	ctrl_outb(asid, UBC_BASRA);	298	ctrl_outb(asid, UBC_BASRA);
299	#endif	299	#endif
300		300
301	ctrl_outl(0, UBC_BAMRA);	301	ctrl_outl(0, UBC_BAMRA);
302		302
303	if (cpu_data->type == CPU_SH7729 \|\| cpu_data->type == CPU_SH7710) {	303	if (cpu_data->type == CPU_SH7729 \|\| cpu_data->type == CPU_SH7710) {
304	ctrl_outw(BBR_INST \| BBR_READ \| BBR_CPU, UBC_BBRA);	304	ctrl_outw(BBR_INST \| BBR_READ \| BBR_CPU, UBC_BBRA);
305	ctrl_outl(BRCR_PCBA \| BRCR_PCTE, UBC_BRCR);	305	ctrl_outl(BRCR_PCBA \| BRCR_PCTE, UBC_BRCR);
306	} else {	306	} else {
307	ctrl_outw(BBR_INST \| BBR_READ, UBC_BBRA);	307	ctrl_outw(BBR_INST \| BBR_READ, UBC_BBRA);
308	ctrl_outw(BRCR_PCBA, UBC_BRCR);	308	ctrl_outw(BRCR_PCBA, UBC_BRCR);
309	}	309	}
310	}	310	}
311		311
312	/*	312	/*
313	* switch_to(x,y) should switch tasks from x to y.	313	* switch_to(x,y) should switch tasks from x to y.
314	*	314	*
315	*/	315	*/
316	struct task_struct __switch_to(struct task_struct prev, struct task_struct *next)	316	struct task_struct __switch_to(struct task_struct prev, struct task_struct *next)
317	{	317	{
318	#if defined(CONFIG_SH_FPU)	318	#if defined(CONFIG_SH_FPU)
319	unlazy_fpu(prev, task_pt_regs(prev));	319	unlazy_fpu(prev, task_pt_regs(prev));
320	#endif	320	#endif
321		321
322	#ifdef CONFIG_PREEMPT	322	#ifdef CONFIG_PREEMPT
323	{	323	{
324	unsigned long flags;	324	unsigned long flags;
325	struct pt_regs *regs;	325	struct pt_regs *regs;
326		326
327	local_irq_save(flags);	327	local_irq_save(flags);
328	regs = task_pt_regs(prev);	328	regs = task_pt_regs(prev);
329	if (user_mode(regs) && regs->regs[15] >= 0xc0000000) {	329	if (user_mode(regs) && regs->regs[15] >= 0xc0000000) {
330	int offset = (int)regs->regs[15];	330	int offset = (int)regs->regs[15];
331		331
332	/* Reset stack pointer: clear critical region mark */	332	/* Reset stack pointer: clear critical region mark */
333	regs->regs[15] = regs->regs[1];	333	regs->regs[15] = regs->regs[1];
334	if (regs->pc < regs->regs[0])	334	if (regs->pc < regs->regs[0])
335	/* Go to rewind point */	335	/* Go to rewind point */
336	regs->pc = regs->regs[0] + offset;	336	regs->pc = regs->regs[0] + offset;
337	}	337	}
338	local_irq_restore(flags);	338	local_irq_restore(flags);
339	}	339	}
340	#endif	340	#endif
341		341
342	#ifdef CONFIG_MMU	342	#ifdef CONFIG_MMU
343	/*	343	/*
344	* Restore the kernel mode register	344	* Restore the kernel mode register
345	* k7 (r7_bank1)	345	* k7 (r7_bank1)
346	*/	346	*/
347	asm volatile("ldc %0, r7_bank"	347	asm volatile("ldc %0, r7_bank"
348	: /* no output */	348	: /* no output */
349	: "r" (task_thread_info(next)));	349	: "r" (task_thread_info(next)));
350	#endif	350	#endif
351		351
352	/* If no tasks are using the UBC, we're done */	352	/* If no tasks are using the UBC, we're done */
353	if (ubc_usercnt == 0)	353	if (ubc_usercnt == 0)
354	/* If no tasks are using the UBC, we're done */;	354	/* If no tasks are using the UBC, we're done */;
355	else if (next->thread.ubc_pc && next->mm) {	355	else if (next->thread.ubc_pc && next->mm) {
356	int asid = 0;	356	int asid = 0;
357	#ifdef CONFIG_MMU	357	#ifdef CONFIG_MMU
358	asid \|= next->mm->context & MMU_CONTEXT_ASID_MASK;	358	asid \|= next->mm->context.id & MMU_CONTEXT_ASID_MASK;
359	#endif	359	#endif
360	ubc_set_tracing(asid, next->thread.ubc_pc);	360	ubc_set_tracing(asid, next->thread.ubc_pc);
361	} else {	361	} else {
362	ctrl_outw(0, UBC_BBRA);	362	ctrl_outw(0, UBC_BBRA);
363	ctrl_outw(0, UBC_BBRB);	363	ctrl_outw(0, UBC_BBRB);
364	}	364	}
365		365
366	return prev;	366	return prev;
367	}	367	}
368		368
369	asmlinkage int sys_fork(unsigned long r4, unsigned long r5,	369	asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
370	unsigned long r6, unsigned long r7,	370	unsigned long r6, unsigned long r7,
371	struct pt_regs regs)	371	struct pt_regs regs)
372	{	372	{
373	#ifdef CONFIG_MMU	373	#ifdef CONFIG_MMU
374	return do_fork(SIGCHLD, regs.regs[15], &regs, 0, NULL, NULL);	374	return do_fork(SIGCHLD, regs.regs[15], &regs, 0, NULL, NULL);
375	#else	375	#else
376	/* fork almost works, enough to trick you into looking elsewhere :-( */	376	/* fork almost works, enough to trick you into looking elsewhere :-( */
377	return -EINVAL;	377	return -EINVAL;
378	#endif	378	#endif
379	}	379	}
380		380
381	asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,	381	asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
382	unsigned long parent_tidptr,	382	unsigned long parent_tidptr,
383	unsigned long child_tidptr,	383	unsigned long child_tidptr,
384	struct pt_regs regs)	384	struct pt_regs regs)
385	{	385	{
386	if (!newsp)	386	if (!newsp)
387	newsp = regs.regs[15];	387	newsp = regs.regs[15];
388	return do_fork(clone_flags, newsp, &regs, 0,	388	return do_fork(clone_flags, newsp, &regs, 0,
389	(int __user )parent_tidptr, (int __user )child_tidptr);	389	(int __user )parent_tidptr, (int __user )child_tidptr);
390	}	390	}
391		391
392	/*	392	/*
393	* This is trivial, and on the face of it looks like it	393	* This is trivial, and on the face of it looks like it
394	* could equally well be done in user mode.	394	* could equally well be done in user mode.
395	*	395	*
396	* Not so, for quite unobvious reasons - register pressure.	396	* Not so, for quite unobvious reasons - register pressure.
397	* In user mode vfork() cannot have a stack frame, and if	397	* In user mode vfork() cannot have a stack frame, and if
398	* done by calling the "clone()" system call directly, you	398	* done by calling the "clone()" system call directly, you
399	* do not have enough call-clobbered registers to hold all	399	* do not have enough call-clobbered registers to hold all
400	* the information you need.	400	* the information you need.
401	*/	401	*/
402	asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,	402	asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
403	unsigned long r6, unsigned long r7,	403	unsigned long r6, unsigned long r7,
404	struct pt_regs regs)	404	struct pt_regs regs)
405	{	405	{
406	return do_fork(CLONE_VFORK \| CLONE_VM \| SIGCHLD, regs.regs[15], &regs,	406	return do_fork(CLONE_VFORK \| CLONE_VM \| SIGCHLD, regs.regs[15], &regs,
407	0, NULL, NULL);	407	0, NULL, NULL);
408	}	408	}
409		409
410	/*	410	/*
411	* sys_execve() executes a new program.	411	* sys_execve() executes a new program.
412	*/	412	*/
413	asmlinkage int sys_execve(char ufilename, char *uargv,	413	asmlinkage int sys_execve(char ufilename, char *uargv,
414	char **uenvp, unsigned long r7,	414	char **uenvp, unsigned long r7,
415	struct pt_regs regs)	415	struct pt_regs regs)
416	{	416	{
417	int error;	417	int error;
418	char *filename;	418	char *filename;
419		419
420	filename = getname((char __user *)ufilename);	420	filename = getname((char __user *)ufilename);
421	error = PTR_ERR(filename);	421	error = PTR_ERR(filename);
422	if (IS_ERR(filename))	422	if (IS_ERR(filename))
423	goto out;	423	goto out;
424		424
425	error = do_execve(filename,	425	error = do_execve(filename,
426	(char __user * __user *)uargv,	426	(char __user * __user *)uargv,
427	(char __user * __user *)uenvp,	427	(char __user * __user *)uenvp,
428	&regs);	428	&regs);
429	if (error == 0) {	429	if (error == 0) {
430	task_lock(current);	430	task_lock(current);
431	current->ptrace &= ~PT_DTRACE;	431	current->ptrace &= ~PT_DTRACE;
432	task_unlock(current);	432	task_unlock(current);
433	}	433	}
434	putname(filename);	434	putname(filename);
435	out:	435	out:
436	return error;	436	return error;
437	}	437	}
438		438
439	unsigned long get_wchan(struct task_struct *p)	439	unsigned long get_wchan(struct task_struct *p)
440	{	440	{
441	unsigned long schedule_frame;	441	unsigned long schedule_frame;
442	unsigned long pc;	442	unsigned long pc;
443		443
444	if (!p \|\| p == current \|\| p->state == TASK_RUNNING)	444	if (!p \|\| p == current \|\| p->state == TASK_RUNNING)
445	return 0;	445	return 0;
446		446
447	/*	447	/*
448	* The same comment as on the Alpha applies here, too ...	448	* The same comment as on the Alpha applies here, too ...
449	*/	449	*/
450	pc = thread_saved_pc(p);	450	pc = thread_saved_pc(p);
451	if (in_sched_functions(pc)) {	451	if (in_sched_functions(pc)) {
452	schedule_frame = ((unsigned long *)(long)p->thread.sp)[1];	452	schedule_frame = ((unsigned long *)(long)p->thread.sp)[1];
453	return (unsigned long)((unsigned long *)schedule_frame)[1];	453	return (unsigned long)((unsigned long *)schedule_frame)[1];
454	}	454	}
455	return pc;	455	return pc;
456	}	456	}
457		457
458	asmlinkage void break_point_trap(unsigned long r4, unsigned long r5,	458	asmlinkage void break_point_trap(unsigned long r4, unsigned long r5,
459	unsigned long r6, unsigned long r7,	459	unsigned long r6, unsigned long r7,
460	struct pt_regs regs)	460	struct pt_regs regs)
461	{	461	{
462	/* Clear tracing. */	462	/* Clear tracing. */
463	ctrl_outw(0, UBC_BBRA);	463	ctrl_outw(0, UBC_BBRA);
464	ctrl_outw(0, UBC_BBRB);	464	ctrl_outw(0, UBC_BBRB);
465	current->thread.ubc_pc = 0;	465	current->thread.ubc_pc = 0;
466	ubc_usercnt -= 1;	466	ubc_usercnt -= 1;
467		467
468	force_sig(SIGTRAP, current);	468	force_sig(SIGTRAP, current);
469	}	469	}
470		470
471	asmlinkage void break_point_trap_software(unsigned long r4, unsigned long r5,	471	asmlinkage void break_point_trap_software(unsigned long r4, unsigned long r5,
472	unsigned long r6, unsigned long r7,	472	unsigned long r6, unsigned long r7,
473	struct pt_regs regs)	473	struct pt_regs regs)
474	{	474	{
475	regs.pc -= 2;	475	regs.pc -= 2;
476	force_sig(SIGTRAP, current);	476	force_sig(SIGTRAP, current);
477	}	477	}
478		478

arch/sh/kernel/signal.c

Diff comments View file @ 19f9a34

 /*
  *  linux/arch/sh/kernel/signal.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  *
  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
  *
  */
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/kernel.h>
 #include <linux/signal.h>
 #include <linux/errno.h>
 #include <linux/wait.h>
 #include <linux/ptrace.h>
 #include <linux/unistd.h>
 #include <linux/stddef.h>
 #include <linux/tty.h>
+#include <linux/elf.h>
 #include <linux/personality.h>
 #include <linux/binfmts.h>
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/cacheflush.h>
-#undef DEBUG
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 /*
  * Atomically swap in the new signal mask, and wait for a signal.
  */
 asmlinkage int
 sys_sigsuspend(old_sigset_t mask,
 	       unsigned long r5, unsigned long r6, unsigned long r7,
 	       struct pt_regs regs)
 {
 	mask &= _BLOCKABLE;
 	spin_lock_irq(&current->sighand->siglock);
 	current->saved_sigmask = current->blocked;
 	siginitset(&current->blocked, mask);
 	recalc_sigpending();
 	spin_unlock_irq(&current->sighand->siglock);
 	current->state = TASK_INTERRUPTIBLE;
 	schedule();
 	set_thread_flag(TIF_RESTORE_SIGMASK);
 	return -ERESTARTNOHAND;
 }
 asmlinkage int
 sys_sigaction(int sig, const struct old_sigaction __user *act,
 	      struct old_sigaction __user *oact)
 {
 	struct k_sigaction new_ka, old_ka;
 	int ret;
 	if (act) {
 		old_sigset_t mask;
 		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 			return -EFAULT;
 		__get_user(new_ka.sa.sa_flags, &act->sa_flags);
 		__get_user(mask, &act->sa_mask);
 		siginitset(&new_ka.sa.sa_mask, mask);
 	}
 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 	if (!ret && oact) {
 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 			return -EFAULT;
 		__put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 		__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 	}
 	return ret;
 }
 asmlinkage int
 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 		unsigned long r6, unsigned long r7,
 		struct pt_regs regs)
 {
 	return do_sigaltstack(uss, uoss, regs.regs[15]);
 }
 /*
  * Do a signal return; undo the signal stack.
  */
 #define MOVW(n)	 (0x9300|((n)-2))	/* Move mem word at PC+n to R3 */
 #define TRAP16	 0xc310			/* Syscall w/no args (NR in R3) */
 #define OR_R0_R0 0x200b			/* or r0,r0 (insert to avoid hardware bug) */
 struct sigframe
 {
 	struct sigcontext sc;
 	unsigned long extramask[_NSIG_WORDS-1];
 	u16 retcode[8];
 };
 struct rt_sigframe
 {
 	struct siginfo info;
 	struct ucontext uc;
 	u16 retcode[8];
 };
 #ifdef CONFIG_SH_FPU
 static inline int restore_sigcontext_fpu(struct sigcontext __user *sc)
 {
 	struct task_struct *tsk = current;
 	if (!(cpu_data->flags & CPU_HAS_FPU))
 		return 0;
 	set_used_math();
 	return __copy_from_user(&tsk->thread.fpu.hard, &sc->sc_fpregs[0],
 				sizeof(long)*(16*2+2));
 }
 static inline int save_sigcontext_fpu(struct sigcontext __user *sc,
 				      struct pt_regs *regs)
 {
 	struct task_struct *tsk = current;
 	if (!(cpu_data->flags & CPU_HAS_FPU))
 		return 0;
 	if (!used_math()) {
 		__put_user(0, &sc->sc_ownedfp);
 		return 0;
 	}
 	__put_user(1, &sc->sc_ownedfp);
 	/* This will cause a "finit" to be triggered by the next
 	   attempted FPU operation by the 'current' process.
 	   */
 	clear_used_math();
 	unlazy_fpu(tsk, regs);
 	return __copy_to_user(&sc->sc_fpregs[0], &tsk->thread.fpu.hard,
 			      sizeof(long)*(16*2+2));
 }
 #endif /* CONFIG_SH_FPU */
 static int
 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p)
 {
 	unsigned int err = 0;
 #define COPY(x)		err |= __get_user(regs->x, &sc->sc_##x)
 			COPY(regs[1]);
 	COPY(regs[2]);	COPY(regs[3]);
 	COPY(regs[4]);	COPY(regs[5]);
 	COPY(regs[6]);	COPY(regs[7]);
 	COPY(regs[8]);	COPY(regs[9]);
 	COPY(regs[10]);	COPY(regs[11]);
 	COPY(regs[12]);	COPY(regs[13]);
 	COPY(regs[14]);	COPY(regs[15]);
 	COPY(gbr);	COPY(mach);
 	COPY(macl);	COPY(pr);
 	COPY(sr);	COPY(pc);
 #undef COPY
 #ifdef CONFIG_SH_FPU
 	if (cpu_data->flags & CPU_HAS_FPU) {
 		int owned_fp;
 		struct task_struct *tsk = current;
 		regs->sr |= SR_FD; /* Release FPU */
 		clear_fpu(tsk, regs);
 		clear_used_math();
 		__get_user (owned_fp, &sc->sc_ownedfp);
 		if (owned_fp)
 			err |= restore_sigcontext_fpu(sc);
 	}
 #endif
 	regs->tra = -1;		/* disable syscall checks */
 	err |= __get_user(*r0_p, &sc->sc_regs[0]);
 	return err;
 }
 asmlinkage int sys_sigreturn(unsigned long r4, unsigned long r5,
 			     unsigned long r6, unsigned long r7,
 			     struct pt_regs regs)
 {
 	struct sigframe __user *frame = (struct sigframe __user *)regs.regs[15];
 	sigset_t set;
 	int r0;
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__get_user(set.sig[0], &frame->sc.oldmask)
 	    || (_NSIG_WORDS > 1
 		&& __copy_from_user(&set.sig[1], &frame->extramask,
 				    sizeof(frame->extramask))))
 		goto badframe;
 	sigdelsetmask(&set, ~_BLOCKABLE);
 	spin_lock_irq(&current->sighand->siglock);
 	current->blocked = set;
 	recalc_sigpending();
 	spin_unlock_irq(&current->sighand->siglock);
 	if (restore_sigcontext(&regs, &frame->sc, &r0))
 		goto badframe;
 	return r0;
 badframe:
 	force_sig(SIGSEGV, current);
 	return 0;
 }
 asmlinkage int sys_rt_sigreturn(unsigned long r4, unsigned long r5,
 				unsigned long r6, unsigned long r7,
 				struct pt_regs regs)
 {
 	struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs.regs[15];
 	sigset_t set;
 	stack_t st;
 	int r0;
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 		goto badframe;
 	sigdelsetmask(&set, ~_BLOCKABLE);
 	spin_lock_irq(&current->sighand->siglock);
 	current->blocked = set;
 	recalc_sigpending();
 	spin_unlock_irq(&current->sighand->siglock);
 	if (restore_sigcontext(&regs, &frame->uc.uc_mcontext, &r0))
 		goto badframe;
 	if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 		goto badframe;
 	/* It is more difficult to avoid calling this function than to
 	   call it and ignore errors.  */
 	do_sigaltstack(&st, NULL, regs.regs[15]);
 	return r0;
 badframe:
 	force_sig(SIGSEGV, current);
 	return 0;
 }
 /*
  * Set up a signal frame.
  */
 static int
 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 		 unsigned long mask)
 {
 	int err = 0;
 #define COPY(x)		err |= __put_user(regs->x, &sc->sc_##x)
 	COPY(regs[0]);	COPY(regs[1]);
 	COPY(regs[2]);	COPY(regs[3]);
 	COPY(regs[4]);	COPY(regs[5]);
 	COPY(regs[6]);	COPY(regs[7]);
 	COPY(regs[8]);	COPY(regs[9]);
 	COPY(regs[10]);	COPY(regs[11]);
 	COPY(regs[12]);	COPY(regs[13]);
 	COPY(regs[14]);	COPY(regs[15]);
 	COPY(gbr);	COPY(mach);
 	COPY(macl);	COPY(pr);
 	COPY(sr);	COPY(pc);
 #undef COPY
 #ifdef CONFIG_SH_FPU
 	err |= save_sigcontext_fpu(sc, regs);
 #endif
 	/* non-iBCS2 extensions.. */
 	err |= __put_user(mask, &sc->oldmask);
 	return err;
 }
 /*
  * Determine which stack to use..
  */
 static inline void __user *
 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 {
 	if (ka->sa.sa_flags & SA_ONSTACK) {
 		if (sas_ss_flags(sp) == 0)
 			sp = current->sas_ss_sp + current->sas_ss_size;
 	}
 	return (void __user *)((sp - frame_size) & -8ul);
 }
+/* These symbols are defined with the addresses in the vsyscall page.
+   See vsyscall-trapa.S.  */
+extern void __user __kernel_sigreturn;
+extern void __user __kernel_rt_sigreturn;
 static int setup_frame(int sig, struct k_sigaction *ka,
 			sigset_t *set, struct pt_regs *regs)
 {
 	struct sigframe __user *frame;
 	int err = 0;
 	int signal;
 	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		goto give_sigsegv;
 	signal = current_thread_info()->exec_domain
 		&& current_thread_info()->exec_domain->signal_invmap
 		&& sig < 32
 		? current_thread_info()->exec_domain->signal_invmap[sig]
 		: sig;
 	err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 	if (_NSIG_WORDS > 1)
 		err |= __copy_to_user(frame->extramask, &set->sig[1],
 				      sizeof(frame->extramask));
 	/* Set up to return from userspace.  If provided, use a stub
 	   already in userspace.  */
 	if (ka->sa.sa_flags & SA_RESTORER) {
 		regs->pr = (unsigned long) ka->sa.sa_restorer;
+#ifdef CONFIG_VSYSCALL
+	} else if (likely(current->mm->context.vdso)) {
+		regs->pr = VDSO_SYM(&__kernel_sigreturn);
+#endif
 	} else {
 		/* Generate return code (system call to sigreturn) */
 		err |= __put_user(MOVW(7), &frame->retcode[0]);
 		err |= __put_user(TRAP16, &frame->retcode[1]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[2]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[3]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[4]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[5]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[6]);
 		err |= __put_user((__NR_sigreturn), &frame->retcode[7]);
 		regs->pr = (unsigned long) frame->retcode;
 	}
 	if (err)
 		goto give_sigsegv;
 	/* Set up registers for signal handler */
 	regs->regs[15] = (unsigned long) frame;
 	regs->regs[4] = signal; /* Arg for signal handler */
 	regs->regs[5] = 0;
 	regs->regs[6] = (unsigned long) &frame->sc;
 	regs->pc = (unsigned long) ka->sa.sa_handler;
 	set_fs(USER_DS);
 	pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
 		 current->comm, current->pid, frame, regs->pc, regs->pr);
 	flush_cache_sigtramp(regs->pr);
 	if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
 		flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
 	return 0;
 give_sigsegv:
 	force_sigsegv(sig, current);
 	return -EFAULT;
 }
 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 			   sigset_t *set, struct pt_regs *regs)
 {
 	struct rt_sigframe __user *frame;
 	int err = 0;
 	int signal;
 	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		goto give_sigsegv;
 	signal = current_thread_info()->exec_domain
 		&& current_thread_info()->exec_domain->signal_invmap
 		&& sig < 32
 		? current_thread_info()->exec_domain->signal_invmap[sig]
 		: sig;
 	err |= copy_siginfo_to_user(&frame->info, info);
 	/* Create the ucontext.  */
 	err |= __put_user(0, &frame->uc.uc_flags);
 	err |= __put_user(0, &frame->uc.uc_link);
 	err |= __put_user((void *)current->sas_ss_sp,
 			  &frame->uc.uc_stack.ss_sp);
 	err |= __put_user(sas_ss_flags(regs->regs[15]),
 			  &frame->uc.uc_stack.ss_flags);
 	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 	err |= setup_sigcontext(&frame->uc.uc_mcontext,
 			        regs, set->sig[0]);
 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 	/* Set up to return from userspace.  If provided, use a stub
 	   already in userspace.  */
 	if (ka->sa.sa_flags & SA_RESTORER) {
 		regs->pr = (unsigned long) ka->sa.sa_restorer;
+#ifdef CONFIG_VSYSCALL
+	} else if (likely(current->mm->context.vdso)) {
+		regs->pr = VDSO_SYM(&__kernel_rt_sigreturn);
+#endif
 	} else {
 		/* Generate return code (system call to rt_sigreturn) */
 		err |= __put_user(MOVW(7), &frame->retcode[0]);
 		err |= __put_user(TRAP16, &frame->retcode[1]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[2]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[3]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[4]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[5]);
 		err |= __put_user(OR_R0_R0, &frame->retcode[6]);
 		err |= __put_user((__NR_rt_sigreturn), &frame->retcode[7]);
 		regs->pr = (unsigned long) frame->retcode;
 	}
 	if (err)
 		goto give_sigsegv;
 	/* Set up registers for signal handler */
 	regs->regs[15] = (unsigned long) frame;
 	regs->regs[4] = signal; /* Arg for signal handler */
 	regs->regs[5] = (unsigned long) &frame->info;
 	regs->regs[6] = (unsigned long) &frame->uc;
 	regs->pc = (unsigned long) ka->sa.sa_handler;
 	set_fs(USER_DS);
 	pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
 		 current->comm, current->pid, frame, regs->pc, regs->pr);
 	flush_cache_sigtramp(regs->pr);
 	if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
 		flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
 	return 0;
 give_sigsegv:
 	force_sigsegv(sig, current);
 	return -EFAULT;
 }
 /*
  * OK, we're invoking a handler
  */
 static int
 handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
 	      sigset_t *oldset, struct pt_regs *regs)
 {
 	int ret;
 	/* Are we from a system call? */
 	if (regs->tra >= 0) {
 		/* If so, check system call restarting.. */
 		switch (regs->regs[0]) {
 			case -ERESTARTNOHAND:
 				regs->regs[0] = -EINTR;
 				break;
 			case -ERESTARTSYS:
 				if (!(ka->sa.sa_flags & SA_RESTART)) {
 					regs->regs[0] = -EINTR;
 					break;
 				}
 			/* fallthrough */
 			case -ERESTARTNOINTR:
 				regs->pc -= 2;
 		}
 	} else {
 		/* gUSA handling */
 #ifdef CONFIG_PREEMPT
 		unsigned long flags;
 		local_irq_save(flags);
 #endif
 		if (regs->regs[15] >= 0xc0000000) {
 			int offset = (int)regs->regs[15];
 			/* Reset stack pointer: clear critical region mark */
 			regs->regs[15] = regs->regs[1];
 			if (regs->pc < regs->regs[0])
 				/* Go to rewind point #1 */
 				regs->pc = regs->regs[0] + offset - 2;
 		}
 #ifdef CONFIG_PREEMPT
 		local_irq_restore(flags);
 #endif
 	}
 	/* Set up the stack frame */
 	if (ka->sa.sa_flags & SA_SIGINFO)
 		ret = setup_rt_frame(sig, ka, info, oldset, regs);
 	else
 		ret = setup_frame(sig, ka, oldset, regs);
 	if (ka->sa.sa_flags & SA_ONESHOT)
 		ka->sa.sa_handler = SIG_DFL;
 	if (ret == 0) {
 		spin_lock_irq(&current->sighand->siglock);
 		sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 		if (!(ka->sa.sa_flags & SA_NODEFER))
 			sigaddset(&current->blocked,sig);
 		recalc_sigpending();
 		spin_unlock_irq(&current->sighand->siglock);
 	}
 	return ret;
 }
 /*
  * Note that 'init' is a special process: it doesn't get signals it doesn't
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  *
  * Note that we go through the signals twice: once to check the signals that
  * the kernel can handle, and then we build all the user-level signal handling
  * stack-frames in one go after that.
  */
 static void do_signal(struct pt_regs *regs, unsigned int save_r0)
 {
 	siginfo_t info;
 	int signr;
 	struct k_sigaction ka;
 	sigset_t *oldset;
 	/*
 	 * We want the common case to go fast, which
 	 * is why we may in certain cases get here from
 	 * kernel mode. Just return without doing anything
 	 * if so.
 	 */
 	if (!user_mode(regs))
 		return;
 	if (try_to_freeze())
 		goto no_signal;
 	if (test_thread_flag(TIF_RESTORE_SIGMASK))
 		oldset = &current->saved_sigmask;
 	else
 		oldset = &current->blocked;
 	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 	if (signr > 0) {
 		/* Whee!  Actually deliver the signal.  */
 		if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
 			/* a signal was successfully delivered; the saved
 			 * sigmask will have been stored in the signal frame,
 			 * and will be restored by sigreturn, so we can simply
 			 * clear the TIF_RESTORE_SIGMASK flag */
 			if (test_thread_flag(TIF_RESTORE_SIGMASK))
 				clear_thread_flag(TIF_RESTORE_SIGMASK);
 		}
 	}
  no_signal:
 	/* Did we come from a system call? */
 	if (regs->tra >= 0) {
 		/* Restart the system call - no handlers present */
 		if (regs->regs[0] == -ERESTARTNOHAND ||
 		    regs->regs[0] == -ERESTARTSYS ||
 		    regs->regs[0] == -ERESTARTNOINTR) {
 		    	regs->regs[0] = save_r0;
 			regs->pc -= 2;
 		} else if (regs->regs[0] == -ERESTART_RESTARTBLOCK) {
 			regs->pc -= 2;
 			regs->regs[3] = __NR_restart_syscall;
 		}
 	}
 	/* if there's no signal to deliver, we just put the saved sigmask
 	 * back */
 	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 		clear_thread_flag(TIF_RESTORE_SIGMASK);
 		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 	}
 }
 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned int save_r0,
 				 __u32 thread_info_flags)
 {
 	/* deal with pending signal delivery */
 	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))

arch/sh/kernel/vsyscall/Makefile

Diff comments View file @ 19f9a34

File was created	1	obj-y += vsyscall.o vsyscall-syscall.o
	2
	3	$(obj)/vsyscall-syscall.o: \
	4	$(foreach F,trapa,$(obj)/vsyscall-$F.so)
	5
	6	# Teach kbuild about targets
	7	targets += $(foreach F,trapa,vsyscall-$F.o vsyscall-$F.so)
	8	targets += vsyscall-note.o vsyscall.lds
	9
	10	# The DSO images are built using a special linker script
	11	quiet_cmd_syscall = SYSCALL $@
	12	cmd_syscall = $(CC) -nostdlib $(SYSCFLAGS_$(@F)) \
	13	-Wl,-T,$(filter-out FORCE,$^) -o $@
	14
	15	export CPPFLAGS_vsyscall.lds += -P -C -Ush
	16
	17	vsyscall-flags = -shared -s -Wl,-soname=linux-gate.so.1 \
	18	$(call ld-option, -Wl$(comma)--hash-style=sysv)
	19
	20	SYSCFLAGS_vsyscall-trapa.so = $(vsyscall-flags)
	21
	22	$(obj)/vsyscall-trapa.so: \
	23	$(obj)/vsyscall-%.so: $(src)/vsyscall.lds $(obj)/vsyscall-%.o FORCE
	24	$(call if_changed,syscall)
	25
	26	# We also create a special relocatable object that should mirror the symbol
	27	# table and layout of the linked DSO. With ld -R we can then refer to
	28	# these symbols in the kernel code rather than hand-coded addresses.
	29	extra-y += vsyscall-syms.o
	30	$(obj)/built-in.o: $(obj)/vsyscall-syms.o
	31	$(obj)/built-in.o: ld_flags += -R $(obj)/vsyscall-syms.o
	32
	33	SYSCFLAGS_vsyscall-syms.o = -r
	34	$(obj)/vsyscall-syms.o: $(src)/vsyscall.lds \
	35	$(obj)/vsyscall-trapa.o $(obj)/vsyscall-note.o FORCE
	36	$(call if_changed,syscall)
	37

arch/sh/kernel/vsyscall/vsyscall-note.S

Diff comments View file @ 19f9a34

File was created	1	/*
	2	* This supplies .note.* sections to go into the PT_NOTE inside the vDSO text.
	3	* Here we can supply some information useful to userland.
	4	*/
	5
	6	#include <linux/uts.h>
	7	#include <linux/version.h>
	8
	9	#define ASM_ELF_NOTE_BEGIN(name, flags, vendor, type) \
	10	.section name, flags; \
	11	.balign 4; \
	12	.long 1f - 0f; /* name length */ \
	13	.long 3f - 2f; /* data length */ \
	14	.long type; /* note type */ \
	15	0: .asciz vendor; /* vendor name */ \
	16	1: .balign 4; \
	17	2:
	18
	19	#define ASM_ELF_NOTE_END \
	20	3: .balign 4; /* pad out section */ \
	21	.previous
	22
	23	ASM_ELF_NOTE_BEGIN(".note.kernel-version", "a", UTS_SYSNAME, 0)
	24	.long LINUX_VERSION_CODE
	25	ASM_ELF_NOTE_END
	26

arch/sh/kernel/vsyscall/vsyscall-sigreturn.S

Diff comments View file @ 19f9a34

File was created	1	#include <asm/unistd.h>
	2
	3	.text
	4	.balign 32
	5	.globl __kernel_sigreturn
	6	.type __kernel_sigreturn,@function
	7	__kernel_sigreturn:
	8	.LSTART_sigreturn:
	9	mov.w 1f, r3
	10	trapa #0x10
	11	or r0, r0
	12	or r0, r0
	13	or r0, r0
	14	or r0, r0
	15	or r0, r0
	16
	17	1: .short __NR_sigreturn
	18	.LEND_sigreturn:
	19	.size __kernel_sigreturn,.-.LSTART_sigreturn
	20
	21	.balign 32
	22	.globl __kernel_rt_sigreturn
	23	.type __kernel_rt_sigreturn,@function
	24	__kernel_rt_sigreturn:
	25	.LSTART_rt_sigreturn:
	26	mov.w 1f, r3
	27	trapa #0x10
	28	or r0, r0
	29	or r0, r0
	30	or r0, r0
	31	or r0, r0
	32	or r0, r0
	33
	34	1: .short __NR_rt_sigreturn
	35	.LEND_rt_sigreturn:
	36	.size __kernel_rt_sigreturn,.-.LSTART_rt_sigreturn
	37
	38	.section .eh_frame,"a",@progbits
	39	.previous
	40

arch/sh/kernel/vsyscall/vsyscall-syscall.S

Diff comments View file @ 19f9a34

File was created	1	#include <linux/init.h>
	2
	3	__INITDATA
	4
	5	.globl vsyscall_trapa_start, vsyscall_trapa_end
	6	vsyscall_trapa_start:
	7	.incbin "arch/sh/kernel/vsyscall/vsyscall-trapa.so"
	8	vsyscall_trapa_end:
	9
	10	__FINIT
	11

arch/sh/kernel/vsyscall/vsyscall-trapa.S

Diff comments View file @ 19f9a34

File was created	1	.text
	2	.globl __kernel_vsyscall
	3	.type __kernel_vsyscall,@function
	4	__kernel_vsyscall:
	5	.LSTART_vsyscall:
	6	/* XXX: We'll have to do something here once we opt to use the vDSO
	7	* page for something other than the signal trampoline.. as well as
	8	* fill out .eh_frame -- PFM. */
	9	.LEND_vsyscall:
	10	.size __kernel_vsyscall,.-.LSTART_vsyscall
	11	.previous
	12
	13	.section .eh_frame,"a",@progbits
	14	.LCIE:
	15	.ualong .LCIE_end - .LCIE_start
	16	.LCIE_start:
	17	.ualong 0 /* CIE ID */
	18	.byte 0x1 /* Version number */
	19	.string "zRS" /* NUL-terminated augmentation string */
	20	.uleb128 0x1 /* Code alignment factor */
	21	.sleb128 -4 /* Data alignment factor */
	22	.byte 0x11 /* Return address register column */
	23	/* Augmentation length and data (none) */
	24	.byte 0xc /* DW_CFA_def_cfa */
	25	.uleb128 0xf /* r15 */
	26	.uleb128 0x0 /* offset 0 */
	27
	28	.align 2
	29	.LCIE_end:
	30
	31	.ualong .LFDE_end-.LFDE_start /* Length FDE */
	32	.LFDE_start:
	33	.ualong .LCIE /* CIE pointer */
	34	.ualong .LSTART_vsyscall-. /* start address */
	35	.ualong .LEND_vsyscall-.LSTART_vsyscall
	36	.uleb128 0
	37	.align 2
	38	.LFDE_end:
	39	.previous
	40
	41	/* Get the common code for the sigreturn entry points */
	42	#include "vsyscall-sigreturn.S"
	43

arch/sh/kernel/vsyscall/vsyscall.c

Diff comments View file @ 19f9a34

File was created	1	/*
	2	* arch/sh/kernel/vsyscall.c
	3	*
	4	* Copyright (C) 2006 Paul Mundt
	5	*
	6	* vDSO randomization
	7	* Copyright(C) 2005-2006, Red Hat, Inc., Ingo Molnar
	8	*
	9	* This file is subject to the terms and conditions of the GNU General Public
	10	* License. See the file "COPYING" in the main directory of this archive
	11	* for more details.
	12	*/
	13	#include <linux/mm.h>
	14	#include <linux/slab.h>
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/gfp.h>
	18	#include <linux/module.h>
	19	#include <linux/elf.h>
	20
	21	/*
	22	* Should the kernel map a VDSO page into processes and pass its
	23	* address down to glibc upon exec()?
	24	*/
	25	unsigned int __read_mostly vdso_enabled = 1;
	26	EXPORT_SYMBOL_GPL(vdso_enabled);
	27
	28	static int __init vdso_setup(char *s)
	29	{
	30	vdso_enabled = simple_strtoul(s, NULL, 0);
	31	return 1;
	32	}
	33	__setup("vdso=", vdso_setup);
	34
	35	/*
	36	* These symbols are defined by vsyscall.o to mark the bounds
	37	* of the ELF DSO images included therein.
	38	*/
	39	extern const char vsyscall_trapa_start, vsyscall_trapa_end;
	40	static void *syscall_page;
	41
	42	int __init vsyscall_init(void)
	43	{
	44	syscall_page = (void *)get_zeroed_page(GFP_ATOMIC);
	45
	46	/*
	47	* XXX: Map this page to a fixmap entry if we get around
	48	* to adding the page to ELF core dumps
	49	*/
	50
	51	memcpy(syscall_page,
	52	&vsyscall_trapa_start,
	53	&vsyscall_trapa_end - &vsyscall_trapa_start);
	54
	55	return 0;
	56	}
	57
	58	static struct page syscall_vma_nopage(struct vm_area_struct vma,
	59	unsigned long address, int *type)
	60	{
	61	unsigned long offset = address - vma->vm_start;
	62	struct page *page;
	63
	64	if (address < vma->vm_start \|\| address > vma->vm_end)
	65	return NOPAGE_SIGBUS;
	66
	67	page = virt_to_page(syscall_page + offset);
	68
	69	get_page(page);
	70
	71	return page;
	72	}
	73
	74	/* Prevent VMA merging */
	75	static void syscall_vma_close(struct vm_area_struct *vma)
	76	{
	77	}
	78
	79	static struct vm_operations_struct syscall_vm_ops = {
	80	.nopage = syscall_vma_nopage,
	81	.close = syscall_vma_close,
	82	};
	83
	84	/* Setup a VMA at program startup for the vsyscall page */
	85	int arch_setup_additional_pages(struct linux_binprm *bprm,
	86	int executable_stack)
	87	{
	88	struct vm_area_struct *vma;
	89	struct mm_struct *mm = current->mm;
	90	unsigned long addr;
	91	int ret;
	92
	93	down_write(&mm->mmap_sem);
	94	addr = get_unmapped_area(NULL, 0, PAGE_SIZE, 0, 0);
	95	if (IS_ERR_VALUE(addr)) {
	96	ret = addr;
	97	goto up_fail;
	98	}
	99
	100	vma = kmem_cache_zalloc(vm_area_cachep, SLAB_KERNEL);
	101	if (!vma) {
	102	ret = -ENOMEM;
	103	goto up_fail;
	104	}
	105
	106	vma->vm_start = addr;
	107	vma->vm_end = addr + PAGE_SIZE;
	108	/* MAYWRITE to allow gdb to COW and set breakpoints */
	109	vma->vm_flags = VM_READ\|VM_EXEC\|VM_MAYREAD\|VM_MAYEXEC\|VM_MAYWRITE;
	110	vma->vm_flags \|= mm->def_flags;
	111	vma->vm_page_prot = protection_map[vma->vm_flags & 7];
	112	vma->vm_ops = &syscall_vm_ops;
	113	vma->vm_mm = mm;
	114
	115	ret = insert_vm_struct(mm, vma);
	116	if (unlikely(ret)) {
	117	kmem_cache_free(vm_area_cachep, vma);
	118	goto up_fail;
	119	}
	120
	121	current->mm->context.vdso = (void *)addr;
	122
	123	mm->total_vm++;
	124	up_fail:
	125	up_write(&mm->mmap_sem);
	126	return ret;
	127	}
	128
	129	const char arch_vma_name(struct vm_area_struct vma)
	130	{
	131	if (vma->vm_mm && vma->vm_start == (long)vma->vm_mm->context.vdso)
	132	return "[vdso]";
	133
	134	return NULL;
	135	}
	136
	137	struct vm_area_struct get_gate_vma(struct task_struct task)
	138	{
	139	return NULL;
	140	}
	141
	142	int in_gate_area(struct task_struct *task, unsigned long address)
	143	{
	144	return 0;
	145	}
	146
	147	int in_gate_area_no_task(unsigned long address)
	148	{
	149	return 0;
	150	}
	151

arch/sh/kernel/vsyscall/vsyscall.lds.S

Diff comments View file @ 19f9a34

File was created	1	/*
	2	* Linker script for vsyscall DSO. The vsyscall page is an ELF shared
	3	* object prelinked to its virtual address, and with only one read-only
	4	* segment (that fits in one page). This script controls its layout.
	5	*/
	6	#include <asm/asm-offsets.h>
	7
	8	#ifdef CONFIG_CPU_LITTLE_ENDIAN
	9	OUTPUT_FORMAT("elf32-sh-linux", "elf32-sh-linux", "elf32-sh-linux")
	10	#else
	11	OUTPUT_FORMAT("elf32-shbig-linux", "elf32-shbig-linux", "elf32-shbig-linux")
	12	#endif
	13	OUTPUT_ARCH(sh)
	14
	15	/* The ELF entry point can be used to set the AT_SYSINFO value. */
	16	ENTRY(__kernel_vsyscall);
	17
	18	SECTIONS
	19	{
	20	. = SIZEOF_HEADERS;
	21
	22	.hash : { *(.hash) } :text
	23	.gnu.hash : { *(.gnu.hash) }
	24	.dynsym : { *(.dynsym) }
	25	.dynstr : { *(.dynstr) }
	26	.gnu.version : { *(.gnu.version) }
	27	.gnu.version_d : { *(.gnu.version_d) }
	28	.gnu.version_r : { *(.gnu.version_r) }
	29
	30	/* This linker script is used both with -r and with -shared.
	31	For the layouts to match, we need to skip more than enough
	32	space for the dynamic symbol table et al. If this amount
	33	is insufficient, ld -shared will barf. Just increase it here. */
	34	. = 0x400;
	35
	36	.text : { *(.text) } :text =0x90909090
	37	.note : { (.note.) } :text :note
	38	.eh_frame_hdr : { *(.eh_frame_hdr) } :text :eh_frame_hdr
	39	.eh_frame : { KEEP (*(.eh_frame)) } :text
	40	.dynamic : { *(.dynamic) } :text :dynamic
	41	.useless : {
	42	(.got.plt) (.got)
	43	(.data .data. .gnu.linkonce.d.*)
	44	*(.dynbss)
	45	(.bss .bss. .gnu.linkonce.b.*)
	46	} :text
	47	}
	48
	49	/*
	50	* We must supply the ELF program headers explicitly to get just one
	51	* PT_LOAD segment, and set the flags explicitly to make segments read-only.
	52	*/
	53	PHDRS
	54	{
	55	text PT_LOAD FILEHDR PHDRS FLAGS(5); /* PF_R\|PF_X */
	56	dynamic PT_DYNAMIC FLAGS(4); /* PF_R */
	57	note PT_NOTE FLAGS(4); /* PF_R */
	58	eh_frame_hdr 0x6474e550; /* PT_GNU_EH_FRAME, but ld doesn't match the name */
	59	}
	60
	61	/*
	62	* This controls what symbols we export from the DSO.
	63	*/
	64	VERSION
	65	{
	66	LINUX_2.6 {
	67	global:
	68	__kernel_vsyscall;
	69	__kernel_sigreturn;
	70	__kernel_rt_sigreturn;
	71
	72	local: *;
	73	};
	74	}
	75

arch/sh/mm/Kconfig

Diff comments View file @ 19f9a34

 menu "Processor selection"
 #
 # Processor families
 #
 config CPU_SH2
 	bool
 	select SH_WRITETHROUGH
 config CPU_SH3
 	bool
 	select CPU_HAS_INTEVT
 	select CPU_HAS_SR_RB
 config CPU_SH4
 	bool
 	select CPU_HAS_INTEVT
 	select CPU_HAS_SR_RB
 config CPU_SH4A
 	bool
 	select CPU_SH4
 config CPU_SH4AL_DSP
 	bool
 	select CPU_SH4A
 config CPU_SUBTYPE_ST40
 	bool
 	select CPU_SH4
 	select CPU_HAS_INTC2_IRQ
 #
 # Processor subtypes
 #
 comment "SH-2 Processor Support"
 config CPU_SUBTYPE_SH7604
 	bool "Support SH7604 processor"
 	select CPU_SH2
 comment "SH-3 Processor Support"
 config CPU_SUBTYPE_SH7300
 	bool "Support SH7300 processor"
 	select CPU_SH3
 config CPU_SUBTYPE_SH7705
 	bool "Support SH7705 processor"
 	select CPU_SH3
 	select CPU_HAS_PINT_IRQ
 config CPU_SUBTYPE_SH7706
 	bool "Support SH7706 processor"
 	select CPU_SH3
 	help
 	  Select SH7706 if you have a 133 Mhz SH-3 HD6417706 CPU.
 config CPU_SUBTYPE_SH7707
 	bool "Support SH7707 processor"
 	select CPU_SH3
 	select CPU_HAS_PINT_IRQ
 	help
 	  Select SH7707 if you have a  60 Mhz SH-3 HD6417707 CPU.
 config CPU_SUBTYPE_SH7708
 	bool "Support SH7708 processor"
 	select CPU_SH3
 	help
 	  Select SH7708 if you have a  60 Mhz SH-3 HD6417708S or
 	  if you have a 100 Mhz SH-3 HD6417708R CPU.
 config CPU_SUBTYPE_SH7709
 	bool "Support SH7709 processor"
 	select CPU_SH3
 	select CPU_HAS_PINT_IRQ
 	help
 	  Select SH7709 if you have a  80 Mhz SH-3 HD6417709 CPU.
 config CPU_SUBTYPE_SH7710
 	bool "Support SH7710 processor"
 	select CPU_SH3
 	help
 	  Select SH7710 if you have a SH3-DSP SH7710 CPU.
 comment "SH-4 Processor Support"
 config CPU_SUBTYPE_SH7750
 	bool "Support SH7750 processor"
 	select CPU_SH4
 	help
 	  Select SH7750 if you have a 200 Mhz SH-4 HD6417750 CPU.
 config CPU_SUBTYPE_SH7091
 	bool "Support SH7091 processor"
 	select CPU_SH4
 	select CPU_SUBTYPE_SH7750
 	help
 	  Select SH7091 if you have an SH-4 based Sega device (such as
 	  the Dreamcast, Naomi, and Naomi 2).
 config CPU_SUBTYPE_SH7750R
 	bool "Support SH7750R processor"
 	select CPU_SH4
 	select CPU_SUBTYPE_SH7750
 config CPU_SUBTYPE_SH7750S
 	bool "Support SH7750S processor"
 	select CPU_SH4
 	select CPU_SUBTYPE_SH7750
 config CPU_SUBTYPE_SH7751
 	bool "Support SH7751 processor"
 	select CPU_SH4
 	help
 	  Select SH7751 if you have a 166 Mhz SH-4 HD6417751 CPU,
 	  or if you have a HD6417751R CPU.
 config CPU_SUBTYPE_SH7751R
 	bool "Support SH7751R processor"
 	select CPU_SH4
 	select CPU_SUBTYPE_SH7751
 config CPU_SUBTYPE_SH7760
 	bool "Support SH7760 processor"
 	select CPU_SH4
 	select CPU_HAS_INTC2_IRQ
 config CPU_SUBTYPE_SH4_202
 	bool "Support SH4-202 processor"
 	select CPU_SH4
 comment "ST40 Processor Support"
 config CPU_SUBTYPE_ST40STB1
 	bool "Support ST40STB1/ST40RA processors"
 	select CPU_SUBTYPE_ST40
 	help
 	  Select ST40STB1 if you have a ST40RA CPU.
 	  This was previously called the ST40STB1, hence the option name.
 config CPU_SUBTYPE_ST40GX1
 	bool "Support ST40GX1 processor"
 	select CPU_SUBTYPE_ST40
 	help
 	  Select ST40GX1 if you have a ST40GX1 CPU.
 comment "SH-4A Processor Support"
 config CPU_SUBTYPE_SH7770
 	bool "Support SH7770 processor"
 	select CPU_SH4A
 config CPU_SUBTYPE_SH7780
 	bool "Support SH7780 processor"
 	select CPU_SH4A
 	select CPU_HAS_INTC2_IRQ
 comment "SH4AL-DSP Processor Support"
 config CPU_SUBTYPE_SH73180
 	bool "Support SH73180 processor"
 	select CPU_SH4AL_DSP
 config CPU_SUBTYPE_SH7343
 	bool "Support SH7343 processor"
 	select CPU_SH4AL_DSP
 endmenu
 menu "Memory management options"
 config MMU
         bool "Support for memory management hardware"
 	depends on !CPU_SH2
 	default y
 	help
 	  Some SH processors (such as SH-2/SH-2A) lack an MMU. In order to
 	  boot on these systems, this option must not be set.
 	  On other systems (such as the SH-3 and 4) where an MMU exists,
 	  turning this off will boot the kernel on these machines with the
 	  MMU implicitly switched off.
 config PAGE_OFFSET
 	hex
 	default "0x80000000" if MMU
 	default "0x00000000"
 config MEMORY_START
 	hex "Physical memory start address"
 	default "0x08000000"
 	---help---
 	  Computers built with Hitachi SuperH processors always
 	  map the ROM starting at address zero.  But the processor
 	  does not specify the range that RAM takes.
 	  The physical memory (RAM) start address will be automatically
 	  set to 08000000. Other platforms, such as the Solution Engine
 	  boards typically map RAM at 0C000000.
 	  Tweak this only when porting to a new machine which does not
 	  already have a defconfig. Changing it from the known correct
 	  value on any of the known systems will only lead to disaster.
 config MEMORY_SIZE
 	hex "Physical memory size"
 	default "0x00400000"
 	help
 	  This sets the default memory size assumed by your SH kernel. It can
 	  be overridden as normal by the 'mem=' argument on the kernel command
 	  line. If unsure, consult your board specifications or just leave it
 	  as 0x00400000 which was the default value before this became
 	  configurable.
 config 32BIT
 	bool "Support 32-bit physical addressing through PMB"
 	depends on CPU_SH4A && MMU
 	default y
 	help
 	  If you say Y here, physical addressing will be extended to
 	  32-bits through the SH-4A PMB. If this is not set, legacy
 	  29-bit physical addressing will be used.
+config VSYSCALL
+	bool "Support vsyscall page"
+	depends on MMU
+	default y
+	help
+	  This will enable support for the kernel mapping a vDSO page
+	  in process space, and subsequently handing down the entry point
+	  to the libc through the ELF auxiliary vector.
+	  From the kernel side this is used for the signal trampoline.
+	  For systems with an MMU that can afford to give up a page,
+	  (the default value) say Y.
 choice
 	prompt "HugeTLB page size"
 	depends on HUGETLB_PAGE && CPU_SH4 && MMU
 	default HUGETLB_PAGE_SIZE_64K
 config HUGETLB_PAGE_SIZE_64K
 	bool "64K"
 config HUGETLB_PAGE_SIZE_1MB
 	bool "1MB"
 endchoice
 source "mm/Kconfig"
 endmenu
 menu "Cache configuration"
 config SH7705_CACHE_32KB
 	bool "Enable 32KB cache size for SH7705"
 	depends on CPU_SUBTYPE_SH7705
 	default y
 config SH_DIRECT_MAPPED
 	bool "Use direct-mapped caching"
 	default n
 	help
 	  Selecting this option will configure the caches to be direct-mapped,
 	  even if the cache supports a 2 or 4-way mode. This is useful primarily
 	  for debugging on platforms with 2 and 4-way caches (SH7750R/SH7751R,
 	  SH4-202, SH4-501, etc.)
 	  Turn this option off for platforms that do not have a direct-mapped
 	  cache, and you have no need to run the caches in such a configuration.
 config SH_WRITETHROUGH
 	bool "Use write-through caching"
 	default y if CPU_SH2
 	help
 	  Selecting this option will configure the caches in write-through
 	  mode, as opposed to the default write-back configuration.
 	  Since there's sill some aliasing issues on SH-4, this option will
 	  unfortunately still require the majority of flushing functions to
 	  be implemented to deal with aliasing.
 	  If unsure, say N.
 config SH_OCRAM
 	bool "Operand Cache RAM (OCRAM) support"
 	help
 	  Selecting this option will automatically tear down the number of
 	  sets in the dcache by half, which in turn exposes a memory range.
 	  The addresses for the OC RAM base will vary according to the
 	  processor version. Consult vendor documentation for specifics.
 	  If unsure, say N.
 endmenu

arch/sh/mm/init.c

Diff comments View file @ 19f9a34

 /* $Id: init.c,v 1.19 2004/02/21 04:42:16 kkojima Exp $
  *
  *  linux/arch/sh/mm/init.c
  *
  *  Copyright (C) 1999  Niibe Yutaka
  *  Copyright (C) 2002, 2004  Paul Mundt
  *
  *  Based on linux/arch/i386/mm/init.c:
  *   Copyright (C) 1995  Linus Torvalds
  */
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/ptrace.h>
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/smp.h>
 #include <linux/init.h>
 #include <linux/highmem.h>
 #include <linux/bootmem.h>
 #include <linux/pagemap.h>
 #include <linux/proc_fs.h>
 #include <asm/processor.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/mmu_context.h>
 #include <asm/io.h>
 #include <asm/tlb.h>
 #include <asm/cacheflush.h>
 #include <asm/cache.h>
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 pgd_t swapper_pg_dir[PTRS_PER_PGD];
 /*
  * Cache of MMU context last used.
  */
 unsigned long mmu_context_cache = NO_CONTEXT;
 #ifdef CONFIG_MMU
 /* It'd be good if these lines were in the standard header file. */
 #define START_PFN	(NODE_DATA(0)->bdata->node_boot_start >> PAGE_SHIFT)
 #define MAX_LOW_PFN	(NODE_DATA(0)->bdata->node_low_pfn)
 #endif
 void (*copy_page)(void *from, void *to);
 void (*clear_page)(void *to);
 void show_mem(void)
 {
 	int i, total = 0, reserved = 0;
 	int shared = 0, cached = 0;
 	printk("Mem-info:\n");
 	show_free_areas();
 	printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
 	i = max_mapnr;
 	while (i-- > 0) {
 		total++;
 		if (PageReserved(mem_map+i))
 			reserved++;
 		else if (PageSwapCache(mem_map+i))
 			cached++;
 		else if (page_count(mem_map+i))
 			shared += page_count(mem_map+i) - 1;
 	}
 	printk("%d pages of RAM\n",total);
 	printk("%d reserved pages\n",reserved);
 	printk("%d pages shared\n",shared);
 	printk("%d pages swap cached\n",cached);
 }
 static void set_pte_phys(unsigned long addr, unsigned long phys, pgprot_t prot)
 {
 	pgd_t *pgd;
 	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;
 	pgd = swapper_pg_dir + pgd_index(addr);
 	if (pgd_none(*pgd)) {
 		pgd_ERROR(*pgd);
 		return;
 	}
 	pud = pud_offset(pgd, addr);
 	if (pud_none(*pud)) {
 		pmd = (pmd_t *)get_zeroed_page(GFP_ATOMIC);
 		set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
 		if (pmd != pmd_offset(pud, 0)) {
 			pud_ERROR(*pud);
 			return;
 		}
 	}
 	pmd = pmd_offset(pud, addr);
 	if (pmd_none(*pmd)) {
 		pte = (pte_t *)get_zeroed_page(GFP_ATOMIC);
 		set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
 		if (pte != pte_offset_kernel(pmd, 0)) {
 			pmd_ERROR(*pmd);
 			return;
 		}
 	}
 	pte = pte_offset_kernel(pmd, addr);
 	if (!pte_none(*pte)) {
 		pte_ERROR(*pte);
 		return;
 	}
 	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, prot));
 	__flush_tlb_page(get_asid(), addr);
 }
 /*
  * As a performance optimization, other platforms preserve the fixmap mapping
  * across a context switch, we don't presently do this, but this could be done
  * in a similar fashion as to the wired TLB interface that sh64 uses (by way
  * of the memorry mapped UTLB configuration) -- this unfortunately forces us to
  * give up a TLB entry for each mapping we want to preserve. While this may be
  * viable for a small number of fixmaps, it's not particularly useful for
  * everything and needs to be carefully evaluated. (ie, we may want this for
  * the vsyscall page).
  *
  * XXX: Perhaps add a _PAGE_WIRED flag or something similar that we can pass
  * in at __set_fixmap() time to determine the appropriate behavior to follow.
  *
  *					 -- PFM.
  */
 void __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
 {
 	unsigned long address = __fix_to_virt(idx);
 	if (idx >= __end_of_fixed_addresses) {
 		BUG();
 		return;
 	}
 	set_pte_phys(address, phys, prot);
 }
 /* References to section boundaries */
 extern char _text, _etext, _edata, __bss_start, _end;
 extern char __init_begin, __init_end;
 /*
  * paging_init() sets up the page tables
  *
  * This routines also unmaps the page at virtual kernel address 0, so
  * that we can trap those pesky NULL-reference errors in the kernel.
  */
 void __init paging_init(void)
 {
 	unsigned long zones_size[MAX_NR_ZONES] = { 0, };
 	/*
 	 * Setup some defaults for the zone sizes.. these should be safe
 	 * regardless of distcontiguous memory or MMU settings.
 	 */
 	zones_size[ZONE_DMA] = 0 >> PAGE_SHIFT;
 	zones_size[ZONE_NORMAL] = __MEMORY_SIZE >> PAGE_SHIFT;
 #ifdef CONFIG_HIGHMEM
 	zones_size[ZONE_HIGHMEM] = 0 >> PAGE_SHIFT;
 #endif
 #ifdef CONFIG_MMU
 	/*
 	 * If we have an MMU, and want to be using it .. we need to adjust
 	 * the zone sizes accordingly, in addition to turning it on.
 	 */
 	{
 		unsigned long max_dma, low, start_pfn;
 		pgd_t *pg_dir;
 		int i;
 		/* We don't need kernel mapping as hardware support that. */
 		pg_dir = swapper_pg_dir;
 		for (i = 0; i < PTRS_PER_PGD; i++)
 			pgd_val(pg_dir[i]) = 0;
 		/* Turn on the MMU */
 		enable_mmu();
 		/* Fixup the zone sizes */
 		start_pfn = START_PFN;
 		max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 		low = MAX_LOW_PFN;
 		if (low < max_dma) {
 			zones_size[ZONE_DMA] = low - start_pfn;
 			zones_size[ZONE_NORMAL] = 0;
 		} else {
 			zones_size[ZONE_DMA] = max_dma - start_pfn;
 			zones_size[ZONE_NORMAL] = low - max_dma;
 		}
 	}
 #elif defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4)
 	/*
 	 * If we don't have CONFIG_MMU set and the processor in question
 	 * still has an MMU, care needs to be taken to make sure it doesn't
 	 * stay on.. Since the boot loader could have potentially already
 	 * turned it on, and we clearly don't want it, we simply turn it off.
 	 *
 	 * We don't need to do anything special for the zone sizes, since the
 	 * default values that were already configured up above should be
 	 * satisfactory.
 	 */
 	disable_mmu();
 #endif
 	NODE_DATA(0)->node_mem_map = NULL;
 	free_area_init_node(0, NODE_DATA(0), zones_size, __MEMORY_START >> PAGE_SHIFT, 0);
 }
 static struct kcore_list kcore_mem, kcore_vmalloc;
 void __init mem_init(void)
 {
 	extern unsigned long empty_zero_page[1024];
 	int codesize, reservedpages, datasize, initsize;
 	int tmp;
 	extern unsigned long memory_start;
 #ifdef CONFIG_MMU
 	high_memory = (void *)__va(MAX_LOW_PFN * PAGE_SIZE);
 #else
 	extern unsigned long memory_end;
 	high_memory = (void *)(memory_end & PAGE_MASK);
 #endif
 	max_mapnr = num_physpages = MAP_NR(high_memory) - MAP_NR(memory_start);
 	/* clear the zero-page */
 	memset(empty_zero_page, 0, PAGE_SIZE);
 	__flush_wback_region(empty_zero_page, PAGE_SIZE);
 	/*
 	 * Setup wrappers for copy/clear_page(), these will get overridden
 	 * later in the boot process if a better method is available.
 	 */
 #ifdef CONFIG_MMU
 	copy_page = copy_page_slow;
 	clear_page = clear_page_slow;
 #else
 	copy_page = copy_page_nommu;
 	clear_page = clear_page_nommu;
 #endif
 	/* this will put all low memory onto the freelists */
 	totalram_pages += free_all_bootmem_node(NODE_DATA(0));
 	reservedpages = 0;
 	for (tmp = 0; tmp < num_physpages; tmp++)
 		/*
 		 * Only count reserved RAM pages
 		 */
 		if (PageReserved(mem_map+tmp))
 			reservedpages++;
 	codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 	datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 	initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 	kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 	kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 		   VMALLOC_END - VMALLOC_START);
 	printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
 	       "%dk reserved, %dk data, %dk init)\n",
 		(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 		max_mapnr << (PAGE_SHIFT-10),
 		codesize >> 10,
 		reservedpages << (PAGE_SHIFT-10),
 		datasize >> 10,
 		initsize >> 10);
 	p3_cache_init();
+	/* Initialize the vDSO */
+	vsyscall_init();
 }
 void free_initmem(void)
 {
 	unsigned long addr;
 	addr = (unsigned long)(&__init_begin);
 	for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
 		ClearPageReserved(virt_to_page(addr));
 		init_page_count(virt_to_page(addr));
 		free_page(addr);
 		totalram_pages++;
 	}
 	printk ("Freeing unused kernel memory: %dk freed\n", (&__init_end - &__init_begin) >> 10);
 }
 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
 	unsigned long p;
 	for (p = start; p < end; p += PAGE_SIZE) {
 		ClearPageReserved(virt_to_page(p));
 		init_page_count(virt_to_page(p));
 		free_page(p);
 		totalram_pages++;
 	}
 	printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
 }
 #endif

arch/sh/mm/tlb-flush.c

Diff comments View file @ 19f9a34

 /*
  * TLB flushing operations for SH with an MMU.
  *
  *  Copyright (C) 1999  Niibe Yutaka
  *  Copyright (C) 2003  Paul Mundt
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  */
 #include <linux/mm.h>
 #include <asm/mmu_context.h>
 #include <asm/tlbflush.h>
 void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
 {
-	if (vma->vm_mm && vma->vm_mm->context != NO_CONTEXT) {
+	if (vma->vm_mm && vma->vm_mm->context.id != NO_CONTEXT) {
 		unsigned long flags;
 		unsigned long asid;
 		unsigned long saved_asid = MMU_NO_ASID;
-		asid = vma->vm_mm->context & MMU_CONTEXT_ASID_MASK;
+		asid = vma->vm_mm->context.id & MMU_CONTEXT_ASID_MASK;
 		page &= PAGE_MASK;
 		local_irq_save(flags);
 		if (vma->vm_mm != current->mm) {
 			saved_asid = get_asid();
 			set_asid(asid);
 		}
 		__flush_tlb_page(asid, page);
 		if (saved_asid != MMU_NO_ASID)
 			set_asid(saved_asid);
 		local_irq_restore(flags);
 	}
 }
 void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
 		     unsigned long end)
 {
 	struct mm_struct *mm = vma->vm_mm;
-	if (mm->context != NO_CONTEXT) {
+	if (mm->context.id != NO_CONTEXT) {
 		unsigned long flags;
 		int size;
 		local_irq_save(flags);
 		size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
 		if (size > (MMU_NTLB_ENTRIES/4)) { /* Too many TLB to flush */
-			mm->context = NO_CONTEXT;
+			mm->context.id = NO_CONTEXT;
 			if (mm == current->mm)
 				activate_context(mm);
 		} else {
-			unsigned long asid = mm->context&MMU_CONTEXT_ASID_MASK;
+			unsigned long asid;
 			unsigned long saved_asid = MMU_NO_ASID;
+			asid = mm->context.id & MMU_CONTEXT_ASID_MASK;
 			start &= PAGE_MASK;
 			end += (PAGE_SIZE - 1);
 			end &= PAGE_MASK;
 			if (mm != current->mm) {
 				saved_asid = get_asid();
 				set_asid(asid);
 			}
 			while (start < end) {
 				__flush_tlb_page(asid, start);
 				start += PAGE_SIZE;
 			}
 			if (saved_asid != MMU_NO_ASID)
 				set_asid(saved_asid);
 		}
 		local_irq_restore(flags);
 	}
 }
 void flush_tlb_kernel_range(unsigned long start, unsigned long end)
 {
 	unsigned long flags;
 	int size;
 	local_irq_save(flags);
 	size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
 	if (size > (MMU_NTLB_ENTRIES/4)) { /* Too many TLB to flush */
 		flush_tlb_all();
 	} else {
-		unsigned long asid = init_mm.context&MMU_CONTEXT_ASID_MASK;
+		unsigned long asid;
 		unsigned long saved_asid = get_asid();
+		asid = init_mm.context.id & MMU_CONTEXT_ASID_MASK;
 		start &= PAGE_MASK;
 		end += (PAGE_SIZE - 1);
 		end &= PAGE_MASK;
 		set_asid(asid);
 		while (start < end) {
 			__flush_tlb_page(asid, start);
 			start += PAGE_SIZE;
 		}
 		set_asid(saved_asid);
 	}
 	local_irq_restore(flags);
 }
 void flush_tlb_mm(struct mm_struct *mm)
 {
 	/* Invalidate all TLB of this process. */
 	/* Instead of invalidating each TLB, we get new MMU context. */
-	if (mm->context != NO_CONTEXT) {
+	if (mm->context.id != NO_CONTEXT) {
 		unsigned long flags;
 		local_irq_save(flags);
-		mm->context = NO_CONTEXT;
+		mm->context.id = NO_CONTEXT;
 		if (mm == current->mm)
 			activate_context(mm);
 		local_irq_restore(flags);
 	}
 }
 void flush_tlb_all(void)
 {
 	unsigned long flags, status;
 	/*
 	 * Flush all the TLB.
 	 *
 	 * Write to the MMU control register's bit:
 	 *	TF-bit for SH-3, TI-bit for SH-4.
 	 *      It's same position, bit #2.
 	 */
 	local_irq_save(flags);
 	status = ctrl_inl(MMUCR);
 	status |= 0x04;
 	ctrl_outl(status, MMUCR);
 	ctrl_barrier();
 	local_irq_restore(flags);
 }

include/asm-sh/auxvec.h

Diff comments View file @ 19f9a34

1	#ifndef __ASM_SH_AUXVEC_H	1	#ifndef __ASM_SH_AUXVEC_H
2	#define __ASM_SH_AUXVEC_H	2	#define __ASM_SH_AUXVEC_H
3		3
		4	/*
		5	* Architecture-neutral AT_ values in 0-17, leave some room
		6	* for more of them.
		7	*/
		8
		9	#ifdef CONFIG_VSYSCALL
		10	/*
		11	* Only define this in the vsyscall case, the entry point to
		12	* the vsyscall page gets placed here. The kernel will attempt
		13	* to build a gate VMA we don't care about otherwise..
		14	*/
		15	#define AT_SYSINFO_EHDR 33
		16	#endif
		17
4	#endif /* __ASM_SH_AUXVEC_H */	18	#endif /* __ASM_SH_AUXVEC_H */
5		19

include/asm-sh/elf.h

Diff comments View file @ 19f9a34

 #ifndef __ASM_SH_ELF_H
 #define __ASM_SH_ELF_H
 #include <asm/processor.h>
 #include <asm/auxvec.h>
 #include <asm/ptrace.h>
 #include <asm/user.h>
 /* SH relocation types  */
 #define	R_SH_NONE		0
 #define	R_SH_DIR32		1
 #define	R_SH_REL32		2
 #define	R_SH_DIR8WPN		3
 #define	R_SH_IND12W		4
 #define	R_SH_DIR8WPL		5
 #define	R_SH_DIR8WPZ		6
 #define	R_SH_DIR8BP		7
 #define	R_SH_DIR8W		8
 #define	R_SH_DIR8L		9
 #define	R_SH_SWITCH16		25
 #define	R_SH_SWITCH32		26
 #define	R_SH_USES		27
 #define	R_SH_COUNT		28
 #define	R_SH_ALIGN		29
 #define	R_SH_CODE		30
 #define	R_SH_DATA		31
 #define	R_SH_LABEL		32
 #define	R_SH_SWITCH8		33
 #define	R_SH_GNU_VTINHERIT	34
 #define	R_SH_GNU_VTENTRY	35
 #define	R_SH_TLS_GD_32		144
 #define	R_SH_TLS_LD_32		145
 #define	R_SH_TLS_LDO_32		146
 #define	R_SH_TLS_IE_32		147
 #define	R_SH_TLS_LE_32		148
 #define	R_SH_TLS_DTPMOD32	149
 #define	R_SH_TLS_DTPOFF32	150
 #define	R_SH_TLS_TPOFF32	151
 #define	R_SH_GOT32		160
 #define	R_SH_PLT32		161
 #define	R_SH_COPY		162
 #define	R_SH_GLOB_DAT		163
 #define	R_SH_JMP_SLOT		164
 #define	R_SH_RELATIVE		165
 #define	R_SH_GOTOFF		166
 #define	R_SH_GOTPC		167
 /* Keep this the last entry.  */
 #define	R_SH_NUM		256
 /*
  * ELF register definitions..
  */
 typedef unsigned long elf_greg_t;
 #define ELF_NGREG (sizeof (struct pt_regs) / sizeof(elf_greg_t))
 typedef elf_greg_t elf_gregset_t[ELF_NGREG];
 typedef struct user_fpu_struct elf_fpregset_t;
 /*
  * This is used to ensure we don't load something for the wrong architecture.
  */
 #define elf_check_arch(x) ( (x)->e_machine == EM_SH )
 /*
  * These are used to set parameters in the core dumps.
  */
 #define ELF_CLASS	ELFCLASS32
 #ifdef __LITTLE_ENDIAN__
 #define ELF_DATA	ELFDATA2LSB
 #else
 #define ELF_DATA	ELFDATA2MSB
 #endif
 #define ELF_ARCH	EM_SH
 #define USE_ELF_CORE_DUMP
 #define ELF_EXEC_PAGESIZE	4096
 /* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
    use of this is to invoke "./ld.so someprog" to test out a new version of
    the loader.  We need to make sure that it is out of the way of the program
    that it will "exec", and that there is sufficient room for the brk.  */
 #define ELF_ET_DYN_BASE         (2 * TASK_SIZE / 3)
 #define ELF_CORE_COPY_REGS(_dest,_regs)				\
 	memcpy((char *) &_dest, (char *) _regs,			\
 	       sizeof(struct pt_regs));
 /* This yields a mask that user programs can use to figure out what
    instruction set this CPU supports.  This could be done in user space,
    but it's not easy, and we've already done it here.  */
 #define ELF_HWCAP	(boot_cpu_data.flags)
 /* This yields a string that ld.so will use to load implementation
    specific libraries for optimization.  This is more specific in
    intent than poking at uname or /proc/cpuinfo.
    For the moment, we have only optimizations for the Intel generations,
    but that could change... */
 #define ELF_PLATFORM  (NULL)
 #define ELF_PLAT_INIT(_r, load_addr) \
   do { _r->regs[0]=0; _r->regs[1]=0; _r->regs[2]=0; _r->regs[3]=0; \
        _r->regs[4]=0; _r->regs[5]=0; _r->regs[6]=0; _r->regs[7]=0; \
        _r->regs[8]=0; _r->regs[9]=0; _r->regs[10]=0; _r->regs[11]=0; \
        _r->regs[12]=0; _r->regs[13]=0; _r->regs[14]=0; \
        _r->sr = SR_FD; } while (0)
 #ifdef __KERNEL__
 #define SET_PERSONALITY(ex, ibcs2) set_personality(PER_LINUX_32BIT)
 struct task_struct;
 extern int dump_task_regs (struct task_struct *, elf_gregset_t *);
 extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
 #define ELF_CORE_COPY_TASK_REGS(tsk, elf_regs) dump_task_regs(tsk, elf_regs)
 #define ELF_CORE_COPY_FPREGS(tsk, elf_fpregs) dump_task_fpu(tsk, elf_fpregs)
 #endif
+#ifdef CONFIG_VSYSCALL
+/* vDSO has arch_setup_additional_pages */
+#define ARCH_HAS_SETUP_ADDITIONAL_PAGES
+struct linux_binprm;
+extern int arch_setup_additional_pages(struct linux_binprm *bprm,
+				       int executable_stack);
+extern unsigned int vdso_enabled;
+extern void __kernel_vsyscall;
+#define VDSO_BASE		((unsigned long)current->mm->context.vdso)
+#define VDSO_SYM(x)		(VDSO_BASE + (unsigned long)(x))
+#define ARCH_DLINFO						\
+do {								\
+	if (vdso_enabled)					\
+		NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_BASE);	\
+} while (0)
+#endif /* CONFIG_VSYSCALL */
 #endif /* __ASM_SH_ELF_H */

include/asm-sh/mmu.h

Diff comments View file @ 19f9a34

 #ifndef __MMU_H
 #define __MMU_H
 #if !defined(CONFIG_MMU)
 typedef struct {
 	struct vm_list_struct	*vmlist;
 	unsigned long		end_brk;
 } mm_context_t;
 #else
 /* Default "unsigned long" context */
-typedef unsigned long mm_context_t;
+typedef unsigned long mm_context_id_t;
+typedef struct {
+	mm_context_id_t id;
+	void *vdso;
+} mm_context_t;
 #endif /* CONFIG_MMU */
 /*
  * Privileged Space Mapping Buffer (PMB) definitions
  */
 #define PMB_PASCR		0xff000070
 #define PMB_IRMCR		0xff000078
 #define PMB_ADDR		0xf6100000
 #define PMB_DATA		0xf7100000
 #define PMB_ENTRY_MAX		16
 #define PMB_E_MASK		0x0000000f
 #define PMB_E_SHIFT		8
 #define PMB_SZ_16M		0x00000000
 #define PMB_SZ_64M		0x00000010
 #define PMB_SZ_128M		0x00000080
 #define PMB_SZ_512M		0x00000090
 #define PMB_SZ_MASK		PMB_SZ_512M
 #define PMB_C			0x00000008
 #define PMB_WT			0x00000001
 #define PMB_UB			0x00000200
 #define PMB_V			0x00000100
 #define PMB_NO_ENTRY		(-1)
 struct pmb_entry;
 struct pmb_entry {
 	unsigned long vpn;
 	unsigned long ppn;
 	unsigned long flags;
 	/*
 	 * 0 .. NR_PMB_ENTRIES for specific entry selection, or
 	 * PMB_NO_ENTRY to search for a free one
 	 */
 	int entry;
 	struct pmb_entry *next;
 	/* Adjacent entry link for contiguous multi-entry mappings */
 	struct pmb_entry *link;
 };
 /* arch/sh/mm/pmb.c */
 int __set_pmb_entry(unsigned long vpn, unsigned long ppn,
 		    unsigned long flags, int *entry);
 int set_pmb_entry(struct pmb_entry *pmbe);
 void clear_pmb_entry(struct pmb_entry *pmbe);
 struct pmb_entry *pmb_alloc(unsigned long vpn, unsigned long ppn,
 			    unsigned long flags);
 void pmb_free(struct pmb_entry *pmbe);
 long pmb_remap(unsigned long virt, unsigned long phys,
 	       unsigned long size, unsigned long flags);
 void pmb_unmap(unsigned long addr);
 #endif /* __MMU_H */

include/asm-sh/mmu_context.h

Diff comments View file @ 19f9a34

1	/*	1	/*
2	* Copyright (C) 1999 Niibe Yutaka	2	* Copyright (C) 1999 Niibe Yutaka
3	* Copyright (C) 2003 Paul Mundt	3	* Copyright (C) 2003 Paul Mundt
4	*	4	*
5	* ASID handling idea taken from MIPS implementation.	5	* ASID handling idea taken from MIPS implementation.
6	*/	6	*/
7	#ifndef __ASM_SH_MMU_CONTEXT_H	7	#ifndef __ASM_SH_MMU_CONTEXT_H
8	#define __ASM_SH_MMU_CONTEXT_H	8	#define __ASM_SH_MMU_CONTEXT_H
9	#ifdef __KERNEL__	9	#ifdef __KERNEL__
10		10
11	#include <asm/cpu/mmu_context.h>	11	#include <asm/cpu/mmu_context.h>
12	#include <asm/tlbflush.h>	12	#include <asm/tlbflush.h>
13	#include <asm/pgalloc.h>	13	#include <asm/pgalloc.h>
14	#include <asm/uaccess.h>	14	#include <asm/uaccess.h>
15	#include <asm/io.h>	15	#include <asm/io.h>
16		16
17	/*	17	/*
18	* The MMU "context" consists of two things:	18	* The MMU "context" consists of two things:
19	* (a) TLB cache version (or round, cycle whatever expression you like)	19	* (a) TLB cache version (or round, cycle whatever expression you like)
20	* (b) ASID (Address Space IDentifier)	20	* (b) ASID (Address Space IDentifier)
21	*/	21	*/
22		22
23	/*	23	/*
24	* Cache of MMU context last used.	24	* Cache of MMU context last used.
25	*/	25	*/
26	extern unsigned long mmu_context_cache;	26	extern unsigned long mmu_context_cache;
27		27
28	#define MMU_CONTEXT_ASID_MASK 0x000000ff	28	#define MMU_CONTEXT_ASID_MASK 0x000000ff
29	#define MMU_CONTEXT_VERSION_MASK 0xffffff00	29	#define MMU_CONTEXT_VERSION_MASK 0xffffff00
30	#define MMU_CONTEXT_FIRST_VERSION 0x00000100	30	#define MMU_CONTEXT_FIRST_VERSION 0x00000100
31	#define NO_CONTEXT 0	31	#define NO_CONTEXT 0
32		32
33	/* ASID is 8-bit value, so it can't be 0x100 */	33	/* ASID is 8-bit value, so it can't be 0x100 */
34	#define MMU_NO_ASID 0x100	34	#define MMU_NO_ASID 0x100
35		35
36	/*	36	/*
37	* Virtual Page Number mask	37	* Virtual Page Number mask
38	*/	38	*/
39	#define MMU_VPN_MASK 0xfffff000	39	#define MMU_VPN_MASK 0xfffff000
40		40
41	#ifdef CONFIG_MMU	41	#ifdef CONFIG_MMU
42	/*	42	/*
43	* Get MMU context if needed.	43	* Get MMU context if needed.
44	*/	44	*/
45	static __inline__ void	45	static __inline__ void
46	get_mmu_context(struct mm_struct *mm)	46	get_mmu_context(struct mm_struct *mm)
47	{	47	{
48	extern void flush_tlb_all(void);	48	extern void flush_tlb_all(void);
49	unsigned long mc = mmu_context_cache;	49	unsigned long mc = mmu_context_cache;
50		50
51	/* Check if we have old version of context. */	51	/* Check if we have old version of context. */
52	if (((mm->context ^ mc) & MMU_CONTEXT_VERSION_MASK) == 0)	52	if (((mm->context.id ^ mc) & MMU_CONTEXT_VERSION_MASK) == 0)
53	/* It's up to date, do nothing */	53	/* It's up to date, do nothing */
54	return;	54	return;
55		55
56	/* It's old, we need to get new context with new version. */	56	/* It's old, we need to get new context with new version. */
57	mc = ++mmu_context_cache;	57	mc = ++mmu_context_cache;
58	if (!(mc & MMU_CONTEXT_ASID_MASK)) {	58	if (!(mc & MMU_CONTEXT_ASID_MASK)) {
59	/*	59	/*
60	* We exhaust ASID of this version.	60	* We exhaust ASID of this version.
61	* Flush all TLB and start new cycle.	61	* Flush all TLB and start new cycle.
62	*/	62	*/
63	flush_tlb_all();	63	flush_tlb_all();
64	/*	64	/*
65	* Fix version; Note that we avoid version #0	65	* Fix version; Note that we avoid version #0
66	* to distingush NO_CONTEXT.	66	* to distingush NO_CONTEXT.
67	*/	67	*/
68	if (!mc)	68	if (!mc)
69	mmu_context_cache = mc = MMU_CONTEXT_FIRST_VERSION;	69	mmu_context_cache = mc = MMU_CONTEXT_FIRST_VERSION;
70	}	70	}
71	mm->context = mc;	71	mm->context.id = mc;
72	}	72	}
73		73
74	/*	74	/*
75	* Initialize the context related info for a new mm_struct	75	* Initialize the context related info for a new mm_struct
76	* instance.	76	* instance.
77	*/	77	*/
78	static __inline__ int init_new_context(struct task_struct *tsk,	78	static __inline__ int init_new_context(struct task_struct *tsk,
79	struct mm_struct *mm)	79	struct mm_struct *mm)
80	{	80	{
81	mm->context = NO_CONTEXT;	81	mm->context.id = NO_CONTEXT;
82		82
83	return 0;	83	return 0;
84	}	84	}
85		85
86	/*	86	/*
87	* Destroy context related info for an mm_struct that is about	87	* Destroy context related info for an mm_struct that is about
88	* to be put to rest.	88	* to be put to rest.
89	*/	89	*/
90	static __inline__ void destroy_context(struct mm_struct *mm)	90	static __inline__ void destroy_context(struct mm_struct *mm)
91	{	91	{
92	/* Do nothing */	92	/* Do nothing */
93	}	93	}
94		94
95	static __inline__ void set_asid(unsigned long asid)	95	static __inline__ void set_asid(unsigned long asid)
96	{	96	{
97	unsigned long __dummy;	97	unsigned long __dummy;
98		98
99	__asm__ __volatile__ ("mov.l %2, %0\n\t"	99	__asm__ __volatile__ ("mov.l %2, %0\n\t"
100	"and %3, %0\n\t"	100	"and %3, %0\n\t"
101	"or %1, %0\n\t"	101	"or %1, %0\n\t"
102	"mov.l %0, %2"	102	"mov.l %0, %2"
103	: "=&r" (__dummy)	103	: "=&r" (__dummy)
104	: "r" (asid), "m" (__m(MMU_PTEH)),	104	: "r" (asid), "m" (__m(MMU_PTEH)),
105	"r" (0xffffff00));	105	"r" (0xffffff00));
106	}	106	}
107		107
108	static __inline__ unsigned long get_asid(void)	108	static __inline__ unsigned long get_asid(void)
109	{	109	{
110	unsigned long asid;	110	unsigned long asid;
111		111
112	__asm__ __volatile__ ("mov.l %1, %0"	112	__asm__ __volatile__ ("mov.l %1, %0"
113	: "=r" (asid)	113	: "=r" (asid)
114	: "m" (__m(MMU_PTEH)));	114	: "m" (__m(MMU_PTEH)));
115	asid &= MMU_CONTEXT_ASID_MASK;	115	asid &= MMU_CONTEXT_ASID_MASK;
116	return asid;	116	return asid;
117	}	117	}
118		118
119	/*	119	/*
120	* After we have set current->mm to a new value, this activates	120	* After we have set current->mm to a new value, this activates
121	* the context for the new mm so we see the new mappings.	121	* the context for the new mm so we see the new mappings.
122	*/	122	*/
123	static __inline__ void activate_context(struct mm_struct *mm)	123	static __inline__ void activate_context(struct mm_struct *mm)
124	{	124	{
125	get_mmu_context(mm);	125	get_mmu_context(mm);
126	set_asid(mm->context & MMU_CONTEXT_ASID_MASK);	126	set_asid(mm->context.id & MMU_CONTEXT_ASID_MASK);
127	}	127	}
128		128
129	/* MMU_TTB can be used for optimizing the fault handling.	129	/* MMU_TTB can be used for optimizing the fault handling.
130	(Currently not used) */	130	(Currently not used) */
131	static __inline__ void switch_mm(struct mm_struct *prev,	131	static __inline__ void switch_mm(struct mm_struct *prev,
132	struct mm_struct *next,	132	struct mm_struct *next,
133	struct task_struct *tsk)	133	struct task_struct *tsk)
134	{	134	{
135	if (likely(prev != next)) {	135	if (likely(prev != next)) {
136	unsigned long __pgdir = (unsigned long)next->pgd;	136	unsigned long __pgdir = (unsigned long)next->pgd;
137		137
138	__asm__ __volatile__("mov.l %0, %1"	138	__asm__ __volatile__("mov.l %0, %1"
139	: /* no output */	139	: /* no output */
140	: "r" (__pgdir), "m" (__m(MMU_TTB)));	140	: "r" (__pgdir), "m" (__m(MMU_TTB)));
141	activate_context(next);	141	activate_context(next);
142	}	142	}
143	}	143	}
144		144
145	#define deactivate_mm(tsk,mm) do { } while (0)	145	#define deactivate_mm(tsk,mm) do { } while (0)
146		146
147	#define activate_mm(prev, next) \	147	#define activate_mm(prev, next) \
148	switch_mm((prev),(next),NULL)	148	switch_mm((prev),(next),NULL)
149		149
150	static __inline__ void	150	static __inline__ void
151	enter_lazy_tlb(struct mm_struct mm, struct task_struct tsk)	151	enter_lazy_tlb(struct mm_struct mm, struct task_struct tsk)
152	{	152	{
153	}	153	}
154	#else /* !CONFIG_MMU */	154	#else /* !CONFIG_MMU */
155	#define get_mmu_context(mm) do { } while (0)	155	#define get_mmu_context(mm) do { } while (0)
156	#define init_new_context(tsk,mm) (0)	156	#define init_new_context(tsk,mm) (0)
157	#define destroy_context(mm) do { } while (0)	157	#define destroy_context(mm) do { } while (0)
158	#define set_asid(asid) do { } while (0)	158	#define set_asid(asid) do { } while (0)
159	#define get_asid() (0)	159	#define get_asid() (0)
160	#define activate_context(mm) do { } while (0)	160	#define activate_context(mm) do { } while (0)
161	#define switch_mm(prev,next,tsk) do { } while (0)	161	#define switch_mm(prev,next,tsk) do { } while (0)
162	#define deactivate_mm(tsk,mm) do { } while (0)	162	#define deactivate_mm(tsk,mm) do { } while (0)
163	#define activate_mm(prev,next) do { } while (0)	163	#define activate_mm(prev,next) do { } while (0)
164	#define enter_lazy_tlb(mm,tsk) do { } while (0)	164	#define enter_lazy_tlb(mm,tsk) do { } while (0)
165	#endif /* CONFIG_MMU */	165	#endif /* CONFIG_MMU */
166		166
167	#if defined(CONFIG_CPU_SH3) \|\| defined(CONFIG_CPU_SH4)	167	#if defined(CONFIG_CPU_SH3) \|\| defined(CONFIG_CPU_SH4)
168	/*	168	/*
169	* If this processor has an MMU, we need methods to turn it off/on ..	169	* If this processor has an MMU, we need methods to turn it off/on ..
170	* paging_init() will also have to be updated for the processor in	170	* paging_init() will also have to be updated for the processor in
171	* question.	171	* question.
172	*/	172	*/
173	static inline void enable_mmu(void)	173	static inline void enable_mmu(void)
174	{	174	{
175	/* Enable MMU */	175	/* Enable MMU */
176	ctrl_outl(MMU_CONTROL_INIT, MMUCR);	176	ctrl_outl(MMU_CONTROL_INIT, MMUCR);
177	ctrl_barrier();	177	ctrl_barrier();
178		178
179	if (mmu_context_cache == NO_CONTEXT)	179	if (mmu_context_cache == NO_CONTEXT)
180	mmu_context_cache = MMU_CONTEXT_FIRST_VERSION;	180	mmu_context_cache = MMU_CONTEXT_FIRST_VERSION;
181		181
182	set_asid(mmu_context_cache & MMU_CONTEXT_ASID_MASK);	182	set_asid(mmu_context_cache & MMU_CONTEXT_ASID_MASK);
183	}	183	}
184		184
185	static inline void disable_mmu(void)	185	static inline void disable_mmu(void)
186	{	186	{
187	unsigned long cr;	187	unsigned long cr;
188		188
189	cr = ctrl_inl(MMUCR);	189	cr = ctrl_inl(MMUCR);
190	cr &= ~MMU_CONTROL_INIT;	190	cr &= ~MMU_CONTROL_INIT;
191	ctrl_outl(cr, MMUCR);	191	ctrl_outl(cr, MMUCR);
192		192
193	ctrl_barrier();	193	ctrl_barrier();
194	}	194	}
195	#else	195	#else
196	/*	196	/*
197	* MMU control handlers for processors lacking memory	197	* MMU control handlers for processors lacking memory
198	* management hardware.	198	* management hardware.
199	*/	199	*/
200	#define enable_mmu() do { BUG(); } while (0)	200	#define enable_mmu() do { BUG(); } while (0)
201	#define disable_mmu() do { BUG(); } while (0)	201	#define disable_mmu() do { BUG(); } while (0)
202	#endif	202	#endif
203		203
204	#endif /* __KERNEL__ */	204	#endif /* __KERNEL__ */
205	#endif /* __ASM_SH_MMU_CONTEXT_H */	205	#endif /* __ASM_SH_MMU_CONTEXT_H */
206		206

include/asm-sh/page.h

Diff comments View file @ 19f9a34

 #ifndef __ASM_SH_PAGE_H
 #define __ASM_SH_PAGE_H
 /*
  * Copyright (C) 1999  Niibe Yutaka
  */
 /*
    [ P0/U0 (virtual) ]		0x00000000     <------ User space
    [ P1 (fixed)   cached ]	0x80000000     <------ Kernel space
    [ P2 (fixed)  non-cachable]	0xA0000000     <------ Physical access
    [ P3 (virtual) cached]	0xC0000000     <------ vmalloced area
    [ P4 control   ]		0xE0000000
  */
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT	12
 #ifdef __ASSEMBLY__
 #define PAGE_SIZE	(1 << PAGE_SHIFT)
 #else
 #define PAGE_SIZE	(1UL << PAGE_SHIFT)
 #endif
 #define PAGE_MASK	(~(PAGE_SIZE-1))
 #define PTE_MASK	PAGE_MASK
 #if defined(CONFIG_HUGETLB_PAGE_SIZE_64K)
 #define HPAGE_SHIFT	16
 #elif defined(CONFIG_HUGETLB_PAGE_SIZE_1MB)
 #define HPAGE_SHIFT	20
 #endif
 #ifdef CONFIG_HUGETLB_PAGE
 #define HPAGE_SIZE		(1UL << HPAGE_SHIFT)
 #define HPAGE_MASK		(~(HPAGE_SIZE-1))
 #define HUGETLB_PAGE_ORDER	(HPAGE_SHIFT-PAGE_SHIFT)
 #endif
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 extern void (*clear_page)(void *to);
 extern void (*copy_page)(void *to, void *from);
 #ifdef CONFIG_MMU
 extern void clear_page_slow(void *to);
 extern void copy_page_slow(void *to, void *from);
 #else
 extern void clear_page_nommu(void *to);
 extern void copy_page_nommu(void *to, void *from);
 #endif
 #if defined(CONFIG_MMU) && (defined(CONFIG_CPU_SH4) || \
 	defined(CONFIG_SH7705_CACHE_32KB))
 struct page;
 extern void clear_user_page(void *to, unsigned long address, struct page *pg);
 extern void copy_user_page(void *to, void *from, unsigned long address, struct page *pg);
 extern void __clear_user_page(void *to, void *orig_to);
 extern void __copy_user_page(void *to, void *from, void *orig_to);
 #elif defined(CONFIG_CPU_SH2) || defined(CONFIG_CPU_SH3) || !defined(CONFIG_MMU)
 #define clear_user_page(page, vaddr, pg)	clear_page(page)
 #define copy_user_page(to, from, vaddr, pg)	copy_page(to, from)
 #endif
 /*
  * These are used to make use of C type-checking..
  */
 typedef struct { unsigned long pte; } pte_t;
 typedef struct { unsigned long pgd; } pgd_t;
 typedef struct { unsigned long pgprot; } pgprot_t;
 #define pte_val(x)	((x).pte)
 #define pgd_val(x)	((x).pgd)
 #define pgprot_val(x)	((x).pgprot)
 #define __pte(x) ((pte_t) { (x) } )
 #define __pgd(x) ((pgd_t) { (x) } )
 #define __pgprot(x)	((pgprot_t) { (x) } )
 #endif /* !__ASSEMBLY__ */
 /* to align the pointer to the (next) page boundary */
 #define PAGE_ALIGN(addr)	(((addr)+PAGE_SIZE-1)&PAGE_MASK)
 /*
  * IF YOU CHANGE THIS, PLEASE ALSO CHANGE
  *
  *	arch/sh/kernel/vmlinux.lds.S
  *
  * which has the same constant encoded..
  */
 #define __MEMORY_START		CONFIG_MEMORY_START
 #define __MEMORY_SIZE		CONFIG_MEMORY_SIZE
 #define PAGE_OFFSET		CONFIG_PAGE_OFFSET
 #define __pa(x)			((unsigned long)(x)-PAGE_OFFSET)
 #define __va(x)			((void *)((unsigned long)(x)+PAGE_OFFSET))
 #define MAP_NR(addr)		(((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT)
 #define phys_to_page(phys)	(mem_map + (((phys)-__MEMORY_START) >> PAGE_SHIFT))
 #define page_to_phys(page)	(((page - mem_map) << PAGE_SHIFT) + __MEMORY_START)
 /* PFN start number, because of __MEMORY_START */
 #define PFN_START		(__MEMORY_START >> PAGE_SHIFT)
 #define ARCH_PFN_OFFSET		(PFN_START)
 #define virt_to_page(kaddr)	pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)		(((pfn) - PFN_START) < max_mapnr)
 #define virt_addr_valid(kaddr)	pfn_valid(__pa(kaddr) >> PAGE_SHIFT)
 #define VM_DATA_DEFAULT_FLAGS	(VM_READ | VM_WRITE | VM_EXEC | \
 				 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
 #include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
+/* vDSO support */
+#ifdef CONFIG_VSYSCALL
+#define __HAVE_ARCH_GATE_AREA
+#endif
 #endif /* __KERNEL__ */
 #endif /* __ASM_SH_PAGE_H */

include/asm-sh/processor.h

Diff comments View file @ 19f9a34

 /*
  * include/asm-sh/processor.h
  *
  * Copyright (C) 1999, 2000  Niibe Yutaka
  * Copyright (C) 2002, 2003  Paul Mundt
  */
 #ifndef __ASM_SH_PROCESSOR_H
 #define __ASM_SH_PROCESSOR_H
 #ifdef __KERNEL__
 #include <linux/compiler.h>
 #include <asm/page.h>
 #include <asm/types.h>
 #include <asm/cache.h>
 #include <asm/ptrace.h>
 #include <asm/cpu-features.h>
 /*
  * Default implementation of macro that returns current
  * instruction pointer ("program counter").
  */
 #define current_text_addr() ({ void *pc; __asm__("mova	1f, %0\n1:":"=z" (pc)); pc; })
 /* Core Processor Version Register */
 #define CCN_PVR		0xff000030
 #define CCN_CVR		0xff000040
 #define CCN_PRR		0xff000044
 /*
  *  CPU type and hardware bug flags. Kept separately for each CPU.
  *
  *  Each one of these also needs a CONFIG_CPU_SUBTYPE_xxx entry
  *  in arch/sh/mm/Kconfig, as well as an entry in arch/sh/kernel/setup.c
  *  for parsing the subtype in get_cpu_subtype().
  */
 enum cpu_type {
 	/* SH-2 types */
 	CPU_SH7604,
 	/* SH-3 types */
 	CPU_SH7705, CPU_SH7706, CPU_SH7707,
 	CPU_SH7708, CPU_SH7708S, CPU_SH7708R,
 	CPU_SH7709, CPU_SH7709A, CPU_SH7710,
 	CPU_SH7729, CPU_SH7300,
 	/* SH-4 types */
 	CPU_SH7750, CPU_SH7750S, CPU_SH7750R, CPU_SH7751, CPU_SH7751R,
 	CPU_SH7760, CPU_ST40RA, CPU_ST40GX1, CPU_SH4_202, CPU_SH4_501,
 	CPU_SH73180, CPU_SH7343, CPU_SH7770, CPU_SH7780, CPU_SH7781,
 	/* Unknown subtype */
 	CPU_SH_NONE
 };
 struct sh_cpuinfo {
 	unsigned int type;
 	unsigned long loops_per_jiffy;
 	struct cache_info icache;	/* Primary I-cache */
 	struct cache_info dcache;	/* Primary D-cache */
 	struct cache_info scache;	/* Secondary cache */
 	unsigned long flags;
 } __attribute__ ((aligned(SMP_CACHE_BYTES)));
 extern struct sh_cpuinfo boot_cpu_data;
 #ifdef CONFIG_SMP
 extern struct sh_cpuinfo cpu_data[];
 #define current_cpu_data cpu_data[smp_processor_id()]
 #else
 #define cpu_data (&boot_cpu_data)
 #define current_cpu_data boot_cpu_data
 #endif
 /*
  * User space process size: 2GB.
  *
  * Since SH7709 and SH7750 have "area 7", we can't use 0x7c000000--0x7fffffff
  */
 #define TASK_SIZE	0x7c000000UL
 /* This decides where the kernel will search for a free chunk of vm
  * space during mmap's.
  */
 #define TASK_UNMAPPED_BASE	(TASK_SIZE / 3)
 /*
  * Bit of SR register
  *
  * FD-bit:
  *     When it's set, it means the processor doesn't have right to use FPU,
  *     and it results exception when the floating operation is executed.
  *
  * IMASK-bit:
  *     Interrupt level mask
  */
 #define SR_FD		0x00008000
 #define SR_DSP		0x00001000
 #define SR_IMASK	0x000000f0
 /*
  * FPU structure and data
  */
 struct sh_fpu_hard_struct {
 	unsigned long fp_regs[16];
 	unsigned long xfp_regs[16];
 	unsigned long fpscr;
 	unsigned long fpul;
 	long status; /* software status information */
 };
 /* Dummy fpu emulator  */
 struct sh_fpu_soft_struct {
 	unsigned long fp_regs[16];
 	unsigned long xfp_regs[16];
 	unsigned long fpscr;
 	unsigned long fpul;
 	unsigned char lookahead;
 	unsigned long entry_pc;
 };
 union sh_fpu_union {
 	struct sh_fpu_hard_struct hard;
 	struct sh_fpu_soft_struct soft;
 };
 struct thread_struct {
 	unsigned long sp;
 	unsigned long pc;
 	unsigned long trap_no, error_code;
 	unsigned long address;
 	/* Hardware debugging registers may come here */
 	unsigned long ubc_pc;
 	/* floating point info */
 	union sh_fpu_union fpu;
 };
 typedef struct {
 	unsigned long seg;
 } mm_segment_t;
 /* Count of active tasks with UBC settings */
 extern int ubc_usercnt;
 #define INIT_THREAD  {						\
 	sizeof(init_stack) + (long) &init_stack, /* sp */	\
 	0,					 /* pc */	\
 	0, 0,							\
 	0,							\
 	0,							\
 	{{{0,}},}				/* fpu state */	\
 }
 /*
  * Do necessary setup to start up a newly executed thread.
  */
 #define start_thread(regs, new_pc, new_sp)	 \
 	set_fs(USER_DS);			 \
 	regs->pr = 0;				 \
 	regs->sr = SR_FD;	/* User mode. */ \
 	regs->pc = new_pc;			 \
 	regs->regs[15] = new_sp
 /* Forward declaration, a strange C thing */
 struct task_struct;
 struct mm_struct;
 /* Free all resources held by a thread. */
 extern void release_thread(struct task_struct *);
 /* Prepare to copy thread state - unlazy all lazy status */
 #define prepare_to_copy(tsk)	do { } while (0)
 /*
  * create a kernel thread without removing it from tasklists
  */
 extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 /* Copy and release all segment info associated with a VM */
 #define copy_segments(p, mm)	do { } while(0)
 #define release_segments(mm)	do { } while(0)
 /*
  * FPU lazy state save handling.
  */
 static __inline__ void disable_fpu(void)
 {
 	unsigned long __dummy;
 	/* Set FD flag in SR */
 	__asm__ __volatile__("stc	sr, %0\n\t"
 			     "or	%1, %0\n\t"
 			     "ldc	%0, sr"
 			     : "=&r" (__dummy)
 			     : "r" (SR_FD));
 }
 static __inline__ void enable_fpu(void)
 {
 	unsigned long __dummy;
 	/* Clear out FD flag in SR */
 	__asm__ __volatile__("stc	sr, %0\n\t"
 			     "and	%1, %0\n\t"
 			     "ldc	%0, sr"
 			     : "=&r" (__dummy)
 			     : "r" (~SR_FD));
 }
 static __inline__ void release_fpu(struct pt_regs *regs)
 {
 	regs->sr |= SR_FD;
 }
 static __inline__ void grab_fpu(struct pt_regs *regs)
 {
 	regs->sr &= ~SR_FD;
 }
 #ifdef CONFIG_CPU_SH4
 extern void save_fpu(struct task_struct *__tsk, struct pt_regs *regs);
 #else
 #define save_fpu(tsk)	do { } while (0)
 #endif
 #define unlazy_fpu(tsk, regs) do {			\
 	if (test_tsk_thread_flag(tsk, TIF_USEDFPU)) {	\
 		save_fpu(tsk, regs);			\
 	}						\
 } while (0)
 #define clear_fpu(tsk, regs) do {				\
 	if (test_tsk_thread_flag(tsk, TIF_USEDFPU)) {		\
 		clear_tsk_thread_flag(tsk, TIF_USEDFPU);	\
 		release_fpu(regs);				\
 	}							\
 } while (0)
 /* Double presision, NANS as NANS, rounding to nearest, no exceptions */
 #define FPSCR_INIT  0x00080000
 #define	FPSCR_CAUSE_MASK	0x0001f000	/* Cause bits */
 #define	FPSCR_FLAG_MASK		0x0000007c	/* Flag bits */
 /*
  * Return saved PC of a blocked thread.
  */
 #define thread_saved_pc(tsk)	(tsk->thread.pc)
 extern unsigned long get_wchan(struct task_struct *p);
 #define KSTK_EIP(tsk)  ((tsk)->thread.pc)
 #define KSTK_ESP(tsk)  ((tsk)->thread.sp)
 #define cpu_sleep()	__asm__ __volatile__ ("sleep" : : : "memory")
 #define cpu_relax()	barrier()
 #if defined(CONFIG_CPU_SH2A) || defined(CONFIG_CPU_SH3) || \
     defined(CONFIG_CPU_SH4)
 #define PREFETCH_STRIDE		L1_CACHE_BYTES
 #define ARCH_HAS_PREFETCH
 #define ARCH_HAS_PREFETCHW
 static inline void prefetch(void *x)
 {
 	__asm__ __volatile__ ("pref @%0\n\t" : : "r" (x) : "memory");
 }
 #define prefetchw(x)	prefetch(x)
 #endif
+#ifdef CONFIG_VSYSCALL
+extern int vsyscall_init(void);
+#else
+#define vsyscall_init() do { } while (0)
+#endif
 #endif /* __KERNEL__ */
 #endif /* __ASM_SH_PROCESSOR_H */