commit 10d4e7f8b0525bbf72981e3e5fcf0c10833a7631
Author: Richard Cochran <richardcochran@gmail.com>
Date: Tue Jan 3 20:55:18 2017 +0100
port: Make the finite state machine into a function variable.
This allows adding new FSM flavors in the future.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
diff --git a/port.c b/port.c
index a1ad6f6..afe0057 100644
--- a/port.c
+++ b/port.c
@@ -94,6 +94,8 @@ struct port {
unsigned int pdr_missing;
unsigned int multiple_seq_pdr_count;
unsigned int multiple_pdr_detected;
+ enum port_state (*state_machine)(enum port_state state,
+ enum fsm_event event, int mdiff);
/* portDS */
struct PortIdentity portIdentity;
enum port_state state; /*portState*/
@@ -2142,10 +2144,8 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
if (event == EV_RS_MASTER || event == EV_RS_GRAND_MASTER) {
port_slave_priority_warning(p);
}
- next = ptp_slave_fsm(p->state, event, mdiff);
- } else {
- next = ptp_fsm(p->state, event, mdiff);
}
+ next = p->state_machine(p->state, event, mdiff);
if (!fault_interval(p, last_fault_type(p), &i) &&
((i.val == FRI_ASAP && i.type == FTMO_LOG2_SECONDS) ||
@@ -2555,6 +2555,7 @@ struct port *port_open(int phc_index,
memset(p, 0, sizeof(*p));
+ p->state_machine = clock_slave_only(clock) ? ptp_slave_fsm : ptp_fsm;
p->phc_index = phc_index;
p->jbod = config_get_int(cfg, interface->name, "boundary_clock_jbod");
transport = config_get_int(cfg, interface->name, "network_transport");
commit 80a28a9dc322f28b991effc44ec1c5362a598281
Author: Richard Cochran <richardcochran@gmail.com>
Date: Tue Jan 3 20:55:33 2017 +0100
Change a misleading fault handling function signature.
Looking at the fault logic in port_dispatch(), you might think that
the function, fault_interval(), checks whether a fault is active, but
you would be wrong, since that function always returns zero.
This patch removes the superfluous input error checking inside of
fault_interval() and changes the return type to void, making the
actual behavior explicit. Dropping the input check is safe because
that function has exactly two callers, both of whom always provide
valid inputs.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
diff --git a/port.c b/port.c
index afe0057..6c9aa72 100644
--- a/port.c
+++ b/port.c
@@ -205,16 +205,11 @@ enum fault_type last_fault_type(struct port *port)
return port->last_fault_type;
}
-int fault_interval(struct port *port, enum fault_type ft,
- struct fault_interval *i)
+void fault_interval(struct port *port, enum fault_type ft,
+ struct fault_interval *i)
{
- if (!port || !i)
- return -EINVAL;
- if (ft < 0 || ft >= FT_CNT)
- return -EINVAL;
i->type = port->flt_interval_pertype[ft].type;
i->val = port->flt_interval_pertype[ft].val;
- return 0;
}
int port_fault_fd(struct port *port)
@@ -2147,9 +2142,9 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
}
next = p->state_machine(p->state, event, mdiff);
- if (!fault_interval(p, last_fault_type(p), &i) &&
- ((i.val == FRI_ASAP && i.type == FTMO_LOG2_SECONDS) ||
- (i.val == 0 && i.type == FTMO_LINEAR_SECONDS)))
+ fault_interval(p, last_fault_type(p), &i);
+ if ((i.val == FRI_ASAP && i.type == FTMO_LOG2_SECONDS) ||
+ (i.val == 0 && i.type == FTMO_LINEAR_SECONDS))
fri_asap = 1;
if (PS_INITIALIZING == next || (PS_FAULTY == next && fri_asap)) {
/*
diff --git a/port.h b/port.h
index 19dec4a..d2e0865 100644
--- a/port.h
+++ b/port.h
@@ -318,9 +318,8 @@ enum fault_type last_fault_type(struct port *port);
* @param port A port instance.
* @param ft Fault type.
* @param i Pointer to the struct which will be filled in.
- * @return Zero on success, non-zero otherwise.
*/
-int fault_interval(struct port *port, enum fault_type ft,
- struct fault_interval *i);
+void fault_interval(struct port *port, enum fault_type ft,
+ struct fault_interval *i);
#endif
commit 1f66948d3853c8b08c7f52c9c8daecb361164a43
Author: Richard Cochran <richardcochran@gmail.com>
Date: Tue Jan 3 20:55:42 2017 +0100
Make the fault handling code more readable.
The code that decides whether a fault qualifies for ASAP treatment is
a tangle of logical operators. This patch replaces the open coded
logic with a helper function whose name makes the intent clear. This
is a cosmetic change only.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
diff --git a/port.c b/port.c
index 6c9aa72..02dbabb 100644
--- a/port.c
+++ b/port.c
@@ -161,6 +161,19 @@ static void announce_to_dataset(struct ptp_message *m, struct port *p,
out->receiver = p->portIdentity;
}
+static int clear_fault_asap(struct fault_interval *faint)
+{
+ switch (faint->type) {
+ case FTMO_LINEAR_SECONDS:
+ return faint->val == 0 ? 1 : 0;
+ case FTMO_LOG2_SECONDS:
+ return faint->val == FRI_ASAP ? 1 : 0;
+ case FTMO_CNT:
+ return 0;
+ }
+ return 0;
+}
+
static int msg_current(struct ptp_message *m, struct timespec now)
{
int64_t t1, t2, tmo;
@@ -2143,9 +2156,9 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
next = p->state_machine(p->state, event, mdiff);
fault_interval(p, last_fault_type(p), &i);
- if ((i.val == FRI_ASAP && i.type == FTMO_LOG2_SECONDS) ||
- (i.val == 0 && i.type == FTMO_LINEAR_SECONDS))
+ if (clear_fault_asap(&i)) {
fri_asap = 1;
+ }
if (PS_INITIALIZING == next || (PS_FAULTY == next && fri_asap)) {
/*
* This is a special case. Since we initialize the
commit 01ee947457813078f63d606c310818d6dedb4ca3
Author: Richard Cochran <richardcochran@gmail.com>
Date: Tue Jan 3 20:55:50 2017 +0100
Disentangle initialization from fault clearing.
Although leaving the INITIALIZING state and clearing the FAULTY state
ASAP both result in a port entering the LISTENING state, still there
is no benefit from conflating the two. In the FAULTY case, the
current code actually skips the INITIALIZING state altogether.
This patch separates the two cases resulting in two benefits. First,
the check for ASAP fault status is only made when a fault is actually
present, unlike the present unconditional check. Second, this change
will allow us to cleanly support alternative state machines later on.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
diff --git a/port.c b/port.c
index 02dbabb..ebe7342 100644
--- a/port.c
+++ b/port.c
@@ -2145,8 +2145,6 @@ static void port_p2p_transition(struct port *p, enum port_state next)
int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
{
enum port_state next;
- struct fault_interval i;
- int fri_asap = 0;
if (clock_slave_only(p->clock)) {
if (event == EV_RS_MASTER || event == EV_RS_GRAND_MASTER) {
@@ -2155,11 +2153,15 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
}
next = p->state_machine(p->state, event, mdiff);
- fault_interval(p, last_fault_type(p), &i);
- if (clear_fault_asap(&i)) {
- fri_asap = 1;
+ if (PS_FAULTY == next) {
+ 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));
+ next = PS_INITIALIZING;
+ }
}
- if (PS_INITIALIZING == next || (PS_FAULTY == next && fri_asap)) {
+ if (PS_INITIALIZING == next) {
/*
* This is a special case. Since we initialize the
* port immediately, we can skip right to listening
commit b738afb6044a8c59310fc13f646c8f5c4dcf2963
Author: Richard Cochran <richardcochran@gmail.com>
Date: Thu Oct 27 15:20:36 2016 +0200
fsm: Make the transition out of INITIALIZING part of the FSM code.
The state machines in 1588 do not specify an event that causes a transition
out of the initializing state. This was left as a local issue. For this
transition, the current code assigns the next state outside of the FSM. But
doing so prevents an alternative FSM to handle this transition differently.
By introducing a new event, this patch places this transition where it
belongs, namely under the control of the FSM code,
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
diff --git a/fsm.c b/fsm.c
index d1423e7..ce6efad 100644
--- a/fsm.c
+++ b/fsm.c
@@ -27,7 +27,16 @@ enum port_state ptp_fsm(enum port_state state, enum fsm_event event, int mdiff)
switch (state) {
case PS_INITIALIZING:
- next = PS_LISTENING;
+ switch (event) {
+ case EV_FAULT_DETECTED:
+ next = PS_FAULTY;
+ break;
+ case EV_INIT_COMPLETE:
+ next = PS_LISTENING;
+ break;
+ default:
+ break;
+ }
break;
case PS_FAULTY:
@@ -220,7 +229,16 @@ enum port_state ptp_slave_fsm(enum port_state state, enum fsm_event event,
switch (state) {
case PS_INITIALIZING:
- next = PS_LISTENING;
+ switch (event) {
+ case EV_FAULT_DETECTED:
+ next = PS_FAULTY;
+ break;
+ case EV_INIT_COMPLETE:
+ next = PS_LISTENING;
+ break;
+ default:
+ break;
+ }
break;
case PS_FAULTY:
diff --git a/fsm.h b/fsm.h
index 5d4ae91..0616daa 100644
--- a/fsm.h
+++ b/fsm.h
@@ -48,6 +48,7 @@ enum fsm_event {
EV_ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES,
EV_SYNCHRONIZATION_FAULT,
EV_MASTER_CLOCK_SELECTED,
+ EV_INIT_COMPLETE,
EV_RS_MASTER,
EV_RS_GRAND_MASTER,
EV_RS_SLAVE,
diff --git a/port.c b/port.c
index ebe7342..5f1646b 100644
--- a/port.c
+++ b/port.c
@@ -2120,6 +2120,7 @@ static void port_p2p_transition(struct port *p, enum port_state next)
break;
case PS_LISTENING:
port_set_announce_tmo(p);
+ port_set_delay_tmo(p);
break;
case PS_PRE_MASTER:
port_set_qualification_tmo(p);
@@ -2158,7 +2159,7 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
fault_interval(p, last_fault_type(p), &i);
if (clear_fault_asap(&i)) {
pr_notice("port %hu: clearing fault immediately", portnum(p));
- next = PS_INITIALIZING;
+ next = p->state_machine(next, EV_FAULT_CLEARED, 0);
}
}
if (PS_INITIALIZING == next) {
@@ -2170,14 +2171,12 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
if (port_is_enabled(p)) {
port_disable(p);
}
- next = port_initialize(p) ? PS_FAULTY : PS_LISTENING;
- port_show_transition(p, next, event);
- p->state = next;
- if (next == PS_LISTENING && p->delayMechanism == DM_P2P) {
- port_set_delay_tmo(p);
+ if (port_initialize(p)) {
+ event = EV_FAULT_DETECTED;
+ } else {
+ event = EV_INIT_COMPLETE;
}
- port_notify_event(p, NOTIFY_PORT_STATE);
- return 1;
+ next = p->state_machine(next, event, 0);
}
if (next == p->state)
diff --git a/util.c b/util.c
index 594b49f..2b880ff 100644
--- a/util.c
+++ b/util.c
@@ -61,6 +61,7 @@ const char *ev_str[] = {
"ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES",
"SYNCHRONIZATION_FAULT",
"MASTER_CLOCK_SELECTED",
+ "INIT_COMPLETE",
"RS_MASTER",
"RS_GRAND_MASTER",
"RS_SLAVE",
commit 6b471d45edfdfa835a9115ce4be96d92f100e2ac
Author: Richard Cochran <richardcochran@gmail.com>
Date: Sun Feb 5 18:25:18 2017 +0100
port: Change port_dispatch() into a void function.
This global function used to return an error code, but now it always
returns zero. This patch converts the function signature to return void
and simplifies the main clock loop by removing the useless test.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
diff --git a/clock.c b/clock.c
index a6a1a1a..f027305 100644
--- a/clock.c
+++ b/clock.c
@@ -1463,7 +1463,7 @@ struct PortIdentity clock_parent_identity(struct clock *c)
int clock_poll(struct clock *c)
{
- int cnt, err, i, sde = 0;
+ int cnt, i, sde = 0;
enum fsm_event event;
struct pollfd *cur;
struct port *p;
@@ -1490,14 +1490,14 @@ int clock_poll(struct clock *c)
cur++;
LIST_FOREACH(p, &c->ports, list) {
/* Let the ports handle their events. */
- for (i = err = 0; i < N_POLLFD && !err; i++) {
+ for (i = 0; i < N_POLLFD; i++) {
if (cur[i].revents & (POLLIN|POLLPRI)) {
event = port_event(p, i);
if (EV_STATE_DECISION_EVENT == event)
sde = 1;
if (EV_ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES == event)
sde = 1;
- err = port_dispatch(p, event, 0);
+ port_dispatch(p, event, 0);
/* Clear any fault after a little while. */
if (PS_FAULTY == port_state(p)) {
clock_fault_timeout(p, 1);
diff --git a/port.c b/port.c
index 5f1646b..0f99b1b 100644
--- a/port.c
+++ b/port.c
@@ -2143,7 +2143,7 @@ static void port_p2p_transition(struct port *p, enum port_state next)
};
}
-int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
+void port_dispatch(struct port *p, enum fsm_event event, int mdiff)
{
enum port_state next;
@@ -2180,7 +2180,7 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
}
if (next == p->state)
- return 0;
+ return;
port_show_transition(p, next, event);
@@ -2196,12 +2196,11 @@ int port_dispatch(struct port *p, enum fsm_event event, int mdiff)
if (p->jbod && next == PS_UNCALIBRATED) {
if (clock_switch_phc(p->clock, p->phc_index)) {
p->last_fault_type = FT_SWITCH_PHC;
- return port_dispatch(p, EV_FAULT_DETECTED, 0);
+ port_dispatch(p, EV_FAULT_DETECTED, 0);
+ return;
}
clock_sync_interval(p->clock, p->log_sync_interval);
}
-
- return 0;
}
enum fsm_event port_event(struct port *p, int fd_index)
diff --git a/port.h b/port.h
index d2e0865..b00bc64 100644
--- a/port.h
+++ b/port.h
@@ -69,10 +69,8 @@ struct foreign_clock *port_compute_best(struct port *port);
* @param port A pointer previously obtained via port_open().
* @param event One of the @a fsm_event codes.
* @param mdiff Whether a new master has been selected.
- * @return Zero if the port's file descriptor array is still valid,
- * and non-zero if it has become invalid.
*/
-int port_dispatch(struct port *p, enum fsm_event event, int mdiff);
+void port_dispatch(struct port *p, enum fsm_event event, int mdiff);
/**
* Generates state machine events based on activity on a port's file