Remove timer_list.magic and associated debugging code.
I originally added this when a spinlock was added to timer_list - this meant
that an all-zeroes timer became illegal and init_timer() was required.
That spinlock isn't even there any more, although timer.base must now be
initialised.
I'll keep this debugging code in -mm.
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
 #include <asm/s390_ext.h>
 #include <asm/timer.h>
 
-#define VTIMER_MAGIC (TIMER_MAGIC + 1)
 static ext_int_info_t ext_int_info_timer;
 DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);
 
 
 void init_virt_timer(struct vtimer_list *timer)
 {
-       timer->magic = VTIMER_MAGIC;
        timer->function = NULL;
        INIT_LIST_HEAD(&timer->entry);
        spin_lock_init(&timer->lock);
 }
 EXPORT_SYMBOL(init_virt_timer);
 
-static inline int check_vtimer(struct vtimer_list *timer)
-{
-       if (timer->magic != VTIMER_MAGIC)
-               return -EINVAL;
-       return 0;
-}
-
 static inline int vtimer_pending(struct vtimer_list *timer)
 {
        return (!list_empty(&timer->entry));
 
 static inline int prepare_vtimer(struct vtimer_list *timer)
 {
-       if (check_vtimer(timer) || !timer->function) {
+       if (!timer->function) {
                printk("add_virt_timer: uninitialized timer\n");
                return -EINVAL;
        }
        unsigned long flags;
        int cpu;
 
-       if (check_vtimer(timer) || !timer->function) {
+       if (!timer->function) {
                printk("mod_virt_timer: uninitialized timer\n");
                return  -EINVAL;
        }
        unsigned long flags;
        struct vtimer_queue *vt_list;
 
-       if (check_vtimer(timer)) {
-               printk("del_virt_timer: timer not initialized\n");
-               return -EINVAL;
-       }
-
        /* check if timer is pending */
        if (!vtimer_pending(timer))
                return 0;
 
        struct list_head entry;
        unsigned long expires;
 
-       unsigned long magic;
-
        void (*function)(unsigned long);
        unsigned long data;
 
        struct timer_base_s *base;
 };
 
-#define TIMER_MAGIC    0x4b87ad6e
-
 extern struct timer_base_s __init_timer_base;
 
 #define TIMER_INITIALIZER(_function, _expires, _data) {                \
                .expires = (_expires),                          \
                .data = (_data),                                \
                .base = &__init_timer_base,                     \
-               .magic = TIMER_MAGIC,                           \
        }
 
 #define DEFINE_TIMER(_name, _function, _expires, _data)                \
 
 #endif
 }
 
-static void check_timer_failed(struct timer_list *timer)
-{
-       static int whine_count;
-       if (whine_count < 16) {
-               whine_count++;
-               printk("Uninitialised timer!\n");
-               printk("This is just a warning.  Your computer is OK\n");
-               printk("function=0x%p, data=0x%lx\n",
-                       timer->function, timer->data);
-               dump_stack();
-       }
-       /*
-        * Now fix it up
-        */
-       timer->magic = TIMER_MAGIC;
-}
-
-static inline void check_timer(struct timer_list *timer)
-{
-       if (timer->magic != TIMER_MAGIC)
-               check_timer_failed(timer);
-}
-
-
 static void internal_add_timer(tvec_base_t *base, struct timer_list *timer)
 {
        unsigned long expires = timer->expires;
 {
        timer->entry.next = NULL;
        timer->base = &per_cpu(tvec_bases, raw_smp_processor_id()).t_base;
-       timer->magic = TIMER_MAGIC;
 }
 EXPORT_SYMBOL(init_timer);
 
        int ret = 0;
 
        BUG_ON(!timer->function);
-       check_timer(timer);
 
        base = lock_timer_base(timer, &flags);
 
        unsigned long flags;
 
        BUG_ON(timer_pending(timer) || !timer->function);
-
-       check_timer(timer);
-
        spin_lock_irqsave(&base->t_base.lock, flags);
        timer->base = &base->t_base;
        internal_add_timer(base, timer);
 {
        BUG_ON(!timer->function);
 
-       check_timer(timer);
-
        /*
         * This is a common optimization triggered by the
         * networking code - if the timer is re-modified
        unsigned long flags;
        int ret = 0;
 
-       check_timer(timer);
-
        if (timer_pending(timer)) {
                base = lock_timer_base(timer, &flags);
                if (timer_pending(timer)) {
  */
 int del_timer_sync(struct timer_list *timer)
 {
-       check_timer(timer);
-
        for (;;) {
                int ret = try_to_del_timer_sync(timer);
                if (ret >= 0)