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