Debian 3.9.10debian/3.9.10debian

7 files changed, 2557 insertions, 0 deletions

diff --git a/src/pmlc/GNUmakefile b/src/pmlc/GNUmakefile
new file mode 100644
index 0000000..78b1fab
--- /dev/null
+++ b/src/pmlc/GNUmakefile
@@ -0,0 +1,46 @@
+#
+# Copyright (c) 2000,2004 Silicon Graphics, Inc.  All Rights Reserved.
+# 
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+# 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+# 
+
+TOPDIR = ../..
+include $(TOPDIR)/src/include/builddefs
+
+CMDTARGET = pmlc$(EXECSUFFIX)
+CFILES	= pmlc.c util.c actions.c
+HFILES	= pmlc.h
+LFILES  = lex.l
+YFILES	= gram.y
+LDIRT	= *.log foo.* $(YFILES:%.y=%.tab.?) $(CMDTARGET) $(LFILES:.l=.c) gram.h
+LLDLIBS = $(PCPLIB)
+
+default: $(CMDTARGET)
+
+$(CMDTARGET):	$(OBJECTS)
+
+install:	$(CMDTARGET) 
+	$(INSTALL) -m 755 $(CMDTARGET) $(PCP_BIN_DIR)/$(CMDTARGET)
+
+pmlc.o:	gram.h
+
+.NOTPARALLEL:
+gram.tab.h gram.tab.c:	gram.y
+	$(YACC) -d -b `basename $< .y` $<
+
+gram.h:	gram.tab.h
+	rm -f $@ && $(LN_S) $< $@
+
+include $(BUILDRULES)
+
+default_pcp:	default
+
+install_pcp:	install
diff --git a/src/pmlc/actions.c b/src/pmlc/actions.c
new file mode 100644
index 0000000..43ea25c
--- /dev/null
+++ b/src/pmlc/actions.c
@@ -0,0 +1,868 @@
+/*
+ * Copyright (c) 2014 Red Hat.
+ * Copyright (c) 1995-2001 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include <inttypes.h>
+#include "pmapi.h"
+#include "impl.h"
+#include "pmlc.h"
+
+/* for the pmlogger/PMCD we currently have a connection to */
+static int	logger_fd = -1;		/* file desc pmlogger */
+static char	*lasthost;		/* host that logger_ctx is for */
+static int	src_ctx = -1;		/* context for logged host's PMCD*/
+static char	*srchost;		/* host that logged_ctx is for */
+
+static time_t	tmp;		/* for pmCtime */
+
+/* PCP 1.x pmlogger returns one of these when a status request is made */
+typedef struct {
+    __pmTimeval  ls_start;	/* start time for log */
+    __pmTimeval  ls_last;	/* last time log written */
+    __pmTimeval  ls_timenow;	/* current time */
+    int		ls_state;	/* state of log (from __pmLogCtl) */
+    int		ls_vol;		/* current volume number of log */
+    __int64_t	ls_size;	/* size of current volume */
+    char	ls_hostname[PM_LOG_MAXHOSTLEN];
+				/* name of pmcd host */
+    char	ls_tz[40];      /* $TZ at collection host */
+    char	ls_tzlogger[40]; /* $TZ at pmlogger */
+} __pmLoggerStatus_v1;
+
+static int
+IsLocal(const char *hostspec)
+{
+    if (strcmp(hostspec, "localhost") == 0 ||
+	strcmp(hostspec, "local:") == 0 ||
+	strcmp(hostspec, "unix:") == 0)
+	return 1;
+    return 0;
+}
+int
+ConnectPMCD(void)
+{
+    int			sts;
+    __pmPDU		*pb = NULL;
+
+    if (src_ctx >= 0)
+	return src_ctx;
+
+    if (__pmVersionIPC(logger_fd) >= LOG_PDU_VERSION2) {
+	__pmLoggerStatus	*lsp;
+#ifdef PCP_DEBUG
+	if (pmDebug & DBG_TRACE_PDU)
+	     fprintf(stderr, "pmlc: sending version 2 status request\n");
+#endif
+	if ((sts = __pmSendLogRequest(logger_fd, LOG_REQUEST_STATUS)) < 0) {
+	    fprintf(stderr, "Error sending request to pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return sts;
+	}
+	if ((sts = __pmGetPDU(logger_fd, ANY_SIZE, __pmLoggerTimeout(), &pb)) <= 0) {
+	    if (sts == 0)
+		/* end of file! */
+		sts = PM_ERR_IPC;
+	    fprintf(stderr, "Error receiving response from pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return sts;
+	}
+	if (sts == PDU_ERROR) {
+	    __pmDecodeError(pb, &sts);
+	    fprintf(stderr, "Error: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    sts = 0;
+	    goto done;
+	}
+	if (sts != PDU_LOG_STATUS) {
+	    fprintf(stderr, "Error PDU response from pmlogger %s", __pmPDUTypeStr(sts));
+	    fprintf(stderr, " not %s as expected\n", __pmPDUTypeStr(PDU_LOG_STATUS));
+	    sts = 0;
+	    goto done;
+	}
+	sts = __pmDecodeLogStatus(pb, &lsp);
+	__pmUnpinPDUBuf(pb);
+	if (sts < 0) {
+	    fprintf(stderr, "Error decoding response from pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    goto done;
+	} 
+	if (IsLocal(lsp->ls_fqdn)) {
+	    /*
+	     * if pmcd host is "localhost"-alike then use hostname that
+	     * was used to contact pmlogger, as from here (where pmlc is
+	     * running) "localhost" is likely to connect us to the wrong
+	     * pmcd or no pmcd at all.
+	     */
+	    srchost = strdup(lasthost);
+	    if (srchost == NULL)
+		__pmNoMem("Error copying host name", strlen(lasthost), PM_FATAL_ERR);
+	}
+	else {
+	    srchost = strdup(lsp->ls_fqdn);
+	    if (srchost == NULL)
+		__pmNoMem("Error copying host name", strlen(lsp->ls_fqdn), PM_FATAL_ERR);
+	}
+    }
+
+    if ((sts = pmNewContext(PM_CONTEXT_HOST, srchost)) < 0) {
+	/* no PMCD connection, we can't do anything, give up */
+	fprintf(stderr, "Error trying to connect to PMCD on %s: %s\n",
+		srchost, pmErrStr(sts));
+    }
+    else
+        src_ctx = sts;
+
+done:
+    if (pb)
+	__pmUnpinPDUBuf(pb);
+    return sts;
+}
+
+int
+ConnectLogger(char *hostname, int *pid, int *port)
+{
+    int		sts;
+
+    if (lasthost != NULL) {
+	free(lasthost);
+	lasthost = NULL;
+    }
+    DisconnectLogger();
+
+    if (src_ctx != -1) {
+	if ((sts = pmDestroyContext(src_ctx)) < 0)
+		fprintf(stderr, "Error deleting PMCD connection to %s: %s\n",
+			srchost, pmErrStr(sts));
+	src_ctx = -1;
+    }
+    if (srchost != NULL) {
+	free(srchost);
+	srchost = NULL;
+    }
+
+    if ((sts = __pmConnectLogger(hostname, pid, port)) < 0) {
+	logger_fd = -1;
+	return sts;
+    }
+    else {
+	logger_fd = sts;
+	if ((lasthost = strdup(hostname)) == NULL) {
+	    __pmNoMem("Error copying host name", strlen(hostname), PM_FATAL_ERR);
+	}
+	return 0;
+    }
+}
+
+void
+DisconnectLogger(void)
+{
+    if (logger_fd != -1) {
+	__pmCloseSocket(logger_fd);
+	logger_fd = -1;
+	sleep(1);
+    }
+}
+
+void
+ShowLoggers(char *hostname)
+{
+    int		i, n;
+    int		ctx;
+    int		primary = -1;		/* ports[] index for primary logger */
+    int		pport = -1;		/* port for primary logger */
+    __pmLogPort	*ports;
+
+    if ((n = __pmIsLocalhost(hostname)) == 0) {
+	/* remote, need PMCD's help for __pmLogFindPort */
+	if ((ctx = pmNewContext(PM_CONTEXT_HOST, hostname)) < 0) {
+	    fprintf(stderr, "Error trying to connect to PMCD on %s: %s\n",
+		hostname, pmErrStr(ctx));
+	    return;
+	}
+    }
+    else
+	ctx = -1;
+
+    if ((n = __pmLogFindPort(hostname, PM_LOG_ALL_PIDS, &ports)) < 0) {
+	fprintf(stderr, "Error finding pmloggers on %s: ",
+		hostname);
+	if (still_connected(n))
+	    fprintf(stderr, "%s\n", pmErrStr(n));
+    }
+    else if (n == 0)
+	    printf("No pmloggers running on %s\n", hostname);
+    else {
+	/* find the position of the primary logger */
+	for (i = 0; i < n; i++) {
+	    if (ports[i].pid == PM_LOG_PRIMARY_PID) {
+		pport = ports[i].port;
+		break;
+	    }
+	}
+	for (i = 0; i < n; i++) {
+	    if (ports[i].port == pport) {
+		primary = i;
+		break;
+	    }
+	}
+	printf("The following pmloggers are running on %s:\n    ", hostname);
+	/* print any primary logger first, with its pid alias in parentheses) */
+	if (primary != -1) {
+	    printf("primary");
+	    printf(" (%d)", ports[primary].pid);
+	}
+	/* now print everything except the primary logger */
+	for (i = 0; i < n; i++) {
+	    if (i != primary &&
+		ports[i].pid != PM_LOG_PRIMARY_PID) {
+		    printf(" %d", ports[i].pid);
+	    }
+	}
+	putchar('\n');
+
+	/* Note: Don't free ports, it's storage is managed by __pmLogFindPort() */
+    }
+
+    if (ctx >= 0)
+	pmDestroyContext(ctx);
+}
+
+static void
+PrintState(int state)
+{
+    static char	*units[] = {"msec", "sec ", "min ", "hour"};
+    static int	factor[] = {1000, 60, 60, 24};
+    int		nfactors = sizeof(factor) / sizeof(factor[0]);
+    int		i, j, is_on;
+    int		delta = PMLC_GET_DELTA(state);
+    float	t = delta;
+    int		frac;
+
+    fputs(PMLC_GET_MAND(state) ? "mand " : "adv  ", stdout);
+    is_on = PMLC_GET_ON(state);
+    fputs(is_on ? "on  " : "off ", stdout);
+    if (PMLC_GET_INLOG(state))
+	fputs(PMLC_GET_AVAIL(state) ? "   " : "na ", stdout);
+    else
+	fputs("nl ", stdout);
+
+    /* don't display time unless logging on */
+    if (!is_on) {
+	fputs("            ", stdout);
+	return;
+    }
+
+    if (delta == 0) {
+	fputs("        once", stdout);
+	return;
+    }
+
+    for (i = 0; i < nfactors; i++) {
+	if (t < factor[i])
+	    break;
+	t /= factor[i];
+    }
+    if (i >= nfactors)
+	i = nfactors - 1;
+    
+    frac = (int) ((t - (int)t) * 1000);	/* get 3 decimal places */
+    if (frac % 10)
+	j = 3;
+    else
+	if (frac % 100)
+	    j = 2;
+	else
+	    if (frac % 1000)
+		j = 1;
+	    else
+		j = 0;
+    fprintf(stdout, "%*.*f %s", 7 - j, j, t, units[i]);
+    return;
+}
+
+
+/* this pmResult is built during parsing of each pmlc statement.
+ * the metrics and indoms likewise
+ */
+extern pmResult	*logreq;
+extern metric_t	*metric;
+extern int	n_metrics;
+extern indom_t	*indom;
+extern int	n_indoms;
+
+void
+Query(void)
+{
+    int		i, j, k, inst;
+    metric_t	*mp;
+    pmValueSet	*vsp;
+    pmResult	*res;
+
+    if (!connected())
+	return;
+
+    if ((i = __pmControlLog(logger_fd, logreq, PM_LOG_ENQUIRE, 0, 0, &res)) < 0) {
+	fprintf(stderr, "Error receiving response from pmlogger: ");
+	if (still_connected(i))
+	    fprintf(stderr, "%s\n", pmErrStr(i));
+	return;
+    }
+    if (res == NULL) {
+	fprintf(stderr, "Error: NULL result from __pmControlLog\n");
+	return;
+    }
+
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	vsp = res->vset[i];
+	if (mp->pmid != vsp->pmid) {
+	    fprintf(stderr, "GAK! %s not found in returned result\n", mp->name);
+	    return;
+	}
+	puts(mp->name);
+	if (vsp->numval < 0) {
+	    fputs("    ", stdout);
+	    puts(pmErrStr(vsp->numval));
+	}
+	else if (mp->indom == -1) {
+	    fputs("    ", stdout);
+	    PrintState(vsp->vlist[0].value.lval);
+	    putchar('\n');
+	}
+	else if (mp->status.has_insts)
+	    for (j = 0; j < mp->n_insts; j++) {
+		inst = mp->inst[j];
+		for (k = 0; k < vsp->numval; k++)
+		    if (inst == vsp->vlist[k].inst)
+			break;
+		if (k >= vsp->numval) {
+		    printf("                  [%d] (not found)\n", inst);
+		    continue;
+		}
+		fputs("    ", stdout);
+		PrintState(vsp->vlist[k].value.lval);
+		for (k = 0; k < indom[mp->indom].n_insts; k++)
+		    if (inst == indom[mp->indom].inst[k])
+			break;
+		printf(" [%d or \"%s\"]\n", inst,
+		       (k < indom[mp->indom].n_insts) ? indom[mp->indom].name[k] : "???");
+	    }
+	else {
+	    if (vsp->numval <= 0)
+		puts("    (no instances)");
+	    else
+		for (j = 0; j < vsp->numval; j++) {
+		    fputs("    ", stdout);
+		    PrintState(vsp->vlist[j].value.lval);
+		    inst = vsp->vlist[j].inst;
+		    for (k = 0; k < indom[mp->indom].n_insts; k++)
+			if (inst == indom[mp->indom].inst[k])
+			    break;
+		    printf(" [%d or \"%s\"]\n",
+			   inst,
+			   (k < indom[mp->indom].n_insts) ? indom[mp->indom].name[k] : "???");
+		}
+	}
+	putchar('\n');
+    }
+    pmFreeResult(res);
+}
+
+void LogCtl(int control, int state, int delta)
+{
+    int		i;
+    metric_t	*mp;
+    pmValueSet	*vsp;
+    pmResult	*res;
+    int		newstate, newdelta;	/* from pmlogger */
+    int		expstate = 0;		/* expected from pmlogger */
+    int		expdelta;
+    int		firsterr = 1;
+    unsigned	statemask;
+    static char	*heading = "Warning: unable to change logging state for:";
+
+    if (!connected())
+	return;
+
+    i = __pmControlLog(logger_fd, logreq, control, state, delta, &res);
+    if (i < 0 && i != PM_ERR_GENERIC) {
+	fprintf(stderr, "Error receiving response from pmlogger: ");
+	if (still_connected(i))
+	    fprintf(stderr, "%s\n", pmErrStr(i));
+	return;
+    }
+    if (res == NULL) {
+	fprintf(stderr, "Error: NULL result from __pmControlLog\n");
+	return;
+    }
+
+    /* Set up the state that we expect pmlogger to return.  The encoding for
+     * control and state passed to __pmControlLog differs from that returned
+     * in the result.
+     */
+    statemask = 0;
+    if (state != PM_LOG_MAYBE) {
+	if (control == PM_LOG_MANDATORY)
+	    PMLC_SET_MAND(expstate, 1);
+	else
+	    PMLC_SET_MAND(expstate, 0);
+	if (state == PM_LOG_ON)
+	    PMLC_SET_ON(expstate, 1);
+	else
+	    PMLC_SET_ON(expstate, 0);
+	PMLC_SET_MAND(statemask, 1);
+	PMLC_SET_ON(statemask, 1);
+    }
+    else {
+	/* only mandatory+maybe is allowed by parser, which should return
+	 * advisory+off OR advisory+on from pmlogger
+	 */
+	PMLC_SET_MAND(expstate, 0);
+	PMLC_SET_MAND(statemask, 1);
+	/* don't set ON bit in statemask; ignore returned on/off status */
+    }
+
+    expdelta = PMLC_GET_ON(expstate) ? delta : 0;
+
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	int	j, k, inst;
+	int	hadinstmsg;
+	char	*name;
+
+	vsp = res->vset[i];
+	if (mp->pmid != vsp->pmid) {
+	    fprintf(stderr, "GAK! %s not found in returned result\n", mp->name);
+	    return;
+	}
+	if (vsp->numval < 0) {
+	    if (firsterr) {
+		firsterr = 0;
+		puts(heading);
+	    }
+	    printf("%s:%s\n", mp->name, pmErrStr(vsp->numval));
+	    continue;
+	}
+
+	if (mp->indom == -1) {
+	    newstate = PMLC_GET_STATE(vsp->vlist[0].value.lval) & statemask;
+	    newdelta = PMLC_GET_DELTA(vsp->vlist[0].value.lval);
+	    if (expstate != newstate || expdelta != newdelta) {
+		if (firsterr) {
+		    firsterr = 0;
+		    puts(heading);
+		}
+		printf("%s\n\n", mp->name);
+	    }
+	}
+	else if (mp->status.has_insts) {
+	    long	val;
+
+	    hadinstmsg = 0;
+	    for (j = 0; j < mp->n_insts; j++) {
+		inst = mp->inst[j];
+		/* find inst name via mp->indom */
+		for (k = 0; k < indom[mp->indom].n_insts; k++)
+		    if (inst == indom[mp->indom].inst[k])
+			break;
+		if (k < indom[mp->indom].n_insts)
+		    name = indom[mp->indom].name[k];
+		else
+		    name = "???";
+		/* look for inst in pmValueSet from pmlogger */
+		for (k = 0; k < vsp->numval; k++)
+		    if (inst == vsp->vlist[k].inst)
+			break;
+		if (k >= vsp->numval) {
+		    if (firsterr) {
+			firsterr = 0;
+			puts(heading);
+		    }
+		    if (!hadinstmsg) {
+			hadinstmsg = 1;
+			printf("%s\n", mp->name);
+		    }
+		    printf("    [%d or \"%s\"] instance not found\n", inst, name);
+		    continue;
+		}
+		val = vsp->vlist[k].value.lval;
+		newstate = (int)PMLC_GET_STATE(val) & statemask;
+		newdelta = PMLC_GET_DELTA(val);
+		if (expstate != newstate || expdelta != newdelta) {
+		    if (firsterr) {
+			firsterr = 0;
+			puts(heading);
+		    }
+		    if (!hadinstmsg) {
+			hadinstmsg = 1;
+			printf("%s instance(s):\n", mp->name);
+		    }
+		    printf("    [%d or \"%s\"]\n", inst, name);
+		}
+	    }
+	    if (hadinstmsg)
+		putchar('\n');
+	}
+	else {
+	    hadinstmsg = 0;
+	    for (j = 0; j < vsp->numval; j++) {
+		newstate = PMLC_GET_STATE(vsp->vlist[j].value.lval) & statemask;
+		newdelta = PMLC_GET_DELTA(vsp->vlist[j].value.lval);
+		if (expstate != newstate || expdelta != newdelta) {
+		    if (firsterr) {
+			firsterr = 0;
+			puts(heading);
+		    }
+		    if (!hadinstmsg) {
+			hadinstmsg = 1;
+			printf("%s instance(s):\n", mp->name);
+		    }
+		    inst = vsp->vlist[j].inst;
+		    for (k = 0; k < indom[mp->indom].n_insts; k++)
+			if (inst == indom[mp->indom].inst[k])
+			    break;
+		    if (k < indom[mp->indom].n_insts)
+			name = indom[mp->indom].name[k];
+		    else
+			name = "???";
+		    printf("    [%d or \"%s\"]\n", inst, name);
+		}
+	    }
+	    if (hadinstmsg)
+		putchar('\n');
+	}
+    }
+    pmFreeResult(res);
+}
+
+/*
+ * Used to flag timezone changes.
+ * These changes are only relevant to Status() so they are made here.
+ */
+int	tzchange = 0;
+
+#define TZBUFSZ	30			/* for pmCtime buffers */
+
+void Status(int pid, int primary)
+{
+    static int		localtz = -1;
+    static char 	*ltzstr = "";	/* pmNewZone doesn't like null pointers */
+    char		*str;
+    __pmLoggerStatus	*lsp;
+    static char		localzone[] = "local"; 
+    static char		*zonename = localzone;
+    char		*tzlogger;
+    __pmTimeval		*start;
+    __pmTimeval		*last;
+    __pmTimeval		*timenow;
+    char		*hostname;
+    int			state;
+    int			vol;
+    __int64_t		size;
+    char		startbuf[TZBUFSZ];
+    char		lastbuf[TZBUFSZ];
+    char		timenowbuf[TZBUFSZ];
+    int			sts;
+    __pmPDU		*pb;
+
+    if (!connected())
+	return;
+
+    if (__pmVersionIPC(logger_fd) >= LOG_PDU_VERSION2) {
+#ifdef PCP_DEBUG
+	if (pmDebug & DBG_TRACE_PDU)
+	    fprintf(stderr, "pmlc: sending version 2 status request\n");
+#endif
+	if ((sts = __pmSendLogRequest(logger_fd, LOG_REQUEST_STATUS)) < 0) {
+	    fprintf(stderr, "Error sending status request to pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return;
+	}
+	if ((sts = __pmGetPDU(logger_fd, ANY_SIZE, __pmLoggerTimeout(), &pb)) <= 0) {
+	    if (sts == 0)
+		/* end of file! */
+		sts = PM_ERR_IPC;
+	    fprintf(stderr, "Error receiving response from pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return;
+	}
+	if (sts == PDU_ERROR) {
+	    __pmDecodeError(pb, &sts);
+	    fprintf(stderr, "Error: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    sts = 0;
+	    goto done;
+	}
+	if (sts != PDU_LOG_STATUS) {
+	    fprintf(stderr, "Error PDU response from pmlogger %s", __pmPDUTypeStr(sts));
+	    fprintf(stderr, " not %s as expected\n", __pmPDUTypeStr(PDU_LOG_STATUS));
+	    __pmUnpinPDUBuf(pb);
+	    return;
+	}
+	sts = __pmDecodeLogStatus(pb, &lsp);
+	__pmUnpinPDUBuf(pb);
+	if (sts < 0) {
+	    fprintf(stderr, "Error decoding response from pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return;
+	}
+	tzlogger = lsp->ls_tzlogger;
+	start = &lsp->ls_start;
+	last = &lsp->ls_last;
+	timenow = &lsp->ls_timenow;
+	hostname = lsp->ls_hostname;
+	state = lsp->ls_state;
+	vol = lsp->ls_vol;
+	size = lsp->ls_size;
+    }
+    else {
+	fprintf(stderr, "Error: logger IPC version < LOG_PDU_VERSION2, not supported\n");
+	return;
+    }
+
+    if (tzchange) {
+	switch (tztype) {
+	    case TZ_LOCAL:
+		if (localtz == -1) {
+                    str = __pmTimezone();
+		    if (str != NULL)
+			ltzstr = str;
+		    localtz = pmNewZone(ltzstr);
+		    /* (exits if it fails) */
+		}
+		else
+		    pmUseZone(localtz);
+		zonename = localzone;
+		break;
+
+	    case TZ_LOGGER:
+		if (tzlogger)
+		    pmNewZone(tzlogger);	/* but keep me! */
+		zonename = "pmlogger";
+		break;
+
+	    case TZ_OTHER:
+		pmNewZone(tz);
+		zonename = tz;
+		break;
+	}
+    }
+    tmp = start->tv_sec;
+    pmCtime(&tmp, startbuf);
+    startbuf[strlen(startbuf)-1] = '\0'; /* zap the '\n' at the end */
+    tmp = last->tv_sec;
+    pmCtime(&tmp, lastbuf);
+    lastbuf[strlen(lastbuf)-1] = '\0';
+    tmp = timenow->tv_sec;
+    pmCtime(&tmp, timenowbuf);
+    timenowbuf[strlen(timenowbuf)-1] = '\0';
+    printf("pmlogger ");
+    if (primary)
+	printf("[primary]");
+    else
+	printf("[%d]", pid);
+    printf(" on host %s is logging metrics from host %s\n",
+	lasthost, hostname);
+    /* NB: FQDN cleanup: note that this is not 'the fqdn' of the
+       pmlogger host or that of its target.  */
+    if (__pmVersionIPC(logger_fd) >= LOG_PDU_VERSION2)
+	printf("PMCD host        %s\n",
+		IsLocal(lsp->ls_fqdn) ? hostname : lsp->ls_fqdn);
+    if (state == PM_LOG_STATE_NEW) {
+	puts("logging hasn't started yet");
+	goto done;
+    }
+    printf("log started      %s (times in %s time)\n"
+	   "last log entry   %s\n"
+	   "current time     %s\n"
+	   "log volume       %d\n"
+	   "log size         %" PRIi64 "\n",
+	   startbuf, zonename, lastbuf, timenowbuf, vol, size);
+
+done:
+    return;
+
+}
+
+void
+Sync(void)
+{
+    int			sts;
+    __pmPDU		*pb;
+
+    if (!connected())
+	return;
+
+    if (__pmVersionIPC(logger_fd) >= LOG_PDU_VERSION2) {
+#ifdef PCP_DEBUG
+	if (pmDebug & DBG_TRACE_PDU)
+	    fprintf(stderr, "pmlc: sending version 2 sync request\n");
+#endif
+	if ((sts = __pmSendLogRequest(logger_fd, LOG_REQUEST_SYNC)) < 0) {
+	    fprintf(stderr, "Error sending sync request to pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return;
+	}
+    }
+
+    if ((sts = __pmGetPDU(logger_fd, ANY_SIZE, __pmLoggerTimeout(), &pb)) != PDU_ERROR) {
+	if (sts > 0)
+	    __pmUnpinPDUBuf(pb);
+	if (sts == 0)
+	    /* end of file! */
+	    sts = PM_ERR_IPC;
+	fprintf(stderr, "Error receiving response from pmlogger: ");
+	if (still_connected(sts))
+	    fprintf(stderr, "%s\n", pmErrStr(sts));
+	return;
+    }
+    __pmDecodeError(pb, &sts);
+    __pmUnpinPDUBuf(pb);
+    if (sts < 0) {
+	fprintf(stderr, "Error: ");
+	if (still_connected(sts))
+	    fprintf(stderr, "%s\n", pmErrStr(sts));
+	return;
+    }
+
+    return;
+}
+
+void
+Qa(void)
+{
+    int			sts;
+    __pmPDU		*pb;
+
+    if (!connected())
+	return;
+
+    if (__pmVersionIPC(logger_fd) >= LOG_PDU_VERSION2) {
+#ifdef PCP_DEBUG
+	if (pmDebug & DBG_TRACE_PDU)
+	    fprintf(stderr, "pmlc: sending version 2 qa request\n");
+#endif
+	if ((sts = __pmSendLogRequest(logger_fd, 100+qa_case)) < 0) {
+	    fprintf(stderr, "Error sending qa request to pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return;
+	}
+    }
+
+    if ((sts = __pmGetPDU(logger_fd, ANY_SIZE, __pmLoggerTimeout(), &pb)) != PDU_ERROR) {
+	if (sts > 0)
+	    __pmUnpinPDUBuf(pb);
+	if (sts == 0)
+	    /* end of file! */
+	    sts = PM_ERR_IPC;
+	fprintf(stderr, "Error receiving response from pmlogger: ");
+	if (still_connected(sts))
+	    fprintf(stderr, "%s\n", pmErrStr(sts));
+	return;
+    }
+    __pmDecodeError(pb, &sts);
+    __pmUnpinPDUBuf(pb);
+    if (sts < 0) {
+	fprintf(stderr, "Error: ");
+	if (still_connected(sts))
+	    fprintf(stderr, "%s\n", pmErrStr(sts));
+	return;
+    }
+
+    return;
+}
+
+void
+NewVolume(void)
+{
+    int			sts;
+    __pmPDU		*pb;
+
+    if (!connected())
+	return;
+
+    if (__pmVersionIPC(logger_fd) >= LOG_PDU_VERSION2) {
+#ifdef PCP_DEBUG
+	if (pmDebug & DBG_TRACE_PDU)
+	    fprintf(stderr, "pmlc: sending version 2 newvol request\n");
+#endif
+	if ((sts = __pmSendLogRequest(logger_fd, LOG_REQUEST_NEWVOLUME)) < 0) {
+	    fprintf(stderr, "Error sending newvolume request to pmlogger: ");
+	    if (still_connected(sts))
+		fprintf(stderr, "%s\n", pmErrStr(sts));
+	    return;
+	}
+    }
+
+    if ((sts = __pmGetPDU(logger_fd, ANY_SIZE, __pmLoggerTimeout(), &pb)) != PDU_ERROR) {
+	if (sts > 0)
+	    __pmUnpinPDUBuf(pb);
+	if (sts == 0)
+	    /* end of file! */
+	    sts = PM_ERR_IPC;
+	fprintf(stderr, "Error receiving response from pmlogger: ");
+	if (still_connected(sts))
+	    fprintf(stderr, "%s\n", pmErrStr(sts));
+	return;
+    }
+    __pmDecodeError(pb, &sts);
+    __pmUnpinPDUBuf(pb);
+    if (sts < 0) {
+	fprintf(stderr, "Error: ");
+	if (still_connected(sts))
+	    fprintf(stderr, "%s\n", pmErrStr(sts));
+	return;
+    }
+    else
+	fprintf(stderr, "New log volume %d\n", sts);
+
+    __pmUnpinPDUBuf(pb);
+    return;
+}
+
+int
+connected(void)
+{
+    if (logger_fd == -1) {
+	yyerror("Not connected to any pmlogger instance");
+	return 0;
+    }
+    else
+	return 1;
+}
+
+int
+still_connected(int sts)
+{
+    if (sts == PM_ERR_IPC || sts == -EPIPE) {
+	fprintf(stderr, "Lost connection to the pmlogger instance\n");
+	DisconnectLogger();
+	return 0;
+    }
+    if (sts == PM_ERR_TIMEOUT) {
+	fprintf(stderr, "Timeout, closed connection to the pmlogger instance\n");
+	DisconnectLogger();
+	return 0;
+    }
+
+    return 1;
+}
diff --git a/src/pmlc/gram.y b/src/pmlc/gram.y
new file mode 100644
index 0000000..1455329
--- /dev/null
+++ b/src/pmlc/gram.y
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2014 Red Hat.
+ * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+%{
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include "pmapi.h"
+#include "impl.h"
+#include "./pmlc.h"
+
+#ifdef YYDEBUG
+int yydebug=1;
+#endif
+
+int	mystate = GLOBAL;
+int	logfreq;
+int	parse_stmt;
+char	emess[160];
+char	*hostname;
+int	state;
+int	control;
+int	qa_case;
+
+static int	sts;
+
+extern int	port;
+extern int	pid;
+extern int	is_local;
+extern int	is_unix;
+extern int	is_socket_path;
+
+%}
+
+%union {
+    long lval;
+    char * str;
+}
+
+%term	LSQB
+	RSQB
+	COMMA
+	LBRACE
+	RBRACE
+	AT
+	EOL
+
+	LOG
+	MANDATORY ADVISORY
+	ON OFF MAYBE
+	EVERY ONCE
+	MSEC SECOND MINUTE HOUR
+
+	QUERY SHOW LOGGER CONNECT PRIMARY QUIT STATUS HELP
+	TIMEZONE LOCAL PORT SOCKET
+	NEW VOLUME
+
+	SYNC
+	QA
+
+%token<str>	NAME HOSTNAME STRING URL
+%token<lval>	NUMBER
+
+%type<lval> timeunits
+%%
+
+stmt   		: dowhat
+		{
+		    mystate |= INSPEC;
+		    if (!connected()) {
+			metric_cnt = -1;
+			return 0;
+		    }
+		    if (ConnectPMCD()) {
+			yyerror("");
+			metric_cnt = -1;
+			return 0;
+		    }
+		    beginmetrics();
+		}
+		somemetrics
+		{
+		    mystate = GLOBAL;
+		    endmetrics();
+		}
+		EOL
+		{
+		    parse_stmt = LOG;
+		    YYACCEPT;
+		}
+		| SHOW loggersopt hostopt EOL
+		{
+		    parse_stmt = SHOW;
+		    YYACCEPT;
+		}
+		| CONNECT towhom hostopt EOL
+		{
+		    parse_stmt = CONNECT;
+		    YYACCEPT;
+		}
+		| HELP EOL
+		{
+		    parse_stmt = HELP;
+		    YYACCEPT;
+		}
+		| QUIT EOL
+		{
+		    parse_stmt = QUIT;
+		    YYACCEPT;
+		}
+		| STATUS EOL
+		{
+		    parse_stmt = STATUS;
+		    YYACCEPT;
+		}
+		| NEW VOLUME EOL
+		{
+		    parse_stmt = NEW;
+		    YYACCEPT;
+		}
+		| TIMEZONE tzspec EOL
+		{
+		    parse_stmt = TIMEZONE;
+		    YYACCEPT;
+		}
+		| SYNC EOL
+		{
+		    parse_stmt = SYNC;
+		    YYACCEPT;
+		}
+		| QA NUMBER EOL
+		{
+		    parse_stmt = QA;
+		    qa_case = $2;
+		    YYACCEPT;
+		}
+		| EOL
+		{
+		    parse_stmt = 0;
+		    YYACCEPT;
+		}
+		| { YYERROR; }
+		;
+
+dowhat		: action 
+		;
+
+action		: QUERY				{ state = PM_LOG_ENQUIRE; }
+		| logopt cntrl ON frequency	{ state = PM_LOG_ON; }
+		| logopt cntrl OFF		{ state = PM_LOG_OFF; }
+		| logopt MANDATORY MAYBE
+		{
+		    control = PM_LOG_MANDATORY;
+		    state = PM_LOG_MAYBE;
+		}
+		;
+
+logopt		: LOG 
+		| /* nothing */
+		;
+
+cntrl		: MANDATORY			{ control = PM_LOG_MANDATORY; }
+		| ADVISORY			{ control = PM_LOG_ADVISORY; }
+		;
+
+frequency	: everyopt NUMBER timeunits	{ logfreq = $2 * $3; }
+		| ONCE				{ logfreq = -1; }
+		;
+
+everyopt	: EVERY
+		| /* nothing */
+		;
+
+timeunits	: MSEC		{ $$ = 1; }
+		| SECOND	{ $$ = 1000; }
+		| MINUTE	{ $$ = 60000; }
+		| HOUR		{ $$ = 3600000; }
+		;
+
+somemetrics	: LBRACE { mystate |= INSPECLIST; } metriclist RBRACE
+		| metricspec
+		;
+
+metriclist	: metricspec
+		| metriclist metricspec
+		| metriclist COMMA metricspec
+		;
+
+metricspec	: NAME
+		{
+		    beginmetgrp();
+		    if ((sts = pmTraversePMNS($1, addmetric)) < 0)
+			/* metric_cnt is set by addmetric but if
+			 * traversePMNS fails, set it so that the bad
+			 * news is visible to other routines
+			 */
+			metric_cnt = sts;
+		    else if (metric_cnt < 0) /* addmetric failed */
+			sts = metric_cnt;
+
+		    if (sts < 0 || metric_cnt == 0) {
+			sprintf(emess, 
+				"Problem with lookup for metric \"%s\" ...",$1);
+			yywarn(emess);
+			if (sts < 0) {
+			    fprintf(stderr, "Reason: ");
+			    fprintf(stderr, "%s\n", pmErrStr(sts));
+			}
+		    }
+		}
+		optinst		{ endmetgrp(); }
+		;
+
+optinst		: LSQB instancelist RSQB
+		| /* nothing */
+		;
+
+instancelist	: instance
+		| instance instancelist
+		| instance COMMA instancelist
+		;
+
+instance	: NAME		{ addinst($1, 0); }
+		| NUMBER	{ addinst(NULL, $1); }
+		| STRING	{ addinst($1, 0); }
+		;
+
+loggersopt	: LOGGER
+		| /* nothing */
+		;
+
+hostopt		: AT NAME	{ hostname = strdup($2); }
+		| AT HOSTNAME	{ hostname = strdup($2); }
+		| AT URL
+		{
+		    char	*prefix_end;
+		    size_t	prefix_len;
+		    hostname = strdup($2);
+		    prefix_end = strchr(hostname, ':');
+		    if (prefix_end != NULL) {
+			prefix_len = prefix_end - hostname + 1;
+			if (prefix_len == 6 && strncmp(hostname, "local:", prefix_len) == 0)
+			    is_local = 1;
+			else if (prefix_len == 5 && strncmp(hostname, "unix:", prefix_len) == 0)
+			    is_unix = 1;
+			if (is_local || is_unix) {
+			    const char *p;
+			    /*
+			     * Find out is a path was specified.
+			     * Skip any initial path separators.
+			     */
+			    for (p = hostname + prefix_len; *p == __pmPathSeparator(); ++p)
+				;
+			    if (*p != '\0')
+				is_socket_path = 1;
+			}
+		    }
+		}
+		| AT NUMBER
+		{ 
+			/* That MUST be a mistake! */
+			char tb[64];
+			sprintf (tb, "%d", (int)$2);
+			hostname = strdup(tb); 
+		}
+		| AT STRING	{ hostname = strdup($2); }
+		| /* nothing */
+		;
+
+towhom		: PRIMARY	{ pid = PM_LOG_PRIMARY_PID; port = PM_LOG_NO_PORT; }
+		| NUMBER	{ pid = $1; port = PM_LOG_NO_PORT; }
+		| PORT NUMBER	{ pid = PM_LOG_NO_PID; port = $2; }
+		| SOCKET	{ pid = PM_LOG_NO_PID; port = PM_LOG_NO_PORT; }
+		;
+
+tzspec		: LOCAL		{ tztype = TZ_LOCAL; }
+		| LOGGER	{ tztype = TZ_LOGGER; }
+		| STRING		
+		{
+		    tztype = TZ_OTHER;
+		    /* ignore the quotes: skip the leading one and
+		     * clobber the trailing one with a null to
+		     * terminate the string really required.
+		     */
+		    if (tz != NULL)
+			free(tz);
+		    if ((tz = strdup($1)) == NULL) {
+			__pmNoMem("setting up timezone",
+				 strlen($1), PM_FATAL_ERR);
+		    }
+		}
+		;
+
+%%
+
+extern char	*configfile;
+extern int	lineno;
+
+void
+yywarn(char *s)
+{
+    fprintf(stderr, "Warning [%s, line %d]\n",
+	    configfile == NULL ? "<stdin>" : configfile, lineno);
+    if (s != NULL && s[0] != '\0')
+	fprintf(stderr, "%s\n", s);
+}
+
+void
+yyerror(char *s)
+{
+    fprintf(stderr, "Error [%s, line %d]\n",
+	    configfile == NULL ? "<stdin>" : configfile, lineno);
+    if (s != NULL && s[0] != '\0')
+	fprintf(stderr, "%s\n", s);
+
+    skipAhead ();
+    yyclearin;
+    mystate = GLOBAL;
+}
diff --git a/src/pmlc/lex.l b/src/pmlc/lex.l
new file mode 100644
index 0000000..c523a36
--- /dev/null
+++ b/src/pmlc/lex.l
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2014 Red Hat.
+ * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+%{
+#include "pmapi.h"
+#include "./pmlc.h"
+
+extern int eflag;
+
+#ifdef FLEX_SCANNER
+#include "gram.tab.h"
+int pmlcFlexInput (char *, int);
+int lineno = 0;
+#else /* AT&T lex */
+#include "gram.h"
+int lineno = 1;
+#endif
+
+static int
+ctx(int type)
+{
+    if (mystate == GLOBAL)
+        return type;
+    else {
+       yylval.str = yytext;
+       return NAME;
+    }
+}
+
+%}
+
+%option noinput
+%option nounput
+
+%{
+#ifdef FLEX_SCANNER
+#ifndef YY_NO_UNPUT
+#define YY_NO_UNPUT
+#endif
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) (r=pmlcFlexInput(b, ms))
+#else /* AT&T Lex */
+#undef input
+#undef unput
+#undef yywrap
+#endif
+%}
+
+%%
+"["	{ return LSQB; }
+"]"	{ return RSQB; }
+","	{ return COMMA; }
+"{"	{ return LBRACE; }
+"}"	{ return RBRACE; }
+"@"	{ return AT; }
+
+milliseconds?	{ return ctx(MSEC); }
+mandatory	{ return ctx(MANDATORY); }
+advisory	{ return ctx(ADVISORY); }
+timezone	{ return ctx(TIMEZONE); }
+loggers?	{ return ctx(LOGGER); }
+minutes?	{ return ctx(MINUTE); }
+seconds?	{ return ctx(SECOND); }
+connect		{ return ctx(CONNECT); }
+primary		{ return ctx(PRIMARY); }
+status		{ return ctx(STATUS); }
+volume		{ return ctx(VOLUME); }
+flush		{ return ctx(SYNC); }
+every		{ return ctx(EVERY); }
+local		{ return ctx(LOCAL); }
+maybe		{ return ctx(MAYBE); }
+query		{ return ctx(QUERY); }
+hours?		{ return ctx(HOUR); }
+msecs?		{ return ctx(MSEC); }
+mins?		{ return ctx(MINUTE); }
+secs?		{ return ctx(SECOND); }
+help		{ return ctx(HELP); }
+once		{ return ctx(ONCE); }
+port		{ return ctx(PORT); }
+quit		{ return ctx(QUIT); }
+socket		{ return ctx(SOCKET); }
+show		{ return ctx(SHOW); }
+sync		{ return ctx(SYNC); }
+log		{ return ctx(LOG); }
+new		{ return ctx(NEW); }
+off		{ return ctx(OFF); }
+on		{ return ctx(ON); }
+qa		{ return ctx(QA); }
+at		{ return ctx(AT); }
+h		{ return ctx(HELP); }
+q		{ return ctx(QUIT); }
+\?		{ return ctx(HELP); }
+
+unix:[A-Za-z0-9_.-/]*\*		{ yylval.str = yytext; return URL; }
+unix:[A-Za-z0-9_.-/]*		{ yylval.str = yytext; return URL; }
+local:[A-Za-z0-9_.-/]*\*	{ yylval.str = yytext; return URL; }
+local:[A-Za-z0-9_.-/]*		{ yylval.str = yytext; return URL; }
+
+[A-Za-z][A-Za-z0-9_.]*	{ yylval.str = yytext; return NAME; }
+
+[A-Za-z][A-Za-z0-9_.-]* { yylval.str = yytext; return HOSTNAME; }
+
+\"[^\"\n][^\"\n]*\"	{ /* strip quotes before returing */
+			    yytext[strlen(yytext)-1] = '\0';
+			    yylval.str = yytext+1; 
+			    return STRING; 
+    	                }
+
+[0-9]+			{ yylval.lval = atol(yytext); return NUMBER; }
+
+\#[^\n]*		{ }
+\n			{ if (!(mystate & INSPECLIST)) return EOL; }
+
+[ \r\t]+		{ }
+
+.			{
+			    char emess[160];
+			    sprintf(emess, "Unexpected character '%c'", 
+				    yytext[0]);
+			    yyerror(emess);
+			}
+%%
+
+#ifdef FLEX_SCANNER
+static int in = '\n';
+
+int yywrap(void)
+{
+    return in == EOF;
+}
+
+int
+pmlcFlexInput (char * buf, int ms)
+{
+    extern int iflag;
+
+    if ( in == '\n' ) {
+	lineno++;
+	if ( iflag ) {
+	    if ( mystate == GLOBAL ) 
+		printf ("pmlc> ");
+	    else
+		printf ("? ");
+	    fflush (stdout);
+	}
+    }
+
+    if (ms > 0 ) {
+	if ( (in = fgetc (yyin)) != EOF ) {
+	    buf[0] = in & 0xFFU;
+	    ms = 1;
+	    if ( eflag ) {
+		putchar (in);
+		fflush (stdout);
+	    }
+	} else {
+	    ms = 0;
+	}
+    }
+
+    return (ms);
+}
+
+void
+skipAhead (void) 
+{
+    if ( mystate & INSPECLIST ) {
+	while ( in != '}' && in != EOF ) {
+	    char c;
+	    pmlcFlexInput (&c, 1);
+	}
+	mystate = GLOBAL;
+    }
+
+    while ( (in != '\n') && (in != EOF) ) {
+	char c;
+	pmlcFlexInput (&c, 1);
+    }
+}
+
+#else
+static char	lastc;
+static char	peekc = '\0';
+
+char input(void)
+{
+    int		get;
+    static int	first = 1;
+
+    if (peekc) {
+	lastc = peekc;
+	peekc = '\0';
+	return lastc;
+    }
+	
+    if (lastc == '\n' || first) {
+	extern int iflag;
+	if (iflag) {
+	    if (mystate == GLOBAL)
+		printf("pmlc> ");
+	    else
+		printf("? ");
+	    fflush(stdout);
+	}
+    	if (first)
+    	    first = 0;
+    	else
+	    lineno++;
+    }
+    else if (lastc == '\0')
+	return lastc;
+
+    get = getchar();
+    if (get == EOF)
+	lastc = '\0';
+    else {
+	lastc = get;
+	if (eflag) {
+	    putchar(lastc);
+	    fflush(stdout);
+	}
+    }
+
+    return lastc;
+}
+
+void unput(char c)
+{
+    peekc = c;
+}
+
+void
+skipAhead (void)
+{
+    int c = lastc;
+
+    for ( ; ; ) {
+	if (c == '\0')
+	    break;
+	if ((mystate == GLOBAL || (mystate & INSPEC)) && c == '\n')
+	    break;
+	if ((mystate & INSPECLIST) && c == '}')
+	    break;
+	c = input();
+    }
+}
+
+int yywrap(void)
+{
+    return lastc == '\0';
+}
+#endif
diff --git a/src/pmlc/pmlc.c b/src/pmlc/pmlc.c
new file mode 100644
index 0000000..cb477fb
--- /dev/null
+++ b/src/pmlc/pmlc.c
@@ -0,0 +1,398 @@
+/*
+ * Copyright (c) 2014 Red Hat.
+ * Copyright (c) 1995-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "pmapi.h"
+#include "impl.h"
+#include "pmlc.h"
+#include "gram.h"
+
+char		*configfile;
+__pmLogCtl	logctl;
+int		parse_done;
+int		pid = PM_LOG_NO_PID;
+int		port = PM_LOG_NO_PORT;
+int		is_unix;	/* host spec is a unix: url. */
+int		is_local;	/* host spec is a local: url. */
+int		is_socket_path; /* host spec is a url with a path. */
+char 		*tz;		/* for -Z timezone */
+int		tztype = TZ_LOCAL;	/* timezone for status cmd */
+int		eflag;
+int		iflag;
+
+extern int	parse_stmt;
+extern int	tzchange;
+
+static char title[] = "Performance Co-Pilot Logger Control (pmlc), Version %s\n\n%s\n";
+static char menu[] =
+"pmlc commands\n\n"
+"  show loggers [@<host>]             display <pid>s of running pmloggers\n"
+"  connect _logger_id [@<host>]       connect to designated pmlogger\n"
+"  status                             information about connected pmlogger\n"
+"  query metric-list                  show logging state of metrics\n"
+"  new volume                         start a new log volume\n"
+"\n"
+"  log { mandatory | advisory } on <interval> _metric-list\n"
+"  log { mandatory | advisory } off _metric-list\n"
+"  log mandatory maybe _metric-list\n"
+"\n"
+"  timezone local|logger|'<timezone>' change reporting timezone\n"
+"  help                               print this help message\n"
+"  quit                               exit from pmlc\n"
+"\n"
+"  _logger_id   is  primary | <pid> | port <n>\n"
+"  _metric-list is  _metric-spec | { _metric-spec ... }\n"
+"  _metric-spec is  <metric-name> | <metric-name> [ <instance> ... ]\n";
+
+static int overrides(int, pmOptions *);
+
+static pmLongOptions longopts[] = {
+    PMAPI_OPTIONS_HEADER("Options"),
+    PMOPT_DEBUG,
+    { "echo", 0, 'e', 0, "echo input" },
+    { "host", 1, 'h', "HOST", "connect to pmlogger using host specification" },
+    { "interactive", 0, 'i', 0, "be interactive and prompt" },
+    PMOPT_NAMESPACE,
+    { "primary", 0, 'P', 0, "connect to primary pmlogger" },
+    { "port", 1, 'p', "N", "connect to pmlogger on this TCP/IP port" },
+    PMOPT_TIMEZONE,
+    { "logzone", 0, 'z', 0, "set reporting timezone to local time for pmlogger" },
+    PMOPT_HELP,
+    PMAPI_OPTIONS_END
+};
+
+static pmOptions opts = {
+    .short_options = "D:eh:in:Pp:zZ:?",
+    .long_options = longopts,
+    .short_usage = "[options] [pid]",
+    .override = overrides,
+};
+
+static int
+overrides(int opt, pmOptions *opts)
+{
+    if (opt == 'h' || opt == 'p')
+	return 1;
+    return 0;
+}
+
+int
+main(int argc, char **argv)
+{
+    int			c;
+    int			sts = 0;	/* initialize to pander to gcc */
+    char		*host = NULL;
+    char		*endnum;
+    int			primary;
+    size_t		prefix_len;
+    char		*prefix_end;
+
+    iflag = isatty(0);
+
+    while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
+	switch (c) {
+
+	case 'e':		/* echo input */
+	    eflag++;
+	    break;
+
+	case 'h':		/* hostspec */
+	    /*
+	     * We need to know if a socket path has been specified.
+	     */
+	    host = opts.optarg;
+	    prefix_end = strchr(host, ':');
+	    if (prefix_end != NULL) {
+		prefix_len = prefix_end - host + 1;
+		if (prefix_len == 6 && strncmp(host, "local:", prefix_len) == 0)
+		    is_local = 1;
+		else if (prefix_len == 5 && strncmp(host, "unix:", prefix_len) == 0)
+		    is_unix = 1;
+		if (is_local || is_unix) {
+		    const char *p;
+		    /*
+		     * Find out is a path was specified.
+		     * Skip any initial path separators.
+		     */
+		    for (p = host + prefix_len; *p == __pmPathSeparator(); ++p)
+			;
+		    if (*p != '\0')
+			is_socket_path = 1;
+		}
+	    }
+	    break;
+
+	case 'i':		/* be interactive */
+	    iflag++;
+	    break;
+
+	case 'P':		/* connect to primary logger */
+	    if (port != PM_LOG_NO_PORT || (is_unix && is_socket_path)) {
+		pmprintf("%s: at most one of -P, -p, unix socket, or PID may be specified\n",
+			pmProgname);
+		opts.errors++;
+	    } else {
+		port = PM_LOG_PRIMARY_PORT;
+	    }
+	    break;
+
+	case 'p':		/* connect via port */
+	    if (port != PM_LOG_NO_PORT || is_unix) {
+		pmprintf("%s: at most one of -P, -p, unix socket, or PID may be specified\n",
+			pmProgname);
+		opts.errors++;
+	    } else {
+		port = (int)strtol(opts.optarg, &endnum, 10);
+		if (*endnum != '\0' || port <= PM_LOG_PRIMARY_PORT) {
+		    pmprintf("%s: port must be numeric and greater than %d\n",
+			    pmProgname, PM_LOG_PRIMARY_PORT);
+		    opts.errors++;
+		}
+	    }
+	    break;
+	}
+    }
+
+    if (opts.optind < argc - 1)
+	opts.errors++;
+    else if (opts.optind == argc - 1) {
+	/* pid was specified */
+	if (port != PM_LOG_NO_PORT || (is_unix && is_socket_path)) {
+	    pmprintf("%s: at most one of -P, -p, unix socket, or PID may be specified\n",
+		    pmProgname);
+	    opts.errors++;
+	}
+	else {
+	    pid = (int)strtol(argv[opts.optind], &endnum, 10);
+	    if (*endnum != '\0' || pid <= PM_LOG_PRIMARY_PID) {
+		pmprintf("%s: PID must be a numeric process ID and greater than %d\n",
+			pmProgname, PM_LOG_PRIMARY_PID);
+		opts.errors++;
+	    }
+	}
+    }
+
+    if (!opts.errors && host && pid == PM_LOG_NO_PID &&
+	port == PM_LOG_NO_PORT && !is_socket_path) {
+	pmprintf("%s: -h may not be used without -P or -p or a socket path or a PID\n",
+		pmProgname);
+	opts.errors++;
+    }
+
+    if (opts.errors) {
+	pmUsageMessage(&opts);
+	exit(1);
+    }
+
+    if (opts.tzflag) {
+	tztype = TZ_LOGGER;
+	tzchange = 1;
+    } else if (opts.timezone) {
+	tz = opts.timezone;
+	tztype = TZ_OTHER;
+	tzchange = 1;
+    }
+
+    if (host == NULL)
+	host = "local:";
+
+    primary = 0;
+    if (port == PM_LOG_PRIMARY_PORT || pid == PM_LOG_PRIMARY_PID)
+	primary = 1;
+
+    if (pid != PM_LOG_NO_PID || port != PM_LOG_NO_PORT || is_socket_path)
+	sts = ConnectLogger(host, &pid, &port);
+
+    if (iflag)
+	printf(title, PCP_VERSION, menu);
+
+    if (pid != PM_LOG_NO_PID || port != PM_LOG_NO_PORT || is_socket_path) {
+	if (sts < 0) {
+	    if (primary) {
+		fprintf(stderr, "Unable to connect to primary pmlogger at %s: ",
+			host);
+		if (still_connected(sts))
+		    fprintf(stderr, "%s\n", pmErrStr(sts));
+	    }
+	    else if (is_socket_path) {
+		fprintf(stderr, "Unable to connect to pmlogger via the local socket at %s: ",
+			host);
+		if (still_connected(sts))
+		    fprintf(stderr, "%s\n", pmErrStr(sts));
+	    }
+	    else if (port != PM_LOG_NO_PORT) {
+		fprintf(stderr, "Unable to connect to pmlogger on port %d at %s: ",
+			port, host);
+		if (still_connected(sts))
+		    fprintf(stderr, "%s\n", pmErrStr(sts));
+	    }
+	    else {
+		fprintf(stderr, "Unable to connect to pmlogger pid %d at %s: ",
+			pid, host);
+		if (still_connected(sts))
+		    fprintf(stderr, "%s\n", pmErrStr(sts));
+	    }
+	}
+	else {
+	    if (primary)
+		printf("Connected to primary pmlogger at %s\n", host);
+	    else if (is_socket_path)
+		printf("Connected to pmlogger via local socket at %s\n", host);
+	    else if (port != PM_LOG_NO_PORT)
+		printf("Connected to pmlogger on port %d at %s\n", port, host);
+	    else
+		printf("Connected to pmlogger pid %d at %s\n", pid, host);
+	}
+    }
+
+    for ( ; ; ) {
+	char		*realhost;
+
+	is_local = 0;
+	is_unix = 0;
+	is_socket_path = 0;
+	parse_stmt = -1;
+	metric_cnt = 0;
+	yyparse();
+	if (yywrap()) {
+	    if (iflag)
+		putchar('\n');
+	    break;
+	}
+	if (metric_cnt < 0)
+	    continue;
+#ifdef PCP_DEBUG
+	if (pmDebug & DBG_TRACE_APPL1)
+	    printf("stmt=%d, state=%d, control=%d, hostspec=%s, pid=%d, port=%d\n",
+		   parse_stmt, state, control, hostname, pid, port);
+#endif
+
+	realhost = (hostname == NULL) ? host : hostname;
+	switch (parse_stmt) {
+
+	    case SHOW:
+		ShowLoggers(realhost);
+		break;
+
+	    case CONNECT:
+		/* The unix: url requres either 'primary', a pid or a socket path. */
+		if (is_unix && pid == PM_LOG_NO_PID && ! is_socket_path) {
+		    fprintf(stderr, "The 'unix:' url requires either 'primary', a pid or a socket path");
+		    if (still_connected(sts))
+			fprintf(stderr, "\n");
+		    break;
+		}
+		/* The local: url requres either 'primary', a pid a port or a socket path. */
+		if (is_local && pid == PM_LOG_NO_PID && port == PM_LOG_NO_PORT && ! is_socket_path) {
+		    fprintf(stderr, "The 'local:' url requires either 'primary', a pid, a port or a socket path");
+		    if (still_connected(sts))
+			fprintf(stderr, "\n");
+		    break;
+		}
+		primary = 0;
+		if (port == PM_LOG_PRIMARY_PORT || pid == PM_LOG_PRIMARY_PID)
+		    primary = 1;
+		if ((sts = ConnectLogger(realhost, &pid, &port)) < 0) {
+		    if (primary) {
+			fprintf(stderr, "Unable to connect to primary pmlogger at %s: ",
+				realhost);
+		    }
+		    else if (is_socket_path) {
+			fprintf(stderr, "Unable to connect to pmlogger via local socket at %s: ",
+				realhost);
+		    }
+		    else if (port != PM_LOG_NO_PORT) {
+			fprintf(stderr, "Unable to connect to pmlogger on port %d at %s: ",
+				port, realhost);
+		    }
+		    else {
+			fprintf(stderr, "Unable to connect to pmlogger pid %d at %s: ",
+				pid, realhost);
+		    }
+		    if (still_connected(sts))
+			fprintf(stderr, "%s\n", pmErrStr(sts));
+		}
+		else
+		    /* if the timezone is "logger time", it has changed
+		     * because the logger may be in a different zone
+		     * (note that tzchange may already be set (e.g. -Z and
+		     * this connect is the first).
+		     */
+		    tzchange |= (tztype == TZ_LOGGER);
+		break;		
+
+	    case HELP:
+		puts(menu);
+		break;
+
+	    case LOG:
+		if (state == PM_LOG_ENQUIRE) {
+		    Query();
+		    break;
+		}
+		if (logfreq == -1)
+		    logfreq = 0;
+		if (state == PM_LOG_ON) {
+		    if (logfreq < 0) {
+fprintf(stderr, "Logging delta (%d msec) must be positive\n", logfreq);
+			break;
+		    }
+		    else if (logfreq > PMLC_MAX_DELTA) {
+fprintf(stderr, "Logging delta (%d msec) cannot be bigger than %d msec\n", logfreq, PMLC_MAX_DELTA);
+			break;
+		    }
+		}
+		LogCtl(control, state, logfreq);
+		break;
+
+	    case QUIT:
+		printf("Goodbye\n");
+		DisconnectLogger();
+		exit(0);
+		break;
+
+	    case STATUS:
+		Status(pid, primary);
+		break;
+
+	    case NEW:
+		NewVolume();
+		break;
+
+	    case TIMEZONE:
+		tzchange = 1;
+		break;
+
+	    case SYNC:
+		Sync();
+		break;
+
+	    case QA:
+		if (qa_case == 0)
+		    fprintf(stderr, "QA Test Case deactivated\n");
+		else
+		    fprintf(stderr, "QA Test Case #%d activated\n", qa_case);
+		Qa();
+	}
+
+	if (hostname != NULL) {
+	    free(hostname);
+	    hostname = NULL;
+	}
+
+    }
+
+    DisconnectLogger();
+    exit(0);
+}
diff --git a/src/pmlc/pmlc.h b/src/pmlc/pmlc.h
new file mode 100644
index 0000000..83fd38a
--- /dev/null
+++ b/src/pmlc/pmlc.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2014 Red Hat.
+ * Copyright (c) 2000,2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+#ifndef _PMLC_H
+#define _PMLC_H
+
+/* config file parser states (bit field values) */
+#define GLOBAL  	0
+#define INSPEC  	1
+#define INSPECLIST	2
+
+/* timezone to use when printing status */
+#define TZ_LOCAL	0
+#define TZ_LOGGER	1
+#define TZ_OTHER	2
+
+/* timezone variables */
+extern char	*tz;			/* for -Z timezone */
+extern int	tztype;			/* timezone for status cmd */
+
+/* parse summary back from yacc to main */
+extern char	*hostname;
+extern int	state;
+extern int	control;
+extern int	mystate;
+extern int	qa_case;
+
+extern void yyerror(char *);
+extern void yywarn(char *);
+extern int yywrap(void);
+extern int yylex(void);
+extern void skipAhead (void);
+extern int yyparse(void);
+extern void beginmetrics(void);
+extern void endmetrics(void);
+extern void beginmetgrp(void);
+extern void endmetgrp(void);
+extern void addmetric(const char *);
+extern void addinst(char *, int);
+extern int connected(void);
+extern int still_connected(int);
+extern int metric_cnt;
+#ifdef PCP_DEBUG
+extern void dumpmetrics(FILE *);
+#endif
+
+/* connection routines */
+extern int ConnectLogger(char *, int *, int *);
+extern void DisconnectLogger(void);
+extern int ConnectPMCD(void);
+
+/* command routines */
+extern int logfreq;
+extern void ShowLoggers(char *);
+extern void Query(void);
+extern void LogCtl(int, int, int);
+extern void Status(int, int);
+extern void NewVolume(void);
+extern void Sync(void);
+extern void Qa(void);
+
+/* information about an instance domain */
+typedef struct {
+    pmInDom	indom;
+    int		n_insts;
+    int		*inst;
+    char	**name;
+} indom_t;
+
+/* a metric plus an optional list of instances */
+typedef struct {
+    char		*name;
+    pmID		pmid;
+    int			indom;		/* index of indom (or -1) */
+    int			n_insts;	/* number of insts for this metric */
+    int			*inst;		/* list of insts for this metric */
+    struct {
+	unsigned	selected : 1,	/* apply instances to metric? */
+			new : 1,	/* new in current PMNS subtree */
+			has_insts : 1;	/* free inst list? */
+    } status;
+} metric_t;
+
+#endif /* _PMLC_H */
diff --git a/src/pmlc/util.c b/src/pmlc/util.c
new file mode 100644
index 0000000..30e3881
--- /dev/null
+++ b/src/pmlc/util.c
@@ -0,0 +1,546 @@
+/*
+ * Copyright (c) 1995-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "pmapi.h"
+#include "impl.h"
+#include "pmlc.h"
+
+/* this pmResult is built after parsing the current statement.  The action
+ * routines (Status, LogReq) send it to the logger as a request.
+ */
+pmResult	*logreq = NULL;
+int		sz_logreq = 0;
+int		n_logreq = 0;
+
+int		n_metrics = 0;
+int		sz_metrics = 0;
+metric_t	*metric = NULL;
+
+int		n_indoms = 0;
+int		sz_indoms = 0;
+indom_t		*indom = NULL;
+
+void
+freemetrics(void)
+{
+    int		i;
+    metric_t	*mp;
+
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	free(mp->name);
+	if (mp->status.has_insts && mp->inst != NULL)
+	    free(mp->inst);
+    }
+    n_metrics = 0;
+    /* keep the array around for re-use */
+}
+
+void
+freeindoms(void)
+{
+    int		i;
+    indom_t	*ip;
+
+    for (i = 0, ip = indom; i < n_indoms; i++, ip++) {
+	free(ip->inst);
+	free(ip->name);
+    }
+    free(indom);
+    sz_indoms = n_indoms = 0;
+    indom = NULL;
+}
+
+/* Return a pointer to the specified instance domain, adding it to the list if
+ * it is not already present.  Returns < 0 on error.
+ */
+int
+addindom(pmInDom newindom, int *resptr)
+{
+    int		i;
+    indom_t	*ip;
+
+    for (i = 0; i < n_indoms; i++)
+	if (newindom == indom[i].indom) {
+	    *resptr = i;
+	    return 0;
+	}
+
+    *resptr = -1;			/* in case of errors */
+    if (n_indoms >= sz_indoms) {
+	sz_indoms += 4;
+	i = sz_indoms * sizeof(indom_t);
+	if ((indom = (indom_t *)realloc(indom, i)) == NULL) {
+	    __pmNoMem("expanding instance domain array", i, PM_FATAL_ERR);
+	}
+    }
+    ip = &indom[n_indoms];
+    ip->inst = NULL;
+    ip->name = NULL;
+
+    if ((i = pmGetInDom(newindom, &ip->inst, &ip->name)) < 0) {
+	*resptr = -1;
+	return i;
+    }
+    ip->indom = newindom;
+    ip->n_insts = i;
+    *resptr = n_indoms;
+    n_indoms++;
+    return 0;
+}
+
+int		metric_cnt;		/* status of addmetric operation(s) */
+static int	had_insts;		/* new metric(s) had instances specified */
+static int	n_selected;		/* number of metrics selected */
+static int	first_inst;		/* check consistency of new metrics' InDoms */
+
+void
+beginmetrics(void)
+{
+    metric_cnt = 0;
+    fflush(stdout);
+    fflush(stderr);
+    freemetrics();
+}
+
+void
+beginmetgrp(void)
+{
+    int		i;
+    metric_t	*mp;
+
+    had_insts = 0;
+    n_selected = 0;
+    first_inst = 1;
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	mp->status.selected = 0;
+	mp->status.new = 0;
+    }
+}
+
+/* Perform any instance domain fixups and error checks required for the latest
+ * metrics added.
+ */
+void
+endmetgrp(void)
+{
+    int		i;
+    metric_t	*mp;
+
+    if (n_metrics <= 0) {
+	if (metric_cnt >= 0)
+	    metric_cnt = PM_ERR_PMID;
+	return;
+    }
+
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	if (!mp->status.selected)
+	    continue;
+
+	/* just added metric, no instances => use all instances */
+	if (mp->status.new) {
+	    if (mp->indom != -1 && !had_insts) {
+		mp->n_insts = indom[mp->indom].n_insts;
+		mp->inst = indom[mp->indom].inst;
+		mp->status.has_insts = 0;
+	    }
+	}
+	/* metric was there already */
+	else
+	    if (mp->indom == -1)
+		fprintf(stderr, "Warning: %s has already been specified\n", mp->name);
+	    else
+		/* if metric had specific instances */
+		if (mp->status.has_insts) {
+		    if (!had_insts) {
+			fprintf(stderr,
+				"Warning: %s had instance(s) specified previously.\n"
+				"         Using all instances since none specified this time\n",
+				mp->name);
+			if (mp->inst != NULL)
+			    free(mp->inst);
+			mp->n_insts = indom[mp->indom].n_insts;
+			mp->inst = indom[mp->indom].inst;
+			mp->status.has_insts = 0;
+		    }
+		}
+		/* metric had "use all instances" */
+		else
+		    if (!had_insts)
+			fprintf(stderr,
+				"Warning: already using all instances for %s\n",
+				mp->name);
+		    else
+			fprintf(stderr,
+				"Warning: instance(s) specified for %s\n"
+				"         (already using all instances)\n",
+				mp->name);
+    }
+}
+
+void
+endmetrics(void)
+{
+    int			i, j, need;
+    metric_t		*mp;
+    pmValueSet		*vsp;
+
+    if (metric_cnt < 0) {
+	if (connected())
+	    fputs("Logging statement ignored due to error(s)\n", stderr);
+	goto done;
+    }
+
+#ifdef PCP_DEBUG
+    if (pmDebug & DBG_TRACE_APPL0)
+	dumpmetrics(stdout);
+#endif
+
+    /* free any old values in the reusable pmResult skeleton */
+    if (n_logreq) {
+	for (i = 0; i < n_logreq; i++)
+	    free(logreq->vset[i]);
+	n_logreq = 0;
+    }
+
+    /* build a result from the metrics and instances in the metric array */
+    if (n_metrics > sz_logreq) {
+	if (sz_logreq)
+	    free(logreq);
+	need = sizeof(pmResult) + (n_metrics - 1) * sizeof(pmValueSet *);
+	/* - 1 because a pmResult already contains one pmValueSet ptr */
+	if ((logreq = (pmResult *)malloc(need)) == NULL) {
+	    __pmNoMem("building result to send", need, PM_FATAL_ERR);
+	}
+	sz_logreq = n_metrics;
+    }
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	need = sizeof(pmValueSet);
+	/* pmValueSet contains one pmValue, allow for more if > 1 inst */
+	if (mp->status.has_insts && mp->n_insts > 1)
+	    need += (mp->n_insts - 1) * sizeof(pmValue);
+	if ((vsp = (pmValueSet *)malloc(need)) == NULL) {
+	    __pmNoMem("building result value set", need , PM_FATAL_ERR);
+	}
+	logreq->vset[i] = vsp;
+	vsp->pmid = mp->pmid;
+	if (mp->indom == -1)
+	    vsp->numval = 1;
+	else
+	    vsp->numval = mp->status.has_insts ? mp->n_insts : 0;
+	vsp->valfmt = PM_VAL_INSITU;
+	if (mp->status.has_insts)
+	    for (j = 0; j < vsp->numval; j++)
+		vsp->vlist[j].inst = mp->inst[j];
+	else
+	    vsp->vlist[0].inst = PM_IN_NULL;
+    }
+    logreq->numpmid = n_metrics;
+    n_logreq = n_metrics;
+
+done:
+    fflush(stderr);
+    fflush(stdout);
+}
+
+/* Add a metric to the metric list. Sets metric_cnt to < 0 on fatal error. */
+
+void
+addmetric(const char *name)
+{
+    int		i;
+    pmID	pmid;
+    int		need;
+    metric_t	*mp;
+    pmDesc	desc;
+    int		sts;
+
+    if (metric_cnt < 0)
+	return;
+
+    /* Cast const away as pmLookUpName should not modify name */
+    if ((sts = pmLookupName(1, (char **)&name, &pmid)) < 0) {
+	metric_cnt = sts;
+	return;
+    }
+
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++)
+	if (pmid == mp->pmid)
+	    break;
+
+    if (i >= n_metrics) {
+	/* expand metric array if necessary */
+	if (n_metrics >= sz_metrics) {
+	    sz_metrics += 4;
+	    need = sz_metrics * sizeof(metric_t);
+	    if ((metric = (metric_t *)realloc(metric, need)) == NULL) {
+		__pmNoMem("expanding metric array", need, PM_FATAL_ERR);
+	    }
+	}
+	mp = &metric[i];
+	mp->status.new = 1;
+    }
+    mp->status.selected = 1;
+    n_selected++;
+    if (i < n_metrics)			/* already have this metric */
+	return;
+
+    if ((sts = pmLookupDesc(pmid, &desc)) == PM_ERR_PMID
+	|| desc.type == PM_TYPE_NOSUPPORT) {
+	/*
+	 * Name is bad or descriptor is not available ...
+	 * this is not fatal, but need to back off a little
+	 */
+	n_selected--;
+	return;
+    }
+    if (sts < 0) {
+	/* other errors are more serious */
+	metric_cnt = sts;
+	return;
+    }
+    if (desc.indom == PM_INDOM_NULL)
+	i = -1;
+    else
+	if ((metric_cnt = addindom(desc.indom, &i)) < 0)
+	    return;
+
+    mp->name = strdup(name);
+    mp->pmid = pmid;
+    mp->indom = i;
+    mp->n_insts = 0;
+    mp->inst = NULL;
+    mp->status.has_insts = 0;
+    metric_cnt = ++n_metrics;
+    return;
+}
+
+/* Add an instance to the selected metric(s) on the metric list.
+ * If name is NULL, use instance number in inst.
+ * Check that
+ *    - the last group of metrics added have the same pmInDom
+ *    - the specified instance exists in the metrics' instance domain.
+ */
+void
+addinst(char *name, int instid)
+{
+    metric_t	*mp, *first_mp;
+    indom_t	*ip;
+    int		m, i, j, need;
+    int		inst;
+    static int	done_inst_msg = 0;
+
+    /* don't try to add instances if one more metrics were erroneous */
+    if (metric_cnt < 0)
+	return;
+
+    had_insts = 1;
+
+    /* Find the first selected metric */
+    for (m = 0, mp = metric; m < n_metrics; m++, mp++)
+	if (mp->status.selected)
+	    break;
+#ifdef PCP_DEBUG
+    if (m >= n_metrics) {
+	fprintf(stderr, "Ark! No metrics selected for addinst(%s)\n", name);
+	abort();
+    }
+#endif
+    first_mp = mp;
+
+    if (first_inst) {
+	/* check that the first metric doesn't have PM_INDOM_NULL */
+	if (mp->indom == -1) {
+	    metric_cnt = PM_ERR_INDOM;
+	    fprintf(stderr, "%s has no instance domain but an instance was specified\n",
+		    mp->name);
+	    return;
+	}
+
+	/* check that all of the metrics have the same instance domain */
+	if (n_selected > 1) {
+	    i = 0;
+	    for (i++, mp++; m < n_metrics; m++, mp++) {
+		if (!mp->status.selected)
+		    continue;
+
+		/* check pointers to indoms; PM_INDOM_NULL has -1 */
+		if (first_mp->indom != mp->indom) {
+		    if (i++ == 0) {
+			fprintf(stderr,
+				"The instance domains for the following metrics clash with %s:\n",
+				first_mp->name);
+			metric_cnt = PM_ERR_INDOM;
+		    }
+		    if (i < 5) {		/* elide any domain errors after this */
+			fputs(mp->name, stderr);
+			putc('\n', stderr);
+		    }
+		    else {
+			fputs("(etc.)\n", stderr);
+			break;
+		    }
+		}
+	    }
+	    if (i)
+		return;
+	}
+	first_inst = 0;
+    }
+
+    mp = first_mp;			/* go back to first selected metric */
+    ip = &indom[mp->indom];
+    for (i = 0; i < ip->n_insts; i++)
+	if (name != NULL) {
+	    if (strcasecmp(name, ip->name[i]) == 0)
+		break;
+	}
+	else
+	    if (instid == ip->inst[i])
+		break;
+
+    for ( ; m < n_metrics; m++, mp++) {
+	if (!mp->status.selected)
+	    continue;
+
+	/* check that metric with explicit instances has the specified inst.
+	 * For those metrics that specify "all instances" an instance not there yet
+	 * is OK (but generates a warning) since we don't need to give pmlogger any
+	 * instance ids.
+	 * For metrics with specific instances, an unknown instance is an error
+	 * since the instance id can't be given to pmlogger.
+	 */
+	if (i >= ip->n_insts) {
+	    if (mp->status.has_insts || mp->status.new) {
+		metric_cnt = PM_ERR_INST;
+		if (name != NULL)
+		    fprintf(stderr, "%s currently has no instance named %s\n", mp->name, name);
+		else
+		    fprintf(stderr, "%s currently has no instance number %d\n", mp->name, instid);
+		if (!done_inst_msg) {
+		    fputs("    - you may only specify metric instances active now.  However if no\n"
+			  "      instances are specified, pmlogger will use all of the instances\n"
+			  "      available at the time the metric is logged\n",
+			  stderr);
+		    done_inst_msg = 1;
+		}
+	    }
+	    /* for an old metric specifying all instances warn if the specified
+	     * instance is not currently in the instance domain.
+	     */	    
+	    else {
+		if (name != NULL)
+		    fprintf(stderr,
+			    "Warning: instance %s not currently in %s's instance domain\n",
+			    name, mp->name);
+		else
+		    fprintf(stderr,
+			    "Warning: instance %d not currently in %s's instance domain\n",
+			    instid, mp->name);
+		fputs("         (getting all instances anyway)\n", stderr);
+	    }
+	    continue;
+	}
+	inst = ip->inst[i];
+
+	/* check that we don't already have the same instance */
+	for (j = 0; j < mp->n_insts; j++)
+	    if (inst == mp->inst[j])
+		break;
+
+	if (j < mp->n_insts) {		/* already have inst */
+	    if (mp->status.has_insts) {
+		if (name != NULL) {
+		    fprintf(stderr,
+			    "Warning: instance %s already specified for %s\n",
+			    name, mp->name);
+		}
+		else {
+		    fprintf(stderr,
+			    "Warning: instance %d already specified for %s\n",
+			    instid, mp->name);
+		}
+	    }
+
+	    /* if the metric had no insts of its own, (it specifies all insts)
+	     * just do nothing.  endmetgrp() will print a single message which
+	     * is better than having, one printed for each instance specified.
+	     */
+	    continue;
+	}
+
+	else {				/* don't have this inst */
+	    /* add inst for new metric or old metric with explicit insts */
+	    if (mp->status.new || mp->status.has_insts) {
+		j = mp->n_insts++;
+		if (j == 0)
+		    mp->status.has_insts = 1;
+		need = mp->n_insts * sizeof(int);
+		if ((mp->inst = (int *)realloc(mp->inst, need)) == NULL) {
+		    if (name != NULL)
+			fprintf(stderr, "%s inst %s: ", mp->name, name);
+		    else
+			fprintf(stderr, "%s inst %d: ", mp->name, instid);
+		    __pmNoMem("expanding instance array", need, PM_FATAL_ERR);
+		}
+		mp->inst[j] = inst;
+	    }
+	}
+    }
+}
+
+#ifdef PCP_DEBUG
+void
+dumpmetrics(FILE *f)
+{
+    int		i, j, k;
+    metric_t	*mp;
+
+    fprintf(f, "     Inst  Inst Name\n");
+    fprintf(f, "    ====== =========\n");
+
+    for (i = 0, mp = metric; i < n_metrics; i++, mp++) {
+	fprintf(f, "%s\n", mp->name);
+	if (mp->indom == -1)
+	    fprintf(f, "           singular instance\n");
+	else {
+	    indom_t	*ip = &indom[mp->indom];		    
+	    int		*inst = ip->inst;
+	    char	**name = ip->name;
+	    int		n_insts = ip->n_insts;
+
+	    /* No instances specified, use them all */
+	    if (mp->n_insts == 0)
+		for (j = 0; j < n_insts; j++)
+		    fprintf(f, "    %6d %s\n", inst[j], name[j]);
+	    else
+		for (j = 0; j < mp->n_insts; j++) {
+		    int		m_inst = mp->inst[j];;
+
+		    for (k = 0; k < n_insts; k++)
+			if (m_inst == inst[k])
+			    break;
+		    if (k < n_insts)
+			fprintf(f, "    %6d %s\n", inst[k], name[k]);
+		    else
+			fprintf(f, "    KAPOWIE! inst %d not found\n", m_inst);
+		}
+	}
+	putc('\n', f);
+    }
+}
+#endif