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

Commit 3b74d18e54e20fc1d398eb391bea5b9aed22aca5

Authored by akpm@linux-foundation.org 2007-07-25 10:44:55 +0800

Committed by Tony Luck 2007-07-26 03:56:39 +0800

Exists in master and in 7 other branches

[IA64] rename partial_page

Jens has added a partial_page thing in splice whcih conflicts with the ia64
one.  Rename ia64 out of the way.  (ia64 chose poorly).

Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Tony Luck <tony.luck@intel.com>

Showing 6 changed files with 62 additions and 59 deletions Inline Diff

arch/ia64/ia32/ia32_support.c
arch/ia64/ia32/ia32priv.h
arch/ia64/ia32/sys_ia32.c
arch/ia64/kernel/process.c
include/asm-ia64/ia32.h
include/asm-ia64/processor.h

arch/ia64/ia32/ia32_support.c

Diff comments View file @ 3b74d18

1	/*	1	/*
2	* IA32 helper functions	2	* IA32 helper functions
3	*	3	*
4	* Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>	4	* Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
5	* Copyright (C) 2000 Asit K. Mallick <asit.k.mallick@intel.com>	5	* Copyright (C) 2000 Asit K. Mallick <asit.k.mallick@intel.com>
6	* Copyright (C) 2001-2002 Hewlett-Packard Co	6	* Copyright (C) 2001-2002 Hewlett-Packard Co
7	* David Mosberger-Tang <davidm@hpl.hp.com>	7	* David Mosberger-Tang <davidm@hpl.hp.com>
8	*	8	*
9	* 06/16/00 A. Mallick added csd/ssd/tssd for ia32 thread context	9	* 06/16/00 A. Mallick added csd/ssd/tssd for ia32 thread context
10	* 02/19/01 D. Mosberger dropped tssd; it's not needed	10	* 02/19/01 D. Mosberger dropped tssd; it's not needed
11	* 09/14/01 D. Mosberger fixed memory management for gdt/tss page	11	* 09/14/01 D. Mosberger fixed memory management for gdt/tss page
12	* 09/29/01 D. Mosberger added ia32_load_segment_descriptors()	12	* 09/29/01 D. Mosberger added ia32_load_segment_descriptors()
13	*/	13	*/
14		14
15	#include <linux/kernel.h>	15	#include <linux/kernel.h>
16	#include <linux/init.h>	16	#include <linux/init.h>
17	#include <linux/mm.h>	17	#include <linux/mm.h>
18	#include <linux/personality.h>	18	#include <linux/personality.h>
19	#include <linux/sched.h>	19	#include <linux/sched.h>
20		20
21	#include <asm/intrinsics.h>	21	#include <asm/intrinsics.h>
22	#include <asm/page.h>	22	#include <asm/page.h>
23	#include <asm/pgtable.h>	23	#include <asm/pgtable.h>
24	#include <asm/system.h>	24	#include <asm/system.h>
25	#include <asm/processor.h>	25	#include <asm/processor.h>
26	#include <asm/uaccess.h>	26	#include <asm/uaccess.h>
27		27
28	#include "ia32priv.h"	28	#include "ia32priv.h"
29		29
30	extern void die_if_kernel (char str, struct pt_regs regs, long err);	30	extern void die_if_kernel (char str, struct pt_regs regs, long err);
31		31
32	struct exec_domain ia32_exec_domain;	32	struct exec_domain ia32_exec_domain;
33	struct page *ia32_shared_page[NR_CPUS];	33	struct page *ia32_shared_page[NR_CPUS];
34	unsigned long *ia32_boot_gdt;	34	unsigned long *ia32_boot_gdt;
35	unsigned long *cpu_gdt_table[NR_CPUS];	35	unsigned long *cpu_gdt_table[NR_CPUS];
36	struct page *ia32_gate_page;	36	struct page *ia32_gate_page;
37		37
38	static unsigned long	38	static unsigned long
39	load_desc (u16 selector)	39	load_desc (u16 selector)
40	{	40	{
41	unsigned long *table, limit, index;	41	unsigned long *table, limit, index;
42		42
43	if (!selector)	43	if (!selector)
44	return 0;	44	return 0;
45	if (selector & IA32_SEGSEL_TI) {	45	if (selector & IA32_SEGSEL_TI) {
46	table = (unsigned long *) IA32_LDT_OFFSET;	46	table = (unsigned long *) IA32_LDT_OFFSET;
47	limit = IA32_LDT_ENTRIES;	47	limit = IA32_LDT_ENTRIES;
48	} else {	48	} else {
49	table = cpu_gdt_table[smp_processor_id()];	49	table = cpu_gdt_table[smp_processor_id()];
50	limit = IA32_PAGE_SIZE / sizeof(ia32_boot_gdt[0]);	50	limit = IA32_PAGE_SIZE / sizeof(ia32_boot_gdt[0]);
51	}	51	}
52	index = selector >> IA32_SEGSEL_INDEX_SHIFT;	52	index = selector >> IA32_SEGSEL_INDEX_SHIFT;
53	if (index >= limit)	53	if (index >= limit)
54	return 0;	54	return 0;
55	return IA32_SEG_UNSCRAMBLE(table[index]);	55	return IA32_SEG_UNSCRAMBLE(table[index]);
56	}	56	}
57		57
58	void	58	void
59	ia32_load_segment_descriptors (struct task_struct *task)	59	ia32_load_segment_descriptors (struct task_struct *task)
60	{	60	{
61	struct pt_regs *regs = task_pt_regs(task);	61	struct pt_regs *regs = task_pt_regs(task);
62		62
63	/* Setup the segment descriptors */	63	/* Setup the segment descriptors */
64	regs->r24 = load_desc(regs->r16 >> 16); /* ESD */	64	regs->r24 = load_desc(regs->r16 >> 16); /* ESD */
65	regs->r27 = load_desc(regs->r16 >> 0); /* DSD */	65	regs->r27 = load_desc(regs->r16 >> 0); /* DSD */
66	regs->r28 = load_desc(regs->r16 >> 32); /* FSD */	66	regs->r28 = load_desc(regs->r16 >> 32); /* FSD */
67	regs->r29 = load_desc(regs->r16 >> 48); /* GSD */	67	regs->r29 = load_desc(regs->r16 >> 48); /* GSD */
68	regs->ar_csd = load_desc(regs->r17 >> 0); /* CSD */	68	regs->ar_csd = load_desc(regs->r17 >> 0); /* CSD */
69	regs->ar_ssd = load_desc(regs->r17 >> 16); /* SSD */	69	regs->ar_ssd = load_desc(regs->r17 >> 16); /* SSD */
70	}	70	}
71		71
72	int	72	int
73	ia32_clone_tls (struct task_struct child, struct pt_regs childregs)	73	ia32_clone_tls (struct task_struct child, struct pt_regs childregs)
74	{	74	{
75	struct desc_struct *desc;	75	struct desc_struct *desc;
76	struct ia32_user_desc info;	76	struct ia32_user_desc info;
77	int idx;	77	int idx;
78		78
79	if (copy_from_user(&info, (void __user *)(childregs->r14 & 0xffffffff), sizeof(info)))	79	if (copy_from_user(&info, (void __user *)(childregs->r14 & 0xffffffff), sizeof(info)))
80	return -EFAULT;	80	return -EFAULT;
81	if (LDT_empty(&info))	81	if (LDT_empty(&info))
82	return -EINVAL;	82	return -EINVAL;
83		83
84	idx = info.entry_number;	84	idx = info.entry_number;
85	if (idx < GDT_ENTRY_TLS_MIN \|\| idx > GDT_ENTRY_TLS_MAX)	85	if (idx < GDT_ENTRY_TLS_MIN \|\| idx > GDT_ENTRY_TLS_MAX)
86	return -EINVAL;	86	return -EINVAL;
87		87
88	desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;	88	desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
89	desc->a = LDT_entry_a(&info);	89	desc->a = LDT_entry_a(&info);
90	desc->b = LDT_entry_b(&info);	90	desc->b = LDT_entry_b(&info);
91		91
92	/* XXX: can this be done in a cleaner way ? */	92	/* XXX: can this be done in a cleaner way ? */
93	load_TLS(&child->thread, smp_processor_id());	93	load_TLS(&child->thread, smp_processor_id());
94	ia32_load_segment_descriptors(child);	94	ia32_load_segment_descriptors(child);
95	load_TLS(&current->thread, smp_processor_id());	95	load_TLS(&current->thread, smp_processor_id());
96		96
97	return 0;	97	return 0;
98	}	98	}
99		99
100	void	100	void
101	ia32_save_state (struct task_struct *t)	101	ia32_save_state (struct task_struct *t)
102	{	102	{
103	t->thread.eflag = ia64_getreg(_IA64_REG_AR_EFLAG);	103	t->thread.eflag = ia64_getreg(_IA64_REG_AR_EFLAG);
104	t->thread.fsr = ia64_getreg(_IA64_REG_AR_FSR);	104	t->thread.fsr = ia64_getreg(_IA64_REG_AR_FSR);
105	t->thread.fcr = ia64_getreg(_IA64_REG_AR_FCR);	105	t->thread.fcr = ia64_getreg(_IA64_REG_AR_FCR);
106	t->thread.fir = ia64_getreg(_IA64_REG_AR_FIR);	106	t->thread.fir = ia64_getreg(_IA64_REG_AR_FIR);
107	t->thread.fdr = ia64_getreg(_IA64_REG_AR_FDR);	107	t->thread.fdr = ia64_getreg(_IA64_REG_AR_FDR);
108	ia64_set_kr(IA64_KR_IO_BASE, t->thread.old_iob);	108	ia64_set_kr(IA64_KR_IO_BASE, t->thread.old_iob);
109	ia64_set_kr(IA64_KR_TSSD, t->thread.old_k1);	109	ia64_set_kr(IA64_KR_TSSD, t->thread.old_k1);
110	}	110	}
111		111
112	void	112	void
113	ia32_load_state (struct task_struct *t)	113	ia32_load_state (struct task_struct *t)
114	{	114	{
115	unsigned long eflag, fsr, fcr, fir, fdr, tssd;	115	unsigned long eflag, fsr, fcr, fir, fdr, tssd;
116	struct pt_regs *regs = task_pt_regs(t);	116	struct pt_regs *regs = task_pt_regs(t);
117		117
118	eflag = t->thread.eflag;	118	eflag = t->thread.eflag;
119	fsr = t->thread.fsr;	119	fsr = t->thread.fsr;
120	fcr = t->thread.fcr;	120	fcr = t->thread.fcr;
121	fir = t->thread.fir;	121	fir = t->thread.fir;
122	fdr = t->thread.fdr;	122	fdr = t->thread.fdr;
123	tssd = load_desc(_TSS); /* TSSD */	123	tssd = load_desc(_TSS); /* TSSD */
124		124
125	ia64_setreg(_IA64_REG_AR_EFLAG, eflag);	125	ia64_setreg(_IA64_REG_AR_EFLAG, eflag);
126	ia64_setreg(_IA64_REG_AR_FSR, fsr);	126	ia64_setreg(_IA64_REG_AR_FSR, fsr);
127	ia64_setreg(_IA64_REG_AR_FCR, fcr);	127	ia64_setreg(_IA64_REG_AR_FCR, fcr);
128	ia64_setreg(_IA64_REG_AR_FIR, fir);	128	ia64_setreg(_IA64_REG_AR_FIR, fir);
129	ia64_setreg(_IA64_REG_AR_FDR, fdr);	129	ia64_setreg(_IA64_REG_AR_FDR, fdr);
130	current->thread.old_iob = ia64_get_kr(IA64_KR_IO_BASE);	130	current->thread.old_iob = ia64_get_kr(IA64_KR_IO_BASE);
131	current->thread.old_k1 = ia64_get_kr(IA64_KR_TSSD);	131	current->thread.old_k1 = ia64_get_kr(IA64_KR_TSSD);
132	ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);	132	ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
133	ia64_set_kr(IA64_KR_TSSD, tssd);	133	ia64_set_kr(IA64_KR_TSSD, tssd);
134		134
135	regs->r17 = (_TSS << 48) \| (_LDT << 32) \| (__u32) regs->r17;	135	regs->r17 = (_TSS << 48) \| (_LDT << 32) \| (__u32) regs->r17;
136	regs->r30 = load_desc(_LDT); /* LDTD */	136	regs->r30 = load_desc(_LDT); /* LDTD */
137	load_TLS(&t->thread, smp_processor_id());	137	load_TLS(&t->thread, smp_processor_id());
138	}	138	}
139		139
140	/*	140	/*
141	* Setup IA32 GDT and TSS	141	* Setup IA32 GDT and TSS
142	*/	142	*/
143	void	143	void
144	ia32_gdt_init (void)	144	ia32_gdt_init (void)
145	{	145	{
146	int cpu = smp_processor_id();	146	int cpu = smp_processor_id();
147		147
148	ia32_shared_page[cpu] = alloc_page(GFP_KERNEL);	148	ia32_shared_page[cpu] = alloc_page(GFP_KERNEL);
149	if (!ia32_shared_page[cpu])	149	if (!ia32_shared_page[cpu])
150	panic("failed to allocate ia32_shared_page[%d]\n", cpu);	150	panic("failed to allocate ia32_shared_page[%d]\n", cpu);
151		151
152	cpu_gdt_table[cpu] = page_address(ia32_shared_page[cpu]);	152	cpu_gdt_table[cpu] = page_address(ia32_shared_page[cpu]);
153		153
154	/* Copy from the boot cpu's GDT */	154	/* Copy from the boot cpu's GDT */
155	memcpy(cpu_gdt_table[cpu], ia32_boot_gdt, PAGE_SIZE);	155	memcpy(cpu_gdt_table[cpu], ia32_boot_gdt, PAGE_SIZE);
156	}	156	}
157		157
158		158
159	/*	159	/*
160	* Setup IA32 GDT and TSS	160	* Setup IA32 GDT and TSS
161	*/	161	*/
162	static void	162	static void
163	ia32_boot_gdt_init (void)	163	ia32_boot_gdt_init (void)
164	{	164	{
165	unsigned long ldt_size;	165	unsigned long ldt_size;
166		166
167	ia32_shared_page[0] = alloc_page(GFP_KERNEL);	167	ia32_shared_page[0] = alloc_page(GFP_KERNEL);
168	if (!ia32_shared_page[0])	168	if (!ia32_shared_page[0])
169	panic("failed to allocate ia32_shared_page[0]\n");	169	panic("failed to allocate ia32_shared_page[0]\n");
170		170
171	ia32_boot_gdt = page_address(ia32_shared_page[0]);	171	ia32_boot_gdt = page_address(ia32_shared_page[0]);
172	cpu_gdt_table[0] = ia32_boot_gdt;	172	cpu_gdt_table[0] = ia32_boot_gdt;
173		173
174	/* CS descriptor in IA-32 (scrambled) format */	174	/* CS descriptor in IA-32 (scrambled) format */
175	ia32_boot_gdt[__USER_CS >> 3]	175	ia32_boot_gdt[__USER_CS >> 3]
176	= IA32_SEG_DESCRIPTOR(0, (IA32_GATE_END-1) >> IA32_PAGE_SHIFT,	176	= IA32_SEG_DESCRIPTOR(0, (IA32_GATE_END-1) >> IA32_PAGE_SHIFT,
177	0xb, 1, 3, 1, 1, 1, 1);	177	0xb, 1, 3, 1, 1, 1, 1);
178		178
179	/* DS descriptor in IA-32 (scrambled) format */	179	/* DS descriptor in IA-32 (scrambled) format */
180	ia32_boot_gdt[__USER_DS >> 3]	180	ia32_boot_gdt[__USER_DS >> 3]
181	= IA32_SEG_DESCRIPTOR(0, (IA32_GATE_END-1) >> IA32_PAGE_SHIFT,	181	= IA32_SEG_DESCRIPTOR(0, (IA32_GATE_END-1) >> IA32_PAGE_SHIFT,
182	0x3, 1, 3, 1, 1, 1, 1);	182	0x3, 1, 3, 1, 1, 1, 1);
183		183
184	ldt_size = PAGE_ALIGN(IA32_LDT_ENTRIES*IA32_LDT_ENTRY_SIZE);	184	ldt_size = PAGE_ALIGN(IA32_LDT_ENTRIES*IA32_LDT_ENTRY_SIZE);
185	ia32_boot_gdt[TSS_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_TSS_OFFSET, 235,	185	ia32_boot_gdt[TSS_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_TSS_OFFSET, 235,
186	0xb, 0, 3, 1, 1, 1, 0);	186	0xb, 0, 3, 1, 1, 1, 0);
187	ia32_boot_gdt[LDT_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_LDT_OFFSET, ldt_size - 1,	187	ia32_boot_gdt[LDT_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_LDT_OFFSET, ldt_size - 1,
188	0x2, 0, 3, 1, 1, 1, 0);	188	0x2, 0, 3, 1, 1, 1, 0);
189	}	189	}
190		190
191	static void	191	static void
192	ia32_gate_page_init(void)	192	ia32_gate_page_init(void)
193	{	193	{
194	unsigned long *sr;	194	unsigned long *sr;
195		195
196	ia32_gate_page = alloc_page(GFP_KERNEL);	196	ia32_gate_page = alloc_page(GFP_KERNEL);
197	sr = page_address(ia32_gate_page);	197	sr = page_address(ia32_gate_page);
198	/* This is popl %eax ; movl $,%eax ; int $0x80 */	198	/* This is popl %eax ; movl $,%eax ; int $0x80 */
199	*sr++ = 0xb858 \| (__IA32_NR_sigreturn << 16) \| (0x80cdUL << 48);	199	*sr++ = 0xb858 \| (__IA32_NR_sigreturn << 16) \| (0x80cdUL << 48);
200		200
201	/* This is movl $,%eax ; int $0x80 */	201	/* This is movl $,%eax ; int $0x80 */
202	*sr = 0xb8 \| (__IA32_NR_rt_sigreturn << 8) \| (0x80cdUL << 40);	202	*sr = 0xb8 \| (__IA32_NR_rt_sigreturn << 8) \| (0x80cdUL << 40);
203	}	203	}
204		204
205	void	205	void
206	ia32_mem_init(void)	206	ia32_mem_init(void)
207	{	207	{
208	ia32_boot_gdt_init();	208	ia32_boot_gdt_init();
209	ia32_gate_page_init();	209	ia32_gate_page_init();
210	}	210	}
211		211
212	/*	212	/*
213	* Handle bad IA32 interrupt via syscall	213	* Handle bad IA32 interrupt via syscall
214	*/	214	*/
215	void	215	void
216	ia32_bad_interrupt (unsigned long int_num, struct pt_regs *regs)	216	ia32_bad_interrupt (unsigned long int_num, struct pt_regs *regs)
217	{	217	{
218	siginfo_t siginfo;	218	siginfo_t siginfo;
219		219
220	die_if_kernel("Bad IA-32 interrupt", regs, int_num);	220	die_if_kernel("Bad IA-32 interrupt", regs, int_num);
221		221
222	siginfo.si_signo = SIGTRAP;	222	siginfo.si_signo = SIGTRAP;
223	siginfo.si_errno = int_num; /* XXX is it OK to abuse si_errno like this? */	223	siginfo.si_errno = int_num; /* XXX is it OK to abuse si_errno like this? */
224	siginfo.si_flags = 0;	224	siginfo.si_flags = 0;
225	siginfo.si_isr = 0;	225	siginfo.si_isr = 0;
226	siginfo.si_addr = NULL;	226	siginfo.si_addr = NULL;
227	siginfo.si_imm = 0;	227	siginfo.si_imm = 0;
228	siginfo.si_code = TRAP_BRKPT;	228	siginfo.si_code = TRAP_BRKPT;
229	force_sig_info(SIGTRAP, &siginfo, current);	229	force_sig_info(SIGTRAP, &siginfo, current);
230	}	230	}
231		231
232	void	232	void
233	ia32_cpu_init (void)	233	ia32_cpu_init (void)
234	{	234	{
235	/* initialize global ia32 state - CR0 and CR4 */	235	/* initialize global ia32 state - CR0 and CR4 */
236	ia64_setreg(_IA64_REG_AR_CFLAG, (((ulong) IA32_CR4 << 32) \| IA32_CR0));	236	ia64_setreg(_IA64_REG_AR_CFLAG, (((ulong) IA32_CR4 << 32) \| IA32_CR0));
237	}	237	}
238		238
239	static int __init	239	static int __init
240	ia32_init (void)	240	ia32_init (void)
241	{	241	{
242	ia32_exec_domain.name = "Linux/x86";	242	ia32_exec_domain.name = "Linux/x86";
243	ia32_exec_domain.handler = NULL;	243	ia32_exec_domain.handler = NULL;
244	ia32_exec_domain.pers_low = PER_LINUX32;	244	ia32_exec_domain.pers_low = PER_LINUX32;
245	ia32_exec_domain.pers_high = PER_LINUX32;	245	ia32_exec_domain.pers_high = PER_LINUX32;
246	ia32_exec_domain.signal_map = default_exec_domain.signal_map;	246	ia32_exec_domain.signal_map = default_exec_domain.signal_map;
247	ia32_exec_domain.signal_invmap = default_exec_domain.signal_invmap;	247	ia32_exec_domain.signal_invmap = default_exec_domain.signal_invmap;
248	register_exec_domain(&ia32_exec_domain);	248	register_exec_domain(&ia32_exec_domain);
249		249
250	#if PAGE_SHIFT > IA32_PAGE_SHIFT	250	#if PAGE_SHIFT > IA32_PAGE_SHIFT
251	{	251	{
252	extern struct kmem_cache *partial_page_cachep;	252	extern struct kmem_cache *ia64_partial_page_cachep;
253		253
254	partial_page_cachep = kmem_cache_create("partial_page_cache",	254	ia64_partial_page_cachep = kmem_cache_create("ia64_partial_page_cache",
255	sizeof(struct partial_page),	255	sizeof(struct ia64_partial_page),
256	0, SLAB_PANIC, NULL);	256	0, SLAB_PANIC, NULL);
257	}	257	}
258	#endif	258	#endif
259	return 0;	259	return 0;
260	}	260	}
261		261
262	__initcall(ia32_init);	262	__initcall(ia32_init);
263		263

arch/ia64/ia32/ia32priv.h

Diff comments View file @ 3b74d18

1	#ifndef _ASM_IA64_IA32_PRIV_H	1	#ifndef _ASM_IA64_IA32_PRIV_H
2	#define _ASM_IA64_IA32_PRIV_H	2	#define _ASM_IA64_IA32_PRIV_H
3		3
4		4
5	#include <asm/ia32.h>	5	#include <asm/ia32.h>
6		6
7	#ifdef CONFIG_IA32_SUPPORT	7	#ifdef CONFIG_IA32_SUPPORT
8		8
9	#include <linux/binfmts.h>	9	#include <linux/binfmts.h>
10	#include <linux/compat.h>	10	#include <linux/compat.h>
11	#include <linux/rbtree.h>	11	#include <linux/rbtree.h>
12		12
13	#include <asm/processor.h>	13	#include <asm/processor.h>
14		14
15	/*	15	/*
16	* 32 bit structures for IA32 support.	16	* 32 bit structures for IA32 support.
17	*/	17	*/
18		18
19	#define IA32_PAGE_SIZE (1UL << IA32_PAGE_SHIFT)	19	#define IA32_PAGE_SIZE (1UL << IA32_PAGE_SHIFT)
20	#define IA32_PAGE_MASK (~(IA32_PAGE_SIZE - 1))	20	#define IA32_PAGE_MASK (~(IA32_PAGE_SIZE - 1))
21	#define IA32_PAGE_ALIGN(addr) (((addr) + IA32_PAGE_SIZE - 1) & IA32_PAGE_MASK)	21	#define IA32_PAGE_ALIGN(addr) (((addr) + IA32_PAGE_SIZE - 1) & IA32_PAGE_MASK)
22	#define IA32_CLOCKS_PER_SEC 100 /* Cast in stone for IA32 Linux */	22	#define IA32_CLOCKS_PER_SEC 100 /* Cast in stone for IA32 Linux */
23		23
24	/*	24	/*
25	* partially mapped pages provide precise accounting of which 4k sub pages	25	* partially mapped pages provide precise accounting of which 4k sub pages
26	* are mapped and which ones are not, thereby improving IA-32 compatibility.	26	* are mapped and which ones are not, thereby improving IA-32 compatibility.
27	*/	27	*/
28	struct partial_page {	28	struct ia64_partial_page {
29	struct partial_page next; / linked list, sorted by address */	29	struct ia64_partial_page next; / linked list, sorted by address */
30	struct rb_node pp_rb;	30	struct rb_node pp_rb;
31	/* 64K is the largest "normal" page supported by ia64 ABI. So 4K*64	31	/* 64K is the largest "normal" page supported by ia64 ABI. So 4K*64
32	* should suffice.*/	32	* should suffice.*/
33	unsigned long bitmap;	33	unsigned long bitmap;
34	unsigned int base;	34	unsigned int base;
35	};	35	};
36		36
37	struct partial_page_list {	37	struct ia64_partial_page_list {
38	struct partial_page pp_head; / list head, points to the lowest	38	struct ia64_partial_page pp_head; / list head, points to the lowest
39	* addressed partial page */	39	* addressed partial page */
40	struct rb_root ppl_rb;	40	struct rb_root ppl_rb;
41	struct partial_page pp_hint; / pp_hint->next is the last	41	struct ia64_partial_page pp_hint; / pp_hint->next is the last
42	* accessed partial page */	42	* accessed partial page */
43	atomic_t pp_count; /* reference count */	43	atomic_t pp_count; /* reference count */
44	};	44	};
45		45
46	#if PAGE_SHIFT > IA32_PAGE_SHIFT	46	#if PAGE_SHIFT > IA32_PAGE_SHIFT
47	struct partial_page_list* ia32_init_pp_list (void);	47	struct ia64_partial_page_list* ia32_init_pp_list (void);
48	#else	48	#else
49	# define ia32_init_pp_list() 0	49	# define ia32_init_pp_list() 0
50	#endif	50	#endif
51		51
52	/* sigcontext.h */	52	/* sigcontext.h */
53	/*	53	/*
54	* As documented in the iBCS2 standard..	54	* As documented in the iBCS2 standard..
55	*	55	*
56	* The first part of "struct _fpstate" is just the	56	* The first part of "struct _fpstate" is just the
57	* normal i387 hardware setup, the extra "status"	57	* normal i387 hardware setup, the extra "status"
58	* word is used to save the coprocessor status word	58	* word is used to save the coprocessor status word
59	* before entering the handler.	59	* before entering the handler.
60	*/	60	*/
61	struct _fpreg_ia32 {	61	struct _fpreg_ia32 {
62	unsigned short significand[4];	62	unsigned short significand[4];
63	unsigned short exponent;	63	unsigned short exponent;
64	};	64	};
65		65
66	struct _fpxreg_ia32 {	66	struct _fpxreg_ia32 {
67	unsigned short significand[4];	67	unsigned short significand[4];
68	unsigned short exponent;	68	unsigned short exponent;
69	unsigned short padding[3];	69	unsigned short padding[3];
70	};	70	};
71		71
72	struct _xmmreg_ia32 {	72	struct _xmmreg_ia32 {
73	unsigned int element[4];	73	unsigned int element[4];
74	};	74	};
75		75
76		76
77	struct _fpstate_ia32 {	77	struct _fpstate_ia32 {
78	unsigned int cw,	78	unsigned int cw,
79	sw,	79	sw,
80	tag,	80	tag,
81	ipoff,	81	ipoff,
82	cssel,	82	cssel,
83	dataoff,	83	dataoff,
84	datasel;	84	datasel;
85	struct _fpreg_ia32 _st[8];	85	struct _fpreg_ia32 _st[8];
86	unsigned short status;	86	unsigned short status;
87	unsigned short magic; /* 0xffff = regular FPU data only */	87	unsigned short magic; /* 0xffff = regular FPU data only */
88		88
89	/* FXSR FPU environment */	89	/* FXSR FPU environment */
90	unsigned int _fxsr_env[6]; /* FXSR FPU env is ignored */	90	unsigned int _fxsr_env[6]; /* FXSR FPU env is ignored */
91	unsigned int mxcsr;	91	unsigned int mxcsr;
92	unsigned int reserved;	92	unsigned int reserved;
93	struct _fpxreg_ia32 _fxsr_st[8]; /* FXSR FPU reg data is ignored */	93	struct _fpxreg_ia32 _fxsr_st[8]; /* FXSR FPU reg data is ignored */
94	struct _xmmreg_ia32 _xmm[8];	94	struct _xmmreg_ia32 _xmm[8];
95	unsigned int padding[56];	95	unsigned int padding[56];
96	};	96	};
97		97
98	struct sigcontext_ia32 {	98	struct sigcontext_ia32 {
99	unsigned short gs, __gsh;	99	unsigned short gs, __gsh;
100	unsigned short fs, __fsh;	100	unsigned short fs, __fsh;
101	unsigned short es, __esh;	101	unsigned short es, __esh;
102	unsigned short ds, __dsh;	102	unsigned short ds, __dsh;
103	unsigned int edi;	103	unsigned int edi;
104	unsigned int esi;	104	unsigned int esi;
105	unsigned int ebp;	105	unsigned int ebp;
106	unsigned int esp;	106	unsigned int esp;
107	unsigned int ebx;	107	unsigned int ebx;
108	unsigned int edx;	108	unsigned int edx;
109	unsigned int ecx;	109	unsigned int ecx;
110	unsigned int eax;	110	unsigned int eax;
111	unsigned int trapno;	111	unsigned int trapno;
112	unsigned int err;	112	unsigned int err;
113	unsigned int eip;	113	unsigned int eip;
114	unsigned short cs, __csh;	114	unsigned short cs, __csh;
115	unsigned int eflags;	115	unsigned int eflags;
116	unsigned int esp_at_signal;	116	unsigned int esp_at_signal;
117	unsigned short ss, __ssh;	117	unsigned short ss, __ssh;
118	unsigned int fpstate; /* really (struct _fpstate_ia32 ) /	118	unsigned int fpstate; /* really (struct _fpstate_ia32 ) /
119	unsigned int oldmask;	119	unsigned int oldmask;
120	unsigned int cr2;	120	unsigned int cr2;
121	};	121	};
122		122
123	/* user.h */	123	/* user.h */
124	/*	124	/*
125	* IA32 (Pentium III/4) FXSR, SSE support	125	* IA32 (Pentium III/4) FXSR, SSE support
126	*	126	*
127	* Provide support for the GDB 5.0+ PTRACE_{GET\|SET}FPXREGS requests for	127	* Provide support for the GDB 5.0+ PTRACE_{GET\|SET}FPXREGS requests for
128	* interacting with the FXSR-format floating point environment. Floating	128	* interacting with the FXSR-format floating point environment. Floating
129	* point data can be accessed in the regular format in the usual manner,	129	* point data can be accessed in the regular format in the usual manner,
130	* and both the standard and SIMD floating point data can be accessed via	130	* and both the standard and SIMD floating point data can be accessed via
131	* the new ptrace requests. In either case, changes to the FPU environment	131	* the new ptrace requests. In either case, changes to the FPU environment
132	* will be reflected in the task's state as expected.	132	* will be reflected in the task's state as expected.
133	*/	133	*/
134	struct ia32_user_i387_struct {	134	struct ia32_user_i387_struct {
135	int cwd;	135	int cwd;
136	int swd;	136	int swd;
137	int twd;	137	int twd;
138	int fip;	138	int fip;
139	int fcs;	139	int fcs;
140	int foo;	140	int foo;
141	int fos;	141	int fos;
142	/* 810 bytes for each FP-reg = 80 bytes /	142	/* 810 bytes for each FP-reg = 80 bytes /
143	struct _fpreg_ia32 st_space[8];	143	struct _fpreg_ia32 st_space[8];
144	};	144	};
145		145
146	struct ia32_user_fxsr_struct {	146	struct ia32_user_fxsr_struct {
147	unsigned short cwd;	147	unsigned short cwd;
148	unsigned short swd;	148	unsigned short swd;
149	unsigned short twd;	149	unsigned short twd;
150	unsigned short fop;	150	unsigned short fop;
151	int fip;	151	int fip;
152	int fcs;	152	int fcs;
153	int foo;	153	int foo;
154	int fos;	154	int fos;
155	int mxcsr;	155	int mxcsr;
156	int reserved;	156	int reserved;
157	int st_space[32]; /* 816 bytes for each FP-reg = 128 bytes /	157	int st_space[32]; /* 816 bytes for each FP-reg = 128 bytes /
158	int xmm_space[32]; /* 816 bytes for each XMM-reg = 128 bytes /	158	int xmm_space[32]; /* 816 bytes for each XMM-reg = 128 bytes /
159	int padding[56];	159	int padding[56];
160	};	160	};
161		161
162	/* signal.h */	162	/* signal.h */
163	#define IA32_SET_SA_HANDLER(ka,handler,restorer) \	163	#define IA32_SET_SA_HANDLER(ka,handler,restorer) \
164	((ka)->sa.sa_handler = (__sighandler_t) \	164	((ka)->sa.sa_handler = (__sighandler_t) \
165	(((unsigned long)(restorer) << 32) \	165	(((unsigned long)(restorer) << 32) \
166	\| ((handler) & 0xffffffff)))	166	\| ((handler) & 0xffffffff)))
167	#define IA32_SA_HANDLER(ka) ((unsigned long) (ka)->sa.sa_handler & 0xffffffff)	167	#define IA32_SA_HANDLER(ka) ((unsigned long) (ka)->sa.sa_handler & 0xffffffff)
168	#define IA32_SA_RESTORER(ka) ((unsigned long) (ka)->sa.sa_handler >> 32)	168	#define IA32_SA_RESTORER(ka) ((unsigned long) (ka)->sa.sa_handler >> 32)
169		169
170	#define __IA32_NR_sigreturn 119	170	#define __IA32_NR_sigreturn 119
171	#define __IA32_NR_rt_sigreturn 173	171	#define __IA32_NR_rt_sigreturn 173
172		172
173	struct sigaction32 {	173	struct sigaction32 {
174	unsigned int sa_handler; /* Really a pointer, but need to deal with 32 bits */	174	unsigned int sa_handler; /* Really a pointer, but need to deal with 32 bits */
175	unsigned int sa_flags;	175	unsigned int sa_flags;
176	unsigned int sa_restorer; /* Another 32 bit pointer */	176	unsigned int sa_restorer; /* Another 32 bit pointer */
177	compat_sigset_t sa_mask; /* A 32 bit mask */	177	compat_sigset_t sa_mask; /* A 32 bit mask */
178	};	178	};
179		179
180	struct old_sigaction32 {	180	struct old_sigaction32 {
181	unsigned int sa_handler; /* Really a pointer, but need to deal	181	unsigned int sa_handler; /* Really a pointer, but need to deal
182	with 32 bits */	182	with 32 bits */
183	compat_old_sigset_t sa_mask; /* A 32 bit mask */	183	compat_old_sigset_t sa_mask; /* A 32 bit mask */
184	unsigned int sa_flags;	184	unsigned int sa_flags;
185	unsigned int sa_restorer; /* Another 32 bit pointer */	185	unsigned int sa_restorer; /* Another 32 bit pointer */
186	};	186	};
187		187
188	typedef struct sigaltstack_ia32 {	188	typedef struct sigaltstack_ia32 {
189	unsigned int ss_sp;	189	unsigned int ss_sp;
190	int ss_flags;	190	int ss_flags;
191	unsigned int ss_size;	191	unsigned int ss_size;
192	} stack_ia32_t;	192	} stack_ia32_t;
193		193
194	struct ucontext_ia32 {	194	struct ucontext_ia32 {
195	unsigned int uc_flags;	195	unsigned int uc_flags;
196	unsigned int uc_link;	196	unsigned int uc_link;
197	stack_ia32_t uc_stack;	197	stack_ia32_t uc_stack;
198	struct sigcontext_ia32 uc_mcontext;	198	struct sigcontext_ia32 uc_mcontext;
199	sigset_t uc_sigmask; /* mask last for extensibility */	199	sigset_t uc_sigmask; /* mask last for extensibility */
200	};	200	};
201		201
202	struct stat64 {	202	struct stat64 {
203	unsigned long long st_dev;	203	unsigned long long st_dev;
204	unsigned char __pad0[4];	204	unsigned char __pad0[4];
205	unsigned int __st_ino;	205	unsigned int __st_ino;
206	unsigned int st_mode;	206	unsigned int st_mode;
207	unsigned int st_nlink;	207	unsigned int st_nlink;
208	unsigned int st_uid;	208	unsigned int st_uid;
209	unsigned int st_gid;	209	unsigned int st_gid;
210	unsigned long long st_rdev;	210	unsigned long long st_rdev;
211	unsigned char __pad3[4];	211	unsigned char __pad3[4];
212	unsigned int st_size_lo;	212	unsigned int st_size_lo;
213	unsigned int st_size_hi;	213	unsigned int st_size_hi;
214	unsigned int st_blksize;	214	unsigned int st_blksize;
215	unsigned int st_blocks; /* Number 512-byte blocks allocated. */	215	unsigned int st_blocks; /* Number 512-byte blocks allocated. */
216	unsigned int __pad4; /* future possible st_blocks high bits */	216	unsigned int __pad4; /* future possible st_blocks high bits */
217	unsigned int st_atime;	217	unsigned int st_atime;
218	unsigned int st_atime_nsec;	218	unsigned int st_atime_nsec;
219	unsigned int st_mtime;	219	unsigned int st_mtime;
220	unsigned int st_mtime_nsec;	220	unsigned int st_mtime_nsec;
221	unsigned int st_ctime;	221	unsigned int st_ctime;
222	unsigned int st_ctime_nsec;	222	unsigned int st_ctime_nsec;
223	unsigned int st_ino_lo;	223	unsigned int st_ino_lo;
224	unsigned int st_ino_hi;	224	unsigned int st_ino_hi;
225	};	225	};
226		226
227	typedef struct compat_siginfo {	227	typedef struct compat_siginfo {
228	int si_signo;	228	int si_signo;
229	int si_errno;	229	int si_errno;
230	int si_code;	230	int si_code;
231		231
232	union {	232	union {
233	int _pad[((128/sizeof(int)) - 3)];	233	int _pad[((128/sizeof(int)) - 3)];
234		234
235	/* kill() */	235	/* kill() */
236	struct {	236	struct {
237	unsigned int _pid; /* sender's pid */	237	unsigned int _pid; /* sender's pid */
238	unsigned int _uid; /* sender's uid */	238	unsigned int _uid; /* sender's uid */
239	} _kill;	239	} _kill;
240		240
241	/* POSIX.1b timers */	241	/* POSIX.1b timers */
242	struct {	242	struct {
243	compat_timer_t _tid; /* timer id */	243	compat_timer_t _tid; /* timer id */
244	int _overrun; /* overrun count */	244	int _overrun; /* overrun count */
245	char _pad[sizeof(unsigned int) - sizeof(int)];	245	char _pad[sizeof(unsigned int) - sizeof(int)];
246	compat_sigval_t _sigval; /* same as below */	246	compat_sigval_t _sigval; /* same as below */
247	int _sys_private; /* not to be passed to user */	247	int _sys_private; /* not to be passed to user */
248	} _timer;	248	} _timer;
249		249
250	/* POSIX.1b signals */	250	/* POSIX.1b signals */
251	struct {	251	struct {
252	unsigned int _pid; /* sender's pid */	252	unsigned int _pid; /* sender's pid */
253	unsigned int _uid; /* sender's uid */	253	unsigned int _uid; /* sender's uid */
254	compat_sigval_t _sigval;	254	compat_sigval_t _sigval;
255	} _rt;	255	} _rt;
256		256
257	/* SIGCHLD */	257	/* SIGCHLD */
258	struct {	258	struct {
259	unsigned int _pid; /* which child */	259	unsigned int _pid; /* which child */
260	unsigned int _uid; /* sender's uid */	260	unsigned int _uid; /* sender's uid */
261	int _status; /* exit code */	261	int _status; /* exit code */
262	compat_clock_t _utime;	262	compat_clock_t _utime;
263	compat_clock_t _stime;	263	compat_clock_t _stime;
264	} _sigchld;	264	} _sigchld;
265		265
266	/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */	266	/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
267	struct {	267	struct {
268	unsigned int _addr; /* faulting insn/memory ref. */	268	unsigned int _addr; /* faulting insn/memory ref. */
269	} _sigfault;	269	} _sigfault;
270		270
271	/* SIGPOLL */	271	/* SIGPOLL */
272	struct {	272	struct {
273	int _band; /* POLL_IN, POLL_OUT, POLL_MSG */	273	int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
274	int _fd;	274	int _fd;
275	} _sigpoll;	275	} _sigpoll;
276	} _sifields;	276	} _sifields;
277	} compat_siginfo_t;	277	} compat_siginfo_t;
278		278
279	struct old_linux32_dirent {	279	struct old_linux32_dirent {
280	u32 d_ino;	280	u32 d_ino;
281	u32 d_offset;	281	u32 d_offset;
282	u16 d_namlen;	282	u16 d_namlen;
283	char d_name[1];	283	char d_name[1];
284	};	284	};
285		285
286	/*	286	/*
287	* IA-32 ELF specific definitions for IA-64.	287	* IA-32 ELF specific definitions for IA-64.
288	*/	288	*/
289		289
290	#define _ASM_IA64_ELF_H /* Don't include elf.h */	290	#define _ASM_IA64_ELF_H /* Don't include elf.h */
291		291
292	#include <linux/sched.h>	292	#include <linux/sched.h>
293	#include <asm/processor.h>	293	#include <asm/processor.h>
294		294
295	/*	295	/*
296	* This is used to ensure we don't load something for the wrong architecture.	296	* This is used to ensure we don't load something for the wrong architecture.
297	*/	297	*/
298	#define elf_check_arch(x) ((x)->e_machine == EM_386)	298	#define elf_check_arch(x) ((x)->e_machine == EM_386)
299		299
300	/*	300	/*
301	* These are used to set parameters in the core dumps.	301	* These are used to set parameters in the core dumps.
302	*/	302	*/
303	#define ELF_CLASS ELFCLASS32	303	#define ELF_CLASS ELFCLASS32
304	#define ELF_DATA ELFDATA2LSB	304	#define ELF_DATA ELFDATA2LSB
305	#define ELF_ARCH EM_386	305	#define ELF_ARCH EM_386
306		306
307	#define IA32_STACK_TOP IA32_PAGE_OFFSET	307	#define IA32_STACK_TOP IA32_PAGE_OFFSET
308	#define IA32_GATE_OFFSET IA32_PAGE_OFFSET	308	#define IA32_GATE_OFFSET IA32_PAGE_OFFSET
309	#define IA32_GATE_END IA32_PAGE_OFFSET + PAGE_SIZE	309	#define IA32_GATE_END IA32_PAGE_OFFSET + PAGE_SIZE
310		310
311	/*	311	/*
312	* The system segments (GDT, TSS, LDT) have to be mapped below 4GB so the IA-32 engine can	312	* The system segments (GDT, TSS, LDT) have to be mapped below 4GB so the IA-32 engine can
313	* access them.	313	* access them.
314	*/	314	*/
315	#define IA32_GDT_OFFSET (IA32_PAGE_OFFSET + PAGE_SIZE)	315	#define IA32_GDT_OFFSET (IA32_PAGE_OFFSET + PAGE_SIZE)
316	#define IA32_TSS_OFFSET (IA32_PAGE_OFFSET + 2*PAGE_SIZE)	316	#define IA32_TSS_OFFSET (IA32_PAGE_OFFSET + 2*PAGE_SIZE)
317	#define IA32_LDT_OFFSET (IA32_PAGE_OFFSET + 3*PAGE_SIZE)	317	#define IA32_LDT_OFFSET (IA32_PAGE_OFFSET + 3*PAGE_SIZE)
318		318
319	#define ELF_EXEC_PAGESIZE IA32_PAGE_SIZE	319	#define ELF_EXEC_PAGESIZE IA32_PAGE_SIZE
320		320
321	/*	321	/*
322	* This is the location that an ET_DYN program is loaded if exec'ed.	322	* This is the location that an ET_DYN program is loaded if exec'ed.
323	* Typical use of this is to invoke "./ld.so someprog" to test out a	323	* Typical use of this is to invoke "./ld.so someprog" to test out a
324	* new version of the loader. We need to make sure that it is out of	324	* new version of the loader. We need to make sure that it is out of
325	* the way of the program that it will "exec", and that there is	325	* the way of the program that it will "exec", and that there is
326	* sufficient room for the brk.	326	* sufficient room for the brk.
327	*/	327	*/
328	#define ELF_ET_DYN_BASE (IA32_PAGE_OFFSET/3 + 0x1000000)	328	#define ELF_ET_DYN_BASE (IA32_PAGE_OFFSET/3 + 0x1000000)
329		329
330	void ia64_elf32_init(struct pt_regs *regs);	330	void ia64_elf32_init(struct pt_regs *regs);
331	#define ELF_PLAT_INIT(_r, load_addr) ia64_elf32_init(_r)	331	#define ELF_PLAT_INIT(_r, load_addr) ia64_elf32_init(_r)
332		332
333	/* This macro yields a bitmask that programs can use to figure out	333	/* This macro yields a bitmask that programs can use to figure out
334	what instruction set this CPU supports. */	334	what instruction set this CPU supports. */
335	#define ELF_HWCAP 0	335	#define ELF_HWCAP 0
336		336
337	/* This macro yields a string that ld.so will use to load	337	/* This macro yields a string that ld.so will use to load
338	implementation specific libraries for optimization. Not terribly	338	implementation specific libraries for optimization. Not terribly
339	relevant until we have real hardware to play with... */	339	relevant until we have real hardware to play with... */
340	#define ELF_PLATFORM NULL	340	#define ELF_PLATFORM NULL
341		341
342	#ifdef __KERNEL__	342	#ifdef __KERNEL__
343	# define SET_PERSONALITY(EX,IBCS2) \	343	# define SET_PERSONALITY(EX,IBCS2) \
344	(current->personality = (IBCS2) ? PER_SVR4 : PER_LINUX)	344	(current->personality = (IBCS2) ? PER_SVR4 : PER_LINUX)
345	#endif	345	#endif
346		346
347	#define IA32_EFLAG 0x200	347	#define IA32_EFLAG 0x200
348		348
349	/*	349	/*
350	* IA-32 ELF specific definitions for IA-64.	350	* IA-32 ELF specific definitions for IA-64.
351	*/	351	*/
352		352
353	#define __USER_CS 0x23	353	#define __USER_CS 0x23
354	#define __USER_DS 0x2B	354	#define __USER_DS 0x2B
355		355
356	/*	356	/*
357	* The per-cpu GDT has 32 entries: see <asm-i386/segment.h>	357	* The per-cpu GDT has 32 entries: see <asm-i386/segment.h>
358	*/	358	*/
359	#define GDT_ENTRIES 32	359	#define GDT_ENTRIES 32
360		360
361	#define GDT_SIZE (GDT_ENTRIES * 8)	361	#define GDT_SIZE (GDT_ENTRIES * 8)
362		362
363	#define TSS_ENTRY 14	363	#define TSS_ENTRY 14
364	#define LDT_ENTRY (TSS_ENTRY + 1)	364	#define LDT_ENTRY (TSS_ENTRY + 1)
365		365
366	#define IA32_SEGSEL_RPL (0x3 << 0)	366	#define IA32_SEGSEL_RPL (0x3 << 0)
367	#define IA32_SEGSEL_TI (0x1 << 2)	367	#define IA32_SEGSEL_TI (0x1 << 2)
368	#define IA32_SEGSEL_INDEX_SHIFT 3	368	#define IA32_SEGSEL_INDEX_SHIFT 3
369		369
370	#define _TSS ((unsigned long) TSS_ENTRY << IA32_SEGSEL_INDEX_SHIFT)	370	#define _TSS ((unsigned long) TSS_ENTRY << IA32_SEGSEL_INDEX_SHIFT)
371	#define _LDT ((unsigned long) LDT_ENTRY << IA32_SEGSEL_INDEX_SHIFT)	371	#define _LDT ((unsigned long) LDT_ENTRY << IA32_SEGSEL_INDEX_SHIFT)
372		372
373	#define IA32_SEG_BASE 16	373	#define IA32_SEG_BASE 16
374	#define IA32_SEG_TYPE 40	374	#define IA32_SEG_TYPE 40
375	#define IA32_SEG_SYS 44	375	#define IA32_SEG_SYS 44
376	#define IA32_SEG_DPL 45	376	#define IA32_SEG_DPL 45
377	#define IA32_SEG_P 47	377	#define IA32_SEG_P 47
378	#define IA32_SEG_HIGH_LIMIT 48	378	#define IA32_SEG_HIGH_LIMIT 48
379	#define IA32_SEG_AVL 52	379	#define IA32_SEG_AVL 52
380	#define IA32_SEG_DB 54	380	#define IA32_SEG_DB 54
381	#define IA32_SEG_G 55	381	#define IA32_SEG_G 55
382	#define IA32_SEG_HIGH_BASE 56	382	#define IA32_SEG_HIGH_BASE 56
383		383
384	#define IA32_SEG_DESCRIPTOR(base, limit, segtype, nonsysseg, dpl, segpresent, avl, segdb, gran) \	384	#define IA32_SEG_DESCRIPTOR(base, limit, segtype, nonsysseg, dpl, segpresent, avl, segdb, gran) \
385	(((limit) & 0xffff) \	385	(((limit) & 0xffff) \
386	\| (((unsigned long) (base) & 0xffffff) << IA32_SEG_BASE) \	386	\| (((unsigned long) (base) & 0xffffff) << IA32_SEG_BASE) \
387	\| ((unsigned long) (segtype) << IA32_SEG_TYPE) \	387	\| ((unsigned long) (segtype) << IA32_SEG_TYPE) \
388	\| ((unsigned long) (nonsysseg) << IA32_SEG_SYS) \	388	\| ((unsigned long) (nonsysseg) << IA32_SEG_SYS) \
389	\| ((unsigned long) (dpl) << IA32_SEG_DPL) \	389	\| ((unsigned long) (dpl) << IA32_SEG_DPL) \
390	\| ((unsigned long) (segpresent) << IA32_SEG_P) \	390	\| ((unsigned long) (segpresent) << IA32_SEG_P) \
391	\| ((((unsigned long) (limit) >> 16) & 0xf) << IA32_SEG_HIGH_LIMIT) \	391	\| ((((unsigned long) (limit) >> 16) & 0xf) << IA32_SEG_HIGH_LIMIT) \
392	\| ((unsigned long) (avl) << IA32_SEG_AVL) \	392	\| ((unsigned long) (avl) << IA32_SEG_AVL) \
393	\| ((unsigned long) (segdb) << IA32_SEG_DB) \	393	\| ((unsigned long) (segdb) << IA32_SEG_DB) \
394	\| ((unsigned long) (gran) << IA32_SEG_G) \	394	\| ((unsigned long) (gran) << IA32_SEG_G) \
395	\| ((((unsigned long) (base) >> 24) & 0xff) << IA32_SEG_HIGH_BASE))	395	\| ((((unsigned long) (base) >> 24) & 0xff) << IA32_SEG_HIGH_BASE))
396		396
397	#define SEG_LIM 32	397	#define SEG_LIM 32
398	#define SEG_TYPE 52	398	#define SEG_TYPE 52
399	#define SEG_SYS 56	399	#define SEG_SYS 56
400	#define SEG_DPL 57	400	#define SEG_DPL 57
401	#define SEG_P 59	401	#define SEG_P 59
402	#define SEG_AVL 60	402	#define SEG_AVL 60
403	#define SEG_DB 62	403	#define SEG_DB 62
404	#define SEG_G 63	404	#define SEG_G 63
405		405
406	/* Unscramble an IA-32 segment descriptor into the IA-64 format. */	406	/* Unscramble an IA-32 segment descriptor into the IA-64 format. */
407	#define IA32_SEG_UNSCRAMBLE(sd) \	407	#define IA32_SEG_UNSCRAMBLE(sd) \
408	( (((sd) >> IA32_SEG_BASE) & 0xffffff) \| ((((sd) >> IA32_SEG_HIGH_BASE) & 0xff) << 24) \	408	( (((sd) >> IA32_SEG_BASE) & 0xffffff) \| ((((sd) >> IA32_SEG_HIGH_BASE) & 0xff) << 24) \
409	\| ((((sd) & 0xffff) \| ((((sd) >> IA32_SEG_HIGH_LIMIT) & 0xf) << 16)) << SEG_LIM) \	409	\| ((((sd) & 0xffff) \| ((((sd) >> IA32_SEG_HIGH_LIMIT) & 0xf) << 16)) << SEG_LIM) \
410	\| ((((sd) >> IA32_SEG_TYPE) & 0xf) << SEG_TYPE) \	410	\| ((((sd) >> IA32_SEG_TYPE) & 0xf) << SEG_TYPE) \
411	\| ((((sd) >> IA32_SEG_SYS) & 0x1) << SEG_SYS) \	411	\| ((((sd) >> IA32_SEG_SYS) & 0x1) << SEG_SYS) \
412	\| ((((sd) >> IA32_SEG_DPL) & 0x3) << SEG_DPL) \	412	\| ((((sd) >> IA32_SEG_DPL) & 0x3) << SEG_DPL) \
413	\| ((((sd) >> IA32_SEG_P) & 0x1) << SEG_P) \	413	\| ((((sd) >> IA32_SEG_P) & 0x1) << SEG_P) \
414	\| ((((sd) >> IA32_SEG_AVL) & 0x1) << SEG_AVL) \	414	\| ((((sd) >> IA32_SEG_AVL) & 0x1) << SEG_AVL) \
415	\| ((((sd) >> IA32_SEG_DB) & 0x1) << SEG_DB) \	415	\| ((((sd) >> IA32_SEG_DB) & 0x1) << SEG_DB) \
416	\| ((((sd) >> IA32_SEG_G) & 0x1) << SEG_G))	416	\| ((((sd) >> IA32_SEG_G) & 0x1) << SEG_G))
417		417
418	#define IA32_IOBASE 0x2000000000000000UL /* Virtual address for I/O space */	418	#define IA32_IOBASE 0x2000000000000000UL /* Virtual address for I/O space */
419		419
420	#define IA32_CR0 0x80000001 /* Enable PG and PE bits */	420	#define IA32_CR0 0x80000001 /* Enable PG and PE bits */
421	#define IA32_CR4 0x600 /* MMXEX and FXSR on */	421	#define IA32_CR4 0x600 /* MMXEX and FXSR on */
422		422
423	/*	423	/*
424	* IA32 floating point control registers starting values	424	* IA32 floating point control registers starting values
425	*/	425	*/
426		426
427	#define IA32_FSR_DEFAULT 0x55550000 /* set all tag bits */	427	#define IA32_FSR_DEFAULT 0x55550000 /* set all tag bits */
428	#define IA32_FCR_DEFAULT 0x17800000037fUL /* extended precision, all masks */	428	#define IA32_FCR_DEFAULT 0x17800000037fUL /* extended precision, all masks */
429		429
430	#define IA32_PTRACE_GETREGS 12	430	#define IA32_PTRACE_GETREGS 12
431	#define IA32_PTRACE_SETREGS 13	431	#define IA32_PTRACE_SETREGS 13
432	#define IA32_PTRACE_GETFPREGS 14	432	#define IA32_PTRACE_GETFPREGS 14
433	#define IA32_PTRACE_SETFPREGS 15	433	#define IA32_PTRACE_SETFPREGS 15
434	#define IA32_PTRACE_GETFPXREGS 18	434	#define IA32_PTRACE_GETFPXREGS 18
435	#define IA32_PTRACE_SETFPXREGS 19	435	#define IA32_PTRACE_SETFPXREGS 19
436		436
437	#define ia32_start_thread(regs,new_ip,new_sp) do { \	437	#define ia32_start_thread(regs,new_ip,new_sp) do { \
438	set_fs(USER_DS); \	438	set_fs(USER_DS); \
439	ia64_psr(regs)->cpl = 3; /* set user mode */ \	439	ia64_psr(regs)->cpl = 3; /* set user mode */ \
440	ia64_psr(regs)->ri = 0; /* clear return slot number */ \	440	ia64_psr(regs)->ri = 0; /* clear return slot number */ \
441	ia64_psr(regs)->is = 1; /* IA-32 instruction set */ \	441	ia64_psr(regs)->is = 1; /* IA-32 instruction set */ \
442	regs->cr_iip = new_ip; \	442	regs->cr_iip = new_ip; \
443	regs->ar_rsc = 0xc; /* enforced lazy mode, priv. level 3 */ \	443	regs->ar_rsc = 0xc; /* enforced lazy mode, priv. level 3 */ \
444	regs->ar_rnat = 0; \	444	regs->ar_rnat = 0; \
445	regs->loadrs = 0; \	445	regs->loadrs = 0; \
446	regs->r12 = new_sp; \	446	regs->r12 = new_sp; \
447	} while (0)	447	} while (0)
448		448
449	/*	449	/*
450	* Local Descriptor Table (LDT) related declarations.	450	* Local Descriptor Table (LDT) related declarations.
451	*/	451	*/
452		452
453	#define IA32_LDT_ENTRIES 8192 /* Maximum number of LDT entries supported. */	453	#define IA32_LDT_ENTRIES 8192 /* Maximum number of LDT entries supported. */
454	#define IA32_LDT_ENTRY_SIZE 8 /* The size of each LDT entry. */	454	#define IA32_LDT_ENTRY_SIZE 8 /* The size of each LDT entry. */
455		455
456	#define LDT_entry_a(info) \	456	#define LDT_entry_a(info) \
457	((((info)->base_addr & 0x0000ffff) << 16) \| ((info)->limit & 0x0ffff))	457	((((info)->base_addr & 0x0000ffff) << 16) \| ((info)->limit & 0x0ffff))
458		458
459	#define LDT_entry_b(info) \	459	#define LDT_entry_b(info) \
460	(((info)->base_addr & 0xff000000) \| \	460	(((info)->base_addr & 0xff000000) \| \
461	(((info)->base_addr & 0x00ff0000) >> 16) \| \	461	(((info)->base_addr & 0x00ff0000) >> 16) \| \
462	((info)->limit & 0xf0000) \| \	462	((info)->limit & 0xf0000) \| \
463	(((info)->read_exec_only ^ 1) << 9) \| \	463	(((info)->read_exec_only ^ 1) << 9) \| \
464	((info)->contents << 10) \| \	464	((info)->contents << 10) \| \
465	(((info)->seg_not_present ^ 1) << 15) \| \	465	(((info)->seg_not_present ^ 1) << 15) \| \
466	((info)->seg_32bit << 22) \| \	466	((info)->seg_32bit << 22) \| \
467	((info)->limit_in_pages << 23) \| \	467	((info)->limit_in_pages << 23) \| \
468	((info)->useable << 20) \| \	468	((info)->useable << 20) \| \
469	0x7100)	469	0x7100)
470		470
471	#define LDT_empty(info) ( \	471	#define LDT_empty(info) ( \
472	(info)->base_addr == 0 && \	472	(info)->base_addr == 0 && \
473	(info)->limit == 0 && \	473	(info)->limit == 0 && \
474	(info)->contents == 0 && \	474	(info)->contents == 0 && \
475	(info)->read_exec_only == 1 && \	475	(info)->read_exec_only == 1 && \
476	(info)->seg_32bit == 0 && \	476	(info)->seg_32bit == 0 && \
477	(info)->limit_in_pages == 0 && \	477	(info)->limit_in_pages == 0 && \
478	(info)->seg_not_present == 1 && \	478	(info)->seg_not_present == 1 && \
479	(info)->useable == 0 )	479	(info)->useable == 0 )
480		480
481	static inline void	481	static inline void
482	load_TLS (struct thread_struct *t, unsigned int cpu)	482	load_TLS (struct thread_struct *t, unsigned int cpu)
483	{	483	{
484	extern unsigned long *cpu_gdt_table[NR_CPUS];	484	extern unsigned long *cpu_gdt_table[NR_CPUS];
485		485
486	memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 0, &t->tls_array[0], sizeof(long));	486	memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 0, &t->tls_array[0], sizeof(long));
487	memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 1, &t->tls_array[1], sizeof(long));	487	memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 1, &t->tls_array[1], sizeof(long));
488	memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 2, &t->tls_array[2], sizeof(long));	488	memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 2, &t->tls_array[2], sizeof(long));
489	}	489	}
490		490
491	struct ia32_user_desc {	491	struct ia32_user_desc {
492	unsigned int entry_number;	492	unsigned int entry_number;
493	unsigned int base_addr;	493	unsigned int base_addr;
494	unsigned int limit;	494	unsigned int limit;
495	unsigned int seg_32bit:1;	495	unsigned int seg_32bit:1;
496	unsigned int contents:2;	496	unsigned int contents:2;
497	unsigned int read_exec_only:1;	497	unsigned int read_exec_only:1;
498	unsigned int limit_in_pages:1;	498	unsigned int limit_in_pages:1;
499	unsigned int seg_not_present:1;	499	unsigned int seg_not_present:1;
500	unsigned int useable:1;	500	unsigned int useable:1;
501	};	501	};
502		502
503	struct linux_binprm;	503	struct linux_binprm;
504		504
505	extern void ia32_init_addr_space (struct pt_regs *regs);	505	extern void ia32_init_addr_space (struct pt_regs *regs);
506	extern int ia32_setup_arg_pages (struct linux_binprm *bprm, int exec_stack);	506	extern int ia32_setup_arg_pages (struct linux_binprm *bprm, int exec_stack);
507	extern unsigned long ia32_do_mmap (struct file *, unsigned long, unsigned long, int, int, loff_t);	507	extern unsigned long ia32_do_mmap (struct file *, unsigned long, unsigned long, int, int, loff_t);
508	extern void ia32_load_segment_descriptors (struct task_struct *task);	508	extern void ia32_load_segment_descriptors (struct task_struct *task);
509		509
510	#define ia32f2ia64f(dst,src) \	510	#define ia32f2ia64f(dst,src) \
511	do { \	511	do { \
512	ia64_ldfe(6,src); \	512	ia64_ldfe(6,src); \
513	ia64_stop(); \	513	ia64_stop(); \
514	ia64_stf_spill(dst, 6); \	514	ia64_stf_spill(dst, 6); \
515	} while(0)	515	} while(0)
516		516
517	#define ia64f2ia32f(dst,src) \	517	#define ia64f2ia32f(dst,src) \
518	do { \	518	do { \
519	ia64_ldf_fill(6, src); \	519	ia64_ldf_fill(6, src); \
520	ia64_stop(); \	520	ia64_stop(); \
521	ia64_stfe(dst, 6); \	521	ia64_stfe(dst, 6); \
522	} while(0)	522	} while(0)
523		523
524	struct user_regs_struct32 {	524	struct user_regs_struct32 {
525	__u32 ebx, ecx, edx, esi, edi, ebp, eax;	525	__u32 ebx, ecx, edx, esi, edi, ebp, eax;
526	unsigned short ds, __ds, es, __es;	526	unsigned short ds, __ds, es, __es;
527	unsigned short fs, __fs, gs, __gs;	527	unsigned short fs, __fs, gs, __gs;
528	__u32 orig_eax, eip;	528	__u32 orig_eax, eip;
529	unsigned short cs, __cs;	529	unsigned short cs, __cs;
530	__u32 eflags, esp;	530	__u32 eflags, esp;
531	unsigned short ss, __ss;	531	unsigned short ss, __ss;
532	};	532	};
533		533
534	/* Prototypes for use in elfcore32.h */	534	/* Prototypes for use in elfcore32.h */
535	extern int save_ia32_fpstate (struct task_struct , struct ia32_user_i387_struct __user );	535	extern int save_ia32_fpstate (struct task_struct , struct ia32_user_i387_struct __user );
536	extern int save_ia32_fpxstate (struct task_struct , struct ia32_user_fxsr_struct __user );	536	extern int save_ia32_fpxstate (struct task_struct , struct ia32_user_fxsr_struct __user );
537		537
538	#endif /* !CONFIG_IA32_SUPPORT */	538	#endif /* !CONFIG_IA32_SUPPORT */
539		539
540	#endif /* _ASM_IA64_IA32_PRIV_H */	540	#endif /* _ASM_IA64_IA32_PRIV_H */
541		541

arch/ia64/ia32/sys_ia32.c

Diff comments View file @ 3b74d18

 /*
  * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Derived from sys_sparc32.c.
  *
  * Copyright (C) 2000		VA Linux Co
  * Copyright (C) 2000		Don Dugger <n0ano@valinux.com>
  * Copyright (C) 1999		Arun Sharma <arun.sharma@intel.com>
  * Copyright (C) 1997,1998	Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  * Copyright (C) 1997		David S. Miller (davem@caip.rutgers.edu)
  * Copyright (C) 2000-2003, 2005 Hewlett-Packard Co
  *	David Mosberger-Tang <davidm@hpl.hp.com>
  * Copyright (C) 2004		Gordon Jin <gordon.jin@intel.com>
  *
  * These routines maintain argument size conversion between 32bit and 64bit
  * environment.
  */
 #include <linux/kernel.h>
 #include <linux/syscalls.h>
 #include <linux/sysctl.h>
 #include <linux/sched.h>
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/signal.h>
 #include <linux/resource.h>
 #include <linux/times.h>
 #include <linux/utsname.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/sem.h>
 #include <linux/msg.h>
 #include <linux/mm.h>
 #include <linux/shm.h>
 #include <linux/slab.h>
 #include <linux/uio.h>
 #include <linux/nfs_fs.h>
 #include <linux/quota.h>
 #include <linux/syscalls.h>
 #include <linux/sunrpc/svc.h>
 #include <linux/nfsd/nfsd.h>
 #include <linux/nfsd/cache.h>
 #include <linux/nfsd/xdr.h>
 #include <linux/nfsd/syscall.h>
 #include <linux/poll.h>
 #include <linux/eventpoll.h>
 #include <linux/personality.h>
 #include <linux/ptrace.h>
 #include <linux/stat.h>
 #include <linux/ipc.h>
 #include <linux/capability.h>
 #include <linux/compat.h>
 #include <linux/vfs.h>
 #include <linux/mman.h>
 #include <linux/mutex.h>
 #include <asm/intrinsics.h>
 #include <asm/types.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 #include "ia32priv.h"
 #include <net/scm.h>
 #include <net/sock.h>
 #define DEBUG	0
 #if DEBUG
 # define DBG(fmt...)	printk(KERN_DEBUG fmt)
 #else
 # define DBG(fmt...)
 #endif
 #define ROUND_UP(x,a)	((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
 #define OFFSET4K(a)		((a) & 0xfff)
 #define PAGE_START(addr)	((addr) & PAGE_MASK)
 #define MINSIGSTKSZ_IA32	2048
 #define high2lowuid(uid) ((uid) > 65535 ? 65534 : (uid))
 #define high2lowgid(gid) ((gid) > 65535 ? 65534 : (gid))
 /*
  * Anything that modifies or inspects ia32 user virtual memory must hold this semaphore
  * while doing so.
  */
 /* XXX make per-mm: */
 static DEFINE_MUTEX(ia32_mmap_mutex);
 asmlinkage long
 sys32_execve (char __user *name, compat_uptr_t __user *argv, compat_uptr_t __user *envp,
 	      struct pt_regs *regs)
 {
 	long error;
 	char *filename;
 	unsigned long old_map_base, old_task_size, tssd;
 	filename = getname(name);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		return error;
 	old_map_base  = current->thread.map_base;
 	old_task_size = current->thread.task_size;
 	tssd = ia64_get_kr(IA64_KR_TSSD);
 	/* we may be exec'ing a 64-bit process: reset map base, task-size, and io-base: */
 	current->thread.map_base  = DEFAULT_MAP_BASE;
 	current->thread.task_size = DEFAULT_TASK_SIZE;
 	ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
 	ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
 	error = compat_do_execve(filename, argv, envp, regs);
 	putname(filename);
 	if (error < 0) {
 		/* oops, execve failed, switch back to old values... */
 		ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
 		ia64_set_kr(IA64_KR_TSSD, tssd);
 		current->thread.map_base  = old_map_base;
 		current->thread.task_size = old_task_size;
 	}
 	return error;
 }
 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
 {
 	compat_ino_t ino;
 	int err;
 	if ((u64) stat->size > MAX_NON_LFS ||
 	    !old_valid_dev(stat->dev) ||
 	    !old_valid_dev(stat->rdev))
 		return -EOVERFLOW;
 	ino = stat->ino;
 	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
 		return -EOVERFLOW;
 	if (clear_user(ubuf, sizeof(*ubuf)))
 		return -EFAULT;
 	err  = __put_user(old_encode_dev(stat->dev), &ubuf->st_dev);
 	err |= __put_user(ino, &ubuf->st_ino);
 	err |= __put_user(stat->mode, &ubuf->st_mode);
 	err |= __put_user(stat->nlink, &ubuf->st_nlink);
 	err |= __put_user(high2lowuid(stat->uid), &ubuf->st_uid);
 	err |= __put_user(high2lowgid(stat->gid), &ubuf->st_gid);
 	err |= __put_user(old_encode_dev(stat->rdev), &ubuf->st_rdev);
 	err |= __put_user(stat->size, &ubuf->st_size);
 	err |= __put_user(stat->atime.tv_sec, &ubuf->st_atime);
 	err |= __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec);
 	err |= __put_user(stat->mtime.tv_sec, &ubuf->st_mtime);
 	err |= __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec);
 	err |= __put_user(stat->ctime.tv_sec, &ubuf->st_ctime);
 	err |= __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec);
 	err |= __put_user(stat->blksize, &ubuf->st_blksize);
 	err |= __put_user(stat->blocks, &ubuf->st_blocks);
 	return err;
 }
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 static int
 get_page_prot (struct vm_area_struct *vma, unsigned long addr)
 {
 	int prot = 0;
 	if (!vma || vma->vm_start > addr)
 		return 0;
 	if (vma->vm_flags & VM_READ)
 		prot |= PROT_READ;
 	if (vma->vm_flags & VM_WRITE)
 		prot |= PROT_WRITE;
 	if (vma->vm_flags & VM_EXEC)
 		prot |= PROT_EXEC;
 	return prot;
 }
 /*
  * Map a subpage by creating an anonymous page that contains the union of the old page and
  * the subpage.
  */
 static unsigned long
 mmap_subpage (struct file *file, unsigned long start, unsigned long end, int prot, int flags,
 	      loff_t off)
 {
 	void *page = NULL;
 	struct inode *inode;
 	unsigned long ret = 0;
 	struct vm_area_struct *vma = find_vma(current->mm, start);
 	int old_prot = get_page_prot(vma, start);
 	DBG("mmap_subpage(file=%p,start=0x%lx,end=0x%lx,prot=%x,flags=%x,off=0x%llx)\n",
 	    file, start, end, prot, flags, off);
 	/* Optimize the case where the old mmap and the new mmap are both anonymous */
 	if ((old_prot & PROT_WRITE) && (flags & MAP_ANONYMOUS) && !vma->vm_file) {
 		if (clear_user((void __user *) start, end - start)) {
 			ret = -EFAULT;
 			goto out;
 		}
 		goto skip_mmap;
 	}
 	page = (void *) get_zeroed_page(GFP_KERNEL);
 	if (!page)
 		return -ENOMEM;
 	if (old_prot)
 		copy_from_user(page, (void __user *) PAGE_START(start), PAGE_SIZE);
 	down_write(&current->mm->mmap_sem);
 	{
 		ret = do_mmap(NULL, PAGE_START(start), PAGE_SIZE, prot | PROT_WRITE,
 			      flags | MAP_FIXED | MAP_ANONYMOUS, 0);
 	}
 	up_write(&current->mm->mmap_sem);
 	if (IS_ERR((void *) ret))
 		goto out;
 	if (old_prot) {
 		/* copy back the old page contents.  */
 		if (offset_in_page(start))
 			copy_to_user((void __user *) PAGE_START(start), page,
 				     offset_in_page(start));
 		if (offset_in_page(end))
 			copy_to_user((void __user *) end, page + offset_in_page(end),
 				     PAGE_SIZE - offset_in_page(end));
 	}
 	if (!(flags & MAP_ANONYMOUS)) {
 		/* read the file contents */
 		inode = file->f_path.dentry->d_inode;
 		if (!inode->i_fop || !file->f_op->read
 		    || ((*file->f_op->read)(file, (char __user *) start, end - start, &off) < 0))
 		{
 			ret = -EINVAL;
 			goto out;
 		}
 	}
  skip_mmap:
 	if (!(prot & PROT_WRITE))
 		ret = sys_mprotect(PAGE_START(start), PAGE_SIZE, prot | old_prot);
   out:
 	if (page)
 		free_page((unsigned long) page);
 	return ret;
 }
-/* SLAB cache for partial_page structures */
+/* SLAB cache for ia64_partial_page structures */
-struct kmem_cache *partial_page_cachep;
+struct kmem_cache *ia64_partial_page_cachep;
 /*
- * init partial_page_list.
+ * init ia64_partial_page_list.
  * return 0 means kmalloc fail.
  */
-struct partial_page_list*
+struct ia64_partial_page_list*
 ia32_init_pp_list(void)
 {
-	struct partial_page_list *p;
+	struct ia64_partial_page_list *p;
 	if ((p = kmalloc(sizeof(*p), GFP_KERNEL)) == NULL)
 		return p;
 	p->pp_head = NULL;
 	p->ppl_rb = RB_ROOT;
 	p->pp_hint = NULL;
 	atomic_set(&p->pp_count, 1);
 	return p;
 }
 /*
  * Search for the partial page with @start in partial page list @ppl.
  * If finds the partial page, return the found partial page.
  * Else, return 0 and provide @pprev, @rb_link, @rb_parent to
  * be used by later __ia32_insert_pp().
  */
-static struct partial_page *
+static struct ia64_partial_page *
-__ia32_find_pp(struct partial_page_list *ppl, unsigned int start,
+__ia32_find_pp(struct ia64_partial_page_list *ppl, unsigned int start,
-	struct partial_page **pprev, struct rb_node ***rb_link,
+	struct ia64_partial_page **pprev, struct rb_node ***rb_link,
 	struct rb_node **rb_parent)
 {
-	struct partial_page *pp;
+	struct ia64_partial_page *pp;
 	struct rb_node **__rb_link, *__rb_parent, *rb_prev;
 	pp = ppl->pp_hint;
 	if (pp && pp->base == start)
 		return pp;
 	__rb_link = &ppl->ppl_rb.rb_node;
 	rb_prev = __rb_parent = NULL;
 	while (*__rb_link) {
 		__rb_parent = *__rb_link;
-		pp = rb_entry(__rb_parent, struct partial_page, pp_rb);
+		pp = rb_entry(__rb_parent, struct ia64_partial_page, pp_rb);
 		if (pp->base == start) {
 			ppl->pp_hint = pp;
 			return pp;
 		} else if (pp->base < start) {
 			rb_prev = __rb_parent;
 			__rb_link = &__rb_parent->rb_right;
 		} else {
 			__rb_link = &__rb_parent->rb_left;
 		}
 	}
 	*rb_link = __rb_link;
 	*rb_parent = __rb_parent;
 	*pprev = NULL;
 	if (rb_prev)
-		*pprev = rb_entry(rb_prev, struct partial_page, pp_rb);
+		*pprev = rb_entry(rb_prev, struct ia64_partial_page, pp_rb);
 	return NULL;
 }
 /*
  * insert @pp into @ppl.
  */
 static void
-__ia32_insert_pp(struct partial_page_list *ppl, struct partial_page *pp,
+__ia32_insert_pp(struct ia64_partial_page_list *ppl,
-	 struct partial_page *prev, struct rb_node **rb_link,
+	struct ia64_partial_page *pp, struct ia64_partial_page *prev,
-	struct rb_node *rb_parent)
+	struct rb_node **rb_link, struct rb_node *rb_parent)
 {
 	/* link list */
 	if (prev) {
 		pp->next = prev->next;
 		prev->next = pp;
 	} else {
 		ppl->pp_head = pp;
 		if (rb_parent)
 			pp->next = rb_entry(rb_parent,
-				struct partial_page, pp_rb);
+				struct ia64_partial_page, pp_rb);
 		else
 			pp->next = NULL;
 	}
 	/* link rb */
 	rb_link_node(&pp->pp_rb, rb_parent, rb_link);
 	rb_insert_color(&pp->pp_rb, &ppl->ppl_rb);
 	ppl->pp_hint = pp;
 }
 /*
  * delete @pp from partial page list @ppl.
  */
 static void
-__ia32_delete_pp(struct partial_page_list *ppl, struct partial_page *pp,
+__ia32_delete_pp(struct ia64_partial_page_list *ppl,
-	struct partial_page *prev)
+	struct ia64_partial_page *pp, struct ia64_partial_page *prev)
 {
 	if (prev) {
 		prev->next = pp->next;
 		if (ppl->pp_hint == pp)
 			ppl->pp_hint = prev;
 	} else {
 		ppl->pp_head = pp->next;
 		if (ppl->pp_hint == pp)
 			ppl->pp_hint = pp->next;
 	}
 	rb_erase(&pp->pp_rb, &ppl->ppl_rb);
-	kmem_cache_free(partial_page_cachep, pp);
+	kmem_cache_free(ia64_partial_page_cachep, pp);
 }
-static struct partial_page *
+static struct ia64_partial_page *
-__pp_prev(struct partial_page *pp)
+__pp_prev(struct ia64_partial_page *pp)
 {
 	struct rb_node *prev = rb_prev(&pp->pp_rb);
 	if (prev)
-		return rb_entry(prev, struct partial_page, pp_rb);
+		return rb_entry(prev, struct ia64_partial_page, pp_rb);
 	else
 		return NULL;
 }
 /*
  * Delete partial pages with address between @start and @end.
  * @start and @end are page aligned.
  */
 static void
 __ia32_delete_pp_range(unsigned int start, unsigned int end)
 {
-	struct partial_page *pp, *prev;
+	struct ia64_partial_page *pp, *prev;
 	struct rb_node **rb_link, *rb_parent;
 	if (start >= end)
 		return;
 	pp = __ia32_find_pp(current->thread.ppl, start, &prev,
 					&rb_link, &rb_parent);
 	if (pp)
 		prev = __pp_prev(pp);
 	else {
 		if (prev)
 			pp = prev->next;
 		else
 			pp = current->thread.ppl->pp_head;
 	}
 	while (pp && pp->base < end) {
-		struct partial_page *tmp = pp->next;
+		struct ia64_partial_page *tmp = pp->next;
 		__ia32_delete_pp(current->thread.ppl, pp, prev);
 		pp = tmp;
 	}
 }
 /*
  * Set the range between @start and @end in bitmap.
  * @start and @end should be IA32 page aligned and in the same IA64 page.
  */
 static int
 __ia32_set_pp(unsigned int start, unsigned int end, int flags)
 {
-	struct partial_page *pp, *prev;
+	struct ia64_partial_page *pp, *prev;
 	struct rb_node ** rb_link, *rb_parent;
 	unsigned int pstart, start_bit, end_bit, i;
 	pstart = PAGE_START(start);
 	start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
 	end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
 	if (end_bit == 0)
 		end_bit = PAGE_SIZE / IA32_PAGE_SIZE;
 	pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
 					&rb_link, &rb_parent);
 	if (pp) {
 		for (i = start_bit; i < end_bit; i++)
 			set_bit(i, &pp->bitmap);
 		/*
 		 * Check: if this partial page has been set to a full page,
 		 * then delete it.
 		 */
 		if (find_first_zero_bit(&pp->bitmap, sizeof(pp->bitmap)*8) >=
 				PAGE_SIZE/IA32_PAGE_SIZE) {
 			__ia32_delete_pp(current->thread.ppl, pp, __pp_prev(pp));
 		}
 		return 0;
 	}
 	/*
 	 * MAP_FIXED may lead to overlapping mmap.
 	 * In this case, the requested mmap area may already mmaped as a full
 	 * page. So check vma before adding a new partial page.
 	 */
 	if (flags & MAP_FIXED) {
 		struct vm_area_struct *vma = find_vma(current->mm, pstart);
 		if (vma && vma->vm_start <= pstart)
 			return 0;
 	}
-	/* new a partial_page */
+	/* new a ia64_partial_page */
-	pp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
+	pp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
 	if (!pp)
 		return -ENOMEM;
 	pp->base = pstart;
 	pp->bitmap = 0;
 	for (i=start_bit; i<end_bit; i++)
 		set_bit(i, &(pp->bitmap));
 	pp->next = NULL;
 	__ia32_insert_pp(current->thread.ppl, pp, prev, rb_link, rb_parent);
 	return 0;
 }
 /*
  * @start and @end should be IA32 page aligned, but don't need to be in the
  * same IA64 page. Split @start and @end to make sure they're in the same IA64
  * page, then call __ia32_set_pp().
  */
 static void
 ia32_set_pp(unsigned int start, unsigned int end, int flags)
 {
 	down_write(&current->mm->mmap_sem);
 	if (flags & MAP_FIXED) {
 		/*
 		 * MAP_FIXED may lead to overlapping mmap. When this happens,
 		 * a series of complete IA64 pages results in deletion of
 		 * old partial pages in that range.
 		 */
 		__ia32_delete_pp_range(PAGE_ALIGN(start), PAGE_START(end));
 	}
 	if (end < PAGE_ALIGN(start)) {
 		__ia32_set_pp(start, end, flags);
 	} else {
 		if (offset_in_page(start))
 			__ia32_set_pp(start, PAGE_ALIGN(start), flags);
 		if (offset_in_page(end))
 			__ia32_set_pp(PAGE_START(end), end, flags);
 	}
 	up_write(&current->mm->mmap_sem);
 }
 /*
  * Unset the range between @start and @end in bitmap.
  * @start and @end should be IA32 page aligned and in the same IA64 page.
  * After doing that, if the bitmap is 0, then free the page and return 1,
  * 	else return 0;
  * If not find the partial page in the list, then
  * 	If the vma exists, then the full page is set to a partial page;
  *	Else return -ENOMEM.
  */
 static int
 __ia32_unset_pp(unsigned int start, unsigned int end)
 {
-	struct partial_page *pp, *prev;
+	struct ia64_partial_page *pp, *prev;
 	struct rb_node ** rb_link, *rb_parent;
 	unsigned int pstart, start_bit, end_bit, i;
 	struct vm_area_struct *vma;
 	pstart = PAGE_START(start);
 	start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
 	end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
 	if (end_bit == 0)
 		end_bit = PAGE_SIZE / IA32_PAGE_SIZE;
 	pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
 					&rb_link, &rb_parent);
 	if (pp) {
 		for (i = start_bit; i < end_bit; i++)
 			clear_bit(i, &pp->bitmap);
 		if (pp->bitmap == 0) {
 			__ia32_delete_pp(current->thread.ppl, pp, __pp_prev(pp));
 			return 1;
 		}
 		return 0;
 	}
 	vma = find_vma(current->mm, pstart);
 	if (!vma || vma->vm_start > pstart) {
 		return -ENOMEM;
 	}
-	/* new a partial_page */
+	/* new a ia64_partial_page */
-	pp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
+	pp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
 	if (!pp)
 		return -ENOMEM;
 	pp->base = pstart;
 	pp->bitmap = 0;
 	for (i = 0; i < start_bit; i++)
 		set_bit(i, &(pp->bitmap));
 	for (i = end_bit; i < PAGE_SIZE / IA32_PAGE_SIZE; i++)
 		set_bit(i, &(pp->bitmap));
 	pp->next = NULL;
 	__ia32_insert_pp(current->thread.ppl, pp, prev, rb_link, rb_parent);
 	return 0;
 }
 /*
  * Delete pp between PAGE_ALIGN(start) and PAGE_START(end) by calling
  * __ia32_delete_pp_range(). Unset possible partial pages by calling
  * __ia32_unset_pp().
  * The returned value see __ia32_unset_pp().
  */
 static int
 ia32_unset_pp(unsigned int *startp, unsigned int *endp)
 {
 	unsigned int start = *startp, end = *endp;
 	int ret = 0;
 	down_write(&current->mm->mmap_sem);
 	__ia32_delete_pp_range(PAGE_ALIGN(start), PAGE_START(end));
 	if (end < PAGE_ALIGN(start)) {
 		ret = __ia32_unset_pp(start, end);
 		if (ret == 1) {
 			*startp = PAGE_START(start);
 			*endp = PAGE_ALIGN(end);
 		}
 		if (ret == 0) {
 			/* to shortcut sys_munmap() in sys32_munmap() */
 			*startp = PAGE_START(start);
 			*endp = PAGE_START(end);
 		}
 	} else {
 		if (offset_in_page(start)) {
 			ret = __ia32_unset_pp(start, PAGE_ALIGN(start));
 			if (ret == 1)
 				*startp = PAGE_START(start);
 			if (ret == 0)
 				*startp = PAGE_ALIGN(start);
 			if (ret < 0)
 				goto out;
 		}
 		if (offset_in_page(end)) {
 			ret = __ia32_unset_pp(PAGE_START(end), end);
 			if (ret == 1)
 				*endp = PAGE_ALIGN(end);
 			if (ret == 0)
 				*endp = PAGE_START(end);
 		}
 	}
  out:
 	up_write(&current->mm->mmap_sem);
 	return ret;
 }
 /*
  * Compare the range between @start and @end with bitmap in partial page.
  * @start and @end should be IA32 page aligned and in the same IA64 page.
  */
 static int
 __ia32_compare_pp(unsigned int start, unsigned int end)
 {
-	struct partial_page *pp, *prev;
+	struct ia64_partial_page *pp, *prev;
 	struct rb_node ** rb_link, *rb_parent;
 	unsigned int pstart, start_bit, end_bit, size;
 	unsigned int first_bit, next_zero_bit;	/* the first range in bitmap */
 	pstart = PAGE_START(start);
 	pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
 					&rb_link, &rb_parent);
 	if (!pp)
 		return 1;
 	start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
 	end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
 	size = sizeof(pp->bitmap) * 8;
 	first_bit = find_first_bit(&pp->bitmap, size);
 	next_zero_bit = find_next_zero_bit(&pp->bitmap, size, first_bit);
 	if ((start_bit < first_bit) || (end_bit > next_zero_bit)) {
 		/* exceeds the first range in bitmap */
 		return -ENOMEM;
 	} else if ((start_bit == first_bit) && (end_bit == next_zero_bit)) {
 		first_bit = find_next_bit(&pp->bitmap, size, next_zero_bit);
 		if ((next_zero_bit < first_bit) && (first_bit < size))
 			return 1;	/* has next range */
 		else
 			return 0; 	/* no next range */
 	} else
 		return 1;
 }
 /*
  * @start and @end should be IA32 page aligned, but don't need to be in the
  * same IA64 page. Split @start and @end to make sure they're in the same IA64
  * page, then call __ia32_compare_pp().
  *
  * Take this as example: the range is the 1st and 2nd 4K page.
  * Return 0 if they fit bitmap exactly, i.e. bitmap = 00000011;
  * Return 1 if the range doesn't cover whole bitmap, e.g. bitmap = 00001111;
  * Return -ENOMEM if the range exceeds the bitmap, e.g. bitmap = 00000001 or
  * 	bitmap = 00000101.
  */
 static int
 ia32_compare_pp(unsigned int *startp, unsigned int *endp)
 {
 	unsigned int start = *startp, end = *endp;
 	int retval = 0;
 	down_write(&current->mm->mmap_sem);
 	if (end < PAGE_ALIGN(start)) {
 		retval = __ia32_compare_pp(start, end);
 		if (retval == 0) {
 			*startp = PAGE_START(start);
 			*endp = PAGE_ALIGN(end);
 		}
 	} else {
 		if (offset_in_page(start)) {
 			retval = __ia32_compare_pp(start,
 						   PAGE_ALIGN(start));
 			if (retval == 0)
 				*startp = PAGE_START(start);
 			if (retval < 0)
 				goto out;
 		}
 		if (offset_in_page(end)) {
 			retval = __ia32_compare_pp(PAGE_START(end), end);
 			if (retval == 0)
 				*endp = PAGE_ALIGN(end);
 		}
 	}
  out:
 	up_write(&current->mm->mmap_sem);
 	return retval;
 }
 static void
-__ia32_drop_pp_list(struct partial_page_list *ppl)
+__ia32_drop_pp_list(struct ia64_partial_page_list *ppl)
 {
-	struct partial_page *pp = ppl->pp_head;
+	struct ia64_partial_page *pp = ppl->pp_head;
 	while (pp) {
-		struct partial_page *next = pp->next;
+		struct ia64_partial_page *next = pp->next;
-		kmem_cache_free(partial_page_cachep, pp);
+		kmem_cache_free(ia64_partial_page_cachep, pp);
 		pp = next;
 	}
 	kfree(ppl);
 }
 void
-ia32_drop_partial_page_list(struct task_struct *task)
+ia32_drop_ia64_partial_page_list(struct task_struct *task)
 {
-	struct partial_page_list* ppl = task->thread.ppl;
+	struct ia64_partial_page_list* ppl = task->thread.ppl;
 	if (ppl && atomic_dec_and_test(&ppl->pp_count))
 		__ia32_drop_pp_list(ppl);
 }
 /*
  * Copy current->thread.ppl to ppl (already initialized).
  */
 static int
-__ia32_copy_pp_list(struct partial_page_list *ppl)
+__ia32_copy_pp_list(struct ia64_partial_page_list *ppl)
 {
-	struct partial_page *pp, *tmp, *prev;
+	struct ia64_partial_page *pp, *tmp, *prev;
 	struct rb_node **rb_link, *rb_parent;
 	ppl->pp_head = NULL;
 	ppl->pp_hint = NULL;
 	ppl->ppl_rb = RB_ROOT;
 	rb_link = &ppl->ppl_rb.rb_node;
 	rb_parent = NULL;
 	prev = NULL;
 	for (pp = current->thread.ppl->pp_head; pp; pp = pp->next) {
-		tmp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
+		tmp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
 		if (!tmp)
 			return -ENOMEM;
 		*tmp = *pp;
 		__ia32_insert_pp(ppl, tmp, prev, rb_link, rb_parent);
 		prev = tmp;
 		rb_link = &tmp->pp_rb.rb_right;
 		rb_parent = &tmp->pp_rb;
 	}
 	return 0;
 }
 int
-ia32_copy_partial_page_list(struct task_struct *p, unsigned long clone_flags)
+ia32_copy_ia64_partial_page_list(struct task_struct *p,
+				unsigned long clone_flags)
 {
 	int retval = 0;
 	if (clone_flags & CLONE_VM) {
 		atomic_inc(&current->thread.ppl->pp_count);
 		p->thread.ppl = current->thread.ppl;
 	} else {
 		p->thread.ppl = ia32_init_pp_list();
 		if (!p->thread.ppl)
 			return -ENOMEM;
 		down_write(&current->mm->mmap_sem);
 		{
 			retval = __ia32_copy_pp_list(p->thread.ppl);
 		}
 		up_write(&current->mm->mmap_sem);
 	}
 	return retval;
 }
 static unsigned long
 emulate_mmap (struct file *file, unsigned long start, unsigned long len, int prot, int flags,
 	      loff_t off)
 {
 	unsigned long tmp, end, pend, pstart, ret, is_congruent, fudge = 0;
 	struct inode *inode;
 	loff_t poff;
 	end = start + len;
 	pstart = PAGE_START(start);
 	pend = PAGE_ALIGN(end);
 	if (flags & MAP_FIXED) {
 		ia32_set_pp((unsigned int)start, (unsigned int)end, flags);
 		if (start > pstart) {
 			if (flags & MAP_SHARED)
 				printk(KERN_INFO
 				       "%s(%d): emulate_mmap() can't share head (addr=0x%lx)\n",
 				       current->comm, current->pid, start);
 			ret = mmap_subpage(file, start, min(PAGE_ALIGN(start), end), prot, flags,
 					   off);
 			if (IS_ERR((void *) ret))
 				return ret;
 			pstart += PAGE_SIZE;
 			if (pstart >= pend)
 				goto out;	/* done */
 		}
 		if (end < pend) {
 			if (flags & MAP_SHARED)
 				printk(KERN_INFO
 				       "%s(%d): emulate_mmap() can't share tail (end=0x%lx)\n",
 				       current->comm, current->pid, end);
 			ret = mmap_subpage(file, max(start, PAGE_START(end)), end, prot, flags,
 					   (off + len) - offset_in_page(end));
 			if (IS_ERR((void *) ret))
 				return ret;
 			pend -= PAGE_SIZE;
 			if (pstart >= pend)
 				goto out;	/* done */
 		}
 	} else {
 		/*
 		 * If a start address was specified, use it if the entire rounded out area
 		 * is available.
 		 */
 		if (start && !pstart)
 			fudge = 1;	/* handle case of mapping to range (0,PAGE_SIZE) */
 		tmp = arch_get_unmapped_area(file, pstart - fudge, pend - pstart, 0, flags);
 		if (tmp != pstart) {
 			pstart = tmp;
 			start = pstart + offset_in_page(off);	/* make start congruent with off */
 			end = start + len;
 			pend = PAGE_ALIGN(end);
 		}
 	}
 	poff = off + (pstart - start);	/* note: (pstart - start) may be negative */
 	is_congruent = (flags & MAP_ANONYMOUS) || (offset_in_page(poff) == 0);
 	if ((flags & MAP_SHARED) && !is_congruent)
 		printk(KERN_INFO "%s(%d): emulate_mmap() can't share contents of incongruent mmap "
 		       "(addr=0x%lx,off=0x%llx)\n", current->comm, current->pid, start, off);
 	DBG("mmap_body: mapping [0x%lx-0x%lx) %s with poff 0x%llx\n", pstart, pend,
 	    is_congruent ? "congruent" : "not congruent", poff);
 	down_write(&current->mm->mmap_sem);
 	{
 		if (!(flags & MAP_ANONYMOUS) && is_congruent)
 			ret = do_mmap(file, pstart, pend - pstart, prot, flags | MAP_FIXED, poff);
 		else
 			ret = do_mmap(NULL, pstart, pend - pstart,
 				      prot | ((flags & MAP_ANONYMOUS) ? 0 : PROT_WRITE),
 				      flags | MAP_FIXED | MAP_ANONYMOUS, 0);
 	}
 	up_write(&current->mm->mmap_sem);
 	if (IS_ERR((void *) ret))
 		return ret;
 	if (!is_congruent) {
 		/* read the file contents */
 		inode = file->f_path.dentry->d_inode;
 		if (!inode->i_fop || !file->f_op->read
 		    || ((*file->f_op->read)(file, (char __user *) pstart, pend - pstart, &poff)
 			< 0))
 		{
 			sys_munmap(pstart, pend - pstart);
 			return -EINVAL;
 		}
 		if (!(prot & PROT_WRITE) && sys_mprotect(pstart, pend - pstart, prot) < 0)
 			return -EINVAL;
 	}
 	if (!(flags & MAP_FIXED))
 		ia32_set_pp((unsigned int)start, (unsigned int)end, flags);
 out:
 	return start;
 }
 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
 static inline unsigned int
 get_prot32 (unsigned int prot)
 {
 	if (prot & PROT_WRITE)
 		/* on x86, PROT_WRITE implies PROT_READ which implies PROT_EEC */
 		prot |= PROT_READ | PROT_WRITE | PROT_EXEC;
 	else if (prot & (PROT_READ | PROT_EXEC))
 		/* on x86, there is no distinction between PROT_READ and PROT_EXEC */
 		prot |= (PROT_READ | PROT_EXEC);
 	return prot;
 }
 unsigned long
 ia32_do_mmap (struct file *file, unsigned long addr, unsigned long len, int prot, int flags,
 	      loff_t offset)
 {
 	DBG("ia32_do_mmap(file=%p,addr=0x%lx,len=0x%lx,prot=%x,flags=%x,offset=0x%llx)\n",
 	    file, addr, len, prot, flags, offset);
 	if (file && (!file->f_op || !file->f_op->mmap))
 		return -ENODEV;
 	len = IA32_PAGE_ALIGN(len);
 	if (len == 0)
 		return addr;
 	if (len > IA32_PAGE_OFFSET || addr > IA32_PAGE_OFFSET - len)
 	{
 		if (flags & MAP_FIXED)
 			return -ENOMEM;
 		else
 		return -EINVAL;
 	}
 	if (OFFSET4K(offset))
 		return -EINVAL;
 	prot = get_prot32(prot);
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 	mutex_lock(&ia32_mmap_mutex);
 	{
 		addr = emulate_mmap(file, addr, len, prot, flags, offset);
 	}
 	mutex_unlock(&ia32_mmap_mutex);
 #else
 	down_write(&current->mm->mmap_sem);
 	{
 		addr = do_mmap(file, addr, len, prot, flags, offset);
 	}
 	up_write(&current->mm->mmap_sem);
 #endif
 	DBG("ia32_do_mmap: returning 0x%lx\n", addr);
 	return addr;
 }
 /*
  * Linux/i386 didn't use to be able to handle more than 4 system call parameters, so these
  * system calls used a memory block for parameter passing..
  */
 struct mmap_arg_struct {
 	unsigned int addr;
 	unsigned int len;
 	unsigned int prot;
 	unsigned int flags;
 	unsigned int fd;
 	unsigned int offset;
 };
 asmlinkage long
 sys32_mmap (struct mmap_arg_struct __user *arg)
 {
 	struct mmap_arg_struct a;
 	struct file *file = NULL;
 	unsigned long addr;
 	int flags;
 	if (copy_from_user(&a, arg, sizeof(a)))
 		return -EFAULT;
 	if (OFFSET4K(a.offset))
 		return -EINVAL;
 	flags = a.flags;
 	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 	if (!(flags & MAP_ANONYMOUS)) {
 		file = fget(a.fd);
 		if (!file)
 			return -EBADF;
 	}
 	addr = ia32_do_mmap(file, a.addr, a.len, a.prot, flags, a.offset);
 	if (file)
 		fput(file);
 	return addr;
 }
 asmlinkage long
 sys32_mmap2 (unsigned int addr, unsigned int len, unsigned int prot, unsigned int flags,
 	     unsigned int fd, unsigned int pgoff)
 {
 	struct file *file = NULL;
 	unsigned long retval;
 	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 	if (!(flags & MAP_ANONYMOUS)) {
 		file = fget(fd);
 		if (!file)
 			return -EBADF;
 	}
 	retval = ia32_do_mmap(file, addr, len, prot, flags,
 			      (unsigned long) pgoff << IA32_PAGE_SHIFT);
 	if (file)
 		fput(file);
 	return retval;
 }
 asmlinkage long
 sys32_munmap (unsigned int start, unsigned int len)
 {
 	unsigned int end = start + len;
 	long ret;
 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
 	ret = sys_munmap(start, end - start);
 #else
 	if (OFFSET4K(start))
 		return -EINVAL;
 	end = IA32_PAGE_ALIGN(end);
 	if (start >= end)
 		return -EINVAL;
 	ret = ia32_unset_pp(&start, &end);
 	if (ret < 0)
 		return ret;
 	if (start >= end)
 		return 0;
 	mutex_lock(&ia32_mmap_mutex);
 	ret = sys_munmap(start, end - start);
 	mutex_unlock(&ia32_mmap_mutex);
 #endif
 	return ret;
 }
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 /*
  * When mprotect()ing a partial page, we set the permission to the union of the old
  * settings and the new settings.  In other words, it's only possible to make access to a
  * partial page less restrictive.
  */
 static long
 mprotect_subpage (unsigned long address, int new_prot)
 {
 	int old_prot;
 	struct vm_area_struct *vma;
 	if (new_prot == PROT_NONE)
 		return 0;		/* optimize case where nothing changes... */
 	vma = find_vma(current->mm, address);
 	old_prot = get_page_prot(vma, address);
 	return sys_mprotect(address, PAGE_SIZE, new_prot | old_prot);
 }
 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
 asmlinkage long
 sys32_mprotect (unsigned int start, unsigned int len, int prot)
 {
 	unsigned int end = start + len;
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
 	long retval = 0;
 #endif
 	prot = get_prot32(prot);
 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
 	return sys_mprotect(start, end - start, prot);
 #else
 	if (OFFSET4K(start))
 		return -EINVAL;
 	end = IA32_PAGE_ALIGN(end);
 	if (end < start)
 		return -EINVAL;
 	retval = ia32_compare_pp(&start, &end);
 	if (retval < 0)
 		return retval;
 	mutex_lock(&ia32_mmap_mutex);
 	{
 		if (offset_in_page(start)) {
 			/* start address is 4KB aligned but not page aligned. */
 			retval = mprotect_subpage(PAGE_START(start), prot);
 			if (retval < 0)
 				goto out;
 			start = PAGE_ALIGN(start);
 			if (start >= end)
 				goto out;	/* retval is already zero... */
 		}
 		if (offset_in_page(end)) {
 			/* end address is 4KB aligned but not page aligned. */
 			retval = mprotect_subpage(PAGE_START(end), prot);
 			if (retval < 0)
 				goto out;
 			end = PAGE_START(end);
 		}
 		retval = sys_mprotect(start, end - start, prot);
 	}
   out:
 	mutex_unlock(&ia32_mmap_mutex);
 	return retval;
 #endif
 }
 asmlinkage long
 sys32_mremap (unsigned int addr, unsigned int old_len, unsigned int new_len,
 		unsigned int flags, unsigned int new_addr)
 {
 	long ret;
 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
 	ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
 #else
 	unsigned int old_end, new_end;
 	if (OFFSET4K(addr))
 		return -EINVAL;
 	old_len = IA32_PAGE_ALIGN(old_len);
 	new_len = IA32_PAGE_ALIGN(new_len);
 	old_end = addr + old_len;
 	new_end = addr + new_len;
 	if (!new_len)
 		return -EINVAL;
 	if ((flags & MREMAP_FIXED) && (OFFSET4K(new_addr)))
 		return -EINVAL;
 	if (old_len >= new_len) {
 		ret = sys32_munmap(addr + new_len, old_len - new_len);
 		if (ret && old_len != new_len)
 			return ret;
 		ret = addr;
 		if (!(flags & MREMAP_FIXED) || (new_addr == addr))
 			return ret;
 		old_len = new_len;
 	}
 	addr = PAGE_START(addr);
 	old_len = PAGE_ALIGN(old_end) - addr;
 	new_len = PAGE_ALIGN(new_end) - addr;
 	mutex_lock(&ia32_mmap_mutex);
 	ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
 	mutex_unlock(&ia32_mmap_mutex);
 	if ((ret >= 0) && (old_len < new_len)) {
 		/* mremap expanded successfully */
 		ia32_set_pp(old_end, new_end, flags);
 	}
 #endif
 	return ret;
 }
 asmlinkage long
 sys32_pipe (int __user *fd)
 {
 	int retval;
 	int fds[2];
 	retval = do_pipe(fds);
 	if (retval)
 		goto out;
 	if (copy_to_user(fd, fds, sizeof(fds)))
 		retval = -EFAULT;
   out:
 	return retval;
 }
 static inline long
 get_tv32 (struct timeval *o, struct compat_timeval __user *i)
 {
 	return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
 		(__get_user(o->tv_sec, &i->tv_sec) | __get_user(o->tv_usec, &i->tv_usec)));
 }
 static inline long
 put_tv32 (struct compat_timeval __user *o, struct timeval *i)
 {
 	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 		(__put_user(i->tv_sec, &o->tv_sec) | __put_user(i->tv_usec, &o->tv_usec)));
 }
 asmlinkage unsigned long
 sys32_alarm (unsigned int seconds)
 {
 	return alarm_setitimer(seconds);
 }
 /* Translations due to time_t size differences.  Which affects all
    sorts of things, like timeval and itimerval.  */
 extern struct timezone sys_tz;
 asmlinkage long
 sys32_gettimeofday (struct compat_timeval __user *tv, struct timezone __user *tz)
 {
 	if (tv) {
 		struct timeval ktv;
 		do_gettimeofday(&ktv);
 		if (put_tv32(tv, &ktv))
 			return -EFAULT;
 	}
 	if (tz) {
 		if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 			return -EFAULT;
 	}
 	return 0;
 }
 asmlinkage long
 sys32_settimeofday (struct compat_timeval __user *tv, struct timezone __user *tz)
 {
 	struct timeval ktv;
 	struct timespec kts;
 	struct timezone ktz;
 	if (tv) {
 		if (get_tv32(&ktv, tv))
 			return -EFAULT;
 		kts.tv_sec = ktv.tv_sec;
 		kts.tv_nsec = ktv.tv_usec * 1000;
 	}
 	if (tz) {
 		if (copy_from_user(&ktz, tz, sizeof(ktz)))
 			return -EFAULT;
 	}
 	return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
 }
 struct getdents32_callback {
 	struct compat_dirent __user *current_dir;
 	struct compat_dirent __user *previous;
 	int count;
 	int error;
 };
 struct readdir32_callback {
 	struct old_linux32_dirent __user * dirent;
 	int count;
 };
 static int
 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, u64 ino,
 	   unsigned int d_type)
 {
 	struct compat_dirent __user * dirent;
 	struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
 	int reclen = ROUND_UP(offsetof(struct compat_dirent, d_name) + namlen + 1, 4);
 	u32 d_ino;
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
 	d_ino = ino;
 	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
 		return -EOVERFLOW;
 	buf->error = -EFAULT;	/* only used if we fail.. */
 	dirent = buf->previous;
 	if (dirent)
 		if (put_user(offset, &dirent->d_off))
 			return -EFAULT;
 	dirent = buf->current_dir;
 	buf->previous = dirent;
 	if (put_user(d_ino, &dirent->d_ino)
 	    || put_user(reclen, &dirent->d_reclen)
 	    || copy_to_user(dirent->d_name, name, namlen)
 	    || put_user(0, dirent->d_name + namlen))
 		return -EFAULT;
 	dirent = (struct compat_dirent __user *) ((char __user *) dirent + reclen);
 	buf->current_dir = dirent;
 	buf->count -= reclen;
 	return 0;
 }
 asmlinkage long
 sys32_getdents (unsigned int fd, struct compat_dirent __user *dirent, unsigned int count)
 {
 	struct file * file;
 	struct compat_dirent __user * lastdirent;
 	struct getdents32_callback buf;
 	int error;
 	error = -EFAULT;
 	if (!access_ok(VERIFY_WRITE, dirent, count))
 		goto out;
 	error = -EBADF;
 	file = fget(fd);
 	if (!file)
 		goto out;
 	buf.current_dir = dirent;
 	buf.previous = NULL;
 	buf.count = count;
 	buf.error = 0;
 	error = vfs_readdir(file, filldir32, &buf);
 	if (error < 0)
 		goto out_putf;
 	error = buf.error;
 	lastdirent = buf.previous;
 	if (lastdirent) {
 		if (put_user(file->f_pos, &lastdirent->d_off))
 			error = -EFAULT;
 		else
 			error = count - buf.count;
 	}
 out_putf:
 	fput(file);
 out:
 	return error;
 }
 static int
 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, u64 ino,
 	      unsigned int d_type)
 {
 	struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
 	struct old_linux32_dirent __user * dirent;
 	u32 d_ino;
 	if (buf->count)
 		return -EINVAL;
 	d_ino = ino;
 	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
 		return -EOVERFLOW;
 	buf->count++;
 	dirent = buf->dirent;
 	if (put_user(d_ino, &dirent->d_ino)
 	    || put_user(offset, &dirent->d_offset)
 	    || put_user(namlen, &dirent->d_namlen)
 	    || copy_to_user(dirent->d_name, name, namlen)
 	    || put_user(0, dirent->d_name + namlen))
 		return -EFAULT;
 	return 0;
 }
 asmlinkage long
 sys32_readdir (unsigned int fd, void __user *dirent, unsigned int count)
 {
 	int error;
 	struct file * file;
 	struct readdir32_callback buf;
 	error = -EBADF;
 	file = fget(fd);
 	if (!file)
 		goto out;
 	buf.count = 0;
 	buf.dirent = dirent;
 	error = vfs_readdir(file, fillonedir32, &buf);
 	if (error >= 0)
 		error = buf.count;
 	fput(file);
 out:
 	return error;
 }
 struct sel_arg_struct {
 	unsigned int n;
 	unsigned int inp;
 	unsigned int outp;
 	unsigned int exp;
 	unsigned int tvp;
 };
 asmlinkage long
 sys32_old_select (struct sel_arg_struct __user *arg)
 {
 	struct sel_arg_struct a;
 	if (copy_from_user(&a, arg, sizeof(a)))
 		return -EFAULT;
 	return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
 				 compat_ptr(a.exp), compat_ptr(a.tvp));
 }
 #define SEMOP		 1
 #define SEMGET		 2
 #define SEMCTL		 3
 #define SEMTIMEDOP	 4
 #define MSGSND		11
 #define MSGRCV		12
 #define MSGGET		13
 #define MSGCTL		14
 #define SHMAT		21
 #define SHMDT		22
 #define SHMGET		23
 #define SHMCTL		24
 asmlinkage long
 sys32_ipc(u32 call, int first, int second, int third, u32 ptr, u32 fifth)
 {
 	int version;
 	version = call >> 16; /* hack for backward compatibility */
 	call &= 0xffff;
 	switch (call) {
 	      case SEMTIMEDOP:
 		if (fifth)
 			return compat_sys_semtimedop(first, compat_ptr(ptr),
 				second, compat_ptr(fifth));
 		/* else fall through for normal semop() */
 	      case SEMOP:
 		/* struct sembuf is the same on 32 and 64bit :)) */
 		return sys_semtimedop(first, compat_ptr(ptr), second,
 				      NULL);
 	      case SEMGET:
 		return sys_semget(first, second, third);
 	      case SEMCTL:
 		return compat_sys_semctl(first, second, third, compat_ptr(ptr));
 	      case MSGSND:
 		return compat_sys_msgsnd(first, second, third, compat_ptr(ptr));
 	      case MSGRCV:
 		return compat_sys_msgrcv(first, second, fifth, third, version, compat_ptr(ptr));
 	      case MSGGET:
 		return sys_msgget((key_t) first, second);
 	      case MSGCTL:
 		return compat_sys_msgctl(first, second, compat_ptr(ptr));
 	      case SHMAT:
 		return compat_sys_shmat(first, second, third, version, compat_ptr(ptr));
 		break;
 	      case SHMDT:
 		return sys_shmdt(compat_ptr(ptr));
 	      case SHMGET:
 		return sys_shmget(first, (unsigned)second, third);
 	      case SHMCTL:
 		return compat_sys_shmctl(first, second, compat_ptr(ptr));
 	      default:
 		return -ENOSYS;
 	}
 	return -EINVAL;
 }
 asmlinkage long
 compat_sys_wait4 (compat_pid_t pid, compat_uint_t * stat_addr, int options,
 		 struct compat_rusage *ru);
 asmlinkage long
 sys32_waitpid (int pid, unsigned int *stat_addr, int options)
 {
 	return compat_sys_wait4(pid, stat_addr, options, NULL);
 }
 static unsigned int
 ia32_peek (struct task_struct *child, unsigned long addr, unsigned int *val)
 {
 	size_t copied;
 	unsigned int ret;
 	copied = access_process_vm(child, addr, val, sizeof(*val), 0);
 	return (copied != sizeof(ret)) ? -EIO : 0;
 }
 static unsigned int
 ia32_poke (struct task_struct *child, unsigned long addr, unsigned int val)
 {
 	if (access_process_vm(child, addr, &val, sizeof(val), 1) != sizeof(val))
 		return -EIO;
 	return 0;
 }
 /*
  *  The order in which registers are stored in the ptrace regs structure
  */
 #define PT_EBX	0
 #define PT_ECX	1
 #define PT_EDX	2
 #define PT_ESI	3
 #define PT_EDI	4
 #define PT_EBP	5
 #define PT_EAX	6
 #define PT_DS	7
 #define PT_ES	8
 #define PT_FS	9
 #define PT_GS	10
 #define PT_ORIG_EAX 11
 #define PT_EIP	12
 #define PT_CS	13
 #define PT_EFL	14
 #define PT_UESP	15
 #define PT_SS	16
 static unsigned int
 getreg (struct task_struct *child, int regno)
 {
 	struct pt_regs *child_regs;
 	child_regs = task_pt_regs(child);
 	switch (regno / sizeof(int)) {
 	      case PT_EBX: return child_regs->r11;
 	      case PT_ECX: return child_regs->r9;
 	      case PT_EDX: return child_regs->r10;
 	      case PT_ESI: return child_regs->r14;
 	      case PT_EDI: return child_regs->r15;
 	      case PT_EBP: return child_regs->r13;
 	      case PT_EAX: return child_regs->r8;
 	      case PT_ORIG_EAX: return child_regs->r1; /* see dispatch_to_ia32_handler() */
 	      case PT_EIP: return child_regs->cr_iip;
 	      case PT_UESP: return child_regs->r12;
 	      case PT_EFL: return child->thread.eflag;
 	      case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
 		return __USER_DS;
 	      case PT_CS: return __USER_CS;
 	      default:
 		printk(KERN_ERR "ia32.getreg(): unknown register %d\n", regno);
 		break;
 	}
 	return 0;
 }
 static void
 putreg (struct task_struct *child, int regno, unsigned int value)
 {
 	struct pt_regs *child_regs;
 	child_regs = task_pt_regs(child);
 	switch (regno / sizeof(int)) {
 	      case PT_EBX: child_regs->r11 = value; break;
 	      case PT_ECX: child_regs->r9 = value; break;
 	      case PT_EDX: child_regs->r10 = value; break;
 	      case PT_ESI: child_regs->r14 = value; break;
 	      case PT_EDI: child_regs->r15 = value; break;
 	      case PT_EBP: child_regs->r13 = value; break;
 	      case PT_EAX: child_regs->r8 = value; break;
 	      case PT_ORIG_EAX: child_regs->r1 = value; break;
 	      case PT_EIP: child_regs->cr_iip = value; break;
 	      case PT_UESP: child_regs->r12 = value; break;
 	      case PT_EFL: child->thread.eflag = value; break;
 	      case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
 		if (value != __USER_DS)
 			printk(KERN_ERR
 			       "ia32.putreg: attempt to set invalid segment register %d = %x\n",
 			       regno, value);
 		break;
 	      case PT_CS:
 		if (value != __USER_CS)
 			printk(KERN_ERR
 			       "ia32.putreg: attempt to to set invalid segment register %d = %x\n",
 			       regno, value);
 		break;
 	      default:
 		printk(KERN_ERR "ia32.putreg: unknown register %d\n", regno);
 		break;
 	}
 }
 static void
 put_fpreg (int regno, struct _fpreg_ia32 __user *reg, struct pt_regs *ptp,
 	   struct switch_stack *swp, int tos)
 {
 	struct _fpreg_ia32 *f;
 	char buf[32];
 	f = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
 	if ((regno += tos) >= 8)
 		regno -= 8;
 	switch (regno) {
 	      case 0:
 		ia64f2ia32f(f, &ptp->f8);
 		break;
 	      case 1:
 		ia64f2ia32f(f, &ptp->f9);
 		break;
 	      case 2:
 		ia64f2ia32f(f, &ptp->f10);
 		break;
 	      case 3:
 		ia64f2ia32f(f, &ptp->f11);
 		break;
 	      case 4:
 	      case 5:
 	      case 6:
 	      case 7:
 		ia64f2ia32f(f, &swp->f12 + (regno - 4));
 		break;
 	}
 	copy_to_user(reg, f, sizeof(*reg));
 }
 static void
 get_fpreg (int regno, struct _fpreg_ia32 __user *reg, struct pt_regs *ptp,
 	   struct switch_stack *swp, int tos)
 {
 	if ((regno += tos) >= 8)
 		regno -= 8;
 	switch (regno) {
 	      case 0:
 		copy_from_user(&ptp->f8, reg, sizeof(*reg));
 		break;
 	      case 1:
 		copy_from_user(&ptp->f9, reg, sizeof(*reg));
 		break;
 	      case 2:
 		copy_from_user(&ptp->f10, reg, sizeof(*reg));
 		break;
 	      case 3:
 		copy_from_user(&ptp->f11, reg, sizeof(*reg));
 		break;
 	      case 4:
 	      case 5:
 	      case 6:
 	      case 7:
 		copy_from_user(&swp->f12 + (regno - 4), reg, sizeof(*reg));
 		break;
 	}
 	return;
 }
 int
 save_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct __user *save)
 {
 	struct switch_stack *swp;
 	struct pt_regs *ptp;
 	int i, tos;
 	if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
 		return -EFAULT;
 	__put_user(tsk->thread.fcr & 0xffff, &save->cwd);
 	__put_user(tsk->thread.fsr & 0xffff, &save->swd);
 	__put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
 	__put_user(tsk->thread.fir, &save->fip);
 	__put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
 	__put_user(tsk->thread.fdr, &save->foo);
 	__put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
 	/*
 	 *  Stack frames start with 16-bytes of temp space
 	 */
 	swp = (struct switch_stack *)(tsk->thread.ksp + 16);
 	ptp = task_pt_regs(tsk);
 	tos = (tsk->thread.fsr >> 11) & 7;
 	for (i = 0; i < 8; i++)
 		put_fpreg(i, &save->st_space[i], ptp, swp, tos);
 	return 0;
 }
 static int
 restore_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct __user *save)
 {
 	struct switch_stack *swp;
 	struct pt_regs *ptp;
 	int i, tos;
 	unsigned int fsrlo, fsrhi, num32;
 	if (!access_ok(VERIFY_READ, save, sizeof(*save)))
 		return(-EFAULT);
 	__get_user(num32, (unsigned int __user *)&save->cwd);
 	tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
 	__get_user(fsrlo, (unsigned int __user *)&save->swd);
 	__get_user(fsrhi, (unsigned int __user *)&save->twd);
 	num32 = (fsrhi << 16) | fsrlo;
 	tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
 	__get_user(num32, (unsigned int __user *)&save->fip);
 	tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
 	__get_user(num32, (unsigned int __user *)&save->foo);
 	tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
 	/*
 	 *  Stack frames start with 16-bytes of temp space
 	 */
 	swp = (struct switch_stack *)(tsk->thread.ksp + 16);
 	ptp = task_pt_regs(tsk);
 	tos = (tsk->thread.fsr >> 11) & 7;
 	for (i = 0; i < 8; i++)
 		get_fpreg(i, &save->st_space[i], ptp, swp, tos);
 	return 0;
 }
 int
 save_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __user *save)
 {
 	struct switch_stack *swp;
 	struct pt_regs *ptp;
 	int i, tos;
 	unsigned long mxcsr=0;
 	unsigned long num128[2];
 	if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
 		return -EFAULT;
 	__put_user(tsk->thread.fcr & 0xffff, &save->cwd);
 	__put_user(tsk->thread.fsr & 0xffff, &save->swd);
 	__put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
 	__put_user(tsk->thread.fir, &save->fip);
 	__put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
 	__put_user(tsk->thread.fdr, &save->foo);
 	__put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
         /*
          *  Stack frames start with 16-bytes of temp space
          */
         swp = (struct switch_stack *)(tsk->thread.ksp + 16);
         ptp = task_pt_regs(tsk);
 	tos = (tsk->thread.fsr >> 11) & 7;
         for (i = 0; i < 8; i++)
 		put_fpreg(i, (struct _fpreg_ia32 __user *)&save->st_space[4*i], ptp, swp, tos);
 	mxcsr = ((tsk->thread.fcr>>32) & 0xff80) | ((tsk->thread.fsr>>32) & 0x3f);
 	__put_user(mxcsr & 0xffff, &save->mxcsr);
 	for (i = 0; i < 8; i++) {
 		memcpy(&(num128[0]), &(swp->f16) + i*2, sizeof(unsigned long));
 		memcpy(&(num128[1]), &(swp->f17) + i*2, sizeof(unsigned long));
 		copy_to_user(&save->xmm_space[0] + 4*i, num128, sizeof(struct _xmmreg_ia32));
 	}
 	return 0;
 }
 static int
 restore_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __user *save)
 {
 	struct switch_stack *swp;
 	struct pt_regs *ptp;
 	int i, tos;
 	unsigned int fsrlo, fsrhi, num32;
 	int mxcsr;
 	unsigned long num64;
 	unsigned long num128[2];
 	if (!access_ok(VERIFY_READ, save, sizeof(*save)))
 		return(-EFAULT);
 	__get_user(num32, (unsigned int __user *)&save->cwd);
 	tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
 	__get_user(fsrlo, (unsigned int __user *)&save->swd);
 	__get_user(fsrhi, (unsigned int __user *)&save->twd);
 	num32 = (fsrhi << 16) | fsrlo;
 	tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
 	__get_user(num32, (unsigned int __user *)&save->fip);
 	tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
 	__get_user(num32, (unsigned int __user *)&save->foo);
 	tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
 	/*
 	 *  Stack frames start with 16-bytes of temp space
 	 */
 	swp = (struct switch_stack *)(tsk->thread.ksp + 16);
 	ptp = task_pt_regs(tsk);
 	tos = (tsk->thread.fsr >> 11) & 7;
 	for (i = 0; i < 8; i++)
 	get_fpreg(i, (struct _fpreg_ia32 __user *)&save->st_space[4*i], ptp, swp, tos);
 	__get_user(mxcsr, (unsigned int __user *)&save->mxcsr);
 	num64 = mxcsr & 0xff10;
 	tsk->thread.fcr = (tsk->thread.fcr & (~0xff1000000000UL)) | (num64<<32);
 	num64 = mxcsr & 0x3f;
 	tsk->thread.fsr = (tsk->thread.fsr & (~0x3f00000000UL)) | (num64<<32);
 	for (i = 0; i < 8; i++) {
 		copy_from_user(num128, &save->xmm_space[0] + 4*i, sizeof(struct _xmmreg_ia32));
 		memcpy(&(swp->f16) + i*2, &(num128[0]), sizeof(unsigned long));
 		memcpy(&(swp->f17) + i*2, &(num128[1]), sizeof(unsigned long));
 	}
 	return 0;
 }
 asmlinkage long
 sys32_ptrace (int request, pid_t pid, unsigned int addr, unsigned int data)
 {
 	struct task_struct *child;
 	unsigned int value, tmp;
 	long i, ret;
 	lock_kernel();
 	if (request == PTRACE_TRACEME) {
 		ret = ptrace_traceme();
 		goto out;
 	}
 	child = ptrace_get_task_struct(pid);
 	if (IS_ERR(child)) {
 		ret = PTR_ERR(child);
 		goto out;
 	}
 	if (request == PTRACE_ATTACH) {
 		ret = sys_ptrace(request, pid, addr, data);
 		goto out_tsk;
 	}
 	ret = ptrace_check_attach(child, request == PTRACE_KILL);
 	if (ret < 0)
 		goto out_tsk;
 	switch (request) {
 	      case PTRACE_PEEKTEXT:
 	      case PTRACE_PEEKDATA:	/* read word at location addr */
 		ret = ia32_peek(child, addr, &value);
 		if (ret == 0)
 			ret = put_user(value, (unsigned int __user *) compat_ptr(data));
 		else
 			ret = -EIO;
 		goto out_tsk;
 	      case PTRACE_POKETEXT:
 	      case PTRACE_POKEDATA:	/* write the word at location addr */
 		ret = ia32_poke(child, addr, data);
 		goto out_tsk;
 	      case PTRACE_PEEKUSR:	/* read word at addr in USER area */
 		ret = -EIO;
 		if ((addr & 3) || addr > 17*sizeof(int))
 			break;
 		tmp = getreg(child, addr);
 		if (!put_user(tmp, (unsigned int __user *) compat_ptr(data)))
 			ret = 0;
 		break;
 	      case PTRACE_POKEUSR:	/* write word at addr in USER area */
 		ret = -EIO;
 		if ((addr & 3) || addr > 17*sizeof(int))
 			break;
 		putreg(child, addr, data);
 		ret = 0;
 		break;
 	      case IA32_PTRACE_GETREGS:
 		if (!access_ok(VERIFY_WRITE, compat_ptr(data), 17*sizeof(int))) {
 			ret = -EIO;
 			break;
 		}
 		for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
 			put_user(getreg(child, i), (unsigned int __user *) compat_ptr(data));
 			data += sizeof(int);
 		}
 		ret = 0;
 		break;
 	      case IA32_PTRACE_SETREGS:
 		if (!access_ok(VERIFY_READ, compat_ptr(data), 17*sizeof(int))) {
 			ret = -EIO;
 			break;
 		}
 		for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
 			get_user(tmp, (unsigned int __user *) compat_ptr(data));
 			putreg(child, i, tmp);
 			data += sizeof(int);
 		}
 		ret = 0;
 		break;
 	      case IA32_PTRACE_GETFPREGS:
 		ret = save_ia32_fpstate(child, (struct ia32_user_i387_struct __user *)
 					compat_ptr(data));
 		break;
 	      case IA32_PTRACE_GETFPXREGS:
 		ret = save_ia32_fpxstate(child, (struct ia32_user_fxsr_struct __user *)
 					 compat_ptr(data));
 		break;
 	      case IA32_PTRACE_SETFPREGS:
 		ret = restore_ia32_fpstate(child, (struct ia32_user_i387_struct __user *)
 					   compat_ptr(data));
 		break;
 	      case IA32_PTRACE_SETFPXREGS:
 		ret = restore_ia32_fpxstate(child, (struct ia32_user_fxsr_struct __user *)
 					    compat_ptr(data));
 		break;
 	      case PTRACE_GETEVENTMSG:
 		ret = put_user(child->ptrace_message, (unsigned int __user *) compat_ptr(data));
 		break;
 	      case PTRACE_SYSCALL:	/* continue, stop after next syscall */
 	      case PTRACE_CONT:		/* restart after signal. */
 	      case PTRACE_KILL:
 	      case PTRACE_SINGLESTEP:	/* execute chile for one instruction */
 	      case PTRACE_DETACH:	/* detach a process */
 		ret = sys_ptrace(request, pid, addr, data);
 		break;
 	      default:
 		ret = ptrace_request(child, request, addr, data);
 		break;
 	}
   out_tsk:
 	put_task_struct(child);
   out:
 	unlock_kernel();
 	return ret;
 }
 typedef struct {
 	unsigned int	ss_sp;
 	unsigned int	ss_flags;
 	unsigned int	ss_size;
 } ia32_stack_t;
 asmlinkage long
 sys32_sigaltstack (ia32_stack_t __user *uss32, ia32_stack_t __user *uoss32,
 		   long arg2, long arg3, long arg4, long arg5, long arg6,
 		   long arg7, struct pt_regs pt)
 {
 	stack_t uss, uoss;
 	ia32_stack_t buf32;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	if (uss32) {
 		if (copy_from_user(&buf32, uss32, sizeof(ia32_stack_t)))
 			return -EFAULT;
 		uss.ss_sp = (void __user *) (long) buf32.ss_sp;
 		uss.ss_flags = buf32.ss_flags;
 		/* MINSIGSTKSZ is different for ia32 vs ia64. We lie here to pass the
 	           check and set it to the user requested value later */
 		if ((buf32.ss_flags != SS_DISABLE) && (buf32.ss_size < MINSIGSTKSZ_IA32)) {
 			ret = -ENOMEM;
 			goto out;
 		}
 		uss.ss_size = MINSIGSTKSZ;
 	}
 	set_fs(KERNEL_DS);
 	ret = do_sigaltstack(uss32 ? (stack_t __user *) &uss : NULL,
 			     (stack_t __user *) &uoss, pt.r12);
  	current->sas_ss_size = buf32.ss_size;
 	set_fs(old_fs);
 out:
 	if (ret < 0)
 		return(ret);
 	if (uoss32) {
 		buf32.ss_sp = (long __user) uoss.ss_sp;
 		buf32.ss_flags = uoss.ss_flags;
 		buf32.ss_size = uoss.ss_size;
 		if (copy_to_user(uoss32, &buf32, sizeof(ia32_stack_t)))
 			return -EFAULT;
 	}
 	return ret;
 }
 asmlinkage int
 sys32_pause (void)
 {
 	current->state = TASK_INTERRUPTIBLE;
 	schedule();
 	return -ERESTARTNOHAND;
 }
 asmlinkage int
 sys32_msync (unsigned int start, unsigned int len, int flags)
 {
 	unsigned int addr;
 	if (OFFSET4K(start))
 		return -EINVAL;
 	addr = PAGE_START(start);
 	return sys_msync(addr, len + (start - addr), flags);
 }
 struct sysctl32 {
 	unsigned int	name;
 	int		nlen;
 	unsigned int	oldval;
 	unsigned int	oldlenp;
 	unsigned int	newval;
 	unsigned int	newlen;
 	unsigned int	__unused[4];
 };
 #ifdef CONFIG_SYSCTL_SYSCALL
 asmlinkage long
 sys32_sysctl (struct sysctl32 __user *args)
 {
 	struct sysctl32 a32;
 	mm_segment_t old_fs = get_fs ();
 	void __user *oldvalp, *newvalp;
 	size_t oldlen;
 	int __user *namep;
 	long ret;
 	if (copy_from_user(&a32, args, sizeof(a32)))
 		return -EFAULT;
 	/*
 	 * We need to pre-validate these because we have to disable address checking
 	 * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
 	 * user specifying bad addresses here.  Well, since we're dealing with 32 bit
 	 * addresses, we KNOW that access_ok() will always succeed, so this is an
 	 * expensive NOP, but so what...
 	 */
 	namep = (int __user *) compat_ptr(a32.name);
 	oldvalp = compat_ptr(a32.oldval);
 	newvalp = compat_ptr(a32.newval);
 	if ((oldvalp && get_user(oldlen, (int __user *) compat_ptr(a32.oldlenp)))
 	    || !access_ok(VERIFY_WRITE, namep, 0)
 	    || !access_ok(VERIFY_WRITE, oldvalp, 0)
 	    || !access_ok(VERIFY_WRITE, newvalp, 0))
 		return -EFAULT;
 	set_fs(KERNEL_DS);
 	lock_kernel();
 	ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *) &oldlen,
 			newvalp, (size_t) a32.newlen);
 	unlock_kernel();
 	set_fs(old_fs);
 	if (oldvalp && put_user (oldlen, (int __user *) compat_ptr(a32.oldlenp)))
 		return -EFAULT;
 	return ret;
 }
 #endif
 asmlinkage long
 sys32_newuname (struct new_utsname __user *name)
 {
 	int ret = sys_newuname(name);
 	if (!ret)
 		if (copy_to_user(name->machine, "i686\0\0\0", 8))
 			ret = -EFAULT;
 	return ret;
 }
 asmlinkage long
 sys32_getresuid16 (u16 __user *ruid, u16 __user *euid, u16 __user *suid)
 {
 	uid_t a, b, c;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_getresuid((uid_t __user *) &a, (uid_t __user *) &b, (uid_t __user *) &c);
 	set_fs(old_fs);
 	if (put_user(a, ruid) || put_user(b, euid) || put_user(c, suid))
 		return -EFAULT;
 	return ret;
 }
 asmlinkage long
 sys32_getresgid16 (u16 __user *rgid, u16 __user *egid, u16 __user *sgid)
 {
 	gid_t a, b, c;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_getresgid((gid_t __user *) &a, (gid_t __user *) &b, (gid_t __user *) &c);
 	set_fs(old_fs);
 	if (ret)
 		return ret;
 	return put_user(a, rgid) | put_user(b, egid) | put_user(c, sgid);
 }
 asmlinkage long
 sys32_lseek (unsigned int fd, int offset, unsigned int whence)
 {
 	/* Sign-extension of "offset" is important here... */
 	return sys_lseek(fd, offset, whence);
 }
 static int
 groups16_to_user(short __user *grouplist, struct group_info *group_info)
 {
 	int i;
 	short group;
 	for (i = 0; i < group_info->ngroups; i++) {
 		group = (short)GROUP_AT(group_info, i);
 		if (put_user(group, grouplist+i))
 			return -EFAULT;
 	}
 	return 0;
 }
 static int
 groups16_from_user(struct group_info *group_info, short __user *grouplist)
 {
 	int i;
 	short group;
 	for (i = 0; i < group_info->ngroups; i++) {
 		if (get_user(group, grouplist+i))
 			return  -EFAULT;
 		GROUP_AT(group_info, i) = (gid_t)group;
 	}
 	return 0;
 }
 asmlinkage long
 sys32_getgroups16 (int gidsetsize, short __user *grouplist)
 {
 	int i;
 	if (gidsetsize < 0)
 		return -EINVAL;
 	get_group_info(current->group_info);
 	i = current->group_info->ngroups;
 	if (gidsetsize) {
 		if (i > gidsetsize) {
 			i = -EINVAL;
 			goto out;
 		}
 		if (groups16_to_user(grouplist, current->group_info)) {
 			i = -EFAULT;
 			goto out;
 		}
 	}
 out:
 	put_group_info(current->group_info);
 	return i;
 }
 asmlinkage long
 sys32_setgroups16 (int gidsetsize, short __user *grouplist)
 {
 	struct group_info *group_info;
 	int retval;
 	if (!capable(CAP_SETGID))
 		return -EPERM;
 	if ((unsigned)gidsetsize > NGROUPS_MAX)
 		return -EINVAL;
 	group_info = groups_alloc(gidsetsize);
 	if (!group_info)
 		return -ENOMEM;
 	retval = groups16_from_user(group_info, grouplist);
 	if (retval) {
 		put_group_info(group_info);
 		return retval;
 	}
 	retval = set_current_groups(group_info);
 	put_group_info(group_info);
 	return retval;
 }
 asmlinkage long
 sys32_truncate64 (unsigned int path, unsigned int len_lo, unsigned int len_hi)
 {
 	return sys_truncate(compat_ptr(path), ((unsigned long) len_hi << 32) | len_lo);
 }
 asmlinkage long
 sys32_ftruncate64 (int fd, unsigned int len_lo, unsigned int len_hi)
 {
 	return sys_ftruncate(fd, ((unsigned long) len_hi << 32) | len_lo);
 }
 static int
 putstat64 (struct stat64 __user *ubuf, struct kstat *kbuf)
 {
 	int err;
 	u64 hdev;
 	if (clear_user(ubuf, sizeof(*ubuf)))
 		return -EFAULT;
 	hdev = huge_encode_dev(kbuf->dev);
 	err  = __put_user(hdev, (u32 __user*)&ubuf->st_dev);
 	err |= __put_user(hdev >> 32, ((u32 __user*)&ubuf->st_dev) + 1);
 	err |= __put_user(kbuf->ino, &ubuf->__st_ino);
 	err |= __put_user(kbuf->ino, &ubuf->st_ino_lo);
 	err |= __put_user(kbuf->ino >> 32, &ubuf->st_ino_hi);
 	err |= __put_user(kbuf->mode, &ubuf->st_mode);
 	err |= __put_user(kbuf->nlink, &ubuf->st_nlink);
 	err |= __put_user(kbuf->uid, &ubuf->st_uid);
 	err |= __put_user(kbuf->gid, &ubuf->st_gid);
 	hdev = huge_encode_dev(kbuf->rdev);
 	err  = __put_user(hdev, (u32 __user*)&ubuf->st_rdev);
 	err |= __put_user(hdev >> 32, ((u32 __user*)&ubuf->st_rdev) + 1);
 	err |= __put_user(kbuf->size, &ubuf->st_size_lo);
 	err |= __put_user((kbuf->size >> 32), &ubuf->st_size_hi);
 	err |= __put_user(kbuf->atime.tv_sec, &ubuf->st_atime);
 	err |= __put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec);
 	err |= __put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime);
 	err |= __put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec);
 	err |= __put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime);
 	err |= __put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec);
 	err |= __put_user(kbuf->blksize, &ubuf->st_blksize);
 	err |= __put_user(kbuf->blocks, &ubuf->st_blocks);
 	return err;
 }
 asmlinkage long
 sys32_stat64 (char __user *filename, struct stat64 __user *statbuf)
 {
 	struct kstat s;
 	long ret = vfs_stat(filename, &s);
 	if (!ret)
 		ret = putstat64(statbuf, &s);
 	return ret;
 }
 asmlinkage long
 sys32_lstat64 (char __user *filename, struct stat64 __user *statbuf)
 {
 	struct kstat s;
 	long ret = vfs_lstat(filename, &s);
 	if (!ret)
 		ret = putstat64(statbuf, &s);
 	return ret;
 }
 asmlinkage long
 sys32_fstat64 (unsigned int fd, struct stat64 __user *statbuf)
 {
 	struct kstat s;
 	long ret = vfs_fstat(fd, &s);
 	if (!ret)
 		ret = putstat64(statbuf, &s);
 	return ret;
 }
 asmlinkage long
 sys32_sched_rr_get_interval (pid_t pid, struct compat_timespec __user *interval)
 {
 	mm_segment_t old_fs = get_fs();
 	struct timespec t;
 	long ret;
 	set_fs(KERNEL_DS);
 	ret = sys_sched_rr_get_interval(pid, (struct timespec __user *) &t);
 	set_fs(old_fs);
 	if (put_compat_timespec(&t, interval))
 		return -EFAULT;
 	return ret;
 }
 asmlinkage long
 sys32_pread (unsigned int fd, void __user *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
 {
 	return sys_pread64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
 }
 asmlinkage long
 sys32_pwrite (unsigned int fd, void __user *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
 {
 	return sys_pwrite64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
 }
 asmlinkage long
 sys32_sendfile (int out_fd, int in_fd, int __user *offset, unsigned int count)
 {
 	mm_segment_t old_fs = get_fs();
 	long ret;
 	off_t of;
 	if (offset && get_user(of, offset))
 		return -EFAULT;
 	set_fs(KERNEL_DS);
 	ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *) &of : NULL, count);
 	set_fs(old_fs);
 	if (offset && put_user(of, offset))
 		return -EFAULT;
 	return ret;
 }
 asmlinkage long
 sys32_personality (unsigned int personality)
 {
 	long ret;
 	if (current->personality == PER_LINUX32 && personality == PER_LINUX)
 		personality = PER_LINUX32;
 	ret = sys_personality(personality);
 	if (ret == PER_LINUX32)
 		ret = PER_LINUX;
 	return ret;
 }
 asmlinkage unsigned long
 sys32_brk (unsigned int brk)
 {
 	unsigned long ret, obrk;
 	struct mm_struct *mm = current->mm;
 	obrk = mm->brk;
 	ret = sys_brk(brk);
 	if (ret < obrk)
 		clear_user(compat_ptr(ret), PAGE_ALIGN(ret) - ret);
 	return ret;
 }
 /* Structure for ia32 emulation on ia64 */
 struct epoll_event32
 {
 	u32 events;
 	u32 data[2];
 };
 asmlinkage long
 sys32_epoll_ctl(int epfd, int op, int fd, struct epoll_event32 __user *event)
 {
 	mm_segment_t old_fs = get_fs();
 	struct epoll_event event64;
 	int error;
 	u32 data_halfword;
 	if (!access_ok(VERIFY_READ, event, sizeof(struct epoll_event32)))
 		return -EFAULT;
 	__get_user(event64.events, &event->events);
 	__get_user(data_halfword, &event->data[0]);
 	event64.data = data_halfword;
 	__get_user(data_halfword, &event->data[1]);
  	event64.data |= (u64)data_halfword << 32;
 	set_fs(KERNEL_DS);
 	error = sys_epoll_ctl(epfd, op, fd, (struct epoll_event __user *) &event64);
 	set_fs(old_fs);
 	return error;
 }
 asmlinkage long
 sys32_epoll_wait(int epfd, struct epoll_event32 __user * events, int maxevents,
 		 int timeout)
 {
 	struct epoll_event *events64 = NULL;
 	mm_segment_t old_fs = get_fs();
 	int numevents, size;
 	int evt_idx;
 	int do_free_pages = 0;
 	if (maxevents <= 0) {
 		return -EINVAL;
 	}
 	/* Verify that the area passed by the user is writeable */
 	if (!access_ok(VERIFY_WRITE, events, maxevents * sizeof(struct epoll_event32)))
 		return -EFAULT;
 	/*
  	 * Allocate space for the intermediate copy.  If the space needed
 	 * is large enough to cause kmalloc to fail, then try again with
 	 * __get_free_pages.
 	 */
 	size = maxevents * sizeof(struct epoll_event);
 	events64 = kmalloc(size, GFP_KERNEL);
 	if (events64 == NULL) {
 		events64 = (struct epoll_event *)
 				__get_free_pages(GFP_KERNEL, get_order(size));
 		if (events64 == NULL)
 			return -ENOMEM;
 		do_free_pages = 1;
 	}
 	/* Do the system call */
 	set_fs(KERNEL_DS); /* copy_to/from_user should work on kernel mem*/
 	numevents = sys_epoll_wait(epfd, (struct epoll_event __user *) events64,
 				   maxevents, timeout);
 	set_fs(old_fs);
 	/* Don't modify userspace memory if we're returning an error */
 	if (numevents > 0) {
 		/* Translate the 64-bit structures back into the 32-bit
 		   structures */
 		for (evt_idx = 0; evt_idx < numevents; evt_idx++) {
 			__put_user(events64[evt_idx].events,
 				   &events[evt_idx].events);
 			__put_user((u32)events64[evt_idx].data,
 				   &events[evt_idx].data[0]);
 			__put_user((u32)(events64[evt_idx].data >> 32),
 				   &events[evt_idx].data[1]);
 		}
 	}
 	if (do_free_pages)
 		free_pages((unsigned long) events64, get_order(size));
 	else
 		kfree(events64);
 	return numevents;
 }
 /*
  * Get a yet unused TLS descriptor index.
  */
 static int
 get_free_idx (void)
 {
 	struct thread_struct *t = &current->thread;
 	int idx;
 	for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
 		if (desc_empty(t->tls_array + idx))
 			return idx + GDT_ENTRY_TLS_MIN;
 	return -ESRCH;
 }
 /*
  * Set a given TLS descriptor:
  */
 asmlinkage int
 sys32_set_thread_area (struct ia32_user_desc __user *u_info)
 {
 	struct thread_struct *t = &current->thread;
 	struct ia32_user_desc info;
 	struct desc_struct *desc;
 	int cpu, idx;
 	if (copy_from_user(&info, u_info, sizeof(info)))
 		return -EFAULT;
 	idx = info.entry_number;
 	/*
 	 * index -1 means the kernel should try to find and allocate an empty descriptor:
 	 */
 	if (idx == -1) {
 		idx = get_free_idx();
 		if (idx < 0)
 			return idx;
 		if (put_user(idx, &u_info->entry_number))
 			return -EFAULT;
 	}
 	if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
 		return -EINVAL;
 	desc = t->tls_array + idx - GDT_ENTRY_TLS_MIN;
 	cpu = smp_processor_id();
 	if (LDT_empty(&info)) {
 		desc->a = 0;
 		desc->b = 0;
 	} else {
 		desc->a = LDT_entry_a(&info);
 		desc->b = LDT_entry_b(&info);
 	}
 	load_TLS(t, cpu);
 	return 0;
 }
 /*
  * Get the current Thread-Local Storage area:
  */
 #define GET_BASE(desc) (			\
 	(((desc)->a >> 16) & 0x0000ffff) |	\
 	(((desc)->b << 16) & 0x00ff0000) |	\
 	( (desc)->b        & 0xff000000)   )
 #define GET_LIMIT(desc) (			\
 	((desc)->a & 0x0ffff) |			\
 	 ((desc)->b & 0xf0000) )
 #define GET_32BIT(desc)		(((desc)->b >> 22) & 1)
 #define GET_CONTENTS(desc)	(((desc)->b >> 10) & 3)
 #define GET_WRITABLE(desc)	(((desc)->b >>  9) & 1)
 #define GET_LIMIT_PAGES(desc)	(((desc)->b >> 23) & 1)
 #define GET_PRESENT(desc)	(((desc)->b >> 15) & 1)
 #define GET_USEABLE(desc)	(((desc)->b >> 20) & 1)
 asmlinkage int
 sys32_get_thread_area (struct ia32_user_desc __user *u_info)
 {
 	struct ia32_user_desc info;
 	struct desc_struct *desc;
 	int idx;
 	if (get_user(idx, &u_info->entry_number))
 		return -EFAULT;
 	if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
 		return -EINVAL;
 	desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
 	info.entry_number = idx;
 	info.base_addr = GET_BASE(desc);
 	info.limit = GET_LIMIT(desc);
 	info.seg_32bit = GET_32BIT(desc);
 	info.contents = GET_CONTENTS(desc);
 	info.read_exec_only = !GET_WRITABLE(desc);
 	info.limit_in_pages = GET_LIMIT_PAGES(desc);
 	info.seg_not_present = !GET_PRESENT(desc);
 	info.useable = GET_USEABLE(desc);
 	if (copy_to_user(u_info, &info, sizeof(info)))
 		return -EFAULT;
 	return 0;
 }
 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
 			__u32 len_low, __u32 len_high, int advice)
 {
 	return sys_fadvise64_64(fd,
 			       (((u64)offset_high)<<32) | offset_low,
 			       (((u64)len_high)<<32) | len_low,
 			       advice);
 }
 #ifdef	NOTYET  /* UNTESTED FOR IA64 FROM HERE DOWN */
 asmlinkage long sys32_setreuid(compat_uid_t ruid, compat_uid_t euid)
 {
 	uid_t sruid, seuid;
 	sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
 	seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
 	return sys_setreuid(sruid, seuid);
 }
 asmlinkage long
 sys32_setresuid(compat_uid_t ruid, compat_uid_t euid,
 		compat_uid_t suid)
 {
 	uid_t sruid, seuid, ssuid;
 	sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
 	seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
 	ssuid = (suid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)suid);
 	return sys_setresuid(sruid, seuid, ssuid);
 }
 asmlinkage long
 sys32_setregid(compat_gid_t rgid, compat_gid_t egid)
 {
 	gid_t srgid, segid;
 	srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
 	segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
 	return sys_setregid(srgid, segid);
 }
 asmlinkage long
 sys32_setresgid(compat_gid_t rgid, compat_gid_t egid,
 		compat_gid_t sgid)
 {
 	gid_t srgid, segid, ssgid;
 	srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
 	segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
 	ssgid = (sgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)sgid);
 	return sys_setresgid(srgid, segid, ssgid);
 }
 #endif /* NOTYET */

arch/ia64/kernel/process.c

Diff comments View file @ 3b74d18

 /*
  * Architecture-specific setup.
  *
  * Copyright (C) 1998-2003 Hewlett-Packard Co
  *	David Mosberger-Tang <davidm@hpl.hp.com>
  * 04/11/17 Ashok Raj	<ashok.raj@intel.com> Added CPU Hotplug Support
  *
  * 2005-10-07 Keith Owens <kaos@sgi.com>
  *	      Add notify_die() hooks.
  */
 #include <linux/cpu.h>
 #include <linux/pm.h>
 #include <linux/elf.h>
 #include <linux/errno.h>
 #include <linux/kallsyms.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/personality.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/stddef.h>
 #include <linux/thread_info.h>
 #include <linux/unistd.h>
 #include <linux/efi.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/kdebug.h>
 #include <asm/cpu.h>
 #include <asm/delay.h>
 #include <asm/elf.h>
 #include <asm/ia32.h>
 #include <asm/irq.h>
 #include <asm/kexec.h>
 #include <asm/pgalloc.h>
 #include <asm/processor.h>
 #include <asm/sal.h>
 #include <asm/tlbflush.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
 #include <asm/user.h>
 #include "entry.h"
 #ifdef CONFIG_PERFMON
 # include <asm/perfmon.h>
 #endif
 #include "sigframe.h"
 void (*ia64_mark_idle)(int);
 static DEFINE_PER_CPU(unsigned int, cpu_idle_state);
 unsigned long boot_option_idle_override = 0;
 EXPORT_SYMBOL(boot_option_idle_override);
 void
 ia64_do_show_stack (struct unw_frame_info *info, void *arg)
 {
 	unsigned long ip, sp, bsp;
 	char buf[128];			/* don't make it so big that it overflows the stack! */
 	printk("\nCall Trace:\n");
 	do {
 		unw_get_ip(info, &ip);
 		if (ip == 0)
 			break;
 		unw_get_sp(info, &sp);
 		unw_get_bsp(info, &bsp);
 		snprintf(buf, sizeof(buf),
 			 " [<%016lx>] %%s\n"
 			 "                                sp=%016lx bsp=%016lx\n",
 			 ip, sp, bsp);
 		print_symbol(buf, ip);
 	} while (unw_unwind(info) >= 0);
 }
 void
 show_stack (struct task_struct *task, unsigned long *sp)
 {
 	if (!task)
 		unw_init_running(ia64_do_show_stack, NULL);
 	else {
 		struct unw_frame_info info;
 		unw_init_from_blocked_task(&info, task);
 		ia64_do_show_stack(&info, NULL);
 	}
 }
 void
 dump_stack (void)
 {
 	show_stack(NULL, NULL);
 }
 EXPORT_SYMBOL(dump_stack);
 void
 show_regs (struct pt_regs *regs)
 {
 	unsigned long ip = regs->cr_iip + ia64_psr(regs)->ri;
 	print_modules();
 	printk("\nPid: %d, CPU %d, comm: %20s\n", current->pid, smp_processor_id(), current->comm);
 	printk("psr : %016lx ifs : %016lx ip  : [<%016lx>]    %s\n",
 	       regs->cr_ipsr, regs->cr_ifs, ip, print_tainted());
 	print_symbol("ip is at %s\n", ip);
 	printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
 	       regs->ar_unat, regs->ar_pfs, regs->ar_rsc);
 	printk("rnat: %016lx bsps: %016lx pr  : %016lx\n",
 	       regs->ar_rnat, regs->ar_bspstore, regs->pr);
 	printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
 	       regs->loadrs, regs->ar_ccv, regs->ar_fpsr);
 	printk("csd : %016lx ssd : %016lx\n", regs->ar_csd, regs->ar_ssd);
 	printk("b0  : %016lx b6  : %016lx b7  : %016lx\n", regs->b0, regs->b6, regs->b7);
 	printk("f6  : %05lx%016lx f7  : %05lx%016lx\n",
 	       regs->f6.u.bits[1], regs->f6.u.bits[0],
 	       regs->f7.u.bits[1], regs->f7.u.bits[0]);
 	printk("f8  : %05lx%016lx f9  : %05lx%016lx\n",
 	       regs->f8.u.bits[1], regs->f8.u.bits[0],
 	       regs->f9.u.bits[1], regs->f9.u.bits[0]);
 	printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
 	       regs->f10.u.bits[1], regs->f10.u.bits[0],
 	       regs->f11.u.bits[1], regs->f11.u.bits[0]);
 	printk("r1  : %016lx r2  : %016lx r3  : %016lx\n", regs->r1, regs->r2, regs->r3);
 	printk("r8  : %016lx r9  : %016lx r10 : %016lx\n", regs->r8, regs->r9, regs->r10);
 	printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs->r11, regs->r12, regs->r13);
 	printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs->r14, regs->r15, regs->r16);
 	printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs->r17, regs->r18, regs->r19);
 	printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs->r20, regs->r21, regs->r22);
 	printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs->r23, regs->r24, regs->r25);
 	printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs->r26, regs->r27, regs->r28);
 	printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs->r29, regs->r30, regs->r31);
 	if (user_mode(regs)) {
 		/* print the stacked registers */
 		unsigned long val, *bsp, ndirty;
 		int i, sof, is_nat = 0;
 		sof = regs->cr_ifs & 0x7f;	/* size of frame */
 		ndirty = (regs->loadrs >> 19);
 		bsp = ia64_rse_skip_regs((unsigned long *) regs->ar_bspstore, ndirty);
 		for (i = 0; i < sof; ++i) {
 			get_user(val, (unsigned long __user *) ia64_rse_skip_regs(bsp, i));
 			printk("r%-3u:%c%016lx%s", 32 + i, is_nat ? '*' : ' ', val,
 			       ((i == sof - 1) || (i % 3) == 2) ? "\n" : " ");
 		}
 	} else
 		show_stack(NULL, NULL);
 }
 void
 do_notify_resume_user (sigset_t *unused, struct sigscratch *scr, long in_syscall)
 {
 	if (fsys_mode(current, &scr->pt)) {
 		/* defer signal-handling etc. until we return to privilege-level 0.  */
 		if (!ia64_psr(&scr->pt)->lp)
 			ia64_psr(&scr->pt)->lp = 1;
 		return;
 	}
 #ifdef CONFIG_PERFMON
 	if (current->thread.pfm_needs_checking)
 		pfm_handle_work();
 #endif
 	/* deal with pending signal delivery */
 	if (test_thread_flag(TIF_SIGPENDING)||test_thread_flag(TIF_RESTORE_SIGMASK))
 		ia64_do_signal(scr, in_syscall);
 }
 static int pal_halt        = 1;
 static int can_do_pal_halt = 1;
 static int __init nohalt_setup(char * str)
 {
 	pal_halt = can_do_pal_halt = 0;
 	return 1;
 }
 __setup("nohalt", nohalt_setup);
 void
 update_pal_halt_status(int status)
 {
 	can_do_pal_halt = pal_halt && status;
 }
 /*
  * We use this if we don't have any better idle routine..
  */
 void
 default_idle (void)
 {
 	local_irq_enable();
 	while (!need_resched()) {
 		if (can_do_pal_halt)
 			safe_halt();
 		else
 			cpu_relax();
 	}
 }
 #ifdef CONFIG_HOTPLUG_CPU
 /* We don't actually take CPU down, just spin without interrupts. */
 static inline void play_dead(void)
 {
 	extern void ia64_cpu_local_tick (void);
 	unsigned int this_cpu = smp_processor_id();
 	/* Ack it */
 	__get_cpu_var(cpu_state) = CPU_DEAD;
 	max_xtp();
 	local_irq_disable();
 	idle_task_exit();
 	ia64_jump_to_sal(&sal_boot_rendez_state[this_cpu]);
 	/*
 	 * The above is a point of no-return, the processor is
 	 * expected to be in SAL loop now.
 	 */
 	BUG();
 }
 #else
 static inline void play_dead(void)
 {
 	BUG();
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 void cpu_idle_wait(void)
 {
 	unsigned int cpu, this_cpu = get_cpu();
 	cpumask_t map;
 	cpumask_t tmp = current->cpus_allowed;
 	set_cpus_allowed(current, cpumask_of_cpu(this_cpu));
 	put_cpu();
 	cpus_clear(map);
 	for_each_online_cpu(cpu) {
 		per_cpu(cpu_idle_state, cpu) = 1;
 		cpu_set(cpu, map);
 	}
 	__get_cpu_var(cpu_idle_state) = 0;
 	wmb();
 	do {
 		ssleep(1);
 		for_each_online_cpu(cpu) {
 			if (cpu_isset(cpu, map) && !per_cpu(cpu_idle_state, cpu))
 				cpu_clear(cpu, map);
 		}
 		cpus_and(map, map, cpu_online_map);
 	} while (!cpus_empty(map));
 	set_cpus_allowed(current, tmp);
 }
 EXPORT_SYMBOL_GPL(cpu_idle_wait);
 void __attribute__((noreturn))
 cpu_idle (void)
 {
 	void (*mark_idle)(int) = ia64_mark_idle;
   	int cpu = smp_processor_id();
 	/* endless idle loop with no priority at all */
 	while (1) {
 		if (can_do_pal_halt) {
 			current_thread_info()->status &= ~TS_POLLING;
 			/*
 			 * TS_POLLING-cleared state must be visible before we
 			 * test NEED_RESCHED:
 			 */
 			smp_mb();
 		} else {
 			current_thread_info()->status |= TS_POLLING;
 		}
 		if (!need_resched()) {
 			void (*idle)(void);
 #ifdef CONFIG_SMP
 			min_xtp();
 #endif
 			if (__get_cpu_var(cpu_idle_state))
 				__get_cpu_var(cpu_idle_state) = 0;
 			rmb();
 			if (mark_idle)
 				(*mark_idle)(1);
 			idle = pm_idle;
 			if (!idle)
 				idle = default_idle;
 			(*idle)();
 			if (mark_idle)
 				(*mark_idle)(0);
 #ifdef CONFIG_SMP
 			normal_xtp();
 #endif
 		}
 		preempt_enable_no_resched();
 		schedule();
 		preempt_disable();
 		check_pgt_cache();
 		if (cpu_is_offline(cpu))
 			play_dead();
 	}
 }
 void
 ia64_save_extra (struct task_struct *task)
 {
 #ifdef CONFIG_PERFMON
 	unsigned long info;
 #endif
 	if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
 		ia64_save_debug_regs(&task->thread.dbr[0]);
 #ifdef CONFIG_PERFMON
 	if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
 		pfm_save_regs(task);
 	info = __get_cpu_var(pfm_syst_info);
 	if (info & PFM_CPUINFO_SYST_WIDE)
 		pfm_syst_wide_update_task(task, info, 0);
 #endif
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(task_pt_regs(task)))
 		ia32_save_state(task);
 #endif
 }
 void
 ia64_load_extra (struct task_struct *task)
 {
 #ifdef CONFIG_PERFMON
 	unsigned long info;
 #endif
 	if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
 		ia64_load_debug_regs(&task->thread.dbr[0]);
 #ifdef CONFIG_PERFMON
 	if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
 		pfm_load_regs(task);
 	info = __get_cpu_var(pfm_syst_info);
 	if (info & PFM_CPUINFO_SYST_WIDE)
 		pfm_syst_wide_update_task(task, info, 1);
 #endif
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(task_pt_regs(task)))
 		ia32_load_state(task);
 #endif
 }
 /*
  * Copy the state of an ia-64 thread.
  *
  * We get here through the following  call chain:
  *
  *	from user-level:	from kernel:
  *
  *	<clone syscall>	        <some kernel call frames>
  *	sys_clone		   :
  *	do_fork			do_fork
  *	copy_thread		copy_thread
  *
  * This means that the stack layout is as follows:
  *
  *	+---------------------+ (highest addr)
  *	|   struct pt_regs    |
  *	+---------------------+
  *	| struct switch_stack |
  *	+---------------------+
  *	|                     |
  *	|    memory stack     |
  *	|                     | <-- sp (lowest addr)
  *	+---------------------+
  *
  * Observe that we copy the unat values that are in pt_regs and switch_stack.  Spilling an
  * integer to address X causes bit N in ar.unat to be set to the NaT bit of the register,
  * with N=(X & 0x1ff)/8.  Thus, copying the unat value preserves the NaT bits ONLY if the
  * pt_regs structure in the parent is congruent to that of the child, modulo 512.  Since
  * the stack is page aligned and the page size is at least 4KB, this is always the case,
  * so there is nothing to worry about.
  */
 int
 copy_thread (int nr, unsigned long clone_flags,
 	     unsigned long user_stack_base, unsigned long user_stack_size,
 	     struct task_struct *p, struct pt_regs *regs)
 {
 	extern char ia64_ret_from_clone, ia32_ret_from_clone;
 	struct switch_stack *child_stack, *stack;
 	unsigned long rbs, child_rbs, rbs_size;
 	struct pt_regs *child_ptregs;
 	int retval = 0;
 #ifdef CONFIG_SMP
 	/*
 	 * For SMP idle threads, fork_by_hand() calls do_fork with
 	 * NULL regs.
 	 */
 	if (!regs)
 		return 0;
 #endif
 	stack = ((struct switch_stack *) regs) - 1;
 	child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
 	child_stack = (struct switch_stack *) child_ptregs - 1;
 	/* copy parent's switch_stack & pt_regs to child: */
 	memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
 	rbs = (unsigned long) current + IA64_RBS_OFFSET;
 	child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
 	rbs_size = stack->ar_bspstore - rbs;
 	/* copy the parent's register backing store to the child: */
 	memcpy((void *) child_rbs, (void *) rbs, rbs_size);
 	if (likely(user_mode(child_ptregs))) {
 		if ((clone_flags & CLONE_SETTLS) && !IS_IA32_PROCESS(regs))
 			child_ptregs->r13 = regs->r16;	/* see sys_clone2() in entry.S */
 		if (user_stack_base) {
 			child_ptregs->r12 = user_stack_base + user_stack_size - 16;
 			child_ptregs->ar_bspstore = user_stack_base;
 			child_ptregs->ar_rnat = 0;
 			child_ptregs->loadrs = 0;
 		}
 	} else {
 		/*
 		 * Note: we simply preserve the relative position of
 		 * the stack pointer here.  There is no need to
 		 * allocate a scratch area here, since that will have
 		 * been taken care of by the caller of sys_clone()
 		 * already.
 		 */
 		child_ptregs->r12 = (unsigned long) child_ptregs - 16; /* kernel sp */
 		child_ptregs->r13 = (unsigned long) p;		/* set `current' pointer */
 	}
 	child_stack->ar_bspstore = child_rbs + rbs_size;
 	if (IS_IA32_PROCESS(regs))
 		child_stack->b0 = (unsigned long) &ia32_ret_from_clone;
 	else
 		child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
 	/* copy parts of thread_struct: */
 	p->thread.ksp = (unsigned long) child_stack - 16;
 	/* stop some PSR bits from being inherited.
 	 * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
 	 * therefore we must specify them explicitly here and not include them in
 	 * IA64_PSR_BITS_TO_CLEAR.
 	 */
 	child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
 				 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
 	/*
 	 * NOTE: The calling convention considers all floating point
 	 * registers in the high partition (fph) to be scratch.  Since
 	 * the only way to get to this point is through a system call,
 	 * we know that the values in fph are all dead.  Hence, there
 	 * is no need to inherit the fph state from the parent to the
 	 * child and all we have to do is to make sure that
 	 * IA64_THREAD_FPH_VALID is cleared in the child.
 	 *
 	 * XXX We could push this optimization a bit further by
 	 * clearing IA64_THREAD_FPH_VALID on ANY system call.
 	 * However, it's not clear this is worth doing.  Also, it
 	 * would be a slight deviation from the normal Linux system
 	 * call behavior where scratch registers are preserved across
 	 * system calls (unless used by the system call itself).
 	 */
 #	define THREAD_FLAGS_TO_CLEAR	(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
 					 | IA64_THREAD_PM_VALID)
 #	define THREAD_FLAGS_TO_SET	0
 	p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
 			   | THREAD_FLAGS_TO_SET);
 	ia64_drop_fpu(p);	/* don't pick up stale state from a CPU's fph */
 #ifdef CONFIG_IA32_SUPPORT
 	/*
 	 * If we're cloning an IA32 task then save the IA32 extra
 	 * state from the current task to the new task
 	 */
 	if (IS_IA32_PROCESS(task_pt_regs(current))) {
 		ia32_save_state(p);
 		if (clone_flags & CLONE_SETTLS)
 			retval = ia32_clone_tls(p, child_ptregs);
 		/* Copy partially mapped page list */
 		if (!retval)
-			retval = ia32_copy_partial_page_list(p, clone_flags);
+			retval = ia32_copy_ia64_partial_page_list(p,
+								clone_flags);
 	}
 #endif
 #ifdef CONFIG_PERFMON
 	if (current->thread.pfm_context)
 		pfm_inherit(p, child_ptregs);
 #endif
 	return retval;
 }
 static void
 do_copy_task_regs (struct task_struct *task, struct unw_frame_info *info, void *arg)
 {
 	unsigned long mask, sp, nat_bits = 0, ar_rnat, urbs_end, cfm;
 	unsigned long uninitialized_var(ip);	/* GCC be quiet */
 	elf_greg_t *dst = arg;
 	struct pt_regs *pt;
 	char nat;
 	int i;
 	memset(dst, 0, sizeof(elf_gregset_t));	/* don't leak any kernel bits to user-level */
 	if (unw_unwind_to_user(info) < 0)
 		return;
 	unw_get_sp(info, &sp);
 	pt = (struct pt_regs *) (sp + 16);
 	urbs_end = ia64_get_user_rbs_end(task, pt, &cfm);
 	if (ia64_sync_user_rbs(task, info->sw, pt->ar_bspstore, urbs_end) < 0)
 		return;
 	ia64_peek(task, info->sw, urbs_end, (long) ia64_rse_rnat_addr((long *) urbs_end),
 		  &ar_rnat);
 	/*
 	 * coredump format:
 	 *	r0-r31
 	 *	NaT bits (for r0-r31; bit N == 1 iff rN is a NaT)
 	 *	predicate registers (p0-p63)
 	 *	b0-b7
 	 *	ip cfm user-mask
 	 *	ar.rsc ar.bsp ar.bspstore ar.rnat
 	 *	ar.ccv ar.unat ar.fpsr ar.pfs ar.lc ar.ec
 	 */
 	/* r0 is zero */
 	for (i = 1, mask = (1UL << i); i < 32; ++i) {
 		unw_get_gr(info, i, &dst[i], &nat);
 		if (nat)
 			nat_bits |= mask;
 		mask <<= 1;
 	}
 	dst[32] = nat_bits;
 	unw_get_pr(info, &dst[33]);
 	for (i = 0; i < 8; ++i)
 		unw_get_br(info, i, &dst[34 + i]);
 	unw_get_rp(info, &ip);
 	dst[42] = ip + ia64_psr(pt)->ri;
 	dst[43] = cfm;
 	dst[44] = pt->cr_ipsr & IA64_PSR_UM;
 	unw_get_ar(info, UNW_AR_RSC, &dst[45]);
 	/*
 	 * For bsp and bspstore, unw_get_ar() would return the kernel
 	 * addresses, but we need the user-level addresses instead:
 	 */
 	dst[46] = urbs_end;	/* note: by convention PT_AR_BSP points to the end of the urbs! */
 	dst[47] = pt->ar_bspstore;
 	dst[48] = ar_rnat;
 	unw_get_ar(info, UNW_AR_CCV, &dst[49]);
 	unw_get_ar(info, UNW_AR_UNAT, &dst[50]);
 	unw_get_ar(info, UNW_AR_FPSR, &dst[51]);
 	dst[52] = pt->ar_pfs;	/* UNW_AR_PFS is == to pt->cr_ifs for interrupt frames */
 	unw_get_ar(info, UNW_AR_LC, &dst[53]);
 	unw_get_ar(info, UNW_AR_EC, &dst[54]);
 	unw_get_ar(info, UNW_AR_CSD, &dst[55]);
 	unw_get_ar(info, UNW_AR_SSD, &dst[56]);
 }
 void
 do_dump_task_fpu (struct task_struct *task, struct unw_frame_info *info, void *arg)
 {
 	elf_fpreg_t *dst = arg;
 	int i;
 	memset(dst, 0, sizeof(elf_fpregset_t));	/* don't leak any "random" bits */
 	if (unw_unwind_to_user(info) < 0)
 		return;
 	/* f0 is 0.0, f1 is 1.0 */
 	for (i = 2; i < 32; ++i)
 		unw_get_fr(info, i, dst + i);
 	ia64_flush_fph(task);
 	if ((task->thread.flags & IA64_THREAD_FPH_VALID) != 0)
 		memcpy(dst + 32, task->thread.fph, 96*16);
 }
 void
 do_copy_regs (struct unw_frame_info *info, void *arg)
 {
 	do_copy_task_regs(current, info, arg);
 }
 void
 do_dump_fpu (struct unw_frame_info *info, void *arg)
 {
 	do_dump_task_fpu(current, info, arg);
 }
 int
 dump_task_regs(struct task_struct *task, elf_gregset_t *regs)
 {
 	struct unw_frame_info tcore_info;
 	if (current == task) {
 		unw_init_running(do_copy_regs, regs);
 	} else {
 		memset(&tcore_info, 0, sizeof(tcore_info));
 		unw_init_from_blocked_task(&tcore_info, task);
 		do_copy_task_regs(task, &tcore_info, regs);
 	}
 	return 1;
 }
 void
 ia64_elf_core_copy_regs (struct pt_regs *pt, elf_gregset_t dst)
 {
 	unw_init_running(do_copy_regs, dst);
 }
 int
 dump_task_fpu (struct task_struct *task, elf_fpregset_t *dst)
 {
 	struct unw_frame_info tcore_info;
 	if (current == task) {
 		unw_init_running(do_dump_fpu, dst);
 	} else {
 		memset(&tcore_info, 0, sizeof(tcore_info));
 		unw_init_from_blocked_task(&tcore_info, task);
 		do_dump_task_fpu(task, &tcore_info, dst);
 	}
 	return 1;
 }
 int
 dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
 {
 	unw_init_running(do_dump_fpu, dst);
 	return 1;	/* f0-f31 are always valid so we always return 1 */
 }
 long
 sys_execve (char __user *filename, char __user * __user *argv, char __user * __user *envp,
 	    struct pt_regs *regs)
 {
 	char *fname;
 	int error;
 	fname = getname(filename);
 	error = PTR_ERR(fname);
 	if (IS_ERR(fname))
 		goto out;
 	error = do_execve(fname, argv, envp, regs);
 	putname(fname);
 out:
 	return error;
 }
 pid_t
 kernel_thread (int (*fn)(void *), void *arg, unsigned long flags)
 {
 	extern void start_kernel_thread (void);
 	unsigned long *helper_fptr = (unsigned long *) &start_kernel_thread;
 	struct {
 		struct switch_stack sw;
 		struct pt_regs pt;
 	} regs;
 	memset(&regs, 0, sizeof(regs));
 	regs.pt.cr_iip = helper_fptr[0];	/* set entry point (IP) */
 	regs.pt.r1 = helper_fptr[1];		/* set GP */
 	regs.pt.r9 = (unsigned long) fn;	/* 1st argument */
 	regs.pt.r11 = (unsigned long) arg;	/* 2nd argument */
 	/* Preserve PSR bits, except for bits 32-34 and 37-45, which we can't read.  */
 	regs.pt.cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
 	regs.pt.cr_ifs = 1UL << 63;		/* mark as valid, empty frame */
 	regs.sw.ar_fpsr = regs.pt.ar_fpsr = ia64_getreg(_IA64_REG_AR_FPSR);
 	regs.sw.ar_bspstore = (unsigned long) current + IA64_RBS_OFFSET;
 	regs.sw.pr = (1 << PRED_KERNEL_STACK);
 	return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs.pt, 0, NULL, NULL);
 }
 EXPORT_SYMBOL(kernel_thread);
 /* This gets called from kernel_thread() via ia64_invoke_thread_helper().  */
 int
 kernel_thread_helper (int (*fn)(void *), void *arg)
 {
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(task_pt_regs(current))) {
 		/* A kernel thread is always a 64-bit process. */
 		current->thread.map_base  = DEFAULT_MAP_BASE;
 		current->thread.task_size = DEFAULT_TASK_SIZE;
 		ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
 		ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
 	}
 #endif
 	return (*fn)(arg);
 }
 /*
  * Flush thread state.  This is called when a thread does an execve().
  */
 void
 flush_thread (void)
 {
 	/* drop floating-point and debug-register state if it exists: */
 	current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
 	ia64_drop_fpu(current);
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(task_pt_regs(current))) {
-		ia32_drop_partial_page_list(current);
+		ia32_drop_ia64_partial_page_list(current);
 		current->thread.task_size = IA32_PAGE_OFFSET;
 		set_fs(USER_DS);
 	}
 #endif
 }
 /*
  * Clean up state associated with current thread.  This is called when
  * the thread calls exit().
  */
 void
 exit_thread (void)
 {
 	ia64_drop_fpu(current);
 #ifdef CONFIG_PERFMON
        /* if needed, stop monitoring and flush state to perfmon context */
 	if (current->thread.pfm_context)
 		pfm_exit_thread(current);
 	/* free debug register resources */
 	if (current->thread.flags & IA64_THREAD_DBG_VALID)
 		pfm_release_debug_registers(current);
 #endif
 	if (IS_IA32_PROCESS(task_pt_regs(current)))
-		ia32_drop_partial_page_list(current);
+		ia32_drop_ia64_partial_page_list(current);
 }
 unsigned long
 get_wchan (struct task_struct *p)
 {
 	struct unw_frame_info info;
 	unsigned long ip;
 	int count = 0;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	/*
 	 * Note: p may not be a blocked task (it could be current or
 	 * another process running on some other CPU.  Rather than
 	 * trying to determine if p is really blocked, we just assume
 	 * it's blocked and rely on the unwind routines to fail
 	 * gracefully if the process wasn't really blocked after all.
 	 * --davidm 99/12/15
 	 */
 	unw_init_from_blocked_task(&info, p);
 	do {
 		if (p->state == TASK_RUNNING)
 			return 0;
 		if (unw_unwind(&info) < 0)
 			return 0;
 		unw_get_ip(&info, &ip);
 		if (!in_sched_functions(ip))
 			return ip;
 	} while (count++ < 16);
 	return 0;
 }
 void
 cpu_halt (void)
 {
 	pal_power_mgmt_info_u_t power_info[8];
 	unsigned long min_power;
 	int i, min_power_state;
 	if (ia64_pal_halt_info(power_info) != 0)
 		return;
 	min_power_state = 0;
 	min_power = power_info[0].pal_power_mgmt_info_s.power_consumption;
 	for (i = 1; i < 8; ++i)
 		if (power_info[i].pal_power_mgmt_info_s.im
 		    && power_info[i].pal_power_mgmt_info_s.power_consumption < min_power) {
 			min_power = power_info[i].pal_power_mgmt_info_s.power_consumption;
 			min_power_state = i;
 		}
 	while (1)
 		ia64_pal_halt(min_power_state);
 }
 void machine_shutdown(void)
 {
 #ifdef CONFIG_HOTPLUG_CPU
 	int cpu;
 	for_each_online_cpu(cpu) {
 		if (cpu != smp_processor_id())
 			cpu_down(cpu);
 	}
 #endif
 #ifdef CONFIG_KEXEC
 	kexec_disable_iosapic();
 #endif
 }
 void
 machine_restart (char *restart_cmd)
 {
 	(void) notify_die(DIE_MACHINE_RESTART, restart_cmd, NULL, 0, 0, 0);
 	(*efi.reset_system)(EFI_RESET_WARM, 0, 0, NULL);
 }
 void
 machine_halt (void)
 {
 	(void) notify_die(DIE_MACHINE_HALT, "", NULL, 0, 0, 0);
 	cpu_halt();
 }
 void
 machine_power_off (void)
 {
 	if (pm_power_off)
 		pm_power_off();
 	machine_halt();
 }

include/asm-ia64/ia32.h

Diff comments View file @ 3b74d18

 #ifndef _ASM_IA64_IA32_H
 #define _ASM_IA64_IA32_H
 #include <asm/ptrace.h>
 #include <asm/signal.h>
 #define IA32_NR_syscalls		285	/* length of syscall table */
 #define IA32_PAGE_SHIFT			12	/* 4KB pages */
 #ifndef __ASSEMBLY__
 # ifdef CONFIG_IA32_SUPPORT
 #define IA32_PAGE_OFFSET	0xc0000000
 extern void ia32_cpu_init (void);
 extern void ia32_mem_init (void);
 extern void ia32_gdt_init (void);
 extern int ia32_exception (struct pt_regs *regs, unsigned long isr);
 extern int ia32_intercept (struct pt_regs *regs, unsigned long isr);
 extern int ia32_clone_tls (struct task_struct *child, struct pt_regs *childregs);
 # endif /* !CONFIG_IA32_SUPPORT */
 /* Declare this unconditionally, so we don't get warnings for unreachable code.  */
 extern int ia32_setup_frame1 (int sig, struct k_sigaction *ka, siginfo_t *info,
 			      sigset_t *set, struct pt_regs *regs);
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
-extern int ia32_copy_partial_page_list (struct task_struct *, unsigned long);
+extern int ia32_copy_ia64_partial_page_list(struct task_struct *,
-extern void ia32_drop_partial_page_list (struct task_struct *);
+					unsigned long);
+extern void ia32_drop_ia64_partial_page_list(struct task_struct *);
 #else
-# define ia32_copy_partial_page_list(a1, a2)	0
+# define ia32_copy_ia64_partial_page_list(a1, a2)	0
-# define ia32_drop_partial_page_list(a1)	do { ; } while (0)
+# define ia32_drop_ia64_partial_page_list(a1)	do { ; } while (0)
 #endif
 #endif /* !__ASSEMBLY__ */
 #endif /* _ASM_IA64_IA32_H */

include/asm-ia64/processor.h

Diff comments View file @ 3b74d18

1	#ifndef _ASM_IA64_PROCESSOR_H	1	#ifndef _ASM_IA64_PROCESSOR_H
2	#define _ASM_IA64_PROCESSOR_H	2	#define _ASM_IA64_PROCESSOR_H
3		3
4	/*	4	/*
5	* Copyright (C) 1998-2004 Hewlett-Packard Co	5	* Copyright (C) 1998-2004 Hewlett-Packard Co
6	* David Mosberger-Tang <davidm@hpl.hp.com>	6	* David Mosberger-Tang <davidm@hpl.hp.com>
7	* Stephane Eranian <eranian@hpl.hp.com>	7	* Stephane Eranian <eranian@hpl.hp.com>
8	* Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>	8	* Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>
9	* Copyright (C) 1999 Don Dugger <don.dugger@intel.com>	9	* Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
10	*	10	*
11	* 11/24/98 S.Eranian added ia64_set_iva()	11	* 11/24/98 S.Eranian added ia64_set_iva()
12	* 12/03/99 D. Mosberger implement thread_saved_pc() via kernel unwind API	12	* 12/03/99 D. Mosberger implement thread_saved_pc() via kernel unwind API
13	* 06/16/00 A. Mallick added csd/ssd/tssd for ia32 support	13	* 06/16/00 A. Mallick added csd/ssd/tssd for ia32 support
14	*/	14	*/
15		15
16		16
17	#include <asm/intrinsics.h>	17	#include <asm/intrinsics.h>
18	#include <asm/kregs.h>	18	#include <asm/kregs.h>
19	#include <asm/ptrace.h>	19	#include <asm/ptrace.h>
20	#include <asm/ustack.h>	20	#include <asm/ustack.h>
21		21
22	#define IA64_NUM_PHYS_STACK_REG 96	22	#define IA64_NUM_PHYS_STACK_REG 96
23	#define IA64_NUM_DBG_REGS 8	23	#define IA64_NUM_DBG_REGS 8
24		24
25	#define DEFAULT_MAP_BASE __IA64_UL_CONST(0x2000000000000000)	25	#define DEFAULT_MAP_BASE __IA64_UL_CONST(0x2000000000000000)
26	#define DEFAULT_TASK_SIZE __IA64_UL_CONST(0xa000000000000000)	26	#define DEFAULT_TASK_SIZE __IA64_UL_CONST(0xa000000000000000)
27		27
28	/*	28	/*
29	* TASK_SIZE really is a mis-named. It really is the maximum user	29	* TASK_SIZE really is a mis-named. It really is the maximum user
30	* space address (plus one). On IA-64, there are five regions of 2TB	30	* space address (plus one). On IA-64, there are five regions of 2TB
31	* each (assuming 8KB page size), for a total of 8TB of user virtual	31	* each (assuming 8KB page size), for a total of 8TB of user virtual
32	* address space.	32	* address space.
33	*/	33	*/
34	#define TASK_SIZE (current->thread.task_size)	34	#define TASK_SIZE (current->thread.task_size)
35		35
36	/*	36	/*
37	* This decides where the kernel will search for a free chunk of vm	37	* This decides where the kernel will search for a free chunk of vm
38	* space during mmap's.	38	* space during mmap's.
39	*/	39	*/
40	#define TASK_UNMAPPED_BASE (current->thread.map_base)	40	#define TASK_UNMAPPED_BASE (current->thread.map_base)
41		41
42	#define IA64_THREAD_FPH_VALID (__IA64_UL(1) << 0) /* floating-point high state valid? */	42	#define IA64_THREAD_FPH_VALID (__IA64_UL(1) << 0) /* floating-point high state valid? */
43	#define IA64_THREAD_DBG_VALID (__IA64_UL(1) << 1) /* debug registers valid? */	43	#define IA64_THREAD_DBG_VALID (__IA64_UL(1) << 1) /* debug registers valid? */
44	#define IA64_THREAD_PM_VALID (__IA64_UL(1) << 2) /* performance registers valid? */	44	#define IA64_THREAD_PM_VALID (__IA64_UL(1) << 2) /* performance registers valid? */
45	#define IA64_THREAD_UAC_NOPRINT (__IA64_UL(1) << 3) /* don't log unaligned accesses */	45	#define IA64_THREAD_UAC_NOPRINT (__IA64_UL(1) << 3) /* don't log unaligned accesses */
46	#define IA64_THREAD_UAC_SIGBUS (__IA64_UL(1) << 4) /* generate SIGBUS on unaligned acc. */	46	#define IA64_THREAD_UAC_SIGBUS (__IA64_UL(1) << 4) /* generate SIGBUS on unaligned acc. */
47	#define IA64_THREAD_MIGRATION (__IA64_UL(1) << 5) /* require migration	47	#define IA64_THREAD_MIGRATION (__IA64_UL(1) << 5) /* require migration
48	sync at ctx sw */	48	sync at ctx sw */
49	#define IA64_THREAD_FPEMU_NOPRINT (__IA64_UL(1) << 6) /* don't log any fpswa faults */	49	#define IA64_THREAD_FPEMU_NOPRINT (__IA64_UL(1) << 6) /* don't log any fpswa faults */
50	#define IA64_THREAD_FPEMU_SIGFPE (__IA64_UL(1) << 7) /* send a SIGFPE for fpswa faults */	50	#define IA64_THREAD_FPEMU_SIGFPE (__IA64_UL(1) << 7) /* send a SIGFPE for fpswa faults */
51		51
52	#define IA64_THREAD_UAC_SHIFT 3	52	#define IA64_THREAD_UAC_SHIFT 3
53	#define IA64_THREAD_UAC_MASK (IA64_THREAD_UAC_NOPRINT \| IA64_THREAD_UAC_SIGBUS)	53	#define IA64_THREAD_UAC_MASK (IA64_THREAD_UAC_NOPRINT \| IA64_THREAD_UAC_SIGBUS)
54	#define IA64_THREAD_FPEMU_SHIFT 6	54	#define IA64_THREAD_FPEMU_SHIFT 6
55	#define IA64_THREAD_FPEMU_MASK (IA64_THREAD_FPEMU_NOPRINT \| IA64_THREAD_FPEMU_SIGFPE)	55	#define IA64_THREAD_FPEMU_MASK (IA64_THREAD_FPEMU_NOPRINT \| IA64_THREAD_FPEMU_SIGFPE)
56		56
57		57
58	/*	58	/*
59	* This shift should be large enough to be able to represent 1000000000/itc_freq with good	59	* This shift should be large enough to be able to represent 1000000000/itc_freq with good
60	* accuracy while being small enough to fit 10*1000000000<<IA64_NSEC_PER_CYC_SHIFT in 64 bits	60	* accuracy while being small enough to fit 10*1000000000<<IA64_NSEC_PER_CYC_SHIFT in 64 bits
61	* (this will give enough slack to represent 10 seconds worth of time as a scaled number).	61	* (this will give enough slack to represent 10 seconds worth of time as a scaled number).
62	*/	62	*/
63	#define IA64_NSEC_PER_CYC_SHIFT 30	63	#define IA64_NSEC_PER_CYC_SHIFT 30
64		64
65	#ifndef __ASSEMBLY__	65	#ifndef __ASSEMBLY__
66		66
67	#include <linux/cache.h>	67	#include <linux/cache.h>
68	#include <linux/compiler.h>	68	#include <linux/compiler.h>
69	#include <linux/threads.h>	69	#include <linux/threads.h>
70	#include <linux/types.h>	70	#include <linux/types.h>
71		71
72	#include <asm/fpu.h>	72	#include <asm/fpu.h>
73	#include <asm/page.h>	73	#include <asm/page.h>
74	#include <asm/percpu.h>	74	#include <asm/percpu.h>
75	#include <asm/rse.h>	75	#include <asm/rse.h>
76	#include <asm/unwind.h>	76	#include <asm/unwind.h>
77	#include <asm/atomic.h>	77	#include <asm/atomic.h>
78	#ifdef CONFIG_NUMA	78	#ifdef CONFIG_NUMA
79	#include <asm/nodedata.h>	79	#include <asm/nodedata.h>
80	#endif	80	#endif
81		81
82	/* like above but expressed as bitfields for more efficient access: */	82	/* like above but expressed as bitfields for more efficient access: */
83	struct ia64_psr {	83	struct ia64_psr {
84	__u64 reserved0 : 1;	84	__u64 reserved0 : 1;
85	__u64 be : 1;	85	__u64 be : 1;
86	__u64 up : 1;	86	__u64 up : 1;
87	__u64 ac : 1;	87	__u64 ac : 1;
88	__u64 mfl : 1;	88	__u64 mfl : 1;
89	__u64 mfh : 1;	89	__u64 mfh : 1;
90	__u64 reserved1 : 7;	90	__u64 reserved1 : 7;
91	__u64 ic : 1;	91	__u64 ic : 1;
92	__u64 i : 1;	92	__u64 i : 1;
93	__u64 pk : 1;	93	__u64 pk : 1;
94	__u64 reserved2 : 1;	94	__u64 reserved2 : 1;
95	__u64 dt : 1;	95	__u64 dt : 1;
96	__u64 dfl : 1;	96	__u64 dfl : 1;
97	__u64 dfh : 1;	97	__u64 dfh : 1;
98	__u64 sp : 1;	98	__u64 sp : 1;
99	__u64 pp : 1;	99	__u64 pp : 1;
100	__u64 di : 1;	100	__u64 di : 1;
101	__u64 si : 1;	101	__u64 si : 1;
102	__u64 db : 1;	102	__u64 db : 1;
103	__u64 lp : 1;	103	__u64 lp : 1;
104	__u64 tb : 1;	104	__u64 tb : 1;
105	__u64 rt : 1;	105	__u64 rt : 1;
106	__u64 reserved3 : 4;	106	__u64 reserved3 : 4;
107	__u64 cpl : 2;	107	__u64 cpl : 2;
108	__u64 is : 1;	108	__u64 is : 1;
109	__u64 mc : 1;	109	__u64 mc : 1;
110	__u64 it : 1;	110	__u64 it : 1;
111	__u64 id : 1;	111	__u64 id : 1;
112	__u64 da : 1;	112	__u64 da : 1;
113	__u64 dd : 1;	113	__u64 dd : 1;
114	__u64 ss : 1;	114	__u64 ss : 1;
115	__u64 ri : 2;	115	__u64 ri : 2;
116	__u64 ed : 1;	116	__u64 ed : 1;
117	__u64 bn : 1;	117	__u64 bn : 1;
118	__u64 reserved4 : 19;	118	__u64 reserved4 : 19;
119	};	119	};
120		120
121	/*	121	/*
122	* CPU type, hardware bug flags, and per-CPU state. Frequently used	122	* CPU type, hardware bug flags, and per-CPU state. Frequently used
123	* state comes earlier:	123	* state comes earlier:
124	*/	124	*/
125	struct cpuinfo_ia64 {	125	struct cpuinfo_ia64 {
126	__u32 softirq_pending;	126	__u32 softirq_pending;
127	__u64 itm_delta; /* # of clock cycles between clock ticks */	127	__u64 itm_delta; /* # of clock cycles between clock ticks */
128	__u64 itm_next; /* interval timer mask value to use for next clock tick */	128	__u64 itm_next; /* interval timer mask value to use for next clock tick */
129	__u64 nsec_per_cyc; /* (1000000000<<IA64_NSEC_PER_CYC_SHIFT)/itc_freq */	129	__u64 nsec_per_cyc; /* (1000000000<<IA64_NSEC_PER_CYC_SHIFT)/itc_freq */
130	__u64 unimpl_va_mask; /* mask of unimplemented virtual address bits (from PAL) */	130	__u64 unimpl_va_mask; /* mask of unimplemented virtual address bits (from PAL) */
131	__u64 unimpl_pa_mask; /* mask of unimplemented physical address bits (from PAL) */	131	__u64 unimpl_pa_mask; /* mask of unimplemented physical address bits (from PAL) */
132	__u64 itc_freq; /* frequency of ITC counter */	132	__u64 itc_freq; /* frequency of ITC counter */
133	__u64 proc_freq; /* frequency of processor */	133	__u64 proc_freq; /* frequency of processor */
134	__u64 cyc_per_usec; /* itc_freq/1000000 */	134	__u64 cyc_per_usec; /* itc_freq/1000000 */
135	__u64 ptce_base;	135	__u64 ptce_base;
136	__u32 ptce_count[2];	136	__u32 ptce_count[2];
137	__u32 ptce_stride[2];	137	__u32 ptce_stride[2];
138	struct task_struct ksoftirqd; / kernel softirq daemon for this CPU */	138	struct task_struct ksoftirqd; / kernel softirq daemon for this CPU */
139		139
140	#ifdef CONFIG_SMP	140	#ifdef CONFIG_SMP
141	__u64 loops_per_jiffy;	141	__u64 loops_per_jiffy;
142	int cpu;	142	int cpu;
143	__u32 socket_id; /* physical processor socket id */	143	__u32 socket_id; /* physical processor socket id */
144	__u16 core_id; /* core id */	144	__u16 core_id; /* core id */
145	__u16 thread_id; /* thread id */	145	__u16 thread_id; /* thread id */
146	__u16 num_log; /* Total number of logical processors on	146	__u16 num_log; /* Total number of logical processors on
147	* this socket that were successfully booted */	147	* this socket that were successfully booted */
148	__u8 cores_per_socket; /* Cores per processor socket */	148	__u8 cores_per_socket; /* Cores per processor socket */
149	__u8 threads_per_core; /* Threads per core */	149	__u8 threads_per_core; /* Threads per core */
150	#endif	150	#endif
151		151
152	/* CPUID-derived information: */	152	/* CPUID-derived information: */
153	__u64 ppn;	153	__u64 ppn;
154	__u64 features;	154	__u64 features;
155	__u8 number;	155	__u8 number;
156	__u8 revision;	156	__u8 revision;
157	__u8 model;	157	__u8 model;
158	__u8 family;	158	__u8 family;
159	__u8 archrev;	159	__u8 archrev;
160	char vendor[16];	160	char vendor[16];
161	char *model_name;	161	char *model_name;
162		162
163	#ifdef CONFIG_NUMA	163	#ifdef CONFIG_NUMA
164	struct ia64_node_data *node_data;	164	struct ia64_node_data *node_data;
165	#endif	165	#endif
166	};	166	};
167		167
168	DECLARE_PER_CPU(struct cpuinfo_ia64, cpu_info);	168	DECLARE_PER_CPU(struct cpuinfo_ia64, cpu_info);
169		169
170	/*	170	/*
171	* The "local" data variable. It refers to the per-CPU data of the currently executing	171	* The "local" data variable. It refers to the per-CPU data of the currently executing
172	* CPU, much like "current" points to the per-task data of the currently executing task.	172	* CPU, much like "current" points to the per-task data of the currently executing task.
173	* Do not use the address of local_cpu_data, since it will be different from	173	* Do not use the address of local_cpu_data, since it will be different from
174	* cpu_data(smp_processor_id())!	174	* cpu_data(smp_processor_id())!
175	*/	175	*/
176	#define local_cpu_data (&__ia64_per_cpu_var(cpu_info))	176	#define local_cpu_data (&__ia64_per_cpu_var(cpu_info))
177	#define cpu_data(cpu) (&per_cpu(cpu_info, cpu))	177	#define cpu_data(cpu) (&per_cpu(cpu_info, cpu))
178		178
179	extern void print_cpu_info (struct cpuinfo_ia64 *);	179	extern void print_cpu_info (struct cpuinfo_ia64 *);
180		180
181	typedef struct {	181	typedef struct {
182	unsigned long seg;	182	unsigned long seg;
183	} mm_segment_t;	183	} mm_segment_t;
184		184
185	#define SET_UNALIGN_CTL(task,value) \	185	#define SET_UNALIGN_CTL(task,value) \
186	({ \	186	({ \
187	(task)->thread.flags = (((task)->thread.flags & ~IA64_THREAD_UAC_MASK) \	187	(task)->thread.flags = (((task)->thread.flags & ~IA64_THREAD_UAC_MASK) \
188	\| (((value) << IA64_THREAD_UAC_SHIFT) & IA64_THREAD_UAC_MASK)); \	188	\| (((value) << IA64_THREAD_UAC_SHIFT) & IA64_THREAD_UAC_MASK)); \
189	0; \	189	0; \
190	})	190	})
191	#define GET_UNALIGN_CTL(task,addr) \	191	#define GET_UNALIGN_CTL(task,addr) \
192	({ \	192	({ \
193	put_user(((task)->thread.flags & IA64_THREAD_UAC_MASK) >> IA64_THREAD_UAC_SHIFT, \	193	put_user(((task)->thread.flags & IA64_THREAD_UAC_MASK) >> IA64_THREAD_UAC_SHIFT, \
194	(int __user *) (addr)); \	194	(int __user *) (addr)); \
195	})	195	})
196		196
197	#define SET_FPEMU_CTL(task,value) \	197	#define SET_FPEMU_CTL(task,value) \
198	({ \	198	({ \
199	(task)->thread.flags = (((task)->thread.flags & ~IA64_THREAD_FPEMU_MASK) \	199	(task)->thread.flags = (((task)->thread.flags & ~IA64_THREAD_FPEMU_MASK) \
200	\| (((value) << IA64_THREAD_FPEMU_SHIFT) & IA64_THREAD_FPEMU_MASK)); \	200	\| (((value) << IA64_THREAD_FPEMU_SHIFT) & IA64_THREAD_FPEMU_MASK)); \
201	0; \	201	0; \
202	})	202	})
203	#define GET_FPEMU_CTL(task,addr) \	203	#define GET_FPEMU_CTL(task,addr) \
204	({ \	204	({ \
205	put_user(((task)->thread.flags & IA64_THREAD_FPEMU_MASK) >> IA64_THREAD_FPEMU_SHIFT, \	205	put_user(((task)->thread.flags & IA64_THREAD_FPEMU_MASK) >> IA64_THREAD_FPEMU_SHIFT, \
206	(int __user *) (addr)); \	206	(int __user *) (addr)); \
207	})	207	})
208		208
209	#ifdef CONFIG_IA32_SUPPORT	209	#ifdef CONFIG_IA32_SUPPORT
210	struct desc_struct {	210	struct desc_struct {
211	unsigned int a, b;	211	unsigned int a, b;
212	};	212	};
213		213
214	#define desc_empty(desc) (!((desc)->a \| (desc)->b))	214	#define desc_empty(desc) (!((desc)->a \| (desc)->b))
215	#define desc_equal(desc1, desc2) (((desc1)->a == (desc2)->a) && ((desc1)->b == (desc2)->b))	215	#define desc_equal(desc1, desc2) (((desc1)->a == (desc2)->a) && ((desc1)->b == (desc2)->b))
216		216
217	#define GDT_ENTRY_TLS_ENTRIES 3	217	#define GDT_ENTRY_TLS_ENTRIES 3
218	#define GDT_ENTRY_TLS_MIN 6	218	#define GDT_ENTRY_TLS_MIN 6
219	#define GDT_ENTRY_TLS_MAX (GDT_ENTRY_TLS_MIN + GDT_ENTRY_TLS_ENTRIES - 1)	219	#define GDT_ENTRY_TLS_MAX (GDT_ENTRY_TLS_MIN + GDT_ENTRY_TLS_ENTRIES - 1)
220		220
221	#define TLS_SIZE (GDT_ENTRY_TLS_ENTRIES * 8)	221	#define TLS_SIZE (GDT_ENTRY_TLS_ENTRIES * 8)
222		222
223	struct partial_page_list;	223	struct ia64_partial_page_list;
224	#endif	224	#endif
225		225
226	struct thread_struct {	226	struct thread_struct {
227	__u32 flags; /* various thread flags (see IA64_THREAD_) /	227	__u32 flags; /* various thread flags (see IA64_THREAD_) /
228	/* writing on_ustack is performance-critical, so it's worth spending 8 bits on it... */	228	/* writing on_ustack is performance-critical, so it's worth spending 8 bits on it... */
229	__u8 on_ustack; /* executing on user-stacks? */	229	__u8 on_ustack; /* executing on user-stacks? */
230	__u8 pad[3];	230	__u8 pad[3];
231	__u64 ksp; /* kernel stack pointer */	231	__u64 ksp; /* kernel stack pointer */
232	__u64 map_base; /* base address for get_unmapped_area() */	232	__u64 map_base; /* base address for get_unmapped_area() */
233	__u64 task_size; /* limit for task size */	233	__u64 task_size; /* limit for task size */
234	__u64 rbs_bot; /* the base address for the RBS */	234	__u64 rbs_bot; /* the base address for the RBS */
235	int last_fph_cpu; /* CPU that may hold the contents of f32-f127 */	235	int last_fph_cpu; /* CPU that may hold the contents of f32-f127 */
236		236
237	#ifdef CONFIG_IA32_SUPPORT	237	#ifdef CONFIG_IA32_SUPPORT
238	__u64 eflag; /* IA32 EFLAGS reg */	238	__u64 eflag; /* IA32 EFLAGS reg */
239	__u64 fsr; /* IA32 floating pt status reg */	239	__u64 fsr; /* IA32 floating pt status reg */
240	__u64 fcr; /* IA32 floating pt control reg */	240	__u64 fcr; /* IA32 floating pt control reg */
241	__u64 fir; /* IA32 fp except. instr. reg */	241	__u64 fir; /* IA32 fp except. instr. reg */
242	__u64 fdr; /* IA32 fp except. data reg */	242	__u64 fdr; /* IA32 fp except. data reg */
243	__u64 old_k1; /* old value of ar.k1 */	243	__u64 old_k1; /* old value of ar.k1 */
244	__u64 old_iob; /* old IOBase value */	244	__u64 old_iob; /* old IOBase value */
245	struct partial_page_list ppl; / partial page list for 4K page size issue */	245	struct ia64_partial_page_list ppl; / partial page list for 4K page size issue */
246	/* cached TLS descriptors. */	246	/* cached TLS descriptors. */
247	struct desc_struct tls_array[GDT_ENTRY_TLS_ENTRIES];	247	struct desc_struct tls_array[GDT_ENTRY_TLS_ENTRIES];
248		248
249	# define INIT_THREAD_IA32 .eflag = 0, \	249	# define INIT_THREAD_IA32 .eflag = 0, \
250	.fsr = 0, \	250	.fsr = 0, \
251	.fcr = 0x17800000037fULL, \	251	.fcr = 0x17800000037fULL, \
252	.fir = 0, \	252	.fir = 0, \
253	.fdr = 0, \	253	.fdr = 0, \
254	.old_k1 = 0, \	254	.old_k1 = 0, \
255	.old_iob = 0, \	255	.old_iob = 0, \
256	.ppl = NULL,	256	.ppl = NULL,
257	#else	257	#else
258	# define INIT_THREAD_IA32	258	# define INIT_THREAD_IA32
259	#endif /* CONFIG_IA32_SUPPORT */	259	#endif /* CONFIG_IA32_SUPPORT */
260	#ifdef CONFIG_PERFMON	260	#ifdef CONFIG_PERFMON
261	void pfm_context; / pointer to detailed PMU context */	261	void pfm_context; / pointer to detailed PMU context */
262	unsigned long pfm_needs_checking; /* when >0, pending perfmon work on kernel exit */	262	unsigned long pfm_needs_checking; /* when >0, pending perfmon work on kernel exit */
263	# define INIT_THREAD_PM .pfm_context = NULL, \	263	# define INIT_THREAD_PM .pfm_context = NULL, \
264	.pfm_needs_checking = 0UL,	264	.pfm_needs_checking = 0UL,
265	#else	265	#else
266	# define INIT_THREAD_PM	266	# define INIT_THREAD_PM
267	#endif	267	#endif
268	__u64 dbr[IA64_NUM_DBG_REGS];	268	__u64 dbr[IA64_NUM_DBG_REGS];
269	__u64 ibr[IA64_NUM_DBG_REGS];	269	__u64 ibr[IA64_NUM_DBG_REGS];
270	struct ia64_fpreg fph[96]; /* saved/loaded on demand */	270	struct ia64_fpreg fph[96]; /* saved/loaded on demand */
271	};	271	};
272		272
273	#define INIT_THREAD { \	273	#define INIT_THREAD { \
274	.flags = 0, \	274	.flags = 0, \
275	.on_ustack = 0, \	275	.on_ustack = 0, \
276	.ksp = 0, \	276	.ksp = 0, \
277	.map_base = DEFAULT_MAP_BASE, \	277	.map_base = DEFAULT_MAP_BASE, \
278	.rbs_bot = STACK_TOP - DEFAULT_USER_STACK_SIZE, \	278	.rbs_bot = STACK_TOP - DEFAULT_USER_STACK_SIZE, \
279	.task_size = DEFAULT_TASK_SIZE, \	279	.task_size = DEFAULT_TASK_SIZE, \
280	.last_fph_cpu = -1, \	280	.last_fph_cpu = -1, \
281	INIT_THREAD_IA32 \	281	INIT_THREAD_IA32 \
282	INIT_THREAD_PM \	282	INIT_THREAD_PM \
283	.dbr = {0, }, \	283	.dbr = {0, }, \
284	.ibr = {0, }, \	284	.ibr = {0, }, \
285	.fph = {{{{0}}}, } \	285	.fph = {{{{0}}}, } \
286	}	286	}
287		287
288	#define start_thread(regs,new_ip,new_sp) do { \	288	#define start_thread(regs,new_ip,new_sp) do { \
289	set_fs(USER_DS); \	289	set_fs(USER_DS); \
290	regs->cr_ipsr = ((regs->cr_ipsr \| (IA64_PSR_BITS_TO_SET \| IA64_PSR_CPL)) \	290	regs->cr_ipsr = ((regs->cr_ipsr \| (IA64_PSR_BITS_TO_SET \| IA64_PSR_CPL)) \
291	& ~(IA64_PSR_BITS_TO_CLEAR \| IA64_PSR_RI \| IA64_PSR_IS)); \	291	& ~(IA64_PSR_BITS_TO_CLEAR \| IA64_PSR_RI \| IA64_PSR_IS)); \
292	regs->cr_iip = new_ip; \	292	regs->cr_iip = new_ip; \
293	regs->ar_rsc = 0xf; /* eager mode, privilege level 3 */ \	293	regs->ar_rsc = 0xf; /* eager mode, privilege level 3 */ \
294	regs->ar_rnat = 0; \	294	regs->ar_rnat = 0; \
295	regs->ar_bspstore = current->thread.rbs_bot; \	295	regs->ar_bspstore = current->thread.rbs_bot; \
296	regs->ar_fpsr = FPSR_DEFAULT; \	296	regs->ar_fpsr = FPSR_DEFAULT; \
297	regs->loadrs = 0; \	297	regs->loadrs = 0; \
298	regs->r8 = get_dumpable(current->mm); /* set "don't zap registers" flag */ \	298	regs->r8 = get_dumpable(current->mm); /* set "don't zap registers" flag */ \
299	regs->r12 = new_sp - 16; /* allocate 16 byte scratch area */ \	299	regs->r12 = new_sp - 16; /* allocate 16 byte scratch area */ \
300	if (unlikely(!get_dumpable(current->mm))) { \	300	if (unlikely(!get_dumpable(current->mm))) { \
301	/* \	301	/* \
302	* Zap scratch regs to avoid leaking bits between processes with different \	302	* Zap scratch regs to avoid leaking bits between processes with different \
303	* uid/privileges. \	303	* uid/privileges. \
304	*/ \	304	*/ \
305	regs->ar_pfs = 0; regs->b0 = 0; regs->pr = 0; \	305	regs->ar_pfs = 0; regs->b0 = 0; regs->pr = 0; \
306	regs->r1 = 0; regs->r9 = 0; regs->r11 = 0; regs->r13 = 0; regs->r15 = 0; \	306	regs->r1 = 0; regs->r9 = 0; regs->r11 = 0; regs->r13 = 0; regs->r15 = 0; \
307	} \	307	} \
308	} while (0)	308	} while (0)
309		309
310	/* Forward declarations, a strange C thing... */	310	/* Forward declarations, a strange C thing... */
311	struct mm_struct;	311	struct mm_struct;
312	struct task_struct;	312	struct task_struct;
313		313
314	/*	314	/*
315	* Free all resources held by a thread. This is called after the	315	* Free all resources held by a thread. This is called after the
316	* parent of DEAD_TASK has collected the exit status of the task via	316	* parent of DEAD_TASK has collected the exit status of the task via
317	* wait().	317	* wait().
318	*/	318	*/
319	#define release_thread(dead_task)	319	#define release_thread(dead_task)
320		320
321	/* Prepare to copy thread state - unlazy all lazy status */	321	/* Prepare to copy thread state - unlazy all lazy status */
322	#define prepare_to_copy(tsk) do { } while (0)	322	#define prepare_to_copy(tsk) do { } while (0)
323		323
324	/*	324	/*
325	* This is the mechanism for creating a new kernel thread.	325	* This is the mechanism for creating a new kernel thread.
326	*	326	*
327	* NOTE 1: Only a kernel-only process (ie the swapper or direct	327	* NOTE 1: Only a kernel-only process (ie the swapper or direct
328	* descendants who haven't done an "execve()") should use this: it	328	* descendants who haven't done an "execve()") should use this: it
329	* will work within a system call from a "real" process, but the	329	* will work within a system call from a "real" process, but the
330	* process memory space will not be free'd until both the parent and	330	* process memory space will not be free'd until both the parent and
331	* the child have exited.	331	* the child have exited.
332	*	332	*
333	* NOTE 2: This MUST NOT be an inlined function. Otherwise, we get	333	* NOTE 2: This MUST NOT be an inlined function. Otherwise, we get
334	* into trouble in init/main.c when the child thread returns to	334	* into trouble in init/main.c when the child thread returns to
335	* do_basic_setup() and the timing is such that free_initmem() has	335	* do_basic_setup() and the timing is such that free_initmem() has
336	* been called already.	336	* been called already.
337	*/	337	*/
338	extern pid_t kernel_thread (int (fn)(void ), void *arg, unsigned long flags);	338	extern pid_t kernel_thread (int (fn)(void ), void *arg, unsigned long flags);
339		339
340	/* Get wait channel for task P. */	340	/* Get wait channel for task P. */
341	extern unsigned long get_wchan (struct task_struct *p);	341	extern unsigned long get_wchan (struct task_struct *p);
342		342
343	/* Return instruction pointer of blocked task TSK. */	343	/* Return instruction pointer of blocked task TSK. */
344	#define KSTK_EIP(tsk) \	344	#define KSTK_EIP(tsk) \
345	({ \	345	({ \
346	struct pt_regs *_regs = task_pt_regs(tsk); \	346	struct pt_regs *_regs = task_pt_regs(tsk); \
347	_regs->cr_iip + ia64_psr(_regs)->ri; \	347	_regs->cr_iip + ia64_psr(_regs)->ri; \
348	})	348	})
349		349
350	/* Return stack pointer of blocked task TSK. */	350	/* Return stack pointer of blocked task TSK. */
351	#define KSTK_ESP(tsk) ((tsk)->thread.ksp)	351	#define KSTK_ESP(tsk) ((tsk)->thread.ksp)
352		352
353	extern void ia64_getreg_unknown_kr (void);	353	extern void ia64_getreg_unknown_kr (void);
354	extern void ia64_setreg_unknown_kr (void);	354	extern void ia64_setreg_unknown_kr (void);
355		355
356	#define ia64_get_kr(regnum) \	356	#define ia64_get_kr(regnum) \
357	({ \	357	({ \
358	unsigned long r = 0; \	358	unsigned long r = 0; \
359	\	359	\
360	switch (regnum) { \	360	switch (regnum) { \
361	case 0: r = ia64_getreg(_IA64_REG_AR_KR0); break; \	361	case 0: r = ia64_getreg(_IA64_REG_AR_KR0); break; \
362	case 1: r = ia64_getreg(_IA64_REG_AR_KR1); break; \	362	case 1: r = ia64_getreg(_IA64_REG_AR_KR1); break; \
363	case 2: r = ia64_getreg(_IA64_REG_AR_KR2); break; \	363	case 2: r = ia64_getreg(_IA64_REG_AR_KR2); break; \
364	case 3: r = ia64_getreg(_IA64_REG_AR_KR3); break; \	364	case 3: r = ia64_getreg(_IA64_REG_AR_KR3); break; \
365	case 4: r = ia64_getreg(_IA64_REG_AR_KR4); break; \	365	case 4: r = ia64_getreg(_IA64_REG_AR_KR4); break; \
366	case 5: r = ia64_getreg(_IA64_REG_AR_KR5); break; \	366	case 5: r = ia64_getreg(_IA64_REG_AR_KR5); break; \
367	case 6: r = ia64_getreg(_IA64_REG_AR_KR6); break; \	367	case 6: r = ia64_getreg(_IA64_REG_AR_KR6); break; \
368	case 7: r = ia64_getreg(_IA64_REG_AR_KR7); break; \	368	case 7: r = ia64_getreg(_IA64_REG_AR_KR7); break; \
369	default: ia64_getreg_unknown_kr(); break; \	369	default: ia64_getreg_unknown_kr(); break; \
370	} \	370	} \
371	r; \	371	r; \
372	})	372	})
373		373
374	#define ia64_set_kr(regnum, r) \	374	#define ia64_set_kr(regnum, r) \
375	({ \	375	({ \
376	switch (regnum) { \	376	switch (regnum) { \
377	case 0: ia64_setreg(_IA64_REG_AR_KR0, r); break; \	377	case 0: ia64_setreg(_IA64_REG_AR_KR0, r); break; \
378	case 1: ia64_setreg(_IA64_REG_AR_KR1, r); break; \	378	case 1: ia64_setreg(_IA64_REG_AR_KR1, r); break; \
379	case 2: ia64_setreg(_IA64_REG_AR_KR2, r); break; \	379	case 2: ia64_setreg(_IA64_REG_AR_KR2, r); break; \
380	case 3: ia64_setreg(_IA64_REG_AR_KR3, r); break; \	380	case 3: ia64_setreg(_IA64_REG_AR_KR3, r); break; \
381	case 4: ia64_setreg(_IA64_REG_AR_KR4, r); break; \	381	case 4: ia64_setreg(_IA64_REG_AR_KR4, r); break; \
382	case 5: ia64_setreg(_IA64_REG_AR_KR5, r); break; \	382	case 5: ia64_setreg(_IA64_REG_AR_KR5, r); break; \
383	case 6: ia64_setreg(_IA64_REG_AR_KR6, r); break; \	383	case 6: ia64_setreg(_IA64_REG_AR_KR6, r); break; \
384	case 7: ia64_setreg(_IA64_REG_AR_KR7, r); break; \	384	case 7: ia64_setreg(_IA64_REG_AR_KR7, r); break; \
385	default: ia64_setreg_unknown_kr(); break; \	385	default: ia64_setreg_unknown_kr(); break; \
386	} \	386	} \
387	})	387	})
388		388
389	/*	389	/*
390	* The following three macros can't be inline functions because we don't have struct	390	* The following three macros can't be inline functions because we don't have struct
391	* task_struct at this point.	391	* task_struct at this point.
392	*/	392	*/
393		393
394	/*	394	/*
395	* Return TRUE if task T owns the fph partition of the CPU we're running on.	395	* Return TRUE if task T owns the fph partition of the CPU we're running on.
396	* Must be called from code that has preemption disabled.	396	* Must be called from code that has preemption disabled.
397	*/	397	*/
398	#define ia64_is_local_fpu_owner(t) \	398	#define ia64_is_local_fpu_owner(t) \
399	({ \	399	({ \
400	struct task_struct *__ia64_islfo_task = (t); \	400	struct task_struct *__ia64_islfo_task = (t); \
401	(__ia64_islfo_task->thread.last_fph_cpu == smp_processor_id() \	401	(__ia64_islfo_task->thread.last_fph_cpu == smp_processor_id() \
402	&& __ia64_islfo_task == (struct task_struct *) ia64_get_kr(IA64_KR_FPU_OWNER)); \	402	&& __ia64_islfo_task == (struct task_struct *) ia64_get_kr(IA64_KR_FPU_OWNER)); \
403	})	403	})
404		404
405	/*	405	/*
406	* Mark task T as owning the fph partition of the CPU we're running on.	406	* Mark task T as owning the fph partition of the CPU we're running on.
407	* Must be called from code that has preemption disabled.	407	* Must be called from code that has preemption disabled.
408	*/	408	*/
409	#define ia64_set_local_fpu_owner(t) do { \	409	#define ia64_set_local_fpu_owner(t) do { \
410	struct task_struct *__ia64_slfo_task = (t); \	410	struct task_struct *__ia64_slfo_task = (t); \
411	__ia64_slfo_task->thread.last_fph_cpu = smp_processor_id(); \	411	__ia64_slfo_task->thread.last_fph_cpu = smp_processor_id(); \
412	ia64_set_kr(IA64_KR_FPU_OWNER, (unsigned long) __ia64_slfo_task); \	412	ia64_set_kr(IA64_KR_FPU_OWNER, (unsigned long) __ia64_slfo_task); \
413	} while (0)	413	} while (0)
414		414
415	/* Mark the fph partition of task T as being invalid on all CPUs. */	415	/* Mark the fph partition of task T as being invalid on all CPUs. */
416	#define ia64_drop_fpu(t) ((t)->thread.last_fph_cpu = -1)	416	#define ia64_drop_fpu(t) ((t)->thread.last_fph_cpu = -1)
417		417
418	extern void __ia64_init_fpu (void);	418	extern void __ia64_init_fpu (void);
419	extern void __ia64_save_fpu (struct ia64_fpreg *fph);	419	extern void __ia64_save_fpu (struct ia64_fpreg *fph);
420	extern void __ia64_load_fpu (struct ia64_fpreg *fph);	420	extern void __ia64_load_fpu (struct ia64_fpreg *fph);
421	extern void ia64_save_debug_regs (unsigned long *save_area);	421	extern void ia64_save_debug_regs (unsigned long *save_area);
422	extern void ia64_load_debug_regs (unsigned long *save_area);	422	extern void ia64_load_debug_regs (unsigned long *save_area);
423		423
424	#ifdef CONFIG_IA32_SUPPORT	424	#ifdef CONFIG_IA32_SUPPORT
425	extern void ia32_save_state (struct task_struct *task);	425	extern void ia32_save_state (struct task_struct *task);
426	extern void ia32_load_state (struct task_struct *task);	426	extern void ia32_load_state (struct task_struct *task);
427	#endif	427	#endif
428		428
429	#define ia64_fph_enable() do { ia64_rsm(IA64_PSR_DFH); ia64_srlz_d(); } while (0)	429	#define ia64_fph_enable() do { ia64_rsm(IA64_PSR_DFH); ia64_srlz_d(); } while (0)
430	#define ia64_fph_disable() do { ia64_ssm(IA64_PSR_DFH); ia64_srlz_d(); } while (0)	430	#define ia64_fph_disable() do { ia64_ssm(IA64_PSR_DFH); ia64_srlz_d(); } while (0)
431		431
432	/* load fp 0.0 into fph */	432	/* load fp 0.0 into fph */
433	static inline void	433	static inline void
434	ia64_init_fpu (void) {	434	ia64_init_fpu (void) {
435	ia64_fph_enable();	435	ia64_fph_enable();
436	__ia64_init_fpu();	436	__ia64_init_fpu();
437	ia64_fph_disable();	437	ia64_fph_disable();
438	}	438	}
439		439
440	/* save f32-f127 at FPH */	440	/* save f32-f127 at FPH */
441	static inline void	441	static inline void
442	ia64_save_fpu (struct ia64_fpreg *fph) {	442	ia64_save_fpu (struct ia64_fpreg *fph) {
443	ia64_fph_enable();	443	ia64_fph_enable();
444	__ia64_save_fpu(fph);	444	__ia64_save_fpu(fph);
445	ia64_fph_disable();	445	ia64_fph_disable();
446	}	446	}
447		447
448	/* load f32-f127 from FPH */	448	/* load f32-f127 from FPH */
449	static inline void	449	static inline void
450	ia64_load_fpu (struct ia64_fpreg *fph) {	450	ia64_load_fpu (struct ia64_fpreg *fph) {
451	ia64_fph_enable();	451	ia64_fph_enable();
452	__ia64_load_fpu(fph);	452	__ia64_load_fpu(fph);
453	ia64_fph_disable();	453	ia64_fph_disable();
454	}	454	}
455		455
456	static inline __u64	456	static inline __u64
457	ia64_clear_ic (void)	457	ia64_clear_ic (void)
458	{	458	{
459	__u64 psr;	459	__u64 psr;
460	psr = ia64_getreg(_IA64_REG_PSR);	460	psr = ia64_getreg(_IA64_REG_PSR);
461	ia64_stop();	461	ia64_stop();
462	ia64_rsm(IA64_PSR_I \| IA64_PSR_IC);	462	ia64_rsm(IA64_PSR_I \| IA64_PSR_IC);
463	ia64_srlz_i();	463	ia64_srlz_i();
464	return psr;	464	return psr;
465	}	465	}
466		466
467	/*	467	/*
468	* Restore the psr.	468	* Restore the psr.
469	*/	469	*/
470	static inline void	470	static inline void
471	ia64_set_psr (__u64 psr)	471	ia64_set_psr (__u64 psr)
472	{	472	{
473	ia64_stop();	473	ia64_stop();
474	ia64_setreg(_IA64_REG_PSR_L, psr);	474	ia64_setreg(_IA64_REG_PSR_L, psr);
475	ia64_srlz_d();	475	ia64_srlz_d();
476	}	476	}
477		477
478	/*	478	/*
479	* Insert a translation into an instruction and/or data translation	479	* Insert a translation into an instruction and/or data translation
480	* register.	480	* register.
481	*/	481	*/
482	static inline void	482	static inline void
483	ia64_itr (__u64 target_mask, __u64 tr_num,	483	ia64_itr (__u64 target_mask, __u64 tr_num,
484	__u64 vmaddr, __u64 pte,	484	__u64 vmaddr, __u64 pte,
485	__u64 log_page_size)	485	__u64 log_page_size)
486	{	486	{
487	ia64_setreg(_IA64_REG_CR_ITIR, (log_page_size << 2));	487	ia64_setreg(_IA64_REG_CR_ITIR, (log_page_size << 2));
488	ia64_setreg(_IA64_REG_CR_IFA, vmaddr);	488	ia64_setreg(_IA64_REG_CR_IFA, vmaddr);
489	ia64_stop();	489	ia64_stop();
490	if (target_mask & 0x1)	490	if (target_mask & 0x1)
491	ia64_itri(tr_num, pte);	491	ia64_itri(tr_num, pte);
492	if (target_mask & 0x2)	492	if (target_mask & 0x2)
493	ia64_itrd(tr_num, pte);	493	ia64_itrd(tr_num, pte);
494	}	494	}
495		495
496	/*	496	/*
497	* Insert a translation into the instruction and/or data translation	497	* Insert a translation into the instruction and/or data translation
498	* cache.	498	* cache.
499	*/	499	*/
500	static inline void	500	static inline void
501	ia64_itc (__u64 target_mask, __u64 vmaddr, __u64 pte,	501	ia64_itc (__u64 target_mask, __u64 vmaddr, __u64 pte,
502	__u64 log_page_size)	502	__u64 log_page_size)
503	{	503	{
504	ia64_setreg(_IA64_REG_CR_ITIR, (log_page_size << 2));	504	ia64_setreg(_IA64_REG_CR_ITIR, (log_page_size << 2));
505	ia64_setreg(_IA64_REG_CR_IFA, vmaddr);	505	ia64_setreg(_IA64_REG_CR_IFA, vmaddr);
506	ia64_stop();	506	ia64_stop();
507	/* as per EAS2.6, itc must be the last instruction in an instruction group */	507	/* as per EAS2.6, itc must be the last instruction in an instruction group */
508	if (target_mask & 0x1)	508	if (target_mask & 0x1)
509	ia64_itci(pte);	509	ia64_itci(pte);
510	if (target_mask & 0x2)	510	if (target_mask & 0x2)
511	ia64_itcd(pte);	511	ia64_itcd(pte);
512	}	512	}
513		513
514	/*	514	/*
515	* Purge a range of addresses from instruction and/or data translation	515	* Purge a range of addresses from instruction and/or data translation
516	* register(s).	516	* register(s).
517	*/	517	*/
518	static inline void	518	static inline void
519	ia64_ptr (__u64 target_mask, __u64 vmaddr, __u64 log_size)	519	ia64_ptr (__u64 target_mask, __u64 vmaddr, __u64 log_size)
520	{	520	{
521	if (target_mask & 0x1)	521	if (target_mask & 0x1)
522	ia64_ptri(vmaddr, (log_size << 2));	522	ia64_ptri(vmaddr, (log_size << 2));
523	if (target_mask & 0x2)	523	if (target_mask & 0x2)
524	ia64_ptrd(vmaddr, (log_size << 2));	524	ia64_ptrd(vmaddr, (log_size << 2));
525	}	525	}
526		526
527	/* Set the interrupt vector address. The address must be suitably aligned (32KB). */	527	/* Set the interrupt vector address. The address must be suitably aligned (32KB). */
528	static inline void	528	static inline void
529	ia64_set_iva (void *ivt_addr)	529	ia64_set_iva (void *ivt_addr)
530	{	530	{
531	ia64_setreg(_IA64_REG_CR_IVA, (__u64) ivt_addr);	531	ia64_setreg(_IA64_REG_CR_IVA, (__u64) ivt_addr);
532	ia64_srlz_i();	532	ia64_srlz_i();
533	}	533	}
534		534
535	/* Set the page table address and control bits. */	535	/* Set the page table address and control bits. */
536	static inline void	536	static inline void
537	ia64_set_pta (__u64 pta)	537	ia64_set_pta (__u64 pta)
538	{	538	{
539	/* Note: srlz.i implies srlz.d */	539	/* Note: srlz.i implies srlz.d */
540	ia64_setreg(_IA64_REG_CR_PTA, pta);	540	ia64_setreg(_IA64_REG_CR_PTA, pta);
541	ia64_srlz_i();	541	ia64_srlz_i();
542	}	542	}
543		543
544	static inline void	544	static inline void
545	ia64_eoi (void)	545	ia64_eoi (void)
546	{	546	{
547	ia64_setreg(_IA64_REG_CR_EOI, 0);	547	ia64_setreg(_IA64_REG_CR_EOI, 0);
548	ia64_srlz_d();	548	ia64_srlz_d();
549	}	549	}
550		550
551	#define cpu_relax() ia64_hint(ia64_hint_pause)	551	#define cpu_relax() ia64_hint(ia64_hint_pause)
552		552
553	static inline int	553	static inline int
554	ia64_get_irr(unsigned int vector)	554	ia64_get_irr(unsigned int vector)
555	{	555	{
556	unsigned int reg = vector / 64;	556	unsigned int reg = vector / 64;
557	unsigned int bit = vector % 64;	557	unsigned int bit = vector % 64;
558	u64 irr;	558	u64 irr;
559		559
560	switch (reg) {	560	switch (reg) {
561	case 0: irr = ia64_getreg(_IA64_REG_CR_IRR0); break;	561	case 0: irr = ia64_getreg(_IA64_REG_CR_IRR0); break;
562	case 1: irr = ia64_getreg(_IA64_REG_CR_IRR1); break;	562	case 1: irr = ia64_getreg(_IA64_REG_CR_IRR1); break;
563	case 2: irr = ia64_getreg(_IA64_REG_CR_IRR2); break;	563	case 2: irr = ia64_getreg(_IA64_REG_CR_IRR2); break;
564	case 3: irr = ia64_getreg(_IA64_REG_CR_IRR3); break;	564	case 3: irr = ia64_getreg(_IA64_REG_CR_IRR3); break;
565	}	565	}
566		566
567	return test_bit(bit, &irr);	567	return test_bit(bit, &irr);
568	}	568	}
569		569
570	static inline void	570	static inline void
571	ia64_set_lrr0 (unsigned long val)	571	ia64_set_lrr0 (unsigned long val)
572	{	572	{
573	ia64_setreg(_IA64_REG_CR_LRR0, val);	573	ia64_setreg(_IA64_REG_CR_LRR0, val);
574	ia64_srlz_d();	574	ia64_srlz_d();
575	}	575	}
576		576
577	static inline void	577	static inline void
578	ia64_set_lrr1 (unsigned long val)	578	ia64_set_lrr1 (unsigned long val)
579	{	579	{
580	ia64_setreg(_IA64_REG_CR_LRR1, val);	580	ia64_setreg(_IA64_REG_CR_LRR1, val);
581	ia64_srlz_d();	581	ia64_srlz_d();
582	}	582	}
583		583
584		584
585	/*	585	/*
586	* Given the address to which a spill occurred, return the unat bit	586	* Given the address to which a spill occurred, return the unat bit
587	* number that corresponds to this address.	587	* number that corresponds to this address.
588	*/	588	*/
589	static inline __u64	589	static inline __u64
590	ia64_unat_pos (void *spill_addr)	590	ia64_unat_pos (void *spill_addr)
591	{	591	{
592	return ((__u64) spill_addr >> 3) & 0x3f;	592	return ((__u64) spill_addr >> 3) & 0x3f;
593	}	593	}
594		594
595	/*	595	/*
596	* Set the NaT bit of an integer register which was spilled at address	596	* Set the NaT bit of an integer register which was spilled at address
597	* SPILL_ADDR. UNAT is the mask to be updated.	597	* SPILL_ADDR. UNAT is the mask to be updated.
598	*/	598	*/
599	static inline void	599	static inline void
600	ia64_set_unat (__u64 unat, void spill_addr, unsigned long nat)	600	ia64_set_unat (__u64 unat, void spill_addr, unsigned long nat)
601	{	601	{
602	__u64 bit = ia64_unat_pos(spill_addr);	602	__u64 bit = ia64_unat_pos(spill_addr);
603	__u64 mask = 1UL << bit;	603	__u64 mask = 1UL << bit;
604		604
605	unat = (unat & ~mask) \| (nat << bit);	605	unat = (unat & ~mask) \| (nat << bit);
606	}	606	}
607		607
608	/*	608	/*
609	* Return saved PC of a blocked thread.	609	* Return saved PC of a blocked thread.
610	* Note that the only way T can block is through a call to schedule() -> switch_to().	610	* Note that the only way T can block is through a call to schedule() -> switch_to().
611	*/	611	*/
612	static inline unsigned long	612	static inline unsigned long
613	thread_saved_pc (struct task_struct *t)	613	thread_saved_pc (struct task_struct *t)
614	{	614	{
615	struct unw_frame_info info;	615	struct unw_frame_info info;
616	unsigned long ip;	616	unsigned long ip;
617		617
618	unw_init_from_blocked_task(&info, t);	618	unw_init_from_blocked_task(&info, t);
619	if (unw_unwind(&info) < 0)	619	if (unw_unwind(&info) < 0)
620	return 0;	620	return 0;
621	unw_get_ip(&info, &ip);	621	unw_get_ip(&info, &ip);
622	return ip;	622	return ip;
623	}	623	}
624		624
625	/*	625	/*
626	* Get the current instruction/program counter value.	626	* Get the current instruction/program counter value.
627	*/	627	*/
628	#define current_text_addr() \	628	#define current_text_addr() \
629	({ void _pc; _pc = (void )ia64_getreg(_IA64_REG_IP); _pc; })	629	({ void _pc; _pc = (void )ia64_getreg(_IA64_REG_IP); _pc; })
630		630
631	static inline __u64	631	static inline __u64
632	ia64_get_ivr (void)	632	ia64_get_ivr (void)
633	{	633	{
634	__u64 r;	634	__u64 r;
635	ia64_srlz_d();	635	ia64_srlz_d();
636	r = ia64_getreg(_IA64_REG_CR_IVR);	636	r = ia64_getreg(_IA64_REG_CR_IVR);
637	ia64_srlz_d();	637	ia64_srlz_d();
638	return r;	638	return r;
639	}	639	}
640		640
641	static inline void	641	static inline void
642	ia64_set_dbr (__u64 regnum, __u64 value)	642	ia64_set_dbr (__u64 regnum, __u64 value)
643	{	643	{
644	__ia64_set_dbr(regnum, value);	644	__ia64_set_dbr(regnum, value);
645	#ifdef CONFIG_ITANIUM	645	#ifdef CONFIG_ITANIUM
646	ia64_srlz_d();	646	ia64_srlz_d();
647	#endif	647	#endif
648	}	648	}
649		649
650	static inline __u64	650	static inline __u64
651	ia64_get_dbr (__u64 regnum)	651	ia64_get_dbr (__u64 regnum)
652	{	652	{
653	__u64 retval;	653	__u64 retval;
654		654
655	retval = __ia64_get_dbr(regnum);	655	retval = __ia64_get_dbr(regnum);
656	#ifdef CONFIG_ITANIUM	656	#ifdef CONFIG_ITANIUM
657	ia64_srlz_d();	657	ia64_srlz_d();
658	#endif	658	#endif
659	return retval;	659	return retval;
660	}	660	}
661		661
662	static inline __u64	662	static inline __u64
663	ia64_rotr (__u64 w, __u64 n)	663	ia64_rotr (__u64 w, __u64 n)
664	{	664	{
665	return (w >> n) \| (w << (64 - n));	665	return (w >> n) \| (w << (64 - n));
666	}	666	}
667		667
668	#define ia64_rotl(w,n) ia64_rotr((w), (64) - (n))	668	#define ia64_rotl(w,n) ia64_rotr((w), (64) - (n))
669		669
670	/*	670	/*
671	* Take a mapped kernel address and return the equivalent address	671	* Take a mapped kernel address and return the equivalent address
672	* in the region 7 identity mapped virtual area.	672	* in the region 7 identity mapped virtual area.
673	*/	673	*/
674	static inline void *	674	static inline void *
675	ia64_imva (void *addr)	675	ia64_imva (void *addr)
676	{	676	{
677	void *result;	677	void *result;
678	result = (void *) ia64_tpa(addr);	678	result = (void *) ia64_tpa(addr);
679	return __va(result);	679	return __va(result);
680	}	680	}
681		681
682	#define ARCH_HAS_PREFETCH	682	#define ARCH_HAS_PREFETCH
683	#define ARCH_HAS_PREFETCHW	683	#define ARCH_HAS_PREFETCHW
684	#define ARCH_HAS_SPINLOCK_PREFETCH	684	#define ARCH_HAS_SPINLOCK_PREFETCH
685	#define PREFETCH_STRIDE L1_CACHE_BYTES	685	#define PREFETCH_STRIDE L1_CACHE_BYTES
686		686
687	static inline void	687	static inline void
688	prefetch (const void *x)	688	prefetch (const void *x)
689	{	689	{
690	ia64_lfetch(ia64_lfhint_none, x);	690	ia64_lfetch(ia64_lfhint_none, x);
691	}	691	}
692		692
693	static inline void	693	static inline void
694	prefetchw (const void *x)	694	prefetchw (const void *x)
695	{	695	{
696	ia64_lfetch_excl(ia64_lfhint_none, x);	696	ia64_lfetch_excl(ia64_lfhint_none, x);
697	}	697	}
698		698
699	#define spin_lock_prefetch(x) prefetchw(x)	699	#define spin_lock_prefetch(x) prefetchw(x)
700		700
701	extern unsigned long boot_option_idle_override;	701	extern unsigned long boot_option_idle_override;
702		702
703	#endif /* !__ASSEMBLY__ */	703	#endif /* !__ASSEMBLY__ */
704		704
705	#endif /* _ASM_IA64_PROCESSOR_H */	705	#endif /* _ASM_IA64_PROCESSOR_H */
706		706