/*
	 * Copyright 2004-2012 Red Hat, Inc.
	 *
	 * This copyrighted material is made available to anyone wishing to use,
	 * modify, copy, or redistribute it subject to the terms and conditions
	 * of the GNU General Public License v2 or (at your option) any later version.
	 */
	
	#include <unistd.h>
	#include <stdio.h>
	#include <stdint.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <fcntl.h>
	#include <string.h>
	#include <errno.h>
	#include <limits.h>
	#include <sys/types.h>
	#include <sys/un.h>
	#include <inttypes.h>
	#include <netinet/in.h>
	
	#include <linux/dlmconstants.h>
	#include "libdlm.h"
	#include "libdlmcontrol.h"
	#include "dlm_controld.h"
	#include "dlm_sand_sock.h"
	#include "copyright.cf"
	#include "version.cf"
	
	#define LKM_IVMODE -1
	
	#define OP_JOIN				1
	#define OP_LEAVE			2
	#define OP_JOINLEAVE			3
	#define OP_LIST				4
	#define OP_DEADLOCK_CHECK		5
	#define OP_DUMP_DEBUG			6
	#define OP_PLOCKS			7
	#define OP_LOCKDUMP			8
	#define OP_LOCKDEBUG			9
	#define OP_LOG_PLOCK			10
	#define OP_FENCE_ACK			11
	#define OP_DUMP_STATUS			12
	#define OP_DUMP_CONFIG			13
	#define OP_RUN				14
	#define OP_RUN_START			15
	#define OP_RUN_CHECK			16
	#define OP_RUN_CANCEL			17
	#define OP_RUN_LIST			18
	#define OP_DUMP_RUN			19
	#define OP_RELOAD_CONFIG		20
	#define OP_SET_CONFIG			21
	
	static char *prog_name;
	static char *lsname;
	static int operation;
	static int opt_ind;
	static int ls_all_nodes = 0;
	static int opt_excl = 0;
	static int opt_fs = 0;
	static int dump_mstcpy = 0;
	static mode_t create_mode = 0600;
	static int verbose;
	static int wide;
	static int wait_sec;
	static int summarize;
	static int use_dlmc;
	static int use_dlms;
	static int dlms_fd;
	
	char run_command[DLMC_RUN_COMMAND_LEN];
	char run_uuid[DLMC_RUN_UUID_LEN];
	
	#define MAX_NODES 128
	
	/* from linux/fs/dlm/dlm_internal.h */
	#define DLM_LKSTS_WAITING       1
	#define DLM_LKSTS_GRANTED       2
	#define DLM_LKSTS_CONVERT       3
	
	#define DLM_MSG_REQUEST         1
	#define DLM_MSG_CONVERT         2
	#define DLM_MSG_UNLOCK          3
	#define DLM_MSG_CANCEL          4
	#define DLM_MSG_REQUEST_REPLY   5
	#define DLM_MSG_CONVERT_REPLY   6
	#define DLM_MSG_UNLOCK_REPLY    7
	#define DLM_MSG_CANCEL_REPLY    8
	#define DLM_MSG_GRANT           9
	#define DLM_MSG_BAST            10
	#define DLM_MSG_LOOKUP          11
	#define DLM_MSG_REMOVE          12
	#define DLM_MSG_LOOKUP_REPLY    13
	#define DLM_MSG_PURGE           14
	
	
	struct dlmc_node nodes[MAX_NODES];
	
	struct rinfo {
		int print_granted;
		int print_convert;
		int print_waiting;
		int print_lookup;
		int namelen;
		int nodeid;
		int lvb;
		unsigned int lkb_count;
		unsigned int lkb_granted;
		unsigned int lkb_convert;
		unsigned int lkb_waiting;
		unsigned int lkb_lookup;
		unsigned int lkb_wait_msg;
		unsigned int lkb_master_copy;
		unsigned int lkb_local_copy;
		unsigned int lkb_process_copy;
	};
	
	struct summary {
		unsigned int rsb_total;
		unsigned int rsb_with_lvb;
		unsigned int rsb_no_locks;
		unsigned int rsb_lookup;
		unsigned int rsb_master;
		unsigned int rsb_local;
		unsigned int rsb_nodeid_error;
		unsigned int lkb_count;
		unsigned int lkb_granted;
		unsigned int lkb_convert;
		unsigned int lkb_waiting;
		unsigned int lkb_lookup;
		unsigned int lkb_wait_msg;
		unsigned int lkb_master_copy;
		unsigned int lkb_local_copy;
		unsigned int lkb_process_copy;
		unsigned int expect_replies;
		unsigned int toss_total;
	};
	
	static const char *mode_str(int mode)
	{
		switch (mode) {
		case -1:
			return "IV";
		case LKM_NLMODE:
			return "NL";
		case LKM_CRMODE:
			return "CR";
		case LKM_CWMODE:
			return "CW";
		case LKM_PRMODE:
			return "PR";
		case LKM_PWMODE:
			return "PW";
		case LKM_EXMODE:
			return "EX";
		}
		return "??";
	}
	
	static const char *msg_str(int type)
	{
		switch (type) {
		case DLM_MSG_REQUEST:
			return "request";
		case DLM_MSG_CONVERT:
			return "convert";
		case DLM_MSG_UNLOCK:
			return "unlock ";
		case DLM_MSG_CANCEL:
			return "cancel ";
		case DLM_MSG_REQUEST_REPLY:
			return "r_reply";
		case DLM_MSG_CONVERT_REPLY:
			return "c_reply";
		case DLM_MSG_UNLOCK_REPLY:
			return "u_reply";
		case DLM_MSG_CANCEL_REPLY:
			return "c_reply";
		case DLM_MSG_GRANT:
			return "grant  ";
		case DLM_MSG_BAST:
			return "bast   ";
		case DLM_MSG_LOOKUP:
			return "lookup ";
		case DLM_MSG_REMOVE:
			return "remove ";
		case DLM_MSG_LOOKUP_REPLY:
			return "l_reply";
		case DLM_MSG_PURGE:
			return "purge  ";
		default:
			return "unknown";
		}
	}
	
	static void print_usage(void)
	{
		printf("Usage:\n");
		printf("\n");
		printf("dlm_tool [command] [options] [name]\n");
		printf("\n");
		printf("Commands:\n");
		printf("ls, status, dump, fence_ack\n");
		printf("dump_config, reload_config, set_config\n");
		printf("log_plock, plocks\n");
		printf("join, leave, lockdebug\n");
		printf("run, run_start, run_check, run_cancel, run_list\n");
		printf("\n");
		printf("Options:\n");
		printf("  -n               Show all node information in ls\n");
		printf("  -e 0|1           Exclusive create off/on in join, default 0\n");
		printf("  -f 0|1           FS (filesystem) flag off/on in join, default 0\n");
		printf("  -m <mode>        Permission mode for lockspace device (octal), default 0600\n");
		printf("  -s               Summary following lockdebug output (experimental)\n");
		printf("  -v               Verbose lockdebug output\n");
		printf("  -w               Wide lockdebug output\n");
		printf("  -i <sec>         Wait for <sec>.\n");
		printf("  -h               Print help, then exit\n");
		printf("  -V               Print program version information, then exit\n");
		printf("\n");
	}
	
	#define OPTION_STRING "MhVnm:e:f:vwsi:"
	
	static void decode_arguments(int argc, char **argv)
	{
		int cont = 1;
		int optchar;
		int need_lsname;
		int need_command = 0;
		int need_uuid = 0;
		int optional_lsname = 0;
		int i;
		char modebuf[8];
	
		while (cont) {
			optchar = getopt(argc, argv, OPTION_STRING);
	
			switch (optchar) {
			case 'e':
				opt_excl = atoi(optarg);
				break;
	
			case 'f':
				opt_fs = atoi(optarg);
				break;
	
			case 'm':
				memset(modebuf, 0, sizeof(modebuf));
				snprintf(modebuf, 8, "%s", optarg);
				sscanf(modebuf, "%o", &create_mode);
				break;
	
			case 'M':
				dump_mstcpy = 1;
				break;
	
			case 'n':
				ls_all_nodes = 1;
				break;
	
			case 's':
				summarize = 1;
				break;
	
			case 'v':
				verbose = 1;
				break;
	
			case 'w':
				wide = 1;
				break;
	
			case 'i':
				wait_sec = atoi(optarg);
				break;
	
			case 'h':
				print_usage();
				exit(EXIT_SUCCESS);
				break;
	
			case 'V':
				printf("%s %s (built %s %s)\n",
					prog_name, RELEASE_VERSION, __DATE__, __TIME__);
				printf("%s\n", REDHAT_COPYRIGHT);
				exit(EXIT_SUCCESS);
				break;
	
			case ':':
			case '?':
				fprintf(stderr, "Please use '-h' for usage.\n");
				exit(EXIT_FAILURE);
				break;
	
			case EOF:
				cont = 0;
				break;
	
			default:
				fprintf(stderr, "unknown option: %c\n", optchar);
				exit(EXIT_FAILURE);
				break;
			};
		}
	
		need_lsname = 1;
	
		while (optind < argc) {
			if (!strncmp(argv[optind], "join", 4) &&
			    (strlen(argv[optind]) == 4)) {
				operation = OP_JOIN;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "leave", 5) &&
				   (strlen(argv[optind]) == 5)) {
				operation = OP_LEAVE;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "joinleave", 9) &&
				   (strlen(argv[optind]) == 9)) {
				operation = OP_JOINLEAVE;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "ls", 2) &&
				   (strlen(argv[optind]) == 2)) {
				operation = OP_LIST;
				opt_ind = optind + 1;
				need_lsname = 0;
				optional_lsname = 1;
				break;
			} else if (!strncmp(argv[optind], "status", 6) &&
				   (strlen(argv[optind]) == 6)) {
				operation = OP_DUMP_STATUS;
				opt_ind = optind + 1;
				need_lsname = 0;
				break;
			} else if (!strncmp(argv[optind], "deadlock_check", 14) &&
				   (strlen(argv[optind]) == 14)) {
				operation = OP_DEADLOCK_CHECK;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "fence_ack", 9) &&
				   (strlen(argv[optind]) == 9)) {
				operation = OP_FENCE_ACK;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "dump", 4) &&
				   (strlen(argv[optind]) == 4)) {
				operation = OP_DUMP_DEBUG;
				opt_ind = optind + 1;
				need_lsname = 0;
				break;
			} else if (!strncmp(argv[optind], "dump_config", 11) &&
				   (strlen(argv[optind]) == 11)) {
				operation = OP_DUMP_CONFIG;
				opt_ind = optind + 1;
				need_lsname = 0;
				break;
			} else if (!strncmp(argv[optind], "reload_config", 13) &&
				   (strlen(argv[optind]) == 13)) {
				operation = OP_RELOAD_CONFIG;
				opt_ind = optind + 1;
				need_lsname = 0;
				break;
			} else if (!strncmp(argv[optind], "set_config", 10) &&
				   (strlen(argv[optind]) == 10)) {
				operation = OP_SET_CONFIG;
				opt_ind = optind + 1;
				need_lsname = 0;
				need_command = 1;
				break;
			} else if (!strncmp(argv[optind], "plocks", 6) &&
				   (strlen(argv[optind]) == 6)) {
				operation = OP_PLOCKS;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "log_plock", 9) &&
				   (strlen(argv[optind]) == 9)) {
				operation = OP_LOG_PLOCK;
				opt_ind = optind + 1;
				need_lsname = 0;
				break;
			} else if (!strcmp(argv[optind], "run")) {
				operation = OP_RUN;
				opt_ind = optind + 1;
				need_lsname = 0;
				need_command = 1;
				break;
			} else if (!strcmp(argv[optind], "run_start")) {
				operation = OP_RUN_START;
				opt_ind = optind + 1;
				need_lsname = 0;
				need_command = 1;
				break;
			} else if (!strcmp(argv[optind], "run_check")) {
				operation = OP_RUN_CHECK;
				opt_ind = optind + 1;
				need_lsname = 0;
				need_uuid = 1;
				break;
			} else if (!strcmp(argv[optind], "run_cancel")) {
				operation = OP_RUN_CANCEL;
				opt_ind = optind + 1;
				need_lsname = 0;
				need_uuid = 1;
				break;
			} else if (!strcmp(argv[optind], "run_list")) {
				operation = OP_DUMP_RUN;
				opt_ind = optind + 1;
				need_lsname = 0;
				need_uuid = 0;
				break;
			}
	
	
			/*
			 * debugfs
			 */
	
			else if (!strncmp(argv[optind], "lockdump", 8) &&
				   (strlen(argv[optind]) == 8)) {
				operation = OP_LOCKDUMP;
				opt_ind = optind + 1;
				break;
			} else if (!strncmp(argv[optind], "lockdebug", 9) &&
				   (strlen(argv[optind]) == 9)) {
				operation = OP_LOCKDEBUG;
				opt_ind = optind + 1;
				break;
			}
			optind++;
		}
	
		if (!operation || !opt_ind) {
			print_usage();
			exit(EXIT_FAILURE);
		}
	
		/*
		 * The operation does not require an arg, but may
		 * accept an optional arg, i.e. dlm_tool ls [name]
		 */
		if (!need_lsname && !need_uuid && !need_command) {
			if (optind < argc - 1) {
				if (optional_lsname)
					lsname = argv[opt_ind];
			}
			return;
		}
	
		if (optind < argc - 1) {
			if (need_lsname)
				lsname = argv[opt_ind];
			else if (need_uuid) {
				strncpy(run_uuid, argv[opt_ind], DLMC_RUN_UUID_LEN - 1);
				run_uuid[DLMC_RUN_UUID_LEN - 1] = '\0';
			} else if (need_command)
				goto copy_command;
		} else if (need_lsname) {
			if (operation == OP_FENCE_ACK)
				fprintf(stderr, "nodeid required\n");
			else
				fprintf(stderr, "lockspace name required\n");
			exit(EXIT_FAILURE);
		} else if (need_command) {
			fprintf(stderr, "command required\n");
			exit(EXIT_FAILURE);
		} else if (need_uuid) {
			fprintf(stderr, "uuid required\n");
			exit(EXIT_FAILURE);
		} else {
			fprintf(stderr, "missing arg\n");
			exit(EXIT_FAILURE);
		}
	
	 copy_command:
		for (i = opt_ind; i < argc; i++) {
			if (strlen(run_command) + strlen(argv[i]) + 2 > DLMC_RUN_COMMAND_LEN) {
				fprintf(stderr, "command too long (max %d)\n", DLMC_RUN_COMMAND_LEN);
				exit(EXIT_FAILURE);
			}
	
			if (strlen(argv[i])) {
				strcat(run_command, argv[i]);
				strcat(run_command, " ");
			}
		}
	}
	
	static int do_read(int fd, void *buf, size_t count)
	{
		int rv, off = 0;
	
		while (off < count) {
			rv = read(fd, (char *)buf + off, count - off);
			if (rv == 0)
				return -1;
			if (rv == -1 && errno == EINTR)
				continue;
			if (rv == -1)
				return -1;
			off += rv;
		}
		return 0;
	}
	
	static int do_write(int fd, void *buf, size_t count)
	{
		int rv, off = 0;
	
	 retry:
		rv = write(fd, (char *)buf + off, count);
		if (rv == -1 && errno == EINTR)
			goto retry;
		if (rv < 0)
			return rv;
	
		if (rv != count) {
			count -= rv;
			off += rv;
			goto retry;
		}
		return 0;
	}
	
	static char *flag_str(uint32_t flags)
	{
		static char join_flags[128];
	
		memset(join_flags, 0, sizeof(join_flags));
	
		strcat(join_flags, "flags ");
	
		if (flags & DLM_LSFL_NEWEXCL)
			strcat(join_flags, "NEWEXCL ");
	
		if (flags & DLM_LSFL_FS)
			strcat(join_flags, "FS ");
	
		return join_flags;
	}
	
	static void do_join(char *name)
	{
		dlm_lshandle_t *dh;
		uint32_t flags = 0;
	
		if (opt_excl)
			flags |= DLM_LSFL_NEWEXCL;
	
		if (opt_fs)
			flags |= DLM_LSFL_FS;
	
		printf("Joining lockspace \"%s\" permission %o %s\n",
		       name, create_mode, flags ? flag_str(flags) : "");
		fflush(stdout);
	
		dh = dlm_new_lockspace(name, create_mode, flags);
		if (!dh) {
			fprintf(stderr, "dlm_new_lockspace %s error %d\n",
				name, errno);
			exit(-1);
		}
	
		dlm_close_lockspace(dh);
		/* there's no autofree so the ls should stay around */
		printf("done\n");
	}
	
	static void do_leave(char *name)
	{
		dlm_lshandle_t *dh;
	
		printf("Leaving lockspace \"%s\"\n", name);
		fflush(stdout);
	
		dh = dlm_open_lockspace(name);
		if (!dh) {
			fprintf(stderr, "dlm_open_lockspace %s error %p %d\n",
				name, dh, errno);
			exit(-1);
		}
	
		dlm_release_lockspace(name, dh, 1);
		printf("done\n");
	}
	
	static char *pr_master(int nodeid)
	{
		static char buf[64];
	
		memset(buf, 0, sizeof(buf));
	
		if (nodeid > 0)
			sprintf(buf, "Master:%d", nodeid);
		else if (!nodeid)
			sprintf(buf, "Master");
		else if (nodeid == -1)
			sprintf(buf, "Lookup");
	
		return buf;
	}
	
	static char *pr_extra(uint32_t flags, int root_list, int recover_list,
		       int recover_locks_count, char *first_lkid)
	{
		static char buf[128];
		int first = 0;
	
		memset(buf, 0, sizeof(buf));
	
		if (strcmp(first_lkid, "0"))
			first = 1;
	
		if (flags || first || root_list || recover_list || recover_locks_count)
			sprintf(buf,
			   "flags %08x first_lkid %s root %d recover %d locks %d",
			   flags, first_lkid, root_list, recover_list, recover_locks_count);
	
		return buf;
	}
	
	static void print_rsb(char *line, struct rinfo *ri)
	{
		char type[4], namefmt[4], *p;
		char addr[64];
		char first_lkid[64];
		int rv, nodeid, root_list, recover_list, recover_locks_count, namelen;
		uint32_t flags;
	
		rv = sscanf(line, "%s %s %d %s %u %d %d %u %u %s",
			    type,
			    addr,
			    &nodeid,
			    first_lkid,
			    &flags,
			    &root_list,
			    &recover_list,
			    &recover_locks_count,
			    &namelen,
			    namefmt);
	
		if (rv != 10)
			goto fail;
	
		/* used for lkb prints */
		ri->nodeid = nodeid;
	
		ri->namelen = namelen;
		
		p = strchr(line, '\n');
		if (!p)
			goto fail;
		*p = '\0';
	
		p = strstr(line, namefmt);
		if (!p)
			goto fail;
		p += 4;
	
		strcat(addr, " ");
	
		if (!strncmp(namefmt, "str", 3))
			printf("Resource len %2d  \"%s\"\n", namelen, p);
		else if (!strncmp(namefmt, "hex", 3))
			printf("Resource len %2d hex %s\n", namelen, p);
		else
			goto fail;
	
		printf("%-16s %s\n",
			pr_master(nodeid),
			pr_extra(flags, root_list, recover_list, recover_locks_count, first_lkid));
		return;
	
	 fail:
		fprintf(stderr, "print_rsb error rv %d line \"%s\"\n", rv, line);
	}
	
	static void print_lvb(char *line)
	{
		char lvb[1024];
		char type[4];
		int i, c, rv, lvblen;
		uint32_t lvbseq;
	
		memset(lvb, 0, 1024);
	
		rv = sscanf(line, "%s %u %d %[0-9A-Fa-f ]", type, &lvbseq, &lvblen, lvb);
	
		if (rv != 4) {
			fprintf(stderr, "print_lvb error rv %d line \"%s\"\n", rv, line);
			return;
		}
	
		printf("LVB len %d seq %u\n", lvblen, lvbseq);
	
		for (c = 0, i = 0; ; i++) {
			printf("%c", lvb[i]);
			if (lvb[i] != ' ')
				c++;
			if (!wide && lvb[i] == ' ' && !(c % 32))
				printf("\n");
			if (c == (lvblen * 2))
				break;
		}
		printf("\n");
	}
	
	struct lkb {
		uint64_t xid, timestamp, time_bast;
		uint32_t id, remid, exflags, flags, lvbseq;
		int nodeid, ownpid, status, grmode, rqmode, highbast, rsb_lookup, wait_type;
	};
	
	static const char *pr_grmode(struct lkb *lkb)
	{
		if (lkb->status == DLM_LKSTS_GRANTED || lkb->status == DLM_LKSTS_CONVERT)
			return mode_str(lkb->grmode);
		else if (lkb->status == DLM_LKSTS_WAITING || lkb->rsb_lookup)
			return "--";
		else
			return "XX";
	}
	
	static const char *pr_rqmode(struct lkb *lkb)
	{
		static char buf[5];
	
		memset(buf, 0, sizeof(buf));
	
		if (lkb->status == DLM_LKSTS_GRANTED) {
			return "    ";
		} else if (lkb->status == DLM_LKSTS_CONVERT ||
			   lkb->status == DLM_LKSTS_WAITING ||
			   lkb->rsb_lookup) {
			sprintf(buf, "(%s)", mode_str(lkb->rqmode));
			return buf;
		} else {
			return "(XX)";
		}
	}
	
	static const char *pr_remote(struct lkb *lkb, struct rinfo *ri)
	{
		static char buf[64];
	
		memset(buf, 0, sizeof(buf));
	
		if (!lkb->nodeid) {
			return "                    ";
		} else if (lkb->nodeid != ri->nodeid) {
			sprintf(buf, "Remote: %3d %08x", lkb->nodeid, lkb->remid);
			return buf;
		} else {
			sprintf(buf, "Master: %3d %08x", lkb->nodeid, lkb->remid);
			return buf;
		}
	}
	
	static const char *pr_wait(struct lkb *lkb)
	{
		static char buf[16];
	
		memset(buf, 0, sizeof(buf));
	
		if (!lkb->wait_type) {
			return "        ";
		} else {
			sprintf(buf, " wait %02d", lkb->wait_type);
			return buf;
		}
	}
	
	static char *pr_verbose(struct lkb *lkb)
	{
		static char buf[128];
	
		memset(buf, 0, sizeof(buf));
	
		sprintf(buf, "time %016llu flags %08x %08x bast %d %llu pid %d",
			(unsigned long long)lkb->timestamp,
			lkb->exflags, lkb->flags, lkb->highbast,
			(unsigned long long)lkb->time_bast, lkb->ownpid);
	
		return buf;
	}
	
	static void print_lkb(char *line, struct rinfo *ri)
	{
		struct lkb lkb;
		char type[4];
	
		sscanf(line, "%s %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu",
			    type,
			    &lkb.id,
			    &lkb.nodeid,
			    &lkb.remid,
			    &lkb.ownpid,
			    (unsigned long long *)&lkb.xid,
			    &lkb.exflags,
			    &lkb.flags,
			    &lkb.status,
			    &lkb.grmode,
			    &lkb.rqmode,
			    &lkb.highbast,
			    &lkb.rsb_lookup,
			    &lkb.wait_type,
			    &lkb.lvbseq,
			    (unsigned long long *)&lkb.timestamp,
			    (unsigned long long *)&lkb.time_bast);
	
		ri->lkb_count++;
	
		if (lkb.status == DLM_LKSTS_GRANTED) {
		       	if (!ri->print_granted++)
				printf("Granted\n");
			ri->lkb_granted++;
		}
		if (lkb.status == DLM_LKSTS_CONVERT) {
			if (!ri->print_convert++)
				printf("Convert\n");
			ri->lkb_convert++;
		}
		if (lkb.status == DLM_LKSTS_WAITING) {
		       	if (!ri->print_waiting++)
				printf("Waiting\n");
			ri->lkb_waiting++;
		}
		if (lkb.rsb_lookup) {
		       	if (!ri->print_lookup++)
				printf("Lookup\n");
			ri->lkb_lookup++;
		}
	
		if (lkb.wait_type)
			ri->lkb_wait_msg++;
	
		if (!ri->nodeid) {
			if (lkb.nodeid)
				ri->lkb_master_copy++;
			else
				ri->lkb_local_copy++;
		} else {
			ri->lkb_process_copy++;
		}
	
		printf("%08x %s %s %s %s %s\n",
		       lkb.id, pr_grmode(&lkb), pr_rqmode(&lkb),
		       pr_remote(&lkb, ri), pr_wait(&lkb),
		       (verbose && wide) ? pr_verbose(&lkb) : "");
	
		if (verbose && !wide)
			printf("%s\n", pr_verbose(&lkb));
	}
	
	static void print_rsb_toss(char *line)
	{
		char type[4], namefmt[4], *p;
		char addr[64];
		char toss_time[16];
		int res_nodeid, master_nodeid, dir_nodeid, our_nodeid;
		int rv, namelen;
		uint32_t flags;
	
		rv = sscanf(line, "%s %s %d %d %d %d %s %u %u %s",
			    type,
			    addr,
			    &res_nodeid,
			    &master_nodeid,
			    &dir_nodeid,
			    &our_nodeid,
			    toss_time,
			    &flags,
			    &namelen,
			    namefmt);
	
		if (rv != 10)
			goto fail;
	
		p = strchr(line, '\n');
		if (!p)
			goto fail;
		*p = '\0';
	
		p = strstr(line, namefmt);
		if (!p)
			goto fail;
		p += 4;
	
		strcat(addr, " ");
	
		if (!strncmp(namefmt, "str", 3))
			printf("Resource len %2d  \"%s\"\n", namelen, p);
		else if (!strncmp(namefmt, "hex", 3))
			printf("Resource len %2d hex %s\n", namelen, p);
		else
			goto fail;
	
		if (master_nodeid != our_nodeid)
			printf("Master:%d", master_nodeid);
		else
			printf("Master");
	
		if (dir_nodeid != our_nodeid)
			printf(" Dir:%d", dir_nodeid);
		else
			printf(" Dir");
	
		if (master_nodeid == our_nodeid && res_nodeid != 0)
			printf(" res_nodeid %d", res_nodeid);
	
		printf("\n");
	
		return;
	
	 fail:
		fprintf(stderr, "print_rsb_toss error rv %d line \"%s\"\n", rv, line);
	}
	
	static void clear_rinfo(struct rinfo *ri)
	{
		memset(ri, 0, sizeof(struct rinfo));
		ri->nodeid = -9;
	}
	
	static void count_rinfo(struct summary *s, struct rinfo *ri)
	{
		/* the first time called */
		if (!ri->namelen)
			return;
	
		s->rsb_total++;
	
		if (ri->lvb)
			s->rsb_with_lvb++;
	
		if (!ri->lkb_count) {
			s->rsb_no_locks++;
			printf("no locks\n");
		}
	
		if (!ri->nodeid)
			s->rsb_master++;
		else if (ri->nodeid == -1)
			s->rsb_lookup++;
		else if (ri->nodeid > 0)
			s->rsb_local++;
		else
			s->rsb_nodeid_error++;
	
		s->lkb_count        += ri->lkb_count;
		s->lkb_granted      += ri->lkb_granted;
		s->lkb_convert      += ri->lkb_convert;
		s->lkb_waiting      += ri->lkb_waiting;
		s->lkb_lookup       += ri->lkb_lookup;
		s->lkb_wait_msg     += ri->lkb_wait_msg;
		s->lkb_master_copy  += ri->lkb_master_copy;
		s->lkb_local_copy   += ri->lkb_local_copy;
		s->lkb_process_copy += ri->lkb_process_copy;
	}
	
	static void print_summary(struct summary *s)
	{
		printf("rsb\n");
		printf("  active        %u\n", s->rsb_total);
		printf("  master        %u\n", s->rsb_master);
		printf("  remote master %u\n", s->rsb_local);
		printf("  lookup master %u\n", s->rsb_lookup);
		printf("  with lvb      %u\n", s->rsb_with_lvb);
		printf("  with no locks %u\n", s->rsb_no_locks);
		printf("  nodeid error  %u\n", s->rsb_nodeid_error);
		printf("  inactive      %u\n", s->toss_total);
		printf("\n");
	
		printf("lkb\n");
		printf("  total         %u\n", s->lkb_count);
		printf("  granted       %u\n", s->lkb_granted);
		printf("  convert       %u\n", s->lkb_convert);
		printf("  waiting       %u\n", s->lkb_waiting);
		printf("  local copy    %u\n", s->lkb_local_copy);
		printf("  master copy   %u\n", s->lkb_master_copy);
		printf("  process copy  %u\n", s->lkb_process_copy);
		printf("  rsb lookup    %u\n", s->lkb_lookup);
		printf("  wait message  %u\n", s->lkb_wait_msg);
		printf("  expect reply  %u\n", s->expect_replies);
	}
	
	#define LOCK_LINE_MAX 1024
	
	static void do_waiters(char *name, struct summary *sum)
	{
		FILE *file;
		char path[PATH_MAX];
		char line[LOCK_LINE_MAX];
		char rname[DLM_RESNAME_MAXLEN+1];
		int header = 0;
		int i, j, spaces;
		int rv, nodeid, wait_type;
		uint32_t id;
	
		snprintf(path, PATH_MAX, "/sys/kernel/debug/dlm/%s_waiters", name);
	
		file = fopen(path, "r");
		if (!file)
			return;
	
		while (fgets(line, LOCK_LINE_MAX, file)) {
			if (!header) {
				printf("\n");
				printf("Expecting reply\n");
				header = 1;
			}
	
			rv = sscanf(line, "%x %d %d",
				    &id, &wait_type, &nodeid);
	
			if (rv != 3) {
				printf("waiters: %s", line);
				continue;
			}
	
			/* parse the resource name from the remainder of the line */
			j = 0;
			spaces = 0;
			memset(rname, 0, sizeof(rname));
	
			for (i = 0; i < LOCK_LINE_MAX; i++) {
				if (line[i] == '\n')
					break;
				if (spaces == 3) {
					rname[j++] = line[i];
					if (j == (sizeof(rname) - 1))
						break;
				} else if (line[i] == ' ') {
					spaces++;
				}
			}
	
			printf("nodeid %2d msg %s lkid %08x resource \"%s\"\n",
			       nodeid, msg_str(wait_type), id, rname);
	
			sum->expect_replies++;
		}
		fclose(file);
	}
	
	static void do_toss(char *name, struct summary *sum)
	{
		FILE *file;
		char path[PATH_MAX];
		char line[LOCK_LINE_MAX];
	
		snprintf(path, PATH_MAX, "/sys/kernel/debug/dlm/%s_toss", name);
	
		file = fopen(path, "r");
		if (!file)
			return;
	
		while (fgets(line, LOCK_LINE_MAX, file)) {
			if (!strncmp(line, "version", 7))
				continue;
	
			if (!strncmp(line, "rsb", 3)) {
				print_rsb_toss(line);
				sum->toss_total++;
				printf("\n");
			}
		}
		fclose(file);
	}
	
	static void do_lockdebug(char *name)
	{
		struct summary summary;
		struct rinfo info;
		FILE *file;
		char path[PATH_MAX];
		char line[LOCK_LINE_MAX];
		int old = 0;
	
		snprintf(path, PATH_MAX, "/sys/kernel/debug/dlm/%s_all", name);
	
		file = fopen(path, "r");
		if (!file) {
			snprintf(path, PATH_MAX, "/sys/kernel/debug/dlm/%s", name);
			file = fopen(path, "r");
			if (!file) {
				fprintf(stderr, "can't open %s: %s\n", path, strerror(errno));
				return;
			}
			old = 1;
		}
	
		memset(&summary, 0, sizeof(struct summary));
		memset(&info, 0, sizeof(struct rinfo));
	
		/* skip file header */
		if (!fgets(line, LOCK_LINE_MAX, file))
			goto done;
	
		while (fgets(line, LOCK_LINE_MAX, file)) {
	
			if (old)
				goto raw;
	
			if (!strncmp(line, "version", 7))
				continue;
	
			if (!strncmp(line, "rsb", 3)) {
				count_rinfo(&summary, &info);
				clear_rinfo(&info);
				printf("\n");
				print_rsb(line, &info);
				continue;
			}
			
			if (!strncmp(line, "lvb", 3)) {
				print_lvb(line);
				info.lvb = 1;
				continue;
			}
			
			if (!strncmp(line, "lkb", 3)) {
				print_lkb(line, &info);
				continue;
			}
	 raw:
			printf("%s", line);
		}
	 done:
		count_rinfo(&summary, &info);
		clear_rinfo(&info);
		printf("\n");
		fclose(file);
	
		do_toss(name, &summary);
	
		do_waiters(name, &summary);
	
		if (summarize) {
			printf("\n");
			print_summary(&summary);
		}
	}
	
	static void parse_r_name(char *line, char *name)
	{
		char *p;
		int i = 0;
		int begin = 0;
	
		for (p = line; ; p++) {
			if (*p == '"') {
				if (begin)
					break;
				begin = 1;
				continue;
			}
			if (begin)
				name[i++] = *p;
		}
	}
	
	static void do_lockdump(char *name)
	{
		FILE *file;
		char path[PATH_MAX];
		char line[LOCK_LINE_MAX];
		char r_name[DLM_RESNAME_MAXLEN+1];
		int r_nodeid;
		int r_len;
		int rv;
		unsigned int tm;
		unsigned long long xid;
		uint32_t	id;
		int		nodeid;
		uint32_t	remid;
		int		ownpid;
		uint32_t	exflags;
		uint32_t	flags;
		int8_t		status;
		int8_t		grmode;
		int8_t		rqmode;
	
		snprintf(path, PATH_MAX, "/sys/kernel/debug/dlm/%s_locks", name);
	
		file = fopen(path, "r");
		if (!file) {
			fprintf(stderr, "can't open %s: %s\n", path, strerror(errno));
			return;
		}
	
		/* skip the header on the first line */
		if (!fgets(line, LOCK_LINE_MAX, file)) {
			goto out;
		}
	
		while (fgets(line, LOCK_LINE_MAX, file)) {
			rv = sscanf(line, "%x %d %x %u %llu %x %x %hhd %hhd %hhd %u %d %d",
			       &id,
			       &nodeid,
			       &remid,
			       &ownpid,
			       &xid,
			       &exflags,
			       &flags,
			       &status,
			       &grmode,
			       &rqmode,
			       &tm,
			       &r_nodeid,
			       &r_len);
	
			if (rv != 13) {
				fprintf(stderr, "invalid debugfs line %d: %s\n",
					rv, line);
				goto out;
			}
	
			memset(r_name, 0, sizeof(r_name));
			parse_r_name(line, r_name);
	
			/* don't print MSTCPY locks without -M */
			if (!r_nodeid && nodeid) {
				if (!dump_mstcpy)
					continue;
				printf("id %08x gr %s rq %s pid %u MSTCPY %d \"%s\"\n",
					id, mode_str(grmode), mode_str(rqmode),
					ownpid, nodeid, r_name);
				continue;
			}
	
			/* A hack because dlm-kernel doesn't set rqmode back to IV when
			   a NOQUEUE convert fails, which means in a lockdump it looks
			   like a granted lock is still converting since rqmode is not
			   IV.  (does it make sense to include status in the output,
			   e.g. G,C,W?) */
	
			if (status == DLM_LKSTS_GRANTED)
				rqmode = LKM_IVMODE;
	
			printf("id %08x gr %s rq %s pid %u master %d \"%s\"\n",
				id, mode_str(grmode), mode_str(rqmode),
				ownpid, nodeid, r_name);
		}
	
	 out:
		fclose(file);
	}
	
	static char *dlmc_lf_str(uint32_t flags)
	{
		static char str[128];
		int i = 0;
	
		memset(str, 0, sizeof(str));
	
		if (flags & DLMC_LF_SAVE_PLOCKS) {
			i++;
			strcat(str, "save_plock");
		}
		if (flags & DLMC_LF_NEED_PLOCKS) {
			strcat(str, i++ ? "," : "");
			strcat(str, "need_plock");
		}
		if (flags & DLMC_LF_FS_REGISTERED) {
			strcat(str, i++ ? "," : "");
			strcat(str, "fs_reg");
		}
		if (flags & DLMC_LF_KERNEL_STOPPED) {
			strcat(str, i++ ? "," : "");
			strcat(str, "kern_stop");
		}
		if (flags & DLMC_LF_LEAVING) {
			strcat(str, i++ ? "," : "");
			strcat(str, "leave");
		}
		if (flags & DLMC_LF_JOINING) {
			strcat(str, i++ ? "," : "");
			strcat(str, "join");
		}
	
		return str;
	}
	
	static const char *check_str(struct dlmc_node *n)
	{
		static char _check_str[32];
	
		if (n->flags & DLMC_NF_NEED_FENCING) {
			memset(_check_str, 0, sizeof(_check_str));
			snprintf(_check_str, sizeof(_check_str) - 1, "fence %llu",
				(unsigned long long)n->fail_monotime);
			return _check_str;
		}
	
		if (n->flags & DLMC_NF_CHECK_FS)
			return "fs";
	
		return "none";
	}
	
	static const char *condition_str(int cond)
	{
		switch (cond) {
		case DLMC_LS_WAIT_RINGID:
			return "ringid";
		case DLMC_LS_WAIT_QUORUM:
			return "quorum";
		case DLMC_LS_WAIT_FENCING:
			return "fencing";
		case DLMC_LS_WAIT_FSDONE:
			return "fsdone";
		default:
			return "unknown";
		}
	}
	
	static int node_compare(const void *va, const void *vb)
	{
		const struct dlmc_node *a = va;
		const struct dlmc_node *b = vb;
	
		return a->nodeid - b->nodeid;
	}
	
	static void show_nodeids(int count, struct dlmc_node *nodes_in)
	{
		struct dlmc_node *n = nodes_in;
		int i;
	
		for (i = 0; i < count; i++) {
			printf("%d ", n->nodeid);
			n++;
		}
		printf("\n");
	}
	
	static void show_ls(struct dlmc_lockspace *ls)
	{
		int rv, node_count;
	
		printf("name          %s\n", ls->name);
		printf("id            0x%08x\n", ls->global_id);
		printf("flags         0x%08x %s\n", ls->flags, dlmc_lf_str(ls->flags));
		printf("change        member %d joined %d remove %d failed %d seq %d,%d\n",
			ls->cg_prev.member_count, ls->cg_prev.joined_count,
			ls->cg_prev.remove_count, ls->cg_prev.failed_count,
			ls->cg_prev.combined_seq, ls->cg_prev.seq);
	
		node_count = 0;
		memset(&nodes, 0, sizeof(nodes));
		rv = dlmc_lockspace_nodes(ls->name, DLMC_NODES_MEMBERS,
					  MAX_NODES, &node_count, nodes);
		if (rv < 0) {
			printf("members       error\n");
			goto next;
		}
		qsort(nodes, node_count, sizeof(struct dlmc_node), node_compare);
	
		printf("members       ");
		show_nodeids(node_count, nodes);
	
	 next:
		if (!ls->cg_next.seq)
			return;
	
		printf("new change    member %d joined %d remove %d failed %d seq %d,%d\n",
			ls->cg_next.member_count, ls->cg_next.joined_count,
			ls->cg_next.remove_count, ls->cg_next.failed_count,
		        ls->cg_next.combined_seq, ls->cg_next.seq);
	
		if (ls->cg_next.wait_messages)
			printf("new status    wait messages %d\n", ls->cg_next.wait_condition);
		else
			printf("new status    wait %s\n", condition_str(ls->cg_next.wait_condition));
	
		node_count = 0;
		memset(&nodes, 0, sizeof(nodes));
		rv = dlmc_lockspace_nodes(ls->name, DLMC_NODES_NEXT,
					  MAX_NODES, &node_count, nodes);
		if (rv < 0) {
			printf("new members   error\n");
			return;
		}
		qsort(nodes, node_count, sizeof(struct dlmc_node), node_compare);
	
		printf("new members   ");
		show_nodeids(node_count, nodes);
	}
	
	static int member_int(struct dlmc_node *n)
	{
		if (n->flags & DLMC_NF_DISALLOWED)
			return -1;
		if (n->flags & DLMC_NF_MEMBER)
			return 1;
		return 0;
	}
	
	static void show_all_nodes(int count, struct dlmc_node *nodes_in)
	{
		struct dlmc_node *n = nodes_in;
		int i;
	
		for (i = 0; i < count; i++) {
			printf("nodeid %d member %d failed %d start %d seq_add %u seq_rem %u check %s\n",
				n->nodeid,
				member_int(n),
				n->fail_reason,
				(n->flags & DLMC_NF_START) ? 1 : 0,
				n->added_seq,
				n->removed_seq,
				check_str(n));
			n++;
		}
	}
	
	static void _dlmc_list(char *name)
	{
		struct dlmc_lockspace *lss;
		struct dlmc_lockspace *ls;
		int node_count;
		int ls_count;
		int rv;
		int i;
	

		if (name) {
			/* get only one specific lockspace by name */
			ls_count = 1;
			lss = malloc(sizeof(struct dlmc_lockspace));

			if (!lss)

				exit(EXIT_FAILURE);
	
			rv = dlmc_lockspace_info(name, lss);

		} else {
			rv = dlmc_lockspaces(&ls_count, &lss);

		}
	

		if (rv < 0)

			exit(EXIT_FAILURE); /* dlm_controld probably not running */
	

		if (ls_count)
			printf("dlm lockspaces\n");
	

		for (i = 0; i < ls_count; i++) {
			ls = &lss[i];
	
			show_ls(ls);
	

			if (!ls_all_nodes)

				goto next;
	
			node_count = 0;
			memset(&nodes, 0, sizeof(nodes));
	

			rv = dlmc_lockspace_nodes(ls->name, DLMC_NODES_ALL,
						  MAX_NODES, &node_count, nodes);

			if (rv < 0) {
				printf("all nodes error %d %d\n", rv, errno);
				goto next;

			}
	

			qsort(nodes, node_count, sizeof(struct dlmc_node),node_compare);
	
			printf("all nodes\n");
			show_all_nodes(node_count, nodes);
	 next:
			printf("\n");
		}
	
		free(lss);
	}
	
	static int _dlmc_plocks(char *name)
	{
		char buf[DLMC_DUMP_SIZE];
		int rv, data;
	
		memset(buf, 0, sizeof(buf));
	
		rv = dlmc_dump_plocks(name, buf, &data);
		if (rv)
			return rv;
		else if (data)
			return data;
	
		buf[DLMC_DUMP_SIZE-1] = '\0';
	
		do_write(STDOUT_FILENO, buf, strlen(buf));
	
		return 0;
	}
	
	static int _dlmc_dump(int op)
	{
		int rv = -EOPNOTSUPP, data;
		char buf[DLMC_DUMP_SIZE];
	
		memset(buf, 0, sizeof(buf));
	
		if (op == OP_DUMP_DEBUG)
			rv = dlmc_dump_debug(buf, &data);
		else if (op == OP_DUMP_CONFIG)
			rv = dlmc_dump_config(buf, &data);
		else if (op == OP_DUMP_RUN)
			rv = dlmc_dump_run(buf, &data);
	
		if (rv)
			return rv;
		else if (data)
			return data;
	
		buf[DLMC_DUMP_SIZE-1] = '\0';
	
		do_write(STDOUT_FILENO, buf, strlen(buf));
		printf("\n");
	
		return 0;
	}
	
	static void _dlmc_reload_config(void)
	{
		if (dlmc_reload_config() < 0)
			printf("reload_config failed\n");
		else
			printf("reload_config done\n");
	}
	
	static void _dlmc_set_config(void)
	{
		if (dlmc_set_config(run_command) < 0)
			printf("set_config failed\n");
		else
			printf("set_config done\n");
	}
	
	static int _dlmc_log_plock(void)
	{
		char buf[DLMC_DUMP_SIZE];
		int rv, data;
	
		memset(buf, 0, sizeof(buf));
	
		rv = dlmc_dump_log_plock(buf, &data);
		if (rv)
			return rv;
		else if (data)
			return data;
	
		buf[DLMC_DUMP_SIZE-1] = '\0';
	
		do_write(STDOUT_FILENO, buf, strlen(buf));
		printf("\n");
	
		return 0;
	}
	
	static int _dlmc_run(int op)
	{
		int do_start = (op == OP_RUN) || (op == OP_RUN_START);
		int do_check = (op == OP_RUN) || (op == OP_RUN_CHECK);
		int do_cancel = (op == OP_RUN_CANCEL);
		uint32_t flags = 0;
		uint32_t check_status = 0;
		int rv = 0;
	
		if (do_start) {
			/* FIXME: use proper option to specify */
			flags = DLMC_FLAG_RUN_START_NODE_NONE;
			if (ls_all_nodes)
				flags = DLMC_FLAG_RUN_START_NODE_RECV;
	
			rv = dlmc_run_start(run_command, strlen(run_command), 0,
					    flags, run_uuid);
	
			printf("run_uuid: %s\n", run_uuid);
		}
	
		if (do_check || do_cancel) {
			if (do_cancel)
				flags = DLMC_FLAG_RUN_CHECK_CANCEL;
			else
				flags = DLMC_FLAG_RUN_CHECK_CLEAR;
	
			rv = dlmc_run_check(run_uuid, strlen(run_uuid), wait_sec, flags,
					    &check_status);
	
			printf("check_status: ");
	
			if (check_status & DLMC_RUN_STATUS_WAITING)
				printf("waiting ");
			if (check_status & DLMC_RUN_STATUS_DONE)
				printf("done ");
			if (check_status & DLMC_RUN_STATUS_FAILED)
				printf("failed ");
			printf("\n");
		}
	
		return rv;
	}
	
	static char dlms_buf[DLM_SD_DUMP_SIZE];
	
	static int _dlms_dump(int op)
	{
		struct dlm_sd_header h = { 0 };
		uint32_t cmd;
		int len;
		int rv;
	
		if (op == OP_DUMP_DEBUG)
			cmd = DLM_SDQ_CMD_DUMP_DEBUG;
		else if (op == OP_DUMP_CONFIG)
			cmd = DLM_SDQ_CMD_DUMP_CONFIG;
		else if (op == OP_DUMP_STATUS)
			cmd = DLM_SDQ_CMD_DUMP_STATUS;
		else
			return -1;
	
		h.magic = DLM_SD_MAGIC;
		h.version = DLM_SD_VERSION;
		h.command = cmd;
		h.len = sizeof(h);
	
		rv = do_write(dlms_fd, &h, sizeof(h));
		if (rv < 0) {
			printf("cannot send to dlm_sand\n");
			return rv;
		}
	
		memset(&h, 0, sizeof(h));
	
		rv = do_read(dlms_fd, &h, sizeof(h));
		if (rv < 0)
			return rv;
	
		len = h.len - sizeof(h);
	
		rv = do_read(dlms_fd, dlms_buf, len);
		if (rv < 0)
			return rv;
	
		fprintf(stdout, "%s\n", dlms_buf);
		return 0;
	}
	
	static int daemon_status(int v)
	{
		if (use_dlmc)
			return dlmc_print_status(v ? DLMC_STATUS_VERBOSE : 0);
		else
			return _dlms_dump(OP_DUMP_STATUS);
	}
	
	static int daemon_dump(int op)
	{
		if (use_dlmc)
			return _dlmc_dump(op);
		else
			return _dlms_dump(op);
	}
	
	static void daemon_reload_config(void)
	{
		if (use_dlmc)
			_dlmc_reload_config();
		/*
		else
			_dlms_reload_config();
		*/
	}
	
	static void daemon_set_config(void)
	{
		if (use_dlmc)
			_dlmc_set_config();
		/*
		else
			_dlms_set_config();
		*/
	}
	
	static int _daemon_socket_connect(const char *sock_path, int *fd_out)
	{
		struct sockaddr_un sun;
		socklen_t addrlen;
		int rv, fd;
	
		fd = socket(PF_UNIX, SOCK_STREAM, 0);
		if (fd < 0)
			return -1;
	
		memset(&sun, 0, sizeof(sun));
		sun.sun_family = AF_UNIX;
		strcpy(&sun.sun_path[1], sock_path);
		addrlen = sizeof(sa_family_t) + strlen(sun.sun_path+1) + 1;
	
		rv = connect(fd, (struct sockaddr *) &sun, addrlen);
		if (rv < 0) {
			close(fd);
			return rv;
		}
		*fd_out = fd;
		return 0;
	}
	
	static int _daemon_connect(int query_op, int *fd_out)
	{
		if (query_op) {
			if (!_daemon_socket_connect(DLMC_QUERY_SOCK_PATH, fd_out)) {
				use_dlmc = 1;
				return 0;
			}
	
			if (!_daemon_socket_connect(DLM_SDQ_SOCK_PATH, fd_out)) {
				use_dlms = 1;
				return 0;
			}
		} else {
			if (!_daemon_socket_connect(DLMC_SOCK_PATH, fd_out)) {
				use_dlmc = 1;
				return 0;
			}
	
			if (!_daemon_socket_connect(DLM_SD_SOCK_PATH, fd_out)) {
				use_dlms = 1;
				return 0;
			}
		}
		return -1;
	}
	
	static int is_daemon_op(int op, int *query_op, int *only_dlmc)
	{
		int rv = 0;
	
		switch (op) {
		case OP_LIST:
		case OP_LOG_PLOCK:
		case OP_PLOCKS:
		case OP_FENCE_ACK:
		case OP_RUN:
		case OP_RUN_START:
		case OP_RUN_CHECK:
		case OP_RUN_CANCEL:
		case OP_DUMP_RUN:
			*only_dlmc = 1;
			rv = 1;
			break;
		case OP_DUMP_DEBUG:
		case OP_DUMP_STATUS:
		case OP_DUMP_CONFIG:
		case OP_RELOAD_CONFIG:
		case OP_SET_CONFIG:
			*only_dlmc = 0;
			rv = 1;
			break;
		default:
			rv = 0;
		}
	
		switch (op) {
		case OP_LIST:
		case OP_DUMP_RUN:
		case OP_DUMP_DEBUG:
		case OP_DUMP_STATUS:
		case OP_DUMP_CONFIG:
		case OP_LOG_PLOCK:
		case OP_PLOCKS:
			*query_op = 1;
			rv = 1;
			break;
		case OP_FENCE_ACK:
		case OP_RUN:
		case OP_RUN_START:
		case OP_RUN_CHECK:
		case OP_RUN_CANCEL:
		case OP_RELOAD_CONFIG:
		case OP_SET_CONFIG:
			*query_op = 0;
			rv = 1;
			break;
		default:
			rv = 0;
		}
	
		return rv;
	}
	
	int main(int argc, char **argv)
	{
		prog_name = argv[0];
		decode_arguments(argc, argv);
		int query_op = 0;
		int only_dlmc = 0;
		int fd;
		int rv = 0;
	
		if (is_daemon_op(operation, &query_op, &only_dlmc)) {
			rv = _daemon_connect(query_op, &fd);
			if (rv < 0) {
				fprintf(stderr, "Cannot connect to dlm daemon.\n");
				return -1;
			}
	
			/* libdlmcontrol apis create their own fd connection */
			if (use_dlmc)
				close(fd);
			if (use_dlms)
				dlms_fd = fd;
		}
	
		if (!use_dlmc && only_dlmc) {
			fprintf(stderr, "Command only valid for dlm_controld.\n");
			return -1;
		}
	
		switch (operation) {
	
		/* libdlm commands, kernel-based op */
	
		case OP_JOIN:
			do_join(lsname);
			break;
		case OP_LEAVE:
			do_leave(lsname);
			break;
		case OP_JOINLEAVE:
			do_join(lsname);
			do_leave(lsname);
			break;
	
		/* debugfs commands */
	
		case OP_LOCKDUMP:
			do_lockdump(lsname);
			break;
		case OP_LOCKDEBUG:
			do_lockdebug(lsname);
			break;
	
		/* dlm_controld-only commands */
	
		case OP_LIST:
			_dlmc_list(lsname);
			break;
		case OP_LOG_PLOCK:
			rv = _dlmc_log_plock();
			break;
		case OP_PLOCKS:
			rv = _dlmc_plocks(lsname);
			break;
		case OP_FENCE_ACK:
			dlmc_fence_ack(lsname);
			break;
		case OP_RUN:
		case OP_RUN_START:
		case OP_RUN_CHECK:
		case OP_RUN_CANCEL:
			rv = _dlmc_run(operation);
			break;
		case OP_DUMP_RUN:
			rv = _dlmc_dump(operation);
			break;
	
		/* dlm_controld or dlm_sand commands */
	
		case OP_DUMP_STATUS:
			rv = daemon_status(verbose);
			break;
		case OP_DUMP_DEBUG:
		case OP_DUMP_CONFIG:
			rv = daemon_dump(operation);
			break;
		case OP_RELOAD_CONFIG:
			daemon_reload_config();
			break;
		case OP_SET_CONFIG:
			daemon_set_config();
			break;
		}
	
		if (dlms_fd)
			close(dlms_fd);
	
		if (rv < 0) {
			fprintf(stderr, "failed: %s\n", strerror(-rv));
			return EXIT_FAILURE;
		}
	
		return EXIT_SUCCESS;
	}