[linux-block.git] / include / linux / rethook.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Return hooking with list-based shadow stack.
 */
#ifndef _LINUX_RETHOOK_H
#define _LINUX_RETHOOK_H

#include <linux/compiler.h>
#include <linux/freelist.h>
#include <linux/kallsyms.h>
#include <linux/llist.h>
#include <linux/rcupdate.h>
#include <linux/refcount.h>

struct rethook_node;

typedef void (*rethook_handler_t) (struct rethook_node *, void *, struct pt_regs *);

/**
 * struct rethook - The rethook management data structure.
 * @data: The user-defined data storage.
 * @handler: The user-defined return hook handler.
 * @pool: The pool of struct rethook_node.
 * @ref: The reference counter.
 * @rcu: The rcu_head for deferred freeing.
 *
 * Don't embed to another data structure, because this is a self-destructive
 * data structure when all rethook_node are freed.
 */
struct rethook {
	void			*data;
	rethook_handler_t	handler;
	struct freelist_head	pool;
	refcount_t		ref;
	struct rcu_head		rcu;
};

/**
 * struct rethook_node - The rethook shadow-stack entry node.
 * @freelist: The freelist, linked to struct rethook::pool.
 * @rcu: The rcu_head for deferred freeing.
 * @llist: The llist, linked to a struct task_struct::rethooks.
 * @rethook: The pointer to the struct rethook.
 * @ret_addr: The storage for the real return address.
 * @frame: The storage for the frame pointer.
 *
 * You can embed this to your extended data structure to store any data
 * on each entry of the shadow stack.
 */
struct rethook_node {
	union {
		struct freelist_node freelist;
		struct rcu_head      rcu;
	};
	struct llist_node	llist;
	struct rethook		*rethook;
	unsigned long		ret_addr;
	unsigned long		frame;
};

struct rethook *rethook_alloc(void *data, rethook_handler_t handler);
void rethook_free(struct rethook *rh);
void rethook_add_node(struct rethook *rh, struct rethook_node *node);
struct rethook_node *rethook_try_get(struct rethook *rh);
void rethook_recycle(struct rethook_node *node);
void rethook_hook(struct rethook_node *node, struct pt_regs *regs, bool mcount);
unsigned long rethook_find_ret_addr(struct task_struct *tsk, unsigned long frame,
				    struct llist_node **cur);

/* Arch dependent code must implement arch_* and trampoline code */
void arch_rethook_prepare(struct rethook_node *node, struct pt_regs *regs, bool mcount);
void arch_rethook_trampoline(void);

/**
 * is_rethook_trampoline() - Check whether the address is rethook trampoline
 * @addr: The address to be checked
 *
 * Return true if the @addr is the rethook trampoline address.
 */
static inline bool is_rethook_trampoline(unsigned long addr)
{
	return addr == (unsigned long)dereference_symbol_descriptor(arch_rethook_trampoline);
}

/* If the architecture needs to fixup the return address, implement it. */
void arch_rethook_fixup_return(struct pt_regs *regs,
			       unsigned long correct_ret_addr);

/* Generic trampoline handler, arch code must prepare asm stub */
unsigned long rethook_trampoline_handler(struct pt_regs *regs,
					 unsigned long frame);

#ifdef CONFIG_RETHOOK
void rethook_flush_task(struct task_struct *tk);
#else
#define rethook_flush_task(tsk)	do { } while (0)
#endif

#endif
Commit	Line	Data
54ecbe6f MH	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Return hooking with list-based shadow stack.
	4	*/
	5	#ifndef _LINUX_RETHOOK_H
	6	#define _LINUX_RETHOOK_H
	7
	8	#include <linux/compiler.h>
	9	#include <linux/freelist.h>
	10	#include <linux/kallsyms.h>
	11	#include <linux/llist.h>
	12	#include <linux/rcupdate.h>
	13	#include <linux/refcount.h>
	14
	15	struct rethook_node;
	16
	17	typedef void (rethook_handler_t) (struct rethook_node , void , struct pt_regs );
	18
	19	/**
	20	* struct rethook - The rethook management data structure.
	21	* @data: The user-defined data storage.
	22	* @handler: The user-defined return hook handler.
	23	* @pool: The pool of struct rethook_node.
	24	* @ref: The reference counter.
	25	* @rcu: The rcu_head for deferred freeing.
	26	*
	27	* Don't embed to another data structure, because this is a self-destructive
	28	* data structure when all rethook_node are freed.
	29	*/
	30	struct rethook {
	31	void *data;
	32	rethook_handler_t handler;
	33	struct freelist_head pool;
	34	refcount_t ref;
	35	struct rcu_head rcu;
	36	};
	37
	38	/**
	39	* struct rethook_node - The rethook shadow-stack entry node.
	40	* @freelist: The freelist, linked to struct rethook::pool.
	41	* @rcu: The rcu_head for deferred freeing.
	42	* @llist: The llist, linked to a struct task_struct::rethooks.
	43	* @rethook: The pointer to the struct rethook.
	44	* @ret_addr: The storage for the real return address.
	45	* @frame: The storage for the frame pointer.
	46	*
	47	* You can embed this to your extended data structure to store any data
	48	* on each entry of the shadow stack.
	49	*/
	50	struct rethook_node {
	51	union {
	52	struct freelist_node freelist;
	53	struct rcu_head rcu;
	54	};
	55	struct llist_node llist;
	56	struct rethook *rethook;
	57	unsigned long ret_addr;
	58	unsigned long frame;
	59	};
	60
	61	struct rethook rethook_alloc(void data, rethook_handler_t handler);
	62	void rethook_free(struct rethook *rh);
	63	void rethook_add_node(struct rethook rh, struct rethook_node node);
	64	struct rethook_node rethook_try_get(struct rethook rh);
65	void rethook_recycle(struct rethook_node *node);
66	void rethook_hook(struct rethook_node node, struct pt_regs regs, bool mcount);
67	unsigned long rethook_find_ret_addr(struct task_struct *tsk, unsigned long frame,
68	struct llist_node **cur);
69
70	/* Arch dependent code must implement arch_* and trampoline code */
71	void arch_rethook_prepare(struct rethook_node node, struct pt_regs regs, bool mcount);
72	void arch_rethook_trampoline(void);
73
74	/**
75	* is_rethook_trampoline() - Check whether the address is rethook trampoline
76	* @addr: The address to be checked
77	*
78	* Return true if the @addr is the rethook trampoline address.
79	*/
80	static inline bool is_rethook_trampoline(unsigned long addr)
81	{
82	return addr == (unsigned long)dereference_symbol_descriptor(arch_rethook_trampoline);
83	}
84
85	/* If the architecture needs to fixup the return address, implement it. */
86	void arch_rethook_fixup_return(struct pt_regs *regs,
87	unsigned long correct_ret_addr);
88
89	/* Generic trampoline handler, arch code must prepare asm stub */
90	unsigned long rethook_trampoline_handler(struct pt_regs *regs,
91	unsigned long frame);
92
93	#ifdef CONFIG_RETHOOK
94	void rethook_flush_task(struct task_struct *tk);
95	#else
96	#define rethook_flush_task(tsk) do { } while (0)
97	#endif
98
99	#endif
100