2006-01-16 16:50:04 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 14:37:57 +00:00
|
|
|
* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
2006-09-01 15:05:15 +00:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/pagemap.h>
|
2006-05-05 20:59:11 +00:00
|
|
|
#include <linux/pagevec.h>
|
2006-01-30 11:55:32 +00:00
|
|
|
#include <linux/mpage.h>
|
2006-02-14 11:54:42 +00:00
|
|
|
#include <linux/fs.h>
|
2007-01-15 13:52:17 +00:00
|
|
|
#include <linux/writeback.h>
|
2006-02-27 22:23:27 +00:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-09-19 05:56:29 +00:00
|
|
|
#include <linux/lm_interface.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "incore.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "bmap.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "inode.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "ops_address.h"
|
|
|
|
#include "quota.h"
|
|
|
|
#include "trans.h"
|
2006-02-08 11:50:51 +00:00
|
|
|
#include "rgrp.h"
|
2006-02-15 10:15:18 +00:00
|
|
|
#include "ops_file.h"
|
2007-05-14 17:42:18 +00:00
|
|
|
#include "super.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "util.h"
|
2006-07-11 13:46:33 +00:00
|
|
|
#include "glops.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-07-26 15:27:10 +00:00
|
|
|
|
|
|
|
static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
|
|
|
|
unsigned int from, unsigned int to)
|
|
|
|
{
|
|
|
|
struct buffer_head *head = page_buffers(page);
|
|
|
|
unsigned int bsize = head->b_size;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
unsigned int start, end;
|
|
|
|
|
|
|
|
for (bh = head, start = 0; bh != head || !start;
|
|
|
|
bh = bh->b_this_page, start = end) {
|
|
|
|
end = start + bsize;
|
|
|
|
if (end <= from || start >= to)
|
|
|
|
continue;
|
[GFS2] fix jdata issues
This is a patch for the first three issues of RHBZ #238162
The first issue is that when you allocate a new page for a file, it will not
start off uptodate. This makes sense, since you haven't written anything to that
part of the file yet. Unfortunately, gfs2_pin() checks to make sure that the
buffers are uptodate. The solution to this is to mark the buffers uptodate in
gfs2_commit_write(), after they have been zeroed out and have the data written
into them. I'm pretty confident with this fix, although it's not completely
obvious that there is no problem with marking the buffers uptodate here.
The second issue is simply that you can try to pin a data buffer that is already
on the incore log, and thus, already pinned. This patch checks to see if this
buffer is already on the log, and exits databuf_lo_add() if it is, just like
buf_lo_add() does.
The third issue is that gfs2_log_flush() doesn't do it's block accounting
correctly. Both metadata and journaled data are logged, but gfs2_log_flush()
only compares the number of metadata blocks with the number of blocks to commit
to the ondisk journal. This patch also counts the journaled data blocks.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-06-01 19:21:38 +00:00
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
set_buffer_uptodate(bh);
|
2006-07-26 15:27:10 +00:00
|
|
|
gfs2_trans_add_bh(ip->i_gl, bh, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
2006-01-30 09:39:10 +00:00
|
|
|
* gfs2_get_block - Fills in a buffer head with details about a block
|
2006-01-16 16:50:04 +00:00
|
|
|
* @inode: The inode
|
|
|
|
* @lblock: The block number to look up
|
|
|
|
* @bh_result: The buffer head to return the result in
|
|
|
|
* @create: Non-zero if we may add block to the file
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-01-30 09:39:10 +00:00
|
|
|
int gfs2_get_block(struct inode *inode, sector_t lblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-10-13 21:25:45 +00:00
|
|
|
return gfs2_block_map(inode, lblock, create, bh_result);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-09-18 21:18:23 +00:00
|
|
|
* gfs2_get_block_noalloc - Fills in a buffer head with details about a block
|
2006-01-16 16:50:04 +00:00
|
|
|
* @inode: The inode
|
|
|
|
* @lblock: The block number to look up
|
|
|
|
* @bh_result: The buffer head to return the result in
|
|
|
|
* @create: Non-zero if we may add block to the file
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-09-18 21:18:23 +00:00
|
|
|
static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2006-10-13 21:25:45 +00:00
|
|
|
error = gfs2_block_map(inode, lblock, 0, bh_result);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-09-18 21:18:23 +00:00
|
|
|
if (bh_result->b_blocknr == 0)
|
|
|
|
return -EIO;
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-09-18 21:18:23 +00:00
|
|
|
static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
2006-08-31 16:14:44 +00:00
|
|
|
{
|
2006-10-13 21:25:45 +00:00
|
|
|
return gfs2_block_map(inode, lblock, 0, bh_result);
|
2006-08-31 16:14:44 +00:00
|
|
|
}
|
2006-09-18 21:18:23 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* gfs2_writepage - Write complete page
|
|
|
|
* @page: Page to write
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*
|
2006-02-08 11:50:51 +00:00
|
|
|
* Some of this is copied from block_write_full_page() although we still
|
|
|
|
* call it to do most of the work.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
|
|
|
|
{
|
2006-02-08 11:50:51 +00:00
|
|
|
struct inode *inode = page->mapping->host;
|
2006-08-08 17:23:19 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-02-08 11:50:51 +00:00
|
|
|
loff_t i_size = i_size_read(inode);
|
|
|
|
pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned offset;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
2006-02-08 11:50:51 +00:00
|
|
|
int done_trans = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
|
|
|
|
unlock_page(page);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2006-02-27 22:23:27 +00:00
|
|
|
if (current->journal_info)
|
2006-02-08 11:50:51 +00:00
|
|
|
goto out_ignore;
|
|
|
|
|
|
|
|
/* Is the page fully outside i_size? (truncate in progress) */
|
|
|
|
offset = i_size & (PAGE_CACHE_SIZE-1);
|
2006-05-02 16:09:42 +00:00
|
|
|
if (page->index > end_index || (page->index == end_index && !offset)) {
|
2006-02-08 11:50:51 +00:00
|
|
|
page->mapping->a_ops->invalidatepage(page, 0);
|
2006-01-16 16:50:04 +00:00
|
|
|
unlock_page(page);
|
2006-02-08 11:50:51 +00:00
|
|
|
return 0; /* don't care */
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2007-06-12 16:24:36 +00:00
|
|
|
if ((sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) &&
|
|
|
|
PageChecked(page)) {
|
|
|
|
ClearPageChecked(page);
|
2006-02-08 11:50:51 +00:00
|
|
|
error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
|
|
|
|
if (error)
|
|
|
|
goto out_ignore;
|
2006-08-08 17:23:19 +00:00
|
|
|
if (!page_has_buffers(page)) {
|
|
|
|
create_empty_buffers(page, inode->i_sb->s_blocksize,
|
|
|
|
(1 << BH_Dirty)|(1 << BH_Uptodate));
|
|
|
|
}
|
2006-02-08 11:50:51 +00:00
|
|
|
gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
|
|
|
|
done_trans = 1;
|
|
|
|
}
|
2006-09-18 21:18:23 +00:00
|
|
|
error = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
|
2006-02-08 11:50:51 +00:00
|
|
|
if (done_trans)
|
|
|
|
gfs2_trans_end(sdp);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_meta_cache_flush(ip);
|
|
|
|
return error;
|
2006-02-08 11:50:51 +00:00
|
|
|
|
|
|
|
out_ignore:
|
|
|
|
redirty_page_for_writepage(wbc, page);
|
|
|
|
unlock_page(page);
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2007-01-15 13:52:17 +00:00
|
|
|
/**
|
|
|
|
* gfs2_writepages - Write a bunch of dirty pages back to disk
|
|
|
|
* @mapping: The mapping to write
|
|
|
|
* @wbc: Write-back control
|
|
|
|
*
|
|
|
|
* For journaled files and/or ordered writes this just falls back to the
|
|
|
|
* kernel's default writepages path for now. We will probably want to change
|
|
|
|
* that eventually (i.e. when we look at allocate on flush).
|
|
|
|
*
|
|
|
|
* For the data=writeback case though we can already ignore buffer heads
|
|
|
|
* and write whole extents at once. This is a big reduction in the
|
|
|
|
* number of I/O requests we send and the bmap calls we make in this case.
|
|
|
|
*/
|
2007-02-06 22:12:49 +00:00
|
|
|
static int gfs2_writepages(struct address_space *mapping,
|
|
|
|
struct writeback_control *wbc)
|
2007-01-15 13:52:17 +00:00
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK && !gfs2_is_jdata(ip))
|
|
|
|
return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
|
|
|
|
|
|
|
|
return generic_writepages(mapping, wbc);
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* stuffed_readpage - Fill in a Linux page with stuffed file data
|
|
|
|
* @ip: the inode
|
|
|
|
* @page: the page
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
|
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
void *kaddr;
|
|
|
|
int error;
|
|
|
|
|
2007-04-20 08:18:30 +00:00
|
|
|
/*
|
|
|
|
* Due to the order of unstuffing files and ->nopage(), we can be
|
|
|
|
* asked for a zero page in the case of a stuffed file being extended,
|
|
|
|
* so we need to supply one here. It doesn't happen often.
|
|
|
|
*/
|
|
|
|
if (unlikely(page->index)) {
|
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
|
|
|
memset(kaddr, 0, PAGE_CACHE_SIZE);
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
flush_dcache_page(page);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-05-05 20:59:11 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-02-15 12:26:19 +00:00
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
2006-05-05 20:59:11 +00:00
|
|
|
memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
|
2006-01-16 16:50:04 +00:00
|
|
|
ip->i_di.di_size);
|
2006-05-05 20:59:11 +00:00
|
|
|
memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
|
2006-10-12 13:23:41 +00:00
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
2007-04-20 08:18:30 +00:00
|
|
|
flush_dcache_page(page);
|
2006-01-16 16:50:04 +00:00
|
|
|
brelse(dibh);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_readpage - readpage with locking
|
2006-02-08 11:50:51 +00:00
|
|
|
* @file: The file to read a page for. N.B. This may be NULL if we are
|
|
|
|
* reading an internal file.
|
2006-01-16 16:50:04 +00:00
|
|
|
* @page: The page to read
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_readpage(struct file *file, struct page *page)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(page->mapping->host);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
|
2006-09-18 21:26:48 +00:00
|
|
|
struct gfs2_file *gf = NULL;
|
2006-02-08 11:50:51 +00:00
|
|
|
struct gfs2_holder gh;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
2006-08-04 19:41:22 +00:00
|
|
|
int do_unlock = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-04 18:53:30 +00:00
|
|
|
if (likely(file != &gfs2_internal_file_sentinel)) {
|
2006-08-04 19:41:22 +00:00
|
|
|
if (file) {
|
2006-09-18 21:26:48 +00:00
|
|
|
gf = file->private_data;
|
2006-08-04 19:41:22 +00:00
|
|
|
if (test_bit(GFF_EXLOCK, &gf->f_flags))
|
2006-09-18 21:26:48 +00:00
|
|
|
/* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
|
2006-08-04 19:41:22 +00:00
|
|
|
goto skip_lock;
|
|
|
|
}
|
2006-11-08 15:26:54 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
|
2006-08-04 19:41:22 +00:00
|
|
|
do_unlock = 1;
|
2006-11-16 16:08:16 +00:00
|
|
|
error = gfs2_glock_nq_atime(&gh);
|
2006-05-05 20:59:11 +00:00
|
|
|
if (unlikely(error))
|
2006-02-15 10:15:18 +00:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-08-04 19:41:22 +00:00
|
|
|
skip_lock:
|
2006-02-08 11:50:51 +00:00
|
|
|
if (gfs2_is_stuffed(ip)) {
|
2006-05-05 20:59:11 +00:00
|
|
|
error = stuffed_readpage(ip, page);
|
|
|
|
unlock_page(page);
|
2006-01-16 16:50:04 +00:00
|
|
|
} else
|
2006-02-08 11:50:51 +00:00
|
|
|
error = mpage_readpage(page, gfs2_get_block);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
|
|
|
|
error = -EIO;
|
|
|
|
|
2006-09-18 21:30:05 +00:00
|
|
|
if (do_unlock) {
|
2006-02-15 10:15:18 +00:00
|
|
|
gfs2_glock_dq_m(1, &gh);
|
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
}
|
2006-02-08 11:50:51 +00:00
|
|
|
out:
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
2006-02-08 11:50:51 +00:00
|
|
|
out_unlock:
|
|
|
|
unlock_page(page);
|
2007-02-23 17:49:51 +00:00
|
|
|
if (error == GLR_TRYFAILED) {
|
|
|
|
error = AOP_TRUNCATED_PAGE;
|
|
|
|
yield();
|
|
|
|
}
|
2006-08-04 19:41:22 +00:00
|
|
|
if (do_unlock)
|
2006-05-05 20:59:11 +00:00
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_readpages - Read a bunch of pages at once
|
|
|
|
*
|
|
|
|
* Some notes:
|
|
|
|
* 1. This is only for readahead, so we can simply ignore any things
|
|
|
|
* which are slightly inconvenient (such as locking conflicts between
|
|
|
|
* the page lock and the glock) and return having done no I/O. Its
|
|
|
|
* obviously not something we'd want to do on too regular a basis.
|
|
|
|
* Any I/O we ignore at this time will be done via readpage later.
|
2006-12-15 21:49:51 +00:00
|
|
|
* 2. We don't handle stuffed files here we let readpage do the honours.
|
2006-05-05 20:59:11 +00:00
|
|
|
* 3. mpage_readpages() does most of the heavy lifting in the common case.
|
|
|
|
* 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places.
|
|
|
|
* 5. We use LM_FLAG_TRY_1CB here, effectively we then have lock-ahead as
|
|
|
|
* well as read-ahead.
|
|
|
|
*/
|
|
|
|
static int gfs2_readpages(struct file *file, struct address_space *mapping,
|
|
|
|
struct list_head *pages, unsigned nr_pages)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-05-05 20:59:11 +00:00
|
|
|
struct gfs2_holder gh;
|
2006-12-15 21:49:51 +00:00
|
|
|
int ret = 0;
|
2006-08-04 19:41:22 +00:00
|
|
|
int do_unlock = 0;
|
2006-05-05 20:59:11 +00:00
|
|
|
|
2006-09-04 18:53:30 +00:00
|
|
|
if (likely(file != &gfs2_internal_file_sentinel)) {
|
2006-08-04 19:41:22 +00:00
|
|
|
if (file) {
|
|
|
|
struct gfs2_file *gf = file->private_data;
|
|
|
|
if (test_bit(GFF_EXLOCK, &gf->f_flags))
|
|
|
|
goto skip_lock;
|
|
|
|
}
|
2006-05-05 20:59:11 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
|
2006-11-08 15:26:54 +00:00
|
|
|
LM_FLAG_TRY_1CB|GL_ATIME, &gh);
|
2006-08-04 19:41:22 +00:00
|
|
|
do_unlock = 1;
|
2006-11-16 16:08:16 +00:00
|
|
|
ret = gfs2_glock_nq_atime(&gh);
|
2006-09-25 13:26:04 +00:00
|
|
|
if (ret == GLR_TRYFAILED)
|
2006-05-05 20:59:11 +00:00
|
|
|
goto out_noerror;
|
|
|
|
if (unlikely(ret))
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2006-08-04 19:41:22 +00:00
|
|
|
skip_lock:
|
2006-12-15 21:49:51 +00:00
|
|
|
if (!gfs2_is_stuffed(ip))
|
2006-05-05 20:59:11 +00:00
|
|
|
ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
|
|
|
|
|
2006-08-04 19:41:22 +00:00
|
|
|
if (do_unlock) {
|
2006-05-05 20:59:11 +00:00
|
|
|
gfs2_glock_dq_m(1, &gh);
|
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
|
|
|
|
ret = -EIO;
|
|
|
|
return ret;
|
|
|
|
out_noerror:
|
|
|
|
ret = 0;
|
|
|
|
out_unlock:
|
2006-08-04 19:41:22 +00:00
|
|
|
if (do_unlock)
|
2006-05-05 20:59:11 +00:00
|
|
|
gfs2_holder_uninit(&gh);
|
2006-02-08 11:50:51 +00:00
|
|
|
goto out;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_prepare_write - Prepare to write a page to a file
|
|
|
|
* @file: The file to write to
|
|
|
|
* @page: The page which is to be prepared for writing
|
|
|
|
* @from: From (byte range within page)
|
|
|
|
* @to: To (byte range within page)
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_prepare_write(struct file *file, struct page *page,
|
|
|
|
unsigned from, unsigned to)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(page->mapping->host);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
|
2006-02-08 11:50:51 +00:00
|
|
|
unsigned int data_blocks, ind_blocks, rblocks;
|
|
|
|
int alloc_required;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error = 0;
|
2006-02-08 11:50:51 +00:00
|
|
|
loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from;
|
|
|
|
loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
|
|
|
|
struct gfs2_alloc *al;
|
2006-10-09 17:11:54 +00:00
|
|
|
unsigned int write_len = to - from;
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-11-08 15:26:54 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|LM_FLAG_TRY_1CB, &ip->i_gh);
|
2006-11-16 16:08:16 +00:00
|
|
|
error = gfs2_glock_nq_atime(&ip->i_gh);
|
2006-11-08 15:26:54 +00:00
|
|
|
if (unlikely(error)) {
|
2007-02-07 15:25:59 +00:00
|
|
|
if (error == GLR_TRYFAILED) {
|
|
|
|
unlock_page(page);
|
2006-11-08 15:26:54 +00:00
|
|
|
error = AOP_TRUNCATED_PAGE;
|
2007-02-23 17:49:51 +00:00
|
|
|
yield();
|
2007-02-07 15:25:59 +00:00
|
|
|
}
|
2006-02-08 11:50:51 +00:00
|
|
|
goto out_uninit;
|
2006-11-08 15:26:54 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-10-09 17:11:54 +00:00
|
|
|
gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
|
2006-02-08 11:50:51 +00:00
|
|
|
|
2006-10-09 17:11:54 +00:00
|
|
|
error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
|
2006-02-08 11:50:51 +00:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
|
2006-10-10 17:45:15 +00:00
|
|
|
ip->i_alloc.al_requested = 0;
|
2006-02-08 11:50:51 +00:00
|
|
|
if (alloc_required) {
|
|
|
|
al = gfs2_alloc_get(ip);
|
|
|
|
|
|
|
|
error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
|
|
|
|
if (error)
|
|
|
|
goto out_alloc_put;
|
|
|
|
|
2006-11-01 18:23:29 +00:00
|
|
|
error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
|
2006-02-08 11:50:51 +00:00
|
|
|
if (error)
|
|
|
|
goto out_qunlock;
|
|
|
|
|
|
|
|
al->al_requested = data_blocks + ind_blocks;
|
|
|
|
error = gfs2_inplace_reserve(ip);
|
|
|
|
if (error)
|
|
|
|
goto out_qunlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
rblocks = RES_DINODE + ind_blocks;
|
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
rblocks += data_blocks ? data_blocks : 1;
|
|
|
|
if (ind_blocks || data_blocks)
|
|
|
|
rblocks += RES_STATFS + RES_QUOTA;
|
|
|
|
|
|
|
|
error = gfs2_trans_begin(sdp, rblocks, 0);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip)) {
|
|
|
|
if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
|
2006-07-26 14:51:20 +00:00
|
|
|
error = gfs2_unstuff_dinode(ip, page);
|
2006-02-15 12:26:19 +00:00
|
|
|
if (error == 0)
|
|
|
|
goto prepare_write;
|
|
|
|
} else if (!PageUptodate(page))
|
2006-01-16 16:50:04 +00:00
|
|
|
error = stuffed_readpage(ip, page);
|
2006-02-15 12:26:19 +00:00
|
|
|
goto out;
|
2006-02-08 11:50:51 +00:00
|
|
|
}
|
|
|
|
|
2006-02-15 12:26:19 +00:00
|
|
|
prepare_write:
|
2006-02-08 11:50:51 +00:00
|
|
|
error = block_prepare_write(page, from, to, gfs2_get_block);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (error) {
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
if (alloc_required) {
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
out_qunlock:
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
out_alloc_put:
|
|
|
|
gfs2_alloc_put(ip);
|
|
|
|
}
|
|
|
|
out_unlock:
|
|
|
|
gfs2_glock_dq_m(1, &ip->i_gh);
|
|
|
|
out_uninit:
|
|
|
|
gfs2_holder_uninit(&ip->i_gh);
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 14:37:57 +00:00
|
|
|
/**
|
|
|
|
* adjust_fs_space - Adjusts the free space available due to gfs2_grow
|
|
|
|
* @inode: the rindex inode
|
|
|
|
*/
|
|
|
|
static void adjust_fs_space(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
|
|
|
|
struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
|
|
|
|
struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
|
|
|
|
u64 fs_total, new_free;
|
|
|
|
|
|
|
|
/* Total up the file system space, according to the latest rindex. */
|
|
|
|
fs_total = gfs2_ri_total(sdp);
|
|
|
|
|
|
|
|
spin_lock(&sdp->sd_statfs_spin);
|
|
|
|
if (fs_total > (m_sc->sc_total + l_sc->sc_total))
|
|
|
|
new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
|
|
|
|
else
|
|
|
|
new_free = 0;
|
|
|
|
spin_unlock(&sdp->sd_statfs_spin);
|
2007-05-10 21:54:38 +00:00
|
|
|
fs_warn(sdp, "File system extended by %llu blocks.\n",
|
|
|
|
(unsigned long long)new_free);
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 14:37:57 +00:00
|
|
|
gfs2_statfs_change(sdp, new_free, new_free, 0);
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* gfs2_commit_write - Commit write to a file
|
|
|
|
* @file: The file to write to
|
|
|
|
* @page: The page containing the data
|
|
|
|
* @from: From (byte range within page)
|
|
|
|
* @to: To (byte range within page)
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_commit_write(struct file *file, struct page *page,
|
|
|
|
unsigned from, unsigned to)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-02-08 11:50:51 +00:00
|
|
|
int error = -EOPNOTSUPP;
|
|
|
|
struct buffer_head *dibh;
|
2006-10-02 16:39:19 +00:00
|
|
|
struct gfs2_alloc *al = &ip->i_alloc;
|
|
|
|
struct gfs2_dinode *di;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
|
|
|
|
goto fail_nounlock;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
goto fail_endtrans;
|
|
|
|
|
|
|
|
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
|
2006-10-02 16:39:19 +00:00
|
|
|
di = (struct gfs2_dinode *)dibh->b_data;
|
2006-02-08 11:50:51 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
if (gfs2_is_stuffed(ip)) {
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 file_size;
|
2006-01-16 16:50:04 +00:00
|
|
|
void *kaddr;
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
file_size = ((u64)page->index << PAGE_CACHE_SHIFT) + to;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
2006-01-16 16:50:04 +00:00
|
|
|
memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
|
2006-09-04 18:59:35 +00:00
|
|
|
kaddr + from, to - from);
|
2006-10-12 13:23:41 +00:00
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
SetPageUptodate(page);
|
|
|
|
|
2006-11-22 16:28:47 +00:00
|
|
|
if (inode->i_size < file_size) {
|
2006-01-16 16:50:04 +00:00
|
|
|
i_size_write(inode, file_size);
|
2006-11-22 16:28:47 +00:00
|
|
|
mark_inode_dirty(inode);
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
} else {
|
2006-02-27 17:00:42 +00:00
|
|
|
if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
|
|
|
|
gfs2_is_jdata(ip))
|
2006-01-31 10:00:25 +00:00
|
|
|
gfs2_page_add_databufs(ip, page, from, to);
|
2006-01-16 16:50:04 +00:00
|
|
|
error = generic_commit_write(file, page, from, to);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2006-10-02 16:39:19 +00:00
|
|
|
if (ip->i_di.di_size < inode->i_size) {
|
2006-02-08 11:50:51 +00:00
|
|
|
ip->i_di.di_size = inode->i_size;
|
2006-10-02 16:39:19 +00:00
|
|
|
di->di_size = cpu_to_be64(inode->i_size);
|
|
|
|
}
|
|
|
|
|
[GFS2] kernel changes to support new gfs2_grow command
This is another revision of my gfs2 kernel patch that allows
gfs2_grow to function properly.
Steve Whitehouse expressed some concerns about the previous
patch and I restructured it based on his comments.
The previous patch was doing the statfs_change at file close time,
under its own transaction. The current patch does the statfs_change
inside the gfs2_commit_write function, which keeps it under the
umbrella of the inode transaction.
I can't call ri_update to re-read the rindex file during the
transaction because the transaction may have outstanding unwritten
buffers attached to the rgrps that would be otherwise blown away.
So instead, I created a new function, gfs2_ri_total, that will
re-read the rindex file just to total the file system space
for the sake of the statfs_change. The ri_update will happen
later, when gfs2 realizes the version number has changed, as it
happened before my patch.
Since the statfs_change is happening at write_commit time and there
may be multiple writes to the rindex file for one grow operation.
So one consequence of this restructuring is that instead of getting
one kernel message to indicate the change, you may see several.
For example, before when you did a gfs2_grow, you'd get a single
message like:
GFS2: File system extended by 247876 blocks (968MB)
Now you get something like:
GFS2: File system extended by 207896 blocks (812MB)
GFS2: File system extended by 39980 blocks (156MB)
This version has also been successfully run against the hours-long
"gfs2_fsck_hellfire" test that does several gfs2_grow and gfs2_fsck
while interjecting file system damage. It does this repeatedly
under a variety Resource Group conditions.
Signed-off-By: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-05-09 14:37:57 +00:00
|
|
|
if (inode == sdp->sd_rindex)
|
|
|
|
adjust_fs_space(inode);
|
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
brelse(dibh);
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
if (al->al_requested) {
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
gfs2_alloc_put(ip);
|
|
|
|
}
|
2007-03-12 21:55:07 +00:00
|
|
|
unlock_page(page);
|
2006-02-08 11:50:51 +00:00
|
|
|
gfs2_glock_dq_m(1, &ip->i_gh);
|
2007-03-12 21:55:07 +00:00
|
|
|
lock_page(page);
|
2006-02-08 11:50:51 +00:00
|
|
|
gfs2_holder_uninit(&ip->i_gh);
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
fail:
|
|
|
|
brelse(dibh);
|
|
|
|
fail_endtrans:
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
if (al->al_requested) {
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
gfs2_alloc_put(ip);
|
|
|
|
}
|
2007-03-12 21:55:07 +00:00
|
|
|
unlock_page(page);
|
2006-02-08 11:50:51 +00:00
|
|
|
gfs2_glock_dq_m(1, &ip->i_gh);
|
2007-03-12 21:55:07 +00:00
|
|
|
lock_page(page);
|
2006-02-08 11:50:51 +00:00
|
|
|
gfs2_holder_uninit(&ip->i_gh);
|
|
|
|
fail_nounlock:
|
2006-01-16 16:50:04 +00:00
|
|
|
ClearPageUptodate(page);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-06-12 16:24:36 +00:00
|
|
|
/**
|
|
|
|
* gfs2_set_page_dirty - Page dirtying function
|
|
|
|
* @page: The page to dirty
|
|
|
|
*
|
|
|
|
* Returns: 1 if it dirtyed the page, or 0 otherwise
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_set_page_dirty(struct page *page)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(page->mapping->host);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip))
|
|
|
|
SetPageChecked(page);
|
|
|
|
return __set_page_dirty_buffers(page);
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* gfs2_bmap - Block map function
|
|
|
|
* @mapping: Address space info
|
|
|
|
* @lblock: The block to map
|
|
|
|
*
|
|
|
|
* Returns: The disk address for the block or 0 on hole or error
|
|
|
|
*/
|
|
|
|
|
|
|
|
static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(mapping->host);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
sector_t dblock = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
|
|
|
|
if (error)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!gfs2_is_stuffed(ip))
|
2006-01-30 09:39:10 +00:00
|
|
|
dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
|
|
|
|
return dblock;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
|
|
|
|
{
|
2006-01-18 13:14:40 +00:00
|
|
|
struct gfs2_bufdata *bd;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
gfs2_log_lock(sdp);
|
2006-02-27 22:23:27 +00:00
|
|
|
bd = bh->b_private;
|
2006-01-18 13:14:40 +00:00
|
|
|
if (bd) {
|
|
|
|
bd->bd_bh = NULL;
|
2006-02-27 22:23:27 +00:00
|
|
|
bh->b_private = NULL;
|
2007-06-12 16:24:36 +00:00
|
|
|
if (!bd->bd_ail && list_empty(&bd->bd_le.le_list))
|
|
|
|
kmem_cache_free(gfs2_bufdata_cachep, bd);
|
2006-08-18 19:51:09 +00:00
|
|
|
}
|
|
|
|
gfs2_log_unlock(sdp);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
lock_buffer(bh);
|
|
|
|
clear_buffer_dirty(bh);
|
|
|
|
bh->b_bdev = NULL;
|
|
|
|
clear_buffer_mapped(bh);
|
|
|
|
clear_buffer_req(bh);
|
|
|
|
clear_buffer_new(bh);
|
|
|
|
clear_buffer_delay(bh);
|
|
|
|
unlock_buffer(bh);
|
|
|
|
}
|
|
|
|
|
2006-03-31 21:48:41 +00:00
|
|
|
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-08-18 19:51:09 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct buffer_head *head, *bh, *next;
|
|
|
|
unsigned int curr_off = 0;
|
|
|
|
|
|
|
|
BUG_ON(!PageLocked(page));
|
2007-06-12 16:24:36 +00:00
|
|
|
if (offset == 0)
|
|
|
|
ClearPageChecked(page);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!page_has_buffers(page))
|
2006-03-31 21:48:41 +00:00
|
|
|
return;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
bh = head = page_buffers(page);
|
|
|
|
do {
|
|
|
|
unsigned int next_off = curr_off + bh->b_size;
|
|
|
|
next = bh->b_this_page;
|
|
|
|
|
|
|
|
if (offset <= curr_off)
|
|
|
|
discard_buffer(sdp, bh);
|
|
|
|
|
|
|
|
curr_off = next_off;
|
|
|
|
bh = next;
|
|
|
|
} while (bh != head);
|
|
|
|
|
|
|
|
if (!offset)
|
2006-03-31 21:48:41 +00:00
|
|
|
try_to_release_page(page, 0);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-31 21:48:41 +00:00
|
|
|
return;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-12-14 18:24:26 +00:00
|
|
|
/**
|
|
|
|
* gfs2_ok_for_dio - check that dio is valid on this file
|
|
|
|
* @ip: The inode
|
|
|
|
* @rw: READ or WRITE
|
|
|
|
* @offset: The offset at which we are reading or writing
|
|
|
|
*
|
|
|
|
* Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)
|
|
|
|
* 1 (to accept the i/o request)
|
|
|
|
*/
|
|
|
|
static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Should we return an error here? I can't see that O_DIRECT for
|
|
|
|
* a journaled file makes any sense. For now we'll silently fall
|
|
|
|
* back to buffered I/O, likewise we do the same for stuffed
|
|
|
|
* files since they are (a) small and (b) unaligned.
|
|
|
|
*/
|
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (offset > i_size_read(&ip->i_inode))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-07-25 21:24:12 +00:00
|
|
|
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
|
|
|
|
const struct iovec *iov, loff_t offset,
|
|
|
|
unsigned long nr_segs)
|
2006-02-14 11:54:42 +00:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-02-14 11:54:42 +00:00
|
|
|
struct gfs2_holder gh;
|
|
|
|
int rv;
|
|
|
|
|
|
|
|
/*
|
2006-12-14 18:24:26 +00:00
|
|
|
* Deferred lock, even if its a write, since we do no allocation
|
|
|
|
* on this path. All we need change is atime, and this lock mode
|
|
|
|
* ensures that other nodes have flushed their buffered read caches
|
|
|
|
* (i.e. their page cache entries for this inode). We do not,
|
|
|
|
* unfortunately have the option of only flushing a range like
|
|
|
|
* the VFS does.
|
2006-02-14 11:54:42 +00:00
|
|
|
*/
|
2006-12-14 18:24:26 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
|
2006-11-16 16:08:16 +00:00
|
|
|
rv = gfs2_glock_nq_atime(&gh);
|
2006-02-14 11:54:42 +00:00
|
|
|
if (rv)
|
2006-12-14 18:24:26 +00:00
|
|
|
return rv;
|
|
|
|
rv = gfs2_ok_for_dio(ip, rw, offset);
|
|
|
|
if (rv != 1)
|
|
|
|
goto out; /* dio not valid, fall back to buffered i/o */
|
|
|
|
|
|
|
|
rv = blockdev_direct_IO_no_locking(rw, iocb, inode, inode->i_sb->s_bdev,
|
|
|
|
iov, offset, nr_segs,
|
|
|
|
gfs2_get_block_direct, NULL);
|
2006-02-14 11:54:42 +00:00
|
|
|
out:
|
|
|
|
gfs2_glock_dq_m(1, &gh);
|
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2006-07-11 13:46:33 +00:00
|
|
|
/**
|
|
|
|
* stuck_releasepage - We're stuck in gfs2_releasepage(). Print stuff out.
|
|
|
|
* @bh: the buffer we're stuck on
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void stuck_releasepage(struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
struct inode *inode = bh->b_page->mapping->host;
|
|
|
|
struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
|
|
|
|
struct gfs2_bufdata *bd = bh->b_private;
|
|
|
|
struct gfs2_glock *gl;
|
2006-08-24 19:59:40 +00:00
|
|
|
static unsigned limit = 0;
|
|
|
|
|
2006-09-04 18:59:35 +00:00
|
|
|
if (limit > 3)
|
2006-08-24 19:59:40 +00:00
|
|
|
return;
|
2006-09-04 18:59:35 +00:00
|
|
|
limit++;
|
2006-07-11 13:46:33 +00:00
|
|
|
|
|
|
|
fs_warn(sdp, "stuck in gfs2_releasepage() %p\n", inode);
|
|
|
|
fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n",
|
|
|
|
(unsigned long long)bh->b_blocknr, atomic_read(&bh->b_count));
|
|
|
|
fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh));
|
|
|
|
fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL");
|
|
|
|
|
|
|
|
if (!bd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
gl = bd->bd_gl;
|
|
|
|
|
2006-09-25 13:26:04 +00:00
|
|
|
fs_warn(sdp, "gl = (%u, %llu)\n",
|
2006-07-11 13:46:33 +00:00
|
|
|
gl->gl_name.ln_type, (unsigned long long)gl->gl_name.ln_number);
|
|
|
|
|
|
|
|
fs_warn(sdp, "bd_list_tr = %s, bd_le.le_list = %s\n",
|
|
|
|
(list_empty(&bd->bd_list_tr)) ? "no" : "yes",
|
|
|
|
(list_empty(&bd->bd_le.le_list)) ? "no" : "yes");
|
|
|
|
|
|
|
|
if (gl->gl_ops == &gfs2_inode_glops) {
|
|
|
|
struct gfs2_inode *ip = gl->gl_object;
|
|
|
|
unsigned int x;
|
|
|
|
|
|
|
|
if (!ip)
|
|
|
|
return;
|
|
|
|
|
|
|
|
fs_warn(sdp, "ip = %llu %llu\n",
|
2007-05-15 14:37:50 +00:00
|
|
|
(unsigned long long)ip->i_no_formal_ino,
|
|
|
|
(unsigned long long)ip->i_no_addr);
|
2006-07-11 13:46:33 +00:00
|
|
|
|
|
|
|
for (x = 0; x < GFS2_MAX_META_HEIGHT; x++)
|
|
|
|
fs_warn(sdp, "ip->i_cache[%u] = %s\n",
|
|
|
|
x, (ip->i_cache[x]) ? "!NULL" : "NULL");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-08-31 16:14:44 +00:00
|
|
|
* gfs2_releasepage - free the metadata associated with a page
|
2006-07-11 13:46:33 +00:00
|
|
|
* @page: the page that's being released
|
|
|
|
* @gfp_mask: passed from Linux VFS, ignored by us
|
|
|
|
*
|
|
|
|
* Call try_to_free_buffers() if the buffers in this page can be
|
|
|
|
* released.
|
|
|
|
*
|
|
|
|
* Returns: 0
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
|
|
|
|
{
|
|
|
|
struct inode *aspace = page->mapping->host;
|
|
|
|
struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;
|
|
|
|
struct buffer_head *bh, *head;
|
|
|
|
struct gfs2_bufdata *bd;
|
2006-08-24 19:59:40 +00:00
|
|
|
unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
|
2006-07-11 13:46:33 +00:00
|
|
|
|
|
|
|
if (!page_has_buffers(page))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
head = bh = page_buffers(page);
|
|
|
|
do {
|
|
|
|
while (atomic_read(&bh->b_count)) {
|
2006-08-24 19:59:40 +00:00
|
|
|
if (!atomic_read(&aspace->i_writecount))
|
|
|
|
return 0;
|
|
|
|
|
2006-11-09 16:42:33 +00:00
|
|
|
if (!(gfp_mask & __GFP_WAIT))
|
|
|
|
return 0;
|
|
|
|
|
2006-08-24 19:59:40 +00:00
|
|
|
if (time_after_eq(jiffies, t)) {
|
|
|
|
stuck_releasepage(bh);
|
|
|
|
/* should we withdraw here? */
|
|
|
|
return 0;
|
2006-07-11 13:46:33 +00:00
|
|
|
}
|
|
|
|
|
2006-08-24 19:59:40 +00:00
|
|
|
yield();
|
2006-07-11 13:46:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_assert_warn(sdp, !buffer_pinned(bh));
|
2006-08-31 16:14:44 +00:00
|
|
|
gfs2_assert_warn(sdp, !buffer_dirty(bh));
|
2006-07-11 13:46:33 +00:00
|
|
|
|
2006-08-31 16:14:44 +00:00
|
|
|
gfs2_log_lock(sdp);
|
2006-07-11 13:46:33 +00:00
|
|
|
bd = bh->b_private;
|
|
|
|
if (bd) {
|
|
|
|
gfs2_assert_warn(sdp, bd->bd_bh == bh);
|
|
|
|
gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
|
|
|
|
gfs2_assert_warn(sdp, !bd->bd_ail);
|
2006-08-31 16:14:44 +00:00
|
|
|
bd->bd_bh = NULL;
|
|
|
|
if (!list_empty(&bd->bd_le.le_list))
|
|
|
|
bd = NULL;
|
2006-07-11 13:46:33 +00:00
|
|
|
bh->b_private = NULL;
|
|
|
|
}
|
2006-08-31 16:14:44 +00:00
|
|
|
gfs2_log_unlock(sdp);
|
|
|
|
if (bd)
|
|
|
|
kmem_cache_free(gfs2_bufdata_cachep, bd);
|
2006-07-11 13:46:33 +00:00
|
|
|
|
|
|
|
bh = bh->b_this_page;
|
2006-08-24 19:59:40 +00:00
|
|
|
} while (bh != head);
|
2006-07-11 13:46:33 +00:00
|
|
|
|
2006-07-25 21:24:12 +00:00
|
|
|
out:
|
2006-07-11 13:46:33 +00:00
|
|
|
return try_to_free_buffers(page);
|
|
|
|
}
|
|
|
|
|
2006-07-03 17:37:30 +00:00
|
|
|
const struct address_space_operations gfs2_file_aops = {
|
2006-01-16 16:50:04 +00:00
|
|
|
.writepage = gfs2_writepage,
|
2007-01-15 13:52:17 +00:00
|
|
|
.writepages = gfs2_writepages,
|
2006-01-16 16:50:04 +00:00
|
|
|
.readpage = gfs2_readpage,
|
2006-05-05 20:59:11 +00:00
|
|
|
.readpages = gfs2_readpages,
|
2006-01-16 16:50:04 +00:00
|
|
|
.sync_page = block_sync_page,
|
|
|
|
.prepare_write = gfs2_prepare_write,
|
|
|
|
.commit_write = gfs2_commit_write,
|
2007-06-12 16:24:36 +00:00
|
|
|
.set_page_dirty = gfs2_set_page_dirty,
|
2006-01-16 16:50:04 +00:00
|
|
|
.bmap = gfs2_bmap,
|
|
|
|
.invalidatepage = gfs2_invalidatepage,
|
2006-07-11 13:46:33 +00:00
|
|
|
.releasepage = gfs2_releasepage,
|
2006-01-16 16:50:04 +00:00
|
|
|
.direct_IO = gfs2_direct_IO,
|
|
|
|
};
|
|
|
|
|