Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6

8 files changed, 89 insertions, 61 deletions

diff --git a/arch/alpha/kernel/pci_iommu.c b/arch/alpha/kernel/pci_iommu.c
index be6fa105cd34..e07a23fc5b74 100644
--- a/arch/alpha/kernel/pci_iommu.c
+++ b/arch/alpha/kernel/pci_iommu.c
@@ -144,15 +144,14 @@ iommu_arena_find_pages(struct device *dev, struct pci_iommu_arena *arena,
         unsigned long base;
         unsigned long boundary_size;
 
-        BUG_ON(arena->dma_base & ~PAGE_MASK);
         base = arena->dma_base >> PAGE_SHIFT;
-        if (dev)
-                boundary_size = ALIGN(dma_get_max_seg_size(dev) + 1, PAGE_SIZE)
-                        >> PAGE_SHIFT;
-        else
-                boundary_size = ALIGN(1UL << 32, PAGE_SIZE) >> PAGE_SHIFT;
-
-        BUG_ON(!is_power_of_2(boundary_size));
+        if (dev) {
+                boundary_size = dma_get_seg_boundary(dev) + 1;
+                BUG_ON(!is_power_of_2(boundary_size));
+                boundary_size >>= PAGE_SHIFT;
+        } else {
+                boundary_size = 1UL << (32 - PAGE_SHIFT);
+        }
 
         /* Search forward for the first mask-aligned sequence of N free ptes */
         ptes = arena->ptes;
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index f41c9538ca30..237fc128143d 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -66,9 +66,6 @@ config MMU
 config ZONE_DMA
         def_bool y
 
-config QUICKLIST
-        def_bool X86_32
-
 config SBUS
         bool
 
diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c
index 8f64abe699fd..d5904eef1d31 100644
--- a/arch/x86/kernel/ptrace.c
+++ b/arch/x86/kernel/ptrace.c
@@ -1055,10 +1055,17 @@ static int putreg32(struct task_struct *child, unsigned regno, u32 value)
         R32(esi, si);
         R32(ebp, bp);
         R32(eax, ax);
-        R32(orig_eax, orig_ax);
         R32(eip, ip);
         R32(esp, sp);
 
+        case offsetof(struct user32, regs.orig_eax):
+                /*
+                 * Sign-extend the value so that orig_eax = -1
+                 * causes (long)orig_ax < 0 tests to fire correctly.
+                 */
+                regs->orig_ax = (long) (s32) value;
+                break;
+
         case offsetof(struct user32, regs.eflags):
                 return set_flags(child, value);
 
diff --git a/arch/x86/kernel/signal_64.c b/arch/x86/kernel/signal_64.c
index 56b72fb67f9b..1c83e5124c65 100644
--- a/arch/x86/kernel/signal_64.c
+++ b/arch/x86/kernel/signal_64.c
@@ -311,6 +311,35 @@ give_sigsegv:
 }
 
 /*
+ * Return -1L or the syscall number that @regs is executing.
+ */
+static long current_syscall(struct pt_regs *regs)
+{
+        /*
+         * We always sign-extend a -1 value being set here,
+         * so this is always either -1L or a syscall number.
+         */
+        return regs->orig_ax;
+}
+
+/*
+ * Return a value that is -EFOO if the system call in @regs->orig_ax
+ * returned an error.  This only works for @regs from @current.
+ */
+static long current_syscall_ret(struct pt_regs *regs)
+{
+#ifdef CONFIG_IA32_EMULATION
+        if (test_thread_flag(TIF_IA32))
+                /*
+                 * Sign-extend the value so (int)-EFOO becomes (long)-EFOO
+                 * and will match correctly in comparisons.
+                 */
+                return (int) regs->ax;
+#endif
+        return regs->ax;
+}
+
+/*
  * OK, we're invoking a handler
  */     
 
@@ -327,9 +356,9 @@ handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 #endif
 
         /* Are we from a system call? */
-        if ((long)regs->orig_ax >= 0) {
+        if (current_syscall(regs) >= 0) {
                 /* If so, check system call restarting.. */
-                switch (regs->ax) {
+                switch (current_syscall_ret(regs)) {
                         case -ERESTART_RESTARTBLOCK:
                         case -ERESTARTNOHAND:
                                 regs->ax = -EINTR;
@@ -426,10 +455,9 @@ static void do_signal(struct pt_regs *regs)
         }
 
         /* Did we come from a system call? */
-        if ((long)regs->orig_ax >= 0) {
+        if (current_syscall(regs) >= 0) {
                 /* Restart the system call - no handlers present */
-                long res = regs->ax;
-                switch (res) {
+                switch (current_syscall_ret(regs)) {
                 case -ERESTARTNOHAND:
                 case -ERESTARTSYS:
                 case -ERESTARTNOINTR:
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c
index cccb38a59653..a104c532ff70 100644
--- a/arch/x86/lguest/boot.c
+++ b/arch/x86/lguest/boot.c
@@ -84,7 +84,6 @@ struct lguest_data lguest_data = {
         .blocked_interrupts = { 1 }, /* Block timer interrupts */
         .syscall_vec = SYSCALL_VECTOR,
 };
-static cycle_t clock_base;
 
 /*G:037 async_hcall() is pretty simple: I'm quite proud of it really.  We have a
  * ring buffer of stored hypercalls which the Host will run though next time we
@@ -327,8 +326,8 @@ static void lguest_cpuid(unsigned int *ax, unsigned int *bx,
         case 1: /* Basic feature request. */
                 /* We only allow kernel to see SSE3, CMPXCHG16B and SSSE3 */
                 *cx &= 0x00002201;
-                /* SSE, SSE2, FXSR, MMX, CMOV, CMPXCHG8B, FPU. */
-                *dx &= 0x07808101;
+                /* SSE, SSE2, FXSR, MMX, CMOV, CMPXCHG8B, TSC, FPU. */
+                *dx &= 0x07808111;
                 /* The Host can do a nice optimization if it knows that the
                  * kernel mappings (addresses above 0xC0000000 or whatever
                  * PAGE_OFFSET is set to) haven't changed.  But Linux calls
@@ -481,7 +480,7 @@ static void lguest_set_pmd(pmd_t *pmdp, pmd_t pmdval)
 {
         *pmdp = pmdval;
         lazy_hcall(LHCALL_SET_PMD, __pa(pmdp)&PAGE_MASK,
-                   (__pa(pmdp)&(PAGE_SIZE-1)), 0);
+                   (__pa(pmdp)&(PAGE_SIZE-1))/4, 0);
 }
 
 /* There are a couple of legacy places where the kernel sets a PTE, but we
@@ -595,19 +594,25 @@ static unsigned long lguest_get_wallclock(void)
         return lguest_data.time.tv_sec;
 }
 
+/* The TSC is a Time Stamp Counter.  The Host tells us what speed it runs at,
+ * or 0 if it's unusable as a reliable clock source.  This matches what we want
+ * here: if we return 0 from this function, the x86 TSC clock will not register
+ * itself. */
+static unsigned long lguest_cpu_khz(void)
+{
+        return lguest_data.tsc_khz;
+}
+
+/* If we can't use the TSC, the kernel falls back to our "lguest_clock", where
+ * we read the time value given to us by the Host. */
 static cycle_t lguest_clock_read(void)
 {
         unsigned long sec, nsec;
 
-        /* If the Host tells the TSC speed, we can trust that. */
-        if (lguest_data.tsc_khz)
-                return native_read_tsc();
-
-        /* If we can't use the TSC, we read the time value written by the Host.
-         * Since it's in two parts (seconds and nanoseconds), we risk reading
-         * it just as it's changing from 99 & 0.999999999 to 100 and 0, and
-         * getting 99 and 0.  As Linux tends to come apart under the stress of
-         * time travel, we must be careful: */
+        /* Since the time is in two parts (seconds and nanoseconds), we risk
+         * reading it just as it's changing from 99 & 0.999999999 to 100 and 0,
+         * and getting 99 and 0.  As Linux tends to come apart under the stress
+         * of time travel, we must be careful: */
         do {
                 /* First we read the seconds part. */
                 sec = lguest_data.time.tv_sec;
@@ -622,14 +627,14 @@ static cycle_t lguest_clock_read(void)
                 /* Now if the seconds part has changed, try again. */
         } while (unlikely(lguest_data.time.tv_sec != sec));
 
-        /* Our non-TSC clock is in real nanoseconds. */
+        /* Our lguest clock is in real nanoseconds. */
         return sec*1000000000ULL + nsec;
 }
 
-/* This is what we tell the kernel is our clocksource.  */
+/* This is the fallback clocksource: lower priority than the TSC clocksource. */
 static struct clocksource lguest_clock = {
         .name           = "lguest",
-        .rating         = 400,
+        .rating         = 200,
         .read           = lguest_clock_read,
         .mask           = CLOCKSOURCE_MASK(64),
         .mult           = 1 << 22,
@@ -637,12 +642,6 @@ static struct clocksource lguest_clock = {
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
-/* The "scheduler clock" is just our real clock, adjusted to start at zero */
-static unsigned long long lguest_sched_clock(void)
-{
-        return cyc2ns(&lguest_clock, lguest_clock_read() - clock_base);
-}
-
 /* We also need a "struct clock_event_device": Linux asks us to set it to go
  * off some time in the future.  Actually, James Morris figured all this out, I
  * just applied the patch. */
@@ -712,19 +711,8 @@ static void lguest_time_init(void)
         /* Set up the timer interrupt (0) to go to our simple timer routine */
         set_irq_handler(0, lguest_time_irq);
 
-        /* Our clock structure looks like arch/x86/kernel/tsc_32.c if we can
-         * use the TSC, otherwise it's a dumb nanosecond-resolution clock.
-         * Either way, the "rating" is set so high that it's always chosen over
-         * any other clocksource. */
-        if (lguest_data.tsc_khz)
-                lguest_clock.mult = clocksource_khz2mult(lguest_data.tsc_khz,
-                                                         lguest_clock.shift);
-        clock_base = lguest_clock_read();
         clocksource_register(&lguest_clock);
 
-        /* Now we've set up our clock, we can use it as the scheduler clock */
-        pv_time_ops.sched_clock = lguest_sched_clock;
-
         /* We can't set cpumask in the initializer: damn C limitations!  Set it
          * here and register our timer device. */
         lguest_clockevent.cpumask = cpumask_of_cpu(0);
@@ -995,6 +983,7 @@ __init void lguest_init(void)
         /* time operations */
         pv_time_ops.get_wallclock = lguest_get_wallclock;
         pv_time_ops.time_init = lguest_time_init;
+        pv_time_ops.get_cpu_khz = lguest_cpu_khz;
 
         /* Now is a good time to look at the implementations of these functions
          * before returning to the rest of lguest_init(). */
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index ac3c959e271d..8fe576baa148 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -134,8 +134,6 @@ static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
                         return NULL;
         }
 
-        WARN_ON_ONCE(page_is_ram(pfn));
-
         switch (mode) {
         case IOR_MODE_UNCACHED:
         default:
diff --git a/arch/x86/mm/pgtable_32.c b/arch/x86/mm/pgtable_32.c
index 73aba7125203..2f9e9afcb9f4 100644
--- a/arch/x86/mm/pgtable_32.c
+++ b/arch/x86/mm/pgtable_32.c
@@ -342,12 +342,16 @@ static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp)
 
 pgd_t *pgd_alloc(struct mm_struct *mm)
 {
-        pgd_t *pgd = quicklist_alloc(0, GFP_KERNEL, pgd_ctor);
+        pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
 
-        mm->pgd = pgd;          /* so that alloc_pd can use it */
+        /* so that alloc_pd can use it */
+        mm->pgd = pgd;
+        if (pgd)
+                pgd_ctor(pgd);
 
         if (pgd && !pgd_prepopulate_pmd(mm, pgd)) {
-                quicklist_free(0, pgd_dtor, pgd);
+                pgd_dtor(pgd);
+                free_page((unsigned long)pgd);
                 pgd = NULL;
         }
 
@@ -357,12 +361,8 @@ pgd_t *pgd_alloc(struct mm_struct *mm)
 void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
         pgd_mop_up_pmds(mm, pgd);
-        quicklist_free(0, pgd_dtor, pgd);
-}
-
-void check_pgt_cache(void)
-{
-        quicklist_trim(0, pgd_dtor, 25, 16);
+        pgd_dtor(pgd);
+        free_page((unsigned long)pgd);
 }
 
 void __pte_free_tlb(struct mmu_gather *tlb, struct page *pte)
diff --git a/arch/x86/pci/pcbios.c b/arch/x86/pci/pcbios.c
index 10ac8c316c46..2f7109ac4c15 100644
--- a/arch/x86/pci/pcbios.c
+++ b/arch/x86/pci/pcbios.c
@@ -198,6 +198,11 @@ static int pci_bios_read(unsigned int seg, unsigned int bus,
                           "b" (bx),
                           "D" ((long)reg),
                           "S" (&pci_indirect));
+                /*
+                 * Zero-extend the result beyond 8 bits, do not trust the
+                 * BIOS having done it:
+                 */
+                *value &= 0xff;
                 break;
         case 2:
                 __asm__("lcall *(%%esi); cld\n\t"
@@ -210,6 +215,11 @@ static int pci_bios_read(unsigned int seg, unsigned int bus,
                           "b" (bx),
                           "D" ((long)reg),
                           "S" (&pci_indirect));
+                /*
+                 * Zero-extend the result beyond 16 bits, do not trust the
+                 * BIOS having done it:
+                 */
+                *value &= 0xffff;
                 break;
         case 4:
                 __asm__("lcall *(%%esi); cld\n\t"