Merge ../linus

9 files changed, 196 insertions, 50 deletions

diff --git a/mm/fadvise.c b/mm/fadvise.c
index 60a5d55e51d9..168c78a121bb 100644
--- a/mm/fadvise.c
+++ b/mm/fadvise.c
@@ -73,7 +73,6 @@ asmlinkage long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
                 file->f_ra.ra_pages = bdi->ra_pages * 2;
                 break;
         case POSIX_FADV_WILLNEED:
-        case POSIX_FADV_NOREUSE:
                 if (!mapping->a_ops->readpage) {
                         ret = -EINVAL;
                         break;
@@ -94,6 +93,8 @@ asmlinkage long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
                 if (ret > 0)
                         ret = 0;
                 break;
+        case POSIX_FADV_NOREUSE:
+                break;
         case POSIX_FADV_DONTNEED:
                 if (!bdi_write_congested(mapping->backing_dev_info))
                         filemap_flush(mapping);
diff --git a/mm/filemap.c b/mm/filemap.c
index d087fc3d3281..b9a60c43b61a 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -849,8 +849,6 @@ static void shrink_readahead_size_eio(struct file *filp,
                 return;
 
         ra->ra_pages /= 4;
-        printk(KERN_WARNING "Reducing readahead size to %luK\n",
-                        ra->ra_pages << (PAGE_CACHE_SHIFT - 10));
 }
 
 /**
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 01c9fb97c619..c37319542b70 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -52,6 +52,9 @@ static int __add_section(struct zone *zone, unsigned long phys_start_pfn)
         int nr_pages = PAGES_PER_SECTION;
         int ret;
 
+        if (pfn_valid(phys_start_pfn))
+                return -EEXIST;
+
         ret = sparse_add_one_section(zone, phys_start_pfn, nr_pages);
 
         if (ret < 0)
@@ -76,15 +79,22 @@ int __add_pages(struct zone *zone, unsigned long phys_start_pfn,
 {
         unsigned long i;
         int err = 0;
+        int start_sec, end_sec;
+        /* during initialize mem_map, align hot-added range to section */
+        start_sec = pfn_to_section_nr(phys_start_pfn);
+        end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1);
 
-        for (i = 0; i < nr_pages; i += PAGES_PER_SECTION) {
-                err = __add_section(zone, phys_start_pfn + i);
+        for (i = start_sec; i <= end_sec; i++) {
+                err = __add_section(zone, i << PFN_SECTION_SHIFT);
 
-                /* We want to keep adding the rest of the
-                 * sections if the first ones already exist
+                /*
+                 * EEXIST is finally dealed with by ioresource collision
+                 * check. see add_memory() => register_memory_resource()
+                 * Warning will be printed if there is collision.
                  */
                 if (err && (err != -EEXIST))
                         break;
+                err = 0;
         }
 
         return err;
@@ -156,7 +166,7 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
         res.flags = IORESOURCE_MEM; /* we just need system ram */
         section_end = res.end;
 
-        while (find_next_system_ram(&res) >= 0) {
+        while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {
                 start_pfn = (unsigned long)(res.start >> PAGE_SHIFT);
                 nr_pages = (unsigned long)
                            ((res.end + 1 - res.start) >> PAGE_SHIFT);
@@ -213,10 +223,9 @@ static void rollback_node_hotadd(int nid, pg_data_t *pgdat)
 }
 
 /* add this memory to iomem resource */
-static void register_memory_resource(u64 start, u64 size)
+static struct resource *register_memory_resource(u64 start, u64 size)
 {
         struct resource *res;
-
         res = kzalloc(sizeof(struct resource), GFP_KERNEL);
         BUG_ON(!res);
 
@@ -228,7 +237,18 @@ static void register_memory_resource(u64 start, u64 size)
                 printk("System RAM resource %llx - %llx cannot be added\n",
                 (unsigned long long)res->start, (unsigned long long)res->end);
                 kfree(res);
+                res = NULL;
         }
+        return res;
+}
+
+static void release_memory_resource(struct resource *res)
+{
+        if (!res)
+                return;
+        release_resource(res);
+        kfree(res);
+        return;
 }
 
 
@@ -237,8 +257,13 @@ int add_memory(int nid, u64 start, u64 size)
 {
         pg_data_t *pgdat = NULL;
         int new_pgdat = 0;
+        struct resource *res;
         int ret;
 
+        res = register_memory_resource(start, size);
+        if (!res)
+                return -EEXIST;
+
         if (!node_online(nid)) {
                 pgdat = hotadd_new_pgdat(nid, start);
                 if (!pgdat)
@@ -268,14 +293,13 @@ int add_memory(int nid, u64 start, u64 size)
                 BUG_ON(ret);
         }
 
-        /* register this memory as resource */
-        register_memory_resource(start, size);
-
         return ret;
 error:
         /* rollback pgdat allocation and others */
         if (new_pgdat)
                 rollback_node_hotadd(nid, pgdat);
+        if (res)
+                release_memory_resource(res);
 
         return ret;
 }
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index e07e27e846a2..a9963ceddd65 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1176,7 +1176,15 @@ static inline unsigned interleave_nid(struct mempolicy *pol,
         if (vma) {
                 unsigned long off;
 
-                off = vma->vm_pgoff;
+                /*
+                 * for small pages, there is no difference between
+                 * shift and PAGE_SHIFT, so the bit-shift is safe.
+                 * for huge pages, since vm_pgoff is in units of small
+                 * pages, we need to shift off the always 0 bits to get
+                 * a useful offset.
+                 */
+                BUG_ON(shift < PAGE_SHIFT);
+                off = vma->vm_pgoff >> (shift - PAGE_SHIFT);
                 off += (addr - vma->vm_start) >> shift;
                 return offset_il_node(pol, vma, off);
         } else
diff --git a/mm/mempool.c b/mm/mempool.c
index fe6e05289cc5..ccd8cb8cd41f 100644
--- a/mm/mempool.c
+++ b/mm/mempool.c
@@ -238,8 +238,13 @@ repeat_alloc:
         init_wait(&wait);
         prepare_to_wait(&pool->wait, &wait, TASK_UNINTERRUPTIBLE);
         smp_mb();
-        if (!pool->curr_nr)
-                io_schedule();
+        if (!pool->curr_nr) {
+                /*
+                 * FIXME: this should be io_schedule().  The timeout is there
+                 * as a workaround for some DM problems in 2.6.18.
+                 */
+                io_schedule_timeout(5*HZ);
+        }
         finish_wait(&pool->wait, &wait);
 
         goto repeat_alloc;
diff --git a/mm/slab.c b/mm/slab.c
index 0f20843beffd..21ba06035700 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1106,7 +1106,7 @@ static inline int cache_free_alien(struct kmem_cache *cachep, void *objp)
 
 #endif
 
-static int __devinit cpuup_callback(struct notifier_block *nfb,
+static int __cpuinit cpuup_callback(struct notifier_block *nfb,
                                     unsigned long action, void *hcpu)
 {
         long cpu = (long)hcpu;
@@ -3224,7 +3224,7 @@ void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
 EXPORT_SYMBOL(kmem_cache_alloc);
 
 /**
- * kmem_cache_alloc - Allocate an object. The memory is set to zero.
+ * kmem_cache_zalloc - Allocate an object. The memory is set to zero.
  * @cache: The cache to allocate from.
  * @flags: See kmalloc().
  *
diff --git a/mm/swap.c b/mm/swap.c
index 8fd095c4ae51..687686a61f7c 100644
--- a/mm/swap.c
+++ b/mm/swap.c
@@ -54,6 +54,26 @@ void put_page(struct page *page)
 }
 EXPORT_SYMBOL(put_page);
 
+/**
+ * put_pages_list(): release a list of pages
+ *
+ * Release a list of pages which are strung together on page.lru.  Currently
+ * used by read_cache_pages() and related error recovery code.
+ *
+ * @pages: list of pages threaded on page->lru
+ */
+void put_pages_list(struct list_head *pages)
+{
+        while (!list_empty(pages)) {
+                struct page *victim;
+
+                victim = list_entry(pages->prev, struct page, lru);
+                list_del(&victim->lru);
+                page_cache_release(victim);
+        }
+}
+EXPORT_SYMBOL(put_pages_list);
+
 /*
  * Writeback is about to end against a page which has been marked for immediate
  * reclaim.  If it still appears to be reclaimable, move it to the tail of the
diff --git a/mm/swapfile.c b/mm/swapfile.c
index e70d6c6d6fee..f1f5ec783781 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -442,11 +442,12 @@ int swap_type_of(dev_t device)
 
                 if (!(swap_info[i].flags & SWP_WRITEOK))
                         continue;
+
                 if (!device) {
                         spin_unlock(&swap_lock);
                         return i;
                 }
-                inode = swap_info->swap_file->f_dentry->d_inode;
+                inode = swap_info[i].swap_file->f_dentry->d_inode;
                 if (S_ISBLK(inode->i_mode) &&
                     device == MKDEV(imajor(inode), iminor(inode))) {
                         spin_unlock(&swap_lock);
diff --git a/mm/vmstat.c b/mm/vmstat.c
index dfdf24133901..c1b5f4106b38 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -12,6 +12,7 @@
 #include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/cpu.h>
 
 void __get_zone_counts(unsigned long *active, unsigned long *inactive,
                         unsigned long *free, struct pglist_data *pgdat)
@@ -114,17 +115,72 @@ EXPORT_SYMBOL(vm_stat);
 
 #ifdef CONFIG_SMP
 
-#define STAT_THRESHOLD 32
+static int calculate_threshold(struct zone *zone)
+{
+        int threshold;
+        int mem;        /* memory in 128 MB units */
+
+        /*
+         * The threshold scales with the number of processors and the amount
+         * of memory per zone. More memory means that we can defer updates for
+         * longer, more processors could lead to more contention.
+         * fls() is used to have a cheap way of logarithmic scaling.
+         *
+         * Some sample thresholds:
+         *
+         * Threshold    Processors      (fls)   Zonesize        fls(mem+1)
+         * ------------------------------------------------------------------
+         * 8            1               1       0.9-1 GB        4
+         * 16           2               2       0.9-1 GB        4
+         * 20           2               2       1-2 GB          5
+         * 24           2               2       2-4 GB          6
+         * 28           2               2       4-8 GB          7
+         * 32           2               2       8-16 GB         8
+         * 4            2               2       <128M           1
+         * 30           4               3       2-4 GB          5
+         * 48           4               3       8-16 GB         8
+         * 32           8               4       1-2 GB          4
+         * 32           8               4       0.9-1GB         4
+         * 10           16              5       <128M           1
+         * 40           16              5       900M            4
+         * 70           64              7       2-4 GB          5
+         * 84           64              7       4-8 GB          6
+         * 108          512             9       4-8 GB          6
+         * 125          1024            10      8-16 GB         8
+         * 125          1024            10      16-32 GB        9
+         */
+
+        mem = zone->present_pages >> (27 - PAGE_SHIFT);
+
+        threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
+
+        /*
+         * Maximum threshold is 125
+         */
+        threshold = min(125, threshold);
+
+        return threshold;
+}
 
 /*
- * Determine pointer to currently valid differential byte given a zone and
- * the item number.
- *
- * Preemption must be off
+ * Refresh the thresholds for each zone.
  */
-static inline s8 *diff_pointer(struct zone *zone, enum zone_stat_item item)
+static void refresh_zone_stat_thresholds(void)
 {
-        return &zone_pcp(zone, smp_processor_id())->vm_stat_diff[item];
+        struct zone *zone;
+        int cpu;
+        int threshold;
+
+        for_each_zone(zone) {
+
+                if (!zone->present_pages)
+                        continue;
+
+                threshold = calculate_threshold(zone);
+
+                for_each_online_cpu(cpu)
+                        zone_pcp(zone, cpu)->stat_threshold = threshold;
+        }
 }
 
 /*
@@ -133,17 +189,16 @@ static inline s8 *diff_pointer(struct zone *zone, enum zone_stat_item item)
 void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
                                 int delta)
 {
-        s8 *p;
+        struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id());
+        s8 *p = pcp->vm_stat_diff + item;
         long x;
 
-        p = diff_pointer(zone, item);
         x = delta + *p;
 
-        if (unlikely(x > STAT_THRESHOLD || x < -STAT_THRESHOLD)) {
+        if (unlikely(x > pcp->stat_threshold || x < -pcp->stat_threshold)) {
                 zone_page_state_add(x, zone, item);
                 x = 0;
         }
-
         *p = x;
 }
 EXPORT_SYMBOL(__mod_zone_page_state);
@@ -172,10 +227,12 @@ EXPORT_SYMBOL(mod_zone_page_state);
  * No overflow check is necessary and therefore the differential can be
  * incremented or decremented in place which may allow the compilers to
  * generate better code.
- *
  * The increment or decrement is known and therefore one boundary check can
  * be omitted.
  *
+ * NOTE: These functions are very performance sensitive. Change only
+ * with care.
+ *
  * Some processors have inc/dec instructions that are atomic vs an interrupt.
  * However, the code must first determine the differential location in a zone
  * based on the processor number and then inc/dec the counter. There is no
@@ -185,13 +242,16 @@ EXPORT_SYMBOL(mod_zone_page_state);
  */
 static void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
 {
-        s8 *p = diff_pointer(zone, item);
+        struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id());
+        s8 *p = pcp->vm_stat_diff + item;
 
         (*p)++;
 
-        if (unlikely(*p > STAT_THRESHOLD)) {
-                zone_page_state_add(*p, zone, item);
-                *p = 0;
+        if (unlikely(*p > pcp->stat_threshold)) {
+                int overstep = pcp->stat_threshold / 2;
+
+                zone_page_state_add(*p + overstep, zone, item);
+                *p = -overstep;
         }
 }
 
@@ -204,13 +264,16 @@ EXPORT_SYMBOL(__inc_zone_page_state);
 void __dec_zone_page_state(struct page *page, enum zone_stat_item item)
 {
         struct zone *zone = page_zone(page);
-        s8 *p = diff_pointer(zone, item);
+        struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id());
+        s8 *p = pcp->vm_stat_diff + item;
 
         (*p)--;
 
-        if (unlikely(*p < -STAT_THRESHOLD)) {
-                zone_page_state_add(*p, zone, item);
-                *p = 0;
+        if (unlikely(*p < - pcp->stat_threshold)) {
+                int overstep = pcp->stat_threshold / 2;
+
+                zone_page_state_add(*p - overstep, zone, item);
+                *p = overstep;
         }
 }
 EXPORT_SYMBOL(__dec_zone_page_state);
@@ -239,19 +302,9 @@ EXPORT_SYMBOL(inc_zone_page_state);
 void dec_zone_page_state(struct page *page, enum zone_stat_item item)
 {
         unsigned long flags;
-        struct zone *zone;
-        s8 *p;
 
-        zone = page_zone(page);
         local_irq_save(flags);
-        p = diff_pointer(zone, item);
-
-        (*p)--;
-
-        if (unlikely(*p < -STAT_THRESHOLD)) {
-                zone_page_state_add(*p, zone, item);
-                *p = 0;
-        }
+        __dec_zone_page_state(page, item);
         local_irq_restore(flags);
 }
 EXPORT_SYMBOL(dec_zone_page_state);
@@ -525,6 +578,10 @@ static int zoneinfo_show(struct seq_file *m, void *arg)
                                            pageset->pcp[j].high,
                                            pageset->pcp[j].batch);
                         }
+#ifdef CONFIG_SMP
+                        seq_printf(m, "\n  vm stats threshold: %d",
+                                        pageset->stat_threshold);
+#endif
                 }
                 seq_printf(m,
                            "\n  all_unreclaimable: %u"
@@ -613,3 +670,35 @@ struct seq_operations vmstat_op = {
 
 #endif /* CONFIG_PROC_FS */
 
+#ifdef CONFIG_SMP
+/*
+ * Use the cpu notifier to insure that the thresholds are recalculated
+ * when necessary.
+ */
+static int __cpuinit vmstat_cpuup_callback(struct notifier_block *nfb,
+                unsigned long action,
+                void *hcpu)
+{
+        switch (action) {
+                case CPU_UP_PREPARE:
+                case CPU_UP_CANCELED:
+                case CPU_DEAD:
+                        refresh_zone_stat_thresholds();
+                        break;
+                default:
+                        break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block __cpuinitdata vmstat_notifier =
+        { &vmstat_cpuup_callback, NULL, 0 };
+
+int __init setup_vmstat(void)
+{
+        refresh_zone_stat_thresholds();
+        register_cpu_notifier(&vmstat_notifier);
+        return 0;
+}
+module_init(setup_vmstat)
+#endif