[ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.kabi / mm-page_mkwrite-rename.patch

From: Nick Piggin <npiggin@suse.de>
Subject: mm: page_mkwrite kABI compat 1
Patch-upstream: never

Rename page_mkwrite to page_mkwrite2, put it into a union, and in that union
also add a new page_mkwrite which has the same prototype as the old one. Update
all in-tree code to use page_mkwrite2 (can't initialize anonymous unions so
it's a bit ugly :( ).

[mmarek: added __GENKSYMS__ ifdef: ->_pmkw.page_mkwrite() will be the same
 as ->page_mkwrite() in assembly, but for genksyms it's two different things.]

Signed-off-by: Nick Piggin <npiggin@suse.de>
---
 drivers/video/fb_defio.c    |    2 +-
 fs/buffer.c                 |   38 +++++++++++++++++++++++++++++++++++++-
 fs/ext4/file.c              |    2 +-
 fs/fuse/file.c              |    2 +-
 fs/gfs2/ops_file.c          |    2 +-
 fs/nfs/file.c               |    2 +-
 fs/ocfs2/mmap.c             |    2 +-
 fs/ubifs/file.c             |    2 +-
 fs/xfs/linux-2.6/xfs_file.c |    4 ++--
 include/linux/buffer_head.h |    4 +++-
 include/linux/mm.h          |   19 ++++++++++++++++---
 mm/memory.c                 |    8 ++++----
 mm/mmap.c                   |    2 +-
 13 files changed, 70 insertions(+), 19 deletions(-)

--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -112,7 +112,7 @@ page_already_added:
 
 static struct vm_operations_struct fb_deferred_io_vm_ops = {
 	.fault		= fb_deferred_io_fault,
-	.page_mkwrite	= fb_deferred_io_mkwrite,
+	._pmkw.page_mkwrite2	= fb_deferred_io_mkwrite,
 };
 
 static int fb_deferred_io_set_page_dirty(struct page *page)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2402,7 +2402,7 @@ int block_commit_write(struct page *page
  * unlock the page.
  */
 int
-block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
+block_page_mkwrite2(struct vm_area_struct *vma, struct vm_fault *vmf,
 		   get_block_t get_block)
 {
 	struct page *page = vmf->page;
@@ -2444,6 +2444,41 @@ out:
 }
 
 /*
+ * XXX: ABI hack
+ */
+int
+block_page_mkwrite(struct vm_area_struct *vma, struct page *page,
+		   get_block_t get_block)
+{
+	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+	unsigned long end;
+	loff_t size;
+	int ret = -EINVAL;
+
+	lock_page(page);
+	size = i_size_read(inode);
+	if ((page->mapping != inode->i_mapping) ||
+	    (page_offset(page) > size)) {
+		/* page got truncated out from underneath us */
+		goto out_unlock;
+	}
+
+	/* page is wholly or partially inside EOF */
+	if (((page->index + 1) << PAGE_CACHE_SHIFT) > size)
+		end = size & ~PAGE_CACHE_MASK;
+	else
+		end = PAGE_CACHE_SIZE;
+
+	ret = block_prepare_write(page, 0, end, get_block);
+	if (!ret)
+		ret = block_commit_write(page, 0, end);
+
+out_unlock:
+	unlock_page(page);
+	return ret;
+}
+
+/*
  * nobh_write_begin()'s prereads are special: the buffer_heads are freed
  * immediately, while under the page lock.  So it needs a special end_io
  * handler which does not touch the bh after unlocking it.
@@ -3362,6 +3397,7 @@ EXPORT_SYMBOL(__wait_on_buffer);
 EXPORT_SYMBOL(block_commit_write);
 EXPORT_SYMBOL(block_prepare_write);
 EXPORT_SYMBOL(block_page_mkwrite);
+EXPORT_SYMBOL(block_page_mkwrite2);
 EXPORT_SYMBOL(block_read_full_page);
 EXPORT_SYMBOL(block_sync_page);
 EXPORT_SYMBOL(block_truncate_page);
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -125,7 +125,7 @@ force_commit:
 
 static struct vm_operations_struct ext4_file_vm_ops = {
 	.fault		= filemap_fault,
-	.page_mkwrite   = ext4_page_mkwrite,
+	._pmkw.page_mkwrite2  = ext4_page_mkwrite,
 };
 
 static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1235,7 +1235,7 @@ static int fuse_page_mkwrite(struct vm_a
 static struct vm_operations_struct fuse_file_vm_ops = {
 	.close		= fuse_vma_close,
 	.fault		= filemap_fault,
-	.page_mkwrite	= fuse_page_mkwrite,
+	._pmkw.page_mkwrite2	= fuse_page_mkwrite,
 };
 
 static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/ops_file.c
@@ -421,7 +421,7 @@ out:
 
 static struct vm_operations_struct gfs2_vm_ops = {
 	.fault = filemap_fault,
-	.page_mkwrite = gfs2_page_mkwrite,
+	._pmkw.page_mkwrite2 = gfs2_page_mkwrite,
 };
 
 
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -486,7 +486,7 @@ out_unlock:
 
 static struct vm_operations_struct nfs_file_vm_ops = {
 	.fault = filemap_fault,
-	.page_mkwrite = nfs_vm_page_mkwrite,
+	._pmkw.page_mkwrite2 = nfs_vm_page_mkwrite,
 };
 
 static int nfs_need_sync_write(struct file *filp, struct inode *inode)
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -200,7 +200,7 @@ out:
 
 static struct vm_operations_struct ocfs2_file_vm_ops = {
 	.fault		= ocfs2_fault,
-	.page_mkwrite	= ocfs2_page_mkwrite,
+	._pmkw.page_mkwrite2	= ocfs2_page_mkwrite,
 };
 
 int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1234,7 +1234,7 @@ out_unlock:
 
 static struct vm_operations_struct ubifs_file_vm_ops = {
 	.fault        = filemap_fault,
-	.page_mkwrite = ubifs_vm_page_mkwrite,
+	._pmkw.page_mkwrite2 = ubifs_vm_page_mkwrite,
 };
 
 static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma)
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -429,7 +429,7 @@ xfs_vm_page_mkwrite(
 	struct vm_area_struct	*vma,
 	struct vm_fault		*vmf)
 {
-	return block_page_mkwrite(vma, vmf, xfs_get_blocks);
+	return block_page_mkwrite2(vma, vmf, xfs_get_blocks);
 }
 
 const struct file_operations xfs_file_operations = {
@@ -485,5 +485,5 @@ const struct file_operations xfs_dir_fil
 
 static struct vm_operations_struct xfs_file_vm_ops = {
 	.fault		= filemap_fault,
-	.page_mkwrite	= xfs_vm_page_mkwrite,
+	._pmkw.page_mkwrite2	= xfs_vm_page_mkwrite,
 };
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -222,7 +222,9 @@ int cont_write_begin(struct file *, stru
 			get_block_t *, loff_t *);
 int generic_cont_expand_simple(struct inode *inode, loff_t size);
 int block_commit_write(struct page *page, unsigned from, unsigned to);
-int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
+int block_page_mkwrite(struct vm_area_struct *vma, struct page *page,
+				get_block_t get_block);
+int block_page_mkwrite2(struct vm_area_struct *vma, struct vm_fault *vmf,
 				get_block_t get_block);
 void block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -172,9 +172,22 @@ struct vm_operations_struct {
 	void (*close)(struct vm_area_struct * area);
 	int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);
 
-	/* notification that a previously read-only page is about to become
-	 * writable, if an error is returned it will cause a SIGBUS */
-	int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);
+#ifdef __GENKSYMS__
+	int (*page_mkwrite)(struct vm_area_struct *, struct page *);
+#else
+	union {
+		/*
+		 * XXX: this is an ABI compatibility hack.
+		 * Using the fixed page_mkwrite2 call requires VM_PAGE_MKWRITE2 to be
+		 * set in vma->vm_flags
+		 */
+
+		/* notification that a previously read-only page is about to become
+		 * writable, if an error is returned it will cause a SIGBUS */
+		int (*page_mkwrite)(struct vm_area_struct *, struct page *);
+		int (*page_mkwrite2)(struct vm_area_struct *vma, struct vm_fault *vmf);
+	} _pmkw;
+#endif
 
 	/* called by access_process_vm when get_user_pages() fails, typically
 	 * for use by special VMAs that can switch between memory and hardware
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -1800,7 +1800,7 @@ static int do_wp_page(struct mm_struct *
 		 * read-only shared pages can get COWed by
 		 * get_user_pages(.write=1, .force=1).
 		 */
-		if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
+		if (vma->vm_ops && vma->vm_ops->_pmkw.page_mkwrite2) {
 			struct vm_fault vmf;
 			int tmp;
 
@@ -1821,7 +1821,7 @@ static int do_wp_page(struct mm_struct *
 			page_cache_get(old_page);
 			pte_unmap_unlock(page_table, ptl);
 
-			tmp = vma->vm_ops->page_mkwrite(vma, &vmf);
+			tmp = vma->vm_ops->_pmkw.page_mkwrite2(vma, &vmf);
 			if (unlikely(tmp &
 					(VM_FAULT_ERROR | VM_FAULT_NOPAGE))) {
 				ret = tmp;
@@ -2517,12 +2517,12 @@ static int __do_fault(struct mm_struct *
 			 * address space wants to know that the page is about
 			 * to become writable
 			 */
-			if (vma->vm_ops->page_mkwrite) {
+			if (vma->vm_ops->_pmkw.page_mkwrite2) {
 				int tmp;
 
 				unlock_page(page);
 				vmf.flags = FAULT_FLAG_WRITE|FAULT_FLAG_MKWRITE;
-				tmp = vma->vm_ops->page_mkwrite(vma, &vmf);
+				tmp = vma->vm_ops->_pmkw.page_mkwrite2(vma, &vmf);
 				if (unlikely(tmp &
 					  (VM_FAULT_ERROR | VM_FAULT_NOPAGE))) {
 					ret = tmp;
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -1074,7 +1074,7 @@ int vma_wants_writenotify(struct vm_area
 		return 0;
 
 	/* The backer wishes to know when pages are first written to? */
-	if (vma->vm_ops && vma->vm_ops->page_mkwrite)
+	if (vma->vm_ops && vma->vm_ops->_pmkw.page_mkwrite)
 		return 1;
 
 	/* The open routine did something to the protections already? */
Commit	Line	Data
2cb7cef9 BS	1	From: Nick Piggin <npiggin@suse.de>
	2	Subject: mm: page_mkwrite kABI compat 1
	3	Patch-upstream: never
	4
	5	Rename page_mkwrite to page_mkwrite2, put it into a union, and in that union
	6	also add a new page_mkwrite which has the same prototype as the old one. Update
	7	all in-tree code to use page_mkwrite2 (can't initialize anonymous unions so
	8	it's a bit ugly :( ).
	9
	10	[mmarek: added __GENKSYMS__ ifdef: ->_pmkw.page_mkwrite() will be the same
	11	as ->page_mkwrite() in assembly, but for genksyms it's two different things.]
	12
	13	Signed-off-by: Nick Piggin <npiggin@suse.de>
	14	---
	15	drivers/video/fb_defio.c \| 2 +-
	16	fs/buffer.c \| 38 +++++++++++++++++++++++++++++++++++++-
	17	fs/ext4/file.c \| 2 +-
	18	fs/fuse/file.c \| 2 +-
	19	fs/gfs2/ops_file.c \| 2 +-
	20	fs/nfs/file.c \| 2 +-
	21	fs/ocfs2/mmap.c \| 2 +-
	22	fs/ubifs/file.c \| 2 +-
	23	fs/xfs/linux-2.6/xfs_file.c \| 4 ++--
	24	include/linux/buffer_head.h \| 4 +++-
	25	include/linux/mm.h \| 19 ++++++++++++++++---
	26	mm/memory.c \| 8 ++++----
	27	mm/mmap.c \| 2 +-
	28	13 files changed, 70 insertions(+), 19 deletions(-)
	29
	30	--- a/drivers/video/fb_defio.c
	31	+++ b/drivers/video/fb_defio.c
	32	@@ -112,7 +112,7 @@ page_already_added:
	33
	34	static struct vm_operations_struct fb_deferred_io_vm_ops = {
	35	.fault = fb_deferred_io_fault,
	36	- .page_mkwrite = fb_deferred_io_mkwrite,
	37	+ ._pmkw.page_mkwrite2 = fb_deferred_io_mkwrite,
	38	};
	39
	40	static int fb_deferred_io_set_page_dirty(struct page *page)
	41	--- a/fs/buffer.c
	42	+++ b/fs/buffer.c
	43	@@ -2402,7 +2402,7 @@ int block_commit_write(struct page *page
	44	* unlock the page.
	45	*/
	46	int
	47	-block_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf,
	48	+block_page_mkwrite2(struct vm_area_struct vma, struct vm_fault vmf,
	49	get_block_t get_block)
	50	{
	51	struct page *page = vmf->page;
	52	@@ -2444,6 +2444,41 @@ out:
	53	}
	54
	55	/*
	56	+ * XXX: ABI hack
	57	+ */
	58	+int
	59	+block_page_mkwrite(struct vm_area_struct vma, struct page page,
	60	+ get_block_t get_block)
	61	+{
	62	+ struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
	63	+ unsigned long end;
	64	+ loff_t size;
65	+ int ret = -EINVAL;
66	+
67	+ lock_page(page);
68	+ size = i_size_read(inode);
69	+ if ((page->mapping != inode->i_mapping) \|\|
70	+ (page_offset(page) > size)) {
71	+ /* page got truncated out from underneath us */
72	+ goto out_unlock;
73	+ }
74	+
75	+ /* page is wholly or partially inside EOF */
76	+ if (((page->index + 1) << PAGE_CACHE_SHIFT) > size)
77	+ end = size & ~PAGE_CACHE_MASK;
78	+ else
79	+ end = PAGE_CACHE_SIZE;
80	+
81	+ ret = block_prepare_write(page, 0, end, get_block);
82	+ if (!ret)
83	+ ret = block_commit_write(page, 0, end);
84	+
85	+out_unlock:
86	+ unlock_page(page);
87	+ return ret;
88	+}
89	+
90	+/*
91	* nobh_write_begin()'s prereads are special: the buffer_heads are freed
92	* immediately, while under the page lock. So it needs a special end_io
93	* handler which does not touch the bh after unlocking it.
94	@@ -3362,6 +3397,7 @@ EXPORT_SYMBOL(__wait_on_buffer);
95	EXPORT_SYMBOL(block_commit_write);
96	EXPORT_SYMBOL(block_prepare_write);
97	EXPORT_SYMBOL(block_page_mkwrite);
98	+EXPORT_SYMBOL(block_page_mkwrite2);
99	EXPORT_SYMBOL(block_read_full_page);
100	EXPORT_SYMBOL(block_sync_page);
101	EXPORT_SYMBOL(block_truncate_page);
102	--- a/fs/ext4/file.c
103	+++ b/fs/ext4/file.c
104	@@ -125,7 +125,7 @@ force_commit:
105
106	static struct vm_operations_struct ext4_file_vm_ops = {
107	.fault = filemap_fault,
108	- .page_mkwrite = ext4_page_mkwrite,
109	+ ._pmkw.page_mkwrite2 = ext4_page_mkwrite,
110	};
111
112	static int ext4_file_mmap(struct file file, struct vm_area_struct vma)
113	--- a/fs/fuse/file.c
114	+++ b/fs/fuse/file.c
115	@@ -1235,7 +1235,7 @@ static int fuse_page_mkwrite(struct vm_a
116	static struct vm_operations_struct fuse_file_vm_ops = {
117	.close = fuse_vma_close,
118	.fault = filemap_fault,
119	- .page_mkwrite = fuse_page_mkwrite,
120	+ ._pmkw.page_mkwrite2 = fuse_page_mkwrite,
121	};
122
123	static int fuse_file_mmap(struct file file, struct vm_area_struct vma)
124	--- a/fs/gfs2/ops_file.c
125	+++ b/fs/gfs2/ops_file.c
126	@@ -421,7 +421,7 @@ out:
127
128	static struct vm_operations_struct gfs2_vm_ops = {
129	.fault = filemap_fault,
130	- .page_mkwrite = gfs2_page_mkwrite,
131	+ ._pmkw.page_mkwrite2 = gfs2_page_mkwrite,
132	};
133
134
135	--- a/fs/nfs/file.c
136	+++ b/fs/nfs/file.c
137	@@ -486,7 +486,7 @@ out_unlock:
138
139	static struct vm_operations_struct nfs_file_vm_ops = {
140	.fault = filemap_fault,
141	- .page_mkwrite = nfs_vm_page_mkwrite,
142	+ ._pmkw.page_mkwrite2 = nfs_vm_page_mkwrite,
143	};
144
145	static int nfs_need_sync_write(struct file filp, struct inode inode)
146	--- a/fs/ocfs2/mmap.c
147	+++ b/fs/ocfs2/mmap.c
148	@@ -200,7 +200,7 @@ out:
149
150	static struct vm_operations_struct ocfs2_file_vm_ops = {
151	.fault = ocfs2_fault,
152	- .page_mkwrite = ocfs2_page_mkwrite,
153	+ ._pmkw.page_mkwrite2 = ocfs2_page_mkwrite,
154	};
155
156	int ocfs2_mmap(struct file file, struct vm_area_struct vma)
157	--- a/fs/ubifs/file.c
158	+++ b/fs/ubifs/file.c
159	@@ -1234,7 +1234,7 @@ out_unlock:
160
161	static struct vm_operations_struct ubifs_file_vm_ops = {
162	.fault = filemap_fault,
163	- .page_mkwrite = ubifs_vm_page_mkwrite,
164	+ ._pmkw.page_mkwrite2 = ubifs_vm_page_mkwrite,
165	};
166
167	static int ubifs_file_mmap(struct file file, struct vm_area_struct vma)
168	--- a/fs/xfs/linux-2.6/xfs_file.c
169	+++ b/fs/xfs/linux-2.6/xfs_file.c
170	@@ -429,7 +429,7 @@ xfs_vm_page_mkwrite(
171	struct vm_area_struct *vma,
172	struct vm_fault *vmf)
173	{
174	- return block_page_mkwrite(vma, vmf, xfs_get_blocks);
175	+ return block_page_mkwrite2(vma, vmf, xfs_get_blocks);
176	}
177
178	const struct file_operations xfs_file_operations = {
179	@@ -485,5 +485,5 @@ const struct file_operations xfs_dir_fil
180
181	static struct vm_operations_struct xfs_file_vm_ops = {
182	.fault = filemap_fault,
183	- .page_mkwrite = xfs_vm_page_mkwrite,
184	+ ._pmkw.page_mkwrite2 = xfs_vm_page_mkwrite,
185	};
186	--- a/include/linux/buffer_head.h
187	+++ b/include/linux/buffer_head.h
188	@@ -222,7 +222,9 @@ int cont_write_begin(struct file *, stru
189	get_block_t , loff_t );
190	int generic_cont_expand_simple(struct inode *inode, loff_t size);
191	int block_commit_write(struct page *page, unsigned from, unsigned to);
192	-int block_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf,
193	+int block_page_mkwrite(struct vm_area_struct vma, struct page page,
194	+ get_block_t get_block);
195	+int block_page_mkwrite2(struct vm_area_struct vma, struct vm_fault vmf,
196	get_block_t get_block);
197	void block_sync_page(struct page *);
198	sector_t generic_block_bmap(struct address_space , sector_t, get_block_t );
199	--- a/include/linux/mm.h
200	+++ b/include/linux/mm.h
201	@@ -172,9 +172,22 @@ struct vm_operations_struct {
202	void (close)(struct vm_area_struct area);
203	int (fault)(struct vm_area_struct vma, struct vm_fault *vmf);
204
205	- /* notification that a previously read-only page is about to become
206	- * writable, if an error is returned it will cause a SIGBUS */
207	- int (page_mkwrite)(struct vm_area_struct vma, struct vm_fault *vmf);
208	+#ifdef __GENKSYMS__
209	+ int (page_mkwrite)(struct vm_area_struct , struct page *);
210	+#else
211	+ union {
212	+ /*
213	+ * XXX: this is an ABI compatibility hack.
214	+ * Using the fixed page_mkwrite2 call requires VM_PAGE_MKWRITE2 to be
215	+ * set in vma->vm_flags
216	+ */
217	+
218	+ /* notification that a previously read-only page is about to become
219	+ * writable, if an error is returned it will cause a SIGBUS */
220	+ int (page_mkwrite)(struct vm_area_struct , struct page *);
221	+ int (page_mkwrite2)(struct vm_area_struct vma, struct vm_fault *vmf);
222	+ } _pmkw;
223	+#endif
224
225	/* called by access_process_vm when get_user_pages() fails, typically
226	* for use by special VMAs that can switch between memory and hardware
227	--- a/mm/memory.c
228	+++ b/mm/memory.c
229	@@ -1800,7 +1800,7 @@ static int do_wp_page(struct mm_struct *
230	* read-only shared pages can get COWed by
231	* get_user_pages(.write=1, .force=1).
232	*/
233	- if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
234	+ if (vma->vm_ops && vma->vm_ops->_pmkw.page_mkwrite2) {
235	struct vm_fault vmf;
236	int tmp;
237
238	@@ -1821,7 +1821,7 @@ static int do_wp_page(struct mm_struct *
239	page_cache_get(old_page);
240	pte_unmap_unlock(page_table, ptl);
241
242	- tmp = vma->vm_ops->page_mkwrite(vma, &vmf);
243	+ tmp = vma->vm_ops->_pmkw.page_mkwrite2(vma, &vmf);
244	if (unlikely(tmp &
245	(VM_FAULT_ERROR \| VM_FAULT_NOPAGE))) {
246	ret = tmp;
247	@@ -2517,12 +2517,12 @@ static int __do_fault(struct mm_struct *
248	* address space wants to know that the page is about
249	* to become writable
250	*/
251	- if (vma->vm_ops->page_mkwrite) {
252	+ if (vma->vm_ops->_pmkw.page_mkwrite2) {
253	int tmp;
254
255	unlock_page(page);
256	vmf.flags = FAULT_FLAG_WRITE\|FAULT_FLAG_MKWRITE;
257	- tmp = vma->vm_ops->page_mkwrite(vma, &vmf);
258	+ tmp = vma->vm_ops->_pmkw.page_mkwrite2(vma, &vmf);
259	if (unlikely(tmp &
260	(VM_FAULT_ERROR \| VM_FAULT_NOPAGE))) {
261	ret = tmp;
262	--- a/mm/mmap.c
263	+++ b/mm/mmap.c
264	@@ -1074,7 +1074,7 @@ int vma_wants_writenotify(struct vm_area
265	return 0;
266
267	/* The backer wishes to know when pages are first written to? */
268	- if (vma->vm_ops && vma->vm_ops->page_mkwrite)
269	+ if (vma->vm_ops && vma->vm_ops->_pmkw.page_mkwrite)
270	return 1;
271
272	/* The open routine did something to the protections already? */