1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _LINUX_SCHED_TASK_H |
3 | #define _LINUX_SCHED_TASK_H |
4 | |
5 | /* |
6 | * Interface between the scheduler and various task lifetime (fork()/exit()) |
7 | * functionality: |
8 | */ |
9 | |
10 | #include <linux/rcupdate.h> |
11 | #include <linux/refcount.h> |
12 | #include <linux/sched.h> |
13 | #include <linux/uaccess.h> |
14 | |
15 | struct task_struct; |
16 | struct rusage; |
17 | union thread_union; |
18 | struct css_set; |
19 | |
20 | /* All the bits taken by the old clone syscall. */ |
21 | #define CLONE_LEGACY_FLAGS 0xffffffffULL |
22 | |
23 | struct kernel_clone_args { |
24 | u64 flags; |
25 | int __user *pidfd; |
26 | int __user *child_tid; |
27 | int __user *parent_tid; |
28 | const char *name; |
29 | int exit_signal; |
30 | u32 kthread:1; |
31 | u32 io_thread:1; |
32 | u32 user_worker:1; |
33 | u32 no_files:1; |
34 | unsigned long stack; |
35 | unsigned long stack_size; |
36 | unsigned long tls; |
37 | pid_t *set_tid; |
38 | /* Number of elements in *set_tid */ |
39 | size_t set_tid_size; |
40 | int cgroup; |
41 | int idle; |
42 | int (*fn)(void *); |
43 | void *fn_arg; |
44 | struct cgroup *cgrp; |
45 | struct css_set *cset; |
46 | unsigned int kill_seq; |
47 | }; |
48 | |
49 | /* |
50 | * This serializes "schedule()" and also protects |
51 | * the run-queue from deletions/modifications (but |
52 | * _adding_ to the beginning of the run-queue has |
53 | * a separate lock). |
54 | */ |
55 | extern rwlock_t tasklist_lock; |
56 | extern spinlock_t mmlist_lock; |
57 | |
58 | extern union thread_union init_thread_union; |
59 | extern struct task_struct init_task; |
60 | |
61 | extern int lockdep_tasklist_lock_is_held(void); |
62 | |
63 | extern asmlinkage void schedule_tail(struct task_struct *prev); |
64 | extern void init_idle(struct task_struct *idle, int cpu); |
65 | |
66 | extern int sched_fork(unsigned long clone_flags, struct task_struct *p); |
67 | extern int sched_cgroup_fork(struct task_struct *p, struct kernel_clone_args *kargs); |
68 | extern void sched_cancel_fork(struct task_struct *p); |
69 | extern void sched_post_fork(struct task_struct *p); |
70 | extern void sched_dead(struct task_struct *p); |
71 | |
72 | void __noreturn do_task_dead(void); |
73 | void __noreturn make_task_dead(int signr); |
74 | |
75 | extern void mm_cache_init(void); |
76 | extern void proc_caches_init(void); |
77 | |
78 | extern void fork_init(void); |
79 | |
80 | extern void release_task(struct task_struct * p); |
81 | |
82 | extern int copy_thread(struct task_struct *, const struct kernel_clone_args *); |
83 | |
84 | extern void flush_thread(void); |
85 | |
86 | #ifdef CONFIG_HAVE_EXIT_THREAD |
87 | extern void exit_thread(struct task_struct *tsk); |
88 | #else |
89 | static inline void exit_thread(struct task_struct *tsk) |
90 | { |
91 | } |
92 | #endif |
93 | extern __noreturn void do_group_exit(int); |
94 | |
95 | extern void exit_files(struct task_struct *); |
96 | extern void exit_itimers(struct task_struct *); |
97 | |
98 | extern pid_t kernel_clone(struct kernel_clone_args *kargs); |
99 | struct task_struct *copy_process(struct pid *pid, int trace, int node, |
100 | struct kernel_clone_args *args); |
101 | struct task_struct *create_io_thread(int (*fn)(void *), void *arg, int node); |
102 | struct task_struct *fork_idle(int); |
103 | extern pid_t kernel_thread(int (*fn)(void *), void *arg, const char *name, |
104 | unsigned long flags); |
105 | extern pid_t user_mode_thread(int (*fn)(void *), void *arg, unsigned long flags); |
106 | extern long kernel_wait4(pid_t, int __user *, int, struct rusage *); |
107 | int kernel_wait(pid_t pid, int *stat); |
108 | |
109 | extern void free_task(struct task_struct *tsk); |
110 | |
111 | /* sched_exec is called by processes performing an exec */ |
112 | #ifdef CONFIG_SMP |
113 | extern void sched_exec(void); |
114 | #else |
115 | #define sched_exec() {} |
116 | #endif |
117 | |
118 | static inline struct task_struct *get_task_struct(struct task_struct *t) |
119 | { |
120 | refcount_inc(r: &t->usage); |
121 | return t; |
122 | } |
123 | |
124 | static inline struct task_struct *tryget_task_struct(struct task_struct *t) |
125 | { |
126 | return refcount_inc_not_zero(r: &t->usage) ? t : NULL; |
127 | } |
128 | |
129 | extern void __put_task_struct(struct task_struct *t); |
130 | extern void __put_task_struct_rcu_cb(struct rcu_head *rhp); |
131 | |
132 | static inline void put_task_struct(struct task_struct *t) |
133 | { |
134 | if (!refcount_dec_and_test(r: &t->usage)) |
135 | return; |
136 | |
137 | /* |
138 | * In !RT, it is always safe to call __put_task_struct(). |
139 | * Under RT, we can only call it in preemptible context. |
140 | */ |
141 | if (!IS_ENABLED(CONFIG_PREEMPT_RT) || preemptible()) { |
142 | static DEFINE_WAIT_OVERRIDE_MAP(put_task_map, LD_WAIT_SLEEP); |
143 | |
144 | lock_map_acquire_try(&put_task_map); |
145 | __put_task_struct(t); |
146 | lock_map_release(&put_task_map); |
147 | return; |
148 | } |
149 | |
150 | /* |
151 | * under PREEMPT_RT, we can't call put_task_struct |
152 | * in atomic context because it will indirectly |
153 | * acquire sleeping locks. |
154 | * |
155 | * call_rcu() will schedule delayed_put_task_struct_rcu() |
156 | * to be called in process context. |
157 | * |
158 | * __put_task_struct() is called when |
159 | * refcount_dec_and_test(&t->usage) succeeds. |
160 | * |
161 | * This means that it can't "conflict" with |
162 | * put_task_struct_rcu_user() which abuses ->rcu the same |
163 | * way; rcu_users has a reference so task->usage can't be |
164 | * zero after rcu_users 1 -> 0 transition. |
165 | * |
166 | * delayed_free_task() also uses ->rcu, but it is only called |
167 | * when it fails to fork a process. Therefore, there is no |
168 | * way it can conflict with put_task_struct(). |
169 | */ |
170 | call_rcu(head: &t->rcu, func: __put_task_struct_rcu_cb); |
171 | } |
172 | |
173 | DEFINE_FREE(put_task, struct task_struct *, if (_T) put_task_struct(_T)) |
174 | |
175 | static inline void put_task_struct_many(struct task_struct *t, int nr) |
176 | { |
177 | if (refcount_sub_and_test(i: nr, r: &t->usage)) |
178 | __put_task_struct(t); |
179 | } |
180 | |
181 | void put_task_struct_rcu_user(struct task_struct *task); |
182 | |
183 | /* Free all architecture-specific resources held by a thread. */ |
184 | void release_thread(struct task_struct *dead_task); |
185 | |
186 | #ifdef CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT |
187 | extern int arch_task_struct_size __read_mostly; |
188 | #else |
189 | # define arch_task_struct_size (sizeof(struct task_struct)) |
190 | #endif |
191 | |
192 | #ifndef CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST |
193 | /* |
194 | * If an architecture has not declared a thread_struct whitelist we |
195 | * must assume something there may need to be copied to userspace. |
196 | */ |
197 | static inline void arch_thread_struct_whitelist(unsigned long *offset, |
198 | unsigned long *size) |
199 | { |
200 | *offset = 0; |
201 | /* Handle dynamically sized thread_struct. */ |
202 | *size = arch_task_struct_size - offsetof(struct task_struct, thread); |
203 | } |
204 | #endif |
205 | |
206 | #ifdef CONFIG_VMAP_STACK |
207 | static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t) |
208 | { |
209 | return t->stack_vm_area; |
210 | } |
211 | #else |
212 | static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t) |
213 | { |
214 | return NULL; |
215 | } |
216 | #endif |
217 | |
218 | /* |
219 | * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring |
220 | * subscriptions and synchronises with wait4(). Also used in procfs. Also |
221 | * pins the final release of task.io_context. Also protects ->cpuset and |
222 | * ->cgroup.subsys[]. And ->vfork_done. And ->sysvshm.shm_clist. |
223 | * |
224 | * Nests both inside and outside of read_lock(&tasklist_lock). |
225 | * It must not be nested with write_lock_irq(&tasklist_lock), |
226 | * neither inside nor outside. |
227 | */ |
228 | static inline void task_lock(struct task_struct *p) |
229 | { |
230 | spin_lock(lock: &p->alloc_lock); |
231 | } |
232 | |
233 | static inline void task_unlock(struct task_struct *p) |
234 | { |
235 | spin_unlock(lock: &p->alloc_lock); |
236 | } |
237 | |
238 | DEFINE_GUARD(task_lock, struct task_struct *, task_lock(_T), task_unlock(_T)) |
239 | |
240 | #endif /* _LINUX_SCHED_TASK_H */ |
241 | |