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
Signed-off-by: Cliff Spradlin <csprad...@google.com>
Change-Id: Id43b82aad3c30c93aea233a1e76f9a8196e25b71
Signed-off-by: Cliff Spradlin <csprad...@google.com>
---
clock.c | 22 +++----
e2e_tc.c | 10 +--
p2p_tc.c | 10 +--
port.c | 158 +++++++++++++++++++++++-----------------------
port_signaling.c | 2 +-
tc.c | 24 +++----
unicast_client.c | 42 ++++++------
unicast_service.c | 2 +-
8 files changed, 135 insertions(+), 135 deletions(-)
diff --git a/clock.c b/clock.c
index 08c61eb..a34737a 100644
--- a/clock.c
+++ b/clock.c
@@ -296,19 +296,19 @@ 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 %s", port_log_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 %s",
+ i.val, port_log_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 %s",
+ i.val, port_log_name(port));
return port_set_fault_timer_log(port, 1, i.val);
}
@@ -1360,8 +1360,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("%s: management forward failed",
+ port_log_name(piter));
}
if (clock_do_forward_mgmt(c, p, c->uds_port, msg, &msg_ready))
pr_err("uds port: management forward failed");
@@ -1562,8 +1562,8 @@ 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("%s: unexpected socket error",
+ port_log_name(p));
event = EV_FAULT_DETECTED;
} else {
event = port_event(p, i);
@@ -1882,8 +1882,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("%s: assuming the grand master role",
+ port_log_name(piter));
clock_update_grandmaster(c);
event = EV_RS_GRAND_MASTER;
break;
diff --git a/e2e_tc.c b/e2e_tc.c
index 6aaf572..2f8e821 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("%s: %s timeout", p->log_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("%s: delay timeout", p->log_name);
port_set_delay_tmo(p);
delay_req_prune(p);
tc_prune(p);
@@ -111,7 +111,7 @@ 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("%s: qualification timeout", p->log_name);
return EV_QUALIFICATION_TIMEOUT_EXPIRES;
case FD_MANNO_TIMER:
@@ -122,7 +122,7 @@ 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("%s: received link status notification", p->log_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 +142,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("%s: recv message failed", p->log_name);
msg_put(msg);
return EV_FAULT_DETECTED;
}
diff --git a/p2p_tc.c b/p2p_tc.c
index acf9e51..75cb3b9 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("%s: %s timeout", p->log_name,
fd_index == FD_SYNC_RX_TIMER ? "rx sync" : "announce");
if (p->best) {
fc_clear(p->best);
@@ -108,13 +108,13 @@ 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("%s: delay timeout", p->log_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("%s: qualification timeout", p->log_name);
return EV_QUALIFICATION_TIMEOUT_EXPIRES;
case FD_MANNO_TIMER:
@@ -125,7 +125,7 @@ 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("%s: received link status notification", p->log_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 +145,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("%s: recv message failed", p->log_name);
msg_put(msg);
return EV_FAULT_DETECTED;
}
diff --git a/port.c b/port.c
index eb49d87..f44d239 100644
--- a/port.c
+++ b/port.c
@@ -349,7 +349,7 @@ static int add_foreign_master(struct port *p, struct
ptp_message *m)
}
}
if (!fc) {
- pr_notice("port %hu: new foreign master %s", portnum(p),
+ pr_notice("%s: new foreign master %s", p->log_name,
pid2str(&m->header.sourcePortIdentity));
fc = malloc(sizeof(*fc));
@@ -621,8 +621,8 @@ 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 "
- "(%" PRId32 "), resetting asCapable",
portnum(p),
+ pr_debug("%s: peer_delay (%" PRId64 ") >
neighborPropDelayThresh "
+ "(%" PRId32 "), resetting asCapable",
p->log_name,
tmv_to_nanoseconds(p->peer_delay),
p->neighborPropDelayThresh);
goto not_capable;
@@ -630,8 +630,8 @@ int port_capable(struct port *p)
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 "
- "(%" PRId32 "), resetting asCapable",
portnum(p),
+ pr_debug("%s: peer_delay (%" PRId64 ") <
min_neighbor_prop_delay "
+ "(%" PRId32 "), resetting asCapable",
p->log_name,
tmv_to_nanoseconds(p->peer_delay),
p->min_neighbor_prop_delay);
goto not_capable;
@@ -639,35 +639,35 @@ int port_capable(struct port *p)
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("%s: missed %d peer delay resp, "
+ "resetting asCapable", p->log_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("%s: multiple sequential peer delay resp, "
+ "resetting asCapable", p->log_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("%s: invalid peer port id, "
+ "resetting asCapable", p->log_name);
goto not_capable;
}
if (!p->nrate.ratio_valid) {
if (p->asCapable)
- pr_debug("port %hu: invalid nrate, "
- "resetting asCapable", portnum(p));
+ pr_debug("%s: invalid nrate, "
+ "resetting asCapable", p->log_name);
goto not_capable;
}
capable:
if (p->asCapable == NOT_CAPABLE) {
- pr_debug("port %hu: setting asCapable", portnum(p));
+ pr_debug("%s: setting asCapable", p->log_name);
p->asCapable = AS_CAPABLE;
}
return 1;
@@ -775,7 +775,7 @@ 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("%s: management error failed", p->log_name);
}
static const Octet profile_id_drr[] = {0x00, 0x1B, 0x19, 0x00, 0x01, 0x00};
@@ -1007,7 +1007,7 @@ 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("%s: failed to send management set response",
target->log_name);
return respond ? 1 : 0;
}
@@ -1115,20 +1115,20 @@ 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),
+ pr_notice("%s: %s to %s on %s (%s)", p->log_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("%s: %s to %s on %s", p->log_name,
ps_str[p->state], ps_str[next], ev_str[event]);
}
}
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);
+ const char *n = p->log_name;
+ pr_warning("%s: master state recommended in slave only mode", n);
+ pr_warning("%s: defaultDS.priority1 probably misconfigured", n);
}
static void message_interval_request(struct port *p,
@@ -1225,8 +1225,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("%s: have %s %hu, expecting %s but got %s %hu, dropping",
+ p->log_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 +1361,7 @@ 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("%s: send peer delay request failed", p->log_name);
goto out;
}
if (msg_sots_missing(msg)) {
@@ -1424,7 +1424,7 @@ 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("%s: send delay request failed", p->log_name);
goto out;
}
if (msg_sots_missing(msg)) {
@@ -1484,12 +1484,12 @@ 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("%s: append path trace failed", p->log_name);
}
err = port_prepare_and_send(p, msg, TRANS_GENERAL);
if (err) {
- pr_err("port %hu: send announce failed", portnum(p));
+ pr_err("%s: send announce failed", p->log_name);
}
msg_put(msg);
return err;
@@ -1557,7 +1557,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("%s: send sync failed", p->log_name);
goto out;
}
if (p->timestamping == TS_ONESTEP || p->timestamping == TS_P2P1STEP) {
@@ -1589,14 +1589,14 @@ 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("%s: append fup info failed", p->log_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("%s: send follow up failed", p->log_name);
}
out:
msg_put(msg);
@@ -1893,7 +1893,7 @@ 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("%s: delay request on P2P port", p->log_name);
return 0;
}
@@ -1924,13 +1924,13 @@ 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("%s: append NSM failed", p->log_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("%s: send delay response failed", p->log_name);
goto out;
}
if (nsm) {
@@ -1990,13 +1990,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, "%s: ignore bogus delay request interval 2^%d",
+ p->log_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("%s: minimum delay request interval 2^%d",
+ p->log_name, p->logMinDelayReqInterval);
port_set_delay_tmo(p);
}
@@ -2059,19 +2059,19 @@ 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("%s: pdelay_req on E2E port", p->log_name);
return 0;
}
if (p->delayMechanism == DM_AUTO) {
- pr_info("port %hu: peer detected, switch to P2P", portnum(p));
+ pr_info("%s: peer detected, switch to P2P", p->log_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("%s: received pdelay_req msg with "
"unexpected peer port id %s",
- portnum(p),
+ p->log_name,
pid2str(&m->header.sourcePortIdentity));
p->peer_portid_valid = 0;
port_capable(p);
@@ -2079,7 +2079,7 @@ 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),
+ pr_debug("%s: peer port id set to %s", p->log_name,
pid2str(&p->peer_portid));
}
@@ -2127,7 +2127,7 @@ 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("%s: send peer delay response failed", p->log_name);
goto out;
}
if (p->timestamping == TS_P2P1STEP) {
@@ -2165,7 +2165,7 @@ 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("%s: send pdelay_resp_fup failed", p->log_name);
}
out:
msg_put(rsp);
@@ -2249,7 +2249,7 @@ 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("%s: multiple peer responses", p->log_name);
if (!p->multiple_pdr_detected) {
p->multiple_pdr_detected = 1;
p->multiple_seq_pdr_count++;
@@ -2261,14 +2261,14 @@ 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("%s: rogue peer delay response", p->log_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("%s: received pdelay_resp msg with "
"unexpected peer port id %s",
- portnum(p),
+ p->log_name,
pid2str(&m->header.sourcePortIdentity));
p->peer_portid_valid = 0;
port_capable(p);
@@ -2276,7 +2276,7 @@ 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),
+ pr_debug("%s: peer port id set to %s", p->log_name,
pid2str(&p->peer_portid));
}
@@ -2544,7 +2544,7 @@ 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("%s: link %s", p->log_name, linkup ? "up" : "down");
}
/* ts_label changed */
@@ -2552,7 +2552,7 @@ 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("%s: ts label changed to %s", p->log_name, ts_label);
}
/* Both link down/up and change ts_label may change phc index. */
@@ -2570,9 +2570,9 @@ void port_link_status(void *ctx, int linkup, int ts_index)
interface_label(p->iface));
p->link_status = LINK_DOWN | LINK_STATE_CHANGED;
} else if (p->phc_from_cmdline) {
- pr_warning("port %d: taking /dev/ptp%d from the
"
+ pr_warning("%s: taking /dev/ptp%d from the "
"command line, not the attached
ptp%d",
- portnum(p), p->phc_index,
+ p->log_name, p->phc_index,
interface_phc_index(p->iface));
} else if (p->phc_index !=
interface_phc_index(p->iface)) {
p->phc_index = interface_phc_index(p->iface);
@@ -2609,7 +2609,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("%s: %s timeout", p->log_name,
fd_index == FD_SYNC_RX_TIMER ? "rx sync" : "announce");
if (p->best) {
fc_clear(p->best);
@@ -2642,35 +2642,35 @@ 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("%s: delay timeout", p->log_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("%s: qualification timeout", p->log_name);
return EV_QUALIFICATION_TIMEOUT_EXPIRES;
case FD_MANNO_TIMER:
- pr_debug("port %hu: master tx announce timeout", portnum(p));
+ pr_debug("%s: master tx announce timeout", p->log_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("%s: master sync timeout", p->log_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("%s: unicast service timeout", p->log_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("%s: unicast request timeout", p->log_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("%s: received link status notification", p->log_name);
rtnl_link_status(fd, p->name, port_link_status, p);
if (p->link_status == (LINK_UP | LINK_STATE_CHANGED))
return EV_FAULT_CLEARED;
@@ -2689,7 +2689,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("%s: recv message failed", p->log_name);
msg_put(msg);
return EV_FAULT_DETECTED;
}
@@ -2697,10 +2697,10 @@ 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("%s: bad message", p->log_name);
break;
case -EPROTO:
- pr_debug("port %hu: ignoring message", portnum(p));
+ pr_debug("%s: ignoring message", p->log_name);
break;
}
msg_put(msg);
@@ -2713,8 +2713,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("%s: received %s without timestamp",
+ p->log_name, msg_type_string(msg_type(msg)));
msg_put(msg);
return EV_NONE;
}
@@ -3070,22 +3070,22 @@ 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("%s: get_ts_info not supported", p->log_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("%s: just a bunch of devices", p->log_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,
- interface_phc_index(interface));
+ pr_warning("%s: taking %s from the command line, "
+ "not the attached ptp%d", p->log_name,
+ phc_device, interface_phc_index(interface));
p->phc_index = phc_index;
p->phc_from_cmdline = 1;
} 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("%s: PHC device mismatch", p->log_name);
+ pr_err("%s: /dev/ptp%d requested, ptp%d attached",
+ p->log_name, phc_index,
interface_phc_index(interface));
goto err_log_name;
}
@@ -3132,18 +3132,18 @@ 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("%s: P2P TC needs P2P ports", p->log_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("%s: E2E TC needs E2E ports", p->log_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("%s: hybrid_e2e only works with E2E", p->log_name);
}
if (p->net_sync_monitor && !p->hybrid_e2e) {
- pr_warning("port %d: net_sync_monitor needs hybrid_e2e",
number);
+ pr_warning("%s: net_sync_monitor needs hybrid_e2e",
p->log_name);
}
/* Set fault timeouts to a default value */
@@ -3206,7 +3206,7 @@ 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("%s: clearing fault immediately",
p->log_name);
next = p->state_machine(next, EV_FAULT_CLEARED, 0);
}
}
diff --git a/port_signaling.c b/port_signaling.c
index 2f5a682..ed217c0 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("%s: send signaling failed", p->log_name);
}
out:
msg_put(msg);
diff --git a/tc.c b/tc.c
index fb46603..d9e4853 100644
--- a/tc.c
+++ b/tc.c
@@ -126,8 +126,8 @@ 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 %s to %s seqid %hu residence %lu",
+ q->log_name, p->log_name, ntohs(req->header.sequenceId),
(unsigned long) tmv_to_nanoseconds(residence));
#endif
msg_get(req);
@@ -146,8 +146,8 @@ 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 %s to %s seqid %hu",
+ q->log_name, p->log_name, ntohs(resp->header.sequenceId));
#endif
TAILQ_FOREACH(txd, &q->tc_transmitted, list) {
type = tc_match_delay(portnum(p), resp, txd);
@@ -164,7 +164,7 @@ 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 %s", p->log_name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
/* Restore original correction value for next egress port. */
@@ -225,7 +225,7 @@ 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 %s", p->log_name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
/* Restore original correction value for next egress port. */
@@ -279,8 +279,8 @@ 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 %s to %s",
+ q->log_name, p->log_name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
}
@@ -292,8 +292,8 @@ 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 %s to %s event",
+ q->log_name, p->log_name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
continue;
}
@@ -397,8 +397,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 %s",
+ p->log_name);
port_dispatch(p, EV_FAULT_DETECTED, 0);
}
}
diff --git a/unicast_client.c b/unicast_client.c
index 98ccc89..87d8471 100644
--- a/unicast_client.c
+++ b/unicast_client.c
@@ -81,7 +81,7 @@ 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("%s: signaling message failed", p->log_name);
}
out:
msg_put(msg);
@@ -102,8 +102,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("%s: received rogue unicast grant or cancel",
+ p->log_name);
return NULL;
}
return ucma;
@@ -129,7 +129,7 @@ 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("%s: time to renew P2P unicast subscription", p->log_name);
msg = port_signaling_uc_construct(p, &peer->address,
&peer->portIdentity);
if (!msg) {
@@ -142,7 +142,7 @@ 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("%s: P2P signaling message failed", p->log_name);
}
out:
msg_put(msg);
@@ -165,7 +165,7 @@ 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("%s: time to renew unicast subscriptions", p->log_name);
msg = port_signaling_uc_construct(p, &dst->address, &dst->portIdentity);
if (!msg) {
@@ -195,7 +195,7 @@ 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("%s: signaling message failed", p->log_name);
}
out:
msg_put(msg);
@@ -217,7 +217,7 @@ 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("%s: renewal timeout at %lld", p->log_name, (long
long)tmo);
}
}
@@ -245,7 +245,7 @@ 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("%s: signaling message failed", p->log_name);
}
out:
msg_put(msg);
@@ -319,8 +319,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("%s: server unilaterally canceled unicast %s grant",
+ p->log_name, msg_type_string(mtype));
ucma->state = unicast_fsm(ucma->state, UC_EV_CANCEL);
ucma->granted &= ~(1 << mtype);
@@ -336,7 +336,7 @@ 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("%s: signaling message failed", p->log_name);
}
out:
msg_put(msg);
@@ -360,7 +360,7 @@ int unicast_client_initialize(struct port *p)
}
}
if (!table) {
- pr_err("port %d: no table with id %d", portnum(p), table_id);
+ pr_err("%s: no table with id %d", p->log_name, table_id);
return -1;
}
table = clone_master_table(table);
@@ -371,15 +371,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("%s: bad peer address: %s",
+ p->log_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("%s: unicast master transport mismatch",
+ p->log_name);
}
if (p->delayMechanism == DM_P2P) {
master->sydymsk = P2P_SYDY_MASK;
@@ -420,15 +420,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("%s: unicast grant of %s rejected",
+ p->log_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("%s: unicast %s granted for %u sec",
+ p->log_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..2078740 100644
--- a/unicast_service.c
+++ b/unicast_service.c
@@ -252,7 +252,7 @@ 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("%s: signaling message failed", p->log_name);
}
out:
msg_put(msg);
--
2.30.0.280.ga3ce27912f-goog
_______________________________________________
Linuxptp-devel mailing list
Linuxptp-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linuxptp-devel
