]>
Commit | Line | Data |
---|---|---|
7336d0e6 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b3b94faa DT |
2 | /* |
3 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | |
7eabb77e | 4 | * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. |
b3b94faa DT |
5 | */ |
6 | ||
7 | #include <linux/sched.h> | |
8 | #include <linux/slab.h> | |
9 | #include <linux/spinlock.h> | |
10 | #include <linux/completion.h> | |
11 | #include <linux/buffer_head.h> | |
12 | #include <linux/pagemap.h> | |
fd88de56 | 13 | #include <linux/pagevec.h> |
9b124fbb | 14 | #include <linux/mpage.h> |
d1665e41 | 15 | #include <linux/fs.h> |
a8d638e3 | 16 | #include <linux/writeback.h> |
7765ec26 | 17 | #include <linux/swap.h> |
5c676f6d | 18 | #include <linux/gfs2_ondisk.h> |
47e83b50 | 19 | #include <linux/backing-dev.h> |
e2e40f2c | 20 | #include <linux/uio.h> |
774016b2 | 21 | #include <trace/events/writeback.h> |
64bc06bb | 22 | #include <linux/sched/signal.h> |
b3b94faa DT |
23 | |
24 | #include "gfs2.h" | |
5c676f6d | 25 | #include "incore.h" |
b3b94faa DT |
26 | #include "bmap.h" |
27 | #include "glock.h" | |
28 | #include "inode.h" | |
b3b94faa DT |
29 | #include "log.h" |
30 | #include "meta_io.h" | |
b3b94faa DT |
31 | #include "quota.h" |
32 | #include "trans.h" | |
18ec7d5c | 33 | #include "rgrp.h" |
cd81a4ba | 34 | #include "super.h" |
5c676f6d | 35 | #include "util.h" |
4340fe62 | 36 | #include "glops.h" |
64bc06bb | 37 | #include "aops.h" |
b3b94faa | 38 | |
ba7f7290 | 39 | |
64bc06bb AG |
40 | void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page, |
41 | unsigned int from, unsigned int len) | |
ba7f7290 SW |
42 | { |
43 | struct buffer_head *head = page_buffers(page); | |
44 | unsigned int bsize = head->b_size; | |
45 | struct buffer_head *bh; | |
88b65ce5 | 46 | unsigned int to = from + len; |
ba7f7290 SW |
47 | unsigned int start, end; |
48 | ||
49 | for (bh = head, start = 0; bh != head || !start; | |
50 | bh = bh->b_this_page, start = end) { | |
51 | end = start + bsize; | |
88b65ce5 | 52 | if (end <= from) |
ba7f7290 | 53 | continue; |
88b65ce5 AG |
54 | if (start >= to) |
55 | break; | |
845802b1 | 56 | set_buffer_uptodate(bh); |
350a9b0a | 57 | gfs2_trans_add_data(ip->i_gl, bh); |
ba7f7290 SW |
58 | } |
59 | } | |
60 | ||
b3b94faa | 61 | /** |
7a6bbacb | 62 | * gfs2_get_block_noalloc - Fills in a buffer head with details about a block |
b3b94faa DT |
63 | * @inode: The inode |
64 | * @lblock: The block number to look up | |
65 | * @bh_result: The buffer head to return the result in | |
66 | * @create: Non-zero if we may add block to the file | |
67 | * | |
68 | * Returns: errno | |
69 | */ | |
70 | ||
7a6bbacb SW |
71 | static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock, |
72 | struct buffer_head *bh_result, int create) | |
b3b94faa | 73 | { |
b3b94faa DT |
74 | int error; |
75 | ||
e9e1ef2b | 76 | error = gfs2_block_map(inode, lblock, bh_result, 0); |
b3b94faa DT |
77 | if (error) |
78 | return error; | |
de986e85 | 79 | if (!buffer_mapped(bh_result)) |
7a6bbacb SW |
80 | return -EIO; |
81 | return 0; | |
b3b94faa DT |
82 | } |
83 | ||
b3b94faa | 84 | /** |
59c01c50 CH |
85 | * gfs2_writepage - Write page for writeback mappings |
86 | * @page: The page | |
9ff8ec32 | 87 | * @wbc: The writeback control |
b3b94faa | 88 | */ |
59c01c50 | 89 | static int gfs2_writepage(struct page *page, struct writeback_control *wbc) |
b3b94faa | 90 | { |
18ec7d5c | 91 | struct inode *inode = page->mapping->host; |
f4387149 SW |
92 | struct gfs2_inode *ip = GFS2_I(inode); |
93 | struct gfs2_sbd *sdp = GFS2_SB(inode); | |
18ec7d5c | 94 | loff_t i_size = i_size_read(inode); |
09cbfeaf | 95 | pgoff_t end_index = i_size >> PAGE_SHIFT; |
18ec7d5c | 96 | unsigned offset; |
b3b94faa | 97 | |
9ff8ec32 SW |
98 | if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) |
99 | goto out; | |
5c676f6d | 100 | if (current->journal_info) |
9ff8ec32 | 101 | goto redirty; |
18ec7d5c | 102 | /* Is the page fully outside i_size? (truncate in progress) */ |
09cbfeaf | 103 | offset = i_size & (PAGE_SIZE-1); |
d2d7b8a2 | 104 | if (page->index > end_index || (page->index == end_index && !offset)) { |
09cbfeaf | 105 | page->mapping->a_ops->invalidatepage(page, 0, PAGE_SIZE); |
9ff8ec32 | 106 | goto out; |
b3b94faa | 107 | } |
59c01c50 CH |
108 | |
109 | return nobh_writepage(page, gfs2_get_block_noalloc, wbc); | |
110 | ||
9ff8ec32 SW |
111 | redirty: |
112 | redirty_page_for_writepage(wbc, page); | |
113 | out: | |
114 | unlock_page(page); | |
115 | return 0; | |
116 | } | |
117 | ||
fd4c5748 BM |
118 | /* This is the same as calling block_write_full_page, but it also |
119 | * writes pages outside of i_size | |
120 | */ | |
c548a1c1 AP |
121 | static int gfs2_write_full_page(struct page *page, get_block_t *get_block, |
122 | struct writeback_control *wbc) | |
fd4c5748 BM |
123 | { |
124 | struct inode * const inode = page->mapping->host; | |
125 | loff_t i_size = i_size_read(inode); | |
126 | const pgoff_t end_index = i_size >> PAGE_SHIFT; | |
127 | unsigned offset; | |
128 | ||
129 | /* | |
130 | * The page straddles i_size. It must be zeroed out on each and every | |
131 | * writepage invocation because it may be mmapped. "A file is mapped | |
132 | * in multiples of the page size. For a file that is not a multiple of | |
133 | * the page size, the remaining memory is zeroed when mapped, and | |
134 | * writes to that region are not written out to the file." | |
135 | */ | |
136 | offset = i_size & (PAGE_SIZE-1); | |
137 | if (page->index == end_index && offset) | |
138 | zero_user_segment(page, offset, PAGE_SIZE); | |
139 | ||
140 | return __block_write_full_page(inode, page, get_block, wbc, | |
141 | end_buffer_async_write); | |
142 | } | |
143 | ||
b8e7cbb6 SW |
144 | /** |
145 | * __gfs2_jdata_writepage - The core of jdata writepage | |
146 | * @page: The page to write | |
147 | * @wbc: The writeback control | |
148 | * | |
149 | * This is shared between writepage and writepages and implements the | |
150 | * core of the writepage operation. If a transaction is required then | |
151 | * PageChecked will have been set and the transaction will have | |
152 | * already been started before this is called. | |
153 | */ | |
154 | ||
155 | static int __gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc) | |
156 | { | |
157 | struct inode *inode = page->mapping->host; | |
158 | struct gfs2_inode *ip = GFS2_I(inode); | |
159 | struct gfs2_sbd *sdp = GFS2_SB(inode); | |
160 | ||
161 | if (PageChecked(page)) { | |
162 | ClearPageChecked(page); | |
163 | if (!page_has_buffers(page)) { | |
164 | create_empty_buffers(page, inode->i_sb->s_blocksize, | |
47a9a527 | 165 | BIT(BH_Dirty)|BIT(BH_Uptodate)); |
b8e7cbb6 | 166 | } |
88b65ce5 | 167 | gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize); |
b8e7cbb6 | 168 | } |
fd4c5748 | 169 | return gfs2_write_full_page(page, gfs2_get_block_noalloc, wbc); |
b8e7cbb6 SW |
170 | } |
171 | ||
9ff8ec32 SW |
172 | /** |
173 | * gfs2_jdata_writepage - Write complete page | |
174 | * @page: Page to write | |
1272574b | 175 | * @wbc: The writeback control |
9ff8ec32 SW |
176 | * |
177 | * Returns: errno | |
178 | * | |
179 | */ | |
180 | ||
181 | static int gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc) | |
182 | { | |
183 | struct inode *inode = page->mapping->host; | |
fd4c5748 | 184 | struct gfs2_inode *ip = GFS2_I(inode); |
9ff8ec32 | 185 | struct gfs2_sbd *sdp = GFS2_SB(inode); |
1bb7322f | 186 | int ret; |
9ff8ec32 | 187 | |
fd4c5748 BM |
188 | if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) |
189 | goto out; | |
190 | if (PageChecked(page) || current->journal_info) | |
191 | goto out_ignore; | |
192 | ret = __gfs2_jdata_writepage(page, wbc); | |
1bb7322f | 193 | return ret; |
18ec7d5c SW |
194 | |
195 | out_ignore: | |
196 | redirty_page_for_writepage(wbc, page); | |
fd4c5748 | 197 | out: |
18ec7d5c SW |
198 | unlock_page(page); |
199 | return 0; | |
b3b94faa DT |
200 | } |
201 | ||
a8d638e3 | 202 | /** |
45138990 | 203 | * gfs2_writepages - Write a bunch of dirty pages back to disk |
a8d638e3 SW |
204 | * @mapping: The mapping to write |
205 | * @wbc: Write-back control | |
206 | * | |
45138990 | 207 | * Used for both ordered and writeback modes. |
a8d638e3 | 208 | */ |
45138990 SW |
209 | static int gfs2_writepages(struct address_space *mapping, |
210 | struct writeback_control *wbc) | |
a8d638e3 | 211 | { |
b066a4ee AD |
212 | struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping); |
213 | int ret = mpage_writepages(mapping, wbc, gfs2_get_block_noalloc); | |
214 | ||
215 | /* | |
216 | * Even if we didn't write any pages here, we might still be holding | |
217 | * dirty pages in the ail. We forcibly flush the ail because we don't | |
218 | * want balance_dirty_pages() to loop indefinitely trying to write out | |
219 | * pages held in the ail that it can't find. | |
220 | */ | |
221 | if (ret == 0) | |
222 | set_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags); | |
223 | ||
224 | return ret; | |
a8d638e3 SW |
225 | } |
226 | ||
b8e7cbb6 SW |
227 | /** |
228 | * gfs2_write_jdata_pagevec - Write back a pagevec's worth of pages | |
229 | * @mapping: The mapping | |
230 | * @wbc: The writeback control | |
b8e7cbb6 SW |
231 | * @pvec: The vector of pages |
232 | * @nr_pages: The number of pages to write | |
1272574b | 233 | * @done_index: Page index |
b8e7cbb6 SW |
234 | * |
235 | * Returns: non-zero if loop should terminate, zero otherwise | |
236 | */ | |
237 | ||
238 | static int gfs2_write_jdata_pagevec(struct address_space *mapping, | |
239 | struct writeback_control *wbc, | |
240 | struct pagevec *pvec, | |
9aa01593 | 241 | int nr_pages, |
774016b2 | 242 | pgoff_t *done_index) |
b8e7cbb6 SW |
243 | { |
244 | struct inode *inode = mapping->host; | |
245 | struct gfs2_sbd *sdp = GFS2_SB(inode); | |
09cbfeaf | 246 | unsigned nrblocks = nr_pages * (PAGE_SIZE/inode->i_sb->s_blocksize); |
b8e7cbb6 SW |
247 | int i; |
248 | int ret; | |
249 | ||
20b95bf2 | 250 | ret = gfs2_trans_begin(sdp, nrblocks, nrblocks); |
b8e7cbb6 SW |
251 | if (ret < 0) |
252 | return ret; | |
253 | ||
254 | for(i = 0; i < nr_pages; i++) { | |
255 | struct page *page = pvec->pages[i]; | |
256 | ||
774016b2 SW |
257 | *done_index = page->index; |
258 | ||
b8e7cbb6 SW |
259 | lock_page(page); |
260 | ||
261 | if (unlikely(page->mapping != mapping)) { | |
774016b2 | 262 | continue_unlock: |
b8e7cbb6 SW |
263 | unlock_page(page); |
264 | continue; | |
265 | } | |
266 | ||
774016b2 SW |
267 | if (!PageDirty(page)) { |
268 | /* someone wrote it for us */ | |
269 | goto continue_unlock; | |
b8e7cbb6 SW |
270 | } |
271 | ||
774016b2 SW |
272 | if (PageWriteback(page)) { |
273 | if (wbc->sync_mode != WB_SYNC_NONE) | |
274 | wait_on_page_writeback(page); | |
275 | else | |
276 | goto continue_unlock; | |
b8e7cbb6 SW |
277 | } |
278 | ||
774016b2 SW |
279 | BUG_ON(PageWriteback(page)); |
280 | if (!clear_page_dirty_for_io(page)) | |
281 | goto continue_unlock; | |
282 | ||
de1414a6 | 283 | trace_wbc_writepage(wbc, inode_to_bdi(inode)); |
b8e7cbb6 SW |
284 | |
285 | ret = __gfs2_jdata_writepage(page, wbc); | |
774016b2 SW |
286 | if (unlikely(ret)) { |
287 | if (ret == AOP_WRITEPAGE_ACTIVATE) { | |
288 | unlock_page(page); | |
289 | ret = 0; | |
290 | } else { | |
291 | ||
292 | /* | |
293 | * done_index is set past this page, | |
294 | * so media errors will not choke | |
295 | * background writeout for the entire | |
296 | * file. This has consequences for | |
297 | * range_cyclic semantics (ie. it may | |
298 | * not be suitable for data integrity | |
299 | * writeout). | |
300 | */ | |
301 | *done_index = page->index + 1; | |
302 | ret = 1; | |
303 | break; | |
304 | } | |
305 | } | |
b8e7cbb6 | 306 | |
774016b2 SW |
307 | /* |
308 | * We stop writing back only if we are not doing | |
309 | * integrity sync. In case of integrity sync we have to | |
310 | * keep going until we have written all the pages | |
311 | * we tagged for writeback prior to entering this loop. | |
312 | */ | |
313 | if (--wbc->nr_to_write <= 0 && wbc->sync_mode == WB_SYNC_NONE) { | |
b8e7cbb6 | 314 | ret = 1; |
774016b2 SW |
315 | break; |
316 | } | |
317 | ||
b8e7cbb6 SW |
318 | } |
319 | gfs2_trans_end(sdp); | |
320 | return ret; | |
321 | } | |
322 | ||
323 | /** | |
324 | * gfs2_write_cache_jdata - Like write_cache_pages but different | |
325 | * @mapping: The mapping to write | |
326 | * @wbc: The writeback control | |
b8e7cbb6 SW |
327 | * |
328 | * The reason that we use our own function here is that we need to | |
329 | * start transactions before we grab page locks. This allows us | |
330 | * to get the ordering right. | |
331 | */ | |
332 | ||
333 | static int gfs2_write_cache_jdata(struct address_space *mapping, | |
334 | struct writeback_control *wbc) | |
335 | { | |
b8e7cbb6 SW |
336 | int ret = 0; |
337 | int done = 0; | |
338 | struct pagevec pvec; | |
339 | int nr_pages; | |
774016b2 | 340 | pgoff_t uninitialized_var(writeback_index); |
b8e7cbb6 SW |
341 | pgoff_t index; |
342 | pgoff_t end; | |
774016b2 SW |
343 | pgoff_t done_index; |
344 | int cycled; | |
b8e7cbb6 | 345 | int range_whole = 0; |
10bbd235 | 346 | xa_mark_t tag; |
b8e7cbb6 | 347 | |
86679820 | 348 | pagevec_init(&pvec); |
b8e7cbb6 | 349 | if (wbc->range_cyclic) { |
774016b2 SW |
350 | writeback_index = mapping->writeback_index; /* prev offset */ |
351 | index = writeback_index; | |
352 | if (index == 0) | |
353 | cycled = 1; | |
354 | else | |
355 | cycled = 0; | |
b8e7cbb6 SW |
356 | end = -1; |
357 | } else { | |
09cbfeaf KS |
358 | index = wbc->range_start >> PAGE_SHIFT; |
359 | end = wbc->range_end >> PAGE_SHIFT; | |
b8e7cbb6 SW |
360 | if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) |
361 | range_whole = 1; | |
774016b2 | 362 | cycled = 1; /* ignore range_cyclic tests */ |
b8e7cbb6 | 363 | } |
774016b2 SW |
364 | if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) |
365 | tag = PAGECACHE_TAG_TOWRITE; | |
366 | else | |
367 | tag = PAGECACHE_TAG_DIRTY; | |
b8e7cbb6 SW |
368 | |
369 | retry: | |
774016b2 SW |
370 | if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) |
371 | tag_pages_for_writeback(mapping, index, end); | |
372 | done_index = index; | |
373 | while (!done && (index <= end)) { | |
d2bc5b3c | 374 | nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end, |
67fd707f | 375 | tag); |
774016b2 SW |
376 | if (nr_pages == 0) |
377 | break; | |
378 | ||
9aa01593 | 379 | ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, &done_index); |
b8e7cbb6 SW |
380 | if (ret) |
381 | done = 1; | |
382 | if (ret > 0) | |
383 | ret = 0; | |
b8e7cbb6 SW |
384 | pagevec_release(&pvec); |
385 | cond_resched(); | |
386 | } | |
387 | ||
774016b2 | 388 | if (!cycled && !done) { |
b8e7cbb6 | 389 | /* |
774016b2 | 390 | * range_cyclic: |
b8e7cbb6 SW |
391 | * We hit the last page and there is more work to be done: wrap |
392 | * back to the start of the file | |
393 | */ | |
774016b2 | 394 | cycled = 1; |
b8e7cbb6 | 395 | index = 0; |
774016b2 | 396 | end = writeback_index - 1; |
b8e7cbb6 SW |
397 | goto retry; |
398 | } | |
399 | ||
400 | if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) | |
774016b2 SW |
401 | mapping->writeback_index = done_index; |
402 | ||
b8e7cbb6 SW |
403 | return ret; |
404 | } | |
405 | ||
406 | ||
407 | /** | |
408 | * gfs2_jdata_writepages - Write a bunch of dirty pages back to disk | |
409 | * @mapping: The mapping to write | |
410 | * @wbc: The writeback control | |
411 | * | |
412 | */ | |
413 | ||
414 | static int gfs2_jdata_writepages(struct address_space *mapping, | |
415 | struct writeback_control *wbc) | |
416 | { | |
417 | struct gfs2_inode *ip = GFS2_I(mapping->host); | |
418 | struct gfs2_sbd *sdp = GFS2_SB(mapping->host); | |
419 | int ret; | |
420 | ||
421 | ret = gfs2_write_cache_jdata(mapping, wbc); | |
422 | if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) { | |
805c0907 BP |
423 | gfs2_log_flush(sdp, ip->i_gl, GFS2_LOG_HEAD_FLUSH_NORMAL | |
424 | GFS2_LFC_JDATA_WPAGES); | |
b8e7cbb6 SW |
425 | ret = gfs2_write_cache_jdata(mapping, wbc); |
426 | } | |
427 | return ret; | |
428 | } | |
429 | ||
b3b94faa DT |
430 | /** |
431 | * stuffed_readpage - Fill in a Linux page with stuffed file data | |
432 | * @ip: the inode | |
433 | * @page: the page | |
434 | * | |
435 | * Returns: errno | |
436 | */ | |
437 | ||
64bc06bb | 438 | int stuffed_readpage(struct gfs2_inode *ip, struct page *page) |
b3b94faa DT |
439 | { |
440 | struct buffer_head *dibh; | |
602c89d2 | 441 | u64 dsize = i_size_read(&ip->i_inode); |
b3b94faa DT |
442 | void *kaddr; |
443 | int error; | |
444 | ||
bf126aee | 445 | /* |
3c18ddd1 | 446 | * Due to the order of unstuffing files and ->fault(), we can be |
bf126aee SW |
447 | * asked for a zero page in the case of a stuffed file being extended, |
448 | * so we need to supply one here. It doesn't happen often. | |
449 | */ | |
450 | if (unlikely(page->index)) { | |
09cbfeaf | 451 | zero_user(page, 0, PAGE_SIZE); |
0a7ab79c | 452 | SetPageUptodate(page); |
bf126aee SW |
453 | return 0; |
454 | } | |
fd88de56 | 455 | |
b3b94faa DT |
456 | error = gfs2_meta_inode_buffer(ip, &dibh); |
457 | if (error) | |
458 | return error; | |
459 | ||
d9349285 | 460 | kaddr = kmap_atomic(page); |
235628c5 AG |
461 | if (dsize > gfs2_max_stuffed_size(ip)) |
462 | dsize = gfs2_max_stuffed_size(ip); | |
602c89d2 | 463 | memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize); |
09cbfeaf | 464 | memset(kaddr + dsize, 0, PAGE_SIZE - dsize); |
d9349285 | 465 | kunmap_atomic(kaddr); |
bf126aee | 466 | flush_dcache_page(page); |
b3b94faa | 467 | brelse(dibh); |
b3b94faa DT |
468 | SetPageUptodate(page); |
469 | ||
470 | return 0; | |
471 | } | |
472 | ||
b3b94faa | 473 | |
b3b94faa | 474 | /** |
51ff87bd SW |
475 | * __gfs2_readpage - readpage |
476 | * @file: The file to read a page for | |
b3b94faa DT |
477 | * @page: The page to read |
478 | * | |
9db115a0 AG |
479 | * This is the core of gfs2's readpage. It's used by the internal file |
480 | * reading code as in that case we already hold the glock. Also it's | |
51ff87bd | 481 | * called by gfs2_readpage() once the required lock has been granted. |
b3b94faa DT |
482 | */ |
483 | ||
51ff87bd | 484 | static int __gfs2_readpage(void *file, struct page *page) |
b3b94faa | 485 | { |
feaa7bba SW |
486 | struct gfs2_inode *ip = GFS2_I(page->mapping->host); |
487 | struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); | |
f95cbb44 | 488 | |
b3b94faa DT |
489 | int error; |
490 | ||
f95cbb44 AG |
491 | if (i_blocksize(page->mapping->host) == PAGE_SIZE && |
492 | !page_has_buffers(page)) { | |
493 | error = iomap_readpage(page, &gfs2_iomap_ops); | |
494 | } else if (gfs2_is_stuffed(ip)) { | |
fd88de56 SW |
495 | error = stuffed_readpage(ip, page); |
496 | unlock_page(page); | |
51ff87bd | 497 | } else { |
e9e1ef2b | 498 | error = mpage_readpage(page, gfs2_block_map); |
51ff87bd | 499 | } |
b3b94faa | 500 | |
04aea0ca | 501 | if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags))) |
51ff87bd | 502 | return -EIO; |
b3b94faa | 503 | |
51ff87bd SW |
504 | return error; |
505 | } | |
506 | ||
507 | /** | |
508 | * gfs2_readpage - read a page of a file | |
509 | * @file: The file to read | |
510 | * @page: The page of the file | |
511 | * | |
01b7c7ae SW |
512 | * This deals with the locking required. We have to unlock and |
513 | * relock the page in order to get the locking in the right | |
514 | * order. | |
51ff87bd SW |
515 | */ |
516 | ||
517 | static int gfs2_readpage(struct file *file, struct page *page) | |
518 | { | |
01b7c7ae SW |
519 | struct address_space *mapping = page->mapping; |
520 | struct gfs2_inode *ip = GFS2_I(mapping->host); | |
6802e340 | 521 | struct gfs2_holder gh; |
51ff87bd SW |
522 | int error; |
523 | ||
01b7c7ae | 524 | unlock_page(page); |
719ee344 SW |
525 | gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); |
526 | error = gfs2_glock_nq(&gh); | |
01b7c7ae | 527 | if (unlikely(error)) |
6802e340 | 528 | goto out; |
01b7c7ae SW |
529 | error = AOP_TRUNCATED_PAGE; |
530 | lock_page(page); | |
531 | if (page->mapping == mapping && !PageUptodate(page)) | |
532 | error = __gfs2_readpage(file, page); | |
533 | else | |
534 | unlock_page(page); | |
6802e340 | 535 | gfs2_glock_dq(&gh); |
18ec7d5c | 536 | out: |
6802e340 | 537 | gfs2_holder_uninit(&gh); |
01b7c7ae SW |
538 | if (error && error != AOP_TRUNCATED_PAGE) |
539 | lock_page(page); | |
51ff87bd SW |
540 | return error; |
541 | } | |
542 | ||
543 | /** | |
544 | * gfs2_internal_read - read an internal file | |
545 | * @ip: The gfs2 inode | |
51ff87bd SW |
546 | * @buf: The buffer to fill |
547 | * @pos: The file position | |
548 | * @size: The amount to read | |
549 | * | |
550 | */ | |
551 | ||
4306629e AP |
552 | int gfs2_internal_read(struct gfs2_inode *ip, char *buf, loff_t *pos, |
553 | unsigned size) | |
51ff87bd SW |
554 | { |
555 | struct address_space *mapping = ip->i_inode.i_mapping; | |
09cbfeaf KS |
556 | unsigned long index = *pos / PAGE_SIZE; |
557 | unsigned offset = *pos & (PAGE_SIZE - 1); | |
51ff87bd SW |
558 | unsigned copied = 0; |
559 | unsigned amt; | |
560 | struct page *page; | |
561 | void *p; | |
562 | ||
563 | do { | |
564 | amt = size - copied; | |
09cbfeaf KS |
565 | if (offset + size > PAGE_SIZE) |
566 | amt = PAGE_SIZE - offset; | |
51ff87bd SW |
567 | page = read_cache_page(mapping, index, __gfs2_readpage, NULL); |
568 | if (IS_ERR(page)) | |
569 | return PTR_ERR(page); | |
d9349285 | 570 | p = kmap_atomic(page); |
51ff87bd | 571 | memcpy(buf + copied, p + offset, amt); |
d9349285 | 572 | kunmap_atomic(p); |
09cbfeaf | 573 | put_page(page); |
51ff87bd SW |
574 | copied += amt; |
575 | index++; | |
576 | offset = 0; | |
577 | } while(copied < size); | |
578 | (*pos) += size; | |
579 | return size; | |
fd88de56 SW |
580 | } |
581 | ||
fd88de56 SW |
582 | /** |
583 | * gfs2_readpages - Read a bunch of pages at once | |
1272574b FF |
584 | * @file: The file to read from |
585 | * @mapping: Address space info | |
586 | * @pages: List of pages to read | |
587 | * @nr_pages: Number of pages to read | |
fd88de56 SW |
588 | * |
589 | * Some notes: | |
590 | * 1. This is only for readahead, so we can simply ignore any things | |
591 | * which are slightly inconvenient (such as locking conflicts between | |
592 | * the page lock and the glock) and return having done no I/O. Its | |
593 | * obviously not something we'd want to do on too regular a basis. | |
594 | * Any I/O we ignore at this time will be done via readpage later. | |
e1d5b18a | 595 | * 2. We don't handle stuffed files here we let readpage do the honours. |
fd88de56 | 596 | * 3. mpage_readpages() does most of the heavy lifting in the common case. |
e9e1ef2b | 597 | * 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places. |
fd88de56 | 598 | */ |
3cc3f710 | 599 | |
fd88de56 SW |
600 | static int gfs2_readpages(struct file *file, struct address_space *mapping, |
601 | struct list_head *pages, unsigned nr_pages) | |
602 | { | |
603 | struct inode *inode = mapping->host; | |
feaa7bba SW |
604 | struct gfs2_inode *ip = GFS2_I(inode); |
605 | struct gfs2_sbd *sdp = GFS2_SB(inode); | |
fd88de56 | 606 | struct gfs2_holder gh; |
3cc3f710 | 607 | int ret; |
fd88de56 | 608 | |
719ee344 SW |
609 | gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); |
610 | ret = gfs2_glock_nq(&gh); | |
51ff87bd | 611 | if (unlikely(ret)) |
3cc3f710 | 612 | goto out_uninit; |
e1d5b18a | 613 | if (!gfs2_is_stuffed(ip)) |
e9e1ef2b | 614 | ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map); |
3cc3f710 SW |
615 | gfs2_glock_dq(&gh); |
616 | out_uninit: | |
617 | gfs2_holder_uninit(&gh); | |
04aea0ca | 618 | if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags))) |
fd88de56 SW |
619 | ret = -EIO; |
620 | return ret; | |
b3b94faa DT |
621 | } |
622 | ||
7ae8fa84 RP |
623 | /** |
624 | * adjust_fs_space - Adjusts the free space available due to gfs2_grow | |
625 | * @inode: the rindex inode | |
626 | */ | |
64bc06bb | 627 | void adjust_fs_space(struct inode *inode) |
7ae8fa84 | 628 | { |
d0a22a4b | 629 | struct gfs2_sbd *sdp = GFS2_SB(inode); |
1946f70a BM |
630 | struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); |
631 | struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); | |
7ae8fa84 RP |
632 | struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; |
633 | struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; | |
1946f70a | 634 | struct buffer_head *m_bh, *l_bh; |
7ae8fa84 RP |
635 | u64 fs_total, new_free; |
636 | ||
d0a22a4b AG |
637 | if (gfs2_trans_begin(sdp, 2 * RES_STATFS, 0) != 0) |
638 | return; | |
639 | ||
7ae8fa84 RP |
640 | /* Total up the file system space, according to the latest rindex. */ |
641 | fs_total = gfs2_ri_total(sdp); | |
1946f70a | 642 | if (gfs2_meta_inode_buffer(m_ip, &m_bh) != 0) |
d0a22a4b | 643 | goto out; |
7ae8fa84 RP |
644 | |
645 | spin_lock(&sdp->sd_statfs_spin); | |
1946f70a BM |
646 | gfs2_statfs_change_in(m_sc, m_bh->b_data + |
647 | sizeof(struct gfs2_dinode)); | |
7ae8fa84 RP |
648 | if (fs_total > (m_sc->sc_total + l_sc->sc_total)) |
649 | new_free = fs_total - (m_sc->sc_total + l_sc->sc_total); | |
650 | else | |
651 | new_free = 0; | |
652 | spin_unlock(&sdp->sd_statfs_spin); | |
6c53267f RP |
653 | fs_warn(sdp, "File system extended by %llu blocks.\n", |
654 | (unsigned long long)new_free); | |
7ae8fa84 | 655 | gfs2_statfs_change(sdp, new_free, new_free, 0); |
1946f70a BM |
656 | |
657 | if (gfs2_meta_inode_buffer(l_ip, &l_bh) != 0) | |
d0a22a4b | 658 | goto out2; |
1946f70a BM |
659 | update_statfs(sdp, m_bh, l_bh); |
660 | brelse(l_bh); | |
d0a22a4b | 661 | out2: |
1946f70a | 662 | brelse(m_bh); |
d0a22a4b AG |
663 | out: |
664 | sdp->sd_rindex_uptodate = 0; | |
665 | gfs2_trans_end(sdp); | |
7ae8fa84 RP |
666 | } |
667 | ||
8fb68595 | 668 | /** |
b9e03f18 | 669 | * jdata_set_page_dirty - Page dirtying function |
8fb68595 RP |
670 | * @page: The page to dirty |
671 | * | |
672 | * Returns: 1 if it dirtyed the page, or 0 otherwise | |
673 | */ | |
674 | ||
b9e03f18 | 675 | static int jdata_set_page_dirty(struct page *page) |
8fb68595 | 676 | { |
5561093e | 677 | SetPageChecked(page); |
8fb68595 RP |
678 | return __set_page_dirty_buffers(page); |
679 | } | |
680 | ||
b3b94faa DT |
681 | /** |
682 | * gfs2_bmap - Block map function | |
683 | * @mapping: Address space info | |
684 | * @lblock: The block to map | |
685 | * | |
686 | * Returns: The disk address for the block or 0 on hole or error | |
687 | */ | |
688 | ||
689 | static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock) | |
690 | { | |
feaa7bba | 691 | struct gfs2_inode *ip = GFS2_I(mapping->host); |
b3b94faa DT |
692 | struct gfs2_holder i_gh; |
693 | sector_t dblock = 0; | |
694 | int error; | |
695 | ||
b3b94faa DT |
696 | error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); |
697 | if (error) | |
698 | return 0; | |
699 | ||
700 | if (!gfs2_is_stuffed(ip)) | |
e9e1ef2b | 701 | dblock = generic_block_bmap(mapping, lblock, gfs2_block_map); |
b3b94faa DT |
702 | |
703 | gfs2_glock_dq_uninit(&i_gh); | |
704 | ||
705 | return dblock; | |
706 | } | |
707 | ||
d7b616e2 SW |
708 | static void gfs2_discard(struct gfs2_sbd *sdp, struct buffer_head *bh) |
709 | { | |
710 | struct gfs2_bufdata *bd; | |
711 | ||
712 | lock_buffer(bh); | |
713 | gfs2_log_lock(sdp); | |
714 | clear_buffer_dirty(bh); | |
715 | bd = bh->b_private; | |
716 | if (bd) { | |
c0752aa7 BP |
717 | if (!list_empty(&bd->bd_list) && !buffer_pinned(bh)) |
718 | list_del_init(&bd->bd_list); | |
16615be1 | 719 | else |
68cd4ce2 | 720 | gfs2_remove_from_journal(bh, REMOVE_JDATA); |
d7b616e2 SW |
721 | } |
722 | bh->b_bdev = NULL; | |
723 | clear_buffer_mapped(bh); | |
724 | clear_buffer_req(bh); | |
725 | clear_buffer_new(bh); | |
726 | gfs2_log_unlock(sdp); | |
727 | unlock_buffer(bh); | |
728 | } | |
729 | ||
d47992f8 LC |
730 | static void gfs2_invalidatepage(struct page *page, unsigned int offset, |
731 | unsigned int length) | |
b3b94faa | 732 | { |
d7b616e2 | 733 | struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); |
5c0bb97c | 734 | unsigned int stop = offset + length; |
09cbfeaf | 735 | int partial_page = (offset || length < PAGE_SIZE); |
d7b616e2 SW |
736 | struct buffer_head *bh, *head; |
737 | unsigned long pos = 0; | |
738 | ||
b3b94faa | 739 | BUG_ON(!PageLocked(page)); |
5c0bb97c | 740 | if (!partial_page) |
8fb68595 | 741 | ClearPageChecked(page); |
d7b616e2 SW |
742 | if (!page_has_buffers(page)) |
743 | goto out; | |
b3b94faa | 744 | |
d7b616e2 SW |
745 | bh = head = page_buffers(page); |
746 | do { | |
5c0bb97c LC |
747 | if (pos + bh->b_size > stop) |
748 | return; | |
749 | ||
d7b616e2 SW |
750 | if (offset <= pos) |
751 | gfs2_discard(sdp, bh); | |
752 | pos += bh->b_size; | |
753 | bh = bh->b_this_page; | |
754 | } while (bh != head); | |
755 | out: | |
5c0bb97c | 756 | if (!partial_page) |
d7b616e2 | 757 | try_to_release_page(page, 0); |
b3b94faa DT |
758 | } |
759 | ||
4340fe62 | 760 | /** |
623d9355 | 761 | * gfs2_releasepage - free the metadata associated with a page |
4340fe62 SW |
762 | * @page: the page that's being released |
763 | * @gfp_mask: passed from Linux VFS, ignored by us | |
764 | * | |
0ebbe4f9 AG |
765 | * Calls try_to_free_buffers() to free the buffers and put the page if the |
766 | * buffers can be released. | |
4340fe62 | 767 | * |
0ebbe4f9 | 768 | * Returns: 1 if the page was put or else 0 |
4340fe62 SW |
769 | */ |
770 | ||
771 | int gfs2_releasepage(struct page *page, gfp_t gfp_mask) | |
772 | { | |
009d8518 SW |
773 | struct address_space *mapping = page->mapping; |
774 | struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping); | |
4340fe62 SW |
775 | struct buffer_head *bh, *head; |
776 | struct gfs2_bufdata *bd; | |
4340fe62 SW |
777 | |
778 | if (!page_has_buffers(page)) | |
891ba6d4 | 779 | return 0; |
4340fe62 | 780 | |
1c185c02 AG |
781 | /* |
782 | * From xfs_vm_releasepage: mm accommodates an old ext3 case where | |
783 | * clean pages might not have had the dirty bit cleared. Thus, it can | |
784 | * send actual dirty pages to ->releasepage() via shrink_active_list(). | |
785 | * | |
786 | * As a workaround, we skip pages that contain dirty buffers below. | |
787 | * Once ->releasepage isn't called on dirty pages anymore, we can warn | |
788 | * on dirty buffers like we used to here again. | |
789 | */ | |
790 | ||
bb3b0e3d | 791 | gfs2_log_lock(sdp); |
380f7c65 | 792 | spin_lock(&sdp->sd_ail_lock); |
4340fe62 SW |
793 | head = bh = page_buffers(page); |
794 | do { | |
bb3b0e3d SW |
795 | if (atomic_read(&bh->b_count)) |
796 | goto cannot_release; | |
797 | bd = bh->b_private; | |
16ca9412 | 798 | if (bd && bd->bd_tr) |
bb3b0e3d | 799 | goto cannot_release; |
1c185c02 AG |
800 | if (buffer_dirty(bh) || WARN_ON(buffer_pinned(bh))) |
801 | goto cannot_release; | |
bb3b0e3d SW |
802 | bh = bh->b_this_page; |
803 | } while(bh != head); | |
380f7c65 | 804 | spin_unlock(&sdp->sd_ail_lock); |
4340fe62 | 805 | |
bb3b0e3d SW |
806 | head = bh = page_buffers(page); |
807 | do { | |
4340fe62 SW |
808 | bd = bh->b_private; |
809 | if (bd) { | |
810 | gfs2_assert_warn(sdp, bd->bd_bh == bh); | |
e4f29206 SW |
811 | if (!list_empty(&bd->bd_list)) |
812 | list_del_init(&bd->bd_list); | |
813 | bd->bd_bh = NULL; | |
4340fe62 | 814 | bh->b_private = NULL; |
623d9355 | 815 | kmem_cache_free(gfs2_bufdata_cachep, bd); |
e4f29206 | 816 | } |
4340fe62 SW |
817 | |
818 | bh = bh->b_this_page; | |
166afccd | 819 | } while (bh != head); |
e4f29206 | 820 | gfs2_log_unlock(sdp); |
4340fe62 | 821 | |
4340fe62 | 822 | return try_to_free_buffers(page); |
8f065d36 | 823 | |
bb3b0e3d | 824 | cannot_release: |
380f7c65 | 825 | spin_unlock(&sdp->sd_ail_lock); |
bb3b0e3d SW |
826 | gfs2_log_unlock(sdp); |
827 | return 0; | |
4340fe62 SW |
828 | } |
829 | ||
eadd7535 | 830 | static const struct address_space_operations gfs2_aops = { |
9d358143 | 831 | .writepage = gfs2_writepage, |
45138990 | 832 | .writepages = gfs2_writepages, |
5561093e SW |
833 | .readpage = gfs2_readpage, |
834 | .readpages = gfs2_readpages, | |
5561093e SW |
835 | .bmap = gfs2_bmap, |
836 | .invalidatepage = gfs2_invalidatepage, | |
837 | .releasepage = gfs2_releasepage, | |
967bcc91 | 838 | .direct_IO = noop_direct_IO, |
e5d9dc27 | 839 | .migratepage = buffer_migrate_page, |
229615de | 840 | .is_partially_uptodate = block_is_partially_uptodate, |
aa261f54 | 841 | .error_remove_page = generic_error_remove_page, |
5561093e SW |
842 | }; |
843 | ||
5561093e | 844 | static const struct address_space_operations gfs2_jdata_aops = { |
9ff8ec32 | 845 | .writepage = gfs2_jdata_writepage, |
b8e7cbb6 | 846 | .writepages = gfs2_jdata_writepages, |
5561093e SW |
847 | .readpage = gfs2_readpage, |
848 | .readpages = gfs2_readpages, | |
b9e03f18 | 849 | .set_page_dirty = jdata_set_page_dirty, |
5561093e SW |
850 | .bmap = gfs2_bmap, |
851 | .invalidatepage = gfs2_invalidatepage, | |
852 | .releasepage = gfs2_releasepage, | |
229615de | 853 | .is_partially_uptodate = block_is_partially_uptodate, |
aa261f54 | 854 | .error_remove_page = generic_error_remove_page, |
5561093e SW |
855 | }; |
856 | ||
857 | void gfs2_set_aops(struct inode *inode) | |
858 | { | |
eadd7535 | 859 | if (gfs2_is_jdata(GFS2_I(inode))) |
977767a7 | 860 | inode->i_mapping->a_ops = &gfs2_jdata_aops; |
5561093e | 861 | else |
eadd7535 | 862 | inode->i_mapping->a_ops = &gfs2_aops; |
5561093e | 863 | } |