[PATCH] kill __init_timer_base in favor of boot_tvec_bases

#include <linux/spinlock.h>

#include <linux/stddef.h>

struct timer_base_s;

struct tvec_t_base_s;

struct timer_list {

	struct list_head entry;

	void (*function)(unsigned long);

	unsigned long data;

	struct timer_base_s *base;

	struct tvec_t_base_s *base;

};

extern struct timer_base_s __init_timer_base;

extern struct tvec_t_base_s boot_tvec_bases;

#define TIMER_INITIALIZER(_function, _expires, _data) {		\

		.function = (_function),			\

		.expires = (_expires),				\

		.data = (_data),				\

		.base = &__init_timer_base,			\

		.base = &boot_tvec_bases,			\

	}

#define DEFINE_TIMER(_name, _function, _expires, _data)		\

/*

 * per-CPU timer vector definitions:

 */

#define TVN_BITS (CONFIG_BASE_SMALL ? 4 : 6)

#define TVR_BITS (CONFIG_BASE_SMALL ? 6 : 8)

#define TVN_SIZE (1 << TVN_BITS)

#define TVN_MASK (TVN_SIZE - 1)

#define TVR_MASK (TVR_SIZE - 1)

struct timer_base_s {

	spinlock_t lock;

	struct timer_list *running_timer;

};

typedef struct tvec_s {

	struct list_head vec[TVN_SIZE];

} tvec_t;

} tvec_root_t;

struct tvec_t_base_s {

	struct timer_base_s t_base;

	spinlock_t lock;

	struct timer_list *running_timer;

	unsigned long timer_jiffies;

	tvec_root_t tv1;

	tvec_t tv2;

typedef struct tvec_t_base_s tvec_base_t;

static DEFINE_PER_CPU(tvec_base_t *, tvec_bases);

static tvec_base_t boot_tvec_bases;

tvec_base_t boot_tvec_bases;

EXPORT_SYMBOL(boot_tvec_bases);

static inline void set_running_timer(tvec_base_t *base,

					struct timer_list *timer)

{

#ifdef CONFIG_SMP

	base->t_base.running_timer = timer;

	base->running_timer = timer;

#endif

}

	list_add_tail(&timer->entry, vec);

}

typedef struct timer_base_s timer_base_t;

/*

 * Used by TIMER_INITIALIZER, we can't use per_cpu(tvec_bases)

 * at compile time, and we need timer->base to lock the timer.

 */

timer_base_t __init_timer_base

	____cacheline_aligned_in_smp = { .lock = SPIN_LOCK_UNLOCKED };

EXPORT_SYMBOL(__init_timer_base);

/***

 * init_timer - initialize a timer.

 * @timer: the timer to be initialized

void fastcall init_timer(struct timer_list *timer)

{

	timer->entry.next = NULL;

	timer->base = &per_cpu(tvec_bases, raw_smp_processor_id())->t_base;

	timer->base = per_cpu(tvec_bases, raw_smp_processor_id());

}

EXPORT_SYMBOL(init_timer);

}

/*

 * We are using hashed locking: holding per_cpu(tvec_bases).t_base.lock

 * We are using hashed locking: holding per_cpu(tvec_bases).lock

 * means that all timers which are tied to this base via timer->base are

 * locked, and the base itself is locked too.

 *

 * possible to set timer->base = NULL and drop the lock: the timer remains

 * locked.

 */

static timer_base_t *lock_timer_base(struct timer_list *timer,

static tvec_base_t *lock_timer_base(struct timer_list *timer,

					unsigned long *flags)

{

	timer_base_t *base;

	tvec_base_t *base;

	for (;;) {

		base = timer->base;

int __mod_timer(struct timer_list *timer, unsigned long expires)

{

	timer_base_t *base;

	tvec_base_t *new_base;

	tvec_base_t *base, *new_base;

	unsigned long flags;

	int ret = 0;

	new_base = __get_cpu_var(tvec_bases);

	if (base != &new_base->t_base) {

	if (base != new_base) {

		/*

		 * We are trying to schedule the timer on the local CPU.

		 * However we can't change timer's base while it is running,

		 */

		if (unlikely(base->running_timer == timer)) {

			/* The timer remains on a former base */

			new_base = container_of(base, tvec_base_t, t_base);

			new_base = base;

		} else {

			/* See the comment in lock_timer_base() */

			timer->base = NULL;

			spin_unlock(&base->lock);

			spin_lock(&new_base->t_base.lock);

			timer->base = &new_base->t_base;

			spin_lock(&new_base->lock);

			timer->base = new_base;

		}

	}

	timer->expires = expires;

	internal_add_timer(new_base, timer);

	spin_unlock_irqrestore(&new_base->t_base.lock, flags);

	spin_unlock_irqrestore(&new_base->lock, flags);

	return ret;

}

  	unsigned long flags;

  	BUG_ON(timer_pending(timer) || !timer->function);

	spin_lock_irqsave(&base->t_base.lock, flags);

	timer->base = &base->t_base;

	spin_lock_irqsave(&base->lock, flags);

	timer->base = base;

	internal_add_timer(base, timer);

	spin_unlock_irqrestore(&base->t_base.lock, flags);

	spin_unlock_irqrestore(&base->lock, flags);

}

 */

int del_timer(struct timer_list *timer)

{

	timer_base_t *base;

	tvec_base_t *base;

	unsigned long flags;

	int ret = 0;

 */

int try_to_del_timer_sync(struct timer_list *timer)

{

	timer_base_t *base;

	tvec_base_t *base;

	unsigned long flags;

	int ret = -1;

		struct timer_list *tmp;

		tmp = list_entry(curr, struct timer_list, entry);

		BUG_ON(tmp->base != &base->t_base);

		BUG_ON(tmp->base != base);

		curr = curr->next;

		internal_add_timer(base, tmp);

	}

{

	struct timer_list *timer;

	spin_lock_irq(&base->t_base.lock);

	spin_lock_irq(&base->lock);

	while (time_after_eq(jiffies, base->timer_jiffies)) {

		struct list_head work_list = LIST_HEAD_INIT(work_list);

		struct list_head *head = &work_list;

			set_running_timer(base, timer);

			detach_timer(timer, 1);

			spin_unlock_irq(&base->t_base.lock);

			spin_unlock_irq(&base->lock);

			{

				int preempt_count = preempt_count();

				fn(data);

					BUG();

				}

			}

			spin_lock_irq(&base->t_base.lock);

			spin_lock_irq(&base->lock);

		}

	}

	set_running_timer(base, NULL);

	spin_unlock_irq(&base->t_base.lock);

	spin_unlock_irq(&base->lock);

}

#ifdef CONFIG_NO_IDLE_HZ

	hr_expires += jiffies;

	base = __get_cpu_var(tvec_bases);

	spin_lock(&base->t_base.lock);

	spin_lock(&base->lock);

	expires = base->timer_jiffies + (LONG_MAX >> 1);

	list = NULL;

				expires = nte->expires;

		}

	}

	spin_unlock(&base->t_base.lock);

	spin_unlock(&base->lock);

	if (time_before(hr_expires, expires))

		return hr_expires;

		}

		per_cpu(tvec_bases, cpu) = base;

	}

	spin_lock_init(&base->t_base.lock);

	spin_lock_init(&base->lock);

	for (j = 0; j < TVN_SIZE; j++) {

		INIT_LIST_HEAD(base->tv5.vec + j);

		INIT_LIST_HEAD(base->tv4.vec + j);

	while (!list_empty(head)) {

		timer = list_entry(head->next, struct timer_list, entry);

		detach_timer(timer, 0);

		timer->base = &new_base->t_base;

		timer->base = new_base;

		internal_add_timer(new_base, timer);

	}

}

	new_base = get_cpu_var(tvec_bases);

	local_irq_disable();

	spin_lock(&new_base->t_base.lock);

	spin_lock(&old_base->t_base.lock);

	spin_lock(&new_base->lock);

	spin_lock(&old_base->lock);

	BUG_ON(old_base->running_timer);

	if (old_base->t_base.running_timer)

		BUG();

	for (i = 0; i < TVR_SIZE; i++)

		migrate_timer_list(new_base, old_base->tv1.vec + i);

	for (i = 0; i < TVN_SIZE; i++) {

		migrate_timer_list(new_base, old_base->tv5.vec + i);

	}

	spin_unlock(&old_base->t_base.lock);

	spin_unlock(&new_base->t_base.lock);

	spin_unlock(&old_base->lock);

	spin_unlock(&new_base->lock);

	local_irq_enable();

	put_cpu_var(tvec_bases);

}