From 14e09fd9ed1a57ea64279b79a87aae316efa107a Mon Sep 17 00:00:00 2001 From: Vladimir Oltean Date: Tue, 18 Aug 2020 02:19:30 +0300 Subject: [PATCH] phc2sys: rename struct node to struct phc2sys_private We will be reusing some PMC code between phc2sys and ts2phc. In preparation of that, we would like to extract the PMC related properties of the current private program data structure of phc2sys, "struct node", into something smaller that can be shared properly. The "struct node" name is nice enough, so use that to denote the smaller data structure for PMC from now on. Rename the bigger data structure to phc2sys_private. Signed-off-by: Vladimir Oltean Reviewed-by: Jacob Keller --- phc2sys.c | 433 ++++++++++++++++++++++++++++-------------------------- 1 file changed, 221 insertions(+), 212 deletions(-) diff --git a/phc2sys.c b/phc2sys.c index 64bdf26..a36cbe0 100644 --- a/phc2sys.c +++ b/phc2sys.c @@ -99,7 +99,7 @@ struct port { struct clock *clock; }; -struct node { +struct phc2sys_private { unsigned int stats_max_count; int sanity_freq_limit; enum servo_type servo_type; @@ -124,18 +124,21 @@ struct node { static struct config *phc2sys_config; -static int update_pmc(struct node *node, int subscribe); -static int clock_handle_leap(struct node *node, struct clock *clock, +static int update_pmc(struct phc2sys_private *priv, int subscribe); +static int clock_handle_leap(struct phc2sys_private *priv, + struct clock *clock, int64_t offset, uint64_t ts); -static int run_pmc_get_utc_offset(struct node *node, int timeout); -static void run_pmc_events(struct node *node); +static int run_pmc_get_utc_offset(struct phc2sys_private *priv, + int timeout); +static void run_pmc_events(struct phc2sys_private *priv); static int normalize_state(int state); -static int run_pmc_port_properties(struct node *node, int timeout, - unsigned int port, +static int run_pmc_port_properties(struct phc2sys_private *priv, + int timeout, unsigned int port, int *state, int *tstamping, char *iface); -static struct servo *servo_add(struct node *node, struct clock *clock) +static struct servo *servo_add(struct phc2sys_private *priv, + struct clock *clock) { double ppb; int max_ppb; @@ -157,19 +160,19 @@ static struct servo *servo_add(struct node *node, struct clock *clock) } } - servo = servo_create(phc2sys_config, node->servo_type, + servo = servo_create(phc2sys_config, priv->servo_type, -ppb, max_ppb, 0); if (!servo) { pr_err("Failed to create servo"); return NULL; } - servo_sync_interval(servo, node->phc_interval); + servo_sync_interval(servo, priv->phc_interval); return servo; } -static struct clock *clock_add(struct node *node, char *device) +static struct clock *clock_add(struct phc2sys_private *priv, char *device) { struct clock *c; clockid_t clkid = CLOCK_INVALID; @@ -198,7 +201,7 @@ static struct clock *clock_add(struct node *node, char *device) c->source_label = "phc"; } - if (node->stats_max_count > 0) { + if (priv->stats_max_count > 0) { c->offset_stats = stats_create(); c->freq_stats = stats_create(); c->delay_stats = stats_create(); @@ -209,8 +212,8 @@ static struct clock *clock_add(struct node *node, char *device) return NULL; } } - if (node->sanity_freq_limit) { - c->sanity_check = clockcheck_create(node->sanity_freq_limit); + if (priv->sanity_freq_limit) { + c->sanity_check = clockcheck_create(priv->sanity_freq_limit); if (!c->sanity_check) { pr_err("failed to create clock check"); return NULL; @@ -218,21 +221,21 @@ static struct clock *clock_add(struct node *node, char *device) } if (clkid != CLOCK_INVALID) - c->servo = servo_add(node, c); + c->servo = servo_add(priv, c); if (clkid != CLOCK_INVALID && clkid != CLOCK_REALTIME) c->sysoff_method = sysoff_probe(CLOCKID_TO_FD(clkid), - node->phc_readings); + priv->phc_readings); - LIST_INSERT_HEAD(&node->clocks, c, list); + LIST_INSERT_HEAD(&priv->clocks, c, list); return c; } -static void clock_cleanup(struct node *node) +static void clock_cleanup(struct phc2sys_private *priv) { struct clock *c, *tmp; - LIST_FOREACH_SAFE(c, &node->clocks, list, tmp) { + LIST_FOREACH_SAFE(c, &priv->clocks, list, tmp) { if (c->servo) { servo_destroy(c->servo); } @@ -255,45 +258,45 @@ static void clock_cleanup(struct node *node) } } -static void port_cleanup(struct node *node) +static void port_cleanup(struct phc2sys_private *priv) { struct port *p, *tmp; - LIST_FOREACH_SAFE(p, &node->ports, list, tmp) { + LIST_FOREACH_SAFE(p, &priv->ports, list, tmp) { free(p); } } -static struct port *port_get(struct node *node, unsigned int number) +static struct port *port_get(struct phc2sys_private *priv, unsigned int number) { struct port *p; - LIST_FOREACH(p, &node->ports, list) { + LIST_FOREACH(p, &priv->ports, list) { if (p->number == number) return p; } return NULL; } -static struct port *port_add(struct node *node, unsigned int number, +static struct port *port_add(struct phc2sys_private *priv, unsigned int number, char *device) { struct port *p; struct clock *c = NULL, *tmp; - p = port_get(node, number); + 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, &node->clocks, list) { + LIST_FOREACH(tmp, &priv->clocks, list) { if (!strcmp(tmp->device, device)) { c = tmp; break; } } if (!c) { - c = clock_add(node, device); + c = clock_add(priv, device); if (!c) return NULL; } @@ -304,11 +307,12 @@ static struct port *port_add(struct node *node, unsigned int number, } p->number = number; p->clock = c; - LIST_INSERT_HEAD(&node->ports, p, list); + LIST_INSERT_HEAD(&priv->ports, p, list); return p; } -static void clock_reinit(struct node *node, struct clock *clock, int new_state) +static void clock_reinit(struct phc2sys_private *priv, struct clock *clock, + int new_state) { int phc_index = -1, phc_switched = 0; int state, timestamping, ret = -1; @@ -318,9 +322,9 @@ static void clock_reinit(struct node *node, struct clock *clock, int new_state) char iface[IFNAMSIZ]; clockid_t clkid = CLOCK_INVALID; - LIST_FOREACH(p, &node->ports, list) { + LIST_FOREACH(p, &priv->ports, list) { if (p->clock == clock) { - ret = run_pmc_port_properties(node, 1000, p->number, + ret = run_pmc_port_properties(priv, 1000, p->number, &state, ×tamping, iface); if (ret > 0) @@ -345,7 +349,7 @@ static void clock_reinit(struct node *node, struct clock *clock, int new_state) clock->clkid = clkid; clock->phc_index = phc_index; - servo = servo_add(node, clock); + servo = servo_add(priv, clock); if (servo) { servo_destroy(clock->servo); clock->servo = servo; @@ -367,9 +371,11 @@ static void clock_reinit(struct node *node, struct clock *clock, int new_state) } } -static struct clock *find_dst_clock(struct node *node, int phc_index) { +static struct clock *find_dst_clock(struct phc2sys_private *priv, + int phc_index) +{ struct clock *c = NULL; - LIST_FOREACH(c, &node->dst_clocks, dst_list) { + LIST_FOREACH(c, &priv->dst_clocks, dst_list) { if (c->phc_index == phc_index) { break; } @@ -377,26 +383,26 @@ static struct clock *find_dst_clock(struct node *node, int phc_index) { return c; } -static void reconfigure(struct node *node) +static void reconfigure(struct phc2sys_private *priv) { struct clock *c, *rt = NULL, *src = NULL, *last = NULL, *dup = NULL; int src_cnt = 0, dst_cnt = 0; pr_info("reconfiguring after port state change"); - node->state_changed = 0; + priv->state_changed = 0; - while (node->dst_clocks.lh_first != NULL) { - LIST_REMOVE(node->dst_clocks.lh_first, dst_list); + while (priv->dst_clocks.lh_first != NULL) { + LIST_REMOVE(priv->dst_clocks.lh_first, dst_list); } - LIST_FOREACH(c, &node->clocks, list) { + LIST_FOREACH(c, &priv->clocks, list) { if (c->clkid == CLOCK_REALTIME) { rt = c; continue; } if (c->new_state) { - clock_reinit(node, c, c->new_state); + clock_reinit(priv, c, c->new_state); c->state = c->new_state; c->new_state = 0; } @@ -408,12 +414,12 @@ static void reconfigure(struct node *node) case PS_PRE_MASTER: case PS_MASTER: case PS_PASSIVE: - dup = find_dst_clock(node, c->phc_index); + dup = find_dst_clock(priv, c->phc_index); if (!dup) { pr_info("selecting %s for synchronization", c->device); dst_cnt++; - LIST_INSERT_HEAD(&node->dst_clocks, + LIST_INSERT_HEAD(&priv->dst_clocks, c, dst_list); } else { pr_info("skipping %s: %s has the same clock " @@ -433,10 +439,10 @@ static void reconfigure(struct node *node) } if (dst_cnt > 1 && !src) { if (!rt || rt->dest_only) { - node->master = last; + priv->master = last; /* Reset to original state in next reconfiguration. */ - node->master->new_state = node->master->state; - node->master->state = PS_SLAVE; + priv->master->new_state = priv->master->state; + priv->master->state = PS_SLAVE; if (rt) rt->state = PS_SLAVE; pr_info("no source, selecting %s as the default clock", @@ -446,23 +452,23 @@ static void reconfigure(struct node *node) } if (src_cnt > 1) { pr_info("multiple master clocks available, postponing sync..."); - node->master = NULL; + priv->master = NULL; return; } if (src_cnt > 0 && !src) { pr_info("master clock not ready, waiting..."); - node->master = NULL; + priv->master = NULL; return; } if (!src_cnt && !dst_cnt) { pr_info("no PHC ready, waiting..."); - node->master = NULL; + priv->master = NULL; return; } if ((!src_cnt && (!rt || rt->dest_only)) || (!dst_cnt && !rt)) { pr_info("nothing to synchronize"); - node->master = NULL; + priv->master = NULL; return; } if (!src_cnt) { @@ -471,12 +477,12 @@ static void reconfigure(struct node *node) } else if (rt) { if (rt->state != PS_MASTER) { rt->state = PS_MASTER; - clock_reinit(node, rt, rt->state); + clock_reinit(priv, rt, rt->state); } - LIST_INSERT_HEAD(&node->dst_clocks, rt, dst_list); + LIST_INSERT_HEAD(&priv->dst_clocks, rt, dst_list); pr_info("selecting %s for synchronization", rt->device); } - node->master = src; + priv->master = src; pr_info("selecting %s as the master clock", src->device); } @@ -511,12 +517,12 @@ static int read_phc(clockid_t clkid, clockid_t sysclk, int readings, return 1; } -static int64_t get_sync_offset(struct node *node, struct clock *dst) +static int64_t get_sync_offset(struct phc2sys_private *priv, struct clock *dst) { - int direction = node->forced_sync_offset; + int direction = priv->forced_sync_offset; if (!direction) - direction = dst->is_utc - node->master->is_utc; + direction = dst->is_utc - priv->master->is_utc; return (int64_t)dst->sync_offset * NS_PER_SEC * direction; } @@ -559,16 +565,16 @@ static void update_clock_stats(struct clock *clock, unsigned int max_count, stats_reset(clock->delay_stats); } -static void update_clock(struct node *node, struct clock *clock, +static void update_clock(struct phc2sys_private *priv, struct clock *clock, int64_t offset, uint64_t ts, int64_t delay) { enum servo_state state; double ppb; - if (clock_handle_leap(node, clock, offset, ts)) + if (clock_handle_leap(priv, clock, offset, ts)) return; - offset += get_sync_offset(node, clock); + offset += get_sync_offset(priv, clock); if (clock->sanity_check && clockcheck_sample(clock->sanity_check, ts)) servo_reset(clock->servo); @@ -595,16 +601,16 @@ static void update_clock(struct node *node, struct clock *clock, } if (clock->offset_stats) { - update_clock_stats(clock, node->stats_max_count, offset, ppb, delay); + update_clock_stats(clock, priv->stats_max_count, offset, ppb, delay); } else { if (delay >= 0) { pr_info("%s %s offset %9" PRId64 " s%d freq %+7.0f " "delay %6" PRId64, - clock->device, node->master->source_label, + clock->device, priv->master->source_label, offset, state, ppb, delay); } else { pr_info("%s %s offset %9" PRId64 " s%d freq %+7.0f", - clock->device, node->master->source_label, + clock->device, priv->master->source_label, offset, state, ppb); } } @@ -642,19 +648,20 @@ static int read_pps(int fd, int64_t *offset, uint64_t *ts) return 1; } -static int do_pps_loop(struct node *node, struct clock *clock, int fd) +static int do_pps_loop(struct phc2sys_private *priv, struct clock *clock, + int fd) { int64_t pps_offset, phc_offset, phc_delay; uint64_t pps_ts, phc_ts; - clockid_t src = node->master->clkid; + clockid_t src = priv->master->clkid; - node->master->source_label = "pps"; + priv->master->source_label = "pps"; if (src == CLOCK_INVALID) { /* The sync offset can't be applied with PPS alone. */ - node->sync_offset = 0; + priv->sync_offset = 0; } else { - enable_pps_output(node->master->clkid); + enable_pps_output(priv->master->clkid); } while (is_running()) { @@ -665,7 +672,7 @@ static int do_pps_loop(struct node *node, struct clock *clock, int fd) /* If a PHC is available, use it to get the whole number of seconds in the offset and PPS for the rest. */ if (src != CLOCK_INVALID) { - if (!read_phc(src, clock->clkid, node->phc_readings, + if (!read_phc(src, clock->clkid, priv->phc_readings, &phc_offset, &phc_ts, &phc_delay)) return -1; @@ -683,9 +690,9 @@ static int do_pps_loop(struct node *node, struct clock *clock, int fd) pps_offset = pps_ts - phc_ts; } - if (update_pmc(node, 0) < 0) + if (update_pmc(priv, 0) < 0) continue; - update_clock(node, clock, pps_offset, pps_ts, -1); + update_clock(priv, clock, pps_offset, pps_ts, -1); } close(fd); return 0; @@ -708,45 +715,45 @@ static int update_needed(struct clock *c) return 0; } -static int do_loop(struct node *node, int subscriptions) +static int do_loop(struct phc2sys_private *priv, int subscriptions) { struct timespec interval; struct clock *clock; uint64_t ts; int64_t offset, delay; - interval.tv_sec = node->phc_interval; - interval.tv_nsec = (node->phc_interval - interval.tv_sec) * 1e9; + interval.tv_sec = priv->phc_interval; + interval.tv_nsec = (priv->phc_interval - interval.tv_sec) * 1e9; while (is_running()) { clock_nanosleep(CLOCK_MONOTONIC, 0, &interval, NULL); - if (update_pmc(node, subscriptions) < 0) + if (update_pmc(priv, subscriptions) < 0) continue; if (subscriptions) { - run_pmc_events(node); - if (node->state_changed) { + run_pmc_events(priv); + if (priv->state_changed) { /* force getting offset, as it may have * changed after the port state change */ - if (run_pmc_get_utc_offset(node, 1000) <= 0) { + if (run_pmc_get_utc_offset(priv, 1000) <= 0) { pr_err("failed to get UTC offset"); continue; } - reconfigure(node); + reconfigure(priv); } } - if (!node->master) + if (!priv->master) continue; - LIST_FOREACH(clock, &node->dst_clocks, dst_list) { + LIST_FOREACH(clock, &priv->dst_clocks, dst_list) { if (!update_needed(clock)) continue; /* don't try to synchronize the clock to itself */ - if (clock->clkid == node->master->clkid || + if (clock->clkid == priv->master->clkid || (clock->phc_index >= 0 && - clock->phc_index == node->master->phc_index) || - !strcmp(clock->device, node->master->device)) + clock->phc_index == priv->master->phc_index) || + !strcmp(clock->device, priv->master->device)) continue; if (!clock->servo) { @@ -755,41 +762,42 @@ static int do_loop(struct node *node, int subscriptions) } if (clock->clkid == CLOCK_REALTIME && - node->master->sysoff_method >= 0) { + priv->master->sysoff_method >= 0) { /* use sysoff */ - if (sysoff_measure(CLOCKID_TO_FD(node->master->clkid), - node->master->sysoff_method, - node->phc_readings, + if (sysoff_measure(CLOCKID_TO_FD(priv->master->clkid), + priv->master->sysoff_method, + priv->phc_readings, &offset, &ts, &delay) < 0) return -1; - } else if (node->master->clkid == CLOCK_REALTIME && + } else if (priv->master->clkid == CLOCK_REALTIME && clock->sysoff_method >= 0) { /* use reversed sysoff */ if (sysoff_measure(CLOCKID_TO_FD(clock->clkid), clock->sysoff_method, - node->phc_readings, + priv->phc_readings, &offset, &ts, &delay) < 0) return -1; offset = -offset; ts += offset; } else { /* use phc */ - if (!read_phc(node->master->clkid, clock->clkid, - node->phc_readings, + if (!read_phc(priv->master->clkid, clock->clkid, + priv->phc_readings, &offset, &ts, &delay)) continue; } - update_clock(node, clock, offset, ts, delay); + update_clock(priv, clock, offset, ts, delay); } } return 0; } -static int check_clock_identity(struct node *node, struct ptp_message *msg) +static int check_clock_identity(struct phc2sys_private *priv, + struct ptp_message *msg) { - if (!node->clock_identity_set) + if (!priv->clock_identity_set) return 1; - return cid_eq(&node->clock_identity, + return cid_eq(&priv->clock_identity, &msg->header.sourcePortIdentity.clockIdentity); } @@ -841,12 +849,13 @@ static int normalize_state(int state) return state; } -static int clock_compute_state(struct node *node, struct clock *clock) +static int clock_compute_state(struct phc2sys_private *priv, + struct clock *clock) { struct port *p; int state = PS_DISABLED; - LIST_FOREACH(p, &node->ports, list) { + LIST_FOREACH(p, &priv->ports, list) { if (p->clock != clock) continue; /* PS_SLAVE takes the highest precedence, PS_UNCALIBRATED @@ -859,8 +868,8 @@ static int clock_compute_state(struct node *node, struct clock *clock) return state; } -static int recv_subscribed(struct node *node, struct ptp_message *msg, - int excluded) +static int recv_subscribed(struct phc2sys_private *priv, + struct ptp_message *msg, int excluded) { int mgt_id, state; struct portDS *pds; @@ -873,7 +882,7 @@ static int recv_subscribed(struct node *node, struct ptp_message *msg, switch (mgt_id) { case TLV_PORT_DATA_SET: pds = get_mgt_data(msg); - port = port_get(node, pds->portIdentity.portNumber); + port = port_get(priv, pds->portIdentity.portNumber); if (!port) { pr_info("received data for unknown port %s", pid2str(&pds->portIdentity)); @@ -885,10 +894,10 @@ static int recv_subscribed(struct node *node, struct ptp_message *msg, pid2str(&pds->portIdentity)); port->state = state; clock = port->clock; - state = clock_compute_state(node, clock); + state = clock_compute_state(priv, clock); if (clock->state != state || clock->new_state) { clock->new_state = state; - node->state_changed = 1; + priv->state_changed = 1; } } return 1; @@ -896,26 +905,26 @@ static int recv_subscribed(struct node *node, struct ptp_message *msg, return 0; } -static void send_subscription(struct node *node) +static void send_subscription(struct phc2sys_private *priv) { struct subscribe_events_np sen; memset(&sen, 0, sizeof(sen)); sen.duration = PMC_SUBSCRIBE_DURATION; sen.bitmask[0] = 1 << NOTIFY_PORT_STATE; - pmc_send_set_action(node->pmc, TLV_SUBSCRIBE_EVENTS_NP, &sen, sizeof(sen)); + pmc_send_set_action(priv->pmc, TLV_SUBSCRIBE_EVENTS_NP, &sen, sizeof(sen)); } -static int init_pmc(struct config *cfg, struct node *node) +static int init_pmc(struct config *cfg, struct phc2sys_private *priv) { char uds_local[MAX_IFNAME_SIZE + 1]; snprintf(uds_local, sizeof(uds_local), "/var/run/phc2sys.%d", getpid()); - node->pmc = pmc_create(cfg, TRANS_UDS, uds_local, 0, + priv->pmc = pmc_create(cfg, TRANS_UDS, uds_local, 0, config_get_int(cfg, NULL, "domainNumber"), config_get_int(cfg, NULL, "transportSpecific") << 4, 1); - if (!node->pmc) { + if (!priv->pmc) { pr_err("failed to create pmc"); return -1; } @@ -929,7 +938,7 @@ static int init_pmc(struct config *cfg, struct node *node) * -1: error reported by the other side * -2: local error, fatal */ -static int run_pmc(struct node *node, int timeout, int ds_id, +static int run_pmc(struct phc2sys_private *priv, int timeout, int ds_id, struct ptp_message **msg) { #define N_FD 1 @@ -937,9 +946,9 @@ static int run_pmc(struct node *node, int timeout, int ds_id, int cnt, res; while (1) { - pollfd[0].fd = pmc_get_transport_fd(node->pmc); + pollfd[0].fd = pmc_get_transport_fd(priv->pmc); pollfd[0].events = POLLIN|POLLPRI; - if (!node->pmc_ds_requested && ds_id >= 0) + if (!priv->pmc_ds_requested && ds_id >= 0) pollfd[0].events |= POLLOUT; cnt = poll(pollfd, N_FD, timeout); @@ -949,7 +958,7 @@ static int run_pmc(struct node *node, int timeout, int ds_id, } if (!cnt) { /* Request the data set again in the next run. */ - node->pmc_ds_requested = 0; + priv->pmc_ds_requested = 0; return 0; } @@ -958,24 +967,24 @@ static int run_pmc(struct node *node, int timeout, int ds_id, !(pollfd[0].revents & (POLLIN|POLLPRI))) { switch (ds_id) { case TLV_SUBSCRIBE_EVENTS_NP: - send_subscription(node); + send_subscription(priv); break; default: - pmc_send_get_action(node->pmc, ds_id); + pmc_send_get_action(priv->pmc, ds_id); break; } - node->pmc_ds_requested = 1; + priv->pmc_ds_requested = 1; } if (!(pollfd[0].revents & (POLLIN|POLLPRI))) continue; - *msg = pmc_recv(node->pmc); + *msg = pmc_recv(priv->pmc); if (!*msg) continue; - if (!check_clock_identity(node, *msg)) { + if (!check_clock_identity(priv, *msg)) { msg_put(*msg); *msg = NULL; continue; @@ -983,21 +992,21 @@ static int run_pmc(struct node *node, int timeout, int ds_id, res = is_msg_mgt(*msg); if (res < 0 && get_mgt_err_id(*msg) == ds_id) { - node->pmc_ds_requested = 0; + priv->pmc_ds_requested = 0; return -1; } - if (res <= 0 || recv_subscribed(node, *msg, ds_id) || + if (res <= 0 || recv_subscribed(priv, *msg, ds_id) || get_mgt_id(*msg) != ds_id) { msg_put(*msg); *msg = NULL; continue; } - node->pmc_ds_requested = 0; + priv->pmc_ds_requested = 0; return 1; } } -static int run_pmc_wait_sync(struct node *node, int timeout) +static int run_pmc_wait_sync(struct phc2sys_private *priv, int timeout) { struct ptp_message *msg; int res; @@ -1005,7 +1014,7 @@ static int run_pmc_wait_sync(struct node *node, int timeout) Enumeration8 portState; while (1) { - res = run_pmc(node, timeout, TLV_PORT_DATA_SET, &msg); + res = run_pmc(priv, timeout, TLV_PORT_DATA_SET, &msg); if (res <= 0) return res; @@ -1019,47 +1028,47 @@ static int run_pmc_wait_sync(struct node *node, int timeout) return 1; } /* try to get more data sets (for other ports) */ - node->pmc_ds_requested = 1; + priv->pmc_ds_requested = 1; } } -static int run_pmc_get_utc_offset(struct node *node, int timeout) +static int run_pmc_get_utc_offset(struct phc2sys_private *priv, int timeout) { struct ptp_message *msg; int res; struct timePropertiesDS *tds; - res = run_pmc(node, timeout, TLV_TIME_PROPERTIES_DATA_SET, &msg); + res = run_pmc(priv, timeout, TLV_TIME_PROPERTIES_DATA_SET, &msg); if (res <= 0) return res; tds = (struct timePropertiesDS *)get_mgt_data(msg); if (tds->flags & PTP_TIMESCALE) { - node->sync_offset = tds->currentUtcOffset; + priv->sync_offset = tds->currentUtcOffset; if (tds->flags & LEAP_61) - node->leap = 1; + priv->leap = 1; else if (tds->flags & LEAP_59) - node->leap = -1; + priv->leap = -1; else - node->leap = 0; - node->utc_offset_traceable = tds->flags & UTC_OFF_VALID && + priv->leap = 0; + priv->utc_offset_traceable = tds->flags & UTC_OFF_VALID && tds->flags & TIME_TRACEABLE; } else { - node->sync_offset = 0; - node->leap = 0; - node->utc_offset_traceable = 0; + priv->sync_offset = 0; + priv->leap = 0; + priv->utc_offset_traceable = 0; } msg_put(msg); return 1; } -static int run_pmc_get_number_ports(struct node *node, int timeout) +static int run_pmc_get_number_ports(struct phc2sys_private *priv, int timeout) { struct ptp_message *msg; int res; struct defaultDS *dds; - res = run_pmc(node, timeout, TLV_DEFAULT_DATA_SET, &msg); + res = run_pmc(priv, timeout, TLV_DEFAULT_DATA_SET, &msg); if (res <= 0) return res; @@ -1069,26 +1078,26 @@ static int run_pmc_get_number_ports(struct node *node, int timeout) return res; } -static int run_pmc_subscribe(struct node *node, int timeout) +static int run_pmc_subscribe(struct phc2sys_private *priv, int timeout) { struct ptp_message *msg; int res; - res = run_pmc(node, timeout, TLV_SUBSCRIBE_EVENTS_NP, &msg); + res = run_pmc(priv, timeout, TLV_SUBSCRIBE_EVENTS_NP, &msg); if (res <= 0) return res; msg_put(msg); return 1; } -static void run_pmc_events(struct node *node) +static void run_pmc_events(struct phc2sys_private *priv) { struct ptp_message *msg; - run_pmc(node, 0, -1, &msg); + run_pmc(priv, 0, -1, &msg); } -static int run_pmc_port_properties(struct node *node, int timeout, +static int run_pmc_port_properties(struct phc2sys_private *priv, int timeout, unsigned int port, int *state, int *tstamping, char *iface) { @@ -1096,9 +1105,9 @@ static int run_pmc_port_properties(struct node *node, int timeout, int res, len; struct port_properties_np *ppn; - pmc_target_port(node->pmc, port); + pmc_target_port(priv->pmc, port); while (1) { - res = run_pmc(node, timeout, TLV_PORT_PROPERTIES_NP, &msg); + res = run_pmc(priv, timeout, TLV_PORT_PROPERTIES_NP, &msg); if (res <= 0) goto out; @@ -1121,35 +1130,35 @@ static int run_pmc_port_properties(struct node *node, int timeout, break; } out: - pmc_target_all(node->pmc); + pmc_target_all(priv->pmc); return res; } -static int run_pmc_clock_identity(struct node *node, int timeout) +static int run_pmc_clock_identity(struct phc2sys_private *priv, int timeout) { struct ptp_message *msg; struct defaultDS *dds; int res; - res = run_pmc(node, timeout, TLV_DEFAULT_DATA_SET, &msg); + res = run_pmc(priv, timeout, TLV_DEFAULT_DATA_SET, &msg); if (res <= 0) return res; dds = (struct defaultDS *)get_mgt_data(msg); - memcpy(&node->clock_identity, &dds->clockIdentity, + memcpy(&priv->clock_identity, &dds->clockIdentity, sizeof(struct ClockIdentity)); - node->clock_identity_set = 1; + priv->clock_identity_set = 1; msg_put(msg); return 1; } -static void close_pmc(struct node *node) +static void close_pmc(struct phc2sys_private *priv) { - pmc_destroy(node->pmc); - node->pmc = NULL; + pmc_destroy(priv->pmc); + priv->pmc = NULL; } -static int auto_init_ports(struct node *node, int add_rt) +static int auto_init_ports(struct phc2sys_private *priv, int add_rt) { struct port *port; struct clock *clock; @@ -1161,7 +1170,7 @@ static int auto_init_ports(struct node *node, int add_rt) while (1) { if (!is_running()) return -1; - res = run_pmc_clock_identity(node, 1000); + res = run_pmc_clock_identity(priv, 1000); if (res < 0) return -1; if (res > 0) @@ -1170,20 +1179,20 @@ static int auto_init_ports(struct node *node, int add_rt) pr_notice("Waiting for ptp4l..."); } - number_ports = run_pmc_get_number_ports(node, 1000); + number_ports = run_pmc_get_number_ports(priv, 1000); if (number_ports <= 0) { pr_err("failed to get number of ports"); return -1; } - res = run_pmc_subscribe(node, 1000); + res = run_pmc_subscribe(priv, 1000); if (res <= 0) { pr_err("failed to subscribe"); return -1; } for (i = 1; i <= number_ports; i++) { - res = run_pmc_port_properties(node, 1000, i, &state, + res = run_pmc_port_properties(priv, 1000, i, &state, ×tamping, iface); if (res == -1) { /* port does not exist, ignore the port */ @@ -1197,22 +1206,22 @@ static int auto_init_ports(struct node *node, int add_rt) /* ignore ports with software time stamping */ continue; } - port = port_add(node, i, iface); + port = port_add(priv, i, iface); if (!port) return -1; port->state = normalize_state(state); } - if (LIST_EMPTY(&node->clocks)) { + if (LIST_EMPTY(&priv->clocks)) { pr_err("no suitable ports available"); return -1; } - LIST_FOREACH(clock, &node->clocks, list) { - clock->new_state = clock_compute_state(node, clock); + LIST_FOREACH(clock, &priv->clocks, list) { + clock->new_state = clock_compute_state(priv, clock); } - node->state_changed = 1; + priv->state_changed = 1; if (add_rt) { - clock = clock_add(node, "CLOCK_REALTIME"); + clock = clock_add(priv, "CLOCK_REALTIME"); if (!clock) return -1; if (add_rt == 1) @@ -1220,7 +1229,7 @@ static int auto_init_ports(struct node *node, int add_rt) } /* get initial offset */ - if (run_pmc_get_utc_offset(node, 1000) <= 0) { + if (run_pmc_get_utc_offset(priv, 1000) <= 0) { pr_err("failed to get UTC offset"); return -1; } @@ -1228,7 +1237,7 @@ static int auto_init_ports(struct node *node, int add_rt) } /* Returns: -1 in case of error, 0 otherwise */ -static int update_pmc(struct node *node, int subscribe) +static int update_pmc(struct phc2sys_private *priv, int subscribe) { struct timespec tp; uint64_t ts; @@ -1239,33 +1248,33 @@ static int update_pmc(struct node *node, int subscribe) } ts = tp.tv_sec * NS_PER_SEC + tp.tv_nsec; - if (node->pmc && - !(ts > node->pmc_last_update && - ts - node->pmc_last_update < PMC_UPDATE_INTERVAL)) { + if (priv->pmc && + !(ts > priv->pmc_last_update && + ts - priv->pmc_last_update < PMC_UPDATE_INTERVAL)) { if (subscribe) - run_pmc_subscribe(node, 0); - if (run_pmc_get_utc_offset(node, 0) > 0) - node->pmc_last_update = ts; + run_pmc_subscribe(priv, 0); + if (run_pmc_get_utc_offset(priv, 0) > 0) + priv->pmc_last_update = ts; } return 0; } /* Returns: non-zero to skip clock update */ -static int clock_handle_leap(struct node *node, struct clock *clock, +static int clock_handle_leap(struct phc2sys_private *priv, struct clock *clock, int64_t offset, uint64_t ts) { - int clock_leap, node_leap = node->leap; + int clock_leap, node_leap = priv->leap; - clock->sync_offset = node->sync_offset; + clock->sync_offset = priv->sync_offset; if ((node_leap || clock->leap_set) && - clock->is_utc != node->master->is_utc) { + clock->is_utc != priv->master->is_utc) { /* If the master clock is in UTC, get a time stamp from it, as it is the clock which will include the leap second. */ - if (node->master->is_utc) { + if (priv->master->is_utc) { struct timespec tp; - if (clock_gettime(node->master->clkid, &tp)) { + if (clock_gettime(priv->master->clkid, &tp)) { pr_err("failed to read clock: %m"); return -1; } @@ -1275,7 +1284,7 @@ static int clock_handle_leap(struct node *node, struct clock *clock, /* If the clock will be stepped, the time stamp has to be the new time. Ignore possible 1 second error in UTC offset. */ if (clock->is_utc && clock->servo_state == SERVO_UNLOCKED) - ts -= offset + get_sync_offset(node, clock); + ts -= offset + get_sync_offset(priv, clock); /* Suspend clock updates in the last second before midnight. */ if (is_utc_ambiguous(ts)) { @@ -1290,7 +1299,7 @@ static int clock_handle_leap(struct node *node, struct clock *clock, if (clock->leap_set != clock_leap) { /* Only the system clock can leap. */ if (clock->clkid == CLOCK_REALTIME && - node->kernel_leap) + priv->kernel_leap) sysclk_set_leap(clock_leap); else servo_leap(clock->servo, clock_leap); @@ -1298,7 +1307,7 @@ static int clock_handle_leap(struct node *node, struct clock *clock, } } - if (node->utc_offset_traceable && + if (priv->utc_offset_traceable && clock->utc_offset_set != clock->sync_offset) { if (clock->clkid == CLOCK_REALTIME) sysclk_set_tai_offset(clock->sync_offset); @@ -1358,7 +1367,7 @@ int main(int argc, char *argv[]) int autocfg = 0, c, domain_number = 0, index, ntpshm_segment; int pps_fd = -1, print_level = LOG_INFO, r = -1, rt = 0, wait_sync = 0; double phc_rate, tmp; - struct node node = { + struct phc2sys_private priv = { .phc_readings = 5, .phc_interval = 1.0, }; @@ -1453,21 +1462,21 @@ int main(int argc, char *argv[]) case 'R': if (get_arg_val_d(c, optarg, &phc_rate, 1e-9, DBL_MAX)) goto end; - node.phc_interval = 1.0 / phc_rate; + priv.phc_interval = 1.0 / phc_rate; break; case 'N': - if (get_arg_val_i(c, optarg, &node.phc_readings, 1, INT_MAX)) + if (get_arg_val_i(c, optarg, &priv.phc_readings, 1, INT_MAX)) goto end; break; case 'O': - if (get_arg_val_i(c, optarg, &node.sync_offset, + if (get_arg_val_i(c, optarg, &priv.sync_offset, INT_MIN, INT_MAX)) goto end; - node.forced_sync_offset = -1; + priv.forced_sync_offset = -1; break; case 'L': - if (get_arg_val_i(c, optarg, &node.sanity_freq_limit, 0, INT_MAX) || - config_set_int(cfg, "sanity_freq_limit", node.sanity_freq_limit)) { + if (get_arg_val_i(c, optarg, &priv.sanity_freq_limit, 0, INT_MAX) || + config_set_int(cfg, "sanity_freq_limit", priv.sanity_freq_limit)) { goto end; } break; @@ -1477,7 +1486,7 @@ int main(int argc, char *argv[]) goto end; break; case 'u': - if (get_arg_val_ui(c, optarg, &node.stats_max_count, + if (get_arg_val_ui(c, optarg, &priv.stats_max_count, 0, UINT_MAX)) goto end; break; @@ -1544,7 +1553,7 @@ int main(int argc, char *argv[]) return c; } - if (autocfg && (src_name || dst_name || pps_fd >= 0 || wait_sync || node.forced_sync_offset)) { + if (autocfg && (src_name || dst_name || pps_fd >= 0 || wait_sync || priv.forced_sync_offset)) { fprintf(stderr, "autoconfiguration cannot be mixed with manual config options.\n"); goto bad_usage; @@ -1555,15 +1564,15 @@ int main(int argc, char *argv[]) goto bad_usage; } - if (!autocfg && !wait_sync && !node.forced_sync_offset) { + if (!autocfg && !wait_sync && !priv.forced_sync_offset) { fprintf(stderr, "time offset must be specified using -w or -O\n"); goto bad_usage; } - if (node.servo_type == CLOCK_SERVO_NTPSHM) { - node.kernel_leap = 0; - node.sanity_freq_limit = 0; + if (priv.servo_type == CLOCK_SERVO_NTPSHM) { + priv.kernel_leap = 0; + priv.sanity_freq_limit = 0; } print_set_progname(progname); @@ -1572,24 +1581,24 @@ int main(int argc, char *argv[]) print_set_syslog(config_get_int(cfg, NULL, "use_syslog")); print_set_level(config_get_int(cfg, NULL, "logging_level")); - node.servo_type = config_get_int(cfg, NULL, "clock_servo"); - if (node.servo_type == CLOCK_SERVO_NTPSHM) { + priv.servo_type = config_get_int(cfg, NULL, "clock_servo"); + if (priv.servo_type == CLOCK_SERVO_NTPSHM) { config_set_int(cfg, "kernel_leap", 0); config_set_int(cfg, "sanity_freq_limit", 0); } - node.kernel_leap = config_get_int(cfg, NULL, "kernel_leap"); - node.sanity_freq_limit = config_get_int(cfg, NULL, "sanity_freq_limit"); + priv.kernel_leap = config_get_int(cfg, NULL, "kernel_leap"); + priv.sanity_freq_limit = config_get_int(cfg, NULL, "sanity_freq_limit"); if (autocfg) { - if (init_pmc(cfg, &node)) + if (init_pmc(cfg, &priv)) goto end; - if (auto_init_ports(&node, rt) < 0) + if (auto_init_ports(&priv, rt) < 0) goto end; - r = do_loop(&node, 1); + r = do_loop(&priv, 1); goto end; } - src = clock_add(&node, src_name); + src = clock_add(&priv, src_name); free(src_name); if (!src) { fprintf(stderr, @@ -1597,9 +1606,9 @@ int main(int argc, char *argv[]) goto bad_usage; } src->state = PS_SLAVE; - node.master = src; + priv.master = src; - dst = clock_add(&node, dst_name ? dst_name : "CLOCK_REALTIME"); + dst = clock_add(&priv, dst_name ? dst_name : "CLOCK_REALTIME"); free(dst_name); if (!dst) { fprintf(stderr, @@ -1607,7 +1616,7 @@ int main(int argc, char *argv[]) goto bad_usage; } dst->state = PS_MASTER; - LIST_INSERT_HEAD(&node.dst_clocks, dst, dst_list); + LIST_INSERT_HEAD(&priv.dst_clocks, dst, dst_list); if (pps_fd >= 0 && dst->clkid != CLOCK_REALTIME) { fprintf(stderr, @@ -1618,11 +1627,11 @@ int main(int argc, char *argv[]) r = -1; if (wait_sync) { - if (init_pmc(cfg, &node)) + if (init_pmc(cfg, &priv)) goto end; while (is_running()) { - r = run_pmc_wait_sync(&node, 1000); + r = run_pmc_wait_sync(&priv, 1000); if (r < 0) goto end; if (r > 0) @@ -1631,34 +1640,34 @@ int main(int argc, char *argv[]) pr_notice("Waiting for ptp4l..."); } - if (!node.forced_sync_offset) { - r = run_pmc_get_utc_offset(&node, 1000); + if (!priv.forced_sync_offset) { + r = run_pmc_get_utc_offset(&priv, 1000); if (r <= 0) { pr_err("failed to get UTC offset"); goto end; } } - if (node.forced_sync_offset || + if (priv.forced_sync_offset || (src->clkid != CLOCK_REALTIME && dst->clkid != CLOCK_REALTIME) || src->clkid == CLOCK_INVALID) - close_pmc(&node); + close_pmc(&priv); } if (pps_fd >= 0) { /* only one destination clock allowed with PPS until we * implement a mean to specify PTP port to PPS mapping */ servo_sync_interval(dst->servo, 1.0); - r = do_pps_loop(&node, dst, pps_fd); + r = do_pps_loop(&priv, dst, pps_fd); } else { - r = do_loop(&node, 0); + r = do_loop(&priv, 0); } end: - if (node.pmc) - close_pmc(&node); - clock_cleanup(&node); - port_cleanup(&node); + if (priv.pmc) + close_pmc(&priv); + clock_cleanup(&priv); + port_cleanup(&priv); config_destroy(cfg); msg_cleanup(); return r;