1 /* 2 * arch/xtensa/kernel/process.c 3 * 4 * Xtensa Processor version. 5 * 6 * This file is subject to the terms and conditions of the GNU General Public 7 * License. See the file "COPYING" in the main directory of this archive 8 * for more details. 9 * 10 * Copyright (C) 2001 - 2005 Tensilica Inc. 11 * 12 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com> 13 * Chris Zankel <chris@zankel.net> 14 * Marc Gauthier <marc@tensilica.com, marc@alumni.uwaterloo.ca> 15 * Kevin Chea 16 */ 17 18 #include <linux/errno.h> 19 #include <linux/sched.h> 20 #include <linux/sched/debug.h> 21 #include <linux/sched/task.h> 22 #include <linux/sched/task_stack.h> 23 #include <linux/kernel.h> 24 #include <linux/mm.h> 25 #include <linux/smp.h> 26 #include <linux/stddef.h> 27 #include <linux/unistd.h> 28 #include <linux/ptrace.h> 29 #include <linux/elf.h> 30 #include <linux/hw_breakpoint.h> 31 #include <linux/init.h> 32 #include <linux/prctl.h> 33 #include <linux/init_task.h> 34 #include <linux/module.h> 35 #include <linux/mqueue.h> 36 #include <linux/fs.h> 37 #include <linux/slab.h> 38 #include <linux/rcupdate.h> 39 40 #include <asm/pgtable.h> 41 #include <linux/uaccess.h> 42 #include <asm/io.h> 43 #include <asm/processor.h> 44 #include <asm/platform.h> 45 #include <asm/mmu.h> 46 #include <asm/irq.h> 47 #include <linux/atomic.h> 48 #include <asm/asm-offsets.h> 49 #include <asm/regs.h> 50 #include <asm/hw_breakpoint.h> 51 52 extern void ret_from_fork(void); 53 extern void ret_from_kernel_thread(void); 54 55 struct task_struct *current_set[NR_CPUS] = {&init_task, }; 56 57 void (*pm_power_off)(void) = NULL; 58 EXPORT_SYMBOL(pm_power_off); 59 60 61 #ifdef CONFIG_STACKPROTECTOR 62 #include <linux/stackprotector.h> 63 unsigned long __stack_chk_guard __read_mostly; 64 EXPORT_SYMBOL(__stack_chk_guard); 65 #endif 66 67 #if XTENSA_HAVE_COPROCESSORS 68 69 void coprocessor_release_all(struct thread_info *ti) 70 { 71 unsigned long cpenable; 72 int i; 73 74 /* Make sure we don't switch tasks during this operation. */ 75 76 preempt_disable(); 77 78 /* Walk through all cp owners and release it for the requested one. */ 79 80 cpenable = ti->cpenable; 81 82 for (i = 0; i < XCHAL_CP_MAX; i++) { 83 if (coprocessor_owner[i] == ti) { 84 coprocessor_owner[i] = 0; 85 cpenable &= ~(1 << i); 86 } 87 } 88 89 ti->cpenable = cpenable; 90 coprocessor_clear_cpenable(); 91 92 preempt_enable(); 93 } 94 95 void coprocessor_flush_all(struct thread_info *ti) 96 { 97 unsigned long cpenable; 98 int i; 99 100 preempt_disable(); 101 102 cpenable = ti->cpenable; 103 104 for (i = 0; i < XCHAL_CP_MAX; i++) { 105 if ((cpenable & 1) != 0 && coprocessor_owner[i] == ti) 106 coprocessor_flush(ti, i); 107 cpenable >>= 1; 108 } 109 110 preempt_enable(); 111 } 112 113 #endif 114 115 116 /* 117 * Powermanagement idle function, if any is provided by the platform. 118 */ 119 void arch_cpu_idle(void) 120 { 121 platform_idle(); 122 } 123 124 /* 125 * This is called when the thread calls exit(). 126 */ 127 void exit_thread(struct task_struct *tsk) 128 { 129 #if XTENSA_HAVE_COPROCESSORS 130 coprocessor_release_all(task_thread_info(tsk)); 131 #endif 132 } 133 134 /* 135 * Flush thread state. This is called when a thread does an execve() 136 * Note that we flush coprocessor registers for the case execve fails. 137 */ 138 void flush_thread(void) 139 { 140 #if XTENSA_HAVE_COPROCESSORS 141 struct thread_info *ti = current_thread_info(); 142 coprocessor_flush_all(ti); 143 coprocessor_release_all(ti); 144 #endif 145 flush_ptrace_hw_breakpoint(current); 146 } 147 148 /* 149 * this gets called so that we can store coprocessor state into memory and 150 * copy the current task into the new thread. 151 */ 152 int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src) 153 { 154 #if XTENSA_HAVE_COPROCESSORS 155 coprocessor_flush_all(task_thread_info(src)); 156 #endif 157 *dst = *src; 158 return 0; 159 } 160 161 /* 162 * Copy thread. 163 * 164 * There are two modes in which this function is called: 165 * 1) Userspace thread creation, 166 * regs != NULL, usp_thread_fn is userspace stack pointer. 167 * It is expected to copy parent regs (in case CLONE_VM is not set 168 * in the clone_flags) and set up passed usp in the childregs. 169 * 2) Kernel thread creation, 170 * regs == NULL, usp_thread_fn is the function to run in the new thread 171 * and thread_fn_arg is its parameter. 172 * childregs are not used for the kernel threads. 173 * 174 * The stack layout for the new thread looks like this: 175 * 176 * +------------------------+ 177 * | childregs | 178 * +------------------------+ <- thread.sp = sp in dummy-frame 179 * | dummy-frame | (saved in dummy-frame spill-area) 180 * +------------------------+ 181 * 182 * We create a dummy frame to return to either ret_from_fork or 183 * ret_from_kernel_thread: 184 * a0 points to ret_from_fork/ret_from_kernel_thread (simulating a call4) 185 * sp points to itself (thread.sp) 186 * a2, a3 are unused for userspace threads, 187 * a2 points to thread_fn, a3 holds thread_fn arg for kernel threads. 188 * 189 * Note: This is a pristine frame, so we don't need any spill region on top of 190 * childregs. 191 * 192 * The fun part: if we're keeping the same VM (i.e. cloning a thread, 193 * not an entire process), we're normally given a new usp, and we CANNOT share 194 * any live address register windows. If we just copy those live frames over, 195 * the two threads (parent and child) will overflow the same frames onto the 196 * parent stack at different times, likely corrupting the parent stack (esp. 197 * if the parent returns from functions that called clone() and calls new 198 * ones, before the child overflows its now old copies of its parent windows). 199 * One solution is to spill windows to the parent stack, but that's fairly 200 * involved. Much simpler to just not copy those live frames across. 201 */ 202 203 int copy_thread(unsigned long clone_flags, unsigned long usp_thread_fn, 204 unsigned long thread_fn_arg, struct task_struct *p) 205 { 206 struct pt_regs *childregs = task_pt_regs(p); 207 208 #if (XTENSA_HAVE_COPROCESSORS || XTENSA_HAVE_IO_PORTS) 209 struct thread_info *ti; 210 #endif 211 212 /* Create a call4 dummy-frame: a0 = 0, a1 = childregs. */ 213 SPILL_SLOT(childregs, 1) = (unsigned long)childregs; 214 SPILL_SLOT(childregs, 0) = 0; 215 216 p->thread.sp = (unsigned long)childregs; 217 218 if (!(p->flags & PF_KTHREAD)) { 219 struct pt_regs *regs = current_pt_regs(); 220 unsigned long usp = usp_thread_fn ? 221 usp_thread_fn : regs->areg[1]; 222 223 p->thread.ra = MAKE_RA_FOR_CALL( 224 (unsigned long)ret_from_fork, 0x1); 225 226 /* This does not copy all the regs. 227 * In a bout of brilliance or madness, 228 * ARs beyond a0-a15 exist past the end of the struct. 229 */ 230 *childregs = *regs; 231 childregs->areg[1] = usp; 232 childregs->areg[2] = 0; 233 234 /* When sharing memory with the parent thread, the child 235 usually starts on a pristine stack, so we have to reset 236 windowbase, windowstart and wmask. 237 (Note that such a new thread is required to always create 238 an initial call4 frame) 239 The exception is vfork, where the new thread continues to 240 run on the parent's stack until it calls execve. This could 241 be a call8 or call12, which requires a legal stack frame 242 of the previous caller for the overflow handlers to work. 243 (Note that it's always legal to overflow live registers). 244 In this case, ensure to spill at least the stack pointer 245 of that frame. */ 246 247 if (clone_flags & CLONE_VM) { 248 /* check that caller window is live and same stack */ 249 int len = childregs->wmask & ~0xf; 250 if (regs->areg[1] == usp && len != 0) { 251 int callinc = (regs->areg[0] >> 30) & 3; 252 int caller_ars = XCHAL_NUM_AREGS - callinc * 4; 253 put_user(regs->areg[caller_ars+1], 254 (unsigned __user*)(usp - 12)); 255 } 256 childregs->wmask = 1; 257 childregs->windowstart = 1; 258 childregs->windowbase = 0; 259 } else { 260 int len = childregs->wmask & ~0xf; 261 memcpy(&childregs->areg[XCHAL_NUM_AREGS - len/4], 262 ®s->areg[XCHAL_NUM_AREGS - len/4], len); 263 } 264 265 /* The thread pointer is passed in the '4th argument' (= a5) */ 266 if (clone_flags & CLONE_SETTLS) 267 childregs->threadptr = childregs->areg[5]; 268 } else { 269 p->thread.ra = MAKE_RA_FOR_CALL( 270 (unsigned long)ret_from_kernel_thread, 1); 271 272 /* pass parameters to ret_from_kernel_thread: 273 * a2 = thread_fn, a3 = thread_fn arg 274 */ 275 SPILL_SLOT(childregs, 3) = thread_fn_arg; 276 SPILL_SLOT(childregs, 2) = usp_thread_fn; 277 278 /* Childregs are only used when we're going to userspace 279 * in which case start_thread will set them up. 280 */ 281 } 282 283 #if (XTENSA_HAVE_COPROCESSORS || XTENSA_HAVE_IO_PORTS) 284 ti = task_thread_info(p); 285 ti->cpenable = 0; 286 #endif 287 288 clear_ptrace_hw_breakpoint(p); 289 290 return 0; 291 } 292 293 294 /* 295 * These bracket the sleeping functions.. 296 */ 297 298 unsigned long get_wchan(struct task_struct *p) 299 { 300 unsigned long sp, pc; 301 unsigned long stack_page = (unsigned long) task_stack_page(p); 302 int count = 0; 303 304 if (!p || p == current || p->state == TASK_RUNNING) 305 return 0; 306 307 sp = p->thread.sp; 308 pc = MAKE_PC_FROM_RA(p->thread.ra, p->thread.sp); 309 310 do { 311 if (sp < stack_page + sizeof(struct task_struct) || 312 sp >= (stack_page + THREAD_SIZE) || 313 pc == 0) 314 return 0; 315 if (!in_sched_functions(pc)) 316 return pc; 317 318 /* Stack layout: sp-4: ra, sp-3: sp' */ 319 320 pc = MAKE_PC_FROM_RA(*(unsigned long*)sp - 4, sp); 321 sp = *(unsigned long *)sp - 3; 322 } while (count++ < 16); 323 return 0; 324 } 325 326 /* 327 * xtensa_gregset_t and 'struct pt_regs' are vastly different formats 328 * of processor registers. Besides different ordering, 329 * xtensa_gregset_t contains non-live register information that 330 * 'struct pt_regs' does not. Exception handling (primarily) uses 331 * 'struct pt_regs'. Core files and ptrace use xtensa_gregset_t. 332 * 333 */ 334 335 void xtensa_elf_core_copy_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs) 336 { 337 unsigned long wb, ws, wm; 338 int live, last; 339 340 wb = regs->windowbase; 341 ws = regs->windowstart; 342 wm = regs->wmask; 343 ws = ((ws >> wb) | (ws << (WSBITS - wb))) & ((1 << WSBITS) - 1); 344 345 /* Don't leak any random bits. */ 346 347 memset(elfregs, 0, sizeof(*elfregs)); 348 349 /* Note: PS.EXCM is not set while user task is running; its 350 * being set in regs->ps is for exception handling convenience. 351 */ 352 353 elfregs->pc = regs->pc; 354 elfregs->ps = (regs->ps & ~(1 << PS_EXCM_BIT)); 355 elfregs->lbeg = regs->lbeg; 356 elfregs->lend = regs->lend; 357 elfregs->lcount = regs->lcount; 358 elfregs->sar = regs->sar; 359 elfregs->windowstart = ws; 360 361 live = (wm & 2) ? 4 : (wm & 4) ? 8 : (wm & 8) ? 12 : 16; 362 last = XCHAL_NUM_AREGS - (wm >> 4) * 4; 363 memcpy(elfregs->a, regs->areg, live * 4); 364 memcpy(elfregs->a + last, regs->areg + last, (wm >> 4) * 16); 365 } 366 367 int dump_fpu(void) 368 { 369 return 0; 370 } 371