mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-21 11:44:01 +08:00
970343cd49
this patch is for the same problem that Benjamin Marzinski fixes at commit
b94a170e96
quotation of the original problem:
---cut here---
When a file is deleted from a gfs2 filesystem on one node, a dcache
entry for it may still exist on other nodes in the cluster. If this
happens, gfs2 will be unable to free this file on disk. Because of this,
it's possible to have a gfs2 filesystem with no files on it and no free
space. With this patch, when a node receives a callback notifying it
that the file is being deleted on another node, it schedules a new
workqueue thread to remove the file's dcache entry.
---end cut---
after applying Benjamin's patch, I think there is still a case in which the disk
inode remains even when "no space" is hit. the case is that when running
d_prune_aliases() against the inode, there are one or more dentries(aliases)
which have reference count number > 0. in this case the dentries won't be pruned.
and even later, the reference count becomes to 0, the dentries can still be
cached in memory. unfortunately, no callback come again, things come back to
the state before the callback runs. thus the on disk inode remains there until
in memoryinode is removed for some other reason(shrinking inode cache or unmount
the volume..).
this patch is to remove those dentries when their reference count becomes to 0 and
the inode is deleted by remote node. for implementation, gfs2_dentry_delete() is
added as dentry_operations.d_delete. the function returns true when the inode is
deleted by remote node. in dput(), gfs2_dentry_delete() is called and since it
returns true, the dentry is unhashed from dcache and then removed. when all dentries
are removed, the in memory inode get removed so that the on disk inode is freed.
Signed-off-by: Wengang Wang <wen.gang.wang@oracle.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
133 lines
2.7 KiB
C
133 lines
2.7 KiB
C
/*
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU General Public License version 2.
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/buffer_head.h>
|
|
#include <linux/gfs2_ondisk.h>
|
|
#include <linux/crc32.h>
|
|
|
|
#include "gfs2.h"
|
|
#include "incore.h"
|
|
#include "dir.h"
|
|
#include "glock.h"
|
|
#include "super.h"
|
|
#include "util.h"
|
|
#include "inode.h"
|
|
|
|
/**
|
|
* gfs2_drevalidate - Check directory lookup consistency
|
|
* @dentry: the mapping to check
|
|
* @nd:
|
|
*
|
|
* Check to make sure the lookup necessary to arrive at this inode from its
|
|
* parent is still good.
|
|
*
|
|
* Returns: 1 if the dentry is ok, 0 if it isn't
|
|
*/
|
|
|
|
static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
struct dentry *parent = dget_parent(dentry);
|
|
struct gfs2_sbd *sdp = GFS2_SB(parent->d_inode);
|
|
struct gfs2_inode *dip = GFS2_I(parent->d_inode);
|
|
struct inode *inode = dentry->d_inode;
|
|
struct gfs2_holder d_gh;
|
|
struct gfs2_inode *ip = NULL;
|
|
int error;
|
|
int had_lock = 0;
|
|
|
|
if (inode) {
|
|
if (is_bad_inode(inode))
|
|
goto invalid;
|
|
ip = GFS2_I(inode);
|
|
}
|
|
|
|
if (sdp->sd_args.ar_localcaching)
|
|
goto valid;
|
|
|
|
had_lock = (gfs2_glock_is_locked_by_me(dip->i_gl) != NULL);
|
|
if (!had_lock) {
|
|
error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
|
|
if (error)
|
|
goto fail;
|
|
}
|
|
|
|
error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
|
|
switch (error) {
|
|
case 0:
|
|
if (!inode)
|
|
goto invalid_gunlock;
|
|
break;
|
|
case -ENOENT:
|
|
if (!inode)
|
|
goto valid_gunlock;
|
|
goto invalid_gunlock;
|
|
default:
|
|
goto fail_gunlock;
|
|
}
|
|
|
|
valid_gunlock:
|
|
if (!had_lock)
|
|
gfs2_glock_dq_uninit(&d_gh);
|
|
valid:
|
|
dput(parent);
|
|
return 1;
|
|
|
|
invalid_gunlock:
|
|
if (!had_lock)
|
|
gfs2_glock_dq_uninit(&d_gh);
|
|
invalid:
|
|
if (inode && S_ISDIR(inode->i_mode)) {
|
|
if (have_submounts(dentry))
|
|
goto valid;
|
|
shrink_dcache_parent(dentry);
|
|
}
|
|
d_drop(dentry);
|
|
dput(parent);
|
|
return 0;
|
|
|
|
fail_gunlock:
|
|
gfs2_glock_dq_uninit(&d_gh);
|
|
fail:
|
|
dput(parent);
|
|
return 0;
|
|
}
|
|
|
|
static int gfs2_dhash(struct dentry *dentry, struct qstr *str)
|
|
{
|
|
str->hash = gfs2_disk_hash(str->name, str->len);
|
|
return 0;
|
|
}
|
|
|
|
static int gfs2_dentry_delete(struct dentry *dentry)
|
|
{
|
|
struct gfs2_inode *ginode;
|
|
|
|
if (!dentry->d_inode)
|
|
return 0;
|
|
|
|
ginode = GFS2_I(dentry->d_inode);
|
|
if (!ginode->i_iopen_gh.gh_gl)
|
|
return 0;
|
|
|
|
if (test_bit(GLF_DEMOTE, &ginode->i_iopen_gh.gh_gl->gl_flags))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
const struct dentry_operations gfs2_dops = {
|
|
.d_revalidate = gfs2_drevalidate,
|
|
.d_hash = gfs2_dhash,
|
|
.d_delete = gfs2_dentry_delete,
|
|
};
|
|
|