2006-01-16 09:50:04 -07:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 13:09:15 -06:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 09:50:04 -07: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 09:05:15 -06:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 09:50:04 -07:00
|
|
|
*/
|
|
|
|
|
2009-11-20 14:50:40 -07:00
|
|
|
#include <linux/module.h>
|
2006-01-16 09:50:04 -07:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
2006-02-27 15:23:27 -07:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-03-28 12:14:04 -07:00
|
|
|
#include <linux/crc32.h>
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 15:23:27 -07:00
|
|
|
#include "incore.h"
|
2006-01-16 09:50:04 -07:00
|
|
|
#include "bmap.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "lops.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "recovery.h"
|
|
|
|
#include "super.h"
|
2006-02-27 15:23:27 -07:00
|
|
|
#include "util.h"
|
2006-03-28 12:14:04 -07:00
|
|
|
#include "dir.h"
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2010-07-20 14:09:02 -06:00
|
|
|
struct workqueue_struct *gfs_recovery_wq;
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
|
|
|
|
struct buffer_head **bh)
|
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
2006-02-27 15:23:27 -07:00
|
|
|
struct gfs2_glock *gl = ip->i_gl;
|
2006-01-16 09:50:04 -07:00
|
|
|
int new = 0;
|
2006-09-04 10:49:07 -06:00
|
|
|
u64 dblock;
|
|
|
|
u32 extlen;
|
2006-01-16 09:50:04 -07:00
|
|
|
int error;
|
|
|
|
|
2006-06-14 13:32:57 -06:00
|
|
|
error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
if (!dblock) {
|
2006-02-27 15:23:27 -07:00
|
|
|
gfs2_consist_inode(ip);
|
2006-01-16 09:50:04 -07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2006-09-21 15:05:23 -06:00
|
|
|
*bh = gfs2_meta_ra(gl, dblock, extlen);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2014-03-06 15:19:15 -07:00
|
|
|
int gfs2_revoke_add(struct gfs2_jdesc *jd, u64 blkno, unsigned int where)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2014-03-06 15:19:15 -07:00
|
|
|
struct list_head *head = &jd->jd_revoke_list;
|
2006-01-16 09:50:04 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-04-09 07:33:41 -06:00
|
|
|
rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (!rr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
rr->rr_blkno = blkno;
|
|
|
|
rr->rr_where = where;
|
|
|
|
list_add(&rr->rr_list, head);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-03-06 15:19:15 -07:00
|
|
|
int gfs2_revoke_check(struct gfs2_jdesc *jd, u64 blkno, unsigned int where)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
struct gfs2_revoke_replay *rr;
|
|
|
|
int wrap, a, b, revoke;
|
|
|
|
int found = 0;
|
|
|
|
|
2014-03-06 15:19:15 -07:00
|
|
|
list_for_each_entry(rr, &jd->jd_revoke_list, rr_list) {
|
2006-01-16 09:50:04 -07:00
|
|
|
if (rr->rr_blkno == blkno) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found)
|
|
|
|
return 0;
|
|
|
|
|
2014-03-06 15:19:15 -07:00
|
|
|
wrap = (rr->rr_where < jd->jd_replay_tail);
|
|
|
|
a = (jd->jd_replay_tail < where);
|
2006-01-16 09:50:04 -07:00
|
|
|
b = (where < rr->rr_where);
|
|
|
|
revoke = (wrap) ? (a || b) : (a && b);
|
|
|
|
|
|
|
|
return revoke;
|
|
|
|
}
|
|
|
|
|
2014-03-06 15:19:15 -07:00
|
|
|
void gfs2_revoke_clean(struct gfs2_jdesc *jd)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2014-03-06 15:19:15 -07:00
|
|
|
struct list_head *head = &jd->jd_revoke_list;
|
2006-01-16 09:50:04 -07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
|
|
|
|
{
|
|
|
|
const struct gfs2_log_header *str = buf;
|
|
|
|
|
|
|
|
if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
|
|
|
|
str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
lh->lh_sequence = be64_to_cpu(str->lh_sequence);
|
|
|
|
lh->lh_flags = be32_to_cpu(str->lh_flags);
|
|
|
|
lh->lh_tail = be32_to_cpu(str->lh_tail);
|
|
|
|
lh->lh_blkno = be32_to_cpu(str->lh_blkno);
|
|
|
|
lh->lh_hash = be32_to_cpu(str->lh_hash);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
/**
|
|
|
|
* 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,
|
2006-10-13 19:47:13 -06:00
|
|
|
struct gfs2_log_header_host *head)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
2008-03-12 15:01:29 -06:00
|
|
|
struct gfs2_log_header_host uninitialized_var(lh);
|
2006-12-05 11:34:17 -07:00
|
|
|
const u32 nothing = 0;
|
2006-09-04 10:49:07 -06:00
|
|
|
u32 hash;
|
2006-01-16 09:50:04 -07:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_replay_read_block(jd, blk, &bh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-10-31 12:44:50 -07:00
|
|
|
hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) -
|
|
|
|
sizeof(u32));
|
|
|
|
hash = crc32_le(hash, (unsigned char const *)¬hing, sizeof(nothing));
|
|
|
|
hash ^= (u32)~0;
|
2007-06-01 07:11:58 -06:00
|
|
|
error = gfs2_log_header_in(&lh, bh->b_data);
|
2006-01-16 09:50:04 -07:00
|
|
|
brelse(bh);
|
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
|
2006-01-16 09:50:04 -07:00
|
|
|
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,
|
2006-10-13 19:47:13 -06:00
|
|
|
struct gfs2_log_header_host *head)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
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) {
|
2006-06-14 13:32:57 -06:00
|
|
|
gfs2_consist_inode(GFS2_I(jd->jd_inode));
|
2006-01-16 09:50:04 -07:00
|
|
|
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
|
|
|
|
*/
|
|
|
|
|
2006-10-13 19:47:13 -06:00
|
|
|
static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
|
|
|
unsigned int blk = head->lh_blkno;
|
2006-10-13 19:47:13 -06:00
|
|
|
struct gfs2_log_header_host lh;
|
2006-01-16 09:50:04 -07:00
|
|
|
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) {
|
2006-06-14 13:32:57 -06:00
|
|
|
gfs2_consist_inode(GFS2_I(jd->jd_inode));
|
2006-01-16 09:50:04 -07:00
|
|
|
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
|
|
|
|
*/
|
|
|
|
|
2006-10-13 19:47:13 -06:00
|
|
|
int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-10-13 19:47:13 -06:00
|
|
|
struct gfs2_log_header_host lh_1, lh_m;
|
2006-09-04 10:49:07 -06:00
|
|
|
u32 blk_1, blk_2, blk_m;
|
2006-01-16 09:50:04 -07:00
|
|
|
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)
|
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
|
2006-01-16 09:50:04 -07:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_log_descriptor *ld;
|
|
|
|
int error = 0;
|
|
|
|
u32 length;
|
|
|
|
__be64 *ptr;
|
|
|
|
unsigned int offset = sizeof(struct gfs2_log_descriptor);
|
2006-09-05 12:41:30 -06:00
|
|
|
offset += sizeof(__be64) - 1;
|
|
|
|
offset &= ~(sizeof(__be64) - 1);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2006-03-30 13:46:23 -07:00
|
|
|
if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
|
2006-10-13 19:47:13 -06:00
|
|
|
struct gfs2_log_header_host lh;
|
2006-01-16 09:50:04 -07:00
|
|
|
error = get_log_header(jd, start, &lh);
|
|
|
|
if (!error) {
|
2016-07-21 12:02:44 -06:00
|
|
|
gfs2_replay_incr_blk(jd, &start);
|
2006-08-10 10:08:40 -06:00
|
|
|
brelse(bh);
|
2006-01-16 09:50:04 -07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (error == 1) {
|
2006-06-14 13:32:57 -06:00
|
|
|
gfs2_consist_inode(GFS2_I(jd->jd_inode));
|
2006-01-16 09:50:04 -07:00
|
|
|
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--)
|
2016-07-21 12:02:44 -06:00
|
|
|
gfs2_replay_incr_blk(jd, &start);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
|
2006-10-13 19:47:13 -06:00
|
|
|
static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
|
2006-01-16 09:50:04 -07:00
|
|
|
unsigned int lblock;
|
|
|
|
struct gfs2_log_header *lh;
|
2006-09-04 10:49:07 -06:00
|
|
|
u32 hash;
|
2006-01-16 09:50:04 -07:00
|
|
|
struct buffer_head *bh;
|
|
|
|
int error;
|
2006-10-13 15:25:45 -06:00
|
|
|
struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
|
2006-05-05 14:59:11 -06:00
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
lblock = head->lh_blkno;
|
2016-07-21 12:02:44 -06:00
|
|
|
gfs2_replay_incr_blk(jd, &lblock);
|
2006-10-13 15:25:45 -06:00
|
|
|
bh_map.b_size = 1 << ip->i_inode.i_blkbits;
|
2007-12-10 13:13:27 -07:00
|
|
|
error = gfs2_block_map(&ip->i_inode, lblock, &bh_map, 0);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-09-18 15:18:23 -06:00
|
|
|
if (!bh_map.b_blocknr) {
|
2006-01-16 09:50:04 -07:00
|
|
|
gfs2_consist_inode(ip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2006-09-18 15:18:23 -06:00
|
|
|
bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr);
|
2006-01-16 09:50:04 -07:00
|
|
|
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);
|
2006-08-10 10:08:40 -06:00
|
|
|
lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
|
GFS2: Tag all metadata with jid
There are two spare field in the header common to all GFS2
metadata. One is just the right size to fit a journal id
in it, and this patch updates the journal code so that each
time a metadata block is modified, we tag it with the journal
id of the node which is performing the modification.
The reason for this is that it should make it much easier to
debug issues which arise if we can tell which node was the
last to modify a particular metadata block.
Since the field is updated before the block is written into
the journal, each journal should only contain metadata which
is tagged with its own journal id. The one exception to this
is the journal header block, which might have a different node's
id in it, if that journal was recovered by another node in the
cluster.
Thus each journal will contain a record of which nodes recovered
it, via the journal header.
The other field in the metadata header could potentially be
used to hold information about what kind of operation was
performed, but for the time being we just zero it on each
transaction so that if we use it for that in future, we'll
know that the information (where it exists) is reliable.
I did consider using the other field to hold the journal
sequence number, however since in GFS2's journaling we write
the modified data into the journal and not the original
data, this gives no information as to what action caused the
modification, so I think we can probably come up with a better
use for those 64 bits in the future.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2009-11-06 09:20:51 -07:00
|
|
|
lh->lh_header.__pad0 = cpu_to_be64(0);
|
2006-03-30 13:46:23 -07:00
|
|
|
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
|
GFS2: Tag all metadata with jid
There are two spare field in the header common to all GFS2
metadata. One is just the right size to fit a journal id
in it, and this patch updates the journal code so that each
time a metadata block is modified, we tag it with the journal
id of the node which is performing the modification.
The reason for this is that it should make it much easier to
debug issues which arise if we can tell which node was the
last to modify a particular metadata block.
Since the field is updated before the block is written into
the journal, each journal should only contain metadata which
is tagged with its own journal id. The one exception to this
is the journal header block, which might have a different node's
id in it, if that journal was recovered by another node in the
cluster.
Thus each journal will contain a record of which nodes recovered
it, via the journal header.
The other field in the metadata header could potentially be
used to hold information about what kind of operation was
performed, but for the time being we just zero it on each
transaction so that if we use it for that in future, we'll
know that the information (where it exists) is reliable.
I did consider using the other field to hold the journal
sequence number, however since in GFS2's journaling we write
the modified data into the journal and not the original
data, this gives no information as to what action caused the
modification, so I think we can probably come up with a better
use for those 64 bits in the future.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2009-11-06 09:20:51 -07:00
|
|
|
lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
|
2006-01-16 09:50:04 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-01-30 08:34:04 -07:00
|
|
|
|
2009-01-12 03:43:39 -07:00
|
|
|
static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
|
|
|
|
unsigned int message)
|
2008-01-30 08:34:04 -07:00
|
|
|
{
|
2009-01-12 03:43:39 -07:00
|
|
|
char env_jid[20];
|
|
|
|
char env_status[20];
|
|
|
|
char *envp[] = { env_jid, env_status, NULL };
|
|
|
|
struct lm_lockstruct *ls = &sdp->sd_lockstruct;
|
2012-01-09 15:18:05 -07:00
|
|
|
|
2009-01-12 03:43:39 -07:00
|
|
|
ls->ls_recover_jid_done = jid;
|
|
|
|
ls->ls_recover_jid_status = message;
|
2015-01-12 04:01:03 -07:00
|
|
|
sprintf(env_jid, "JID=%u", jid);
|
2009-01-12 03:43:39 -07:00
|
|
|
sprintf(env_status, "RECOVERY=%s",
|
|
|
|
message == LM_RD_SUCCESS ? "Done" : "Failed");
|
|
|
|
kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
|
2012-01-09 15:18:05 -07:00
|
|
|
|
|
|
|
if (sdp->sd_lockstruct.ls_ops->lm_recovery_result)
|
|
|
|
sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message);
|
2008-01-30 08:34:04 -07:00
|
|
|
}
|
|
|
|
|
2010-07-20 14:09:02 -06:00
|
|
|
void gfs2_recover_func(struct work_struct *work)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2009-05-19 03:01:18 -06:00
|
|
|
struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work);
|
2006-06-14 13:32:57 -06:00
|
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
|
2006-10-13 19:47:13 -06:00
|
|
|
struct gfs2_log_header_host head;
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
struct gfs2_holder j_gh, ji_gh, thaw_gh;
|
2006-01-16 09:50:04 -07:00
|
|
|
unsigned long t;
|
|
|
|
int ro = 0;
|
|
|
|
unsigned int pass;
|
|
|
|
int error;
|
2010-09-29 07:20:52 -06:00
|
|
|
int jlocked = 0;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2010-09-27 08:58:11 -06:00
|
|
|
if (sdp->sd_args.ar_spectator ||
|
|
|
|
(jd->jd_jid != sdp->sd_lockstruct.ls_jid)) {
|
2006-04-26 11:21:55 -06:00
|
|
|
fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
|
|
|
|
jd->jd_jid);
|
2010-09-29 07:20:52 -06:00
|
|
|
jlocked = 1;
|
2008-02-03 08:33:42 -07:00
|
|
|
/* Acquire the journal lock so we can do recovery */
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2006-04-26 11:21:55 -06:00
|
|
|
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;
|
2006-09-25 07:26:04 -06:00
|
|
|
|
2006-04-26 11:21:55 -06:00
|
|
|
case GLR_TRYFAILED:
|
|
|
|
fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
|
|
|
|
error = 0;
|
2006-09-25 07:26:04 -06:00
|
|
|
|
2006-04-26 11:21:55 -06:00
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
};
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2006-04-26 11:21:55 -06:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
|
2007-08-08 16:08:14 -06:00
|
|
|
LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh);
|
2006-04-26 11:21:55 -06:00
|
|
|
if (error)
|
|
|
|
goto fail_gunlock_j;
|
|
|
|
} else {
|
|
|
|
fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
/* Acquire a shared hold on the freeze lock */
|
2006-01-16 09:50:04 -07:00
|
|
|
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
|
|
|
|
LM_FLAG_NOEXP | LM_FLAG_PRIORITY,
|
|
|
|
&thaw_gh);
|
2006-01-16 09:50:04 -07:00
|
|
|
if (error)
|
|
|
|
goto fail_gunlock_ji;
|
|
|
|
|
2012-01-09 12:40:06 -07:00
|
|
|
if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) {
|
|
|
|
ro = 1;
|
|
|
|
} else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
|
2006-01-16 09:50:04 -07:00
|
|
|
if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
|
|
|
|
ro = 1;
|
|
|
|
} else {
|
2008-01-18 13:06:37 -07:00
|
|
|
if (sdp->sd_vfs->s_flags & MS_RDONLY) {
|
|
|
|
/* check if device itself is read-only */
|
|
|
|
ro = bdev_read_only(sdp->sd_vfs->s_bdev);
|
|
|
|
if (!ro) {
|
|
|
|
fs_info(sdp, "recovery required on "
|
|
|
|
"read-only filesystem.\n");
|
|
|
|
fs_info(sdp, "write access will be "
|
|
|
|
"enabled during recovery.\n");
|
|
|
|
}
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ro) {
|
2008-01-18 13:06:37 -07:00
|
|
|
fs_warn(sdp, "jid=%u: Can't replay: read-only block "
|
|
|
|
"device\n", jd->jd_jid);
|
2006-01-16 09:50:04 -07:00
|
|
|
error = -EROFS;
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
goto fail_gunlock_thaw;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
goto fail_gunlock_thaw;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
error = clean_journal(jd, &head);
|
|
|
|
if (error)
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
goto fail_gunlock_thaw;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
gfs2_glock_dq_uninit(&thaw_gh);
|
2006-02-27 15:23:27 -07:00
|
|
|
t = DIV_ROUND_UP(jiffies - t, HZ);
|
2006-01-16 09:50:04 -07:00
|
|
|
fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
|
|
|
|
jd->jd_jid, t);
|
|
|
|
}
|
|
|
|
|
2009-01-12 03:43:39 -07:00
|
|
|
gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2010-09-29 07:20:52 -06:00
|
|
|
if (jlocked) {
|
|
|
|
gfs2_glock_dq_uninit(&ji_gh);
|
2006-04-26 11:21:55 -06:00
|
|
|
gfs2_glock_dq_uninit(&j_gh);
|
2010-09-29 07:20:52 -06:00
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
|
2010-07-20 14:09:02 -06:00
|
|
|
goto done;
|
2006-01-16 09:50:04 -07:00
|
|
|
|
GFS2: remove transaction glock
GFS2 has a transaction glock, which must be grabbed for every
transaction, whose purpose is to deal with freezing the filesystem.
Aside from this involving a large amount of locking, it is very easy to
make the current fsfreeze code hang on unfreezing.
This patch rewrites how gfs2 handles freezing the filesystem. The
transaction glock is removed. In it's place is a freeze glock, which is
cached (but not held) in a shared state by every node in the cluster
when the filesystem is mounted. This lock only needs to be grabbed on
freezing, and actions which need to be safe from freezing, like
recovery.
When a node wants to freeze the filesystem, it grabs this glock
exclusively. When the freeze glock state changes on the nodes (either
from shared to unlocked, or shared to exclusive), the filesystem does a
special log flush. gfs2_log_flush() does all the work for flushing out
the and shutting down the incore log, and then it tries to grab the
freeze glock in a shared state again. Since the filesystem is stuck in
gfs2_log_flush, no new transaction can start, and nothing can be written
to disk. Unfreezing the filesytem simply involes dropping the freeze
glock, allowing gfs2_log_flush() to grab and then release the shared
lock, so it is cached for next time.
However, in order for the unfreezing ioctl to occur, gfs2 needs to get a
shared lock on the filesystem root directory inode to check permissions.
If that glock has already been grabbed exclusively, fsfreeze will be
unable to get the shared lock and unfreeze the filesystem.
In order to allow the unfreeze, this patch makes gfs2 grab a shared lock
on the filesystem root directory during the freeze, and hold it until it
unfreezes the filesystem. The functions which need to grab a shared
lock in order to allow the unfreeze ioctl to be issued now use the lock
grabbed by the freeze code instead.
The freeze and unfreeze code take care to make sure that this shared
lock will not be dropped while another process is using it.
Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-05-01 21:26:55 -06:00
|
|
|
fail_gunlock_thaw:
|
|
|
|
gfs2_glock_dq_uninit(&thaw_gh);
|
2006-04-26 11:21:55 -06:00
|
|
|
fail_gunlock_ji:
|
2010-09-29 07:20:52 -06:00
|
|
|
if (jlocked) {
|
2006-04-26 11:21:55 -06:00
|
|
|
gfs2_glock_dq_uninit(&ji_gh);
|
|
|
|
fail_gunlock_j:
|
|
|
|
gfs2_glock_dq_uninit(&j_gh);
|
|
|
|
}
|
2006-01-16 09:50:04 -07:00
|
|
|
|
|
|
|
fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
|
2006-04-26 11:21:55 -06:00
|
|
|
fail:
|
2012-01-09 13:29:20 -07:00
|
|
|
jd->jd_recover_error = error;
|
2009-01-12 03:43:39 -07:00
|
|
|
gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
|
2010-07-20 14:09:02 -06:00
|
|
|
done:
|
|
|
|
clear_bit(JDF_RECOVERY, &jd->jd_flags);
|
2014-03-17 11:06:10 -06:00
|
|
|
smp_mb__after_atomic();
|
2010-07-20 14:09:02 -06:00
|
|
|
wake_up_bit(&jd->jd_flags, JDF_RECOVERY);
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2010-07-20 14:09:02 -06:00
|
|
|
int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait)
|
2008-11-19 03:08:22 -07:00
|
|
|
{
|
2009-05-19 03:01:18 -06:00
|
|
|
int rv;
|
2010-07-20 14:09:02 -06:00
|
|
|
|
|
|
|
if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/* we have JDF_RECOVERY, queue should always succeed */
|
|
|
|
rv = queue_work(gfs_recovery_wq, &jd->jd_work);
|
|
|
|
BUG_ON(!rv);
|
|
|
|
|
|
|
|
if (wait)
|
sched: Remove proliferation of wait_on_bit() action functions
The current "wait_on_bit" interface requires an 'action'
function to be provided which does the actual waiting.
There are over 20 such functions, many of them identical.
Most cases can be satisfied by one of just two functions, one
which uses io_schedule() and one which just uses schedule().
So:
Rename wait_on_bit and wait_on_bit_lock to
wait_on_bit_action and wait_on_bit_lock_action
to make it explicit that they need an action function.
Introduce new wait_on_bit{,_lock} and wait_on_bit{,_lock}_io
which are *not* given an action function but implicitly use
a standard one.
The decision to error-out if a signal is pending is now made
based on the 'mode' argument rather than being encoded in the action
function.
All instances of the old wait_on_bit and wait_on_bit_lock which
can use the new version have been changed accordingly and their
action functions have been discarded.
wait_on_bit{_lock} does not return any specific error code in the
event of a signal so the caller must check for non-zero and
interpolate their own error code as appropriate.
The wait_on_bit() call in __fscache_wait_on_invalidate() was
ambiguous as it specified TASK_UNINTERRUPTIBLE but used
fscache_wait_bit_interruptible as an action function.
David Howells confirms this should be uniformly
"uninterruptible"
The main remaining user of wait_on_bit{,_lock}_action is NFS
which needs to use a freezer-aware schedule() call.
A comment in fs/gfs2/glock.c notes that having multiple 'action'
functions is useful as they display differently in the 'wchan'
field of 'ps'. (and /proc/$PID/wchan).
As the new bit_wait{,_io} functions are tagged "__sched", they
will not show up at all, but something higher in the stack. So
the distinction will still be visible, only with different
function names (gds2_glock_wait versus gfs2_glock_dq_wait in the
gfs2/glock.c case).
Since first version of this patch (against 3.15) two new action
functions appeared, on in NFS and one in CIFS. CIFS also now
uses an action function that makes the same freezer aware
schedule call as NFS.
Signed-off-by: NeilBrown <neilb@suse.de>
Acked-by: David Howells <dhowells@redhat.com> (fscache, keys)
Acked-by: Steven Whitehouse <swhiteho@redhat.com> (gfs2)
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Steve French <sfrench@samba.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: http://lkml.kernel.org/r/20140707051603.28027.72349.stgit@notabene.brown
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-07-06 23:16:04 -06:00
|
|
|
wait_on_bit(&jd->jd_flags, JDF_RECOVERY,
|
2010-07-20 14:09:02 -06:00
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
|
2012-01-09 13:29:20 -07:00
|
|
|
return wait ? jd->jd_recover_error : 0;
|
2008-11-19 03:08:22 -07:00
|
|
|
}
|
|
|
|
|