2005-04-16 15:20:36 -07:00
|
|
|
/**
|
|
|
|
* @file backtrace.c
|
|
|
|
*
|
|
|
|
* @remark Copyright 2002 OProfile authors
|
|
|
|
* @remark Read the file COPYING
|
|
|
|
*
|
|
|
|
* @author John Levon
|
|
|
|
* @author David Smith
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/oprofile.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <asm/ptrace.h>
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
#include <asm/uaccess.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
struct frame_head {
|
|
|
|
struct frame_head * ebp;
|
|
|
|
unsigned long ret;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
static struct frame_head *
|
2006-02-14 08:19:04 -07:00
|
|
|
dump_kernel_backtrace(struct frame_head * head)
|
|
|
|
{
|
|
|
|
oprofile_add_trace(head->ret);
|
|
|
|
|
|
|
|
/* frame pointers should strictly progress back up the stack
|
|
|
|
* (towards higher addresses) */
|
|
|
|
if (head >= head->ebp)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return head->ebp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct frame_head *
|
|
|
|
dump_user_backtrace(struct frame_head * head)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
struct frame_head bufhead[2];
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
/* Also check accessibility of one struct frame_head beyond */
|
|
|
|
if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
|
|
|
|
return NULL;
|
|
|
|
if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
|
2005-04-16 15:20:36 -07:00
|
|
|
return NULL;
|
|
|
|
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
oprofile_add_trace(bufhead[0].ret);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
/* frame pointers should strictly progress back up the stack
|
|
|
|
* (towards higher addresses) */
|
|
|
|
if (head >= bufhead[0].ebp)
|
|
|
|
return NULL;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
return bufhead[0].ebp;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* | | /\ Higher addresses
|
|
|
|
* | |
|
|
|
|
* --------------- stack base (address of current_thread_info)
|
|
|
|
* | thread info |
|
|
|
|
* . .
|
|
|
|
* | stack |
|
|
|
|
* --------------- saved regs->ebp value if valid (frame_head address)
|
|
|
|
* . .
|
2006-02-03 04:04:09 -07:00
|
|
|
* --------------- saved regs->rsp value if x86_64
|
|
|
|
* | |
|
|
|
|
* --------------- struct pt_regs * stored on stack if 32-bit
|
2005-04-16 15:20:36 -07:00
|
|
|
* | |
|
|
|
|
* . .
|
|
|
|
* | |
|
|
|
|
* --------------- %esp
|
|
|
|
* | |
|
|
|
|
* | | \/ Lower addresses
|
|
|
|
*
|
2006-02-03 04:04:09 -07:00
|
|
|
* Thus, regs (or regs->rsp for x86_64) <-> stack base restricts the
|
|
|
|
* valid(ish) ebp values. Note: (1) for x86_64, NMI and several other
|
|
|
|
* exceptions use special stacks, maintained by the interrupt stack table
|
|
|
|
* (IST). These stacks are set up in trap_init() in
|
|
|
|
* arch/x86_64/kernel/traps.c. Thus, for x86_64, regs now does not point
|
|
|
|
* to the kernel stack; instead, it points to some location on the NMI
|
|
|
|
* stack. On the other hand, regs->rsp is the stack pointer saved when the
|
|
|
|
* NMI occurred. (2) For 32-bit, regs->esp is not valid because the
|
|
|
|
* processor does not save %esp on the kernel stack when interrupts occur
|
|
|
|
* in the kernel mode.
|
2005-04-16 15:20:36 -07:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_FRAME_POINTER
|
|
|
|
static int valid_kernel_stack(struct frame_head * head, struct pt_regs * regs)
|
|
|
|
{
|
|
|
|
unsigned long headaddr = (unsigned long)head;
|
2006-02-03 04:04:09 -07:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
unsigned long stack = (unsigned long)regs->rsp;
|
|
|
|
#else
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned long stack = (unsigned long)regs;
|
2006-02-03 04:04:09 -07:00
|
|
|
#endif
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned long stack_base = (stack & ~(THREAD_SIZE - 1)) + THREAD_SIZE;
|
|
|
|
|
|
|
|
return headaddr > stack && headaddr < stack_base;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* without fp, it's just junk */
|
|
|
|
static int valid_kernel_stack(struct frame_head * head, struct pt_regs * regs)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
x86_backtrace(struct pt_regs * const regs, unsigned int depth)
|
|
|
|
{
|
|
|
|
struct frame_head *head;
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
head = (struct frame_head *)regs->rbp;
|
|
|
|
#else
|
|
|
|
head = (struct frame_head *)regs->ebp;
|
|
|
|
#endif
|
|
|
|
|
2005-06-23 00:08:44 -07:00
|
|
|
if (!user_mode_vm(regs)) {
|
2005-04-16 15:20:36 -07:00
|
|
|
while (depth-- && valid_kernel_stack(head, regs))
|
2006-02-14 08:19:04 -07:00
|
|
|
head = dump_kernel_backtrace(head);
|
2005-04-16 15:20:36 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
[PATCH] mm: kill check_user_page_readable
check_user_page_readable is a problematic variant of follow_page. It's used
only by oprofile's i386 and arm backtrace code, at interrupt time, to
establish whether a userspace stackframe is currently readable.
This is problematic, because we want to push the page_table_lock down inside
follow_page, and later split it; whereas oprofile is doing a spin_trylock on
it (in the i386 case, forgotten in the arm case), and needs that to pin
perhaps two pages spanned by the stackframe (which might be covered by
different locks when we split).
I think oprofile is going about this in the wrong way: it doesn't need to know
the area is readable (neither i386 nor arm uses read protection of user
pages), it doesn't need to pin the memory, it should simply
__copy_from_user_inatomic, and see if that succeeds or not. Sorry, but I've
not got around to devising the sparse __user annotations for this.
Then we can eliminate check_user_page_readable, and return to a single
follow_page without the __follow_page variants.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 18:16:32 -07:00
|
|
|
while (depth-- && head)
|
2006-02-14 08:19:04 -07:00
|
|
|
head = dump_user_backtrace(head);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|