gmane.linux.cluster.redhat.cluster.devel

[PATCH] libgfs2: Use flags for versions in metadatadescription

Andrew Price — 2012-05-25T15:05:28

Consolidate the .gfs1 and .gfs2 fields into one .versions field and add
constants so we can test lgfs2_metadata versions more easily.

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/edit/hexedit.c    |    8 +++---
 gfs2/libgfs2/libgfs2.h |    5 ++-
 gfs2/libgfs2/meta.c    |   67 ++++++++++++++++++++----------------------------
 3 files changed, 35 insertions(+), 45 deletions(-)

diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index b4e6d15..2ff1125 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
< at >< at > -813,14 +813,13 < at >< at > int display_block_type(int from_restore)
 return ret_type;
 }
 
-static const struct lgfs2_metadata *find_mtype(uint32_t mtype, int gfs1)
+static const struct lgfs2_metadata *find_mtype(uint32_t mtype, const unsigned versions)
 {
 const struct lgfs2_metadata *m = lgfs2_metadata;
 unsigned n = 0;
 
 do {
-if (((gfs1 && m[n].gfs1) || (!gfs1 && m[n].gfs2))
-                         && m[n].mh_type == mtype)
+if ((m[n].versions & versions) && m[n].mh_type == mtype)
 return &m[n];
 n++;
 } while (n < lgfs2_metadata_size);
< at >< at > -936,7 +935,8 < at >< at > static int hexdump(uint64_t startaddr, int len)
 }
 print_gfs2("] ");
 if (print_field >= 0) {
-const struct lgfs2_metadata *m = find_mtype(block_type, sbd.gfs1);
+const struct lgfs2_metadata *m = find_mtype(block_type,
+               sbd.gfs1 ? LGFS2_MD_GFS1 : LGFS2_MD_GFS2);
 if (m) {
 const struct lgfs2_metafield *f;
 unsigned n;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 8ed08dd..2fc47de 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
< at >< at > -142,8 +142,9 < at >< at > struct lgfs2_metafield {
 };
 
 struct lgfs2_metadata {
-const unsigned gfs1:1;
-const unsigned gfs2:1;
+const unsigned versions:2;
+#define LGFS2_MD_GFS1 0x01
+#define LGFS2_MD_GFS2 0x02
 const unsigned header:1;
 const uint32_t mh_type;
 const uint32_t mh_format;
diff --git a/gfs2/libgfs2/meta.c b/gfs2/libgfs2/meta.c
index 1f796c8..a677cdc 100644
--- a/gfs2/libgfs2/meta.c
+++ b/gfs2/libgfs2/meta.c
< at >< at > -478,7 +478,7 < at >< at > RF(bt_pad)
 
 const struct lgfs2_metadata lgfs2_metadata[] = {
 [LGFS2_MT_GFS2_SB] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_SB,
 .mh_format = GFS2_FORMAT_SB,
< at >< at > -488,7 +488,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_sb),
 },
 [LGFS2_MT_GFS_SB] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .header = 1,
 .mh_type = GFS2_METATYPE_SB,
 .mh_format = GFS_FORMAT_SB,
< at >< at > -498,15 +498,14 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs_sb),
 },
 [LGFS2_MT_RINDEX] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .name = "rindex",
 .fields = gfs2_rindex_fields,
 .nfields = ARRAY_SIZE(gfs2_rindex_fields),
 .size = sizeof(struct gfs2_rindex),
 },
 [LGFS2_MT_GFS2_RGRP] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_RG,
 .mh_format = GFS2_FORMAT_RG,
< at >< at > -516,7 +515,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_rgrp),
 },
 [LGFS2_MT_GFS_RGRP] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .header = 1,
 .mh_type = GFS2_METATYPE_RG,
 .mh_format = GFS2_FORMAT_RG,
< at >< at > -526,8 +525,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs_rgrp),
 },
 [LGFS2_MT_RGRP_BITMAP] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_RB,
 .mh_format = GFS2_FORMAT_RB,
< at >< at > -537,7 +535,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_meta_header),
 },
 [LGFS2_MT_GFS2_DINODE] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_DI,
 .mh_format = GFS2_FORMAT_DI,
< at >< at > -547,7 +545,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_dinode),
 },
 [LGFS2_MT_GFS_DINODE] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .header = 1,
 .mh_type = GFS2_METATYPE_DI,
 .mh_format = GFS2_FORMAT_DI,
< at >< at > -557,7 +555,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs_dinode),
 },
 [LGFS2_MT_GFS2_INDIRECT] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_IN,
 .mh_format = GFS2_FORMAT_IN,
< at >< at > -567,7 +565,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_meta_header),
 },
 [LGFS2_MT_GFS_INDIRECT] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .header = 1,
 .mh_type = GFS2_METATYPE_IN,
 .mh_format = GFS2_FORMAT_IN,
< at >< at > -577,8 +575,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs_indirect),
 },
 [LGFS2_MT_DIR_LEAF] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_LF,
 .mh_format = GFS2_FORMAT_LF,
< at >< at > -588,8 +585,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_leaf),
 },
 [LGFS2_MT_JRNL_DATA] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_JD,
 .mh_format = GFS2_FORMAT_JD,
< at >< at > -599,7 +595,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_meta_header),
 },
 [LGFS2_MT_GFS2_LOG_HEADER] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_LH,
 .mh_format = GFS2_FORMAT_LH,
< at >< at > -609,7 +605,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_log_header),
 },
 [LGFS2_MT_GFS_LOG_HEADER] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .header = 1,
 .mh_type = GFS2_METATYPE_LH,
 .mh_format = GFS2_FORMAT_LH,
< at >< at > -619,7 +615,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs_log_header),
 },
 [LGFS2_MT_GFS2_LOG_DESC] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_LD,
 .mh_format = GFS2_FORMAT_LD,
< at >< at > -629,7 +625,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_log_descriptor),
 },
 [LGFS2_MT_GFS_LOG_DESC] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .header = 1,
 .mh_type = GFS2_METATYPE_LD,
 .mh_format = GFS2_FORMAT_LD,
< at >< at > -639,7 +635,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs_log_descriptor),
 },
 [LGFS2_MT_GFS2_LOG_BLOCK] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_LB,
 .mh_format = GFS2_FORMAT_LB,
< at >< at > -649,8 +645,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_meta_header),
 },
 [LGFS2_MT_EA_ATTR] = {
-.gfs2 = 1,
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_EA,
 .mh_format = GFS2_FORMAT_EA,
< at >< at > -660,8 +655,7 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_meta_header),
 },
 [LGFS2_MT_EA_DATA] = {
-.gfs2 = 1,
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .header = 1,
 .mh_type = GFS2_METATYPE_ED,
 .mh_format = GFS2_FORMAT_ED,
< at >< at > -671,65 +665,60 < at >< at > const struct lgfs2_metadata lgfs2_metadata[] = {
 .size = sizeof(struct gfs2_meta_header),
 },
 [LGFS2_MT_GFS2_QUOTA_CHANGE] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .name = "gfs2_quota_change",
 .fields = gfs2_quota_change_fields,
 .nfields = ARRAY_SIZE(gfs2_quota_change_fields),
 .size = sizeof(struct gfs2_quota_change),
 },
 [LGFS2_MT_DIRENT] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .name = "gfs2_dirent",
 .fields = gfs2_dirent_fields,
 .nfields = ARRAY_SIZE(gfs2_dirent_fields),
 .size = sizeof(struct gfs2_dirent),
 },
 [LGFS2_MT_EA_HEADER] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .name = "gfs2_ea_header",
 .fields = gfs2_ea_header_fields,
 .nfields = ARRAY_SIZE(gfs2_ea_header_fields),
 .size = sizeof(struct gfs2_ea_header),
 },
 [LGFS2_MT_GFS2_INUM_RANGE] = {
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS2,
 .name = "gfs2_inum_range",
 .fields = gfs2_inum_range_fields,
 .nfields = ARRAY_SIZE(gfs2_inum_range_fields),
 .size = sizeof(struct gfs2_inum_range),
 },
 [LGFS2_MT_STATFS_CHANGE] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .name = "gfs2_statfs_change",
 .fields = gfs2_statfs_change_fields,
 .nfields = ARRAY_SIZE(gfs2_statfs_change_fields),
 .size = sizeof(struct gfs2_statfs_change),
 },
 [LGFS2_MT_GFS_JINDEX] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .name = "gfs_jindex",
 .fields = gfs_jindex_fields,
 .nfields = ARRAY_SIZE(gfs_jindex_fields),
 .size = sizeof(struct gfs_jindex),
 },
 [LGFS2_MT_GFS_BLOCK_TAG] = {
-.gfs1 = 1,
+.versions = LGFS2_MD_GFS1,
 .name = "gfs_block_tag",
 .fields = gfs_block_tag_fields,
 .nfields = ARRAY_SIZE(gfs_block_tag_fields),
 .size = sizeof(struct gfs_block_tag),
 },
 [LGFS2_MT_DATA] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .name = "data",
 },
 [LGFS2_MT_FREE] = {
-.gfs1 = 1,
-.gfs2 = 1,
+.versions = LGFS2_MD_GFS1 | LGFS2_MD_GFS2,
 .name = "free",
 },
 };

[PATCH 1/3] gfs2-utils: Remove references tounlinked file tag

Andrew Price — 2012-05-25T10:07:02

Remove references to an obsolete unlinked tag file (or file tag).

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/libgfs2/libgfs2.h |    1 -
 gfs2/man/gfs2_jadd.8   |    3 ---
 gfs2/man/mkfs.gfs2.8   |    3 ---
 gfs2/mkfs/main_mkfs.c  |    5 +----
 4 files changed, 1 insertions(+), 11 deletions(-)

diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index e2a7e45..8ed08dd 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
< at >< at > -255,7 +255,6 < at >< at > struct gfs2_sbd {
 unsigned int bsize;     /* The block size of the FS (in bytes) */
 unsigned int jsize;     /* Size of journals (in MB) */
 unsigned int rgsize;     /* Size of resource groups (in MB) */
-unsigned int utsize;     /* Size of unlinked tag files (in MB) */
 unsigned int qcsize;     /* Size of quota change files (in MB) */
 
 int debug;
diff --git a/gfs2/man/gfs2_jadd.8 b/gfs2/man/gfs2_jadd.8
index a645fb7..5453edd 100644
--- a/gfs2/man/gfs2_jadd.8
+++ b/gfs2/man/gfs2_jadd.8
< at >< at > -50,9 +50,6 < at >< at > The number of new journals to add.
 \fB-q\fP
 Be quiet.  Don't print anything.
 .TP
-\fB-u MegaBytes\fP
-Initial size of each journal's unlinked tag file
-.TP
 \fB-V\fP
 Version. Print version information, then exit.
 .
diff --git a/gfs2/man/mkfs.gfs2.8 b/gfs2/man/mkfs.gfs2.8
index 63348f8..d17e272 100644
--- a/gfs2/man/mkfs.gfs2.8
+++ b/gfs2/man/mkfs.gfs2.8
< at >< at > -75,9 +75,6 < at >< at > Fsname is a unique file system name used to distinguish this GFS2 file
 system from others created (1 to 16 characters).  Lock_nolock doesn't
 use this field.
 .TP
-\fB-u\fP \fIMegaBytes\fR
-Initial size of each journal's unlinked tag file
-.TP
 \fB-V\fP
 Print program version information, then exit.
 
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 7c93621..e6b00a0 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
< at >< at > -109,7 +109,7 < at >< at > static void decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
 sdp->orig_fssize = 0;
 
 while (cont) {
-optchar = getopt(argc, argv, "-b:c:DhJ:j:KOp:qr:t:u:VX");
+optchar = getopt(argc, argv, "-b:c:DhJ:j:KOp:qr:t:VX");
 
 switch (optchar) {
 case 'b':
< at >< at > -166,9 +166,6 < at >< at > static void decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
 strcpy(sdp->locktable, optarg);
 break;
 
-case 'u':
-break;
-
 case 'V':
 printf("gfs2_mkfs %s (built %s %s)\n", VERSION,
        __DATE__, __TIME__);

GFS2 git tree

Steven Whitehouse — 2012-05-22T10:28:10

Hi,

Linus has pulled all the patches for the merge window. Although I've got
a few patches queued up, I'll put them in at -rc1 as usual to avoid the
next window's patches getting tangled up with the current window. So the
tree is empty again for the time being,

Steve.

[PATCH] GFS2: Use lvbs for storing rgrp information

Benjamin Marzinski — 2012-05-22T05:25:39

Instead of reading in the resource groups when gfs2 is checking
for free space to allocate from, gfs2 can store the necessary infromation
in the resource group's lvb.  Also, instead of searching for unlinked
inodes in every resource group that's checked for free space, gfs2 can
store the number of unlinked but inodes in the lvb, and only check for
unlinked inodes if it will find some.

The first time a resource group is locked, the lvb must initialized.
Since this involves counting the unlinked inodes in the resource group,
this takes a little extra time.  But after that, if the resource group
is locked with GL_SKIP, the buffer head won't be read in unless it's
actually needed.

Signed-off-by: Benjamin Marzinski <bmarzins< at >redhat.com>
---
 fs/gfs2/glock.c             |    1 
 fs/gfs2/incore.h            |    1 
 fs/gfs2/rgrp.c              |  138 +++++++++++++++++++++++++++++++++++++++++---
 include/linux/gfs2_ondisk.h |   10 +++
 4 files changed, 141 insertions(+), 9 deletions(-)

Index: gfs2-3.0-nmw/fs/gfs2/glock.c
===================================================================
--- gfs2-3.0-nmw.orig/fs/gfs2/glock.c
+++ gfs2-3.0-nmw/fs/gfs2/glock.c
< at >< at > -767,6 +767,7 < at >< at > int gfs2_glock_get(struct gfs2_sbd *sdp,
 gl->gl_stats.stats[GFS2_LKS_DCOUNT] = 0;
 gl->gl_stats.stats[GFS2_LKS_QCOUNT] = 0;
 memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));
+memset(gl->gl_lvb, 0, 32 * sizeof(char));
 gl->gl_lksb.sb_lvbptr = gl->gl_lvb;
 gl->gl_tchange = jiffies;
 gl->gl_object = NULL;
Index: gfs2-3.0-nmw/fs/gfs2/incore.h
===================================================================
--- gfs2-3.0-nmw.orig/fs/gfs2/incore.h
+++ gfs2-3.0-nmw/fs/gfs2/incore.h
< at >< at > -89,6 +89,7 < at >< at > struct gfs2_rgrpd {
 u64 rd_igeneration;
 struct gfs2_bitmap *rd_bits;
 struct gfs2_sbd *rd_sbd;
+struct gfs2_rgrp_lvb *rd_rgl;
 u32 rd_last_alloc;
 u32 rd_flags;
 #define GFS2_RDF_CHECK0x10000000 /* check for unlinked inodes */
Index: gfs2-3.0-nmw/fs/gfs2/rgrp.c
===================================================================
--- gfs2-3.0-nmw.orig/fs/gfs2/rgrp.c
+++ gfs2-3.0-nmw/fs/gfs2/rgrp.c
< at >< at > -627,6 +627,7 < at >< at > static int read_rindex_entry(struct gfs2
 goto fail;
 
 rgd->rd_gl->gl_object = rgd;
+rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lvb;
 rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
 if (rgd->rd_data > sdp->sd_max_rg_data)
 sdp->sd_max_rg_data = rgd->rd_data;
< at >< at > -736,9 +737,65 < at >< at > static void gfs2_rgrp_out(struct gfs2_rg
 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
 }
 
+static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
+{
+struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
+struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
+
+if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
+    rgl->rl_dinodes != str->rg_dinodes ||
+    rgl->rl_igeneration != str->rg_igeneration)
+return 0;
+return 1;
+}
+
+static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
+{
+const struct gfs2_rgrp *str = buf;
+
+rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
+rgl->rl_flags = str->rg_flags;
+rgl->rl_free = str->rg_free;
+rgl->rl_dinodes = str->rg_dinodes;
+rgl->rl_igeneration = str->rg_igeneration;
+rgl->__pad = 0UL;
+}
+
+static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
+{
+struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
+u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
+rgl->rl_unlinked = cpu_to_be32(unlinked);
+}
+
+static u32 count_unlinked(struct gfs2_rgrpd *rgd)
+{
+struct gfs2_bitmap *bi;
+const u32 length = rgd->rd_length;
+const u8 *buffer = NULL;
+u32 i, goal, count = 0;
+
+for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
+goal = 0;
+buffer = bi->bi_bh->b_data + bi->bi_offset;
+WARN_ON(!buffer_uptodate(bi->bi_bh));
+while (goal < bi->bi_len * GFS2_NBBY) {
+goal = gfs2_bitfit(buffer, bi->bi_len, goal,
+   GFS2_BLKST_UNLINKED);
+if (goal == BFITNOENT)
+break;
+count++;
+goal++;
+}
+}
+
+return count;
+}
+
+
 /**
- * gfs2_rgrp_go_lock - Read in a RG's header and bitmaps
- * < at >gh: The glock holder for the resource group
+ * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
+ * < at >rgd: the struct gfs2_rgrpd describing the RG to read in
  *
  * Read in all of a Resource Group's header and bitmap blocks.
  * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
< at >< at > -746,9 +803,8 < at >< at > static void gfs2_rgrp_out(struct gfs2_rg
  * Returns: errno
  */
 
-int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
+int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
 {
-struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
 struct gfs2_sbd *sdp = rgd->rd_sbd;
 struct gfs2_glock *gl = rgd->rd_gl;
 unsigned int length = rgd->rd_length;
< at >< at > -756,6 +812,9 < at >< at > int gfs2_rgrp_go_lock(struct gfs2_holder
 unsigned int x, y;
 int error;
 
+if (rgd->rd_bits[0].bi_bh != NULL)
+return 0;
+
 for (x = 0; x < length; x++) {
 bi = rgd->rd_bits + x;
 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
< at >< at > -782,6 +841,18 < at >< at > int gfs2_rgrp_go_lock(struct gfs2_holder
 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
 rgd->rd_free_clone = rgd->rd_free;
 }
+if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
+rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
+gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
+     rgd->rd_bits[0].bi_bh->b_data);
+}
+else if (!gfs2_rgrp_lvb_valid(rgd)){
+gfs2_consist_rgrpd(rgd);
+error = -EIO;
+goto fail;
+}
+if (rgd->rd_rgl->rl_unlinked == 0)
+rgd->rd_flags &= ~GFS2_RDF_CHECK;
 
 return 0;
 
< at >< at > -796,6 +867,36 < at >< at > fail:
 return error;
 }
 
+int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
+{
+u32 rl_flags;
+
+if (rgd->rd_flags & GFS2_RDF_UPTODATE)
+return 0;
+
+if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
+return gfs2_rgrp_bh_get(rgd);
+
+rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
+rl_flags &= ~GFS2_RDF_MASK;
+rgd->rd_flags &= GFS2_RDF_MASK;
+rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
+if (rgd->rd_rgl->rl_unlinked == 0)
+rgd->rd_flags &= ~GFS2_RDF_CHECK;
+rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
+rgd->rd_free_clone = rgd->rd_free;
+rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
+rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
+return 0;
+}
+
+int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
+{
+if (gh->gh_flags & GL_SKIP)
+return 0;
+return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
+}
+
 /**
  * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
  * < at >gh: The glock holder for the resource group
< at >< at > -809,8 +910,10 < at >< at > void gfs2_rgrp_go_unlock(struct gfs2_hol
 
 for (x = 0; x < length; x++) {
 struct gfs2_bitmap *bi = rgd->rd_bits + x;
-brelse(bi->bi_bh);
-bi->bi_bh = NULL;
+if (bi->bi_bh) {
+brelse(bi->bi_bh);
+bi->bi_bh = NULL;
+}
 }
 
 }
< at >< at > -954,6 +1057,7 < at >< at > int gfs2_fitrim(struct file *filp, void 
 rgd->rd_flags |= GFS2_RGF_TRIMMED;
 gfs2_trans_add_bh(rgd->rd_gl, bh, 1);
 gfs2_rgrp_out(rgd, bh->b_data);
+gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
 gfs2_trans_end(sdp);
 }
 }
< at >< at > -1115,7 +1219,7 < at >< at > static int get_local_rgrp(struct gfs2_in
 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 struct gfs2_rgrpd *rgd, *begin = NULL;
 struct gfs2_blkreserv *rs = ip->i_res;
-int error, rg_locked, flags = LM_FLAG_TRY;
+int error, rg_locked, flags = LM_FLAG_TRY | GL_SKIP;
 int loops = 0;
 
 if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal))
< at >< at > -1135,22 +1239,32 < at >< at > static int get_local_rgrp(struct gfs2_in
 } else {
 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
    flags, &rs->rs_rgd_gh);
+if (!error) {
+error = update_rgrp_lvb(rgd);
+if (error) {
+gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
+return error;
+}
+}
 }
 switch (error) {
 case 0:
 if (try_rgrp_fit(rgd, ip)) {
+gfs2_rgrp_bh_get(rgd);
 ip->i_rgd = rgd;
 return 0;
 }
-if (rgd->rd_flags & GFS2_RDF_CHECK)
+if (rgd->rd_flags & GFS2_RDF_CHECK) {
+gfs2_rgrp_bh_get(rgd);
 try_rgrp_unlink(rgd, last_unlinked, ip->i_no_addr);
+}
 if (!rg_locked)
 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
 /* fall through */
 case GLR_TRYFAILED:
 rgd = gfs2_rgrpd_get_next(rgd);
 if (rgd == begin) {
-flags = 0;
+flags = GL_SKIP;
 loops++;
 }
 break;
< at >< at > -1542,6 +1656,7 < at >< at > int gfs2_alloc_blocks(struct gfs2_inode 
 
 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
+gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
 
 gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
 if (dinode)
< at >< at > -1588,6 +1703,7 < at >< at > void __gfs2_free_blocks(struct gfs2_inod
 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
+gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
 
 /* Directories keep their data in the metadata address space */
 if (meta || ip->i_depth)
< at >< at > -1624,6 +1740,8 < at >< at > void gfs2_unlink_di(struct inode *inode)
 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
+gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
+update_rgrp_lvb_unlinked(rgd, 1);
 }
 
 static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
< at >< at > -1643,6 +1761,8 < at >< at > static void gfs2_free_uninit_di(struct g
 
 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
+gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
+update_rgrp_lvb_unlinked(rgd, -1);
 
 gfs2_statfs_change(sdp, 0, +1, -1);
 }
Index: gfs2-3.0-nmw/include/linux/gfs2_ondisk.h
===================================================================
--- gfs2-3.0-nmw.orig/include/linux/gfs2_ondisk.h
+++ gfs2-3.0-nmw/include/linux/gfs2_ondisk.h
< at >< at > -170,6 +170,16 < at >< at > struct gfs2_rindex {
 #define GFS2_RGF_NOALLOC0x00000008
 #define GFS2_RGF_TRIMMED0x00000010
 
+struct gfs2_rgrp_lvb {
+__be32 rl_magic;
+__be32 rl_flags;
+__be32 rl_free;
+__be32 rl_dinodes;
+__be64 rl_igeneration;
+__be32 rl_unlinked;
+__be32 __pad;
+};
+
 struct gfs2_rgrp {
 struct gfs2_meta_header rg_header;

[PATCH] rgmanager: add nfsdrestart option as lastresource to umount fs

Fabio M. Di Nitto — 2012-05-16T13:37:08

From: "Fabio M. Di Nitto" <fdinitto< at >redhat.com>

Resolves: rhbz#822066

Signed-off-by: Fabio M. Di Nitto <fdinitto< at >redhat.com>
---
 rgmanager/src/resources/fs.sh |   27 +++++++++++++++++++++++++++
 1 files changed, 27 insertions(+), 0 deletions(-)

diff --git a/rgmanager/src/resources/fs.sh b/rgmanager/src/resources/fs.sh
index 49912c2..f67f80e 100755
--- a/rgmanager/src/resources/fs.sh
+++ b/rgmanager/src/resources/fs.sh
< at >< at > -202,6 +202,18 < at >< at > meta_data()
     <content type="boolean"/>
 </parameter>
 
+<parameter name="nfsrestart" inherit="nfsrestart">
+    <longdesc lang="en">
+If set and unmounting the file system fails, the node will
+try to restart nfs daemon and nfs lockd to drop all filesystem
+references. Use this option as last resource.
+    </longdesc>
+    <shortdesc lang="en">
+Enable NFS daemon and lockd workaround
+    </shortdesc>
+    <content type="boolean"/>
+</parameter>
+
 <parameter name="fsid">
     <longdesc lang="en">
     File system ID for NFS exports.  This can be overridden
< at >< at > -1005,6 +1017,7 < at >< at > stopFilesystem() {
 typeset -i max_tries=3# how many times to try umount
 typeset -i sleep_time=5# time between each umount failure
 typeset -i nfslock_reclaim=0
+typeset nfsdthreads
 typeset done=""
 typeset umount_failed=""
 typeset force_umount=""
< at >< at > -1108,6 +1121,20 < at >< at > stop: Could not match $OCF_RESKEY_device with a real device"
     notify_list_store $mp/.clumanager/statd
     nfslock_reclaim=1
   fi
+
+  if [ "$OCF_RESKEY_nfsrestart" = "yes" ] || \
+     [ "$OCF_RESKEY_nfsrestart" = "1" ]; then
+if [ -f /proc/fs/nfsd/threads ]; then
+ocf_log warning "Restarting nfsd/nfslock"
+nfsdthreads="$(cat /proc/fs/nfsd/threads)"
+service nfslock stop
+echo 0 > /proc/fs/nfsd/threads
+echo $nfsdthreads > /proc/fs/nfsd/threads
+service nfslock start
+else
+ocf_log err "Unable to determin nfsd information. nfsd restart aborted"
+fi
+  fi
 else
   fuser -kvm "$mp"
 fi

[PATCH] rgmanager: add nfsdrestart option as lastresource to umount fs

Fabio M. Di Nitto — 2012-05-16T13:36:54

From: "Fabio M. Di Nitto" <fdinitto< at >redhat.com>

Resolves: rhbz#822053

Signed-off-by: Fabio M. Di Nitto <fdinitto< at >redhat.com>
---
 rgmanager/src/resources/fs.sh.in |   26 ++++++++++++++++++++++++++
 1 files changed, 26 insertions(+), 0 deletions(-)

diff --git a/rgmanager/src/resources/fs.sh.in b/rgmanager/src/resources/fs.sh.in
index c43c177..404fe01 100644
--- a/rgmanager/src/resources/fs.sh.in
+++ b/rgmanager/src/resources/fs.sh.in
< at >< at > -135,6 +135,18 < at >< at > do_metadata()
     <content type="boolean"/>
 </parameter>
 
+<parameter name="nfsrestart" inherit="nfsrestart">
+    <longdesc lang="en">
+If set and unmounting the file system fails, the node will
+try to restart nfs daemon and nfs lockd to drop all filesystem
+references. Use this option as last resource.
+    </longdesc>
+    <shortdesc lang="en">
+Enable NFS daemon and lockd workaround
+    </shortdesc>
+    <content type="boolean"/>
+</parameter>
+
 <parameter name="fsid">
     <longdesc lang="en">
     File system ID for NFS exports.  This can be overridden
< at >< at > -446,6 +458,20 < at >< at > do_force_unmount() {
 export nfslock_reclaim=1
 fi
 
+if [ "$OCF_RESKEY_nfsrestart" = "yes" ] || \
+   [ "$OCF_RESKEY_nfsrestart" = "1" ]; then
+if [ -f /proc/fs/nfsd/threads ]; then
+ocf_log warning "Restarting nfsd/nfslock"
+nfsdthreads="$(cat /proc/fs/nfsd/threads)"
+service nfslock stop
+rpc.nfsd 0
+rpc.nfsd $nfsdthreads
+service nfslock start
+else
+ocf_log err "Unable to determin nfsd information. nfsd restart aborted"
+fi
+fi
+
 # Proceed with fuser -kvm...
 return 1
 }

[PATCH] cman init: add extra documentation forFENCE_JOIN=""

Fabio M. Di Nitto — 2012-05-15T14:38:10

From: "Fabio M. Di Nitto" <fdinitto< at >redhat.com>

Related: rhbz#821016

Signed-off-by: Fabio M. Di Nitto <fdinitto< at >redhat.com>
---
 cman/init.d/cman.in               |    3 +++
 cman/init.d/cman.init.defaults.in |    3 +++
 2 files changed, 6 insertions(+), 0 deletions(-)

diff --git a/cman/init.d/cman.in b/cman/init.d/cman.in
index dddfe6e..95323b4 100644
--- a/cman/init.d/cman.in
+++ b/cman/init.d/cman.in
< at >< at > -135,6 +135,9 < at >< at > fi
 #     set to "yes", then the script will attempt to join the fence domain.
 #     If FENCE_JOIN is set to any other value, the default behavior is
 #     to join the fence domain (equivalent to "yes").
+#     When setting FENCE_JOIN to "no", it is important to check 
+#     DLM_CONTROLD_OPTS to reflect expected behavior regarding fencing
+#     and quorum.
 [ -z "$FENCE_JOIN" ] && FENCE_JOIN="yes"
 
 # FENCED_OPTS -- allow extra options to be passed to fence daemon.
diff --git a/cman/init.d/cman.init.defaults.in b/cman/init.d/cman.init.defaults.in
index adde8d9..b981bab 100644
--- a/cman/init.d/cman.init.defaults.in
+++ b/cman/init.d/cman.init.defaults.in
< at >< at > -58,6 +58,9 < at >< at >
 #     set to "yes", then the script will attempt to join the fence domain.
 #     If FENCE_JOIN is set to any other value, the default behavior is
 #     to join the fence domain (equivalent to "yes").
+#     When setting FENCE_JOIN to "no", it is important to check
+#     DLM_CONTROLD_OPTS to reflect expected behavior regarding fencing
+#     and quorum.
 #FENCE_JOIN="yes"
 
 # FENCED_OPTS -- allow extra options to be passed to fence daemon.

[PATCH] cman init: allow sysconfig/cman to passoptions to dlm_controld

Fabio M. Di Nitto — 2012-05-15T11:55:00

From: "Fabio M. Di Nitto" <fdinitto< at >redhat.com>

DLM_CONTROLD_OPTS="" can now be used to pass startup options to the
daemon.

Resolves: rhbz#821016

Signed-off-by: Fabio M. Di Nitto <fdinitto< at >redhat.com>
---
 cman/init.d/cman.in               |    5 ++++-
 cman/init.d/cman.init.defaults.in |    3 +++
 2 files changed, 7 insertions(+), 1 deletions(-)

diff --git a/cman/init.d/cman.in b/cman/init.d/cman.in
index a39f19f..dddfe6e 100644
--- a/cman/init.d/cman.in
+++ b/cman/init.d/cman.in
< at >< at > -116,6 +116,9 < at >< at > fi
 # empty or any other value (default) | cman init will start the daemons
 #CMAN_DAEMONS_START=
 
+# DLM_CONTROLD_OPTS -- allow extra options to be passed to dlm_controld daemon.
+[ -z "$DLM_CONTROLD_OPTS" ] && DLM_CONTROLD_OPTS=""
+
 # FENCE_JOIN_TIMEOUT -- seconds to wait for fence domain join to
 #     complete.  If the join hasn't completed in this time, fence_tool join
 #     exits with an error, and this script exits with an error.  To wait
< at >< at > -674,7 +677,7 < at >< at > stop_fenced()
 
 start_dlm_controld()
 {
-start_daemon dlm_controld || return 1
+start_daemon dlm_controld "$DLM_CONTROLD_OPTS" || return 1
 
 if [ "$INITLOGLEVEL" = "full" ]; then
 ok
diff --git a/cman/init.d/cman.init.defaults.in b/cman/init.d/cman.init.defaults.in
index 04b3b5b..adde8d9 100644
--- a/cman/init.d/cman.init.defaults.in
+++ b/cman/init.d/cman.init.defaults.in
< at >< at > -39,6 +39,9 < at >< at >
 # empty or any other value (default) | cman init will start the daemons
 #CMAN_DAEMONS_START= 
 
+# DLM_CONTROLD_OPTS -- allow extra options to be passed to dlm_controld daemon.
+#DLM_CONTROLD_OPTS=""
+
 # FENCE_JOIN_TIMEOUT -- seconds to wait for fence domain join to
 #     complete.  If the join hasn't completed in this time, fence_tool join
 #     exits with an error, and this script exits with an error.  To wait

GFS2: Update glock doc to add new stats info

Steven Whitehouse — 2012-05-10T12:12:35

From: Steven Whitehouse <swhiteho< at >redhat.com>
Date: Thu, 10 May 2012 12:41:40 +0100
Subject: [PATCH 2/2] GFS2: Update glock doc to add new stats info

We recently added some glock statistics to GFS2, so this is
a docs update to explain what they all mean. It is based
upon the checkin comment of the patch in question.

Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/Documentation/filesystems/gfs2-glocks.txt b/Documentation/filesystems/gfs2-glocks.txt
index 0494f78..fcc7995 100644
--- a/Documentation/filesystems/gfs2-glocks.txt
+++ b/Documentation/filesystems/gfs2-glocks.txt
< at >< at > -61,7 +61,9 < at >< at > go_unlock        | Called on the final local unlock of a lock
 go_dump          | Called to print content of object for debugfs file, or on
                  | error to dump glock to the log.
 go_type          | The type of the glock, LM_TYPE_.....
-go_min_hold_time | The minimum hold time
+go_callback | Called if the DLM sends a callback to drop this lock
+go_flags | GLOF_ASPACE is set, if the glock has an address space
+                 | associated with it
 
 The minimum hold time for each lock is the time after a remote lock
 grant for which we ignore remote demote requests. This is in order to
< at >< at > -89,6 +91,7 < at >< at > go_demote_ok  |       Sometimes         |       Yes
 go_lock       |       Yes               |       No
 go_unlock     |       Yes               |       No
 go_dump       |       Sometimes         |       Yes
+go_callback   |       Sometimes (N/A)   |       Yes
 
 N.B. Operations must not drop either the bit lock or the spinlock
 if its held on entry. go_dump and do_demote_ok must never block.
< at >< at > -111,4 +114,118 < at >< at > itself (locking order as above), and the other, known as the iopen
 glock is used in conjunction with the i_nlink field in the inode to
 determine the lifetime of the inode in question. Locking of inodes
 is on a per-inode basis. Locking of rgrps is on a per rgrp basis.
+In general we prefer to lock local locks prior to cluster locks.
+
+                            Glock Statistics
+                           ------------------
+
+The stats are divided into two sets: those relating to the
+super block and those relating to an individual glock. The
+super block stats are done on a per cpu basis in order to
+try and reduce the overhead of gathering them. They are also
+further divided by glock type. All timings are in nanoseconds.
+
+In the case of both the super block and glock statistics,
+the same information is gathered in each case. The super
+block timing statistics are used to provide default values for
+the glock timing statistics, so that newly created glocks
+should have, as far as possible, a sensible starting point.
+The per-glock counters are initialised to zero when the
+glock is created. The per-glock statistics are lost when
+the glock is ejected from memory.
+
+The statistics are divided into three pairs of mean and
+variance, plus two counters. The mean/variance pairs are
+smoothed exponential estimates and the algorithm used is
+one which will be very familiar to those used to calculation
+of round trip times in network code. See "TCP/IP Illustrated,
+Volume 1", W. Richard Stevens, sect 21.3, "Round-Trip Time Measurement",
+p. 299 and onwards. Also, Volume 2, Sect. 25.10, p. 838 and onwards.
+Unlike the TCP/IP Illustrated case, the mean and variance are
+not scaled, but are in units of integer nanoseconds.
+
+The three pairs of mean/variance measure the following
+things:
+
+ 1. DLM lock time (non-blocking requests)
+ 2. DLM lock time (blocking requests)
+ 3. Inter-request time (again to the DLM)
+
+A non-blocking request is one which will complete right
+away, whatever the state of the DLM lock in question. That
+currently means any requests when (a) the current state of
+the lock is exclusive, i.e. a lock demotion (b) the requested
+state is either null or unlocked (again, a demotion) or (c) the
+"try lock" flag is set. A blocking request covers all the other
+lock requests.
+
+There are two counters. The first is there primarily to show
+how many lock requests have been made, and thus how much data
+has gone into the mean/variance calculations. The other counter
+is counting queuing of holders at the top layer of the glock
+code. Hopefully that number will be a lot larger than the number
+of dlm lock requests issued.
+
+So why gather these statistics? There are several reasons
+we'd like to get a better idea of these timings:
+
+1. To be able to better set the glock "min hold time"
+2. To spot performance issues more easily
+3. To improve the algorithm for selecting resource groups for
+allocation (to base it on lock wait time, rather than blindly
+using a "try lock")
+
+Due to the smoothing action of the updates, a step change in
+some input quantity being sampled will only fully be taken
+into account after 8 samples (or 4 for the variance) and this
+needs to be carefully considered when interpreting the
+results.
+
+Knowing both the time it takes a lock request to complete and
+the average time between lock requests for a glock means we
+can compute the total percentage of the time for which the
+node is able to use a glock vs. time that the rest of the
+cluster has its share. That will be very useful when setting
+the lock min hold time.
+
+Great care has been taken to ensure that we
+measure exactly the quantities that we want, as accurately
+as possible. There are always inaccuracies in any
+measuring system, but I hope this is as accurate as we
+can reasonably make it.
+
+Per sb stats can be found here:
+/sys/kernel/debug/gfs2/<fsname>/sbstats
+Per glock stats can be found here:
+/sys/kernel/debug/gfs2/<fsname>/glstats
+
+Assuming that debugfs is mounted on /sys/kernel/debug and also
+that <fsname> is replaced with the name of the gfs2 filesystem
+in question.
+
+The abbreviations used in the output as are follows:
+
+srtt     - Smoothed round trip time for non-blocking dlm requests
+srttvar  - Variance estimate for srtt
+srttb    - Smoothed round trip time for (potentially) blocking dlm requests
+srttvarb - Variance estimate for srttb
+sirt     - Smoothed inter-request time (for dlm requests)
+sirtvar  - Variance estimate for sirt
+dlm      - Number of dlm requests made (dcnt in glstats file)
+queue    - Number of glock requests queued (qcnt in glstats file)
+
+The sbstats file contains a set of these stats for each glock type (so 8 lines
+for each type) and for each cpu (one column per cpu). The glstats file contains
+a set of these stats for each glock in a similar format to the glocks file, but
+using the format mean/variance for each of the timing stats.
+
+The gfs2_glock_lock_time tracepoint prints out the current values of the stats
+for the glock in question, along with some addition information on each dlm
+reply that is received:
+
+status - The status of the dlm request
+flags  - The dlm request flags
+tdiff  - The time taken by this specific request
+(remaining fields as per above list)
+

GFS2: Update main gfs2 doc

Steven Whitehouse — 2012-05-10T12:11:59

From: Steven Whitehouse <swhiteho< at >redhat.com>
Date: Thu, 10 May 2012 11:45:31 +0100
Subject: [PATCH 1/2] GFS2: Update main gfs2 doc

Various items were a bit out of date, so this is a refresh to the
latest info.

Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/Documentation/filesystems/gfs2.txt b/Documentation/filesystems/gfs2.txt
index 4cda926..cc4f230 100644
--- a/Documentation/filesystems/gfs2.txt
+++ b/Documentation/filesystems/gfs2.txt
< at >< at > -1,7 +1,7 < at >< at >
 Global File System
 ------------------
 
-http://sources.redhat.com/cluster/wiki/
+https://fedorahosted.org/cluster/wiki/HomePage
 
 GFS is a cluster file system. It allows a cluster of computers to
 simultaneously use a block device that is shared between them (with FC,
< at >< at > -30,7 +30,8 < at >< at > needed, simply:
 
 If you are using Fedora, you need to install the gfs2-utils package
 and, for lock_dlm, you will also need to install the cman package
-and write a cluster.conf as per the documentation.
+and write a cluster.conf as per the documentation. For F17 and above
+cman has been replaced by the dlm package.
 
 GFS2 is not on-disk compatible with previous versions of GFS, but it
 is pretty close.
< at >< at > -39,8 +40,6 < at >< at > The following man pages can be found at the URL above:
   fsck.gfs2to repair a filesystem
   gfs2_growto expand a filesystem online
   gfs2_jaddto add journals to a filesystem online
-  gfs2_toolto manipulate, examine and tune a filesystem
-  gfs2_quotato examine and change quota values in a filesystem
+  tunegfs2to manipulate, examine and tune a filesystem
   gfs2_convertto convert a gfs filesystem to gfs2 in-place
-  mount.gfs2to help mount(8) mount a filesystem
   mkfs.gfs2to make a filesystem

[PATCH] Autodetect EOL in fence agents

Marek 'marx' Grac — 2012-05-09T08:37:55

Fence agents diffes in EOL they accept. EOL \r\n is quite universal but in some cases
it is translated to \n\n what makes login process impossible to complete as it ends like
(capitals are fence agent response)

Login: USER\n
Password: \n

Login: PASSWORD\n

Until now there was a device option that handles that login_eol_lf but we found out that there are few
APC devices which does not work correctly with \r\n and needs \n. So we have to autodetect it, this feature was
added to standard library. As it can also helps with common problem when you have to write exactly
conn.send("message" + "\r\n"). Method conn.sendline("") uses EOL according to platform, so we have decided to create
new method conn.sendxline (need a better name) which uses correct EOL. We need conn.sendline in communication with other local
application so we should not reuse it for this purpose.
---
 fence/agents/lib/fencing.py.py |   37 +++++++++++++++++++++++--------------
 1 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/fence/agents/lib/fencing.py.py b/fence/agents/lib/fencing.py.py
index 5748391..a61c45f 100644
--- a/fence/agents/lib/fencing.py.py
+++ b/fence/agents/lib/fencing.py.py
< at >< at > -175,11 +175,6 < at >< at > all_opt = {
 "required" : "0",
 "shortdesc" : "Force ribcl version to use",
 "order" : 1 },
-"login_eol_lf" : {
-"getopt" : "",
-"help" : "",
-"order" : 1
-},
 "cmd_prompt" : {
 "getopt" : "c:",
 "longopt" : "command-prompt",
< at >< at > -407,12 +402,20 < at >< at > all_opt = {
 common_opt = [ "retry_on", "delay" ]
 
 class fspawn(pexpect.spawn):
+def __init__(self, options, command):
+pexpect.spawn.__init__(self, command)
+self.opt = options
+
 def log_expect(self, options, pattern, timeout):
 result = self.expect(pattern, timeout)
 if options["log"] >= LOG_MODE_VERBOSE:
 options["debug_fh"].write(self.before + self.after)
 return result
 
+# send EOL according to what was detected in login process (telnet)
+def sendxline(self, message):
+self.send(message + self.opt["eol"])
+
 def atexit_handler():
 try:
 sys.stdout.close()
< at >< at > -864,10 +867,7 < at >< at > def fence_login(options):
 if (options.has_key("-4")):
 force_ipvx="-4 "
 
-if (options["device_opt"].count("login_eol_lf")):
-login_eol = "\n"
-else:
-login_eol = "\r\n"
+options["eol"] = "\r\n"
 
 ## Do the delay of the fence device before logging in
 ## Delay is important for two-node clusters fencing but we do not need to delay 'status' operations
< at >< at > -939,7 +939,7 < at >< at > def fence_login(options):
 fail_usage("Failed: You have to enter passphrase (-p) for identity file")
 else:
 try:
-conn = fspawn(TELNET_PATH)
+conn = fspawn(options, TELNET_PATH)
 conn.send("set binary\n")
 conn.send("open %s -%s\n"%(options["-a"], options["-u"]))
 except pexpect.ExceptionPexpect, ex:
< at >< at > -948,11 +948,20 < at >< at > def fence_login(options):
 "are not in the spec file and must be installed separately." + "\n")
 sys.exit(EC_GENERIC_ERROR)
 
-conn.log_expect(options, re_login, int(options["-y"]))
-conn.send(options["-l"] + login_eol)
-conn.log_expect(options, re_pass, int(options["-Y"]))
+result = conn.log_expect(options, re_login, int(options["-y"]))
+conn.sendxline(options["-l"])
+
+## automatically change end of line separator
+screen = conn.read_nonblocking(size=100, timeout=int(options["-Y"]))
+if (re_login.search(screen) != None):
+options["eol"] = "\n"
+conn.sendxline(options["-l"])
+result = conn.log_expect(options, re_pass, int(options["-y"]))
+elif (re_pass.search(screen) == None):
+conn.log_expect(options, re_pass, int(options["-Y"]))
+
 try:
-conn.send(options["-p"] + login_eol)
+conn.sendxline(options["-p"])
 conn.log_expect(options, options["-c"], int(options["-Y"]))
 except KeyError:
 fail(EC_PASSWORD_MISSING)

[PATCH] cmannotifyd: deliver cluster status atstartup and fix daemon init

Fabio M. Di Nitto — 2012-05-08T12:29:15

From: "Fabio M. Di Nitto" <fdinitto< at >redhat.com>

cmannotifyd is very often (if not always) started _after_ cman is
completely settled. That means cmannotifyd does not receive/dispatch
any notifications on the current cluster status at startup.

change cman connection loop to generate a fake notification that
config and membership have changed (we can't poll if they did)
and use those information internally too, to reinit logging with
new cman connection.

Resolves: rhbz#819787

Signed-off-by: Fabio M. Di Nitto <fdinitto< at >redhat.com>
---
 cman/notifyd/main.c |   14 ++++++++++++++
 1 files changed, 14 insertions(+), 0 deletions(-)

diff --git a/cman/notifyd/main.c b/cman/notifyd/main.c
index 3091d2f..4a9f868 100644
--- a/cman/notifyd/main.c
+++ b/cman/notifyd/main.c
< at >< at > -189,6 +189,10 < at >< at > static void init_logging(int reconf)
 ccs_read_logging(ccs_handle, "cmannotifyd", &debug, &mode,
  &syslog_facility, &syslog_priority, &logfile_priority, logfile);
 ccs_disconnect(ccs_handle);
+} else {
+if (debug) {
+logfile_priority = LOG_DEBUG;
+}
 }
 
 if (!daemonize)
< at >< at > -311,6 +315,8 < at >< at > static void byebye_cman(void)
 static void setup_cman(int forever)
 {
 int init = 0, active = 0;
+int quorate;
+const char *str = NULL;
 
 retry_init:
 cman_handle = cman_init(NULL);
< at >< at > -346,6 +352,14 < at >< at > retry_active:
 exit(EXIT_FAILURE);
 }
 
+logt_print(LOG_DEBUG, "Dispatching first cluster status\n");
+init_logging(1);
+str = "CMAN_REASON_CONFIG_UPDATE";
+dispatch_notification(str, 0);
+str = "CMAN_REASON_STATECHANGE";
+quorate = cman_is_quorate(cman_handle);
+dispatch_notification(str, &quorate);
+
 return;
 
 out:

[PATCH] qdisk: Fix man page example (take 2)

Fabio M. Di Nitto — 2012-05-08T11:57:32

From: "Fabio M. Di Nitto" <fdinitto< at >redhat.com>

Resolves: rhbz#745538

Signed-off-by: Fabio M. Di Nitto <fdinitto< at >redhat.com>
---
 cman/man/qdisk.5 |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cman/man/qdisk.5 b/cman/man/qdisk.5
index e0b0ff6..ca974fa 100644
--- a/cman/man/qdisk.5
+++ b/cman/man/qdisk.5
< at >< at > -479,11 +479,11 < at >< at > by the qdiskd timeout.
 .br
 <quorumd interval="1" tko="10" votes="3" label="testing">
 .in 12
-<heuristic program="ping A -c1 -t1" score="1" interval="2" tko="3"/>
+<heuristic program="ping A -c1 -w1" score="1" interval="2" tko="3"/>
 .br
-<heuristic program="ping B -c1 -t1" score="1" interval="2" tko="3"/>
+<heuristic program="ping B -c1 -w1" score="1" interval="2" tko="3"/>
 .br
-<heuristic program="ping C -c1 -t1" score="1" interval="2" tko="3"/>
+<heuristic program="ping C -c1 -w1" score="1" interval="2" tko="3"/>
 .br
 .in 8
 </quorumd>

GFS2: Fix sgid propagation when using ACLs

Steven Whitehouse — 2012-05-04T14:06:28

From: Steven Whitehouse <swhiteho< at >redhat.com>
Date: Fri, 4 May 2012 14:33:06 +0100
Subject: [PATCH] GFS2: Fix sgid propagation when using ACLs

This cleans up the mode setting code when creating inodes. The
SGID bit was being reset by setattr_copy() when the user creating a
subdirectory was not in the owning group. When ACLs are in use this
SGID bit should have been propagated if the ACL allows creation of
a subdirectory. GFS2's behaviour now matches that of the other ACL
supporting filesystems in this regard.

Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/acl.c b/fs/gfs2/acl.c
index 230eb0f..bd4a589 100644
--- a/fs/gfs2/acl.c
+++ b/fs/gfs2/acl.c
< at >< at > -73,12 +73,8 < at >< at > static int gfs2_set_mode(struct inode *inode, umode_t mode)
 int error = 0;
 
 if (mode != inode->i_mode) {
-struct iattr iattr;
-
-iattr.ia_valid = ATTR_MODE;
-iattr.ia_mode = mode;
-
-error = gfs2_setattr_simple(inode, &iattr);
+inode->i_mode = mode;
+mark_inode_dirty(inode);
 }
 
 return error;
< at >< at > -126,9 +122,7 < at >< at > int gfs2_acl_create(struct gfs2_inode *dip, struct inode *inode)
 return PTR_ERR(acl);
 if (!acl) {
 mode &= ~current_umask();
-if (mode != inode->i_mode)
-error = gfs2_set_mode(inode, mode);
-return error;
+return gfs2_set_mode(inode, mode);
 }
 
 if (S_ISDIR(inode->i_mode)) {

[PATCH] rgmanager: Add man page for cpglockd;update rgmanager.8

Lon Hohberger — 2012-05-01T14:28:25

Signed-off-by: Lon Hohberger <lhh< at >redhat.com>
---
 rgmanager/man/cpglockd.8  |   21 +++++++++++++++++++++
 rgmanager/man/rgmanager.8 |    7 ++++++-
 2 files changed, 27 insertions(+), 1 deletions(-)
 create mode 100644 rgmanager/man/cpglockd.8

diff --git a/rgmanager/man/cpglockd.8 b/rgmanager/man/cpglockd.8
new file mode 100644
index 0000000..8084d96
--- /dev/null
+++ b/rgmanager/man/cpglockd.8
< at >< at > -0,0 +1,21 < at >< at >
+.TH "cpglockd" "8" "May 2012" "" "Red Hat High Availability"
+.SH "NAME"
+cpglockd \- CPG lock server for rgmanager
+.SH "DESCRIPTION"
+.PP 
+.B cpglockd
+utilizes the extended virtual synchrony features of the Corosync
+Cluster Engine to implement a simplistic, distributed lock server
+for rgmanager.
+.SH "COMMAND LINE OPTIONS"
+.IP \-F
+Don't wait for the current node to join the fencing domain at startup
+.IP \-Q
+Don't wait for quorum formation at startup
+.IP \-f
+Operate in the foreground mode; do not daemonize
+.IP \-h
+Print command line usage.
+
+.SH "SEE ALSO"
+rgmanager(8), corosync(8)
diff --git a/rgmanager/man/rgmanager.8 b/rgmanager/man/rgmanager.8
index 2b018d2..bab52ef 100644
--- a/rgmanager/man/rgmanager.8
+++ b/rgmanager/man/rgmanager.8
< at >< at > -380,8 +380,13 < at >< at > Do not perform stop-before-start.  Combined with the
 .I -Z
 flag to clusvcadm, this can be used to allow rgmanager to be upgraded
 without stopping a given user service or set of services.
+.IP \-C [0|1]
+Explicitly disable or enable CPG-based locking.  The default is to
+enable this when RRP is turned on (which requires a cluster outage).
+This option MUST be the same on all hosts in the cluster and must
+only be enabled or disabled with all instances of rgmanager turned off.
 
 .SH "SEE ALSO"
 http://sources.redhat.com/cluster/wiki/RGManager
 
-clusvcadm(8), cluster.conf(5)
+clusvcadm(8), cluster.conf(5), cpglockd(8)

[PATCH] rgmanager: Add man page for cpglockd;update rgmanager.8

Lon Hohberger — 2012-05-01T14:24:37

Signed-off-by: Lon Hohberger <lhh< at >redhat.com>
---
 rgmanager/man/cpglockd.8  |   24 ++++++++++++++++++++++++
 rgmanager/man/rgmanager.8 |    7 ++++++-
 2 files changed, 30 insertions(+), 1 deletions(-)
 create mode 100644 rgmanager/man/cpglockd.8

diff --git a/rgmanager/man/cpglockd.8 b/rgmanager/man/cpglockd.8
new file mode 100644
index 0000000..eaf7877
--- /dev/null
+++ b/rgmanager/man/cpglockd.8
< at >< at > -0,0 +1,24 < at >< at >
+.TH "cpglockd" "8" "May 2012" "" "Red Hat High Availability"
+.SH "NAME"
+cpglockd \- CPG lock server for rgmanager
+.SH "DESCRIPTION"
+.PP 
+.B cpglockd
+utilizes the extended virtual synchrony features of the Corosync
+Cluster Engine to implement a simplistic, distributed lock server
+for rgmanager.
+.SH "CONFIGURATION"
+.PP
+Cpglockd has no configuration options.
+.SH "COMMAND LINE OPTIONS"
+.IP \-F
+Don't wait for the current node to join the fencing domain at startup
+.IP \-Q
+Don't wait for quorum formation at startup
+.IP \-f
+Operate in the foreground mode; do not daemonize
+.IP \-h
+Print command line usage.
+
+.SH "SEE ALSO"
+clusvcadm(8), cluster.conf(5), cpglockd(8), rgmanager(8), corosync(8)
diff --git a/rgmanager/man/rgmanager.8 b/rgmanager/man/rgmanager.8
index 2b018d2..bab52ef 100644
--- a/rgmanager/man/rgmanager.8
+++ b/rgmanager/man/rgmanager.8
< at >< at > -380,8 +380,13 < at >< at > Do not perform stop-before-start.  Combined with the
 .I -Z
 flag to clusvcadm, this can be used to allow rgmanager to be upgraded
 without stopping a given user service or set of services.
+.IP \-C [0|1]
+Explicitly disable or enable CPG-based locking.  The default is to
+enable this when RRP is turned on (which requires a cluster outage).
+This option MUST be the same on all hosts in the cluster and must
+only be enabled or disabled with all instances of rgmanager turned off.
 
 .SH "SEE ALSO"
 http://sources.redhat.com/cluster/wiki/RGManager
 
-clusvcadm(8), cluster.conf(5)
+clusvcadm(8), cluster.conf(5), cpglockd(8)

[PATCH 1/2] libgfs2: Remove gfs_get_leaf_nr

Andrew Price — 2012-04-30T17:29:47

gfs2_get_leaf_nr and gfs_get_leaf_nr are identical so we can remove
gfs_get_leaf_nr.

Signed-off-by: Andrew Price <anprice< at >redhat.com>
---
 gfs2/libgfs2/fs_ops.c  |    2 --
 gfs2/libgfs2/gfs1.c    |   16 ----------------
 gfs2/libgfs2/libgfs2.h |    2 --
 3 files changed, 0 insertions(+), 20 deletions(-)

diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index a72394f..470916c 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
< at >< at > -851,8 +851,6 < at >< at > void gfs2_get_leaf_nr(struct gfs2_inode *dip, uint32_t lindex,
 uint64_t leaf_no;
 int count;
 
-if (dip->i_sbd->gfs1)
-return gfs_get_leaf_nr(dip, lindex, leaf_out);
 count = gfs2_readi(dip, (char *)&leaf_no, lindex * sizeof(uint64_t),
    sizeof(uint64_t));
 if (count != sizeof(uint64_t)) {
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index 8e3fc93..d6f8794 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
< at >< at > -395,22 +395,6 < at >< at > void gfs_rgrp_out(struct gfs_rgrp *rgrp, struct gfs2_buffer_head *rbh)
 bmodified(rbh);
 }
 
-void gfs_get_leaf_nr(struct gfs2_inode *dip, uint32_t lindex,
-     uint64_t *leaf_out)
-{
-uint64_t leaf_no;
-int count;
-
-count = gfs2_readi(dip, (char *)&leaf_no, lindex * sizeof(uint64_t),
-   sizeof(uint64_t));
-if (count != sizeof(uint64_t)) {
-fprintf(stderr, "gfs_get_leaf_nr:  Bad internal read.\n");
-exit(1);
-}
-
-*leaf_out = be64_to_cpu(leaf_no);
-}
-
 void gfs_put_leaf_nr(struct gfs2_inode *dip, uint32_t inx, uint64_t leaf_out)
 {
 uint64_t leaf_no;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 4bd01a8..e2a7e45 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
< at >< at > -660,8 +660,6 < at >< at > extern struct gfs2_inode *gfs_inode_read(struct gfs2_sbd *sdp,
 extern void gfs_jindex_in(struct gfs_jindex *jindex, char *buf);
 extern void gfs_rgrp_in(struct gfs_rgrp *rg, struct gfs2_buffer_head *bh);
 extern void gfs_rgrp_out(struct gfs_rgrp *rg, struct gfs2_buffer_head *bh);
-extern void gfs_get_leaf_nr(struct gfs2_inode *dip, uint32_t lindex,
-    uint64_t *leaf_out);
 extern void gfs_put_leaf_nr(struct gfs2_inode *dip, uint32_t inx,
     uint64_t leaf_out);

GFS2 git trees

Steven Whitehouse — 2012-04-24T16:14:28

Hi,

Linus has pulled the fix that I sent him earlier, so I've rebased the
-nmw tree on top of that now,

Steve.

GFS2: Pull request (fix)

Steven Whitehouse — 2012-04-24T14:06:40

Hi,

Please consider pulling the following fix,

Steve.

-----------------------------------------------------------------------------
The following changes since commit 95f714727436836bb46236ce2bcd8ee8f9274aed:

  Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 (2012-04-23 19:52:00 -0700)

are available in the git repository at:

  git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-fixes.git master

Bob Peterson (1):
      GFS2: Instruct DLM to avoid queue convert slowdown

 fs/gfs2/lock_dlm.c |   10 +++++++---
 1 files changed, 7 insertions(+), 3 deletions(-)

--------------------------------------------------------------------------
From 4c569a72c30dfee9b5133284aba67e3aa0c9505d Mon Sep 17 00:00:00 2001
From: Bob Peterson <rpeterso< at >redhat.com>
Date: Tue, 10 Apr 2012 14:45:24 -0400
Subject: [PATCH] GFS2: Instruct DLM to avoid queue convert slowdown

This patch instructs DLM to prevent an "in place" conversion, where the
lock just stays on the granted queue, and instead forces the conversion to
the back of the convert queue. This is done on upward conversions only.

This is useful in cases where, for example, a lock is frequently needed in
PR on one node, but another node needs it temporarily in EX to update it.
This may happen, for example, when the rindex is being updated by gfs2_grow.
The gfs2_grow needs to have the lock in EX, but the other nodes need to
re-read it to retrieve the updates. The glock is already granted in PR on
the non-growing nodes, so this prevents them from continually re-granting
the lock in PR, and forces the EX from gfs2_grow to go through.

Signed-off-by: Bob Peterson <rpeterso< at >redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho< at >redhat.com>

diff --git a/fs/gfs2/lock_dlm.c b/fs/gfs2/lock_dlm.c
index f8411bd..5f5e70e 100644
--- a/fs/gfs2/lock_dlm.c
+++ b/fs/gfs2/lock_dlm.c
< at >< at > -200,10 +200,11 < at >< at > static int make_mode(const unsigned int lmstate)
 return -1;
 }
 
-static u32 make_flags(const u32 lkid, const unsigned int gfs_flags,
+static u32 make_flags(struct gfs2_glock *gl, const unsigned int gfs_flags,
       const int req)
 {
 u32 lkf = DLM_LKF_VALBLK;
+u32 lkid = gl->gl_lksb.sb_lkid;
 
 if (gfs_flags & LM_FLAG_TRY)
 lkf |= DLM_LKF_NOQUEUE;
< at >< at > -227,8 +228,11 < at >< at > static u32 make_flags(const u32 lkid, const unsigned int gfs_flags,
 BUG();
 }
 
-if (lkid != 0) 
+if (lkid != 0) {
 lkf |= DLM_LKF_CONVERT;
+if (test_bit(GLF_BLOCKING, &gl->gl_flags))
+lkf |= DLM_LKF_QUECVT;
+}
 
 return lkf;
 }
< at >< at > -250,7 +254,7 < at >< at > static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state,
 char strname[GDLM_STRNAME_BYTES] = "";
 
 req = make_mode(req_state);
-lkf = make_flags(gl->gl_lksb.sb_lkid, flags, req);
+lkf = make_flags(gl, flags, req);
 gfs2_glstats_inc(gl, GFS2_LKS_DCOUNT);
 gfs2_sbstats_inc(gl, GFS2_LKS_DCOUNT);
 if (gl->gl_lksb.sb_lkid) {

AUTO: Gaia Banchelli/Italy/IBM is out of the office(returning 04/26/2012)

Gaia Banchelli — 2012-04-23T18:05:37

I am out of the office until 04/26/2012.

Sono fuori ufficio. Risponderò al vostro messaggio al mio rientro, il
giorno 26 aprile 2012.
Per comunicazioni urgenti relative a problemi software aperti, vi prego di
contattare il numero verde IBM 800820094 facendo riferimento al numero del
PMR, chiedendo di essere ricontattati. Un collega vi ricontatterà appena
possibile.
*******************************************************************************************************************************************************

I am on leave. I will respond to your message upon my return, on April 26th
2012.
For urgent needs related to a software problem, please call your local IBM
support center and request a callback quoting the problem number, or email
techsupport< at >ecurep.ibm.com wit the full PMR number (xxxxx,xxx,xxx) in the
subject line. A colleague will get back to you as soon as possible.


Note: This is an automated response to your message  "Cluster-devel Digest,
Vol 71, Issue 15" sent on 23/4/2012 18:00:05.

This is the only notification you will receive while this person is away.

[PATCH 2/2] fence_scsi: remove limitations sectionfrom man page

Ryan O'Hara — 2012-04-18T00:02:15

Resolves: rhbz#753839

Signed-off-by: Ryan O'Hara <rohara< at >redhat.com>
---
  fence/man/fence_scsi.8 |    7 -------
  1 files changed, 0 insertions(+), 7 deletions(-)

diff --git a/fence/man/fence_scsi.8 b/fence/man/fence_scsi.8
index 8a2d5a8..d9ab03f 100644
--- a/fence/man/fence_scsi.8
+++ b/fence/man/fence_scsi.8
< at >< at > -99,12 +99,5 < at >< at > Name of the node to be fenced.
  \fIverbose = < param >\fR
  Verbose output.
  -.SH LIMITATIONS
-The fence_scsi fencing agent requires a minimum of three nodes in the
-cluster to operate.  For SAN devices connected via fiber channel,
-these must be physical nodes.  SAN devices connected via iSCSI may use
-virtual or physical nodes.  In addition, fence_scsi cannot be used in
-conjunction with qdisk.
-
  .SH SEE ALSO
  fence(8), fence_node(8), sg_persist(8), lvs(8), lvm.conf(5)