Release 4.15 kernel/time/posix-cpu-timers.c

Directory: kernel/time
// SPDX-License-Identifier: GPL-2.0
/*
 * Implement CPU time clocks for the POSIX clock interface.
 */

#include <linux/sched/signal.h>
#include <linux/sched/cputime.h>
#include <linux/posix-timers.h>
#include <linux/errno.h>
#include <linux/math64.h>
#include <linux/uaccess.h>
#include <linux/kernel_stat.h>
#include <trace/events/timer.h>
#include <linux/tick.h>
#include <linux/workqueue.h>
#include <linux/compat.h>

#include "posix-timers.h"

static void posix_cpu_timer_rearm(struct k_itimer *timer);

/*
 * Called after updating RLIMIT_CPU to run cpu timer and update
 * tsk->signal->cputime_expires expiration cache if necessary. Needs
 * siglock protection since other code may update expiration cache as
 * well.
 */


void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new)
{
	u64 nsecs = rlim_new * NSEC_PER_SEC;

	spin_lock_irq(&task->sighand->siglock);
	set_process_cpu_timer(task, CPUCLOCK_PROF, &nsecs, NULL);
	spin_unlock_irq(&task->sighand->siglock);
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 27 50.94% 1 16.67%
Roland McGrath 11 20.75% 2 33.33%
Jiri Slaby 8 15.09% 1 16.67%
Frédéric Weisbecker 5 9.43% 1 16.67%
Stanislaw Gruszka 2 3.77% 1 16.67%
Total 53 100.00% 6 100.00%



static int check_clock(const clockid_t which_clock)
{
	int error = 0;
	struct task_struct *p;
	const pid_t pid = CPUCLOCK_PID(which_clock);

	if (CPUCLOCK_WHICH(which_clock) >= CPUCLOCK_MAX)
		return -EINVAL;

	if (pid == 0)
		return 0;

	rcu_read_lock();
	p = find_task_by_vpid(pid);
	if (!p || !(CPUCLOCK_PERTHREAD(which_clock) ?
		   same_thread_group(p, current) : has_group_leader_pid(p))) {
		error = -EINVAL;
	}
	rcu_read_unlock();

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 72 72.73% 1 20.00%
Roland McGrath 21 21.21% 2 40.00%
Sergey Senozhatsky 5 5.05% 1 20.00%
Thomas Gleixner 1 1.01% 1 20.00%
Total 99 100.00% 5 100.00%

/*
 * Update expiry time from increment, and increase overrun count,
 * given the current clock sample.
 */


static void bump_cpu_timer(struct k_itimer *timer, u64 now)
{
	int i;
	u64 delta, incr;

	if (timer->it.cpu.incr == 0)
		return;

	if (now < timer->it.cpu.expires)
		return;

	incr = timer->it.cpu.incr;
	delta = now + incr - timer->it.cpu.expires;

	/* Don't use (incr*2 < delta), incr*2 might overflow. */
	for (i = 0; incr < delta - incr; i++)
		incr = incr << 1;

	for (; i >= 0; incr >>= 1, i--) {
		if (delta < incr)
			continue;

		timer->it.cpu.expires += incr;
		timer->it_overrun += 1 << i;
		delta -= incr;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 98 70.50% 1 20.00%
Roland McGrath 24 17.27% 1 20.00%
Martin Schwidefsky 9 6.47% 1 20.00%
Frédéric Weisbecker 8 5.76% 2 40.00%
Total 139 100.00% 5 100.00%

/**
 * task_cputime_zero - Check a task_cputime struct for all zero fields.
 *
 * @cputime:    The struct to compare.
 *
 * Checks @cputime to see if all fields are zero.  Returns true if all fields
 * are zero, false if any field is nonzero.
 */


static inline int task_cputime_zero(const struct task_cputime *cputime)
{
	if (!cputime->utime && !cputime->stime && !cputime->sum_exec_runtime)
		return 1;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Frédéric Weisbecker 36 100.00% 2 100.00%
Total 36 100.00% 2 100.00%



static inline u64 prof_ticks(struct task_struct *p)
{
	u64 utime, stime;

	task_cputime(p, &utime, &stime);

	return utime + stime;
}
Contributors
Person Tokens Prop Commits CommitProp
Frédéric Weisbecker 17 51.52% 2 33.33%
Frank Mayhar 12 36.36% 1 16.67%
Roland McGrath 3 9.09% 2 33.33%
Martin Schwidefsky 1 3.03% 1 16.67%
Total 33 100.00% 6 100.00%



static inline u64 virt_ticks(struct task_struct *p)
{
	u64 utime, stime;

	task_cputime(p, &utime, &stime);

	return utime;
}

Contributors
Person Tokens Prop Commits CommitProp
Frédéric Weisbecker 13 41.94% 2 40.00%
Frank Mayhar 12 38.71% 1 20.00%
Stanislaw Gruszka 4 12.90% 1 20.00%
Roland McGrath 2 6.45% 1 20.00%
Total 31 100.00% 5 100.00%


static int

posix_cpu_clock_getres(const clockid_t which_clock, struct timespec64 *tp)
{
	int error = check_clock(which_clock);
	if (!error) {
		tp->tv_sec = 0;
		tp->tv_nsec = ((NSEC_PER_SEC + HZ - 1) / HZ);
		if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
			/*
                         * If sched_clock is using a cycle counter, we
                         * don't have any idea of its true resolution
                         * exported, but it is much more than 1s/HZ.
                         */
			tp->tv_nsec = 1;
		}
	}
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 47 64.38% 1 16.67%
Roland McGrath 23 31.51% 2 33.33%
Thomas Gleixner 2 2.74% 2 33.33%
Deepa Dinamani 1 1.37% 1 16.67%
Total 73 100.00% 6 100.00%


static int

posix_cpu_clock_set(const clockid_t which_clock, const struct timespec64 *tp)
{
	/*
         * You can never reset a CPU clock, but we check for other errors
         * in the call before failing with EPERM.
         */
	int error = check_clock(which_clock);
	if (error == 0) {
		error = -EPERM;
	}
	return error;
}


Contributors
Person Tokens Prop Commits CommitProp
Roland McGrath 27 65.85% 1 20.00%
Frank Mayhar 11 26.83% 1 20.00%
Thomas Gleixner 2 4.88% 2 40.00%
Deepa Dinamani 1 2.44% 1 20.00%
Total 41 100.00% 5 100.00%

/*
 * Sample a per-thread clock for the given task.
 */


static int cpu_clock_sample(const clockid_t which_clock,
			    struct task_struct *p, u64 *sample)
{
	switch (CPUCLOCK_WHICH(which_clock)) {
	default:
		return -EINVAL;
	case CPUCLOCK_PROF:
		*sample = prof_ticks(p);
		break;
	case CPUCLOCK_VIRT:
		*sample = virt_ticks(p);
		break;
	case CPUCLOCK_SCHED:
		*sample = task_sched_runtime(p);
		break;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 36 50.00% 1 16.67%
Roland McGrath 25 34.72% 1 16.67%
Frédéric Weisbecker 8 11.11% 2 33.33%
Pavel Emelyanov 2 2.78% 1 16.67%
Hidetoshi Seto 1 1.39% 1 16.67%
Total 72 100.00% 6 100.00%

/*
 * Set cputime to sum_cputime if sum_cputime > cputime. Use cmpxchg
 * to avoid race conditions with concurrent updates to cputime.
 */


static inline void __update_gt_cputime(atomic64_t *cputime, u64 sum_cputime)
{
	u64 curr_cputime;
retry:
	curr_cputime = atomic64_read(cputime);
	if (sum_cputime > curr_cputime) {
		if (atomic64_cmpxchg(cputime, curr_cputime, sum_cputime) != curr_cputime)
			goto retry;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jason Low 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%



static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic, struct task_cputime *sum)
{
	__update_gt_cputime(&cputime_atomic->utime, sum->utime);
	__update_gt_cputime(&cputime_atomic->stime, sum->stime);
	__update_gt_cputime(&cputime_atomic->sum_exec_runtime, sum->sum_exec_runtime);
}

Contributors
Person Tokens Prop Commits CommitProp
Jason Low 36 69.23% 2 40.00%
Peter Zijlstra 14 26.92% 1 20.00%
Frédéric Weisbecker 2 3.85% 2 40.00%
Total 52 100.00% 5 100.00%

/* Sample task_cputime_atomic values in "atomic_timers", store results in "times". */


static inline void sample_cputime_atomic(struct task_cputime *times,
					 struct task_cputime_atomic *atomic_times)
{
	times->utime = atomic64_read(&atomic_times->utime);
	times->stime = atomic64_read(&atomic_times->stime);
	times->sum_exec_runtime = atomic64_read(&atomic_times->sum_exec_runtime);
}

Contributors
Person Tokens Prop Commits CommitProp
Jason Low 33 62.26% 2 50.00%
Peter Zijlstra 19 35.85% 1 25.00%
Frédéric Weisbecker 1 1.89% 1 25.00%
Total 53 100.00% 4 100.00%



void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times)
{
	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
	struct task_cputime sum;

	/* Check if cputimer isn't running. This is accessed without locking. */
	if (!READ_ONCE(cputimer->running)) {
		/*
                 * The POSIX timer interface allows for absolute time expiry
                 * values through the TIMER_ABSTIME flag, therefore we have
                 * to synchronize the timer to the clock every time we start it.
                 */
		thread_group_cputime(tsk, &sum);
		update_gt_cputime(&cputimer->cputime_atomic, &sum);

		/*
                 * We're setting cputimer->running without a lock. Ensure
                 * this only gets written to in one operation. We set
                 * running after update_gt_cputime() as a small optimization,
                 * but barriers are not required because update_gt_cputime()
                 * can handle concurrent updates.
                 */
		WRITE_ONCE(cputimer->running, true);
	}
	sample_cputime_atomic(times, &cputimer->cputime_atomic);
}

Contributors
Person Tokens Prop Commits CommitProp
Peter Zijlstra 62 73.81% 2 33.33%
Jason Low 19 22.62% 3 50.00%
Frédéric Weisbecker 3 3.57% 1 16.67%
Total 84 100.00% 6 100.00%

/*
 * Sample a process (thread group) clock for the given group_leader task.
 * Must be called with task sighand lock held for safe while_each_thread()
 * traversal.
 */


static int cpu_clock_sample_group(const clockid_t which_clock,
				  struct task_struct *p,
				  u64 *sample)
{
	struct task_cputime cputime;

	switch (CPUCLOCK_WHICH(which_clock)) {
	default:
		return -EINVAL;
	case CPUCLOCK_PROF:
		thread_group_cputime(p, &cputime);
		*sample = cputime.utime + cputime.stime;
		break;
	case CPUCLOCK_VIRT:
		thread_group_cputime(p, &cputime);
		*sample = cputime.utime;
		break;
	case CPUCLOCK_SCHED:
		thread_group_cputime(p, &cputime);
		*sample = cputime.sum_exec_runtime;
		break;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 39 38.61% 2 22.22%
Roland McGrath 22 21.78% 1 11.11%
Hidetoshi Seto 14 13.86% 1 11.11%
Frédéric Weisbecker 12 11.88% 2 22.22%
Peter Zijlstra 10 9.90% 1 11.11%
Petr Tesarik 3 2.97% 1 11.11%
Martin Schwidefsky 1 0.99% 1 11.11%
Total 101 100.00% 9 100.00%



static int posix_cpu_clock_get_task(struct task_struct *tsk,
				    const clockid_t which_clock,
				    struct timespec64 *tp)
{
	int err = -EINVAL;
	u64 rtn;

	if (CPUCLOCK_PERTHREAD(which_clock)) {
		if (same_thread_group(tsk, current))
			err = cpu_clock_sample(which_clock, tsk, &rtn);
	} else {
		if (tsk == current || thread_group_leader(tsk))
			err = cpu_clock_sample_group(which_clock, tsk, &rtn);
	}

	if (!err)
		*tp = ns_to_timespec64(rtn);

	return err;
}


Contributors
Person Tokens Prop Commits CommitProp
Frédéric Weisbecker 42 41.58% 3 33.33%
Frank Mayhar 36 35.64% 1 11.11%
Roland McGrath 11 10.89% 1 11.11%
Oleg Nesterov 6 5.94% 1 11.11%
Linus Torvalds 3 2.97% 1 11.11%
Deepa Dinamani 2 1.98% 1 11.11%
Thomas Gleixner 1 0.99% 1 11.11%
Total 101 100.00% 9 100.00%



static int posix_cpu_clock_get(const clockid_t which_clock, struct timespec64 *tp)
{
	const pid_t pid = CPUCLOCK_PID(which_clock);
	int err = -EINVAL;

	if (pid == 0) {
		/*
                 * Special case constant value for our own clocks.
                 * We don't have to do any lookup to find ourselves.
                 */
		err = posix_cpu_clock_get_task(current, which_clock, tp);
	} else {
		/*
                 * Find the given PID, and validate that the caller
                 * should be able to see it.
                 */
		struct task_struct *p;
		rcu_read_lock();
		p = find_task_by_vpid(pid);
		if (p)
			err = posix_cpu_clock_get_task(p, which_clock, tp);
		rcu_read_unlock();
	}

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Frédéric Weisbecker 55 61.11% 1 16.67%
Frank Mayhar 25 27.78% 1 16.67%
Roland McGrath 6 6.67% 1 16.67%
Linus Torvalds 2 2.22% 1 16.67%
Oleg Nesterov 1 1.11% 1 16.67%
Deepa Dinamani 1 1.11% 1 16.67%
Total 90 100.00% 6 100.00%

/*
 * Validate the clockid_t for a new CPU-clock timer, and initialize the timer.
 * This is called from sys_timer_create() and do_cpu_nanosleep() with the
 * new timer already all-zeros initialized.
 */


static int posix_cpu_timer_create(struct k_itimer *new_timer)
{
	int ret = 0;
	const pid_t pid = CPUCLOCK_PID(new_timer->it_clock);
	struct task_struct *p;

	if (CPUCLOCK_WHICH(new_timer->it_clock) >= CPUCLOCK_MAX)
		return -EINVAL;

	new_timer->kclock = &clock_posix_cpu;

	INIT_LIST_HEAD(&new_timer->it.cpu.entry);

	rcu_read_lock();
	if (CPUCLOCK_PERTHREAD(new_timer->it_clock)) {
		if (pid == 0) {
			p = current;
		} else {
			p = find_task_by_vpid(pid);
			if (p && !same_thread_group(p, current))
				p = NULL;
		}
	} else {
		if (pid == 0) {
			p = current->group_leader;
		} else {
			p = find_task_by_vpid(pid);
			if (p && !has_group_leader_pid(p))
				p = NULL;
		}
	}
	new_timer->it.cpu.task = p;
	if (p) {
		get_task_struct(p);
	} else {
		ret = -EINVAL;
	}
	rcu_read_unlock();

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 115 59.28% 1 20.00%
Roland McGrath 66 34.02% 1 20.00%
Thomas Gleixner 8 4.12% 2 40.00%
Sergey Senozhatsky 5 2.58% 1 20.00%
Total 194 100.00% 5 100.00%

/*
 * Clean up a CPU-clock timer that is about to be destroyed.
 * This is called from timer deletion with the timer already locked.
 * If we return TIMER_RETRY, it's necessary to release the timer's lock
 * and try again.  (This happens when the timer is in the middle of firing.)
 */


static int posix_cpu_timer_del(struct k_itimer *timer)
{
	int ret = 0;
	unsigned long flags;
	struct sighand_struct *sighand;
	struct task_struct *p = timer->it.cpu.task;

	WARN_ON_ONCE(p == NULL);

	/*
         * Protect against sighand release/switch in exit/exec and process/
         * thread timer list entry concurrent read/writes.
         */
	sighand = lock_task_sighand(p, &flags);
	if (unlikely(sighand == NULL)) {
		/*
                 * We raced with the reaping of the task.
                 * The deletion should have cleared us off the list.
                 */
		WARN_ON_ONCE(!list_empty(&timer->it.cpu.entry));
	} else {
		if (timer->it.cpu.firing)
			ret = TIMER_RETRY;
		else
			list_del(&timer->it.cpu.entry);

		unlock_task_sighand(p, &flags);
	}

	if (!ret)
		put_task_struct(p);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 86 63.70% 1 12.50%
Frédéric Weisbecker 30 22.22% 3 37.50%
Roland McGrath 16 11.85% 1 12.50%
Ingo Molnar 1 0.74% 1 12.50%
Thomas Gleixner 1 0.74% 1 12.50%
Oleg Nesterov 1 0.74% 1 12.50%
Total 135 100.00% 8 100.00%



static void cleanup_timers_list(struct list_head *head)
{
	struct cpu_timer_list *timer, *next;

	list_for_each_entry_safe(timer, next, head, entry)
		list_del_init(&timer->entry);
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 19 51.35% 1 20.00%
Roland McGrath 14 37.84% 2 40.00%
Martin Schwidefsky 2 5.41% 1 20.00%
Frédéric Weisbecker 2 5.41% 1 20.00%
Total 37 100.00% 5 100.00%

/*
 * Clean out CPU timers still ticking when a thread exited.  The task
 * pointer is cleared, and the expiry time is replaced with the residual
 * time for later timer_gettime calls to return.
 * This must be called with the siglock held.
 */


static void cleanup_timers(struct list_head *head)
{
	cleanup_timers_list(head);
	cleanup_timers_list(++head);
	cleanup_timers_list(++head);
}

Contributors
Person Tokens Prop Commits CommitProp
Frédéric Weisbecker 19 67.86% 2 50.00%
Roland McGrath 5 17.86% 1 25.00%
Frank Mayhar 4 14.29% 1 25.00%
Total 28 100.00% 4 100.00%

/*
 * These are both called with the siglock held, when the current thread
 * is being reaped.  When the final (leader) thread in the group is reaped,
 * posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit.
 */


void posix_cpu_timers_exit(struct task_struct *tsk)
{
	cleanup_timers(tsk->cpu_timers);
}
Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 13 76.47% 1 50.00%
Roland McGrath 4 23.53% 1 50.00%
Total 17 100.00% 2 100.00%



void posix_cpu_timers_exit_group(struct task_struct *tsk)
{
	cleanup_timers(tsk->signal->cpu_timers);
}

Contributors
Person Tokens Prop Commits CommitProp
Frank Mayhar 18 94.74% 1 50.00%
Roland McGrath 1 5.26% 1 50.00%
Total 19 100.00% 2 100.00%



static inline int expires_gt(u64 expires, u64 new_exp)
{
	return expires == 0 || expires > new_exp;
}

Contributors
Person Tokens Prop Commits CommitProp
Stanislaw Gruszka 17 77.27% 1 33.33%
Martin Schwidefsky 3 13.64% 1 33.33%
Frédéric Weisbecker 2 9.09% 1 33.33%
Total 22 100.00% 3 100.00%

/*
 * Insert the timer on the appropriate list before any timers that
 * expire later.  This must be called with the sighand lock held.
 */


static void arm_timer(struct k_itimer *timer)
{
	struct task_struct *p = timer->it.cpu.task;
	struct list_head *head, *listpos;
	struct task_cputime *cputime_expires;
	struct cpu_timer_list *const nt = &timer->it.cpu;
	struct cpu_timer_list *next;

	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
		head = p->cpu_timers;
		cputime_expires = &p->cputime_expires;
	} else {
		head = p->signal->cpu_timers;
		cputime_expires = &p->signal->cputime_expires;
	}
	head += CPUCLOCK_WHICH(timer->it_clock);

	listpos = head;
	list_for_each_entry(next, head, entry) {
		if (nt->expires < next->expires)
			break;
		listpos = &next->entry;
	}
	list_add(&nt->entry, listpos);

	if (listpos == head) {
		u64 exp = nt->expires;

		/*
                 * We are the new earliest-expiring POSIX 1.b timer, hence
                 * need to update expiration cache. Take into account that
                 * for process timers we share expiration cache with itimers
                 * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME.
                 */

		switch (CPUCLOCK_WHICH(timer->it_clock)) {
		case CPUCLOCK_PROF:
			if (expires_gt(cputime_expires->prof_exp, exp))
				cputime_expires->prof_exp = exp;
			break;
		case CPUCLOCK_VIRT:
			if (expires_gt(cputime_expires->virt_exp, exp))
				cputime_expires->virt_exp = exp;
			break;
		case CPUCLOCK_SCHED:
			if (expires_gt(cputime_expires->sched_exp, exp))
				cputime_expires->sched_exp = exp;
			break;
		}
		if (CPUCLOCK_PERTHREAD(timer->it_clock))
			tick_dep_set_task(p, TICK_DEP_BIT_POSIX_TIMER);
		else
			tick_dep_set_signal(p->signal, TICK_DEP_BIT_POSIX_TIMER);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Roland McGrath 140 52.63% 2 18.18%
Stanislaw Gruszka 53 19.92% 3 27.27%
Frédéric Weisbecker 35 13.16% 3 27.27%
Martin Schwidefsky 23 8.65% 1 9.09%
Frank Mayhar 14 5.26% 1 9.09%
Linus Torvalds 1 0.38% 1 9.09%
Total 266 100.00% 11 100.00%

/*
 * The timer is locked, fire it and arrange for its reload.
 */


static void cpu_timer_fire(struct k_itimer *timer)
{
	if ((timer->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
		/*
                 * User don't want any signal.
                 */
		timer->it.cpu.expires = 0;
	} else if (unlikely(timer->sigq == NULL)) {
		/*
                 * This a special case for clock_nanosleep,
                 * not a normal timer from sys_timer_create.
                 */
		wake_up_process(timer->it_process);
		timer->it.cpu.expires = 0;
	} else if (timer->it.cpu.incr == 0) {
		/*
                 * One-shot timer.  Clear it as soon as it's fired.
                 */
		posix_timer_event(timer, 0);
		timer->it.cpu.expires = 0;
	} else if (posix_timer_event(timer, ++timer->it_requeue_pending)) {
		/*
                 * The signal did not get queued because the signal
                 * was ignored, so we won't get any callback to
                 * reload the timer.  But we need to keep it
                 * ticking in case the signal is deliverable next time.
                 */
		posix_cpu_timer_rearm(timer);
		++timer->it_requeue_pending;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Roland McGrath 95 74.22% 2 40.00%
Stanislaw Gruszka 27 21.09% 1 20.00%
Thomas Gleixner 6 4.69% 2 40.00%
Total 128 100.00% 5 100.00%

/*
 * Sample a process (thread group) timer for the given group_leader task.
 * Must be called with task sighand lock held for safe while_each_thread()
 * traversal.
 */


static int cpu_timer_sample_group(const clockid_t which_clock,
				  struct task_struct *p, u64 *sample)
{
	struct task_cputime cputime;

	thread_group_cputimer(p, &cputime);
	switch (CPUCLOCK_WHICH(which_clock)) {
	default:
		return -EINVAL;
	case CPUCLOCK_PROF:
		*sample = cputime.utime + cputime.stime;
		break;
	case CPUCLOCK_VIRT:
		*sample = cputime.utime;
		break;
	case CPUCLOCK_SCHED:
		*sample = cputime.sum_exec_runtime;
		break;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Peter Zijlstra 75 88.24% 1 25.00%
Frédéric Weisbecker 9 10.59% 2 50.00%
Martin Schwidefsky 1 1.18% 1 25.00%
Total 85 100.00% 4 100.00%

/*
 * Guts of sys_timer_settime for CPU timers.
 * This is called with the timer locked and interrupts disabled.
 * If we return TIMER_RETRY, it's necessary to release the timer's lock
 * and try again.  (This happens when the timer is in the middle of firing.)
 */


static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags,
			       struct itimerspec64 *new, struct itimerspec64 *old)
{
	unsigned long flags;
	struct sighand_struct *sighand;
	struct task_struct *p = timer->it.cpu.task;
	u64 old_expires, new_expires, old_incr, val;
	int ret;

	WARN_ON_ONCE(p == NULL);

	/*
         * Use the to_ktime conversion because that clamps the maximum
         * value to KTIME_MAX and avoid multiplication overflows.
         */
	new_expires = ktime_to_ns(timespec64_to_ktime(new->it_value));

	/*
         * Protect against sighand release/switch in exit/exec and p->cpu_timers
         * and p->signal->cpu_timers read/write in arm_timer()
         */
	sighand = lock_task_sighand(p, &flags);
	/*
         * If p has just been reaped, we can no
         * longer get any information about it at all.
         */
	if (unlikely(sighand == NULL)) {
		return -ESRCH;
	}

	/*
         * Disarm any old timer after extracting its expiry time.
         */
	lockdep_assert_irqs_disabled();

	ret = 0;
	old_incr = timer->it.cpu.incr;
	old_expires = timer->it.cpu.expires;
	if (unlikely(timer->it.cpu.firing)) {
		timer->it.cpu.firing = -1;
		ret = TIMER_RETRY;
	} else
		list_del_init(&timer->it.cpu.entry);

	/*
         * We need to sample the current value to convert the new
         * value from to relative and absolute, and to convert the
         * old value from absolute to relative.  To set a process
         * timer, we need a sample to balance the thread expiry
         * times (in arm_timer).  With an absolute time, we must
         * check if it's already passed.  In short, we need a sample.
         */
	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
		cpu_clock_sample(timer->it_clock, p, &val);
	} else {
		cpu_timer_sample_group(timer->it_clock, p, &val);
	}

	if (old) {
		if (old_expires == 0) {
			old->it_value.tv_sec = 0;
			old->it_value.tv_nsec = 0;
		} else {
			/*
                         * Update the timer in case it has
                         * overrun already.  If it has,
                         * we'll report it as having overrun
                         * and with the next reloaded timer
                         * already ticking, though we are
                         * swallowing that pending
                         * notification here to install the
                         * new setting.
                         */
			bump_cpu_timer(timer, val);
			if (val < timer->it.cpu.expires) {
				old_expires = timer->it.cpu.expires - val;
				old->it_value = ns_to_timespec64(old_expires);
			} else {
				old->it_value.tv_nsec = 1;
				old->it_value.tv_sec = 0;
			}
		}
	}

	if (unlikely(ret)) {
		/*
                 * We are colliding with the timer actually firing.
                 * Punt after filling in the timer's old value, and
                 * disable this firing since we are already reporting
                 * it as an overrun (thanks to bump_cpu_timer above).
                 */
		unlock_task_sighand(p, &flags);
		goto out;
	}

	if (new_expires != 0 && !(timer_flags & TIMER_ABSTIME)) {
		new_expires += val;
	}

	/*
         * Install the new expiry time (or zero).
         * For a timer with no notification action, we don't actually
         * arm the timer (we'll just fake it for timer_gettime).
         */
	timer->it.cpu.expires = new_expires;
	if (new_expires != 0 && val < new_expires) {
		arm_timer(timer);
	}

	unlock_task_sighand(p, &flags);
	/*
         * Install the new reload setting, and
         * set up the signal and overrun bookkeeping.
         */
	timer->it.cpu.incr = timespec64_to_ns(&new->it_interval);

	/*
         * This acts as a modification timestamp for the timer,
         * so any automatic reload attempt will punt on seeing
         * that we have reset the timer manually.
         */
	timer->it_requeue_pending = (timer->it_requeue_pending + 2) &
		~REQUEUE_PENDING;
	timer->it_overrun_last = 0;
	timer->it_overrun = -1;

	if (new_expires != 0 && !(val < new_expires)) {
		/*
                 * The designated time already passed, so we notify
                 * immediately, even if the thread never runs to
                 * accumulate more time on this clock.
                 */
		cpu_timer_fire(timer);
	}

	ret = 0;
 out:
	if (old)
		old->it_interval = ns_to_timespec64(old_incr);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Roland McGrath 368 77.47% 1 7.14%
Frédéric Weisbecker 42 8.84% 5 35.71%
Oleg Nesterov 37 7.79% 2 14.29%
Stanislaw Gruszka 16 3.37% 2 14.29%
Thomas Gleixner 6 1.26% 2 14.29%
Deepa Dinamani 5 1.05% 1 7.14%
Peter Zijlstra 1 0.21% 1 7.14%
Total 475 100.00% 14 100.00%



static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp)
{
	u64 now;
	struct task_struct *p = timer->it.cpu.task;

	WARN_ON_ONCE(p == NULL);

	/*
         * Easy part: convert the reload time.
         */
	itp->it_interval = ns_to_timespec64(timer->it.cpu.incr);

	if (!timer->it.cpu.expires)
		return;

	/*
         * Sample the clock to take the difference with the expiry time.
         */
	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
		cpu_clock_sample(timer->it_clock, p, &now);
	} else {
		struct sighand_struct *sighand;
		unsigned long flags;

		/*
                 * Protect against sighand release/switch in exit/exec and
                 * also make timer sampling safe if it ends up calling
                 * thread_group_cputime().
                 */
		sighand = lock_task_sighand(p, &flags);
		if (unlikely(sighand
Person	Tokens	Prop	Commits	CommitProp
Frank Mayhar	27	50.94%	1	16.67%
Roland McGrath	11	20.75%	2	33.33%
Jiri Slaby	8	15.09%	1	16.67%
Frédéric Weisbecker	5	9.43%	1	16.67%
Stanislaw Gruszka	2	3.77%	1	16.67%
Total	53	100.00%	6	100.00%
cregit-Linux how code gets into the kernel

Release 4.15 kernel/time/posix-cpu-timers.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
