From ddf06b4f35bc9dd53c4e22e5517bced7104cc7af Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Sat, 26 Jun 2021 04:19:37 +0000 Subject: [PATCH] import pcp-5.3.1-2.el8 --- SOURCES/redhat-bugzilla-1947989.patch | 849 +++++++++ SOURCES/redhat-bugzilla-1974266.patch | 2478 +++++++++++++++++++++++++ SPECS/pcp.spec | 11 +- 3 files changed, 3337 insertions(+), 1 deletion(-) create mode 100644 SOURCES/redhat-bugzilla-1947989.patch create mode 100644 SOURCES/redhat-bugzilla-1974266.patch diff --git a/SOURCES/redhat-bugzilla-1947989.patch b/SOURCES/redhat-bugzilla-1947989.patch new file mode 100644 index 0000000..afe4717 --- /dev/null +++ b/SOURCES/redhat-bugzilla-1947989.patch @@ -0,0 +1,849 @@ +commit 2bad6aef10339f000f7cb578108db5ee80bd640c +Author: Mark Goodwin +Date: Wed Jun 9 17:04:33 2021 +1000 + + pmproxy: add mutex for client req lists, fix https/tls support, QA + + Add a new mutext to struct proxy and use it to protect parallel + multithreaded updates to the proxy->first client list. + + Also use the same mutext to protect updates to the pending_writes + client list and avoid the doubly linked list corruption that was + causing parallel https/tls requests to get stuck spinning in + flush_secure_module(), as reported in BZ#1947989. + + qa/1457 is extensively updated to test parallel http, https/tls + (and combinations of http and https/tls) RESTAPI calls. Previously + it only tested a single https/tls call. + + With these changes, parallel https/tls RESTAPI requests from the + grafana-pcp datasource to pmproxy now work correctly whereas previously + pmproxy would hang/spin. + + Resolves: RHBZ#1947989 - pmproxy hangs and consume 100% cpu if the + redis datasource is configured with TLS. + + Related: https://github.com/performancecopilot/pcp/issues/1311 + +diff --git a/qa/1457 b/qa/1457 +index 94969f6e0..8bf395944 100755 +--- a/qa/1457 ++++ b/qa/1457 +@@ -2,7 +2,7 @@ + # PCP QA Test No. 1457 + # Exercise HTTPS access to the PMWEBAPI(3). + # +-# Copyright (c) 2019 Red Hat. ++# Copyright (c) 2019,2021 Red Hat. + # + + seq=`basename $0` +@@ -138,14 +138,59 @@ else + fi + + date >>$seq.full +-echo "=== checking TLS operation ===" | tee -a $seq.full +-# (-k) allows us to use self-signed (insecure) certificates, so for testing only +-# (-v) provides very detailed TLS connection information, for debugging only +-curl -k --get 2>$tmp.err \ +- "https://localhost:$port/pmapi/metric?name=sample.long.ten" \ +- | _filter_json +-cat $tmp.err >>$seq.full ++echo "=== checking serial http operation ===" | tee -a $seq.full ++for i in 1 2 3 4; do ++ curl -Gs "http://localhost:$port/pmapi/metric?name=sample.long.ten" 2>$tmp.err$i >$tmp.out$i ++done ++for i in 1 2 3 4; do ++echo === out$i === | tee -a $seq.full ++_filter_json < $tmp.out$i ++done ++ ++date >>$seq.full ++echo "=== checking parallel http operation ===" | tee -a $seq.full ++for i in 1 2 3 4; do ++ curl -Gs "http://localhost:$port/pmapi/metric?name=sample.long.ten" 2>$tmp.err$i >$tmp.out$i & 2>/dev/null eval pid$i=$! ++done ++wait $pid1 $pid2 $pid3 $pid4 ++for i in 1 2 3 4; do ++echo === out$i === | tee -a $seq.full ++_filter_json < $tmp.out$i ++done ++ ++date >>$seq.full ++echo "=== checking serial https/TLS operation ===" | tee -a $seq.full ++for i in 1 2 3 4; do ++ curl -k -Gs "https://localhost:$port/pmapi/metric?name=sample.long.ten" 2>$tmp.err$i >$tmp.out$i ++done ++for i in 1 2 3 4; do ++echo === out$i === | tee -a $seq.full ++_filter_json < $tmp.out$i ++done ++ + date >>$seq.full ++echo "=== checking parallel https/TLS operation ===" | tee -a $seq.full ++for i in 1 2 3 4; do ++ curl -k -Gs "https://localhost:$port/pmapi/metric?name=sample.long.ten" 2>$tmp.err$i >$tmp.out$i & 2>/dev/null eval pid$i=$! ++done ++wait $pid1 $pid2 $pid3 $pid4 ++for i in 1 2 3 4; do ++echo === out$i === | tee -a $seq.full ++_filter_json < $tmp.out$i ++done ++ ++date >>$seq.full ++echo "=== checking parallel mixed http and https/TLS operations ===" | tee -a $seq.full ++for i in 1 3 5 7; do ++ j=`expr $i + 1` ++ curl -k -Gs "http://localhost:$port/pmapi/metric?name=sample.long.ten" 2>$tmp.err$i >$tmp.out$i & 2>/dev/null eval pid$i=$! ++ curl -k -Gs "https://localhost:$port/pmapi/metric?name=sample.long.ten" 2>$tmp.err$j >$tmp.out$j & 2>/dev/null eval pid$j=$! ++done ++wait $pid1 $pid2 $pid3 $pid4 $pid5 $pid6 $pid7 $pid8 ++for i in 1 2 3 4 5 6 7 8; do ++echo === out$i === | tee -a $seq.full ++_filter_json < $tmp.out$i ++done + + echo "=== check pmproxy is running ===" + pminfo -v -h localhost@localhost:$port hinv.ncpu +@@ -156,7 +201,7 @@ else + fi + + # valgrind takes awhile to shutdown too +-pmsignal $pid ++pmsignal $pid >/dev/null 2>&1 + pmsleep 3.5 + echo "=== valgrind stdout ===" | tee -a $seq.full + cat $tmp.valout | _filter_valgrind +@@ -164,6 +209,9 @@ cat $tmp.valout | _filter_valgrind + echo "=== valgrind stderr ===" | tee -a $seq.full + cat $tmp.valerr | _filter_pmproxy_log | _filter_port + ++# final kill if it's spinning ++$sudo kill -9 $pid >/dev/null 2>&1 ++ + # success, all done + status=0 + exit +diff --git a/qa/1457.out b/qa/1457.out +index a7b64cdc5..422176db2 100644 +--- a/qa/1457.out ++++ b/qa/1457.out +@@ -1,5 +1,539 @@ + QA output created by 1457 +-=== checking TLS operation === ++=== checking serial http operation === ++=== out1 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out2 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out3 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out4 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== checking parallel http operation === ++=== out1 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out2 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out3 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out4 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== checking serial https/TLS operation === ++=== out1 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out2 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out3 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out4 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== checking parallel https/TLS operation === ++=== out1 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out2 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out3 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out4 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== checking parallel mixed http and https/TLS operations === ++=== out1 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out2 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out3 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out4 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out5 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out6 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out7 === ++{ ++ "context": "CONTEXT" ++ "metrics": [ ++ { ++ "name": "sample.long.ten", ++ "series": "SERIES" ++ "pmid": "29.0.11", ++ "type": "32", ++ "sem": "instant", ++ "units": "none", ++ "labels": { ++ "agent": "sample", ++ "cluster": "zero", ++ "domainname": "DOMAINNAME" ++ "hostname": "HOSTNAME" ++ "role": "testing" ++ }, ++ "text-oneline": "10 as a 32-bit integer", ++ "text-help": "10 as a 32-bit integer" ++ } ++ ] ++} ++=== out8 === + { + "context": "CONTEXT" + "metrics": [ +diff --git a/qa/group b/qa/group +index 462dffaaa..77cac788d 100644 +--- a/qa/group ++++ b/qa/group +@@ -1818,7 +1818,7 @@ x11 + 1436 pmda.postgresql local + 1437 pmda.kvm local + 1455 pmlogrewrite labels pmdumplog local +-1457 pmproxy local ++1457 pmproxy libpcp_web threads secure local + 1480 pmda.lmsensors local + 1489 python pmrep pmimport local + 1490 python local labels +diff --git a/src/pmproxy/src/secure.c b/src/pmproxy/src/secure.c +index 77265894c..072e2a085 100644 +--- a/src/pmproxy/src/secure.c ++++ b/src/pmproxy/src/secure.c +@@ -16,13 +16,25 @@ + #include + #include + ++/* called with proxy->mutex locked */ + static void + remove_connection_from_queue(struct client *client) + { ++ struct proxy *proxy = client->proxy; ++ + if (client->secure.pending.writes_buffer != NULL) + free(client->secure.pending.writes_buffer); +- if (client->secure.pending.prev != NULL) +- *client->secure.pending.prev = client->secure.pending.next; ++ if (client->secure.pending.prev == NULL) { ++ /* next (if any) becomes first in pending_writes list */ ++ proxy->pending_writes = client->secure.pending.next; ++ if (proxy->pending_writes) ++ proxy->pending_writes->secure.pending.prev = NULL; ++ } ++ else { ++ /* link next and prev */ ++ client->secure.pending.prev->secure.pending.next = client->secure.pending.next; ++ client->secure.pending.next->secure.pending.prev = client->secure.pending.prev; ++ } + memset(&client->secure.pending, 0, sizeof(client->secure.pending)); + } + +@@ -32,7 +44,9 @@ on_secure_client_close(struct client *client) + if (pmDebugOptions.auth || pmDebugOptions.http) + fprintf(stderr, "%s: client %p\n", "on_secure_client_close", client); + ++ uv_mutex_lock(&client->proxy->mutex); + remove_connection_from_queue(client); ++ uv_mutex_unlock(&client->proxy->mutex); + /* client->read and client->write freed by SSL_free */ + SSL_free(client->secure.ssl); + } +@@ -40,6 +54,8 @@ on_secure_client_close(struct client *client) + static void + maybe_flush_ssl(struct proxy *proxy, struct client *client) + { ++ struct client *c; ++ + if (client->secure.pending.queued) + return; + +@@ -47,13 +63,19 @@ maybe_flush_ssl(struct proxy *proxy, struct client *client) + client->secure.pending.writes_count > 0) + return; + +- client->secure.pending.next = proxy->pending_writes; +- if (client->secure.pending.next != NULL) +- client->secure.pending.next->secure.pending.prev = &client->secure.pending.next; +- client->secure.pending.prev = &proxy->pending_writes; ++ uv_mutex_lock(&proxy->mutex); ++ if (proxy->pending_writes == NULL) { ++ proxy->pending_writes = client; ++ client->secure.pending.prev = client->secure.pending.next = NULL; ++ } ++ else { ++ for (c=proxy->pending_writes; c->secure.pending.next; c = c->secure.pending.next) ++ ; /**/ ++ c->secure.pending.next = client; ++ client->secure.pending.prev = c; ++ } + client->secure.pending.queued = 1; +- +- proxy->pending_writes = client; ++ uv_mutex_unlock(&proxy->mutex); + } + + static void +@@ -135,10 +157,12 @@ flush_ssl_buffer(struct client *client) + void + flush_secure_module(struct proxy *proxy) + { +- struct client *client, **head = &proxy->pending_writes; ++ struct client *client, **head; + size_t i, used; + int sts; + ++ uv_mutex_lock(&proxy->mutex); ++ head = &proxy->pending_writes; + while ((client = *head) != NULL) { + flush_ssl_buffer(client); + +@@ -188,6 +212,7 @@ flush_secure_module(struct proxy *proxy) + sizeof(uv_buf_t) * client->secure.pending.writes_count); + } + } ++ uv_mutex_unlock(&proxy->mutex); + } + + void +diff --git a/src/pmproxy/src/server.c b/src/pmproxy/src/server.c +index 612d3613b..b5c5d84de 100644 +--- a/src/pmproxy/src/server.c ++++ b/src/pmproxy/src/server.c +@@ -149,6 +149,7 @@ server_init(int portcount, const char *localpath) + pmGetProgname()); + return NULL; + } ++ uv_mutex_init(&proxy->mutex); + + count = portcount + (*localpath ? 1 : 0); + if (count) { +@@ -251,6 +252,7 @@ void + client_put(struct client *client) + { + unsigned int refcount; ++ struct proxy *proxy = client->proxy; + + uv_mutex_lock(&client->mutex); + assert(client->refcount); +@@ -259,9 +261,11 @@ client_put(struct client *client) + + if (refcount == 0) { + /* remove client from the doubly-linked list */ ++ uv_mutex_lock(&proxy->mutex); + if (client->next != NULL) + client->next->prev = client->prev; + *client->prev = client->next; ++ uv_mutex_unlock(&proxy->mutex); + + if (client->protocol & STREAM_PCP) + on_pcp_client_close(client); +@@ -514,10 +518,12 @@ on_client_connection(uv_stream_t *stream, int status) + client->proxy = proxy; + + /* insert client into doubly-linked list at the head */ ++ uv_mutex_lock(&proxy->mutex); + if ((client->next = proxy->first) != NULL) + proxy->first->prev = &client->next; + proxy->first = client; + client->prev = &proxy->first; ++ uv_mutex_unlock(&proxy->mutex); + + status = uv_read_start((uv_stream_t *)&client->stream.u.tcp, + on_buffer_alloc, on_client_read); +diff --git a/src/pmproxy/src/server.h b/src/pmproxy/src/server.h +index f0b7a5f68..f93daeff4 100644 +--- a/src/pmproxy/src/server.h ++++ b/src/pmproxy/src/server.h +@@ -118,7 +118,7 @@ typedef struct secure_client { + BIO *write; + struct { + struct client *next; +- struct client **prev; ++ struct client *prev; + unsigned int queued; + size_t writes_count; + uv_buf_t *writes_buffer; +@@ -166,6 +166,7 @@ typedef struct proxy { + struct dict *config; /* configuration dictionary */ + uv_loop_t *events; /* global, async event loop */ + uv_callback_t write_callbacks; ++ uv_mutex_t mutex; /* protects client lists and pending writes */ + } proxy; + + extern void proxylog(pmLogLevel, sds, void *); diff --git a/SOURCES/redhat-bugzilla-1974266.patch b/SOURCES/redhat-bugzilla-1974266.patch new file mode 100644 index 0000000..06ced55 --- /dev/null +++ b/SOURCES/redhat-bugzilla-1974266.patch @@ -0,0 +1,2478 @@ +diff -Naurp pcp-5.3.1.orig/qa/1072 pcp-5.3.1/qa/1072 +--- pcp-5.3.1.orig/qa/1072 2021-02-17 15:27:41.000000000 +1100 ++++ pcp-5.3.1/qa/1072 2021-06-24 17:22:58.945372343 +1000 +@@ -88,6 +88,12 @@ pmrep -u -s 5 -o archive -F $tmp.new_arc + pmrep -u -a $tmp.new_archive4 -z hinv.machine mem.util.used + pmdumplog -z -dim $tmp.new_archive4 + ++echo "=== pmrep archive creation with scaled values" ++pmrep -u -s 5 -o archive -F $tmp.new_archive5 -z $log2 -i sda,sdc disk.dev.write_bytes,,,MB | _pid_filter ++# Using -r to display the unit in the archive ++pmrep -u -a $tmp.new_archive5 -z -r disk.dev.write_bytes ++pmdumplog -z -dim $tmp.new_archive5 ++ + rm -f $tmp.a1-out* $tmp.a2-out* $tmp.new_archive* + + # success, all done +diff -Naurp pcp-5.3.1.orig/qa/1072.out pcp-5.3.1/qa/1072.out +--- pcp-5.3.1.orig/qa/1072.out 2021-02-17 15:27:41.000000000 +1100 ++++ pcp-5.3.1/qa/1072.out 2021-06-24 17:22:58.945372343 +1000 +@@ -93,4 +93,53 @@ Instance Domains in the Log ... + + 14:39:17.882326 1 metric + 60.1.1 (mem.util.used): value 13573800 ++=== pmrep archive creation with scaled values ++Recording 1 metrics to TMP.new_archive5: ++5 samples(s) with 1.0 sec interval ~ 4 sec duration. ++ d.d.write_bytes d.d.write_bytes ++ sda sdc ++ Kbyte Kbyte ++ 369846691 948239088 ++ 369847163 948239160 ++ 369847575 948239236 ++ 369848903 948239408 ++ 369849315 948239540 ++Note: timezone set to local timezone of host "billing02" from archive ++ ++ ++Descriptions for Metrics in the Log ... ++PMID: 60.0.39 (disk.dev.write_bytes) ++ Data Type: 32-bit unsigned int InDom: 60.1 0xf000001 ++ Semantics: counter Units: Kbyte ++ ++Instance Domains in the Log ... ++InDom: 60.1 ++00:28:01.923022 2 instances ++ 0 or "sda" ++ 2 or "sdc" ++ ++00:28:01.923022 1 metric ++ 60.0.39 (disk.dev.write_bytes): ++ inst [0 or "sda"] value 369846691 ++ inst [2 or "sdc"] value 948239088 ++ ++00:29:01.925641 1 metric ++ 60.0.39 (disk.dev.write_bytes): ++ inst [0 or "sda"] value 369847163 ++ inst [2 or "sdc"] value 948239160 ++ ++00:30:01.923324 1 metric ++ 60.0.39 (disk.dev.write_bytes): ++ inst [0 or "sda"] value 369847575 ++ inst [2 or "sdc"] value 948239236 ++ ++00:31:01.922091 1 metric ++ 60.0.39 (disk.dev.write_bytes): ++ inst [0 or "sda"] value 369848903 ++ inst [2 or "sdc"] value 948239408 ++ ++00:32:01.922742 1 metric ++ 60.0.39 (disk.dev.write_bytes): ++ inst [0 or "sda"] value 369849315 ++ inst [2 or "sdc"] value 948239540 + == done +diff -Naurp pcp-5.3.1.orig/qa/1627 pcp-5.3.1/qa/1627 +--- pcp-5.3.1.orig/qa/1627 1970-01-01 10:00:00.000000000 +1000 ++++ pcp-5.3.1/qa/1627 2021-06-24 17:22:58.942372394 +1000 +@@ -0,0 +1,62 @@ ++#!/bin/sh ++# PCP QA Test No. 1627 ++# Exercise LOGIMPORT PM_ERR_CONV error handling condition ++# https://github.com/performancecopilot/pcp/issues/1327 ++# ++# Copyright (c) 2021 Red Hat. All Rights Reserved. ++# ++ ++if [ $# -eq 0 ] ++then ++ seq=`basename $0` ++ echo "QA output created by $seq" ++else ++ # use $seq from caller, unless not set ++ [ -n "$seq" ] || seq=`basename $0` ++ echo "QA output created by `basename $0` $*" ++fi ++ ++# get standard environment, filters and checks ++. ./common.product ++. ./common.filter ++. ./common.check ++ ++do_valgrind=false ++if [ "$1" = "--valgrind" ] ++then ++ _check_valgrind ++ do_valgrind=true ++fi ++ ++_cleanup() ++{ ++ cd $here ++ $sudo rm -rf $tmp $tmp.* ++} ++ ++status=0 # success is the default! ++$sudo rm -rf $tmp $tmp.* $seq.full ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++_filter() ++{ ++ sed \ ++ -e "s,$tmp.log,TMPLOG,g" \ ++ # end ++} ++ ++# real QA test starts here ++rm -f $tmp.log.* ++ ++if $do_valgrind ++then ++ _run_valgrind ./src/check_pmi_errconv $tmp.log ++else ++ ./src/check_pmi_errconv $tmp.log ++fi \ ++| _filter ++ ++PCP_DERIVED_CONFIG="" TZ=UTC pminfo -fd -a $tmp.log ++ ++# success, all done ++exit +diff -Naurp pcp-5.3.1.orig/qa/1627.out pcp-5.3.1/qa/1627.out +--- pcp-5.3.1.orig/qa/1627.out 1970-01-01 10:00:00.000000000 +1000 ++++ pcp-5.3.1/qa/1627.out 2021-06-24 17:22:58.945372343 +1000 +@@ -0,0 +1,18 @@ ++QA output created by 1627 ++pmiPutValue: inst 0: Impossible value or scale conversion ++pmiPutValue: inst 1: Impossible value or scale conversion ++ ++my.metric.int ++ Data Type: 32-bit int InDom: 245.0 0x3d400000 ++ Semantics: instant Units: none ++Error: Impossible value or scale conversion ++ ++event.flags ++ Data Type: 32-bit unsigned int InDom: PM_INDOM_NULL 0xffffffff ++ Semantics: discrete Units: none ++No value(s) available! ++ ++event.missed ++ Data Type: 32-bit unsigned int InDom: PM_INDOM_NULL 0xffffffff ++ Semantics: discrete Units: none ++No value(s) available! +diff -Naurp pcp-5.3.1.orig/qa/1628 pcp-5.3.1/qa/1628 +--- pcp-5.3.1.orig/qa/1628 1970-01-01 10:00:00.000000000 +1000 ++++ pcp-5.3.1/qa/1628 2021-06-24 17:22:58.943372377 +1000 +@@ -0,0 +1,40 @@ ++#!/bin/sh ++# PCP QA Test No. 1628 ++# Exercise LOGIMPORT PM_ERR_CONV error handling condition ++# https://github.com/performancecopilot/pcp/issues/1327 ++# valgrind-enabled variant. ++# ++# Copyright (c) 2021 Red Hat. All Rights Reserved. ++# ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++# get standard environment, filters and checks ++. ./common.product ++. ./common.filter ++. ./common.check ++ ++_check_valgrind ++ ++_cleanup() ++{ ++ cd $here ++ $sudo rm -rf $tmp $tmp.* ++} ++ ++status=0 # success is the default! ++$sudo rm -rf $tmp $tmp.* $seq.full ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# real QA test starts here ++export seq ++./1627 --valgrind \ ++| $PCP_AWK_PROG ' ++skip == 1 && $1 == "===" { skip = 0 } ++/^=== std err ===/ { skip = 1 } ++skip == 0 { print } ++skip == 1 { print >>"'$here/$seq.full'" }' ++ ++# success, all done ++exit +diff -Naurp pcp-5.3.1.orig/qa/1628.out pcp-5.3.1/qa/1628.out +--- pcp-5.3.1.orig/qa/1628.out 1970-01-01 10:00:00.000000000 +1000 ++++ pcp-5.3.1/qa/1628.out 2021-06-24 17:22:58.945372343 +1000 +@@ -0,0 +1,25 @@ ++QA output created by 1628 ++QA output created by 1627 --valgrind ++=== std out === ++=== filtered valgrind report === ++Memcheck, a memory error detector ++Command: ./src/check_pmi_errconv TMPLOG ++LEAK SUMMARY: ++definitely lost: 0 bytes in 0 blocks ++indirectly lost: 0 bytes in 0 blocks ++ERROR SUMMARY: 0 errors from 0 contexts ... ++ ++my.metric.int ++ Data Type: 32-bit int InDom: 245.0 0x3d400000 ++ Semantics: instant Units: none ++Error: Impossible value or scale conversion ++ ++event.flags ++ Data Type: 32-bit unsigned int InDom: PM_INDOM_NULL 0xffffffff ++ Semantics: discrete Units: none ++No value(s) available! ++ ++event.missed ++ Data Type: 32-bit unsigned int InDom: PM_INDOM_NULL 0xffffffff ++ Semantics: discrete Units: none ++No value(s) available! +diff -Naurp pcp-5.3.1.orig/qa/group pcp-5.3.1/qa/group +--- pcp-5.3.1.orig/qa/group 2021-06-02 13:30:30.000000000 +1000 ++++ pcp-5.3.1/qa/group 2021-06-24 17:22:58.943372377 +1000 +@@ -1849,6 +1849,8 @@ x11 + 1613 pmda.linux kernel local + 1622 selinux local + 1623 libpcp_import collectl local ++1627 libpcp_import local ++1628 libpcp_import valgrind local + 1634 pmda.sockets local + 1644 pmda.perfevent local + 1660 libpcp labels local +diff -Naurp pcp-5.3.1.orig/qa/group.orig pcp-5.3.1/qa/group.orig +--- pcp-5.3.1.orig/qa/group.orig 1970-01-01 10:00:00.000000000 +1000 ++++ pcp-5.3.1/qa/group.orig 2021-06-02 13:30:30.000000000 +1000 +@@ -0,0 +1,1929 @@ ++## QA groups control ++## ++## define groups ++## ++## Do not start group name with a digit, expect alphabetic ++## ++## Last comment starting with a single # before a group name is the ++## one-line summary that "new" will report when asked to list groups ++## ++## Comments starting with a ## (or # ++## are ignored for the purposes of one-line summaries. ++ ++# catch-all ++other ++ ++# sanity check ... quick coverage of most functionality ++## Expectation is to run in 3-5 minutes, and must pass 100% ++## in the sense of no failures; _notrun is OK. ++## NOTE: used by testing orgs beyond developers, must pass! ++sanity ++ ++# not_in_ci ... tests that will not work in the fully automated ++# CI environment (github actions this week), where the following ++# analysis and protocols have been followed: ++# (a) the test has repeatedly failed on most hosts in the daily CI QA ++# run ++# (b) the test is not a candidates for some _notrun medicine ++# (c) failures have been analyzed and it has been determined that the ++# failure is an artifact of the CI setup (not the code and not ++# the QA test) ++# (d) the test is passing universally elsewhere outside CI ++# and the test is annotated with a comment like ++# # :not_in_ci: ++# explaining the reason for assigning this one to the not_in_ci ++# group (./check-group not_in_ci can be used to check for the ++# presence of the explanation in the test) ++not_in_ci ++ ++# local check ... runs on localhost alone, no remotes used ++## NOTE: used by testing orgs beyond developers, do not add ++## tests here that are known to fail - goal is for 100% pass ++## rate, but due to test volume and chaos theory, some tests ++## do fail sometimes, on some platforms, during a full moon. ++local ++ ++# packaging verification ++## Suitable for standalone use, particularly immediately after ++## installation to check. ++verify ++ ++# flakey checks ... known to have intermittent races/hangs. ++## NOTE: some threading race conditions (possibly in tests), ++## prevent 100% pass rate being achieved here. Goal is to ++## get this group devoid of any tests. ++flakey ++ ++# tests requiring creation/manipulation of very large files ++# (can be extremely slow on certain devices), or otherwise ++# known to take a long time (where long is approx > 3mins). ++slow ++ ++# platform/kernel PMDA sanity checks ... tests that use the ++# common platform metrics, kernel.*, disk.*, hinv.*, mem.* ++kernel ++ ++## specific apps ++## ++# pcp collector infrastructure ++pmcd ++pmproxy ++pmcpp ++# strip chart app ++pmchart ++# 3D scene app ++pmview ++# time control ++pmtime ++# dialog ++pmquery ++# pmdumptext app ++pmdumptext ++# pmdumplog app ++pmdumplog ++# pmloglabel app ++pmloglabel ++# pmlogger app (not control scripts) ++pmlogger ++# pmie app, sample rules and friends ++pmie ++# dbpmda app ++dbpmda ++# pmlc app and pmlc-pmlogger IPC ++pmlc ++# pmfind app ++pmfind ++# folio handling (mkaf and pmafm), also record mode ++folio ++# pmval app ++pmval ++# pmstat app ++pmstat ++# pminfo app ++pminfo ++# pmprobe app ++pmprobe ++# pmrep app ++pmrep ++# pmpost ++pmpost ++# pmdate ++pmdate ++# pcp and sub-commands ++pcp ++# pmclient demo apps ++pmclient ++ ++# general PDU encode/decode ++pdu ++ ++# PMNS related functions/programs ++pmns ++ ++# PCP version compatability ++compat ++ ++# generic libpcp services (not pdu, not context, not archive) ++libpcp ++ ++# fetch-specific, optfetch, fetchgroup ++fetch ++ ++# archive support in libpcp, includes interp.c ++archive ++ ++# multi-archive support in libpcp, includes interp.c ++multi-archive ++ ++# xz decompression support in libpcp ++decompress-xz ++ ++# getopt support - libpcp, pmgetopt, python ++getopt ++ ++# pmlogger_* scripts (but not pmlogger) ++logutil ++ ++# find-filter (used in pmlogger_daily) ++find-filter ++ ++# pmie_* scripts (but not pmie) ++pmieutil ++ ++# NSS, SASL, other authentication ++secure ++ ++# Containers functionality ++containers ++ ++# log extraction app ++pmlogextract ++# log reduction app ++pmlogreduce ++# log rotation script ++#retired# pmnewlog ++# log move script ++pmlogmv ++# log summary app ++pmlogsummary ++# log comparison app ++pmdiff ++# pmlogger configuration app ++pmlogconf ++ ++# general context manipulations, includes profile cacheing ++context ++ ++# indom specific services ++indom ++ ++# PM_CONTEXT_LOCAL ++context_local ++ ++# PCP on different platforms ++interop ++ ++# memory leaks, assorted ++mem_leak ++ ++# general pmdas, but includes libpcp_pmda ++pmda ++ ++# pmda installation scripts and procedures ++pmda.install ++ ++## Assorted PMDAs ++pmda.activemq ++pmda.apache ++pmda.bash ++pmda.bcc ++pmda.bind2 ++pmda.bpftrace ++pmda.cifs ++pmda.cisco ++pmda.dm ++pmda.docker ++pmda.ds389 ++pmda.elasticsearch ++pmda.environ ++pmda.gfs2 ++pmda.gluster ++pmda.gpfs ++pmda.hacluster ++pmda.haproxy ++pmda.hotproc ++pmda.jbd2 ++pmda.json ++pmda.kvm ++pmda.libvirt ++pmda.lio ++pmda.lmsensors ++pmda.logger ++pmda.lustre ++pmda.mailq ++pmda.memcache ++pmda.mic ++pmda.mmv ++pmda.mounts ++pmda.mpi ++pmda.mysql ++pmda.named ++pmda.netcheck ++pmda.netfilter ++pmda.news ++pmda.nfsclient ++pmda.nginx ++pmda.nutcracker ++pmda.nvidia ++pmda.openmetrics ++pmda.oracle ++pmda.perfevent ++pmda.pipe ++pmda.pmcd ++pmda.pmproxy ++pmda.podman ++pmda.postfix ++pmda.postgresql ++pmda.proc ++pmda.redis ++pmda.root ++pmda.rpm # note this group has been retired ++pmda.rsyslog ++pmda.sample ++pmda.sendmail ++pmda.shping ++pmda.simple ++pmda.slurm ++pmda.smart ++pmda.sockets ++pmda.summary ++pmda.systemd ++pmda.trace ++pmda.trivial ++pmda.txmon ++pmda.unbound ++pmda.weblog ++pmda.xfs ++pmda.zfs ++pmda.zswap ++ ++# tools which use PCP_COUNTER_WRAP ++wrap ++ ++# pmstore command and pmStore() libpcp routine ++pmstore ++ ++# metadata labels and pm*Labels() libpcp routines ++labels ++ ++# trace library ++trace ++ ++# Linux platform PMDA ++pmda.linux ++ ++# metrics class tests ++libpcp_qmc ++ ++# shared memory transport for PMDAs ++libpcp_mmv ++ ++# libpcp_import - pmi* routines for log importing ++libpcp_import ++ ++# pmsocks ++pmsocks ++ ++# newhelp, chkhelp and associated library support ++help ++ ++# pmgadgets ++pmgadgets ++ ++# tests that use purify ++purify ++ ++# tests that use valgrind ++valgrind ++ ++# pmcd_wait - wait for pmcd to be ready for connections ++pmcd_wait ++ ++# pmimport and plugins ++pmimport ++ ++# pmieconf - app, pconf and lconf ++pmieconf ++ ++# os testing - eagan ++ostest ++ ++# mpi library ++libpcp_mpi ++ ++# mpi read library ++libpcp_mpiread ++ ++# derived metrics ++derive ++ ++# event records and pmevent ++event ++ ++# multi-threading and thread-safe exercises ++threads ++ ++# perl bits ++perl ++ ++# python modules and client tools ++python ++ ++# fault injection (in libpcp) ++fault ++ ++# log rewriting app ++pmlogrewrite ++ ++# log checking ++pmlogcheck ++ ++# uses avahi ++avahi ++ ++# zabbix exporting ++zbxpcp ++ ++# pcp system commands ++atop ++dstat ++free ++pidstat ++iostat ++tapestat ++ipcs ++mpstat ++ ++# full test search ++pmsearch ++ ++# scalable queries ++pmseries ++ ++# Uses Linux kernel cgroups ++cgroups ++ ++# Timezone services in libpcp ++timezone ++ ++# JSON parsing and metric extraction in libpcp_web ++libpcp_web ++ ++# Old PCP versions interoperability ++oldversion ++ ++# Shell command completion ++bash ++zsh ++ ++# collectl2pcp ++collectl ++ ++# pmlogsize ++pmlogsize ++ ++# pmdbg ++pmdbg ++ ++# pmlogctl ++pmlogctl ++ ++# pmiectl ++pmiectl ++ ++# pcp2... pcp2xxx is generic ++pcp2xxx ++pcp2elasticsearch ++pcp2graphite ++pcp2influxdb ++pcp2json ++pcp2spark ++pcp2xlsx ++pcp2xml ++pcp2zabbix ++ ++# ...2pcp ++ganglia2pcp ++ ++# man pages ++man ++ ++# selinux stuff ++selinux ++ ++# retired tools ++pmmgr # note this group has been retired ++pmwebd # note this group has been retired ++ ++# Bad tests with unacceptable cross-platform behaviour, these ones ++# will NOT be run in the QA Farm ++BAD ++ ++# these test don't work in containers (yet) ++not_in_container ++ ++# need an accessible X11 server ++x11 ++ ++# test-group association ... one line per test ++# add :retired or :reserved as a tag immediately after the test number ++# to keep the test number allocated, but prevent the test from being run ++ ++# ... use sort -n from here on down to tidy up this mess ++# ++000 other pmcd local ostest ++001 pdu local ostest sanity ++002 pdu pmcd local ostest sanity ++003 pdu pmcd mem_leak local ostest kernel ++004 context local ostest sanity ++005 context archive local ostest sanity ++006 libpcp local ostest ++007 fetch local ostest sanity ++008 pmda kernel ostest local not_in_ci ++009:retired kernel local ostest ++010 libpcp local ostest sanity ++011 mem_leak local ostest ++012 archive local ++013 archive pmdumplog local ostest ++014 archive local ostest pmdumplog ++015 pdu local ostest pmstore ++016 archive indom local ostest pmdumplog ++017 context local ostest ++018 pmcd local ostest ++019 context_local local ostest kernel ++020 context_local local ostest kernel ++021 other local ostest ++022 context_local pmda pmda.proc local ostest ++023 pmcd local pmprobe ostest pmstore kernel ++024 context context_local ostest remote ++025 context local ostest ++026 other help local ostest sanity libpcp ++027 libpcp local ostest sanity ++028 pmns local ostest ++029 pmns local ostest pmdumplog pmda.sample ++030 pdu pmcd pmda context_local local ostest pmstore ++031 pmns local sanity ++032 pmlc local ostest pmlogger ++033 kernel local ostest ++034 archive local ostest sanity pmdumplog ++035 pmrep local python kernel ++036 libpcp local ++037 archive local ostest ++038 pmlogger local pmdumplog kernel ++039 pmlogger archive local ostest pmdumplog ++040 pmlogger mem_leak local ostest ++041 pmcd local ostest ++042 pmcd local ostest containers pmda.linux pmda.proc pmda.root ++043 libpcp fetch local ostest ++044 fetch pmval local ostest ++045 libpcp pmda local ostest pmstore ++046 archive pmlogger pmdumplog local ostest ++047 pmcd local ostest containers pmda.linux pmda.root ++048 archive local ostest sanity ++049 archive local ostest pmdumplog ++050 archive local ostest ++051 pmcd ostest remote ++052 pmns local ostest ++053 local pmprobe ostest pmlogger pmclient pmdumplog python kernel ++054 pmlogger archive ostest remote pmdumplog kernel ++055 pmie ostest local sanity ++056 local pmprobe ostest pmlogger pmclient python pmdumplog kernel ++057 pmns local ostest ++058 pmval local ostest ++059 archive local ostest sanity pmdumplog ++060 archive context local ostest ++061 pmlogger local ostest pmdumplog ++062 pmcd local ostest ++063 fetch local ostest ++064 pidstat local python pcp ++065 libpcp local ostest pmstore ++066 pmcd ostest remote folio ++067 pmcd local ostest folio ++068 context local ostest sanity folio ++069 pmcd pmval remote pmstore folio ++070 other ostest remote ++071 context_local local ostest ++072 pmlogger ostest remote pmdumplog kernel ++073 pmclient local pmprobe python kernel ++074 pmda pmda.cisco pmda.pmcd local ostest sanity kernel ++075 pmval pmstore ostest remote ++076 pmda.pmcd local ostest ++077 libpcp ostest remote timezone ++078 pmdumplog local ostest ++079 libpcp archive local ostest pmclient ++080 libpcp pmval local sanity kernel ++081 indom archive pmns remote pmdumplog kernel ++082 pmns local ostest ++083 pmlc pmlogger compat remote kernel ++084 other local ostest ++085 pmlogger local ostest sanity ++086 libpcp ostest remote timezone ++087 archive local ostest sanity ++088 archive #500237 pmval local ostest ++089 archive pmval local ostest ++090 archive local ostest ++091 archive local ostest sanity ++092 archive local ostest ++093 archive local ostest ++094 pmval archive local ostest ++095 archive local ostest ++096 pmda.proc local ++097 archive local ostest ++098 pmlc pmlogger other local pmdumplog ++099 pmlc local ++100 pmlc pmlogger local pmdumplog ++101 pmlc pmlogger remote pmdumplog ++102 pmlc local pmlogger ++103 pmlc pmlogger local pmdumplog ++104 pmlc pmlogger local pmdumplog ++105 pmlc pmlogger local pmdumplog ++106 pmlc pmlogger local pmdumplog ++107 pmlc local sanity ++108 pmda.cisco pmda.sample local ++109 pmclient local pmprobe python kernel ++110 pmda.simple pmda.proc local pmda.install ++111 pmda.proc pmval local ++112 pmns local sanity ++113 kernel local ++114 pmda.linux local ++115 pmie remote pmieutil ++116 other pmie pmval remote pmlc ++117 kernel local ++118 pmie local kernel ++119 logutil local #877570 ++120 kernel local kernel ++121 pmlogconf #893249 local kernel ++122 trace local #893884 remote pmda.trace ++123 libpcp local ++124 pmie local #870661 kernel ++125 pmval archive kernel ++126:retired pmda.linux local ++127 pmlogreduce local sanity pmdumplog ++128 kernel pminfo local ++129 pmlogreduce local pmval kernel ++130 kernel local ++131 libpcp remote ++132 pmlogger local pmlc ++133 pmlc pmlogger local pmdumplog ++134 pmlc pmlogger local pmdumplog ++135 pmlc archive local pmdumplog ++136 pmlogger local pmdumplog pmloglabel pmlc ++137 dbpmda local pmda.simple sanity ++138 pmns local ++139 pmlc local pmda.sample ++140 pmns local ++141 archive context local ++142 pmlogreduce local pmdumplog ++143 pmns local ++144 pmlogreduce local pmval kernel ++145 pmns local ++146 pmns libpcp local sanity ++147 dbpmda local ++148:retired kernel local ++149 kernel local kernel ++150 pmlogreduce local pmval kernel ++151 logutil local pmlogextract ++152 pmda.pmcd pmval local ++153 folio local sanity ++154 pmda.cisco help local sanity ++155 pmcd pmstore pmda.sample local sanity ++156 pmda.sample pmda.proc local pmcd_wait pmda.install ++157 pmlogger local ++158 pmval pmie local kernel ++159 pmda.cisco local pmda.install pmstore pmpost ++160 libpcp local ++161 pmlogger local ++162:retired pmda pmda.proc local pmda.shping pmda.install ++163 archive local ++164:retired local pmval pmdumplog ++165 pmval local kernel ++166 pmlogreduce local pmval pmdumplog archive ++167 pmda.pmcd pmval local pmstore ++168 pmlogextract #933456 local pmstore pmdumplog ++169 pmcd local pmstore ++170 other local ++171 archive local pmdumplog ++172 pmcd pmlc local folio ++173 archive local pmdumplog ++174 dbpmda local ++175 pmval local ++176 libpcp pmval local ++177 archive pmval local pmdumplog pmlc ++178 pmval local pmlogextract sanity pmdumplog pmlogger ++179 pmval pmlc local pmdumplog kernel ++180 archive pmval local ++181 pmval archive pmval local ++182 pmlc pmlogger local ++183:retired local pmlc pmnewlog ++184:retired logutil remote sanity pmdumplog pmnewlog ++185:retired local pmnewlog ++186 local pmlogextract ++187 pmcd pmlogger #327288 remote ++188 libpcp local ++189 pmie local kernel ++190 libpcp local ++191 pmie local kernel ++192 pdu local folio ++193 libpcp pmcd #935490 local pdu ++194 libpcp pmcd #935490 local ++195 archive local pmdumplog ++196 pmcd remote ++197 context local ++198 pmda context #934332 local ++199 pmda.trivial pmda.proc local pmda.install ++200 context local ++201 pmda local sanity ++202 pmval local pmlogextract pmdumplog ++203 archive pmval local pmlogextract pmdumplog ++204 pmlogger local pmdumplog kernel ++205 pdu local ++206 archive pmval local kernel ++207 pmns local sanity ++208 pmns local sanity ++209 pmval local kernel ++210 pmns local pmval pmie sanity pmdumplog ++211 pmns local pmval pmie pmdumplog ++212:retired pmda pmda.cisco local ++213 dbpmda pmns local pmda.sample pmda.mmv sanity ++214 pmlogextract local pmdumplog timezone ++215 other pmsocks pmval remote pmdumplog ++216 pmda.linux local ++217 folio local ++218 archive local pmlogextract pmdumplog ++219 pmdbg local ++220 pmlogger local folio ++221 pmlogger local ++222 other local ++223:retired pmns local ++224 pmcd local ++225 derive local kernel ++226 dbpmda local ++227 folio local ++228 pmie local ++229 pmie local ++230 pmlogger pmlc local ++231 pmie #421411 local kernel ++232 libpcp local sanity kernel ++233 context_local local ++234 local pmdumplog pmlogsummary pmlogextract sanity ++235 pmns local ++236 pmns local ++237 pmns local ++238 pmns local ++239 pmns local kernel ++240 pmns local ++241 pmda.mmv local pmval perl ++242 pmlogger local kernel ++243 pmcd local pmprobe ++244 pmcd local pmprobe ++245 pmns local ++246 derive local valgrind ++247 derive local kernel ++248 pmlogger local pmdumplog ++249 derive local sanity ++250 pmns local ++251 archive pmval local pmdumplog ++252 pmlogger local pmdumplog ++253 derive local ++254 libpcp pmns local ++255 compat pmda #508731 #509091 pmda.proc help pmda.install local pmda.simple ++256 derive pmns local sanity pmda.sample ++257 libpcp pmns compat remote ++258 trace local pmda.install folio pmda.trace ++259 derive pmval local ++260 derive pmie local pmstore ++261 pmdumplog pmval local pmlogextract ++262 context_local pmie pmsocks remote pmstat kernel ++263 derive local sanity ++264 pmns local ++265 libpcp local ++266 #466346 patch2140 patch2141 local pmlogextract pmdumplog timezone ++267 libpcp local ++268 interop local ++269 wrap pmval local pmstore ++270 local pmdumplog kernel ++271 archive local pmdumplog ++272 pmcd pmval pmprobe remote pmstore ++273 libpcp local pmval pmstore pmda.sample kernel ++274 pmda help local pmda.install dbpmda ++275 derive local kernel ++276 pmie pmval indom local ++277 libpcp pdu interop local ++278 other help local sanity ++279 pmcd local folio ++280 pmlogger logutil local folio pmlc ++281 archive mem_leak #504616 local ++282 pmcd local pmprobe logutil pmlc folio ++283 context pmcd local ++284:retired pdu local purify ++285 dbpmda local ++286 pmda.linux local pmval kernel ++287 pmlogreduce local pmval ++288 archive local ++289 libpcp fetch archive #505498 local ++290:retired pmns local purify ++291 logutil local pmlogextract pmdumplog ++292 pmlogextract logutil pmval local ++293 pmstat #939275 local ++294 pmproxy local pmval pmie pmstat pmdumptext ++295 pmproxy local pmval pmstat pmie ++296 pmcd local ++297 pmproxy local ++298 pmie local kernel ++299 libpcp local sanity kernel ++300 pmcd local pmpost ++301 pmda pmcd pmlogger local ++302 pmlogextract local pmdumplog ++303 local pmlogextract pmdumplog ++304 pmlogger local ++305 pmgadgets local ++306 other local pmpost ++307 pmlc #936084 local pmie ++308 pmlc pmlogger #452417 remote pmdumplog pmda.proc ++309 libpcp pmcd pmda.linux pmda.simple local pmstore kernel ++310 pmie local kernel ++311:retired archive compat #509592 pminfo local pmdumplog ++312 pmie local ++313 pmval archive local pmdumplog kernel ++314 pmie local pmieutil pmstore ++315 pmie local pmieutil ++316 libpcp local ++317 pmlogsummary local pmlogcheck pmie pmval derive pmrep python kernel ++318 pmie local ++319 pmie local kernel ++320 local folio pmlogcheck pmclient ++321 pmie local ++322 pmlc pmlogger remote pmdumplog kernel ++323 pmda.shping pmda.proc local pmda.install ++324 pmda.txmon pmda.proc local pmda.install ++325 libpcp local pmquery x11 ++326 pmlogger pmval libpcp pmcd local pmda.install pmdumplog timezone ++327 archive local pmdumplog pmloglabel timezone ++328 local pmlogextract pmdumplog ++329:retired archive mem_leak local purify ++330:retired archive mem_leak local purify ++331:retired archive mem_leak local purify ++332:retired archive mem_leak local purify ++333:retired archive mem_leak local purify ++334 derive local ++335 derive local pmval pmstore ++336 trace local pmda.install folio pmda.trace ++337 pmlogextract local pmval pmdumplog ++338 logutil pmlogextract local sanity ++339 pmie local kernel ++340 pmcd remote pmstore ++341 pmda local ++342 other remote ++343 pmlogreduce local pmdumplog ++344 context_local local pmval pmprobe ++345 pmns derive local sanity ++346 pmda.mailq local pmda.install ++347 pmda.news local pmda.install perl pmstore ++348 pmda.kvm local pmda.install ++349 pmda.summary local pmda.install ++350 pmda.simple pmda local ++351 derive local ++352 derive pmlogger local pmdumplog ++353 pmsocks remote ++354 folio local sanity pmlc ++355 trace local pmda.install pmda.trace ++356 derive local pmie ++357 other local ++358 pmie local pmstore ++359 pmcd pminfo sanity local ++360 pmie remote ++361 pmda.linux local cgroups ++362 pmlogconf local kernel ++363 local pmlogsummary ++364 pmlogconf local kernel ++365 pmcd remote pmlc kernel ++366:retired pmlogconf local ++367 pdu local trace ++368 pmlogconf local ++369 pmimport local sanity pmdumplog perl ++370 pmimport local derive pmdumplog perl pmval ++371 pmimport local pmdumplog perl ++372 pmimport local pmdumplog perl ++373 pmimport local perl pmdumplog ++374 pmlc pmlogger remote pmdumplog ++375 pmlc pmlogger remote pmdumplog ++376 trace local pmda.install pmda.trace ++377 other local ++378 pmie local kernel ++379 pmda.cisco local ++380 libpcp pmda pmda.sample local pmval pmprobe ++381 pmlc remote ++382 dbpmda pmda pmda.sample local ++383 pmda.cisco local flakey ++384 pmda.pmcd local ++385 libpcp pmda.sample pminfo pmprobe local event sanity pmstore ++386 pdu mem_leak valgrind local ++387 pmns mem_leak valgrind local ++388 archive mem_leak valgrind local ++389 pmlogger local pmdumplog ++390 pmda.proc local pmval ++391 archive mem_leak valgrind local ++392 pmns local ++393 archive mem_leak valgrind local ++394 archive mem_leak valgrind local flakey ++395 archive mem_leak valgrind local kernel ++396 pmval local kernel ++397 dbpmda libpcp local pdu event sanity ++398 pmcd local ++399 pmie local kernel ++400 pminfo mem_leak valgrind context_local libpcp local event ++401 libpcp pminfo local event sanity pmstore ++402 archive local pmprobe kernel ++403 pmprobe pminfo pmval #541380 local sanity kernel ++404 libpcp local event sanity ++405 libpcp mem_leak valgrind local event ++406 libpcp local event ++407 derive local event sanity pmstore ++408 pmda local #627395 help ++409 libpcp pminfo local event ++410 pmdumplog local event ++411 pmda.simple local pmda.install ++412 wrap archive libpcp pmval local pmdumplog timezone pmstore ++413 pmie local event ++414 libpcp local ++415 pmstore local event ++416 pmda.news dbpmda local sanity perl ++417 archive local pmdumplog ++418 pmdumplog local pmlogger ++419 pmdumplog local pmlogger kernel ++420 local pmdumplog ++421 trace local pmda.install pmda.trace ++422 libpcp local pmstore ++423 libpcp local ++424 local pmlogsummary ++425 wrap local pmlogsummary pmdumplog ++426 trace local pmstore pmda.trace ++427 pmcd #564017 local ++428 archive local pmval pmstore ++429 pmns local ++430 logutil local #553276 #568199 ++431 derive local ++432 pmlogreduce local ++433 pmie local #573184 kernel ++434 pmval local ++435 archive local sanity pmdumplog ++436 archive local sanity pmdumplog ++437 archive local sanity ++438 archive local pmdumplog ++439 pmlc local ++440 pmlogger local pmdumplog ++441 pmlogger local ++442 pmlogextract local ++443 event local pmstore ++444 event local pmstore ++445 trace local pmda.trace ++446 trace local pmda.trace ++447 event local pmstore ++448 libpcp local ++449 threads local flakey pmns ++450 pmlogextract local #584487 pmval ++451 threads local ++452 pmda.linux local ++453 perl local sanity kernel ++454 pmcd local ++455 pmda.rsyslog local flakey pmda.install ++456 logutil local #591459 pmlogextract ++457 pmda.logger pmda.install event local ++458 pmda.logger pmda.install event local ++459 pmlogreduce local valgrind ++460 pmlogextract local #598265 pmdumplog ++461 pmda.logger pmda.install event local ++462 pmcd_wait local #589006 #581025 ++463 pmns local pmcpp ++464 pmns local pmcpp ++465 pmdumplog local #625913 ++466 pmlogger local #625913 ++467 pmns pmdumptext local ++468 pmns pmdumptext local ++469 help local #626853 kernel ++470 threads local ++471 pmda local #621699 ++472 threads local ++473 threads local ++474 threads local ++475 threads local ++476 fault local ++477 event fault local pmstore ++478 fault local ++479 archive pmdumplog local pmie pmval kernel ++480 archive fault local pmdumplog ++481 pmlogrewrite local kernel ++482 pmlogsummary local pmdumplog ++483 pmlogrewrite local kernel ++484 pmlogrewrite local pmdumplog ++485 pmlogrewrite local pmdumplog ++486 pmlogrewrite local pmdumplog kernel ++487 pmlogrewrite pmdumplog local pmval ++488 pmlogrewrite pmdumplog local ++489 pmda local ++490 pmlogrewrite mem_leak valgrind local pmdumplog kernel ++491 pmda local ++492 pmlogrewrite local pmdumplog ++493 pmlogrewrite local pmval ++494 pmlogrewrite pmdumplog local pmval kernel ++495 pmlogrewrite local pmlogextract pmdumplog kernel ++496 pmlogrewrite pmdumplog local ++497 pmlogconf local ++498 event pmda local ++499 pmlogrewrite local timezone pmdumplog kernel ++500:retired local #636417 pmnewlog ++501 pmie local kernel ++502 pmlogrewrite local pmdumplog kernel ++503 logutil pmlogrewrite local pmlogextract pmdumplog ++504 libpcp fault local ++505 pmlogrewrite local pmdumplog ++506 pmlogrewrite local slow ++507 pcp local kernel ++508 archive pmlogreduce local pmval kernel ++509 derive pmns local pmda.sample ++510 pmlogger pmlc local ++511 pmimport pmdumplog pmlogsummary perl local ++512 threads pminfo pmlogger pmlogextract pmdumplog dbpmda local fault ++513 libpcp pdu local valgrind ++514 pmie local ++515 pmie local pmstore ++516 pmie local kernel ++517 other local ++518 pcp local flakey pmie ++519 pmie remote ++520 pmie local kernel ++521 pmie local ++522 pmcd local ++523 pmie local ++524 libpcp pmlogger local pmdumplog ++525 pmda.summary pmie local ++526 pmimport local valgrind ++527 libpcp_import perl local timezone ++528 pmimport pmdumplog perl local ++529 pmie local pmdumplog ++530 logutil pmlogextract local ++531 dbpmda local pmda.sample ++532 logutil pmlogextract local pmdumplog ++533 dbpmda local pmda.sample ++534 pmie local ++535 pmie local pmprobe ++536 pmimport local iostat pmval pmprobe pmdumplog timezone collectl pcp python ++537 pmimport perl local ++538 pmie local pmstore ++539 pmpost local flakey ++540 libpcp valgrind fault local ++541 pmie #535080 local pmprobe ++542 pmdate #666344 local ++543 logutil remote pmlogextract ++544 pmimport local collectl pcp python ++545 pmsocks local ++546 pmcd local secure ++547 libpcp pmcd local python ++548 pmie local sanity ++549 pmie local ++550 libpcp pmcd local python ++551 libpcp pmcd local python kernel ++552 libpcp local ++553 dbpmda python pmda.gluster local ++554 pmie local kernel ++555 pmie local kernel ++556 pmie local kernel ++557 pmie local ++558 pmie local kernel ++559 pmlogsummary local ++560 pmda.simple local pmda.install ++561 libpcp python labels local sanity ++562 pmcd pmda.sample dbpmda pminfo labels libpcp local sanity ++563 pmcd pmda.pmcd pminfo labels libpcp local ++564 logutil local pmlogextract ++565 pmda.sendmail local pmda.install ++566 pmlogcheck local ++567 libpcp labels local sanity python ++568 pmcd pmda.sample pminfo labels libpcp local sanity ++569 pmprobe #679693 local sanity pmstore pmda.sample ++570:retired pmns #690735 local ++571 pmlogger local pmdumplog ++572 pmcd pmda local pmda.install pmda.sample pmda.simple pmda.trivial pmstore ++573 other remote pmdumplog ++574 libpcp pmns compat local sanity ++575 pmie local ++576 pcp2xml python pcp2xxx derive local ++577 pmlogger local ++578 pmcd local pmda.install pmval ++579 collectl local ++580 indom local ostest kernel ++581 pmie local kernel ++582 pmdumplog local ++583 pmie #698718 remote ++584:retired libpcp pmie local #698774 purify ++585 pmval pmprobe local pminfo kernel ++586 other local ++587 pmcd #754795 local pmda.install pmda.trivial ++588 libpcp threads local archive multi-archive kernel ++589 remote ++590 libpcp threads local archive multi-archive ++591 pminfo archive multi-archive decompress-xz local pmlogextract ++592 pmda.sample local pmstore ++593 pmlogger #779495 local pmstore ++594 pmda.sample #779246 #782029 local ++595 libpcp threads local archive multi-archive kernel ++596 pmlogextract archive local ++597 pmda.shping pmda.proc pmda.install local ++598 derive local ++599 pmie local ++600 libpcp local timezone ++601 trace pmda.install local pmda.trace ++602 trace pmda.install local pmda.trace ++603 trace pmda.install remote pmda.trace ++604 archive pmval pmlogextract pmdumplog local ++605 trace local pmda.trace ++606 python archive pmns iostat local pidstat pcp ++607 libpcp local ++608 pmpost local ++609 pmdumplog local ++610 libpcp local ++611 pmlogger pmdumplog local ++612 other local ++613 pmdumplog local kernel ++614 pmns local ++615 pmlogsize local ++616 pmlogsize local ++617 dbpmda help local ++618 pmlogsize local ++619 pmlogsize local ++620 pmlogsize valgrind local ++621 pmlogsize local ++622 pmie remote ++623 logutil local ++624 pmlogrewrite pmdumplog decompress-xz local kernel ++625 libpcp getopt pmval local kernel ++626 logutil local ++627 pmlogcheck decompress-xz local ++628 pmda local pmda.simple ++629 pmlogmv pmlogcheck local ++630 other local ++631:retired pmlogrewrite ++632 libpcp pmlogrewrite local ++633 pmlogger local ++634 kernel local pmval timezone kernel ++635 pmda.linux kernel remote ++636 libpcp local ++637 other pmlogmv pmlogrewrite pmdumplog local ++638 pmns local ++639 pmns local ++640 pmpost local ++641 logutil pmdumplog local pmlogrewrite pmlogmv ++642 pmda.trivial pmns local pmda.simple pmda.sample pmda.sendmail trace pmda.trace ++643 pmda.trivial pmns local ++644 pmns local ++645 pmlogger local kernel ++646 pmda.mmv local sanity ++647 pmda.mmv local ++648 pmda.mmv local ++649 pmda.mmv local ++650 pmlogger local pmdumplog ++651 pmproxy local ++652 pmda.systemd event flakey ++653 libpcp local ++654 pmda.gfs2 local ++655 pmda.gfs2 local pmstore ++656 pmda.cifs local valgrind ++657 pmda.dm local ++658 logutil local pmlogrewrite pmlogmv ++659 pmlogreduce local ++660:retired pmwebd local ++661:retired pmwebd local python kernel ++662 pmproxy pmda.sample local python pmda.sample ++663:retired pmwebd local python ++664 logutil local pmlogrewrite pmlogmv ++665 pmda.linux local ++666:retired pmmgr local slow valgrind pmrep python pmlogrewrite ++667 pcp2graphite python pcp2xxx local ++668:retired pmmgr local containers pmdumplog ++669:retired pmmgr local pmlogcheck ++670 libpcp local ++671 folio local pmlogrewrite pmlogmv ++672 valgrind libpcp pmval local ++673 pmdumplog local decompress-xz ++674 pcp local ++675 pmlogrewrite local logutil kernel ++676 logutil pmlogrewrite local ++677 pmprobe archive multi-archive decompress-xz local pmlogextract ++678 logutil pmlogrewrite local ++679 logutil local pmlogrewrite pmlogmv ++680 libpcp local ++681 valgrind libpcp local ++682 libpcp_mmv labels local valgrind ++683 libpcp_mmv labels local ++684 pmstat archive multi-archive decompress-xz local pmlogextract ++685 pmns local ++686 logutil local ++687 pmlogger local man ++688 derive local ++689 pmclient archive multi-archive decompress-xz local sanity pmlogextract python ++690 derive local ++691 derive local ++692 pmie pmda.sample local ++693 pmie pmda.sample local ++694 pmie valgrind local ++695 pmda.trivial perl local ++696 pmda.trivial python local ++697 pmie valgrind local kernel ++698 pmie valgrind local ++699 pmlogrewrite local ++700 other local ++701 pmlogcheck local ++702 python libpcp local sanity ++703 pmda.weblog local ++704 pmda.mmv python libpcp_mmv local ++705 libpcp local ++706 libpcp local ++707 python libpcp local sanity ++708 python pmimport local ++709:retired pmcollect ++710 python pmimport local pmdumplog ++711 pmimport pmlogsummary perl local ++712 context libpcp pmcd secure local kernel ++713 context libpcp pmproxy secure local ++714 context libpcp pmcd secure local kernel ++715 pmda.simple perl ++716 dbpmda pmda.simple perl ++717 pmda.simple python ++718 dbpmda pmda.simple python ++719 libpcp local valgrind ++720 libpcp local valgrind ++721 dbpmda local ++722 python local pcp ++723 pmda.proc local ++724 pmfind local ++725 pmda.jbd2 local ++726 pmlogger pmdumplog local ++727:retired avahi local ++728 libpcp getopt local timezone ++729 python local ++730 pmda.proc local cgroups ++731 pmda.proc local cgroups valgrind pmval ++732 pmda.linux local ++733 pmie pmval pmdumplog local kernel ++734 libpcp pmstat remote ++735 pmda.proc local ++736 pmlogrewrite local pmdumplog ++737 python local timezone ++738 local pmlogmv sanity ++739 python getopt local timezone ++740 pmda.sample pmstore secure local pmdbg ++741 python getopt local ++742 pcp python local ++743 pcp python local ++744 pmda.nvidia local ++745 pmda.nvidia local valgrind ++746 valgrind libpcp local ++747 pmda.linux local kernel ++748 pmlogrewrite pmda.mysql local pmdumplog ++749 pmcd local ++750:retired pmda.rpm local flakey pmval ++751:retired pmda.rpm local pmdumplog pmlogrewrite ++752 libpcp local pmval timezone ++753 derive local pmval pmstore kernel ++754 pmda.unbound local python ++755 pmda.apache pmda.install local ++756 pmda.perfevent local ++757 pmda.perfevent pmda.install local ++758 perl local pmstore ++759 pmda.unbound pmda.install local python ++760 pmda.activemq pmda.install local ++761 pmda.root local containers ++762 help local pmda.sample ++763 pmda local ++764 pmie local ++765 pmlogsummary local ++766 pmfind local ++767 pmda.linux pmda.proc pmda.root local containers kernel ++768 pmlogextract local pmdumplog ++769 other local ++770 libpcp pdu fault local valgrind ++771 perl local ++772 pmns local ++773 derive local ++774 pmdumplog local ++775 pmfind local ++776 pmfind local ++777 derive pmprobe pmie local pmval ++778 pmda.postgresql pmie local ++779 pmda local ++780 pmproxy local ++781 logutil local ++782:retired pmwebd local ++783:retired pmda.rpm local valgrind ++784 pmda.mic python local ++785 pcp atop local ++786 context context_local libpcp local ++787 archive local pmie pmlogrewrite pmdumplog pmval flakey kernel ++788 pmda.nginx pmda.install local ++789 pmda.zimbra local ++790 pmlogextract local ++791 pmlogextract valgrind local pmdumplog ++792 libpcp local pmdbg ++793 logutil local kernel ++794 containers pmcd pmda.pmcd local ++795 pmimport pmdumplog perl local ++796 pmda.elasticsearch local ++797 pmlogrewrite local pmdumplog ++798 pmda.nfsclient local python dbpmda ++799 pmlogrewrite local ++800 pmda.proc pmda.hotproc local ++801 pmda.netfilter local ++802 pmda valgrind dbpmda local ++803 libpcp derive local kernel ++804 pcp pmstat local ++805 pmda.postfix local ++806 pmstore pminfo pmie pmval pmprobe dbpmda local ++807 pcp local ++808 pmlogger local logutil ++809:retired pmcollect ++810 iostat archive multi-archive local pmlogextract pcp python ++811 pmlogger pmcpp local kernel ++812 pmlogextract local pmdumplog ++813 pmlogextract local ++814 pmprobe archive multi-archive local pmlogextract ++815 pmie local ++816 libpcp local ++817 pmstat archive multi-archive local pmlogextract ++818 pmval archive multi-archive local pmlogextract ++819 pmda.elasticsearch local ++820 pmda.linux local ++821 pmda.linux local ++822:reserved pmlogrewrite ++823 pmda.sample pmstore secure local pmdbg ++824 pmlogsummary local #1132476 pmdumplog kernel ++825 pmda.ds389 local ++826 pmda.linux local ++827 pmlogrewrite pmda.linux local pmdumplog ++828 valgrind archive context local kernel ++829 pcp python local ++830 other local ++831 pmda.sample pmstore secure local pmdbg ++832 pmda.sample pmstore secure local ++833 archive context local kernel ++834 pmie local ++835 pmda.memcache local ++836 pmlogsummary local pmdiff ++837 pmda.sample containers local pmval pmstore pmprobe pmdbg ++838 pmns local ++839 pcp python local ++840 avahi local ++841 pmda local python ++842 python local iostat pmval pcp kernel ++843 pmda local python ++844 pmda.linux local ++845 pmda.mounts local python ++846 pmimport pmdumplog perl local ++847 containers local ++848 pmcd secure local kernel ++849 pmie local ++850:retired pmcollect ++851 iostat local pcp python kernel ++852 pmda.proc local ++853 pmcpp local kernel ++854 pmlogger local pmlc pmdumplog pmstore folio ++855 pmda.netfilter local ++856 pmlogger local pmlc pmdumplog pmstore folio ++857 pmda.linux local valgrind kernel ++858 libpcp local fetch valgrind pmstore ++859 python libpcp local fetch ++860 pmda pmda.proc ostest local pmval ++861 pmcd pmda.pmcd local ++862 pmie local ++863 python local ++864 pcp python local collectl ++865 pmda local ++866 fault libpcp local ++867 pmproxy libpcp_web local ++868 pmda.install local ++869 pmda.linux local kernel ++870 pmlogcheck local ++871 pmie local pmstore ++872 pmda.linux local ++873 pmda.linux local kernel ++874 valgrind pmval libpcp local ++875 libpcp local valgrind ++876 pmda.xfs local ++877 libpcp local ++878 pmda.pipe local pmval ++879 pmda.pipe local ++880 pmrep python local kernel ++881 pmcd local ++882 pmlogger local pmlc pmdumplog pmstore folio ++883 pcp mpstat python local ++884 libpcp_web local ++885 pmda.linux local kernel ++886 pmda.linux local kernel ++887 pmlogsummary archive multi-archive local pmlogextract ++888 pmda.linux local ++889 pmda.proc local ++890 libpcp_import local ++891 libpcp local ++892 pmcd libpcp local ++893 pmcd local ++894 pmlogconf pmieconf local ++895 pmlogger local ++896 pmlogger local pmdumplog kernel ++897 pmlc pmlogger local ++898 pmlogmv local ++899 libpcp getopt folio local ++900 libpcp sanity local timezone ++901 libpcp event local ++902 libpcp mem_leak valgrind event local ++903 libpcp threads local context_local context ++904 python local ++905 oldversion remote ++906 pmda.sample indom help pmda pminfo local ++907 pmlogextract local pmdumplog ++908 indom help pmda pminfo local ++909 libpcp pmns local ++910 pmda.linux pmval local kernel ++911 pmda.linux local ++912 pmda.nutcracker local ++913 pmda.redis local ++914 libpcp threads local context_local context ++915 pmcd pmlogger pmproxy libpcp local pmlc ++916 pmlogextract pmlogcheck local kernel ++917 selinux local ++918 pmcd local kernel ++919 pmlogger pmstat local pmdumplog ++920 logutil local ++921 pmdumplog local kernel ++922 derive pmie pmval local kernel ++923 derive libpcp valgrind local ++924 pmda.docker local valgrind helgrind ++925 logutil local ++926 ganglia2pcp local pmdumplog ++927 derive local kernel ++928 archive local pmdumplog ++929 logutil local ++930 pmlogrewrite local pmdumplog ++931 archive pmval local ++932 pmlogger local pmdumplog folio ++933 pmda.proc local ++934 pmieutil local ++935 derive local ++936 pcp tapestat python local ++937 derive local ++938 derive local kernel ++939 derive local kernel ++940 selinux local ++941 pmcd local ++942 threads valgrind local helgrind ++943 pmprobe pmda.proc local ++944 pmcd secure local pmstore ++945 pmlogrewrite pmda.xfs local pmdumplog ++946 pmfind avahi local ++947 pmlogger local pmdumplog ++948 pmlogger context_local local pmlogcheck pmdumplog kernel ++949 python local timezone ++950 pmproxy avahi local ++951 pmie local pmval kernel ++952 threads valgrind local helgrind ++953 libpcp threads local ++954 libpcp threads derive local ++955:retired pmda.linux local kernel ++956 pmcd local ++957 pmda.linux local valgrind ++958 archive local pmdumplog ++959 pmda.sample pmstore local ++960 pmda.ds389 local ++961 pmlogextract local ++962 archive local pmval pmdumplog kernel ++963 libpcp local ++964 pmcd local pmda.xfs pmda.dm ++965 derive local kernel ++966 secure local kernel ++967 zsh local pcp2xxx pcp2elasticsearch pcp2xlsx pcp2influxdb pcp2graphite pmrep python pcp2zabbix pcp2xml pcp2json ++968 python local derive kernel ++969 derive local kernel ++970 pmclient archive multi-archive local sanity pmlogextract python ++971 pmlogrewrite pmda.proc local pmdumplog ++972 pmda.zswap dbpmda local python ++973 pmda.zswap pmda.install local python kernel ++974 pmda.proc local ++975 pmimport local ++976 dbpmda perl pmda.lustre local ++977 libpcp valgrind local containers ++978 libpcp getopt sanity local timezone ++979 python local ++980 python local ++981 dbpmda perl pmda.gpfs local ++982 pmda.proc pmda.hotproc local pmstore ++983 pmie local ++984 cgroups local pmlogrewrite ++985 pmimport pmdumplog perl local ++986 pmimport pmdumplog perl local ++987 pmda.xfs local ++988 pmda.xfs local valgrind ++989 archive local ++990 pmda.mmv local valgrind ++991 pcp python free local ++992 pmcpp pmlogger local kernel ++993 pmlogger pmdumplog local ++994 other verify ++995 python local ++996 pmdiff local ++997 pmlogextract local pmlogcheck pmdumplog ++998 threads libpcp local ++999 pmns local ++1000 pmdumptext local ++1001 pmchart local x11 ++1002 pmchart local x11 ++1003 pmchart local kernel x11 ++1004 pmchart local kernel x11 ++1005 pmchart local x11 ++1006 pmchart local x11 ++1007 pmchart local kernel x11 ++1008 pmdumptext libpcp_qmc local kernel x11 ++1009 pmdumptext libpcp_qmc local x11 ++1010 pmdumptext pmlogger libpcp_qmc local x11 ++1011 pmdumptext pmval libpcp_qmc local x11 ++1012 pmdumptext libpcp_qmc local x11 ++1013 libpcp_qmc local x11 ++1014 libpcp_qmc local x11 ++1015 libpcp_qmc local x11 ++1016 libpcp_qmc local x11 ++1017:retired libpcp_qmc local flakey kernel x11 ++1018:retired libpcp_qmc local flakey x11 ++1019:retired libpcp_qmc local flakey pmstore x11 ++1020:retired libpcp_qmc local flakey pmstore x11 ++1021 libpcp_qmc local x11 ++1022 pmdumptext local kernel x11 ++1023 pmdumptext local x11 ++1024 pmda.linux local kernel ++1025 pmdumptext pmlogger pmdumplog pmloglabel local x11 ++1026 pmdumptext remote kernel x11 ++1027 pmdumptext local pmstore x11 ++1028 pmdumptext local kernel x11 ++1029 libpcp_qmc local pmstore x11 ++1030 pmda.linux local ++1031 pmda.slurm perl local ++1032 pmproxy containers local python ++1033 pmda.named local ++1034 pmda.named local ++1035 pmda.oracle local pmstore ++1036 pmclient archive multi-archive local pmlogextract python ++1037 pminfo archive multi-archive local pmlogextract ++1038 pmrep archive multi-archive local pmlogextract python ++1039 libpcp local ++1040 dbpmda local ++1041 pmda.libvirt local python ++1042 pmproxy pmda.proc local python ++1043 pmda.linux local kernel ++1044 pmie local pmieconf sanity ++1045 pmie local pmieconf pmpost ++1046 pmie local pmieconf ++1047 pmie local pmieconf ++1048 python local kernel ++1049 pmie pmieconf local ++1050 pmieconf local ++1051 pmieconf #696008 local ++1052 pmda.json local python ++1053 pmda.json pmda.install local python ++1054 pmlogger pmcpp local pmdumplog kernel ++1055 pmlogger local pmdumplog pmstore folio ++1056 derive local kernel ++1057 pmlogrewrite local ++1058 pmda.bash local ++1059 pmcd local ++1060 pmieutil local ++1061 pmda.lio local python ++1062 pmrep python local ++1063 derive local ++1064 derive local ++1065 libpcp valgrind local ++1066 derive valgrind local ++1067 zbxpcp local pmda.sample ++1068 pcp2zabbix python pcp2xxx local ++1069 pmrep python local timezone kernel ++1070 pmrep pmimport python perl local ++1071 pmrep python local kernel ++1072 pmrep python archive local kernel ++1073 pmda.linux local kernel ++1074 threads valgrind local helgrind ++1075 pmlogrewrite valgrind local ++1076 pmlogcheck local ++1077 pmcd libpcp archive local kernel ++1078 pcp python pidstat local ++1079 pcp atop local ++1080 valgrind pcp atop local ++1081 python pcp local ++1082 python local ++1083 pmcd local kernel ++1084 pmda.linux local ++1085 pmlogger local pmdumplog ++1086 pmprobe local ++1087 pmda.bind2 local ++1088:retired pmmgr local ++1089 atop local folio ++1090 pmproxy local context ++1091 pmns libpcp context local kernel ++1092 libpcp local ++1093 pmcpp local ++1094 other local ++1095 derive local kernel ++1096:retired libpcp threads pmmgr local ++1097 pmlogconf local ++1098 python local pmstore sanity ++1099 archive iostat local pmie pcp python ++1100 bash local pcp2xxx pcp2elasticsearch pcp2xlsx pcp2influxdb pcp2graphite pmrep python pcp2zabbix pcp2xml pcp2json ++1101 libpcp_web local valgrind ++1102 pmda.openmetrics local python ++1103 derive local ++1104 kernel local ++1105 derive local kernel ++1106 libpcp local ++1107 pmie local ++1108 logutil local folio pmlogextract ++1109 pmlogger valgrind local pmdumplog ++1110 pmda.haproxy local python ++1111 pcp2influxdb python pcp2xxx local ++1112 pmda.linux local ++1113 pcp ipcs python local ++1114 archive pmval multi-archive local pmlogextract kernel ++1115 pmda.bcc local python ++1116 pmda.bcc local python ++1117 pmda.bcc local python labels kernel ++1118 pmda.bcc local python labels ++1119 pmlogsummary archive multi-archive decompress-xz local pmlogextract ++1120 pmda.openmetrics local python ++1121 pmda.linux local kernel ++1122 pmie local ++1123 pmchart local kernel x11 ++1124 pmda.bcc local python ++1125:retired pmcollect ++1126 pmda.bcc local python ++1127 pmda.bcc local python ++1128 pmie local ++1129 derive local kernel ++1130 pcp2elasticsearch python pcp2xxx local ++1131 pcp2json python pcp2xxx local ++1132 pcp2xlsx python pcp2xxx local kernel ++1133 pcp2xml python pcp2xxx local ++1134 pmrep pcp2json pcp2xml python pcp2xxx local python kernel ++1135 pmrep python pmda.sample archive local kernel ++1136 pmrep python pmda.sample local kernel ++1137 derive pmrep local python kernel ++1138 archive pmval multi-archive decompress-xz local pmlogextract kernel ++1139 pmrep python local kernel ++1140 pidstat local python pcp pmlogrewrite pmrep derive free ++1141 selinux local ++1142 pmie local kernel ++1143 pmie local ++1144 pmda.proc local ++1145 fault libpcp local ++1146 logutil local ++1147 logutil local ++1148 logutil local ++1149 pmlogrewrite local ++1150 pmda.bcc local python ++1151 pmda.bcc local python ++1152 pmda.bcc local python ++1153 pmda.bcc local python ++1154 pmda.bcc local python ++1155 pmda.bcc local python ++1156 pmda.bcc local python ++1157 pmda.bcc local python ++1158 pmda.bcc local python ++1159 pmlogger local pmdumplog kernel ++1160 pmda.netcheck local python ++1161 pmda.netcheck local python ++1162 find-filter local ++1163 pmlogrewrite local ++1164 pmda.linux local valgrind ++1165 pmda.bcc local python ++1166 libpcp local ++1167 pmdumplog labels archive local pmrep python kernel ++1168 pmrep pmda.bcc local python ++1169 pmrep python local kernel ++1170 pmda.bcc local python ++1171 pmda.bcc local python ++1172 pmda.bcc local python ++1173 pmda.bcc local python ++1174 threads valgrind local helgrind ++1175 pmda.bcc local python ++1176 pmda.bcc local python ++1177 pmns derive libpcp pmlogger local kernel ++1178 pmda.bcc local python ++1179 pmda.bcc local python ++1180 logutil local pmrep python ++1181 pmda.bcc local python ++1182 libpcp local ++1183 pmrep python archive local ++1184 pminfo pmseries local ++1185 pmrep python archive local ++1186 pmie local not_in_ci ++1187 python pcp dstat local ++1188 pmda.dm local valgrind ++1189 find-filter local ++1190 other local ++1191 pmda.openmetrics local python ++1192 containers local ++1193 pmlogrewrite labels help pmdumplog local ++1194 pmlogrewrite local ++1195 pmlogrewrite local ++1196 pmcd local ++1197 pmlogextract local ++1198 pmlogrewrite pmda.linux local ++1199 libpcp pmcd local ++1200 logutil local ++1201 logutil remote ++1202 pmda.dm local pmrep python ++1203 derive pmval libpcp local ++1204 pmlogctl local sanity ++1205 pmlogctl local ++1206 pmlogctl local ++1207 pcp dstat python local ++1208 pmlogctl local ++1209 pmlogctl local ++1210 pmlogctl local ++1211 pmseries local kernel ++1212 pmseries local ++1213 pmlogctl local ++1214 pmproxy pmseries libpcp_web local ++1215 pmlogctl local ++1216 pmlogctl local ++1217 pmrep python local ++1218 pmda.root local ++1219 pcp local ++1220 pmda.proc local ++1221 labels pmda.openmetrics local python ++1222 pmda.linux pmda.proc local valgrind ++1223 pmlogctl local ++1224 pcp dstat python local ++1225:retired pmwebd local pmrep python pcp kernel ++1226 pmiectl local ++1227 derive local ++1228 pmiectl local ++1229 pmlogextract pmdumplog labels help local sanity ++1230 pmiectl local ++1231 pmlogrewrite labels help pmdumplog local ++1232 logutil pmlogctl local ++1233 derive local ++1234 libpcp_web local ++1235 derive local ++1236 derive local ++1237 derive local ++1238 iostat archive multi-archive decompress-xz local pmlogextract pcp python ++1239 pmlogrewrite labels pmdumplog local ++1240 libpcp pmrep local python ++1241 pmlogrewrite local ++1242 pmrep archive multi-archive decompress-xz local pmlogextract python ++1243 valgrind pmfind libpcp local helgrind ++1244 pmlogextract local ++1245 libpcp local ++1246:reserved pmlogreduce local ++1247 pmlogrewrite labels pmdumplog local ++1248 pmlogctl local ++1249 pmiectl local ++1250 selinux local ++1251 man local ++1252 derive local ++1253 derive local valgrind ++1254 derive local ++1255 libpcp local kernel ++1256 derive valgrind local ++1257 libpcp python local ++1258 pmda.linux local valgrind ++1259 derive valgrind local ++1260 derive local ++1261 derive local ++1262 derive valgrind local ++1263 derive local ++1264:retired pmcollect ++1265 pmda.linux local valgrind ++1266 atop pcp local ++1267 pmlogrewrite labels help pmdumplog local ++1268 derive local ++1269 libpcp local kernel ++1270 derive fault local ++1271 derive local ++1272 pmlogmv local ++1273 pmlogger fetch local ++1274 pmlogextract pmdumplog labels help local sanity ++1275 man pmlogger local ++1276:retired pmmgr containers local ++1277 dbpmda local pmdbg ++1278 dbpmda local pmdbg ++1279 dbpmda local ++1280 archive pmdumplog local ++1281 archive pmdumplog valgrind local ++1282:retired other local ++1283 dbpmda local ++1284 pmrep pmda.linux local ++1285 pmlogsummary local ++1286 pmda.bcc local python ++1287 pmda.install pmda.openmetrics local python ++1288 archive pmval local ++1289 pmval archive multi-archive decompress-xz local pmlogextract ++1290:reserved pmproxy local pmval pmie pmstat valgrind pmdumptext ++1291 atop archive local ++1292 pmlc local ++1293 pmlc local valgrind ++1294 libpcp_mmv labels local valgrind ++1295 pmda.sample local ++1296 pmie local ++1297 pmieutil local ++1298 pmval local ++1299 libpcp pminfo local ++1300 libpcp local ++1301 pmda.pmproxy pmda.mmv local ++1302 pmlogrewrite valgrind local ++1303 pcp dstat python local ++1304 pmstat context context_local local ++1305 pmlogger local valgrind ++1306 pmda.openmetrics labels local python ++1307 dbpmda pmda.sample local ++1308 dbpmda pmda.sample valgrind local ++1309 pmda.zfs local ++1310 labels python local ++1311 derive pmdumptext local ++1312 derive pmdumptext valgrind local ++1313 libpcp local ++1314 libpcp valgrind local ++1315 sanity local ++1316 libpcp local ++1317 libpcp local valgrind ++1318 pmprobe pmlogconf local kernel ++1319 libpcp local valgrind helgrind ++1320 pmval local ++1321 pmlogger pmda.openmetrics local python ++1322 pmval local valgrind ++1323 pmlogrewrite labels help pmdumplog local ++1324 pmclient archive multi-archive decompress-xz local pmlogextract python ++1325 pmdumplog local ++1326 pmstore pmda.pmcd local ++1327 pmdumplog local valgrind ++1330 pmda.openmetrics local python ++1331 verify local ++1337 pmda.mssql local ++1338 pmlogrewrite labels pmdumplog local ++1340 pmcd pmda.pmcd pmstore local ++1342 pmda.openmetrics local python ++1343:retired pmmgr local pmlogrewrite ++1344:retired pmmgr local ++1347 atop pcp local ++1349 pmlogrewrite labels pmdumplog local kernel ++1350 pmda.proc local ++1351 pmcd pmda.mmv libpcp pmda local ++1354 pmval archive local ++1357 pmda.podman valgrind local ++1358 pmda.podman local ++1359 libpcp local pmdbg ++1362 pmda.postgresql local ++1367 labels pmda.simple local python ++1368 labels help pmlogger pmdumplog local sanity ++1369 labels pmcd pmlogger pmdumplog local ++1370:reserved man local ++1372 pmie local ++1379 pmproxy local ++1383 pmlogrewrite labels pmdumplog local ++1385 pmda.openmetrics local python ++1388 pmproxy local secure ++1389:retired pmwebd local ++1390 atop pcp local ++1393 pmda.linux local ++1395 pmda.openmetrics local python ++1396 pcp python pidstat local archive ++1397 pmda.smart local valgrind ++1398 pidstat local ++1399 pidstat local ++1400 pcp free local ++1401 pmproxy local ++1403 pmda.linux local valgrind ++1407 pmchart derive local x11 ++1408 pmchart libpcp_qmc local x11 ++1415 pmda.mmv labels local ++1416 pmlogrewrite local ++1422 pmda.mmv local valgrind ++1423 pcp2spark python pcp2xxx local ++1433 pmproxy local ++1434 pmda.nfsclient local ++1435 pmda.elasticsearch local ++1436 pmda.postgresql local ++1437 pmda.kvm local ++1455 pmlogrewrite labels pmdumplog local ++1457 pmproxy local ++1480 pmda.lmsensors local ++1489 python pmrep pmimport local ++1490 python local labels ++1495 pmlogrewrite labels pmdumplog local ++1511 pmcd local ++1530 pmda.zfs local valgrind ++1531 pmda.zfs local valgrind ++1532 pmda.zfs local ++1533 pmda.zfs local valgrind ++1534 pmda.zfs local valgrind ++1543 pmproxy local ++1544 pmproxy python local ++1545 pcp2xml python pcp2xxx local ++1546 pmrep python local ++1547 pmrep python local ++1548 pmrep python local ++1549 pmrep python local ++1566 logutil libpcp local ++1573 pmproxy libpcp_web pmlogger local ++1588 python iostat local ++1598 pmda.statsd local ++1599 pmda.statsd local ++1600 pmseries pmcd pmproxy pmlogger local ++1601 pmseries pmproxy local ++1602 pmproxy local ++1603 pmproxy local ++1608 pmproxy local ++1613 pmda.linux kernel local ++1622 selinux local ++1623 libpcp_import collectl local ++1634 pmda.sockets local ++1644 pmda.perfevent local ++1660 libpcp labels local ++1661 pmproxy libpcp_web pmlogger local ++1671 multi-archive archive libpcp pmrep local python ++1672 secure pmcd local ++1680 openvswitch local ++1681 pmrep pcp2xxx pmlogconf local ++1682 pmrep pcp2xxx pmlogconf valgrind local ++1688 pmieconf local ++1689 pmproxy libpcp_web local ++1690 pmseries local ++1692 pmda.pmcd local ++1694 pidstat local python pcp ++1695 pmproxy valgrind local ++1696 pmproxy valgrind local ++1700 pmda.bpftrace local python ++1701 pmda.bpftrace local python ++1702 pmda.bpftrace local python ++1703 pmda.bpftrace local python ++1704 pmda.bpftrace local python ++1705 pmda.bpftrace local python ++1706 pmda.bpftrace local python ++1707 pmda.bpftrace local python ++1708 pmda.statsd local ++1709 pmda.statsd local ++1710 pmda.statsd local ++1711 pmda.statsd local ++1712 pmda.statsd local ++1713 pmda.statsd local ++1714 pmda.statsd local ++1715 pmda.statsd local ++1716 pmda.statsd local ++1717 pmda.statsd local ++1718 pmda.statsd local ++1719 pmda.statsd local ++1720 pmda.statsd local valgrind dbpmda ++1721 pmda.bpftrace local python ++1722 pmda.bpftrace local python ++1723 pmda.bpftrace local python ++1724 pmda.bpftrace local python ++1725 pmda.bpftrace local python ++1740 pmda.proc local ++1745 pmlogger libpcp pmval local ++1748 atop local ++1753 fetch valgrind local ++1763 pmlogctl local ++1768 pmfind local ++1769 pmda.linux local ++1773 pmseries pmproxy libpcp_web local ++1775 pmdumptext archive local ++1793 pmrep pcp2xxx python local ++1801 dstat python pcp local ++1805 pmda.linux kernel local ++1813 python labels local ++1814 pmda.linux local ++1820 atop local ++1821 pmlogpaste local ++1824 pmproxy local ++1825 libpcp pmcd local valgrind ++1826 libpcp pmcd local ++1837 pmproxy local ++1844 pmdumptext libpcp_qmc remote ++1850 pmseries libpcp_web local ++1855 pmda.rabbitmq local ++1871 pmsearch local ++1872 pmproxy local ++1874 pmseries pmproxy local ++1876 pmcd secure local ++1886 pmseries libpcp_web local ++1896 pmlogger logutil pmlc local ++1897 pmda.hacluster local valgrind ++1899 fetch local ++1901 pmlogger local ++1902 help local ++1937 pmlogrewrite pmda.xfs local ++1955 libpcp pmda pmda.pmcd local ++4751 libpcp threads valgrind local pcp helgrind +diff -Naurp pcp-5.3.1.orig/qa/src/check_pmi_errconv.c pcp-5.3.1/qa/src/check_pmi_errconv.c +--- pcp-5.3.1.orig/qa/src/check_pmi_errconv.c 1970-01-01 10:00:00.000000000 +1000 ++++ pcp-5.3.1/qa/src/check_pmi_errconv.c 2021-06-24 17:22:58.945372343 +1000 +@@ -0,0 +1,61 @@ ++/* ++ * check error handling with pmiWrite after PM_ERR_CONV. ++ * ++ * Copyright (c) 2021 Red Hat. All Rights Reserved. ++ */ ++ ++#include ++#include ++ ++int ++main(int argc, char **argv) ++{ ++ pmInDom indom = pmInDom_build(245, 0); ++ pmID pmid = pmID_build(245, 0, 0); ++ int sts; ++ ++ if (argc != 2) { ++ fprintf(stderr, "Usage: %s \n", argv[0]); ++ exit(2); ++ } ++ ++ if ((sts = pmiStart(argv[1], 0)) < 0) { ++ fprintf(stderr, "pmiStart: %s - %s\n", argv[1], pmiErrStr(sts)); ++ exit(1); ++ } ++ if ((sts = pmiSetTimezone("UTC")) < 0) { ++ fprintf(stderr, "pmiSetTimezone(UTC): %s\n", pmiErrStr(sts)); ++ exit(1); ++ } ++ ++ if ((sts = pmiAddMetric("my.metric.int", pmid, PM_TYPE_32, ++ indom, PM_SEM_INSTANT, pmiUnits(0,0,0,0,0,0))) < 0) { ++ fprintf(stderr, "pmiAddMetric: %s\n", pmiErrStr(sts)); ++ exit(1); ++ } ++ if ((sts = pmiAddInstance(indom, "0", 0)) < 0) { ++ fprintf(stderr, "pmiAddInstance(0): %s\n", pmiErrStr(sts)); ++ exit(1); ++ } ++ if ((sts = pmiAddInstance(indom, "1", 1)) < 0) { ++ fprintf(stderr, "pmiAddInstance(1): %s\n", pmiErrStr(sts)); ++ exit(1); ++ } ++ ++ /* FALLTHROUGH on all error paths now to exercise the problem */ ++ ++ if ((sts = pmiPutValue("my.metric.int", "0", "1234.5678")) < 0) ++ fprintf(stderr, "pmiPutValue: inst 0: %s\n", pmiErrStr(sts)); ++ ++ if ((sts = pmiPutValue("my.metric.int", "1", "123.45678")) < 0) ++ fprintf(stderr, "pmiPutValue: inst 1: %s\n", pmiErrStr(sts)); ++ ++ /* TZ=UTC date --date='@1547483647' */ ++ if ((sts = pmiWrite(1547483647, 0)) < 0) ++ fprintf(stderr, "pmiWrite: %s\n", pmiErrStr(sts)); ++ ++ if ((sts = pmiEnd()) < 0) ++ fprintf(stderr, "pmiEnd: %s\n", pmiErrStr(sts)); ++ ++ return 0; ++} +diff -Naurp pcp-5.3.1.orig/qa/src/.gitignore pcp-5.3.1/qa/src/.gitignore +--- pcp-5.3.1.orig/qa/src/.gitignore 2021-05-26 17:43:26.000000000 +1000 ++++ pcp-5.3.1/qa/src/.gitignore 2021-06-24 17:22:58.945372343 +1000 +@@ -26,6 +26,7 @@ check_import + check_import_name + check_import.pl + check_pmiend_fdleak ++check_pmi_errconv + checkstructs + chkacc1 + chkacc2 +diff -Naurp pcp-5.3.1.orig/qa/src/GNUlocaldefs pcp-5.3.1/qa/src/GNUlocaldefs +--- pcp-5.3.1.orig/qa/src/GNUlocaldefs 2021-05-26 17:43:26.000000000 +1000 ++++ pcp-5.3.1/qa/src/GNUlocaldefs 2021-06-24 17:22:58.945372343 +1000 +@@ -1,5 +1,5 @@ + # +-# Copyright (c) 2012-2020 Red Hat. ++# Copyright (c) 2012-2021 Red Hat. + # Copyright (c) 2009 Aconex. All Rights Reserved. + # Copyright (c) 1997-2002 Silicon Graphics, Inc. All Rights Reserved. + # +@@ -42,9 +42,9 @@ CFILES = disk_test.c exercise.c context_ + username.c rtimetest.c getcontexthost.c badpmda.c chkputlogresult.c \ + churnctx.c badUnitsStr_r.c units-parse.c rootclient.c derived.c \ + lookupnametest.c getversion.c pdubufbounds.c statvfs.c storepmcd.c \ +- github-50.c archfetch.c sortinst.c fetchgroup.c \ ++ github-50.c archfetch.c sortinst.c fetchgroup.c loadconfig2.c \ + loadderived.c sum16.c badmmv.c multictx.c mmv_simple.c \ +- httpfetch.c json_test.c check_pmiend_fdleak.c loadconfig2.c \ ++ httpfetch.c json_test.c check_pmiend_fdleak.c check_pmi_errconv.c \ + archctl_segfault.c debug.c int2pmid.c int2indom.c exectest.c \ + unpickargs.c hanoi.c progname.c countmark.c \ + indom2int.c pmid2int.c scanmeta.c traverse_return_codes.c \ +@@ -537,6 +537,10 @@ check_pmiend_fdleak: check_pmiend_fdleak + rm -f $@ + $(CCF) $(CDEFS) -o $@ $@.c $(LDLIBS) -lpcp_import + ++check_pmi_errconv: check_pmi_errconv.c ++ rm -f $@ ++ $(CCF) $(CDEFS) -o $@ $@.c $(LDLIBS) -lpcp_import ++ + # --- need libpcp_web + # + +diff -Naurp pcp-5.3.1.orig/src/libpcp_import/src/stuff.c pcp-5.3.1/src/libpcp_import/src/stuff.c +--- pcp-5.3.1.orig/src/libpcp_import/src/stuff.c 2021-02-25 10:10:21.000000000 +1100 ++++ pcp-5.3.1/src/libpcp_import/src/stuff.c 2021-06-24 17:22:58.945372343 +1000 +@@ -39,13 +39,10 @@ _pmi_stuff_value(pmi_context *current, p + + if (current->result == NULL) { + /* first time */ +- current->result = (pmResult *)malloc(sizeof(pmResult)); ++ current->result = (pmResult *)calloc(1, sizeof(pmResult)); + if (current->result == NULL) { +- pmNoMem("_pmi_stuff_value: result malloc:", sizeof(pmResult), PM_FATAL_ERR); ++ pmNoMem("_pmi_stuff_value: result calloc", sizeof(pmResult), PM_FATAL_ERR); + } +- current->result->numpmid = 0; +- current->result->timestamp.tv_sec = 0; +- current->result->timestamp.tv_usec = 0; + } + rp = current->result; + +@@ -60,19 +57,26 @@ _pmi_stuff_value(pmi_context *current, p + } + if (i == rp->numpmid) { + rp->numpmid++; +- size = sizeof(pmResult) + (rp->numpmid - 1)*sizeof(pmValueSet *); ++ size = sizeof(pmResult) + (rp->numpmid-1)*sizeof(pmValueSet *); + rp = current->result = (pmResult *)realloc(current->result, size); + if (current->result == NULL) { +- pmNoMem("_pmi_stuff_value: result realloc:", size, PM_FATAL_ERR); ++ pmNoMem("_pmi_stuff_value: result realloc", size, PM_FATAL_ERR); + } + rp->vset[rp->numpmid-1] = (pmValueSet *)malloc(sizeof(pmValueSet)); + if (rp->vset[rp->numpmid-1] == NULL) { +- pmNoMem("_pmi_stuff_value: vset alloc:", sizeof(pmValueSet), PM_FATAL_ERR); ++ pmNoMem("_pmi_stuff_value: vset alloc", sizeof(pmValueSet), PM_FATAL_ERR); + } + vsp = rp->vset[rp->numpmid-1]; + vsp->pmid = pmid; + vsp->numval = 1; + } ++ else if (rp->vset[i]->numval < 0) { ++ /* ++ * This metric is already under an error condition - do ++ * not attempt to add additional instances / values now. ++ */ ++ return rp->vset[i]->numval; ++ } + else { + int j; + for (j = 0; j < rp->vset[i]->numval; j++) { +@@ -84,7 +88,7 @@ _pmi_stuff_value(pmi_context *current, p + size = sizeof(pmValueSet) + (rp->vset[i]->numval-1)*sizeof(pmValue); + vsp = rp->vset[i] = (pmValueSet *)realloc(rp->vset[i], size); + if (rp->vset[i] == NULL) { +- pmNoMem("_pmi_stuff_value: vset realloc:", size, PM_FATAL_ERR); ++ pmNoMem("_pmi_stuff_value: vset realloc", size, PM_FATAL_ERR); + } + } + vp = &vsp->vlist[vsp->numval-1]; +@@ -92,75 +96,82 @@ _pmi_stuff_value(pmi_context *current, p + dsize = -1; + switch (mp->desc.type) { + case PM_TYPE_32: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_INSITU; + vp->value.lval = (__int32_t)strtol(value, &end, 10); + if (*end != '\0') { +- vsp->numval = PM_ERR_CONV; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_CONV; ++ else rp->vset[i]->numval--; + return PM_ERR_CONV; + } ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_INSITU; + break; + + case PM_TYPE_U32: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_INSITU; + vp->value.lval = (__uint32_t)strtoul(value, &end, 10); + if (*end != '\0') { +- vsp->numval = PM_ERR_CONV; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_CONV; ++ else rp->vset[i]->numval--; + return PM_ERR_CONV; + } ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_INSITU; + break; + + case PM_TYPE_64: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + ll = strtoint64(value, &end, 10); + if (*end != '\0') { +- vsp->numval = PM_ERR_CONV; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_CONV; ++ else rp->vset[i]->numval--; + return PM_ERR_CONV; + } + dsize = sizeof(ll); + data = (void *)≪ ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + break; + + case PM_TYPE_U64: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + ull = strtouint64(value, &end, 10); + if (*end != '\0') { +- vsp->numval = PM_ERR_CONV; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_CONV; ++ else rp->vset[i]->numval--; + return PM_ERR_CONV; + } + dsize = sizeof(ull); + data = (void *)&ull; ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + break; + + case PM_TYPE_FLOAT: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + f = strtof(value, &end); + if (*end != '\0') { +- vsp->numval = PM_ERR_CONV; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_CONV; ++ else rp->vset[i]->numval--; + return PM_ERR_CONV; + } + dsize = sizeof(f); + data = (void *)&f; ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + break; + + case PM_TYPE_DOUBLE: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + d = strtod(value, &end); + if (*end != '\0') { +- vsp->numval = PM_ERR_CONV; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_CONV; ++ else rp->vset[i]->numval--; + return PM_ERR_CONV; + } + dsize = sizeof(d); + data = (void *)&d; ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + break; + + case PM_TYPE_STRING: +- if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + dsize = strlen(value)+1; + data = (void *)value; ++ if (vsp->numval == 1) vsp->valfmt = PM_VAL_DPTR; + break; + + default: +- vsp->numval = PM_ERR_TYPE; ++ if (vsp->numval == 1) vsp->numval = PM_ERR_TYPE; ++ else rp->vset[i]->numval--; + return PM_ERR_TYPE; + } + +@@ -170,7 +181,7 @@ _pmi_stuff_value(pmi_context *current, p + + vp->value.pval = (pmValueBlock *)malloc(need < sizeof(pmValueBlock) ? sizeof(pmValueBlock) : need); + if (vp->value.pval == NULL) { +- pmNoMem("_pmi_stuff_value: pmValueBlock:", need < sizeof(pmValueBlock) ? sizeof(pmValueBlock) : need, PM_FATAL_ERR); ++ pmNoMem("_pmi_stuff_value: pmValueBlock", need < sizeof(pmValueBlock) ? sizeof(pmValueBlock) : need, PM_FATAL_ERR); + } + vp->value.pval->vlen = (int)need; + vp->value.pval->vtype = mp->desc.type; +diff -Naurp pcp-5.3.1.orig/src/python/pcp/pmconfig.py pcp-5.3.1/src/python/pcp/pmconfig.py +--- pcp-5.3.1.orig/src/python/pcp/pmconfig.py 2021-05-20 15:04:32.000000000 +1000 ++++ pcp-5.3.1/src/python/pcp/pmconfig.py 2021-06-24 17:22:58.946372326 +1000 +@@ -869,8 +869,8 @@ class pmConfig(object): + self.util.metrics[metric][3] = 1 + else: + self.util.metrics[metric][3] = 0 +- # As a special service for the pmrep(1) utility, +- # we force raw output with its archive mode. ++ # Force raw output with archive mode of any tool in order to ++ # create pmlogger(1) compatible archives that can be merged. + if (hasattr(self.util, 'type') and self.util.type == 1) or \ + self.util.metrics[metric][3] == 'raw' or \ + (hasattr(self.util, 'output') and self.util.output == 'archive'): +@@ -930,6 +930,11 @@ class pmConfig(object): + if not self.util.metrics[metric][2]: + self.util.metrics[metric][2] = str(unit) + ++ # Force native units with archive mode of any tool in order to ++ # create pmlogger(1) compatible archives that can be merged. ++ if hasattr(self.util, 'output') and self.util.output == 'archive': ++ self.util.metrics[metric][2] = str(unit) ++ + # Finalize text label and unit/scale + try: + label = self.util.metrics[metric][2] diff --git a/SPECS/pcp.spec b/SPECS/pcp.spec index 82a2da0..ab3962e 100644 --- a/SPECS/pcp.spec +++ b/SPECS/pcp.spec @@ -1,6 +1,6 @@ Name: pcp Version: 5.3.1 -Release: 1%{?dist} +Release: 2%{?dist} Summary: System-level performance monitoring and performance management License: GPLv2+ and LGPLv2+ and CC-BY URL: https://pcp.io @@ -8,6 +8,9 @@ URL: https://pcp.io %global artifactory https://performancecopilot.jfrog.io/artifactory Source0: %{artifactory}/pcp-source-release/pcp-%{version}.src.tar.gz +Patch000: redhat-bugzilla-1947989.patch +Patch001: redhat-bugzilla-1974266.patch + %if 0%{?fedora} >= 26 || 0%{?rhel} > 7 %global __python2 python2 %else @@ -2213,6 +2216,8 @@ updated policy package. %prep %setup -q +%patch000 -p1 +%patch001 -p1 %build # fix up build version @@ -3270,6 +3275,10 @@ PCP_LOG_DIR=%{_logsdir} %files zeroconf -f pcp-zeroconf-files.rpm %changelog +* Thu Jun 24 2021 Nathan Scott - 5.3.1-2 +- Fix pmproxy parallel TLS requests bug (BZ 1947989) +- Backport pmrep archive creation fix (BZ 1974266) + * Fri Jun 04 2021 Nathan Scott - 5.3.1-1 - Improved diagnostics from pmie service scripts (BZ 1954576) - Drop option configuration file env var setting (BZ 1967174)