2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/pagemap.h>
16 #include <linux/pagevec.h>
17 #include <linux/mpage.h>
19 #include <linux/writeback.h>
20 #include <linux/gfs2_ondisk.h>
21 #include <linux/lm_interface.h>
30 #include "ops_address.h"
40 static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
41 unsigned int from, unsigned int to)
43 struct buffer_head *head = page_buffers(page);
44 unsigned int bsize = head->b_size;
45 struct buffer_head *bh;
46 unsigned int start, end;
48 for (bh = head, start = 0; bh != head || !start;
49 bh = bh->b_this_page, start = end) {
51 if (end <= from || start >= to)
53 if (gfs2_is_jdata(ip))
54 set_buffer_uptodate(bh);
55 gfs2_trans_add_bh(ip->i_gl, bh, 0);
60 * gfs2_get_block - Fills in a buffer head with details about a block
62 * @lblock: The block number to look up
63 * @bh_result: The buffer head to return the result in
64 * @create: Non-zero if we may add block to the file
69 int gfs2_get_block(struct inode *inode, sector_t lblock,
70 struct buffer_head *bh_result, int create)
72 return gfs2_block_map(inode, lblock, create, bh_result);
76 * gfs2_get_block_noalloc - Fills in a buffer head with details about a block
78 * @lblock: The block number to look up
79 * @bh_result: The buffer head to return the result in
80 * @create: Non-zero if we may add block to the file
85 static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
86 struct buffer_head *bh_result, int create)
90 error = gfs2_block_map(inode, lblock, 0, bh_result);
93 if (bh_result->b_blocknr == 0)
98 static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
99 struct buffer_head *bh_result, int create)
101 return gfs2_block_map(inode, lblock, 0, bh_result);
105 * gfs2_writepage - Write complete page
106 * @page: Page to write
110 * Some of this is copied from block_write_full_page() although we still
111 * call it to do most of the work.
114 static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
116 struct inode *inode = page->mapping->host;
117 struct gfs2_inode *ip = GFS2_I(inode);
118 struct gfs2_sbd *sdp = GFS2_SB(inode);
119 loff_t i_size = i_size_read(inode);
120 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
125 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
129 if (current->journal_info)
132 /* Is the page fully outside i_size? (truncate in progress) */
133 offset = i_size & (PAGE_CACHE_SIZE-1);
134 if (page->index > end_index || (page->index == end_index && !offset)) {
135 page->mapping->a_ops->invalidatepage(page, 0);
137 return 0; /* don't care */
140 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) {
141 error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
144 if (!page_has_buffers(page)) {
145 create_empty_buffers(page, inode->i_sb->s_blocksize,
146 (1 << BH_Dirty)|(1 << BH_Uptodate));
148 gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
151 error = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
154 gfs2_meta_cache_flush(ip);
158 redirty_page_for_writepage(wbc, page);
164 * gfs2_writepages - Write a bunch of dirty pages back to disk
165 * @mapping: The mapping to write
166 * @wbc: Write-back control
168 * For journaled files and/or ordered writes this just falls back to the
169 * kernel's default writepages path for now. We will probably want to change
170 * that eventually (i.e. when we look at allocate on flush).
172 * For the data=writeback case though we can already ignore buffer heads
173 * and write whole extents at once. This is a big reduction in the
174 * number of I/O requests we send and the bmap calls we make in this case.
176 static int gfs2_writepages(struct address_space *mapping,
177 struct writeback_control *wbc)
179 struct inode *inode = mapping->host;
180 struct gfs2_inode *ip = GFS2_I(inode);
181 struct gfs2_sbd *sdp = GFS2_SB(inode);
183 if (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK && !gfs2_is_jdata(ip))
184 return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
186 return generic_writepages(mapping, wbc);
190 * stuffed_readpage - Fill in a Linux page with stuffed file data
197 static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
199 struct buffer_head *dibh;
204 * Due to the order of unstuffing files and ->nopage(), we can be
205 * asked for a zero page in the case of a stuffed file being extended,
206 * so we need to supply one here. It doesn't happen often.
208 if (unlikely(page->index)) {
209 kaddr = kmap_atomic(page, KM_USER0);
210 memset(kaddr, 0, PAGE_CACHE_SIZE);
211 kunmap_atomic(kaddr, KM_USER0);
212 flush_dcache_page(page);
213 SetPageUptodate(page);
217 error = gfs2_meta_inode_buffer(ip, &dibh);
221 kaddr = kmap_atomic(page, KM_USER0);
222 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
224 memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
225 kunmap_atomic(kaddr, KM_USER0);
226 flush_dcache_page(page);
228 SetPageUptodate(page);
235 * gfs2_readpage - readpage with locking
236 * @file: The file to read a page for. N.B. This may be NULL if we are
237 * reading an internal file.
238 * @page: The page to read
243 static int gfs2_readpage(struct file *file, struct page *page)
245 struct gfs2_inode *ip = GFS2_I(page->mapping->host);
246 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
247 struct gfs2_file *gf = NULL;
248 struct gfs2_holder gh;
252 if (likely(file != &gfs2_internal_file_sentinel)) {
254 gf = file->private_data;
255 if (test_bit(GFF_EXLOCK, &gf->f_flags))
256 /* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
259 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
261 error = gfs2_glock_nq_atime(&gh);
267 if (gfs2_is_stuffed(ip)) {
268 error = stuffed_readpage(ip, page);
271 error = mpage_readpage(page, gfs2_get_block);
273 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
277 gfs2_glock_dq_m(1, &gh);
278 gfs2_holder_uninit(&gh);
284 if (error == GLR_TRYFAILED) {
285 error = AOP_TRUNCATED_PAGE;
289 gfs2_holder_uninit(&gh);
294 * gfs2_readpages - Read a bunch of pages at once
297 * 1. This is only for readahead, so we can simply ignore any things
298 * which are slightly inconvenient (such as locking conflicts between
299 * the page lock and the glock) and return having done no I/O. Its
300 * obviously not something we'd want to do on too regular a basis.
301 * Any I/O we ignore at this time will be done via readpage later.
302 * 2. We don't handle stuffed files here we let readpage do the honours.
303 * 3. mpage_readpages() does most of the heavy lifting in the common case.
304 * 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places.
305 * 5. We use LM_FLAG_TRY_1CB here, effectively we then have lock-ahead as
306 * well as read-ahead.
308 static int gfs2_readpages(struct file *file, struct address_space *mapping,
309 struct list_head *pages, unsigned nr_pages)
311 struct inode *inode = mapping->host;
312 struct gfs2_inode *ip = GFS2_I(inode);
313 struct gfs2_sbd *sdp = GFS2_SB(inode);
314 struct gfs2_holder gh;
318 if (likely(file != &gfs2_internal_file_sentinel)) {
320 struct gfs2_file *gf = file->private_data;
321 if (test_bit(GFF_EXLOCK, &gf->f_flags))
324 gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
325 LM_FLAG_TRY_1CB|GL_ATIME, &gh);
327 ret = gfs2_glock_nq_atime(&gh);
328 if (ret == GLR_TRYFAILED)
334 if (!gfs2_is_stuffed(ip))
335 ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
338 gfs2_glock_dq_m(1, &gh);
339 gfs2_holder_uninit(&gh);
342 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
349 gfs2_holder_uninit(&gh);
354 * gfs2_prepare_write - Prepare to write a page to a file
355 * @file: The file to write to
356 * @page: The page which is to be prepared for writing
357 * @from: From (byte range within page)
358 * @to: To (byte range within page)
363 static int gfs2_prepare_write(struct file *file, struct page *page,
364 unsigned from, unsigned to)
366 struct gfs2_inode *ip = GFS2_I(page->mapping->host);
367 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
368 unsigned int data_blocks, ind_blocks, rblocks;
371 loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from;
372 loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
373 struct gfs2_alloc *al;
374 unsigned int write_len = to - from;
377 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|LM_FLAG_TRY_1CB, &ip->i_gh);
378 error = gfs2_glock_nq_atime(&ip->i_gh);
379 if (unlikely(error)) {
380 if (error == GLR_TRYFAILED) {
382 error = AOP_TRUNCATED_PAGE;
388 gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
390 error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
395 ip->i_alloc.al_requested = 0;
396 if (alloc_required) {
397 al = gfs2_alloc_get(ip);
399 error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
403 error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
407 al->al_requested = data_blocks + ind_blocks;
408 error = gfs2_inplace_reserve(ip);
413 rblocks = RES_DINODE + ind_blocks;
414 if (gfs2_is_jdata(ip))
415 rblocks += data_blocks ? data_blocks : 1;
416 if (ind_blocks || data_blocks)
417 rblocks += RES_STATFS + RES_QUOTA;
419 error = gfs2_trans_begin(sdp, rblocks, 0);
423 if (gfs2_is_stuffed(ip)) {
424 if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
425 error = gfs2_unstuff_dinode(ip, page);
428 } else if (!PageUptodate(page))
429 error = stuffed_readpage(ip, page);
434 error = block_prepare_write(page, from, to, gfs2_get_block);
439 if (alloc_required) {
440 gfs2_inplace_release(ip);
442 gfs2_quota_unlock(ip);
447 gfs2_glock_dq_m(1, &ip->i_gh);
449 gfs2_holder_uninit(&ip->i_gh);
456 * adjust_fs_space - Adjusts the free space available due to gfs2_grow
457 * @inode: the rindex inode
459 static void adjust_fs_space(struct inode *inode)
461 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
462 struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
463 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
464 u64 fs_total, new_free;
466 /* Total up the file system space, according to the latest rindex. */
467 fs_total = gfs2_ri_total(sdp);
469 spin_lock(&sdp->sd_statfs_spin);
470 if (fs_total > (m_sc->sc_total + l_sc->sc_total))
471 new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
474 spin_unlock(&sdp->sd_statfs_spin);
475 fs_warn(sdp, "File system extended by %llu blocks.\n",
476 (unsigned long long)new_free);
477 gfs2_statfs_change(sdp, new_free, new_free, 0);
481 * gfs2_commit_write - Commit write to a file
482 * @file: The file to write to
483 * @page: The page containing the data
484 * @from: From (byte range within page)
485 * @to: To (byte range within page)
490 static int gfs2_commit_write(struct file *file, struct page *page,
491 unsigned from, unsigned to)
493 struct inode *inode = page->mapping->host;
494 struct gfs2_inode *ip = GFS2_I(inode);
495 struct gfs2_sbd *sdp = GFS2_SB(inode);
496 int error = -EOPNOTSUPP;
497 struct buffer_head *dibh;
498 struct gfs2_alloc *al = &ip->i_alloc;
499 struct gfs2_dinode *di;
501 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
504 error = gfs2_meta_inode_buffer(ip, &dibh);
508 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
509 di = (struct gfs2_dinode *)dibh->b_data;
511 if (gfs2_is_stuffed(ip)) {
515 file_size = ((u64)page->index << PAGE_CACHE_SHIFT) + to;
517 kaddr = kmap_atomic(page, KM_USER0);
518 memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
519 kaddr + from, to - from);
520 kunmap_atomic(kaddr, KM_USER0);
522 SetPageUptodate(page);
524 if (inode->i_size < file_size) {
525 i_size_write(inode, file_size);
526 mark_inode_dirty(inode);
529 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
531 gfs2_page_add_databufs(ip, page, from, to);
532 error = generic_commit_write(file, page, from, to);
537 if (ip->i_di.di_size < inode->i_size) {
538 ip->i_di.di_size = inode->i_size;
539 di->di_size = cpu_to_be64(inode->i_size);
542 if (inode == sdp->sd_rindex)
543 adjust_fs_space(inode);
547 if (al->al_requested) {
548 gfs2_inplace_release(ip);
549 gfs2_quota_unlock(ip);
553 gfs2_glock_dq_m(1, &ip->i_gh);
555 gfs2_holder_uninit(&ip->i_gh);
562 if (al->al_requested) {
563 gfs2_inplace_release(ip);
564 gfs2_quota_unlock(ip);
568 gfs2_glock_dq_m(1, &ip->i_gh);
570 gfs2_holder_uninit(&ip->i_gh);
572 ClearPageUptodate(page);
577 * gfs2_bmap - Block map function
578 * @mapping: Address space info
579 * @lblock: The block to map
581 * Returns: The disk address for the block or 0 on hole or error
584 static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
586 struct gfs2_inode *ip = GFS2_I(mapping->host);
587 struct gfs2_holder i_gh;
591 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
595 if (!gfs2_is_stuffed(ip))
596 dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
598 gfs2_glock_dq_uninit(&i_gh);
603 static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
605 struct gfs2_bufdata *bd;
611 bh->b_private = NULL;
613 gfs2_log_unlock(sdp);
616 clear_buffer_dirty(bh);
618 clear_buffer_mapped(bh);
619 clear_buffer_req(bh);
620 clear_buffer_new(bh);
621 clear_buffer_delay(bh);
625 static void gfs2_invalidatepage(struct page *page, unsigned long offset)
627 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
628 struct buffer_head *head, *bh, *next;
629 unsigned int curr_off = 0;
631 BUG_ON(!PageLocked(page));
632 if (!page_has_buffers(page))
635 bh = head = page_buffers(page);
637 unsigned int next_off = curr_off + bh->b_size;
638 next = bh->b_this_page;
640 if (offset <= curr_off)
641 discard_buffer(sdp, bh);
645 } while (bh != head);
648 try_to_release_page(page, 0);
654 * gfs2_ok_for_dio - check that dio is valid on this file
657 * @offset: The offset at which we are reading or writing
659 * Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)
660 * 1 (to accept the i/o request)
662 static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
665 * Should we return an error here? I can't see that O_DIRECT for
666 * a journaled file makes any sense. For now we'll silently fall
667 * back to buffered I/O, likewise we do the same for stuffed
668 * files since they are (a) small and (b) unaligned.
670 if (gfs2_is_jdata(ip))
673 if (gfs2_is_stuffed(ip))
676 if (offset > i_size_read(&ip->i_inode))
683 static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
684 const struct iovec *iov, loff_t offset,
685 unsigned long nr_segs)
687 struct file *file = iocb->ki_filp;
688 struct inode *inode = file->f_mapping->host;
689 struct gfs2_inode *ip = GFS2_I(inode);
690 struct gfs2_holder gh;
694 * Deferred lock, even if its a write, since we do no allocation
695 * on this path. All we need change is atime, and this lock mode
696 * ensures that other nodes have flushed their buffered read caches
697 * (i.e. their page cache entries for this inode). We do not,
698 * unfortunately have the option of only flushing a range like
701 gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
702 rv = gfs2_glock_nq_atime(&gh);
705 rv = gfs2_ok_for_dio(ip, rw, offset);
707 goto out; /* dio not valid, fall back to buffered i/o */
709 rv = blockdev_direct_IO_no_locking(rw, iocb, inode, inode->i_sb->s_bdev,
710 iov, offset, nr_segs,
711 gfs2_get_block_direct, NULL);
713 gfs2_glock_dq_m(1, &gh);
714 gfs2_holder_uninit(&gh);
719 * stuck_releasepage - We're stuck in gfs2_releasepage(). Print stuff out.
720 * @bh: the buffer we're stuck on
724 static void stuck_releasepage(struct buffer_head *bh)
726 struct inode *inode = bh->b_page->mapping->host;
727 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
728 struct gfs2_bufdata *bd = bh->b_private;
729 struct gfs2_glock *gl;
730 static unsigned limit = 0;
736 fs_warn(sdp, "stuck in gfs2_releasepage() %p\n", inode);
737 fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n",
738 (unsigned long long)bh->b_blocknr, atomic_read(&bh->b_count));
739 fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh));
740 fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL");
747 fs_warn(sdp, "gl = (%u, %llu)\n",
748 gl->gl_name.ln_type, (unsigned long long)gl->gl_name.ln_number);
750 fs_warn(sdp, "bd_list_tr = %s, bd_le.le_list = %s\n",
751 (list_empty(&bd->bd_list_tr)) ? "no" : "yes",
752 (list_empty(&bd->bd_le.le_list)) ? "no" : "yes");
754 if (gl->gl_ops == &gfs2_inode_glops) {
755 struct gfs2_inode *ip = gl->gl_object;
761 fs_warn(sdp, "ip = %llu %llu\n",
762 (unsigned long long)ip->i_no_formal_ino,
763 (unsigned long long)ip->i_no_addr);
765 for (x = 0; x < GFS2_MAX_META_HEIGHT; x++)
766 fs_warn(sdp, "ip->i_cache[%u] = %s\n",
767 x, (ip->i_cache[x]) ? "!NULL" : "NULL");
772 * gfs2_releasepage - free the metadata associated with a page
773 * @page: the page that's being released
774 * @gfp_mask: passed from Linux VFS, ignored by us
776 * Call try_to_free_buffers() if the buffers in this page can be
782 int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
784 struct inode *aspace = page->mapping->host;
785 struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;
786 struct buffer_head *bh, *head;
787 struct gfs2_bufdata *bd;
788 unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
790 if (!page_has_buffers(page))
793 head = bh = page_buffers(page);
795 while (atomic_read(&bh->b_count)) {
796 if (!atomic_read(&aspace->i_writecount))
799 if (!(gfp_mask & __GFP_WAIT))
802 if (time_after_eq(jiffies, t)) {
803 stuck_releasepage(bh);
804 /* should we withdraw here? */
811 gfs2_assert_warn(sdp, !buffer_pinned(bh));
812 gfs2_assert_warn(sdp, !buffer_dirty(bh));
817 gfs2_assert_warn(sdp, bd->bd_bh == bh);
818 gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
819 gfs2_assert_warn(sdp, !bd->bd_ail);
821 if (!list_empty(&bd->bd_le.le_list))
823 bh->b_private = NULL;
825 gfs2_log_unlock(sdp);
827 kmem_cache_free(gfs2_bufdata_cachep, bd);
829 bh = bh->b_this_page;
830 } while (bh != head);
833 return try_to_free_buffers(page);
836 const struct address_space_operations gfs2_file_aops = {
837 .writepage = gfs2_writepage,
838 .writepages = gfs2_writepages,
839 .readpage = gfs2_readpage,
840 .readpages = gfs2_readpages,
841 .sync_page = block_sync_page,
842 .prepare_write = gfs2_prepare_write,
843 .commit_write = gfs2_commit_write,
845 .invalidatepage = gfs2_invalidatepage,
846 .releasepage = gfs2_releasepage,
847 .direct_IO = gfs2_direct_IO,