Skip to content

Commit

Permalink
timers: Give a few structs and members proper names
Browse files Browse the repository at this point in the history 
Some of the names in the internal implementation of the timer code
are not longer correct and others are simply too long to type.

Clean it up before we switch the wheel implementation over to
the new scheme.

No functional change.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Arjan van de Ven <arjan@infradead.org>
Cc: Chris Mason <clm@fb.com>
Cc: Eric Dumazet <edumazet@google.com>
Cc: George Spelvin <linux@sciencehorizons.net>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Len Brown <lenb@kernel.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: rt@linutronix.de
Link: http://lkml.kernel.org/r/20160704094341.948752516@linutronix.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>
  • Loading branch information
Thomas Gleixner authored and Ingo Molnar committed Jul 7, 2016
1 parent 15dba1e commit 494af3e
Showing 1 changed file with 59 additions and 59 deletions.
118 changes: 59 additions & 59 deletions kernel/time/timer.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -77,10 +77,10 @@ struct tvec_root {
struct hlist_head vec[TVR_SIZE];
};

struct tvec_base {
struct timer_base {
spinlock_t lock;
struct timer_list *running_timer;
unsigned long timer_jiffies;
unsigned long clk;
unsigned long next_timer;
unsigned long active_timers;
unsigned long all_timers;
Expand All @@ -95,7 +95,7 @@ struct tvec_base {
} ____cacheline_aligned;


static DEFINE_PER_CPU(struct tvec_base, tvec_bases);
static DEFINE_PER_CPU(struct timer_base, timer_bases);

#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
unsigned int sysctl_timer_migration = 1;
Expand All @@ -106,15 +106,15 @@ void timers_update_migration(bool update_nohz)
unsigned int cpu;

/* Avoid the loop, if nothing to update */
if (this_cpu_read(tvec_bases.migration_enabled) == on)
if (this_cpu_read(timer_bases.migration_enabled) == on)
return;

for_each_possible_cpu(cpu) {
per_cpu(tvec_bases.migration_enabled, cpu) = on;
per_cpu(timer_bases.migration_enabled, cpu) = on;
per_cpu(hrtimer_bases.migration_enabled, cpu) = on;
if (!update_nohz)
continue;
per_cpu(tvec_bases.nohz_active, cpu) = true;
per_cpu(timer_bases.nohz_active, cpu) = true;
per_cpu(hrtimer_bases.nohz_active, cpu) = true;
}
}
Expand All @@ -134,18 +134,18 @@ int timer_migration_handler(struct ctl_table *table, int write,
return ret;
}

static inline struct tvec_base *get_target_base(struct tvec_base *base,
static inline struct timer_base *get_target_base(struct timer_base *base,
int pinned)
{
if (pinned || !base->migration_enabled)
return this_cpu_ptr(&tvec_bases);
return per_cpu_ptr(&tvec_bases, get_nohz_timer_target());
return this_cpu_ptr(&timer_bases);
return per_cpu_ptr(&timer_bases, get_nohz_timer_target());
}
#else
static inline struct tvec_base *get_target_base(struct tvec_base *base,
static inline struct timer_base *get_target_base(struct timer_base *base,
int pinned)
{
return this_cpu_ptr(&tvec_bases);
return this_cpu_ptr(&timer_bases);
}
#endif

Expand Down Expand Up @@ -371,10 +371,10 @@ void set_timer_slack(struct timer_list *timer, int slack_hz)
EXPORT_SYMBOL_GPL(set_timer_slack);

static void
__internal_add_timer(struct tvec_base *base, struct timer_list *timer)
__internal_add_timer(struct timer_base *base, struct timer_list *timer)
{
unsigned long expires = timer->expires;
unsigned long idx = expires - base->timer_jiffies;
unsigned long idx = expires - base->clk;
struct hlist_head *vec;

if (idx < TVR_SIZE) {
Expand All @@ -394,7 +394,7 @@ __internal_add_timer(struct tvec_base *base, struct timer_list *timer)
* Can happen if you add a timer with expires == jiffies,
* or you set a timer to go off in the past
*/
vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
vec = base->tv1.vec + (base->clk & TVR_MASK);
} else {
int i;
/* If the timeout is larger than MAX_TVAL (on 64-bit
Expand All @@ -403,7 +403,7 @@ __internal_add_timer(struct tvec_base *base, struct timer_list *timer)
*/
if (idx > MAX_TVAL) {
idx = MAX_TVAL;
expires = idx + base->timer_jiffies;
expires = idx + base->clk;
}
i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
vec = base->tv5.vec + i;
Expand All @@ -412,11 +412,11 @@ __internal_add_timer(struct tvec_base *base, struct timer_list *timer)
hlist_add_head(&timer->entry, vec);
}

static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
static void internal_add_timer(struct timer_base *base, struct timer_list *timer)
{
/* Advance base->jiffies, if the base is empty */
if (!base->all_timers++)
base->timer_jiffies = jiffies;
base->clk = jiffies;

__internal_add_timer(base, timer);
/*
Expand Down Expand Up @@ -707,15 +707,15 @@ static inline void detach_timer(struct timer_list *timer, bool clear_pending)
}

static inline void
detach_expired_timer(struct timer_list *timer, struct tvec_base *base)
detach_expired_timer(struct timer_list *timer, struct timer_base *base)
{
detach_timer(timer, true);
if (!(timer->flags & TIMER_DEFERRABLE))
base->active_timers--;
base->all_timers--;
}

static int detach_if_pending(struct timer_list *timer, struct tvec_base *base,
static int detach_if_pending(struct timer_list *timer, struct timer_base *base,
bool clear_pending)
{
if (!timer_pending(timer))
Expand All @@ -725,16 +725,16 @@ static int detach_if_pending(struct timer_list *timer, struct tvec_base *base,
if (!(timer->flags & TIMER_DEFERRABLE)) {
base->active_timers--;
if (timer->expires == base->next_timer)
base->next_timer = base->timer_jiffies;
base->next_timer = base->clk;
}
/* If this was the last timer, advance base->jiffies */
if (!--base->all_timers)
base->timer_jiffies = jiffies;
base->clk = jiffies;
return 1;
}

/*
* We are using hashed locking: holding per_cpu(tvec_bases).lock
* We are using hashed locking: holding per_cpu(timer_bases).lock
* means that all timers which are tied to this base via timer->base are
* locked, and the base itself is locked too.
*
Expand All @@ -744,16 +744,16 @@ static int detach_if_pending(struct timer_list *timer, struct tvec_base *base,
* When the timer's base is locked and removed from the list, the
* TIMER_MIGRATING flag is set, FIXME
*/
static struct tvec_base *lock_timer_base(struct timer_list *timer,
static struct timer_base *lock_timer_base(struct timer_list *timer,
unsigned long *flags)
__acquires(timer->base->lock)
{
for (;;) {
u32 tf = timer->flags;
struct tvec_base *base;
struct timer_base *base;

if (!(tf & TIMER_MIGRATING)) {
base = per_cpu_ptr(&tvec_bases, tf & TIMER_CPUMASK);
base = per_cpu_ptr(&timer_bases, tf & TIMER_CPUMASK);
spin_lock_irqsave(&base->lock, *flags);
if (timer->flags == tf)
return base;
Expand All @@ -766,7 +766,7 @@ static struct tvec_base *lock_timer_base(struct timer_list *timer,
static inline int
__mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
{
struct tvec_base *base, *new_base;
struct timer_base *base, *new_base;
unsigned long flags;
int ret = 0;

Expand Down Expand Up @@ -933,8 +933,8 @@ EXPORT_SYMBOL(add_timer);
*/
void add_timer_on(struct timer_list *timer, int cpu)
{
struct tvec_base *new_base = per_cpu_ptr(&tvec_bases, cpu);
struct tvec_base *base;
struct timer_base *new_base = per_cpu_ptr(&timer_bases, cpu);
struct timer_base *base;
unsigned long flags;

timer_stats_timer_set_start_info(timer);
Expand Down Expand Up @@ -975,7 +975,7 @@ EXPORT_SYMBOL_GPL(add_timer_on);
*/
int del_timer(struct timer_list *timer)
{
struct tvec_base *base;
struct timer_base *base;
unsigned long flags;
int ret = 0;

Expand All @@ -1001,7 +1001,7 @@ EXPORT_SYMBOL(del_timer);
*/
int try_to_del_timer_sync(struct timer_list *timer)
{
struct tvec_base *base;
struct timer_base *base;
unsigned long flags;
int ret = -1;

Expand Down Expand Up @@ -1085,7 +1085,7 @@ int del_timer_sync(struct timer_list *timer)
EXPORT_SYMBOL(del_timer_sync);
#endif

static int cascade(struct tvec_base *base, struct tvec *tv, int index)
static int cascade(struct timer_base *base, struct tvec *tv, int index)
{
/* cascade all the timers from tv up one level */
struct timer_list *timer;
Expand Down Expand Up @@ -1149,7 +1149,7 @@ static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long),
}
}

#define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
#define INDEX(N) ((base->clk >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)

/**
* __run_timers - run all expired timers (if any) on this CPU.
Expand All @@ -1158,23 +1158,23 @@ static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long),
* This function cascades all vectors and executes all expired timer
* vectors.
*/
static inline void __run_timers(struct tvec_base *base)
static inline void __run_timers(struct timer_base *base)
{
struct timer_list *timer;

spin_lock_irq(&base->lock);

while (time_after_eq(jiffies, base->timer_jiffies)) {
while (time_after_eq(jiffies, base->clk)) {
struct hlist_head work_list;
struct hlist_head *head = &work_list;
int index;

if (!base->all_timers) {
base->timer_jiffies = jiffies;
base->clk = jiffies;
break;
}

index = base->timer_jiffies & TVR_MASK;
index = base->clk & TVR_MASK;

/*
* Cascade timers:
Expand All @@ -1184,7 +1184,7 @@ static inline void __run_timers(struct tvec_base *base)
(!cascade(base, &base->tv3, INDEX(1))) &&
!cascade(base, &base->tv4, INDEX(2)))
cascade(base, &base->tv5, INDEX(3));
++base->timer_jiffies;
++base->clk;
hlist_move_list(base->tv1.vec + index, head);
while (!hlist_empty(head)) {
void (*fn)(unsigned long);
Expand Down Expand Up @@ -1222,16 +1222,16 @@ static inline void __run_timers(struct tvec_base *base)
* is used on S/390 to stop all activity when a CPU is idle.
* This function needs to be called with interrupts disabled.
*/
static unsigned long __next_timer_interrupt(struct tvec_base *base)
static unsigned long __next_timer_interrupt(struct timer_base *base)
{
unsigned long timer_jiffies = base->timer_jiffies;
unsigned long expires = timer_jiffies + NEXT_TIMER_MAX_DELTA;
unsigned long clk = base->clk;
unsigned long expires = clk + NEXT_TIMER_MAX_DELTA;
int index, slot, array, found = 0;
struct timer_list *nte;
struct tvec *varray[4];

/* Look for timer events in tv1. */
index = slot = timer_jiffies & TVR_MASK;
index = slot = clk & TVR_MASK;
do {
hlist_for_each_entry(nte, base->tv1.vec + slot, entry) {
if (nte->flags & TIMER_DEFERRABLE)
Expand All @@ -1250,8 +1250,8 @@ static unsigned long __next_timer_interrupt(struct tvec_base *base)
cascade:
/* Calculate the next cascade event */
if (index)
timer_jiffies += TVR_SIZE - index;
timer_jiffies >>= TVR_BITS;
clk += TVR_SIZE - index;
clk >>= TVR_BITS;

/* Check tv2-tv5. */
varray[0] = &base->tv2;
Expand All @@ -1262,7 +1262,7 @@ static unsigned long __next_timer_interrupt(struct tvec_base *base)
for (array = 0; array < 4; array++) {
struct tvec *varp = varray[array];

index = slot = timer_jiffies & TVN_MASK;
index = slot = clk & TVN_MASK;
do {
hlist_for_each_entry(nte, varp->vec + slot, entry) {
if (nte->flags & TIMER_DEFERRABLE)
Expand All @@ -1286,8 +1286,8 @@ static unsigned long __next_timer_interrupt(struct tvec_base *base)
} while (slot != index);

if (index)
timer_jiffies += TVN_SIZE - index;
timer_jiffies >>= TVN_BITS;
clk += TVN_SIZE - index;
clk >>= TVN_BITS;
}
return expires;
}
Expand Down Expand Up @@ -1335,7 +1335,7 @@ static u64 cmp_next_hrtimer_event(u64 basem, u64 expires)
*/
u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
{
struct tvec_base *base = this_cpu_ptr(&tvec_bases);
struct timer_base *base = this_cpu_ptr(&timer_bases);
u64 expires = KTIME_MAX;
unsigned long nextevt;

Expand All @@ -1348,7 +1348,7 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)

spin_lock(&base->lock);
if (base->active_timers) {
if (time_before_eq(base->next_timer, base->timer_jiffies))
if (time_before_eq(base->next_timer, base->clk))
base->next_timer = __next_timer_interrupt(base);
nextevt = base->next_timer;
if (time_before_eq(nextevt, basej))
Expand Down Expand Up @@ -1387,9 +1387,9 @@ void update_process_times(int user_tick)
*/
static void run_timer_softirq(struct softirq_action *h)
{
struct tvec_base *base = this_cpu_ptr(&tvec_bases);
struct timer_base *base = this_cpu_ptr(&timer_bases);

if (time_after_eq(jiffies, base->timer_jiffies))
if (time_after_eq(jiffies, base->clk))
__run_timers(base);
}

Expand Down Expand Up @@ -1534,7 +1534,7 @@ signed long __sched schedule_timeout_idle(signed long timeout)
EXPORT_SYMBOL(schedule_timeout_idle);

#ifdef CONFIG_HOTPLUG_CPU
static void migrate_timer_list(struct tvec_base *new_base, struct hlist_head *head)
static void migrate_timer_list(struct timer_base *new_base, struct hlist_head *head)
{
struct timer_list *timer;
int cpu = new_base->cpu;
Expand All @@ -1550,13 +1550,13 @@ static void migrate_timer_list(struct tvec_base *new_base, struct hlist_head *he

static void migrate_timers(int cpu)
{
struct tvec_base *old_base;
struct tvec_base *new_base;
struct timer_base *old_base;
struct timer_base *new_base;
int i;

BUG_ON(cpu_online(cpu));
old_base = per_cpu_ptr(&tvec_bases, cpu);
new_base = get_cpu_ptr(&tvec_bases);
old_base = per_cpu_ptr(&timer_bases, cpu);
new_base = get_cpu_ptr(&timer_bases);
/*
* The caller is globally serialized and nobody else
* takes two locks at once, deadlock is not possible.
Expand All @@ -1580,7 +1580,7 @@ static void migrate_timers(int cpu)

spin_unlock(&old_base->lock);
spin_unlock_irq(&new_base->lock);
put_cpu_ptr(&tvec_bases);
put_cpu_ptr(&timer_bases);
}

static int timer_cpu_notify(struct notifier_block *self,
Expand Down Expand Up @@ -1608,13 +1608,13 @@ static inline void timer_register_cpu_notifier(void) { }

static void __init init_timer_cpu(int cpu)
{
struct tvec_base *base = per_cpu_ptr(&tvec_bases, cpu);
struct timer_base *base = per_cpu_ptr(&timer_bases, cpu);

base->cpu = cpu;
spin_lock_init(&base->lock);

base->timer_jiffies = jiffies;
base->next_timer = base->timer_jiffies;
base->clk = jiffies;
base->next_timer = base->clk;
}

static void __init init_timer_cpus(void)
Expand Down

0 comments on commit 494af3e

Please sign in to comment.