Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'csky-for-linus-5.7-rc6' of git://github.com/c-sky/csky-linux
Pull csky updates from Guo Ren:
- fix for copy_from/to_user (a hard-to-find bug, thx Viro)
- fix for calltrace panic without FRAME_POINT
- two fixes for perf
- two build fixes
- four fixes for non-fatal bugs (msa, rm dis_irq, cleanup psr,
gdbmacros.txt)
* tag 'csky-for-linus-5.7-rc6' of git://github.com/c-sky/csky-linux:
csky: Fixup raw_copy_from_user()
csky: Fixup gdbmacros.txt with name sp in thread_struct
csky: Fixup remove unnecessary save/restore PSR code
csky: Fixup remove duplicate irq_disable
csky: Fixup calltrace panic
csky: Fixup perf callchain unwind
csky: Fixup msa highest 3 bits mask
csky: Fixup perf probe -x hungup
csky: Fixup compile error for abiv1 entry.S
csky/ftrace: Fixup error when disable CONFIG_DYNAMIC_FTRACE
+234
-186
+2
arch/csky/Kconfig
+2
arch/csky/Kconfig
···
8
8
select ARCH_HAS_SYNC_DMA_FOR_DEVICE
9
9
select ARCH_USE_BUILTIN_BSWAP
10
10
select ARCH_USE_QUEUED_RWLOCKS if NR_CPUS>2
11
+
select ARCH_WANT_FRAME_POINTERS if !CPU_CK610
11
12
select COMMON_CLK
12
13
select CLKSRC_MMIO
13
14
select CSKY_MPINTC if CPU_CK860
···
39
38
select HAVE_ARCH_TRACEHOOK
40
39
select HAVE_ARCH_AUDITSYSCALL
41
40
select HAVE_COPY_THREAD_TLS
41
+
select HAVE_DEBUG_BUGVERBOSE
42
42
select HAVE_DYNAMIC_FTRACE
43
43
select HAVE_DYNAMIC_FTRACE_WITH_REGS
44
44
select HAVE_FUNCTION_TRACER
+1
-1
arch/csky/Makefile
+1
-1
arch/csky/Makefile
+2
-2
arch/csky/abiv1/inc/abi/entry.h
+2
-2
arch/csky/abiv1/inc/abi/entry.h
+2
-2
arch/csky/abiv2/inc/abi/entry.h
+2
-2
arch/csky/abiv2/inc/abi/entry.h
+2
arch/csky/abiv2/mcount.S
+2
arch/csky/abiv2/mcount.S
+2
-4
arch/csky/include/asm/processor.h
+2
-4
arch/csky/include/asm/processor.h
···
41
41
#define TASK_UNMAPPED_BASE (TASK_SIZE / 3)
42
42
43
43
struct thread_struct {
44
-
unsigned long ksp; /* kernel stack pointer */
45
-
unsigned long sr; /* saved status register */
44
+
unsigned long sp; /* kernel stack pointer */
46
45
unsigned long trap_no; /* saved status register */
47
46
48
47
/* FPU regs */
···
49
50
};
50
51
51
52
#define INIT_THREAD { \
52
-
.ksp = sizeof(init_stack) + (unsigned long) &init_stack, \
53
-
.sr = DEFAULT_PSR_VALUE, \
53
+
.sp = sizeof(init_stack) + (unsigned long) &init_stack, \
54
54
}
55
55
56
56
/*
+10
arch/csky/include/asm/ptrace.h
+10
arch/csky/include/asm/ptrace.h
···
58
58
return regs->usp;
59
59
}
60
60
61
+
static inline unsigned long frame_pointer(struct pt_regs *regs)
62
+
{
63
+
return regs->regs[4];
64
+
}
65
+
static inline void frame_pointer_set(struct pt_regs *regs,
66
+
unsigned long val)
67
+
{
68
+
regs->regs[4] = val;
69
+
}
70
+
61
71
extern int regs_query_register_offset(const char *name);
62
72
extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
63
73
unsigned int n);
+11
-5
arch/csky/include/asm/thread_info.h
+11
-5
arch/csky/include/asm/thread_info.h
···
38
38
#define THREAD_SIZE_ORDER (THREAD_SHIFT - PAGE_SHIFT)
39
39
40
40
#define thread_saved_fp(tsk) \
41
-
((unsigned long)(((struct switch_stack *)(tsk->thread.ksp))->r8))
41
+
((unsigned long)(((struct switch_stack *)(tsk->thread.sp))->r8))
42
+
43
+
#define thread_saved_sp(tsk) \
44
+
((unsigned long)(tsk->thread.sp))
45
+
46
+
#define thread_saved_lr(tsk) \
47
+
((unsigned long)(((struct switch_stack *)(tsk->thread.sp))->r15))
42
48
43
49
static inline struct thread_info *current_thread_info(void)
44
50
{
···
60
54
#define TIF_SIGPENDING 0 /* signal pending */
61
55
#define TIF_NOTIFY_RESUME 1 /* callback before returning to user */
62
56
#define TIF_NEED_RESCHED 2 /* rescheduling necessary */
63
-
#define TIF_SYSCALL_TRACE 3 /* syscall trace active */
64
-
#define TIF_SYSCALL_TRACEPOINT 4 /* syscall tracepoint instrumentation */
65
-
#define TIF_SYSCALL_AUDIT 5 /* syscall auditing */
66
-
#define TIF_UPROBE 6 /* uprobe breakpoint or singlestep */
57
+
#define TIF_UPROBE 3 /* uprobe breakpoint or singlestep */
58
+
#define TIF_SYSCALL_TRACE 4 /* syscall trace active */
59
+
#define TIF_SYSCALL_TRACEPOINT 5 /* syscall tracepoint instrumentation */
60
+
#define TIF_SYSCALL_AUDIT 6 /* syscall auditing */
67
61
#define TIF_POLLING_NRFLAG 16 /* poll_idle() is TIF_NEED_RESCHED */
68
62
#define TIF_MEMDIE 18 /* is terminating due to OOM killer */
69
63
#define TIF_RESTORE_SIGMASK 20 /* restore signal mask in do_signal() */
+26
-23
arch/csky/include/asm/uaccess.h
+26
-23
arch/csky/include/asm/uaccess.h
···
253
253
254
254
extern int __get_user_bad(void);
255
255
256
-
#define __copy_user(to, from, n) \
256
+
#define ___copy_to_user(to, from, n) \
257
257
do { \
258
258
int w0, w1, w2, w3; \
259
259
asm volatile( \
···
288
288
" subi %0, 4 \n" \
289
289
" br 3b \n" \
290
290
"5: cmpnei %0, 0 \n" /* 1B */ \
291
-
" bf 8f \n" \
291
+
" bf 13f \n" \
292
292
" ldb %3, (%2, 0) \n" \
293
293
"6: stb %3, (%1, 0) \n" \
294
294
" addi %2, 1 \n" \
295
295
" addi %1, 1 \n" \
296
296
" subi %0, 1 \n" \
297
297
" br 5b \n" \
298
-
"7: br 8f \n" \
298
+
"7: subi %0, 4 \n" \
299
+
"8: subi %0, 4 \n" \
300
+
"12: subi %0, 4 \n" \
301
+
" br 13f \n" \
299
302
".section __ex_table, \"a\" \n" \
300
303
".align 2 \n" \
301
-
".long 2b, 7b \n" \
302
-
".long 9b, 7b \n" \
303
-
".long 10b, 7b \n" \
304
+
".long 2b, 13f \n" \
305
+
".long 4b, 13f \n" \
306
+
".long 6b, 13f \n" \
307
+
".long 9b, 12b \n" \
308
+
".long 10b, 8b \n" \
304
309
".long 11b, 7b \n" \
305
-
".long 4b, 7b \n" \
306
-
".long 6b, 7b \n" \
307
310
".previous \n" \
308
-
"8: \n" \
311
+
"13: \n" \
309
312
: "=r"(n), "=r"(to), "=r"(from), "=r"(w0), \
310
313
"=r"(w1), "=r"(w2), "=r"(w3) \
311
314
: "0"(n), "1"(to), "2"(from) \
312
315
: "memory"); \
313
316
} while (0)
314
317
315
-
#define __copy_user_zeroing(to, from, n) \
318
+
#define ___copy_from_user(to, from, n) \
316
319
do { \
317
320
int tmp; \
318
321
int nsave; \
···
358
355
" addi %1, 1 \n" \
359
356
" subi %0, 1 \n" \
360
357
" br 5b \n" \
361
-
"8: mov %3, %0 \n" \
362
-
" movi %4, 0 \n" \
363
-
"9: stb %4, (%1, 0) \n" \
364
-
" addi %1, 1 \n" \
365
-
" subi %3, 1 \n" \
366
-
" cmpnei %3, 0 \n" \
367
-
" bt 9b \n" \
368
-
" br 7f \n" \
358
+
"8: stw %3, (%1, 0) \n" \
359
+
" subi %0, 4 \n" \
360
+
" bf 7f \n" \
361
+
"9: subi %0, 8 \n" \
362
+
" bf 7f \n" \
363
+
"13: stw %3, (%1, 8) \n" \
364
+
" subi %0, 12 \n" \
365
+
" bf 7f \n" \
369
366
".section __ex_table, \"a\" \n" \
370
367
".align 2 \n" \
371
-
".long 2b, 8b \n" \
368
+
".long 2b, 7f \n" \
369
+
".long 4b, 7f \n" \
370
+
".long 6b, 7f \n" \
372
371
".long 10b, 8b \n" \
373
-
".long 11b, 8b \n" \
374
-
".long 12b, 8b \n" \
375
-
".long 4b, 8b \n" \
376
-
".long 6b, 8b \n" \
372
+
".long 11b, 9b \n" \
373
+
".long 12b,13b \n" \
377
374
".previous \n" \
378
375
"7: \n" \
379
376
: "=r"(n), "=r"(to), "=r"(from), "=r"(nsave), \
+1
-1
arch/csky/kernel/Makefile
+1
-1
arch/csky/kernel/Makefile
···
3
3
4
4
obj-y += entry.o atomic.o signal.o traps.o irq.o time.o vdso.o
5
5
obj-y += power.o syscall.o syscall_table.o setup.o
6
-
obj-y += process.o cpu-probe.o ptrace.o dumpstack.o
6
+
obj-y += process.o cpu-probe.o ptrace.o stacktrace.o
7
7
obj-y += probes/
8
8
9
9
obj-$(CONFIG_MODULES) += module.o
+1
-2
arch/csky/kernel/asm-offsets.c
+1
-2
arch/csky/kernel/asm-offsets.c
···
18
18
DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm));
19
19
20
20
/* offsets into the thread struct */
21
-
DEFINE(THREAD_KSP, offsetof(struct thread_struct, ksp));
22
-
DEFINE(THREAD_SR, offsetof(struct thread_struct, sr));
21
+
DEFINE(THREAD_KSP, offsetof(struct thread_struct, sp));
23
22
DEFINE(THREAD_FESR, offsetof(struct thread_struct, user_fp.fesr));
24
23
DEFINE(THREAD_FCR, offsetof(struct thread_struct, user_fp.fcr));
25
24
DEFINE(THREAD_FPREG, offsetof(struct thread_struct, user_fp.vr));
-49
arch/csky/kernel/dumpstack.c
-49
arch/csky/kernel/dumpstack.c
···
1
-
// SPDX-License-Identifier: GPL-2.0
2
-
// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
3
-
4
-
#include <linux/ptrace.h>
5
-
6
-
int kstack_depth_to_print = 48;
7
-
8
-
void show_trace(unsigned long *stack)
9
-
{
10
-
unsigned long *stack_end;
11
-
unsigned long *stack_start;
12
-
unsigned long *fp;
13
-
unsigned long addr;
14
-
15
-
addr = (unsigned long) stack & THREAD_MASK;
16
-
stack_start = (unsigned long *) addr;
17
-
stack_end = (unsigned long *) (addr + THREAD_SIZE);
18
-
19
-
fp = stack;
20
-
pr_info("\nCall Trace:");
21
-
22
-
while (fp > stack_start && fp < stack_end) {
23
-
#ifdef CONFIG_STACKTRACE
24
-
addr = fp[1];
25
-
fp = (unsigned long *) fp[0];
26
-
#else
27
-
addr = *fp++;
28
-
#endif
29
-
if (__kernel_text_address(addr))
30
-
pr_cont("\n[<%08lx>] %pS", addr, (void *)addr);
31
-
}
32
-
pr_cont("\n");
33
-
}
34
-
35
-
void show_stack(struct task_struct *task, unsigned long *stack)
36
-
{
37
-
if (!stack) {
38
-
if (task)
39
-
stack = (unsigned long *)thread_saved_fp(task);
40
-
else
41
-
#ifdef CONFIG_STACKTRACE
42
-
asm volatile("mov %0, r8\n":"=r"(stack)::"memory");
43
-
#else
44
-
stack = (unsigned long *)&stack;
45
-
#endif
46
-
}
47
-
48
-
show_trace(stack);
49
-
}
+2
-10
arch/csky/kernel/entry.S
+2
-10
arch/csky/kernel/entry.S
···
330
330
lrw a3, TASK_THREAD
331
331
addu a3, a0
332
332
333
-
mfcr a2, psr /* Save PSR value */
334
-
stw a2, (a3, THREAD_SR) /* Save PSR in task struct */
335
-
bclri a2, 6 /* Disable interrupts */
336
-
mtcr a2, psr
337
-
338
333
SAVE_SWITCH_STACK
339
334
340
335
stw sp, (a3, THREAD_KSP)
···
340
345
341
346
ldw sp, (a3, THREAD_KSP) /* Set next kernel sp */
342
347
343
-
ldw a2, (a3, THREAD_SR) /* Set next PSR */
344
-
mtcr a2, psr
345
-
346
348
#if defined(__CSKYABIV2__)
347
-
addi r7, a1, TASK_THREAD_INFO
348
-
ldw tls, (r7, TINFO_TP_VALUE)
349
+
addi a3, a1, TASK_THREAD_INFO
350
+
ldw tls, (a3, TINFO_TP_VALUE)
349
351
#endif
350
352
351
353
RESTORE_SWITCH_STACK
+2
arch/csky/kernel/ftrace.c
+2
arch/csky/kernel/ftrace.c
···
202
202
#endif /* CONFIG_DYNAMIC_FTRACE */
203
203
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
204
204
205
+
#ifdef CONFIG_DYNAMIC_FTRACE
205
206
#ifndef CONFIG_CPU_HAS_ICACHE_INS
206
207
struct ftrace_modify_param {
207
208
int command;
···
232
231
stop_machine(__ftrace_modify_code, ¶m, cpu_online_mask);
233
232
}
234
233
#endif
234
+
#endif /* CONFIG_DYNAMIC_FTRACE */
235
235
236
236
/* _mcount is defined in abi's mcount.S */
237
237
EXPORT_SYMBOL(_mcount);
+7
-2
arch/csky/kernel/perf_callchain.c
+7
-2
arch/csky/kernel/perf_callchain.c
···
12
12
13
13
static int unwind_frame_kernel(struct stackframe *frame)
14
14
{
15
-
if (kstack_end((void *)frame->fp))
15
+
unsigned long low = (unsigned long)task_stack_page(current);
16
+
unsigned long high = low + THREAD_SIZE;
17
+
18
+
if (unlikely(frame->fp < low || frame->fp > high))
16
19
return -EPERM;
17
-
if (frame->fp & 0x3 || frame->fp < TASK_SIZE)
20
+
21
+
if (kstack_end((void *)frame->fp) || frame->fp & 0x3)
18
22
return -EPERM;
19
23
20
24
*frame = *(struct stackframe *)frame->fp;
25
+
21
26
if (__kernel_text_address(frame->lr)) {
22
27
int graph = 0;
23
28
+5
arch/csky/kernel/probes/uprobes.c
+5
arch/csky/kernel/probes/uprobes.c
+3
-34
arch/csky/kernel/process.c
+3
-34
arch/csky/kernel/process.c
···
35
35
*/
36
36
unsigned long thread_saved_pc(struct task_struct *tsk)
37
37
{
38
-
struct switch_stack *sw = (struct switch_stack *)tsk->thread.ksp;
38
+
struct switch_stack *sw = (struct switch_stack *)tsk->thread.sp;
39
39
40
40
return sw->r15;
41
41
}
···
56
56
childstack = ((struct switch_stack *) childregs) - 1;
57
57
memset(childstack, 0, sizeof(struct switch_stack));
58
58
59
-
/* setup ksp for switch_to !!! */
60
-
p->thread.ksp = (unsigned long)childstack;
59
+
/* setup thread.sp for switch_to !!! */
60
+
p->thread.sp = (unsigned long)childstack;
61
61
62
62
if (unlikely(p->flags & PF_KTHREAD)) {
63
63
memset(childregs, 0, sizeof(struct pt_regs));
···
97
97
98
98
return 1;
99
99
}
100
-
101
-
unsigned long get_wchan(struct task_struct *p)
102
-
{
103
-
unsigned long lr;
104
-
unsigned long *fp, *stack_start, *stack_end;
105
-
int count = 0;
106
-
107
-
if (!p || p == current || p->state == TASK_RUNNING)
108
-
return 0;
109
-
110
-
stack_start = (unsigned long *)end_of_stack(p);
111
-
stack_end = (unsigned long *)(task_stack_page(p) + THREAD_SIZE);
112
-
113
-
fp = (unsigned long *) thread_saved_fp(p);
114
-
do {
115
-
if (fp < stack_start || fp > stack_end)
116
-
return 0;
117
-
#ifdef CONFIG_STACKTRACE
118
-
lr = fp[1];
119
-
fp = (unsigned long *)fp[0];
120
-
#else
121
-
lr = *fp++;
122
-
#endif
123
-
if (!in_sched_functions(lr) &&
124
-
__kernel_text_address(lr))
125
-
return lr;
126
-
} while (count++ < 16);
127
-
128
-
return 0;
129
-
}
130
-
EXPORT_SYMBOL(get_wchan);
131
100
132
101
#ifndef CONFIG_CPU_PM_NONE
133
102
void arch_cpu_idle(void)
+6
arch/csky/kernel/ptrace.c
+6
arch/csky/kernel/ptrace.c
···
41
41
42
42
regs = task_pt_regs(tsk);
43
43
regs->sr = (regs->sr & TRACE_MODE_MASK) | TRACE_MODE_RUN;
44
+
45
+
/* Enable irq */
46
+
regs->sr |= BIT(6);
44
47
}
45
48
46
49
static void singlestep_enable(struct task_struct *tsk)
···
52
49
53
50
regs = task_pt_regs(tsk);
54
51
regs->sr = (regs->sr & TRACE_MODE_MASK) | TRACE_MODE_SI;
52
+
53
+
/* Disable irq */
54
+
regs->sr &= ~BIT(6);
55
55
}
56
56
57
57
/*
+147
-45
arch/csky/kernel/stacktrace.c
+147
-45
arch/csky/kernel/stacktrace.c
···
1
1
// SPDX-License-Identifier: GPL-2.0
2
-
/* Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd. */
3
2
4
3
#include <linux/sched/debug.h>
5
4
#include <linux/sched/task_stack.h>
6
5
#include <linux/stacktrace.h>
7
6
#include <linux/ftrace.h>
7
+
#include <linux/ptrace.h>
8
+
9
+
#ifdef CONFIG_FRAME_POINTER
10
+
11
+
struct stackframe {
12
+
unsigned long fp;
13
+
unsigned long ra;
14
+
};
15
+
16
+
void notrace walk_stackframe(struct task_struct *task, struct pt_regs *regs,
17
+
bool (*fn)(unsigned long, void *), void *arg)
18
+
{
19
+
unsigned long fp, sp, pc;
20
+
21
+
if (regs) {
22
+
fp = frame_pointer(regs);
23
+
sp = user_stack_pointer(regs);
24
+
pc = instruction_pointer(regs);
25
+
} else if (task == NULL || task == current) {
26
+
const register unsigned long current_sp __asm__ ("sp");
27
+
const register unsigned long current_fp __asm__ ("r8");
28
+
fp = current_fp;
29
+
sp = current_sp;
30
+
pc = (unsigned long)walk_stackframe;
31
+
} else {
32
+
/* task blocked in __switch_to */
33
+
fp = thread_saved_fp(task);
34
+
sp = thread_saved_sp(task);
35
+
pc = thread_saved_lr(task);
36
+
}
37
+
38
+
for (;;) {
39
+
unsigned long low, high;
40
+
struct stackframe *frame;
41
+
42
+
if (unlikely(!__kernel_text_address(pc) || fn(pc, arg)))
43
+
break;
44
+
45
+
/* Validate frame pointer */
46
+
low = sp;
47
+
high = ALIGN(sp, THREAD_SIZE);
48
+
if (unlikely(fp < low || fp > high || fp & 0x3))
49
+
break;
50
+
/* Unwind stack frame */
51
+
frame = (struct stackframe *)fp;
52
+
sp = fp;
53
+
fp = frame->fp;
54
+
pc = ftrace_graph_ret_addr(current, NULL, frame->ra,
55
+
(unsigned long *)(fp - 8));
56
+
}
57
+
}
58
+
59
+
#else /* !CONFIG_FRAME_POINTER */
60
+
61
+
static void notrace walk_stackframe(struct task_struct *task,
62
+
struct pt_regs *regs, bool (*fn)(unsigned long, void *), void *arg)
63
+
{
64
+
unsigned long sp, pc;
65
+
unsigned long *ksp;
66
+
67
+
if (regs) {
68
+
sp = user_stack_pointer(regs);
69
+
pc = instruction_pointer(regs);
70
+
} else if (task == NULL || task == current) {
71
+
const register unsigned long current_sp __asm__ ("sp");
72
+
sp = current_sp;
73
+
pc = (unsigned long)walk_stackframe;
74
+
} else {
75
+
/* task blocked in __switch_to */
76
+
sp = thread_saved_sp(task);
77
+
pc = thread_saved_lr(task);
78
+
}
79
+
80
+
if (unlikely(sp & 0x3))
81
+
return;
82
+
83
+
ksp = (unsigned long *)sp;
84
+
while (!kstack_end(ksp)) {
85
+
if (__kernel_text_address(pc) && unlikely(fn(pc, arg)))
86
+
break;
87
+
pc = (*ksp++) - 0x4;
88
+
}
89
+
}
90
+
#endif /* CONFIG_FRAME_POINTER */
91
+
92
+
static bool print_trace_address(unsigned long pc, void *arg)
93
+
{
94
+
print_ip_sym(pc);
95
+
return false;
96
+
}
97
+
98
+
void show_stack(struct task_struct *task, unsigned long *sp)
99
+
{
100
+
pr_cont("Call Trace:\n");
101
+
walk_stackframe(task, NULL, print_trace_address, NULL);
102
+
}
103
+
104
+
static bool save_wchan(unsigned long pc, void *arg)
105
+
{
106
+
if (!in_sched_functions(pc)) {
107
+
unsigned long *p = arg;
108
+
*p = pc;
109
+
return true;
110
+
}
111
+
return false;
112
+
}
113
+
114
+
unsigned long get_wchan(struct task_struct *task)
115
+
{
116
+
unsigned long pc = 0;
117
+
118
+
if (likely(task && task != current && task->state != TASK_RUNNING))
119
+
walk_stackframe(task, NULL, save_wchan, &pc);
120
+
return pc;
121
+
}
122
+
123
+
#ifdef CONFIG_STACKTRACE
124
+
static bool __save_trace(unsigned long pc, void *arg, bool nosched)
125
+
{
126
+
struct stack_trace *trace = arg;
127
+
128
+
if (unlikely(nosched && in_sched_functions(pc)))
129
+
return false;
130
+
if (unlikely(trace->skip > 0)) {
131
+
trace->skip--;
132
+
return false;
133
+
}
134
+
135
+
trace->entries[trace->nr_entries++] = pc;
136
+
return (trace->nr_entries >= trace->max_entries);
137
+
}
138
+
139
+
static bool save_trace(unsigned long pc, void *arg)
140
+
{
141
+
return __save_trace(pc, arg, false);
142
+
}
143
+
144
+
/*
145
+
* Save stack-backtrace addresses into a stack_trace buffer.
146
+
*/
147
+
void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
148
+
{
149
+
walk_stackframe(tsk, NULL, save_trace, trace);
150
+
}
151
+
EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
8
152
9
153
void save_stack_trace(struct stack_trace *trace)
10
154
{
11
-
save_stack_trace_tsk(current, trace);
155
+
save_stack_trace_tsk(NULL, trace);
12
156
}
13
157
EXPORT_SYMBOL_GPL(save_stack_trace);
14
158
15
-
void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
16
-
{
17
-
unsigned long *fp, *stack_start, *stack_end;
18
-
unsigned long addr;
19
-
int skip = trace->skip;
20
-
int savesched;
21
-
int graph_idx = 0;
22
-
23
-
if (tsk == current) {
24
-
asm volatile("mov %0, r8\n":"=r"(fp));
25
-
savesched = 1;
26
-
} else {
27
-
fp = (unsigned long *)thread_saved_fp(tsk);
28
-
savesched = 0;
29
-
}
30
-
31
-
addr = (unsigned long) fp & THREAD_MASK;
32
-
stack_start = (unsigned long *) addr;
33
-
stack_end = (unsigned long *) (addr + THREAD_SIZE);
34
-
35
-
while (fp > stack_start && fp < stack_end) {
36
-
unsigned long lpp, fpp;
37
-
38
-
fpp = fp[0];
39
-
lpp = fp[1];
40
-
if (!__kernel_text_address(lpp))
41
-
break;
42
-
else
43
-
lpp = ftrace_graph_ret_addr(tsk, &graph_idx, lpp, NULL);
44
-
45
-
if (savesched || !in_sched_functions(lpp)) {
46
-
if (skip) {
47
-
skip--;
48
-
} else {
49
-
trace->entries[trace->nr_entries++] = lpp;
50
-
if (trace->nr_entries >= trace->max_entries)
51
-
break;
52
-
}
53
-
}
54
-
fp = (unsigned long *)fpp;
55
-
}
56
-
}
57
-
EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
159
+
#endif /* CONFIG_STACKTRACE */
+2
-6
arch/csky/lib/usercopy.c
+2
-6
arch/csky/lib/usercopy.c
···
7
7
unsigned long raw_copy_from_user(void *to, const void *from,
8
8
unsigned long n)
9
9
{
10
-
if (access_ok(from, n))
11
-
__copy_user_zeroing(to, from, n);
12
-
else
13
-
memset(to, 0, n);
10
+
___copy_from_user(to, from, n);
14
11
return n;
15
12
}
16
13
EXPORT_SYMBOL(raw_copy_from_user);
···
15
18
unsigned long raw_copy_to_user(void *to, const void *from,
16
19
unsigned long n)
17
20
{
18
-
if (access_ok(to, n))
19
-
__copy_user(to, from, n);
21
+
___copy_to_user(to, from, n);
20
22
return n;
21
23
}
22
24
EXPORT_SYMBOL(raw_copy_to_user);