19 files changed, 457 insertions, 138 deletions

diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index ac6d9b23b018..2087d6de67ea 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -1000,9 +1000,10 @@ static int audit_log_single_execve_arg(struct audit_context *context,
          * for strings that are too long, we should not have created
          * any.
          */
-        if (unlikely((len  = -1) || len > MAX_ARG_STRLEN - 1)) {
+        if (unlikely((len == -1) || len > MAX_ARG_STRLEN - 1)) {
                 WARN_ON(1);
                 send_sig(SIGKILL, current, 0);
+                return -1;
         }
 
         /* walk the whole argument looking for non-ascii chars */
@@ -1020,6 +1021,7 @@ static int audit_log_single_execve_arg(struct audit_context *context,
                 if (ret) {
                         WARN_ON(1);
                         send_sig(SIGKILL, current, 0);
+                        return -1;
                 }
                 buf[to_send] = '\0';
                 has_cntl = audit_string_contains_control(buf, to_send);
@@ -1083,6 +1085,7 @@ static int audit_log_single_execve_arg(struct audit_context *context,
                 if (ret) {
                         WARN_ON(1);
                         send_sig(SIGKILL, current, 0);
+                        return -1;
                 }
                 buf[to_send] = '\0';
 
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 4766bb65e4d9..d8abe996e009 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -113,9 +113,9 @@ static int root_count;
 #define dummytop (&rootnode.top_cgroup)
 
 /* This flag indicates whether tasks in the fork and exit paths should
- * take callback_mutex and check for fork/exit handlers to call. This
- * avoids us having to do extra work in the fork/exit path if none of the
- * subsystems need to be called.
+ * check for fork/exit handlers to call. This avoids us having to do
+ * extra work in the fork/exit path if none of the subsystems need to
+ * be called.
  */
 static int need_forkexit_callback;
 
@@ -307,7 +307,6 @@ static inline void put_css_set_taskexit(struct css_set *cg)
  * template: location in which to build the desired set of subsystem
  * state objects for the new cgroup group
  */
-
 static struct css_set *find_existing_css_set(
         struct css_set *oldcg,
         struct cgroup *cgrp,
@@ -320,7 +319,7 @@ static struct css_set *find_existing_css_set(
         /* Built the set of subsystem state objects that we want to
          * see in the new css_set */
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
-                if (root->subsys_bits & (1ull << i)) {
+                if (root->subsys_bits & (1UL << i)) {
                         /* Subsystem is in this hierarchy. So we want
                          * the subsystem state from the new
                          * cgroup */
@@ -354,7 +353,6 @@ static struct css_set *find_existing_css_set(
  * and chains them on tmp through their cgrp_link_list fields. Returns 0 on
  * success or a negative error
  */
-
 static int allocate_cg_links(int count, struct list_head *tmp)
 {
         struct cg_cgroup_link *link;
@@ -396,7 +394,6 @@ static void free_cg_links(struct list_head *tmp)
  * substituted into the appropriate hierarchy. Must be called with
  * cgroup_mutex held
  */
-
 static struct css_set *find_css_set(
         struct css_set *oldcg, struct cgroup *cgrp)
 {
@@ -473,7 +470,6 @@ static struct css_set *find_css_set(
         /* Link this cgroup group into the list */
         list_add(&res->list, &init_css_set.list);
         css_set_count++;
-        INIT_LIST_HEAD(&res->tasks);
         write_unlock(&css_set_lock);
 
         return res;
@@ -507,8 +503,8 @@ static struct css_set *find_css_set(
  * critical pieces of code here.  The exception occurs on cgroup_exit(),
  * when a task in a notify_on_release cgroup exits.  Then cgroup_mutex
  * is taken, and if the cgroup count is zero, a usermode call made
- * to /sbin/cgroup_release_agent with the name of the cgroup (path
- * relative to the root of cgroup file system) as the argument.
+ * to the release agent with the name of the cgroup (path relative to
+ * the root of cgroup file system) as the argument.
  *
  * A cgroup can only be deleted if both its 'count' of using tasks
  * is zero, and its list of 'children' cgroups is empty.  Since all
@@ -521,7 +517,7 @@ static struct css_set *find_css_set(
  *
  * The need for this exception arises from the action of
  * cgroup_attach_task(), which overwrites one tasks cgroup pointer with
- * another.  It does so using cgroup_mutexe, however there are
+ * another.  It does so using cgroup_mutex, however there are
  * several performance critical places that need to reference
  * task->cgroup without the expense of grabbing a system global
  * mutex.  Therefore except as noted below, when dereferencing or, as
@@ -537,7 +533,6 @@ static struct css_set *find_css_set(
  * cgroup_lock - lock out any changes to cgroup structures
  *
  */
-
 void cgroup_lock(void)
 {
         mutex_lock(&cgroup_mutex);
@@ -548,7 +543,6 @@ void cgroup_lock(void)
  *
  * Undo the lock taken in a previous cgroup_lock() call.
  */
-
 void cgroup_unlock(void)
 {
         mutex_unlock(&cgroup_mutex);
@@ -590,7 +584,6 @@ static struct inode *cgroup_new_inode(mode_t mode, struct super_block *sb)
  * Call subsys's pre_destroy handler.
  * This is called before css refcnt check.
  */
-
 static void cgroup_call_pre_destroy(struct cgroup *cgrp)
 {
         struct cgroup_subsys *ss;
@@ -600,7 +593,6 @@ static void cgroup_call_pre_destroy(struct cgroup *cgrp)
         return;
 }
 
-
 static void cgroup_diput(struct dentry *dentry, struct inode *inode)
 {
         /* is dentry a directory ? if so, kfree() associated cgroup */
@@ -696,7 +688,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
         added_bits = final_bits & ~root->actual_subsys_bits;
         /* Check that any added subsystems are currently free */
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
-                unsigned long long bit = 1ull << i;
+                unsigned long bit = 1UL << i;
                 struct cgroup_subsys *ss = subsys[i];
                 if (!(bit & added_bits))
                         continue;
@@ -927,7 +919,6 @@ static int cgroup_get_rootdir(struct super_block *sb)
         if (!inode)
                 return -ENOMEM;
 
-        inode->i_op = &simple_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
         inode->i_op = &cgroup_dir_inode_operations;
         /* directories start off with i_nlink == 2 (for "." entry) */
@@ -961,8 +952,11 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
         }
 
         root = kzalloc(sizeof(*root), GFP_KERNEL);
-        if (!root)
+        if (!root) {
+                if (opts.release_agent)
+                        kfree(opts.release_agent);
                 return -ENOMEM;
+        }
 
         init_cgroup_root(root);
         root->subsys_bits = opts.subsys_bits;
@@ -1129,8 +1123,13 @@ static inline struct cftype *__d_cft(struct dentry *dentry)
         return dentry->d_fsdata;
 }
 
-/*
- * Called with cgroup_mutex held.  Writes path of cgroup into buf.
+/**
+ * cgroup_path - generate the path of a cgroup
+ * @cgrp: the cgroup in question
+ * @buf: the buffer to write the path into
+ * @buflen: the length of the buffer
+ *
+ * Called with cgroup_mutex held. Writes path of cgroup into buf.
  * Returns 0 on success, -errno on error.
  */
 int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen)
@@ -1188,11 +1187,13 @@ static void get_first_subsys(const struct cgroup *cgrp,
                 *subsys_id = test_ss->subsys_id;
 }
 
-/*
- * Attach task 'tsk' to cgroup 'cgrp'
+/**
+ * cgroup_attach_task - attach task 'tsk' to cgroup 'cgrp'
+ * @cgrp: the cgroup the task is attaching to
+ * @tsk: the task to be attached
  *
- * Call holding cgroup_mutex.  May take task_lock of
- * the task 'pid' during call.
+ * Call holding cgroup_mutex. May take task_lock of
+ * the task 'tsk' during call.
  */
 int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
 {
@@ -1293,7 +1294,6 @@ static int attach_task_by_pid(struct cgroup *cgrp, char *pidbuf)
 }
 
 /* The various types of files and directories in a cgroup file system */
-
 enum cgroup_filetype {
         FILE_ROOT,
         FILE_DIR,
@@ -1584,12 +1584,11 @@ static int cgroup_create_file(struct dentry *dentry, int mode,
 }
 
 /*
- *      cgroup_create_dir - create a directory for an object.
- *      cgrp:   the cgroup we create the directory for.
- *              It must have a valid ->parent field
- *              And we are going to fill its ->dentry field.
- *      dentry: dentry of the new cgroup
- *      mode:   mode to set on new directory.
+ * cgroup_create_dir - create a directory for an object.
+ * @cgrp: the cgroup we create the directory for. It must have a valid
+ *        ->parent field. And we are going to fill its ->dentry field.
+ * @dentry: dentry of the new cgroup
+ * @mode: mode to set on new directory.
  */
 static int cgroup_create_dir(struct cgroup *cgrp, struct dentry *dentry,
                                 int mode)
@@ -1651,8 +1650,12 @@ int cgroup_add_files(struct cgroup *cgrp,
         return 0;
 }
 
-/* Count the number of tasks in a cgroup. */
-
+/**
+ * cgroup_task_count - count the number of tasks in a cgroup.
+ * @cgrp: the cgroup in question
+ *
+ * Return the number of tasks in the cgroup.
+ */
 int cgroup_task_count(const struct cgroup *cgrp)
 {
         int count = 0;
@@ -1962,12 +1965,13 @@ static int pid_array_load(pid_t *pidarray, int npids, struct cgroup *cgrp)
 }
 
 /**
- * Build and fill cgroupstats so that taskstats can export it to user
- * space.
- *
+ * cgroupstats_build - build and fill cgroupstats
  * @stats: cgroupstats to fill information into
  * @dentry: A dentry entry belonging to the cgroup for which stats have
  * been requested.
+ *
+ * Build and fill cgroupstats so that taskstats can export it to user
+ * space.
  */
 int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
 {
@@ -2199,14 +2203,13 @@ static void init_cgroup_css(struct cgroup_subsys_state *css,
 }
 
 /*
- *      cgroup_create - create a cgroup
- *      parent: cgroup that will be parent of the new cgroup.
- *      name:           name of the new cgroup. Will be strcpy'ed.
- *      mode:           mode to set on new inode
+ * cgroup_create - create a cgroup
+ * @parent: cgroup that will be parent of the new cgroup
+ * @dentry: dentry of the new cgroup
+ * @mode: mode to set on new inode
  *
- *      Must be called with the mutex on the parent inode held
+ * Must be called with the mutex on the parent inode held
  */
-
 static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
                              int mode)
 {
@@ -2349,13 +2352,12 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
         parent = cgrp->parent;
         root = cgrp->root;
         sb = root->sb;
+
         /*
-         * Call pre_destroy handlers of subsys
+         * Call pre_destroy handlers of subsys. Notify subsystems
+         * that rmdir() request comes.
          */
         cgroup_call_pre_destroy(cgrp);
-        /*
-         * Notify subsyses that rmdir() request comes.
-         */
 
         if (cgroup_has_css_refs(cgrp)) {
                 mutex_unlock(&cgroup_mutex);
@@ -2431,8 +2433,10 @@ static void cgroup_init_subsys(struct cgroup_subsys *ss)
 }
 
 /**
- * cgroup_init_early - initialize cgroups at system boot, and
- * initialize any subsystems that request early init.
+ * cgroup_init_early - cgroup initialization at system boot
+ *
+ * Initialize cgroups at system boot, and initialize any
+ * subsystems that request early init.
  */
 int __init cgroup_init_early(void)
 {
@@ -2474,8 +2478,10 @@ int __init cgroup_init_early(void)
 }
 
 /**
- * cgroup_init - register cgroup filesystem and /proc file, and
- * initialize any subsystems that didn't request early init.
+ * cgroup_init - cgroup initialization
+ *
+ * Register cgroup filesystem and /proc file, and initialize
+ * any subsystems that didn't request early init.
  */
 int __init cgroup_init(void)
 {
@@ -2618,7 +2624,7 @@ static struct file_operations proc_cgroupstats_operations = {
 
 /**
  * cgroup_fork - attach newly forked task to its parents cgroup.
- * @tsk: pointer to task_struct of forking parent process.
+ * @child: pointer to task_struct of forking parent process.
  *
  * Description: A task inherits its parent's cgroup at fork().
  *
@@ -2642,9 +2648,12 @@ void cgroup_fork(struct task_struct *child)
 }
 
 /**
- * cgroup_fork_callbacks - called on a new task very soon before
- * adding it to the tasklist. No need to take any locks since no-one
- * can be operating on this task
+ * cgroup_fork_callbacks - run fork callbacks
+ * @child: the new task
+ *
+ * Called on a new task very soon before adding it to the
+ * tasklist. No need to take any locks since no-one can
+ * be operating on this task.
  */
 void cgroup_fork_callbacks(struct task_struct *child)
 {
@@ -2659,11 +2668,14 @@ void cgroup_fork_callbacks(struct task_struct *child)
 }
 
 /**
- * cgroup_post_fork - called on a new task after adding it to the
- * task list. Adds the task to the list running through its css_set
- * if necessary. Has to be after the task is visible on the task list
- * in case we race with the first call to cgroup_iter_start() - to
- * guarantee that the new task ends up on its list. */
+ * cgroup_post_fork - called on a new task after adding it to the task list
+ * @child: the task in question
+ *
+ * Adds the task to the list running through its css_set if necessary.
+ * Has to be after the task is visible on the task list in case we race
+ * with the first call to cgroup_iter_start() - to guarantee that the
+ * new task ends up on its list.
+ */
 void cgroup_post_fork(struct task_struct *child)
 {
         if (use_task_css_set_links) {
@@ -2676,6 +2688,7 @@ void cgroup_post_fork(struct task_struct *child)
 /**
  * cgroup_exit - detach cgroup from exiting task
  * @tsk: pointer to task_struct of exiting process
+ * @run_callback: run exit callbacks?
  *
  * Description: Detach cgroup from @tsk and release it.
  *
@@ -2706,7 +2719,6 @@ void cgroup_post_fork(struct task_struct *child)
  *    top_cgroup isn't going away, and either task has PF_EXITING set,
  *    which wards off any cgroup_attach_task() attempts, or task is a failed
  *    fork, never visible to cgroup_attach_task.
- *
  */
 void cgroup_exit(struct task_struct *tsk, int run_callbacks)
 {
@@ -2743,9 +2755,13 @@ void cgroup_exit(struct task_struct *tsk, int run_callbacks)
 }
 
 /**
- * cgroup_clone - duplicate the current cgroup in the hierarchy
- * that the given subsystem is attached to, and move this task into
- * the new child
+ * cgroup_clone - clone the cgroup the given subsystem is attached to
+ * @tsk: the task to be moved
+ * @subsys: the given subsystem
+ *
+ * Duplicate the current cgroup in the hierarchy that the given
+ * subsystem is attached to, and move this task into the new
+ * child.
  */
 int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
 {
@@ -2858,9 +2874,12 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
         return ret;
 }
 
-/*
- * See if "cgrp" is a descendant of the current task's cgroup in
- * the appropriate hierarchy
+/**
+ * cgroup_is_descendant - see if @cgrp is a descendant of current task's cgrp
+ * @cgrp: the cgroup in question
+ *
+ * See if @cgrp is a descendant of the current task's cgroup in
+ * the appropriate hierarchy.
  *
  * If we are sending in dummytop, then presumably we are creating
  * the top cgroup in the subsystem.
@@ -2939,9 +2958,7 @@ void __css_put(struct cgroup_subsys_state *css)
  * release agent task.  We don't bother to wait because the caller of
  * this routine has no use for the exit status of the release agent
  * task, so no sense holding our caller up for that.
- *
  */
-
 static void cgroup_release_agent(struct work_struct *work)
 {
         BUG_ON(work != &release_agent_work);
diff --git a/kernel/futex.c b/kernel/futex.c
index 221f2128a437..06968cd79200 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -60,6 +60,8 @@
 
 #include "rtmutex_common.h"
 
+int __read_mostly futex_cmpxchg_enabled;
+
 #define FUTEX_HASHBITS (CONFIG_BASE_SMALL ? 4 : 8)
 
 /*
@@ -469,6 +471,8 @@ void exit_pi_state_list(struct task_struct *curr)
         struct futex_hash_bucket *hb;
         union futex_key key;
 
+        if (!futex_cmpxchg_enabled)
+                return;
         /*
          * We are a ZOMBIE and nobody can enqueue itself on
          * pi_state_list anymore, but we have to be careful
@@ -1870,6 +1874,8 @@ asmlinkage long
 sys_set_robust_list(struct robust_list_head __user *head,
                     size_t len)
 {
+        if (!futex_cmpxchg_enabled)
+                return -ENOSYS;
         /*
          * The kernel knows only one size for now:
          */
@@ -1894,6 +1900,9 @@ sys_get_robust_list(int pid, struct robust_list_head __user * __user *head_ptr,
         struct robust_list_head __user *head;
         unsigned long ret;
 
+        if (!futex_cmpxchg_enabled)
+                return -ENOSYS;
+
         if (!pid)
                 head = current->robust_list;
         else {
@@ -1997,6 +2006,9 @@ void exit_robust_list(struct task_struct *curr)
         unsigned long futex_offset;
         int rc;
 
+        if (!futex_cmpxchg_enabled)
+                return;
+
         /*
          * Fetch the list head (which was registered earlier, via
          * sys_set_robust_list()):
@@ -2051,7 +2063,7 @@ void exit_robust_list(struct task_struct *curr)
 long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
                 u32 __user *uaddr2, u32 val2, u32 val3)
 {
-        int ret;
+        int ret = -ENOSYS;
         int cmd = op & FUTEX_CMD_MASK;
         struct rw_semaphore *fshared = NULL;
 
@@ -2083,13 +2095,16 @@ long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
                 ret = futex_wake_op(uaddr, fshared, uaddr2, val, val2, val3);
                 break;
         case FUTEX_LOCK_PI:
-                ret = futex_lock_pi(uaddr, fshared, val, timeout, 0);
+                if (futex_cmpxchg_enabled)
+                        ret = futex_lock_pi(uaddr, fshared, val, timeout, 0);
                 break;
         case FUTEX_UNLOCK_PI:
-                ret = futex_unlock_pi(uaddr, fshared);
+                if (futex_cmpxchg_enabled)
+                        ret = futex_unlock_pi(uaddr, fshared);
                 break;
         case FUTEX_TRYLOCK_PI:
-                ret = futex_lock_pi(uaddr, fshared, 0, timeout, 1);
+                if (futex_cmpxchg_enabled)
+                        ret = futex_lock_pi(uaddr, fshared, 0, timeout, 1);
                 break;
         default:
                 ret = -ENOSYS;
@@ -2145,8 +2160,29 @@ static struct file_system_type futex_fs_type = {
 
 static int __init init(void)
 {
-        int i = register_filesystem(&futex_fs_type);
+        u32 curval;
+        int i;
+
+        /*
+         * This will fail and we want it. Some arch implementations do
+         * runtime detection of the futex_atomic_cmpxchg_inatomic()
+         * functionality. We want to know that before we call in any
+         * of the complex code paths. Also we want to prevent
+         * registration of robust lists in that case. NULL is
+         * guaranteed to fault and we get -EFAULT on functional
+         * implementation, the non functional ones will return
+         * -ENOSYS.
+         */
+        curval = cmpxchg_futex_value_locked(NULL, 0, 0);
+        if (curval == -EFAULT)
+                futex_cmpxchg_enabled = 1;
 
+        for (i = 0; i < ARRAY_SIZE(futex_queues); i++) {
+                plist_head_init(&futex_queues[i].chain, &futex_queues[i].lock);
+                spin_lock_init(&futex_queues[i].lock);
+        }
+
+        i = register_filesystem(&futex_fs_type);
         if (i)
                 return i;
 
@@ -2156,10 +2192,6 @@ static int __init init(void)
                 return PTR_ERR(futex_mnt);
         }
 
-        for (i = 0; i < ARRAY_SIZE(futex_queues); i++) {
-                plist_head_init(&futex_queues[i].chain, &futex_queues[i].lock);
-                spin_lock_init(&futex_queues[i].lock);
-        }
         return 0;
 }
 __initcall(init);
diff --git a/kernel/futex_compat.c b/kernel/futex_compat.c
index 7d5e4b016f39..ff90f049f8f6 100644
--- a/kernel/futex_compat.c
+++ b/kernel/futex_compat.c
@@ -54,6 +54,9 @@ void compat_exit_robust_list(struct task_struct *curr)
         compat_long_t futex_offset;
         int rc;
 
+        if (!futex_cmpxchg_enabled)
+                return;
+
         /*
          * Fetch the list head (which was registered earlier, via
          * sys_set_robust_list()):
@@ -115,6 +118,9 @@ asmlinkage long
 compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
                            compat_size_t len)
 {
+        if (!futex_cmpxchg_enabled)
+                return -ENOSYS;
+
         if (unlikely(len != sizeof(*head)))
                 return -EINVAL;
 
@@ -130,6 +136,9 @@ compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
         struct compat_robust_list_head __user *head;
         unsigned long ret;
 
+        if (!futex_cmpxchg_enabled)
+                return -ENOSYS;
+
         if (!pid)
                 head = current->compat_robust_list;
         else {
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index cc54c6276356..fdb3fbe2b0c4 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -246,6 +246,17 @@ static unsigned int default_startup(unsigned int irq)
 }
 
 /*
+ * default shutdown function
+ */
+static void default_shutdown(unsigned int irq)
+{
+        struct irq_desc *desc = irq_desc + irq;
+
+        desc->chip->mask(irq);
+        desc->status |= IRQ_MASKED;
+}
+
+/*
  * Fixup enable/disable function pointers
  */
 void irq_chip_set_defaults(struct irq_chip *chip)
@@ -256,8 +267,15 @@ void irq_chip_set_defaults(struct irq_chip *chip)
                 chip->disable = default_disable;
         if (!chip->startup)
                 chip->startup = default_startup;
+        /*
+         * We use chip->disable, when the user provided its own. When
+         * we have default_disable set for chip->disable, then we need
+         * to use default_shutdown, otherwise the irq line is not
+         * disabled on free_irq():
+         */
         if (!chip->shutdown)
-                chip->shutdown = chip->disable;
+                chip->shutdown = chip->disable != default_disable ?
+                        chip->disable : default_shutdown;
         if (!chip->name)
                 chip->name = chip->typename;
         if (!chip->end)
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index a6b2bc831dd0..088dabbf2d6a 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -6,6 +6,7 @@
  * This file contains spurious interrupt handling.
  */
 
+#include <linux/jiffies.h>
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/kallsyms.h>
@@ -179,7 +180,7 @@ void note_interrupt(unsigned int irq, struct irq_desc *desc,
                  * otherwise the couter becomes a doomsday timer for otherwise
                  * working systems
                  */
-                if (jiffies - desc->last_unhandled > HZ/10)
+                if (time_after(jiffies, desc->last_unhandled + HZ/10))
                         desc->irqs_unhandled = 1;
                 else
                         desc->irqs_unhandled++;
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 3574379f4d62..81a4e4a3f087 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -779,6 +779,10 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force)
          * parallel walking of the hash-list safe:
          */
         list_add_tail_rcu(&class->hash_entry, hash_head);
+        /*
+         * Add it to the global list of classes:
+         */
+        list_add_tail_rcu(&class->lock_entry, &all_lock_classes);
 
         if (verbose(class)) {
                 graph_unlock();
@@ -2282,10 +2286,6 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this,
                         return 0;
                 break;
         case LOCK_USED:
-                /*
-                 * Add it to the global list of classes:
-                 */
-                list_add_tail_rcu(&this->class->lock_entry, &all_lock_classes);
                 debug_atomic_dec(&nr_unused_locks);
                 break;
         default:
diff --git a/kernel/marker.c b/kernel/marker.c
index c4c2cd8b61f5..50effc01d9a2 100644
--- a/kernel/marker.c
+++ b/kernel/marker.c
@@ -61,8 +61,8 @@ struct marker_entry {
         int refcount;   /* Number of times armed. 0 if disarmed. */
         struct rcu_head rcu;
         void *oldptr;
-        char rcu_pending:1;
-        char ptype:1;
+        unsigned char rcu_pending:1;
+        unsigned char ptype:1;
         char name[0];   /* Contains name'\0'format'\0' */
 };
 
diff --git a/kernel/module.c b/kernel/module.c
index 92595bad3812..901cd6ac2f11 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -987,12 +987,11 @@ static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
         return ret;
 }
 
-
 /*
  * /sys/module/foo/sections stuff
  * J. Corbet <corbet@lwn.net>
  */
-#ifdef CONFIG_KALLSYMS
+#if defined(CONFIG_KALLSYMS) && defined(CONFIG_SYSFS)
 static ssize_t module_sect_show(struct module_attribute *mattr,
                                 struct module *mod, char *buf)
 {
@@ -1188,7 +1187,7 @@ static inline void add_notes_attrs(struct module *mod, unsigned int nsect,
 static inline void remove_notes_attrs(struct module *mod)
 {
 }
-#endif /* CONFIG_KALLSYMS */
+#endif
 
 #ifdef CONFIG_SYSFS
 int module_add_modinfo_attrs(struct module *mod)
@@ -1231,9 +1230,7 @@ void module_remove_modinfo_attrs(struct module *mod)
         }
         kfree(mod->modinfo_attrs);
 }
-#endif
 
-#ifdef CONFIG_SYSFS
 int mod_sysfs_init(struct module *mod)
 {
         int err;
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 859a8e59773a..14a656cdc652 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -391,7 +391,7 @@ int hibernation_platform_enter(void)
                 goto Close;
 
         suspend_console();
-        error = device_suspend(PMSG_SUSPEND);
+        error = device_suspend(PMSG_HIBERNATE);
         if (error)
                 goto Resume_console;
 
@@ -404,7 +404,7 @@ int hibernation_platform_enter(void)
                 goto Finish;
 
         local_irq_disable();
-        error = device_power_down(PMSG_SUSPEND);
+        error = device_power_down(PMSG_HIBERNATE);
         if (!error) {
                 hibernation_ops->enter();
                 /* We should never get here */
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index 95250d7c8d91..72a020cabb4c 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -875,8 +875,8 @@ static inline void *saveable_highmem_page(unsigned long pfn) { return NULL; }
 #endif /* CONFIG_HIGHMEM */
 
 /**
- *      saveable - Determine whether a non-highmem page should be included in
- *      the suspend image.
+ *      saveable_page - Determine whether a non-highmem page should be included
+ *      in the suspend image.
  *
  *      We should save the page if it isn't Nosave, and is not in the range
  *      of pages statically defined as 'unsaveable', and it isn't a part of
@@ -897,7 +897,8 @@ static struct page *saveable_page(unsigned long pfn)
         if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page))
                 return NULL;
 
-        if (PageReserved(page) && pfn_is_nosave(pfn))
+        if (PageReserved(page)
+            && (!kernel_page_present(page) || pfn_is_nosave(pfn)))
                 return NULL;
 
         return page;
@@ -938,6 +939,25 @@ static inline void do_copy_page(long *dst, long *src)
                 *dst++ = *src++;
 }
 
+
+/**
+ *      safe_copy_page - check if the page we are going to copy is marked as
+ *              present in the kernel page tables (this always is the case if
+ *              CONFIG_DEBUG_PAGEALLOC is not set and in that case
+ *              kernel_page_present() always returns 'true').
+ */
+static void safe_copy_page(void *dst, struct page *s_page)
+{
+        if (kernel_page_present(s_page)) {
+                do_copy_page(dst, page_address(s_page));
+        } else {
+                kernel_map_pages(s_page, 1, 1);
+                do_copy_page(dst, page_address(s_page));
+                kernel_map_pages(s_page, 1, 0);
+        }
+}
+
+
 #ifdef CONFIG_HIGHMEM
 static inline struct page *
 page_is_saveable(struct zone *zone, unsigned long pfn)
@@ -946,8 +966,7 @@ page_is_saveable(struct zone *zone, unsigned long pfn)
                         saveable_highmem_page(pfn) : saveable_page(pfn);
 }
 
-static inline void
-copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
+static void copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
 {
         struct page *s_page, *d_page;
         void *src, *dst;
@@ -961,29 +980,26 @@ copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
                 kunmap_atomic(src, KM_USER0);
                 kunmap_atomic(dst, KM_USER1);
         } else {
-                src = page_address(s_page);
                 if (PageHighMem(d_page)) {
                         /* Page pointed to by src may contain some kernel
                          * data modified by kmap_atomic()
                          */
-                        do_copy_page(buffer, src);
+                        safe_copy_page(buffer, s_page);
                         dst = kmap_atomic(pfn_to_page(dst_pfn), KM_USER0);
                         memcpy(dst, buffer, PAGE_SIZE);
                         kunmap_atomic(dst, KM_USER0);
                 } else {
-                        dst = page_address(d_page);
-                        do_copy_page(dst, src);
+                        safe_copy_page(page_address(d_page), s_page);
                 }
         }
 }
 #else
 #define page_is_saveable(zone, pfn)     saveable_page(pfn)
 
-static inline void
-copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
+static inline void copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
 {
-        do_copy_page(page_address(pfn_to_page(dst_pfn)),
-                        page_address(pfn_to_page(src_pfn)));
+        safe_copy_page(page_address(pfn_to_page(dst_pfn)),
+                                pfn_to_page(src_pfn));
 }
 #endif /* CONFIG_HIGHMEM */
 
diff --git a/kernel/printk.c b/kernel/printk.c
index bee36100f110..9adc2a473e6e 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -666,7 +666,7 @@ asmlinkage int vprintk(const char *fmt, va_list args)
         }
         /* Emit the output into the temporary buffer */
         printed_len += vscnprintf(printk_buf + printed_len,
-                                  sizeof(printk_buf), fmt, args);
+                                  sizeof(printk_buf) - printed_len, fmt, args);
 
         /*
          * Copy the output into log_buf.  If the caller didn't provide
diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
index 987cfb7ade89..e9517014b57c 100644
--- a/kernel/rcupreempt.c
+++ b/kernel/rcupreempt.c
@@ -23,6 +23,10 @@
  *              to Suparna Bhattacharya for pushing me completely away
  *              from atomic instructions on the read side.
  *
+ *  - Added handling of Dynamic Ticks
+ *      Copyright 2007 - Paul E. Mckenney <paulmck@us.ibm.com>
+ *                     - Steven Rostedt <srostedt@redhat.com>
+ *
  * Papers:  http://www.rdrop.com/users/paulmck/RCU
  *
  * Design Document: http://lwn.net/Articles/253651/
@@ -409,6 +413,212 @@ static void __rcu_advance_callbacks(struct rcu_data *rdp)
         }
 }
 
+#ifdef CONFIG_NO_HZ
+
+DEFINE_PER_CPU(long, dynticks_progress_counter) = 1;
+static DEFINE_PER_CPU(long, rcu_dyntick_snapshot);
+static DEFINE_PER_CPU(int, rcu_update_flag);
+
+/**
+ * rcu_irq_enter - Called from Hard irq handlers and NMI/SMI.
+ *
+ * If the CPU was idle with dynamic ticks active, this updates the
+ * dynticks_progress_counter to let the RCU handling know that the
+ * CPU is active.
+ */
+void rcu_irq_enter(void)
+{
+        int cpu = smp_processor_id();
+
+        if (per_cpu(rcu_update_flag, cpu))
+                per_cpu(rcu_update_flag, cpu)++;
+
+        /*
+         * Only update if we are coming from a stopped ticks mode
+         * (dynticks_progress_counter is even).
+         */
+        if (!in_interrupt() &&
+            (per_cpu(dynticks_progress_counter, cpu) & 0x1) == 0) {
+                /*
+                 * The following might seem like we could have a race
+                 * with NMI/SMIs. But this really isn't a problem.
+                 * Here we do a read/modify/write, and the race happens
+                 * when an NMI/SMI comes in after the read and before
+                 * the write. But NMI/SMIs will increment this counter
+                 * twice before returning, so the zero bit will not
+                 * be corrupted by the NMI/SMI which is the most important
+                 * part.
+                 *
+                 * The only thing is that we would bring back the counter
+                 * to a postion that it was in during the NMI/SMI.
+                 * But the zero bit would be set, so the rest of the
+                 * counter would again be ignored.
+                 *
+                 * On return from the IRQ, the counter may have the zero
+                 * bit be 0 and the counter the same as the return from
+                 * the NMI/SMI. If the state machine was so unlucky to
+                 * see that, it still doesn't matter, since all
+                 * RCU read-side critical sections on this CPU would
+                 * have already completed.
+                 */
+                per_cpu(dynticks_progress_counter, cpu)++;
+                /*
+                 * The following memory barrier ensures that any
+                 * rcu_read_lock() primitives in the irq handler
+                 * are seen by other CPUs to follow the above
+                 * increment to dynticks_progress_counter. This is
+                 * required in order for other CPUs to correctly
+                 * determine when it is safe to advance the RCU
+                 * grace-period state machine.
+                 */
+                smp_mb(); /* see above block comment. */
+                /*
+                 * Since we can't determine the dynamic tick mode from
+                 * the dynticks_progress_counter after this routine,
+                 * we use a second flag to acknowledge that we came
+                 * from an idle state with ticks stopped.
+                 */
+                per_cpu(rcu_update_flag, cpu)++;
+                /*
+                 * If we take an NMI/SMI now, they will also increment
+                 * the rcu_update_flag, and will not update the
+                 * dynticks_progress_counter on exit. That is for
+                 * this IRQ to do.
+                 */
+        }
+}
+
+/**
+ * rcu_irq_exit - Called from exiting Hard irq context.
+ *
+ * If the CPU was idle with dynamic ticks active, update the
+ * dynticks_progress_counter to put let the RCU handling be
+ * aware that the CPU is going back to idle with no ticks.
+ */
+void rcu_irq_exit(void)
+{
+        int cpu = smp_processor_id();
+
+        /*
+         * rcu_update_flag is set if we interrupted the CPU
+         * when it was idle with ticks stopped.
+         * Once this occurs, we keep track of interrupt nesting
+         * because a NMI/SMI could also come in, and we still
+         * only want the IRQ that started the increment of the
+         * dynticks_progress_counter to be the one that modifies
+         * it on exit.
+         */
+        if (per_cpu(rcu_update_flag, cpu)) {
+                if (--per_cpu(rcu_update_flag, cpu))
+                        return;
+
+                /* This must match the interrupt nesting */
+                WARN_ON(in_interrupt());
+
+                /*
+                 * If an NMI/SMI happens now we are still
+                 * protected by the dynticks_progress_counter being odd.
+                 */
+
+                /*
+                 * The following memory barrier ensures that any
+                 * rcu_read_unlock() primitives in the irq handler
+                 * are seen by other CPUs to preceed the following
+                 * increment to dynticks_progress_counter. This
+                 * is required in order for other CPUs to determine
+                 * when it is safe to advance the RCU grace-period
+                 * state machine.
+                 */
+                smp_mb(); /* see above block comment. */
+                per_cpu(dynticks_progress_counter, cpu)++;
+                WARN_ON(per_cpu(dynticks_progress_counter, cpu) & 0x1);
+        }
+}
+
+static void dyntick_save_progress_counter(int cpu)
+{
+        per_cpu(rcu_dyntick_snapshot, cpu) =
+                per_cpu(dynticks_progress_counter, cpu);
+}
+
+static inline int
+rcu_try_flip_waitack_needed(int cpu)
+{
+        long curr;
+        long snap;
+
+        curr = per_cpu(dynticks_progress_counter, cpu);
+        snap = per_cpu(rcu_dyntick_snapshot, cpu);
+        smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
+
+        /*
+         * If the CPU remained in dynticks mode for the entire time
+         * and didn't take any interrupts, NMIs, SMIs, or whatever,
+         * then it cannot be in the middle of an rcu_read_lock(), so
+         * the next rcu_read_lock() it executes must use the new value
+         * of the counter.  So we can safely pretend that this CPU
+         * already acknowledged the counter.
+         */
+
+        if ((curr == snap) && ((curr & 0x1) == 0))
+                return 0;
+
+        /*
+         * If the CPU passed through or entered a dynticks idle phase with
+         * no active irq handlers, then, as above, we can safely pretend
+         * that this CPU already acknowledged the counter.
+         */
+
+        if ((curr - snap) > 2 || (snap & 0x1) == 0)
+                return 0;
+
+        /* We need this CPU to explicitly acknowledge the counter flip. */
+
+        return 1;
+}
+
+static inline int
+rcu_try_flip_waitmb_needed(int cpu)
+{
+        long curr;
+        long snap;
+
+        curr = per_cpu(dynticks_progress_counter, cpu);
+        snap = per_cpu(rcu_dyntick_snapshot, cpu);
+        smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
+
+        /*
+         * If the CPU remained in dynticks mode for the entire time
+         * and didn't take any interrupts, NMIs, SMIs, or whatever,
+         * then it cannot have executed an RCU read-side critical section
+         * during that time, so there is no need for it to execute a
+         * memory barrier.
+         */
+
+        if ((curr == snap) && ((curr & 0x1) == 0))
+                return 0;
+
+        /*
+         * If the CPU either entered or exited an outermost interrupt,
+         * SMI, NMI, or whatever handler, then we know that it executed
+         * a memory barrier when doing so.  So we don't need another one.
+         */
+        if (curr != snap)
+                return 0;
+
+        /* We need the CPU to execute a memory barrier. */
+
+        return 1;
+}
+
+#else /* !CONFIG_NO_HZ */
+
+# define dyntick_save_progress_counter(cpu)     do { } while (0)
+# define rcu_try_flip_waitack_needed(cpu)       (1)
+# define rcu_try_flip_waitmb_needed(cpu)        (1)
+
+#endif /* CONFIG_NO_HZ */
+
 /*
  * Get here when RCU is idle.  Decide whether we need to
  * move out of idle state, and return non-zero if so.
@@ -447,8 +657,10 @@ rcu_try_flip_idle(void)
 
         /* Now ask each CPU for acknowledgement of the flip. */
 
-        for_each_cpu_mask(cpu, rcu_cpu_online_map)
+        for_each_cpu_mask(cpu, rcu_cpu_online_map) {
                 per_cpu(rcu_flip_flag, cpu) = rcu_flipped;
+                dyntick_save_progress_counter(cpu);
+        }
 
         return 1;
 }
@@ -464,7 +676,8 @@ rcu_try_flip_waitack(void)
 
         RCU_TRACE_ME(rcupreempt_trace_try_flip_a1);
         for_each_cpu_mask(cpu, rcu_cpu_online_map)
-                if (per_cpu(rcu_flip_flag, cpu) != rcu_flip_seen) {
+                if (rcu_try_flip_waitack_needed(cpu) &&
+                    per_cpu(rcu_flip_flag, cpu) != rcu_flip_seen) {
                         RCU_TRACE_ME(rcupreempt_trace_try_flip_ae1);
                         return 0;
                 }
@@ -509,8 +722,10 @@ rcu_try_flip_waitzero(void)
         smp_mb();  /*  ^^^^^^^^^^^^ */
 
         /* Call for a memory barrier from each CPU. */
-        for_each_cpu_mask(cpu, rcu_cpu_online_map)
+        for_each_cpu_mask(cpu, rcu_cpu_online_map) {
                 per_cpu(rcu_mb_flag, cpu) = rcu_mb_needed;
+                dyntick_save_progress_counter(cpu);
+        }
 
         RCU_TRACE_ME(rcupreempt_trace_try_flip_z2);
         return 1;
@@ -528,7 +743,8 @@ rcu_try_flip_waitmb(void)
 
         RCU_TRACE_ME(rcupreempt_trace_try_flip_m1);
         for_each_cpu_mask(cpu, rcu_cpu_online_map)
-                if (per_cpu(rcu_mb_flag, cpu) != rcu_mb_done) {
+                if (rcu_try_flip_waitmb_needed(cpu) &&
+                    per_cpu(rcu_mb_flag, cpu) != rcu_mb_done) {
                         RCU_TRACE_ME(rcupreempt_trace_try_flip_me1);
                         return 0;
                 }
@@ -702,8 +918,9 @@ void rcu_offline_cpu(int cpu)
          * fix.
          */
 
+        local_irq_save(flags);
         rdp = RCU_DATA_ME();
-        spin_lock_irqsave(&rdp->lock, flags);
+        spin_lock(&rdp->lock);
         *rdp->nexttail = list;
         if (list)
                 rdp->nexttail = tail;
@@ -735,9 +952,11 @@ static void rcu_process_callbacks(struct softirq_action *unused)
 {
         unsigned long flags;
         struct rcu_head *next, *list;
-        struct rcu_data *rdp = RCU_DATA_ME();
+        struct rcu_data *rdp;
 
-        spin_lock_irqsave(&rdp->lock, flags);
+        local_irq_save(flags);
+        rdp = RCU_DATA_ME();
+        spin_lock(&rdp->lock);
         list = rdp->donelist;
         if (list == NULL) {
                 spin_unlock_irqrestore(&rdp->lock, flags);
diff --git a/kernel/sched.c b/kernel/sched.c
index f28f19e65b59..f06950c8a6ce 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -668,6 +668,8 @@ const_debug unsigned int sysctl_sched_nr_migrate = 32;
  */
 unsigned int sysctl_sched_rt_period = 1000000;
 
+static __read_mostly int scheduler_running;
+
 /*
  * part of the period that we allow rt tasks to run in us.
  * default: 0.95s
@@ -689,14 +691,16 @@ unsigned long long cpu_clock(int cpu)
         unsigned long flags;
         struct rq *rq;
 
-        local_irq_save(flags);
-        rq = cpu_rq(cpu);
         /*
          * Only call sched_clock() if the scheduler has already been
          * initialized (some code might call cpu_clock() very early):
          */
-        if (rq->idle)
-                update_rq_clock(rq);
+        if (unlikely(!scheduler_running))
+                return 0;
+
+        local_irq_save(flags);
+        rq = cpu_rq(cpu);
+        update_rq_clock(rq);
         now = rq->clock;
         local_irq_restore(flags);
 
@@ -1831,6 +1835,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
         long old_state;
         struct rq *rq;
 
+        smp_wmb();
         rq = task_rq_lock(p, &flags);
         old_state = p->state;
         if (!(old_state & state))
@@ -3766,7 +3771,7 @@ void scheduler_tick(void)
 
 #if defined(CONFIG_PREEMPT) && defined(CONFIG_DEBUG_PREEMPT)
 
-void add_preempt_count(int val)
+void __kprobes add_preempt_count(int val)
 {
         /*
          * Underflow?
@@ -3782,7 +3787,7 @@ void add_preempt_count(int val)
 }
 EXPORT_SYMBOL(add_preempt_count);
 
-void sub_preempt_count(int val)
+void __kprobes sub_preempt_count(int val)
 {
         /*
          * Underflow?
@@ -3884,7 +3889,7 @@ pick_next_task(struct rq *rq, struct task_struct *prev)
 asmlinkage void __sched schedule(void)
 {
         struct task_struct *prev, *next;
-        long *switch_count;
+        unsigned long *switch_count;
         struct rq *rq;
         int cpu;
 
@@ -7283,6 +7288,8 @@ void __init sched_init(void)
          * During early bootup we pretend to be a normal task:
          */
         current->sched_class = &fair_sched_class;
+
+        scheduler_running = 1;
 }
 
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 6c091d6e159d..c8e6492c5925 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -202,17 +202,12 @@ static struct sched_entity *__pick_next_entity(struct cfs_rq *cfs_rq)
 
 static inline struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
 {
-        struct rb_node **link = &cfs_rq->tasks_timeline.rb_node;
-        struct sched_entity *se = NULL;
-        struct rb_node *parent;
+        struct rb_node *last = rb_last(&cfs_rq->tasks_timeline);
 
-        while (*link) {
-                parent = *link;
-                se = rb_entry(parent, struct sched_entity, run_node);
-                link = &parent->rb_right;
-        }
+        if (!last)
+                return NULL;
 
-        return se;
+        return rb_entry(last, struct sched_entity, run_node);
 }
 
 /**************************************************************
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 5b3aea5f471e..31e9f2a47928 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -313,6 +313,7 @@ void irq_exit(void)
         /* Make sure that timer wheel updates are propagated */
         if (!in_interrupt() && idle_cpu(smp_processor_id()) && !need_resched())
                 tick_nohz_stop_sched_tick();
+        rcu_irq_exit();
 #endif
         preempt_enable_no_resched();
 }
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 7c2da88db4ed..01b6522fd92b 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -216,26 +216,27 @@ static int watchdog(void *__bind_cpu)
         /* initialize timestamp */
         touch_softlockup_watchdog();
 
+        set_current_state(TASK_INTERRUPTIBLE);
         /*
          * Run briefly once per second to reset the softlockup timestamp.
          * If this gets delayed for more than 60 seconds then the
          * debug-printout triggers in softlockup_tick().
          */
         while (!kthread_should_stop()) {
-                set_current_state(TASK_INTERRUPTIBLE);
                 touch_softlockup_watchdog();
                 schedule();
 
                 if (kthread_should_stop())
                         break;
 
-                if (this_cpu != check_cpu)
-                        continue;
-
-                if (sysctl_hung_task_timeout_secs)
-                        check_hung_uninterruptible_tasks(this_cpu);
+                if (this_cpu == check_cpu) {
+                        if (sysctl_hung_task_timeout_secs)
+                                check_hung_uninterruptible_tasks(this_cpu);
+                }
 
+                set_current_state(TASK_INTERRUPTIBLE);
         }
+        __set_current_state(TASK_RUNNING);
 
         return 0;
 }
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index fa9bb73dbdb4..2968298f8f36 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -282,6 +282,7 @@ void tick_nohz_stop_sched_tick(void)
                         ts->idle_tick = ts->sched_timer.expires;
                         ts->tick_stopped = 1;
                         ts->idle_jiffies = last_jiffies;
+                        rcu_enter_nohz();
                 }
 
                 /*
@@ -375,6 +376,8 @@ void tick_nohz_restart_sched_tick(void)
                 return;
         }
 
+        rcu_exit_nohz();
+
         /* Update jiffies first */
         select_nohz_load_balancer(0);
         now = ktime_get();
diff --git a/kernel/time/timer_list.c b/kernel/time/timer_list.c
index d3d94c1a0fd2..67fe8fc21fb1 100644
--- a/kernel/time/timer_list.c
+++ b/kernel/time/timer_list.c
@@ -65,9 +65,9 @@ print_timer(struct seq_file *m, struct hrtimer *timer, int idx, u64 now)
         SEQ_printf(m, ", %s/%d", tmp, timer->start_pid);
 #endif
         SEQ_printf(m, "\n");
-        SEQ_printf(m, " # expires at %Lu nsecs [in %Lu nsecs]\n",
+        SEQ_printf(m, " # expires at %Lu nsecs [in %Ld nsecs]\n",
                 (unsigned long long)ktime_to_ns(timer->expires),
-                (unsigned long long)(ktime_to_ns(timer->expires) - now));
+                (long long)(ktime_to_ns(timer->expires) - now));
 }
 
 static void