int get_stack_info(unsigned long *stack, struct task_struct *task, struct stack_info *info, unsigned long *visit_mask) { if (!stack) goto unknown; task = task ? : current; if (in_task_stack(stack, task, info)) goto recursion_check; if (task != current) goto unknown; if (in_exception_stack(stack, info)) goto recursion_check; if (in_irq_stack(stack, info)) goto recursion_check; if (in_sysenter_stack(stack, info)) goto recursion_check; goto unknown; recursion_check: /* * Make sure we don't iterate through any given stack more than once. * If it comes up a second time then there's something wrong going on: * just break out and report an unknown stack type. */ if (visit_mask) { if (*visit_mask & (1UL << info->type)) { printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); goto unknown; } *visit_mask |= 1UL << info->type; } return 0; unknown: info->type = STACK_TYPE_UNKNOWN; return -EINVAL; }
unsigned long unwind_get_return_address(struct unwind_state *state) { unsigned long addr; unsigned long *addr_p = unwind_get_return_address_ptr(state); if (unwind_done(state)) return 0; if (state->regs && user_mode(state->regs)) return 0; addr = ftrace_graph_ret_addr(state->task, &state->graph_idx, *addr_p, addr_p); if (!__kernel_text_address(addr)) { printk_deferred_once(KERN_WARNING "WARNING: unrecognized kernel stack return address %p at %p in %s:%d\n", (void *)addr, addr_p, state->task->comm, state->task->pid); return 0; } return addr; }
bool unwind_next_frame(struct unwind_state *state) { struct pt_regs *regs; unsigned long *next_bp, *next_frame; size_t next_len; enum stack_type prev_type = state->stack_info.type; if (unwind_done(state)) return false; /* have we reached the end? */ if (state->regs && user_mode(state->regs)) goto the_end; if (is_last_task_frame(state)) { regs = task_pt_regs(state->task); /* * kthreads (other than the boot CPU's idle thread) have some * partial regs at the end of their stack which were placed * there by copy_thread_tls(). But the regs don't have any * useful information, so we can skip them. * * This user_mode() check is slightly broader than a PF_KTHREAD * check because it also catches the awkward situation where a * newly forked kthread transitions into a user task by calling * do_execve(), which eventually clears PF_KTHREAD. */ if (!user_mode(regs)) goto the_end; /* * We're almost at the end, but not quite: there's still the * syscall regs frame. Entry code doesn't encode the regs * pointer for syscalls, so we have to set it manually. */ state->regs = regs; state->bp = NULL; return true; } /* get the next frame pointer */ if (state->regs) next_bp = (unsigned long *)state->regs->bp; else next_bp = (unsigned long *)READ_ONCE_TASK_STACK(state->task,*state->bp); /* is the next frame pointer an encoded pointer to pt_regs? */ regs = decode_frame_pointer(next_bp); if (regs) { next_frame = (unsigned long *)regs; next_len = sizeof(*regs); } else { next_frame = next_bp; next_len = FRAME_HEADER_SIZE; } /* make sure the next frame's data is accessible */ if (!update_stack_state(state, next_frame, next_len)) { /* * Don't warn on bad regs->bp. An interrupt in entry code * might cause a false positive warning. */ if (state->regs) goto the_end; goto bad_address; } /* Make sure it only unwinds up and doesn't overlap the last frame: */ if (state->stack_info.type == prev_type) { if (state->regs && (void *)next_frame < (void *)state->regs + regs_size(state->regs)) goto bad_address; if (state->bp && (void *)next_frame < (void *)state->bp + FRAME_HEADER_SIZE) goto bad_address; } /* move to the next frame */ if (regs) { state->regs = regs; state->bp = NULL; } else { state->bp = next_bp; state->regs = NULL; } return true; bad_address: /* * When unwinding a non-current task, the task might actually be * running on another CPU, in which case it could be modifying its * stack while we're reading it. This is generally not a problem and * can be ignored as long as the caller understands that unwinding * another task will not always succeed. */ if (state->task != current) goto the_end; if (state->regs) { printk_deferred_once(KERN_WARNING "WARNING: kernel stack regs at %p in %s:%d has bad 'bp' value %p\n", state->regs, state->task->comm, state->task->pid, next_frame); unwind_dump(state, (unsigned long *)state->regs); } else { printk_deferred_once(KERN_WARNING "WARNING: kernel stack frame pointer at %p in %s:%d has bad value %p\n", state->bp, state->task->comm, state->task->pid, next_frame); unwind_dump(state, state->bp); } the_end: state->stack_info.type = STACK_TYPE_UNKNOWN; return false; }
bool unwind_next_frame(struct unwind_state *state) { struct pt_regs *regs; unsigned long *next_bp; if (unwind_done(state)) return false; /* Have we reached the end? */ if (state->regs && user_mode(state->regs)) goto the_end; if (is_last_task_frame(state)) { regs = task_pt_regs(state->task); /* * kthreads (other than the boot CPU's idle thread) have some * partial regs at the end of their stack which were placed * there by copy_thread_tls(). But the regs don't have any * useful information, so we can skip them. * * This user_mode() check is slightly broader than a PF_KTHREAD * check because it also catches the awkward situation where a * newly forked kthread transitions into a user task by calling * do_execve(), which eventually clears PF_KTHREAD. */ if (!user_mode(regs)) goto the_end; /* * We're almost at the end, but not quite: there's still the * syscall regs frame. Entry code doesn't encode the regs * pointer for syscalls, so we have to set it manually. */ state->regs = regs; state->bp = NULL; state->ip = 0; return true; } /* Get the next frame pointer: */ if (state->regs) next_bp = (unsigned long *)state->regs->bp; else next_bp = (unsigned long *)READ_ONCE_TASK_STACK(state->task, *state->bp); /* Move to the next frame if it's safe: */ if (!update_stack_state(state, next_bp)) goto bad_address; return true; bad_address: state->error = true; /* * When unwinding a non-current task, the task might actually be * running on another CPU, in which case it could be modifying its * stack while we're reading it. This is generally not a problem and * can be ignored as long as the caller understands that unwinding * another task will not always succeed. */ if (state->task != current) goto the_end; /* * Don't warn if the unwinder got lost due to an interrupt in entry * code or in the C handler before the first frame pointer got set up: */ if (state->got_irq && in_entry_code(state->ip)) goto the_end; if (state->regs && state->regs->sp >= (unsigned long)last_aligned_frame(state) && state->regs->sp < (unsigned long)task_pt_regs(state->task)) goto the_end; if (state->regs) { printk_deferred_once(KERN_WARNING "WARNING: kernel stack regs at %p in %s:%d has bad 'bp' value %p\n", state->regs, state->task->comm, state->task->pid, next_bp); unwind_dump(state); } else { printk_deferred_once(KERN_WARNING "WARNING: kernel stack frame pointer at %p in %s:%d has bad value %p\n", state->bp, state->task->comm, state->task->pid, next_bp); unwind_dump(state); } the_end: state->stack_info.type = STACK_TYPE_UNKNOWN; return false; }