[linux-2.6-block.git] / include / linux / thread_info.h

/* SPDX-License-Identifier: GPL-2.0 */
/* thread_info.h: common low-level thread information accessors
 *
 * Copyright (C) 2002  David Howells (dhowells@redhat.com)
 * - Incorporating suggestions made by Linus Torvalds
 */

#ifndef _LINUX_THREAD_INFO_H
#define _LINUX_THREAD_INFO_H

#include <linux/types.h>
#include <linux/bug.h>
#include <linux/restart_block.h>

#ifdef CONFIG_THREAD_INFO_IN_TASK
/*
 * For CONFIG_THREAD_INFO_IN_TASK kernels we need <asm/current.h> for the
 * definition of current, but for !CONFIG_THREAD_INFO_IN_TASK kernels,
 * including <asm/current.h> can cause a circular dependency on some platforms.
 */
#include <asm/current.h>
#define current_thread_info() ((struct thread_info *)current)
#endif

#include <linux/bitops.h>

/*
 * For per-arch arch_within_stack_frames() implementations, defined in
 * asm/thread_info.h.
 */
enum {
	BAD_STACK = -1,
	NOT_STACK = 0,
	GOOD_FRAME,
	GOOD_STACK,
};

enum syscall_work_bit {
	SYSCALL_WORK_BIT_SECCOMP,
	SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT,
	SYSCALL_WORK_BIT_SYSCALL_TRACE,
	SYSCALL_WORK_BIT_SYSCALL_EMU,
	SYSCALL_WORK_BIT_SYSCALL_AUDIT,
};

#define SYSCALL_WORK_SECCOMP		BIT(SYSCALL_WORK_BIT_SECCOMP)
#define SYSCALL_WORK_SYSCALL_TRACEPOINT	BIT(SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT)
#define SYSCALL_WORK_SYSCALL_TRACE	BIT(SYSCALL_WORK_BIT_SYSCALL_TRACE)
#define SYSCALL_WORK_SYSCALL_EMU	BIT(SYSCALL_WORK_BIT_SYSCALL_EMU)
#define SYSCALL_WORK_SYSCALL_AUDIT	BIT(SYSCALL_WORK_BIT_SYSCALL_AUDIT)

#include <asm/thread_info.h>

#ifdef __KERNEL__

#ifndef THREAD_ALIGN
#define THREAD_ALIGN	THREAD_SIZE
#endif

#define THREADINFO_GFP		(GFP_KERNEL_ACCOUNT | __GFP_ZERO)

/*
 * flag set/clear/test wrappers
 * - pass TIF_xxxx constants to these functions
 */

static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
{
	set_bit(flag, (unsigned long *)&ti->flags);
}

static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
{
	clear_bit(flag, (unsigned long *)&ti->flags);
}

static inline void update_ti_thread_flag(struct thread_info *ti, int flag,
					 bool value)
{
	if (value)
		set_ti_thread_flag(ti, flag);
	else
		clear_ti_thread_flag(ti, flag);
}

static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
{
	return test_and_set_bit(flag, (unsigned long *)&ti->flags);
}

static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
{
	return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
}

static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
{
	return test_bit(flag, (unsigned long *)&ti->flags);
}

#define set_thread_flag(flag) \
	set_ti_thread_flag(current_thread_info(), flag)
#define clear_thread_flag(flag) \
	clear_ti_thread_flag(current_thread_info(), flag)
#define update_thread_flag(flag, value) \
	update_ti_thread_flag(current_thread_info(), flag, value)
#define test_and_set_thread_flag(flag) \
	test_and_set_ti_thread_flag(current_thread_info(), flag)
#define test_and_clear_thread_flag(flag) \
	test_and_clear_ti_thread_flag(current_thread_info(), flag)
#define test_thread_flag(flag) \
	test_ti_thread_flag(current_thread_info(), flag)

#ifdef CONFIG_GENERIC_ENTRY
#define set_syscall_work(fl) \
	set_bit(SYSCALL_WORK_BIT_##fl, &current_thread_info()->syscall_work)
#define test_syscall_work(fl) \
	test_bit(SYSCALL_WORK_BIT_##fl, &current_thread_info()->syscall_work)
#define clear_syscall_work(fl) \
	clear_bit(SYSCALL_WORK_BIT_##fl, &current_thread_info()->syscall_work)

#define set_task_syscall_work(t, fl) \
	set_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
#define test_task_syscall_work(t, fl) \
	test_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
#define clear_task_syscall_work(t, fl) \
	clear_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)

#else /* CONFIG_GENERIC_ENTRY */

#define set_syscall_work(fl)						\
	set_ti_thread_flag(current_thread_info(), SYSCALL_WORK_##fl)
#define test_syscall_work(fl) \
	test_ti_thread_flag(current_thread_info(), SYSCALL_WORK_##fl)
#define clear_syscall_work(fl) \
	clear_ti_thread_flag(current_thread_info(), SYSCALL_WORK_##fl)

#define set_task_syscall_work(t, fl) \
	set_ti_thread_flag(task_thread_info(t), TIF_##fl)
#define test_task_syscall_work(t, fl) \
	test_ti_thread_flag(task_thread_info(t), TIF_##fl)
#define clear_task_syscall_work(t, fl) \
	clear_ti_thread_flag(task_thread_info(t), TIF_##fl)
#endif /* !CONFIG_GENERIC_ENTRY */

#define tif_need_resched() test_thread_flag(TIF_NEED_RESCHED)

#ifndef CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES
static inline int arch_within_stack_frames(const void * const stack,
					   const void * const stackend,
					   const void *obj, unsigned long len)
{
	return 0;
}
#endif

#ifdef CONFIG_HARDENED_USERCOPY
extern void __check_object_size(const void *ptr, unsigned long n,
					bool to_user);

static __always_inline void check_object_size(const void *ptr, unsigned long n,
					      bool to_user)
{
	if (!__builtin_constant_p(n))
		__check_object_size(ptr, n, to_user);
}
#else
static inline void check_object_size(const void *ptr, unsigned long n,
				     bool to_user)
{ }
#endif /* CONFIG_HARDENED_USERCOPY */

extern void __compiletime_error("copy source size is too small")
__bad_copy_from(void);
extern void __compiletime_error("copy destination size is too small")
__bad_copy_to(void);

static inline void copy_overflow(int size, unsigned long count)
{
	WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
}

static __always_inline __must_check bool
check_copy_size(const void *addr, size_t bytes, bool is_source)
{
	int sz = __compiletime_object_size(addr);
	if (unlikely(sz >= 0 && sz < bytes)) {
		if (!__builtin_constant_p(bytes))
			copy_overflow(sz, bytes);
		else if (is_source)
			__bad_copy_from();
		else
			__bad_copy_to();
		return false;
	}
	if (WARN_ON_ONCE(bytes > INT_MAX))
		return false;
	check_object_size(addr, bytes, is_source);
	return true;
}

#ifndef arch_setup_new_exec
static inline void arch_setup_new_exec(void) { }
#endif

#endif	/* __KERNEL__ */

#endif /* _LINUX_THREAD_INFO_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4 LT	2	/* thread_info.h: common low-level thread information accessors
	3	*
	4	* Copyright (C) 2002 David Howells (dhowells@redhat.com)
	5	* - Incorporating suggestions made by Linus Torvalds
	6	*/
	7
	8	#ifndef _LINUX_THREAD_INFO_H
	9	#define _LINUX_THREAD_INFO_H
	10
ce6bd420	11	#include <linux/types.h>
edd63a27	12	#include <linux/bug.h>
53d74d05	13	#include <linux/restart_block.h>
a332d86d	14
c65eacbe	15	#ifdef CONFIG_THREAD_INFO_IN_TASK
dc3d2a67 MR	16	/*
	17	* For CONFIG_THREAD_INFO_IN_TASK kernels we need <asm/current.h> for the
	18	* definition of current, but for !CONFIG_THREAD_INFO_IN_TASK kernels,
	19	* including <asm/current.h> can cause a circular dependency on some platforms.
	20	*/
	21	#include <asm/current.h>
c65eacbe AL	22	#define current_thread_info() ((struct thread_info *)current)
	23	#endif
	24
1da177e4	25	#include <linux/bitops.h>
96dc4f9f S	26
	27	/*
	28	* For per-arch arch_within_stack_frames() implementations, defined in
	29	* asm/thread_info.h.
	30	*/
	31	enum {
	32	BAD_STACK = -1,
	33	NOT_STACK = 0,
	34	GOOD_FRAME,
	35	GOOD_STACK,
	36	};
	37
23d67a54 GKB	38	enum syscall_work_bit {
23d67a54 GKB	39	SYSCALL_WORK_BIT_SECCOMP,
524666cb	40	SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT,
64c19ba2	41	SYSCALL_WORK_BIT_SYSCALL_TRACE,
64eb35f7	42	SYSCALL_WORK_BIT_SYSCALL_EMU,
785dc4eb	43	SYSCALL_WORK_BIT_SYSCALL_AUDIT,
23d67a54 GKB	44	};
	45
	46	#define SYSCALL_WORK_SECCOMP BIT(SYSCALL_WORK_BIT_SECCOMP)
524666cb	47	#define SYSCALL_WORK_SYSCALL_TRACEPOINT BIT(SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT)
64c19ba2	48	#define SYSCALL_WORK_SYSCALL_TRACE BIT(SYSCALL_WORK_BIT_SYSCALL_TRACE)
64eb35f7	49	#define SYSCALL_WORK_SYSCALL_EMU BIT(SYSCALL_WORK_BIT_SYSCALL_EMU)
785dc4eb	50	#define SYSCALL_WORK_SYSCALL_AUDIT BIT(SYSCALL_WORK_BIT_SYSCALL_AUDIT)
23d67a54	51
1da177e4 LT	52	#include <asm/thread_info.h>
	53
	54	#ifdef __KERNEL__
	55
48ac3c18 MR	56	#ifndef THREAD_ALIGN
	57	#define THREAD_ALIGN THREAD_SIZE
	58	#endif
	59
e01e8063	60	#define THREADINFO_GFP (GFP_KERNEL_ACCOUNT \| __GFP_ZERO)
2889f608	61
1da177e4 LT	62	/*
	63	* flag set/clear/test wrappers
	64	* - pass TIF_xxxx constants to these functions
	65	*/
	66
1da177e4 LT	67	static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
1da177e4 LT	68	{
5548fecd	69	set_bit(flag, (unsigned long *)&ti->flags);
1da177e4 LT	70	}
	71
	72	static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
	73	{
5548fecd	74	clear_bit(flag, (unsigned long *)&ti->flags);
1da177e4 LT	75	}
1da177e4 LT	76
93ee37c2 DM	77	static inline void update_ti_thread_flag(struct thread_info *ti, int flag,
	78	bool value)
	79	{
	80	if (value)
	81	set_ti_thread_flag(ti, flag);
	82	else
	83	clear_ti_thread_flag(ti, flag);
	84	}
	85
1da177e4 LT	86	static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
1da177e4 LT	87	{
5548fecd	88	return test_and_set_bit(flag, (unsigned long *)&ti->flags);
1da177e4 LT	89	}
	90
	91	static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
	92	{
5548fecd	93	return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
1da177e4 LT	94	}
	95
	96	static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
	97	{
5548fecd	98	return test_bit(flag, (unsigned long *)&ti->flags);
1da177e4 LT	99	}
1da177e4 LT	100
3b66a1ed RZ	101	#define set_thread_flag(flag) \
	102	set_ti_thread_flag(current_thread_info(), flag)
	103	#define clear_thread_flag(flag) \
	104	clear_ti_thread_flag(current_thread_info(), flag)
93ee37c2 DM	105	#define update_thread_flag(flag, value) \
93ee37c2 DM	106	update_ti_thread_flag(current_thread_info(), flag, value)
3b66a1ed RZ	107	#define test_and_set_thread_flag(flag) \
	108	test_and_set_ti_thread_flag(current_thread_info(), flag)
	109	#define test_and_clear_thread_flag(flag) \
	110	test_and_clear_ti_thread_flag(current_thread_info(), flag)
	111	#define test_thread_flag(flag) \
	112	test_ti_thread_flag(current_thread_info(), flag)
	113
3136b93c GKB	114	#ifdef CONFIG_GENERIC_ENTRY
	115	#define set_syscall_work(fl) \
	116	set_bit(SYSCALL_WORK_BIT_##fl, &current_thread_info()->syscall_work)
	117	#define test_syscall_work(fl) \
	118	test_bit(SYSCALL_WORK_BIT_##fl, &current_thread_info()->syscall_work)
	119	#define clear_syscall_work(fl) \
	120	clear_bit(SYSCALL_WORK_BIT_##fl, &current_thread_info()->syscall_work)
	121
	122	#define set_task_syscall_work(t, fl) \
	123	set_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
	124	#define test_task_syscall_work(t, fl) \
	125	test_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
	126	#define clear_task_syscall_work(t, fl) \
	127	clear_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
	128
	129	#else /* CONFIG_GENERIC_ENTRY */
	130
	131	#define set_syscall_work(fl) \
	132	set_ti_thread_flag(current_thread_info(), SYSCALL_WORK_##fl)
	133	#define test_syscall_work(fl) \
	134	test_ti_thread_flag(current_thread_info(), SYSCALL_WORK_##fl)
	135	#define clear_syscall_work(fl) \
	136	clear_ti_thread_flag(current_thread_info(), SYSCALL_WORK_##fl)
	137
	138	#define set_task_syscall_work(t, fl) \
	139	set_ti_thread_flag(task_thread_info(t), TIF_##fl)
	140	#define test_task_syscall_work(t, fl) \
	141	test_ti_thread_flag(task_thread_info(t), TIF_##fl)
	142	#define clear_task_syscall_work(t, fl) \
	143	clear_ti_thread_flag(task_thread_info(t), TIF_##fl)
	144	#endif /* !CONFIG_GENERIC_ENTRY */
	145
ea811747 PZ	146	#define tif_need_resched() test_thread_flag(TIF_NEED_RESCHED)
ea811747 PZ	147
0f60a8ef KC	148	#ifndef CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES
	149	static inline int arch_within_stack_frames(const void * const stack,
	150	const void * const stackend,
	151	const void *obj, unsigned long len)
	152	{
	153	return 0;
	154	}
	155	#endif
	156
f5509cc1 KC	157	#ifdef CONFIG_HARDENED_USERCOPY
	158	extern void __check_object_size(const void *ptr, unsigned long n,
	159	bool to_user);
	160
a85d6b82 KC	161	static __always_inline void check_object_size(const void *ptr, unsigned long n,
a85d6b82 KC	162	bool to_user)
f5509cc1	163	{
81409e9e KC	164	if (!__builtin_constant_p(n))
81409e9e KC	165	__check_object_size(ptr, n, to_user);
f5509cc1 KC	166	}
	167	#else
	168	static inline void check_object_size(const void *ptr, unsigned long n,
	169	bool to_user)
	170	{ }
	171	#endif /* CONFIG_HARDENED_USERCOPY */
	172
b0377fed AV	173	extern void __compiletime_error("copy source size is too small")
	174	__bad_copy_from(void);
	175	extern void __compiletime_error("copy destination size is too small")
	176	__bad_copy_to(void);
	177
	178	static inline void copy_overflow(int size, unsigned long count)
	179	{
	180	WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
	181	}
	182
9dd819a1	183	static __always_inline __must_check bool
b0377fed AV	184	check_copy_size(const void *addr, size_t bytes, bool is_source)
	185	{
	186	int sz = __compiletime_object_size(addr);
	187	if (unlikely(sz >= 0 && sz < bytes)) {
	188	if (!__builtin_constant_p(bytes))
	189	copy_overflow(sz, bytes);
	190	else if (is_source)
	191	__bad_copy_from();
	192	else
	193	__bad_copy_to();
	194	return false;
	195	}
6d13de14 KC	196	if (WARN_ON_ONCE(bytes > INT_MAX))
6d13de14 KC	197	return false;
b0377fed AV	198	check_object_size(addr, bytes, is_source);
	199	return true;
	200	}
	201
e9ea1e7f KH	202	#ifndef arch_setup_new_exec
	203	static inline void arch_setup_new_exec(void) { }
	204	#endif
	205
4e4c22c7	206	#endif /* __KERNEL__ */
1da177e4 LT	207
1da177e4 LT	208	#endif /* _LINUX_THREAD_INFO_H */