* [mark:stackleak/rework 9/9] drivers/misc/lkdtm/stackleak.c:30:34: error: call to undeclared function 'stackleak_task_high_bound'; ISO C99 and later do not support implicit function declarations
@ 2022-04-27 3:25 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2022-04-27 3:25 UTC (permalink / raw)
To: Mark Rutland; +Cc: llvm, kbuild-all, linux-kernel
tree: https://git.kernel.org/pub/scm/linux/kernel/git/mark/linux.git stackleak/rework
head: 7d99ba3a2a80dcf7265eafacebceaa798f5ca231
commit: 7d99ba3a2a80dcf7265eafacebceaa798f5ca231 [9/9] WIP: stackleak: rework the LKDTM stackleak test
config: hexagon-randconfig-r025-20220425 (https://download.01.org/0day-ci/archive/20220427/202204271126.59JDH9bK-lkp@intel.com/config)
compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project 1cddcfdc3c683b393df1a5c9063252eb60e52818)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://git.kernel.org/pub/scm/linux/kernel/git/mark/linux.git/commit/?id=7d99ba3a2a80dcf7265eafacebceaa798f5ca231
git remote add mark https://git.kernel.org/pub/scm/linux/kernel/git/mark/linux.git
git fetch --no-tags mark stackleak/rework
git checkout 7d99ba3a2a80dcf7265eafacebceaa798f5ca231
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=hexagon SHELL=/bin/bash drivers/misc/lkdtm/
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
>> drivers/misc/lkdtm/stackleak.c:30:34: error: call to undeclared function 'stackleak_task_high_bound'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
const unsigned long task_high = stackleak_task_high_bound(current);
^
>> drivers/misc/lkdtm/stackleak.c:31:33: error: call to undeclared function 'stackleak_task_low_bound'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
const unsigned long task_low = stackleak_task_low_bound(current);
^
>> drivers/misc/lkdtm/stackleak.c:32:37: error: no member named 'lowest_stack' in 'struct task_struct'
unsigned long lowest_sp = current->lowest_stack;
~~~~~~~ ^
>> drivers/misc/lkdtm/stackleak.c:33:29: error: use of undeclared identifier 'current_stack_pointer'
unsigned long current_sp = current_stack_pointer;
^
4 errors generated.
vim +/stackleak_task_high_bound +30 drivers/misc/lkdtm/stackleak.c
13
14 /*
15 * Check that stackleak tracks the lowest stack pointer and erases the stack
16 * below this as expected.
17 *
18 * Returns true if tests pass, false otherwise.
19 *
20 * To prevent the lowest stack pointer changing during the test, IRQs are
21 * masked and instrumentation of this function is disabled. We assume that the
22 * compiler will create a fixed-size stack frame for this function.
23 *
24 * We cannot call any non-inlined functions during the test as these may alter
25 * the lowest stack pointer and the poisoned region. As soon as we log an error
26 * the test must be aborted as the printing code will use the stack.
27 */
28 static noinstr bool check_stackleak_irqoff(void)
29 {
> 30 const unsigned long task_high = stackleak_task_high_bound(current);
> 31 const unsigned long task_low = stackleak_task_low_bound(current);
> 32 unsigned long lowest_sp = current->lowest_stack;
> 33 unsigned long current_sp = current_stack_pointer;
34 unsigned long check_high, check_low, check_ptr;
35 unsigned long untracked_low;
36 unsigned long found = 0;
37 const unsigned long check_depth =
38 STACKLEAK_SEARCH_DEPTH / sizeof(unsigned long);
39
40 /*
41 * Check that the current and lowest recorded stack pointers are within
42 * expected bounds.
43 */
44 if (current_sp < task_low || current_sp >= task_high) {
45 pr_err("FAIL: current_stack_pointer (0x%lx) outside of task stack bounds [0x%lx..0x%lx]\n",
46 current_sp, task_low, task_high - 1);
47 return false;
48 }
49 if (lowest_sp < task_low || lowest_sp >= task_high) {
50 pr_err("FAIL: current->lowest_stack (0x%lx) outside of task stack bounds [0x%lx..0x%lx]\n",
51 lowest_sp, task_low, task_high - 1);
52 return false;
53 }
54
55 /*
56 * Poison values are naturally-aligned unsigned long, and any poison
57 * will be below the used portion of the stack, so align down to find
58 * the address immediately above the first possible poison value.
59 */
60 current_sp = ALIGN_DOWN(current_sp, sizeof(unsigned long));
61 lowest_sp = ALIGN_DOWN(current_sp, sizeof(unsigned long));
62
63 /*
64 * This function is not instrumented. If its stack frame starts more
65 * than STACKLEAK_SEARCH_DEPTH below the lowest recorded stack pointer
66 * (after alignment), erasing will not function correctly.
67 */
68 if (current_sp < lowest_sp - STACKLEAK_SEARCH_DEPTH) {
69 pr_err("FAIL: stack pointer (0x%lx) is %ld bytes below current->lowest_stack (0x%lx)\n",
70 current_sp, lowest_sp - current_sp, lowest_sp);
71 return false;
72 }
73
74 /*
75 * Depending on what has run prior to this function (including any
76 * interrupts handled on the task stack), it's possible that:
77 *
78 * a) current_stack_pointer < current->lowest_stack
79 *
80 * b) current_stack_pointer == current->lowest_stack
81 *
82 * c) current_stack_pointer > current->lowest_stack
83 *
84 * For the high boundary we must start checking immediately below the
85 * lowest of the two.
86 *
87 * For the low boundary we start immediately above the STACK_END_MAGIC.
88 */
89 check_high = min(current_sp, lowest_sp);
90 check_low = task_low;
91
92 check_ptr = check_high - sizeof(unsigned long);
93
94 if (check_ptr <= check_low) {
95 pr_err("FAIL: not enough stack space for the test\n");
96 return false;
97 }
98
99 /*
100 * Search for 'check_depth' poison values in a row as stackleak_erase()
101 * does.
102 */
103 while (check_ptr > check_low && found <= check_depth) {
104 if (*(unsigned long *)check_ptr == STACKLEAK_POISON)
105 found++;
106 else
107 found = 0;
108
109 check_ptr -= sizeof(unsigned long);
110 }
111
112 /*
113 * Either we found 'check_depth' poison values in a row, or we hit the
114 * low check boundary. Either way, 'check_ptr' is just below the last
115 * poison we checked.
116 */
117 untracked_low = check_ptr + sizeof(unsigned long) * found;
118
119 /*
120 * Check for any remaining unpoisoned stack.
121 */
122 while (check_ptr > check_low) {
123 unsigned long val = *(unsigned long *)check_ptr;
124
125 if (val != STACKLEAK_POISON) {
126 pr_err("FAIL: non-poison value 0x%lx %lu bytes into poison region\n",
127 val, untracked_low - check_ptr);
128 return false;
129 }
130
131 check_ptr -= sizeof(unsigned long);
132 }
133
134 pr_info("tracked: %lu bytes, untracked: %lu bytes, poisoned: %lu bytes\n",
135 task_high - check_high,
136 check_high - untracked_low,
137 untracked_low - task_low);
138
139 return true;
140 }
141
--
0-DAY CI Kernel Test Service
https://01.org/lkp
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-04-27 3:25 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2022-04-27 3:25 [mark:stackleak/rework 9/9] drivers/misc/lkdtm/stackleak.c:30:34: error: call to undeclared function 'stackleak_task_high_bound'; ISO C99 and later do not support implicit function declarations kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.