1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _linux_POSIX_TIMERS_H
3 #define _linux_POSIX_TIMERS_H
4
5 #include <linux/spinlock.h>
6 #include <linux/list.h>
7 #include <linux/mutex.h>
8 #include <linux/alarmtimer.h>
9 #include <linux/timerqueue.h>
10 #include <linux/task_work.h>
11
12 struct kernel_siginfo;
13 struct task_struct;
14
15 /*
16 * Bit fields within a clockid:
17 *
18 * The most significant 29 bits hold either a pid or a file descriptor.
19 *
20 * Bit 2 indicates whether a cpu clock refers to a thread or a process.
21 *
22 * Bits 1 and 0 give the type: PROF=0, VIRT=1, SCHED=2, or FD=3.
23 *
24 * A clockid is invalid if bits 2, 1, and 0 are all set.
25 */
26 #define CPUCLOCK_PID(clock) ((pid_t) ~((clock) >> 3))
27 #define CPUCLOCK_PERTHREAD(clock) \
28 (((clock) & (clockid_t) CPUCLOCK_PERTHREAD_MASK) != 0)
29
30 #define CPUCLOCK_PERTHREAD_MASK 4
31 #define CPUCLOCK_WHICH(clock) ((clock) & (clockid_t) CPUCLOCK_CLOCK_MASK)
32 #define CPUCLOCK_CLOCK_MASK 3
33 #define CPUCLOCK_PROF 0
34 #define CPUCLOCK_VIRT 1
35 #define CPUCLOCK_SCHED 2
36 #define CPUCLOCK_MAX 3
37 #define CLOCKFD CPUCLOCK_MAX
38 #define CLOCKFD_MASK (CPUCLOCK_PERTHREAD_MASK|CPUCLOCK_CLOCK_MASK)
39
make_process_cpuclock(const unsigned int pid,const clockid_t clock)40 static inline clockid_t make_process_cpuclock(const unsigned int pid,
41 const clockid_t clock)
42 {
43 return ((~pid) << 3) | clock;
44 }
make_thread_cpuclock(const unsigned int tid,const clockid_t clock)45 static inline clockid_t make_thread_cpuclock(const unsigned int tid,
46 const clockid_t clock)
47 {
48 return make_process_cpuclock(tid, clock | CPUCLOCK_PERTHREAD_MASK);
49 }
50
fd_to_clockid(const int fd)51 static inline clockid_t fd_to_clockid(const int fd)
52 {
53 return make_process_cpuclock((unsigned int) fd, CLOCKFD);
54 }
55
clockid_to_fd(const clockid_t clk)56 static inline int clockid_to_fd(const clockid_t clk)
57 {
58 return ~(clk >> 3);
59 }
60
61 #ifdef CONFIG_POSIX_TIMERS
62
63 /**
64 * cpu_timer - Posix CPU timer representation for k_itimer
65 * @node: timerqueue node to queue in the task/sig
66 * @head: timerqueue head on which this timer is queued
67 * @pid: Pointer to target task PID
68 * @elist: List head for the expiry list
69 * @firing: Timer is currently firing
70 * @handling: Pointer to the task which handles expiry
71 */
72 struct cpu_timer {
73 struct timerqueue_node node;
74 struct timerqueue_head *head;
75 struct pid *pid;
76 struct list_head elist;
77 int firing;
78 struct task_struct __rcu *handling;
79 };
80
cpu_timer_enqueue(struct timerqueue_head * head,struct cpu_timer * ctmr)81 static inline bool cpu_timer_enqueue(struct timerqueue_head *head,
82 struct cpu_timer *ctmr)
83 {
84 ctmr->head = head;
85 return timerqueue_add(head, &ctmr->node);
86 }
87
cpu_timer_dequeue(struct cpu_timer * ctmr)88 static inline void cpu_timer_dequeue(struct cpu_timer *ctmr)
89 {
90 if (ctmr->head) {
91 timerqueue_del(ctmr->head, &ctmr->node);
92 ctmr->head = NULL;
93 }
94 }
95
cpu_timer_getexpires(struct cpu_timer * ctmr)96 static inline u64 cpu_timer_getexpires(struct cpu_timer *ctmr)
97 {
98 return ctmr->node.expires;
99 }
100
cpu_timer_setexpires(struct cpu_timer * ctmr,u64 exp)101 static inline void cpu_timer_setexpires(struct cpu_timer *ctmr, u64 exp)
102 {
103 ctmr->node.expires = exp;
104 }
105
106 /**
107 * posix_cputimer_base - Container per posix CPU clock
108 * @nextevt: Earliest-expiration cache
109 * @tqhead: timerqueue head for cpu_timers
110 */
111 struct posix_cputimer_base {
112 u64 nextevt;
113 struct timerqueue_head tqhead;
114 };
115
116 /**
117 * posix_cputimers - Container for posix CPU timer related data
118 * @bases: Base container for posix CPU clocks
119 * @timers_active: Timers are queued.
120 * @expiry_active: Timer expiry is active. Used for
121 * process wide timers to avoid multiple
122 * task trying to handle expiry concurrently
123 *
124 * Used in task_struct and signal_struct
125 */
126 struct posix_cputimers {
127 struct posix_cputimer_base bases[CPUCLOCK_MAX];
128 unsigned int timers_active;
129 unsigned int expiry_active;
130 };
131
132 /**
133 * posix_cputimers_work - Container for task work based posix CPU timer expiry
134 * @work: The task work to be scheduled
135 * @mutex: Mutex held around expiry in context of this task work
136 * @scheduled: @work has been scheduled already, no further processing
137 */
138 struct posix_cputimers_work {
139 struct callback_head work;
140 struct mutex mutex;
141 unsigned int scheduled;
142 };
143
posix_cputimers_init(struct posix_cputimers * pct)144 static inline void posix_cputimers_init(struct posix_cputimers *pct)
145 {
146 memset(pct, 0, sizeof(*pct));
147 pct->bases[0].nextevt = U64_MAX;
148 pct->bases[1].nextevt = U64_MAX;
149 pct->bases[2].nextevt = U64_MAX;
150 }
151
152 void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit);
153
posix_cputimers_rt_watchdog(struct posix_cputimers * pct,u64 runtime)154 static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,
155 u64 runtime)
156 {
157 pct->bases[CPUCLOCK_SCHED].nextevt = runtime;
158 }
159
160 /* Init task static initializer */
161 #define INIT_CPU_TIMERBASE(b) { \
162 .nextevt = U64_MAX, \
163 }
164
165 #define INIT_CPU_TIMERBASES(b) { \
166 INIT_CPU_TIMERBASE(b[0]), \
167 INIT_CPU_TIMERBASE(b[1]), \
168 INIT_CPU_TIMERBASE(b[2]), \
169 }
170
171 #define INIT_CPU_TIMERS(s) \
172 .posix_cputimers = { \
173 .bases = INIT_CPU_TIMERBASES(s.posix_cputimers.bases), \
174 },
175 #else
176 struct posix_cputimers { };
177 struct cpu_timer { };
178 #define INIT_CPU_TIMERS(s)
posix_cputimers_init(struct posix_cputimers * pct)179 static inline void posix_cputimers_init(struct posix_cputimers *pct) { }
posix_cputimers_group_init(struct posix_cputimers * pct,u64 cpu_limit)180 static inline void posix_cputimers_group_init(struct posix_cputimers *pct,
181 u64 cpu_limit) { }
182 #endif
183
184 #ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK
185 void clear_posix_cputimers_work(struct task_struct *p);
186 void posix_cputimers_init_work(void);
187 #else
clear_posix_cputimers_work(struct task_struct * p)188 static inline void clear_posix_cputimers_work(struct task_struct *p) { }
posix_cputimers_init_work(void)189 static inline void posix_cputimers_init_work(void) { }
190 #endif
191
192 #define REQUEUE_PENDING 1
193
194 /**
195 * struct k_itimer - POSIX.1b interval timer structure.
196 * @list: List head for binding the timer to signals->posix_timers
197 * @t_hash: Entry in the posix timer hash table
198 * @it_lock: Lock protecting the timer
199 * @kclock: Pointer to the k_clock struct handling this timer
200 * @it_clock: The posix timer clock id
201 * @it_id: The posix timer id for identifying the timer
202 * @it_active: Marker that timer is active
203 * @it_overrun: The overrun counter for pending signals
204 * @it_overrun_last: The overrun at the time of the last delivered signal
205 * @it_requeue_pending: Indicator that timer waits for being requeued on
206 * signal delivery
207 * @it_sigev_notify: The notify word of sigevent struct for signal delivery
208 * @it_interval: The interval for periodic timers
209 * @it_signal: Pointer to the creators signal struct
210 * @it_pid: The pid of the process/task targeted by the signal
211 * @it_process: The task to wakeup on clock_nanosleep (CPU timers)
212 * @sigq: Pointer to preallocated sigqueue
213 * @it: Union representing the various posix timer type
214 * internals.
215 * @rcu: RCU head for freeing the timer.
216 */
217 struct k_itimer {
218 struct list_head list;
219 struct hlist_node t_hash;
220 spinlock_t it_lock;
221 const struct k_clock *kclock;
222 clockid_t it_clock;
223 timer_t it_id;
224 int it_active;
225 s64 it_overrun;
226 s64 it_overrun_last;
227 int it_requeue_pending;
228 int it_sigev_notify;
229 ktime_t it_interval;
230 struct signal_struct *it_signal;
231 union {
232 struct pid *it_pid;
233 struct task_struct *it_process;
234 };
235 struct sigqueue *sigq;
236 union {
237 struct {
238 struct hrtimer timer;
239 } real;
240 struct cpu_timer cpu;
241 struct {
242 struct alarm alarmtimer;
243 } alarm;
244 } it;
245 struct rcu_head rcu;
246 };
247
248 void run_posix_cpu_timers(void);
249 void posix_cpu_timers_exit(struct task_struct *task);
250 void posix_cpu_timers_exit_group(struct task_struct *task);
251 void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,
252 u64 *newval, u64 *oldval);
253
254 void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new);
255
256 void posixtimer_rearm(struct kernel_siginfo *info);
257 #endif
258