This introduces the '-a' option in ts2phc, an option inspired from
phc2sys that puts the clocks in "automatic" mode. In this mode, ts2phc
listens, as a PMC, to port state change events from ptp4l, and detects
which port state machine, if any, has transitioned to PS_SLAVE. That
port's clock will become the synchronization master for the hierarchy
described by ts2phc.
The use case is a multi-switch DSA setup with boundary_clock_jbod, where
there is only one grandmaster, connected to one switch's port. The other
switches, connected together through a PPS signal, must adapt themselves
to this new source of time, while the switch connected to the GM must
not be synchronized by ts2phc because it is already synchronized by
ptp4l.
Graphically, the setup looks like this:
+---------------------------------------------------------------+
| LS1028A /dev/ptp0 (unused) |
| +------------------------------+ |
| | DSA master for Felix | |
| |(internal ENETC port 2: eno2))| |
| +------------+------------------------------+-------------+ |
| | Felix embedded L2 switch /dev/ptp1 | |
| | PPS master, sync slave | |
| | +--------------+ +--------------+ +--------------+ | |
| | |DSA master for| |DSA master for| |DSA master for| | |
| | | SJA1105 1 | | SJA1105 2 | | SJA1105 3 | | |
| | |(Felix port 1)| |(Felix port 2)| |(Felix port 3)| | |
+--+-+--------------+---+--------------+---+--------------+--+--+
/dev/ptp2 /dev/ptp3 /dev/ptp4
PPS slave, sync master PPS slave, sync slave PPS slave, sync slave
+-----------------------+ +-----------------------+ +-----------------------+
| SJA1105 switch 1 | | SJA1105 switch 2 | | SJA1105 switch 3 |
+-----+-----+-----+-----+ +-----+-----+-----+-----+ +-----+-----+-----+-----+
|sw1p0|sw1p1|sw1p2|sw1p3| |sw2p0|sw2p1|sw2p2|sw2p3| |sw3p0|sw3p1|sw3p2|sw3p3|
+-----+-----+-----+-----+ +-----+-----+-----+-----+ +-----+-----+-----+-----+
^
|
GM connected here
In the described state, the Felix embedded L2 switch is statically
configured to emit a 1PPS signal on a sort of "simplex bus", and SJA1105
switches 1 to 3 are statically configured to record it in their
respective time bases. Because the GM is connected to one of the ports
of SJA1105 switch 1, that port is in PS_SLAVE and is the source of
ts2phc time. So the embedded L2 switch as well as the other SJA1105
switches synchronize to the SJA1105.
When the GM migrates to a port belonging to a different PHC (say sw2p0),
the PPS distribution tree remains unchanged but the port reported by
ptp4l as being in PS_SLAVE changes. So ts2phc must reconfigure itself to
use the time of /dev/ptp3 as source, and the other PHC devices turn into
sinks.
Signed-off-by: Vladimir Oltean <olte...@gmail.com>
---
Changes in v4:
- use the new pmc agent API
- add more info to the commit message
- priv->state_changed can be delayed to a future patch
- use enum port_state instead of int
Changes in v3:
- Added man page and usage verbiage.
- Removed some useless curly braces in ts2phc_cleanup().
makefile | 5 +-
ts2phc.8 | 15 ++++
ts2phc.c | 227 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
ts2phc.h | 14 +++-
4 files changed, 256 insertions(+), 5 deletions(-)
diff --git a/makefile b/makefile
index 33e7ca0f038b..6d49b911153e 100644
--- a/makefile
+++ b/makefile
@@ -68,8 +68,9 @@ phc_ctl: phc_ctl.o phc.o sk.o util.o clockadj.o sysoff.o
print.o version.o
timemaster: phc.o print.o rtnl.o sk.o timemaster.o util.o version.o
-ts2phc: config.o clockadj.o hash.o interface.o phc.o print.o $(SERVOS) sk.o \
- $(TS2PHC) util.o version.o
+ts2phc: config.o clockadj.o hash.o interface.o msg.o phc.o pmc_agent.o \
+ pmc_common.o print.o $(SERVOS) sk.o $(TS2PHC) tlv.o transport.o raw.o \
+ udp.o udp6.o uds.o util.o version.o
version.o: .version version.sh $(filter-out version.d,$(DEPEND))
diff --git a/ts2phc.8 b/ts2phc.8
index 690c4627f9f2..1a3d2feac1b7 100644
--- a/ts2phc.8
+++ b/ts2phc.8
@@ -26,6 +26,21 @@ A single source may be used to distribute time to one or
more PHC devices.
.SH OPTIONS
.TP
+.BI \-a
+Adjust the direction of synchronization automatically. The program determines
+which PHC should be a source of time and which should be a sink by querying the
+port states from the running instance of
+.B ptp4l.
+Note that using this option, the PPS signal distribution hierarchy still
+remains fixed as per the configuration file. This implies that using this
+option, a PHC PPS master may become a time sink, and a PPS slave may become a
+time source. Other, non-PHC types of PPS masters (generic, NMEA) cannot become
+time sinks. Clocks which are not part of
+.B ptp4l's
+list of ports are not synchronized. This option is useful when the
+.B boundary_clock_jbod
+option of ptp4l is also enabled.
+.TP
.BI \-c " device|name"
Specifies a PHC to be synchronized.
The clock may be identified by its character device (like /dev/ptp0)
diff --git a/ts2phc.c b/ts2phc.c
index 147133721212..fe19f11db7d0 100644
--- a/ts2phc.c
+++ b/ts2phc.c
@@ -6,6 +6,7 @@
* @note Copyright (C) 2012 Richard Cochran <richardcoch...@gmail.com>
* @note SPDX-License-Identifier: GPL-2.0+
*/
+#include <errno.h>
#include <stdlib.h>
#include <net/if.h>
#include <sys/types.h>
@@ -13,6 +14,7 @@
#include "clockadj.h"
#include "config.h"
+#include "contain.h"
#include "interface.h"
#include "phc.h"
#include "print.h"
@@ -25,11 +27,106 @@ struct interface {
static void ts2phc_cleanup(struct ts2phc_private *priv)
{
+ struct port *p, *tmp;
+
ts2phc_slave_cleanup(priv);
if (priv->master)
ts2phc_master_destroy(priv->master);
if (priv->cfg)
config_destroy(priv->cfg);
+
+ pmc_agent_destroy(priv->agent);
+
+ /*
+ * Clocks are destroyed by the cleanup methods of the individual
+ * master and slave PHC modules.
+ */
+ LIST_FOREACH_SAFE(p, &priv->ports, list, tmp)
+ free(p);
+
+ msg_cleanup();
+}
+
+/* FIXME: copied from phc2sys */
+static enum port_state normalize_state(enum port_state state)
+{
+ if (state != PS_MASTER && state != PS_SLAVE &&
+ state != PS_PRE_MASTER && state != PS_UNCALIBRATED) {
+ /* treat any other state as "not a master nor a slave" */
+ state = PS_DISABLED;
+ }
+ return state;
+}
+
+/* FIXME: copied from phc2sys */
+static struct port *port_get(struct ts2phc_private *priv, unsigned int number)
+{
+ struct port *p;
+
+ LIST_FOREACH(p, &priv->ports, list) {
+ if (p->number == number)
+ return p;
+ }
+ return NULL;
+}
+
+/* FIXME: copied from phc2sys */
+static enum port_state clock_compute_state(struct ts2phc_private *priv,
+ struct clock *clock)
+{
+ int state = PS_DISABLED;
+ struct port *p;
+
+ LIST_FOREACH(p, &priv->ports, list) {
+ if (p->clock != clock)
+ continue;
+ /* PS_SLAVE takes the highest precedence, PS_UNCALIBRATED
+ * after that, PS_MASTER is third, PS_PRE_MASTER fourth and
+ * all of that overrides PS_DISABLED, which corresponds
+ * nicely with the numerical values */
+ if (p->state > state)
+ state = p->state;
+ }
+ return state;
+}
+
+static int ts2phc_recv_subscribed(void *context, struct ptp_message *msg,
+ int excluded)
+{
+ struct ts2phc_private *priv = context;
+ enum port_state state;
+ struct clock *clock;
+ struct portDS *pds;
+ struct port *port;
+ int mgt_id;
+
+ mgt_id = management_tlv_id(msg);
+ if (mgt_id == excluded)
+ return 0;
+
+ switch (mgt_id) {
+ case MID_PORT_DATA_SET:
+ pds = management_tlv_data(msg);
+ port = port_get(priv, pds->portIdentity.portNumber);
+ if (!port) {
+ pr_info("received data for unknown port %s",
+ pid2str(&pds->portIdentity));
+ return 1;
+ }
+ state = normalize_state(pds->portState);
+ if (port->state != state) {
+ pr_info("port %s changed state",
+ pid2str(&pds->portIdentity));
+ port->state = state;
+ clock = port->clock;
+ state = clock_compute_state(priv, clock);
+ if (clock->state != state || clock->new_state) {
+ clock->new_state = state;
+ }
+ }
+ return 1;
+ }
+ return 0;
}
static struct servo *servo_add(struct ts2phc_private *priv, struct clock
*clock)
@@ -106,11 +203,112 @@ void clock_destroy(struct clock *c)
free(c);
}
+static struct port *port_add(struct ts2phc_private *priv, unsigned int number,
+ char *device)
+{
+ struct clock *c = NULL;
+ struct port *p, *tmp;
+
+ p = port_get(priv, number);
+ if (p)
+ return p;
+ /* port is a new one, look whether we have the device already
+ * on a different port
+ */
+ LIST_FOREACH(tmp, &priv->ports, list) {
+ if (tmp->number == number) {
+ c = tmp->clock;
+ break;
+ }
+ }
+ if (!c) {
+ c = clock_add(priv, device);
+ if (!c)
+ return NULL;
+ }
+ p = malloc(sizeof(*p));
+ if (!p) {
+ pr_err("failed to allocate memory for a port");
+ clock_destroy(c);
+ return NULL;
+ }
+ p->number = number;
+ p->clock = c;
+ LIST_INSERT_HEAD(&priv->ports, p, list);
+ return p;
+}
+
+static int auto_init_ports(struct ts2phc_private *priv)
+{
+ int state, timestamping;
+ int number_ports, err;
+ char iface[IFNAMSIZ];
+ struct clock *clock;
+ struct port *port;
+ unsigned int i;
+
+ while (1) {
+ if (!is_running())
+ return -1;
+ err = pmc_agent_query_dds(priv->agent, 1000);
+ if (!err)
+ break;
+ if (err == -ETIMEDOUT)
+ pr_notice("Waiting for ptp4l...");
+ else
+ return -1;
+ }
+
+ number_ports = pmc_agent_get_number_ports(priv->agent);
+ if (number_ports <= 0) {
+ pr_err("failed to get number of ports");
+ return -1;
+ }
+
+ err = pmc_agent_subscribe(priv->agent, 1000);
+ if (err) {
+ pr_err("failed to subscribe");
+ return -1;
+ }
+
+ for (i = 1; i <= number_ports; i++) {
+ err = pmc_agent_query_port_properties(priv->agent, 1000, i,
+ &state, ×tamping,
+ iface);
+ if (err == -ENODEV) {
+ /* port does not exist, ignore the port */
+ continue;
+ }
+ if (err) {
+ pr_err("failed to get port properties");
+ return -1;
+ }
+ if (timestamping == TS_SOFTWARE) {
+ /* ignore ports with software time stamping */
+ continue;
+ }
+ port = port_add(priv, i, iface);
+ if (!port)
+ return -1;
+ port->state = normalize_state(state);
+ }
+ if (LIST_EMPTY(&priv->clocks)) {
+ pr_err("no suitable ports available");
+ return -1;
+ }
+ LIST_FOREACH(clock, &priv->clocks, list) {
+ clock->new_state = clock_compute_state(priv, clock);
+ }
+
+ return 0;
+}
+
static void usage(char *progname)
{
fprintf(stderr,
"\n"
"usage: %s [options]\n\n"
+ " -a turn on autoconfiguration\n"
" -c [dev|name] PHC time sink (like /dev/ptp0 or eth0)\n"
" (may be specified multiple times)\n"
" -f [file] read configuration from 'file'\n"
@@ -132,6 +330,7 @@ static void usage(char *progname)
int main(int argc, char *argv[])
{
int c, err = 0, have_slave = 0, index, print_level;
+ char uds_local[MAX_IFNAME_SIZE + 1];
enum ts2phc_master_type pps_type;
struct ts2phc_private priv = {0};
char *config = NULL, *progname;
@@ -139,6 +338,7 @@ int main(int argc, char *argv[])
struct config *cfg = NULL;
struct interface *iface;
struct option *opts;
+ int autocfg = 0;
handle_term_signals();
@@ -147,13 +347,18 @@ int main(int argc, char *argv[])
ts2phc_cleanup(&priv);
return -1;
}
+ priv.agent = pmc_agent_create();
+ if (!priv.agent) {
+ ts2phc_cleanup(&priv);
+ return -1;
+ }
opts = config_long_options(cfg);
/* Process the command line arguments. */
progname = strrchr(argv[0], '/');
progname = progname ? 1 + progname : argv[0];
- while (EOF != (c = getopt_long(argc, argv, "c:f:hi:l:mqs:v", opts,
&index))) {
+ while (EOF != (c = getopt_long(argc, argv, "ac:f:hi:l:mqs:v", opts,
&index))) {
switch (c) {
case 0:
if (config_parse_option(cfg, opts[index].name, optarg))
{
@@ -161,6 +366,9 @@ int main(int argc, char *argv[])
return -1;
}
break;
+ case 'a':
+ autocfg = 1;
+ break;
case 'c':
if (!config_create_interface(optarg, cfg)) {
fprintf(stderr, "failed to add slave\n");
@@ -226,6 +434,23 @@ int main(int argc, char *argv[])
STAILQ_INIT(&priv.slaves);
priv.cfg = cfg;
+ snprintf(uds_local, sizeof(uds_local), "/var/run/ts2phc.%d",
+ getpid());
+
+ if (autocfg) {
+ err = init_pmc_node(cfg, priv.agent, uds_local,
+ ts2phc_recv_subscribed, &priv);
+ if (err) {
+ ts2phc_cleanup(&priv);
+ return -1;
+ }
+ err = auto_init_ports(&priv);
+ if (err) {
+ ts2phc_cleanup(&priv);
+ return -1;
+ }
+ }
+
STAILQ_FOREACH(iface, &cfg->interfaces, list) {
if (1 == config_get_int(cfg, interface_name(iface),
"ts2phc.master")) {
if (pps_source) {
diff --git a/ts2phc.h b/ts2phc.h
index f80f11ae77b3..cd9912d78a1f 100644
--- a/ts2phc.h
+++ b/ts2phc.h
@@ -10,6 +10,7 @@
#include <stdbool.h>
#include <sys/queue.h>
#include <time.h>
+#include "pmc_agent.h"
#include "servo.h"
struct ts2phc_slave_array;
@@ -21,21 +22,30 @@ struct clock {
LIST_ENTRY(clock) dst_list;
clockid_t clkid;
int phc_index;
- int state;
- int new_state;
+ enum port_state state;
+ enum port_state new_state;
struct servo *servo;
enum servo_state servo_state;
char *name;
bool no_adj;
};
+struct port {
+ LIST_ENTRY(port) list;
+ unsigned int number;
+ int state;
+ struct clock *clock;
+};
+
struct ts2phc_private {
struct ts2phc_master *master;
STAILQ_HEAD(slave_ifaces_head, ts2phc_slave) slaves;
unsigned int n_slaves;
struct ts2phc_slave_array *polling_array;
struct config *cfg;
+ struct pmc_agent *agent;
struct clock *source;
+ LIST_HEAD(port_head, port) ports;
LIST_HEAD(clock_head, clock) clocks;
};
--
2.25.1
_______________________________________________
Linuxptp-devel mailing list
Linuxptp-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linuxptp-devel
