Previously, only the logical port number was emitted for most
port-related log messages. Now, the interface name is included.
old: port 12: assuming the grand master role
new: port 12 (eth8): assuming the grand master role
Change-Id: I38f529a4b436f96e9803920bacc605790b3a0b45
Signed-off-by: Cliff Spradlin <csprad...@google.com>
---
clock.c | 24 +++---
e2e_tc.c | 12 +--
p2p_tc.c | 12 +--
port.c | 200 +++++++++++++++++++++++++++-------------------
port.h | 7 ++
port_signaling.c | 2 +-
tc.c | 30 ++++---
unicast_client.c | 51 +++++++-----
unicast_service.c | 3 +-
9 files changed, 205 insertions(+), 136 deletions(-)
diff --git a/clock.c b/clock.c
index 0156bc3..b30f2d1 100644
--- a/clock.c
+++ b/clock.c
@@ -296,19 +296,20 @@ static int clock_fault_timeout(struct port *port, int set)
struct fault_interval i;
if (!set) {
- pr_debug("clearing fault on port %d", port_number(port));
+ pr_debug("clearing fault on port %d (%s)", port_number(port),
+ port_name(port));
return port_set_fault_timer_lin(port, 0);
}
fault_interval(port, last_fault_type(port), &i);
if (i.type == FTMO_LINEAR_SECONDS) {
- pr_debug("waiting %d seconds to clear fault on port %d",
- i.val, port_number(port));
+ pr_debug("waiting %d seconds to clear fault on port %d (%s)",
+ i.val, port_number(port), port_name(port));
return port_set_fault_timer_lin(port, i.val);
} else if (i.type == FTMO_LOG2_SECONDS) {
- pr_debug("waiting 2^{%d} seconds to clear fault on port %d",
- i.val, port_number(port));
+ pr_debug("waiting 2^{%d} seconds to clear fault on port %d
(%s)",
+ i.val, port_number(port), port_name(port));
return port_set_fault_timer_log(port, 1, i.val);
}
@@ -1360,8 +1361,8 @@ static void clock_forward_mgmt_msg(struct clock *c,
struct port *p, struct ptp_m
msg->management.boundaryHops--;
LIST_FOREACH(piter, &c->ports, list) {
if (clock_do_forward_mgmt(c, p, piter, msg, &msg_ready))
- pr_err("port %d: management forward failed",
- port_number(piter));
+ pr_err("port %d (%s): management forward
failed",
+ port_number(piter), port_name(piter));
}
if (clock_do_forward_mgmt(c, p, c->uds_port, msg, &msg_ready))
pr_err("uds port: management forward failed");
@@ -1562,8 +1563,9 @@ int clock_poll(struct clock *c)
for (i = 0; i < N_POLLFD; i++) {
if (cur[i].revents & (POLLIN|POLLPRI|POLLERR)) {
if (cur[i].revents & POLLERR) {
- pr_err("port %d: unexpected socket
error",
- port_number(p));
+ pr_err("port %d (%s): "
+ "unexpected socket error",
+ port_number(p), port_name(p));
event = EV_FAULT_DETECTED;
} else {
event = port_event(p, i);
@@ -1882,8 +1884,8 @@ static void handle_state_decision_event(struct clock *c)
event = EV_NONE;
break;
case PS_GRAND_MASTER:
- pr_notice("port %d: assuming the grand master role",
- port_number(piter));
+ pr_notice("port %d (%s): assuming the grand master
role",
+ port_number(piter), port_name(piter));
clock_update_grandmaster(c);
event = EV_RS_GRAND_MASTER;
break;
diff --git a/e2e_tc.c b/e2e_tc.c
index 6aaf572..2632eb4 100644
--- a/e2e_tc.c
+++ b/e2e_tc.c
@@ -83,7 +83,7 @@ enum fsm_event e2e_event(struct port *p, int fd_index)
switch (fd_index) {
case FD_ANNOUNCE_TIMER:
case FD_SYNC_RX_TIMER:
- pr_debug("port %hu: %s timeout", portnum(p),
+ pr_debug("port %hu (%s): %s timeout", portnum(p), p->name,
fd_index == FD_SYNC_RX_TIMER ? "rx sync" : "announce");
if (p->best) {
fc_clear(p->best);
@@ -92,7 +92,7 @@ enum fsm_event e2e_event(struct port *p, int fd_index)
return EV_ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES;
case FD_DELAY_TIMER:
- pr_debug("port %hu: delay timeout", portnum(p));
+ pr_debug("port %hu (%s): delay timeout", portnum(p), p->name);
port_set_delay_tmo(p);
delay_req_prune(p);
tc_prune(p);
@@ -111,7 +111,8 @@ enum fsm_event e2e_event(struct port *p, int fd_index)
return event;
case FD_QUALIFICATION_TIMER:
- pr_debug("port %hu: qualification timeout", portnum(p));
+ pr_debug("port %hu (%s): qualification timeout", portnum(p),
+ p->name);
return EV_QUALIFICATION_TIMEOUT_EXPIRES;
case FD_MANNO_TIMER:
@@ -122,7 +123,8 @@ enum fsm_event e2e_event(struct port *p, int fd_index)
return EV_NONE;
case FD_RTNL:
- pr_debug("port %hu: received link status notification",
portnum(p));
+ pr_debug("port %hu (%s): received link status notification",
+ portnum(p), p->name);
rtnl_link_status(fd, p->name, port_link_status, p);
if (p->link_status == (LINK_UP|LINK_STATE_CHANGED)) {
return EV_FAULT_CLEARED;
@@ -142,7 +144,7 @@ enum fsm_event e2e_event(struct port *p, int fd_index)
cnt = transport_recv(p->trp, fd, msg);
if (cnt <= 0) {
- pr_err("port %hu: recv message failed", portnum(p));
+ pr_err("port %hu (%s): recv message failed", portnum(p),
p->name);
msg_put(msg);
return EV_FAULT_DETECTED;
}
diff --git a/p2p_tc.c b/p2p_tc.c
index acf9e51..becfb51 100644
--- a/p2p_tc.c
+++ b/p2p_tc.c
@@ -99,7 +99,7 @@ enum fsm_event p2p_event(struct port *p, int fd_index)
switch (fd_index) {
case FD_ANNOUNCE_TIMER:
case FD_SYNC_RX_TIMER:
- pr_debug("port %hu: %s timeout", portnum(p),
+ pr_debug("port %hu (%s): %s timeout", portnum(p), p->name,
fd_index == FD_SYNC_RX_TIMER ? "rx sync" : "announce");
if (p->best) {
fc_clear(p->best);
@@ -108,13 +108,14 @@ enum fsm_event p2p_event(struct port *p, int fd_index)
return EV_ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES;
case FD_DELAY_TIMER:
- pr_debug("port %hu: delay timeout", portnum(p));
+ pr_debug("port %hu (%s): delay timeout", portnum(p), p->name);
port_set_delay_tmo(p);
tc_prune(p);
return p2p_delay_request(p) ? EV_FAULT_DETECTED : EV_NONE;
case FD_QUALIFICATION_TIMER:
- pr_debug("port %hu: qualification timeout", portnum(p));
+ pr_debug("port %hu (%s): qualification timeout", portnum(p),
+ p->name);
return EV_QUALIFICATION_TIMEOUT_EXPIRES;
case FD_MANNO_TIMER:
@@ -125,7 +126,8 @@ enum fsm_event p2p_event(struct port *p, int fd_index)
return EV_NONE;
case FD_RTNL:
- pr_debug("port %hu: received link status notification",
portnum(p));
+ pr_debug("port %hu (%s): received link status notification",
+ portnum(p), p->name);
rtnl_link_status(fd, p->name, port_link_status, p);
if (p->link_status == (LINK_UP|LINK_STATE_CHANGED)) {
return EV_FAULT_CLEARED;
@@ -145,7 +147,7 @@ enum fsm_event p2p_event(struct port *p, int fd_index)
cnt = transport_recv(p->trp, fd, msg);
if (cnt <= 0) {
- pr_err("port %hu: recv message failed", portnum(p));
+ pr_err("port %hu (%s): recv message failed", portnum(p),
p->name);
msg_put(msg);
return EV_FAULT_DETECTED;
}
diff --git a/port.c b/port.c
index db3e9ac..8921ba8 100644
--- a/port.c
+++ b/port.c
@@ -349,8 +349,8 @@ static int add_foreign_master(struct port *p, struct
ptp_message *m)
}
}
if (!fc) {
- pr_notice("port %hu: new foreign master %s", portnum(p),
- pid2str(&m->header.sourcePortIdentity));
+ pr_notice("port %hu (%s): new foreign master %s", portnum(p),
+ p->name, pid2str(&m->header.sourcePortIdentity));
fc = malloc(sizeof(*fc));
if (!fc) {
@@ -621,53 +621,54 @@ int port_capable(struct port *p)
if (tmv_to_nanoseconds(p->peer_delay) > p->neighborPropDelayThresh) {
if (p->asCapable)
- pr_debug("port %hu: peer_delay (%" PRId64 ") >
neighborPropDelayThresh "
+ pr_debug("port %hu (%s): peer_delay (%" PRId64 ") >
neighborPropDelayThresh "
"(%" PRId32 "), resetting asCapable",
portnum(p),
- tmv_to_nanoseconds(p->peer_delay),
+ p->name, tmv_to_nanoseconds(p->peer_delay),
p->neighborPropDelayThresh);
goto not_capable;
}
if (tmv_to_nanoseconds(p->peer_delay) < p->min_neighbor_prop_delay) {
if (p->asCapable)
- pr_debug("port %hu: peer_delay (%" PRId64 ") <
min_neighbor_prop_delay "
+ pr_debug("port %hu (%s): peer_delay (%" PRId64 ") <
min_neighbor_prop_delay "
"(%" PRId32 "), resetting asCapable",
portnum(p),
- tmv_to_nanoseconds(p->peer_delay),
+ p->name, tmv_to_nanoseconds(p->peer_delay),
p->min_neighbor_prop_delay);
goto not_capable;
}
if (p->pdr_missing > ALLOWED_LOST_RESPONSES) {
if (p->asCapable)
- pr_debug("port %hu: missed %d peer delay resp, "
- "resetting asCapable", portnum(p),
p->pdr_missing);
+ pr_debug("port %hu (%s): missed %d peer delay resp, "
+ "resetting asCapable", portnum(p), p->name,
+ p->pdr_missing);
goto not_capable;
}
if (p->multiple_seq_pdr_count) {
if (p->asCapable)
- pr_debug("port %hu: multiple sequential peer delay
resp, "
- "resetting asCapable", portnum(p));
+ pr_debug("port %hu (%s): multiple sequential peer delay
resp, "
+ "resetting asCapable", portnum(p), p->name);
goto not_capable;
}
if (!p->peer_portid_valid) {
if (p->asCapable)
- pr_debug("port %hu: invalid peer port id, "
- "resetting asCapable", portnum(p));
+ pr_debug("port %hu (%s): invalid peer port id, "
+ "resetting asCapable", portnum(p), p->name);
goto not_capable;
}
if (!p->nrate.ratio_valid) {
if (p->asCapable)
- pr_debug("port %hu: invalid nrate, "
- "resetting asCapable", portnum(p));
+ pr_debug("port %hu (%s): invalid nrate, "
+ "resetting asCapable", portnum(p), p->name);
goto not_capable;
}
capable:
if (p->asCapable == NOT_CAPABLE) {
- pr_debug("port %hu: setting asCapable", portnum(p));
+ pr_debug("port %hu (%s): setting asCapable", portnum(p),
p->name);
p->asCapable = AS_CAPABLE;
}
return 1;
@@ -775,7 +776,8 @@ static void port_management_send_error(struct port *p,
struct port *ingress,
struct ptp_message *msg, int error_id)
{
if (port_management_error(p->portIdentity, ingress, msg, error_id))
- pr_err("port %hu: management error failed", portnum(p));
+ pr_err("port %hu (%s): management error failed", portnum(p),
+ p->name);
}
static const Octet profile_id_drr[] = {0x00, 0x1B, 0x19, 0x00, 0x01, 0x00};
@@ -1007,7 +1009,8 @@ static int port_management_set(struct port *target,
break;
}
if (respond && !port_management_get_response(target, ingress, id, req))
- pr_err("port %hu: failed to send management set response",
portnum(target));
+ pr_err("port %hu (%s): failed to send management set response",
+ portnum(target), target->name);
return respond ? 1 : 0;
}
@@ -1115,11 +1118,11 @@ void port_show_transition(struct port *p, enum
port_state next,
enum fsm_event event)
{
if (event == EV_FAULT_DETECTED) {
- pr_notice("port %hu: %s to %s on %s (%s)", portnum(p),
- ps_str[p->state], ps_str[next], ev_str[event],
+ pr_notice("port %hu (%s): %s to %s on %s (%s)", portnum(p),
+ p->name, ps_str[p->state], ps_str[next],
ev_str[event],
ft_str(last_fault_type(p)));
} else {
- pr_notice("port %hu: %s to %s on %s", portnum(p),
+ pr_notice("port %hu (%s): %s to %s on %s", portnum(p), p->name,
ps_str[p->state], ps_str[next], ev_str[event]);
}
}
@@ -1127,8 +1130,10 @@ void port_show_transition(struct port *p, enum
port_state next,
static void port_slave_priority_warning(struct port *p)
{
UInteger16 n = portnum(p);
- pr_warning("port %hu: master state recommended in slave only mode", n);
- pr_warning("port %hu: defaultDS.priority1 probably misconfigured", n);
+ pr_warning("port %hu (%s): master state recommended in slave only mode",
+ n, p->name);
+ pr_warning("port %hu (%s): defaultDS.priority1 probably misconfigured",
+ n, p->name);
}
static void message_interval_request(struct port *p,
@@ -1225,8 +1230,8 @@ static void port_syfufsm_print_mismatch(struct port *p,
enum syfu_event event,
else
expected_msgtype = SYNC;
- pr_debug("port %hu: have %s %hu, expecting %s but got %s %hu, dropping",
- portnum(p), msg_type_string(msg_type(p->last_syncfup)),
+ pr_debug("port %hu (%s): have %s %hu, expecting %s but got %s %hu,
dropping",
+ portnum(p), p->name,
msg_type_string(msg_type(p->last_syncfup)),
p->last_syncfup->header.sequenceId,
msg_type_string(expected_msgtype),
msg_type_string(msg_type(m)), m->header.sequenceId);
@@ -1361,7 +1366,8 @@ static int port_pdelay_request(struct port *p)
err = peer_prepare_and_send(p, msg, TRANS_EVENT);
if (err) {
- pr_err("port %hu: send peer delay request failed", portnum(p));
+ pr_err("port %hu (%s): send peer delay request failed",
+ portnum(p), p->name);
goto out;
}
if (msg_sots_missing(msg)) {
@@ -1424,7 +1430,8 @@ int port_delay_request(struct port *p)
}
if (port_prepare_and_send(p, msg, TRANS_EVENT)) {
- pr_err("port %hu: send delay request failed", portnum(p));
+ pr_err("port %hu (%s): send delay request failed",
+ portnum(p), p->name);
goto out;
}
if (msg_sots_missing(msg)) {
@@ -1484,12 +1491,14 @@ int port_tx_announce(struct port *p, struct address
*dst)
msg->announce.timeSource = tp.timeSource;
if (p->path_trace_enabled && path_trace_append(p, msg, dad)) {
- pr_err("port %hu: append path trace failed", portnum(p));
+ pr_err("port %hu (%s): append path trace failed", portnum(p),
+ p->name);
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: send announce failed", portnum(p));
+ pr_err("port %hu (%s): send announce failed", portnum(p),
+ p->name);
}
msg_put(msg);
return err;
@@ -1557,7 +1566,7 @@ int port_tx_sync(struct port *p, struct address *dst)
}
err = port_prepare_and_send(p, msg, event);
if (err) {
- pr_err("port %hu: send sync failed", portnum(p));
+ pr_err("port %hu (%s): send sync failed", portnum(p), p->name);
goto out;
}
if (p->timestamping == TS_ONESTEP || p->timestamping == TS_P2P1STEP) {
@@ -1589,14 +1598,16 @@ int port_tx_sync(struct port *p, struct address *dst)
fup->header.flagField[0] |= UNICAST;
}
if (p->follow_up_info && follow_up_info_append(fup)) {
- pr_err("port %hu: append fup info failed", portnum(p));
+ pr_err("port %hu (%s): append fup info failed",
+ portnum(p), p->name);
err = -1;
goto out;
}
err = port_prepare_and_send(p, fup, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: send follow up failed", portnum(p));
+ pr_err("port %hu (%s): send follow up failed",
+ portnum(p), p->name);
}
out:
msg_put(msg);
@@ -1893,7 +1904,8 @@ static int process_delay_req(struct port *p, struct
ptp_message *m)
}
if (p->delayMechanism == DM_P2P) {
- pr_warning("port %hu: delay request on P2P port", portnum(p));
+ pr_warning("port %hu (%s): delay request on P2P port",
+ portnum(p), p->name);
return 0;
}
@@ -1924,13 +1936,14 @@ static int process_delay_req(struct port *p, struct
ptp_message *m)
msg->header.logMessageInterval = 0x7f;
}
if (nsm && net_sync_resp_append(p, msg)) {
- pr_err("port %hu: append NSM failed", portnum(p));
+ pr_err("port %hu (%s): append NSM failed", portnum(p), p->name);
err = -1;
goto out;
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: send delay response failed", portnum(p));
+ pr_err("port %hu (%s): send delay response failed", portnum(p),
+ p->name);
goto out;
}
if (nsm) {
@@ -1990,13 +2003,13 @@ void process_delay_resp(struct port *p, struct
ptp_message *m)
}
if (rsp->hdr.logMessageInterval < -10 ||
rsp->hdr.logMessageInterval > 22) {
- pl_info(300, "port %hu: ignore bogus delay request interval
2^%d",
- portnum(p), rsp->hdr.logMessageInterval);
+ pl_info(300, "port %hu (%s): ignore bogus delay request
interval 2^%d",
+ portnum(p), p->name, rsp->hdr.logMessageInterval);
return;
}
p->logMinDelayReqInterval = rsp->hdr.logMessageInterval;
- pr_notice("port %hu: minimum delay request interval 2^%d",
- portnum(p), p->logMinDelayReqInterval);
+ pr_notice("port %hu (%s): minimum delay request interval 2^%d",
+ portnum(p), p->name, p->logMinDelayReqInterval);
port_set_delay_tmo(p);
}
@@ -2059,19 +2072,21 @@ int process_pdelay_req(struct port *p, struct
ptp_message *m)
}
if (p->delayMechanism == DM_E2E) {
- pr_warning("port %hu: pdelay_req on E2E port", portnum(p));
+ pr_warning("port %hu (%s): pdelay_req on E2E port", portnum(p),
+ p->name);
return 0;
}
if (p->delayMechanism == DM_AUTO) {
- pr_info("port %hu: peer detected, switch to P2P", portnum(p));
+ pr_info("port %hu (%s): peer detected, switch to P2P",
+ portnum(p), p->name);
p->delayMechanism = DM_P2P;
port_set_delay_tmo(p);
}
if (p->peer_portid_valid) {
if (!pid_eq(&p->peer_portid, &m->header.sourcePortIdentity)) {
- pr_err("port %hu: received pdelay_req msg with "
+ pr_err("port %hu (%s): received pdelay_req msg with "
"unexpected peer port id %s",
- portnum(p),
+ portnum(p), p->name,
pid2str(&m->header.sourcePortIdentity));
p->peer_portid_valid = 0;
port_capable(p);
@@ -2079,8 +2094,8 @@ int process_pdelay_req(struct port *p, struct ptp_message
*m)
} else {
p->peer_portid_valid = 1;
p->peer_portid = m->header.sourcePortIdentity;
- pr_debug("port %hu: peer port id set to %s", portnum(p),
- pid2str(&p->peer_portid));
+ pr_debug("port %hu (%s): peer port id set to %s", portnum(p),
+ p->name, pid2str(&p->peer_portid));
}
rsp = msg_allocate();
@@ -2127,7 +2142,8 @@ int process_pdelay_req(struct port *p, struct ptp_message
*m)
err = peer_prepare_and_send(p, rsp, event);
if (err) {
- pr_err("port %hu: send peer delay response failed", portnum(p));
+ pr_err("port %hu (%s): send peer delay response failed",
+ portnum(p), p->name);
goto out;
}
if (p->timestamping == TS_P2P1STEP) {
@@ -2165,7 +2181,8 @@ int process_pdelay_req(struct port *p, struct ptp_message
*m)
err = peer_prepare_and_send(p, fup, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: send pdelay_resp_fup failed", portnum(p));
+ pr_err("port %hu (%s): send pdelay_resp_fup failed",
+ portnum(p), p->name);
}
out:
msg_put(rsp);
@@ -2249,7 +2266,8 @@ int process_pdelay_resp(struct port *p, struct
ptp_message *m)
{
if (p->peer_delay_resp) {
if (!source_pid_eq(p->peer_delay_resp, m)) {
- pr_err("port %hu: multiple peer responses", portnum(p));
+ pr_err("port %hu (%s): multiple peer responses",
+ portnum(p), p->name);
if (!p->multiple_pdr_detected) {
p->multiple_pdr_detected = 1;
p->multiple_seq_pdr_count++;
@@ -2261,14 +2279,15 @@ int process_pdelay_resp(struct port *p, struct
ptp_message *m)
}
}
if (!p->peer_delay_req) {
- pr_err("port %hu: rogue peer delay response", portnum(p));
+ pr_err("port %hu (%s): rogue peer delay response", portnum(p),
+ p->name);
return -1;
}
if (p->peer_portid_valid) {
if (!pid_eq(&p->peer_portid, &m->header.sourcePortIdentity)) {
- pr_err("port %hu: received pdelay_resp msg with "
+ pr_err("port %hu (%s): received pdelay_resp msg with "
"unexpected peer port id %s",
- portnum(p),
+ portnum(p), p->name,
pid2str(&m->header.sourcePortIdentity));
p->peer_portid_valid = 0;
port_capable(p);
@@ -2276,8 +2295,8 @@ int process_pdelay_resp(struct port *p, struct
ptp_message *m)
} else {
p->peer_portid_valid = 1;
p->peer_portid = m->header.sourcePortIdentity;
- pr_debug("port %hu: peer port id set to %s", portnum(p),
- pid2str(&p->peer_portid));
+ pr_debug("port %hu (%s): peer port id set to %s", portnum(p),
+ p->name, pid2str(&p->peer_portid));
}
if (p->peer_delay_resp) {
@@ -2543,7 +2562,8 @@ void port_link_status(void *ctx, int linkup, int ts_index)
p->link_status = link_state;
} else {
p->link_status = link_state | LINK_STATE_CHANGED;
- pr_notice("port %hu: link %s", portnum(p), linkup ? "up" :
"down");
+ pr_notice("port %hu (%s): link %s", portnum(p), p->name,
+ linkup ? "up" : "down");
}
/* ts_label changed */
@@ -2551,7 +2571,8 @@ void port_link_status(void *ctx, int linkup, int ts_index)
if (if_indextoname(ts_index, ts_label) && strcmp(old_ts_label,
ts_label)) {
interface_set_label(p->iface, ts_label);
p->link_status |= TS_LABEL_CHANGED;
- pr_notice("port %hu: ts label changed to %s", portnum(p),
ts_label);
+ pr_notice("port %hu (%s): ts label changed to %s", portnum(p),
+ p->name, ts_label);
}
/* Both link down/up and change ts_label may change phc index. */
@@ -2603,7 +2624,7 @@ static enum fsm_event bc_event(struct port *p, int
fd_index)
switch (fd_index) {
case FD_ANNOUNCE_TIMER:
case FD_SYNC_RX_TIMER:
- pr_debug("port %hu: %s timeout", portnum(p),
+ pr_debug("port %hu (%s): %s timeout", portnum(p), p->name,
fd_index == FD_SYNC_RX_TIMER ? "rx sync" : "announce");
if (p->best) {
fc_clear(p->best);
@@ -2636,35 +2657,40 @@ static enum fsm_event bc_event(struct port *p, int
fd_index)
return EV_ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES;
case FD_DELAY_TIMER:
- pr_debug("port %hu: delay timeout", portnum(p));
+ pr_debug("port %hu (%s): delay timeout", portnum(p), p->name);
port_set_delay_tmo(p);
delay_req_prune(p);
return port_delay_request(p) ? EV_FAULT_DETECTED : EV_NONE;
case FD_QUALIFICATION_TIMER:
- pr_debug("port %hu: qualification timeout", portnum(p));
+ pr_debug("port %hu (%s): qualification timeout",
+ portnum(p), p->name);
return EV_QUALIFICATION_TIMEOUT_EXPIRES;
case FD_MANNO_TIMER:
- pr_debug("port %hu: master tx announce timeout", portnum(p));
+ pr_debug("port %hu (%s): master tx announce timeout",
+ portnum(p), p->name);
port_set_manno_tmo(p);
return port_tx_announce(p, NULL) ? EV_FAULT_DETECTED : EV_NONE;
case FD_SYNC_TX_TIMER:
- pr_debug("port %hu: master sync timeout", portnum(p));
+ pr_debug("port %hu (%s): master sync timeout", portnum(p),
p->name);
port_set_sync_tx_tmo(p);
return port_tx_sync(p, NULL) ? EV_FAULT_DETECTED : EV_NONE;
case FD_UNICAST_SRV_TIMER:
- pr_debug("port %hu: unicast service timeout", portnum(p));
+ pr_debug("port %hu (%s): unicast service timeout",
+ portnum(p), p->name);
return unicast_service_timer(p) ? EV_FAULT_DETECTED : EV_NONE;
case FD_UNICAST_REQ_TIMER:
- pr_debug("port %hu: unicast request timeout", portnum(p));
+ pr_debug("port %hu (%s): unicast request timeout", portnum(p),
+ p->name);
return unicast_client_timer(p) ? EV_FAULT_DETECTED : EV_NONE;
case FD_RTNL:
- pr_debug("port %hu: received link status notification",
portnum(p));
+ pr_debug("port %hu (%s): received link status notification",
+ portnum(p), p->name);
rtnl_link_status(fd, p->name, port_link_status, p);
if (p->link_status == (LINK_UP | LINK_STATE_CHANGED))
return EV_FAULT_CLEARED;
@@ -2683,7 +2709,7 @@ static enum fsm_event bc_event(struct port *p, int
fd_index)
cnt = transport_recv(p->trp, fd, msg);
if (cnt < 0) {
- pr_err("port %hu: recv message failed", portnum(p));
+ pr_err("port %hu (%s): recv message failed", portnum(p),
p->name);
msg_put(msg);
return EV_FAULT_DETECTED;
}
@@ -2691,10 +2717,12 @@ static enum fsm_event bc_event(struct port *p, int
fd_index)
if (err) {
switch (err) {
case -EBADMSG:
- pr_err("port %hu: bad message", portnum(p));
+ pr_err("port %hu (%s): bad message", portnum(p),
+ p->name);
break;
case -EPROTO:
- pr_debug("port %hu: ignoring message", portnum(p));
+ pr_debug("port %hu (%s): ignoring message", portnum(p),
+ p->name);
break;
}
msg_put(msg);
@@ -2707,8 +2735,8 @@ static enum fsm_event bc_event(struct port *p, int
fd_index)
}
if (msg_sots_missing(msg) &&
!(p->timestamping == TS_P2P1STEP && msg_type(msg) == PDELAY_REQ)) {
- pr_err("port %hu: received %s without timestamp",
- portnum(p), msg_type_string(msg_type(msg)));
+ pr_err("port %hu (%s): received %s without timestamp",
+ portnum(p), p->name, msg_type_string(msg_type(msg)));
msg_put(msg);
return EV_NONE;
}
@@ -2813,6 +2841,11 @@ struct PortIdentity port_identity(struct port *p)
return p->portIdentity;
}
+const char *port_name(struct port *p)
+{
+ return p->name;
+}
+
int port_number(struct port *p)
{
return portnum(p);
@@ -3036,6 +3069,7 @@ struct port *port_open(const char *phc_device,
transport = config_get_int(cfg, interface_name(interface),
"network_transport");
p->master_only = config_get_int(cfg, interface_name(interface),
"masterOnly");
p->bmca = config_get_int(cfg, interface_name(interface), "BMCA");
+ p->name = interface_name(interface);
if (p->bmca == BMCA_NOOP && transport != TRANS_UDS) {
if (p->master_only) {
@@ -3053,27 +3087,30 @@ struct port *port_open(const char *phc_device,
if (transport == TRANS_UDS) {
; /* UDS cannot have a PHC. */
} else if (!interface_tsinfo_valid(interface)) {
- pr_warning("port %d: get_ts_info not supported", number);
+ pr_warning("port %d (%s): get_ts_info not supported", number,
+ p->name);
} else if (phc_index >= 0 &&
phc_index != interface_phc_index(interface)) {
if (p->jbod) {
- pr_warning("port %d: just a bunch of devices", number);
+ pr_warning("port %d (%s): just a bunch of devices",
+ number, p->name);
p->phc_index = interface_phc_index(interface);
} else if (phc_device) {
- pr_warning("port %d: taking %s from the command line, "
- "not the attached ptp%d", number, phc_device,
+ pr_warning("port %d (%s): taking %s from the command "
+ "line, not the attached ptp%d", number,
+ p->name, phc_device,
interface_phc_index(interface));
p->phc_index = phc_index;
} else {
- pr_err("port %d: PHC device mismatch", number);
- pr_err("port %d: /dev/ptp%d requested, ptp%d attached",
- number, phc_index,
+ pr_err("port %d (%s): PHC device mismatch", number,
+ p->name);
+ pr_err("port %d (%s): /dev/ptp%d requested, ptp%d
attached",
+ number, p->name, phc_index,
interface_phc_index(interface));
goto err_port;
}
}
- p->name = interface_name(interface);
p->iface = interface;
p->asymmetry = config_get_int(cfg, p->name, "delayAsymmetry");
p->asymmetry <<= 16;
@@ -3115,18 +3152,20 @@ struct port *port_open(const char *phc_device,
p->hybrid_e2e = config_get_int(cfg, p->name, "hybrid_e2e");
if (number && type == CLOCK_TYPE_P2P && p->delayMechanism != DM_P2P) {
- pr_err("port %d: P2P TC needs P2P ports", number);
+ pr_err("port %d (%s): P2P TC needs P2P ports", number, p->name);
goto err_uc_service;
}
if (number && type == CLOCK_TYPE_E2E && p->delayMechanism != DM_E2E) {
- pr_err("port %d: E2E TC needs E2E ports", number);
+ pr_err("port %d (%s): E2E TC needs E2E ports", number, p->name);
goto err_uc_service;
}
if (p->hybrid_e2e && p->delayMechanism != DM_E2E) {
- pr_warning("port %d: hybrid_e2e only works with E2E", number);
+ pr_warning("port %d (%s): hybrid_e2e only works with E2E",
+ number, p->name);
}
if (p->net_sync_monitor && !p->hybrid_e2e) {
- pr_warning("port %d: net_sync_monitor needs hybrid_e2e",
number);
+ pr_warning("port %d (%s): net_sync_monitor needs hybrid_e2e",
+ number, p->name);
}
/* Set fault timeouts to a default value */
@@ -3187,7 +3226,8 @@ int port_state_update(struct port *p, enum fsm_event
event, int mdiff)
struct fault_interval i;
fault_interval(p, last_fault_type(p), &i);
if (clear_fault_asap(&i)) {
- pr_notice("port %hu: clearing fault immediately",
portnum(p));
+ pr_notice("port %hu (%s): clearing fault immediately",
+ portnum(p), p->name);
next = p->state_machine(next, EV_FAULT_CLEARED, 0);
}
}
diff --git a/port.h b/port.h
index 0b07d55..75c4a59 100644
--- a/port.h
+++ b/port.h
@@ -120,6 +120,13 @@ int port_prepare_and_send(struct port *p, struct
ptp_message *msg,
*/
struct PortIdentity port_identity(struct port *p);
+/**
+ * Obtain a port's name.
+ * @param p A port instance.
+ * @return The interface name of 'p'.
+ */
+const char *port_name(struct port *p);
+
/**
* Obtain a port number.
* @param p A port instance.
diff --git a/port_signaling.c b/port_signaling.c
index 2f5a682..2d049f1 100644
--- a/port_signaling.c
+++ b/port_signaling.c
@@ -207,7 +207,7 @@ int port_tx_interval_request(struct port *p,
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: send signaling failed", portnum(p));
+ pr_err("port %hu (%s): send signaling failed", portnum(p),
p->name);
}
out:
msg_put(msg);
diff --git a/tc.c b/tc.c
index fb46603..c09065e 100644
--- a/tc.c
+++ b/tc.c
@@ -126,8 +126,9 @@ static void tc_complete_request(struct port *q, struct port
*p,
return;
}
#ifdef DEBUG
- pr_err("stash delay request from port %hd to %hd seqid %hu residence
%lu",
- portnum(q), portnum(p), ntohs(req->header.sequenceId),
+ pr_err("stash delay request from port %hu (%s) to %hu (%s) "
+ "seqid %hu residence %lu", portnum(q), q->name, portnum(p),
+ p->name, ntohs(req->header.sequenceId),
(unsigned long) tmv_to_nanoseconds(residence));
#endif
msg_get(req);
@@ -146,8 +147,9 @@ static void tc_complete_response(struct port *q, struct
port *p,
int cnt;
#ifdef DEBUG
- pr_err("complete delay response from port %hd to %hd seqid %hu",
- portnum(q), portnum(p), ntohs(resp->header.sequenceId));
+ pr_err("complete delay response from port %hu (%s) to %hu (%s) seqid
%hu",
+ portnum(q), q->name, portnum(p), p->name,
+ ntohs(resp->header.sequenceId));
#endif
TAILQ_FOREACH(txd, &q->tc_transmitted, list) {
type = tc_match_delay(portnum(p), resp, txd);
@@ -164,7 +166,8 @@ static void tc_complete_response(struct port *q, struct
port *p,
resp->header.correction = host2net64(c2);
cnt = transport_send(p->trp, &p->fda, TRANS_GENERAL, resp);
if (cnt <= 0) {
- pr_err("tc failed to forward response on port %d", portnum(p));
+ pr_err("tc failed to forward response on port %hu (%s)",
+ portnum(p), p->name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
/* Restore original correction value for next egress port. */
@@ -225,7 +228,8 @@ static void tc_complete_syfup(struct port *q, struct port
*p,
fup->header.correction = host2net64(c2);
cnt = transport_send(p->trp, &p->fda, TRANS_GENERAL, fup);
if (cnt <= 0) {
- pr_err("tc failed to forward follow up on port %d", portnum(p));
+ pr_err("tc failed to forward follow up on port %hu (%s)",
+ portnum(p), p->name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
/* Restore original correction value for next egress port. */
@@ -279,8 +283,9 @@ static int tc_fwd_event(struct port *q, struct ptp_message
*msg)
}
cnt = transport_send(p->trp, &p->fda, TRANS_DEFER_EVENT, msg);
if (cnt <= 0) {
- pr_err("failed to forward event from port %hd to %hd",
- portnum(q), portnum(p));
+ pr_err("failed to forward event from port %hu (%s) to "
+ "%hd (%s)",
+ portnum(q), q->name, portnum(p), p->name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
}
@@ -292,8 +297,9 @@ static int tc_fwd_event(struct port *q, struct ptp_message
*msg)
}
err = transport_txts(&p->fda, msg);
if (err || !msg_sots_valid(msg)) {
- pr_err("failed to fetch txts on port %hd to %hd event",
- portnum(q), portnum(p));
+ pr_err("failed to fetch txts on port %hu (%s) to "
+ "%hu (%s) event",
+ portnum(q), q->name, portnum(p), p->name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
continue;
}
@@ -397,8 +403,8 @@ int tc_forward(struct port *q, struct ptp_message *msg)
}
cnt = transport_send(p->trp, &p->fda, TRANS_GENERAL, msg);
if (cnt <= 0) {
- pr_err("tc failed to forward message on port %d",
- portnum(p));
+ pr_err("tc failed to forward message on port %hu (%s)",
+ portnum(p), p->name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
}
diff --git a/unicast_client.c b/unicast_client.c
index 98ccc89..5caaa1f 100644
--- a/unicast_client.c
+++ b/unicast_client.c
@@ -81,7 +81,8 @@ static int unicast_client_announce(struct port *p,
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: signaling message failed", portnum(p));
+ pr_err("port %hu (%s): signaling message failed",
+ portnum(p), p->name);
}
out:
msg_put(msg);
@@ -102,8 +103,8 @@ static struct unicast_master_address
*unicast_client_ok(struct port *p,
}
}
if (!ucma) {
- pr_warning("port %d: received rogue unicast grant or cancel",
- portnum(p));
+ pr_warning("port %hu (%s): received rogue unicast grant or
cancel",
+ portnum(p), p->name);
return NULL;
}
return ucma;
@@ -129,7 +130,8 @@ static int unicast_client_peer_renew(struct port *p)
return 0;
}
peer->renewal_tmo = 0;
- pr_debug("port %d: time to renew P2P unicast subscription", portnum(p));
+ pr_debug("port %hu (%s): time to renew P2P unicast subscription",
portnum(p),
+ p->name);
msg = port_signaling_uc_construct(p, &peer->address,
&peer->portIdentity);
if (!msg) {
@@ -142,7 +144,8 @@ static int unicast_client_peer_renew(struct port *p)
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: P2P signaling message failed", portnum(p));
+ pr_err("port %hu (%s): P2P signaling message failed",
+ portnum(p), p->name);
}
out:
msg_put(msg);
@@ -165,7 +168,8 @@ static int unicast_client_renew(struct port *p,
return 0;
}
dst->renewal_tmo = 0;
- pr_debug("port %d: time to renew unicast subscriptions", portnum(p));
+ pr_debug("port %hu (%s): time to renew unicast subscriptions",
+ portnum(p), p->name);
msg = port_signaling_uc_construct(p, &dst->address, &dst->portIdentity);
if (!msg) {
@@ -195,7 +199,8 @@ static int unicast_client_renew(struct port *p,
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: signaling message failed", portnum(p));
+ pr_err("port %hu (%s): signaling message failed", portnum(p),
+ p->name);
}
out:
msg_put(msg);
@@ -217,7 +222,8 @@ static void unicast_client_set_renewal(struct port *p,
tmo = now.tv_sec + duration;
if (!master->renewal_tmo || tmo < master->renewal_tmo) {
master->renewal_tmo = tmo;
- pr_debug("port %d: renewal timeout at %lld", portnum(p), (long
long)tmo);
+ pr_debug("port %hu (%s): renewal timeout at %lld",
+ portnum(p), p->name, (long long)tmo);
}
}
@@ -245,7 +251,8 @@ static int unicast_client_sydy(struct port *p,
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: signaling message failed", portnum(p));
+ pr_err("port %hu (%s): signaling message failed", portnum(p),
+ p->name);
}
out:
msg_put(msg);
@@ -319,8 +326,8 @@ int unicast_client_cancel(struct port *p, struct
ptp_message *m,
if (cancel->message_type_flags & CANCEL_UNICAST_MAINTAIN_GRANT) {
return 0;
}
- pr_warning("port %d: server unilaterally canceled unicast %s grant",
- portnum(p), msg_type_string(mtype));
+ pr_warning("port %hu (%s): server unilaterally canceled unicast %s
grant",
+ portnum(p), p->name, msg_type_string(mtype));
ucma->state = unicast_fsm(ucma->state, UC_EV_CANCEL);
ucma->granted &= ~(1 << mtype);
@@ -336,7 +343,8 @@ int unicast_client_cancel(struct port *p, struct
ptp_message *m,
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: signaling message failed", portnum(p));
+ pr_err("port %hu (%s): signaling message failed", portnum(p),
+ p->name);
}
out:
msg_put(msg);
@@ -360,7 +368,8 @@ int unicast_client_initialize(struct port *p)
}
}
if (!table) {
- pr_err("port %d: no table with id %d", portnum(p), table_id);
+ pr_err("port %hu (%s): no table with id %d", portnum(p),
+ p->name, table_id);
return -1;
}
table = clone_master_table(table);
@@ -371,15 +380,15 @@ int unicast_client_initialize(struct port *p)
peer = &table->peer_addr;
if (table->peer_name && str2addr(transport_type(p->trp),
table->peer_name, &peer->address)) {
- pr_err("port %d: bad peer address: %s",
- portnum(p), table->peer_name);
+ pr_err("port %hu (%s): bad peer address: %s",
+ portnum(p), p->name, table->peer_name);
free_master_table(table);
return -1;
}
STAILQ_FOREACH(master, &table->addrs, list) {
if (master->type != transport_type(p->trp)) {
- pr_warning("port %d: unicast master transport mismatch",
- portnum(p));
+ pr_warning("port %hu (%s): unicast master transport
mismatch",
+ portnum(p), p->name);
}
if (p->delayMechanism == DM_P2P) {
master->sydymsk = P2P_SYDY_MASK;
@@ -420,15 +429,15 @@ void unicast_client_grant(struct port *p, struct
ptp_message *m,
mtype = g->message_type >> 4;
if (!g->durationField) {
- pr_warning("port %d: unicast grant of %s rejected",
- portnum(p), msg_type_string(mtype));
+ pr_warning("port %hu (%s): unicast grant of %s rejected",
+ portnum(p), p->name, msg_type_string(mtype));
if (mtype != PDELAY_RESP) {
ucma->state = UC_WAIT;
}
return;
}
- pr_debug("port %d: unicast %s granted for %u sec",
- portnum(p), msg_type_string(mtype), g->durationField);
+ pr_debug("port %hu (%s): unicast %s granted for %u sec",
+ portnum(p), p->name, msg_type_string(mtype), g->durationField);
if (p->delayMechanism == DM_P2P) {
switch (mtype) {
diff --git a/unicast_service.c b/unicast_service.c
index d42c549..c8226d9 100644
--- a/unicast_service.c
+++ b/unicast_service.c
@@ -252,7 +252,8 @@ static int unicast_service_reply(struct port *p, struct
ptp_message *dst,
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: signaling message failed", portnum(p));
+ pr_err("port %hu (%s): signaling message failed", portnum(p),
+ p->name);
}
out:
msg_put(msg);
--
2.29.2.729.g45daf8777d-goog
_______________________________________________
Linuxptp-devel mailing list
Linuxptp-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linuxptp-devel
