phc2sys: split clock and node
Split members that apply to all synchronized clocks and members that apply to an individual clock. Keep all clocks in a list, with a pointer to the source clock. This will allow to support multiple clocks synchronization. Signed-off-by: Jiri Benc <jbenc@redhat.com>master
parent
423eb54530
commit
be4251a552
403
phc2sys.c
403
phc2sys.c
|
@ -28,6 +28,7 @@
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <sys/ioctl.h>
|
#include <sys/ioctl.h>
|
||||||
|
#include <sys/queue.h>
|
||||||
#include <sys/stat.h>
|
#include <sys/stat.h>
|
||||||
#include <sys/types.h>
|
#include <sys/types.h>
|
||||||
#include <unistd.h>
|
#include <unistd.h>
|
||||||
|
@ -60,9 +61,6 @@
|
||||||
#define PMC_UPDATE_INTERVAL (60 * NS_PER_SEC)
|
#define PMC_UPDATE_INTERVAL (60 * NS_PER_SEC)
|
||||||
|
|
||||||
struct clock;
|
struct clock;
|
||||||
static int update_sync_offset(struct clock *clock);
|
|
||||||
static int clock_handle_leap(struct clock *clock, clockid_t src,
|
|
||||||
int64_t offset, uint64_t ts, int do_leap);
|
|
||||||
|
|
||||||
static clockid_t clock_open(char *device)
|
static clockid_t clock_open(char *device)
|
||||||
{
|
{
|
||||||
|
@ -129,14 +127,24 @@ static int read_phc(clockid_t clkid, clockid_t sysclk, int readings,
|
||||||
}
|
}
|
||||||
|
|
||||||
struct clock {
|
struct clock {
|
||||||
|
LIST_ENTRY(clock) list;
|
||||||
clockid_t clkid;
|
clockid_t clkid;
|
||||||
|
int sysoff_supported;
|
||||||
struct servo *servo;
|
struct servo *servo;
|
||||||
enum servo_state servo_state;
|
enum servo_state servo_state;
|
||||||
const char *source_label;
|
const char *source_label;
|
||||||
struct stats *offset_stats;
|
struct stats *offset_stats;
|
||||||
struct stats *freq_stats;
|
struct stats *freq_stats;
|
||||||
struct stats *delay_stats;
|
struct stats *delay_stats;
|
||||||
|
struct clockcheck *sanity_check;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct node {
|
||||||
unsigned int stats_max_count;
|
unsigned int stats_max_count;
|
||||||
|
int sanity_freq_limit;
|
||||||
|
enum servo_type servo_type;
|
||||||
|
int phc_readings;
|
||||||
|
double phc_interval;
|
||||||
int sync_offset;
|
int sync_offset;
|
||||||
int sync_offset_direction;
|
int sync_offset_direction;
|
||||||
int leap;
|
int leap;
|
||||||
|
@ -145,10 +153,15 @@ struct clock {
|
||||||
struct pmc *pmc;
|
struct pmc *pmc;
|
||||||
int pmc_ds_requested;
|
int pmc_ds_requested;
|
||||||
uint64_t pmc_last_update;
|
uint64_t pmc_last_update;
|
||||||
struct clockcheck *sanity_check;
|
LIST_HEAD(clock_head, clock) clocks;
|
||||||
|
struct clock *master;
|
||||||
};
|
};
|
||||||
|
|
||||||
static void update_clock_stats(struct clock *clock,
|
static int update_sync_offset(struct node *node);
|
||||||
|
static int clock_handle_leap(struct node *node, struct clock *clock,
|
||||||
|
int64_t offset, uint64_t ts, int do_leap);
|
||||||
|
|
||||||
|
static void update_clock_stats(struct clock *clock, unsigned int max_count,
|
||||||
int64_t offset, double freq, int64_t delay)
|
int64_t offset, double freq, int64_t delay)
|
||||||
{
|
{
|
||||||
struct stats_result offset_stats, freq_stats, delay_stats;
|
struct stats_result offset_stats, freq_stats, delay_stats;
|
||||||
|
@ -158,7 +171,7 @@ static void update_clock_stats(struct clock *clock,
|
||||||
if (delay >= 0)
|
if (delay >= 0)
|
||||||
stats_add_value(clock->delay_stats, delay);
|
stats_add_value(clock->delay_stats, delay);
|
||||||
|
|
||||||
if (stats_get_num_values(clock->offset_stats) < clock->stats_max_count)
|
if (stats_get_num_values(clock->offset_stats) < max_count)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
stats_get_result(clock->offset_stats, &offset_stats);
|
stats_get_result(clock->offset_stats, &offset_stats);
|
||||||
|
@ -183,19 +196,19 @@ static void update_clock_stats(struct clock *clock,
|
||||||
stats_reset(clock->delay_stats);
|
stats_reset(clock->delay_stats);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void update_clock(struct clock *clock, clockid_t src,
|
static void update_clock(struct node *node, struct clock *clock,
|
||||||
int64_t offset, uint64_t ts, int64_t delay,
|
int64_t offset, uint64_t ts, int64_t delay,
|
||||||
int do_leap)
|
int do_leap)
|
||||||
{
|
{
|
||||||
enum servo_state state;
|
enum servo_state state;
|
||||||
double ppb;
|
double ppb;
|
||||||
|
|
||||||
if (clock_handle_leap(clock, src, offset, ts, do_leap))
|
if (clock_handle_leap(node, clock, offset, ts, do_leap))
|
||||||
return;
|
return;
|
||||||
|
|
||||||
if (clock->sync_offset_direction)
|
if (node->sync_offset_direction)
|
||||||
offset += clock->sync_offset * NS_PER_SEC *
|
offset += node->sync_offset * NS_PER_SEC *
|
||||||
clock->sync_offset_direction;
|
node->sync_offset_direction;
|
||||||
|
|
||||||
if (clock->sanity_check && clockcheck_sample(clock->sanity_check, ts))
|
if (clock->sanity_check && clockcheck_sample(clock->sanity_check, ts))
|
||||||
servo_reset(clock->servo);
|
servo_reset(clock->servo);
|
||||||
|
@ -221,15 +234,15 @@ static void update_clock(struct clock *clock, clockid_t src,
|
||||||
}
|
}
|
||||||
|
|
||||||
if (clock->offset_stats) {
|
if (clock->offset_stats) {
|
||||||
update_clock_stats(clock, offset, ppb, delay);
|
update_clock_stats(clock, node->stats_max_count, offset, ppb, delay);
|
||||||
} else {
|
} else {
|
||||||
if (delay >= 0) {
|
if (delay >= 0) {
|
||||||
pr_info("%s offset %9" PRId64 " s%d freq %+7.0f "
|
pr_info("%s offset %9" PRId64 " s%d freq %+7.0f "
|
||||||
"delay %6" PRId64,
|
"delay %6" PRId64,
|
||||||
clock->source_label, offset, state, ppb, delay);
|
node->master->source_label, offset, state, ppb, delay);
|
||||||
} else {
|
} else {
|
||||||
pr_info("%s offset %9" PRId64 " s%d freq %+7.0f",
|
pr_info("%s offset %9" PRId64 " s%d freq %+7.0f",
|
||||||
clock->source_label, offset, state, ppb);
|
node->master->source_label, offset, state, ppb);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -266,20 +279,20 @@ static int read_pps(int fd, int64_t *offset, uint64_t *ts)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int do_pps_loop(struct clock *clock, int fd,
|
static int do_pps_loop(struct node *node, struct clock *clock, int fd)
|
||||||
clockid_t src, int n_readings)
|
|
||||||
{
|
{
|
||||||
int64_t pps_offset, phc_offset, phc_delay;
|
int64_t pps_offset, phc_offset, phc_delay;
|
||||||
uint64_t pps_ts, phc_ts;
|
uint64_t pps_ts, phc_ts;
|
||||||
|
clockid_t src = node->master->clkid;
|
||||||
int do_leap;
|
int do_leap;
|
||||||
|
|
||||||
clock->source_label = "pps";
|
node->master->source_label = "pps";
|
||||||
|
|
||||||
if (src == CLOCK_INVALID) {
|
if (src == CLOCK_INVALID) {
|
||||||
/* The sync offset can't be applied with PPS alone. */
|
/* The sync offset can't be applied with PPS alone. */
|
||||||
clock->sync_offset_direction = 0;
|
node->sync_offset_direction = 0;
|
||||||
} else {
|
} else {
|
||||||
enable_pps_output(src);
|
enable_pps_output(node->master->clkid);
|
||||||
}
|
}
|
||||||
|
|
||||||
while (1) {
|
while (1) {
|
||||||
|
@ -290,7 +303,7 @@ static int do_pps_loop(struct clock *clock, int fd,
|
||||||
/* If a PHC is available, use it to get the whole number
|
/* If a PHC is available, use it to get the whole number
|
||||||
of seconds in the offset and PPS for the rest. */
|
of seconds in the offset and PPS for the rest. */
|
||||||
if (src != CLOCK_INVALID) {
|
if (src != CLOCK_INVALID) {
|
||||||
if (!read_phc(src, clock->clkid, n_readings,
|
if (!read_phc(src, clock->clkid, node->phc_readings,
|
||||||
&phc_offset, &phc_ts, &phc_delay))
|
&phc_offset, &phc_ts, &phc_delay))
|
||||||
return -1;
|
return -1;
|
||||||
|
|
||||||
|
@ -308,60 +321,54 @@ static int do_pps_loop(struct clock *clock, int fd,
|
||||||
pps_offset = pps_ts - phc_ts;
|
pps_offset = pps_ts - phc_ts;
|
||||||
}
|
}
|
||||||
|
|
||||||
do_leap = update_sync_offset(clock);
|
do_leap = update_sync_offset(node);
|
||||||
if (do_leap <= 0)
|
if (do_leap < 0)
|
||||||
continue;
|
continue;
|
||||||
update_clock(clock, src, pps_offset, pps_ts, -1, do_leap);
|
update_clock(node, clock, pps_offset, pps_ts, -1, do_leap);
|
||||||
}
|
}
|
||||||
close(fd);
|
close(fd);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int do_sysoff_loop(struct clock *clock, clockid_t src,
|
static int do_loop(struct node *node)
|
||||||
struct timespec *interval, int n_readings)
|
|
||||||
{
|
{
|
||||||
|
struct timespec interval;
|
||||||
|
struct clock *clock;
|
||||||
uint64_t ts;
|
uint64_t ts;
|
||||||
int64_t offset, delay;
|
int64_t offset, delay;
|
||||||
int err = 0, fd = CLOCKID_TO_FD(src);
|
int src_fd = CLOCKID_TO_FD(node->master->clkid);
|
||||||
int do_leap;
|
int do_leap;
|
||||||
|
|
||||||
clock->source_label = "sys";
|
interval.tv_sec = node->phc_interval;
|
||||||
|
interval.tv_nsec = (node->phc_interval - interval.tv_sec) * 1e9;
|
||||||
|
|
||||||
while (1) {
|
while (1) {
|
||||||
clock_nanosleep(CLOCK_MONOTONIC, 0, interval, NULL);
|
clock_nanosleep(CLOCK_MONOTONIC, 0, &interval, NULL);
|
||||||
if (sysoff_measure(fd, n_readings, &offset, &ts, &delay)) {
|
do_leap = update_sync_offset(node);
|
||||||
err = -1;
|
if (do_leap < 0)
|
||||||
break;
|
continue;
|
||||||
|
|
||||||
|
LIST_FOREACH(clock, &node->clocks, list) {
|
||||||
|
if (clock == node->master)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (clock->clkid == CLOCK_REALTIME &&
|
||||||
|
node->master->sysoff_supported) {
|
||||||
|
/* use sysoff */
|
||||||
|
if (sysoff_measure(src_fd, node->phc_readings,
|
||||||
|
&offset, &ts, &delay))
|
||||||
|
return -1;
|
||||||
|
} else {
|
||||||
|
/* use phc */
|
||||||
|
if (!read_phc(node->master->clkid, clock->clkid,
|
||||||
|
node->phc_readings,
|
||||||
|
&offset, &ts, &delay))
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
update_clock(node, clock, offset, ts, delay, do_leap);
|
||||||
}
|
}
|
||||||
do_leap = update_sync_offset(clock);
|
|
||||||
if (do_leap <= 0)
|
|
||||||
continue;
|
|
||||||
update_clock(clock, src, offset, ts, delay, do_leap);
|
|
||||||
}
|
}
|
||||||
return err;
|
return 0; /* unreachable */
|
||||||
}
|
|
||||||
|
|
||||||
static int do_phc_loop(struct clock *clock, clockid_t src,
|
|
||||||
struct timespec *interval, int n_readings)
|
|
||||||
{
|
|
||||||
uint64_t ts;
|
|
||||||
int64_t offset, delay;
|
|
||||||
int do_leap;
|
|
||||||
|
|
||||||
clock->source_label = "phc";
|
|
||||||
|
|
||||||
while (1) {
|
|
||||||
clock_nanosleep(CLOCK_MONOTONIC, 0, interval, NULL);
|
|
||||||
if (!read_phc(src, clock->clkid, n_readings,
|
|
||||||
&offset, &ts, &delay)) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
do_leap = update_sync_offset(clock);
|
|
||||||
if (do_leap <= 0)
|
|
||||||
continue;
|
|
||||||
update_clock(clock, src, offset, ts, delay, do_leap);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static int is_msg_mgt(struct ptp_message *msg)
|
static int is_msg_mgt(struct ptp_message *msg)
|
||||||
|
@ -392,11 +399,11 @@ static void *get_mgt_data(struct ptp_message *msg)
|
||||||
return mgt->data;
|
return mgt->data;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int init_pmc(struct clock *clock, int domain_number)
|
static int init_pmc(struct node *node, int domain_number)
|
||||||
{
|
{
|
||||||
clock->pmc = pmc_create(TRANS_UDS, "/var/run/phc2sys", 0,
|
node->pmc = pmc_create(TRANS_UDS, "/var/run/phc2sys", 0,
|
||||||
domain_number, 0, 1);
|
domain_number, 0, 1);
|
||||||
if (!clock->pmc) {
|
if (!node->pmc) {
|
||||||
pr_err("failed to create pmc");
|
pr_err("failed to create pmc");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
@ -404,7 +411,7 @@ static int init_pmc(struct clock *clock, int domain_number)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int run_pmc(struct clock *clock, int timeout, int ds_id,
|
static int run_pmc(struct node *node, int timeout, int ds_id,
|
||||||
struct ptp_message **msg)
|
struct ptp_message **msg)
|
||||||
{
|
{
|
||||||
#define N_FD 1
|
#define N_FD 1
|
||||||
|
@ -412,9 +419,9 @@ static int run_pmc(struct clock *clock, int timeout, int ds_id,
|
||||||
int cnt;
|
int cnt;
|
||||||
|
|
||||||
while (1) {
|
while (1) {
|
||||||
pollfd[0].fd = pmc_get_transport_fd(clock->pmc);
|
pollfd[0].fd = pmc_get_transport_fd(node->pmc);
|
||||||
pollfd[0].events = POLLIN|POLLPRI;
|
pollfd[0].events = POLLIN|POLLPRI;
|
||||||
if (!clock->pmc_ds_requested)
|
if (!node->pmc_ds_requested)
|
||||||
pollfd[0].events |= POLLOUT;
|
pollfd[0].events |= POLLOUT;
|
||||||
|
|
||||||
cnt = poll(pollfd, N_FD, timeout);
|
cnt = poll(pollfd, N_FD, timeout);
|
||||||
|
@ -424,21 +431,21 @@ static int run_pmc(struct clock *clock, int timeout, int ds_id,
|
||||||
}
|
}
|
||||||
if (!cnt) {
|
if (!cnt) {
|
||||||
/* Request the data set again in the next run. */
|
/* Request the data set again in the next run. */
|
||||||
clock->pmc_ds_requested = 0;
|
node->pmc_ds_requested = 0;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Send a new request if there are no pending messages. */
|
/* Send a new request if there are no pending messages. */
|
||||||
if ((pollfd[0].revents & POLLOUT) &&
|
if ((pollfd[0].revents & POLLOUT) &&
|
||||||
!(pollfd[0].revents & (POLLIN|POLLPRI))) {
|
!(pollfd[0].revents & (POLLIN|POLLPRI))) {
|
||||||
pmc_send_get_action(clock->pmc, ds_id);
|
pmc_send_get_action(node->pmc, ds_id);
|
||||||
clock->pmc_ds_requested = 1;
|
node->pmc_ds_requested = 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(pollfd[0].revents & (POLLIN|POLLPRI)))
|
if (!(pollfd[0].revents & (POLLIN|POLLPRI)))
|
||||||
continue;
|
continue;
|
||||||
|
|
||||||
*msg = pmc_recv(clock->pmc);
|
*msg = pmc_recv(node->pmc);
|
||||||
|
|
||||||
if (!*msg)
|
if (!*msg)
|
||||||
continue;
|
continue;
|
||||||
|
@ -449,12 +456,12 @@ static int run_pmc(struct clock *clock, int timeout, int ds_id,
|
||||||
*msg = NULL;
|
*msg = NULL;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
clock->pmc_ds_requested = 0;
|
node->pmc_ds_requested = 0;
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static int run_pmc_wait_sync(struct clock *clock, int timeout)
|
static int run_pmc_wait_sync(struct node *node, int timeout)
|
||||||
{
|
{
|
||||||
struct ptp_message *msg;
|
struct ptp_message *msg;
|
||||||
int res;
|
int res;
|
||||||
|
@ -462,7 +469,7 @@ static int run_pmc_wait_sync(struct clock *clock, int timeout)
|
||||||
Enumeration8 portState;
|
Enumeration8 portState;
|
||||||
|
|
||||||
while (1) {
|
while (1) {
|
||||||
res = run_pmc(clock, timeout, PORT_DATA_SET, &msg);
|
res = run_pmc(node, timeout, PORT_DATA_SET, &msg);
|
||||||
if (res <= 0)
|
if (res <= 0)
|
||||||
return res;
|
return res;
|
||||||
|
|
||||||
|
@ -476,42 +483,42 @@ static int run_pmc_wait_sync(struct clock *clock, int timeout)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
/* try to get more data sets (for other ports) */
|
/* try to get more data sets (for other ports) */
|
||||||
clock->pmc_ds_requested = 1;
|
node->pmc_ds_requested = 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static int run_pmc_get_utc_offset(struct clock *clock, int timeout)
|
static int run_pmc_get_utc_offset(struct node *node, int timeout)
|
||||||
{
|
{
|
||||||
struct ptp_message *msg;
|
struct ptp_message *msg;
|
||||||
int res;
|
int res;
|
||||||
struct timePropertiesDS *tds;
|
struct timePropertiesDS *tds;
|
||||||
|
|
||||||
res = run_pmc(clock, timeout, TIME_PROPERTIES_DATA_SET, &msg);
|
res = run_pmc(node, timeout, TIME_PROPERTIES_DATA_SET, &msg);
|
||||||
if (res <= 0)
|
if (res <= 0)
|
||||||
return res;
|
return res;
|
||||||
|
|
||||||
tds = (struct timePropertiesDS *)get_mgt_data(msg);
|
tds = (struct timePropertiesDS *)get_mgt_data(msg);
|
||||||
if (tds->flags & PTP_TIMESCALE) {
|
if (tds->flags & PTP_TIMESCALE) {
|
||||||
clock->sync_offset = tds->currentUtcOffset;
|
node->sync_offset = tds->currentUtcOffset;
|
||||||
if (tds->flags & LEAP_61)
|
if (tds->flags & LEAP_61)
|
||||||
clock->leap = 1;
|
node->leap = 1;
|
||||||
else if (tds->flags & LEAP_59)
|
else if (tds->flags & LEAP_59)
|
||||||
clock->leap = -1;
|
node->leap = -1;
|
||||||
else
|
else
|
||||||
clock->leap = 0;
|
node->leap = 0;
|
||||||
}
|
}
|
||||||
msg_put(msg);
|
msg_put(msg);
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void close_pmc(struct clock *clock)
|
static void close_pmc(struct node *node)
|
||||||
{
|
{
|
||||||
pmc_destroy(clock->pmc);
|
pmc_destroy(node->pmc);
|
||||||
clock->pmc = NULL;
|
node->pmc = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Returns: -1 in case of error, 0 for normal sync, 1 to leap clock */
|
/* Returns: -1 in case of error, 0 for normal sync, 1 to leap clock */
|
||||||
static int update_sync_offset(struct clock *clock)
|
static int update_sync_offset(struct node *node)
|
||||||
{
|
{
|
||||||
struct timespec tp;
|
struct timespec tp;
|
||||||
uint64_t ts;
|
uint64_t ts;
|
||||||
|
@ -523,40 +530,41 @@ static int update_sync_offset(struct clock *clock)
|
||||||
}
|
}
|
||||||
ts = tp.tv_sec * NS_PER_SEC + tp.tv_nsec;
|
ts = tp.tv_sec * NS_PER_SEC + tp.tv_nsec;
|
||||||
|
|
||||||
if (clock->pmc &&
|
if (node->pmc &&
|
||||||
!(ts > clock->pmc_last_update &&
|
!(ts > node->pmc_last_update &&
|
||||||
ts - clock->pmc_last_update < PMC_UPDATE_INTERVAL)) {
|
ts - node->pmc_last_update < PMC_UPDATE_INTERVAL)) {
|
||||||
if (run_pmc_get_utc_offset(clock, 0) > 0)
|
if (run_pmc_get_utc_offset(node, 0) > 0)
|
||||||
clock->pmc_last_update = ts;
|
node->pmc_last_update = ts;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Handle leap seconds. */
|
/* Handle leap seconds. */
|
||||||
|
|
||||||
if (!clock->leap && !clock->leap_set)
|
if (!node->leap && !node->leap_set)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
clock_leap = leap_second_status(ts, clock->leap_set,
|
clock_leap = leap_second_status(ts, node->leap_set,
|
||||||
&clock->leap, &clock->sync_offset);
|
&node->leap, &node->sync_offset);
|
||||||
if (clock->leap_set != clock_leap) {
|
if (node->leap_set != clock_leap) {
|
||||||
clock->leap_set = clock_leap;
|
node->leap_set = clock_leap;
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Returns: non-zero to skip clock update */
|
/* Returns: non-zero to skip clock update */
|
||||||
static int clock_handle_leap(struct clock *clock, clockid_t src,
|
static int clock_handle_leap(struct node *node, struct clock *clock,
|
||||||
int64_t offset, uint64_t ts, int do_leap)
|
int64_t offset, uint64_t ts, int do_leap)
|
||||||
{
|
{
|
||||||
if (!clock->leap && !do_leap)
|
if (!node->leap && !do_leap)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
if (clock->clkid != CLOCK_REALTIME && src != CLOCK_REALTIME)
|
if (clock->clkid != CLOCK_REALTIME &&
|
||||||
|
node->master->clkid != CLOCK_REALTIME)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
/* If the system clock is the master clock, get a time stamp from
|
/* If the system clock is the master clock, get a time stamp from
|
||||||
it, as it is the clock which will include the leap second. */
|
it, as it is the clock which will include the leap second. */
|
||||||
if (src == CLOCK_REALTIME) {
|
if (node->master->clkid == CLOCK_REALTIME) {
|
||||||
struct timespec tp;
|
struct timespec tp;
|
||||||
if (clock_gettime(CLOCK_REALTIME, &tp)) {
|
if (clock_gettime(CLOCK_REALTIME, &tp)) {
|
||||||
pr_err("failed to read clock: %m");
|
pr_err("failed to read clock: %m");
|
||||||
|
@ -569,8 +577,8 @@ static int clock_handle_leap(struct clock *clock, clockid_t src,
|
||||||
target time. Ignore possible 1 second error in UTC offset. */
|
target time. Ignore possible 1 second error in UTC offset. */
|
||||||
if (clock->clkid == CLOCK_REALTIME &&
|
if (clock->clkid == CLOCK_REALTIME &&
|
||||||
clock->servo_state == SERVO_UNLOCKED) {
|
clock->servo_state == SERVO_UNLOCKED) {
|
||||||
ts -= offset + clock->sync_offset * NS_PER_SEC *
|
ts -= offset + node->sync_offset * NS_PER_SEC *
|
||||||
clock->sync_offset_direction;
|
node->sync_offset_direction;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Suspend clock updates in the last second before midnight. */
|
/* Suspend clock updates in the last second before midnight. */
|
||||||
|
@ -581,13 +589,79 @@ static int clock_handle_leap(struct clock *clock, clockid_t src,
|
||||||
|
|
||||||
if (do_leap) {
|
if (do_leap) {
|
||||||
/* Only the system clock can leap. */
|
/* Only the system clock can leap. */
|
||||||
if (clock->clkid == CLOCK_REALTIME && clock->kernel_leap)
|
if (clock->clkid == CLOCK_REALTIME && node->kernel_leap)
|
||||||
sysclk_set_leap(clock->leap_set);
|
sysclk_set_leap(node->leap_set);
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int clock_add(struct node *node, clockid_t clkid)
|
||||||
|
{
|
||||||
|
struct clock *c;
|
||||||
|
int max_ppb;
|
||||||
|
double ppb;
|
||||||
|
|
||||||
|
c = calloc(1, sizeof(*c));
|
||||||
|
if (!c) {
|
||||||
|
pr_err("failed to allocate memory for a clock");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
c->clkid = clkid;
|
||||||
|
c->servo_state = SERVO_UNLOCKED;
|
||||||
|
|
||||||
|
if (c->clkid == CLOCK_REALTIME)
|
||||||
|
c->source_label = "sys";
|
||||||
|
else
|
||||||
|
c->source_label = "phc";
|
||||||
|
|
||||||
|
if (node->stats_max_count > 0) {
|
||||||
|
c->offset_stats = stats_create();
|
||||||
|
c->freq_stats = stats_create();
|
||||||
|
c->delay_stats = stats_create();
|
||||||
|
if (!c->offset_stats ||
|
||||||
|
!c->freq_stats ||
|
||||||
|
!c->delay_stats) {
|
||||||
|
pr_err("failed to create stats");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (node->sanity_freq_limit) {
|
||||||
|
c->sanity_check = clockcheck_create(node->sanity_freq_limit);
|
||||||
|
if (!c->sanity_check) {
|
||||||
|
pr_err("failed to create clock check");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
clockadj_init(c->clkid);
|
||||||
|
ppb = clockadj_get_freq(c->clkid);
|
||||||
|
/* The reading may silently fail and return 0, reset the frequency to
|
||||||
|
make sure ppb is the actual frequency of the clock. */
|
||||||
|
clockadj_set_freq(c->clkid, ppb);
|
||||||
|
if (c->clkid == CLOCK_REALTIME) {
|
||||||
|
sysclk_set_leap(0);
|
||||||
|
max_ppb = sysclk_max_freq();
|
||||||
|
} else {
|
||||||
|
max_ppb = phc_max_adj(c->clkid);
|
||||||
|
if (!max_ppb) {
|
||||||
|
pr_err("clock is not adjustable");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
c->servo = servo_create(node->servo_type, -ppb, max_ppb, 0);
|
||||||
|
servo_sync_interval(c->servo, node->phc_interval);
|
||||||
|
|
||||||
|
if (clkid != CLOCK_REALTIME)
|
||||||
|
c->sysoff_supported = (SYSOFF_SUPPORTED ==
|
||||||
|
sysoff_probe(CLOCKID_TO_FD(clkid),
|
||||||
|
node->phc_readings));
|
||||||
|
|
||||||
|
LIST_INSERT_HEAD(&node->clocks, c, list);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
static void usage(char *progname)
|
static void usage(char *progname)
|
||||||
{
|
{
|
||||||
fprintf(stderr,
|
fprintf(stderr,
|
||||||
|
@ -622,16 +696,16 @@ int main(int argc, char *argv[])
|
||||||
{
|
{
|
||||||
char *progname;
|
char *progname;
|
||||||
clockid_t src = CLOCK_INVALID;
|
clockid_t src = CLOCK_INVALID;
|
||||||
int c, domain_number = 0, phc_readings = 5, pps_fd = -1;
|
clockid_t dst = CLOCK_REALTIME;
|
||||||
int max_ppb, r, wait_sync = 0, forced_sync_offset = 0;
|
int c, domain_number = 0, pps_fd = -1;
|
||||||
|
int r, wait_sync = 0, forced_sync_offset = 0;
|
||||||
int print_level = LOG_INFO, use_syslog = 1, verbose = 0;
|
int print_level = LOG_INFO, use_syslog = 1, verbose = 0;
|
||||||
int sanity_freq_limit = 200000000;
|
double phc_rate;
|
||||||
enum servo_type servo = CLOCK_SERVO_PI;
|
struct node node = {
|
||||||
double ppb, phc_interval = 1.0, phc_rate;
|
.sanity_freq_limit = 200000000,
|
||||||
struct timespec phc_interval_tp;
|
.servo_type = CLOCK_SERVO_PI,
|
||||||
struct clock dst_clock = {
|
.phc_readings = 5,
|
||||||
.clkid = CLOCK_REALTIME,
|
.phc_interval = 1.0,
|
||||||
.servo_state = SERVO_UNLOCKED,
|
|
||||||
.kernel_leap = 1,
|
.kernel_leap = 1,
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -645,7 +719,7 @@ int main(int argc, char *argv[])
|
||||||
"c:d:s:E:P:I:S:F:R:N:O:L:i:u:wn:xl:mqvh"))) {
|
"c:d:s:E:P:I:S:F:R:N:O:L:i:u:wn:xl:mqvh"))) {
|
||||||
switch (c) {
|
switch (c) {
|
||||||
case 'c':
|
case 'c':
|
||||||
dst_clock.clkid = clock_open(optarg);
|
dst = clock_open(optarg);
|
||||||
break;
|
break;
|
||||||
case 'd':
|
case 'd':
|
||||||
pps_fd = open(optarg, O_RDONLY);
|
pps_fd = open(optarg, O_RDONLY);
|
||||||
|
@ -663,9 +737,9 @@ int main(int argc, char *argv[])
|
||||||
break;
|
break;
|
||||||
case 'E':
|
case 'E':
|
||||||
if (!strcasecmp(optarg, "pi")) {
|
if (!strcasecmp(optarg, "pi")) {
|
||||||
servo = CLOCK_SERVO_PI;
|
node.servo_type = CLOCK_SERVO_PI;
|
||||||
} else if (!strcasecmp(optarg, "linreg")) {
|
} else if (!strcasecmp(optarg, "linreg")) {
|
||||||
servo = CLOCK_SERVO_LINREG;
|
node.servo_type = CLOCK_SERVO_LINREG;
|
||||||
} else {
|
} else {
|
||||||
fprintf(stderr,
|
fprintf(stderr,
|
||||||
"invalid servo name %s\n", optarg);
|
"invalid servo name %s\n", optarg);
|
||||||
|
@ -695,25 +769,25 @@ int main(int argc, char *argv[])
|
||||||
case 'R':
|
case 'R':
|
||||||
if (get_arg_val_d(c, optarg, &phc_rate, 1e-9, DBL_MAX))
|
if (get_arg_val_d(c, optarg, &phc_rate, 1e-9, DBL_MAX))
|
||||||
return -1;
|
return -1;
|
||||||
phc_interval = 1.0 / phc_rate;
|
node.phc_interval = 1.0 / phc_rate;
|
||||||
break;
|
break;
|
||||||
case 'N':
|
case 'N':
|
||||||
if (get_arg_val_i(c, optarg, &phc_readings, 1, INT_MAX))
|
if (get_arg_val_i(c, optarg, &node.phc_readings, 1, INT_MAX))
|
||||||
return -1;
|
return -1;
|
||||||
break;
|
break;
|
||||||
case 'O':
|
case 'O':
|
||||||
if (get_arg_val_i(c, optarg, &dst_clock.sync_offset,
|
if (get_arg_val_i(c, optarg, &node.sync_offset,
|
||||||
INT_MIN, INT_MAX))
|
INT_MIN, INT_MAX))
|
||||||
return -1;
|
return -1;
|
||||||
dst_clock.sync_offset_direction = -1;
|
node.sync_offset_direction = -1;
|
||||||
forced_sync_offset = 1;
|
forced_sync_offset = 1;
|
||||||
break;
|
break;
|
||||||
case 'L':
|
case 'L':
|
||||||
if (get_arg_val_i(c, optarg, &sanity_freq_limit, 0, INT_MAX))
|
if (get_arg_val_i(c, optarg, &node.sanity_freq_limit, 0, INT_MAX))
|
||||||
return -1;
|
return -1;
|
||||||
break;
|
break;
|
||||||
case 'u':
|
case 'u':
|
||||||
if (get_arg_val_ui(c, optarg, &dst_clock.stats_max_count,
|
if (get_arg_val_ui(c, optarg, &node.stats_max_count,
|
||||||
0, UINT_MAX))
|
0, UINT_MAX))
|
||||||
return -1;
|
return -1;
|
||||||
break;
|
break;
|
||||||
|
@ -725,7 +799,7 @@ int main(int argc, char *argv[])
|
||||||
return -1;
|
return -1;
|
||||||
break;
|
break;
|
||||||
case 'x':
|
case 'x':
|
||||||
dst_clock.kernel_leap = 0;
|
node.kernel_leap = 0;
|
||||||
break;
|
break;
|
||||||
case 'l':
|
case 'l':
|
||||||
if (get_arg_val_i(c, optarg, &print_level,
|
if (get_arg_val_i(c, optarg, &print_level,
|
||||||
|
@ -755,13 +829,13 @@ int main(int argc, char *argv[])
|
||||||
goto bad_usage;
|
goto bad_usage;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (dst_clock.clkid == CLOCK_INVALID) {
|
if (dst == CLOCK_INVALID) {
|
||||||
fprintf(stderr,
|
fprintf(stderr,
|
||||||
"valid destination clock must be selected.\n");
|
"valid destination clock must be selected.\n");
|
||||||
goto bad_usage;
|
goto bad_usage;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (pps_fd >= 0 && dst_clock.clkid != CLOCK_REALTIME) {
|
if (pps_fd >= 0 && dst != CLOCK_REALTIME) {
|
||||||
fprintf(stderr,
|
fprintf(stderr,
|
||||||
"cannot use a pps device unless destination is CLOCK_REALTIME\n");
|
"cannot use a pps device unless destination is CLOCK_REALTIME\n");
|
||||||
goto bad_usage;
|
goto bad_usage;
|
||||||
|
@ -773,36 +847,21 @@ int main(int argc, char *argv[])
|
||||||
goto bad_usage;
|
goto bad_usage;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (dst_clock.stats_max_count > 0) {
|
|
||||||
dst_clock.offset_stats = stats_create();
|
|
||||||
dst_clock.freq_stats = stats_create();
|
|
||||||
dst_clock.delay_stats = stats_create();
|
|
||||||
if (!dst_clock.offset_stats ||
|
|
||||||
!dst_clock.freq_stats ||
|
|
||||||
!dst_clock.delay_stats) {
|
|
||||||
fprintf(stderr, "failed to create stats");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (sanity_freq_limit) {
|
|
||||||
dst_clock.sanity_check = clockcheck_create(sanity_freq_limit);
|
|
||||||
if (!dst_clock.sanity_check) {
|
|
||||||
fprintf(stderr, "failed to create clock check");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
print_set_progname(progname);
|
print_set_progname(progname);
|
||||||
print_set_verbose(verbose);
|
print_set_verbose(verbose);
|
||||||
print_set_syslog(use_syslog);
|
print_set_syslog(use_syslog);
|
||||||
print_set_level(print_level);
|
print_set_level(print_level);
|
||||||
|
|
||||||
|
clock_add(&node, src);
|
||||||
|
node.master = LIST_FIRST(&node.clocks);
|
||||||
|
clock_add(&node, dst);
|
||||||
|
|
||||||
if (wait_sync) {
|
if (wait_sync) {
|
||||||
if (init_pmc(&dst_clock, domain_number))
|
if (init_pmc(&node, domain_number))
|
||||||
return -1;
|
return -1;
|
||||||
|
|
||||||
while (1) {
|
while (1) {
|
||||||
r = run_pmc_wait_sync(&dst_clock, 1000);
|
r = run_pmc_wait_sync(&node, 1000);
|
||||||
if (r < 0)
|
if (r < 0)
|
||||||
return -1;
|
return -1;
|
||||||
if (r > 0)
|
if (r > 0)
|
||||||
|
@ -812,60 +871,40 @@ int main(int argc, char *argv[])
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!forced_sync_offset) {
|
if (!forced_sync_offset) {
|
||||||
r = run_pmc_get_utc_offset(&dst_clock, 1000);
|
r = run_pmc_get_utc_offset(&node, 1000);
|
||||||
if (r <= 0) {
|
if (r <= 0) {
|
||||||
pr_err("failed to get UTC offset");
|
pr_err("failed to get UTC offset");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (src != CLOCK_REALTIME &&
|
if (src != CLOCK_REALTIME &&
|
||||||
dst_clock.clkid == CLOCK_REALTIME)
|
dst == CLOCK_REALTIME)
|
||||||
dst_clock.sync_offset_direction = 1;
|
node.sync_offset_direction = 1;
|
||||||
else if (src == CLOCK_REALTIME &&
|
else if (src == CLOCK_REALTIME &&
|
||||||
dst_clock.clkid != CLOCK_REALTIME)
|
dst != CLOCK_REALTIME)
|
||||||
dst_clock.sync_offset_direction = -1;
|
node.sync_offset_direction = -1;
|
||||||
else
|
else
|
||||||
dst_clock.sync_offset_direction = 0;
|
node.sync_offset_direction = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (forced_sync_offset || !dst_clock.sync_offset_direction)
|
if (forced_sync_offset || !node.sync_offset_direction)
|
||||||
close_pmc(&dst_clock);
|
close_pmc(&node);
|
||||||
}
|
}
|
||||||
|
|
||||||
clockadj_init(dst_clock.clkid);
|
|
||||||
ppb = clockadj_get_freq(dst_clock.clkid);
|
|
||||||
/* The reading may silently fail and return 0, reset the frequency to
|
|
||||||
make sure ppb is the actual frequency of the clock. */
|
|
||||||
clockadj_set_freq(dst_clock.clkid, ppb);
|
|
||||||
if (dst_clock.clkid == CLOCK_REALTIME) {
|
|
||||||
sysclk_set_leap(0);
|
|
||||||
max_ppb = sysclk_max_freq();
|
|
||||||
} else {
|
|
||||||
max_ppb = phc_max_adj(dst_clock.clkid);
|
|
||||||
if (!max_ppb) {
|
|
||||||
pr_err("clock is not adjustable");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
dst_clock.servo = servo_create(servo, -ppb, max_ppb, 0);
|
|
||||||
|
|
||||||
if (pps_fd >= 0) {
|
if (pps_fd >= 0) {
|
||||||
servo_sync_interval(dst_clock.servo, 1.0);
|
/* only one destination clock allowed with PPS until we
|
||||||
return do_pps_loop(&dst_clock, pps_fd, src, phc_readings);
|
* implement a mean to specify PTP port to PPS mapping */
|
||||||
|
struct clock *dst_clock;
|
||||||
|
|
||||||
|
LIST_FOREACH(dst_clock, &node.clocks, list) {
|
||||||
|
if (dst_clock != node.master)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
servo_sync_interval(dst_clock->servo, 1.0);
|
||||||
|
return do_pps_loop(&node, dst_clock, pps_fd);
|
||||||
}
|
}
|
||||||
|
|
||||||
servo_sync_interval(dst_clock.servo, phc_interval);
|
return do_loop(&node);
|
||||||
|
|
||||||
phc_interval_tp.tv_sec = phc_interval;
|
|
||||||
phc_interval_tp.tv_nsec = (phc_interval - phc_interval_tp.tv_sec) * 1e9;
|
|
||||||
|
|
||||||
if (dst_clock.clkid == CLOCK_REALTIME && src != CLOCK_REALTIME &&
|
|
||||||
SYSOFF_SUPPORTED == sysoff_probe(CLOCKID_TO_FD(src), phc_readings))
|
|
||||||
return do_sysoff_loop(&dst_clock, src, &phc_interval_tp,
|
|
||||||
phc_readings);
|
|
||||||
|
|
||||||
return do_phc_loop(&dst_clock, src, &phc_interval_tp, phc_readings);
|
|
||||||
|
|
||||||
bad_usage:
|
bad_usage:
|
||||||
usage(progname);
|
usage(progname);
|
||||||
|
|
Loading…
Reference in New Issue