12 files changed, 172 insertions, 71 deletions

diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 1bf093dcffe0..359645cff5b2 100644
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -304,7 +304,7 @@ int __init audit_register_class(int class, unsigned *list)
 
 int audit_match_class(int class, unsigned syscall)
 {
-        if (unlikely(syscall >= AUDIT_BITMASK_SIZE * sizeof(__u32)))
+        if (unlikely(syscall >= AUDIT_BITMASK_SIZE * 32))
                 return 0;
         if (unlikely(class >= AUDIT_SYSCALL_CLASSES || !classes[class]))
                 return 0;
@@ -456,6 +456,13 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
                 case AUDIT_DEVMINOR:
                 case AUDIT_EXIT:
                 case AUDIT_SUCCESS:
+                        /* bit ops are only useful on syscall args */
+                        if (f->op == AUDIT_BIT_MASK ||
+                                                f->op == AUDIT_BIT_TEST) {
+                                err = -EINVAL;
+                                goto exit_free;
+                        }
+                        break;
                 case AUDIT_ARG0:
                 case AUDIT_ARG1:
                 case AUDIT_ARG2:
@@ -1566,6 +1573,10 @@ int audit_comparator(const u32 left, const u32 op, const u32 right)
                 return (left > right);
         case AUDIT_GREATER_THAN_OR_EQUAL:
                 return (left >= right);
+        case AUDIT_BIT_MASK:
+                return (left & right);
+        case AUDIT_BIT_TEST:
+                return ((left & right) == right);
         }
         BUG();
         return 0;
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index 145cbb79c4b9..bde1124d5908 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -173,12 +173,6 @@ struct audit_aux_data_fd_pair {
         int     fd[2];
 };
 
-struct audit_aux_data_path {
-        struct audit_aux_data   d;
-        struct dentry           *dentry;
-        struct vfsmount         *mnt;
-};
-
 struct audit_aux_data_pids {
         struct audit_aux_data   d;
         pid_t                   target_pid[AUDIT_AUX_PIDS];
@@ -654,12 +648,6 @@ static inline void audit_free_aux(struct audit_context *context)
         struct audit_aux_data *aux;
 
         while ((aux = context->aux)) {
-                if (aux->type == AUDIT_AVC_PATH) {
-                        struct audit_aux_data_path *axi = (void *)aux;
-                        dput(axi->dentry);
-                        mntput(axi->mnt);
-                }
-
                 context->aux = aux->next;
                 kfree(aux);
         }
@@ -995,7 +983,7 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                 case AUDIT_IPC: {
                         struct audit_aux_data_ipcctl *axi = (void *)aux;
                         audit_log_format(ab, 
-                                 "ouid=%u ogid=%u mode=%x",
+                                 "ouid=%u ogid=%u mode=%#o",
                                  axi->uid, axi->gid, axi->mode);
                         if (axi->osid != 0) {
                                 char *ctx = NULL;
@@ -1014,7 +1002,7 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                 case AUDIT_IPC_SET_PERM: {
                         struct audit_aux_data_ipcctl *axi = (void *)aux;
                         audit_log_format(ab,
-                                "qbytes=%lx ouid=%u ogid=%u mode=%x",
+                                "qbytes=%lx ouid=%u ogid=%u mode=%#o",
                                 axi->qbytes, axi->uid, axi->gid, axi->mode);
                         break; }
 
@@ -1038,11 +1026,6 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                         audit_log_hex(ab, axs->a, axs->len);
                         break; }
 
-                case AUDIT_AVC_PATH: {
-                        struct audit_aux_data_path *axi = (void *)aux;
-                        audit_log_d_path(ab, "path=", axi->dentry, axi->mnt);
-                        break; }
-
                 case AUDIT_FD_PAIR: {
                         struct audit_aux_data_fd_pair *axs = (void *)aux;
                         audit_log_format(ab, "fd0=%d fd1=%d", axs->fd[0], axs->fd[1]);
@@ -1991,36 +1974,6 @@ void __audit_ptrace(struct task_struct *t)
 }
 
 /**
- * audit_avc_path - record the granting or denial of permissions
- * @dentry: dentry to record
- * @mnt: mnt to record
- *
- * Returns 0 for success or NULL context or < 0 on error.
- *
- * Called from security/selinux/avc.c::avc_audit()
- */
-int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt)
-{
-        struct audit_aux_data_path *ax;
-        struct audit_context *context = current->audit_context;
-
-        if (likely(!context))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->dentry = dget(dentry);
-        ax->mnt = mntget(mnt);
-
-        ax->d.type = AUDIT_AVC_PATH;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
-}
-
-/**
  * audit_signal_info - record signal info for shutting down audit subsystem
  * @sig: signal value
  * @t: task being signaled
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 72d034258ba1..eb1ddebd2c04 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -558,7 +558,8 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
  */
 static int hrtimer_switch_to_hres(void)
 {
-        struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
+        int cpu = smp_processor_id();
+        struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);
         unsigned long flags;
 
         if (base->hres_active)
@@ -568,6 +569,8 @@ static int hrtimer_switch_to_hres(void)
 
         if (tick_init_highres()) {
                 local_irq_restore(flags);
+                printk(KERN_WARNING "Could not switch to high resolution "
+                                    "mode on CPU %d\n", cpu);
                 return 0;
         }
         base->hres_active = 1;
@@ -683,6 +686,7 @@ static void enqueue_hrtimer(struct hrtimer *timer,
         struct rb_node **link = &base->active.rb_node;
         struct rb_node *parent = NULL;
         struct hrtimer *entry;
+        int leftmost = 1;
 
         /*
          * Find the right place in the rbtree:
@@ -694,18 +698,19 @@ static void enqueue_hrtimer(struct hrtimer *timer,
                  * We dont care about collisions. Nodes with
                  * the same expiry time stay together.
                  */
-                if (timer->expires.tv64 < entry->expires.tv64)
+                if (timer->expires.tv64 < entry->expires.tv64) {
                         link = &(*link)->rb_left;
-                else
+                } else {
                         link = &(*link)->rb_right;
+                        leftmost = 0;
+                }
         }
 
         /*
          * Insert the timer to the rbtree and check whether it
          * replaces the first pending timer
          */
-        if (!base->first || timer->expires.tv64 <
-            rb_entry(base->first, struct hrtimer, node)->expires.tv64) {
+        if (leftmost) {
                 /*
                  * Reprogram the clock event device. When the timer is already
                  * expired hrtimer_enqueue_reprogram has either called the
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index b4f1674fca79..50b81b98046a 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -19,7 +19,15 @@ static struct proc_dir_entry *root_irq_dir;
 static int irq_affinity_read_proc(char *page, char **start, off_t off,
                                   int count, int *eof, void *data)
 {
-        int len = cpumask_scnprintf(page, count, irq_desc[(long)data].affinity);
+        struct irq_desc *desc = irq_desc + (long)data;
+        cpumask_t *mask = &desc->affinity;
+        int len;
+
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        if (desc->status & IRQ_MOVE_PENDING)
+                mask = &desc->pending_mask;
+#endif
+        len = cpumask_scnprintf(page, count, *mask);
 
         if (count - len < 2)
                 return -EINVAL;
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 7358609e4735..c1a106d87d90 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -57,7 +57,7 @@ config DISABLE_CONSOLE_SUSPEND
 
 config PM_TRACE
         bool "Suspend/resume event tracing"
-        depends on PM_DEBUG && X86_32 && EXPERIMENTAL
+        depends on PM_DEBUG && X86 && EXPERIMENTAL
         default n
         ---help---
         This enables some cheesy code to save the last PM event point in the
diff --git a/kernel/signal.c b/kernel/signal.c
index 39d122753bac..ef8156a6aad5 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -255,6 +255,16 @@ flush_signal_handlers(struct task_struct *t, int force_default)
         }
 }
 
+int unhandled_signal(struct task_struct *tsk, int sig)
+{
+        if (is_init(tsk))
+                return 1;
+        if (tsk->ptrace & PT_PTRACED)
+                return 0;
+        return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
+                (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
+}
+
 
 /* Notify the system that a driver wants to block all signals for this
  * process, and wants to be notified if any signals at all were to be
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 222299844ad1..ddebf3f2affe 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -1203,6 +1203,16 @@ static ctl_table fs_table[] = {
 };
 
 static ctl_table debug_table[] = {
+#ifdef CONFIG_X86
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "exception-trace",
+                .data           = &show_unhandled_signals,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec
+        },
+#endif
         { .ctl_name = 0 }
 };
 
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index b5e352597cbb..cd91237dbfe3 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -10,6 +10,7 @@
 
 #include <linux/mm.h>
 #include <linux/time.h>
+#include <linux/timer.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/hrtimer.h>
@@ -175,12 +176,64 @@ u64 current_tick_length(void)
         return tick_length;
 }
 
+#ifdef CONFIG_GENERIC_CMOS_UPDATE
 
-void __attribute__ ((weak)) notify_arch_cmos_timer(void)
+/* Disable the cmos update - used by virtualization and embedded */
+int no_sync_cmos_clock  __read_mostly;
+
+static void sync_cmos_clock(unsigned long dummy);
+
+static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
+
+static void sync_cmos_clock(unsigned long dummy)
+{
+        struct timespec now, next;
+        int fail = 1;
+
+        /*
+         * If we have an externally synchronized Linux clock, then update
+         * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
+         * called as close as possible to 500 ms before the new second starts.
+         * This code is run on a timer.  If the clock is set, that timer
+         * may not expire at the correct time.  Thus, we adjust...
+         */
+        if (!ntp_synced())
+                /*
+                 * Not synced, exit, do not restart a timer (if one is
+                 * running, let it run out).
+                 */
+                return;
+
+        getnstimeofday(&now);
+        if (abs(xtime.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
+                fail = update_persistent_clock(now);
+
+        next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec;
+        if (next.tv_nsec <= 0)
+                next.tv_nsec += NSEC_PER_SEC;
+
+        if (!fail)
+                next.tv_sec = 659;
+        else
+                next.tv_sec = 0;
+
+        if (next.tv_nsec >= NSEC_PER_SEC) {
+                next.tv_sec++;
+                next.tv_nsec -= NSEC_PER_SEC;
+        }
+        mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next));
+}
+
+static void notify_cmos_timer(void)
 {
-        return;
+        if (no_sync_cmos_clock)
+                mod_timer(&sync_cmos_timer, jiffies + 1);
 }
 
+#else
+static inline void notify_cmos_timer(void) { }
+#endif
+
 /* adjtimex mainly allows reading (and writing, if superuser) of
  * kernel time-keeping variables. used by xntpd.
  */
@@ -345,6 +398,6 @@ leave:	if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
         txc->stbcnt        = 0;
         write_sequnlock_irq(&xtime_lock);
         do_gettimeofday(&txc->time);
-        notify_arch_cmos_timer();
+        notify_cmos_timer();
         return(result);
 }
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 8001d37071f5..db8e0f3d409b 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -31,6 +31,12 @@ struct tick_device tick_broadcast_device;
 static cpumask_t tick_broadcast_mask;
 static DEFINE_SPINLOCK(tick_broadcast_lock);
 
+#ifdef CONFIG_TICK_ONESHOT
+static void tick_broadcast_clear_oneshot(int cpu);
+#else
+static inline void tick_broadcast_clear_oneshot(int cpu) { }
+#endif
+
 /*
  * Debugging: see timer_list.c
  */
@@ -49,7 +55,7 @@ cpumask_t *tick_get_broadcast_mask(void)
  */
 static void tick_broadcast_start_periodic(struct clock_event_device *bc)
 {
-        if (bc && bc->mode == CLOCK_EVT_MODE_SHUTDOWN)
+        if (bc)
                 tick_setup_periodic(bc, 1);
 }
 
@@ -99,8 +105,19 @@ int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
                 cpu_set(cpu, tick_broadcast_mask);
                 tick_broadcast_start_periodic(tick_broadcast_device.evtdev);
                 ret = 1;
-        }
+        } else {
+                /*
+                 * When the new device is not affected by the stop
+                 * feature and the cpu is marked in the broadcast mask
+                 * then clear the broadcast bit.
+                 */
+                if (!(dev->features & CLOCK_EVT_FEAT_C3STOP)) {
+                        int cpu = smp_processor_id();
 
+                        cpu_clear(cpu, tick_broadcast_mask);
+                        tick_broadcast_clear_oneshot(cpu);
+                }
+        }
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
         return ret;
 }
@@ -299,7 +316,7 @@ void tick_suspend_broadcast(void)
         spin_lock_irqsave(&tick_broadcast_lock, flags);
 
         bc = tick_broadcast_device.evtdev;
-        if (bc && tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
+        if (bc)
                 clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
 
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
@@ -316,6 +333,8 @@ int tick_resume_broadcast(void)
         bc = tick_broadcast_device.evtdev;
 
         if (bc) {
+                clockevents_set_mode(bc, CLOCK_EVT_MODE_RESUME);
+
                 switch (tick_broadcast_device.mode) {
                 case TICKDEV_MODE_PERIODIC:
                         if(!cpus_empty(tick_broadcast_mask))
@@ -485,6 +504,16 @@ out:
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 
+/*
+ * Reset the one shot broadcast for a cpu
+ *
+ * Called with tick_broadcast_lock held
+ */
+static void tick_broadcast_clear_oneshot(int cpu)
+{
+        cpu_clear(cpu, tick_broadcast_oneshot_mask);
+}
+
 /**
  * tick_broadcast_setup_highres - setup the broadcast device for highres
  */
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index a96ec9ab3454..77a21abc8716 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -318,12 +318,17 @@ static void tick_resume(void)
 {
         struct tick_device *td = &__get_cpu_var(tick_cpu_device);
         unsigned long flags;
+        int broadcast = tick_resume_broadcast();
 
         spin_lock_irqsave(&tick_device_lock, flags);
-        if (td->mode == TICKDEV_MODE_PERIODIC)
-                tick_setup_periodic(td->evtdev, 0);
-        else
-                tick_resume_oneshot();
+        clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME);
+
+        if (!broadcast) {
+                if (td->mode == TICKDEV_MODE_PERIODIC)
+                        tick_setup_periodic(td->evtdev, 0);
+                else
+                        tick_resume_oneshot();
+        }
         spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 
@@ -360,8 +365,7 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason,
                 break;
 
         case CLOCK_EVT_NOTIFY_RESUME:
-                if (!tick_resume_broadcast())
-                        tick_resume();
+                tick_resume();
                 break;
 
         default:
diff --git a/kernel/time/tick-oneshot.c b/kernel/time/tick-oneshot.c
index f6997ab0c3c9..0258d3115d54 100644
--- a/kernel/time/tick-oneshot.c
+++ b/kernel/time/tick-oneshot.c
@@ -73,8 +73,21 @@ int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *))
         struct clock_event_device *dev = td->evtdev;
 
         if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT) ||
-            !tick_device_is_functional(dev))
+                    !tick_device_is_functional(dev)) {
+
+                printk(KERN_INFO "Clockevents: "
+                       "could not switch to one-shot mode:");
+                if (!dev) {
+                        printk(" no tick device\n");
+                } else {
+                        if (!tick_device_is_functional(dev))
+                                printk(" %s is not functional.\n", dev->name);
+                        else
+                                printk(" %s does not support one-shot mode.\n",
+                                       dev->name);
+                }
                 return -EINVAL;
+        }
 
         td->mode = TICKDEV_MODE_ONESHOT;
         dev->event_handler = handler;
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 52db9e3c526e..b416995b9757 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -546,6 +546,7 @@ void tick_setup_sched_timer(void)
 {
         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
         ktime_t now = ktime_get();
+        u64 offset;
 
         /*
          * Emulate tick processing via per-CPU hrtimers:
@@ -554,8 +555,12 @@ void tick_setup_sched_timer(void)
         ts->sched_timer.function = tick_sched_timer;
         ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
 
-        /* Get the next period */
+        /* Get the next period (per cpu) */
         ts->sched_timer.expires = tick_init_jiffy_update();
+        offset = ktime_to_ns(tick_period) >> 1;
+        do_div(offset, NR_CPUS);
+        offset *= smp_processor_id();
+        ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
 
         for (;;) {
                 hrtimer_forward(&ts->sched_timer, now, tick_period);