14 files changed, 165 insertions, 178 deletions

diff --git a/kernel/fork.c b/kernel/fork.c
index 56e4e07e45f7..926e5a68ea9e 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -61,9 +61,7 @@ int max_threads;		/* tunable limit on nr_threads */
 
 DEFINE_PER_CPU(unsigned long, process_counts) = 0;
 
- __cacheline_aligned DEFINE_RWLOCK(tasklist_lock);  /* outer */
-
-EXPORT_SYMBOL(tasklist_lock);
+__cacheline_aligned DEFINE_RWLOCK(tasklist_lock);  /* outer */
 
 int nr_processes(void)
 {
diff --git a/kernel/futex.c b/kernel/futex.c
index 1dc98e4dd287..cf0c8e21d1ab 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -476,6 +476,12 @@ lookup_pi_state(u32 uval, struct futex_hash_bucket *hb, struct futex_q *me)
                          * the refcount and return its pi_state:
                          */
                         pi_state = this->pi_state;
+                        /*
+                         * Userspace might have messed up non PI and PI futexes
+                         */
+                        if (unlikely(!pi_state))
+                                return -EINVAL;
+
                         atomic_inc(&pi_state->refcount);
                         me->pi_state = pi_state;
 
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index f32ca78c198d..9bad17884513 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -169,22 +169,17 @@ EXPORT_SYMBOL(lockdep_internal);
  */
 static int class_filter(struct lock_class *class)
 {
+#if 0
+        /* Example */
         if (class->name_version == 1 &&
-                        !strcmp(class->name, "&rl->lock"))
+                        !strcmp(class->name, "lockname"))
                 return 1;
         if (class->name_version == 1 &&
-                        !strcmp(class->name, "&ni->mrec_lock"))
+                        !strcmp(class->name, "&struct->lockfield"))
                 return 1;
-        if (class->name_version == 1 &&
-                        !strcmp(class->name, "mft_ni_runlist_lock"))
-                return 1;
-        if (class->name_version == 1 &&
-                        !strcmp(class->name, "mft_ni_mrec_lock"))
-                return 1;
-        if (class->name_version == 1 &&
-                        !strcmp(class->name, "&vol->lcnbmp_lock"))
-                return 1;
-        return 0;
+#endif
+        /* Allow everything else. 0 would be filter everything else */
+        return 1;
 }
 #endif
 
@@ -408,23 +403,12 @@ static void lockdep_print_held_locks(struct task_struct *curr)
                 print_lock(curr->held_locks + i);
         }
 }
-/*
- * Helper to print a nice hierarchy of lock dependencies:
- */
-static void print_spaces(int nr)
-{
-        int i;
-
-        for (i = 0; i < nr; i++)
-                printk("  ");
-}
 
 static void print_lock_class_header(struct lock_class *class, int depth)
 {
         int bit;
 
-        print_spaces(depth);
-        printk("->");
+        printk("%*s->", depth, "");
         print_lock_name(class);
         printk(" ops: %lu", class->ops);
         printk(" {\n");
@@ -433,17 +417,14 @@ static void print_lock_class_header(struct lock_class *class, int depth)
                 if (class->usage_mask & (1 << bit)) {
                         int len = depth;
 
-                        print_spaces(depth);
-                        len += printk("   %s", usage_str[bit]);
+                        len += printk("%*s   %s", depth, "", usage_str[bit]);
                         len += printk(" at:\n");
                         print_stack_trace(class->usage_traces + bit, len);
                 }
         }
-        print_spaces(depth);
-        printk(" }\n");
+        printk("%*s }\n", depth, "");
 
-        print_spaces(depth);
-        printk(" ... key      at: ");
+        printk("%*s ... key      at: ",depth,"");
         print_ip_sym((unsigned long)class->key);
 }
 
@@ -463,8 +444,7 @@ static void print_lock_dependencies(struct lock_class *class, int depth)
                 DEBUG_LOCKS_WARN_ON(!entry->class);
                 print_lock_dependencies(entry->class, depth + 1);
 
-                print_spaces(depth);
-                printk(" ... acquired at:\n");
+                printk("%*s ... acquired at:\n",depth,"");
                 print_stack_trace(&entry->trace, 2);
                 printk("\n");
         }
@@ -1124,7 +1104,7 @@ extern void __error_too_big_MAX_LOCKDEP_SUBCLASSES(void);
  * itself, so actual lookup of the hash should be once per lock object.
  */
 static inline struct lock_class *
-register_lock_class(struct lockdep_map *lock, unsigned int subclass)
+look_up_lock_class(struct lockdep_map *lock, unsigned int subclass)
 {
         struct lockdep_subclass_key *key;
         struct list_head *hash_head;
@@ -1168,7 +1148,26 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass)
          */
         list_for_each_entry(class, hash_head, hash_entry)
                 if (class->key == key)
-                        goto out_set;
+                        return class;
+
+        return NULL;
+}
+
+/*
+ * Register a lock's class in the hash-table, if the class is not present
+ * yet. Otherwise we look it up. We cache the result in the lock object
+ * itself, so actual lookup of the hash should be once per lock object.
+ */
+static inline struct lock_class *
+register_lock_class(struct lockdep_map *lock, unsigned int subclass)
+{
+        struct lockdep_subclass_key *key;
+        struct list_head *hash_head;
+        struct lock_class *class;
+
+        class = look_up_lock_class(lock, subclass);
+        if (likely(class))
+                return class;
 
         /*
          * Debug-check: all keys must be persistent!
@@ -1183,6 +1182,9 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass)
                 return NULL;
         }
 
+        key = lock->key->subkeys + subclass;
+        hash_head = classhashentry(key);
+
         __raw_spin_lock(&hash_lock);
         /*
          * We have to do the hash-walk again, to avoid races
@@ -1229,8 +1231,8 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass)
 out_unlock_set:
         __raw_spin_unlock(&hash_lock);
 
-out_set:
-        lock->class[subclass] = class;
+        if (!subclass)
+                lock->class_cache = class;
 
         DEBUG_LOCKS_WARN_ON(class->subclass != subclass);
 
@@ -1934,7 +1936,7 @@ void lockdep_init_map(struct lockdep_map *lock, const char *name,
         }
         lock->name = name;
         lock->key = key;
-        memset(lock->class, 0, sizeof(lock->class[0])*MAX_LOCKDEP_SUBCLASSES);
+        lock->class_cache = NULL;
 }
 
 EXPORT_SYMBOL_GPL(lockdep_init_map);
@@ -1948,8 +1950,8 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
                           unsigned long ip)
 {
         struct task_struct *curr = current;
+        struct lock_class *class = NULL;
         struct held_lock *hlock;
-        struct lock_class *class;
         unsigned int depth, id;
         int chain_head = 0;
         u64 chain_key;
@@ -1967,8 +1969,11 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
                 return 0;
         }
 
-        class = lock->class[subclass];
-        /* not cached yet? */
+        if (!subclass)
+                class = lock->class_cache;
+        /*
+         * Not cached yet or subclass?
+         */
         if (unlikely(!class)) {
                 class = register_lock_class(lock, subclass);
                 if (!class)
@@ -2469,48 +2474,44 @@ void lockdep_free_key_range(void *start, unsigned long size)
 
 void lockdep_reset_lock(struct lockdep_map *lock)
 {
-        struct lock_class *class, *next, *entry;
+        struct lock_class *class, *next;
         struct list_head *head;
         unsigned long flags;
         int i, j;
 
         raw_local_irq_save(flags);
-        __raw_spin_lock(&hash_lock);
 
         /*
-         * Remove all classes this lock has:
+         * Remove all classes this lock might have:
+         */
+        for (j = 0; j < MAX_LOCKDEP_SUBCLASSES; j++) {
+                /*
+                 * If the class exists we look it up and zap it:
+                 */
+                class = look_up_lock_class(lock, j);
+                if (class)
+                        zap_class(class);
+        }
+        /*
+         * Debug check: in the end all mapped classes should
+         * be gone.
          */
+        __raw_spin_lock(&hash_lock);
         for (i = 0; i < CLASSHASH_SIZE; i++) {
                 head = classhash_table + i;
                 if (list_empty(head))
                         continue;
                 list_for_each_entry_safe(class, next, head, hash_entry) {
-                        for (j = 0; j < MAX_LOCKDEP_SUBCLASSES; j++) {
-                                entry = lock->class[j];
-                                if (class == entry) {
-                                        zap_class(class);
-                                        lock->class[j] = NULL;
-                                        break;
-                                }
+                        if (unlikely(class == lock->class_cache)) {
+                                __raw_spin_unlock(&hash_lock);
+                                DEBUG_LOCKS_WARN_ON(1);
+                                goto out_restore;
                         }
                 }
         }
-
-        /*
-         * Debug check: in the end all mapped classes should
-         * be gone.
-         */
-        for (j = 0; j < MAX_LOCKDEP_SUBCLASSES; j++) {
-                entry = lock->class[j];
-                if (!entry)
-                        continue;
-                __raw_spin_unlock(&hash_lock);
-                DEBUG_LOCKS_WARN_ON(1);
-                raw_local_irq_restore(flags);
-                return;
-        }
-
         __raw_spin_unlock(&hash_lock);
+
+out_restore:
         raw_local_irq_restore(flags);
 }
 
@@ -2571,7 +2572,7 @@ static inline int in_range(const void *start, const void *addr, const void *end)
 
 static void
 print_freed_lock_bug(struct task_struct *curr, const void *mem_from,
-                     const void *mem_to)
+                     const void *mem_to, struct held_lock *hlock)
 {
         if (!debug_locks_off())
                 return;
@@ -2583,6 +2584,7 @@ print_freed_lock_bug(struct task_struct *curr, const void *mem_from,
         printk(  "-------------------------\n");
         printk("%s/%d is freeing memory %p-%p, with a lock still held there!\n",
                 curr->comm, curr->pid, mem_from, mem_to-1);
+        print_lock(hlock);
         lockdep_print_held_locks(curr);
 
         printk("\nstack backtrace:\n");
@@ -2616,7 +2618,7 @@ void debug_check_no_locks_freed(const void *mem_from, unsigned long mem_len)
                                         !in_range(mem_from, lock_to, mem_to))
                         continue;
 
-                print_freed_lock_bug(curr, mem_from, mem_to);
+                print_freed_lock_bug(curr, mem_from, mem_to, hlock);
                 break;
         }
         local_irq_restore(flags);
diff --git a/kernel/panic.c b/kernel/panic.c
index ab13f0f668b5..d8a0bca21233 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -172,6 +172,7 @@ const char *print_tainted(void)
 
 void add_taint(unsigned flag)
 {
+        debug_locks_off(); /* can't trust the integrity of the kernel anymore */
         tainted |= flag;
 }
 EXPORT_SYMBOL(add_taint);
@@ -256,6 +257,7 @@ int oops_may_print(void)
  */
 void oops_enter(void)
 {
+        debug_locks_off(); /* can't trust the integrity of the kernel anymore */
         do_oops_enter_exit();
 }
 
diff --git a/kernel/power/pm.c b/kernel/power/pm.c
index 84063ac8fcfc..c50d15266c10 100644
--- a/kernel/power/pm.c
+++ b/kernel/power/pm.c
@@ -75,42 +75,6 @@ struct pm_dev *pm_register(pm_dev_t type,
         return dev;
 }
 
-static void __pm_unregister(struct pm_dev *dev)
-{
-        if (dev) {
-                list_del(&dev->entry);
-                kfree(dev);
-        }
-}
-
-/**
- *      pm_unregister_all - unregister all devices with matching callback
- *      @callback: callback function pointer
- *
- *      Unregister every device that would call the callback passed. This
- *      is primarily meant as a helper function for loadable modules. It
- *      enables a module to give up all its managed devices without keeping
- *      its own private list.
- */
- 
-void pm_unregister_all(pm_callback callback)
-{
-        struct list_head *entry;
-
-        if (!callback)
-                return;
-
-        mutex_lock(&pm_devs_lock);
-        entry = pm_devs.next;
-        while (entry != &pm_devs) {
-                struct pm_dev *dev = list_entry(entry, struct pm_dev, entry);
-                entry = entry->next;
-                if (dev->callback == callback)
-                        __pm_unregister(dev);
-        }
-        mutex_unlock(&pm_devs_lock);
-}
-
 /**
  *      pm_send - send request to a single device
  *      @dev: device to send to
@@ -239,7 +203,6 @@ int pm_send_all(pm_request_t rqst, void *data)
 }
 
 EXPORT_SYMBOL(pm_register);
-EXPORT_SYMBOL(pm_unregister_all);
 EXPORT_SYMBOL(pm_send_all);
 EXPORT_SYMBOL(pm_active);
 
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index 24c96f354231..75d4886e648e 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -227,11 +227,17 @@ static void copy_data_pages(struct pbe *pblist)
                 for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn) {
                         if (saveable(zone, &zone_pfn)) {
                                 struct page *page;
+                                long *src, *dst;
+                                int n;
+
                                 page = pfn_to_page(zone_pfn + zone->zone_start_pfn);
                                 BUG_ON(!pbe);
                                 pbe->orig_address = (unsigned long)page_address(page);
-                                /* copy_page is not usable for copying task structs. */
-                                memcpy((void *)pbe->address, (void *)pbe->orig_address, PAGE_SIZE);
+                                /* copy_page and memcpy are not usable for copying task structs. */
+                                dst = (long *)pbe->address;
+                                src = (long *)pbe->orig_address;
+                                for (n = PAGE_SIZE / sizeof(long); n; n--)
+                                        *dst++ = *src++;
                                 pbe = pbe->next;
                         }
                 }
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 044b8e0c1025..f1dd146bd64d 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -263,7 +263,6 @@ int swsusp_write(void)
         struct swap_map_handle handle;
         struct snapshot_handle snapshot;
         struct swsusp_info *header;
-        unsigned long start;
         int error;
 
         if ((error = swsusp_swap_check())) {
@@ -281,16 +280,17 @@ int swsusp_write(void)
         }
         error = get_swap_writer(&handle);
         if (!error) {
-                start = handle.cur_swap;
+                unsigned long start = handle.cur_swap;
                 error = swap_write_page(&handle, header);
-        }
-        if (!error)
-                error = save_image(&handle, &snapshot, header->pages - 1);
-        if (!error) {
-                flush_swap_writer(&handle);
-                printk("S");
-                error = mark_swapfiles(swp_entry(root_swap, start));
-                printk("|\n");
+                if (!error)
+                        error = save_image(&handle, &snapshot,
+                                        header->pages - 1);
+                if (!error) {
+                        flush_swap_writer(&handle);
+                        printk("S");
+                        error = mark_swapfiles(swp_entry(root_swap, start));
+                        printk("|\n");
+                }
         }
         if (error)
                 free_all_swap_pages(root_swap, handle.bitmap);
@@ -311,8 +311,10 @@ static atomic_t io_done = ATOMIC_INIT(0);
 
 static int end_io(struct bio *bio, unsigned int num, int err)
 {
-        if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
-                panic("I/O error reading memory image");
+        if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
+                printk(KERN_ERR "I/O error reading swsusp image.\n");
+                return -EIO;
+        }
         atomic_set(&io_done, 0);
         return 0;
 }
diff --git a/kernel/printk.c b/kernel/printk.c
index bdba5d80496c..65ca0688f86f 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -52,7 +52,7 @@ int console_printk[4] = {
         DEFAULT_CONSOLE_LOGLEVEL,       /* default_console_loglevel */
 };
 
-EXPORT_SYMBOL(console_printk);
+EXPORT_UNUSED_SYMBOL(console_printk);  /*  June 2006  */
 
 /*
  * Low lever drivers may need that to know if they can schedule in
@@ -773,7 +773,7 @@ int is_console_locked(void)
 {
         return console_locked;
 }
-EXPORT_SYMBOL(is_console_locked);
+EXPORT_UNUSED_SYMBOL(is_console_locked);  /*  June 2006  */
 
 /**
  * release_console_sem - unlock the console system
diff --git a/kernel/resource.c b/kernel/resource.c
index 129cf046e561..0dd3a857579e 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -404,8 +404,6 @@ int insert_resource(struct resource *parent, struct resource *new)
         return result;
 }
 
-EXPORT_SYMBOL(insert_resource);
-
 /*
  * Given an existing resource, change its start and size to match the
  * arguments.  Returns -EBUSY if it can't fit.  Existing children of
diff --git a/kernel/sched.c b/kernel/sched.c
index 4ee400f9d56b..d714611f1691 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -3384,7 +3384,7 @@ EXPORT_SYMBOL(schedule);
 
 #ifdef CONFIG_PREEMPT
 /*
- * this is is the entry point to schedule() from in-kernel preemption
+ * this is the entry point to schedule() from in-kernel preemption
  * off of preempt_enable.  Kernel preemptions off return from interrupt
  * occur there and call schedule directly.
  */
@@ -3427,7 +3427,7 @@ need_resched:
 EXPORT_SYMBOL(preempt_schedule);
 
 /*
- * this is is the entry point to schedule() from kernel preemption
+ * this is the entry point to schedule() from kernel preemption
  * off of irq context.
  * Note, that this is called and return with irqs disabled. This will
  * protect us against recursive calling from irq.
@@ -3439,7 +3439,7 @@ asmlinkage void __sched preempt_schedule_irq(void)
         struct task_struct *task = current;
         int saved_lock_depth;
 #endif
-        /* Catch callers which need to be fixed*/
+        /* Catch callers which need to be fixed */
         BUG_ON(ti->preempt_count || !irqs_disabled());
 
 need_resched:
@@ -4650,7 +4650,7 @@ static inline struct task_struct *younger_sibling(struct task_struct *p)
         return list_entry(p->sibling.next,struct task_struct,sibling);
 }
 
-static const char *stat_nam[] = { "R", "S", "D", "T", "t", "Z", "X" };
+static const char stat_nam[] = "RSDTtZX";
 
 static void show_task(struct task_struct *p)
 {
@@ -4658,12 +4658,9 @@ static void show_task(struct task_struct *p)
         unsigned long free = 0;
         unsigned state;
 
-        printk("%-13.13s ", p->comm);
         state = p->state ? __ffs(p->state) + 1 : 0;
-        if (state < ARRAY_SIZE(stat_nam))
-                printk(stat_nam[state]);
-        else
-                printk("?");
+        printk("%-13.13s %c", p->comm,
+                state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
 #if (BITS_PER_LONG == 32)
         if (state == TASK_RUNNING)
                 printk(" running ");
@@ -4877,7 +4874,7 @@ static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
                 p->timestamp = p->timestamp - rq_src->timestamp_last_tick
                                 + rq_dest->timestamp_last_tick;
                 deactivate_task(p, rq_src);
-                activate_task(p, rq_dest, 0);
+                __activate_task(p, rq_dest);
                 if (TASK_PREEMPTS_CURR(p, rq_dest))
                         resched_task(rq_dest->curr);
         }
@@ -5776,7 +5773,7 @@ static unsigned long long measure_migration_cost(int cpu1, int cpu2)
         cache = vmalloc(max_size);
         if (!cache) {
                 printk("could not vmalloc %d bytes for cache!\n", 2*max_size);
-                return 1000000; // return 1 msec on very small boxen
+                return 1000000; /* return 1 msec on very small boxen */
         }
 
         while (size <= max_size) {
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 215541e26c1a..fd12f2556f0d 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -311,7 +311,7 @@ void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
         softirq_vec[nr].action = action;
 }
 
-EXPORT_SYMBOL(open_softirq);
+EXPORT_UNUSED_SYMBOL(open_softirq);  /*  June 2006  */
 
 /* Tasklets */
 struct tasklet_head
diff --git a/kernel/sys.c b/kernel/sys.c
index dbb3b9c7ea64..e236f98f7ec5 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -1983,7 +1983,7 @@ asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
                         error = current->mm->dumpable;
                         break;
                 case PR_SET_DUMPABLE:
-                        if (arg2 < 0 || arg2 > 2) {
+                        if (arg2 < 0 || arg2 > 1) {
                                 error = -EINVAL;
                                 break;
                         }
diff --git a/kernel/timer.c b/kernel/timer.c
index 396a3c024c2c..2a87430a58d4 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -891,6 +891,7 @@ int do_settimeofday(struct timespec *tv)
         set_normalized_timespec(&xtime, sec, nsec);
         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 
+        clock->error = 0;
         ntp_clear();
 
         write_sequnlock_irqrestore(&xtime_lock, flags);
@@ -1008,52 +1009,52 @@ static int __init timekeeping_init_device(void)
 device_initcall(timekeeping_init_device);
 
 /*
- * If the error is already larger, we look ahead another tick,
+ * If the error is already larger, we look ahead even further
  * to compensate for late or lost adjustments.
  */
-static __always_inline int clocksource_bigadjust(int sign, s64 error, s64 *interval, s64 *offset)
+static __always_inline int clocksource_bigadjust(s64 error, s64 *interval, s64 *offset)
 {
-        int adj;
+        s64 tick_error, i;
+        u32 look_ahead, adj;
+        s32 error2, mult;
 
         /*
-         * As soon as the machine is synchronized to the external time
-         * source this should be the common case.
+         * Use the current error value to determine how much to look ahead.
+         * The larger the error the slower we adjust for it to avoid problems
+         * with losing too many ticks, otherwise we would overadjust and
+         * produce an even larger error.  The smaller the adjustment the
+         * faster we try to adjust for it, as lost ticks can do less harm
+         * here.  This is tuned so that an error of about 1 msec is adusted
+         * within about 1 sec (or 2^20 nsec in 2^SHIFT_HZ ticks).
          */
-        error >>= 2;
-        if (likely(sign > 0 ? error <= *interval : error >= *interval))
-                return sign;
+        error2 = clock->error >> (TICK_LENGTH_SHIFT + 22 - 2 * SHIFT_HZ);
+        error2 = abs(error2);
+        for (look_ahead = 0; error2 > 0; look_ahead++)
+                error2 >>= 2;
 
         /*
-         * An extra look ahead dampens the effect of the current error,
-         * which can grow quite large with continously late updates, as
-         * it would dominate the adjustment value and can lead to
-         * oscillation.
+         * Now calculate the error in (1 << look_ahead) ticks, but first
+         * remove the single look ahead already included in the error.
          */
-        error += current_tick_length() >> (TICK_LENGTH_SHIFT - clock->shift + 1);
-        error -= clock->xtime_interval >> 1;
-
-        adj = 0;
-        while (1) {
-                error >>= 1;
-                if (sign > 0 ? error <= *interval : error >= *interval)
-                        break;
-                adj++;
+        tick_error = current_tick_length() >> (TICK_LENGTH_SHIFT - clock->shift + 1);
+        tick_error -= clock->xtime_interval >> 1;
+        error = ((error - tick_error) >> look_ahead) + tick_error;
+
+        /* Finally calculate the adjustment shift value.  */
+        i = *interval;
+        mult = 1;
+        if (error < 0) {
+                error = -error;
+                *interval = -*interval;
+                *offset = -*offset;
+                mult = -1;
         }
-
-        /*
-         * Add the current adjustments to the error and take the offset
-         * into account, the latter can cause the error to be hardly
-         * reduced at the next tick. Check the error again if there's
-         * room for another adjustment, thus further reducing the error
-         * which otherwise had to be corrected at the next update.
-         */
-        error = (error << 1) - *interval + *offset;
-        if (sign > 0 ? error > *interval : error < *interval)
-                adj++;
+        for (adj = 0; error > i; adj++)
+                error >>= 1;
 
         *interval <<= adj;
         *offset <<= adj;
-        return sign << adj;
+        return mult << adj;
 }
 
 /*
@@ -1068,11 +1069,19 @@ static void clocksource_adjust(struct clocksource *clock, s64 offset)
 
         error = clock->error >> (TICK_LENGTH_SHIFT - clock->shift - 1);
         if (error > interval) {
-                adj = clocksource_bigadjust(1, error, &interval, &offset);
+                error >>= 2;
+                if (likely(error <= interval))
+                        adj = 1;
+                else
+                        adj = clocksource_bigadjust(error, &interval, &offset);
         } else if (error < -interval) {
-                interval = -interval;
-                offset = -offset;
-                adj = clocksource_bigadjust(-1, error, &interval, &offset);
+                error >>= 2;
+                if (likely(error >= -interval)) {
+                        adj = -1;
+                        interval = -interval;
+                        offset = -offset;
+                } else
+                        adj = clocksource_bigadjust(error, &interval, &offset);
         } else
                 return;
 
@@ -1129,7 +1138,7 @@ static void update_wall_time(void)
         clocksource_adjust(clock, offset);
 
         /* store full nanoseconds into xtime */
-        xtime.tv_nsec = clock->xtime_nsec >> clock->shift;
+        xtime.tv_nsec = (s64)clock->xtime_nsec >> clock->shift;
         clock->xtime_nsec -= (s64)xtime.tv_nsec << clock->shift;
 
         /* check to see if there is a new clocksource to use */
diff --git a/kernel/wait.c b/kernel/wait.c
index a1d57aeb7f75..59a82f63275d 100644
--- a/kernel/wait.c
+++ b/kernel/wait.c
@@ -10,9 +10,13 @@
 #include <linux/wait.h>
 #include <linux/hash.h>
 
-struct lock_class_key waitqueue_lock_key;
+void init_waitqueue_head(wait_queue_head_t *q)
+{
+        spin_lock_init(&q->lock);
+        INIT_LIST_HEAD(&q->task_list);
+}
 
-EXPORT_SYMBOL(waitqueue_lock_key);
+EXPORT_SYMBOL(init_waitqueue_head);
 
 void fastcall add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
 {