]>
Commit | Line | Data |
---|---|---|
00e5a55c BS |
1 | From: Peter Zijlstra <a.p.zijlstra@chello.nl> |
2 | Subject: nfs: teach the NFS client how to treat PG_swapcache pages | |
3 | Patch-mainline: No | |
4 | References: FATE#303834 | |
5 | ||
6 | Replace all relevant occurences of page->index and page->mapping in the NFS | |
7 | client with the new page_file_index() and page_file_mapping() functions. | |
8 | ||
9 | Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl> | |
10 | Acked-by: Neil Brown <neilb@suse.de> | |
11 | Acked-by: Suresh Jayaraman <sjayaraman@suse.de> | |
12 | ||
13 | --- | |
14 | fs/nfs/file.c | 6 +++--- | |
15 | fs/nfs/internal.h | 7 ++++--- | |
16 | fs/nfs/pagelist.c | 6 +++--- | |
17 | fs/nfs/read.c | 6 +++--- | |
18 | fs/nfs/write.c | 53 +++++++++++++++++++++++++++-------------------------- | |
19 | 5 files changed, 40 insertions(+), 38 deletions(-) | |
20 | ||
21 | --- a/fs/nfs/file.c | |
22 | +++ b/fs/nfs/file.c | |
23 | @@ -413,7 +413,7 @@ static void nfs_invalidate_page(struct p | |
24 | if (offset != 0) | |
25 | return; | |
26 | /* Cancel any unstarted writes on this page */ | |
27 | - nfs_wb_page_cancel(page->mapping->host, page); | |
28 | + nfs_wb_page_cancel(page_file_mapping(page)->host, page); | |
29 | } | |
30 | ||
31 | static int nfs_release_page(struct page *page, gfp_t gfp) | |
32 | @@ -426,7 +426,7 @@ static int nfs_release_page(struct page | |
33 | ||
34 | static int nfs_launder_page(struct page *page) | |
35 | { | |
36 | - struct inode *inode = page->mapping->host; | |
37 | + struct inode *inode = page_file_mapping(page)->host; | |
38 | ||
39 | dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n", | |
40 | inode->i_ino, (long long)page_offset(page)); | |
41 | @@ -463,7 +463,7 @@ static int nfs_vm_page_mkwrite(struct vm | |
42 | (long long)page_offset(page)); | |
43 | ||
44 | lock_page(page); | |
45 | - mapping = page->mapping; | |
46 | + mapping = page_file_mapping(page); | |
47 | if (mapping != dentry->d_inode->i_mapping) | |
48 | goto out_unlock; | |
49 | ||
50 | --- a/fs/nfs/internal.h | |
51 | +++ b/fs/nfs/internal.h | |
52 | @@ -253,13 +253,14 @@ void nfs_super_set_maxbytes(struct super | |
53 | static inline | |
54 | unsigned int nfs_page_length(struct page *page) | |
55 | { | |
56 | - loff_t i_size = i_size_read(page->mapping->host); | |
57 | + loff_t i_size = i_size_read(page_file_mapping(page)->host); | |
58 | ||
59 | if (i_size > 0) { | |
60 | + pgoff_t page_index = page_file_index(page); | |
61 | pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT; | |
62 | - if (page->index < end_index) | |
63 | + if (page_index < end_index) | |
64 | return PAGE_CACHE_SIZE; | |
65 | - if (page->index == end_index) | |
66 | + if (page_index == end_index) | |
67 | return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1; | |
68 | } | |
69 | return 0; | |
70 | --- a/fs/nfs/pagelist.c | |
71 | +++ b/fs/nfs/pagelist.c | |
72 | @@ -76,11 +76,11 @@ nfs_create_request(struct nfs_open_conte | |
73 | * update_nfs_request below if the region is not locked. */ | |
74 | req->wb_page = page; | |
75 | atomic_set(&req->wb_complete, 0); | |
76 | - req->wb_index = page->index; | |
77 | + req->wb_index = page_file_index(page); | |
78 | page_cache_get(page); | |
79 | BUG_ON(PagePrivate(page)); | |
80 | BUG_ON(!PageLocked(page)); | |
81 | - BUG_ON(page->mapping->host != inode); | |
82 | + BUG_ON(page_file_mapping(page)->host != inode); | |
83 | req->wb_offset = offset; | |
84 | req->wb_pgbase = offset; | |
85 | req->wb_bytes = count; | |
86 | @@ -376,7 +376,7 @@ void nfs_pageio_cond_complete(struct nfs | |
87 | * nfs_scan_list - Scan a list for matching requests | |
88 | * @nfsi: NFS inode | |
89 | * @dst: Destination list | |
90 | - * @idx_start: lower bound of page->index to scan | |
91 | + * @idx_start: lower bound of page_file_index(page) to scan | |
92 | * @npages: idx_start + npages sets the upper bound to scan. | |
93 | * @tag: tag to scan for | |
94 | * | |
95 | --- a/fs/nfs/read.c | |
96 | +++ b/fs/nfs/read.c | |
97 | @@ -477,11 +477,11 @@ static const struct rpc_call_ops nfs_rea | |
98 | int nfs_readpage(struct file *file, struct page *page) | |
99 | { | |
100 | struct nfs_open_context *ctx; | |
101 | - struct inode *inode = page->mapping->host; | |
102 | + struct inode *inode = page_file_mapping(page)->host; | |
103 | int error; | |
104 | ||
105 | dprintk("NFS: nfs_readpage (%p %ld@%lu)\n", | |
106 | - page, PAGE_CACHE_SIZE, page->index); | |
107 | + page, PAGE_CACHE_SIZE, page_file_index(page)); | |
108 | nfs_inc_stats(inode, NFSIOS_VFSREADPAGE); | |
109 | nfs_add_stats(inode, NFSIOS_READPAGES, 1); | |
110 | ||
111 | @@ -528,7 +528,7 @@ static int | |
112 | readpage_async_filler(void *data, struct page *page) | |
113 | { | |
114 | struct nfs_readdesc *desc = (struct nfs_readdesc *)data; | |
115 | - struct inode *inode = page->mapping->host; | |
116 | + struct inode *inode = page_file_mapping(page)->host; | |
117 | struct nfs_page *new; | |
118 | unsigned int len; | |
119 | int error; | |
120 | --- a/fs/nfs/write.c | |
121 | +++ b/fs/nfs/write.c | |
122 | @@ -120,7 +120,7 @@ static struct nfs_page *nfs_page_find_re | |
123 | ||
124 | static struct nfs_page *nfs_page_find_request(struct page *page) | |
125 | { | |
126 | - struct inode *inode = page->mapping->host; | |
127 | + struct inode *inode = page_file_mapping(page)->host; | |
128 | struct nfs_page *req = NULL; | |
129 | ||
130 | spin_lock(&inode->i_lock); | |
131 | @@ -132,16 +132,16 @@ static struct nfs_page *nfs_page_find_re | |
132 | /* Adjust the file length if we're writing beyond the end */ | |
133 | static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count) | |
134 | { | |
135 | - struct inode *inode = page->mapping->host; | |
136 | + struct inode *inode = page_file_mapping(page)->host; | |
137 | loff_t end, i_size; | |
138 | pgoff_t end_index; | |
139 | ||
140 | spin_lock(&inode->i_lock); | |
141 | i_size = i_size_read(inode); | |
142 | end_index = (i_size - 1) >> PAGE_CACHE_SHIFT; | |
143 | - if (i_size > 0 && page->index < end_index) | |
144 | + if (i_size > 0 && page_file_index(page) < end_index) | |
145 | goto out; | |
146 | - end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count); | |
147 | + end = page_file_offset(page) + ((loff_t)offset+count); | |
148 | if (i_size >= end) | |
149 | goto out; | |
150 | i_size_write(inode, end); | |
151 | @@ -154,7 +154,7 @@ out: | |
152 | static void nfs_set_pageerror(struct page *page) | |
153 | { | |
154 | SetPageError(page); | |
155 | - nfs_zap_mapping(page->mapping->host, page->mapping); | |
156 | + nfs_zap_mapping(page_file_mapping(page)->host, page_file_mapping(page)); | |
157 | } | |
158 | ||
159 | /* We can set the PG_uptodate flag if we see that a write request | |
160 | @@ -195,7 +195,7 @@ static int nfs_set_page_writeback(struct | |
161 | int ret = test_set_page_writeback(page); | |
162 | ||
163 | if (!ret) { | |
164 | - struct inode *inode = page->mapping->host; | |
165 | + struct inode *inode = page_file_mapping(page)->host; | |
166 | struct nfs_server *nfss = NFS_SERVER(inode); | |
167 | ||
168 | if (atomic_long_inc_return(&nfss->writeback) > | |
169 | @@ -207,7 +207,7 @@ static int nfs_set_page_writeback(struct | |
170 | ||
171 | static void nfs_end_page_writeback(struct page *page) | |
172 | { | |
173 | - struct inode *inode = page->mapping->host; | |
174 | + struct inode *inode = page_file_mapping(page)->host; | |
175 | struct nfs_server *nfss = NFS_SERVER(inode); | |
176 | ||
177 | end_page_writeback(page); | |
178 | @@ -222,7 +222,7 @@ static void nfs_end_page_writeback(struc | |
179 | static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio, | |
180 | struct page *page) | |
181 | { | |
182 | - struct inode *inode = page->mapping->host; | |
183 | + struct inode *inode = page_file_mapping(page)->host; | |
184 | struct nfs_page *req; | |
185 | int ret; | |
186 | ||
187 | @@ -265,12 +265,12 @@ static int nfs_page_async_flush(struct n | |
188 | ||
189 | static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio) | |
190 | { | |
191 | - struct inode *inode = page->mapping->host; | |
192 | + struct inode *inode = page_file_mapping(page)->host; | |
193 | ||
194 | nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE); | |
195 | nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1); | |
196 | ||
197 | - nfs_pageio_cond_complete(pgio, page->index); | |
198 | + nfs_pageio_cond_complete(pgio, page_file_index(page)); | |
199 | return nfs_page_async_flush(pgio, page); | |
200 | } | |
201 | ||
202 | @@ -282,7 +282,7 @@ static int nfs_writepage_locked(struct p | |
203 | struct nfs_pageio_descriptor pgio; | |
204 | int err; | |
205 | ||
206 | - nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc)); | |
207 | + nfs_pageio_init_write(&pgio, page_file_mapping(page)->host, wb_priority(wbc)); | |
208 | err = nfs_do_writepage(page, wbc, &pgio); | |
209 | nfs_pageio_complete(&pgio); | |
210 | if (err < 0) | |
211 | @@ -411,7 +411,8 @@ nfs_mark_request_commit(struct nfs_page | |
212 | NFS_PAGE_TAG_COMMIT); | |
213 | spin_unlock(&inode->i_lock); | |
214 | inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS); | |
215 | - inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE); | |
216 | + inc_bdi_stat(page_file_mapping(req->wb_page)->backing_dev_info, | |
217 | + BDI_RECLAIMABLE); | |
218 | __mark_inode_dirty(inode, I_DIRTY_DATASYNC); | |
219 | } | |
220 | ||
221 | @@ -422,7 +423,7 @@ nfs_clear_request_commit(struct nfs_page | |
222 | ||
223 | if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) { | |
224 | dec_zone_page_state(page, NR_UNSTABLE_NFS); | |
225 | - dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE); | |
226 | + dec_bdi_stat(page_file_mapping(page)->backing_dev_info, BDI_RECLAIMABLE); | |
227 | return 1; | |
228 | } | |
229 | return 0; | |
230 | @@ -528,7 +529,7 @@ static void nfs_cancel_commit_list(struc | |
231 | * nfs_scan_commit - Scan an inode for commit requests | |
232 | * @inode: NFS inode to scan | |
233 | * @dst: destination list | |
234 | - * @idx_start: lower bound of page->index to scan. | |
235 | + * @idx_start: lower bound of page_file_index(page) to scan. | |
236 | * @npages: idx_start + npages sets the upper bound to scan. | |
237 | * | |
238 | * Moves requests from the inode's 'commit' request list. | |
239 | @@ -639,7 +640,7 @@ out_err: | |
240 | static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx, | |
241 | struct page *page, unsigned int offset, unsigned int bytes) | |
242 | { | |
243 | - struct inode *inode = page->mapping->host; | |
244 | + struct inode *inode = page_file_mapping(page)->host; | |
245 | struct nfs_page *req; | |
246 | int error; | |
247 | ||
248 | @@ -694,7 +695,7 @@ int nfs_flush_incompatible(struct file * | |
249 | nfs_release_request(req); | |
250 | if (!do_flush) | |
251 | return 0; | |
252 | - status = nfs_wb_page(page->mapping->host, page); | |
253 | + status = nfs_wb_page(page_file_mapping(page)->host, page); | |
254 | } while (status == 0); | |
255 | return status; | |
256 | } | |
257 | @@ -720,7 +721,7 @@ int nfs_updatepage(struct file *file, st | |
258 | unsigned int offset, unsigned int count) | |
259 | { | |
260 | struct nfs_open_context *ctx = nfs_file_open_context(file); | |
261 | - struct inode *inode = page->mapping->host; | |
262 | + struct inode *inode = page_file_mapping(page)->host; | |
263 | int status = 0; | |
264 | ||
265 | nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE); | |
266 | @@ -728,7 +729,7 @@ int nfs_updatepage(struct file *file, st | |
267 | dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n", | |
268 | file->f_path.dentry->d_parent->d_name.name, | |
269 | file->f_path.dentry->d_name.name, count, | |
270 | - (long long)(page_offset(page) + offset)); | |
271 | + (long long)(page_file_offset(page) + offset)); | |
272 | ||
273 | /* If we're not using byte range locks, and we know the page | |
274 | * is up to date, it may be more efficient to extend the write | |
275 | @@ -1003,7 +1004,7 @@ static void nfs_writeback_release_partia | |
276 | } | |
277 | ||
278 | if (nfs_write_need_commit(data)) { | |
279 | - struct inode *inode = page->mapping->host; | |
280 | + struct inode *inode = page_file_mapping(page)->host; | |
281 | ||
282 | spin_lock(&inode->i_lock); | |
283 | if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) { | |
284 | @@ -1264,7 +1265,7 @@ nfs_commit_list(struct inode *inode, str | |
285 | nfs_list_remove_request(req); | |
286 | nfs_mark_request_commit(req); | |
287 | dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS); | |
288 | - dec_bdi_stat(req->wb_page->mapping->backing_dev_info, | |
289 | + dec_bdi_stat(page_file_mapping(req->wb_page)->backing_dev_info, | |
290 | BDI_RECLAIMABLE); | |
291 | nfs_clear_page_tag_locked(req); | |
292 | } | |
293 | @@ -1455,10 +1456,10 @@ int nfs_wb_nocommit(struct inode *inode) | |
294 | int nfs_wb_page_cancel(struct inode *inode, struct page *page) | |
295 | { | |
296 | struct nfs_page *req; | |
297 | - loff_t range_start = page_offset(page); | |
298 | + loff_t range_start = page_file_offset(page); | |
299 | loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1); | |
300 | struct writeback_control wbc = { | |
301 | - .bdi = page->mapping->backing_dev_info, | |
302 | + .bdi = page_file_mapping(page)->backing_dev_info, | |
303 | .sync_mode = WB_SYNC_ALL, | |
304 | .nr_to_write = LONG_MAX, | |
305 | .range_start = range_start, | |
306 | @@ -1491,7 +1492,7 @@ int nfs_wb_page_cancel(struct inode *ino | |
307 | } | |
308 | if (!PagePrivate(page)) | |
309 | return 0; | |
310 | - ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE); | |
311 | + ret = nfs_sync_mapping_wait(page_file_mapping(page), &wbc, FLUSH_INVALIDATE); | |
312 | out: | |
313 | return ret; | |
314 | } | |
315 | @@ -1499,10 +1500,10 @@ out: | |
316 | static int nfs_wb_page_priority(struct inode *inode, struct page *page, | |
317 | int how) | |
318 | { | |
319 | - loff_t range_start = page_offset(page); | |
320 | + loff_t range_start = page_file_offset(page); | |
321 | loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1); | |
322 | struct writeback_control wbc = { | |
323 | - .bdi = page->mapping->backing_dev_info, | |
324 | + .bdi = page_file_mapping(page)->backing_dev_info, | |
325 | .sync_mode = WB_SYNC_ALL, | |
326 | .nr_to_write = LONG_MAX, | |
327 | .range_start = range_start, | |
328 | @@ -1517,7 +1518,7 @@ static int nfs_wb_page_priority(struct i | |
329 | goto out_error; | |
330 | } else if (!PagePrivate(page)) | |
331 | break; | |
332 | - ret = nfs_sync_mapping_wait(page->mapping, &wbc, how); | |
333 | + ret = nfs_sync_mapping_wait(page_file_mapping(page), &wbc, how); | |
334 | if (ret < 0) | |
335 | goto out_error; | |
336 | } while (PagePrivate(page)); |