Quelle  common.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Common arm64 stack unwinder code.
 *
 * See: arch/arm64/kernel/stacktrace.c for the reference implementation.
 *
 * Copyright (C) 2012 ARM Ltd.
 */
#ifndef __ASM_STACKTRACE_COMMON_H
#define __ASM_STACKTRACE_COMMON_H

#include <linux/types.h>

struct stack_info {
 unsigned long low;
 unsigned long high;
};

/**
 * struct unwind_state - state used for robust unwinding.
 *
 * @fp:          The fp value in the frame record (or the real fp)
 * @pc:          The lr value in the frame record (or the real lr)
 *
 * @stack:       The stack currently being unwound.
 * @stacks:      An array of stacks which can be unwound.
 * @nr_stacks:   The number of stacks in @stacks.
 */
struct unwind_state {
 unsigned long fp;
 unsigned long pc;

 struct stack_info stack;
 struct stack_info *stacks;
 int nr_stacks;
};

static inline struct stack_info stackinfo_get_unknown(void)
{
 return (struct stack_info) {
  .low = 0,
  .high = 0,
 };
}

static inline bool stackinfo_on_stack(const struct stack_info *info,
          unsigned long sp, unsigned long size)
{
 if (!info->low)
  return false;

 if (sp < info->low || sp + size < sp || sp + size > info->high)
  return false;

 return true;
}

static inline void unwind_init_common(struct unwind_state *state)
{
 state->stack = stackinfo_get_unknown();
}

/**
 * unwind_find_stack() - Find the accessible stack which entirely contains an
 * object.
 *
 * @state: the current unwind state.
 * @sp:    the base address of the object.
 * @size:  the size of the object.
 *
 * Return: a pointer to the relevant stack_info if found; NULL otherwise.
 */
static struct stack_info *unwind_find_stack(struct unwind_state *state,
         unsigned long sp,
         unsigned long size)
{
 struct stack_info *info = &state->stack;

 if (stackinfo_on_stack(info, sp, size))
  return info;

 for (int i = 0; i < state->nr_stacks; i++) {
  info = &state->stacks[i];
  if (stackinfo_on_stack(info, sp, size))
   return info;
 }

 return NULL;
}

/**
 * unwind_consume_stack() - Update stack boundaries so that future unwind steps
 * cannot consume this object again.
 *
 * @state: the current unwind state.
 * @info:  the stack_info of the stack containing the object.
 * @sp:    the base address of the object.
 * @size:  the size of the object.
 *
 * Return: 0 upon success, an error code otherwise.
 */
static inline void unwind_consume_stack(struct unwind_state *state,
     struct stack_info *info,
     unsigned long sp,
     unsigned long size)
{
 struct stack_info tmp;

 /*
 * Stack transitions are strictly one-way, and once we've
 * transitioned from one stack to another, it's never valid to
 * unwind back to the old stack.
 *
 * Destroy the old stack info so that it cannot be found upon a
 * subsequent transition. If the stack has not changed, we'll
 * immediately restore the current stack info.
 *
 * Note that stacks can nest in several valid orders, e.g.
 *
 *   TASK -> IRQ -> OVERFLOW -> SDEI_NORMAL
 *   TASK -> SDEI_NORMAL -> SDEI_CRITICAL -> OVERFLOW
 *   HYP -> OVERFLOW
 *
 * ... so we do not check the specific order of stack
 * transitions.
 */
 tmp = *info;
 *info = stackinfo_get_unknown();
 state->stack = tmp;

 /*
 * Future unwind steps can only consume stack above this frame record.
 * Update the current stack to start immediately above it.
 */
 state->stack.low = sp + size;
}

/**
 * unwind_next_frame_record() - Unwind to the next frame record.
 *
 * @state:        the current unwind state.
 *
 * Return: 0 upon success, an error code otherwise.
 */
static inline int
unwind_next_frame_record(struct unwind_state *state)
{
 struct stack_info *info;
 struct frame_record *record;
 unsigned long fp = state->fp;

 if (fp & 0x7)
  return -EINVAL;

 info = unwind_find_stack(state, fp, sizeof(*record));
 if (!info)
  return -EINVAL;

 unwind_consume_stack(state, info, fp, sizeof(*record));

 /*
 * Record this frame record's values.
 */
 record = (struct frame_record *)fp;
 state->fp = READ_ONCE(record->fp);
 state->pc = READ_ONCE(record->lr);

 return 0;
}

#endif /* __ASM_STACKTRACE_COMMON_H */