Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
authorLinus Torvalds <torvalds@linux-foundation.org>
Tue, 5 May 2009 22:48:03 +0000 (15:48 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 5 May 2009 22:48:03 +0000 (15:48 -0700)
* 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6:
  [IA64] xen_domu_defconfig: fix build issues/warnings

14 files changed:
Documentation/lockdep-design.txt
arch/x86/kernel/amd_iommu_init.c
arch/x86/kernel/cpu/common.c
arch/x86/kernel/cpu/proc.c
arch/x86/mm/kmmio.c
arch/x86/vdso/vclock_gettime.c
kernel/irq/handle.c
kernel/posix-cpu-timers.c
kernel/sched.c
kernel/time/tick-common.c
kernel/trace/trace.c
lib/dma-debug.c
mm/madvise.c
scripts/mod/modpost.c

index 938ea22f2cc096f6838a678217e463bf9ec0cd4d..e20d913d5914a29261d12f5fa4585164ed170c82 100644 (file)
@@ -54,9 +54,9 @@ locking error messages, inside curlies. A contrived example:
 The bit position indicates STATE, STATE-read, for each of the states listed
 above, and the character displayed in each indicates:
 
-   '.'  acquired while irqs disabled
-   '+'  acquired in irq context
-   '-'  acquired with irqs enabled
+   '.'  acquired while irqs disabled and not in irq context
+   '-'  acquired in irq context
+   '+'  acquired with irqs enabled
    '?'  acquired in irq context with irqs enabled.
 
 Unused mutexes cannot be part of the cause of an error.
index 42c33cebf00f5c6cbc17b0394f94801a79d64d7e..8c0be0902dacb2cc4e766cbe851891bd889f08e7 100644 (file)
 #define IVHD_DEV_EXT_SELECT             0x46
 #define IVHD_DEV_EXT_SELECT_RANGE       0x47
 
-#define IVHD_FLAG_HT_TUN_EN             0x00
-#define IVHD_FLAG_PASSPW_EN             0x01
-#define IVHD_FLAG_RESPASSPW_EN          0x02
-#define IVHD_FLAG_ISOC_EN               0x03
+#define IVHD_FLAG_HT_TUN_EN_MASK        0x01
+#define IVHD_FLAG_PASSPW_EN_MASK        0x02
+#define IVHD_FLAG_RESPASSPW_EN_MASK     0x04
+#define IVHD_FLAG_ISOC_EN_MASK          0x08
 
 #define IVMD_FLAG_EXCL_RANGE            0x08
 #define IVMD_FLAG_UNITY_MAP             0x01
@@ -569,19 +569,19 @@ static void __init init_iommu_from_acpi(struct amd_iommu *iommu,
         * First set the recommended feature enable bits from ACPI
         * into the IOMMU control registers
         */
-       h->flags & IVHD_FLAG_HT_TUN_EN ?
+       h->flags & IVHD_FLAG_HT_TUN_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_HT_TUN_EN) :
                iommu_feature_disable(iommu, CONTROL_HT_TUN_EN);
 
-       h->flags & IVHD_FLAG_PASSPW_EN ?
+       h->flags & IVHD_FLAG_PASSPW_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_PASSPW_EN) :
                iommu_feature_disable(iommu, CONTROL_PASSPW_EN);
 
-       h->flags & IVHD_FLAG_RESPASSPW_EN ?
+       h->flags & IVHD_FLAG_RESPASSPW_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_RESPASSPW_EN) :
                iommu_feature_disable(iommu, CONTROL_RESPASSPW_EN);
 
-       h->flags & IVHD_FLAG_ISOC_EN ?
+       h->flags & IVHD_FLAG_ISOC_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_ISOC_EN) :
                iommu_feature_disable(iommu, CONTROL_ISOC_EN);
 
index c4f667896c28f1a3eb7e6ae33341f5ba98f74c98..c1caefc82e62512245f52b17251af69d2b2d2c2b 100644 (file)
@@ -1203,6 +1203,8 @@ void __cpuinit cpu_init(void)
        load_TR_desc();
        load_LDT(&init_mm.context);
 
+       t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);
+
 #ifdef CONFIG_DOUBLEFAULT
        /* Set up doublefault TSS pointer in the GDT */
        __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
index f93047fed79128cebc7d00e081e7108ef24b1c03..d5e30397246bfe5f986559aef6dbf483f89dcd28 100644 (file)
@@ -14,7 +14,7 @@ static void show_cpuinfo_core(struct seq_file *m, struct cpuinfo_x86 *c,
        if (c->x86_max_cores * smp_num_siblings > 1) {
                seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
                seq_printf(m, "siblings\t: %d\n",
-                          cpumask_weight(cpu_sibling_mask(cpu)));
+                          cpumask_weight(cpu_core_mask(cpu)));
                seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
                seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
                seq_printf(m, "apicid\t\t: %d\n", c->apicid);
index 4f115e00486bc1fe50fc8c1987298df3b8ac1266..50dc802a1c469b904154be3901f5fc87ebd7da93 100644 (file)
@@ -87,7 +87,7 @@ static struct kmmio_probe *get_kmmio_probe(unsigned long addr)
 {
        struct kmmio_probe *p;
        list_for_each_entry_rcu(p, &kmmio_probes, list) {
-               if (addr >= p->addr && addr <= (p->addr + p->len))
+               if (addr >= p->addr && addr < (p->addr + p->len))
                        return p;
        }
        return NULL;
index d9d35824c56f30e56266445cdf9ed5877f94bf52..6a40b78b46aafae8273ad7ed12ebbfd44187733a 100644 (file)
@@ -104,11 +104,13 @@ notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
 {
        long ret;
        if (likely(gtod->sysctl_enabled && gtod->clock.vread)) {
-               BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
-                            offsetof(struct timespec, tv_nsec) ||
-                            sizeof(*tv) != sizeof(struct timespec));
-               do_realtime((struct timespec *)tv);
-               tv->tv_usec /= 1000;
+               if (likely(tv != NULL)) {
+                       BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
+                                    offsetof(struct timespec, tv_nsec) ||
+                                    sizeof(*tv) != sizeof(struct timespec));
+                       do_realtime((struct timespec *)tv);
+                       tv->tv_usec /= 1000;
+               }
                if (unlikely(tz != NULL)) {
                        /* Avoid memcpy. Some old compilers fail to inline it */
                        tz->tz_minuteswest = gtod->sys_tz.tz_minuteswest;
index d82142be8dd2c8fddc340058ff9cd73373f6a31b..26e08754744fa13dd9da3e919be6adb3976b2b04 100644 (file)
@@ -363,8 +363,6 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
        irqreturn_t ret, retval = IRQ_NONE;
        unsigned int status = 0;
 
-       WARN_ONCE(!in_irq(), "BUG: IRQ handler called from non-hardirq context!");
-
        if (!(action->flags & IRQF_DISABLED))
                local_irq_enable_in_hardirq();
 
index c9dcf98b44633398217e3a7829ace3bf7791403d..bece7c0b67b29d42c3c425d053bd76087b7684f3 100644 (file)
@@ -1420,19 +1420,19 @@ void run_posix_cpu_timers(struct task_struct *tsk)
         * timer call will interfere.
         */
        list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) {
-               int firing;
+               int cpu_firing;
+
                spin_lock(&timer->it_lock);
                list_del_init(&timer->it.cpu.entry);
-               firing = timer->it.cpu.firing;
+               cpu_firing = timer->it.cpu.firing;
                timer->it.cpu.firing = 0;
                /*
                 * The firing flag is -1 if we collided with a reset
                 * of the timer, which already reported this
                 * almost-firing as an overrun.  So don't generate an event.
                 */
-               if (likely(firing >= 0)) {
+               if (likely(cpu_firing >= 0))
                        cpu_timer_fire(timer);
-               }
                spin_unlock(&timer->it_lock);
        }
 }
index b902e587a3a03e32a3e26f676e419f692ba79145..26efa475bdc143f6e4459067c18ce57e71608764 100644 (file)
@@ -4732,7 +4732,7 @@ void account_process_tick(struct task_struct *p, int user_tick)
 
        if (user_tick)
                account_user_time(p, one_jiffy, one_jiffy_scaled);
-       else if (p != rq->idle)
+       else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
                account_system_time(p, HARDIRQ_OFFSET, one_jiffy,
                                    one_jiffy_scaled);
        else
index 21a5ca849514b40b689c5b34e2c9caaf9cbf051b..83c4417b6a3cccd734c8f7f9386670641babd0c8 100644 (file)
@@ -93,7 +93,17 @@ void tick_handle_periodic(struct clock_event_device *dev)
        for (;;) {
                if (!clockevents_program_event(dev, next, ktime_get()))
                        return;
-               tick_periodic(cpu);
+               /*
+                * Have to be careful here. If we're in oneshot mode,
+                * before we call tick_periodic() in a loop, we need
+                * to be sure we're using a real hardware clocksource.
+                * Otherwise we could get trapped in an infinite
+                * loop, as the tick_periodic() increments jiffies,
+                * when then will increment time, posibly causing
+                * the loop to trigger again and again.
+                */
+               if (timekeeping_valid_for_hres())
+                       tick_periodic(cpu);
                next = ktime_add(next, tick_period);
        }
 }
index 1ce5dc6372b8fcc617bcb37722f22fdf95620e0a..a884c09006c4d2141248ff04848cca86dff56d64 100644 (file)
@@ -3448,6 +3448,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                if (!ref)
                        break;
 
+               ref->ref = 1;
                ref->buffer = info->tr->buffer;
                ref->page = ring_buffer_alloc_read_page(ref->buffer);
                if (!ref->page) {
index d3da7edc034f7c60496056332850458b849a4f61..69da09a085a1943ea6a70f4871fd2df1683110fb 100644 (file)
@@ -400,60 +400,9 @@ out_err:
        return -ENOMEM;
 }
 
-static int device_dma_allocations(struct device *dev)
-{
-       struct dma_debug_entry *entry;
-       unsigned long flags;
-       int count = 0, i;
-
-       for (i = 0; i < HASH_SIZE; ++i) {
-               spin_lock_irqsave(&dma_entry_hash[i].lock, flags);
-               list_for_each_entry(entry, &dma_entry_hash[i].list, list) {
-                       if (entry->dev == dev)
-                               count += 1;
-               }
-               spin_unlock_irqrestore(&dma_entry_hash[i].lock, flags);
-       }
-
-       return count;
-}
-
-static int dma_debug_device_change(struct notifier_block *nb,
-                                   unsigned long action, void *data)
-{
-       struct device *dev = data;
-       int count;
-
-
-       switch (action) {
-       case BUS_NOTIFY_UNBIND_DRIVER:
-               count = device_dma_allocations(dev);
-               if (count == 0)
-                       break;
-               err_printk(dev, NULL, "DMA-API: device driver has pending "
-                               "DMA allocations while released from device "
-                               "[count=%d]\n", count);
-               break;
-       default:
-               break;
-       }
-
-       return 0;
-}
-
 void dma_debug_add_bus(struct bus_type *bus)
 {
-       struct notifier_block *nb;
-
-       nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
-       if (nb == NULL) {
-               printk(KERN_ERR "dma_debug_add_bus: out of memory\n");
-               return;
-       }
-
-       nb->notifier_call = dma_debug_device_change;
-
-       bus_register_notifier(bus, nb);
+       /* FIXME: register notifier */
 }
 
 /*
index b9ce574827c8a2a48b972f0261decc234edf9e27..36d6ea2b63405a8bd682b1e225bb3f748de2eda5 100644 (file)
@@ -112,6 +112,14 @@ static long madvise_willneed(struct vm_area_struct * vma,
        if (!file)
                return -EBADF;
 
+       /*
+        * Page cache readahead assumes page cache pages are order-0 which
+        * is not the case for hugetlbfs. Do not give a bad return value
+        * but ignore the advice.
+        */
+       if (vma->vm_flags & VM_HUGETLB)
+               return 0;
+
        if (file->f_mapping->a_ops->get_xip_mem) {
                /* no bad return value, but ignore advice */
                return 0;
index 936b6f8e46ff2fc6663852a5f19e697d41e41296..161b7846733e5ee5988ef42d5bf114cd8f0eef4d 100644 (file)
@@ -384,11 +384,19 @@ static int parse_elf(struct elf_info *info, const char *filename)
                return 0;
        }
        /* Fix endianness in ELF header */
-       hdr->e_shoff    = TO_NATIVE(hdr->e_shoff);
-       hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
-       hdr->e_shnum    = TO_NATIVE(hdr->e_shnum);
-       hdr->e_machine  = TO_NATIVE(hdr->e_machine);
-       hdr->e_type     = TO_NATIVE(hdr->e_type);
+       hdr->e_type      = TO_NATIVE(hdr->e_type);
+       hdr->e_machine   = TO_NATIVE(hdr->e_machine);
+       hdr->e_version   = TO_NATIVE(hdr->e_version);
+       hdr->e_entry     = TO_NATIVE(hdr->e_entry);
+       hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
+       hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
+       hdr->e_flags     = TO_NATIVE(hdr->e_flags);
+       hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
+       hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
+       hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
+       hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
+       hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
+       hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
        sechdrs = (void *)hdr + hdr->e_shoff;
        info->sechdrs = sechdrs;
 
@@ -402,13 +410,16 @@ static int parse_elf(struct elf_info *info, const char *filename)
 
        /* Fix endianness in section headers */
        for (i = 0; i < hdr->e_shnum; i++) {
-               sechdrs[i].sh_type   = TO_NATIVE(sechdrs[i].sh_type);
-               sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
-               sechdrs[i].sh_size   = TO_NATIVE(sechdrs[i].sh_size);
-               sechdrs[i].sh_link   = TO_NATIVE(sechdrs[i].sh_link);
-               sechdrs[i].sh_name   = TO_NATIVE(sechdrs[i].sh_name);
-               sechdrs[i].sh_info   = TO_NATIVE(sechdrs[i].sh_info);
-               sechdrs[i].sh_addr   = TO_NATIVE(sechdrs[i].sh_addr);
+               sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
+               sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
+               sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
+               sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
+               sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
+               sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
+               sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
+               sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
+               sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
+               sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
        }
        /* Find symbol table. */
        for (i = 1; i < hdr->e_shnum; i++) {
@@ -716,7 +727,17 @@ int match(const char *sym, const char * const pat[])
 
 /* sections that we do not want to do full section mismatch check on */
 static const char *section_white_list[] =
-       { ".comment", ".debug*", ".stab*", ".note*", ".got*", ".toc*", NULL };
+{
+       ".comment*",
+       ".debug*",
+       ".mdebug*",        /* alpha, score, mips etc. */
+       ".pdr",            /* alpha, score, mips etc. */
+       ".stab*",
+       ".note*",
+       ".got*",
+       ".toc*",
+       NULL
+};
 
 /*
  * This is used to find sections missing the SHF_ALLOC flag.