1 files changed, 61 insertions, 38 deletions

diff --git a/mm/shmem.c b/mm/shmem.c
index e2a6ae1a44e9..952d361774bb 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -922,20 +922,26 @@ found:
         error = 1;
         if (!inode)
                 goto out;
-        /* Precharge page while we can wait, compensate afterwards */
+        /* Precharge page using GFP_KERNEL while we can wait */
         error = mem_cgroup_cache_charge(page, current->mm, GFP_KERNEL);
         if (error)
                 goto out;
         error = radix_tree_preload(GFP_KERNEL);
-        if (error)
-                goto uncharge;
+        if (error) {
+                mem_cgroup_uncharge_cache_page(page);
+                goto out;
+        }
         error = 1;
 
         spin_lock(&info->lock);
         ptr = shmem_swp_entry(info, idx, NULL);
-        if (ptr && ptr->val == entry.val)
-                error = add_to_page_cache(page, inode->i_mapping,
+        if (ptr && ptr->val == entry.val) {
+                error = add_to_page_cache_locked(page, inode->i_mapping,
                                                 idx, GFP_NOWAIT);
+                /* does mem_cgroup_uncharge_cache_page on error */
+        } else  /* we must compensate for our precharge above */
+                mem_cgroup_uncharge_cache_page(page);
+
         if (error == -EEXIST) {
                 struct page *filepage = find_get_page(inode->i_mapping, idx);
                 error = 1;
@@ -961,8 +967,6 @@ found:
                 shmem_swp_unmap(ptr);
         spin_unlock(&info->lock);
         radix_tree_preload_end();
-uncharge:
-        mem_cgroup_uncharge_page(page);
 out:
         unlock_page(page);
         page_cache_release(page);
@@ -1297,8 +1301,8 @@ repeat:
                         SetPageUptodate(filepage);
                         set_page_dirty(filepage);
                         swap_free(swap);
-                } else if (!(error = add_to_page_cache(
-                                swappage, mapping, idx, GFP_NOWAIT))) {
+                } else if (!(error = add_to_page_cache_locked(swappage, mapping,
+                                        idx, GFP_NOWAIT))) {
                         info->flags |= SHMEM_PAGEIN;
                         shmem_swp_set(info, entry, 0);
                         shmem_swp_unmap(entry);
@@ -1311,17 +1315,14 @@ repeat:
                         shmem_swp_unmap(entry);
                         spin_unlock(&info->lock);
                         unlock_page(swappage);
+                        page_cache_release(swappage);
                         if (error == -ENOMEM) {
                                 /* allow reclaim from this memory cgroup */
-                                error = mem_cgroup_cache_charge(swappage,
-                                        current->mm, gfp & ~__GFP_HIGHMEM);
-                                if (error) {
-                                        page_cache_release(swappage);
+                                error = mem_cgroup_shrink_usage(current->mm,
+                                                                gfp);
+                                if (error)
                                         goto failed;
-                                }
-                                mem_cgroup_uncharge_page(swappage);
                         }
-                        page_cache_release(swappage);
                         goto repeat;
                 }
         } else if (sgp == SGP_READ && !filepage) {
@@ -1358,6 +1359,8 @@ repeat:
                 }
 
                 if (!filepage) {
+                        int ret;
+
                         spin_unlock(&info->lock);
                         filepage = shmem_alloc_page(gfp, info, idx);
                         if (!filepage) {
@@ -1386,10 +1389,18 @@ repeat:
                                 swap = *entry;
                                 shmem_swp_unmap(entry);
                         }
-                        if (error || swap.val || 0 != add_to_page_cache_lru(
-                                        filepage, mapping, idx, GFP_NOWAIT)) {
+                        ret = error || swap.val;
+                        if (ret)
+                                mem_cgroup_uncharge_cache_page(filepage);
+                        else
+                                ret = add_to_page_cache_lru(filepage, mapping,
+                                                idx, GFP_NOWAIT);
+                        /*
+                         * At add_to_page_cache_lru() failure, uncharge will
+                         * be done automatically.
+                         */
+                        if (ret) {
                                 spin_unlock(&info->lock);
-                                mem_cgroup_uncharge_page(filepage);
                                 page_cache_release(filepage);
                                 shmem_unacct_blocks(info->flags, 1);
                                 shmem_free_blocks(inode, 1);
@@ -1398,7 +1409,6 @@ repeat:
                                         goto failed;
                                 goto repeat;
                         }
-                        mem_cgroup_uncharge_page(filepage);
                         info->flags |= SHMEM_PAGEIN;
                 }
 
@@ -1690,26 +1700,38 @@ static void do_shmem_file_read(struct file *filp, loff_t *ppos, read_descriptor_
         file_accessed(filp);
 }
 
-static ssize_t shmem_file_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
+static ssize_t shmem_file_aio_read(struct kiocb *iocb,
+                const struct iovec *iov, unsigned long nr_segs, loff_t pos)
 {
-        read_descriptor_t desc;
+        struct file *filp = iocb->ki_filp;
+        ssize_t retval;
+        unsigned long seg;
+        size_t count;
+        loff_t *ppos = &iocb->ki_pos;
 
-        if ((ssize_t) count < 0)
-                return -EINVAL;
-        if (!access_ok(VERIFY_WRITE, buf, count))
-                return -EFAULT;
-        if (!count)
-                return 0;
+        retval = generic_segment_checks(iov, &nr_segs, &count, VERIFY_WRITE);
+        if (retval)
+                return retval;
 
-        desc.written = 0;
-        desc.count = count;
-        desc.arg.buf = buf;
-        desc.error = 0;
+        for (seg = 0; seg < nr_segs; seg++) {
+                read_descriptor_t desc;
 
-        do_shmem_file_read(filp, ppos, &desc, file_read_actor);
-        if (desc.written)
-                return desc.written;
-        return desc.error;
+                desc.written = 0;
+                desc.arg.buf = iov[seg].iov_base;
+                desc.count = iov[seg].iov_len;
+                if (desc.count == 0)
+                        continue;
+                desc.error = 0;
+                do_shmem_file_read(filp, ppos, &desc, file_read_actor);
+                retval += desc.written;
+                if (desc.error) {
+                        retval = retval ?: desc.error;
+                        break;
+                }
+                if (desc.count > 0)
+                        break;
+        }
+        return retval;
 }
 
 static int shmem_statfs(struct dentry *dentry, struct kstatfs *buf)
@@ -2330,7 +2352,7 @@ static void shmem_destroy_inode(struct inode *inode)
         kmem_cache_free(shmem_inode_cachep, SHMEM_I(inode));
 }
 
-static void init_once(struct kmem_cache *cachep, void *foo)
+static void init_once(void *foo)
 {
         struct shmem_inode_info *p = (struct shmem_inode_info *) foo;
 
@@ -2369,8 +2391,9 @@ static const struct file_operations shmem_file_operations = {
         .mmap           = shmem_mmap,
 #ifdef CONFIG_TMPFS
         .llseek         = generic_file_llseek,
-        .read           = shmem_file_read,
+        .read           = do_sync_read,
         .write          = do_sync_write,
+        .aio_read       = shmem_file_aio_read,
         .aio_write      = generic_file_aio_write,
         .fsync          = simple_sync_file,
         .splice_read    = generic_file_splice_read,