include/linux/thread_info.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   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
  11 #include <linux/types.h>
  12 #include <linux/bug.h>
  13 #include <linux/restart_block.h>
  14 #include <linux/errno.h>
  15
  16 #ifdef CONFIG_THREAD_INFO_IN_TASK
  17 /*
  18  * For CONFIG_THREAD_INFO_IN_TASK kernels we need <asm/current.h> for the
  19  * definition of current, but for !CONFIG_THREAD_INFO_IN_TASK kernels,
  20  * including <asm/current.h> can cause a circular dependency on some platforms.
  21  */
  22 #include <asm/current.h>
  23 #define current_thread_info() ((struct thread_info *)current)
  24 #endif
  25
  26 #include <linux/bitops.h>
  27
  28 /*
  29  * For per-arch arch_within_stack_frames() implementations, defined in
  30  * asm/thread_info.h.
  31  */
  32 enum {
  33         BAD_STACK = -1,
  34         NOT_STACK = 0,
  35         GOOD_FRAME,
  36         GOOD_STACK,
  37 };
  38
  39 #include <asm/thread_info.h>
  40
  41 #ifdef __KERNEL__
  42
  43 #ifndef arch_set_restart_data
  44 #define arch_set_restart_data(restart) do { } while (0)
  45 #endif
  46
  47 static inline long set_restart_fn(struct restart_block *restart,
  48                                         long (*fn)(struct restart_block *))
  49 {
  50         restart->fn = fn;
  51         arch_set_restart_data(restart);
  52         return -ERESTART_RESTARTBLOCK;
  53 }
  54
  55 #ifndef THREAD_ALIGN
  56 #define THREAD_ALIGN    THREAD_SIZE
  57 #endif
  58
  59 #define THREADINFO_GFP          (GFP_KERNEL_ACCOUNT | __GFP_ZERO)
  60
  61 /*
  62  * flag set/clear/test wrappers
  63  * - pass TIF_xxxx constants to these functions
  64  */
  65
  66 static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
  67 {
  68         set_bit(flag, (unsigned long *)&ti->flags);
  69 }
  70
  71 static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
  72 {
  73         clear_bit(flag, (unsigned long *)&ti->flags);
  74 }
  75
  76 static inline void update_ti_thread_flag(struct thread_info *ti, int flag,
  77                                          bool value)
  78 {
  79         if (value)
  80                 set_ti_thread_flag(ti, flag);
  81         else
  82                 clear_ti_thread_flag(ti, flag);
  83 }
  84
  85 static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
  86 {
  87         return test_and_set_bit(flag, (unsigned long *)&ti->flags);
  88 }
  89
  90 static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
  91 {
  92         return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
  93 }
  94
  95 static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
  96 {
  97         return test_bit(flag, (unsigned long *)&ti->flags);
  98 }
  99
 100 #define set_thread_flag(flag) \
 101         set_ti_thread_flag(current_thread_info(), flag)
 102 #define clear_thread_flag(flag) \
 103         clear_ti_thread_flag(current_thread_info(), flag)
 104 #define update_thread_flag(flag, value) \
 105         update_ti_thread_flag(current_thread_info(), flag, value)
 106 #define test_and_set_thread_flag(flag) \
 107         test_and_set_ti_thread_flag(current_thread_info(), flag)
 108 #define test_and_clear_thread_flag(flag) \
 109         test_and_clear_ti_thread_flag(current_thread_info(), flag)
 110 #define test_thread_flag(flag) \
 111         test_ti_thread_flag(current_thread_info(), flag)
 112
 113 #define tif_need_resched() test_thread_flag(TIF_NEED_RESCHED)
 114
 115 #ifndef CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES
 116 static inline int arch_within_stack_frames(const void * const stack,
 117                                            const void * const stackend,
 118                                            const void *obj, unsigned long len)
 119 {
 120         return 0;
 121 }
 122 #endif
 123
 124 #ifdef CONFIG_HARDENED_USERCOPY
 125 extern void __check_object_size(const void *ptr, unsigned long n,
 126                                         bool to_user);
 127
 128 static __always_inline void check_object_size(const void *ptr, unsigned long n,
 129                                               bool to_user)
 130 {
 131         if (!__builtin_constant_p(n))
 132                 __check_object_size(ptr, n, to_user);
 133 }
 134 #else
 135 static inline void check_object_size(const void *ptr, unsigned long n,
 136                                      bool to_user)
 137 { }
 138 #endif /* CONFIG_HARDENED_USERCOPY */
 139
 140 extern void __compiletime_error("copy source size is too small")
 141 __bad_copy_from(void);
 142 extern void __compiletime_error("copy destination size is too small")
 143 __bad_copy_to(void);
 144
 145 static inline void copy_overflow(int size, unsigned long count)
 146 {
 147         WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
 148 }
 149
 150 static __always_inline bool
 151 check_copy_size(const void *addr, size_t bytes, bool is_source)
 152 {
 153         int sz = __compiletime_object_size(addr);
 154         if (unlikely(sz >= 0 && sz < bytes)) {
 155                 if (!__builtin_constant_p(bytes))
 156                         copy_overflow(sz, bytes);
 157                 else if (is_source)
 158                         __bad_copy_from();
 159                 else
 160                         __bad_copy_to();
 161                 return false;
 162         }
 163         check_object_size(addr, bytes, is_source);
 164         return true;
 165 }
 166
 167 #ifndef arch_setup_new_exec
 168 static inline void arch_setup_new_exec(void) { }
 169 #endif
 170
 171 #endif  /* __KERNEL__ */
 172
 173 #endif /* _LINUX_THREAD_INFO_H */