gfs2-utils: master - gfs2_edit: Don't use the global block variable
in block_is_inum_file
by Andrew Price
Gitweb: http://git.fedorahosted.org/git/?p=gfs2-utils.git;a=commitdiff;h=3c430713...
Commit: 3c43071340165032de2aeab6ba1be2688b7dd368
Parent: 8e0b0c05b026ec6d3248c9c264cb02723c1f4a8b
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed Feb 3 14:55:33 2016 +0000
Committer: Andrew Price <anprice(a)redhat.com>
CommitterDate: Wed Feb 3 14:55:33 2016 +0000
gfs2_edit: Don't use the global block variable in block_is_inum_file
Accept it as an argument instead.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/extended.c | 2 +-
gfs2/edit/hexedit.c | 9 +++------
gfs2/edit/hexedit.h | 2 +-
gfs2/edit/savemeta.c | 2 +-
4 files changed, 6 insertions(+), 9 deletions(-)
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index b9d77f8..8c7244b 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -693,7 +693,7 @@ int display_extended(void)
inode_put(&tmp_inode);
brelse(tmp_bh);
}
- else if (block_is_inum_file()) {
+ else if (block_is_inum_file(block)) {
tmp_bh = bread(&sbd, block);
tmp_inode = lgfs2_inode_get(&sbd, tmp_bh);
if (tmp_inode == NULL)
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index cf13304..6125d04 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -897,12 +897,9 @@ int block_is_jindex(uint64_t blk)
return FALSE;
}
-/* ------------------------------------------------------------------------ */
-/* block_is_inum_file */
-/* ------------------------------------------------------------------------ */
-int block_is_inum_file(void)
+int block_is_inum_file(uint64_t blk)
{
- if (!sbd.gfs1 && block == masterblock("inum"))
+ if (!sbd.gfs1 && blk == masterblock("inum"))
return TRUE;
return FALSE;
}
@@ -951,7 +948,7 @@ static int block_has_extended_info(void)
block_is_rgtree() ||
block_is_journals() ||
block_is_jindex(block) ||
- block_is_inum_file() ||
+ block_is_inum_file(block) ||
block_is_statfs_file() ||
block_is_quota_file())
return TRUE;
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index 745e026..f229ed4 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -220,7 +220,7 @@ void die(const char *fmt, ...)
extern int block_is_jindex(uint64_t blk);
extern int block_is_rindex(void);
-extern int block_is_inum_file(void);
+extern int block_is_inum_file(uint64_t blk);
extern int block_is_statfs_file(void);
extern int block_is_quota_file(void);
extern int block_is_per_node(void);
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index dc2c3d7..ab4fe0e 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -166,7 +166,7 @@ static int init_per_node_lookup(void)
static int block_is_systemfile(void)
{
- return block_is_jindex(block) || block_is_inum_file() ||
+ return block_is_jindex(block) || block_is_inum_file(block) ||
block_is_statfs_file() || block_is_quota_file() ||
block_is_rindex() || block_is_a_journal(block) ||
block_is_per_node() || block_is_in_per_node(block);
8 years, 2 months
- 1
- 0
gfs2-utils: master - gfs2_edit: Don't use the global block variable
in block_is_jindex
by Andrew Price
Gitweb: http://git.fedorahosted.org/git/?p=gfs2-utils.git;a=commitdiff;h=8e0b0c05...
Commit: 8e0b0c05b026ec6d3248c9c264cb02723c1f4a8b
Parent: c291aa2f413b70f2ad25d01edb9aacfbd7d1a5b6
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed Feb 3 14:47:40 2016 +0000
Committer: Andrew Price <anprice(a)redhat.com>
CommitterDate: Wed Feb 3 14:47:40 2016 +0000
gfs2_edit: Don't use the global block variable in block_is_jindex
Accept it as an argument instead.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/extended.c | 2 +-
gfs2/edit/hexedit.c | 9 +++------
gfs2/edit/hexedit.h | 2 +-
gfs2/edit/savemeta.c | 2 +-
4 files changed, 6 insertions(+), 9 deletions(-)
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index c01427f..b9d77f8 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -684,7 +684,7 @@ int display_extended(void)
parse_rindex(tmp_inode, FALSE);
inode_put(&tmp_inode);
brelse(tmp_bh);
- } else if (block_is_jindex()) {
+ } else if (block_is_jindex(block)) {
tmp_bh = bread(&sbd, block);
tmp_inode = lgfs2_inode_get(&sbd, tmp_bh);
if (tmp_inode == NULL)
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 70406df..cf13304 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -890,12 +890,9 @@ int block_is_rindex(void)
return FALSE;
}
-/* ------------------------------------------------------------------------ */
-/* block_is_jindex */
-/* ------------------------------------------------------------------------ */
-int block_is_jindex(void)
+int block_is_jindex(uint64_t blk)
{
- if ((sbd.gfs1 && block == sbd1->sb_jindex_di.no_addr))
+ if ((sbd.gfs1 && blk == sbd1->sb_jindex_di.no_addr))
return TRUE;
return FALSE;
}
@@ -953,7 +950,7 @@ static int block_has_extended_info(void)
block_is_rindex() ||
block_is_rgtree() ||
block_is_journals() ||
- block_is_jindex() ||
+ block_is_jindex(block) ||
block_is_inum_file() ||
block_is_statfs_file() ||
block_is_quota_file())
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index 3e9ff5f..745e026 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -218,7 +218,7 @@ void die(const char *fmt, ...)
} \
} while (0)
-extern int block_is_jindex(void);
+extern int block_is_jindex(uint64_t blk);
extern int block_is_rindex(void);
extern int block_is_inum_file(void);
extern int block_is_statfs_file(void);
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 196e2f4..dc2c3d7 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -166,7 +166,7 @@ static int init_per_node_lookup(void)
static int block_is_systemfile(void)
{
- return block_is_jindex() || block_is_inum_file() ||
+ return block_is_jindex(block) || block_is_inum_file() ||
block_is_statfs_file() || block_is_quota_file() ||
block_is_rindex() || block_is_a_journal(block) ||
block_is_per_node() || block_is_in_per_node(block);
8 years, 2 months
- 1
- 0
gfs2-utils: master - gfs2_edit: Don't use the global block variable
in block_is_in_per_node
by Andrew Price
Gitweb: http://git.fedorahosted.org/git/?p=gfs2-utils.git;a=commitdiff;h=c291aa2f...
Commit: c291aa2f413b70f2ad25d01edb9aacfbd7d1a5b6
Parent: 7d700ac0af30715683e3bf8a4d4bb4bc6417e905
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed Feb 3 14:44:39 2016 +0000
Committer: Andrew Price <anprice(a)redhat.com>
CommitterDate: Wed Feb 3 14:44:39 2016 +0000
gfs2_edit: Don't use the global block variable in block_is_in_per_node
Accept it as an argument instead.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/savemeta.c | 8 ++++----
1 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 0dff85a..196e2f4 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -92,14 +92,14 @@ static void destroy_per_node_lookup(void)
}
}
-static int block_is_in_per_node(void)
+static int block_is_in_per_node(uint64_t blk)
{
struct per_node_node *pnp = (struct per_node_node *)per_node_tree.osi_node;
while (pnp) {
- if (block < pnp->block)
+ if (blk < pnp->block)
pnp = (struct per_node_node *)pnp->node.osi_left;
- else if (block > pnp->block)
+ else if (blk > pnp->block)
pnp = (struct per_node_node *)pnp->node.osi_right;
else
return 1;
@@ -169,7 +169,7 @@ static int block_is_systemfile(void)
return block_is_jindex() || block_is_inum_file() ||
block_is_statfs_file() || block_is_quota_file() ||
block_is_rindex() || block_is_a_journal(block) ||
- block_is_per_node() || block_is_in_per_node();
+ block_is_per_node() || block_is_in_per_node(block);
}
/**
8 years, 2 months
- 1
- 0
gfs2-utils: master - gfs2_edit: Don't use the global block variable
in block_is_a_journal
by Andrew Price
Gitweb: http://git.fedorahosted.org/git/?p=gfs2-utils.git;a=commitdiff;h=7d700ac0...
Commit: 7d700ac0af30715683e3bf8a4d4bb4bc6417e905
Parent: 821f7281291fa272ab8293c15a8e1882f538cf08
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed Feb 3 14:42:27 2016 +0000
Committer: Andrew Price <anprice(a)redhat.com>
CommitterDate: Wed Feb 3 14:43:25 2016 +0000
gfs2_edit: Don't use the global block variable in block_is_a_journal
Accept it as an argument instead.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/savemeta.c | 6 +++---
1 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 8ac035c..0dff85a 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -64,12 +64,12 @@ static int journals_found = 0;
int print_level = MSG_NOTICE;
extern char *device;
-static int block_is_a_journal(void)
+static int block_is_a_journal(uint64_t blk)
{
int j;
for (j = 0; j < journals_found; j++)
- if (block == journal_blocks[j])
+ if (blk == journal_blocks[j])
return TRUE;
return FALSE;
}
@@ -168,7 +168,7 @@ static int block_is_systemfile(void)
{
return block_is_jindex() || block_is_inum_file() ||
block_is_statfs_file() || block_is_quota_file() ||
- block_is_rindex() || block_is_a_journal() ||
+ block_is_rindex() || block_is_a_journal(block) ||
block_is_per_node() || block_is_in_per_node();
}
8 years, 2 months
- 1
- 0
cluster: RHEL6 - rgmanager: clunfslock: copy state info if it exists
by Ryan McCabe
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=9b412e7e1c6...
Commit: 9b412e7e1c6bdbc6d3f98efc13c634b6831c7e05
Parent: 4de8c6ac9b4215e1d8199fc7620825387236616a
Author: Ryan McCabe <rmccabe(a)redhat.com>
AuthorDate: Wed Feb 3 17:25:31 2016 -0500
Committer: Ryan McCabe <rmccabe(a)redhat.com>
CommitterDate: Wed Feb 3 17:28:53 2016 -0500
rgmanager: clunfslock: copy state info if it exists
Copy state info from /var/lib/nfs/statd/sm if it exists.
Resolves: rhbz#1278943
Signed-off-by: Ryan McCabe <rmccabe(a)redhat.com>
---
rgmanager/src/utils/clunfslock.sh | 3 +++
1 files changed, 3 insertions(+), 0 deletions(-)
diff --git a/rgmanager/src/utils/clunfslock.sh b/rgmanager/src/utils/clunfslock.sh
index 5ac77d9..699d825 100644
--- a/rgmanager/src/utils/clunfslock.sh
+++ b/rgmanager/src/utils/clunfslock.sh
@@ -33,6 +33,9 @@ add-client()
while read dev mp; do
[ -d "$mp/.clumanager/statd/sm" ] || \
mkdir -p $mp/.clumanager/statd/sm
+ if [ -f "/var/lib/nfs/statd/sm/$1" ]; then
+ cp /var/lib/nfs/statd/sm/$1 $mp/.clumanager/statd/sm/$1
+ fi
touch $mp/.clumanager/statd/sm/$1
done < <(clustered_mounts)
}
8 years, 2 months
- 1
- 0
cluster: RHEL6 - rgmanager: Fix bash syntax error in clunfslock
by Ryan McCabe
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=4de8c6ac9b4...
Commit: 4de8c6ac9b4215e1d8199fc7620825387236616a
Parent: d45d218572552173be30974b5801c1b9e6daea2a
Author: Ryan McCabe <rmccabe(a)redhat.com>
AuthorDate: Wed Feb 3 17:24:29 2016 -0500
Committer: Ryan McCabe <rmccabe(a)redhat.com>
CommitterDate: Wed Feb 3 17:28:53 2016 -0500
rgmanager: Fix bash syntax error in clunfslock
Fix a syntax error in the clunfslock
Resolves: rhbz#1278943
Signed-off-by: Ryan McCabe <rmccabe(a)redhat.com>
---
rgmanager/src/utils/clunfslock.sh | 4 +++-
1 files changed, 3 insertions(+), 1 deletions(-)
diff --git a/rgmanager/src/utils/clunfslock.sh b/rgmanager/src/utils/clunfslock.sh
index 67b2d6d..5ac77d9 100644
--- a/rgmanager/src/utils/clunfslock.sh
+++ b/rgmanager/src/utils/clunfslock.sh
@@ -40,7 +40,9 @@ add-client()
del-client()
{
- while read $dev $mp; do
+ declare dev mp
+
+ while read dev mp; do
[ -d "$mp/.clumanager/statd/sm" ] || \
mkdir -p $mp/.clumanager/statd/sm
rm -f $mp/.clumanager/statd/sm/$1
8 years, 2 months
- 1
- 0
cluster: RHEL6 - rgmanager: Log more errors during resource loading
by Ryan McCabe
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=d45d2185725...
Commit: d45d218572552173be30974b5801c1b9e6daea2a
Parent: 100027214079bfa1901d8aa37ea8e10d9a60ddd6
Author: Ryan McCabe <rmccabe(a)redhat.com>
AuthorDate: Wed Jan 20 09:54:07 2016 -0500
Committer: Ryan McCabe <rmccabe(a)redhat.com>
CommitterDate: Wed Feb 3 17:28:53 2016 -0500
rgmanager: Log more errors during resource loading
Log errors for the remaining cases where loading of resources fails.
Resolves: rhbz#1128877
Signed-off-by: Ryan McCabe <rmccabe(a)redhat.com>
---
rgmanager/src/daemons/restree.c | 7 ++++++-
1 files changed, 6 insertions(+), 1 deletions(-)
diff --git a/rgmanager/src/daemons/restree.c b/rgmanager/src/daemons/restree.c
index 1a649a7..0dc9ced 100644
--- a/rgmanager/src/daemons/restree.c
+++ b/rgmanager/src/daemons/restree.c
@@ -587,6 +587,7 @@ do_load_resource(int ccsfd, char *base,
if (!curres) {
/* No ref and no new one inline ==
no more of the selected type */
+ logt_print(LOG_WARNING, "No resources found for %s\n", base);
return 1;
}
@@ -630,8 +631,12 @@ do_load_resource(int ccsfd, char *base,
}
node = malloc(sizeof(*node));
- if (!node)
+ if (!node) {
+ logt_print(LOG_WARNING, "Out of memory when creating resource"
+ " %s (type %s)\n", curres->r_attrs[0].ra_name,
+ rule->rr_type);
return -1;
+ }
memset(node, 0, sizeof(*node));
8 years, 2 months
- 1
- 0
cluster: RHEL6 - rgmanager: Don't relocate a service if policy should
prevent it
by Ryan McCabe
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=10002721407...
Commit: 100027214079bfa1901d8aa37ea8e10d9a60ddd6
Parent: bbefc264a737ce2aac8a0b6e8ed67ba7ea8741e5
Author: Ryan McCabe <rmccabe(a)redhat.com>
AuthorDate: Wed Jan 20 09:33:08 2016 -0500
Committer: Ryan McCabe <rmccabe(a)redhat.com>
CommitterDate: Wed Feb 3 17:28:53 2016 -0500
rgmanager: Don't relocate a service if policy should prevent it
Resolves: rhbz#1197122
Signed-off-by: Ryan McCabe <rmccabe(a)redhat.com>
---
rgmanager/src/daemons/rg_state.c | 15 ++++++++++++++-
1 files changed, 14 insertions(+), 1 deletions(-)
diff --git a/rgmanager/src/daemons/rg_state.c b/rgmanager/src/daemons/rg_state.c
index 2332ad8..fe5d99d 100644
--- a/rgmanager/src/daemons/rg_state.c
+++ b/rgmanager/src/daemons/rg_state.c
@@ -1413,6 +1413,9 @@ _svc_stop(const char *svcName, int req, int recover, uint32_t newstate)
logt_print(LOG_ERR, "#52: Failed changing RG status\n");
return RG_EFAIL;
}
+
+ rg_unlock(&lockp);
+ return RG_ESUCCESS;
}
logt_print(LOG_NOTICE, "Stopping service %s\n", svcName);
@@ -2065,6 +2068,7 @@ handle_start_req(char *svcName, int req, int *new_owner)
int ret, tolerance = FOD_BEST;
cluster_member_list_t *membership;
int need_check, actual_failure = 0;
+ char policy[20];
/* When we get an enable req. for a migratory service,
check other nodes to see if they are already running
@@ -2160,8 +2164,17 @@ handle_start_req(char *svcName, int req, int *new_owner)
relocate:
/*
* OK, it failed to start - but succeeded to stop. Now,
- * we should relocate the service.
+ * we should relocate the service, unless the policy
+ * calls for it to be disabled.
*/
+ get_recovery_policy(svcName, policy, sizeof(policy));
+ if (strstr(policy, "disable")) {
+ logt_print(LOG_NOTICE,
+ "Starting service %s failed; disabling "
+ "due to recovery policy\n", svcName);
+ return svc_disable(svcName);
+ }
+
if (actual_failure)
logt_print(LOG_WARNING, "#71: Relocating failed service %s\n",
svcName);
8 years, 2 months
- 1
- 0
cluster: RHEL6 - gfs2-utils: Add the glocktop utility
by Andrew Price
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=bbefc264a73...
Commit: bbefc264a737ce2aac8a0b6e8ed67ba7ea8741e5
Parent: 4769ced12fb3a834f801b26d975f023600662245
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu Jan 28 10:13:51 2016 +0000
Committer: Andrew Price <anprice(a)redhat.com>
CommitterDate: Thu Jan 28 17:07:23 2016 +0000
gfs2-utils: Add the glocktop utility
This adds Bob Peterson's glocktop program and glocktop(8) man page.
This tool can be used for debugging glock-related issues and to analyze
locking related performance issues. Changes from the original imported
glocktop.c are:
- Linked against libgfs2 and de-duplicated functions provided by libgfs2
- Fixed build warnings (mainly -Wformat stuff)
- Fixed issues spotted by coverity
Resolves: rhbz#1202817
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/Makefile | 2 +-
gfs2/glocktop/Makefile | 32 +
gfs2/glocktop/glocktop.c | 1873 ++++++++++++++++++++++++++++++++++++++++++++++
gfs2/man/Makefile | 3 +-
gfs2/man/glocktop.8 | 281 +++++++
5 files changed, 2189 insertions(+), 2 deletions(-)
diff --git a/gfs2/Makefile b/gfs2/Makefile
index a3cf6fc..f21d233 100644
--- a/gfs2/Makefile
+++ b/gfs2/Makefile
@@ -1,4 +1,4 @@
include ../make/defines.mk
include $(OBJDIR)/make/passthrough.mk
-SUBDIRS=libgfs2 convert edit fsck mkfs mount quota tool tune man init.d
+SUBDIRS=libgfs2 convert edit fsck mkfs mount quota tool tune man init.d glocktop
diff --git a/gfs2/glocktop/Makefile b/gfs2/glocktop/Makefile
new file mode 100644
index 0000000..714da0a
--- /dev/null
+++ b/gfs2/glocktop/Makefile
@@ -0,0 +1,32 @@
+TARGET= glocktop
+
+SBINDIRT=$(TARGET)
+
+all: depends ${TARGET}
+
+include ../../make/defines.mk
+include $(OBJDIR)/make/cobj.mk
+include $(OBJDIR)/make/clean.mk
+include $(OBJDIR)/make/install.mk
+include $(OBJDIR)/make/uninstall.mk
+
+OBJS=glocktop.o
+
+CFLAGS += -D_FILE_OFFSET_BITS=64
+CFLAGS += -I$(S)/../include -I$(S)/../libgfs2
+CFLAGS += -I${incdir}
+
+LDFLAGS += -L../libgfs2 -lgfs2 -lncurses
+LDFLAGS += -L${libdir}
+
+LDDEPS += ../libgfs2/libgfs2.a
+
+${TARGET}: ${OBJS} ${LDDEPS}
+ $(CC) -o $@ $^ $(LDFLAGS)
+
+depends:
+ $(MAKE) -C ../libgfs2 all
+
+clean: generalclean
+
+-include $(OBJS:.o=.d)
diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c
new file mode 100644
index 0000000..c42965c
--- /dev/null
+++ b/gfs2/glocktop/glocktop.c
@@ -0,0 +1,1873 @@
+/**
+ * glocktop.c - list/print the top GFS2 glock waiters
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <limits.h>
+#include <sys/wait.h>
+#include <sys/mount.h>
+#include <dirent.h>
+#include <curses.h>
+#include <term.h>
+#include <sys/time.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <errno.h>
+#include <libgfs2.h>
+
+#define MAX_GLOCKS 20
+#define MAX_LINES 6000
+#define MAX_MOUNT_POINTS 100
+#define MAX_FILES 512
+#define MAX_CALLTRACE_LINES 4
+#define TITLE1 "glocktop - GFS2 glock monitor"
+#define TITLE2 "Press <ctrl-c> or <escape> to exit"
+
+#define COLOR_TITLE 1
+#define COLOR_NORMAL 2
+#define COLOR_INVERSE 3
+#define COLOR_SPECIAL 4
+#define COLOR_HIGHLIGHT 5
+#define COLOR_OFFSETS 6
+#define COLOR_CONTENTS 7
+#define COLOR_HELD 8
+
+/* init_pair(COLOR_TITLE, COLOR_BLACK, COLOR_CYAN);
+ init_pair(COLOR_INVERSE, COLOR_BLACK, COLOR_WHITE);
+ init_pair(COLOR_NORMAL, COLOR_WHITE, COLOR_BLACK);
+ init_pair(COLOR_SPECIAL, COLOR_MAGENTA, COLOR_WHITE);
+ init_pair(COLOR_HIGHLIGHT, COLOR_WHITE, COLOR_BLUE);
+ init_pair(COLOR_OFFSETS, COLOR_CYAN, COLOR_WHITE);
+ init_pair(COLOR_CONTENTS, COLOR_BLUE, COLOR_WHITE);
+ init_pair(COLOR_HELD, COLOR_CYAN, COLOR_BLACK);
+*/
+
+#define STR_BLACK "[\033[0;30m]"
+#define STR_RED "[\033[0;31m]"
+#define STR_GREEN "[\033[0;32m]"
+#define STR_YELLOW "[\033[0;33m]"
+#define STR_BLUE "[\033[0;34m]"
+#define STR_MAGENTA "[\033[0;35m]"
+#define STR_CYAN "[\033[0;36m]"
+#define STR_WHITE "[\033[0;37m]"
+
+#define BOLD_WHITE "[\033[1;37m]"
+
+#define BKG_CYAN "[\033[46m]"
+#define BKG_WHITE "[\033[47m]"
+#define BKG_BLUE "[\033[44m]"
+
+#define REFRESH_TIME 30
+#define COLORS_TITLE \
+ do { \
+ if (termlines) \
+ attrset(COLOR_PAIR(COLOR_TITLE)); \
+ else \
+ printf(BKG_CYAN); \
+ } while (0)
+#define COLORS_NORMAL_BOLD \
+ do { \
+ if (termlines) { \
+ attrset(COLOR_PAIR(COLOR_NORMAL)); \
+ attron(A_BOLD); \
+ } else { \
+ printf(BOLD_WHITE); \
+ } \
+ } while (0)
+#define COLORS_NORMAL \
+ do { \
+ if (termlines) { \
+ attrset(COLOR_PAIR(COLOR_NORMAL)); \
+ } else { \
+ printf(STR_WHITE); \
+ } \
+ } while (0)
+#define COLORS_INVERSE_BOLD \
+ do { \
+ if (termlines) { \
+ attrset(COLOR_PAIR(COLOR_INVERSE)); \
+ attron(A_BOLD); \
+ } else { \
+ printf(BKG_WHITE); \
+ } \
+ } while (0)
+#define COLORS_INVERSE \
+ do { \
+ if (termlines) { \
+ attrset(COLOR_PAIR(COLOR_INVERSE)); \
+ } else { \
+ printf(BKG_WHITE); \
+ } \
+ } while (0)
+#define COLORS_HELD \
+ do { \
+ if (termlines) { \
+ attrset(COLOR_PAIR(COLOR_HELD)); \
+ } else { \
+ printf(STR_CYAN); \
+ } \
+ } while (0)
+#define COLORS_HIGHLIGHT \
+ do { \
+ if (termlines) { \
+ attrset(COLOR_PAIR(COLOR_HIGHLIGHT)); \
+ } else { \
+ printf(BKG_BLUE); \
+ } \
+ } while (0)
+#define DLM_DIRTBL "/sys/kernel/config/dlm/cluster/dirtbl_size"
+#define DLM_RSBTBL "/sys/kernel/config/dlm/cluster/rsbtbl_size"
+#define DLM_LKBTBL "/sys/kernel/config/dlm/cluster/lkbtbl_size"
+
+#define GFS2_MAX_META_HEIGHT 10
+
+#define DETAILS 0x00000001
+#define FRIENDLY 0x00000002
+
+enum summary_types {
+ all = 0,
+ locked = 1,
+ held_ex = 2,
+ held_sh = 3,
+ held_df = 4,
+ has_waiter = 5,
+ tot_waiters = 6,
+ stypes = 7,
+};
+
+char debugfs[PATH_MAX];
+int termcols = 80, termlines = 30, done = 0;
+unsigned glocks = 0;
+int refresh_time = REFRESH_TIME;
+const char *termtype;
+WINDOW *wind;
+int bufsize = 4 * 1024 * 1024;
+char *glock[MAX_GLOCKS];
+int iterations = 0, show_reservations = 0, iters_done = 0;
+char devices[MAX_MOUNT_POINTS][80];
+char mount_points[MAX_MOUNT_POINTS][80];
+int fs_fd[MAX_MOUNT_POINTS];
+int mounted = 0;
+char dlmwlines[100][96]; /* waiters lines */
+char dlmglines[MAX_LINES][97]; /* granted lines */
+char contended_filenames[MAX_FILES][PATH_MAX];
+unsigned long long contended_blocks[MAX_FILES];
+int contended_count = 0;
+int line = 0;
+const char *prog_name;
+char dlm_dirtbl_size[32], dlm_rsbtbl_size[32], dlm_lkbtbl_size[32];
+int bsize = 0;
+struct gfs2_sb sd_sb[MAX_MOUNT_POINTS];
+int sd_diptrs = 0, sd_inptrs = 0;
+uint64_t sd_heightsize[GFS2_MAX_META_HEIGHT];
+uint64_t sd_jheightsize[GFS2_MAX_META_HEIGHT];
+int sd_max_height, sd_max_jheight;
+char print_dlm_grants = 1;
+char *gbuf = NULL; /* glocks buffer */
+char *gpos = NULL;
+char *gnextpos = NULL;
+int gmaxpos = 0;
+
+char *dbuf = NULL; /* dlm locks buffer */
+char *dpos = NULL;
+char *dnextpos = NULL;
+int dmaxpos = 0;
+char hostname[256];
+
+/*
+ * init_colors
+ */
+static void init_colors(void)
+{
+ init_pair(COLOR_TITLE, COLOR_BLACK, COLOR_CYAN);
+ init_pair(COLOR_INVERSE, COLOR_BLACK, COLOR_WHITE);
+ init_pair(COLOR_NORMAL, COLOR_WHITE, COLOR_BLACK);
+ init_pair(COLOR_SPECIAL, COLOR_MAGENTA, COLOR_WHITE);
+ init_pair(COLOR_HIGHLIGHT, COLOR_WHITE, COLOR_BLUE);
+ init_pair(COLOR_OFFSETS, COLOR_CYAN, COLOR_WHITE);
+ init_pair(COLOR_CONTENTS, COLOR_BLUE, COLOR_WHITE);
+ init_pair(COLOR_HELD, COLOR_CYAN, COLOR_BLACK);
+}
+
+/*
+ * UpdateSize - screen size changed, so update it
+ */
+static void UpdateSize(int sig)
+{
+ static char term_buffer[2048];
+ int rc;
+
+ if (termlines) {
+ termlines = 30;
+ termtype = getenv("TERM");
+ if (termtype == NULL)
+ return;
+ rc=tgetent(term_buffer,termtype);
+ if (rc >= 0) {
+ termlines = tgetnum((char *)"li");
+ if (termlines < 10)
+ termlines = 30;
+ termcols = tgetnum((char *)"co");
+ if (termcols < 80)
+ termcols = 80;
+ } else
+ perror("Error: tgetent failed.");
+ termlines--; /* last line is number of lines -1 */
+ }
+ signal(SIGWINCH, UpdateSize);
+}
+
+static void read_superblock(int fd, int mntpt)
+{
+ struct gfs2_sbd sbd = { .device_fd = fd, .bsize = GFS2_BASIC_BLOCK };
+ struct gfs2_buffer_head *bh;
+ int x;
+ uint64_t space = 0;
+
+ ioctl(fd, BLKFLSBUF, 0);
+ bh = bread(&sbd, GFS2_SB_ADDR);
+ gfs2_sb_in(&sd_sb[mntpt], bh); /* parse it out into the sb structure */
+ bsize = sd_sb[mntpt].sb_bsize;
+ if (!bsize)
+ bsize = 4096;
+ sd_inptrs = (bsize - sizeof(struct gfs2_meta_header)) /
+ sizeof(uint64_t);
+ sd_diptrs = (bsize - sizeof(struct gfs2_dinode)) /
+ sizeof(uint64_t);
+ sd_heightsize[0] = bsize - sizeof(struct gfs2_dinode);
+ sd_heightsize[1] = bsize * sd_diptrs;
+ for (x = 2; ; x++) {
+ space = sd_heightsize[x - 1] * sd_inptrs;
+ if (space / sd_inptrs != sd_heightsize[x - 1] ||
+ space % sd_inptrs != 0)
+ break;
+ sd_heightsize[x] = space;
+ }
+ sd_jheightsize[0] = bsize - sizeof(struct gfs2_dinode);
+ sd_jheightsize[1] = (bsize - sizeof(struct gfs2_meta_header)) *
+ sd_diptrs;
+ for (x = 2; ; x++){
+ space = sd_jheightsize[x - 1] * sd_inptrs;
+ if (space / sd_inptrs != sd_jheightsize[x - 1] ||
+ space % sd_inptrs != 0)
+ break;
+ sd_jheightsize[x] = space;
+ }
+ sd_max_jheight = x;
+}
+
+static int parse_mounts(void)
+{
+ char str[PATH_MAX], dev[PATH_MAX], mnt[PATH_MAX], mtype[PATH_MAX];
+ char opts[PATH_MAX];
+ FILE *fp;
+
+ memset(debugfs, 0, sizeof(debugfs));
+ memset(mount_points, 0, sizeof(mount_points));
+ memset(devices, 0, sizeof(devices));
+
+ fp = fopen("/proc/mounts", "rt");
+ if (fp == NULL) {
+ perror("/proc/mounts");
+ return 1;
+ }
+ while (fgets(str, sizeof(str) - 1, fp)) {
+ sscanf(str, "%s %s %s %s", dev, mnt, mtype, opts);
+ if (!strcmp(mtype, "debugfs")) {
+ strcpy(debugfs, mnt);
+ continue;
+ }
+ if (strcmp(mtype, "gfs2")) /* if not gfs2 */
+ continue;
+
+ strncpy(mount_points[mounted], mnt, 79);
+ mount_points[mounted][79] = '\0';
+ strncpy(devices[mounted], dev, 79);
+ devices[mounted][79] = '\0';
+
+ /* Now find out the mount point's file system name */
+ fs_fd[mounted] = open(dev, O_RDONLY);
+ if (fs_fd[mounted])
+ read_superblock(fs_fd[mounted], mounted);
+ mounted++;
+ }
+ if (debugfs[0] == '\0') {
+ if (mount("debugfs", "/sys/kernel/debug", "debugfs", 0, NULL)){
+ fprintf(stderr, "Unable to mount debugfs.\n");
+ fprintf(stderr, "Please mount it manually.\n");
+ exit(-1);
+ }
+ strcpy(debugfs, "/sys/kernel/debug");
+ }
+ fclose(fp);
+ return 0;
+}
+
+/*
+ * display_title_lines
+ */
+static void display_title_lines(void)
+{
+ if (termlines) {
+ clear(); /* don't use Erase */
+ COLORS_TITLE;
+ attron(A_BOLD);
+ move(0, 0);
+ printw("%-80s", TITLE1);
+ move(termlines, 0);
+ printw("%-79s", TITLE2);
+ COLORS_NORMAL_BOLD;
+ move(1, 0);
+ } else {
+ printf("\n");
+ }
+ line = 1;
+}
+
+/*
+ * bobgets - get a string
+ * returns: 1 if user exited by hitting enter
+ * 0 if user exited by hitting escape
+ */
+static int bobgets(char string[], int x, int y, int sz, int *ch)
+{
+ int finished,runningy,rc;
+
+ if (!termlines)
+ return 0;
+ move(x,y);
+ finished=FALSE;
+ COLORS_INVERSE_BOLD;
+ move(x,y);
+ addstr(string);
+ move(x,y);
+ curs_set(2);
+ refresh();
+ runningy=y;
+ rc=0;
+ while (!finished) {
+ *ch = getch();
+
+ if(*ch < 0x0100 && isprint(*ch)) {
+ char *p=string+strlen(string); // end of the string
+
+ *(p+1)='\0';
+ string[runningy-y]=*ch;
+ runningy++;
+ move(x,y);
+ addstr(string);
+ if (runningy-y >= sz) {
+ rc=1;
+ *ch = KEY_RIGHT;
+ finished = TRUE;
+ }
+ }
+ else {
+ // special character, is it one we recognize?
+ switch(*ch)
+ {
+ case(KEY_ENTER):
+ case('\n'):
+ case('\r'):
+ rc=1;
+ finished=TRUE;
+ string[runningy-y] = '\0';
+ break;
+ case(KEY_CANCEL):
+ case(0x01B):
+ rc=0;
+ finished=TRUE;
+ break;
+ case(KEY_DC):
+ case(0x07F):
+ if (runningy>=y) {
+ char *p;
+ p = &string[runningy - y];
+ while (*p) {
+ *p = *(p + 1);
+ p++;
+ }
+ *p = '\0';
+ runningy--;
+ // remove the character from the string
+ move(x,y);
+ addstr(string);
+ COLORS_NORMAL_BOLD;
+ addstr(" ");
+ COLORS_INVERSE_BOLD;
+ runningy++;
+ }
+ break;
+ case(KEY_BACKSPACE):
+ if (runningy>y) {
+ char *p;
+
+ p = &string[runningy - y - 1];
+ while (*p) {
+ *p = *(p + 1);
+ p++;
+ }
+ *p='\0';
+ runningy--;
+ // remove the character from the string
+ move(x,y);
+ addstr(string);
+ COLORS_NORMAL_BOLD;
+ addstr(" ");
+ COLORS_INVERSE_BOLD;
+ }
+ break;
+ default:
+ move(0,70);
+ printw("%08x", *ch);
+ // ignore all other characters
+ break;
+ } // end switch on non-printable character
+ } // end non-printable character
+ move(line, runningy);
+ refresh();
+ } // while !finished
+ if (sz>0)
+ string[sz]='\0';
+ COLORS_NORMAL_BOLD;
+ return rc;
+}/* bobgets */
+
+static char *bufgets(int fd, char *bigbuf, char **nextpos, char **pos,
+ int *maxpos)
+{
+ if (*nextpos == NULL) {
+ *maxpos = read(fd, bigbuf, bufsize - 1);
+ bigbuf[bufsize - 1] = '\0';
+ if (*maxpos == 0)
+ return NULL;
+ *pos = bigbuf;
+ } else
+ *pos = *nextpos;
+
+ *nextpos = memchr(*pos, '\n', (bigbuf + *maxpos) - *pos);
+ while (*nextpos && (**nextpos == '\n' || **nextpos == '\r') &&
+ *nextpos < bigbuf + (bufsize - 1)) {
+ **nextpos = '\0';
+ (*nextpos)++;
+ }
+ if (*nextpos >= bigbuf + *maxpos)
+ *nextpos = NULL;
+ return *pos;
+}
+
+static char *glock_number(const char *str)
+{
+ const char *glockid;
+ char *p;
+ static char id[32];
+
+ glockid = strchr(str, '/');
+ if (glockid == NULL)
+ return NULL;
+ glockid++;
+ strncpy(id, glockid, sizeof(id));
+ id[31] = '\0';
+ p = strchr(id, ' ');
+ if (p)
+ *p = '\0';
+ return id;
+}
+
+static int this_glock_requested(const char *str)
+{
+ const char *glockid;
+ int i;
+
+ if (!glocks)
+ return 0;
+
+ glockid = glock_number(str);
+ if (glockid == NULL)
+ return 0;
+ for (i = 0; i < glocks; i++)
+ if (!strcmp(glockid, glock[i]))
+ return 1;
+ return 0;
+}
+
+static int is_iopen(const char *str)
+{
+ char *p;
+
+ p = strchr(str, '/');
+ if (p == NULL)
+ return 0;
+ p--;
+ if (*p == '5')
+ return 1;
+ return 0;
+}
+
+static int this_lkb_requested(const char *str)
+{
+ int i;
+
+ if (!glocks)
+ return 1;
+
+ for (i = 0; i < glocks; i++) {
+ if (strstr(str, glock[i]))
+ return 1;
+ }
+ return 0;
+}
+
+static void eol(int col) /* end of line */
+{
+ if (termlines) {
+ line++;
+ move(line, col);
+ } else {
+ printf("\n");
+ for (; col > 0; col--)
+ printf(" ");
+ }
+}
+
+void print_it(const char *label, const char *fmt, const char *fmt2, ...)
+{
+ va_list args;
+ char tmp_string[128];
+
+ if (!termlines || line < termlines) {
+ va_start(args, fmt2);
+ vsnprintf(tmp_string, 127, fmt, args);
+ tmp_string[127] = '\0';
+
+ if (termlines) {
+ printw("%s", tmp_string);
+ refresh();
+ } else {
+ printf("%s", tmp_string);
+ fflush(stdout);
+ }
+ }
+ va_end(args);
+}
+
+static void display_filename(int fd, unsigned long long block,
+ unsigned long long dirarray[256], int subdepth)
+{
+ int i, subs;
+ char *mntpt = NULL;
+ char blk[32];
+ DIR *dir = NULL;
+ struct dirent *dent;
+
+ for (i = 0; i < mounted; i++) {
+ if (fd == fs_fd[i]) {
+ mntpt = mount_points[i];
+ break;
+ }
+ }
+ if (i == mounted)
+ return;
+ for (i = 0; i < contended_count; i++) {
+ if (contended_blocks[i] == block) {
+ break;
+ }
+ }
+ sprintf(blk, "%lld", block);
+ if (i >= contended_count) {
+ memset(contended_filenames[i], 0, PATH_MAX);
+ strcat(contended_filenames[i], mntpt);
+ for (subs = subdepth - 2; subs >= 0; subs--) {
+ dir = opendir(contended_filenames[i]);
+ while ((dent = readdir(dir))) {
+ if (dent->d_ino == dirarray[subs]) {
+ strcat(contended_filenames[i], "/");
+ strcat(contended_filenames[i],
+ dent->d_name);
+ break;
+ }
+ }
+ closedir(dir);
+ }
+ }
+
+ print_it(NULL, "%s", NULL, contended_filenames[i]);
+ eol(0);
+}
+
+static const char *show_inode(const char *id, int fd, unsigned long long block)
+{
+ struct gfs2_inode *ip;
+ const char *inode_type = NULL;
+ struct gfs2_sbd sbd = { .device_fd = fd, .bsize = bsize };
+
+ ip = inode_read(&sbd, block);
+ if (S_ISDIR(ip->i_di.di_mode)) {
+ struct gfs2_inode *parent;
+ unsigned long long dirarray[256];
+ int subdepth = 0, error;
+
+ inode_type = "directory ";
+ dirarray[0] = block;
+ subdepth++;
+ /* Backtrack the directory to its source */
+ while (1) {
+ error = gfs2_lookupi(ip, "..", 2, &parent);
+ if (error)
+ break;
+ /* Stop at the root inode */
+ if (ip->i_di.di_num.no_addr ==
+ parent->i_di.di_num.no_addr)
+ break;
+ inode_put(&ip);
+ ip = parent;
+ dirarray[subdepth++] = parent->i_di.di_num.no_addr;
+ }
+ display_filename(fd, block, dirarray, subdepth);
+ } else if (S_ISREG(ip->i_di.di_mode)) {
+ inode_type = "file ";
+ } else if (S_ISLNK(ip->i_di.di_mode)) {
+ inode_type = "link ";
+ } else if (S_ISCHR(ip->i_di.di_mode)) {
+ inode_type = "char device ";
+ } else if (S_ISBLK(ip->i_di.di_mode)) {
+ inode_type = "block device ";
+ } else if (S_ISFIFO(ip->i_di.di_mode)) {
+ inode_type = "fifo ";
+ } else if (S_ISSOCK(ip->i_di.di_mode)) {
+ inode_type = "socket ";
+ } else
+ inode_type = "file? ";
+ inode_put(&ip);
+ return inode_type;
+}
+
+static const char *show_details(const char *id, const char *fsname, int btype,
+ int trace_dir_path)
+{
+ int mnt_num;
+ unsigned long long block = 0;
+ const char *blk_type = NULL;
+ FILE *dlmf;
+
+ /* Figure out which mount point corresponds to this debugfs id */
+ for (mnt_num = 0; mnt_num < mounted; mnt_num++) {
+ char *p;
+
+ p = strchr(sd_sb[mnt_num].sb_locktable, ':');
+ if (!p)
+ continue;
+ p++;
+ if (!strcmp(p, fsname))
+ break;
+ }
+ memset(dlm_dirtbl_size, 0, sizeof(dlm_dirtbl_size));
+ memset(dlm_rsbtbl_size, 0, sizeof(dlm_rsbtbl_size));
+ memset(dlm_lkbtbl_size, 0, sizeof(dlm_lkbtbl_size));
+ if (!strcmp(sd_sb[mnt_num].sb_lockproto, "lock_dlm")) {
+ char *p;
+
+ dlmf = fopen(DLM_DIRTBL, "rt");
+ if (dlmf) {
+ fgets(dlm_dirtbl_size, sizeof(dlm_dirtbl_size), dlmf);
+ p = strchr(dlm_dirtbl_size, '\n');
+ if (p)
+ *p = '\0';
+ fclose(dlmf);
+ } else {
+ strcpy(dlm_dirtbl_size, " ");
+ }
+ dlmf = fopen(DLM_RSBTBL, "rt");
+ if (dlmf) {
+ fgets(dlm_rsbtbl_size, sizeof(dlm_rsbtbl_size), dlmf);
+ p = strchr(dlm_rsbtbl_size, '\n');
+ if (p)
+ *p = '\0';
+ fclose(dlmf);
+ } else {
+ strcpy(dlm_rsbtbl_size, " ");
+ }
+ dlmf = fopen(DLM_LKBTBL, "rt");
+ if (dlmf) {
+ fgets(dlm_lkbtbl_size, sizeof(dlm_lkbtbl_size), dlmf);
+ p = strchr(dlm_lkbtbl_size, '\n');
+ if (p)
+ *p = '\0';
+ fclose(dlmf);
+ } else {
+ strcpy(dlm_lkbtbl_size, " ");
+ }
+ } else {
+ strcpy(dlm_dirtbl_size, "nolock");
+ strcpy(dlm_lkbtbl_size, "nolock");
+ strcpy(dlm_lkbtbl_size, "nolock");
+ }
+
+ if (mnt_num >= mounted) /* can't find the right superblock */
+ return "unknown";
+
+ /* Read the inode in so we can see its type. */
+ sscanf(id, "%llx", &block);
+ if (block) {
+ if (btype == 2)
+ if (trace_dir_path)
+ blk_type = show_inode(id, fs_fd[mnt_num],
+ block);
+ else
+ blk_type = "";
+ else
+ blk_type = "";
+ }
+ return blk_type;
+}
+
+static int is_dlm_waiting(int dlmwaiters, int locktype, char *id)
+{
+ int i;
+ int dlmid, wait_type, nodeid, type;
+ char locknum[32];
+
+ for (i = 0; i < dlmwaiters && i < 100; i++) {
+ sscanf(dlmwlines[i], "%x %d %d %d %s",
+ &dlmid, &wait_type, &nodeid, &type, locknum);
+ if ((type == locktype) && (!strcmp(locknum, id)))
+ return 1;
+ }
+ return 0;
+}
+
+static const char *friendly_state(const char *glock_line, const char *search)
+{
+ const char *p;
+
+ p = strstr(glock_line, search);
+
+ if (p == NULL)
+ return "Dazed";
+
+ p += 2;
+ if (*p == 'E')
+ return "Exclusive";
+ else if (*p == 'S')
+ return "Shared";
+ else if (*p == 'U')
+ return "Unlocked";
+ else if (*p == 'D')
+ return "Deferred";
+ else
+ return "Confused";
+}
+
+static const char *friendly_gflags(const char *glock_line)
+{
+ static char flagout[PATH_MAX];
+ const char *p;
+
+ memset(flagout, 0, sizeof(flagout));
+
+ p = strstr(glock_line, "f:");
+ if (!p)
+ return " ";
+ p += 2;
+ strcpy(flagout, "[");
+ while (*p != ' ') {
+ switch (*p) {
+ case 'l':
+ /*strcat(flagout, "Locked");*/
+ break;
+ case 'D':
+ strcat(flagout, "Demoting");
+ break;
+ case 'd':
+ strcat(flagout, "Demote pending");
+ break;
+ case 'p':
+ strcat(flagout, "Demote in progress");
+ break;
+ case 'y':
+ strcat(flagout, "Dirty");
+ break;
+ case 'f':
+ strcat(flagout, "Flush");
+ break;
+ case 'i':
+ strcat(flagout, "Invalidating");
+ break;
+ case 'r':
+ strcat(flagout, "Reply pending");
+ break;
+ case 'I':
+ /*strcat(flagout, "Initial");*/
+ break;
+ case 'F':
+ strcat(flagout, "Frozen");
+ break;
+ case 'q':
+ strcat(flagout, "Queued");
+ break;
+ case 'L':
+ strcat(flagout, "LRU");
+ break;
+ case 'o':
+ /*strcat(flagout, "Object present");*/
+ break;
+ case 'b':
+ strcat(flagout, "Blocking");
+ break;
+ default:
+ strcat(flagout, "Unknown");
+ break;
+ }
+ if ((strlen(flagout)) > 1 && (!strchr(" lIo", *(p + 1))))
+ strcat(flagout, ", ");
+ p++;
+ }
+ strcat(flagout, "]");
+ return flagout;
+}
+
+static const char *friendly_glock(const char *glock_line, char prefix)
+{
+ static char gline[PATH_MAX];
+
+ if (prefix == 'W')
+ sprintf(gline, "Is:%s, Want:%s %s",
+ friendly_state(glock_line, "s:"),
+ friendly_state(glock_line, "t:"),
+ friendly_gflags(glock_line));
+ else
+ sprintf(gline, "Held:%s %s",
+ friendly_state(glock_line, "s:"),
+ friendly_gflags(glock_line));
+ return gline;
+}
+
+static const char *dlm_grtype(int grmode)
+{
+ const char *dlm_types[8] = {"NL", "CR", "CW", "PR", "PW", "EX",
+ "NA", "NA"};
+
+ if (grmode < 0)
+ return "-1";
+ return dlm_types[grmode & 0x07];
+}
+
+static const char *dlm_status(int status)
+{
+ const char *dlm_statuses[4] = {"Unknown", "Waiting", "Granted",
+ "Converting"};
+ if (status < 0)
+ return "unknown";
+ return dlm_statuses[status & 0x03];
+}
+
+static const char *dlm_nodeid(int lkbnodeid)
+{
+ static char nodeid[16];
+
+ if (lkbnodeid == 0)
+ return "this node";
+ sprintf(nodeid, "node %d", lkbnodeid);
+ return nodeid;
+}
+
+static const char *getprocname(int ownpid)
+{
+ char fn[1024];
+ static char str[80];
+ const char *procname;
+ FILE *fp;
+
+ sprintf(fn, "/proc/%d/status", ownpid);
+ fp = fopen(fn, "r");
+ if (fp == NULL)
+ return "ended";
+
+ if (fgets(str, 80, fp) != NULL) {
+ char *p;
+
+ procname = str + 6;
+ p = strchr(procname, '\n');
+ if (p)
+ *p = '\0';
+ } else
+ procname = "unknown";
+
+ fclose(fp);
+ return procname;
+}
+
+static void show_dlm_grants(int locktype, const char *g_line, int dlmgrants,
+ int summary)
+{
+ int i;
+ char dlm_resid[64];
+ unsigned int lkb_id, lkbnodeid, remid, ownpid, exflags, flags, status;
+ unsigned int grmode, rqmode, nodeid, length;
+ unsigned long long xid, us;
+ char trgt_res_name[64], res_name[64], *p1, *p2;
+ const char *procname;
+
+ p1 = strchr(g_line, '/');
+ if (!p1)
+ return;
+ p1++;
+ p2 = strchr(p1, ' ');
+ if (!p2)
+ return;
+ memset(trgt_res_name, 0, sizeof(trgt_res_name));
+ memcpy(trgt_res_name, p1, p2 - p1);
+ sprintf(dlm_resid, "%8d%16s", locktype, trgt_res_name);
+ for (i = 0; i < dlmgrants; i++) {
+/*
+lkb_id n remid pid x e f s g rq u n ln res_name 1234567890123456
+1100003 1 2ae0006 8954 0 0 0 2 5 -1 0 1 24 " 2 102ab"
+2a20001 1 30d0001 8934 0 0 0 2 3 -1 0 1 24 " 5 102ab"
+ b0001 2 860001 8868 0 0 10000 2 3 -1 0 0 24 " 1 2"
+2450001 2 1be0002 8962 0 0 10000 1 -1 5 12214 0 24 " 2 102ab"
+*/
+ p1 = strchr(dlmglines[i], '\"');
+ if (!p1)
+ continue;
+ p1++;
+ if (strncmp(dlm_resid, p1, 24))
+ continue;
+
+ sscanf(dlmglines[i], "%x %d %x %u %llu %x %x %d %d %d %llu "
+ "%u %d \"%24s\"\n",
+ &lkb_id, &lkbnodeid, &remid, &ownpid, &xid, &exflags,
+ &flags, &status, &grmode, &rqmode, &us, &nodeid,
+ &length, res_name);
+ if (status == 1) { /* Waiting */
+ if (!lkbnodeid)
+ procname = getprocname(ownpid);
+ else
+ procname = "";
+ if (summary)
+ print_it(NULL, " (", NULL);
+ else
+ print_it(NULL, " D: ", NULL);
+ print_it(NULL, "%s for %s, pid %d %s", NULL,
+ dlm_status(status), dlm_nodeid(lkbnodeid),
+ ownpid, procname);
+ if (summary)
+ print_it(NULL, ")", NULL);
+ } else if (grmode == 0) {
+ continue; /* ignore "D: Granted NL on node X" */
+ } else {
+ procname = getprocname(ownpid);
+ if (summary)
+ print_it(NULL, " (", NULL);
+ else
+ print_it(NULL, " D: ", NULL);
+ print_it(NULL, "%s %s on %s to pid %d %s", NULL,
+ dlm_status(status), dlm_grtype(grmode),
+ dlm_nodeid(lkbnodeid), ownpid, procname);
+ if (summary)
+ print_it(NULL, ")", NULL);
+ }
+ if (!summary)
+ eol(0);
+ }
+}
+
+static void print_call_trace(const char *h_line)
+{
+ char *p, *pid, tmp[32], stackfn[64], str[96];
+ FILE *fp;
+ int i;
+
+ p = strchr(h_line, 'p');
+ if (!p)
+ return;
+ pid = p + 2;
+ p = strchr(pid, ' ');
+ if (!p)
+ return;
+ memset(tmp, 0, sizeof(tmp));
+ memcpy(tmp, pid, p - pid);
+ sprintf(stackfn, "/proc/%s/stack", tmp);
+ fp = fopen(stackfn, "rt");
+ if (fp == NULL)
+ return;
+ for (i = 0; i < MAX_CALLTRACE_LINES; i++) {
+ if (fgets(str, sizeof(str) - 1, fp) == NULL)
+ break;
+ if (strstr(str, "gfs2_glock_")) { /* skip lines we don't
+ care about*/
+ i--;
+ continue;
+ }
+ p = strchr(str, '\n');
+ if (p)
+ *p = '\0';
+ p = strchr(str, ']');
+ if (p)
+ p += 2;
+ else
+ p = str;
+ print_it(NULL, " C: %s ", NULL, p);
+ eol(0);
+ }
+ fclose(fp);
+}
+
+static int is_ex(const char *h_line)
+{
+ if (strncmp(h_line, " H: s:EX ", 9) == 0)
+ return 1;
+ return 0;
+}
+
+static int has_holder_flag(const char *h_line, char flag)
+{
+ const char *p;
+
+ p = strchr(h_line, 'f');
+ if (p == NULL)
+ return 0;
+ p++;
+ if (*p != ':')
+ return 0;
+ p++;
+ while (*p != '\0') {
+ if (*p == ' ')
+ return 0;
+ if (*p == flag)
+ return 1;
+ p++;
+ }
+ return 0;
+}
+
+static int is_holder(const char *h_line)
+{
+ return has_holder_flag(h_line, 'H');
+}
+
+static int is_waiter(const char *h_line)
+{
+ return has_holder_flag(h_line, 'W');
+}
+
+static int get_lock_type(const char *str)
+{
+ const char *p;
+
+ p = strchr(str, '/');
+ return (p ? (*(p - 1)) - '0' : 0);
+}
+
+static long long get_demote_time(const char *str)
+{
+ char *p;
+ char tmp[80];
+
+ p = strchr(str, '/');
+ if (p == NULL)
+ return 0;
+ p++;
+ p = strchr(p, '/');
+ if (p == NULL)
+ return 0;
+ p++;
+ strncpy(tmp, p, 79);
+ tmp[79] = '\0';
+ p = strchr(tmp, ' ');
+ if (p == NULL)
+ return 0;
+ *p = '\0';
+ return atoll(tmp);
+}
+
+static const char *pid_string(const char *str)
+{
+ char *p;
+ static char pidstr[80];
+
+ memset(pidstr, 0, sizeof(pidstr));
+ p = strchr(str, 'p');
+ if (p) {
+ strncpy(pidstr, p + 2, sizeof(pidstr));
+ pidstr[79] = '\0';
+ p = strchr(pidstr, ']');
+ if (p) {
+ p++;
+ *p = '\0';
+ }
+ }
+ return pidstr;
+}
+
+/* If this glock is relevant, return 0, else the reason it's irrelevant */
+static int irrelevant(const char *holder, const char *glockstr)
+{
+ int lock_type = get_lock_type(glockstr);
+
+ /* Exclude shared and locks */
+ if (!is_ex(holder))
+ return 1;
+ /* Exclude locks held at mount time: statfs*/
+ if (strstr(holder, "init_per_node"))
+ return 2;
+ if (strstr(holder, "init_journal"))
+ return 3;
+ if (strstr(holder, "init_inodes"))
+ return 4;
+ if (strstr(holder, "fill_super"))
+ return 5;
+ if (lock_type == 9) /* Exclude journal locks */
+ return 6;
+ return 0;
+}
+
+static const char *reason(int why)
+{
+ const char *reasons[] = {"(N/A:------)", /* 0 */
+ "(N/A:Not EX)", /* 1 */
+ "(N/A:System)", /* 2 */
+ "(N/A:journl)", /* 3 */
+ "(N/A:System)", /* 4 */
+ "(N/A:System)", /* 5 */
+ "(N/A:Journl)"}; /* 6 */
+
+ return reasons[why];
+}
+
+static void print_friendly_prefix(char one_glocks_lines[MAX_LINES][97])
+{
+ int why = irrelevant(one_glocks_lines[1], one_glocks_lines[0]);
+
+ if (why)
+ print_it(NULL, " U: %s ", NULL, reason(why));
+ else
+ print_it(NULL, " U: ", NULL);
+}
+
+static void show_glock(char one_glocks_lines[MAX_LINES][97], int gline,
+ const char *fsname, int dlmwaiters, int dlmgrants,
+ int trace_dir_path, int prev_had_waiter, int flags,
+ int summary)
+{
+ int i, locktype = 0;
+ char id[33], *p;
+ char extras[80], prefix = '\0';
+ long long demote_time = 0;
+ const char *ltype[] = {"N/A", "non-disk", "inode", "rgrp", "meta",
+ "i_open", "flock", "posix lock", "quota",
+ "journal"};
+
+ if (termlines) {
+ if (irrelevant(one_glocks_lines[1], one_glocks_lines[0]))
+ COLORS_HELD;
+ else
+ COLORS_NORMAL;
+ }
+ if (!gline)
+ return;
+
+ memset(extras, 0, sizeof(extras));
+ p = strchr(one_glocks_lines[0], '/');
+ memset(id, 0, sizeof(id));
+
+ if (p) {
+ locktype = get_lock_type(one_glocks_lines[0]);
+ demote_time = get_demote_time(one_glocks_lines[0]);
+ p++;
+ strncpy(id, p, sizeof(id) - 1);
+ id[sizeof(id) - 1] = '\0';
+ p = strchr(id, ' ');
+ if (p)
+ *p = '\0';
+
+ if (locktype != 2) {
+ strncpy(extras, ltype[locktype], 79);
+ extras[79] = '\0';
+ } else {
+ const char *i_type = show_details(id, fsname, 2,
+ trace_dir_path);
+ sprintf(extras, "%sinode", i_type);
+ }
+ }
+ if (flags & DETAILS) {
+ print_it(NULL, " %s ", NULL, one_glocks_lines[0]);
+ print_it(NULL, "(%s)", NULL, extras);
+ if (demote_time)
+ print_it(NULL, " ** demote time is greater than 0 **",
+ NULL);
+ eol(0);
+ if (dlmgrants)
+ show_dlm_grants(locktype, one_glocks_lines[0],
+ dlmgrants, 0);
+ }
+ if (flags & FRIENDLY) {
+ print_friendly_prefix(one_glocks_lines);
+ for (i = 1; i < gline; i++) {
+ if (one_glocks_lines[i][0] == ' ' &&
+ one_glocks_lines[i][1] == 'H' &&
+ prefix != 'W')
+ prefix = (is_holder(one_glocks_lines[i]) ?
+ 'H' : 'W');
+ }
+ print_it(NULL, " %c %-10.10s %-9.9s %s", NULL, prefix,
+ extras, id, friendly_glock(one_glocks_lines[0],
+ prefix));
+ eol(0);
+ }
+ for (i = 1; i < gline; i++) {
+ if (!show_reservations &&
+ one_glocks_lines[i][0] == ' ' &&
+ one_glocks_lines[i][2] == 'B' &&
+ one_glocks_lines[i][3] == ':')
+ continue;
+
+ if (flags & DETAILS) {
+ print_it(NULL, " %-80.80s", NULL, one_glocks_lines[i]);
+ eol(0);
+ continue;
+ }
+ if ((flags & FRIENDLY) &&
+ one_glocks_lines[i][1] == 'H')
+ print_friendly_prefix(one_glocks_lines);
+
+ if (one_glocks_lines[i][0] == ' ' &&
+ one_glocks_lines[i][1] == 'H') {
+ print_it(NULL, " %c ---> %s pid %s ", NULL,
+ prefix, (is_holder(one_glocks_lines[i]) ?
+ "held by" : "waiting"),
+ pid_string(one_glocks_lines[i]));
+ if (demote_time)
+ print_it(NULL, "** demote time is non-"
+ "zero ** ", NULL);
+ if (is_dlm_waiting(dlmwaiters, locktype, id)) {
+ print_it(NULL, "***** DLM is in a "
+ "comm wait for this lock "
+ "***** ", NULL);
+ }
+ show_dlm_grants(locktype, one_glocks_lines[0],
+ dlmgrants, 1);
+ eol(0);
+ print_call_trace(one_glocks_lines[i]);
+ }
+ }
+}
+
+static int parse_dlm_waiters(FILE *dlm, const char *fsname)
+{
+ int dlml = 0;
+
+ memset(dlmwlines, 0, sizeof(dlmwlines));
+ while (fgets(dlmwlines[dlml], 80, dlm))
+ dlml++;
+
+ return dlml;
+}
+
+static int parse_dlm_grants(int dlmfd, const char *fsname)
+{
+ int dlml = 0;
+ char *dlmline;
+
+ memset(dlmglines, 0, sizeof(dlmglines));
+ dnextpos = NULL;
+ while ((dlmline = bufgets(dlmfd, dbuf, &dnextpos, &dpos, &dmaxpos))) {
+ if (!this_lkb_requested(dlmline))
+ continue;
+ strncpy(dlmglines[dlml], dlmline, 96);
+ dlmglines[dlml][96] = '\0';
+ dlml++;
+ if (dlml >= MAX_LINES)
+ break;
+ }
+ return dlml;
+}
+
+static void print_summary(int total_glocks[11][stypes], int dlmwaiters)
+{
+ int i;
+ int total_unlocked = 0;
+ const struct {
+ const char *name;
+ const int width;
+ } column[] = {
+ { "unknown", 7 }, { "nondisk", 7}, { "inode", 8 }, { "rgrp", 7 },
+ { "meta", 4 }, { "iopen", 7 }, { "flock", 7 }, { "p", 1 },
+ { "quota", 5 }, { "jrnl", 4 }, { "Total", 8 }
+ };
+ const int ncols = sizeof(column) / sizeof(column[0]);
+
+ /* Print column headers */
+ print_it(NULL, "S glocks ", NULL);
+ for (i = 1; i < ncols; i++)
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*s ", NULL, column[i].width, column[i].name);
+ eol(0);
+ print_it(NULL, "S --------- ", NULL);
+ for (i = 1; i < ncols; i++)
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*s ", NULL, column[i].width, "--------");
+ eol(0);
+
+ /* Print rows */
+ print_it(NULL, "S Unlocked: ", NULL);
+ for (i = 1; i < (ncols - 1); i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][all] - total_glocks[i][locked]);
+ total_unlocked += total_glocks[i][all] -
+ total_glocks[i][locked];
+ }
+ print_it(NULL, "%*d ", NULL, column[i].width, total_unlocked);
+ eol(0);
+ print_it(NULL, "S Locked: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][locked]);
+ total_glocks[10][locked] += total_glocks[i][locked];
+ }
+ eol(0);
+ print_it(NULL, "S Total: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][all]);
+ total_glocks[10][all] += total_glocks[i][all];
+ }
+ eol(0);
+ print_it(NULL, "S", NULL);
+ eol(0);
+ print_it(NULL, "S Held EX: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][held_ex]);
+ total_glocks[10][held_ex] += total_glocks[i][held_ex];
+ }
+ eol(0);
+ print_it(NULL, "S Held SH: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][held_sh]);
+ total_glocks[10][held_sh] += total_glocks[i][held_sh];
+ }
+ eol(0);
+ print_it(NULL, "S Held DF: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][held_df]);
+ total_glocks[10][held_df] += total_glocks[i][held_df];
+ }
+ eol(0);
+ print_it(NULL, "S G Waiting: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][has_waiter]);
+ total_glocks[10][has_waiter] += total_glocks[i][has_waiter];
+ }
+ eol(0);
+ print_it(NULL, "S P Waiting: ", NULL);
+ for (i = 1; i < ncols; i++) {
+ if (i != 7 && i != 4) /* Ignore plock and meta */
+ print_it(NULL, "%*d ", NULL, column[i].width,
+ total_glocks[i][tot_waiters]);
+ total_glocks[10][tot_waiters] += total_glocks[i][tot_waiters];
+ }
+ eol(0);
+ print_it(NULL, "S DLM wait: %7d", NULL, dlmwaiters);
+ eol(0);
+ eol(0);
+}
+
+/* flags = DETAILS || FRIENDLY or both */
+static void glock_details(int fd, const char *fsname, int dlmwaiters,
+ int dlmgrants, int trace_dir_path, int show_held,
+ int summary)
+{
+ char *ln, *p;
+ char one_glocks_lines[MAX_LINES][97];
+ int gline = 0;
+ int show_prev_glock = 0, prev_had_waiter = 0;
+ int total_glocks[11][stypes], locktype = 0;
+ int holders_this_glock_ex = 0;
+ int holders_this_glock_sh = 0;
+ int holders_this_glock_df = 0;
+ int waiters_this_glock = 0;
+
+ memset(total_glocks, 0, sizeof(total_glocks));
+ gnextpos = NULL;
+ while ((ln = bufgets(fd, gbuf, &gnextpos, &gpos, &gmaxpos))) {
+ if (ln[0] == ' ' && ln[1] == ' ' && ln[2] == ' ')
+ continue;
+ if (ln[0] == 'G') {
+ /* Summary stuff------------------------------------ */
+ if (waiters_this_glock) {
+ total_glocks[locktype][tot_waiters] +=
+ waiters_this_glock;
+ total_glocks[locktype][has_waiter]++;
+ }
+ if (holders_this_glock_ex)
+ total_glocks[locktype][held_ex]++;
+ if (holders_this_glock_sh)
+ total_glocks[locktype][held_sh]++;
+ if (holders_this_glock_df)
+ total_glocks[locktype][held_df]++;
+ locktype = get_lock_type(ln);
+ p = ln + 6;
+ if (*p != 'U' || *(p + 1) != 'N')
+ total_glocks[locktype][locked]++;
+ total_glocks[locktype][all]++;
+ holders_this_glock_ex = 0;
+ holders_this_glock_sh = 0;
+ holders_this_glock_df = 0;
+ waiters_this_glock = 0;
+ /* Detail stuff------------------------------------- */
+ if (show_prev_glock) {
+ show_glock(one_glocks_lines, gline, fsname,
+ dlmwaiters, dlmgrants,
+ trace_dir_path, prev_had_waiter,
+ DETAILS, summary);
+ show_glock(one_glocks_lines, gline, fsname,
+ dlmwaiters, dlmgrants,
+ trace_dir_path, prev_had_waiter,
+ FRIENDLY, summary);
+ memset(one_glocks_lines, 0,
+ sizeof(one_glocks_lines));
+ show_prev_glock = 0;
+ }
+ prev_had_waiter = 0;
+ gline = 0;
+ if (this_glock_requested(ln))
+ show_prev_glock = 1;
+ } else if (ln[0] == ' ' && ln[1] == 'H') {
+ char *flag = strchr(ln, 'f');
+ char *mode = strchr(ln, 's');
+
+ /* Summary stuff------------------------------------ */
+ while (flag) {
+ flag++;
+ switch (*flag) {
+ case ':':
+ break;
+ case 'W':
+ waiters_this_glock++;
+ flag = NULL;
+ break;
+ case 'H':
+ flag = NULL;
+ if (mode == NULL)
+ holders_this_glock_df++;
+ else if (*(mode + 1) == ':' &&
+ *(mode + 2) == 'E' &&
+ *(mode + 3) == 'X')
+ holders_this_glock_ex++;
+ else if (*(mode + 1) == ':' &&
+ *(mode + 2) == 'S' &&
+ *(mode + 3) == 'H')
+ holders_this_glock_sh++;
+ else
+ holders_this_glock_df++;
+ break;
+ case ' ':
+ flag = NULL;
+ break;
+ default:
+ break;
+ };
+ }
+ /* Detail stuff------------------------------------- */
+ if (!glocks) {
+ int haswaiter = is_waiter(ln);
+
+ if (haswaiter) {
+ show_prev_glock = 1;
+ prev_had_waiter = 1;
+ } else if (show_held && is_holder(ln) &&
+ !is_iopen(one_glocks_lines[0])) {
+ show_prev_glock = 1;
+ } else if (!irrelevant(ln, one_glocks_lines[0])) {
+ show_prev_glock = 1;
+ }
+ }
+ }
+ /* Detail stuff--------------------------------------------- */
+ strncpy(one_glocks_lines[gline], ln, 96);
+ one_glocks_lines[gline][96] = '\0';
+ gline++;
+ if (gline >= MAX_LINES)
+ break;
+ if (termlines && line >= termlines)
+ break;
+ }
+ /* Detail stuff----------------------------------------------------- */
+ if (show_prev_glock && gline < MAX_LINES &&
+ (!termlines || line < termlines)) {
+ show_glock(one_glocks_lines, gline, fsname, dlmwaiters,
+ dlmgrants, trace_dir_path, prev_had_waiter,
+ DETAILS, summary);
+ show_glock(one_glocks_lines, gline, fsname, dlmwaiters,
+ dlmgrants, trace_dir_path, prev_had_waiter,
+ FRIENDLY, summary);
+ }
+ if (!summary || ((iters_done % summary) != 0))
+ return;
+
+ print_summary(total_glocks, dlmwaiters);
+}
+
+static void show_help(int help)
+{
+ if (help == 1) {
+ COLORS_NORMAL;
+ eol(0);
+ print_it(NULL, " Glock flags: ", NULL);
+ eol(0);
+ print_it(NULL, " l - Locked ", NULL);
+ print_it(NULL, " r - Reply pending ", NULL);
+ eol(0);
+ print_it(NULL, " d - Demote pending ", NULL);
+ print_it(NULL, " I - Initial ", NULL);
+ eol(0);
+ print_it(NULL, " D - Demote requested ", NULL);
+ print_it(NULL, " F - Frozen ", NULL);
+ eol(0);
+ print_it(NULL, " p - Demote in progress ", NULL);
+ print_it(NULL, " q - Queued holder ", NULL);
+ eol(0);
+ print_it(NULL, " y - Dirty data ", NULL);
+ print_it(NULL, " L - LRU ", NULL);
+ eol(0);
+ print_it(NULL, " f - Flush ", NULL);
+ print_it(NULL, " o - Object present ", NULL);
+ eol(0);
+ print_it(NULL, " i - Invalidating ", NULL);
+ print_it(NULL, " b - Blocking request ", NULL);
+ eol(0);
+ } else if (help == 2) {
+ COLORS_NORMAL;
+ eol(0);
+ print_it(NULL, " Holder flags: ", NULL);
+ eol(0);
+ print_it(NULL, " t - Try (non-blocking) ", NULL);
+ print_it(NULL, " E - Exact lock ", NULL);
+ eol(0);
+ print_it(NULL, " T - Try with callback ", NULL);
+ print_it(NULL, " c - No Cache lock ", NULL);
+ eol(0);
+ print_it(NULL, " e - No exp ", NULL);
+ print_it(NULL, " H - Held (locked) ", NULL);
+ eol(0);
+ print_it(NULL, " A - Any lock ", NULL);
+ print_it(NULL, " W - Waiting for lock ", NULL);
+ eol(0);
+ print_it(NULL, " p - Priority lock ", NULL);
+ print_it(NULL, " a - Asynchronous lock ", NULL);
+ eol(0);
+ print_it(NULL, " F - First ", NULL);
+ eol(0);
+ }
+}
+
+/* flags = DETAILS || FRIENDLY or both */
+static void parse_glocks_file(int fd, const char *fsname, int dlmwaiters,
+ int dlmgrants, int trace_dir_path,
+ int show_held, int help, int summary)
+{
+ char fstitle[96], fsdlm[96];
+ char ctimestr[64];
+ time_t t;
+ int i;
+
+ tzset();
+ t = time(NULL);
+ strftime(ctimestr, 64, "%a %b %d %T %Y", localtime(&t));
+ ctimestr[63] = '\0';
+ memset(fstitle, 0, sizeof(fstitle));
+ memset(fsdlm, 0, sizeof(fsdlm));
+ sprintf(fstitle, "@ %s %s ", fsname, ctimestr);
+ if (dlmwaiters) {
+ sprintf(fsdlm, "dlm: %s/%s/%s [", dlm_dirtbl_size,
+ dlm_rsbtbl_size, dlm_lkbtbl_size);
+ for (i = 0; i < dlmwaiters; i++)
+ strcat(fsdlm, "*");
+ for (; i < 10; i++)
+ strcat(fsdlm, " ");
+ strcat(fsdlm, "]");
+ }
+ attron(A_BOLD);
+ print_it(NULL, "%s @%s %s", NULL, fstitle, hostname, fsdlm);
+ eol(0);
+ attroff(A_BOLD);
+ glock_details(fd, fsname, dlmwaiters, dlmgrants, trace_dir_path,
+ show_held, summary);
+
+ show_help(help);
+ if (termlines)
+ refresh();
+}
+
+static void usage(void)
+{
+ printf("Usage:\n");
+ printf("glocktop [-i] [-d <delay sec>] [-f] [-n <iter>] [-sX] "
+ "[-c] [-D] [-H] [-r] [-t]\n");
+ printf("\n");
+ printf("-i : Runs glocktop in interactive mode.\n");
+ printf("-d : delay between refreshes, in seconds (default: 3).\n");
+ printf("-n : stop after <iter> refreshes.\n");
+ printf("-H : don't show Held glocks, even if not waited on, excluding "
+ "iopen\n");
+ printf("-r : show reservations when rgrp glocks are displayed\n");
+ printf("-s : show glock summary information every X iterations\n");
+ printf("-t : trace directory glocks back\n");
+ printf("-D : don't show DLM lock status\n");
+ printf("\n");
+ fflush(stdout);
+ exit(0);
+}
+
+int main(int argc, char **argv)
+{
+ int fd;
+ DIR *dir = NULL;
+ char fn[PATH_MAX];
+ struct dirent *dent;
+ int retval;
+ struct timeval tv;
+ fd_set readfds;
+ char string[96];
+ int ch, i, dlmwaiters = 0, dlmgrants = 0;
+ int cont = TRUE, optchar;
+ int trace_dir_path = 0;
+ int show_held = 1, help = 0;
+ int interactive = 0;
+ int summary = 10;
+
+ prog_name = argv[0];
+ memset(glock, 0, sizeof(glock));
+ memset(contended_filenames, 0, sizeof(contended_filenames));
+ memset(contended_blocks, 0, sizeof(contended_blocks));
+ UpdateSize(0);
+ /* decode command line arguments */
+ while (cont) {
+ optchar = getopt(argc, argv, "-d:Dn:rs:thHi");
+
+ switch (optchar) {
+ case 'd':
+ refresh_time = atoi(optarg);
+ if (refresh_time < 1) {
+ fprintf(stderr, "Error: delay %d too small; "
+ "must be > 1\n", refresh_time);
+ exit(-1);
+ }
+ break;
+ case 'D':
+ print_dlm_grants = 0;
+ break;
+ case 'n':
+ iterations = atoi(optarg);
+ break;
+ case 'r':
+ show_reservations = 1;
+ break;
+ case 's':
+ summary = atoi(optarg);
+ break;
+ case 't':
+ trace_dir_path = 1;
+ break;
+ case 'h':
+ usage();
+ break;
+ case 'H':
+ show_held = 0; /* held, but not iopen held */
+ break;
+ case 'i':
+ interactive = 1;
+ break;
+ case EOF:
+ cont = FALSE;
+ break;
+ case 1:
+ if (optarg && glocks < MAX_GLOCKS)
+ glock[glocks++] = optarg;
+ break;
+
+ default:
+ fprintf(stderr, "unknown option: %c\n", optchar);
+ exit(-1);
+ };
+ }
+
+ if (interactive) {
+ printf("Initializing. Please wait...");
+ fflush(stdout);
+ }
+ if (gethostname(hostname, sizeof(hostname))) {
+ fprintf(stderr, "Error: unable to determine host name.\n");
+ exit(-1);
+ }
+ if (parse_mounts())
+ exit(-1);
+
+ if (interactive && (wind = initscr()) == NULL) {
+ fprintf(stderr, "Error: unable to initialize screen.\n");
+ exit(-1);
+ }
+
+ if (interactive) {
+ /* Do our initial screen stuff: */
+ signal(SIGWINCH, UpdateSize); /* handle term resize signal */
+ UpdateSize(0); /* update screen size based on term settings */
+ clear(); /* don't use Erase */
+ start_color();
+ noecho();
+ keypad(stdscr, TRUE);
+ raw();
+ curs_set(0);
+ init_colors();
+ } else {
+ termlines = 0;
+ }
+ while (!gbuf) {
+ gbuf = malloc(bufsize);
+ if (gbuf) {
+ /*printf("bufsize=%dK\n", bufsize / 1024);*/
+ break;
+ }
+ bufsize /= 2;
+ }
+ while (!dbuf) {
+ dbuf = malloc(bufsize);
+ if (dbuf) {
+ /*printf("bufsize=%dK\n", bufsize / 1024);*/
+ break;
+ }
+ bufsize /= 2;
+ }
+
+ while (!done) {
+ sprintf(fn, "%s/gfs2/", debugfs);
+ dir = opendir(fn);
+
+ if (!dir) {
+ if (interactive) {
+ refresh();
+ endwin();
+ }
+ fprintf(stderr, "Unable to open gfs2 debugfs directory.\n");
+ fprintf(stderr, "Check if debugfs and gfs2 are mounted.\n");
+ exit(-1);
+ }
+ display_title_lines();
+ while ((dent = readdir(dir))) {
+ const char *fsname;
+ char dlm_fn[PATH_MAX];
+ FILE *dlmf;
+ int dlmfd;
+
+ if (!strcmp(dent->d_name, "."))
+ continue;
+ if (!strcmp(dent->d_name, ".."))
+ continue;
+
+ fsname = strchr(dent->d_name, ':');
+ if (fsname)
+ fsname++;
+ else
+ fsname = dent->d_name;
+
+ memset(dlm_fn, 0, sizeof(dlm_fn));
+ sprintf(dlm_fn, "%s/dlm/%s_waiters", debugfs, fsname);
+ dlmf = fopen(dlm_fn, "rt");
+ if (dlmf) {
+ dlmwaiters = parse_dlm_waiters(dlmf, fsname);
+ fclose(dlmf);
+ }
+
+ if (print_dlm_grants) {
+ memset(dlm_fn, 0, sizeof(dlm_fn));
+ sprintf(dlm_fn, "%s/dlm/%s_locks", debugfs,
+ fsname);
+ dlmfd = open(dlm_fn, O_RDONLY);
+ if (dlmfd > 0) {
+ dlmgrants = parse_dlm_grants(dlmfd,
+ fsname);
+ close(dlmfd);
+ }
+ }
+
+ sprintf(fn, "%s/gfs2/%s/glocks", debugfs,
+ dent->d_name);
+ fd = open(fn, O_RDONLY);
+ if (fd < 0) {
+ if (interactive) {
+ refresh();
+ endwin();
+ }
+ perror(fn);
+ exit(-1);
+ }
+ parse_glocks_file(fd, fsname, dlmwaiters, dlmgrants,
+ trace_dir_path, show_held, help,
+ summary);
+ close(fd);
+ }
+ closedir(dir);
+ tv.tv_sec = refresh_time;
+ tv.tv_usec = 0;
+ FD_ZERO(&readfds);
+ FD_SET(0, &readfds);
+ retval = select(1, &readfds, NULL, NULL, &tv);
+ if (retval) {
+ if (interactive)
+ ch = getch();
+ else
+ ch = getchar();
+ switch (ch) {
+ case 0x1b: /* mount wheel? */
+ case 0x03:
+ case 'q':
+ done = 1;
+ break;
+ case 'h':
+ help = (help + 1) % 3;
+ break;
+ case 's':
+ if (!interactive)
+ break;
+ move(1, 0);
+ printw("Change delay from %d to: ",
+ refresh_time);
+ if (bobgets(string, 1, 25, 5, &ch) == 1)
+ refresh_time = atoi(string);
+ if (refresh_time < 1)
+ refresh_time = 1;
+ break;
+ }
+ }
+ iters_done++;
+ if (iterations && iters_done >= iterations)
+ break;
+ }
+ for (i = 0; i < mounted; i++)
+ close(fs_fd[i]);
+ free(gbuf);
+ free(dbuf);
+ if (interactive) {
+ refresh();
+ endwin();
+ }
+ exit(0);
+}
diff --git a/gfs2/man/Makefile b/gfs2/man/Makefile
index d4d809f..8e5239d 100644
--- a/gfs2/man/Makefile
+++ b/gfs2/man/Makefile
@@ -9,7 +9,8 @@ MANTARGET= \
gfs2_quota.8 \
gfs2_tool.8 \
mkfs.gfs2.8 \
- tunegfs2.8
+ tunegfs2.8 \
+ glocktop.8
include ../../make/defines.mk
include $(OBJDIR)/make/install.mk
diff --git a/gfs2/man/glocktop.8 b/gfs2/man/glocktop.8
new file mode 100644
index 0000000..19379c3
--- /dev/null
+++ b/gfs2/man/glocktop.8
@@ -0,0 +1,281 @@
+.TH glocktop 8
+
+.SH NAME
+glocktop - Display or print active GFS2 locks.
+
+.SH SYNOPSIS
+.B glocktop
+[\fIOPTIONS\fR]
+
+.SH DESCRIPTION
+The glocktop tool is used to display active GFS2 inter-node locks,
+also known as glocks. Simply put, it's a tool to filter and interpret the
+contents of the glocks debugfs file. The glocks debugfs file shows
+all glocks known to GFS2, their holders, and technical data such as flags.
+The glocktop tool will only show the glocks that are important: glocks that
+are being held or for which there are waiters. It also interprets the debugfs
+file of DLM (Distributed Lock Manager).
+
+.SH OPTIONS
+.TP
+\fB-d\fP \fI<delay>\fP
+Specify a time delay (in seconds) between reports. (Default is 30 seconds)
+.TP
+\fB-h\fP
+Print help information.
+.TP
+\fB-i\fP
+Interactive mode. In this mode, glocktop acts more like the top command.
+It shows the pertinent glocks on the terminal session (as many as it can
+fit). The advantage is that it uses different colors to draw attention to
+what's important. The disadvantage is that it's limited by the size of
+your display, so you may not see all the glocks.
+.TP
+\fB-D\fP
+Omit DLM status. This may be used to reduce the amount of output for
+interactive mode.
+.TP
+\fB-n\fP \fI<iterations>\fP
+End the program after the specified number of iterations (reports). The
+default is to keep running until interrupted.
+.TP
+\fB-r\fP
+Show resource group reservation information. Normally, glocktop omits
+resource group reservation information to condense the output. This
+information is only important when debugging information related to the
+GFS2 block allocator and file system fragmentation.
+.TP
+\fB-s\fP \fI<freq>\fR
+Print glock summary information every \fI<freq>\fR reports.
+The glock summary information is bulky and often not needed, so it's
+only printed once every 10 reports. You can eliminate it entirely from
+the output by specifying a value of 0. If you want the statistics to
+print after every report, specify freq as 1.
+.TP
+\fB-t\fP
+Trace directory path. A lot of GFS2 glock performance problems are caused
+by an application's contention for one or two directories. These show up
+as regular inodes in the output, but there's no good way to tell from the
+output which directory is contended. Ordinarily, glocktop won't try to
+look up the full pathname of a contended directory because it's slow,
+especially if there are millions of glocks. This option instructs glocktop
+to try to determine the full directory path names when it can, so you can
+tell the full path (within the mount point) of contended directories.
+.TP
+\fB-H\fP
+Don't show Held glocks, unless there are also waiters for the lock.
+Ordinarily, glocktop will show glocks that are held (but not iopen
+glocks which are almost always held by the thousands) as well as glocks
+for which there are waiters. If it only showed glocks with waiters, you
+could see, for example, that a glock is being blocked on one node,
+but you couldn't see the information for a different node currently
+holding the lock and thus, blocking the waiter. This option forces glocktop to
+stop printing information for glocks with no waiters (on that node).
+The advantage is that the output is smaller and easier to look at.
+The disadvantage is that you can't see information from the node that's
+blocking the waiter, unless both waiter and holder are on the same node.
+.SH OUTPUT LINES
+.TP
+\fB@ name\fP
+This is the GFS2 file system name for which the information is printed. It
+also gives the time stamp of the report, and the cluster node name.
+.TP
+\fBG:\fP
+This line represents a glock (internode GFS2 lock).
+ G: s:UN n:2/609b4 f:lIqob t:EX d:EX/0 a:0 v:0 r:3 m:200 (inode)
+.TP
+\fBD:\fP
+This line gives you glocktop's interpretation of the glock's state as
+far as DLM (distributed lock manager) is concerned.
+ D: Granted PR on node 2 to pid 17511 [python]
+.TP
+\fBH:\fP
+This line represents a glock holder: a process that's either holding the
+glock, or is waiting to hold it. The value after S: represents how this
+holder needs the lock: EX (Exclusive), SH (Shared), PR (Protected Read),
+or UN (Unlocked). The value after F: indicates the holder flags: a W
+indicates the holder is Waiting for the lock to be granted. An H indicates
+the holder is currently holding the lock.
+ H: s:EX f:W e:0 p:17511 [python] gfs2_unlink+0x7e/0x250 [gfs2]
+.TP
+\fBU:\fP
+These lines represent glocktop's user interpretation of the data, both glock
+and holder. Lines that begin with (N/A:...) can probably be ignored because
+they ought to be unimportant: system files such as journals, etc.
+ U: W inode 183f5 Is:Shared, Want:Exclusive [Demote pending, Reply pending, Queued, Blocking]
+ U: W ---> waiting pid 17511 [python] (Granted PR on node 2 to pid 17511 [python])
+.TP
+\fBC:\fP
+These lines give you the call trace (call stack) of the process that's
+either holding or waiting to hold the glock.
+.TP
+\fBS\fP
+These lines give you the summary of all glocks for this file system: How many of
+each category are unlocked, locked, how many are held in EX, SH, and DF, and how
+many are waiting. G Waiting is how many glocks have waiters. P Waiting is
+how many processes are waiting. Thus, you could have one glock that's got
+ten processes waiting, or ten glocks that have ten processes waiting.
+.SH EXAMPLE OUTPUT
+.nf
+.RS
+# glocktop
+.PP
+@ nate_bob1 Wed Jan 27 07:24:14 2016 @host-050
+ G: s:EX n:9/1 f:Iqb t:EX d:EX/0 a:0 v:0 r:2 m:200 (journal)
+ D: Granted EX on node 2 to pid 17468 [ended]
+ H: s:EX f:eH e:0 p:17468 [(ended)] gfs2_glock_nq_num+0x5b/0xa0 [gfs2]
+ U: (N/A:Journl) H journal 1 Held:Exclusive [Queued, Blocking]
+ U: (N/A:Journl) H ---> held by pid 17468 [(ended)] (Granted EX on node 2 to pid 17468 [ended])
+ G: s:SH n:1/1 f:Iqb t:SH d:EX/0 a:0 v:0 r:2 m:200 (non-disk)
+ D: Granted PR on node 2 to pid 17468 [ended]
+ H: s:SH f:eEH e:0 p:17468 [(ended)] gfs2_glock_nq_num+0x5b/0xa0 [gfs2]
+ U: (N/A:Not EX) H non-disk 1 Held:Shared [Queued, Blocking]
+ U: (N/A:Not EX) H ---> held by pid 17468 [(ended)] (Granted PR on node 2 to pid 17468 [ended])
+ G: s:EX n:2/181ec f:yIqob t:EX d:EX/0 a:1 v:0 r:3 m:200 (inode)
+ D: Granted EX on this node to pid 17468 [ended]
+ H: s:EX f:H e:0 p:17468 [(ended)] init_per_node+0x17d/0x280 [gfs2]
+ I: n:12/98796 t:8 f:0x00 d:0x00000201 s:24
+ U: (N/A:System) H inode 181ec Held:Exclusive [Dirty, Queued, Blocking]
+ U: (N/A:System) H ---> held by pid 17468 [(ended)] (Granted EX on this node to pid 17468 [ended])
+ G: s:EX n:2/181ed f:Iqob t:EX d:EX/0 a:0 v:0 r:3 m:200 (inode)
+ D: Granted EX on this node to pid 17468 [ended]
+ H: s:EX f:H e:0 p:17468 [(ended)] init_per_node+0x1b0/0x280 [gfs2]
+ I: n:13/98797 t:8 f:0x00 d:0x00000200 s:1048576
+ U: (N/A:System) H inode 181ed Held:Exclusive [Queued, Blocking]
+ U: (N/A:System) H ---> held by pid 17468 [(ended)] (Granted EX on this node to pid 17468 [ended])
+ G: s:SH n:2/183f5 f:ldrIqob t:EX d:UN/0 a:0 v:0 r:5 m:10 (inode)
+ D: Granted PR on node 2 to pid 17511 [python]
+ H: s:EX f:W e:0 p:17511 [python] gfs2_unlink+0x7e/0x250 [gfs2]
+ I: n:1/99317 t:4 f:0x00 d:0x00000003 s:2048
+ U: W inode 183f5 Is:Shared, Want:Exclusive [Demote pending, Reply pending, Queued, Blocking]
+ U: W ---> waiting pid 17511 [python] (Granted PR on node 2 to pid 17511 [python])
+ C: gfs2_unlink+0xdc/0x250 [gfs2]
+ C: vfs_unlink+0xa0/0xf0
+ C: do_unlinkat+0x163/0x260
+ C: sys_unlink+0x16/0x20
+ G: s:SH n:2/805b f:Iqob t:SH d:EX/0 a:0 v:0 r:3 m:200 (inode)
+ D: Granted PR on node 2 to pid 17468 [ended]
+ H: s:SH f:eEcH e:0 p:17468 [(ended)] init_journal+0x185/0x500 [gfs2]
+ I: n:5/32859 t:8 f:0x01 d:0x00000200 s:134217728
+ U: (N/A:Not EX) H inode 805b Held:Shared [Queued, Blocking]
+ U: (N/A:Not EX) H ---> held by pid 17468 [(ended)] (Granted PR on node 2 to pid 17468 [ended])
+S glocks nondisk inode rgrp iopen flock quota jrnl Total
+S --------- ------- -------- ------- ------- ------- ----- ---- --------
+S Unlocked: 1 5 4 0 0 0 0 10
+S Locked: 2 245 6 58 0 0 1 313
+S Total: 3 250 10 58 0 0 1 323
+S
+S Held EX: 0 2 0 0 0 0 1 3
+S Held SH: 1 1 0 57 0 0 0 59
+S Held DF: 0 0 0 0 0 0 0 0
+S G Waiting: 0 1 0 0 0 0 0 1
+S P Waiting: 0 1 0 0 0 0 0 1
+S DLM wait: 0
+
+@ nate_bob0 Wed Jan 27 07:24:14 2016 @host-050
+ G: s:EX n:2/180e9 f:yIqob t:EX d:EX/0 a:1 v:0 r:3 m:200 (inode)
+ D: Granted EX on this node to pid 17465 [ended]
+ H: s:EX f:H e:0 p:17465 [(ended)] init_per_node+0x17d/0x280 [gfs2]
+ I: n:9/98537 t:8 f:0x00 d:0x00000201 s:24
+ U: (N/A:System) H inode 180e9 Held:Exclusive [Dirty, Queued, Blocking]
+ U: (N/A:System) H ---> held by pid 17465 [(ended)] (Granted EX on this node to pid 17465 [ended])
+ G: s:UN n:2/609b4 f:lIqob t:EX d:EX/0 a:0 v:0 r:3 m:200 (inode)
+ D: Granted EX on node 2 to pid 14367 [ended]
+ H: s:EX f:W e:0 p:16297 [delete_workqueu] gfs2_delete_inode+0x9d/0x450 [gfs2]
+ U: W inode 609b4 Is:Unlocked, Want:Exclusive [Queued, Blocking]
+ U: W ---> waiting pid 16297 [delete_workqueu] (Granted EX on node 2 to pid 14367 [ended])
+ C: gfs2_delete_inode+0xa5/0x450 [gfs2]
+ C: generic_delete_inode+0xde/0x1d0
+ C: generic_drop_inode+0x65/0x80
+ C: gfs2_drop_inode+0x37/0x40 [gfs2]
+ G: s:SH n:2/19 f:Iqob t:SH d:EX/0 a:0 v:0 r:3 m:200 (inode)
+ D: Granted PR on this node to pid 17465 [ended]
+ H: s:SH f:eEcH e:0 p:17465 [(ended)] init_journal+0x185/0x500 [gfs2]
+ I: n:4/25 t:8 f:0x01 d:0x00000200 s:134217728
+ U: (N/A:Not EX) H inode 19 Held:Shared [Queued, Blocking]
+ U: (N/A:Not EX) H ---> held by pid 17465 [(ended)] (Granted PR on this node to pid 17465 [ended])
+ G: s:EX n:2/180ea f:Iqob t:EX d:EX/0 a:0 v:0 r:3 m:200 (inode)
+ D: Granted EX on this node to pid 17465 [ended]
+ H: s:EX f:H e:0 p:17465 [(ended)] init_per_node+0x1b0/0x280 [gfs2]
+ I: n:10/98538 t:8 f:0x00 d:0x00000200 s:1048576
+ U: (N/A:System) H inode 180ea Held:Exclusive [Queued, Blocking]
+ U: (N/A:System) H ---> held by pid 17465 [(ended)] (Granted EX on this node to pid 17465 [ended])
+ G: s:EX n:9/0 f:Iqb t:EX d:EX/0 a:0 v:0 r:2 m:200 (journal)
+ D: Granted EX on this node to pid 17465 [ended]
+ H: s:EX f:eH e:0 p:17465 [(ended)] gfs2_glock_nq_num+0x5b/0xa0 [gfs2]
+ U: (N/A:Journl) H journal 0 Held:Exclusive [Queued, Blocking]
+ U: (N/A:Journl) H ---> held by pid 17465 [(ended)] (Granted EX on this node to pid 17465 [ended])
+ G: s:UN n:2/4fe12 f:ldIqob t:EX d:UN/0 a:0 v:0 r:4 m:10 (inode)
+ H: s:EX f:W e:0 p:17523 [python] gfs2_rename+0x344/0x8b0 [gfs2]
+ H: s:SH f:AW e:0 p:17527 [python] gfs2_permission+0x176/0x210 [gfs2]
+ U: W inode 4fe12 Is:Unlocked, Want:Exclusive [Demote pending, Queued, Blocking]
+ U: W ---> waiting pid 17523 [python]
+ C: gfs2_permission+0x17f/0x210 [gfs2]
+ C: __link_path_walk+0xb3/0x1000
+ C: path_walk+0x6a/0xe0
+ C: filename_lookup+0x6b/0xc0
+ U: W ---> waiting pid 17527 [python]
+ C: do_unlinkat+0x107/0x260
+ C: sys_unlink+0x16/0x20
+ C: system_call_fastpath+0x16/0x1b
+ C: 0xffffffffffffffff
+ G: s:SH n:1/1 f:Iqb t:SH d:EX/0 a:0 v:0 r:2 m:200 (non-disk)
+ D: Granted PR on node 2 to pid 14285 [ended]
+ D: Granted PR on this node to pid 17465 [ended]
+ H: s:SH f:eEH e:0 p:17465 [(ended)] gfs2_glock_nq_num+0x5b/0xa0 [gfs2]
+ U: (N/A:Not EX) H non-disk 1 Held:Shared [Queued, Blocking]
+ U: (N/A:Not EX) H ---> held by pid 17465 [(ended)] (Granted PR on node 2 to pid 14285 [ended]) (Granted PR on this node to pid 17465 [ended])
+S glocks nondisk inode rgrp iopen flock quota jrnl Total
+S --------- ------- -------- ------- ------- ------- ----- ---- --------
+S Unlocked: 1 8 7 0 0 0 0 16
+S Locked: 2 208 3 41 0 0 1 256
+S Total: 3 216 10 41 0 0 1 272
+S
+S Held EX: 0 2 0 0 0 0 1 3
+S Held SH: 1 1 0 41 0 0 0 43
+S Held DF: 0 0 0 0 0 0 0 0
+S G Waiting: 0 2 0 0 0 0 0 2
+S P Waiting: 0 3 0 0 0 0 0 3
+S DLM wait: 0
+.RE
+.fi
+.PP
+From this example output, we can see there are two GFS2 file systems
+mounted on system host-050: nate_bob1 and nate_bob0. In nate_bob1, we can
+see six glocks, but we can ignore all of them marked (N/A:...) because they
+are system files or held in SHared mode, and therefore other nodes should
+be able to hold the lock in SHared as well.
+.PP
+There is one glock, for inode 183f5, which is has a process waiting to
+hold it. The lock is currently in SHared mode (s:SH on the G: line) but
+process 17511 (python) wants to hold the lock in EXclusive mode (S:EX
+on the H: line). That process has a call stack that indicates it is trying
+to hold the glock from gfs2_unlink. The DLM says the lock is currently
+granted on node 2 in PR (Protected Read) mode.
+.PP
+For file system nate_bob0, there are 7 glocks listed. All but two are
+uninteresting. Locks 2/609b4 and 2/4fe12 have processes waiting to
+hold them.
+.PP
+In the summary data for nate_bob0, you can see there are 3 processes waiting
+for 2 inode glocks (so one of those glocks has multiple processes waiting).
+.PP
+Since DLM wait is 0 in the summary data for both GFS2 mount points,
+nobody is waiting for DLM to grant the lock.
+
+.SH KNOWN BUGS AND LIMITATIONS
+.PP
+Since the GFS2 debugfs files are completely separate from the DLM debugfs
+files, and locks can change status in a few nanoseconds time, there will
+always be a lag between the GFS2 view of a lock and the DLM view of a lock.
+If there is some kind of long-term hang, they are more likely to match.
+However, under ordinary conditions, by the time glocktop gets around to
+fetching the DLM status of a lock, the information has changed. Therefore,
+don't be surprised if the DLM's view of a lock is at odds with its glock.
+.PP
+Since iopen glocks are held by the thousands, glocktop skips most of the
+information related to them unless there's a waiter. For that reason,
+iopen lock problems may be difficult to debug with glocktop.
+.PP
+It doesn't handle very large numbers (millions) of glocks.
+
8 years, 2 months
- 1
- 0