lkml.org 
[lkml]   [2017]   [Jun]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[tip:timers/core] posix-timers: Rename do_schedule_next_timer
    Commit-ID:  96fe3b072f134e4993f829d599eaa1e0eb5a10e5
    Gitweb: http://git.kernel.org/tip/96fe3b072f134e4993f829d599eaa1e0eb5a10e5
    Author: Thomas Gleixner <tglx@linutronix.de>
    AuthorDate: Tue, 30 May 2017 23:15:46 +0200
    Committer: Thomas Gleixner <tglx@linutronix.de>
    CommitDate: Sun, 4 Jun 2017 15:40:25 +0200

    posix-timers: Rename do_schedule_next_timer

    That function is a misnomer. Rename it with a proper prefix to
    posixtimer_rearm().

    Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
    Cc: Peter Zijlstra <peterz@infradead.org>
    Cc: John Stultz <john.stultz@linaro.org>
    Link: http://lkml.kernel.org/r/20170530211656.811362578@linutronix.de

    ---
    include/linux/posix-timers.h | 2 +-
    kernel/signal.c | 2 +-
    kernel/time/posix-cpu-timers.c | 2 +-
    kernel/time/posix-timers.c | 10 +++++-----
    4 files changed, 8 insertions(+), 8 deletions(-)

    diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
    index 8f9cca3..771e5f7 100644
    --- a/include/linux/posix-timers.h
    +++ b/include/linux/posix-timers.h
    @@ -112,6 +112,6 @@ long clock_nanosleep_restart(struct restart_block *restart_block);

    void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new);

    -void do_schedule_next_timer(struct siginfo *info);
    +void posixtimer_rearm(struct siginfo *info);

    #endif
    diff --git a/kernel/signal.c b/kernel/signal.c
    index 1f85c84..d031cd2 100644
    --- a/kernel/signal.c
    +++ b/kernel/signal.c
    @@ -630,7 +630,7 @@ int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
    * about to disable them again anyway.
    */
    spin_unlock(&tsk->sighand->siglock);
    - do_schedule_next_timer(info);
    + posixtimer_rearm(info);
    spin_lock(&tsk->sighand->siglock);
    }
    #endif
    diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
    index 0123ece..1ba576d 100644
    --- a/kernel/time/posix-cpu-timers.c
    +++ b/kernel/time/posix-cpu-timers.c
    @@ -981,7 +981,7 @@ static void check_process_timers(struct task_struct *tsk,
    }

    /*
    - * This is called from the signal code (via do_schedule_next_timer)
    + * This is called from the signal code (via posixtimer_rearm)
    * when the last timer signal was delivered and we have to reload the timer.
    */
    void posix_cpu_timer_schedule(struct k_itimer *timer)
    diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
    index eb007e1..036b7e7 100644
    --- a/kernel/time/posix-timers.c
    +++ b/kernel/time/posix-timers.c
    @@ -305,7 +305,7 @@ static void schedule_next_timer(struct k_itimer *timr)
    * To protect against the timer going away while the interrupt is queued,
    * we require that the it_requeue_pending flag be set.
    */
    -void do_schedule_next_timer(struct siginfo *info)
    +void posixtimer_rearm(struct siginfo *info)
    {
    struct k_itimer *timr;
    unsigned long flags;
    @@ -336,12 +336,12 @@ int posix_timer_event(struct k_itimer *timr, int si_private)
    int shared, ret = -1;
    /*
    * FIXME: if ->sigq is queued we can race with
    - * dequeue_signal()->do_schedule_next_timer().
    + * dequeue_signal()->posixtimer_rearm().
    *
    * If dequeue_signal() sees the "right" value of
    - * si_sys_private it calls do_schedule_next_timer().
    + * si_sys_private it calls posixtimer_rearm().
    * We re-queue ->sigq and drop ->it_lock().
    - * do_schedule_next_timer() locks the timer
    + * posixtimer_rearm() locks the timer
    * and re-schedules it while ->sigq is pending.
    * Not really bad, but not that we want.
    */
    @@ -701,7 +701,7 @@ SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
    * accumulating overruns on the next timer. The overrun is frozen when
    * the signal is delivered, either at the notify time (if the info block
    * is not queued) or at the actual delivery time (as we are informed by
    - * the call back to do_schedule_next_timer(). So all we need to do is
    + * the call back to posixtimer_rearm(). So all we need to do is
    * to pick up the frozen overrun.
    */
    SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
    \
     
     \ /
      Last update: 2017-06-05 11:36    [W:4.190 / U:0.036 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site