Merge branch 'linus' into tracing/kmemtrace2

13 files changed, 49 insertions, 31 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index f3e5f8944d1..f5769b4dc07 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -1766,7 +1766,7 @@ int should_remove_suid(struct dentry *dentry)
         if (unlikely((mode & S_ISGID) && (mode & S_IXGRP)))
                 kill |= ATTR_KILL_SGID;
 
-        if (unlikely(kill && !capable(CAP_FSETID)))
+        if (unlikely(kill && !capable(CAP_FSETID) && S_ISREG(mode)))
                 return kill;
 
         return 0;
@@ -2140,19 +2140,24 @@ EXPORT_SYMBOL(generic_file_direct_write);
  * Find or create a page at the given pagecache position. Return the locked
  * page. This function is specifically for buffered writes.
  */
-struct page *__grab_cache_page(struct address_space *mapping, pgoff_t index)
+struct page *grab_cache_page_write_begin(struct address_space *mapping,
+                                        pgoff_t index, unsigned flags)
 {
         int status;
         struct page *page;
+        gfp_t gfp_notmask = 0;
+        if (flags & AOP_FLAG_NOFS)
+                gfp_notmask = __GFP_FS;
 repeat:
         page = find_lock_page(mapping, index);
         if (likely(page))
                 return page;
 
-        page = page_cache_alloc(mapping);
+        page = __page_cache_alloc(mapping_gfp_mask(mapping) & ~gfp_notmask);
         if (!page)
                 return NULL;
-        status = add_to_page_cache_lru(page, mapping, index, GFP_KERNEL);
+        status = add_to_page_cache_lru(page, mapping, index,
+                                                GFP_KERNEL & ~gfp_notmask);
         if (unlikely(status)) {
                 page_cache_release(page);
                 if (status == -EEXIST)
@@ -2161,7 +2166,7 @@ repeat:
         }
         return page;
 }
-EXPORT_SYMBOL(__grab_cache_page);
+EXPORT_SYMBOL(grab_cache_page_write_begin);
 
 static ssize_t generic_perform_write(struct file *file,
                                 struct iov_iter *i, loff_t pos)
diff --git a/mm/memory.c b/mm/memory.c
index 0a2010a9518..7b9db658aca 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2266,7 +2266,7 @@ int vmtruncate(struct inode * inode, loff_t offset)
                 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
         }
 
-        if (inode->i_op && inode->i_op->truncate)
+        if (inode->i_op->truncate)
                 inode->i_op->truncate(inode);
         return 0;
 
@@ -2286,7 +2286,7 @@ int vmtruncate_range(struct inode *inode, loff_t offset, loff_t end)
          * a way to truncate a range of blocks (punch a hole) -
          * we should return failure right now.
          */
-        if (!inode->i_op || !inode->i_op->truncate_range)
+        if (!inode->i_op->truncate_range)
                 return -ENOSYS;
 
         mutex_lock(&inode->i_mutex);
diff --git a/mm/mmap.c b/mm/mmap.c
index d4855a682ab..2c778fcfd9b 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -3,7 +3,7 @@
  *
  * Written by obz.
  *
- * Address space accounting code        <alan@redhat.com>
+ * Address space accounting code        <alan@lxorguk.ukuu.org.uk>
  */
 
 #include <linux/slab.h>
diff --git a/mm/mprotect.c b/mm/mprotect.c
index fded06f923f..cfb4c485206 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -4,7 +4,7 @@
  *  (C) Copyright 1994 Linus Torvalds
  *  (C) Copyright 2002 Christoph Hellwig
  *
- *  Address space accounting code       <alan@redhat.com>
+ *  Address space accounting code       <alan@lxorguk.ukuu.org.uk>
  *  (C) Copyright 2002 Red Hat Inc, All Rights Reserved
  */
 
diff --git a/mm/mremap.c b/mm/mremap.c
index 58a2908f42f..646de959aa5 100644
--- a/mm/mremap.c
+++ b/mm/mremap.c
@@ -3,7 +3,7 @@
  *
  *      (C) Copyright 1996 Linus Torvalds
  *
- *      Address space accounting code   <alan@redhat.com>
+ *      Address space accounting code   <alan@lxorguk.ukuu.org.uk>
  *      (C) Copyright 2002 Red Hat Inc, All Rights Reserved
  */
 
diff --git a/mm/msync.c b/mm/msync.c
index 144a7570535..07dae08cf31 100644
--- a/mm/msync.c
+++ b/mm/msync.c
@@ -82,7 +82,7 @@ asmlinkage long sys_msync(unsigned long start, size_t len, int flags)
                                 (vma->vm_flags & VM_SHARED)) {
                         get_file(file);
                         up_read(&mm->mmap_sem);
-                        error = do_fsync(file, 0);
+                        error = vfs_fsync(file, file->f_path.dentry, 0);
                         fput(file);
                         if (error || start >= end)
                                 goto out;
diff --git a/mm/nommu.c b/mm/nommu.c
index 7695dc85078..1c28ea3a4e9 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -86,7 +86,7 @@ do_expand:
         i_size_write(inode, offset);
 
 out_truncate:
-        if (inode->i_op && inode->i_op->truncate)
+        if (inode->i_op->truncate)
                 inode->i_op->truncate(inode);
         return 0;
 out_sig:
diff --git a/mm/pdflush.c b/mm/pdflush.c
index a0a14c4d507..15de509b68f 100644
--- a/mm/pdflush.c
+++ b/mm/pdflush.c
@@ -172,7 +172,16 @@ static int __pdflush(struct pdflush_work *my_work)
 static int pdflush(void *dummy)
 {
         struct pdflush_work my_work;
-        cpumask_t cpus_allowed;
+        cpumask_var_t cpus_allowed;
+
+        /*
+         * Since the caller doesn't even check kthread_run() worked, let's not
+         * freak out too much if this fails.
+         */
+        if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
+                printk(KERN_WARNING "pdflush failed to allocate cpumask\n");
+                return 0;
+        }
 
         /*
          * pdflush can spend a lot of time doing encryption via dm-crypt.  We
@@ -187,8 +196,9 @@ static int pdflush(void *dummy)
          * This is needed as pdflush's are dynamically created and destroyed.
          * The boottime pdflush's are easily placed w/o these 2 lines.
          */
-        cpuset_cpus_allowed(current, &cpus_allowed);
-        set_cpus_allowed_ptr(current, &cpus_allowed);
+        cpuset_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, cpus_allowed);
+        free_cpumask_var(cpus_allowed);
 
         return __pdflush(&my_work);
 }
diff --git a/mm/slab.c b/mm/slab.c
index c65c52dc78d..dae716b3291 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -2166,7 +2166,7 @@ kmem_cache_create (const char *name, size_t size, size_t align,
 
         /*
          * We use cache_chain_mutex to ensure a consistent view of
-         * cpu_online_map as well.  Please see cpuup_callback
+         * cpu_online_mask as well.  Please see cpuup_callback
          */
         get_online_cpus();
         mutex_lock(&cache_chain_mutex);
diff --git a/mm/slub.c b/mm/slub.c
index 4fac7bbb029..509e96f411f 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2001,7 +2001,7 @@ static DEFINE_PER_CPU(struct kmem_cache_cpu,
                                 kmem_cache_cpu)[NR_KMEM_CACHE_CPU];
 
 static DEFINE_PER_CPU(struct kmem_cache_cpu *, kmem_cache_cpu_free);
-static cpumask_t kmem_cach_cpu_free_init_once = CPU_MASK_NONE;
+static DECLARE_BITMAP(kmem_cach_cpu_free_init_once, CONFIG_NR_CPUS);
 
 static struct kmem_cache_cpu *alloc_kmem_cache_cpu(struct kmem_cache *s,
                                                         int cpu, gfp_t flags)
@@ -2076,13 +2076,13 @@ static void init_alloc_cpu_cpu(int cpu)
 {
         int i;
 
-        if (cpu_isset(cpu, kmem_cach_cpu_free_init_once))
+        if (cpumask_test_cpu(cpu, to_cpumask(kmem_cach_cpu_free_init_once)))
                 return;
 
         for (i = NR_KMEM_CACHE_CPU - 1; i >= 0; i--)
                 free_kmem_cache_cpu(&per_cpu(kmem_cache_cpu, cpu)[i], cpu);
 
-        cpu_set(cpu, kmem_cach_cpu_free_init_once);
+        cpumask_set_cpu(cpu, to_cpumask(kmem_cach_cpu_free_init_once));
 }
 
 static void __init init_alloc_cpu(void)
@@ -3518,7 +3518,7 @@ struct location {
         long max_time;
         long min_pid;
         long max_pid;
-        cpumask_t cpus;
+        DECLARE_BITMAP(cpus, NR_CPUS);
         nodemask_t nodes;
 };
 
@@ -3593,7 +3593,8 @@ static int add_location(struct loc_track *t, struct kmem_cache *s,
                                 if (track->pid > l->max_pid)
                                         l->max_pid = track->pid;
 
-                                cpu_set(track->cpu, l->cpus);
+                                cpumask_set_cpu(track->cpu,
+                                                to_cpumask(l->cpus));
                         }
                         node_set(page_to_nid(virt_to_page(track)), l->nodes);
                         return 1;
@@ -3623,8 +3624,8 @@ static int add_location(struct loc_track *t, struct kmem_cache *s,
         l->max_time = age;
         l->min_pid = track->pid;
         l->max_pid = track->pid;
-        cpus_clear(l->cpus);
-        cpu_set(track->cpu, l->cpus);
+        cpumask_clear(to_cpumask(l->cpus));
+        cpumask_set_cpu(track->cpu, to_cpumask(l->cpus));
         nodes_clear(l->nodes);
         node_set(page_to_nid(virt_to_page(track)), l->nodes);
         return 1;
@@ -3705,11 +3706,12 @@ static int list_locations(struct kmem_cache *s, char *buf,
                         len += sprintf(buf + len, " pid=%ld",
                                 l->min_pid);
 
-                if (num_online_cpus() > 1 && !cpus_empty(l->cpus) &&
+                if (num_online_cpus() > 1 &&
+                                !cpumask_empty(to_cpumask(l->cpus)) &&
                                 len < PAGE_SIZE - 60) {
                         len += sprintf(buf + len, " cpus=");
                         len += cpulist_scnprintf(buf + len, PAGE_SIZE - len - 50,
-                                        l->cpus);
+                                                 to_cpumask(l->cpus));
                 }
 
                 if (num_online_nodes() > 1 && !nodes_empty(l->nodes) &&
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 1ddb77ba399..7465f22fec0 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -151,11 +151,12 @@ static int vmap_pud_range(pgd_t *pgd, unsigned long addr,
  *
  * Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]
  */
-static int vmap_page_range(unsigned long addr, unsigned long end,
+static int vmap_page_range(unsigned long start, unsigned long end,
                                 pgprot_t prot, struct page **pages)
 {
         pgd_t *pgd;
         unsigned long next;
+        unsigned long addr = start;
         int err = 0;
         int nr = 0;
 
@@ -167,7 +168,7 @@ static int vmap_page_range(unsigned long addr, unsigned long end,
                 if (err)
                         break;
         } while (pgd++, addr = next, addr != end);
-        flush_cache_vmap(addr, end);
+        flush_cache_vmap(start, end);
 
         if (unlikely(err))
                 return err;
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 62e7f62fb55..d196f46c880 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1902,7 +1902,7 @@ static int kswapd(void *p)
         };
         node_to_cpumask_ptr(cpumask, pgdat->node_id);
 
-        if (!cpus_empty(*cpumask))
+        if (!cpumask_empty(cpumask))
                 set_cpus_allowed_ptr(tsk, cpumask);
         current->reclaim_state = &reclaim_state;
 
@@ -2141,7 +2141,7 @@ static int __devinit cpu_callback(struct notifier_block *nfb,
                         pg_data_t *pgdat = NODE_DATA(nid);
                         node_to_cpumask_ptr(mask, pgdat->node_id);
 
-                        if (any_online_cpu(*mask) < nr_cpu_ids)
+                        if (cpumask_any_and(cpu_online_mask, mask) < nr_cpu_ids)
                                 /* One of our CPUs online: restore mask */
                                 set_cpus_allowed_ptr(pgdat->kswapd, mask);
                 }
diff --git a/mm/vmstat.c b/mm/vmstat.c
index c3ccfda23ad..91149746bb8 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -20,7 +20,7 @@
 DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};
 EXPORT_PER_CPU_SYMBOL(vm_event_states);
 
-static void sum_vm_events(unsigned long *ret, cpumask_t *cpumask)
+static void sum_vm_events(unsigned long *ret, const struct cpumask *cpumask)
 {
         int cpu;
         int i;
@@ -43,7 +43,7 @@ static void sum_vm_events(unsigned long *ret, cpumask_t *cpumask)
 void all_vm_events(unsigned long *ret)
 {
         get_online_cpus();
-        sum_vm_events(ret, &cpu_online_map);
+        sum_vm_events(ret, cpu_online_mask);
         put_online_cpus();
 }
 EXPORT_SYMBOL_GPL(all_vm_events);