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 int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
  77 {
  78         return test_and_set_bit(flag, (unsigned long *)&ti->flags);
  79 }
  80
  81 static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
  82 {
  83         return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
  84 }
  85
  86 static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
  87 {
  88         return test_bit(flag, (unsigned long *)&ti->flags);
  89 }
  90
  91 #define set_thread_flag(flag) \
  92         set_ti_thread_flag(current_thread_info(), flag)
  93 #define clear_thread_flag(flag) \
  94         clear_ti_thread_flag(current_thread_info(), flag)
  95 #define test_and_set_thread_flag(flag) \
  96         test_and_set_ti_thread_flag(current_thread_info(), flag)
  97 #define test_and_clear_thread_flag(flag) \
  98         test_and_clear_ti_thread_flag(current_thread_info(), flag)
  99 #define test_thread_flag(flag) \
 100         test_ti_thread_flag(current_thread_info(), flag)
 101
 102 #define tif_need_resched() test_thread_flag(TIF_NEED_RESCHED)
 103
 104 #ifndef CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES
 105 static inline int arch_within_stack_frames(const void * const stack,
 106                                            const void * const stackend,
 107                                            const void *obj, unsigned long len)
 108 {
 109         return 0;
 110 }
 111 #endif
 112
 113 #ifdef CONFIG_HARDENED_USERCOPY
 114 extern void __check_object_size(const void *ptr, unsigned long n,
 115                                         bool to_user);
 116
 117 static __always_inline void check_object_size(const void *ptr, unsigned long n,
 118                                               bool to_user)
 119 {
 120         if (!__builtin_constant_p(n))
 121                 __check_object_size(ptr, n, to_user);
 122 }
 123 #else
 124 static inline void check_object_size(const void *ptr, unsigned long n,
 125                                      bool to_user)
 126 { }
 127 #endif /* CONFIG_HARDENED_USERCOPY */
 128
 129 extern void __compiletime_error("copy source size is too small")
 130 __bad_copy_from(void);
 131 extern void __compiletime_error("copy destination size is too small")
 132 __bad_copy_to(void);
 133
 134 static inline void copy_overflow(int size, unsigned long count)
 135 {
 136         WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
 137 }
 138
 139 static __always_inline bool
 140 check_copy_size(const void *addr, size_t bytes, bool is_source)
 141 {
 142         int sz = __compiletime_object_size(addr);
 143         if (unlikely(sz >= 0 && sz < bytes)) {
 144                 if (!__builtin_constant_p(bytes))
 145                         copy_overflow(sz, bytes);
 146                 else if (is_source)
 147                         __bad_copy_from();
 148                 else
 149                         __bad_copy_to();
 150                 return false;
 151         }
 152         check_object_size(addr, bytes, is_source);
 153         return true;
 154 }
 155
 156 #ifndef arch_setup_new_exec
 157 static inline void arch_setup_new_exec(void) { }
 158 #endif
 159
 160 #endif  /* __KERNEL__ */
 161
 162 #endif /* _LINUX_THREAD_INFO_H */