Merge branch 'linus' into cpus4096

Conflicts:

	arch/x86/xen/smp.c
	kernel/sched_rt.c
	net/iucv/iucv.c

Signed-off-by: Ingo Molnar <mingo@elte.hu>

7 files changed, 108 insertions, 50 deletions

diff --git a/mm/Kconfig b/mm/Kconfig
index 3aa819d628c1..c4de85285bb4 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -129,7 +129,7 @@ config MEMORY_HOTPLUG
         bool "Allow for memory hot-add"
         depends on SPARSEMEM || X86_64_ACPI_NUMA
         depends on HOTPLUG && !HIBERNATION && ARCH_ENABLE_MEMORY_HOTPLUG
-        depends on (IA64 || X86 || PPC64 || SUPERH)
+        depends on (IA64 || X86 || PPC64 || SUPERH || S390)
 
 comment "Memory hotplug is currently incompatible with Software Suspend"
         depends on SPARSEMEM && HOTPLUG && HIBERNATION
@@ -199,7 +199,7 @@ config BOUNCE
 config NR_QUICK
         int
         depends on QUICKLIST
-        default "2" if SUPERH
+        default "2" if SUPERH || AVR32
         default "1"
 
 config VIRT_TO_BUS
diff --git a/mm/filemap.c b/mm/filemap.c
index 1e6a7d34874f..65d9d9e2b755 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -236,11 +236,12 @@ int filemap_fdatawrite(struct address_space *mapping)
 }
 EXPORT_SYMBOL(filemap_fdatawrite);
 
-static int filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
+int filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
                                 loff_t end)
 {
         return __filemap_fdatawrite_range(mapping, start, end, WB_SYNC_ALL);
 }
+EXPORT_SYMBOL(filemap_fdatawrite_range);
 
 /**
  * filemap_flush - mostly a non-blocking flush
diff --git a/mm/mprotect.c b/mm/mprotect.c
index a5bf31c27375..acfe7c8d72fc 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -47,19 +47,17 @@ static void change_pte_range(struct mm_struct *mm, pmd_t *pmd,
                 if (pte_present(oldpte)) {
                         pte_t ptent;
 
-                        /* Avoid an SMP race with hardware updated dirty/clean
-                         * bits by wiping the pte and then setting the new pte
-                         * into place.
-                         */
-                        ptent = ptep_get_and_clear(mm, addr, pte);
+                        ptent = ptep_modify_prot_start(mm, addr, pte);
                         ptent = pte_modify(ptent, newprot);
+
                         /*
                          * Avoid taking write faults for pages we know to be
                          * dirty.
                          */
                         if (dirty_accountable && pte_dirty(ptent))
                                 ptent = pte_mkwrite(ptent);
-                        set_pte_at(mm, addr, pte, ptent);
+
+                        ptep_modify_prot_commit(mm, addr, pte, ptent);
 #ifdef CONFIG_MIGRATION
                 } else if (!pte_file(oldpte)) {
                         swp_entry_t entry = pte_to_swp_entry(oldpte);
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 789b6adbef37..94c6d8988ab3 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -126,8 +126,6 @@ static void background_writeout(unsigned long _min_pages);
 static struct prop_descriptor vm_completions;
 static struct prop_descriptor vm_dirties;
 
-static unsigned long determine_dirtyable_memory(void);
-
 /*
  * couple the period to the dirty_ratio:
  *
@@ -347,7 +345,13 @@ static unsigned long highmem_dirtyable_memory(unsigned long total)
 #endif
 }
 
-static unsigned long determine_dirtyable_memory(void)
+/**
+ * determine_dirtyable_memory - amount of memory that may be used
+ *
+ * Returns the numebr of pages that can currently be freed and used
+ * by the kernel for direct mappings.
+ */
+unsigned long determine_dirtyable_memory(void)
 {
         unsigned long x;
 
@@ -956,6 +960,9 @@ retry:
         }
         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
                 mapping->writeback_index = index;
+
+        if (wbc->range_cont)
+                wbc->range_start = index << PAGE_CACHE_SHIFT;
         return ret;
 }
 EXPORT_SYMBOL(write_cache_pages);
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index f32fae3121f0..79ac4afc908c 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -918,7 +918,7 @@ void drain_local_pages(void *arg)
  */
 void drain_all_pages(void)
 {
-        on_each_cpu(drain_local_pages, NULL, 0, 1);
+        on_each_cpu(drain_local_pages, NULL, 1);
 }
 
 #ifdef CONFIG_HIBERNATION
@@ -2929,6 +2929,18 @@ void __init free_bootmem_with_active_regions(int nid,
         }
 }
 
+void __init work_with_active_regions(int nid, work_fn_t work_fn, void *data)
+{
+        int i;
+        int ret;
+
+        for_each_active_range_index_in_nid(i, nid) {
+                ret = work_fn(early_node_map[i].start_pfn,
+                              early_node_map[i].end_pfn, data);
+                if (ret)
+                        break;
+        }
+}
 /**
  * sparse_memory_present_with_active_regions - Call memory_present for each active range
  * @nid: The node to call memory_present for. If MAX_NUMNODES, all nodes will be used.
@@ -3461,6 +3473,11 @@ void __paginginit free_area_init_node(int nid, struct pglist_data *pgdat,
         calculate_node_totalpages(pgdat, zones_size, zholes_size);
 
         alloc_node_mem_map(pgdat);
+#ifdef CONFIG_FLAT_NODE_MEM_MAP
+        printk(KERN_DEBUG "free_area_init_node: node %d, pgdat %08lx, node_mem_map %08lx\n",
+                nid, (unsigned long)pgdat,
+                (unsigned long)pgdat->node_mem_map);
+#endif
 
         free_area_init_core(pgdat, zones_size, zholes_size);
 }
@@ -3503,7 +3520,7 @@ void __init add_active_range(unsigned int nid, unsigned long start_pfn,
 {
         int i;
 
-        printk(KERN_DEBUG "Entering add_active_range(%d, %lu, %lu) "
+        printk(KERN_DEBUG "Entering add_active_range(%d, %#lx, %#lx) "
                           "%d entries of %d used\n",
                           nid, start_pfn, end_pfn,
                           nr_nodemap_entries, MAX_ACTIVE_REGIONS);
@@ -3547,27 +3564,68 @@ void __init add_active_range(unsigned int nid, unsigned long start_pfn,
 }
 
 /**
- * shrink_active_range - Shrink an existing registered range of PFNs
+ * remove_active_range - Shrink an existing registered range of PFNs
  * @nid: The node id the range is on that should be shrunk
- * @old_end_pfn: The old end PFN of the range
- * @new_end_pfn: The new PFN of the range
+ * @start_pfn: The new PFN of the range
+ * @end_pfn: The new PFN of the range
  *
  * i386 with NUMA use alloc_remap() to store a node_mem_map on a local node.
- * The map is kept at the end physical page range that has already been
- * registered with add_active_range(). This function allows an arch to shrink
- * an existing registered range.
+ * The map is kept near the end physical page range that has already been
+ * registered. This function allows an arch to shrink an existing registered
+ * range.
  */
-void __init shrink_active_range(unsigned int nid, unsigned long old_end_pfn,
-                                                unsigned long new_end_pfn)
+void __init remove_active_range(unsigned int nid, unsigned long start_pfn,
+                                unsigned long end_pfn)
 {
-        int i;
+        int i, j;
+        int removed = 0;
+
+        printk(KERN_DEBUG "remove_active_range (%d, %lu, %lu)\n",
+                          nid, start_pfn, end_pfn);
 
         /* Find the old active region end and shrink */
-        for_each_active_range_index_in_nid(i, nid)
-                if (early_node_map[i].end_pfn == old_end_pfn) {
-                        early_node_map[i].end_pfn = new_end_pfn;
-                        break;
+        for_each_active_range_index_in_nid(i, nid) {
+                if (early_node_map[i].start_pfn >= start_pfn &&
+                    early_node_map[i].end_pfn <= end_pfn) {
+                        /* clear it */
+                        early_node_map[i].start_pfn = 0;
+                        early_node_map[i].end_pfn = 0;
+                        removed = 1;
+                        continue;
+                }
+                if (early_node_map[i].start_pfn < start_pfn &&
+                    early_node_map[i].end_pfn > start_pfn) {
+                        unsigned long temp_end_pfn = early_node_map[i].end_pfn;
+                        early_node_map[i].end_pfn = start_pfn;
+                        if (temp_end_pfn > end_pfn)
+                                add_active_range(nid, end_pfn, temp_end_pfn);
+                        continue;
                 }
+                if (early_node_map[i].start_pfn >= start_pfn &&
+                    early_node_map[i].end_pfn > end_pfn &&
+                    early_node_map[i].start_pfn < end_pfn) {
+                        early_node_map[i].start_pfn = end_pfn;
+                        continue;
+                }
+        }
+
+        if (!removed)
+                return;
+
+        /* remove the blank ones */
+        for (i = nr_nodemap_entries - 1; i > 0; i--) {
+                if (early_node_map[i].nid != nid)
+                        continue;
+                if (early_node_map[i].end_pfn)
+                        continue;
+                /* we found it, get rid of it */
+                for (j = i; j < nr_nodemap_entries - 1; j++)
+                        memcpy(&early_node_map[j], &early_node_map[j+1],
+                                sizeof(early_node_map[j]));
+                j = nr_nodemap_entries - 1;
+                memset(&early_node_map[j], 0, sizeof(early_node_map[j]));
+                nr_nodemap_entries--;
+        }
 }
 
 /**
@@ -3611,7 +3669,7 @@ static void __init sort_node_map(void)
 }
 
 /* Find the lowest pfn for a node */
-unsigned long __init find_min_pfn_for_node(unsigned long nid)
+unsigned long __init find_min_pfn_for_node(int nid)
 {
         int i;
         unsigned long min_pfn = ULONG_MAX;
@@ -3622,7 +3680,7 @@ unsigned long __init find_min_pfn_for_node(unsigned long nid)
 
         if (min_pfn == ULONG_MAX) {
                 printk(KERN_WARNING
-                        "Could not find start_pfn for node %lu\n", nid);
+                        "Could not find start_pfn for node %d\n", nid);
                 return 0;
         }
 
@@ -3878,7 +3936,7 @@ void __init free_area_init_nodes(unsigned long *max_zone_pfn)
         for (i = 0; i < MAX_NR_ZONES; i++) {
                 if (i == ZONE_MOVABLE)
                         continue;
-                printk("  %-8s %8lu -> %8lu\n",
+                printk("  %-8s %0#10lx -> %0#10lx\n",
                                 zone_names[i],
                                 arch_zone_lowest_possible_pfn[i],
                                 arch_zone_highest_possible_pfn[i]);
@@ -3894,7 +3952,7 @@ void __init free_area_init_nodes(unsigned long *max_zone_pfn)
         /* Print out the early_node_map[] */
         printk("early_node_map[%d] active PFN ranges\n", nr_nodemap_entries);
         for (i = 0; i < nr_nodemap_entries; i++)
-                printk("  %3d: %8lu -> %8lu\n", early_node_map[i].nid,
+                printk("  %3d: %0#10lx -> %0#10lx\n", early_node_map[i].nid,
                                                 early_node_map[i].start_pfn,
                                                 early_node_map[i].end_pfn);
 
diff --git a/mm/slab.c b/mm/slab.c
index 046607f05f3e..052e7d64537e 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1901,15 +1901,7 @@ static void check_poison_obj(struct kmem_cache *cachep, void *objp)
 #endif
 
 #if DEBUG
-/**
- * slab_destroy_objs - destroy a slab and its objects
- * @cachep: cache pointer being destroyed
- * @slabp: slab pointer being destroyed
- *
- * Call the registered destructor for each object in a slab that is being
- * destroyed.
- */
-static void slab_destroy_objs(struct kmem_cache *cachep, struct slab *slabp)
+static void slab_destroy_debugcheck(struct kmem_cache *cachep, struct slab *slabp)
 {
         int i;
         for (i = 0; i < cachep->num; i++) {
@@ -1938,7 +1930,7 @@ static void slab_destroy_objs(struct kmem_cache *cachep, struct slab *slabp)
         }
 }
 #else
-static void slab_destroy_objs(struct kmem_cache *cachep, struct slab *slabp)
+static void slab_destroy_debugcheck(struct kmem_cache *cachep, struct slab *slabp)
 {
 }
 #endif
@@ -1956,7 +1948,7 @@ static void slab_destroy(struct kmem_cache *cachep, struct slab *slabp)
 {
         void *addr = slabp->s_mem - slabp->colouroff;
 
-        slab_destroy_objs(cachep, slabp);
+        slab_destroy_debugcheck(cachep, slabp);
         if (unlikely(cachep->flags & SLAB_DESTROY_BY_RCU)) {
                 struct slab_rcu *slab_rcu;
 
@@ -2454,7 +2446,7 @@ static void drain_cpu_caches(struct kmem_cache *cachep)
         struct kmem_list3 *l3;
         int node;
 
-        on_each_cpu(do_drain, cachep, 1, 1);
+        on_each_cpu(do_drain, cachep, 1);
         check_irq_on();
         for_each_online_node(node) {
                 l3 = cachep->nodelists[node];
@@ -3939,7 +3931,7 @@ static int do_tune_cpucache(struct kmem_cache *cachep, int limit,
         }
         new->cachep = cachep;
 
-        on_each_cpu(do_ccupdate_local, (void *)new, 1, 1);
+        on_each_cpu(do_ccupdate_local, (void *)new, 1);
 
         check_irq_on();
         cachep->batchcount = batchcount;
diff --git a/mm/slub.c b/mm/slub.c
index 1a427c0ae83b..35ab38a94b46 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -411,7 +411,7 @@ static void set_track(struct kmem_cache *s, void *object,
         if (addr) {
                 p->addr = addr;
                 p->cpu = smp_processor_id();
-                p->pid = current ? current->pid : -1;
+                p->pid = current->pid;
                 p->when = jiffies;
         } else
                 memset(p, 0, sizeof(struct track));
@@ -431,9 +431,8 @@ static void print_track(const char *s, struct track *t)
         if (!t->addr)
                 return;
 
-        printk(KERN_ERR "INFO: %s in ", s);
-        __print_symbol("%s", (unsigned long)t->addr);
-        printk(" age=%lu cpu=%u pid=%d\n", jiffies - t->when, t->cpu, t->pid);
+        printk(KERN_ERR "INFO: %s in %pS age=%lu cpu=%u pid=%d\n",
+                s, t->addr, jiffies - t->when, t->cpu, t->pid);
 }
 
 static void print_tracking(struct kmem_cache *s, void *object)
@@ -1497,7 +1496,7 @@ static void flush_cpu_slab(void *d)
 static void flush_all(struct kmem_cache *s)
 {
 #ifdef CONFIG_SMP
-        on_each_cpu(flush_cpu_slab, s, 1, 1);
+        on_each_cpu(flush_cpu_slab, s, 1);
 #else
         unsigned long flags;
 
@@ -1628,9 +1627,11 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
         void **object;
         struct kmem_cache_cpu *c;
         unsigned long flags;
+        unsigned int objsize;
 
         local_irq_save(flags);
         c = get_cpu_slab(s, smp_processor_id());
+        objsize = c->objsize;
         if (unlikely(!c->freelist || !node_match(c, node)))
 
                 object = __slab_alloc(s, gfpflags, node, addr, c);
@@ -1643,7 +1644,7 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
         local_irq_restore(flags);
 
         if (unlikely((gfpflags & __GFP_ZERO) && object))
-                memset(object, 0, c->objsize);
+                memset(object, 0, objsize);
 
         return object;
 }
@@ -2765,6 +2766,7 @@ void kfree(const void *x)
 
         page = virt_to_head_page(x);
         if (unlikely(!PageSlab(page))) {
+                BUG_ON(!PageCompound(page));
                 put_page(page);
                 return;
         }