1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Shadow Call Stack support.
4 *
5 * Copyright (C) 2019 Google LLC
6 */
7
8 #include <linux/cpuhotplug.h>
9 #include <linux/kasan.h>
10 #include <linux/mm.h>
11 #include <linux/scs.h>
12 #include <linux/vmalloc.h>
13 #include <linux/vmstat.h>
14
__scs_account(void * s,int account)15 static void __scs_account(void *s, int account)
16 {
17 struct page *scs_page = vmalloc_to_page(s);
18
19 mod_node_page_state(page_pgdat(scs_page), NR_KERNEL_SCS_KB,
20 account * (SCS_SIZE / SZ_1K));
21 }
22
23 /* Matches NR_CACHED_STACKS for VMAP_STACK */
24 #define NR_CACHED_SCS 2
25 static DEFINE_PER_CPU(void *, scs_cache[NR_CACHED_SCS]);
26
__scs_alloc(int node)27 static void *__scs_alloc(int node)
28 {
29 int i;
30 void *s;
31
32 for (i = 0; i < NR_CACHED_SCS; i++) {
33 s = this_cpu_xchg(scs_cache[i], NULL);
34 if (s) {
35 kasan_unpoison_vmalloc(s, SCS_SIZE);
36 memset(s, 0, SCS_SIZE);
37 return s;
38 }
39 }
40
41 return __vmalloc_node_range(SCS_SIZE, 1, VMALLOC_START, VMALLOC_END,
42 GFP_SCS, PAGE_KERNEL, 0, node,
43 __builtin_return_address(0));
44 }
45
scs_alloc(int node)46 void *scs_alloc(int node)
47 {
48 void *s;
49
50 s = __scs_alloc(node);
51 if (!s)
52 return NULL;
53
54 *__scs_magic(s) = SCS_END_MAGIC;
55
56 /*
57 * Poison the allocation to catch unintentional accesses to
58 * the shadow stack when KASAN is enabled.
59 */
60 kasan_poison_vmalloc(s, SCS_SIZE);
61 __scs_account(s, 1);
62 return s;
63 }
64
scs_free(void * s)65 void scs_free(void *s)
66 {
67 int i;
68
69 __scs_account(s, -1);
70
71 /*
72 * We cannot sleep as this can be called in interrupt context,
73 * so use this_cpu_cmpxchg to update the cache, and vfree_atomic
74 * to free the stack.
75 */
76
77 for (i = 0; i < NR_CACHED_SCS; i++)
78 if (this_cpu_cmpxchg(scs_cache[i], 0, s) == NULL)
79 return;
80
81 kasan_unpoison_vmalloc(s, SCS_SIZE);
82 vfree_atomic(s);
83 }
84
scs_cleanup(unsigned int cpu)85 static int scs_cleanup(unsigned int cpu)
86 {
87 int i;
88 void **cache = per_cpu_ptr(scs_cache, cpu);
89
90 for (i = 0; i < NR_CACHED_SCS; i++) {
91 vfree(cache[i]);
92 cache[i] = NULL;
93 }
94
95 return 0;
96 }
97
scs_init(void)98 void __init scs_init(void)
99 {
100 cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "scs:scs_cache", NULL,
101 scs_cleanup);
102 }
103
scs_prepare(struct task_struct * tsk,int node)104 int scs_prepare(struct task_struct *tsk, int node)
105 {
106 void *s = scs_alloc(node);
107
108 if (!s)
109 return -ENOMEM;
110
111 task_scs(tsk) = task_scs_sp(tsk) = s;
112 return 0;
113 }
114
scs_check_usage(struct task_struct * tsk)115 static void scs_check_usage(struct task_struct *tsk)
116 {
117 static unsigned long highest;
118
119 unsigned long *p, prev, curr = highest, used = 0;
120
121 if (!IS_ENABLED(CONFIG_DEBUG_STACK_USAGE))
122 return;
123
124 for (p = task_scs(tsk); p < __scs_magic(tsk); ++p) {
125 if (!READ_ONCE_NOCHECK(*p))
126 break;
127 used += sizeof(*p);
128 }
129
130 while (used > curr) {
131 prev = cmpxchg_relaxed(&highest, curr, used);
132
133 if (prev == curr) {
134 pr_info("%s (%d): highest shadow stack usage: %lu bytes\n",
135 tsk->comm, task_pid_nr(tsk), used);
136 break;
137 }
138
139 curr = prev;
140 }
141 }
142
scs_release(struct task_struct * tsk)143 void scs_release(struct task_struct *tsk)
144 {
145 void *s = task_scs(tsk);
146
147 if (!s)
148 return;
149
150 WARN(task_scs_end_corrupted(tsk),
151 "corrupted shadow stack detected when freeing task\n");
152 scs_check_usage(tsk);
153 scs_free(s);
154 }
155