22 files changed, 103 insertions, 116 deletions

diff --git a/fs/buffer.c b/fs/buffer.c
index 456c9ab7705b..1de921484eac 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1798,7 +1798,7 @@ void page_zero_new_buffers(struct page *page, unsigned from, unsigned to)
                                         start = max(from, block_start);
                                         size = min(to, block_end) - start;
 
-                                        zero_user_page(page, start, size, KM_USER0);
+                                        zero_user(page, start, size);
                                         set_buffer_uptodate(bh);
                                 }
 
@@ -1861,19 +1861,10 @@ static int __block_prepare_write(struct inode *inode, struct page *page,
                                         mark_buffer_dirty(bh);
                                         continue;
                                 }
-                                if (block_end > to || block_start < from) {
-                                        void *kaddr;
-
-                                        kaddr = kmap_atomic(page, KM_USER0);
-                                        if (block_end > to)
-                                                memset(kaddr+to, 0,
-                                                        block_end-to);
-                                        if (block_start < from)
-                                                memset(kaddr+block_start,
-                                                        0, from-block_start);
-                                        flush_dcache_page(page);
-                                        kunmap_atomic(kaddr, KM_USER0);
-                                }
+                                if (block_end > to || block_start < from)
+                                        zero_user_segments(page,
+                                                to, block_end,
+                                                block_start, from);
                                 continue;
                         }
                 }
@@ -2104,8 +2095,7 @@ int block_read_full_page(struct page *page, get_block_t *get_block)
                                         SetPageError(page);
                         }
                         if (!buffer_mapped(bh)) {
-                                zero_user_page(page, i * blocksize, blocksize,
-                                                KM_USER0);
+                                zero_user(page, i * blocksize, blocksize);
                                 if (!err)
                                         set_buffer_uptodate(bh);
                                 continue;
@@ -2218,7 +2208,7 @@ int cont_expand_zero(struct file *file, struct address_space *mapping,
                                                 &page, &fsdata);
                 if (err)
                         goto out;
-                zero_user_page(page, zerofrom, len, KM_USER0);
+                zero_user(page, zerofrom, len);
                 err = pagecache_write_end(file, mapping, curpos, len, len,
                                                 page, fsdata);
                 if (err < 0)
@@ -2245,7 +2235,7 @@ int cont_expand_zero(struct file *file, struct address_space *mapping,
                                                 &page, &fsdata);
                 if (err)
                         goto out;
-                zero_user_page(page, zerofrom, len, KM_USER0);
+                zero_user(page, zerofrom, len);
                 err = pagecache_write_end(file, mapping, curpos, len, len,
                                                 page, fsdata);
                 if (err < 0)
@@ -2422,7 +2412,6 @@ int nobh_write_begin(struct file *file, struct address_space *mapping,
         unsigned block_in_page;
         unsigned block_start, block_end;
         sector_t block_in_file;
-        char *kaddr;
         int nr_reads = 0;
         int ret = 0;
         int is_mapped_to_disk = 1;
@@ -2493,13 +2482,8 @@ int nobh_write_begin(struct file *file, struct address_space *mapping,
                         continue;
                 }
                 if (buffer_new(bh) || !buffer_mapped(bh)) {
-                        kaddr = kmap_atomic(page, KM_USER0);
-                        if (block_start < from)
-                                memset(kaddr+block_start, 0, from-block_start);
-                        if (block_end > to)
-                                memset(kaddr + to, 0, block_end - to);
-                        flush_dcache_page(page);
-                        kunmap_atomic(kaddr, KM_USER0);
+                        zero_user_segments(page, block_start, from,
+                                                        to, block_end);
                         continue;
                 }
                 if (buffer_uptodate(bh))
@@ -2636,7 +2620,7 @@ int nobh_writepage(struct page *page, get_block_t *get_block,
          * the  page size, the remaining memory is zeroed when mapped, and
          * writes to that region are not written out to the file."
          */
-        zero_user_page(page, offset, PAGE_CACHE_SIZE - offset, KM_USER0);
+        zero_user_segment(page, offset, PAGE_CACHE_SIZE);
 out:
         ret = mpage_writepage(page, get_block, wbc);
         if (ret == -EAGAIN)
@@ -2709,7 +2693,7 @@ has_buffers:
                 if (page_has_buffers(page))
                         goto has_buffers;
         }
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
         set_page_dirty(page);
         err = 0;
 
@@ -2785,7 +2769,7 @@ int block_truncate_page(struct address_space *mapping,
                         goto unlock;
         }
 
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
         mark_buffer_dirty(bh);
         err = 0;
 
@@ -2831,7 +2815,7 @@ int block_write_full_page(struct page *page, get_block_t *get_block,
          * the  page size, the remaining memory is zeroed when mapped, and
          * writes to that region are not written out to the file."
          */
-        zero_user_page(page, offset, PAGE_CACHE_SIZE - offset, KM_USER0);
+        zero_user_segment(page, offset, PAGE_CACHE_SIZE);
         return __block_write_full_page(inode, page, get_block, wbc);
 }
 
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index d9567ba2960b..47f2621001e4 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -1386,7 +1386,7 @@ static int cifs_truncate_page(struct address_space *mapping, loff_t from)
         if (!page)
                 return -ENOMEM;
 
-        zero_user_page(page, offset, PAGE_CACHE_SIZE - offset, KM_USER0);
+        zero_user_segment(page, offset, PAGE_CACHE_SIZE);
         unlock_page(page);
         page_cache_release(page);
         return rc;
diff --git a/fs/direct-io.c b/fs/direct-io.c
index acf0da1bd257..9e81addbd6ea 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -878,8 +878,8 @@ do_holes:
                                         page_cache_release(page);
                                         goto out;
                                 }
-                                zero_user_page(page, block_in_page << blkbits,
-                                                1 << blkbits, KM_USER0);
+                                zero_user(page, block_in_page << blkbits,
+                                                1 << blkbits);
                                 dio->block_in_file++;
                                 block_in_page++;
                                 goto next_block;
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 32c5711d79a3..0535412d8c64 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -257,8 +257,7 @@ static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
         end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
         if (to > end_byte_in_page)
                 end_byte_in_page = to;
-        zero_user_page(page, end_byte_in_page,
-                PAGE_CACHE_SIZE - end_byte_in_page, KM_USER0);
+        zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE);
 out:
         return 0;
 }
@@ -307,7 +306,7 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page,
          */
         if ((i_size_read(page->mapping->host) == prev_page_end_size) &&
             (from != 0)) {
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
         }
 out:
         return rc;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 9b162cd6c16c..077535439288 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1845,7 +1845,7 @@ static int ext3_block_truncate_page(handle_t *handle, struct page *page,
          */
         if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
              ext3_should_writeback_data(inode) && PageUptodate(page)) {
-                zero_user_page(page, offset, length, KM_USER0);
+                zero_user(page, offset, length);
                 set_page_dirty(page);
                 goto unlock;
         }
@@ -1898,7 +1898,7 @@ static int ext3_block_truncate_page(handle_t *handle, struct page *page,
                         goto unlock;
         }
 
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
         BUFFER_TRACE(bh, "zeroed end of block");
 
         err = 0;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index bb717cbb749c..05c4145dd27d 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1840,7 +1840,7 @@ int ext4_block_truncate_page(handle_t *handle, struct page *page,
          */
         if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
              ext4_should_writeback_data(inode) && PageUptodate(page)) {
-                zero_user_page(page, offset, length, KM_USER0);
+                zero_user(page, offset, length);
                 set_page_dirty(page);
                 goto unlock;
         }
@@ -1893,7 +1893,7 @@ int ext4_block_truncate_page(handle_t *handle, struct page *page,
                         goto unlock;
         }
 
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
 
         BUFFER_TRACE(bh, "zeroed end of block");
 
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index e4effc47abfc..e9456ebd3bb6 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -932,7 +932,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping)
         if (!gfs2_is_writeback(ip))
                 gfs2_trans_add_bh(ip->i_gl, bh, 0);
 
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
 
 unlock:
         unlock_page(page);
diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
index 38dbe99a30ed..ac772b6d9dbb 100644
--- a/fs/gfs2/ops_address.c
+++ b/fs/gfs2/ops_address.c
@@ -446,7 +446,7 @@ static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
          * so we need to supply one here. It doesn't happen often.
          */
         if (unlikely(page->index)) {
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
                 return 0;
         }
 
diff --git a/fs/libfs.c b/fs/libfs.c
index 6e68b700958d..5523bde96387 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -341,13 +341,10 @@ int simple_prepare_write(struct file *file, struct page *page,
                         unsigned from, unsigned to)
 {
         if (!PageUptodate(page)) {
-                if (to - from != PAGE_CACHE_SIZE) {
-                        void *kaddr = kmap_atomic(page, KM_USER0);
-                        memset(kaddr, 0, from);
-                        memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
-                        flush_dcache_page(page);
-                        kunmap_atomic(kaddr, KM_USER0);
-                }
+                if (to - from != PAGE_CACHE_SIZE)
+                        zero_user_segments(page,
+                                0, from,
+                                to, PAGE_CACHE_SIZE);
         }
         return 0;
 }
diff --git a/fs/mpage.c b/fs/mpage.c
index d54f8f897224..5df564366f36 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -276,9 +276,7 @@ do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
         }
 
         if (first_hole != blocks_per_page) {
-                zero_user_page(page, first_hole << blkbits,
-                                PAGE_CACHE_SIZE - (first_hole << blkbits),
-                                KM_USER0);
+                zero_user_segment(page, first_hole << blkbits, PAGE_CACHE_SIZE);
                 if (first_hole == 0) {
                         SetPageUptodate(page);
                         unlock_page(page);
@@ -571,8 +569,7 @@ page_is_mapped:
 
                 if (page->index > end_index || !offset)
                         goto confused;
-                zero_user_page(page, offset, PAGE_CACHE_SIZE - offset,
-                                KM_USER0);
+                zero_user_segment(page, offset, PAGE_CACHE_SIZE);
         }
 
         /*
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 8fd6dfbe1bc3..3d7d9631e125 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -79,7 +79,7 @@ void nfs_readdata_release(void *data)
 static
 int nfs_return_empty_page(struct page *page)
 {
-        zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+        zero_user(page, 0, PAGE_CACHE_SIZE);
         SetPageUptodate(page);
         unlock_page(page);
         return 0;
@@ -103,10 +103,10 @@ static void nfs_readpage_truncate_uninitialised_page(struct nfs_read_data *data)
         pglen = PAGE_CACHE_SIZE - base;
         for (;;) {
                 if (remainder <= pglen) {
-                        zero_user_page(*pages, base, remainder, KM_USER0);
+                        zero_user(*pages, base, remainder);
                         break;
                 }
-                zero_user_page(*pages, base, pglen, KM_USER0);
+                zero_user(*pages, base, pglen);
                 pages++;
                 remainder -= pglen;
                 pglen = PAGE_CACHE_SIZE;
@@ -130,7 +130,7 @@ static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
                 return PTR_ERR(new);
         }
         if (len < PAGE_CACHE_SIZE)
-                zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
+                zero_user_segment(page, len, PAGE_CACHE_SIZE);
 
         nfs_list_add_request(new, &one_request);
         if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
@@ -532,7 +532,7 @@ readpage_async_filler(void *data, struct page *page)
                 goto out_error;
 
         if (len < PAGE_CACHE_SIZE)
-                zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
+                zero_user_segment(page, len, PAGE_CACHE_SIZE);
         nfs_pageio_add_request(desc->pgio, new);
         return 0;
 out_error:
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 522efff3e2c5..b144b1957dd9 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -665,9 +665,7 @@ zero_page:
          * then we need to zero any uninitalised data. */
         if (req->wb_pgbase == 0 && req->wb_bytes != PAGE_CACHE_SIZE
                         && !PageUptodate(req->wb_page))
-                zero_user_page(req->wb_page, req->wb_bytes,
-                                PAGE_CACHE_SIZE - req->wb_bytes,
-                                KM_USER0);
+                zero_user_segment(req->wb_page, req->wb_bytes, PAGE_CACHE_SIZE);
         return req;
 }
 
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index ad87cb01299b..00e9ccde8e42 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -87,13 +87,17 @@ static void ntfs_end_buffer_async_read(struct buffer_head *bh, int uptodate)
                 /* Check for the current buffer head overflowing. */
                 if (unlikely(file_ofs + bh->b_size > init_size)) {
                         int ofs;
+                        void *kaddr;
 
                         ofs = 0;
                         if (file_ofs < init_size)
                                 ofs = init_size - file_ofs;
                         local_irq_save(flags);
-                        zero_user_page(page, bh_offset(bh) + ofs,
-                                         bh->b_size - ofs, KM_BIO_SRC_IRQ);
+                        kaddr = kmap_atomic(page, KM_BIO_SRC_IRQ);
+                        memset(kaddr + bh_offset(bh) + ofs, 0,
+                                        bh->b_size - ofs);
+                        flush_dcache_page(page);
+                        kunmap_atomic(kaddr, KM_BIO_SRC_IRQ);
                         local_irq_restore(flags);
                 }
         } else {
@@ -334,7 +338,7 @@ handle_hole:
                 bh->b_blocknr = -1UL;
                 clear_buffer_mapped(bh);
 handle_zblock:
-                zero_user_page(page, i * blocksize, blocksize, KM_USER0);
+                zero_user(page, i * blocksize, blocksize);
                 if (likely(!err))
                         set_buffer_uptodate(bh);
         } while (i++, iblock++, (bh = bh->b_this_page) != head);
@@ -410,7 +414,7 @@ retry_readpage:
         /* Is the page fully outside i_size? (truncate in progress) */
         if (unlikely(page->index >= (i_size + PAGE_CACHE_SIZE - 1) >>
                         PAGE_CACHE_SHIFT)) {
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
                 ntfs_debug("Read outside i_size - truncated?");
                 goto done;
         }
@@ -459,7 +463,7 @@ retry_readpage:
          * ok to ignore the compressed flag here.
          */
         if (unlikely(page->index > 0)) {
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
                 goto done;
         }
         if (!NInoAttr(ni))
@@ -788,8 +792,7 @@ lock_retry_remap:
                 if (err == -ENOENT || lcn == LCN_ENOENT) {
                         bh->b_blocknr = -1;
                         clear_buffer_dirty(bh);
-                        zero_user_page(page, bh_offset(bh), blocksize,
-                                        KM_USER0);
+                        zero_user(page, bh_offset(bh), blocksize);
                         set_buffer_uptodate(bh);
                         err = 0;
                         continue;
@@ -1414,8 +1417,7 @@ retry_writepage:
                 if (page->index >= (i_size >> PAGE_CACHE_SHIFT)) {
                         /* The page straddles i_size. */
                         unsigned int ofs = i_size & ~PAGE_CACHE_MASK;
-                        zero_user_page(page, ofs, PAGE_CACHE_SIZE - ofs,
-                                        KM_USER0);
+                        zero_user_segment(page, ofs, PAGE_CACHE_SIZE);
                 }
                 /* Handle mst protected attributes. */
                 if (NInoMstProtected(ni))
diff --git a/fs/ntfs/compress.c b/fs/ntfs/compress.c
index d1619d05eb23..33ff314cc507 100644
--- a/fs/ntfs/compress.c
+++ b/fs/ntfs/compress.c
@@ -565,7 +565,7 @@ int ntfs_read_compressed_block(struct page *page)
         if (xpage >= max_page) {
                 kfree(bhs);
                 kfree(pages);
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
                 ntfs_debug("Compressed read outside i_size - truncated?");
                 SetPageUptodate(page);
                 unlock_page(page);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 6cd08dfdc2ed..3c5550cd11d6 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -607,8 +607,8 @@ do_next_page:
                                         ntfs_submit_bh_for_read(bh);
                                         *wait_bh++ = bh;
                                 } else {
-                                        zero_user_page(page, bh_offset(bh),
-                                                        blocksize, KM_USER0);
+                                        zero_user(page, bh_offset(bh),
+                                                        blocksize);
                                         set_buffer_uptodate(bh);
                                 }
                         }
@@ -683,9 +683,8 @@ map_buffer_cached:
                                                 ntfs_submit_bh_for_read(bh);
                                                 *wait_bh++ = bh;
                                         } else {
-                                                zero_user_page(page,
-                                                        bh_offset(bh),
-                                                        blocksize, KM_USER0);
+                                                zero_user(page, bh_offset(bh),
+                                                                blocksize);
                                                 set_buffer_uptodate(bh);
                                         }
                                 }
@@ -703,8 +702,8 @@ map_buffer_cached:
                          */
                         if (bh_end <= pos || bh_pos >= end) {
                                 if (!buffer_uptodate(bh)) {
-                                        zero_user_page(page, bh_offset(bh),
-                                                        blocksize, KM_USER0);
+                                        zero_user(page, bh_offset(bh),
+                                                        blocksize);
                                         set_buffer_uptodate(bh);
                                 }
                                 mark_buffer_dirty(bh);
@@ -743,8 +742,7 @@ map_buffer_cached:
                                 if (!buffer_uptodate(bh))
                                         set_buffer_uptodate(bh);
                         } else if (!buffer_uptodate(bh)) {
-                                zero_user_page(page, bh_offset(bh), blocksize,
-                                                KM_USER0);
+                                zero_user(page, bh_offset(bh), blocksize);
                                 set_buffer_uptodate(bh);
                         }
                         continue;
@@ -868,8 +866,8 @@ rl_not_mapped_enoent:
                                         if (!buffer_uptodate(bh))
                                                 set_buffer_uptodate(bh);
                                 } else if (!buffer_uptodate(bh)) {
-                                        zero_user_page(page, bh_offset(bh),
-                                                        blocksize, KM_USER0);
+                                        zero_user(page, bh_offset(bh),
+                                                blocksize);
                                         set_buffer_uptodate(bh);
                                 }
                                 continue;
@@ -1128,8 +1126,8 @@ rl_not_mapped_enoent:
 
                                 if (likely(bh_pos < initialized_size))
                                         ofs = initialized_size - bh_pos;
-                                zero_user_page(page, bh_offset(bh) + ofs,
-                                                blocksize - ofs, KM_USER0);
+                                zero_user_segment(page, bh_offset(bh) + ofs,
+                                                blocksize);
                         }
                 } else /* if (unlikely(!buffer_uptodate(bh))) */
                         err = -EIO;
@@ -1269,8 +1267,8 @@ rl_not_mapped_enoent:
                                 if (PageUptodate(page))
                                         set_buffer_uptodate(bh);
                                 else {
-                                        zero_user_page(page, bh_offset(bh),
-                                                        blocksize, KM_USER0);
+                                        zero_user(page, bh_offset(bh),
+                                                        blocksize);
                                         set_buffer_uptodate(bh);
                                 }
                         }
@@ -1330,7 +1328,7 @@ err_out:
                 len = PAGE_CACHE_SIZE;
                 if (len > bytes)
                         len = bytes;
-                zero_user_page(*pages, 0, len, KM_USER0);
+                zero_user(*pages, 0, len);
         }
         goto out;
 }
@@ -1451,7 +1449,7 @@ err_out:
                 len = PAGE_CACHE_SIZE;
                 if (len > bytes)
                         len = bytes;
-                zero_user_page(*pages, 0, len, KM_USER0);
+                zero_user(*pages, 0, len);
         }
         goto out;
 }
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index 64713e149e46..447206eb5c2e 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -5670,7 +5670,7 @@ static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
                 mlog_errno(ret);
 
         if (zero)
-                zero_user_page(page, from, to - from, KM_USER0);
+                zero_user_segment(page, from, to);
 
         /*
          * Need to set the buffers we zero'd into uptodate
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index bc7b4cbbe8ec..82243127eebf 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -307,7 +307,7 @@ static int ocfs2_readpage(struct file *file, struct page *page)
          * XXX sys_readahead() seems to get that wrong?
          */
         if (start >= i_size_read(inode)) {
-                zero_user_page(page, 0, PAGE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_SIZE);
                 SetPageUptodate(page);
                 ret = 0;
                 goto out_alloc;
@@ -869,7 +869,7 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
                 if (block_start >= to)
                         break;
 
-                zero_user_page(page, block_start, bh->b_size, KM_USER0);
+                zero_user(page, block_start, bh->b_size);
                 set_buffer_uptodate(bh);
                 mark_buffer_dirty(bh);
 
@@ -1034,7 +1034,7 @@ static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to
                                         start = max(from, block_start);
                                         end = min(to, block_end);
 
-                                        zero_user_page(page, start, end - start, KM_USER0);
+                                        zero_user_segment(page, start, end);
                                         set_buffer_uptodate(bh);
                                 }
 
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 231fd5ccadc5..195309857e63 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -2143,7 +2143,7 @@ int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
                 /* if we are not on a block boundary */
                 if (length) {
                         length = blocksize - length;
-                        zero_user_page(page, offset, length, KM_USER0);
+                        zero_user(page, offset, length);
                         if (buffer_mapped(bh) && bh->b_blocknr != 0) {
                                 mark_buffer_dirty(bh);
                         }
@@ -2367,7 +2367,7 @@ static int reiserfs_write_full_page(struct page *page,
                         unlock_page(page);
                         return 0;
                 }
-                zero_user_page(page, last_offset, PAGE_CACHE_SIZE - last_offset, KM_USER0);
+                zero_user_segment(page, last_offset, PAGE_CACHE_SIZE);
         }
         bh = head;
         block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index d6a8dddb2268..6f614f35f650 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -155,7 +155,7 @@ xfs_iozero(
                 if (status)
                         break;
 
-                zero_user_page(page, offset, bytes, KM_USER0);
+                zero_user(page, offset, bytes);
 
                 status = pagecache_write_end(NULL, mapping, pos, bytes, bytes,
                                         page, fsdata);
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 1fcb0033179e..61a5e5eb27f0 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -124,28 +124,40 @@ static inline void clear_highpage(struct page *page)
         kunmap_atomic(kaddr, KM_USER0);
 }
 
-/*
- * Same but also flushes aliased cache contents to RAM.
- *
- * This must be a macro because KM_USER0 and friends aren't defined if
- * !CONFIG_HIGHMEM
- */
-#define zero_user_page(page, offset, size, km_type)             \
-        do {                                                    \
-                void *kaddr;                                    \
-                                                                \
-                BUG_ON((offset) + (size) > PAGE_SIZE);          \
-                                                                \
-                kaddr = kmap_atomic(page, km_type);             \
-                memset((char *)kaddr + (offset), 0, (size));    \
-                flush_dcache_page(page);                        \
-                kunmap_atomic(kaddr, (km_type));                \
-        } while (0)
+static inline void zero_user_segments(struct page *page,
+        unsigned start1, unsigned end1,
+        unsigned start2, unsigned end2)
+{
+        void *kaddr = kmap_atomic(page, KM_USER0);
+
+        BUG_ON(end1 > PAGE_SIZE || end2 > PAGE_SIZE);
+
+        if (end1 > start1)
+                memset(kaddr + start1, 0, end1 - start1);
+
+        if (end2 > start2)
+                memset(kaddr + start2, 0, end2 - start2);
+
+        kunmap_atomic(kaddr, KM_USER0);
+        flush_dcache_page(page);
+}
+
+static inline void zero_user_segment(struct page *page,
+        unsigned start, unsigned end)
+{
+        zero_user_segments(page, start, end, 0, 0);
+}
+
+static inline void zero_user(struct page *page,
+        unsigned start, unsigned size)
+{
+        zero_user_segments(page, start, start + size, 0, 0);
+}
 
 static inline void __deprecated memclear_highpage_flush(struct page *page,
                         unsigned int offset, unsigned int size)
 {
-        zero_user_page(page, offset, size, KM_USER0);
+        zero_user(page, offset, size);
 }
 
 #ifndef __HAVE_ARCH_COPY_USER_HIGHPAGE
diff --git a/mm/filemap_xip.c b/mm/filemap_xip.c
index f874ae818ad3..0420a0292b03 100644
--- a/mm/filemap_xip.c
+++ b/mm/filemap_xip.c
@@ -431,7 +431,7 @@ xip_truncate_page(struct address_space *mapping, loff_t from)
                 else
                         return PTR_ERR(page);
         }
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
         return 0;
 }
 EXPORT_SYMBOL_GPL(xip_truncate_page);
diff --git a/mm/truncate.c b/mm/truncate.c
index c3123b08ff6d..3855492f1c3a 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -48,7 +48,7 @@ void do_invalidatepage(struct page *page, unsigned long offset)
 
 static inline void truncate_partial_page(struct page *page, unsigned partial)
 {
-        zero_user_page(page, partial, PAGE_CACHE_SIZE - partial, KM_USER0);
+        zero_user_segment(page, partial, PAGE_CACHE_SIZE);
         if (PagePrivate(page))
                 do_invalidatepage(page, partial);
 }