1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _linux_POSIX_TIMERS_H 3 #define _linux_POSIX_TIMERS_H 4 5 #include <linux/alarmtimer.h> 6 #include <linux/list.h> 7 #include <linux/mutex.h> 8 #include <linux/posix-timers_types.h> 9 #include <linux/spinlock.h> 10 #include <linux/timerqueue.h> 11 12 struct kernel_siginfo; 13 struct task_struct; 14 make_process_cpuclock(const unsigned int pid,const clockid_t clock)15 static inline clockid_t make_process_cpuclock(const unsigned int pid, 16 const clockid_t clock) 17 { 18 return ((~pid) << 3) | clock; 19 } make_thread_cpuclock(const unsigned int tid,const clockid_t clock)20 static inline clockid_t make_thread_cpuclock(const unsigned int tid, 21 const clockid_t clock) 22 { 23 return make_process_cpuclock(tid, clock | CPUCLOCK_PERTHREAD_MASK); 24 } 25 fd_to_clockid(const int fd)26 static inline clockid_t fd_to_clockid(const int fd) 27 { 28 return make_process_cpuclock((unsigned int) fd, CLOCKFD); 29 } 30 clockid_to_fd(const clockid_t clk)31 static inline int clockid_to_fd(const clockid_t clk) 32 { 33 return ~(clk >> 3); 34 } 35 36 #ifdef CONFIG_POSIX_TIMERS 37 38 /** 39 * cpu_timer - Posix CPU timer representation for k_itimer 40 * @node: timerqueue node to queue in the task/sig 41 * @head: timerqueue head on which this timer is queued 42 * @pid: Pointer to target task PID 43 * @elist: List head for the expiry list 44 * @firing: Timer is currently firing 45 * @handling: Pointer to the task which handles expiry 46 */ 47 struct cpu_timer { 48 struct timerqueue_node node; 49 struct timerqueue_head *head; 50 struct pid *pid; 51 struct list_head elist; 52 int firing; 53 struct task_struct __rcu *handling; 54 }; 55 cpu_timer_enqueue(struct timerqueue_head * head,struct cpu_timer * ctmr)56 static inline bool cpu_timer_enqueue(struct timerqueue_head *head, 57 struct cpu_timer *ctmr) 58 { 59 ctmr->head = head; 60 return timerqueue_add(head, &ctmr->node); 61 } 62 cpu_timer_queued(struct cpu_timer * ctmr)63 static inline bool cpu_timer_queued(struct cpu_timer *ctmr) 64 { 65 return !!ctmr->head; 66 } 67 cpu_timer_dequeue(struct cpu_timer * ctmr)68 static inline bool cpu_timer_dequeue(struct cpu_timer *ctmr) 69 { 70 if (cpu_timer_queued(ctmr)) { 71 timerqueue_del(ctmr->head, &ctmr->node); 72 ctmr->head = NULL; 73 return true; 74 } 75 return false; 76 } 77 cpu_timer_getexpires(struct cpu_timer * ctmr)78 static inline u64 cpu_timer_getexpires(struct cpu_timer *ctmr) 79 { 80 return ctmr->node.expires; 81 } 82 cpu_timer_setexpires(struct cpu_timer * ctmr,u64 exp)83 static inline void cpu_timer_setexpires(struct cpu_timer *ctmr, u64 exp) 84 { 85 ctmr->node.expires = exp; 86 } 87 posix_cputimers_init(struct posix_cputimers * pct)88 static inline void posix_cputimers_init(struct posix_cputimers *pct) 89 { 90 memset(pct, 0, sizeof(*pct)); 91 pct->bases[0].nextevt = U64_MAX; 92 pct->bases[1].nextevt = U64_MAX; 93 pct->bases[2].nextevt = U64_MAX; 94 } 95 96 void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit); 97 posix_cputimers_rt_watchdog(struct posix_cputimers * pct,u64 runtime)98 static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct, 99 u64 runtime) 100 { 101 pct->bases[CPUCLOCK_SCHED].nextevt = runtime; 102 } 103 104 /* Init task static initializer */ 105 #define INIT_CPU_TIMERBASE(b) { \ 106 .nextevt = U64_MAX, \ 107 } 108 109 #define INIT_CPU_TIMERBASES(b) { \ 110 INIT_CPU_TIMERBASE(b[0]), \ 111 INIT_CPU_TIMERBASE(b[1]), \ 112 INIT_CPU_TIMERBASE(b[2]), \ 113 } 114 115 #define INIT_CPU_TIMERS(s) \ 116 .posix_cputimers = { \ 117 .bases = INIT_CPU_TIMERBASES(s.posix_cputimers.bases), \ 118 }, 119 #else 120 struct cpu_timer { }; 121 #define INIT_CPU_TIMERS(s) posix_cputimers_init(struct posix_cputimers * pct)122 static inline void posix_cputimers_init(struct posix_cputimers *pct) { } posix_cputimers_group_init(struct posix_cputimers * pct,u64 cpu_limit)123 static inline void posix_cputimers_group_init(struct posix_cputimers *pct, 124 u64 cpu_limit) { } 125 #endif 126 127 #ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK 128 void clear_posix_cputimers_work(struct task_struct *p); 129 void posix_cputimers_init_work(void); 130 #else clear_posix_cputimers_work(struct task_struct * p)131 static inline void clear_posix_cputimers_work(struct task_struct *p) { } posix_cputimers_init_work(void)132 static inline void posix_cputimers_init_work(void) { } 133 #endif 134 135 #define REQUEUE_PENDING 1 136 137 /** 138 * struct k_itimer - POSIX.1b interval timer structure. 139 * @list: List head for binding the timer to signals->posix_timers 140 * @t_hash: Entry in the posix timer hash table 141 * @it_lock: Lock protecting the timer 142 * @kclock: Pointer to the k_clock struct handling this timer 143 * @it_clock: The posix timer clock id 144 * @it_id: The posix timer id for identifying the timer 145 * @it_active: Marker that timer is active 146 * @it_overrun: The overrun counter for pending signals 147 * @it_overrun_last: The overrun at the time of the last delivered signal 148 * @it_requeue_pending: Indicator that timer waits for being requeued on 149 * signal delivery 150 * @it_sigev_notify: The notify word of sigevent struct for signal delivery 151 * @it_interval: The interval for periodic timers 152 * @it_signal: Pointer to the creators signal struct 153 * @it_pid: The pid of the process/task targeted by the signal 154 * @it_process: The task to wakeup on clock_nanosleep (CPU timers) 155 * @sigq: Pointer to preallocated sigqueue 156 * @it: Union representing the various posix timer type 157 * internals. 158 * @rcu: RCU head for freeing the timer. 159 */ 160 struct k_itimer { 161 struct hlist_node list; 162 struct hlist_node t_hash; 163 spinlock_t it_lock; 164 const struct k_clock *kclock; 165 clockid_t it_clock; 166 timer_t it_id; 167 int it_active; 168 s64 it_overrun; 169 s64 it_overrun_last; 170 int it_requeue_pending; 171 int it_sigev_notify; 172 ktime_t it_interval; 173 struct signal_struct *it_signal; 174 union { 175 struct pid *it_pid; 176 struct task_struct *it_process; 177 }; 178 struct sigqueue *sigq; 179 union { 180 struct { 181 struct hrtimer timer; 182 } real; 183 struct cpu_timer cpu; 184 struct { 185 struct alarm alarmtimer; 186 } alarm; 187 } it; 188 struct rcu_head rcu; 189 }; 190 191 void run_posix_cpu_timers(void); 192 void posix_cpu_timers_exit(struct task_struct *task); 193 void posix_cpu_timers_exit_group(struct task_struct *task); 194 void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx, 195 u64 *newval, u64 *oldval); 196 197 int update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new); 198 199 void posixtimer_rearm(struct kernel_siginfo *info); 200 #endif 201