Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Implement CPU time clocks for the POSIX clock interface. |
| 3 | */ |
| 4 | |
| 5 | #include <linux/sched.h> |
| 6 | #include <linux/posix-timers.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | #include <linux/errno.h> |
Roman Zippel | f8bd225 | 2008-05-01 04:34:31 -0700 | [diff] [blame] | 8 | #include <linux/math64.h> |
| 9 | #include <asm/uaccess.h> |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 10 | #include <linux/kernel_stat.h> |
Xiao Guangrong | 3f0a525 | 2009-08-10 10:52:30 +0800 | [diff] [blame] | 11 | #include <trace/events/timer.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 13 | /* |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 14 | * Called after updating RLIMIT_CPU to run cpu timer and update |
| 15 | * tsk->signal->cputime_expires expiration cache if necessary. Needs |
| 16 | * siglock protection since other code may update expiration cache as |
| 17 | * well. |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 18 | */ |
Jiri Slaby | 5ab46b3 | 2009-08-28 14:05:12 +0200 | [diff] [blame] | 19 | void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new) |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 20 | { |
Stanislaw Gruszka | 42c4ab4 | 2009-07-29 12:15:26 +0200 | [diff] [blame] | 21 | cputime_t cputime = secs_to_cputime(rlim_new); |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 22 | |
Jiri Slaby | 5ab46b3 | 2009-08-28 14:05:12 +0200 | [diff] [blame] | 23 | spin_lock_irq(&task->sighand->siglock); |
| 24 | set_process_cpu_timer(task, CPUCLOCK_PROF, &cputime, NULL); |
| 25 | spin_unlock_irq(&task->sighand->siglock); |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 26 | } |
| 27 | |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 28 | static int check_clock(const clockid_t which_clock) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | { |
| 30 | int error = 0; |
| 31 | struct task_struct *p; |
| 32 | const pid_t pid = CPUCLOCK_PID(which_clock); |
| 33 | |
| 34 | if (CPUCLOCK_WHICH(which_clock) >= CPUCLOCK_MAX) |
| 35 | return -EINVAL; |
| 36 | |
| 37 | if (pid == 0) |
| 38 | return 0; |
| 39 | |
Sergey Senozhatsky | c0deae8 | 2010-11-03 18:52:56 +0200 | [diff] [blame] | 40 | rcu_read_lock(); |
Pavel Emelyanov | 8dc86af | 2008-02-08 04:21:52 -0800 | [diff] [blame] | 41 | p = find_task_by_vpid(pid); |
Pavel Emelyanov | bac0abd | 2007-10-18 23:40:18 -0700 | [diff] [blame] | 42 | if (!p || !(CPUCLOCK_PERTHREAD(which_clock) ? |
Sergey Senozhatsky | c0deae8 | 2010-11-03 18:52:56 +0200 | [diff] [blame] | 43 | same_thread_group(p, current) : has_group_leader_pid(p))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | error = -EINVAL; |
| 45 | } |
Sergey Senozhatsky | c0deae8 | 2010-11-03 18:52:56 +0200 | [diff] [blame] | 46 | rcu_read_unlock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | |
| 48 | return error; |
| 49 | } |
| 50 | |
| 51 | static inline union cpu_time_count |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 52 | timespec_to_sample(const clockid_t which_clock, const struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | { |
| 54 | union cpu_time_count ret; |
| 55 | ret.sched = 0; /* high half always zero when .cpu used */ |
| 56 | if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) { |
Oleg Nesterov | ee500f2 | 2005-11-28 13:43:55 -0800 | [diff] [blame] | 57 | ret.sched = (unsigned long long)tp->tv_sec * NSEC_PER_SEC + tp->tv_nsec; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | } else { |
| 59 | ret.cpu = timespec_to_cputime(tp); |
| 60 | } |
| 61 | return ret; |
| 62 | } |
| 63 | |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 64 | static void sample_to_timespec(const clockid_t which_clock, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | union cpu_time_count cpu, |
| 66 | struct timespec *tp) |
| 67 | { |
Roman Zippel | f8bd225 | 2008-05-01 04:34:31 -0700 | [diff] [blame] | 68 | if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) |
| 69 | *tp = ns_to_timespec(cpu.sched); |
| 70 | else |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | cputime_to_timespec(cpu.cpu, tp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | } |
| 73 | |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 74 | static inline int cpu_time_before(const clockid_t which_clock, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | union cpu_time_count now, |
| 76 | union cpu_time_count then) |
| 77 | { |
| 78 | if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) { |
| 79 | return now.sched < then.sched; |
| 80 | } else { |
| 81 | return cputime_lt(now.cpu, then.cpu); |
| 82 | } |
| 83 | } |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 84 | static inline void cpu_time_add(const clockid_t which_clock, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | union cpu_time_count *acc, |
| 86 | union cpu_time_count val) |
| 87 | { |
| 88 | if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) { |
| 89 | acc->sched += val.sched; |
| 90 | } else { |
| 91 | acc->cpu = cputime_add(acc->cpu, val.cpu); |
| 92 | } |
| 93 | } |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 94 | static inline union cpu_time_count cpu_time_sub(const clockid_t which_clock, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | union cpu_time_count a, |
| 96 | union cpu_time_count b) |
| 97 | { |
| 98 | if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) { |
| 99 | a.sched -= b.sched; |
| 100 | } else { |
| 101 | a.cpu = cputime_sub(a.cpu, b.cpu); |
| 102 | } |
| 103 | return a; |
| 104 | } |
| 105 | |
| 106 | /* |
Thomas Gleixner | ac08c26 | 2006-10-17 00:09:39 -0700 | [diff] [blame] | 107 | * Divide and limit the result to res >= 1 |
| 108 | * |
| 109 | * This is necessary to prevent signal delivery starvation, when the result of |
| 110 | * the division would be rounded down to 0. |
| 111 | */ |
| 112 | static inline cputime_t cputime_div_non_zero(cputime_t time, unsigned long div) |
| 113 | { |
| 114 | cputime_t res = cputime_div(time, div); |
| 115 | |
| 116 | return max_t(cputime_t, res, 1); |
| 117 | } |
| 118 | |
| 119 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | * Update expiry time from increment, and increase overrun count, |
| 121 | * given the current clock sample. |
| 122 | */ |
Oleg Nesterov | 7a4ed93 | 2005-10-26 20:26:53 +0400 | [diff] [blame] | 123 | static void bump_cpu_timer(struct k_itimer *timer, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | union cpu_time_count now) |
| 125 | { |
| 126 | int i; |
| 127 | |
| 128 | if (timer->it.cpu.incr.sched == 0) |
| 129 | return; |
| 130 | |
| 131 | if (CPUCLOCK_WHICH(timer->it_clock) == CPUCLOCK_SCHED) { |
| 132 | unsigned long long delta, incr; |
| 133 | |
| 134 | if (now.sched < timer->it.cpu.expires.sched) |
| 135 | return; |
| 136 | incr = timer->it.cpu.incr.sched; |
| 137 | delta = now.sched + incr - timer->it.cpu.expires.sched; |
| 138 | /* Don't use (incr*2 < delta), incr*2 might overflow. */ |
| 139 | for (i = 0; incr < delta - incr; i++) |
| 140 | incr = incr << 1; |
| 141 | for (; i >= 0; incr >>= 1, i--) { |
Oleg Nesterov | 7a4ed93 | 2005-10-26 20:26:53 +0400 | [diff] [blame] | 142 | if (delta < incr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | continue; |
| 144 | timer->it.cpu.expires.sched += incr; |
| 145 | timer->it_overrun += 1 << i; |
| 146 | delta -= incr; |
| 147 | } |
| 148 | } else { |
| 149 | cputime_t delta, incr; |
| 150 | |
| 151 | if (cputime_lt(now.cpu, timer->it.cpu.expires.cpu)) |
| 152 | return; |
| 153 | incr = timer->it.cpu.incr.cpu; |
| 154 | delta = cputime_sub(cputime_add(now.cpu, incr), |
| 155 | timer->it.cpu.expires.cpu); |
| 156 | /* Don't use (incr*2 < delta), incr*2 might overflow. */ |
| 157 | for (i = 0; cputime_lt(incr, cputime_sub(delta, incr)); i++) |
| 158 | incr = cputime_add(incr, incr); |
| 159 | for (; i >= 0; incr = cputime_halve(incr), i--) { |
Oleg Nesterov | 7a4ed93 | 2005-10-26 20:26:53 +0400 | [diff] [blame] | 160 | if (cputime_lt(delta, incr)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | continue; |
| 162 | timer->it.cpu.expires.cpu = |
| 163 | cputime_add(timer->it.cpu.expires.cpu, incr); |
| 164 | timer->it_overrun += 1 << i; |
| 165 | delta = cputime_sub(delta, incr); |
| 166 | } |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | static inline cputime_t prof_ticks(struct task_struct *p) |
| 171 | { |
| 172 | return cputime_add(p->utime, p->stime); |
| 173 | } |
| 174 | static inline cputime_t virt_ticks(struct task_struct *p) |
| 175 | { |
| 176 | return p->utime; |
| 177 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 179 | static int |
| 180 | posix_cpu_clock_getres(const clockid_t which_clock, struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | { |
| 182 | int error = check_clock(which_clock); |
| 183 | if (!error) { |
| 184 | tp->tv_sec = 0; |
| 185 | tp->tv_nsec = ((NSEC_PER_SEC + HZ - 1) / HZ); |
| 186 | if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) { |
| 187 | /* |
| 188 | * If sched_clock is using a cycle counter, we |
| 189 | * don't have any idea of its true resolution |
| 190 | * exported, but it is much more than 1s/HZ. |
| 191 | */ |
| 192 | tp->tv_nsec = 1; |
| 193 | } |
| 194 | } |
| 195 | return error; |
| 196 | } |
| 197 | |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 198 | static int |
| 199 | posix_cpu_clock_set(const clockid_t which_clock, const struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | { |
| 201 | /* |
| 202 | * You can never reset a CPU clock, but we check for other errors |
| 203 | * in the call before failing with EPERM. |
| 204 | */ |
| 205 | int error = check_clock(which_clock); |
| 206 | if (error == 0) { |
| 207 | error = -EPERM; |
| 208 | } |
| 209 | return error; |
| 210 | } |
| 211 | |
| 212 | |
| 213 | /* |
| 214 | * Sample a per-thread clock for the given task. |
| 215 | */ |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 216 | static int cpu_clock_sample(const clockid_t which_clock, struct task_struct *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | union cpu_time_count *cpu) |
| 218 | { |
| 219 | switch (CPUCLOCK_WHICH(which_clock)) { |
| 220 | default: |
| 221 | return -EINVAL; |
| 222 | case CPUCLOCK_PROF: |
| 223 | cpu->cpu = prof_ticks(p); |
| 224 | break; |
| 225 | case CPUCLOCK_VIRT: |
| 226 | cpu->cpu = virt_ticks(p); |
| 227 | break; |
| 228 | case CPUCLOCK_SCHED: |
Hidetoshi Seto | c5f8d99 | 2009-03-31 16:56:03 +0900 | [diff] [blame] | 229 | cpu->sched = task_sched_runtime(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | break; |
| 231 | } |
| 232 | return 0; |
| 233 | } |
| 234 | |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 235 | void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times) |
| 236 | { |
Oleg Nesterov | bfac700 | 2010-06-11 01:09:56 +0200 | [diff] [blame] | 237 | struct signal_struct *sig = tsk->signal; |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 238 | struct task_struct *t; |
| 239 | |
Oleg Nesterov | bfac700 | 2010-06-11 01:09:56 +0200 | [diff] [blame] | 240 | times->utime = sig->utime; |
| 241 | times->stime = sig->stime; |
| 242 | times->sum_exec_runtime = sig->sum_sched_runtime; |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 243 | |
| 244 | rcu_read_lock(); |
Oleg Nesterov | bfac700 | 2010-06-11 01:09:56 +0200 | [diff] [blame] | 245 | /* make sure we can trust tsk->thread_group list */ |
| 246 | if (!likely(pid_alive(tsk))) |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 247 | goto out; |
| 248 | |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 249 | t = tsk; |
| 250 | do { |
| 251 | times->utime = cputime_add(times->utime, t->utime); |
| 252 | times->stime = cputime_add(times->stime, t->stime); |
Peter Zijlstra | d670ec1 | 2011-09-01 12:42:04 +0200 | [diff] [blame] | 253 | times->sum_exec_runtime += task_sched_runtime(t); |
Oleg Nesterov | bfac700 | 2010-06-11 01:09:56 +0200 | [diff] [blame] | 254 | } while_each_thread(tsk, t); |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 255 | out: |
| 256 | rcu_read_unlock(); |
| 257 | } |
| 258 | |
Peter Zijlstra | 4da94d49 | 2009-02-11 11:30:27 +0100 | [diff] [blame] | 259 | static void update_gt_cputime(struct task_cputime *a, struct task_cputime *b) |
| 260 | { |
| 261 | if (cputime_gt(b->utime, a->utime)) |
| 262 | a->utime = b->utime; |
| 263 | |
| 264 | if (cputime_gt(b->stime, a->stime)) |
| 265 | a->stime = b->stime; |
| 266 | |
| 267 | if (b->sum_exec_runtime > a->sum_exec_runtime) |
| 268 | a->sum_exec_runtime = b->sum_exec_runtime; |
| 269 | } |
| 270 | |
| 271 | void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times) |
| 272 | { |
| 273 | struct thread_group_cputimer *cputimer = &tsk->signal->cputimer; |
| 274 | struct task_cputime sum; |
| 275 | unsigned long flags; |
| 276 | |
Peter Zijlstra | 4da94d49 | 2009-02-11 11:30:27 +0100 | [diff] [blame] | 277 | if (!cputimer->running) { |
Peter Zijlstra | 4da94d49 | 2009-02-11 11:30:27 +0100 | [diff] [blame] | 278 | /* |
| 279 | * The POSIX timer interface allows for absolute time expiry |
| 280 | * values through the TIMER_ABSTIME flag, therefore we have |
| 281 | * to synchronize the timer to the clock every time we start |
| 282 | * it. |
| 283 | */ |
| 284 | thread_group_cputime(tsk, &sum); |
Linus Torvalds | 3cfef95 | 2011-10-26 16:17:32 +0200 | [diff] [blame] | 285 | raw_spin_lock_irqsave(&cputimer->lock, flags); |
Peter Zijlstra | bcd5cff | 2011-10-17 11:50:30 +0200 | [diff] [blame] | 286 | cputimer->running = 1; |
Peter Zijlstra | 4da94d49 | 2009-02-11 11:30:27 +0100 | [diff] [blame] | 287 | update_gt_cputime(&cputimer->cputime, &sum); |
Peter Zijlstra | bcd5cff | 2011-10-17 11:50:30 +0200 | [diff] [blame] | 288 | } else |
Linus Torvalds | 3cfef95 | 2011-10-26 16:17:32 +0200 | [diff] [blame] | 289 | raw_spin_lock_irqsave(&cputimer->lock, flags); |
Peter Zijlstra | 4da94d49 | 2009-02-11 11:30:27 +0100 | [diff] [blame] | 290 | *times = cputimer->cputime; |
Thomas Gleixner | ee30a7b | 2009-07-25 18:56:56 +0200 | [diff] [blame] | 291 | raw_spin_unlock_irqrestore(&cputimer->lock, flags); |
Peter Zijlstra | 4da94d49 | 2009-02-11 11:30:27 +0100 | [diff] [blame] | 292 | } |
| 293 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | /* |
| 295 | * Sample a process (thread group) clock for the given group_leader task. |
| 296 | * Must be called with tasklist_lock held for reading. |
| 297 | */ |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 298 | static int cpu_clock_sample_group(const clockid_t which_clock, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | struct task_struct *p, |
| 300 | union cpu_time_count *cpu) |
| 301 | { |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 302 | struct task_cputime cputime; |
| 303 | |
Petr Tesarik | eccdaea | 2008-11-24 15:46:31 +0100 | [diff] [blame] | 304 | switch (CPUCLOCK_WHICH(which_clock)) { |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 305 | default: |
| 306 | return -EINVAL; |
| 307 | case CPUCLOCK_PROF: |
Hidetoshi Seto | c5f8d99 | 2009-03-31 16:56:03 +0900 | [diff] [blame] | 308 | thread_group_cputime(p, &cputime); |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 309 | cpu->cpu = cputime_add(cputime.utime, cputime.stime); |
| 310 | break; |
| 311 | case CPUCLOCK_VIRT: |
Hidetoshi Seto | c5f8d99 | 2009-03-31 16:56:03 +0900 | [diff] [blame] | 312 | thread_group_cputime(p, &cputime); |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 313 | cpu->cpu = cputime.utime; |
| 314 | break; |
| 315 | case CPUCLOCK_SCHED: |
Peter Zijlstra | d670ec1 | 2011-09-01 12:42:04 +0200 | [diff] [blame] | 316 | thread_group_cputime(p, &cputime); |
| 317 | cpu->sched = cputime.sum_exec_runtime; |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 318 | break; |
| 319 | } |
| 320 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | } |
| 322 | |
| 323 | |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 324 | static int posix_cpu_clock_get(const clockid_t which_clock, struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | { |
| 326 | const pid_t pid = CPUCLOCK_PID(which_clock); |
| 327 | int error = -EINVAL; |
| 328 | union cpu_time_count rtn; |
| 329 | |
| 330 | if (pid == 0) { |
| 331 | /* |
| 332 | * Special case constant value for our own clocks. |
| 333 | * We don't have to do any lookup to find ourselves. |
| 334 | */ |
| 335 | if (CPUCLOCK_PERTHREAD(which_clock)) { |
| 336 | /* |
| 337 | * Sampling just ourselves we can do with no locking. |
| 338 | */ |
| 339 | error = cpu_clock_sample(which_clock, |
| 340 | current, &rtn); |
| 341 | } else { |
| 342 | read_lock(&tasklist_lock); |
| 343 | error = cpu_clock_sample_group(which_clock, |
| 344 | current, &rtn); |
| 345 | read_unlock(&tasklist_lock); |
| 346 | } |
| 347 | } else { |
| 348 | /* |
| 349 | * Find the given PID, and validate that the caller |
| 350 | * should be able to see it. |
| 351 | */ |
| 352 | struct task_struct *p; |
Paul E. McKenney | 1f2ea08 | 2007-02-16 01:28:22 -0800 | [diff] [blame] | 353 | rcu_read_lock(); |
Pavel Emelyanov | 8dc86af | 2008-02-08 04:21:52 -0800 | [diff] [blame] | 354 | p = find_task_by_vpid(pid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | if (p) { |
| 356 | if (CPUCLOCK_PERTHREAD(which_clock)) { |
Pavel Emelyanov | bac0abd | 2007-10-18 23:40:18 -0700 | [diff] [blame] | 357 | if (same_thread_group(p, current)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | error = cpu_clock_sample(which_clock, |
| 359 | p, &rtn); |
| 360 | } |
Paul E. McKenney | 1f2ea08 | 2007-02-16 01:28:22 -0800 | [diff] [blame] | 361 | } else { |
| 362 | read_lock(&tasklist_lock); |
Oleg Nesterov | d30fda3 | 2010-05-26 14:43:13 -0700 | [diff] [blame] | 363 | if (thread_group_leader(p) && p->sighand) { |
Paul E. McKenney | 1f2ea08 | 2007-02-16 01:28:22 -0800 | [diff] [blame] | 364 | error = |
| 365 | cpu_clock_sample_group(which_clock, |
| 366 | p, &rtn); |
| 367 | } |
| 368 | read_unlock(&tasklist_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 369 | } |
| 370 | } |
Paul E. McKenney | 1f2ea08 | 2007-02-16 01:28:22 -0800 | [diff] [blame] | 371 | rcu_read_unlock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | if (error) |
| 375 | return error; |
| 376 | sample_to_timespec(which_clock, rtn, tp); |
| 377 | return 0; |
| 378 | } |
| 379 | |
| 380 | |
| 381 | /* |
| 382 | * Validate the clockid_t for a new CPU-clock timer, and initialize the timer. |
Stanislaw Gruszka | ba5ea95 | 2009-11-17 14:14:13 -0800 | [diff] [blame] | 383 | * This is called from sys_timer_create() and do_cpu_nanosleep() with the |
| 384 | * new timer already all-zeros initialized. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | */ |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 386 | static int posix_cpu_timer_create(struct k_itimer *new_timer) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | { |
| 388 | int ret = 0; |
| 389 | const pid_t pid = CPUCLOCK_PID(new_timer->it_clock); |
| 390 | struct task_struct *p; |
| 391 | |
| 392 | if (CPUCLOCK_WHICH(new_timer->it_clock) >= CPUCLOCK_MAX) |
| 393 | return -EINVAL; |
| 394 | |
| 395 | INIT_LIST_HEAD(&new_timer->it.cpu.entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | |
Sergey Senozhatsky | c0deae8 | 2010-11-03 18:52:56 +0200 | [diff] [blame] | 397 | rcu_read_lock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | if (CPUCLOCK_PERTHREAD(new_timer->it_clock)) { |
| 399 | if (pid == 0) { |
| 400 | p = current; |
| 401 | } else { |
Pavel Emelyanov | 8dc86af | 2008-02-08 04:21:52 -0800 | [diff] [blame] | 402 | p = find_task_by_vpid(pid); |
Pavel Emelyanov | bac0abd | 2007-10-18 23:40:18 -0700 | [diff] [blame] | 403 | if (p && !same_thread_group(p, current)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | p = NULL; |
| 405 | } |
| 406 | } else { |
| 407 | if (pid == 0) { |
| 408 | p = current->group_leader; |
| 409 | } else { |
Pavel Emelyanov | 8dc86af | 2008-02-08 04:21:52 -0800 | [diff] [blame] | 410 | p = find_task_by_vpid(pid); |
Sergey Senozhatsky | c0deae8 | 2010-11-03 18:52:56 +0200 | [diff] [blame] | 411 | if (p && !has_group_leader_pid(p)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | p = NULL; |
| 413 | } |
| 414 | } |
| 415 | new_timer->it.cpu.task = p; |
| 416 | if (p) { |
| 417 | get_task_struct(p); |
| 418 | } else { |
| 419 | ret = -EINVAL; |
| 420 | } |
Sergey Senozhatsky | c0deae8 | 2010-11-03 18:52:56 +0200 | [diff] [blame] | 421 | rcu_read_unlock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | |
| 423 | return ret; |
| 424 | } |
| 425 | |
| 426 | /* |
| 427 | * Clean up a CPU-clock timer that is about to be destroyed. |
| 428 | * This is called from timer deletion with the timer already locked. |
| 429 | * If we return TIMER_RETRY, it's necessary to release the timer's lock |
| 430 | * and try again. (This happens when the timer is in the middle of firing.) |
| 431 | */ |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 432 | static int posix_cpu_timer_del(struct k_itimer *timer) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | { |
| 434 | struct task_struct *p = timer->it.cpu.task; |
Oleg Nesterov | 108150e | 2005-10-23 20:25:39 +0400 | [diff] [blame] | 435 | int ret = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | |
Oleg Nesterov | 108150e | 2005-10-23 20:25:39 +0400 | [diff] [blame] | 437 | if (likely(p != NULL)) { |
Linus Torvalds | 9465bee | 2005-10-21 15:36:00 -0700 | [diff] [blame] | 438 | read_lock(&tasklist_lock); |
Oleg Nesterov | d30fda3 | 2010-05-26 14:43:13 -0700 | [diff] [blame] | 439 | if (unlikely(p->sighand == NULL)) { |
Linus Torvalds | 9465bee | 2005-10-21 15:36:00 -0700 | [diff] [blame] | 440 | /* |
| 441 | * We raced with the reaping of the task. |
| 442 | * The deletion should have cleared us off the list. |
| 443 | */ |
| 444 | BUG_ON(!list_empty(&timer->it.cpu.entry)); |
| 445 | } else { |
Linus Torvalds | 9465bee | 2005-10-21 15:36:00 -0700 | [diff] [blame] | 446 | spin_lock(&p->sighand->siglock); |
Oleg Nesterov | 108150e | 2005-10-23 20:25:39 +0400 | [diff] [blame] | 447 | if (timer->it.cpu.firing) |
| 448 | ret = TIMER_RETRY; |
| 449 | else |
| 450 | list_del(&timer->it.cpu.entry); |
Linus Torvalds | 9465bee | 2005-10-21 15:36:00 -0700 | [diff] [blame] | 451 | spin_unlock(&p->sighand->siglock); |
| 452 | } |
| 453 | read_unlock(&tasklist_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | |
Oleg Nesterov | 108150e | 2005-10-23 20:25:39 +0400 | [diff] [blame] | 455 | if (!ret) |
| 456 | put_task_struct(p); |
| 457 | } |
| 458 | |
| 459 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | } |
| 461 | |
| 462 | /* |
| 463 | * Clean out CPU timers still ticking when a thread exited. The task |
| 464 | * pointer is cleared, and the expiry time is replaced with the residual |
| 465 | * time for later timer_gettime calls to return. |
| 466 | * This must be called with the siglock held. |
| 467 | */ |
| 468 | static void cleanup_timers(struct list_head *head, |
| 469 | cputime_t utime, cputime_t stime, |
Ingo Molnar | 41b86e9 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 470 | unsigned long long sum_exec_runtime) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | { |
| 472 | struct cpu_timer_list *timer, *next; |
| 473 | cputime_t ptime = cputime_add(utime, stime); |
| 474 | |
| 475 | list_for_each_entry_safe(timer, next, head, entry) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 476 | list_del_init(&timer->entry); |
| 477 | if (cputime_lt(timer->expires.cpu, ptime)) { |
| 478 | timer->expires.cpu = cputime_zero; |
| 479 | } else { |
| 480 | timer->expires.cpu = cputime_sub(timer->expires.cpu, |
| 481 | ptime); |
| 482 | } |
| 483 | } |
| 484 | |
| 485 | ++head; |
| 486 | list_for_each_entry_safe(timer, next, head, entry) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 487 | list_del_init(&timer->entry); |
| 488 | if (cputime_lt(timer->expires.cpu, utime)) { |
| 489 | timer->expires.cpu = cputime_zero; |
| 490 | } else { |
| 491 | timer->expires.cpu = cputime_sub(timer->expires.cpu, |
| 492 | utime); |
| 493 | } |
| 494 | } |
| 495 | |
| 496 | ++head; |
| 497 | list_for_each_entry_safe(timer, next, head, entry) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 498 | list_del_init(&timer->entry); |
Ingo Molnar | 41b86e9 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 499 | if (timer->expires.sched < sum_exec_runtime) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 500 | timer->expires.sched = 0; |
| 501 | } else { |
Ingo Molnar | 41b86e9 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 502 | timer->expires.sched -= sum_exec_runtime; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | } |
| 504 | } |
| 505 | } |
| 506 | |
| 507 | /* |
| 508 | * These are both called with the siglock held, when the current thread |
| 509 | * is being reaped. When the final (leader) thread in the group is reaped, |
| 510 | * posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit. |
| 511 | */ |
| 512 | void posix_cpu_timers_exit(struct task_struct *tsk) |
| 513 | { |
| 514 | cleanup_timers(tsk->cpu_timers, |
Ingo Molnar | 41b86e9 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 515 | tsk->utime, tsk->stime, tsk->se.sum_exec_runtime); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 516 | |
| 517 | } |
| 518 | void posix_cpu_timers_exit_group(struct task_struct *tsk) |
| 519 | { |
Stanislaw Gruszka | 17d42c1 | 2009-08-06 16:03:30 -0700 | [diff] [blame] | 520 | struct signal_struct *const sig = tsk->signal; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 521 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | cleanup_timers(tsk->signal->cpu_timers, |
Stanislaw Gruszka | 17d42c1 | 2009-08-06 16:03:30 -0700 | [diff] [blame] | 523 | cputime_add(tsk->utime, sig->utime), |
| 524 | cputime_add(tsk->stime, sig->stime), |
| 525 | tsk->se.sum_exec_runtime + sig->sum_sched_runtime); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | } |
| 527 | |
| 528 | static void clear_dead_task(struct k_itimer *timer, union cpu_time_count now) |
| 529 | { |
| 530 | /* |
| 531 | * That's all for this thread or process. |
| 532 | * We leave our residual in expires to be reported. |
| 533 | */ |
| 534 | put_task_struct(timer->it.cpu.task); |
| 535 | timer->it.cpu.task = NULL; |
| 536 | timer->it.cpu.expires = cpu_time_sub(timer->it_clock, |
| 537 | timer->it.cpu.expires, |
| 538 | now); |
| 539 | } |
| 540 | |
Stanislaw Gruszka | d1e3b6d | 2009-07-29 12:15:28 +0200 | [diff] [blame] | 541 | static inline int expires_gt(cputime_t expires, cputime_t new_exp) |
| 542 | { |
| 543 | return cputime_eq(expires, cputime_zero) || |
| 544 | cputime_gt(expires, new_exp); |
| 545 | } |
| 546 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | /* |
| 548 | * Insert the timer on the appropriate list before any timers that |
| 549 | * expire later. This must be called with the tasklist_lock held |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 550 | * for reading, interrupts disabled and p->sighand->siglock taken. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 551 | */ |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 552 | static void arm_timer(struct k_itimer *timer) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | { |
| 554 | struct task_struct *p = timer->it.cpu.task; |
| 555 | struct list_head *head, *listpos; |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 556 | struct task_cputime *cputime_expires; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 557 | struct cpu_timer_list *const nt = &timer->it.cpu; |
| 558 | struct cpu_timer_list *next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 559 | |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 560 | if (CPUCLOCK_PERTHREAD(timer->it_clock)) { |
| 561 | head = p->cpu_timers; |
| 562 | cputime_expires = &p->cputime_expires; |
| 563 | } else { |
| 564 | head = p->signal->cpu_timers; |
| 565 | cputime_expires = &p->signal->cputime_expires; |
| 566 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 567 | head += CPUCLOCK_WHICH(timer->it_clock); |
| 568 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 569 | listpos = head; |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 570 | list_for_each_entry(next, head, entry) { |
| 571 | if (cpu_time_before(timer->it_clock, nt->expires, next->expires)) |
| 572 | break; |
| 573 | listpos = &next->entry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | } |
| 575 | list_add(&nt->entry, listpos); |
| 576 | |
| 577 | if (listpos == head) { |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 578 | union cpu_time_count *exp = &nt->expires; |
| 579 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 580 | /* |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 581 | * We are the new earliest-expiring POSIX 1.b timer, hence |
| 582 | * need to update expiration cache. Take into account that |
| 583 | * for process timers we share expiration cache with itimers |
| 584 | * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 585 | */ |
| 586 | |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 587 | switch (CPUCLOCK_WHICH(timer->it_clock)) { |
| 588 | case CPUCLOCK_PROF: |
| 589 | if (expires_gt(cputime_expires->prof_exp, exp->cpu)) |
| 590 | cputime_expires->prof_exp = exp->cpu; |
| 591 | break; |
| 592 | case CPUCLOCK_VIRT: |
| 593 | if (expires_gt(cputime_expires->virt_exp, exp->cpu)) |
| 594 | cputime_expires->virt_exp = exp->cpu; |
| 595 | break; |
| 596 | case CPUCLOCK_SCHED: |
| 597 | if (cputime_expires->sched_exp == 0 || |
| 598 | cputime_expires->sched_exp > exp->sched) |
| 599 | cputime_expires->sched_exp = exp->sched; |
| 600 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 601 | } |
| 602 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 603 | } |
| 604 | |
| 605 | /* |
| 606 | * The timer is locked, fire it and arrange for its reload. |
| 607 | */ |
| 608 | static void cpu_timer_fire(struct k_itimer *timer) |
| 609 | { |
Stanislaw Gruszka | 1f169f8 | 2010-03-11 14:04:41 -0800 | [diff] [blame] | 610 | if ((timer->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) { |
| 611 | /* |
| 612 | * User don't want any signal. |
| 613 | */ |
| 614 | timer->it.cpu.expires.sched = 0; |
| 615 | } else if (unlikely(timer->sigq == NULL)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 616 | /* |
| 617 | * This a special case for clock_nanosleep, |
| 618 | * not a normal timer from sys_timer_create. |
| 619 | */ |
| 620 | wake_up_process(timer->it_process); |
| 621 | timer->it.cpu.expires.sched = 0; |
| 622 | } else if (timer->it.cpu.incr.sched == 0) { |
| 623 | /* |
| 624 | * One-shot timer. Clear it as soon as it's fired. |
| 625 | */ |
| 626 | posix_timer_event(timer, 0); |
| 627 | timer->it.cpu.expires.sched = 0; |
| 628 | } else if (posix_timer_event(timer, ++timer->it_requeue_pending)) { |
| 629 | /* |
| 630 | * The signal did not get queued because the signal |
| 631 | * was ignored, so we won't get any callback to |
| 632 | * reload the timer. But we need to keep it |
| 633 | * ticking in case the signal is deliverable next time. |
| 634 | */ |
| 635 | posix_cpu_timer_schedule(timer); |
| 636 | } |
| 637 | } |
| 638 | |
| 639 | /* |
Peter Zijlstra | 3997ad3 | 2009-02-12 15:00:52 +0100 | [diff] [blame] | 640 | * Sample a process (thread group) timer for the given group_leader task. |
| 641 | * Must be called with tasklist_lock held for reading. |
| 642 | */ |
| 643 | static int cpu_timer_sample_group(const clockid_t which_clock, |
| 644 | struct task_struct *p, |
| 645 | union cpu_time_count *cpu) |
| 646 | { |
| 647 | struct task_cputime cputime; |
| 648 | |
| 649 | thread_group_cputimer(p, &cputime); |
| 650 | switch (CPUCLOCK_WHICH(which_clock)) { |
| 651 | default: |
| 652 | return -EINVAL; |
| 653 | case CPUCLOCK_PROF: |
| 654 | cpu->cpu = cputime_add(cputime.utime, cputime.stime); |
| 655 | break; |
| 656 | case CPUCLOCK_VIRT: |
| 657 | cpu->cpu = cputime.utime; |
| 658 | break; |
| 659 | case CPUCLOCK_SCHED: |
| 660 | cpu->sched = cputime.sum_exec_runtime + task_delta_exec(p); |
| 661 | break; |
| 662 | } |
| 663 | return 0; |
| 664 | } |
| 665 | |
| 666 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 667 | * Guts of sys_timer_settime for CPU timers. |
| 668 | * This is called with the timer locked and interrupts disabled. |
| 669 | * If we return TIMER_RETRY, it's necessary to release the timer's lock |
| 670 | * and try again. (This happens when the timer is in the middle of firing.) |
| 671 | */ |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 672 | static int posix_cpu_timer_set(struct k_itimer *timer, int flags, |
| 673 | struct itimerspec *new, struct itimerspec *old) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 674 | { |
| 675 | struct task_struct *p = timer->it.cpu.task; |
Stanislaw Gruszka | ae1a78e | 2010-03-11 14:04:39 -0800 | [diff] [blame] | 676 | union cpu_time_count old_expires, new_expires, old_incr, val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 677 | int ret; |
| 678 | |
| 679 | if (unlikely(p == NULL)) { |
| 680 | /* |
| 681 | * Timer refers to a dead task's clock. |
| 682 | */ |
| 683 | return -ESRCH; |
| 684 | } |
| 685 | |
| 686 | new_expires = timespec_to_sample(timer->it_clock, &new->it_value); |
| 687 | |
| 688 | read_lock(&tasklist_lock); |
| 689 | /* |
| 690 | * We need the tasklist_lock to protect against reaping that |
Oleg Nesterov | d30fda3 | 2010-05-26 14:43:13 -0700 | [diff] [blame] | 691 | * clears p->sighand. If p has just been reaped, we can no |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 692 | * longer get any information about it at all. |
| 693 | */ |
Oleg Nesterov | d30fda3 | 2010-05-26 14:43:13 -0700 | [diff] [blame] | 694 | if (unlikely(p->sighand == NULL)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 695 | read_unlock(&tasklist_lock); |
| 696 | put_task_struct(p); |
| 697 | timer->it.cpu.task = NULL; |
| 698 | return -ESRCH; |
| 699 | } |
| 700 | |
| 701 | /* |
| 702 | * Disarm any old timer after extracting its expiry time. |
| 703 | */ |
| 704 | BUG_ON(!irqs_disabled()); |
Oleg Nesterov | a69ac4a | 2005-10-24 18:29:58 +0400 | [diff] [blame] | 705 | |
| 706 | ret = 0; |
Stanislaw Gruszka | ae1a78e | 2010-03-11 14:04:39 -0800 | [diff] [blame] | 707 | old_incr = timer->it.cpu.incr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | spin_lock(&p->sighand->siglock); |
| 709 | old_expires = timer->it.cpu.expires; |
Oleg Nesterov | a69ac4a | 2005-10-24 18:29:58 +0400 | [diff] [blame] | 710 | if (unlikely(timer->it.cpu.firing)) { |
| 711 | timer->it.cpu.firing = -1; |
| 712 | ret = TIMER_RETRY; |
| 713 | } else |
| 714 | list_del_init(&timer->it.cpu.entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 715 | |
| 716 | /* |
| 717 | * We need to sample the current value to convert the new |
| 718 | * value from to relative and absolute, and to convert the |
| 719 | * old value from absolute to relative. To set a process |
| 720 | * timer, we need a sample to balance the thread expiry |
| 721 | * times (in arm_timer). With an absolute time, we must |
| 722 | * check if it's already passed. In short, we need a sample. |
| 723 | */ |
| 724 | if (CPUCLOCK_PERTHREAD(timer->it_clock)) { |
| 725 | cpu_clock_sample(timer->it_clock, p, &val); |
| 726 | } else { |
Peter Zijlstra | 3997ad3 | 2009-02-12 15:00:52 +0100 | [diff] [blame] | 727 | cpu_timer_sample_group(timer->it_clock, p, &val); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 728 | } |
| 729 | |
| 730 | if (old) { |
| 731 | if (old_expires.sched == 0) { |
| 732 | old->it_value.tv_sec = 0; |
| 733 | old->it_value.tv_nsec = 0; |
| 734 | } else { |
| 735 | /* |
| 736 | * Update the timer in case it has |
| 737 | * overrun already. If it has, |
| 738 | * we'll report it as having overrun |
| 739 | * and with the next reloaded timer |
| 740 | * already ticking, though we are |
| 741 | * swallowing that pending |
| 742 | * notification here to install the |
| 743 | * new setting. |
| 744 | */ |
| 745 | bump_cpu_timer(timer, val); |
| 746 | if (cpu_time_before(timer->it_clock, val, |
| 747 | timer->it.cpu.expires)) { |
| 748 | old_expires = cpu_time_sub( |
| 749 | timer->it_clock, |
| 750 | timer->it.cpu.expires, val); |
| 751 | sample_to_timespec(timer->it_clock, |
| 752 | old_expires, |
| 753 | &old->it_value); |
| 754 | } else { |
| 755 | old->it_value.tv_nsec = 1; |
| 756 | old->it_value.tv_sec = 0; |
| 757 | } |
| 758 | } |
| 759 | } |
| 760 | |
Oleg Nesterov | a69ac4a | 2005-10-24 18:29:58 +0400 | [diff] [blame] | 761 | if (unlikely(ret)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 762 | /* |
| 763 | * We are colliding with the timer actually firing. |
| 764 | * Punt after filling in the timer's old value, and |
| 765 | * disable this firing since we are already reporting |
| 766 | * it as an overrun (thanks to bump_cpu_timer above). |
| 767 | */ |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 768 | spin_unlock(&p->sighand->siglock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 769 | read_unlock(&tasklist_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 770 | goto out; |
| 771 | } |
| 772 | |
| 773 | if (new_expires.sched != 0 && !(flags & TIMER_ABSTIME)) { |
| 774 | cpu_time_add(timer->it_clock, &new_expires, val); |
| 775 | } |
| 776 | |
| 777 | /* |
| 778 | * Install the new expiry time (or zero). |
| 779 | * For a timer with no notification action, we don't actually |
| 780 | * arm the timer (we'll just fake it for timer_gettime). |
| 781 | */ |
| 782 | timer->it.cpu.expires = new_expires; |
| 783 | if (new_expires.sched != 0 && |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 784 | cpu_time_before(timer->it_clock, val, new_expires)) { |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 785 | arm_timer(timer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 786 | } |
| 787 | |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 788 | spin_unlock(&p->sighand->siglock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 789 | read_unlock(&tasklist_lock); |
| 790 | |
| 791 | /* |
| 792 | * Install the new reload setting, and |
| 793 | * set up the signal and overrun bookkeeping. |
| 794 | */ |
| 795 | timer->it.cpu.incr = timespec_to_sample(timer->it_clock, |
| 796 | &new->it_interval); |
| 797 | |
| 798 | /* |
| 799 | * This acts as a modification timestamp for the timer, |
| 800 | * so any automatic reload attempt will punt on seeing |
| 801 | * that we have reset the timer manually. |
| 802 | */ |
| 803 | timer->it_requeue_pending = (timer->it_requeue_pending + 2) & |
| 804 | ~REQUEUE_PENDING; |
| 805 | timer->it_overrun_last = 0; |
| 806 | timer->it_overrun = -1; |
| 807 | |
| 808 | if (new_expires.sched != 0 && |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 809 | !cpu_time_before(timer->it_clock, val, new_expires)) { |
| 810 | /* |
| 811 | * The designated time already passed, so we notify |
| 812 | * immediately, even if the thread never runs to |
| 813 | * accumulate more time on this clock. |
| 814 | */ |
| 815 | cpu_timer_fire(timer); |
| 816 | } |
| 817 | |
| 818 | ret = 0; |
| 819 | out: |
| 820 | if (old) { |
| 821 | sample_to_timespec(timer->it_clock, |
Stanislaw Gruszka | ae1a78e | 2010-03-11 14:04:39 -0800 | [diff] [blame] | 822 | old_incr, &old->it_interval); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 823 | } |
| 824 | return ret; |
| 825 | } |
| 826 | |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 827 | static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | { |
| 829 | union cpu_time_count now; |
| 830 | struct task_struct *p = timer->it.cpu.task; |
| 831 | int clear_dead; |
| 832 | |
| 833 | /* |
| 834 | * Easy part: convert the reload time. |
| 835 | */ |
| 836 | sample_to_timespec(timer->it_clock, |
| 837 | timer->it.cpu.incr, &itp->it_interval); |
| 838 | |
| 839 | if (timer->it.cpu.expires.sched == 0) { /* Timer not armed at all. */ |
| 840 | itp->it_value.tv_sec = itp->it_value.tv_nsec = 0; |
| 841 | return; |
| 842 | } |
| 843 | |
| 844 | if (unlikely(p == NULL)) { |
| 845 | /* |
| 846 | * This task already died and the timer will never fire. |
| 847 | * In this case, expires is actually the dead value. |
| 848 | */ |
| 849 | dead: |
| 850 | sample_to_timespec(timer->it_clock, timer->it.cpu.expires, |
| 851 | &itp->it_value); |
| 852 | return; |
| 853 | } |
| 854 | |
| 855 | /* |
| 856 | * Sample the clock to take the difference with the expiry time. |
| 857 | */ |
| 858 | if (CPUCLOCK_PERTHREAD(timer->it_clock)) { |
| 859 | cpu_clock_sample(timer->it_clock, p, &now); |
| 860 | clear_dead = p->exit_state; |
| 861 | } else { |
| 862 | read_lock(&tasklist_lock); |
Oleg Nesterov | d30fda3 | 2010-05-26 14:43:13 -0700 | [diff] [blame] | 863 | if (unlikely(p->sighand == NULL)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 864 | /* |
| 865 | * The process has been reaped. |
| 866 | * We can't even collect a sample any more. |
| 867 | * Call the timer disarmed, nothing else to do. |
| 868 | */ |
| 869 | put_task_struct(p); |
| 870 | timer->it.cpu.task = NULL; |
| 871 | timer->it.cpu.expires.sched = 0; |
| 872 | read_unlock(&tasklist_lock); |
| 873 | goto dead; |
| 874 | } else { |
Peter Zijlstra | 3997ad3 | 2009-02-12 15:00:52 +0100 | [diff] [blame] | 875 | cpu_timer_sample_group(timer->it_clock, p, &now); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 876 | clear_dead = (unlikely(p->exit_state) && |
| 877 | thread_group_empty(p)); |
| 878 | } |
| 879 | read_unlock(&tasklist_lock); |
| 880 | } |
| 881 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 882 | if (unlikely(clear_dead)) { |
| 883 | /* |
| 884 | * We've noticed that the thread is dead, but |
| 885 | * not yet reaped. Take this opportunity to |
| 886 | * drop our task ref. |
| 887 | */ |
| 888 | clear_dead_task(timer, now); |
| 889 | goto dead; |
| 890 | } |
| 891 | |
| 892 | if (cpu_time_before(timer->it_clock, now, timer->it.cpu.expires)) { |
| 893 | sample_to_timespec(timer->it_clock, |
| 894 | cpu_time_sub(timer->it_clock, |
| 895 | timer->it.cpu.expires, now), |
| 896 | &itp->it_value); |
| 897 | } else { |
| 898 | /* |
| 899 | * The timer should have expired already, but the firing |
| 900 | * hasn't taken place yet. Say it's just about to expire. |
| 901 | */ |
| 902 | itp->it_value.tv_nsec = 1; |
| 903 | itp->it_value.tv_sec = 0; |
| 904 | } |
| 905 | } |
| 906 | |
| 907 | /* |
| 908 | * Check for any per-thread CPU timers that have fired and move them off |
| 909 | * the tsk->cpu_timers[N] list onto the firing list. Here we update the |
| 910 | * tsk->it_*_expires values to reflect the remaining thread CPU timers. |
| 911 | */ |
| 912 | static void check_thread_timers(struct task_struct *tsk, |
| 913 | struct list_head *firing) |
| 914 | { |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 915 | int maxfire; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 916 | struct list_head *timers = tsk->cpu_timers; |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 917 | struct signal_struct *const sig = tsk->signal; |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 918 | unsigned long soft; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 919 | |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 920 | maxfire = 20; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 921 | tsk->cputime_expires.prof_exp = cputime_zero; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 922 | while (!list_empty(timers)) { |
Pavel Emelianov | b5e6181 | 2007-05-08 00:30:19 -0700 | [diff] [blame] | 923 | struct cpu_timer_list *t = list_first_entry(timers, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 924 | struct cpu_timer_list, |
| 925 | entry); |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 926 | if (!--maxfire || cputime_lt(prof_ticks(tsk), t->expires.cpu)) { |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 927 | tsk->cputime_expires.prof_exp = t->expires.cpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 928 | break; |
| 929 | } |
| 930 | t->firing = 1; |
| 931 | list_move_tail(&t->entry, firing); |
| 932 | } |
| 933 | |
| 934 | ++timers; |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 935 | maxfire = 20; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 936 | tsk->cputime_expires.virt_exp = cputime_zero; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 937 | while (!list_empty(timers)) { |
Pavel Emelianov | b5e6181 | 2007-05-08 00:30:19 -0700 | [diff] [blame] | 938 | struct cpu_timer_list *t = list_first_entry(timers, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 939 | struct cpu_timer_list, |
| 940 | entry); |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 941 | if (!--maxfire || cputime_lt(virt_ticks(tsk), t->expires.cpu)) { |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 942 | tsk->cputime_expires.virt_exp = t->expires.cpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 943 | break; |
| 944 | } |
| 945 | t->firing = 1; |
| 946 | list_move_tail(&t->entry, firing); |
| 947 | } |
| 948 | |
| 949 | ++timers; |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 950 | maxfire = 20; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 951 | tsk->cputime_expires.sched_exp = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 952 | while (!list_empty(timers)) { |
Pavel Emelianov | b5e6181 | 2007-05-08 00:30:19 -0700 | [diff] [blame] | 953 | struct cpu_timer_list *t = list_first_entry(timers, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 954 | struct cpu_timer_list, |
| 955 | entry); |
Ingo Molnar | 41b86e9 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 956 | if (!--maxfire || tsk->se.sum_exec_runtime < t->expires.sched) { |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 957 | tsk->cputime_expires.sched_exp = t->expires.sched; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 958 | break; |
| 959 | } |
| 960 | t->firing = 1; |
| 961 | list_move_tail(&t->entry, firing); |
| 962 | } |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 963 | |
| 964 | /* |
| 965 | * Check for the special case thread timers. |
| 966 | */ |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 967 | soft = ACCESS_ONCE(sig->rlim[RLIMIT_RTTIME].rlim_cur); |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 968 | if (soft != RLIM_INFINITY) { |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 969 | unsigned long hard = |
| 970 | ACCESS_ONCE(sig->rlim[RLIMIT_RTTIME].rlim_max); |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 971 | |
Peter Zijlstra | 5a52dd5 | 2008-01-25 21:08:32 +0100 | [diff] [blame] | 972 | if (hard != RLIM_INFINITY && |
| 973 | tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) { |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 974 | /* |
| 975 | * At the hard limit, we just die. |
| 976 | * No need to calculate anything else now. |
| 977 | */ |
| 978 | __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk); |
| 979 | return; |
| 980 | } |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 981 | if (tsk->rt.timeout > DIV_ROUND_UP(soft, USEC_PER_SEC/HZ)) { |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 982 | /* |
| 983 | * At the soft limit, send a SIGXCPU every second. |
| 984 | */ |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 985 | if (soft < hard) { |
| 986 | soft += USEC_PER_SEC; |
| 987 | sig->rlim[RLIMIT_RTTIME].rlim_cur = soft; |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 988 | } |
Hiroshi Shimamoto | 81d50bb | 2008-05-15 19:42:49 -0700 | [diff] [blame] | 989 | printk(KERN_INFO |
| 990 | "RT Watchdog Timeout: %s[%d]\n", |
| 991 | tsk->comm, task_pid_nr(tsk)); |
Peter Zijlstra | 78f2c7d | 2008-01-25 21:08:27 +0100 | [diff] [blame] | 992 | __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk); |
| 993 | } |
| 994 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 995 | } |
| 996 | |
Stanislaw Gruszka | 15365c1 | 2010-03-11 14:04:31 -0800 | [diff] [blame] | 997 | static void stop_process_timers(struct signal_struct *sig) |
Peter Zijlstra | 3fccfd6 | 2009-02-10 16:37:31 +0100 | [diff] [blame] | 998 | { |
Stanislaw Gruszka | 15365c1 | 2010-03-11 14:04:31 -0800 | [diff] [blame] | 999 | struct thread_group_cputimer *cputimer = &sig->cputimer; |
Peter Zijlstra | 3fccfd6 | 2009-02-10 16:37:31 +0100 | [diff] [blame] | 1000 | unsigned long flags; |
| 1001 | |
Thomas Gleixner | ee30a7b | 2009-07-25 18:56:56 +0200 | [diff] [blame] | 1002 | raw_spin_lock_irqsave(&cputimer->lock, flags); |
Peter Zijlstra | 3fccfd6 | 2009-02-10 16:37:31 +0100 | [diff] [blame] | 1003 | cputimer->running = 0; |
Thomas Gleixner | ee30a7b | 2009-07-25 18:56:56 +0200 | [diff] [blame] | 1004 | raw_spin_unlock_irqrestore(&cputimer->lock, flags); |
Peter Zijlstra | 3fccfd6 | 2009-02-10 16:37:31 +0100 | [diff] [blame] | 1005 | } |
| 1006 | |
Stanislaw Gruszka | 8356b5f | 2009-07-29 12:15:27 +0200 | [diff] [blame] | 1007 | static u32 onecputick; |
| 1008 | |
Stanislaw Gruszka | 42c4ab4 | 2009-07-29 12:15:26 +0200 | [diff] [blame] | 1009 | static void check_cpu_itimer(struct task_struct *tsk, struct cpu_itimer *it, |
| 1010 | cputime_t *expires, cputime_t cur_time, int signo) |
| 1011 | { |
| 1012 | if (cputime_eq(it->expires, cputime_zero)) |
| 1013 | return; |
| 1014 | |
| 1015 | if (cputime_ge(cur_time, it->expires)) { |
Stanislaw Gruszka | 8356b5f | 2009-07-29 12:15:27 +0200 | [diff] [blame] | 1016 | if (!cputime_eq(it->incr, cputime_zero)) { |
| 1017 | it->expires = cputime_add(it->expires, it->incr); |
| 1018 | it->error += it->incr_error; |
| 1019 | if (it->error >= onecputick) { |
| 1020 | it->expires = cputime_sub(it->expires, |
Stanislaw Gruszka | a42548a | 2009-07-29 12:15:29 +0200 | [diff] [blame] | 1021 | cputime_one_jiffy); |
Stanislaw Gruszka | 8356b5f | 2009-07-29 12:15:27 +0200 | [diff] [blame] | 1022 | it->error -= onecputick; |
| 1023 | } |
Xiao Guangrong | 3f0a525 | 2009-08-10 10:52:30 +0800 | [diff] [blame] | 1024 | } else { |
Stanislaw Gruszka | 8356b5f | 2009-07-29 12:15:27 +0200 | [diff] [blame] | 1025 | it->expires = cputime_zero; |
Xiao Guangrong | 3f0a525 | 2009-08-10 10:52:30 +0800 | [diff] [blame] | 1026 | } |
Stanislaw Gruszka | 42c4ab4 | 2009-07-29 12:15:26 +0200 | [diff] [blame] | 1027 | |
Xiao Guangrong | 3f0a525 | 2009-08-10 10:52:30 +0800 | [diff] [blame] | 1028 | trace_itimer_expire(signo == SIGPROF ? |
| 1029 | ITIMER_PROF : ITIMER_VIRTUAL, |
| 1030 | tsk->signal->leader_pid, cur_time); |
Stanislaw Gruszka | 42c4ab4 | 2009-07-29 12:15:26 +0200 | [diff] [blame] | 1031 | __group_send_sig_info(signo, SEND_SIG_PRIV, tsk); |
| 1032 | } |
| 1033 | |
| 1034 | if (!cputime_eq(it->expires, cputime_zero) && |
| 1035 | (cputime_eq(*expires, cputime_zero) || |
| 1036 | cputime_lt(it->expires, *expires))) { |
| 1037 | *expires = it->expires; |
| 1038 | } |
| 1039 | } |
| 1040 | |
Stanislaw Gruszka | 29f87b7 | 2010-04-27 14:12:15 -0700 | [diff] [blame] | 1041 | /** |
| 1042 | * task_cputime_zero - Check a task_cputime struct for all zero fields. |
| 1043 | * |
| 1044 | * @cputime: The struct to compare. |
| 1045 | * |
| 1046 | * Checks @cputime to see if all fields are zero. Returns true if all fields |
| 1047 | * are zero, false if any field is nonzero. |
| 1048 | */ |
| 1049 | static inline int task_cputime_zero(const struct task_cputime *cputime) |
| 1050 | { |
| 1051 | if (cputime_eq(cputime->utime, cputime_zero) && |
| 1052 | cputime_eq(cputime->stime, cputime_zero) && |
| 1053 | cputime->sum_exec_runtime == 0) |
| 1054 | return 1; |
| 1055 | return 0; |
| 1056 | } |
| 1057 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1058 | /* |
| 1059 | * Check for any per-thread CPU timers that have fired and move them |
| 1060 | * off the tsk->*_timers list onto the firing list. Per-thread timers |
| 1061 | * have already been taken off. |
| 1062 | */ |
| 1063 | static void check_process_timers(struct task_struct *tsk, |
| 1064 | struct list_head *firing) |
| 1065 | { |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 1066 | int maxfire; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1067 | struct signal_struct *const sig = tsk->signal; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1068 | cputime_t utime, ptime, virt_expires, prof_expires; |
Ingo Molnar | 41b86e9 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 1069 | unsigned long long sum_sched_runtime, sched_expires; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1070 | struct list_head *timers = sig->cpu_timers; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1071 | struct task_cputime cputime; |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 1072 | unsigned long soft; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1073 | |
| 1074 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1075 | * Collect the current process totals. |
| 1076 | */ |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 1077 | thread_group_cputimer(tsk, &cputime); |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1078 | utime = cputime.utime; |
| 1079 | ptime = cputime_add(utime, cputime.stime); |
| 1080 | sum_sched_runtime = cputime.sum_exec_runtime; |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 1081 | maxfire = 20; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1082 | prof_expires = cputime_zero; |
| 1083 | while (!list_empty(timers)) { |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1084 | struct cpu_timer_list *tl = list_first_entry(timers, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1085 | struct cpu_timer_list, |
| 1086 | entry); |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1087 | if (!--maxfire || cputime_lt(ptime, tl->expires.cpu)) { |
| 1088 | prof_expires = tl->expires.cpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1089 | break; |
| 1090 | } |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1091 | tl->firing = 1; |
| 1092 | list_move_tail(&tl->entry, firing); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1093 | } |
| 1094 | |
| 1095 | ++timers; |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 1096 | maxfire = 20; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1097 | virt_expires = cputime_zero; |
| 1098 | while (!list_empty(timers)) { |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1099 | struct cpu_timer_list *tl = list_first_entry(timers, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1100 | struct cpu_timer_list, |
| 1101 | entry); |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1102 | if (!--maxfire || cputime_lt(utime, tl->expires.cpu)) { |
| 1103 | virt_expires = tl->expires.cpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1104 | break; |
| 1105 | } |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1106 | tl->firing = 1; |
| 1107 | list_move_tail(&tl->entry, firing); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1108 | } |
| 1109 | |
| 1110 | ++timers; |
Linus Torvalds | e80eda9 | 2005-10-23 10:02:50 -0700 | [diff] [blame] | 1111 | maxfire = 20; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1112 | sched_expires = 0; |
| 1113 | while (!list_empty(timers)) { |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1114 | struct cpu_timer_list *tl = list_first_entry(timers, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1115 | struct cpu_timer_list, |
| 1116 | entry); |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1117 | if (!--maxfire || sum_sched_runtime < tl->expires.sched) { |
| 1118 | sched_expires = tl->expires.sched; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1119 | break; |
| 1120 | } |
WANG Cong | ee7dd20 | 2008-04-04 20:54:10 +0200 | [diff] [blame] | 1121 | tl->firing = 1; |
| 1122 | list_move_tail(&tl->entry, firing); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1123 | } |
| 1124 | |
| 1125 | /* |
| 1126 | * Check for the special case process timers. |
| 1127 | */ |
Stanislaw Gruszka | 42c4ab4 | 2009-07-29 12:15:26 +0200 | [diff] [blame] | 1128 | check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF], &prof_expires, ptime, |
| 1129 | SIGPROF); |
| 1130 | check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime, |
| 1131 | SIGVTALRM); |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 1132 | soft = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 1133 | if (soft != RLIM_INFINITY) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1134 | unsigned long psecs = cputime_to_secs(ptime); |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 1135 | unsigned long hard = |
| 1136 | ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_max); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1137 | cputime_t x; |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 1138 | if (psecs >= hard) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1139 | /* |
| 1140 | * At the hard limit, we just die. |
| 1141 | * No need to calculate anything else now. |
| 1142 | */ |
| 1143 | __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk); |
| 1144 | return; |
| 1145 | } |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 1146 | if (psecs >= soft) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1147 | /* |
| 1148 | * At the soft limit, send a SIGXCPU every second. |
| 1149 | */ |
| 1150 | __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk); |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 1151 | if (soft < hard) { |
| 1152 | soft++; |
| 1153 | sig->rlim[RLIMIT_CPU].rlim_cur = soft; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1154 | } |
| 1155 | } |
Jiri Slaby | d4bb5274 | 2010-03-05 13:42:53 -0800 | [diff] [blame] | 1156 | x = secs_to_cputime(soft); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1157 | if (cputime_eq(prof_expires, cputime_zero) || |
| 1158 | cputime_lt(x, prof_expires)) { |
| 1159 | prof_expires = x; |
| 1160 | } |
| 1161 | } |
| 1162 | |
Stanislaw Gruszka | 29f87b7 | 2010-04-27 14:12:15 -0700 | [diff] [blame] | 1163 | sig->cputime_expires.prof_exp = prof_expires; |
| 1164 | sig->cputime_expires.virt_exp = virt_expires; |
| 1165 | sig->cputime_expires.sched_exp = sched_expires; |
| 1166 | if (task_cputime_zero(&sig->cputime_expires)) |
| 1167 | stop_process_timers(sig); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1168 | } |
| 1169 | |
| 1170 | /* |
| 1171 | * This is called from the signal code (via do_schedule_next_timer) |
| 1172 | * when the last timer signal was delivered and we have to reload the timer. |
| 1173 | */ |
| 1174 | void posix_cpu_timer_schedule(struct k_itimer *timer) |
| 1175 | { |
| 1176 | struct task_struct *p = timer->it.cpu.task; |
| 1177 | union cpu_time_count now; |
| 1178 | |
| 1179 | if (unlikely(p == NULL)) |
| 1180 | /* |
| 1181 | * The task was cleaned up already, no future firings. |
| 1182 | */ |
Roland McGrath | 708f430 | 2005-10-30 15:03:13 -0800 | [diff] [blame] | 1183 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1184 | |
| 1185 | /* |
| 1186 | * Fetch the current sample and update the timer's expiry time. |
| 1187 | */ |
| 1188 | if (CPUCLOCK_PERTHREAD(timer->it_clock)) { |
| 1189 | cpu_clock_sample(timer->it_clock, p, &now); |
| 1190 | bump_cpu_timer(timer, now); |
| 1191 | if (unlikely(p->exit_state)) { |
| 1192 | clear_dead_task(timer, now); |
Roland McGrath | 708f430 | 2005-10-30 15:03:13 -0800 | [diff] [blame] | 1193 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1194 | } |
| 1195 | read_lock(&tasklist_lock); /* arm_timer needs it. */ |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 1196 | spin_lock(&p->sighand->siglock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1197 | } else { |
| 1198 | read_lock(&tasklist_lock); |
Oleg Nesterov | d30fda3 | 2010-05-26 14:43:13 -0700 | [diff] [blame] | 1199 | if (unlikely(p->sighand == NULL)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1200 | /* |
| 1201 | * The process has been reaped. |
| 1202 | * We can't even collect a sample any more. |
| 1203 | */ |
| 1204 | put_task_struct(p); |
| 1205 | timer->it.cpu.task = p = NULL; |
| 1206 | timer->it.cpu.expires.sched = 0; |
Roland McGrath | 708f430 | 2005-10-30 15:03:13 -0800 | [diff] [blame] | 1207 | goto out_unlock; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1208 | } else if (unlikely(p->exit_state) && thread_group_empty(p)) { |
| 1209 | /* |
| 1210 | * We've noticed that the thread is dead, but |
| 1211 | * not yet reaped. Take this opportunity to |
| 1212 | * drop our task ref. |
| 1213 | */ |
| 1214 | clear_dead_task(timer, now); |
Roland McGrath | 708f430 | 2005-10-30 15:03:13 -0800 | [diff] [blame] | 1215 | goto out_unlock; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1216 | } |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 1217 | spin_lock(&p->sighand->siglock); |
Peter Zijlstra | 3997ad3 | 2009-02-12 15:00:52 +0100 | [diff] [blame] | 1218 | cpu_timer_sample_group(timer->it_clock, p, &now); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1219 | bump_cpu_timer(timer, now); |
| 1220 | /* Leave the tasklist_lock locked for the call below. */ |
| 1221 | } |
| 1222 | |
| 1223 | /* |
| 1224 | * Now re-arm for the new expiry time. |
| 1225 | */ |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 1226 | BUG_ON(!irqs_disabled()); |
Stanislaw Gruszka | 5eb9aa6 | 2010-03-11 14:04:38 -0800 | [diff] [blame] | 1227 | arm_timer(timer); |
Stanislaw Gruszka | c287393 | 2010-03-11 14:04:42 -0800 | [diff] [blame] | 1228 | spin_unlock(&p->sighand->siglock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1229 | |
Roland McGrath | 708f430 | 2005-10-30 15:03:13 -0800 | [diff] [blame] | 1230 | out_unlock: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1231 | read_unlock(&tasklist_lock); |
Roland McGrath | 708f430 | 2005-10-30 15:03:13 -0800 | [diff] [blame] | 1232 | |
| 1233 | out: |
| 1234 | timer->it_overrun_last = timer->it_overrun; |
| 1235 | timer->it_overrun = -1; |
| 1236 | ++timer->it_requeue_pending; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1237 | } |
| 1238 | |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1239 | /** |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1240 | * task_cputime_expired - Compare two task_cputime entities. |
| 1241 | * |
| 1242 | * @sample: The task_cputime structure to be checked for expiration. |
| 1243 | * @expires: Expiration times, against which @sample will be checked. |
| 1244 | * |
| 1245 | * Checks @sample against @expires to see if any field of @sample has expired. |
| 1246 | * Returns true if any field of the former is greater than the corresponding |
| 1247 | * field of the latter if the latter field is set. Otherwise returns false. |
| 1248 | */ |
| 1249 | static inline int task_cputime_expired(const struct task_cputime *sample, |
| 1250 | const struct task_cputime *expires) |
| 1251 | { |
| 1252 | if (!cputime_eq(expires->utime, cputime_zero) && |
| 1253 | cputime_ge(sample->utime, expires->utime)) |
| 1254 | return 1; |
| 1255 | if (!cputime_eq(expires->stime, cputime_zero) && |
| 1256 | cputime_ge(cputime_add(sample->utime, sample->stime), |
| 1257 | expires->stime)) |
| 1258 | return 1; |
| 1259 | if (expires->sum_exec_runtime != 0 && |
| 1260 | sample->sum_exec_runtime >= expires->sum_exec_runtime) |
| 1261 | return 1; |
| 1262 | return 0; |
| 1263 | } |
| 1264 | |
| 1265 | /** |
| 1266 | * fastpath_timer_check - POSIX CPU timers fast path. |
| 1267 | * |
| 1268 | * @tsk: The task (thread) being checked. |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1269 | * |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1270 | * Check the task and thread group timers. If both are zero (there are no |
| 1271 | * timers set) return false. Otherwise snapshot the task and thread group |
| 1272 | * timers and compare them with the corresponding expiration times. Return |
| 1273 | * true if a timer has expired, else return false. |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1274 | */ |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1275 | static inline int fastpath_timer_check(struct task_struct *tsk) |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1276 | { |
Oleg Nesterov | ad133ba | 2008-11-17 15:39:47 +0100 | [diff] [blame] | 1277 | struct signal_struct *sig; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1278 | |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1279 | if (!task_cputime_zero(&tsk->cputime_expires)) { |
| 1280 | struct task_cputime task_sample = { |
| 1281 | .utime = tsk->utime, |
| 1282 | .stime = tsk->stime, |
| 1283 | .sum_exec_runtime = tsk->se.sum_exec_runtime |
| 1284 | }; |
| 1285 | |
| 1286 | if (task_cputime_expired(&task_sample, &tsk->cputime_expires)) |
| 1287 | return 1; |
| 1288 | } |
Oleg Nesterov | ad133ba | 2008-11-17 15:39:47 +0100 | [diff] [blame] | 1289 | |
| 1290 | sig = tsk->signal; |
Stanislaw Gruszka | 29f87b7 | 2010-04-27 14:12:15 -0700 | [diff] [blame] | 1291 | if (sig->cputimer.running) { |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1292 | struct task_cputime group_sample; |
| 1293 | |
Thomas Gleixner | ee30a7b | 2009-07-25 18:56:56 +0200 | [diff] [blame] | 1294 | raw_spin_lock(&sig->cputimer.lock); |
Oleg Nesterov | 8d1f431 | 2010-06-11 20:04:46 +0200 | [diff] [blame] | 1295 | group_sample = sig->cputimer.cputime; |
Thomas Gleixner | ee30a7b | 2009-07-25 18:56:56 +0200 | [diff] [blame] | 1296 | raw_spin_unlock(&sig->cputimer.lock); |
Oleg Nesterov | 8d1f431 | 2010-06-11 20:04:46 +0200 | [diff] [blame] | 1297 | |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1298 | if (task_cputime_expired(&group_sample, &sig->cputime_expires)) |
| 1299 | return 1; |
| 1300 | } |
Oleg Nesterov | 37bebc7 | 2009-03-23 20:34:11 +0100 | [diff] [blame] | 1301 | |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1302 | return 0; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1303 | } |
| 1304 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1305 | /* |
| 1306 | * This is called from the timer interrupt handler. The irq handler has |
| 1307 | * already updated our counts. We need to check if any timers fire now. |
| 1308 | * Interrupts are disabled. |
| 1309 | */ |
| 1310 | void run_posix_cpu_timers(struct task_struct *tsk) |
| 1311 | { |
| 1312 | LIST_HEAD(firing); |
| 1313 | struct k_itimer *timer, *next; |
Oleg Nesterov | 0bdd2ed | 2010-06-11 01:10:18 +0200 | [diff] [blame] | 1314 | unsigned long flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1315 | |
| 1316 | BUG_ON(!irqs_disabled()); |
| 1317 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1318 | /* |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1319 | * The fast path checks that there are no expired thread or thread |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1320 | * group timers. If that's so, just return. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1321 | */ |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1322 | if (!fastpath_timer_check(tsk)) |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1323 | return; |
Ingo Molnar | 5ce73a4 | 2008-09-14 17:11:46 +0200 | [diff] [blame] | 1324 | |
Oleg Nesterov | 0bdd2ed | 2010-06-11 01:10:18 +0200 | [diff] [blame] | 1325 | if (!lock_task_sighand(tsk, &flags)) |
| 1326 | return; |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1327 | /* |
| 1328 | * Here we take off tsk->signal->cpu_timers[N] and |
| 1329 | * tsk->cpu_timers[N] all the timers that are firing, and |
| 1330 | * put them on the firing list. |
| 1331 | */ |
| 1332 | check_thread_timers(tsk, &firing); |
Stanislaw Gruszka | 29f87b7 | 2010-04-27 14:12:15 -0700 | [diff] [blame] | 1333 | /* |
| 1334 | * If there are any active process wide timers (POSIX 1.b, itimers, |
| 1335 | * RLIMIT_CPU) cputimer must be running. |
| 1336 | */ |
| 1337 | if (tsk->signal->cputimer.running) |
| 1338 | check_process_timers(tsk, &firing); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1339 | |
Frank Mayhar | bb34d92 | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1340 | /* |
| 1341 | * We must release these locks before taking any timer's lock. |
| 1342 | * There is a potential race with timer deletion here, as the |
| 1343 | * siglock now protects our private firing list. We have set |
| 1344 | * the firing flag in each timer, so that a deletion attempt |
| 1345 | * that gets the timer lock before we do will give it up and |
| 1346 | * spin until we've taken care of that timer below. |
| 1347 | */ |
Oleg Nesterov | 0bdd2ed | 2010-06-11 01:10:18 +0200 | [diff] [blame] | 1348 | unlock_task_sighand(tsk, &flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1349 | |
| 1350 | /* |
| 1351 | * Now that all the timers on our list have the firing flag, |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 1352 | * no one will touch their list entries but us. We'll take |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1353 | * each timer's lock before clearing its firing flag, so no |
| 1354 | * timer call will interfere. |
| 1355 | */ |
| 1356 | list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) { |
H Hartley Sweeten | 6e85c5b | 2009-04-29 19:14:32 -0400 | [diff] [blame] | 1357 | int cpu_firing; |
| 1358 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1359 | spin_lock(&timer->it_lock); |
| 1360 | list_del_init(&timer->it.cpu.entry); |
H Hartley Sweeten | 6e85c5b | 2009-04-29 19:14:32 -0400 | [diff] [blame] | 1361 | cpu_firing = timer->it.cpu.firing; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1362 | timer->it.cpu.firing = 0; |
| 1363 | /* |
| 1364 | * The firing flag is -1 if we collided with a reset |
| 1365 | * of the timer, which already reported this |
| 1366 | * almost-firing as an overrun. So don't generate an event. |
| 1367 | */ |
H Hartley Sweeten | 6e85c5b | 2009-04-29 19:14:32 -0400 | [diff] [blame] | 1368 | if (likely(cpu_firing >= 0)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1369 | cpu_timer_fire(timer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1370 | spin_unlock(&timer->it_lock); |
| 1371 | } |
| 1372 | } |
| 1373 | |
| 1374 | /* |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1375 | * Set one of the process-wide special case CPU timers or RLIMIT_CPU. |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1376 | * The tsk->sighand->siglock must be held by the caller. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1377 | */ |
| 1378 | void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx, |
| 1379 | cputime_t *newval, cputime_t *oldval) |
| 1380 | { |
| 1381 | union cpu_time_count now; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1382 | |
| 1383 | BUG_ON(clock_idx == CPUCLOCK_SCHED); |
Peter Zijlstra | 4cd4c1b | 2009-02-05 12:24:16 +0100 | [diff] [blame] | 1384 | cpu_timer_sample_group(clock_idx, tsk, &now); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1385 | |
| 1386 | if (oldval) { |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1387 | /* |
| 1388 | * We are setting itimer. The *oldval is absolute and we update |
| 1389 | * it to be relative, *newval argument is relative and we update |
| 1390 | * it to be absolute. |
| 1391 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1392 | if (!cputime_eq(*oldval, cputime_zero)) { |
| 1393 | if (cputime_le(*oldval, now.cpu)) { |
| 1394 | /* Just about to fire. */ |
Stanislaw Gruszka | a42548a | 2009-07-29 12:15:29 +0200 | [diff] [blame] | 1395 | *oldval = cputime_one_jiffy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1396 | } else { |
| 1397 | *oldval = cputime_sub(*oldval, now.cpu); |
| 1398 | } |
| 1399 | } |
| 1400 | |
| 1401 | if (cputime_eq(*newval, cputime_zero)) |
| 1402 | return; |
| 1403 | *newval = cputime_add(*newval, now.cpu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1404 | } |
| 1405 | |
| 1406 | /* |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1407 | * Update expiration cache if we are the earliest timer, or eventually |
| 1408 | * RLIMIT_CPU limit is earlier than prof_exp cpu timer expire. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1409 | */ |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1410 | switch (clock_idx) { |
| 1411 | case CPUCLOCK_PROF: |
| 1412 | if (expires_gt(tsk->signal->cputime_expires.prof_exp, *newval)) |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1413 | tsk->signal->cputime_expires.prof_exp = *newval; |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1414 | break; |
| 1415 | case CPUCLOCK_VIRT: |
| 1416 | if (expires_gt(tsk->signal->cputime_expires.virt_exp, *newval)) |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1417 | tsk->signal->cputime_expires.virt_exp = *newval; |
Stanislaw Gruszka | f55db60 | 2010-03-11 14:04:37 -0800 | [diff] [blame] | 1418 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1419 | } |
| 1420 | } |
| 1421 | |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1422 | static int do_cpu_nanosleep(const clockid_t which_clock, int flags, |
| 1423 | struct timespec *rqtp, struct itimerspec *it) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1424 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1425 | struct k_itimer timer; |
| 1426 | int error; |
| 1427 | |
| 1428 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1429 | * Set up a temporary timer and then wait for it to go off. |
| 1430 | */ |
| 1431 | memset(&timer, 0, sizeof timer); |
| 1432 | spin_lock_init(&timer.it_lock); |
| 1433 | timer.it_clock = which_clock; |
| 1434 | timer.it_overrun = -1; |
| 1435 | error = posix_cpu_timer_create(&timer); |
| 1436 | timer.it_process = current; |
| 1437 | if (!error) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1438 | static struct itimerspec zero_it; |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1439 | |
| 1440 | memset(it, 0, sizeof *it); |
| 1441 | it->it_value = *rqtp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1442 | |
| 1443 | spin_lock_irq(&timer.it_lock); |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1444 | error = posix_cpu_timer_set(&timer, flags, it, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1445 | if (error) { |
| 1446 | spin_unlock_irq(&timer.it_lock); |
| 1447 | return error; |
| 1448 | } |
| 1449 | |
| 1450 | while (!signal_pending(current)) { |
| 1451 | if (timer.it.cpu.expires.sched == 0) { |
| 1452 | /* |
| 1453 | * Our timer fired and was reset. |
| 1454 | */ |
| 1455 | spin_unlock_irq(&timer.it_lock); |
| 1456 | return 0; |
| 1457 | } |
| 1458 | |
| 1459 | /* |
| 1460 | * Block until cpu_timer_fire (or a signal) wakes us. |
| 1461 | */ |
| 1462 | __set_current_state(TASK_INTERRUPTIBLE); |
| 1463 | spin_unlock_irq(&timer.it_lock); |
| 1464 | schedule(); |
| 1465 | spin_lock_irq(&timer.it_lock); |
| 1466 | } |
| 1467 | |
| 1468 | /* |
| 1469 | * We were interrupted by a signal. |
| 1470 | */ |
| 1471 | sample_to_timespec(which_clock, timer.it.cpu.expires, rqtp); |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1472 | posix_cpu_timer_set(&timer, 0, &zero_it, it); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1473 | spin_unlock_irq(&timer.it_lock); |
| 1474 | |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1475 | if ((it->it_value.tv_sec | it->it_value.tv_nsec) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1476 | /* |
| 1477 | * It actually did fire already. |
| 1478 | */ |
| 1479 | return 0; |
| 1480 | } |
| 1481 | |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1482 | error = -ERESTART_RESTARTBLOCK; |
| 1483 | } |
| 1484 | |
| 1485 | return error; |
| 1486 | } |
| 1487 | |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 1488 | static long posix_cpu_nsleep_restart(struct restart_block *restart_block); |
| 1489 | |
| 1490 | static int posix_cpu_nsleep(const clockid_t which_clock, int flags, |
| 1491 | struct timespec *rqtp, struct timespec __user *rmtp) |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1492 | { |
| 1493 | struct restart_block *restart_block = |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1494 | ¤t_thread_info()->restart_block; |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1495 | struct itimerspec it; |
| 1496 | int error; |
| 1497 | |
| 1498 | /* |
| 1499 | * Diagnose required errors first. |
| 1500 | */ |
| 1501 | if (CPUCLOCK_PERTHREAD(which_clock) && |
| 1502 | (CPUCLOCK_PID(which_clock) == 0 || |
| 1503 | CPUCLOCK_PID(which_clock) == current->pid)) |
| 1504 | return -EINVAL; |
| 1505 | |
| 1506 | error = do_cpu_nanosleep(which_clock, flags, rqtp, &it); |
| 1507 | |
| 1508 | if (error == -ERESTART_RESTARTBLOCK) { |
| 1509 | |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1510 | if (flags & TIMER_ABSTIME) |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1511 | return -ERESTARTNOHAND; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1512 | /* |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1513 | * Report back to the user the time still remaining. |
| 1514 | */ |
| 1515 | if (rmtp && copy_to_user(rmtp, &it.it_value, sizeof *rmtp)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1516 | return -EFAULT; |
| 1517 | |
Toyo Abe | 1711ef3 | 2006-09-29 02:00:28 -0700 | [diff] [blame] | 1518 | restart_block->fn = posix_cpu_nsleep_restart; |
Thomas Gleixner | ab8177b | 2011-05-20 13:05:15 +0200 | [diff] [blame] | 1519 | restart_block->nanosleep.clockid = which_clock; |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1520 | restart_block->nanosleep.rmtp = rmtp; |
| 1521 | restart_block->nanosleep.expires = timespec_to_ns(rqtp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1522 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1523 | return error; |
| 1524 | } |
| 1525 | |
Thomas Gleixner | bc2c8ea | 2011-02-01 13:52:12 +0000 | [diff] [blame] | 1526 | static long posix_cpu_nsleep_restart(struct restart_block *restart_block) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1527 | { |
Thomas Gleixner | ab8177b | 2011-05-20 13:05:15 +0200 | [diff] [blame] | 1528 | clockid_t which_clock = restart_block->nanosleep.clockid; |
Thomas Gleixner | 97735f2 | 2006-01-09 20:52:37 -0800 | [diff] [blame] | 1529 | struct timespec t; |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1530 | struct itimerspec it; |
| 1531 | int error; |
Thomas Gleixner | 97735f2 | 2006-01-09 20:52:37 -0800 | [diff] [blame] | 1532 | |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1533 | t = ns_to_timespec(restart_block->nanosleep.expires); |
Thomas Gleixner | 97735f2 | 2006-01-09 20:52:37 -0800 | [diff] [blame] | 1534 | |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1535 | error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it); |
| 1536 | |
| 1537 | if (error == -ERESTART_RESTARTBLOCK) { |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1538 | struct timespec __user *rmtp = restart_block->nanosleep.rmtp; |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1539 | /* |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1540 | * Report back to the user the time still remaining. |
| 1541 | */ |
| 1542 | if (rmtp && copy_to_user(rmtp, &it.it_value, sizeof *rmtp)) |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1543 | return -EFAULT; |
| 1544 | |
Thomas Gleixner | 3751f9f | 2011-02-01 13:51:20 +0000 | [diff] [blame] | 1545 | restart_block->nanosleep.expires = timespec_to_ns(&t); |
Toyo Abe | e4b7655 | 2006-09-29 02:00:29 -0700 | [diff] [blame] | 1546 | } |
| 1547 | return error; |
| 1548 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1549 | } |
| 1550 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1551 | #define PROCESS_CLOCK MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED) |
| 1552 | #define THREAD_CLOCK MAKE_THREAD_CPUCLOCK(0, CPUCLOCK_SCHED) |
| 1553 | |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 1554 | static int process_cpu_clock_getres(const clockid_t which_clock, |
| 1555 | struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1556 | { |
| 1557 | return posix_cpu_clock_getres(PROCESS_CLOCK, tp); |
| 1558 | } |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 1559 | static int process_cpu_clock_get(const clockid_t which_clock, |
| 1560 | struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1561 | { |
| 1562 | return posix_cpu_clock_get(PROCESS_CLOCK, tp); |
| 1563 | } |
| 1564 | static int process_cpu_timer_create(struct k_itimer *timer) |
| 1565 | { |
| 1566 | timer->it_clock = PROCESS_CLOCK; |
| 1567 | return posix_cpu_timer_create(timer); |
| 1568 | } |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 1569 | static int process_cpu_nsleep(const clockid_t which_clock, int flags, |
Thomas Gleixner | 97735f2 | 2006-01-09 20:52:37 -0800 | [diff] [blame] | 1570 | struct timespec *rqtp, |
| 1571 | struct timespec __user *rmtp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1572 | { |
Thomas Gleixner | 97735f2 | 2006-01-09 20:52:37 -0800 | [diff] [blame] | 1573 | return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1574 | } |
Toyo Abe | 1711ef3 | 2006-09-29 02:00:28 -0700 | [diff] [blame] | 1575 | static long process_cpu_nsleep_restart(struct restart_block *restart_block) |
| 1576 | { |
| 1577 | return -EINVAL; |
| 1578 | } |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 1579 | static int thread_cpu_clock_getres(const clockid_t which_clock, |
| 1580 | struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1581 | { |
| 1582 | return posix_cpu_clock_getres(THREAD_CLOCK, tp); |
| 1583 | } |
Thomas Gleixner | a924b04 | 2006-01-09 20:52:27 -0800 | [diff] [blame] | 1584 | static int thread_cpu_clock_get(const clockid_t which_clock, |
| 1585 | struct timespec *tp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1586 | { |
| 1587 | return posix_cpu_clock_get(THREAD_CLOCK, tp); |
| 1588 | } |
| 1589 | static int thread_cpu_timer_create(struct k_itimer *timer) |
| 1590 | { |
| 1591 | timer->it_clock = THREAD_CLOCK; |
| 1592 | return posix_cpu_timer_create(timer); |
| 1593 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1594 | |
Thomas Gleixner | 1976945 | 2011-02-01 13:51:06 +0000 | [diff] [blame] | 1595 | struct k_clock clock_posix_cpu = { |
| 1596 | .clock_getres = posix_cpu_clock_getres, |
| 1597 | .clock_set = posix_cpu_clock_set, |
| 1598 | .clock_get = posix_cpu_clock_get, |
| 1599 | .timer_create = posix_cpu_timer_create, |
| 1600 | .nsleep = posix_cpu_nsleep, |
| 1601 | .nsleep_restart = posix_cpu_nsleep_restart, |
| 1602 | .timer_set = posix_cpu_timer_set, |
| 1603 | .timer_del = posix_cpu_timer_del, |
| 1604 | .timer_get = posix_cpu_timer_get, |
| 1605 | }; |
| 1606 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1607 | static __init int init_posix_cpu_timers(void) |
| 1608 | { |
| 1609 | struct k_clock process = { |
Thomas Gleixner | 2fd1f04 | 2011-02-01 13:51:03 +0000 | [diff] [blame] | 1610 | .clock_getres = process_cpu_clock_getres, |
| 1611 | .clock_get = process_cpu_clock_get, |
Thomas Gleixner | 2fd1f04 | 2011-02-01 13:51:03 +0000 | [diff] [blame] | 1612 | .timer_create = process_cpu_timer_create, |
| 1613 | .nsleep = process_cpu_nsleep, |
| 1614 | .nsleep_restart = process_cpu_nsleep_restart, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1615 | }; |
| 1616 | struct k_clock thread = { |
Thomas Gleixner | 2fd1f04 | 2011-02-01 13:51:03 +0000 | [diff] [blame] | 1617 | .clock_getres = thread_cpu_clock_getres, |
| 1618 | .clock_get = thread_cpu_clock_get, |
Thomas Gleixner | 2fd1f04 | 2011-02-01 13:51:03 +0000 | [diff] [blame] | 1619 | .timer_create = thread_cpu_timer_create, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1620 | }; |
Stanislaw Gruszka | 8356b5f | 2009-07-29 12:15:27 +0200 | [diff] [blame] | 1621 | struct timespec ts; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1622 | |
Thomas Gleixner | 5270873 | 2011-02-02 12:10:09 +0100 | [diff] [blame] | 1623 | posix_timers_register_clock(CLOCK_PROCESS_CPUTIME_ID, &process); |
| 1624 | posix_timers_register_clock(CLOCK_THREAD_CPUTIME_ID, &thread); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1625 | |
Stanislaw Gruszka | a42548a | 2009-07-29 12:15:29 +0200 | [diff] [blame] | 1626 | cputime_to_timespec(cputime_one_jiffy, &ts); |
Stanislaw Gruszka | 8356b5f | 2009-07-29 12:15:27 +0200 | [diff] [blame] | 1627 | onecputick = ts.tv_nsec; |
| 1628 | WARN_ON(ts.tv_sec != 0); |
| 1629 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1630 | return 0; |
| 1631 | } |
| 1632 | __initcall(init_posix_cpu_timers); |