Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw
Pull GFS2 updates from Steven Whitehouse: "There are a few bug fixes for various, mostly very minor corner cases, plus some interesting new features. The new features include atomic_open whose main benefit will be the reduction in locking overhead in case of combined lookup/create and open operations, sorting the log buffer lists by block number to improve the efficiency of AIL writeback, and aggressively issuing revokes in gfs2_log_flush to reduce overhead when dropping glocks." * git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw: GFS2: Reserve journal space for quota change in do_grow GFS2: Fix fstrim boundary conditions GFS2: fix warning message GFS2: aggressively issue revokes in gfs2_log_flush GFS2: fix regression in dir_double_exhash GFS2: Add atomic_open support GFS2: Only do one directory search on create GFS2: fix error propagation in init_threads() GFS2: Remove no-op wrapper function GFS2: Cocci spatch "ptr_ret.spatch" GFS2: Eliminate gfs2_rg_lops GFS2: Sort buffer lists by inplace block number
This commit is contained in:
Linus Torvalds
commit
c4eb1b0730
17 changed files with 294 additions and 129 deletions
11
fs/dcache.c
11
fs/dcache.c
|
|
@ -1612,6 +1612,10 @@ EXPORT_SYMBOL(d_obtain_alias);
|
|||
* If a dentry was found and moved, then it is returned. Otherwise NULL
|
||||
* is returned. This matches the expected return value of ->lookup.
|
||||
*
|
||||
* Cluster filesystems may call this function with a negative, hashed dentry.
|
||||
* In that case, we know that the inode will be a regular file, and also this
|
||||
* will only occur during atomic_open. So we need to check for the dentry
|
||||
* being already hashed only in the final case.
|
||||
*/
|
||||
struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
|
||||
{
|
||||
|
|
@ -1636,8 +1640,11 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
|
|||
security_d_instantiate(dentry, inode);
|
||||
d_rehash(dentry);
|
||||
}
|
||||
} else
|
||||
d_add(dentry, inode);
|
||||
} else {
|
||||
d_instantiate(dentry, inode);
|
||||
if (d_unhashed(dentry))
|
||||
d_rehash(dentry);
|
||||
}
|
||||
return new;
|
||||
}
|
||||
EXPORT_SYMBOL(d_splice_alias);
|
||||
|
|
|
|||
|
|
@ -1232,7 +1232,9 @@ static int do_grow(struct inode *inode, u64 size)
|
|||
unstuff = 1;
|
||||
}
|
||||
|
||||
error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);
|
||||
error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
|
||||
(sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
|
||||
0 : RES_QUOTA), 0);
|
||||
if (error)
|
||||
goto do_grow_release;
|
||||
|
||||
|
|
|
|||
|
|
@ -1125,13 +1125,14 @@ static int dir_double_exhash(struct gfs2_inode *dip)
|
|||
if (IS_ERR(hc))
|
||||
return PTR_ERR(hc);
|
||||
|
||||
h = hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN);
|
||||
hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN);
|
||||
if (hc2 == NULL)
|
||||
hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS, PAGE_KERNEL);
|
||||
|
||||
if (!hc2)
|
||||
return -ENOMEM;
|
||||
|
||||
h = hc2;
|
||||
error = gfs2_meta_inode_buffer(dip, &dibh);
|
||||
if (error)
|
||||
goto out_kfree;
|
||||
|
|
@ -1547,9 +1548,9 @@ int gfs2_dir_read(struct inode *inode, struct dir_context *ctx,
|
|||
|
||||
/**
|
||||
* gfs2_dir_search - Search a directory
|
||||
* @dip: The GFS2 inode
|
||||
* @filename:
|
||||
* @inode:
|
||||
* @dip: The GFS2 dir inode
|
||||
* @name: The name we are looking up
|
||||
* @fail_on_exist: Fail if the name exists rather than looking it up
|
||||
*
|
||||
* This routine searches a directory for a file or another directory.
|
||||
* Assumes a glock is held on dip.
|
||||
|
|
@ -1557,22 +1558,25 @@ int gfs2_dir_read(struct inode *inode, struct dir_context *ctx,
|
|||
* Returns: errno
|
||||
*/
|
||||
|
||||
struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
|
||||
struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name,
|
||||
bool fail_on_exist)
|
||||
{
|
||||
struct buffer_head *bh;
|
||||
struct gfs2_dirent *dent;
|
||||
struct inode *inode;
|
||||
u64 addr, formal_ino;
|
||||
u16 dtype;
|
||||
|
||||
dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
|
||||
if (dent) {
|
||||
if (IS_ERR(dent))
|
||||
return ERR_CAST(dent);
|
||||
inode = gfs2_inode_lookup(dir->i_sb,
|
||||
be16_to_cpu(dent->de_type),
|
||||
be64_to_cpu(dent->de_inum.no_addr),
|
||||
be64_to_cpu(dent->de_inum.no_formal_ino), 0);
|
||||
dtype = be16_to_cpu(dent->de_type);
|
||||
addr = be64_to_cpu(dent->de_inum.no_addr);
|
||||
formal_ino = be64_to_cpu(dent->de_inum.no_formal_ino);
|
||||
brelse(bh);
|
||||
return inode;
|
||||
if (fail_on_exist)
|
||||
return ERR_PTR(-EEXIST);
|
||||
return gfs2_inode_lookup(dir->i_sb, dtype, addr, formal_ino, 0);
|
||||
}
|
||||
return ERR_PTR(-ENOENT);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,8 @@ struct gfs2_inode;
|
|||
struct gfs2_inum;
|
||||
|
||||
extern struct inode *gfs2_dir_search(struct inode *dir,
|
||||
const struct qstr *filename);
|
||||
const struct qstr *filename,
|
||||
bool fail_on_exist);
|
||||
extern int gfs2_dir_check(struct inode *dir, const struct qstr *filename,
|
||||
const struct gfs2_inode *ip);
|
||||
extern int gfs2_dir_add(struct inode *inode, const struct qstr *filename,
|
||||
|
|
|
|||
|
|
@ -530,11 +530,52 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_open_common - This is common to open and atomic_open
|
||||
* @inode: The inode being opened
|
||||
* @file: The file being opened
|
||||
*
|
||||
* This maybe called under a glock or not depending upon how it has
|
||||
* been called. We must always be called under a glock for regular
|
||||
* files, however. For other file types, it does not matter whether
|
||||
* we hold the glock or not.
|
||||
*
|
||||
* Returns: Error code or 0 for success
|
||||
*/
|
||||
|
||||
int gfs2_open_common(struct inode *inode, struct file *file)
|
||||
{
|
||||
struct gfs2_file *fp;
|
||||
int ret;
|
||||
|
||||
if (S_ISREG(inode->i_mode)) {
|
||||
ret = generic_file_open(inode, file);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
|
||||
if (!fp)
|
||||
return -ENOMEM;
|
||||
|
||||
mutex_init(&fp->f_fl_mutex);
|
||||
|
||||
gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
|
||||
file->private_data = fp;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_open - open a file
|
||||
* @inode: the inode to open
|
||||
* @file: the struct file for this opening
|
||||
*
|
||||
* After atomic_open, this function is only used for opening files
|
||||
* which are already cached. We must still get the glock for regular
|
||||
* files to ensure that we have the file size uptodate for the large
|
||||
* file check which is in the common code. That is only an issue for
|
||||
* regular files though.
|
||||
*
|
||||
* Returns: errno
|
||||
*/
|
||||
|
||||
|
|
@ -542,40 +583,22 @@ static int gfs2_open(struct inode *inode, struct file *file)
|
|||
{
|
||||
struct gfs2_inode *ip = GFS2_I(inode);
|
||||
struct gfs2_holder i_gh;
|
||||
struct gfs2_file *fp;
|
||||
int error;
|
||||
|
||||
fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
|
||||
if (!fp)
|
||||
return -ENOMEM;
|
||||
|
||||
mutex_init(&fp->f_fl_mutex);
|
||||
|
||||
gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
|
||||
file->private_data = fp;
|
||||
bool need_unlock = false;
|
||||
|
||||
if (S_ISREG(ip->i_inode.i_mode)) {
|
||||
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
|
||||
&i_gh);
|
||||
if (error)
|
||||
goto fail;
|
||||
|
||||
if (!(file->f_flags & O_LARGEFILE) &&
|
||||
i_size_read(inode) > MAX_NON_LFS) {
|
||||
error = -EOVERFLOW;
|
||||
goto fail_gunlock;
|
||||
}
|
||||
|
||||
gfs2_glock_dq_uninit(&i_gh);
|
||||
return error;
|
||||
need_unlock = true;
|
||||
}
|
||||
|
||||
return 0;
|
||||
error = gfs2_open_common(inode, file);
|
||||
|
||||
if (need_unlock)
|
||||
gfs2_glock_dq_uninit(&i_gh);
|
||||
|
||||
fail_gunlock:
|
||||
gfs2_glock_dq_uninit(&i_gh);
|
||||
fail:
|
||||
file->private_data = NULL;
|
||||
kfree(fp);
|
||||
return error;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -54,7 +54,6 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
|
|||
struct gfs2_bufdata *bd, *tmp;
|
||||
struct buffer_head *bh;
|
||||
const unsigned long b_state = (1UL << BH_Dirty)|(1UL << BH_Pinned)|(1UL << BH_Lock);
|
||||
sector_t blocknr;
|
||||
|
||||
gfs2_log_lock(sdp);
|
||||
spin_lock(&sdp->sd_ail_lock);
|
||||
|
|
@ -65,13 +64,6 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
|
|||
continue;
|
||||
gfs2_ail_error(gl, bh);
|
||||
}
|
||||
blocknr = bh->b_blocknr;
|
||||
bh->b_private = NULL;
|
||||
gfs2_remove_from_ail(bd); /* drops ref on bh */
|
||||
|
||||
bd->bd_bh = NULL;
|
||||
bd->bd_blkno = blocknr;
|
||||
|
||||
gfs2_trans_add_revoke(sdp, bd);
|
||||
}
|
||||
GLOCK_BUG_ON(gl, !fsync && atomic_read(&gl->gl_ail_count));
|
||||
|
|
|
|||
150
fs/gfs2/inode.c
150
fs/gfs2/inode.c
|
|
@ -313,7 +313,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
|
|||
goto out;
|
||||
}
|
||||
|
||||
inode = gfs2_dir_search(dir, name);
|
||||
inode = gfs2_dir_search(dir, name, false);
|
||||
if (IS_ERR(inode))
|
||||
error = PTR_ERR(inode);
|
||||
out:
|
||||
|
|
@ -346,17 +346,6 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
|
|||
if (!dip->i_inode.i_nlink)
|
||||
return -ENOENT;
|
||||
|
||||
error = gfs2_dir_check(&dip->i_inode, name, NULL);
|
||||
switch (error) {
|
||||
case -ENOENT:
|
||||
error = 0;
|
||||
break;
|
||||
case 0:
|
||||
return -EEXIST;
|
||||
default:
|
||||
return error;
|
||||
}
|
||||
|
||||
if (dip->i_entries == (u32)-1)
|
||||
return -EFBIG;
|
||||
if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
|
||||
|
|
@ -546,6 +535,7 @@ static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
|
|||
* gfs2_create_inode - Create a new inode
|
||||
* @dir: The parent directory
|
||||
* @dentry: The new dentry
|
||||
* @file: If non-NULL, the file which is being opened
|
||||
* @mode: The permissions on the new inode
|
||||
* @dev: For device nodes, this is the device number
|
||||
* @symname: For symlinks, this is the link destination
|
||||
|
|
@ -555,8 +545,9 @@ static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
|
|||
*/
|
||||
|
||||
static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
|
||||
struct file *file,
|
||||
umode_t mode, dev_t dev, const char *symname,
|
||||
unsigned int size, int excl)
|
||||
unsigned int size, int excl, int *opened)
|
||||
{
|
||||
const struct qstr *name = &dentry->d_name;
|
||||
struct gfs2_holder ghs[2];
|
||||
|
|
@ -564,6 +555,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
|
|||
struct gfs2_inode *dip = GFS2_I(dir), *ip;
|
||||
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
||||
struct gfs2_glock *io_gl;
|
||||
struct dentry *d;
|
||||
int error;
|
||||
u32 aflags = 0;
|
||||
int arq;
|
||||
|
|
@ -584,15 +576,30 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
|
|||
goto fail;
|
||||
|
||||
error = create_ok(dip, name, mode);
|
||||
if ((error == -EEXIST) && S_ISREG(mode) && !excl) {
|
||||
inode = gfs2_lookupi(dir, &dentry->d_name, 0);
|
||||
gfs2_glock_dq_uninit(ghs);
|
||||
d_instantiate(dentry, inode);
|
||||
return IS_ERR(inode) ? PTR_ERR(inode) : 0;
|
||||
}
|
||||
if (error)
|
||||
goto fail_gunlock;
|
||||
|
||||
inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
|
||||
error = PTR_ERR(inode);
|
||||
if (!IS_ERR(inode)) {
|
||||
d = d_splice_alias(inode, dentry);
|
||||
error = 0;
|
||||
if (file && !IS_ERR(d)) {
|
||||
if (d == NULL)
|
||||
d = dentry;
|
||||
if (S_ISREG(inode->i_mode))
|
||||
error = finish_open(file, d, gfs2_open_common, opened);
|
||||
else
|
||||
error = finish_no_open(file, d);
|
||||
}
|
||||
gfs2_glock_dq_uninit(ghs);
|
||||
if (IS_ERR(d))
|
||||
return PTR_RET(d);
|
||||
return error;
|
||||
} else if (error != -ENOENT) {
|
||||
goto fail_gunlock;
|
||||
}
|
||||
|
||||
arq = error = gfs2_diradd_alloc_required(dir, name);
|
||||
if (error < 0)
|
||||
goto fail_gunlock;
|
||||
|
|
@ -686,10 +693,12 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
|
|||
goto fail_gunlock3;
|
||||
|
||||
mark_inode_dirty(inode);
|
||||
d_instantiate(dentry, inode);
|
||||
if (file)
|
||||
error = finish_open(file, dentry, gfs2_open_common, opened);
|
||||
gfs2_glock_dq_uninit(ghs);
|
||||
gfs2_glock_dq_uninit(ghs + 1);
|
||||
d_instantiate(dentry, inode);
|
||||
return 0;
|
||||
return error;
|
||||
|
||||
fail_gunlock3:
|
||||
gfs2_glock_dq_uninit(ghs + 1);
|
||||
|
|
@ -729,36 +738,56 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
|
|||
static int gfs2_create(struct inode *dir, struct dentry *dentry,
|
||||
umode_t mode, bool excl)
|
||||
{
|
||||
return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
|
||||
return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_lookup - Look up a filename in a directory and return its inode
|
||||
* __gfs2_lookup - Look up a filename in a directory and return its inode
|
||||
* @dir: The directory inode
|
||||
* @dentry: The dentry of the new inode
|
||||
* @nd: passed from Linux VFS, ignored by us
|
||||
* @file: File to be opened
|
||||
* @opened: atomic_open flags
|
||||
*
|
||||
* Called by the VFS layer. Lock dir and call gfs2_lookupi()
|
||||
*
|
||||
* Returns: errno
|
||||
*/
|
||||
|
||||
static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
|
||||
unsigned int flags)
|
||||
static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
|
||||
struct file *file, int *opened)
|
||||
{
|
||||
struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
|
||||
if (inode && !IS_ERR(inode)) {
|
||||
struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
|
||||
struct gfs2_holder gh;
|
||||
int error;
|
||||
error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
|
||||
if (error) {
|
||||
iput(inode);
|
||||
return ERR_PTR(error);
|
||||
}
|
||||
gfs2_glock_dq_uninit(&gh);
|
||||
struct inode *inode;
|
||||
struct dentry *d;
|
||||
struct gfs2_holder gh;
|
||||
struct gfs2_glock *gl;
|
||||
int error;
|
||||
|
||||
inode = gfs2_lookupi(dir, &dentry->d_name, 0);
|
||||
if (!inode)
|
||||
return NULL;
|
||||
if (IS_ERR(inode))
|
||||
return ERR_CAST(inode);
|
||||
|
||||
gl = GFS2_I(inode)->i_gl;
|
||||
error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
|
||||
if (error) {
|
||||
iput(inode);
|
||||
return ERR_PTR(error);
|
||||
}
|
||||
return d_splice_alias(inode, dentry);
|
||||
|
||||
d = d_splice_alias(inode, dentry);
|
||||
if (file && S_ISREG(inode->i_mode))
|
||||
error = finish_open(file, dentry, gfs2_open_common, opened);
|
||||
|
||||
gfs2_glock_dq_uninit(&gh);
|
||||
if (error)
|
||||
return ERR_PTR(error);
|
||||
return d;
|
||||
}
|
||||
|
||||
static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
|
||||
unsigned flags)
|
||||
{
|
||||
return __gfs2_lookup(dir, dentry, NULL, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1076,7 +1105,7 @@ static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
|
|||
if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
|
||||
return -ENAMETOOLONG;
|
||||
|
||||
return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
|
||||
return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1092,7 +1121,7 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
|||
{
|
||||
struct gfs2_sbd *sdp = GFS2_SB(dir);
|
||||
unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
|
||||
return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, dsize, 0);
|
||||
return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1107,7 +1136,43 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
|||
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
|
||||
dev_t dev)
|
||||
{
|
||||
return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
|
||||
return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* gfs2_atomic_open - Atomically open a file
|
||||
* @dir: The directory
|
||||
* @dentry: The proposed new entry
|
||||
* @file: The proposed new struct file
|
||||
* @flags: open flags
|
||||
* @mode: File mode
|
||||
* @opened: Flag to say whether the file has been opened or not
|
||||
*
|
||||
* Returns: error code or 0 for success
|
||||
*/
|
||||
|
||||
static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
|
||||
struct file *file, unsigned flags,
|
||||
umode_t mode, int *opened)
|
||||
{
|
||||
struct dentry *d;
|
||||
bool excl = !!(flags & O_EXCL);
|
||||
|
||||
d = __gfs2_lookup(dir, dentry, file, opened);
|
||||
if (IS_ERR(d))
|
||||
return PTR_ERR(d);
|
||||
if (d == NULL)
|
||||
d = dentry;
|
||||
if (d->d_inode) {
|
||||
if (!(*opened & FILE_OPENED))
|
||||
return finish_no_open(file, d);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!(flags & O_CREAT))
|
||||
return -ENOENT;
|
||||
|
||||
return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1787,6 +1852,7 @@ const struct inode_operations gfs2_dir_iops = {
|
|||
.removexattr = gfs2_removexattr,
|
||||
.fiemap = gfs2_fiemap,
|
||||
.get_acl = gfs2_get_acl,
|
||||
.atomic_open = gfs2_atomic_open,
|
||||
};
|
||||
|
||||
const struct inode_operations gfs2_symlink_iops = {
|
||||
|
|
|
|||
|
|
@ -109,6 +109,7 @@ extern int gfs2_permission(struct inode *inode, int mask);
|
|||
extern int gfs2_setattr_simple(struct inode *inode, struct iattr *attr);
|
||||
extern struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
|
||||
extern void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
|
||||
extern int gfs2_open_common(struct inode *inode, struct file *file);
|
||||
|
||||
extern const struct inode_operations gfs2_file_iops;
|
||||
extern const struct inode_operations gfs2_dir_iops;
|
||||
|
|
|
|||
|
|
@ -211,15 +211,16 @@ static void gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
|
|||
static int gfs2_ail1_empty(struct gfs2_sbd *sdp)
|
||||
{
|
||||
struct gfs2_trans *tr, *s;
|
||||
int oldest_tr = 1;
|
||||
int ret;
|
||||
|
||||
spin_lock(&sdp->sd_ail_lock);
|
||||
list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
|
||||
gfs2_ail1_empty_one(sdp, tr);
|
||||
if (list_empty(&tr->tr_ail1_list))
|
||||
if (list_empty(&tr->tr_ail1_list) && oldest_tr)
|
||||
list_move(&tr->tr_list, &sdp->sd_ail2_list);
|
||||
else
|
||||
break;
|
||||
oldest_tr = 0;
|
||||
}
|
||||
ret = list_empty(&sdp->sd_ail1_list);
|
||||
spin_unlock(&sdp->sd_ail_lock);
|
||||
|
|
@ -317,7 +318,7 @@ static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
|
|||
|
||||
int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
|
||||
{
|
||||
unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);
|
||||
unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize);
|
||||
unsigned wanted = blks + reserved_blks;
|
||||
DEFINE_WAIT(wait);
|
||||
int did_wait = 0;
|
||||
|
|
@ -545,6 +546,76 @@ void gfs2_ordered_del_inode(struct gfs2_inode *ip)
|
|||
spin_unlock(&sdp->sd_ordered_lock);
|
||||
}
|
||||
|
||||
void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
|
||||
{
|
||||
struct buffer_head *bh = bd->bd_bh;
|
||||
struct gfs2_glock *gl = bd->bd_gl;
|
||||
|
||||
gfs2_remove_from_ail(bd);
|
||||
bd->bd_bh = NULL;
|
||||
bh->b_private = NULL;
|
||||
bd->bd_blkno = bh->b_blocknr;
|
||||
bd->bd_ops = &gfs2_revoke_lops;
|
||||
sdp->sd_log_num_revoke++;
|
||||
atomic_inc(&gl->gl_revokes);
|
||||
set_bit(GLF_LFLUSH, &gl->gl_flags);
|
||||
list_add(&bd->bd_list, &sdp->sd_log_le_revoke);
|
||||
}
|
||||
|
||||
void gfs2_write_revokes(struct gfs2_sbd *sdp)
|
||||
{
|
||||
struct gfs2_trans *tr;
|
||||
struct gfs2_bufdata *bd, *tmp;
|
||||
int have_revokes = 0;
|
||||
int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
|
||||
|
||||
gfs2_ail1_empty(sdp);
|
||||
spin_lock(&sdp->sd_ail_lock);
|
||||
list_for_each_entry(tr, &sdp->sd_ail1_list, tr_list) {
|
||||
list_for_each_entry(bd, &tr->tr_ail2_list, bd_ail_st_list) {
|
||||
if (list_empty(&bd->bd_list)) {
|
||||
have_revokes = 1;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
done:
|
||||
spin_unlock(&sdp->sd_ail_lock);
|
||||
if (have_revokes == 0)
|
||||
return;
|
||||
while (sdp->sd_log_num_revoke > max_revokes)
|
||||
max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64);
|
||||
max_revokes -= sdp->sd_log_num_revoke;
|
||||
if (!sdp->sd_log_num_revoke) {
|
||||
atomic_dec(&sdp->sd_log_blks_free);
|
||||
/* If no blocks have been reserved, we need to also
|
||||
* reserve a block for the header */
|
||||
if (!sdp->sd_log_blks_reserved)
|
||||
atomic_dec(&sdp->sd_log_blks_free);
|
||||
}
|
||||
gfs2_log_lock(sdp);
|
||||
spin_lock(&sdp->sd_ail_lock);
|
||||
list_for_each_entry(tr, &sdp->sd_ail1_list, tr_list) {
|
||||
list_for_each_entry_safe(bd, tmp, &tr->tr_ail2_list, bd_ail_st_list) {
|
||||
if (max_revokes == 0)
|
||||
goto out_of_blocks;
|
||||
if (!list_empty(&bd->bd_list))
|
||||
continue;
|
||||
gfs2_add_revoke(sdp, bd);
|
||||
max_revokes--;
|
||||
}
|
||||
}
|
||||
out_of_blocks:
|
||||
spin_unlock(&sdp->sd_ail_lock);
|
||||
gfs2_log_unlock(sdp);
|
||||
|
||||
if (!sdp->sd_log_num_revoke) {
|
||||
atomic_inc(&sdp->sd_log_blks_free);
|
||||
if (!sdp->sd_log_blks_reserved)
|
||||
atomic_inc(&sdp->sd_log_blks_free);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* log_write_header - Get and initialize a journal header buffer
|
||||
* @sdp: The GFS2 superblock
|
||||
|
|
@ -562,7 +633,6 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
|
|||
lh = page_address(page);
|
||||
clear_page(lh);
|
||||
|
||||
gfs2_ail1_empty(sdp);
|
||||
tail = current_tail(sdp);
|
||||
|
||||
lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
|
||||
|
|
|
|||
|
|
@ -72,5 +72,7 @@ extern void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
|
|||
extern void gfs2_log_shutdown(struct gfs2_sbd *sdp);
|
||||
extern void gfs2_meta_syncfs(struct gfs2_sbd *sdp);
|
||||
extern int gfs2_logd(void *data);
|
||||
extern void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd);
|
||||
extern void gfs2_write_revokes(struct gfs2_sbd *sdp);
|
||||
|
||||
#endif /* __LOG_DOT_H__ */
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@
|
|||
#include <linux/gfs2_ondisk.h>
|
||||
#include <linux/bio.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/list_sort.h>
|
||||
|
||||
#include "gfs2.h"
|
||||
#include "incore.h"
|
||||
|
|
@ -401,6 +402,20 @@ static void gfs2_check_magic(struct buffer_head *bh)
|
|||
kunmap_atomic(kaddr);
|
||||
}
|
||||
|
||||
static int blocknr_cmp(void *priv, struct list_head *a, struct list_head *b)
|
||||
{
|
||||
struct gfs2_bufdata *bda, *bdb;
|
||||
|
||||
bda = list_entry(a, struct gfs2_bufdata, bd_list);
|
||||
bdb = list_entry(b, struct gfs2_bufdata, bd_list);
|
||||
|
||||
if (bda->bd_bh->b_blocknr < bdb->bd_bh->b_blocknr)
|
||||
return -1;
|
||||
if (bda->bd_bh->b_blocknr > bdb->bd_bh->b_blocknr)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
|
||||
unsigned int total, struct list_head *blist,
|
||||
bool is_databuf)
|
||||
|
|
@ -413,6 +428,7 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
|
|||
__be64 *ptr;
|
||||
|
||||
gfs2_log_lock(sdp);
|
||||
list_sort(NULL, blist, blocknr_cmp);
|
||||
bd1 = bd2 = list_prepare_entry(bd1, blist, bd_list);
|
||||
while(total) {
|
||||
num = total;
|
||||
|
|
@ -590,6 +606,7 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
|
|||
struct page *page;
|
||||
unsigned int length;
|
||||
|
||||
gfs2_write_revokes(sdp);
|
||||
if (!sdp->sd_log_num_revoke)
|
||||
return;
|
||||
|
||||
|
|
@ -836,10 +853,6 @@ const struct gfs2_log_operations gfs2_revoke_lops = {
|
|||
.lo_name = "revoke",
|
||||
};
|
||||
|
||||
const struct gfs2_log_operations gfs2_rg_lops = {
|
||||
.lo_name = "rg",
|
||||
};
|
||||
|
||||
const struct gfs2_log_operations gfs2_databuf_lops = {
|
||||
.lo_before_commit = databuf_lo_before_commit,
|
||||
.lo_after_commit = databuf_lo_after_commit,
|
||||
|
|
@ -851,7 +864,6 @@ const struct gfs2_log_operations gfs2_databuf_lops = {
|
|||
const struct gfs2_log_operations *gfs2_log_ops[] = {
|
||||
&gfs2_databuf_lops,
|
||||
&gfs2_buf_lops,
|
||||
&gfs2_rg_lops,
|
||||
&gfs2_revoke_lops,
|
||||
NULL,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@
|
|||
extern const struct gfs2_log_operations gfs2_glock_lops;
|
||||
extern const struct gfs2_log_operations gfs2_buf_lops;
|
||||
extern const struct gfs2_log_operations gfs2_revoke_lops;
|
||||
extern const struct gfs2_log_operations gfs2_rg_lops;
|
||||
extern const struct gfs2_log_operations gfs2_databuf_lops;
|
||||
|
||||
extern const struct gfs2_log_operations *gfs2_log_ops[];
|
||||
|
|
|
|||
|
|
@ -296,10 +296,6 @@ void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int
|
|||
if (bd) {
|
||||
spin_lock(&sdp->sd_ail_lock);
|
||||
if (bd->bd_tr) {
|
||||
gfs2_remove_from_ail(bd);
|
||||
bh->b_private = NULL;
|
||||
bd->bd_bh = NULL;
|
||||
bd->bd_blkno = bh->b_blocknr;
|
||||
gfs2_trans_add_revoke(sdp, bd);
|
||||
}
|
||||
spin_unlock(&sdp->sd_ail_lock);
|
||||
|
|
|
|||
|
|
@ -916,16 +916,16 @@ static int init_threads(struct gfs2_sbd *sdp, int undo)
|
|||
goto fail_quotad;
|
||||
|
||||
p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
|
||||
error = IS_ERR(p);
|
||||
if (error) {
|
||||
if (IS_ERR(p)) {
|
||||
error = PTR_ERR(p);
|
||||
fs_err(sdp, "can't start logd thread: %d\n", error);
|
||||
return error;
|
||||
}
|
||||
sdp->sd_logd_process = p;
|
||||
|
||||
p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
|
||||
error = IS_ERR(p);
|
||||
if (error) {
|
||||
if (IS_ERR(p)) {
|
||||
error = PTR_ERR(p);
|
||||
fs_err(sdp, "can't start quotad thread: %d\n", error);
|
||||
goto fail;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1154,11 +1154,6 @@ int gfs2_quota_sync(struct super_block *sb, int type)
|
|||
return error;
|
||||
}
|
||||
|
||||
static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
|
||||
{
|
||||
return gfs2_quota_sync(sb, type);
|
||||
}
|
||||
|
||||
int gfs2_quota_refresh(struct gfs2_sbd *sdp, struct kqid qid)
|
||||
{
|
||||
struct gfs2_quota_data *qd;
|
||||
|
|
@ -1414,7 +1409,7 @@ int gfs2_quotad(void *data)
|
|||
&tune->gt_statfs_quantum);
|
||||
|
||||
/* Update quota file */
|
||||
quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,
|
||||
quotad_check_timeo(sdp, "sync", gfs2_quota_sync, t,
|
||||
"ad_timeo, &tune->gt_quota_quantum);
|
||||
|
||||
/* Check for & recover partially truncated inodes */
|
||||
|
|
|
|||
|
|
@ -1288,14 +1288,16 @@ int gfs2_fitrim(struct file *filp, void __user *argp)
|
|||
minlen = max_t(u64, r.minlen,
|
||||
q->limits.discard_granularity) >> bs_shift;
|
||||
|
||||
rgd = gfs2_blk2rgrpd(sdp, start, 0);
|
||||
rgd_end = gfs2_blk2rgrpd(sdp, end - 1, 0);
|
||||
|
||||
if (end <= start ||
|
||||
minlen > sdp->sd_max_rg_data ||
|
||||
start > rgd_end->rd_data0 + rgd_end->rd_data)
|
||||
if (end <= start || minlen > sdp->sd_max_rg_data)
|
||||
return -EINVAL;
|
||||
|
||||
rgd = gfs2_blk2rgrpd(sdp, start, 0);
|
||||
rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
|
||||
|
||||
if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
|
||||
&& (start > rgd_end->rd_data0 + rgd_end->rd_data))
|
||||
return -EINVAL; /* start is beyond the end of the fs */
|
||||
|
||||
while (1) {
|
||||
|
||||
ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
||||
|
|
@ -1336,7 +1338,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp)
|
|||
}
|
||||
|
||||
out:
|
||||
r.len = trimmed << 9;
|
||||
r.len = trimmed << bs_shift;
|
||||
if (copy_to_user(argp, &r, sizeof(r)))
|
||||
return -EFAULT;
|
||||
|
||||
|
|
|
|||
|
|
@ -270,19 +270,12 @@ void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
|
|||
|
||||
void gfs2_trans_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
|
||||
{
|
||||
struct gfs2_glock *gl = bd->bd_gl;
|
||||
struct gfs2_trans *tr = current->journal_info;
|
||||
|
||||
BUG_ON(!list_empty(&bd->bd_list));
|
||||
BUG_ON(!list_empty(&bd->bd_ail_st_list));
|
||||
BUG_ON(!list_empty(&bd->bd_ail_gl_list));
|
||||
bd->bd_ops = &gfs2_revoke_lops;
|
||||
gfs2_add_revoke(sdp, bd);
|
||||
tr->tr_touched = 1;
|
||||
tr->tr_num_revoke++;
|
||||
sdp->sd_log_num_revoke++;
|
||||
atomic_inc(&gl->gl_revokes);
|
||||
set_bit(GLF_LFLUSH, &gl->gl_flags);
|
||||
list_add(&bd->bd_list, &sdp->sd_log_le_revoke);
|
||||
}
|
||||
|
||||
void gfs2_trans_add_unrevoke(struct gfs2_sbd *sdp, u64 blkno, unsigned int len)
|
||||
|
|
|
|||
Loading…
Reference in a new issue