#include "clusterautoconfig.h"

/**

 * 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;

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->b_data);

	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 = lgfs2_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) {

				inode_put(&parent);

				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 *sp;

		char *p;

		dlmf = fopen(DLM_DIRTBL, "rt");

		if (dlmf) {

			sp = fgets(dlm_dirtbl_size, sizeof(dlm_dirtbl_size), dlmf);

			if (sp == NULL)

				goto out_err;

			p = strchr(dlm_dirtbl_size, '\n');

			if (p)

				*p = '\0';

			fclose(dlmf);

		} else {

			strcpy(dlm_dirtbl_size, " ");

		}

		dlmf = fopen(DLM_RSBTBL, "rt");

		if (dlmf) {

			sp = fgets(dlm_rsbtbl_size, sizeof(dlm_rsbtbl_size), dlmf);

			if (sp == NULL)

				goto out_err;

			p = strchr(dlm_rsbtbl_size, '\n');

			if (p)

				*p = '\0';

			fclose(dlmf);

		} else {

			strcpy(dlm_rsbtbl_size, " ");

		}

		dlmf = fopen(DLM_LKBTBL, "rt");

		if (dlmf) {

			sp = fgets(dlm_lkbtbl_size, sizeof(dlm_lkbtbl_size), dlmf);

			if (sp == NULL)

				goto out_err;

			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;

out_err:

	fclose(dlmf);

	return "error";

}

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";