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