The PORTS_STATS_NP carries RX/TX counters for each Message Type.
The following patch fills the spare slots in order to add the following 
counters:

(MSG_TYPES EVENT            0x0...0x3)
RX_BAD_MESSAGE              0x4
RX_BAD_PROTOCOL             0x5
RX_FAIL_RECEIVE             0x6
RX_MISSING_TIMESTAMP        0x7
(MSG_TYPES GENERAL          0x8...0xD)
RX_ANNOUNCE_FOREIGN_MASTER  0xE
RX_ANNOUNCE_CURRENT_MASTER  0xF

(MSG_TYPES EVENT            0x0...0x3)
TX_FAIL_TRANSMIT            0x6
TX_MISSING_TIMESTAMP        0x7
(MSG_TYPES GENERAL          0x8...0xD)
(AVAILABLE                  0xE...0xF)

The counters are properly updated by runtime when required.
---
 ddt.h  | 30 ++++++++++++++++++++++++++++++
 pmc.c  | 58 +++++++++++++++++++++++++++++++++++++---------------------
 port.c | 13 +++++++++++++
 3 files changed, 80 insertions(+), 21 deletions(-)

diff --git a/ddt.h b/ddt.h
index 5dc5530..71eec3d 100644
--- a/ddt.h
+++ b/ddt.h
@@ -107,6 +107,36 @@ struct PortStats {
        uint64_t txMsgType[MAX_MESSAGE_TYPES];
 };
 
+#define STATS_RX_SYNC                     0x0 // As Message Type
+#define STATS_RX_DELAY_REQ                0x1 // As Message Type
+#define STATS_RX_PDELAY_REQ               0x2 // As Message Type
+#define STATS_RX_PDELAY_RESP              0x3 // As Message Type
+#define STATS_RX_BAD_MESSAGE              0x4
+#define STATS_RX_BAD_PROTOCOL             0x5
+#define STATS_RX_FAIL_RECEIVE             0x6
+#define STATS_RX_MISSING_TIMESTAMP        0x7
+#define STATS_RX_FOLLOW_UP                0x8 // As Message Type
+#define STATS_RX_DELAY_RESP               0x9 // As Message Type
+#define STATS_RX_PDELAY_RESP_FOLLOW_UP    0xA // As Message Type
+#define STATS_RX_ANNOUNCE                 0xB // As Message Type
+#define STATS_RX_SIGNALING                0xC // As Message Type
+#define STATS_RX_MANAGEMENT               0xD // As Message Type
+#define STATS_RX_ANNOUNCE_FOREIGN_MASTER  0xE
+#define STATS_RX_ANNOUNCE_CURRENT_MASTER  0xF
+
+#define STATS_TX_SYNC                     0x0 // As Message Type
+#define STATS_TX_DELAY_REQ                0x1 // As Message Type
+#define STATS_TX_PDELAY_REQ               0x2 // As Message Type
+#define STATS_TX_PDELAY_RESP              0x3 // As Message Type
+#define STATS_TX_FAIL_TRANSMIT            0x6
+#define STATS_TX_MISSING_TIMESTAMP        0x7
+#define STATS_TX_FOLLOW_UP                0x8 // As Message Type
+#define STATS_TX_DELAY_RESP               0x9 // As Message Type
+#define STATS_TX_PDELAY_RESP_FOLLOW_UP    0xA // As Message Type
+#define STATS_TX_ANNOUNCE                 0xB // As Message Type
+#define STATS_TX_SIGNALING                0xC // As Message Type
+#define STATS_TX_MANAGEMENT               0xD // As Message Type
+
 struct PortServiceStats {
        uint64_t announce_timeout;
        uint64_t sync_timeout;
diff --git a/pmc.c b/pmc.c
index bc87058..c714196 100644
--- a/pmc.c
+++ b/pmc.c
@@ -521,6 +521,12 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
                        IFMT "rx_Announce               %" PRIu64
                        IFMT "rx_Signaling              %" PRIu64
                        IFMT "rx_Management             %" PRIu64
+                       IFMT "rx_Bad_Message            %" PRIu64
+                       IFMT "rx_Bad_Protocol           %" PRIu64
+                       IFMT "rx_Fail                   %" PRIu64
+                       IFMT "rx_Missing_Timestamp      %" PRIu64
+                       IFMT "rx_Announce_For_Master    %" PRIu64
+                       IFMT "rx_Announce_Cur_Master    %" PRIu64
                        IFMT "tx_Sync                   %" PRIu64
                        IFMT "tx_Delay_Req              %" PRIu64
                        IFMT "tx_Pdelay_Req             %" PRIu64
@@ -530,28 +536,38 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
                        IFMT "tx_Pdelay_Resp_Follow_Up  %" PRIu64
                        IFMT "tx_Announce               %" PRIu64
                        IFMT "tx_Signaling              %" PRIu64
-                       IFMT "tx_Management             %" PRIu64,
+                       IFMT "tx_Management             %" PRIu64
+                       IFMT "tx_Fail                   %" PRIu64
+                       IFMT "tx_Missing_Timestamp      %" PRIu64,
                        pid2str(&pcp->portIdentity),
-                       pcp->stats.rxMsgType[SYNC],
-                       pcp->stats.rxMsgType[DELAY_REQ],
-                       pcp->stats.rxMsgType[PDELAY_REQ],
-                       pcp->stats.rxMsgType[PDELAY_RESP],
-                       pcp->stats.rxMsgType[FOLLOW_UP],
-                       pcp->stats.rxMsgType[DELAY_RESP],
-                       pcp->stats.rxMsgType[PDELAY_RESP_FOLLOW_UP],
-                       pcp->stats.rxMsgType[ANNOUNCE],
-                       pcp->stats.rxMsgType[SIGNALING],
-                       pcp->stats.rxMsgType[MANAGEMENT],
-                       pcp->stats.txMsgType[SYNC],
-                       pcp->stats.txMsgType[DELAY_REQ],
-                       pcp->stats.txMsgType[PDELAY_REQ],
-                       pcp->stats.txMsgType[PDELAY_RESP],
-                       pcp->stats.txMsgType[FOLLOW_UP],
-                       pcp->stats.txMsgType[DELAY_RESP],
-                       pcp->stats.txMsgType[PDELAY_RESP_FOLLOW_UP],
-                       pcp->stats.txMsgType[ANNOUNCE],
-                       pcp->stats.txMsgType[SIGNALING],
-                       pcp->stats.txMsgType[MANAGEMENT]);
+                       pcp->stats.rxMsgType[STATS_RX_SYNC],
+                       pcp->stats.rxMsgType[STATS_RX_DELAY_REQ],
+                       pcp->stats.rxMsgType[STATS_RX_PDELAY_REQ],
+                       pcp->stats.rxMsgType[STATS_RX_PDELAY_RESP],
+                       pcp->stats.rxMsgType[STATS_RX_FOLLOW_UP],
+                       pcp->stats.rxMsgType[STATS_RX_DELAY_RESP],
+                       pcp->stats.rxMsgType[STATS_RX_PDELAY_RESP_FOLLOW_UP],
+                       pcp->stats.rxMsgType[STATS_RX_ANNOUNCE],
+                       pcp->stats.rxMsgType[STATS_RX_SIGNALING],
+                       pcp->stats.rxMsgType[STATS_RX_MANAGEMENT],
+                       pcp->stats.rxMsgType[STATS_RX_BAD_MESSAGE],
+                       pcp->stats.rxMsgType[STATS_RX_BAD_PROTOCOL],
+                       pcp->stats.rxMsgType[STATS_RX_FAIL_RECEIVE],
+                       pcp->stats.rxMsgType[STATS_RX_MISSING_TIMESTAMP],
+                       pcp->stats.rxMsgType[STATS_RX_ANNOUNCE_FOREIGN_MASTER],
+                       pcp->stats.rxMsgType[STATS_RX_ANNOUNCE_CURRENT_MASTER],
+                       pcp->stats.txMsgType[STATS_TX_SYNC],
+                       pcp->stats.txMsgType[STATS_TX_DELAY_REQ],
+                       pcp->stats.txMsgType[STATS_TX_PDELAY_REQ],
+                       pcp->stats.txMsgType[STATS_TX_PDELAY_RESP],
+                       pcp->stats.txMsgType[STATS_TX_FOLLOW_UP],
+                       pcp->stats.txMsgType[STATS_TX_DELAY_RESP],
+                       pcp->stats.txMsgType[STATS_TX_PDELAY_RESP_FOLLOW_UP],
+                       pcp->stats.txMsgType[STATS_TX_ANNOUNCE],
+                       pcp->stats.txMsgType[STATS_TX_SIGNALING],
+                       pcp->stats.txMsgType[STATS_TX_MANAGEMENT],
+                       pcp->stats.txMsgType[STATS_TX_FAIL_TRANSMIT],
+                       pcp->stats.txMsgType[STATS_TX_MISSING_TIMESTAMP]);
                break;
        case MID_PORT_SERVICE_STATS_NP:
                pssp = (struct port_service_stats_np *) mgt->data;
diff --git a/port.c b/port.c
index 5803cd3..514bd15 100644
--- a/port.c
+++ b/port.c
@@ -381,6 +381,8 @@ static int add_foreign_master(struct port *p, struct 
ptp_message *m)
        struct ptp_message *tmp;
        int broke_threshold = 0, diff = 0;
 
+       p->stats.rxMsgType[STATS_RX_ANNOUNCE_FOREIGN_MASTER]++;
+
        LIST_FOREACH(fc, &p->foreign_masters, list) {
                if (msg_source_equal(m, fc)) {
                        break;
@@ -1558,6 +1560,7 @@ static int port_pdelay_request(struct port *p)
                goto out;
        }
        if (msg_sots_missing(msg)) {
+               p->stats.txMsgType[STATS_TX_MISSING_TIMESTAMP]++;
                pr_err("missing timestamp on transmitted peer delay request");
                goto out;
        }
@@ -1620,6 +1623,7 @@ int port_delay_request(struct port *p)
                goto out;
        }
        if (msg_sots_missing(msg)) {
+               p->stats.txMsgType[STATS_TX_MISSING_TIMESTAMP]++;
                pr_err("missing timestamp on transmitted delay request");
                goto out;
        }
@@ -1759,6 +1763,7 @@ int port_tx_sync(struct port *p, struct address *dst, 
uint16_t sequence_id)
        if (p->timestamping == TS_ONESTEP || p->timestamping == TS_P2P1STEP) {
                goto out;
        } else if (msg_sots_missing(msg)) {
+               p->stats.txMsgType[STATS_TX_MISSING_TIMESTAMP]++;
                pr_err("missing timestamp on transmitted sync");
                err = -1;
                goto out;
@@ -2025,6 +2030,8 @@ static int update_current_master(struct port *p, struct 
ptp_message *m)
        if (!msg_source_equal(m, fc))
                return add_foreign_master(p, m);
 
+       p->stats.rxMsgType[STATS_RX_ANNOUNCE_CURRENT_MASTER]++;
+
        if (p->state != PS_PASSIVE) {
                tds.currentUtcOffset = m->announce.currentUtcOffset;
                tds.flags = m->header.flagField[1];
@@ -2345,6 +2352,7 @@ int process_pdelay_req(struct port *p, struct ptp_message 
*m)
        if (p->timestamping == TS_P2P1STEP) {
                goto out;
        } else if (msg_sots_missing(rsp)) {
+               p->stats.txMsgType[STATS_TX_MISSING_TIMESTAMP]++;
                pr_err("missing timestamp on transmitted peer delay response");
                err = -1;
                goto out;
@@ -2957,6 +2965,7 @@ static enum fsm_event bc_event(struct port *p, int 
fd_index)
 
        cnt = transport_recv(p->trp, fd, msg);
        if (cnt < 0) {
+               p->stats.rxMsgType[STATS_RX_FAIL_RECEIVE]++;
                pr_err("%s: recv message failed", p->log_name);
                msg_put(msg);
                return EV_FAULT_DETECTED;
@@ -2965,9 +2974,11 @@ static enum fsm_event bc_event(struct port *p, int 
fd_index)
        if (err) {
                switch (err) {
                case -EBADMSG:
+                       p->stats.rxMsgType[STATS_RX_BAD_MESSAGE]++;
                        pr_err("%s: bad message", p->log_name);
                        break;
                case -EPROTO:
+                       p->stats.rxMsgType[STATS_RX_BAD_PROTOCOL]++;
                        pr_debug("%s: ignoring message", p->log_name);
                        break;
                }
@@ -2983,6 +2994,7 @@ static enum fsm_event bc_event(struct port *p, int 
fd_index)
            !(p->timestamping == TS_P2P1STEP && msg_type(msg) == PDELAY_REQ)) {
                pr_err("%s: received %s without timestamp",
                       p->log_name, msg_type_string(msg_type(msg)));
+               p->stats.rxMsgType[STATS_RX_MISSING_TIMESTAMP]++;
                msg_put(msg);
                return EV_NONE;
        }
@@ -3076,6 +3088,7 @@ int port_prepare_and_send(struct port *p, struct 
ptp_message *msg,
                cnt = transport_send(p->trp, &p->fda, event, msg);
        }
        if (cnt <= 0) {
+               p->stats.txMsgType[STATS_TX_FAIL_TRANSMIT]++;
                return -1;
        }
        port_stats_inc_tx(p, msg);
-- 
2.41.0



_______________________________________________
Linuxptp-devel mailing list
Linuxptp-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linuxptp-devel

Reply via email to