fs: Rename page_offset() to page_pos()

page_offset() is at best an ambiguous name for this function (returning
the byte offset in the file of this page).  At least one regular
contributor thought it returned the pgoff_t of the page.  We tend to use
a variable named page_offset to mean the byte offset from the start of
the page, which is also not what page_offset() does.

Fortunately, we have an unambiguous name for the offset in bytes from
the beginning -- pos.  The most common name for an loff_t is 'pos'
(by 773 to 575 for 'offset'), so page_pos() seems like the best name
for this function.

Conversion performed automatically by Coccinelle with this script:

@@ expression a; @@
-       page_offset(a)
+       page_pos(a)

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Acked-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: William Kucharski <william.kucharski@oracle.com>

38 files changed, 138 insertions, 138 deletions

diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index cce9ace651a2..656e6582efd0 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -53,7 +53,7 @@ static int v9fs_fid_readpage(void *data, struct page *page)
 
 	iov_iter_bvec(&to, READ, &bvec, 1, PAGE_SIZE);
 
-	retval = p9_client_read(fid, page_offset(page), &to, &err);
+	retval = p9_client_read(fid, page_pos(page), &to, &err);
 	if (err) {
 		v9fs_uncache_page(inode, page);
 		retval = err;
@@ -169,7 +169,7 @@ static int v9fs_vfs_writepage_locked(struct page *page)
 
 	set_page_writeback(page);
 
-	p9_client_write(v9inode->writeback_fid, page_offset(page), &from, &err);
+	p9_client_write(v9inode->writeback_fid, page_pos(page), &from, &err);
 
 	end_page_writeback(page);
 	return err;
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 5c794f4b051a..88ed6233942f 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -117,7 +117,7 @@ static bool afs_dir_check_page(struct afs_vnode *dvnode, struct page *page,
 	/* Determine how many magic numbers there should be in this page, but
 	 * we must take care because the directory may change size under us.
 	 */
-	off = page_offset(page);
+	off = page_pos(page);
 	if (i_size <= off)
 		goto checked;
 
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 9ab610cc9114..a7d7f2927fcb 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -529,7 +529,7 @@ static u64 bio_end_offset(struct bio *bio)
 {
 	struct bio_vec *last = bio_last_bvec_all(bio);
 
-	return page_offset(last->bv_page) + last->bv_len + last->bv_offset;
+	return page_pos(last->bv_page) + last->bv_len + last->bv_offset;
 }
 
 static noinline int add_ra_bio_pages(struct inode *inode,
@@ -675,7 +675,7 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 	/* we need the actual starting offset of this extent in the file */
 	read_lock(&em_tree->lock);
 	em = lookup_extent_mapping(em_tree,
-				   page_offset(bio_first_page_all(bio)),
+				   page_pos(bio_first_page_all(bio)),
 				   PAGE_SIZE);
 	read_unlock(&em_tree->lock);
 	if (!em)
@@ -1269,7 +1269,7 @@ int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,
 	 * start byte is the first byte of the page we're currently
 	 * copying into relative to the start of the compressed data.
 	 */
-	start_byte = page_offset(bvec.bv_page) - disk_start;
+	start_byte = page_pos(bvec.bv_page) - disk_start;
 
 	/* we haven't yet hit data corresponding to this page */
 	if (total_out <= start_byte)
@@ -1308,7 +1308,7 @@ int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,
 			return 0;
 		bvec = bio_iter_iovec(bio, bio->bi_iter);
 		prev_start_byte = start_byte;
-		start_byte = page_offset(bvec.bv_page) - disk_start;
+		start_byte = page_pos(bvec.bv_page) - disk_start;
 
 		/*
 		 * We need to make sure we're only adjusting
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index a6cb5cbbdb9f..8943030621d0 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -499,7 +499,7 @@ static int btree_read_extent_buffer_pages(struct extent_buffer *eb,
 
 static int csum_dirty_buffer(struct btrfs_fs_info *fs_info, struct page *page)
 {
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 found_start;
 	u8 result[BTRFS_CSUM_SIZE];
 	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
@@ -979,7 +979,7 @@ static void btree_invalidatepage(struct page *page, unsigned int offset,
 	if (PagePrivate(page)) {
 		btrfs_warn(BTRFS_I(page->mapping->host)->root->fs_info,
 			   "page private not zero on page %llu",
-			   (unsigned long long)page_offset(page));
+			   (unsigned long long) page_pos(page));
 		ClearPagePrivate(page);
 		set_page_private(page, 0);
 		put_page(page);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 39e45b8a5031..80a0950e9f63 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2212,7 +2212,7 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end,
  */
 static void check_page_uptodate(struct extent_io_tree *tree, struct page *page)
 {
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 end = start + PAGE_SIZE - 1;
 	if (test_range_bit(tree, start, end, EXTENT_UPTODATE, 1, NULL))
 		SetPageUptodate(page);
@@ -2347,7 +2347,7 @@ int btrfs_repair_eb_io_failure(struct extent_buffer *eb, int mirror_num)
 		struct page *p = eb->pages[i];
 
 		ret = repair_io_failure(fs_info, 0, start, PAGE_SIZE, start, p,
-					start - page_offset(p), mirror_num);
+					start - page_pos(p), mirror_num);
 		if (ret)
 			break;
 		start += PAGE_SIZE;
@@ -2670,7 +2670,7 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
 
 	phy_offset >>= inode->i_sb->s_blocksize_bits;
 	bio = btrfs_create_repair_bio(inode, failed_bio, failrec, page,
-				      start - page_offset(page),
+				      start - page_pos(page),
 				      (int)phy_offset, failed_bio->bi_end_io,
 				      NULL);
 	bio->bi_opf = REQ_OP_READ | read_mode;
@@ -2746,7 +2746,7 @@ static void end_bio_extent_writepage(struct bio *bio)
 					bvec->bv_offset, bvec->bv_len);
 		}
 
-		start = page_offset(page);
+		start = page_pos(page);
 		end = start + bvec->bv_offset + bvec->bv_len - 1;
 
 		end_extent_writepage(page, error, start, end);
@@ -2826,7 +2826,7 @@ static void end_bio_extent_readpage(struct bio *bio)
 					bvec->bv_offset, bvec->bv_len);
 		}
 
-		start = page_offset(page);
+		start = page_pos(page);
 		end = start + bvec->bv_offset + bvec->bv_len - 1;
 		len = bvec->bv_len;
 
@@ -3136,7 +3136,7 @@ static int __do_readpage(struct page *page,
 			 u64 *prev_em_start)
 {
 	struct inode *inode = page->mapping->host;
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	const u64 end = start + PAGE_SIZE - 1;
 	u64 cur = start;
 	u64 extent_offset;
@@ -3361,7 +3361,7 @@ static int __extent_read_full_page(struct page *page,
 				   unsigned int read_flags)
 {
 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 end = start + PAGE_SIZE - 1;
 	int ret;
 
@@ -3488,7 +3488,7 @@ static noinline_for_stack int __extent_writepage_io(struct inode *inode,
 				 int *nr_ret)
 {
 	struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 page_end = start + PAGE_SIZE - 1;
 	u64 end;
 	u64 cur = start;
@@ -3605,7 +3605,7 @@ static int __extent_writepage(struct page *page, struct writeback_control *wbc,
 			      struct extent_page_data *epd)
 {
 	struct inode *inode = page->mapping->host;
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 page_end = start + PAGE_SIZE - 1;
 	int ret;
 	int nr = 0;
@@ -4392,11 +4392,11 @@ int extent_readpages(struct address_space *mapping, struct list_head *pages,
 			}
 
 			pagepool[nr++] = page;
-			contig_end = page_offset(page) + PAGE_SIZE - 1;
+			contig_end = page_pos(page) + PAGE_SIZE - 1;
 		}
 
 		if (nr) {
-			u64 contig_start = page_offset(pagepool[0]);
+			u64 contig_start = page_pos(pagepool[0]);
 
 			ASSERT(contig_start + nr * PAGE_SIZE - 1 == contig_end);
 
@@ -4423,7 +4423,7 @@ int extent_invalidatepage(struct extent_io_tree *tree,
 			  struct page *page, unsigned long offset)
 {
 	struct extent_state *cached_state = NULL;
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 end = start + PAGE_SIZE - 1;
 	size_t blocksize = page->mapping->host->i_sb->s_blocksize;
 
@@ -4446,7 +4446,7 @@ int extent_invalidatepage(struct extent_io_tree *tree,
 static int try_release_extent_state(struct extent_io_tree *tree,
 				    struct page *page, gfp_t mask)
 {
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 end = start + PAGE_SIZE - 1;
 	int ret = 1;
 
@@ -4480,7 +4480,7 @@ static int try_release_extent_state(struct extent_io_tree *tree,
 int try_release_extent_mapping(struct page *page, gfp_t mask)
 {
 	struct extent_map *em;
-	u64 start = page_offset(page);
+	u64 start = page_pos(page);
 	u64 end = start + PAGE_SIZE - 1;
 	struct btrfs_inode *btrfs_inode = BTRFS_I(page->mapping->host);
 	struct extent_io_tree *tree = &btrfs_inode->io_tree;
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index b618ad5339ba..d78363572e09 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -314,7 +314,7 @@ blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
 			goto next;
 
 		if (page_offsets)
-			offset = page_offset(bvec.bv_page) + bvec.bv_offset;
+			offset = page_pos(bvec.bv_page) + bvec.bv_offset;
 		count = btrfs_find_ordered_sum(inode, offset, disk_bytenr,
 					       csum, nblocks);
 		if (count)
@@ -561,7 +561,7 @@ blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
 
 	bio_for_each_segment(bvec, bio, iter) {
 		if (!contig)
-			offset = page_offset(bvec.bv_page) + bvec.bv_offset;
+			offset = page_pos(bvec.bv_page) + bvec.bv_offset;
 
 		if (!ordered) {
 			ordered = btrfs_lookup_ordered_extent(inode, offset);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 320d1062068d..6a3a1eef75e1 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -109,7 +109,7 @@ static inline void btrfs_cleanup_ordered_extents(struct inode *inode,
 {
 	unsigned long index = offset >> PAGE_SHIFT;
 	unsigned long end_index = (offset + bytes - 1) >> PAGE_SHIFT;
-	u64 page_start = page_offset(locked_page);
+	u64 page_start = page_pos(locked_page);
 	u64 page_end = page_start + PAGE_SIZE - 1;
 
 	struct page *page;
@@ -722,8 +722,8 @@ cleanup_and_bail_uncompressed:
 	 * cow_file_range to do the normal delalloc dance.
 	 */
 	if (async_chunk->locked_page &&
-	    (page_offset(async_chunk->locked_page) >= start &&
-	     page_offset(async_chunk->locked_page)) <= end) {
+	    (page_pos(async_chunk->locked_page) >= start &&
+	     page_pos(async_chunk->locked_page)) <= end) {
 		__set_page_dirty_nobuffers(async_chunk->locked_page);
 		/* unlocked later on in the async handlers */
 	}
@@ -2219,8 +2219,8 @@ static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
 	fixup = container_of(work, struct btrfs_writepage_fixup, work);
 	page = fixup->page;
 	inode = fixup->inode;
-	page_start = page_offset(page);
-	page_end = page_offset(page) + PAGE_SIZE - 1;
+	page_start = page_pos(page);
+	page_end = page_pos(page) + PAGE_SIZE - 1;
 
 	/*
 	 * This is similar to page_mkwrite, we need to reserve the space before
@@ -2770,7 +2770,7 @@ static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
 				      u64 phy_offset, struct page *page,
 				      u64 start, u64 end, int mirror)
 {
-	size_t offset = start - page_offset(page);
+	size_t offset = start - page_pos(page);
 	struct inode *inode = page->mapping->host;
 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 	struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -4519,10 +4519,10 @@ again:
 			len = blocksize - offset;
 		kaddr = kmap(page);
 		if (front)
-			memset(kaddr + (block_start - page_offset(page)),
+			memset(kaddr + (block_start - page_pos(page)),
 				0, offset);
 		else
-			memset(kaddr + (block_start - page_offset(page)) +  offset,
+			memset(kaddr + (block_start - page_pos(page)) +  offset,
 				0, len);
 		flush_dcache_page(page);
 		kunmap(page);
@@ -6583,7 +6583,7 @@ next:
 			goto out;
 
 		size = btrfs_file_extent_ram_bytes(leaf, item);
-		extent_offset = page_offset(page) + pg_offset - extent_start;
+		extent_offset = page_pos(page) + pg_offset - extent_start;
 		copy_size = min_t(u64, PAGE_SIZE - pg_offset,
 				  size - extent_offset);
 		em->start = extent_start + extent_offset;
@@ -8358,7 +8358,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
 	struct extent_io_tree *tree;
 	struct btrfs_ordered_extent *ordered;
 	struct extent_state *cached_state = NULL;
-	u64 page_start = page_offset(page);
+	u64 page_start = page_pos(page);
 	u64 page_end = page_start + PAGE_SIZE - 1;
 	u64 start;
 	u64 end;
@@ -8503,7 +8503,7 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	reserved_space = PAGE_SIZE;
 
 	sb_start_pagefault(inode->i_sb);
-	page_start = page_offset(page);
+	page_start = page_pos(page);
 	page_end = page_start + PAGE_SIZE - 1;
 	end = page_end;
 
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 40b729dce91c..e69b1c2a707c 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -1248,7 +1248,7 @@ again:
 		if (!page)
 			break;
 
-		page_start = page_offset(page);
+		page_start = page_pos(page);
 		page_end = page_start + PAGE_SIZE - 1;
 		while (1) {
 			lock_extent_bits(tree, page_start, page_end,
@@ -1308,8 +1308,8 @@ again:
 	for (i = 0; i < i_done; i++)
 		wait_on_page_writeback(pages[i]);
 
-	page_start = page_offset(pages[0]);
-	page_end = page_offset(pages[i_done - 1]) + PAGE_SIZE;
+	page_start = page_pos(pages[0]);
+	page_end = page_pos(pages[i_done - 1]) + PAGE_SIZE;
 
 	lock_extent_bits(&BTRFS_I(inode)->io_tree,
 			 page_start, page_end - 1, &cached_state);
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index f65595602aa8..96686c72f14e 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -3461,7 +3461,7 @@ static int relocate_file_extent_cluster(struct inode *inode,
 			}
 		}
 
-		page_start = page_offset(page);
+		page_start = page_pos(page);
 		page_end = page_start + PAGE_SIZE - 1;
 
 		lock_extent(&BTRFS_I(inode)->io_tree, page_start, page_end);
diff --git a/fs/buffer.c b/fs/buffer.c
index f73276d746bb..d777f9120bf4 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2499,7 +2499,7 @@ int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
 	lock_page(page);
 	size = i_size_read(inode);
 	if ((page->mapping != inode->i_mapping) ||
-	    (page_offset(page) > size)) {
+	    (page_pos(page) > size)) {
 		/* We overload EFAULT to mean page got truncated */
 		ret = -EFAULT;
 		goto out_unlock;
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 6f4678d98df7..86a20815c19e 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -230,7 +230,7 @@ static int ceph_do_readpage(struct file *filp, struct page *page)
 	struct ceph_inode_info *ci = ceph_inode(inode);
 	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
 	int err = 0;
-	u64 off = page_offset(page);
+	u64 off = page_pos(page);
 	u64 len = PAGE_SIZE;
 
 	if (off >= i_size_read(inode)) {
@@ -385,7 +385,7 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 		}
 	}
 
-	off = (u64) page_offset(page);
+	off = (u64) page_pos(page);
 
 	/* count pages */
 	next_index = page->index;
@@ -604,8 +604,8 @@ static u64 get_writepages_data_length(struct inode *inode,
 		spin_unlock(&ci->i_ceph_lock);
 		WARN_ON(!found);
 	}
-	if (end > page_offset(page) + PAGE_SIZE)
-		end = page_offset(page) + PAGE_SIZE;
+	if (end > page_pos(page) + PAGE_SIZE)
+		end = page_pos(page) + PAGE_SIZE;
 	return end > start ? end - start : 0;
 }
 
@@ -662,7 +662,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 	struct ceph_inode_info *ci;
 	struct ceph_fs_client *fsc;
 	struct ceph_snap_context *snapc, *oldest;
-	loff_t page_off = page_offset(page);
+	loff_t page_off = page_pos(page);
 	int err, len = PAGE_SIZE;
 	struct ceph_writeback_ctl ceph_wbc;
 
@@ -980,11 +980,11 @@ get_more_pages:
 				unlock_page(page);
 				continue;
 			}
-			if (page_offset(page) >= ceph_wbc.i_size) {
+			if (page_pos(page) >= ceph_wbc.i_size) {
 				dout("%p page eof %llu\n",
 				     page, ceph_wbc.i_size);
 				if ((ceph_wbc.size_stable ||
-				    page_offset(page) >= i_size_read(inode)) &&
+				    page_pos(page) >= i_size_read(inode)) &&
 				    clear_page_dirty_for_io(page))
 					mapping->a_ops->invalidatepage(page,
 								0, PAGE_SIZE);
@@ -1024,7 +1024,7 @@ get_more_pages:
 				u32 xlen;
 
 				/* prepare async write request */
-				offset = (u64)page_offset(page);
+				offset = (u64) page_pos(page);
 				ceph_calc_file_object_mapping(&ci->i_layout,
 							      offset, wsize,
 							      &objnum, &objoff,
@@ -1057,7 +1057,7 @@ get_more_pages:
 				}
 
 				num_ops++;
-				offset = (u64)page_offset(page);
+				offset = (u64) page_pos(page);
 				len = 0;
 			}
 
@@ -1103,7 +1103,7 @@ get_more_pages:
 		}
 
 new_request:
-		offset = page_offset(pages[0]);
+		offset = page_pos(pages[0]);
 		len = wsize;
 
 		req = ceph_osdc_new_request(&fsc->client->osdc,
@@ -1124,7 +1124,7 @@ new_request:
 						ceph_wbc.truncate_size, true);
 			BUG_ON(IS_ERR(req));
 		}
-		BUG_ON(len < page_offset(pages[locked_pages - 1]) +
+		BUG_ON(len < page_pos(pages[locked_pages - 1]) +
 			     PAGE_SIZE - offset);
 
 		req->r_callback = writepages_finish;
@@ -1135,7 +1135,7 @@ new_request:
 		data_pages = pages;
 		op_idx = 0;
 		for (i = 0; i < locked_pages; i++) {
-			u64 cur_offset = page_offset(pages[i]);
+			u64 cur_offset = page_pos(pages[i]);
 			if (offset + len != cur_offset) {
 				if (op_idx + 1 == req->r_num_ops)
 					break;
@@ -1600,7 +1600,7 @@ static vm_fault_t ceph_page_mkwrite(struct vm_fault *vmf)
 	struct ceph_file_info *fi = vma->vm_file->private_data;
 	struct ceph_cap_flush *prealloc_cf;
 	struct page *page = vmf->page;
-	loff_t off = page_offset(page);
+	loff_t off = page_pos(page);
 	loff_t size = i_size_read(inode);
 	size_t len;
 	int want, got, err;
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 140efc1a9374..13b4ba40e1fe 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -2121,7 +2121,7 @@ cifs_writev_requeue(struct cifs_writedata *wdata)
 
 		wdata2->sync_mode = wdata->sync_mode;
 		wdata2->nr_pages = nr_pages;
-		wdata2->offset = page_offset(wdata2->pages[0]);
+		wdata2->offset = page_pos(wdata2->pages[0]);
 		wdata2->pagesz = PAGE_SIZE;
 		wdata2->tailsz = tailsz;
 		wdata2->bytes = cur_len;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 5920820bfbd0..2ec137873c15 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -2262,7 +2262,7 @@ wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
 		 * See cifs_writepage() for more commentary.
 		 */
 		set_page_writeback(page);
-		if (page_offset(page) >= i_size_read(mapping->host)) {
+		if (page_pos(page) >= i_size_read(mapping->host)) {
 			*done = true;
 			unlock_page(page);
 			end_page_writeback(page);
@@ -2297,10 +2297,10 @@ wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
 
 	wdata->sync_mode = wbc->sync_mode;
 	wdata->nr_pages = nr_pages;
-	wdata->offset = page_offset(wdata->pages[0]);
+	wdata->offset = page_pos(wdata->pages[0]);
 	wdata->pagesz = PAGE_SIZE;
 	wdata->tailsz = min(i_size_read(mapping->host) -
-			page_offset(wdata->pages[nr_pages - 1]),
+			page_pos(wdata->pages[nr_pages - 1]),
 			(loff_t)PAGE_SIZE);
 	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
 	wdata->pid = wdata->cfile->pid;
@@ -4711,7 +4711,7 @@ static void cifs_invalidate_page(struct page *page, unsigned int offset,
 static int cifs_launder_page(struct page *page)
 {
 	int rc = 0;
-	loff_t range_start = page_offset(page);
+	loff_t range_start = page_pos(page);
 	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
 	struct writeback_control wbc = {
 		.sync_mode = WB_SYNC_ALL,
diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c
index c4b6c9aa87ec..5a88c7717bcd 100644
--- a/fs/erofs/zdata.c
+++ b/fs/erofs/zdata.c
@@ -569,7 +569,7 @@ static int z_erofs_do_read_page(struct z_erofs_decompress_frontend *fe,
 	struct erofs_sb_info *const sbi = EROFS_I_SB(inode);
 	struct erofs_map_blocks *const map = &fe->map;
 	struct z_erofs_collector *const clt = &fe->clt;
-	const loff_t offset = page_offset(page);
+	const loff_t offset = page_pos(page);
 	bool tight = true;
 
 	enum z_erofs_cache_alloctype cache_strategy;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 13318e255ebf..9d9158427a6f 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -437,7 +437,7 @@ static int ext2_prepare_chunk(struct page *page, loff_t pos, unsigned len)
 void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
 		   struct page *page, struct inode *inode, int update_times)
 {
-	loff_t pos = page_offset(page) +
+	loff_t pos = page_pos(page) +
 			(char *) de - (char *) page_address(page);
 	unsigned len = ext2_rec_len_from_disk(de->rec_len);
 	int err;
@@ -524,7 +524,7 @@ int ext2_add_link (struct dentry *dentry, struct inode *inode)
 	return -EINVAL;
 
 got_it:
-	pos = page_offset(page) +
+	pos = page_pos(page) +
 		(char*)de - (char*)page_address(page);
 	err = ext2_prepare_chunk(page, pos, rec_len);
 	if (err)
@@ -581,7 +581,7 @@ int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
 	}
 	if (pde)
 		from = (char*)pde - (char*)page_address(page);
-	pos = page_offset(page) + from;
+	pos = page_pos(page) + from;
 	lock_page(page);
 	err = ext2_prepare_chunk(page, pos, to - from);
 	BUG_ON(err);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index e416096fc081..716cf9bd4795 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -5965,7 +5965,7 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 	lock_page(page);
 	size = i_size_read(inode);
 	/* Page got truncated from under us? */
-	if (page->mapping != mapping || page_offset(page) > size) {
+	if (page->mapping != mapping || page_pos(page) > size) {
 		unlock_page(page);
 		ret = VM_FAULT_NOPAGE;
 		goto out;
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 6ab8f621a3c5..e49df390bf74 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -92,7 +92,7 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
 	down_read(&F2FS_I(inode)->i_mmap_sem);
 	lock_page(page);
 	if (unlikely(page->mapping != inode->i_mapping ||
-			page_offset(page) > i_size_read(inode) ||
+			page_pos(page) > i_size_read(inode) ||
 			!PageUptodate(page))) {
 		unlock_page(page);
 		err = -EFAULT;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 9d67b830fb7a..17a14e0ac987 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -773,7 +773,7 @@ static void fuse_short_read(struct inode *inode, u64 attr_ver, size_t num_read,
 			off = 0;
 		}
 	} else {
-		loff_t pos = page_offset(ap->pages[0]) + num_read;
+		loff_t pos = page_pos(ap->pages[0]) + num_read;
 		fuse_read_update_size(inode, pos, attr_ver);
 	}
 }
@@ -782,7 +782,7 @@ static int fuse_do_readpage(struct file *file, struct page *page)
 {
 	struct inode *inode = page->mapping->host;
 	struct fuse_conn *fc = get_fuse_conn(inode);
-	loff_t pos = page_offset(page);
+	loff_t pos = page_pos(page);
 	struct fuse_page_desc desc = { .length = PAGE_SIZE };
 	struct fuse_io_args ia = {
 		.ap.args.page_zeroing = true,
@@ -884,7 +884,7 @@ static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file)
 	struct fuse_file *ff = file->private_data;
 	struct fuse_conn *fc = ff->fc;
 	struct fuse_args_pages *ap = &ia->ap;
-	loff_t pos = page_offset(ap->pages[0]);
+	loff_t pos = page_pos(ap->pages[0]);
 	size_t count = ap->num_pages << PAGE_SHIFT;
 	ssize_t res;
 	int err;
@@ -1838,7 +1838,7 @@ static int fuse_writepage_locked(struct page *page)
 	if (!wpa->ia.ff)
 		goto err_nofile;
 
-	fuse_write_args_fill(&wpa->ia, wpa->ia.ff, page_offset(page), 0);
+	fuse_write_args_fill(&wpa->ia, wpa->ia.ff, page_pos(page), 0);
 
 	copy_highpage(tmp_page, page);
 	wpa->ia.write.in.write_flags |= FUSE_WRITE_CACHE;
@@ -2076,7 +2076,7 @@ static int fuse_writepages_fill(struct page *page,
 		data->max_pages = 1;
 
 		ap = &wpa->ia.ap;
-		fuse_write_args_fill(&wpa->ia, data->ff, page_offset(page), 0);
+		fuse_write_args_fill(&wpa->ia, data->ff, page_pos(page), 0);
 		wpa->ia.write.in.write_flags |= FUSE_WRITE_CACHE;
 		wpa->next = NULL;
 		ap->args.in_pages = true;
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index fe305e4bfd37..7945115102fe 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -416,7 +416,7 @@ static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
  */
 static int gfs2_allocate_page_backing(struct page *page, unsigned int length)
 {
-	u64 pos = page_offset(page);
+	u64 pos = page_pos(page);
 
 	do {
 		struct iomap iomap = { };
@@ -449,7 +449,7 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf)
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct gfs2_alloc_parms ap = { .aflags = 0, };
-	u64 offset = page_offset(page);
+	u64 offset = page_pos(page);
 	unsigned int data_blocks, ind_blocks, rblocks;
 	struct gfs2_holder gh;
 	unsigned int length;
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index c070c0d8e3e9..c6c0296ee018 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -401,7 +401,7 @@ static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
 	struct address_space *mapping = page->mapping;
 	struct inode *inode = mapping->host;
 	char *buffer;
-	loff_t base = page_offset(page);
+	loff_t base = page_pos(page);
 	int count = PAGE_SIZE;
 	int end_index = inode->i_size >> PAGE_SHIFT;
 	int err;
@@ -434,7 +434,7 @@ static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
 static int hostfs_readpage(struct file *file, struct page *page)
 {
 	char *buffer;
-	loff_t start = page_offset(page);
+	loff_t start = page_pos(page);
 	int bytes_read, ret = 0;
 
 	buffer = kmap(page);
diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 89e21961d1ad..996790828783 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -348,9 +348,9 @@ iomap_readpage(struct page *page, const struct iomap_ops *ops)
 	trace_iomap_readpage(page->mapping->host, 1);
 
 	for (poff = 0; poff < PAGE_SIZE; poff += ret) {
-		ret = iomap_apply(inode, page_offset(page) + poff,
-				PAGE_SIZE - poff, 0, ops, &ctx,
-				iomap_readpage_actor);
+		ret = iomap_apply(inode, page_pos(page) + poff,
+				  PAGE_SIZE - poff, 0, ops, &ctx,
+				  iomap_readpage_actor);
 		if (ret <= 0) {
 			WARN_ON_ONCE(ret == 0);
 			SetPageError(page);
@@ -382,7 +382,7 @@ iomap_next_page(struct inode *inode, struct list_head *pages, loff_t pos,
 	while (!list_empty(pages)) {
 		struct page *page = lru_to_page(pages);
 
-		if (page_offset(page) >= (u64)pos + length)
+		if (page_pos(page) >= (u64)pos + length)
 			break;
 
 		list_del(&page->lru);
@@ -439,8 +439,8 @@ iomap_readpages(struct address_space *mapping, struct list_head *pages,
 		.pages		= pages,
 		.is_readahead	= true,
 	};
-	loff_t pos = page_offset(list_entry(pages->prev, struct page, lru));
-	loff_t last = page_offset(list_entry(pages->next, struct page, lru));
+	loff_t pos = page_pos(list_entry(pages->prev, struct page, lru));
+	loff_t last = page_pos(list_entry(pages->next, struct page, lru));
 	loff_t length = last - pos + PAGE_SIZE, ret = 0;
 
 	trace_iomap_readpages(mapping->host, nr_pages);
@@ -511,8 +511,8 @@ EXPORT_SYMBOL_GPL(iomap_is_partially_uptodate);
 int
 iomap_releasepage(struct page *page, gfp_t gfp_mask)
 {
-	trace_iomap_releasepage(page->mapping->host, page_offset(page),
-			PAGE_SIZE);
+	trace_iomap_releasepage(page->mapping->host, page_pos(page),
+				PAGE_SIZE);
 
 	/*
 	 * mm accommodates an old ext3 case where clean pages might not have had
@@ -1088,7 +1088,7 @@ vm_fault_t iomap_page_mkwrite(struct vm_fault *vmf, const struct iomap_ops *ops)
 		goto out_unlock;
 	length = ret;
 
-	offset = page_offset(page);
+	offset = page_pos(page);
 	while (length > 0) {
 		ret = iomap_apply(inode, offset, length,
 				IOMAP_WRITE | IOMAP_FAULT, ops, page,
@@ -1422,7 +1422,7 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 	 * end of the current map or find the current map invalid, grab a new
 	 * one.
 	 */
-	for (i = 0, file_offset = page_offset(page);
+	for (i = 0, file_offset = page_pos(page);
 	     i < (PAGE_SIZE >> inode->i_blkbits) && file_offset < end_offset;
 	     i++, file_offset += len) {
 		if (iop && !test_bit(i, iop->uptodate))
@@ -1521,7 +1521,7 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 	u64 end_offset;
 	loff_t offset;
 
-	trace_iomap_writepage(inode, page_offset(page), PAGE_SIZE);
+	trace_iomap_writepage(inode, page_pos(page), PAGE_SIZE);
 
 	/*
 	 * Refuse to write the page out if we are called from reclaim context.
diff --git a/fs/iomap/seek.c b/fs/iomap/seek.c
index 89f61d93c0bc..aad3ec974353 100644
--- a/fs/iomap/seek.c
+++ b/fs/iomap/seek.c
@@ -21,7 +21,7 @@ page_seek_hole_data(struct inode *inode, struct page *page, loff_t *lastoff,
 	const struct address_space_operations *ops = inode->i_mapping->a_ops;
 	unsigned int bsize = i_blocksize(inode), off;
 	bool seek_data = whence == SEEK_DATA;
-	loff_t poff = page_offset(page);
+	loff_t poff = page_pos(page);
 
 	if (WARN_ON_ONCE(*lastoff >= poff + PAGE_SIZE))
 		return false;
@@ -97,7 +97,7 @@ page_cache_seek_hole_data(struct inode *inode, loff_t offset, loff_t length,
 
 			if (page_seek_hole_data(inode, page, &lastoff, whence))
 				goto check_range;
-			lastoff = page_offset(page) + PAGE_SIZE;
+			lastoff = page_pos(page) + PAGE_SIZE;
 		}
 		pagevec_release(&pvec);
 	} while (index < end);
diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index bc12ac7e2312..c527d4b6d77b 100644
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -221,7 +221,7 @@ static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
 	 * uncompress the whole compression block anyway, fill the surrounding
 	 * pages with the data we have anyway...
 	 */
-	start_off = page_offset(pages[full_page]);
+	start_off = page_pos(pages[full_page]);
 	end_off = min_t(loff_t, start_off + PAGE_SIZE, inode->i_size);
 
 	cstart_block = start_off >> zisofs_block_shift;
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index dcfe5b25378b..f2018b54925f 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -262,7 +262,7 @@ int minix_add_link(struct dentry *dentry, struct inode *inode)
 	return -EINVAL;
 
 got_it:
-	pos = page_offset(page) + p - (char *)page_address(page);
+	pos = page_pos(page) + p - (char *)page_address(page);
 	err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
 	if (err)
 		goto out_unlock;
@@ -290,7 +290,7 @@ int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
 {
 	struct inode *inode = page->mapping->host;
 	char *kaddr = page_address(page);
-	loff_t pos = page_offset(page) + (char*)de - kaddr;
+	loff_t pos = page_pos(page) + (char*)de - kaddr;
 	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
 	unsigned len = sbi->s_dirsize;
 	int err;
@@ -414,7 +414,7 @@ void minix_set_link(struct minix_dir_entry *de, struct page *page,
 {
 	struct inode *dir = page->mapping->host;
 	struct minix_sb_info *sbi = minix_sb(dir->i_sb);
-	loff_t pos = page_offset(page) +
+	loff_t pos = page_pos(page) +
 			(char *)de-(char*)page_address(page);
 	int err;
 
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index f96367a2463e..3d48daccbb73 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -475,7 +475,7 @@ static int nfs_launder_page(struct page *page)
 	struct nfs_inode *nfsi = NFS_I(inode);
 
 	dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
-		inode->i_ino, (long long)page_offset(page));
+		inode->i_ino, (long long) page_pos(page));
 
 	nfs_fscache_wait_on_page_write(nfsi, page);
 	return nfs_wb_page(inode, page);
@@ -547,7 +547,7 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf)
 
 	dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
 		filp, filp->f_mapping->host->i_ino,
-		(long long)page_offset(page));
+		(long long) page_pos(page));
 
 	sb_start_pagefault(inode->i_sb);
 
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 81394e22d0a0..23d3e75b4d87 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -87,7 +87,7 @@ static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr)
 static int nilfs_prepare_chunk(struct page *page, unsigned int from,
 			       unsigned int to)
 {
-	loff_t pos = page_offset(page) + from;
+	loff_t pos = page_pos(page) + from;
 
 	return __block_write_begin(page, pos, to - from, nilfs_get_block);
 }
@@ -97,7 +97,7 @@ static void nilfs_commit_chunk(struct page *page,
 			       unsigned int from, unsigned int to)
 {
 	struct inode *dir = mapping->host;
-	loff_t pos = page_offset(page) + from;
+	loff_t pos = page_pos(page) + from;
 	unsigned int len = to - from;
 	unsigned int nr_dirty, copied;
 	int err;
diff --git a/fs/nilfs2/file.c b/fs/nilfs2/file.c
index 64bc81363c6c..d5db63fc4978 100644
--- a/fs/nilfs2/file.c
+++ b/fs/nilfs2/file.c
@@ -56,7 +56,7 @@ static vm_fault_t nilfs_page_mkwrite(struct vm_fault *vmf)
 	sb_start_pagefault(inode->i_sb);
 	lock_page(page);
 	if (page->mapping != inode->i_mapping ||
-	    page_offset(page) >= i_size_read(inode) || !PageUptodate(page)) {
+	    page_pos(page) >= i_size_read(inode) || !PageUptodate(page)) {
 		unlock_page(page);
 		ret = -EFAULT;	/* make the VM retry the fault */
 		goto out;
diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index d7fc8d369d89..919875d72197 100644
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -393,7 +393,7 @@ void nilfs_clear_dirty_page(struct page *page, bool silent)
 	if (!silent)
 		nilfs_msg(sb, KERN_WARNING,
 			  "discard dirty page: offset=%lld, ino=%lu",
-			  page_offset(page), inode->i_ino);
+			  page_pos(page), inode->i_ino);
 
 	ClearPageUptodate(page);
 	ClearPageMappedToDisk(page);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 3a67a6518ddf..a2e1f43ac020 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -582,7 +582,7 @@ static void ocfs2_clear_page_regions(struct page *page,
 static int ocfs2_should_read_blk(struct inode *inode, struct page *page,
 				 unsigned int block_start)
 {
-	u64 offset = page_offset(page) + block_start;
+	u64 offset = page_pos(page) + block_start;
 
 	if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
 		return 1;
@@ -966,8 +966,8 @@ static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
 	/* treat the write as new if the a hole/lseek spanned across
 	 * the page boundary.
 	 */
-	new = new | ((i_size_read(inode) <= page_offset(page)) &&
-			(page_offset(page) <= user_pos));
+	new = new | ((i_size_read(inode) <= page_pos(page)) &&
+			(page_pos(page) <= user_pos));
 
 	if (page == wc->w_target_page) {
 		map_from = user_pos & (PAGE_SIZE - 1);
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index 3a44e461828a..90adefbf034a 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -52,7 +52,7 @@ static vm_fault_t __ocfs2_page_mkwrite(struct file *file,
 	vm_fault_t ret = VM_FAULT_NOPAGE;
 	struct inode *inode = file_inode(file);
 	struct address_space *mapping = inode->i_mapping;
-	loff_t pos = page_offset(page);
+	loff_t pos = page_pos(page);
 	unsigned int len = PAGE_SIZE;
 	pgoff_t last_index;
 	struct page *locked_page = NULL;
@@ -76,7 +76,7 @@ static vm_fault_t __ocfs2_page_mkwrite(struct file *file,
 	 */
 	if ((page->mapping != inode->i_mapping) ||
 	    (!PageUptodate(page)) ||
-	    (page_offset(page) >= size))
+	    (page_pos(page) >= size))
 		goto out;
 
 	/*
diff --git a/fs/orangefs/inode.c b/fs/orangefs/inode.c
index 12ae630fbed7..df6cc2021afa 100644
--- a/fs/orangefs/inode.c
+++ b/fs/orangefs/inode.c
@@ -39,7 +39,7 @@ static int orangefs_writepage_locked(struct page *page,
 			wlen = wr->len;
 	} else {
 		WARN_ON(1);
-		off = page_offset(page);
+		off = page_pos(page);
 		if (off + PAGE_SIZE > len)
 			wlen = len - off;
 		else
@@ -107,12 +107,12 @@ static int orangefs_writepages_work(struct orangefs_writepages *ow,
 	for (i = 0; i < ow->npages; i++) {
 		set_page_writeback(ow->pages[i]);
 		ow->bv[i].bv_page = ow->pages[i];
-		ow->bv[i].bv_len = min(page_offset(ow->pages[i]) + PAGE_SIZE,
-		    ow->off + ow->len) -
-		    max(ow->off, page_offset(ow->pages[i]));
+		ow->bv[i].bv_len = min(page_pos(ow->pages[i]) + PAGE_SIZE,
+				       ow->off + ow->len) -
+		    max(ow->off, page_pos(ow->pages[i]));
 		if (i == 0)
 			ow->bv[i].bv_offset = ow->off -
-			    page_offset(ow->pages[i]);
+			    page_pos(ow->pages[i]);
 		else
 			ow->bv[i].bv_offset = 0;
 	}
@@ -276,7 +276,7 @@ static int orangefs_readpage(struct file *file, struct page *page)
 	if (PageDirty(page))
 		orangefs_launder_page(page);
 
-	off = page_offset(page);
+	off = page_pos(page);
 	index = off >> PAGE_SHIFT;
 	bv.bv_page = page;
 	bv.bv_len = PAGE_SIZE;
@@ -436,7 +436,7 @@ static int orangefs_write_end(struct file *file, struct address_space *mapping,
 			zero_user(page, from + copied, len - copied);
 		}
 		/* Set fully written pages uptodate. */
-		if (pos == page_offset(page) &&
+		if (pos == page_pos(page) &&
 		    (len == PAGE_SIZE || pos + len == inode->i_size)) {
 			zero_user_segment(page, from + copied, PAGE_SIZE);
 			SetPageUptodate(page);
@@ -465,8 +465,8 @@ static void orangefs_invalidatepage(struct page *page,
 		put_page(page);
 		return;
 	/* write range entirely within invalidate range (or equal) */
-	} else if (page_offset(page) + offset <= wr->pos &&
-	    wr->pos + wr->len <= page_offset(page) + offset + length) {
+	} else if (page_pos(page) + offset <= wr->pos &&
+		   wr->pos + wr->len <= page_pos(page) + offset + length) {
 		kfree((struct orangefs_write_range *)page_private(page));
 		set_page_private(page, 0);
 		ClearPagePrivate(page);
@@ -475,29 +475,29 @@ static void orangefs_invalidatepage(struct page *page,
 		cancel_dirty_page(page);
 		return;
 	/* invalidate range chops off end of write range */
-	} else if (wr->pos < page_offset(page) + offset &&
-	    wr->pos + wr->len <= page_offset(page) + offset + length &&
-	     page_offset(page) + offset < wr->pos + wr->len) {
+	} else if (wr->pos < page_pos(page) + offset &&
+		   wr->pos + wr->len <= page_pos(page) + offset + length &&
+		   page_pos(page) + offset < wr->pos + wr->len) {
 		size_t x;
-		x = wr->pos + wr->len - (page_offset(page) + offset);
+		x = wr->pos + wr->len - (page_pos(page) + offset);
 		WARN_ON(x > wr->len);
 		wr->len -= x;
 		wr->uid = current_fsuid();
 		wr->gid = current_fsgid();
 	/* invalidate range chops off beginning of write range */
-	} else if (page_offset(page) + offset <= wr->pos &&
-	    page_offset(page) + offset + length < wr->pos + wr->len &&
-	    wr->pos < page_offset(page) + offset + length) {
+	} else if (page_pos(page) + offset <= wr->pos &&
+		   page_pos(page) + offset + length < wr->pos + wr->len &&
+		   wr->pos < page_pos(page) + offset + length) {
 		size_t x;
-		x = page_offset(page) + offset + length - wr->pos;
+		x = page_pos(page) + offset + length - wr->pos;
 		WARN_ON(x > wr->len);
 		wr->pos += x;
 		wr->len -= x;
 		wr->uid = current_fsuid();
 		wr->gid = current_fsgid();
 	/* invalidate range entirely within write range (punch hole) */
-	} else if (wr->pos < page_offset(page) + offset &&
-	    page_offset(page) + offset + length < wr->pos + wr->len) {
+	} else if (wr->pos < page_pos(page) + offset &&
+		   page_pos(page) + offset + length < wr->pos + wr->len) {
 		/* XXX what do we do here... should not WARN_ON */
 		WARN_ON(1);
 		/* punch hole */
@@ -509,11 +509,11 @@ static void orangefs_invalidatepage(struct page *page,
 	/* non-overlapping ranges */
 	} else {
 		/* WARN if they do overlap */
-		if (!((page_offset(page) + offset + length <= wr->pos) ^
-		    (wr->pos + wr->len <= page_offset(page) + offset))) {
+		if (!((page_pos(page) + offset + length <= wr->pos) ^
+		      (wr->pos + wr->len <= page_pos(page) + offset))) {
 			WARN_ON(1);
 			printk("invalidate range offset %llu length %u\n",
-			    page_offset(page) + offset, length);
+			    page_pos(page) + offset, length);
 			printk("write range offset %llu length %zu\n",
 			    wr->pos, wr->len);
 		}
@@ -721,7 +721,7 @@ vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
 		wr = (struct orangefs_write_range *)page_private(page);
 		if (uid_eq(wr->uid, current_fsuid()) &&
 		    gid_eq(wr->gid, current_fsgid())) {
-			wr->pos = page_offset(page);
+			wr->pos = page_pos(page);
 			wr->len = PAGE_SIZE;
 			goto okay;
 		} else {
@@ -736,7 +736,7 @@ vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
 		ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
 		goto out;
 	}
-	wr->pos = page_offset(page);
+	wr->pos = page_pos(page);
 	wr->len = PAGE_SIZE;
 	wr->uid = current_fsuid();
 	wr->gid = current_fsgid();
diff --git a/fs/romfs/super.c b/fs/romfs/super.c
index e582d001f792..91d7f5f3df50 100644
--- a/fs/romfs/super.c
+++ b/fs/romfs/super.c
@@ -112,7 +112,7 @@ static int romfs_readpage(struct file *file, struct page *page)
 		return -ENOMEM;
 
 	/* 32 bit warning -- but not for us :) */
-	offset = page_offset(page);
+	offset = page_pos(page);
 	size = i_size_read(inode);
 	fillsize = 0;
 	ret = 0;
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index 88e38cd8f5c9..c029ce7221b2 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -206,7 +206,7 @@ int sysv_add_link(struct dentry *dentry, struct inode *inode)
 	return -EINVAL;
 
 got_it:
-	pos = page_offset(page) +
+	pos = page_pos(page) +
 			(char*)de - (char*)page_address(page);
 	lock_page(page);
 	err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
@@ -231,7 +231,7 @@ int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page)
 {
 	struct inode *inode = page->mapping->host;
 	char *kaddr = (char*)page_address(page);
-	loff_t pos = page_offset(page) + (char *)de - kaddr;
+	loff_t pos = page_pos(page) + (char *)de - kaddr;
 	int err;
 
 	lock_page(page);
@@ -328,7 +328,7 @@ void sysv_set_link(struct sysv_dir_entry *de, struct page *page,
 	struct inode *inode)
 {
 	struct inode *dir = page->mapping->host;
-	loff_t pos = page_offset(page) +
+	loff_t pos = page_pos(page) +
 			(char *)de-(char*)page_address(page);
 	int err;
 
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 743928efffc1..e1dfc86c8c23 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1560,7 +1560,7 @@ static vm_fault_t ubifs_vm_page_mkwrite(struct vm_fault *vmf)
 
 	lock_page(page);
 	if (unlikely(page->mapping != inode->i_mapping ||
-		     page_offset(page) > i_size_read(inode))) {
+		     page_pos(page) > i_size_read(inode))) {
 		/* Page got truncated out from underneath us */
 		goto sigbus;
 	}
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index b721d0bda5e5..6eac85373b88 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -87,7 +87,7 @@ void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
 		  struct page *page, struct inode *inode,
 		  bool update_times)
 {
-	loff_t pos = page_offset(page) +
+	loff_t pos = page_pos(page) +
 			(char *) de - (char *) page_address(page);
 	unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen);
 	int err;
@@ -371,7 +371,7 @@ int ufs_add_link(struct dentry *dentry, struct inode *inode)
 	return -EINVAL;
 
 got_it:
-	pos = page_offset(page) +
+	pos = page_pos(page) +
 			(char*)de - (char*)page_address(page);
 	err = ufs_prepare_chunk(page, pos, rec_len);
 	if (err)
@@ -524,7 +524,7 @@ int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
 	if (pde)
 		from = (char*)pde - (char*)page_address(page);
 
-	pos = page_offset(page) + from;
+	pos = page_pos(page) + from;
 	lock_page(page);
 	err = ufs_prepare_chunk(page, pos, to - from);
 	BUG_ON(err);
diff --git a/fs/vboxsf/file.c b/fs/vboxsf/file.c
index c4ab5996d97a..0aebe12bc432 100644
--- a/fs/vboxsf/file.c
+++ b/fs/vboxsf/file.c
@@ -211,7 +211,7 @@ const struct inode_operations vboxsf_reg_iops = {
 static int vboxsf_readpage(struct file *file, struct page *page)
 {
 	struct vboxsf_handle *sf_handle = file->private_data;
-	loff_t off = page_offset(page);
+	loff_t off = page_pos(page);
 	u32 nread = PAGE_SIZE;
 	u8 *buf;
 	int err;
@@ -255,7 +255,7 @@ static int vboxsf_writepage(struct page *page, struct writeback_control *wbc)
 	struct inode *inode = page->mapping->host;
 	struct vboxsf_inode *sf_i = VBOXSF_I(inode);
 	struct vboxsf_handle *sf_handle;
-	loff_t off = page_offset(page);
+	loff_t off = page_pos(page);
 	loff_t size = i_size_read(inode);
 	u32 nwrite = PAGE_SIZE;
 	u8 *buf;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 9d9cebf18726..8b62cab25882 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -532,7 +532,7 @@ xfs_discard_page(
 	struct inode		*inode = page->mapping->host;
 	struct xfs_inode	*ip = XFS_I(inode);
 	struct xfs_mount	*mp = ip->i_mount;
-	loff_t			offset = page_offset(page);
+	loff_t			offset = page_pos(page);
 	xfs_fileoff_t		start_fsb = XFS_B_TO_FSBT(mp, offset);
 	int			error;
 
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index a8f7bd8ea1c6..7726b186aad6 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -432,7 +432,7 @@ static inline pgoff_t page_to_pgoff(struct page *page)
 /*
  * Return byte-offset into filesystem object for page.
  */
-static inline loff_t page_offset(struct page *page)
+static inline loff_t page_pos(struct page *page)
 {
 	return ((loff_t)page->index) << PAGE_SHIFT;
 }