![Steven Whitehouse](/assets/img/avatar_default.png)
This patch fixes the way we have been dealing with unlinked, but still open files. It removes all limits (other than memory for inodes, as per every other filesystem) on numbers of these which we can support on GFS2. It also means that (like other fs) its the responsibility of the last process to close the file to deallocate the storage, rather than the person who did the unlinking. Note that with GFS2, those two events might take place on different nodes. Also there are a number of other changes: o We use the Linux inode subsystem as it was intended to be used, wrt allocating GFS2 inodes o The Linux inode cache is now the point which we use for local enforcement of only holding one copy of the inode in core at once (previous to this we used the glock layer). o We no longer use the unlinked "special" file. We just ignore it completely. This makes unlinking more efficient. o We now use the 4th block allocation state. The previously unused state is used to track unlinked but still open inodes. o gfs2_inoded is no longer needed o Several fields are now no longer needed (and removed) from the in core struct gfs2_inode o Several fields are no longer needed (and removed) from the in core superblock There are a number of future possible optimisations and clean ups which have been made possible by this patch. Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
576 lines
12 KiB
C
576 lines
12 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 v.2.
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#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 "lm_interface.h"
|
|
#include "incore.h"
|
|
#include "bmap.h"
|
|
#include "glock.h"
|
|
#include "glops.h"
|
|
#include "lm.h"
|
|
#include "lops.h"
|
|
#include "meta_io.h"
|
|
#include "recovery.h"
|
|
#include "super.h"
|
|
#include "util.h"
|
|
#include "dir.h"
|
|
|
|
int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
|
|
struct buffer_head **bh)
|
|
{
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
|
struct gfs2_glock *gl = ip->i_gl;
|
|
int new = 0;
|
|
uint64_t dblock;
|
|
uint32_t extlen;
|
|
int error;
|
|
|
|
error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
|
|
if (error)
|
|
return error;
|
|
if (!dblock) {
|
|
gfs2_consist_inode(ip);
|
|
return -EIO;
|
|
}
|
|
|
|
gfs2_meta_ra(gl, dblock, extlen);
|
|
error = gfs2_meta_read(gl, dblock, DIO_START | DIO_WAIT, bh);
|
|
|
|
return error;
|
|
}
|
|
|
|
int gfs2_revoke_add(struct gfs2_sbd *sdp, uint64_t blkno, unsigned int where)
|
|
{
|
|
struct list_head *head = &sdp->sd_revoke_list;
|
|
struct gfs2_revoke_replay *rr;
|
|
int found = 0;
|
|
|
|
list_for_each_entry(rr, head, rr_list) {
|
|
if (rr->rr_blkno == blkno) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
rr->rr_where = where;
|
|
return 0;
|
|
}
|
|
|
|
rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_KERNEL);
|
|
if (!rr)
|
|
return -ENOMEM;
|
|
|
|
rr->rr_blkno = blkno;
|
|
rr->rr_where = where;
|
|
list_add(&rr->rr_list, head);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int gfs2_revoke_check(struct gfs2_sbd *sdp, uint64_t blkno, unsigned int where)
|
|
{
|
|
struct gfs2_revoke_replay *rr;
|
|
int wrap, a, b, revoke;
|
|
int found = 0;
|
|
|
|
list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
|
|
if (rr->rr_blkno == blkno) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
return 0;
|
|
|
|
wrap = (rr->rr_where < sdp->sd_replay_tail);
|
|
a = (sdp->sd_replay_tail < where);
|
|
b = (where < rr->rr_where);
|
|
revoke = (wrap) ? (a || b) : (a && b);
|
|
|
|
return revoke;
|
|
}
|
|
|
|
void gfs2_revoke_clean(struct gfs2_sbd *sdp)
|
|
{
|
|
struct list_head *head = &sdp->sd_revoke_list;
|
|
struct gfs2_revoke_replay *rr;
|
|
|
|
while (!list_empty(head)) {
|
|
rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list);
|
|
list_del(&rr->rr_list);
|
|
kfree(rr);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get_log_header - read the log header for a given segment
|
|
* @jd: the journal
|
|
* @blk: the block to look at
|
|
* @lh: the log header to return
|
|
*
|
|
* Read the log header for a given segement in a given journal. Do a few
|
|
* sanity checks on it.
|
|
*
|
|
* Returns: 0 on success,
|
|
* 1 if the header was invalid or incomplete,
|
|
* errno on error
|
|
*/
|
|
|
|
static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
|
|
struct gfs2_log_header *head)
|
|
{
|
|
struct buffer_head *bh;
|
|
struct gfs2_log_header lh;
|
|
uint32_t hash;
|
|
int error;
|
|
|
|
error = gfs2_replay_read_block(jd, blk, &bh);
|
|
if (error)
|
|
return error;
|
|
|
|
memcpy(&lh, bh->b_data, sizeof(struct gfs2_log_header));
|
|
lh.lh_hash = 0;
|
|
hash = gfs2_disk_hash((char *)&lh, sizeof(struct gfs2_log_header));
|
|
gfs2_log_header_in(&lh, bh->b_data);
|
|
|
|
brelse(bh);
|
|
|
|
if (lh.lh_header.mh_magic != GFS2_MAGIC ||
|
|
lh.lh_header.mh_type != GFS2_METATYPE_LH ||
|
|
lh.lh_blkno != blk ||
|
|
lh.lh_hash != hash)
|
|
return 1;
|
|
|
|
*head = lh;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* find_good_lh - find a good log header
|
|
* @jd: the journal
|
|
* @blk: the segment to start searching from
|
|
* @lh: the log header to fill in
|
|
* @forward: if true search forward in the log, else search backward
|
|
*
|
|
* Call get_log_header() to get a log header for a segment, but if the
|
|
* segment is bad, either scan forward or backward until we find a good one.
|
|
*
|
|
* Returns: errno
|
|
*/
|
|
|
|
static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
|
|
struct gfs2_log_header *head)
|
|
{
|
|
unsigned int orig_blk = *blk;
|
|
int error;
|
|
|
|
for (;;) {
|
|
error = get_log_header(jd, *blk, head);
|
|
if (error <= 0)
|
|
return error;
|
|
|
|
if (++*blk == jd->jd_blocks)
|
|
*blk = 0;
|
|
|
|
if (*blk == orig_blk) {
|
|
gfs2_consist_inode(GFS2_I(jd->jd_inode));
|
|
return -EIO;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* jhead_scan - make sure we've found the head of the log
|
|
* @jd: the journal
|
|
* @head: this is filled in with the log descriptor of the head
|
|
*
|
|
* At this point, seg and lh should be either the head of the log or just
|
|
* before. Scan forward until we find the head.
|
|
*
|
|
* Returns: errno
|
|
*/
|
|
|
|
static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
|
|
{
|
|
unsigned int blk = head->lh_blkno;
|
|
struct gfs2_log_header lh;
|
|
int error;
|
|
|
|
for (;;) {
|
|
if (++blk == jd->jd_blocks)
|
|
blk = 0;
|
|
|
|
error = get_log_header(jd, blk, &lh);
|
|
if (error < 0)
|
|
return error;
|
|
if (error == 1)
|
|
continue;
|
|
|
|
if (lh.lh_sequence == head->lh_sequence) {
|
|
gfs2_consist_inode(GFS2_I(jd->jd_inode));
|
|
return -EIO;
|
|
}
|
|
if (lh.lh_sequence < head->lh_sequence)
|
|
break;
|
|
|
|
*head = lh;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* gfs2_find_jhead - find the head of a log
|
|
* @jd: the journal
|
|
* @head: the log descriptor for the head of the log is returned here
|
|
*
|
|
* Do a binary search of a journal and find the valid log entry with the
|
|
* highest sequence number. (i.e. the log head)
|
|
*
|
|
* Returns: errno
|
|
*/
|
|
|
|
int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
|
|
{
|
|
struct gfs2_log_header lh_1, lh_m;
|
|
uint32_t blk_1, blk_2, blk_m;
|
|
int error;
|
|
|
|
blk_1 = 0;
|
|
blk_2 = jd->jd_blocks - 1;
|
|
|
|
for (;;) {
|
|
blk_m = (blk_1 + blk_2) / 2;
|
|
|
|
error = find_good_lh(jd, &blk_1, &lh_1);
|
|
if (error)
|
|
return error;
|
|
|
|
error = find_good_lh(jd, &blk_m, &lh_m);
|
|
if (error)
|
|
return error;
|
|
|
|
if (blk_1 == blk_m || blk_m == blk_2)
|
|
break;
|
|
|
|
if (lh_1.lh_sequence <= lh_m.lh_sequence)
|
|
blk_1 = blk_m;
|
|
else
|
|
blk_2 = blk_m;
|
|
}
|
|
|
|
error = jhead_scan(jd, &lh_1);
|
|
if (error)
|
|
return error;
|
|
|
|
*head = lh_1;
|
|
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* foreach_descriptor - go through the active part of the log
|
|
* @jd: the journal
|
|
* @start: the first log header in the active region
|
|
* @end: the last log header (don't process the contents of this entry))
|
|
*
|
|
* Call a given function once for every log descriptor in the active
|
|
* portion of the log.
|
|
*
|
|
* Returns: errno
|
|
*/
|
|
|
|
static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
|
|
unsigned int end, int pass)
|
|
{
|
|
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
|
|
struct buffer_head *bh;
|
|
struct gfs2_log_descriptor *ld;
|
|
int error = 0;
|
|
u32 length;
|
|
__be64 *ptr;
|
|
unsigned int offset = sizeof(struct gfs2_log_descriptor);
|
|
offset += (sizeof(__be64)-1);
|
|
offset &= ~(sizeof(__be64)-1);
|
|
|
|
while (start != end) {
|
|
error = gfs2_replay_read_block(jd, start, &bh);
|
|
if (error)
|
|
return error;
|
|
if (gfs2_meta_check(sdp, bh)) {
|
|
brelse(bh);
|
|
return -EIO;
|
|
}
|
|
ld = (struct gfs2_log_descriptor *)bh->b_data;
|
|
length = be32_to_cpu(ld->ld_length);
|
|
|
|
if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
|
|
struct gfs2_log_header lh;
|
|
error = get_log_header(jd, start, &lh);
|
|
if (!error) {
|
|
gfs2_replay_incr_blk(sdp, &start);
|
|
continue;
|
|
}
|
|
if (error == 1) {
|
|
gfs2_consist_inode(GFS2_I(jd->jd_inode));
|
|
error = -EIO;
|
|
}
|
|
brelse(bh);
|
|
return error;
|
|
} else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
|
|
brelse(bh);
|
|
return -EIO;
|
|
}
|
|
ptr = (__be64 *)(bh->b_data + offset);
|
|
error = lops_scan_elements(jd, start, ld, ptr, pass);
|
|
if (error) {
|
|
brelse(bh);
|
|
return error;
|
|
}
|
|
|
|
while (length--)
|
|
gfs2_replay_incr_blk(sdp, &start);
|
|
|
|
brelse(bh);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* clean_journal - mark a dirty journal as being clean
|
|
* @sdp: the filesystem
|
|
* @jd: the journal
|
|
* @gl: the journal's glock
|
|
* @head: the head journal to start from
|
|
*
|
|
* Returns: errno
|
|
*/
|
|
|
|
static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
|
|
{
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
|
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
|
|
unsigned int lblock;
|
|
int new = 0;
|
|
uint64_t dblock;
|
|
struct gfs2_log_header *lh;
|
|
uint32_t hash;
|
|
struct buffer_head *bh;
|
|
int error;
|
|
int boundary;
|
|
|
|
lblock = head->lh_blkno;
|
|
gfs2_replay_incr_blk(sdp, &lblock);
|
|
error = gfs2_block_map(&ip->i_inode, lblock, &new, &dblock, &boundary);
|
|
if (error)
|
|
return error;
|
|
if (!dblock) {
|
|
gfs2_consist_inode(ip);
|
|
return -EIO;
|
|
}
|
|
|
|
bh = sb_getblk(sdp->sd_vfs, dblock);
|
|
lock_buffer(bh);
|
|
memset(bh->b_data, 0, bh->b_size);
|
|
set_buffer_uptodate(bh);
|
|
clear_buffer_dirty(bh);
|
|
unlock_buffer(bh);
|
|
|
|
lh = (struct gfs2_log_header *)bh->b_data;
|
|
memset(lh, 0, sizeof(struct gfs2_log_header));
|
|
lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
|
|
lh->lh_header.mh_type = cpu_to_be16(GFS2_METATYPE_LH);
|
|
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
|
|
lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
|
|
lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
|
|
lh->lh_blkno = cpu_to_be32(lblock);
|
|
hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
|
|
lh->lh_hash = cpu_to_be32(hash);
|
|
|
|
set_buffer_dirty(bh);
|
|
if (sync_dirty_buffer(bh))
|
|
gfs2_io_error_bh(sdp, bh);
|
|
brelse(bh);
|
|
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* gfs2_recover_journal - recovery a given journal
|
|
* @jd: the struct gfs2_jdesc describing the journal
|
|
*
|
|
* Acquire the journal's lock, check to see if the journal is clean, and
|
|
* do recovery if necessary.
|
|
*
|
|
* Returns: errno
|
|
*/
|
|
|
|
int gfs2_recover_journal(struct gfs2_jdesc *jd)
|
|
{
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
|
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
|
|
struct gfs2_log_header head;
|
|
struct gfs2_holder j_gh, ji_gh, t_gh;
|
|
unsigned long t;
|
|
int ro = 0;
|
|
unsigned int pass;
|
|
int error;
|
|
|
|
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
|
|
fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
|
|
jd->jd_jid);
|
|
|
|
/* Aquire the journal lock so we can do recovery */
|
|
|
|
error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
|
|
LM_ST_EXCLUSIVE,
|
|
LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
|
|
&j_gh);
|
|
switch (error) {
|
|
case 0:
|
|
break;
|
|
|
|
case GLR_TRYFAILED:
|
|
fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
|
|
error = 0;
|
|
|
|
default:
|
|
goto fail;
|
|
};
|
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
|
|
LM_FLAG_NOEXP, &ji_gh);
|
|
if (error)
|
|
goto fail_gunlock_j;
|
|
} else {
|
|
fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
|
|
}
|
|
|
|
fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
|
|
|
|
error = gfs2_jdesc_check(jd);
|
|
if (error)
|
|
goto fail_gunlock_ji;
|
|
|
|
error = gfs2_find_jhead(jd, &head);
|
|
if (error)
|
|
goto fail_gunlock_ji;
|
|
|
|
if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
|
|
fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
|
|
jd->jd_jid);
|
|
|
|
t = jiffies;
|
|
|
|
/* Acquire a shared hold on the transaction lock */
|
|
|
|
error = gfs2_glock_nq_init(sdp->sd_trans_gl,
|
|
LM_ST_SHARED,
|
|
LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
|
|
GL_NOCANCEL | GL_NOCACHE,
|
|
&t_gh);
|
|
if (error)
|
|
goto fail_gunlock_ji;
|
|
|
|
if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
|
|
if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
|
|
ro = 1;
|
|
} else {
|
|
if (sdp->sd_vfs->s_flags & MS_RDONLY)
|
|
ro = 1;
|
|
}
|
|
|
|
if (ro) {
|
|
fs_warn(sdp, "jid=%u: Can't replay: read-only FS\n",
|
|
jd->jd_jid);
|
|
error = -EROFS;
|
|
goto fail_gunlock_tr;
|
|
}
|
|
|
|
fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
|
|
|
|
for (pass = 0; pass < 2; pass++) {
|
|
lops_before_scan(jd, &head, pass);
|
|
error = foreach_descriptor(jd, head.lh_tail,
|
|
head.lh_blkno, pass);
|
|
lops_after_scan(jd, error, pass);
|
|
if (error)
|
|
goto fail_gunlock_tr;
|
|
}
|
|
|
|
error = clean_journal(jd, &head);
|
|
if (error)
|
|
goto fail_gunlock_tr;
|
|
|
|
gfs2_glock_dq_uninit(&t_gh);
|
|
t = DIV_ROUND_UP(jiffies - t, HZ);
|
|
fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
|
|
jd->jd_jid, t);
|
|
}
|
|
|
|
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
|
|
gfs2_glock_dq_uninit(&ji_gh);
|
|
|
|
gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
|
|
|
|
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
|
|
gfs2_glock_dq_uninit(&j_gh);
|
|
|
|
fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
|
|
return 0;
|
|
|
|
fail_gunlock_tr:
|
|
gfs2_glock_dq_uninit(&t_gh);
|
|
fail_gunlock_ji:
|
|
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
|
|
gfs2_glock_dq_uninit(&ji_gh);
|
|
fail_gunlock_j:
|
|
gfs2_glock_dq_uninit(&j_gh);
|
|
}
|
|
|
|
fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
|
|
|
|
fail:
|
|
gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* gfs2_check_journals - Recover any dirty journals
|
|
* @sdp: the filesystem
|
|
*
|
|
*/
|
|
|
|
void gfs2_check_journals(struct gfs2_sbd *sdp)
|
|
{
|
|
struct gfs2_jdesc *jd;
|
|
|
|
for (;;) {
|
|
jd = gfs2_jdesc_find_dirty(sdp);
|
|
if (!jd)
|
|
break;
|
|
|
|
if (jd != sdp->sd_jdesc)
|
|
gfs2_recover_journal(jd);
|
|
}
|
|
}
|
|
|