[XFS] Fix superblock validation regression for the zero imaxpct case.

[firefly-linux-kernel-4.4.55.git] / fs / splice.c

diff --git a/fs/splice.c b/fs/splice.c
index 34591924c783538552641324ba69a87a714c938b..bfa42a277bb874ac94a34db4d3c7f593afc5410c 100644 (file)
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -52,22 +52,22 @@ static int page_cache_pipe_buf_steal(struct pipe_inode_info *info,
        WARN_ON(!PageLocked(page));
        WARN_ON(!PageUptodate(page));
 
+       /*
+        * At least for ext2 with nobh option, we need to wait on writeback
+        * completing on this page, since we'll remove it from the pagecache.
+        * Otherwise truncate wont wait on the page, allowing the disk
+        * blocks to be reused by someone else before we actually wrote our
+        * data to them. fs corruption ensues.
+        */
+       wait_on_page_writeback(page);
+
        if (PagePrivate(page))
                try_to_release_page(page, mapping_gfp_mask(mapping));
 
        if (!remove_mapping(mapping, page))
                return 1;
 
-       if (PageLRU(page)) {
-               struct zone *zone = page_zone(page);
-
-               spin_lock_irq(&zone->lru_lock);
-               BUG_ON(!PageLRU(page));
-               __ClearPageLRU(page);
-               del_page_from_lru(zone, page);
-               spin_unlock_irq(&zone->lru_lock);
-       }
-
+       buf->flags |= PIPE_BUF_FLAG_STOLEN | PIPE_BUF_FLAG_LRU;
        return 0;
 }
 
@@ -76,6 +76,7 @@ static void page_cache_pipe_buf_release(struct pipe_inode_info *info,
 {
        page_cache_release(buf->page);
        buf->page = NULL;
+       buf->flags &= ~(PIPE_BUF_FLAG_STOLEN | PIPE_BUF_FLAG_LRU);
 }
 
 static void *page_cache_pipe_buf_map(struct file *file,
@@ -342,6 +343,8 @@ ssize_t generic_file_splice_read(struct file *in, struct inode *pipe,
        return ret;
 }
 
+EXPORT_SYMBOL(generic_file_splice_read);
+
 /*
  * Send 'sd->len' bytes to socket from 'sd->file' at position 'sd->pos'
  * using sendpage().
@@ -354,6 +357,7 @@ static int pipe_to_sendpage(struct pipe_inode_info *info,
        unsigned int offset;
        ssize_t ret;
        void *ptr;
+       int more;
 
        /*
         * sub-optimal, but we are limited by the pipe ->map. we don't
@@ -366,9 +370,9 @@ static int pipe_to_sendpage(struct pipe_inode_info *info,
                return PTR_ERR(ptr);
 
        offset = pos & ~PAGE_CACHE_MASK;
+       more = (sd->flags & SPLICE_F_MORE) || sd->len < sd->total_len;
 
-       ret = file->f_op->sendpage(file, buf->page, offset, sd->len, &pos,
-                                       sd->len < sd->total_len);
+       ret = file->f_op->sendpage(file, buf->page, offset, sd->len, &pos,more);
 
        buf->ops->unmap(info, buf);
        if (ret == sd->len)
@@ -402,11 +406,12 @@ static int pipe_to_file(struct pipe_inode_info *info, struct pipe_buffer *buf,
 {
        struct file *file = sd->file;
        struct address_space *mapping = file->f_mapping;
+       gfp_t gfp_mask = mapping_gfp_mask(mapping);
        unsigned int offset;
        struct page *page;
        pgoff_t index;
        char *src;
-       int ret, stolen;
+       int ret;
 
        /*
         * after this, page will be locked and unmapped
@@ -417,7 +422,6 @@ static int pipe_to_file(struct pipe_inode_info *info, struct pipe_buffer *buf,
 
        index = sd->pos >> PAGE_CACHE_SHIFT;
        offset = sd->pos & ~PAGE_CACHE_MASK;
-       stolen = 0;
 
        /*
         * reuse buf page, if SPLICE_F_MOVE is set
@@ -431,15 +435,15 @@ static int pipe_to_file(struct pipe_inode_info *info, struct pipe_buffer *buf,
                        goto find_page;
 
                page = buf->page;
-               stolen = 1;
-               if (add_to_page_cache_lru(page, mapping, index,
-                                               mapping_gfp_mask(mapping)))
+               if (add_to_page_cache(page, mapping, index, gfp_mask))
                        goto find_page;
+
+               if (!(buf->flags & PIPE_BUF_FLAG_LRU))
+                       lru_cache_add(page);
        } else {
 find_page:
                ret = -ENOMEM;
-               page = find_or_create_page(mapping, index,
-                                               mapping_gfp_mask(mapping));
+               page = find_or_create_page(mapping, index, gfp_mask);
                if (!page)
                        goto out;
 
@@ -482,7 +486,7 @@ find_page:
        } else if (ret)
                goto out;
 
-       if (!stolen) {
+       if (!(buf->flags & PIPE_BUF_FLAG_STOLEN)) {
                char *dst = kmap_atomic(page, KM_USER0);
 
                memcpy(dst + offset, src + buf->offset, sd->len);
@@ -499,7 +503,7 @@ find_page:
 
        balance_dirty_pages_ratelimited(mapping);
 out:
-       if (!stolen) {
+       if (!(buf->flags & PIPE_BUF_FLAG_STOLEN)) {
                page_cache_release(page);
                unlock_page(page);
        }
@@ -653,6 +657,8 @@ ssize_t generic_file_splice_write(struct inode *inode, struct file *out,
        return ret;
 }
 
+EXPORT_SYMBOL(generic_file_splice_write);
+
 /**
  * generic_splice_sendpage - splice data from a pipe to a socket
  * @inode:     pipe inode
@@ -670,8 +676,7 @@ ssize_t generic_splice_sendpage(struct inode *inode, struct file *out,
        return move_from_pipe(inode, out, len, flags, pipe_to_sendpage);
 }
 
-EXPORT_SYMBOL(generic_file_splice_write);
-EXPORT_SYMBOL(generic_file_splice_read);
+EXPORT_SYMBOL(generic_splice_sendpage);
 
 /*
  * Attempt to initiate a splice from pipe to file.