Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 1 | /* |
| 2 | * This program is used to generate definitions needed by |
| 3 | * assembly language modules. |
| 4 | * |
| 5 | * We use the technique used in the OSF Mach kernel code: |
| 6 | * generate asm statements containing #defines, |
| 7 | * compile this file to assembler, and then extract the |
| 8 | * #defines from the assembly-language output. |
| 9 | * |
| 10 | * This program is free software; you can redistribute it and/or |
| 11 | * modify it under the terms of the GNU General Public License |
| 12 | * as published by the Free Software Foundation; either version |
| 13 | * 2 of the License, or (at your option) any later version. |
| 14 | */ |
| 15 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 16 | #include <linux/signal.h> |
| 17 | #include <linux/sched.h> |
| 18 | #include <linux/kernel.h> |
| 19 | #include <linux/errno.h> |
| 20 | #include <linux/string.h> |
| 21 | #include <linux/types.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 22 | #include <linux/mman.h> |
| 23 | #include <linux/mm.h> |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 24 | #ifdef CONFIG_PPC64 |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 25 | #include <linux/time.h> |
| 26 | #include <linux/hardirq.h> |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 27 | #else |
| 28 | #include <linux/ptrace.h> |
| 29 | #include <linux/suspend.h> |
| 30 | #endif |
| 31 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 32 | #include <asm/io.h> |
| 33 | #include <asm/page.h> |
| 34 | #include <asm/pgtable.h> |
| 35 | #include <asm/processor.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 36 | #include <asm/cputable.h> |
| 37 | #include <asm/thread_info.h> |
Paul Mackerras | 033ef33 | 2005-10-26 17:05:24 +1000 | [diff] [blame] | 38 | #include <asm/rtas.h> |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 39 | #include <asm/vdso_datapage.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 40 | #ifdef CONFIG_PPC64 |
| 41 | #include <asm/paca.h> |
| 42 | #include <asm/lppaca.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 43 | #include <asm/cache.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 44 | #include <asm/compat.h> |
Michael Neuling | 11a27ad | 2006-08-09 17:00:30 +1000 | [diff] [blame] | 45 | #include <asm/mmu.h> |
Olof Johansson | f04da0bc | 2006-09-13 13:32:39 -0500 | [diff] [blame^] | 46 | #include <asm/hvcall.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 47 | #endif |
| 48 | |
| 49 | #define DEFINE(sym, val) \ |
| 50 | asm volatile("\n->" #sym " %0 " #val : : "i" (val)) |
| 51 | |
| 52 | #define BLANK() asm volatile("\n->" : : ) |
| 53 | |
| 54 | int main(void) |
| 55 | { |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 56 | DEFINE(THREAD, offsetof(struct task_struct, thread)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 57 | DEFINE(MM, offsetof(struct task_struct, mm)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 58 | #ifdef CONFIG_PPC64 |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 59 | DEFINE(AUDITCONTEXT, offsetof(struct task_struct, audit_context)); |
| 60 | #else |
| 61 | DEFINE(THREAD_INFO, offsetof(struct task_struct, thread_info)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 62 | DEFINE(PTRACE, offsetof(struct task_struct, ptrace)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 63 | #endif /* CONFIG_PPC64 */ |
| 64 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 65 | DEFINE(KSP, offsetof(struct thread_struct, ksp)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 66 | DEFINE(PT_REGS, offsetof(struct thread_struct, regs)); |
| 67 | DEFINE(THREAD_FPEXC_MODE, offsetof(struct thread_struct, fpexc_mode)); |
| 68 | DEFINE(THREAD_FPR0, offsetof(struct thread_struct, fpr[0])); |
| 69 | DEFINE(THREAD_FPSCR, offsetof(struct thread_struct, fpscr)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 70 | #ifdef CONFIG_ALTIVEC |
| 71 | DEFINE(THREAD_VR0, offsetof(struct thread_struct, vr[0])); |
| 72 | DEFINE(THREAD_VRSAVE, offsetof(struct thread_struct, vrsave)); |
| 73 | DEFINE(THREAD_VSCR, offsetof(struct thread_struct, vscr)); |
| 74 | DEFINE(THREAD_USED_VR, offsetof(struct thread_struct, used_vr)); |
| 75 | #endif /* CONFIG_ALTIVEC */ |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 76 | #ifdef CONFIG_PPC64 |
| 77 | DEFINE(KSP_VSID, offsetof(struct thread_struct, ksp_vsid)); |
| 78 | #else /* CONFIG_PPC64 */ |
| 79 | DEFINE(PGDIR, offsetof(struct thread_struct, pgdir)); |
| 80 | DEFINE(LAST_SYSCALL, offsetof(struct thread_struct, last_syscall)); |
| 81 | #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) |
| 82 | DEFINE(THREAD_DBCR0, offsetof(struct thread_struct, dbcr0)); |
| 83 | DEFINE(PT_PTRACED, PT_PTRACED); |
| 84 | #endif |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 85 | #ifdef CONFIG_SPE |
| 86 | DEFINE(THREAD_EVR0, offsetof(struct thread_struct, evr[0])); |
| 87 | DEFINE(THREAD_ACC, offsetof(struct thread_struct, acc)); |
| 88 | DEFINE(THREAD_SPEFSCR, offsetof(struct thread_struct, spefscr)); |
| 89 | DEFINE(THREAD_USED_SPE, offsetof(struct thread_struct, used_spe)); |
| 90 | #endif /* CONFIG_SPE */ |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 91 | #endif /* CONFIG_PPC64 */ |
| 92 | |
| 93 | DEFINE(TI_FLAGS, offsetof(struct thread_info, flags)); |
Paul Mackerras | f39224a | 2006-04-18 21:49:11 +1000 | [diff] [blame] | 94 | DEFINE(TI_LOCAL_FLAGS, offsetof(struct thread_info, local_flags)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 95 | DEFINE(TI_PREEMPT, offsetof(struct thread_info, preempt_count)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 96 | DEFINE(TI_TASK, offsetof(struct thread_info, task)); |
David Woodhouse | 401d1f0 | 2005-11-15 18:52:18 +0000 | [diff] [blame] | 97 | #ifdef CONFIG_PPC32 |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 98 | DEFINE(TI_EXECDOMAIN, offsetof(struct thread_info, exec_domain)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 99 | DEFINE(TI_CPU, offsetof(struct thread_info, cpu)); |
Paul Mackerras | 033ef33 | 2005-10-26 17:05:24 +1000 | [diff] [blame] | 100 | #endif /* CONFIG_PPC32 */ |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 101 | |
| 102 | #ifdef CONFIG_PPC64 |
| 103 | DEFINE(DCACHEL1LINESIZE, offsetof(struct ppc64_caches, dline_size)); |
| 104 | DEFINE(DCACHEL1LOGLINESIZE, offsetof(struct ppc64_caches, log_dline_size)); |
| 105 | DEFINE(DCACHEL1LINESPERPAGE, offsetof(struct ppc64_caches, dlines_per_page)); |
| 106 | DEFINE(ICACHEL1LINESIZE, offsetof(struct ppc64_caches, iline_size)); |
| 107 | DEFINE(ICACHEL1LOGLINESIZE, offsetof(struct ppc64_caches, log_iline_size)); |
| 108 | DEFINE(ICACHEL1LINESPERPAGE, offsetof(struct ppc64_caches, ilines_per_page)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 109 | /* paca */ |
| 110 | DEFINE(PACA_SIZE, sizeof(struct paca_struct)); |
| 111 | DEFINE(PACAPACAINDEX, offsetof(struct paca_struct, paca_index)); |
| 112 | DEFINE(PACAPROCSTART, offsetof(struct paca_struct, cpu_start)); |
| 113 | DEFINE(PACAKSAVE, offsetof(struct paca_struct, kstack)); |
| 114 | DEFINE(PACACURRENT, offsetof(struct paca_struct, __current)); |
| 115 | DEFINE(PACASAVEDMSR, offsetof(struct paca_struct, saved_msr)); |
| 116 | DEFINE(PACASTABREAL, offsetof(struct paca_struct, stab_real)); |
| 117 | DEFINE(PACASTABVIRT, offsetof(struct paca_struct, stab_addr)); |
| 118 | DEFINE(PACASTABRR, offsetof(struct paca_struct, stab_rr)); |
| 119 | DEFINE(PACAR1, offsetof(struct paca_struct, saved_r1)); |
| 120 | DEFINE(PACATOC, offsetof(struct paca_struct, kernel_toc)); |
| 121 | DEFINE(PACAPROCENABLED, offsetof(struct paca_struct, proc_enabled)); |
| 122 | DEFINE(PACASLBCACHE, offsetof(struct paca_struct, slb_cache)); |
| 123 | DEFINE(PACASLBCACHEPTR, offsetof(struct paca_struct, slb_cache_ptr)); |
| 124 | DEFINE(PACACONTEXTID, offsetof(struct paca_struct, context.id)); |
Paul Mackerras | bf72aeb | 2006-06-15 10:45:18 +1000 | [diff] [blame] | 125 | DEFINE(PACACONTEXTSLLP, offsetof(struct paca_struct, context.sllp)); |
| 126 | DEFINE(PACAVMALLOCSLLP, offsetof(struct paca_struct, vmalloc_sllp)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 127 | #ifdef CONFIG_HUGETLB_PAGE |
| 128 | DEFINE(PACALOWHTLBAREAS, offsetof(struct paca_struct, context.low_htlb_areas)); |
| 129 | DEFINE(PACAHIGHHTLBAREAS, offsetof(struct paca_struct, context.high_htlb_areas)); |
| 130 | #endif /* CONFIG_HUGETLB_PAGE */ |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 131 | DEFINE(PACA_EXGEN, offsetof(struct paca_struct, exgen)); |
| 132 | DEFINE(PACA_EXMC, offsetof(struct paca_struct, exmc)); |
| 133 | DEFINE(PACA_EXSLB, offsetof(struct paca_struct, exslb)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 134 | DEFINE(PACAEMERGSP, offsetof(struct paca_struct, emergency_sp)); |
David Gibson | 3356bb9f7 | 2006-01-13 10:26:42 +1100 | [diff] [blame] | 135 | DEFINE(PACALPPACAPTR, offsetof(struct paca_struct, lppaca_ptr)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 136 | DEFINE(PACAHWCPUID, offsetof(struct paca_struct, hw_cpu_id)); |
Paul Mackerras | c6622f6 | 2006-02-24 10:06:59 +1100 | [diff] [blame] | 137 | DEFINE(PACA_STARTPURR, offsetof(struct paca_struct, startpurr)); |
| 138 | DEFINE(PACA_USER_TIME, offsetof(struct paca_struct, user_time)); |
| 139 | DEFINE(PACA_SYSTEM_TIME, offsetof(struct paca_struct, system_time)); |
Michael Neuling | 2f6093c | 2006-08-07 16:19:19 +1000 | [diff] [blame] | 140 | DEFINE(PACA_SLBSHADOWPTR, offsetof(struct paca_struct, slb_shadow_ptr)); |
Mike Kravetz | 57852a8 | 2006-09-06 16:23:12 -0700 | [diff] [blame] | 141 | DEFINE(PACA_DATA_OFFSET, offsetof(struct paca_struct, data_offset)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 142 | |
Michael Neuling | 11a27ad | 2006-08-09 17:00:30 +1000 | [diff] [blame] | 143 | DEFINE(SLBSHADOW_STACKVSID, |
| 144 | offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].vsid)); |
| 145 | DEFINE(SLBSHADOW_STACKESID, |
| 146 | offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].esid)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 147 | DEFINE(LPPACASRR0, offsetof(struct lppaca, saved_srr0)); |
| 148 | DEFINE(LPPACASRR1, offsetof(struct lppaca, saved_srr1)); |
| 149 | DEFINE(LPPACAANYINT, offsetof(struct lppaca, int_dword.any_int)); |
| 150 | DEFINE(LPPACADECRINT, offsetof(struct lppaca, int_dword.fields.decr_int)); |
Michael Neuling | 2f6093c | 2006-08-07 16:19:19 +1000 | [diff] [blame] | 151 | DEFINE(SLBSHADOW_SAVEAREA, offsetof(struct slb_shadow, save_area)); |
Paul Mackerras | 033ef33 | 2005-10-26 17:05:24 +1000 | [diff] [blame] | 152 | #endif /* CONFIG_PPC64 */ |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 153 | |
| 154 | /* RTAS */ |
| 155 | DEFINE(RTASBASE, offsetof(struct rtas_t, base)); |
| 156 | DEFINE(RTASENTRY, offsetof(struct rtas_t, entry)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 157 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 158 | /* Interrupt register frame */ |
| 159 | DEFINE(STACK_FRAME_OVERHEAD, STACK_FRAME_OVERHEAD); |
| 160 | #ifndef CONFIG_PPC64 |
| 161 | DEFINE(INT_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 162 | #else /* CONFIG_PPC64 */ |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 163 | DEFINE(SWITCH_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 164 | /* 288 = # of volatile regs, int & fp, for leaf routines */ |
| 165 | /* which do not stack a frame. See the PPC64 ABI. */ |
| 166 | DEFINE(INT_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 288); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 167 | /* Create extra stack space for SRR0 and SRR1 when calling prom/rtas. */ |
| 168 | DEFINE(PROM_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16); |
| 169 | DEFINE(RTAS_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16); |
Mike Kravetz | 57852a8 | 2006-09-06 16:23:12 -0700 | [diff] [blame] | 170 | |
| 171 | /* hcall statistics */ |
| 172 | DEFINE(HCALL_STAT_SIZE, sizeof(struct hcall_stats)); |
| 173 | DEFINE(HCALL_STAT_CALLS, offsetof(struct hcall_stats, num_calls)); |
| 174 | DEFINE(HCALL_STAT_TB, offsetof(struct hcall_stats, tb_total)); |
| 175 | DEFINE(HCALL_STAT_PURR, offsetof(struct hcall_stats, purr_total)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 176 | #endif /* CONFIG_PPC64 */ |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 177 | DEFINE(GPR0, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[0])); |
| 178 | DEFINE(GPR1, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[1])); |
| 179 | DEFINE(GPR2, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[2])); |
| 180 | DEFINE(GPR3, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[3])); |
| 181 | DEFINE(GPR4, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[4])); |
| 182 | DEFINE(GPR5, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[5])); |
| 183 | DEFINE(GPR6, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[6])); |
| 184 | DEFINE(GPR7, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[7])); |
| 185 | DEFINE(GPR8, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[8])); |
| 186 | DEFINE(GPR9, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[9])); |
| 187 | DEFINE(GPR10, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[10])); |
| 188 | DEFINE(GPR11, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[11])); |
| 189 | DEFINE(GPR12, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[12])); |
| 190 | DEFINE(GPR13, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[13])); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 191 | #ifndef CONFIG_PPC64 |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 192 | DEFINE(GPR14, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[14])); |
| 193 | DEFINE(GPR15, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[15])); |
| 194 | DEFINE(GPR16, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[16])); |
| 195 | DEFINE(GPR17, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[17])); |
| 196 | DEFINE(GPR18, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[18])); |
| 197 | DEFINE(GPR19, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[19])); |
| 198 | DEFINE(GPR20, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[20])); |
| 199 | DEFINE(GPR21, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[21])); |
| 200 | DEFINE(GPR22, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[22])); |
| 201 | DEFINE(GPR23, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[23])); |
| 202 | DEFINE(GPR24, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[24])); |
| 203 | DEFINE(GPR25, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[25])); |
| 204 | DEFINE(GPR26, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[26])); |
| 205 | DEFINE(GPR27, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[27])); |
| 206 | DEFINE(GPR28, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[28])); |
| 207 | DEFINE(GPR29, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[29])); |
| 208 | DEFINE(GPR30, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[30])); |
| 209 | DEFINE(GPR31, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[31])); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 210 | #endif /* CONFIG_PPC64 */ |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 211 | /* |
| 212 | * Note: these symbols include _ because they overlap with special |
| 213 | * register names |
| 214 | */ |
| 215 | DEFINE(_NIP, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, nip)); |
| 216 | DEFINE(_MSR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, msr)); |
| 217 | DEFINE(_CTR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, ctr)); |
| 218 | DEFINE(_LINK, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, link)); |
| 219 | DEFINE(_CCR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, ccr)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 220 | DEFINE(_XER, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, xer)); |
| 221 | DEFINE(_DAR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, dar)); |
| 222 | DEFINE(_DSISR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, dsisr)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 223 | DEFINE(ORIG_GPR3, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, orig_gpr3)); |
| 224 | DEFINE(RESULT, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, result)); |
Paul Mackerras | d73e0c9 | 2005-10-28 22:45:25 +1000 | [diff] [blame] | 225 | DEFINE(_TRAP, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, trap)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 226 | #ifndef CONFIG_PPC64 |
| 227 | DEFINE(_MQ, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, mq)); |
| 228 | /* |
| 229 | * The PowerPC 400-class & Book-E processors have neither the DAR |
| 230 | * nor the DSISR SPRs. Hence, we overload them to hold the similar |
| 231 | * DEAR and ESR SPRs for such processors. For critical interrupts |
| 232 | * we use them to hold SRR0 and SRR1. |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 233 | */ |
| 234 | DEFINE(_DEAR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, dar)); |
| 235 | DEFINE(_ESR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, dsisr)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 236 | #else /* CONFIG_PPC64 */ |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 237 | DEFINE(SOFTE, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, softe)); |
| 238 | |
| 239 | /* These _only_ to be used with {PROM,RTAS}_FRAME_SIZE!!! */ |
| 240 | DEFINE(_SRR0, STACK_FRAME_OVERHEAD+sizeof(struct pt_regs)); |
| 241 | DEFINE(_SRR1, STACK_FRAME_OVERHEAD+sizeof(struct pt_regs)+8); |
| 242 | #endif /* CONFIG_PPC64 */ |
| 243 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 244 | DEFINE(CLONE_VM, CLONE_VM); |
| 245 | DEFINE(CLONE_UNTRACED, CLONE_UNTRACED); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 246 | |
| 247 | #ifndef CONFIG_PPC64 |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 248 | DEFINE(MM_PGD, offsetof(struct mm_struct, pgd)); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 249 | #endif /* ! CONFIG_PPC64 */ |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 250 | |
| 251 | /* About the CPU features table */ |
| 252 | DEFINE(CPU_SPEC_ENTRY_SIZE, sizeof(struct cpu_spec)); |
| 253 | DEFINE(CPU_SPEC_PVR_MASK, offsetof(struct cpu_spec, pvr_mask)); |
| 254 | DEFINE(CPU_SPEC_PVR_VALUE, offsetof(struct cpu_spec, pvr_value)); |
| 255 | DEFINE(CPU_SPEC_FEATURES, offsetof(struct cpu_spec, cpu_features)); |
| 256 | DEFINE(CPU_SPEC_SETUP, offsetof(struct cpu_spec, cpu_setup)); |
Olof Johansson | f39b7a5 | 2006-08-11 00:07:08 -0500 | [diff] [blame] | 257 | DEFINE(CPU_SPEC_RESTORE, offsetof(struct cpu_spec, cpu_restore)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 258 | |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 259 | #ifndef CONFIG_PPC64 |
| 260 | DEFINE(pbe_address, offsetof(struct pbe, address)); |
| 261 | DEFINE(pbe_orig_address, offsetof(struct pbe, orig_address)); |
| 262 | DEFINE(pbe_next, offsetof(struct pbe, next)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 263 | |
Paul Mackerras | fd582ec | 2005-10-11 22:08:12 +1000 | [diff] [blame] | 264 | DEFINE(TASK_SIZE, TASK_SIZE); |
Stephen Rothwell | d1dead5 | 2005-09-29 00:35:31 +1000 | [diff] [blame] | 265 | DEFINE(NUM_USER_SEGMENTS, TASK_SIZE>>28); |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 266 | #endif /* ! CONFIG_PPC64 */ |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 267 | |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 268 | /* datapage offsets for use by vdso */ |
| 269 | DEFINE(CFG_TB_ORIG_STAMP, offsetof(struct vdso_data, tb_orig_stamp)); |
| 270 | DEFINE(CFG_TB_TICKS_PER_SEC, offsetof(struct vdso_data, tb_ticks_per_sec)); |
| 271 | DEFINE(CFG_TB_TO_XS, offsetof(struct vdso_data, tb_to_xs)); |
| 272 | DEFINE(CFG_STAMP_XSEC, offsetof(struct vdso_data, stamp_xsec)); |
| 273 | DEFINE(CFG_TB_UPDATE_COUNT, offsetof(struct vdso_data, tb_update_count)); |
| 274 | DEFINE(CFG_TZ_MINUTEWEST, offsetof(struct vdso_data, tz_minuteswest)); |
| 275 | DEFINE(CFG_TZ_DSTTIME, offsetof(struct vdso_data, tz_dsttime)); |
| 276 | DEFINE(CFG_SYSCALL_MAP32, offsetof(struct vdso_data, syscall_map_32)); |
| 277 | DEFINE(WTOM_CLOCK_SEC, offsetof(struct vdso_data, wtom_clock_sec)); |
| 278 | DEFINE(WTOM_CLOCK_NSEC, offsetof(struct vdso_data, wtom_clock_nsec)); |
| 279 | #ifdef CONFIG_PPC64 |
| 280 | DEFINE(CFG_SYSCALL_MAP64, offsetof(struct vdso_data, syscall_map_64)); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 281 | DEFINE(TVAL64_TV_SEC, offsetof(struct timeval, tv_sec)); |
| 282 | DEFINE(TVAL64_TV_USEC, offsetof(struct timeval, tv_usec)); |
| 283 | DEFINE(TVAL32_TV_SEC, offsetof(struct compat_timeval, tv_sec)); |
| 284 | DEFINE(TVAL32_TV_USEC, offsetof(struct compat_timeval, tv_usec)); |
Benjamin Herrenschmidt | 0c37ec2 | 2005-11-14 14:55:58 +1100 | [diff] [blame] | 285 | DEFINE(TSPC64_TV_SEC, offsetof(struct timespec, tv_sec)); |
| 286 | DEFINE(TSPC64_TV_NSEC, offsetof(struct timespec, tv_nsec)); |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 287 | DEFINE(TSPC32_TV_SEC, offsetof(struct compat_timespec, tv_sec)); |
| 288 | DEFINE(TSPC32_TV_NSEC, offsetof(struct compat_timespec, tv_nsec)); |
| 289 | #else |
| 290 | DEFINE(TVAL32_TV_SEC, offsetof(struct timeval, tv_sec)); |
| 291 | DEFINE(TVAL32_TV_USEC, offsetof(struct timeval, tv_usec)); |
Benjamin Herrenschmidt | 0c37ec2 | 2005-11-14 14:55:58 +1100 | [diff] [blame] | 292 | DEFINE(TSPC32_TV_SEC, offsetof(struct timespec, tv_sec)); |
| 293 | DEFINE(TSPC32_TV_NSEC, offsetof(struct timespec, tv_nsec)); |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 294 | #endif |
| 295 | /* timeval/timezone offsets for use by vdso */ |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 296 | DEFINE(TZONE_TZ_MINWEST, offsetof(struct timezone, tz_minuteswest)); |
| 297 | DEFINE(TZONE_TZ_DSTTIME, offsetof(struct timezone, tz_dsttime)); |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 298 | |
| 299 | /* Other bits used by the vdso */ |
| 300 | DEFINE(CLOCK_REALTIME, CLOCK_REALTIME); |
| 301 | DEFINE(CLOCK_MONOTONIC, CLOCK_MONOTONIC); |
| 302 | DEFINE(NSEC_PER_SEC, NSEC_PER_SEC); |
| 303 | DEFINE(CLOCK_REALTIME_RES, TICK_NSEC); |
| 304 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 305 | return 0; |
| 306 | } |