arch/riscv/include/asm/processor.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) 2012 Regents of the University of California
   4  */
   5
   6 #ifndef _ASM_RISCV_PROCESSOR_H
   7 #define _ASM_RISCV_PROCESSOR_H
   8
   9 #include <linux/const.h>
  10 #include <linux/cache.h>
  11 #include <linux/prctl.h>
  12
  13 #include <vdso/processor.h>
  14
  15 #include <asm/ptrace.h>
  16
  17 #define arch_get_mmap_end(addr, len, flags)                     \
  18 ({                                                              \
  19         unsigned long mmap_end;                                 \
  20         typeof(addr) _addr = (addr);                            \
  21         if ((_addr) == 0 ||                                     \
  22             (IS_ENABLED(CONFIG_COMPAT) && is_compat_task()) ||  \
  23             ((_addr + len) > BIT(VA_BITS - 1)))                 \
  24                 mmap_end = STACK_TOP_MAX;                       \
  25         else                                                    \
  26                 mmap_end = (_addr + len);                       \
  27         mmap_end;                                               \
  28 })
  29
  30 #define arch_get_mmap_base(addr, base)                          \
  31 ({                                                              \
  32         unsigned long mmap_base;                                \
  33         typeof(addr) _addr = (addr);                            \
  34         typeof(base) _base = (base);                            \
  35         unsigned long rnd_gap = DEFAULT_MAP_WINDOW - (_base);   \
  36         if ((_addr) == 0 ||                                     \
  37             (IS_ENABLED(CONFIG_COMPAT) && is_compat_task()) ||  \
  38             ((_addr + len) > BIT(VA_BITS - 1)))                 \
  39                 mmap_base = (_base);                            \
  40         else                                                    \
  41                 mmap_base = (_addr + len) - rnd_gap;            \
  42         mmap_base;                                              \
  43 })
  44
  45 #ifdef CONFIG_64BIT
  46 #define DEFAULT_MAP_WINDOW      (UL(1) << (MMAP_VA_BITS - 1))
  47 #define STACK_TOP_MAX           TASK_SIZE_64
  48 #else
  49 #define DEFAULT_MAP_WINDOW      TASK_SIZE
  50 #define STACK_TOP_MAX           TASK_SIZE
  51 #endif
  52 #define STACK_ALIGN             16
  53
  54 #define STACK_TOP               DEFAULT_MAP_WINDOW
  55
  56 /*
  57  * This decides where the kernel will search for a free chunk of vm
  58  * space during mmap's.
  59  */
  60 #ifdef CONFIG_64BIT
  61 #define TASK_UNMAPPED_BASE      PAGE_ALIGN((UL(1) << MMAP_MIN_VA_BITS) / 3)
  62 #else
  63 #define TASK_UNMAPPED_BASE      PAGE_ALIGN(TASK_SIZE / 3)
  64 #endif
  65
  66 #ifndef __ASSEMBLY__
  67
  68 struct task_struct;
  69 struct pt_regs;
  70
  71 /* CPU-specific state of a task */
  72 struct thread_struct {
  73         /* Callee-saved registers */
  74         unsigned long ra;
  75         unsigned long sp;       /* Kernel mode stack */
  76         unsigned long s[12];    /* s[0]: frame pointer */
  77         struct __riscv_d_ext_state fstate;
  78         unsigned long bad_cause;
  79         unsigned long vstate_ctrl;
  80         struct __riscv_v_ext_state vstate;
  81         unsigned long align_ctl;
  82 };
  83
  84 /* Whitelist the fstate from the task_struct for hardened usercopy */
  85 static inline void arch_thread_struct_whitelist(unsigned long *offset,
  86                                                 unsigned long *size)
  87 {
  88         *offset = offsetof(struct thread_struct, fstate);
  89         *size = sizeof_field(struct thread_struct, fstate);
  90 }
  91
  92 #define INIT_THREAD {                                   \
  93         .sp = sizeof(init_stack) + (long)&init_stack,   \
  94         .align_ctl = PR_UNALIGN_NOPRINT,                \
  95 }
  96
  97 #define task_pt_regs(tsk)                                               \
  98         ((struct pt_regs *)(task_stack_page(tsk) + THREAD_SIZE          \
  99                             - ALIGN(sizeof(struct pt_regs), STACK_ALIGN)))
 100
 101 #define KSTK_EIP(tsk)           (task_pt_regs(tsk)->epc)
 102 #define KSTK_ESP(tsk)           (task_pt_regs(tsk)->sp)
 103
 104
 105 /* Do necessary setup to start up a newly executed thread. */
 106 extern void start_thread(struct pt_regs *regs,
 107                         unsigned long pc, unsigned long sp);
 108
 109 extern unsigned long __get_wchan(struct task_struct *p);
 110
 111
 112 static inline void wait_for_interrupt(void)
 113 {
 114         __asm__ __volatile__ ("wfi");
 115 }
 116
 117 extern phys_addr_t dma32_phys_limit;
 118
 119 struct device_node;
 120 int riscv_of_processor_hartid(struct device_node *node, unsigned long *hartid);
 121 int riscv_early_of_processor_hartid(struct device_node *node, unsigned long *hartid);
 122 int riscv_of_parent_hartid(struct device_node *node, unsigned long *hartid);
 123
 124 extern void riscv_fill_hwcap(void);
 125 extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);
 126
 127 extern unsigned long signal_minsigstksz __ro_after_init;
 128
 129 #ifdef CONFIG_RISCV_ISA_V
 130 /* Userspace interface for PR_RISCV_V_{SET,GET}_VS prctl()s: */
 131 #define RISCV_V_SET_CONTROL(arg)        riscv_v_vstate_ctrl_set_current(arg)
 132 #define RISCV_V_GET_CONTROL()           riscv_v_vstate_ctrl_get_current()
 133 extern long riscv_v_vstate_ctrl_set_current(unsigned long arg);
 134 extern long riscv_v_vstate_ctrl_get_current(void);
 135 #endif /* CONFIG_RISCV_ISA_V */
 136
 137 extern int get_unalign_ctl(struct task_struct *tsk, unsigned long addr);
 138 extern int set_unalign_ctl(struct task_struct *tsk, unsigned int val);
 139
 140 #define GET_UNALIGN_CTL(tsk, addr)      get_unalign_ctl((tsk), (addr))
 141 #define SET_UNALIGN_CTL(tsk, val)       set_unalign_ctl((tsk), (val))
 142
 143 #endif /* __ASSEMBLY__ */
 144
 145 #endif /* _ASM_RISCV_PROCESSOR_H */