6 files changed, 46 insertions, 50 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index 45a2d18df849..20e5642e9f9f 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -151,6 +151,7 @@ void remove_from_page_cache(struct page *page)
         spin_unlock_irq(&mapping->tree_lock);
         mem_cgroup_uncharge_cache_page(page);
 }
+EXPORT_SYMBOL(remove_from_page_cache);
 
 static int sync_page(void *word)
 {
diff --git a/mm/mmap.c b/mm/mmap.c
index 456ec6f27889..e38e910cb756 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -1734,8 +1734,10 @@ int expand_upwards(struct vm_area_struct *vma, unsigned long address)
                 grow = (address - vma->vm_end) >> PAGE_SHIFT;
 
                 error = acct_stack_growth(vma, size, grow);
-                if (!error)
+                if (!error) {
                         vma->vm_end = address;
+                        perf_event_mmap(vma);
+                }
         }
         anon_vma_unlock(vma);
         return error;
@@ -1781,6 +1783,7 @@ static int expand_downwards(struct vm_area_struct *vma,
                 if (!error) {
                         vma->vm_start = address;
                         vma->vm_pgoff -= grow;
+                        perf_event_mmap(vma);
                 }
         }
         anon_vma_unlock(vma);
@@ -2208,6 +2211,7 @@ unsigned long do_brk(unsigned long addr, unsigned long len)
         vma->vm_page_prot = vm_get_page_prot(flags);
         vma_link(mm, vma, prev, rb_link, rb_parent);
 out:
+        perf_event_mmap(vma);
         mm->total_vm += len >> PAGE_SHIFT;
         if (flags & VM_LOCKED) {
                 if (!mlock_vma_pages_range(vma, addr, addr + len))
diff --git a/mm/shmem.c b/mm/shmem.c
index 855eaf5b8d5b..7e5030ae18ff 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -727,10 +727,11 @@ done2:
         if (inode->i_mapping->nrpages && (info->flags & SHMEM_PAGEIN)) {
                 /*
                  * Call truncate_inode_pages again: racing shmem_unuse_inode
-                 * may have swizzled a page in from swap since vmtruncate or
-                 * generic_delete_inode did it, before we lowered next_index.
-                 * Also, though shmem_getpage checks i_size before adding to
-                 * cache, no recheck after: so fix the narrow window there too.
+                 * may have swizzled a page in from swap since
+                 * truncate_pagecache or generic_delete_inode did it, before we
+                 * lowered next_index.  Also, though shmem_getpage checks
+                 * i_size before adding to cache, no recheck after: so fix the
+                 * narrow window there too.
                  *
                  * Recalling truncate_inode_pages_range and unmap_mapping_range
                  * every time for punch_hole (which never got a chance to clear
@@ -760,19 +761,16 @@ done2:
         }
 }
 
-static void shmem_truncate(struct inode *inode)
-{
-        shmem_truncate_range(inode, inode->i_size, (loff_t)-1);
-}
-
 static int shmem_notify_change(struct dentry *dentry, struct iattr *attr)
 {
         struct inode *inode = dentry->d_inode;
-        struct page *page = NULL;
         int error;
 
         if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
-                if (attr->ia_size < inode->i_size) {
+                loff_t newsize = attr->ia_size;
+                struct page *page = NULL;
+
+                if (newsize < inode->i_size) {
                         /*
                          * If truncating down to a partial page, then
                          * if that page is already allocated, hold it
@@ -780,9 +778,9 @@ static int shmem_notify_change(struct dentry *dentry, struct iattr *attr)
                          * truncate_partial_page cannnot miss it were
                          * it assigned to swap.
                          */
-                        if (attr->ia_size & (PAGE_CACHE_SIZE-1)) {
+                        if (newsize & (PAGE_CACHE_SIZE-1)) {
                                 (void) shmem_getpage(inode,
-                                        attr->ia_size>>PAGE_CACHE_SHIFT,
+                                        newsize >> PAGE_CACHE_SHIFT,
                                                 &page, SGP_READ, NULL);
                                 if (page)
                                         unlock_page(page);
@@ -794,24 +792,29 @@ static int shmem_notify_change(struct dentry *dentry, struct iattr *attr)
                          * if it's being fully truncated to zero-length: the
                          * nrpages check is efficient enough in that case.
                          */
-                        if (attr->ia_size) {
+                        if (newsize) {
                                 struct shmem_inode_info *info = SHMEM_I(inode);
                                 spin_lock(&info->lock);
                                 info->flags &= ~SHMEM_PAGEIN;
                                 spin_unlock(&info->lock);
                         }
                 }
+
+                error = simple_setsize(inode, newsize);
+                if (page)
+                        page_cache_release(page);
+                if (error)
+                        return error;
+                shmem_truncate_range(inode, newsize, (loff_t)-1);
         }
 
         error = inode_change_ok(inode, attr);
         if (!error)
-                error = inode_setattr(inode, attr);
+                generic_setattr(inode, attr);
 #ifdef CONFIG_TMPFS_POSIX_ACL
         if (!error && (attr->ia_valid & ATTR_MODE))
                 error = generic_acl_chmod(inode);
 #endif
-        if (page)
-                page_cache_release(page);
         return error;
 }
 
@@ -819,11 +822,11 @@ static void shmem_delete_inode(struct inode *inode)
 {
         struct shmem_inode_info *info = SHMEM_I(inode);
 
-        if (inode->i_op->truncate == shmem_truncate) {
+        if (inode->i_mapping->a_ops == &shmem_aops) {
                 truncate_inode_pages(inode->i_mapping, 0);
                 shmem_unacct_size(info->flags, inode->i_size);
                 inode->i_size = 0;
-                shmem_truncate(inode);
+                shmem_truncate_range(inode, 0, (loff_t)-1);
                 if (!list_empty(&info->swaplist)) {
                         mutex_lock(&shmem_swaplist_mutex);
                         list_del_init(&info->swaplist);
@@ -2022,7 +2025,6 @@ static const struct inode_operations shmem_symlink_inline_operations = {
 };
 
 static const struct inode_operations shmem_symlink_inode_operations = {
-        .truncate       = shmem_truncate,
         .readlink       = generic_readlink,
         .follow_link    = shmem_follow_link,
         .put_link       = shmem_put_link,
@@ -2433,14 +2435,13 @@ static const struct file_operations shmem_file_operations = {
         .write          = do_sync_write,
         .aio_read       = shmem_file_aio_read,
         .aio_write      = generic_file_aio_write,
-        .fsync          = simple_sync_file,
+        .fsync          = noop_fsync,
         .splice_read    = generic_file_splice_read,
         .splice_write   = generic_file_splice_write,
 #endif
 };
 
 static const struct inode_operations shmem_inode_operations = {
-        .truncate       = shmem_truncate,
         .setattr        = shmem_notify_change,
         .truncate_range = shmem_truncate_range,
 #ifdef CONFIG_TMPFS_POSIX_ACL
diff --git a/mm/slub.c b/mm/slub.c
index a61f1aad1070..7bb7940f4eee 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2136,7 +2136,7 @@ static void free_kmem_cache_nodes(struct kmem_cache *s)
 
         for_each_node_state(node, N_NORMAL_MEMORY) {
                 struct kmem_cache_node *n = s->node[node];
-                if (n && n != &s->local_node)
+                if (n)
                         kmem_cache_free(kmalloc_caches, n);
                 s->node[node] = NULL;
         }
@@ -2145,33 +2145,22 @@ static void free_kmem_cache_nodes(struct kmem_cache *s)
 static int init_kmem_cache_nodes(struct kmem_cache *s, gfp_t gfpflags)
 {
         int node;
-        int local_node;
-
-        if (slab_state >= UP && (s < kmalloc_caches ||
-                        s >= kmalloc_caches + KMALLOC_CACHES))
-                local_node = page_to_nid(virt_to_page(s));
-        else
-                local_node = 0;
 
         for_each_node_state(node, N_NORMAL_MEMORY) {
                 struct kmem_cache_node *n;
 
-                if (local_node == node)
-                        n = &s->local_node;
-                else {
-                        if (slab_state == DOWN) {
-                                early_kmem_cache_node_alloc(gfpflags, node);
-                                continue;
-                        }
-                        n = kmem_cache_alloc_node(kmalloc_caches,
-                                                        gfpflags, node);
-
-                        if (!n) {
-                                free_kmem_cache_nodes(s);
-                                return 0;
-                        }
+                if (slab_state == DOWN) {
+                        early_kmem_cache_node_alloc(gfpflags, node);
+                        continue;
+                }
+                n = kmem_cache_alloc_node(kmalloc_caches,
+                                                gfpflags, node);
 
+                if (!n) {
+                        free_kmem_cache_nodes(s);
+                        return 0;
                 }
+
                 s->node[node] = n;
                 init_kmem_cache_node(n, s);
         }
diff --git a/mm/swap.c b/mm/swap.c
index 7cd60bf0a972..3ce7bc373a52 100644
--- a/mm/swap.c
+++ b/mm/swap.c
@@ -224,6 +224,7 @@ void __lru_cache_add(struct page *page, enum lru_list lru)
                 ____pagevec_lru_add(pvec, lru);
         put_cpu_var(lru_add_pvecs);
 }
+EXPORT_SYMBOL(__lru_cache_add);
 
 /**
  * lru_cache_add_lru - add a page to a page list
diff --git a/mm/truncate.c b/mm/truncate.c
index f42675a3615d..937571b8b233 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -548,18 +548,18 @@ EXPORT_SYMBOL(truncate_pagecache);
  * NOTE! We have to be ready to update the memory sharing
  * between the file and the memory map for a potential last
  * incomplete page.  Ugly, but necessary.
+ *
+ * This function is deprecated and simple_setsize or truncate_pagecache
+ * should be used instead.
  */
 int vmtruncate(struct inode *inode, loff_t offset)
 {
-        loff_t oldsize;
         int error;
 
-        error = inode_newsize_ok(inode, offset);
+        error = simple_setsize(inode, offset);
         if (error)
                 return error;
-        oldsize = inode->i_size;
-        i_size_write(inode, offset);
-        truncate_pagecache(inode, oldsize, offset);
+
         if (inode->i_op->truncate)
                 inode->i_op->truncate(inode);