14 files changed, 250 insertions, 280 deletions

diff --git a/kernel/capability.c b/kernel/capability.c
index bfa3c92e16f2..1a4d8a40d3f9 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -233,3 +233,19 @@ out:
 
      return ret;
 }
+
+int __capable(struct task_struct *t, int cap)
+{
+        if (security_capable(t, cap) == 0) {
+                t->flags |= PF_SUPERPRIV;
+                return 1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(__capable);
+
+int capable(int cap)
+{
+        return __capable(current, cap);
+}
+EXPORT_SYMBOL(capable);
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index 49378738ff5e..2b33f852be3e 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -1,5 +1,4 @@
 
-obj-y := handle.o manage.o spurious.o
+obj-y := handle.o manage.o spurious.o migration.o
 obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_PROC_FS) += proc.o
-
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 97d5559997d2..6edfcef291e8 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -204,10 +204,14 @@ int setup_irq(unsigned int irq, struct irqaction * new)
         p = &desc->action;
         if ((old = *p) != NULL) {
                 /* Can't share interrupts unless both agree to */
-                if (!(old->flags & new->flags & SA_SHIRQ)) {
-                        spin_unlock_irqrestore(&desc->lock,flags);
-                        return -EBUSY;
-                }
+                if (!(old->flags & new->flags & SA_SHIRQ))
+                        goto mismatch;
+
+#if defined(ARCH_HAS_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
+                /* All handlers must agree on per-cpuness */
+                if ((old->flags & IRQ_PER_CPU) != (new->flags & IRQ_PER_CPU))
+                        goto mismatch;
+#endif
 
                 /* add new interrupt at end of irq queue */
                 do {
@@ -218,7 +222,10 @@ int setup_irq(unsigned int irq, struct irqaction * new)
         }
 
         *p = new;
-
+#if defined(ARCH_HAS_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
+        if (new->flags & SA_PERCPU_IRQ)
+                desc->status |= IRQ_PER_CPU;
+#endif
         if (!shared) {
                 desc->depth = 0;
                 desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT |
@@ -236,6 +243,12 @@ int setup_irq(unsigned int irq, struct irqaction * new)
         register_handler_proc(irq, new);
 
         return 0;
+
+mismatch:
+        spin_unlock_irqrestore(&desc->lock, flags);
+        printk(KERN_ERR "%s: irq handler mismatch\n", __FUNCTION__);
+        dump_stack();
+        return -EBUSY;
 }
 
 /**
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
new file mode 100644
index 000000000000..52a8655fa080
--- /dev/null
+++ b/kernel/irq/migration.c
@@ -0,0 +1,65 @@
+#include <linux/irq.h>
+
+#if defined(CONFIG_GENERIC_PENDING_IRQ)
+
+void set_pending_irq(unsigned int irq, cpumask_t mask)
+{
+        irq_desc_t *desc = irq_desc + irq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&desc->lock, flags);
+        desc->move_irq = 1;
+        pending_irq_cpumask[irq] = mask;
+        spin_unlock_irqrestore(&desc->lock, flags);
+}
+
+void move_native_irq(int irq)
+{
+        cpumask_t tmp;
+        irq_desc_t *desc = irq_descp(irq);
+
+        if (likely(!desc->move_irq))
+                return;
+
+        /*
+         * Paranoia: cpu-local interrupts shouldn't be calling in here anyway.
+         */
+        if (CHECK_IRQ_PER_CPU(desc->status)) {
+                WARN_ON(1);
+                return;
+        }
+
+        desc->move_irq = 0;
+
+        if (likely(cpus_empty(pending_irq_cpumask[irq])))
+                return;
+
+        if (!desc->handler->set_affinity)
+                return;
+
+        assert_spin_locked(&desc->lock);
+
+        cpus_and(tmp, pending_irq_cpumask[irq], cpu_online_map);
+
+        /*
+         * If there was a valid mask to work with, please
+         * do the disable, re-program, enable sequence.
+         * This is *not* particularly important for level triggered
+         * but in a edge trigger case, we might be setting rte
+         * when an active trigger is comming in. This could
+         * cause some ioapics to mal-function.
+         * Being paranoid i guess!
+         */
+        if (unlikely(!cpus_empty(tmp))) {
+                if (likely(!(desc->status & IRQ_DISABLED)))
+                        desc->handler->disable(irq);
+
+                desc->handler->set_affinity(irq,tmp);
+
+                if (likely(!(desc->status & IRQ_DISABLED)))
+                        desc->handler->enable(irq);
+        }
+        cpus_clear(pending_irq_cpumask[irq]);
+}
+
+#endif
diff --git a/kernel/itimer.c b/kernel/itimer.c
index 379be2f8c84c..680e6b70c872 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -143,6 +143,60 @@ int it_real_fn(void *data)
         return HRTIMER_NORESTART;
 }
 
+/*
+ * We do not care about correctness. We just sanitize the values so
+ * the ktime_t operations which expect normalized values do not
+ * break. This converts negative values to long timeouts similar to
+ * the code in kernel versions < 2.6.16
+ *
+ * Print a limited number of warning messages when an invalid timeval
+ * is detected.
+ */
+static void fixup_timeval(struct timeval *tv, int interval)
+{
+        static int warnlimit = 10;
+        unsigned long tmp;
+
+        if (warnlimit > 0) {
+                warnlimit--;
+                printk(KERN_WARNING
+                       "setitimer: %s (pid = %d) provided "
+                       "invalid timeval %s: tv_sec = %ld tv_usec = %ld\n",
+                       current->comm, current->pid,
+                       interval ? "it_interval" : "it_value",
+                       tv->tv_sec, (long) tv->tv_usec);
+        }
+
+        tmp = tv->tv_usec;
+        if (tmp >= USEC_PER_SEC) {
+                tv->tv_usec = tmp % USEC_PER_SEC;
+                tv->tv_sec += tmp / USEC_PER_SEC;
+        }
+
+        tmp = tv->tv_sec;
+        if (tmp > LONG_MAX)
+                tv->tv_sec = LONG_MAX;
+}
+
+/*
+ * Returns true if the timeval is in canonical form
+ */
+#define timeval_valid(t) \
+        (((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC))
+
+/*
+ * Check for invalid timevals, sanitize them and print a limited
+ * number of warnings.
+ */
+static void check_itimerval(struct itimerval *value) {
+
+        if (unlikely(!timeval_valid(&value->it_value)))
+                fixup_timeval(&value->it_value, 0);
+
+        if (unlikely(!timeval_valid(&value->it_interval)))
+                fixup_timeval(&value->it_interval, 1);
+}
+
 int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
 {
         struct task_struct *tsk = current;
@@ -150,6 +204,18 @@ int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
         ktime_t expires;
         cputime_t cval, cinterval, nval, ninterval;
 
+        /*
+         * Validate the timevals in value.
+         *
+         * Note: Although the spec requires that invalid values shall
+         * return -EINVAL, we just fixup the value and print a limited
+         * number of warnings in order not to break users of this
+         * historical misfeature.
+         *
+         * Scheduled for replacement in March 2007
+         */
+        check_itimerval(value);
+
         switch (which) {
         case ITIMER_REAL:
 again:
@@ -226,6 +292,43 @@ again:
         return 0;
 }
 
+/**
+ * alarm_setitimer - set alarm in seconds
+ *
+ * @seconds:    number of seconds until alarm
+ *              0 disables the alarm
+ *
+ * Returns the remaining time in seconds of a pending timer or 0 when
+ * the timer is not active.
+ *
+ * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid
+ * negative timeval settings which would cause immediate expiry.
+ */
+unsigned int alarm_setitimer(unsigned int seconds)
+{
+        struct itimerval it_new, it_old;
+
+#if BITS_PER_LONG < 64
+        if (seconds > INT_MAX)
+                seconds = INT_MAX;
+#endif
+        it_new.it_value.tv_sec = seconds;
+        it_new.it_value.tv_usec = 0;
+        it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
+
+        do_setitimer(ITIMER_REAL, &it_new, &it_old);
+
+        /*
+         * We can't return 0 if we have an alarm pending ...  And we'd
+         * better return too much than too little anyway
+         */
+        if ((!it_old.it_value.tv_sec && it_old.it_value.tv_usec) ||
+              it_old.it_value.tv_usec >= 500000)
+                it_old.it_value.tv_sec++;
+
+        return it_old.it_value.tv_sec;
+}
+
 asmlinkage long sys_setitimer(int which,
                               struct itimerval __user *value,
                               struct itimerval __user *ovalue)
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 6a5373868a98..c5f3c6613b6d 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -115,7 +115,9 @@ static void keventd_create_kthread(void *_create)
                 create->result = ERR_PTR(pid);
         } else {
                 wait_for_completion(&create->started);
+                read_lock(&tasklist_lock);
                 create->result = find_task_by_pid(pid);
+                read_unlock(&tasklist_lock);
         }
         complete(&create->done);
 }
diff --git a/kernel/module.c b/kernel/module.c
index 54623c714bba..ddfe45ac2fd1 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -233,24 +233,6 @@ static unsigned long __find_symbol(const char *name,
         return 0;
 }
 
-/* Find a symbol in this elf symbol table */
-static unsigned long find_local_symbol(Elf_Shdr *sechdrs,
-                                       unsigned int symindex,
-                                       const char *strtab,
-                                       const char *name)
-{
-        unsigned int i;
-        Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
-
-        /* Search (defined) internal symbols first. */
-        for (i = 1; i < sechdrs[symindex].sh_size/sizeof(*sym); i++) {
-                if (sym[i].st_shndx != SHN_UNDEF
-                    && strcmp(name, strtab + sym[i].st_name) == 0)
-                        return sym[i].st_value;
-        }
-        return 0;
-}
-
 /* Search for module by name: must hold module_mutex. */
 static struct module *find_module(const char *name)
 {
@@ -785,139 +767,6 @@ static struct module_attribute *modinfo_attrs[] = {
         NULL,
 };
 
-#ifdef CONFIG_OBSOLETE_MODPARM
-/* Bounds checking done below */
-static int obsparm_copy_string(const char *val, struct kernel_param *kp)
-{
-        strcpy(kp->arg, val);
-        return 0;
-}
-
-static int set_obsolete(const char *val, struct kernel_param *kp)
-{
-        unsigned int min, max;
-        unsigned int size, maxsize;
-        int dummy;
-        char *endp;
-        const char *p;
-        struct obsolete_modparm *obsparm = kp->arg;
-
-        if (!val) {
-                printk(KERN_ERR "Parameter %s needs an argument\n", kp->name);
-                return -EINVAL;
-        }
-
-        /* type is: [min[-max]]{b,h,i,l,s} */
-        p = obsparm->type;
-        min = simple_strtol(p, &endp, 10);
-        if (endp == obsparm->type)
-                min = max = 1;
-        else if (*endp == '-') {
-                p = endp+1;
-                max = simple_strtol(p, &endp, 10);
-        } else
-                max = min;
-        switch (*endp) {
-        case 'b':
-                return param_array(kp->name, val, min, max, obsparm->addr,
-                                   1, param_set_byte, &dummy);
-        case 'h':
-                return param_array(kp->name, val, min, max, obsparm->addr,
-                                   sizeof(short), param_set_short, &dummy);
-        case 'i':
-                return param_array(kp->name, val, min, max, obsparm->addr,
-                                   sizeof(int), param_set_int, &dummy);
-        case 'l':
-                return param_array(kp->name, val, min, max, obsparm->addr,
-                                   sizeof(long), param_set_long, &dummy);
-        case 's':
-                return param_array(kp->name, val, min, max, obsparm->addr,
-                                   sizeof(char *), param_set_charp, &dummy);
-
-        case 'c':
-                /* Undocumented: 1-5c50 means 1-5 strings of up to 49 chars,
-                   and the decl is "char xxx[5][50];" */
-                p = endp+1;
-                maxsize = simple_strtol(p, &endp, 10);
-                /* We check lengths here (yes, this is a hack). */
-                p = val;
-                while (p[size = strcspn(p, ",")]) {
-                        if (size >= maxsize) 
-                                goto oversize;
-                        p += size+1;
-                }
-                if (size >= maxsize) 
-                        goto oversize;
-                return param_array(kp->name, val, min, max, obsparm->addr,
-                                   maxsize, obsparm_copy_string, &dummy);
-        }
-        printk(KERN_ERR "Unknown obsolete parameter type %s\n", obsparm->type);
-        return -EINVAL;
- oversize:
-        printk(KERN_ERR
-               "Parameter %s doesn't fit in %u chars.\n", kp->name, maxsize);
-        return -EINVAL;
-}
-
-static int obsolete_params(const char *name,
-                           char *args,
-                           struct obsolete_modparm obsparm[],
-                           unsigned int num,
-                           Elf_Shdr *sechdrs,
-                           unsigned int symindex,
-                           const char *strtab)
-{
-        struct kernel_param *kp;
-        unsigned int i;
-        int ret;
-
-        kp = kmalloc(sizeof(kp[0]) * num, GFP_KERNEL);
-        if (!kp)
-                return -ENOMEM;
-
-        for (i = 0; i < num; i++) {
-                char sym_name[128 + sizeof(MODULE_SYMBOL_PREFIX)];
-
-                snprintf(sym_name, sizeof(sym_name), "%s%s",
-                         MODULE_SYMBOL_PREFIX, obsparm[i].name);
-
-                kp[i].name = obsparm[i].name;
-                kp[i].perm = 000;
-                kp[i].set = set_obsolete;
-                kp[i].get = NULL;
-                obsparm[i].addr
-                        = (void *)find_local_symbol(sechdrs, symindex, strtab,
-                                                    sym_name);
-                if (!obsparm[i].addr) {
-                        printk("%s: falsely claims to have parameter %s\n",
-                               name, obsparm[i].name);
-                        ret = -EINVAL;
-                        goto out;
-                }
-                kp[i].arg = &obsparm[i];
-        }
-
-        ret = parse_args(name, args, kp, num, NULL);
- out:
-        kfree(kp);
-        return ret;
-}
-#else
-static int obsolete_params(const char *name,
-                           char *args,
-                           struct obsolete_modparm obsparm[],
-                           unsigned int num,
-                           Elf_Shdr *sechdrs,
-                           unsigned int symindex,
-                           const char *strtab)
-{
-        if (num != 0)
-                printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",
-                       name);
-        return 0;
-}
-#endif /* CONFIG_OBSOLETE_MODPARM */
-
 static const char vermagic[] = VERMAGIC_STRING;
 
 #ifdef CONFIG_MODVERSIONS
@@ -1874,27 +1723,17 @@ static struct module *load_module(void __user *umod,
         set_fs(old_fs);
 
         mod->args = args;
-        if (obsparmindex) {
-                err = obsolete_params(mod->name, mod->args,
-                                      (struct obsolete_modparm *)
-                                      sechdrs[obsparmindex].sh_addr,
-                                      sechdrs[obsparmindex].sh_size
-                                      / sizeof(struct obsolete_modparm),
-                                      sechdrs, symindex,
-                                      (char *)sechdrs[strindex].sh_addr);
-                if (setupindex)
-                        printk(KERN_WARNING "%s: Ignoring new-style "
-                               "parameters in presence of obsolete ones\n",
-                               mod->name);
-        } else {
-                /* Size of section 0 is 0, so this works well if no params */
-                err = parse_args(mod->name, mod->args,
-                                 (struct kernel_param *)
-                                 sechdrs[setupindex].sh_addr,
-                                 sechdrs[setupindex].sh_size
-                                 / sizeof(struct kernel_param),
-                                 NULL);
-        }
+        if (obsparmindex)
+                printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",
+                       mod->name);
+
+        /* Size of section 0 is 0, so this works well if no params */
+        err = parse_args(mod->name, mod->args,
+                         (struct kernel_param *)
+                         sechdrs[setupindex].sh_addr,
+                         sechdrs[setupindex].sh_size
+                         / sizeof(struct kernel_param),
+                         NULL);
         if (err < 0)
                 goto arch_cleanup;
 
diff --git a/kernel/params.c b/kernel/params.c
index a29150582310..9de637a5c8bc 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -265,12 +265,12 @@ int param_get_invbool(char *buffer, struct kernel_param *kp)
 }
 
 /* We cheat here and temporarily mangle the string. */
-int param_array(const char *name,
-                const char *val,
-                unsigned int min, unsigned int max,
-                void *elem, int elemsize,
-                int (*set)(const char *, struct kernel_param *kp),
-                int *num)
+static int param_array(const char *name,
+                       const char *val,
+                       unsigned int min, unsigned int max,
+                       void *elem, int elemsize,
+                       int (*set)(const char *, struct kernel_param *kp),
+                       int *num)
 {
         int ret;
         struct kernel_param kp;
diff --git a/kernel/power/smp.c b/kernel/power/smp.c
index 911fc62b8225..5957312b2d68 100644
--- a/kernel/power/smp.c
+++ b/kernel/power/smp.c
@@ -49,9 +49,7 @@ void enable_nonboot_cpus(void)
 
         printk("Thawing cpus ...\n");
         for_each_cpu_mask(cpu, frozen_cpus) {
-                error = smp_prepare_cpu(cpu);
-                if (!error)
-                        error = cpu_up(cpu);
+                error = cpu_up(cpu);
                 if (!error) {
                         printk("CPU%d is up\n", cpu);
                         continue;
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 9a1fa8894b95..b4b362b5baf5 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -54,15 +54,15 @@ static int verbose;		/* Print more debug info. */
 static int test_no_idle_hz;     /* Test RCU's support for tickless idle CPUs. */
 static int shuffle_interval = 5; /* Interval between shuffles (in sec)*/
 
-MODULE_PARM(nreaders, "i");
+module_param(nreaders, int, 0);
 MODULE_PARM_DESC(nreaders, "Number of RCU reader threads");
-MODULE_PARM(stat_interval, "i");
+module_param(stat_interval, int, 0);
 MODULE_PARM_DESC(stat_interval, "Number of seconds between stats printk()s");
-MODULE_PARM(verbose, "i");
+module_param(verbose, bool, 0);
 MODULE_PARM_DESC(verbose, "Enable verbose debugging printk()s");
-MODULE_PARM(test_no_idle_hz, "i");
+module_param(test_no_idle_hz, bool, 0);
 MODULE_PARM_DESC(test_no_idle_hz, "Test support for tickless idle CPUs");
-MODULE_PARM(shuffle_interval, "i");
+module_param(shuffle_interval, int, 0);
 MODULE_PARM_DESC(shuffle_interval, "Number of seconds between shuffles");
 #define TORTURE_FLAG "rcutorture: "
 #define PRINTK_STRING(s) \
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index dd9524fa649a..d9b3d5847ed8 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -118,6 +118,7 @@ cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
                         printk("watchdog for %i failed\n", hotcpu);
                         return NOTIFY_BAD;
                 }
+                per_cpu(touch_timestamp, hotcpu) = jiffies;
                 per_cpu(watchdog_task, hotcpu) = p;
                 kthread_bind(p, hotcpu);
                 break;
diff --git a/kernel/sys.c b/kernel/sys.c
index 19d058be49d4..38bc73ede2ba 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -224,18 +224,6 @@ int unregister_reboot_notifier(struct notifier_block * nb)
 
 EXPORT_SYMBOL(unregister_reboot_notifier);
 
-#ifndef CONFIG_SECURITY
-int capable(int cap)
-{
-        if (cap_raised(current->cap_effective, cap)) {
-               current->flags |= PF_SUPERPRIV;
-               return 1;
-        }
-        return 0;
-}
-EXPORT_SYMBOL(capable);
-#endif
-
 static int set_one_prio(struct task_struct *p, int niceval, int error)
 {
         int no_nice;
@@ -1375,7 +1363,7 @@ static void groups_sort(struct group_info *group_info)
 /* a simple bsearch */
 int groups_search(struct group_info *group_info, gid_t grp)
 {
-        int left, right;
+        unsigned int left, right;
 
         if (!group_info)
                 return 0;
@@ -1383,7 +1371,7 @@ int groups_search(struct group_info *group_info, gid_t grp)
         left = 0;
         right = group_info->ngroups;
         while (left < right) {
-                int mid = (left+right)/2;
+                unsigned int mid = (left+right)/2;
                 int cmp = grp - GROUP_AT(group_info, mid);
                 if (cmp > 0)
                         left = mid + 1;
@@ -1433,7 +1421,6 @@ asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist)
                 return -EINVAL;
 
         /* no need to grab task_lock here; it cannot change */
-        get_group_info(current->group_info);
         i = current->group_info->ngroups;
         if (gidsetsize) {
                 if (i > gidsetsize) {
@@ -1446,7 +1433,6 @@ asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist)
                 }
         }
 out:
-        put_group_info(current->group_info);
         return i;
 }
 
@@ -1487,9 +1473,7 @@ int in_group_p(gid_t grp)
 {
         int retval = 1;
         if (grp != current->fsgid) {
-                get_group_info(current->group_info);
                 retval = groups_search(current->group_info, grp);
-                put_group_info(current->group_info);
         }
         return retval;
 }
@@ -1500,9 +1484,7 @@ int in_egroup_p(gid_t grp)
 {
         int retval = 1;
         if (grp != current->egid) {
-                get_group_info(current->group_info);
                 retval = groups_search(current->group_info, grp);
-                put_group_info(current->group_info);
         }
         return retval;
 }
diff --git a/kernel/time.c b/kernel/time.c
index 804539165d8b..e00a97b77241 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -202,24 +202,6 @@ asmlinkage long sys_settimeofday(struct timeval __user *tv,
         return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 }
 
-long pps_offset;                /* pps time offset (us) */
-long pps_jitter = MAXTIME;      /* time dispersion (jitter) (us) */
-
-long pps_freq;                  /* frequency offset (scaled ppm) */
-long pps_stabil = MAXFREQ;      /* frequency dispersion (scaled ppm) */
-
-long pps_valid = PPS_VALID;     /* pps signal watchdog counter */
-
-int pps_shift = PPS_SHIFT;      /* interval duration (s) (shift) */
-
-long pps_jitcnt;                /* jitter limit exceeded */
-long pps_calcnt;                /* calibration intervals */
-long pps_errcnt;                /* calibration errors */
-long pps_stbcnt;                /* stability limit exceeded */
-
-/* hook for a loadable hardpps kernel module */
-void (*hardpps_ptr)(struct timeval *);
-
 /* we call this to notify the arch when the clock is being
  * controlled.  If no such arch routine, do nothing.
  */
@@ -279,7 +261,7 @@ int do_adjtimex(struct timex *txc)
                     result = -EINVAL;
                     goto leave;
                 }
-                time_freq = txc->freq - pps_freq;
+                time_freq = txc->freq;
             }
 
             if (txc->modes & ADJ_MAXERROR) {
@@ -312,10 +294,8 @@ int do_adjtimex(struct timex *txc)
                     if ((time_next_adjust = txc->offset) == 0)
                          time_adjust = 0;
                 }
-                else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
-                    ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
-                            (STA_PPSTIME | STA_PPSSIGNAL) ?
-                            pps_offset : txc->offset;
+                else if (time_status & STA_PLL) {
+                    ltemp = txc->offset;
 
                     /*
                      * Scale the phase adjustment and
@@ -356,23 +336,14 @@ int do_adjtimex(struct timex *txc)
                     }
                     time_freq = min(time_freq, time_tolerance);
                     time_freq = max(time_freq, -time_tolerance);
-                } /* STA_PLL || STA_PPSTIME */
+                } /* STA_PLL */
             } /* txc->modes & ADJ_OFFSET */
             if (txc->modes & ADJ_TICK) {
                 tick_usec = txc->tick;
                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
             }
         } /* txc->modes */
-leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
-            || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
-                && (time_status & STA_PPSSIGNAL) == 0)
-            /* p. 24, (b) */
-            || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
-                == (STA_PPSTIME|STA_PPSJITTER))
-            /* p. 24, (c) */
-            || ((time_status & STA_PPSFREQ) != 0
-                && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
-            /* p. 24, (d) */
+leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
                 result = TIME_ERROR;
         
         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
@@ -380,7 +351,7 @@ leave:	if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
         else {
             txc->offset = shift_right(time_offset, SHIFT_UPDATE);
         }
-        txc->freq          = time_freq + pps_freq;
+        txc->freq          = time_freq;
         txc->maxerror      = time_maxerror;
         txc->esterror      = time_esterror;
         txc->status        = time_status;
@@ -388,14 +359,16 @@ leave:	if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
         txc->precision     = time_precision;
         txc->tolerance     = time_tolerance;
         txc->tick          = tick_usec;
-        txc->ppsfreq       = pps_freq;
-        txc->jitter        = pps_jitter >> PPS_AVG;
-        txc->shift         = pps_shift;
-        txc->stabil        = pps_stabil;
-        txc->jitcnt        = pps_jitcnt;
-        txc->calcnt        = pps_calcnt;
-        txc->errcnt        = pps_errcnt;
-        txc->stbcnt        = pps_stbcnt;
+
+        /* PPS is not implemented, so these are zero */
+        txc->ppsfreq       = 0;
+        txc->jitter        = 0;
+        txc->shift         = 0;
+        txc->stabil        = 0;
+        txc->jitcnt        = 0;
+        txc->calcnt        = 0;
+        txc->errcnt        = 0;
+        txc->stbcnt        = 0;
         write_sequnlock_irq(&xtime_lock);
         do_gettimeofday(&txc->time);
         notify_arch_cmos_timer();
diff --git a/kernel/timer.c b/kernel/timer.c
index 17d956cebcb9..ab189dd187cb 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -697,18 +697,9 @@ static void second_overflow(void)
 
         /*
          * Compute the frequency estimate and additional phase adjustment due
-         * to frequency error for the next second. When the PPS signal is
-         * engaged, gnaw on the watchdog counter and update the frequency
-         * computed by the pll and the PPS signal.
+         * to frequency error for the next second.
          */
-        pps_valid++;
-        if (pps_valid == PPS_VALID) {   /* PPS signal lost */
-                pps_jitter = MAXTIME;
-                pps_stabil = MAXFREQ;
-                time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
-                                STA_PPSWANDER | STA_PPSERROR);
-        }
-        ltemp = time_freq + pps_freq;
+        ltemp = time_freq;
         time_adj += shift_right(ltemp,(SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE));
 
 #if HZ == 100
@@ -956,19 +947,7 @@ void do_timer(struct pt_regs *regs)
  */
 asmlinkage unsigned long sys_alarm(unsigned int seconds)
 {
-        struct itimerval it_new, it_old;
-        unsigned int oldalarm;
-
-        it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
-        it_new.it_value.tv_sec = seconds;
-        it_new.it_value.tv_usec = 0;
-        do_setitimer(ITIMER_REAL, &it_new, &it_old);
-        oldalarm = it_old.it_value.tv_sec;
-        /* ehhh.. We can't return 0 if we have an alarm pending.. */
-        /* And we'd better return too much than too little anyway */
-        if ((!oldalarm && it_old.it_value.tv_usec) || it_old.it_value.tv_usec >= 500000)
-                oldalarm++;
-        return oldalarm;
+        return alarm_setitimer(seconds);
 }
 
 #endif