posix-cpu-timers: Move state tracking to struct posix_cputimers
[sfrench/cifs-2.6.git] / include / linux / posix-timers.h
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/alarmtimer.h>
8
9 struct kernel_siginfo;
10 struct task_struct;
11
12 struct cpu_timer_list {
13         struct list_head entry;
14         u64 expires;
15         struct task_struct *task;
16         int firing;
17 };
18
19 /*
20  * Bit fields within a clockid:
21  *
22  * The most significant 29 bits hold either a pid or a file descriptor.
23  *
24  * Bit 2 indicates whether a cpu clock refers to a thread or a process.
25  *
26  * Bits 1 and 0 give the type: PROF=0, VIRT=1, SCHED=2, or FD=3.
27  *
28  * A clockid is invalid if bits 2, 1, and 0 are all set.
29  */
30 #define CPUCLOCK_PID(clock)             ((pid_t) ~((clock) >> 3))
31 #define CPUCLOCK_PERTHREAD(clock) \
32         (((clock) & (clockid_t) CPUCLOCK_PERTHREAD_MASK) != 0)
33
34 #define CPUCLOCK_PERTHREAD_MASK 4
35 #define CPUCLOCK_WHICH(clock)   ((clock) & (clockid_t) CPUCLOCK_CLOCK_MASK)
36 #define CPUCLOCK_CLOCK_MASK     3
37 #define CPUCLOCK_PROF           0
38 #define CPUCLOCK_VIRT           1
39 #define CPUCLOCK_SCHED          2
40 #define CPUCLOCK_MAX            3
41 #define CLOCKFD                 CPUCLOCK_MAX
42 #define CLOCKFD_MASK            (CPUCLOCK_PERTHREAD_MASK|CPUCLOCK_CLOCK_MASK)
43
44 static inline clockid_t make_process_cpuclock(const unsigned int pid,
45                 const clockid_t clock)
46 {
47         return ((~pid) << 3) | clock;
48 }
49 static inline clockid_t make_thread_cpuclock(const unsigned int tid,
50                 const clockid_t clock)
51 {
52         return make_process_cpuclock(tid, clock | CPUCLOCK_PERTHREAD_MASK);
53 }
54
55 static inline clockid_t fd_to_clockid(const int fd)
56 {
57         return make_process_cpuclock((unsigned int) fd, CLOCKFD);
58 }
59
60 static inline int clockid_to_fd(const clockid_t clk)
61 {
62         return ~(clk >> 3);
63 }
64
65 #ifdef CONFIG_POSIX_TIMERS
66
67 /**
68  * posix_cputimer_base - Container per posix CPU clock
69  * @nextevt:            Earliest-expiration cache
70  * @cpu_timers:         List heads to queue posix CPU timers
71  */
72 struct posix_cputimer_base {
73         u64                     nextevt;
74         struct list_head        cpu_timers;
75 };
76
77 /**
78  * posix_cputimers - Container for posix CPU timer related data
79  * @bases:              Base container for posix CPU clocks
80  * @timers_active:      Timers are queued.
81  * @expiry_active:      Timer expiry is active. Used for
82  *                      process wide timers to avoid multiple
83  *                      task trying to handle expiry concurrently
84  *
85  * Used in task_struct and signal_struct
86  */
87 struct posix_cputimers {
88         struct posix_cputimer_base      bases[CPUCLOCK_MAX];
89         unsigned int                    timers_active;
90         unsigned int                    expiry_active;
91 };
92
93 static inline void posix_cputimers_init(struct posix_cputimers *pct)
94 {
95         pct->timers_active = 0;
96         pct->expiry_active = 0;
97         pct->bases[0].nextevt = U64_MAX;
98         pct->bases[1].nextevt = U64_MAX;
99         pct->bases[2].nextevt = U64_MAX;
100         INIT_LIST_HEAD(&pct->bases[0].cpu_timers);
101         INIT_LIST_HEAD(&pct->bases[1].cpu_timers);
102         INIT_LIST_HEAD(&pct->bases[2].cpu_timers);
103 }
104
105 void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit);
106
107 static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,
108                                                u64 runtime)
109 {
110         pct->bases[CPUCLOCK_SCHED].nextevt = runtime;
111 }
112
113 /* Init task static initializer */
114 #define INIT_CPU_TIMERBASE(b) {                                         \
115         .nextevt        = U64_MAX,                                      \
116         .cpu_timers     = LIST_HEAD_INIT(b.cpu_timers),                 \
117 }
118
119 #define INIT_CPU_TIMERBASES(b) {                                        \
120         INIT_CPU_TIMERBASE(b[0]),                                       \
121         INIT_CPU_TIMERBASE(b[1]),                                       \
122         INIT_CPU_TIMERBASE(b[2]),                                       \
123 }
124
125 #define INIT_CPU_TIMERS(s)                                              \
126         .posix_cputimers = {                                            \
127                 .bases = INIT_CPU_TIMERBASES(s.posix_cputimers.bases),  \
128         },
129 #else
130 struct posix_cputimers { };
131 #define INIT_CPU_TIMERS(s)
132 static inline void posix_cputimers_init(struct posix_cputimers *pct) { }
133 static inline void posix_cputimers_group_init(struct posix_cputimers *pct,
134                                               u64 cpu_limit) { }
135 #endif
136
137 #define REQUEUE_PENDING 1
138
139 /**
140  * struct k_itimer - POSIX.1b interval timer structure.
141  * @list:               List head for binding the timer to signals->posix_timers
142  * @t_hash:             Entry in the posix timer hash table
143  * @it_lock:            Lock protecting the timer
144  * @kclock:             Pointer to the k_clock struct handling this timer
145  * @it_clock:           The posix timer clock id
146  * @it_id:              The posix timer id for identifying the timer
147  * @it_active:          Marker that timer is active
148  * @it_overrun:         The overrun counter for pending signals
149  * @it_overrun_last:    The overrun at the time of the last delivered signal
150  * @it_requeue_pending: Indicator that timer waits for being requeued on
151  *                      signal delivery
152  * @it_sigev_notify:    The notify word of sigevent struct for signal delivery
153  * @it_interval:        The interval for periodic timers
154  * @it_signal:          Pointer to the creators signal struct
155  * @it_pid:             The pid of the process/task targeted by the signal
156  * @it_process:         The task to wakeup on clock_nanosleep (CPU timers)
157  * @sigq:               Pointer to preallocated sigqueue
158  * @it:                 Union representing the various posix timer type
159  *                      internals.
160  * @rcu:                RCU head for freeing the timer.
161  */
162 struct k_itimer {
163         struct list_head        list;
164         struct hlist_node       t_hash;
165         spinlock_t              it_lock;
166         const struct k_clock    *kclock;
167         clockid_t               it_clock;
168         timer_t                 it_id;
169         int                     it_active;
170         s64                     it_overrun;
171         s64                     it_overrun_last;
172         int                     it_requeue_pending;
173         int                     it_sigev_notify;
174         ktime_t                 it_interval;
175         struct signal_struct    *it_signal;
176         union {
177                 struct pid              *it_pid;
178                 struct task_struct      *it_process;
179         };
180         struct sigqueue         *sigq;
181         union {
182                 struct {
183                         struct hrtimer  timer;
184                 } real;
185                 struct cpu_timer_list   cpu;
186                 struct {
187                         struct alarm    alarmtimer;
188                 } alarm;
189         } it;
190         struct rcu_head         rcu;
191 };
192
193 void run_posix_cpu_timers(void);
194 void posix_cpu_timers_exit(struct task_struct *task);
195 void posix_cpu_timers_exit_group(struct task_struct *task);
196 void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,
197                            u64 *newval, u64 *oldval);
198
199 void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new);
200
201 void posixtimer_rearm(struct kernel_siginfo *info);
202 #endif