linux/arch/arm/kernel/process.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  linux/arch/arm/kernel/process.c
   4 *
   5 *  Copyright (C) 1996-2000 Russell King - Converted to ARM.
   6 *  Original Copyright (C) 1995  Linus Torvalds
   7 */
   8#include <stdarg.h>
   9
  10#include <linux/export.h>
  11#include <linux/sched.h>
  12#include <linux/sched/debug.h>
  13#include <linux/sched/task.h>
  14#include <linux/sched/task_stack.h>
  15#include <linux/kernel.h>
  16#include <linux/mm.h>
  17#include <linux/stddef.h>
  18#include <linux/unistd.h>
  19#include <linux/user.h>
  20#include <linux/interrupt.h>
  21#include <linux/init.h>
  22#include <linux/elfcore.h>
  23#include <linux/pm.h>
  24#include <linux/tick.h>
  25#include <linux/utsname.h>
  26#include <linux/uaccess.h>
  27#include <linux/random.h>
  28#include <linux/hw_breakpoint.h>
  29#include <linux/leds.h>
  30
  31#include <asm/processor.h>
  32#include <asm/thread_notify.h>
  33#include <asm/stacktrace.h>
  34#include <asm/system_misc.h>
  35#include <asm/mach/time.h>
  36#include <asm/tls.h>
  37#include <asm/vdso.h>
  38
  39#include "signal.h"
  40
  41#if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)
  42#include <linux/stackprotector.h>
  43unsigned long __stack_chk_guard __read_mostly;
  44EXPORT_SYMBOL(__stack_chk_guard);
  45#endif
  46
  47static const char *processor_modes[] __maybe_unused = {
  48  "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" ,
  49  "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26",
  50  "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "MON_32" , "ABT_32" ,
  51  "UK8_32" , "UK9_32" , "HYP_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
  52};
  53
  54static const char *isa_modes[] __maybe_unused = {
  55  "ARM" , "Thumb" , "Jazelle", "ThumbEE"
  56};
  57
  58/*
  59 * This is our default idle handler.
  60 */
  61
  62void (*arm_pm_idle)(void);
  63
  64/*
  65 * Called from the core idle loop.
  66 */
  67
  68void arch_cpu_idle(void)
  69{
  70        if (arm_pm_idle)
  71                arm_pm_idle();
  72        else
  73                cpu_do_idle();
  74        raw_local_irq_enable();
  75}
  76
  77void arch_cpu_idle_prepare(void)
  78{
  79        local_fiq_enable();
  80}
  81
  82void arch_cpu_idle_enter(void)
  83{
  84        ledtrig_cpu(CPU_LED_IDLE_START);
  85#ifdef CONFIG_PL310_ERRATA_769419
  86        wmb();
  87#endif
  88}
  89
  90void arch_cpu_idle_exit(void)
  91{
  92        ledtrig_cpu(CPU_LED_IDLE_END);
  93}
  94
  95void __show_regs_alloc_free(struct pt_regs *regs)
  96{
  97        int i;
  98
  99        /* check for r0 - r12 only */
 100        for (i = 0; i < 13; i++) {
 101                pr_alert("Register r%d information:", i);
 102                mem_dump_obj((void *)regs->uregs[i]);
 103        }
 104}
 105
 106void __show_regs(struct pt_regs *regs)
 107{
 108        unsigned long flags;
 109        char buf[64];
 110#ifndef CONFIG_CPU_V7M
 111        unsigned int domain, fs;
 112#ifdef CONFIG_CPU_SW_DOMAIN_PAN
 113        /*
 114         * Get the domain register for the parent context. In user
 115         * mode, we don't save the DACR, so lets use what it should
 116         * be. For other modes, we place it after the pt_regs struct.
 117         */
 118        if (user_mode(regs)) {
 119                domain = DACR_UACCESS_ENABLE;
 120                fs = get_fs();
 121        } else {
 122                domain = to_svc_pt_regs(regs)->dacr;
 123                fs = to_svc_pt_regs(regs)->addr_limit;
 124        }
 125#else
 126        domain = get_domain();
 127        fs = get_fs();
 128#endif
 129#endif
 130
 131        show_regs_print_info(KERN_DEFAULT);
 132
 133        printk("PC is at %pS\n", (void *)instruction_pointer(regs));
 134        printk("LR is at %pS\n", (void *)regs->ARM_lr);
 135        printk("pc : [<%08lx>]    lr : [<%08lx>]    psr: %08lx\n",
 136               regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr);
 137        printk("sp : %08lx  ip : %08lx  fp : %08lx\n",
 138               regs->ARM_sp, regs->ARM_ip, regs->ARM_fp);
 139        printk("r10: %08lx  r9 : %08lx  r8 : %08lx\n",
 140                regs->ARM_r10, regs->ARM_r9,
 141                regs->ARM_r8);
 142        printk("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
 143                regs->ARM_r7, regs->ARM_r6,
 144                regs->ARM_r5, regs->ARM_r4);
 145        printk("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
 146                regs->ARM_r3, regs->ARM_r2,
 147                regs->ARM_r1, regs->ARM_r0);
 148
 149        flags = regs->ARM_cpsr;
 150        buf[0] = flags & PSR_N_BIT ? 'N' : 'n';
 151        buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z';
 152        buf[2] = flags & PSR_C_BIT ? 'C' : 'c';
 153        buf[3] = flags & PSR_V_BIT ? 'V' : 'v';
 154        buf[4] = '\0';
 155
 156#ifndef CONFIG_CPU_V7M
 157        {
 158                const char *segment;
 159
 160                if ((domain & domain_mask(DOMAIN_USER)) ==
 161                    domain_val(DOMAIN_USER, DOMAIN_NOACCESS))
 162                        segment = "none";
 163                else if (fs == KERNEL_DS)
 164                        segment = "kernel";
 165                else
 166                        segment = "user";
 167
 168                printk("Flags: %s  IRQs o%s  FIQs o%s  Mode %s  ISA %s  Segment %s\n",
 169                        buf, interrupts_enabled(regs) ? "n" : "ff",
 170                        fast_interrupts_enabled(regs) ? "n" : "ff",
 171                        processor_modes[processor_mode(regs)],
 172                        isa_modes[isa_mode(regs)], segment);
 173        }
 174#else
 175        printk("xPSR: %08lx\n", regs->ARM_cpsr);
 176#endif
 177
 178#ifdef CONFIG_CPU_CP15
 179        {
 180                unsigned int ctrl;
 181
 182                buf[0] = '\0';
 183#ifdef CONFIG_CPU_CP15_MMU
 184                {
 185                        unsigned int transbase;
 186                        asm("mrc p15, 0, %0, c2, c0\n\t"
 187                            : "=r" (transbase));
 188                        snprintf(buf, sizeof(buf), "  Table: %08x  DAC: %08x",
 189                                transbase, domain);
 190                }
 191#endif
 192                asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl));
 193
 194                printk("Control: %08x%s\n", ctrl, buf);
 195        }
 196#endif
 197}
 198
 199void show_regs(struct pt_regs * regs)
 200{
 201        __show_regs(regs);
 202        dump_stack();
 203}
 204
 205ATOMIC_NOTIFIER_HEAD(thread_notify_head);
 206
 207EXPORT_SYMBOL_GPL(thread_notify_head);
 208
 209/*
 210 * Free current thread data structures etc..
 211 */
 212void exit_thread(struct task_struct *tsk)
 213{
 214        thread_notify(THREAD_NOTIFY_EXIT, task_thread_info(tsk));
 215}
 216
 217void flush_thread(void)
 218{
 219        struct thread_info *thread = current_thread_info();
 220        struct task_struct *tsk = current;
 221
 222        flush_ptrace_hw_breakpoint(tsk);
 223
 224        memset(thread->used_cp, 0, sizeof(thread->used_cp));
 225        memset(&tsk->thread.debug, 0, sizeof(struct debug_info));
 226        memset(&thread->fpstate, 0, sizeof(union fp_state));
 227
 228        flush_tls();
 229
 230        thread_notify(THREAD_NOTIFY_FLUSH, thread);
 231}
 232
 233void release_thread(struct task_struct *dead_task)
 234{
 235}
 236
 237asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
 238
 239int copy_thread(unsigned long clone_flags, unsigned long stack_start,
 240                unsigned long stk_sz, struct task_struct *p, unsigned long tls)
 241{
 242        struct thread_info *thread = task_thread_info(p);
 243        struct pt_regs *childregs = task_pt_regs(p);
 244
 245        memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
 246
 247#ifdef CONFIG_CPU_USE_DOMAINS
 248        /*
 249         * Copy the initial value of the domain access control register
 250         * from the current thread: thread->addr_limit will have been
 251         * copied from the current thread via setup_thread_stack() in
 252         * kernel/fork.c
 253         */
 254        thread->cpu_domain = get_domain();
 255#endif
 256
 257        if (likely(!(p->flags & (PF_KTHREAD | PF_IO_WORKER)))) {
 258                *childregs = *current_pt_regs();
 259                childregs->ARM_r0 = 0;
 260                if (stack_start)
 261                        childregs->ARM_sp = stack_start;
 262        } else {
 263                memset(childregs, 0, sizeof(struct pt_regs));
 264                thread->cpu_context.r4 = stk_sz;
 265                thread->cpu_context.r5 = stack_start;
 266                childregs->ARM_cpsr = SVC_MODE;
 267        }
 268        thread->cpu_context.pc = (unsigned long)ret_from_fork;
 269        thread->cpu_context.sp = (unsigned long)childregs;
 270
 271        clear_ptrace_hw_breakpoint(p);
 272
 273        if (clone_flags & CLONE_SETTLS)
 274                thread->tp_value[0] = tls;
 275        thread->tp_value[1] = get_tpuser();
 276
 277        thread_notify(THREAD_NOTIFY_COPY, thread);
 278
 279#ifdef CONFIG_STACKPROTECTOR_PER_TASK
 280        thread->stack_canary = p->stack_canary;
 281#endif
 282
 283        return 0;
 284}
 285
 286unsigned long get_wchan(struct task_struct *p)
 287{
 288        struct stackframe frame;
 289        unsigned long stack_page;
 290        int count = 0;
 291        if (!p || p == current || task_is_running(p))
 292                return 0;
 293
 294        frame.fp = thread_saved_fp(p);
 295        frame.sp = thread_saved_sp(p);
 296        frame.lr = 0;                   /* recovered from the stack */
 297        frame.pc = thread_saved_pc(p);
 298        stack_page = (unsigned long)task_stack_page(p);
 299        do {
 300                if (frame.sp < stack_page ||
 301                    frame.sp >= stack_page + THREAD_SIZE ||
 302                    unwind_frame(&frame) < 0)
 303                        return 0;
 304                if (!in_sched_functions(frame.pc))
 305                        return frame.pc;
 306        } while (count ++ < 16);
 307        return 0;
 308}
 309
 310#ifdef CONFIG_MMU
 311#ifdef CONFIG_KUSER_HELPERS
 312/*
 313 * The vectors page is always readable from user space for the
 314 * atomic helpers. Insert it into the gate_vma so that it is visible
 315 * through ptrace and /proc/<pid>/mem.
 316 */
 317static struct vm_area_struct gate_vma;
 318
 319static int __init gate_vma_init(void)
 320{
 321        vma_init(&gate_vma, NULL);
 322        gate_vma.vm_page_prot = PAGE_READONLY_EXEC;
 323        gate_vma.vm_start = 0xffff0000;
 324        gate_vma.vm_end = 0xffff0000 + PAGE_SIZE;
 325        gate_vma.vm_flags = VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYEXEC;
 326        return 0;
 327}
 328arch_initcall(gate_vma_init);
 329
 330struct vm_area_struct *get_gate_vma(struct mm_struct *mm)
 331{
 332        return &gate_vma;
 333}
 334
 335int in_gate_area(struct mm_struct *mm, unsigned long addr)
 336{
 337        return (addr >= gate_vma.vm_start) && (addr < gate_vma.vm_end);
 338}
 339
 340int in_gate_area_no_mm(unsigned long addr)
 341{
 342        return in_gate_area(NULL, addr);
 343}
 344#define is_gate_vma(vma)        ((vma) == &gate_vma)
 345#else
 346#define is_gate_vma(vma)        0
 347#endif
 348
 349const char *arch_vma_name(struct vm_area_struct *vma)
 350{
 351        return is_gate_vma(vma) ? "[vectors]" : NULL;
 352}
 353
 354/* If possible, provide a placement hint at a random offset from the
 355 * stack for the sigpage and vdso pages.
 356 */
 357static unsigned long sigpage_addr(const struct mm_struct *mm,
 358                                  unsigned int npages)
 359{
 360        unsigned long offset;
 361        unsigned long first;
 362        unsigned long last;
 363        unsigned long addr;
 364        unsigned int slots;
 365
 366        first = PAGE_ALIGN(mm->start_stack);
 367
 368        last = TASK_SIZE - (npages << PAGE_SHIFT);
 369
 370        /* No room after stack? */
 371        if (first > last)
 372                return 0;
 373
 374        /* Just enough room? */
 375        if (first == last)
 376                return first;
 377
 378        slots = ((last - first) >> PAGE_SHIFT) + 1;
 379
 380        offset = get_random_int() % slots;
 381
 382        addr = first + (offset << PAGE_SHIFT);
 383
 384        return addr;
 385}
 386
 387static struct page *signal_page;
 388extern struct page *get_signal_page(void);
 389
 390static int sigpage_mremap(const struct vm_special_mapping *sm,
 391                struct vm_area_struct *new_vma)
 392{
 393        current->mm->context.sigpage = new_vma->vm_start;
 394        return 0;
 395}
 396
 397static const struct vm_special_mapping sigpage_mapping = {
 398        .name = "[sigpage]",
 399        .pages = &signal_page,
 400        .mremap = sigpage_mremap,
 401};
 402
 403int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
 404{
 405        struct mm_struct *mm = current->mm;
 406        struct vm_area_struct *vma;
 407        unsigned long npages;
 408        unsigned long addr;
 409        unsigned long hint;
 410        int ret = 0;
 411
 412        if (!signal_page)
 413                signal_page = get_signal_page();
 414        if (!signal_page)
 415                return -ENOMEM;
 416
 417        npages = 1; /* for sigpage */
 418        npages += vdso_total_pages;
 419
 420        if (mmap_write_lock_killable(mm))
 421                return -EINTR;
 422        hint = sigpage_addr(mm, npages);
 423        addr = get_unmapped_area(NULL, hint, npages << PAGE_SHIFT, 0, 0);
 424        if (IS_ERR_VALUE(addr)) {
 425                ret = addr;
 426                goto up_fail;
 427        }
 428
 429        vma = _install_special_mapping(mm, addr, PAGE_SIZE,
 430                VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC,
 431                &sigpage_mapping);
 432
 433        if (IS_ERR(vma)) {
 434                ret = PTR_ERR(vma);
 435                goto up_fail;
 436        }
 437
 438        mm->context.sigpage = addr;
 439
 440        /* Unlike the sigpage, failure to install the vdso is unlikely
 441         * to be fatal to the process, so no error check needed
 442         * here.
 443         */
 444        arm_install_vdso(mm, addr + PAGE_SIZE);
 445
 446 up_fail:
 447        mmap_write_unlock(mm);
 448        return ret;
 449}
 450#endif
 451