linux-imx

// 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 <linux/sched/deadline.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);

}

​

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;

}

​

/*

 * 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_interval)

        return;

​

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

        return;

​

    incr = timer->it_interval;

    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 += 1LL << i;

        delta -= incr;

    }

}

​