int validate_freq(void)
{
struct timex tx;
int ret, pass = 0;
int i;
clear_time_state();
memset(&tx, 0, sizeof(struct timex));
/* Set the leap second insert flag */
printf("Testing ADJ_FREQ... ");
fflush(stdout);
for (i = 0; i < NUM_FREQ_VALID; i++) {
tx.modes = ADJ_FREQUENCY;
tx.freq = valid_freq[i];
ret = adjtimex(&tx);
if (ret < 0) {
printf("[FAIL]\n");
printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
valid_freq[i], valid_freq[i]>>16);
pass = -1;
goto out;
}
tx.modes = 0;
ret = adjtimex(&tx);
if (tx.freq != valid_freq[i]) {
printf("Warning: freq value %ld not what we set it (%ld)!\n",
tx.freq, valid_freq[i]);
}
}
int main(int argv, char **argc)
{
struct timespec mon, raw, start, end;
long long delta1, delta2, interval, eppm, ppm;
struct timex tx1, tx2;
setbuf(stdout, NULL);
if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
return -1;
}
tx1.modes = 0;
adjtimex(&tx1);
get_monotonic_and_raw(&mon, &raw);
start = mon;
delta1 = diff_timespec(mon, raw);
if (tx1.offset)
printf("WARNING: ADJ_OFFSET in progress, this will cause inaccurate results\n");
printf("Estimating clock drift: ");
sleep(120);
get_monotonic_and_raw(&mon, &raw);
end = mon;
tx2.modes = 0;
adjtimex(&tx2);
delta2 = diff_timespec(mon, raw);
interval = diff_timespec(start, end);
/* calculate measured ppm between MONOTONIC and MONOTONIC_RAW */
eppm = ((delta2-delta1)*NSEC_PER_SEC)/interval;
eppm = -eppm;
printf("%lld.%i(est)", eppm/1000, abs((int)(eppm%1000)));
/* Avg the two actual freq samples adjtimex gave us */
ppm = (tx1.freq + tx2.freq) * 1000 / 2;
ppm = (long long)tx1.freq * 1000;
ppm = shift_right(ppm, 16);
printf(" %lld.%i(act)", ppm/1000, abs((int)(ppm%1000)));
if (llabs(eppm - ppm) > 1000) {
printf(" [FAILED]\n");
return ksft_exit_fail();
}
printf(" [OK]\n");
return ksft_exit_pass();
}
static void adjtimex_status(struct timex *tx, int status)
{
const char *const msgs[6] = {
"clock synchronized",
"insert leap second",
"delete leap second",
"leap second in progress",
"leap second has occurred",
"clock not synchronized",
};
int r;
struct timespec now;
tx->modes = ADJ_STATUS;
tx->status = status;
r = adjtimex(tx);
now.tv_sec = tx->time.tv_sec;
now.tv_nsec = tx->time.tv_usec * 1000;
if ((tx->status & status) != status)
tst_brkm(TBROK, cleanup, "adjtimex status %d not set", status);
else if (r < 0)
tst_brkm(TBROK | TERRNO, cleanup, "adjtimex");
else if (r < 6)
tst_resm(TINFO, "%s adjtimex: %s", strtime(&now), msgs[r]);
else
tst_resm(TINFO, "%s adjtimex: clock state %d",
strtime(&now), r);
}
/* setup() - performs all ONE TIME setup for this test */
void setup(void)
{
tim_save.modes = 0;
/* Check whether we are root */
if (geteuid() != 0) {
tst_brkm(TBROK, NULL, "Test must be run as root");
}
tst_sig(NOFORK, DEF_HANDLER, cleanup);
/* set the expected errnos... */
TEST_EXP_ENOS(exp_enos);
/* set the HZ from sysconf */
hz = sysconf(_SC_CLK_TCK);
if (hz == -1) {
tst_brkm(TBROK, NULL, "Failed to read the HZ from sysconf\n");
}
TEST_PAUSE;
/* Save current parameters in tim_save */
if ((adjtimex(&tim_save)) == -1) {
tst_brkm(TBROK, NULL, "Failed to save current parameters");
}
}
int
main(
int argc,
char *argv[]
)
{
if (argc > 2)
{
fprintf(stderr, "Usage: %s [tick_value]\n", argv[0]);
exit(-1);
}
else if (argc == 2)
{
#ifdef ADJ_TIMETICK
if ( (txc.time_tick = atoi(argv[1])) < 1 )
#else
if ( (txc.tick = atoi(argv[1])) < 1 )
#endif
{
fprintf(stderr, "Silly value for tick: %s\n", argv[1]);
exit(-1);
}
#ifdef ADJ_TIMETICK
txc.modes = ADJ_TIMETICK;
#else
#ifdef MOD_OFFSET
txc.modes = ADJ_TICK;
#else
txc.mode = ADJ_TICK;
#endif
#endif
}
else
{
#ifdef ADJ_TIMETICK
txc.modes = 0;
#else
#ifdef MOD_OFFSET
txc.modes = 0;
#else
txc.mode = 0;
#endif
#endif
}
if (adjtimex(&txc) < 0)
{
perror("adjtimex");
}
else
{
#ifdef ADJ_TIMETICK
printf("tick = %ld\ntick_adj = %ld\n", txc.time_tick, txc.tickadj);
#else
printf("tick = %ld\n", txc.tick);
#endif
}
exit(0);
}
static int clock_adjust(struct p *p)
{
int i;
int ret = NTP_OK;
double old;
double offset;
struct timex tx;
dprint("clock_adjust: p->offset:%f\n", p->offset);
if (p->offset < CLOCK_MAX) {
memset(&tx, 0, sizeof(tx));
tx.modes = ADJ_OFFSET_SINGLESHOT;
ret = get_old_offset(&old);
if (ret) return ret;
offset = p->offset + old;
tx.offset = (long)(offset * USEC_IN_SEC);
if (adjtimex(&tx) < 0) return NTP_ERR_SYS;
for (i = 0; i < NSTAGE; i++)
if (p->f[i].t > p->t && p->f[i].disp < MAXDISPERSE)
p->f[i].offset -= p->offset;
ret = freq_adjust(p);
dprint("clock_adjust: freq_adjust_ret:%i\n", ret);
}
else {
ret = movetime(p->offset);
offset = p->offset;
peer_clear(p);
if (ret) return ret;
}
p->effective_offset = offset;
return ret;
}
int main(int ac, char **av)
{
int lc;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
Tst_count = 0;
/* Call adjtimex(2) */
tim_save.modes = SET_MODE;
TEST(adjtimex(&tim_save));
if ((TEST_RETURN >= 0) && (TEST_RETURN <= 5)) {
tst_resm(TPASS, "adjtimex() returned %ld", TEST_RETURN);
} else {
tst_resm(TFAIL | TTERRNO, "Test Failed, adjtimex()"
"returned %ld", TEST_RETURN);
}
}
cleanup();
tst_exit();
}
Boolean adjFreq(Integer32 adj)
{
#ifndef __WINDOWS__
#ifndef CONFIG_MPC831X
struct timex t;
#endif
#endif
if(adj > ADJ_FREQ_MAX)
adj = ADJ_FREQ_MAX;
else if(adj < -ADJ_FREQ_MAX)
adj = -ADJ_FREQ_MAX;
#ifdef CONFIG_MPC831X
if (++temp_debug_max_adjustments < 10000)
mpc831x_adj_addend(adj);
return (TRUE);
#elif defined(__WINDOWS__)
return(!( SetSystemTimeAdjustment((adj/100),FALSE)));
#else
t.modes = MOD_FREQUENCY;
t.freq = adj*((1<<16)/1000);
return !adjtimex(&t);
#endif
}
int main(int ac, char **av)
{
int lc;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/* Call adjtimex(2) */
tim_save.modes = SET_MODE;
TEST(adjtimex(&tim_save));
if ((TEST_RETURN >= 0) && (TEST_RETURN <= 5)) {
tst_resm(TPASS, "adjtimex() with mode %u returned %ld",
SET_MODE, TEST_RETURN);
} else {
tst_resm(TFAIL | TTERRNO,
"Test Failed, adjtimex() with mode %u "
"returned %ld", SET_MODE, TEST_RETURN);
}
/* Call adjtimex(2) */
tim_save.modes = ADJ_OFFSET_SINGLESHOT;
TEST(adjtimex(&tim_save));
if ((TEST_RETURN >= 0) && (TEST_RETURN <= 5)) {
tst_resm(TPASS, "adjtimex() with mode %u returned %ld",
ADJ_OFFSET_SINGLESHOT, TEST_RETURN);
} else {
tst_resm(TFAIL | TTERRNO,
"Test Failed, adjtimex() with mode %u returned "
"%ld", ADJ_OFFSET_SINGLESHOT, TEST_RETURN);
}
}
cleanup();
tst_exit();
}
int get_tai(void)
{
struct timex tx;
memset(&tx, 0, sizeof(tx));
adjtimex(&tx);
return tx.tai;
}
static int get_old_offset(double *offset)
{
struct timex tx;
memset(&tx, 0, sizeof(tx));
tx.modes = ADJ_OFFSET_SS_READ;
if (adjtimex(&tx) < 0) return NTP_ERR_SYS;
*offset = (double)tx.offset / USEC_IN_SEC;
return NTP_OK;
}
/* clear NTP time_status & time_state */
void clear_time_state(void)
{
struct timex tx;
int ret;
/*
* We have to call adjtime twice here, as kernels
* prior to 6b1859dba01c7 (included in 3.5 and
* -stable), had an issue with the state machine
* and wouldn't clear the STA_INS/DEL flag directly.
*/
tx.modes = ADJ_STATUS;
tx.status = STA_PLL;
ret = adjtimex(&tx);
tx.modes = ADJ_STATUS;
tx.status = 0;
ret = adjtimex(&tx);
}
/* clear NTP time_status & time_state */
int clear_time_state(void)
{
struct timex tx;
int ret;
tx.modes = ADJ_STATUS;
tx.status = 0;
ret = adjtimex(&tx);
return ret;
}
bool RDTimeSynced()
{
struct timex timex;
memset(&timex,0,sizeof(struct timex));
if(adjtimex(&timex)==TIME_OK) {
return true;
}
return false;
}
int set_tai(int offset)
{
struct timex tx;
memset(&tx, 0, sizeof(tx));
tx.modes = ADJ_TAI;
tx.constant = offset;
return adjtimex(&tx);
}
bool ntp_synced(void) {
struct timex txc = {};
if (adjtimex(&txc) < 0)
return false;
if (txc.status & STA_UNSYNC)
return false;
return true;
}
static GVariant *get_clock_synchronized(void) {
struct timex t;
gboolean ret;
/* Consider the system clock synchronized if the maximum error reported
by adjtimex() is smaller than 10 seconds. Ignore the STA_UNSYNC flag
as it may be set to prevent the kernel from touching the RTC. */
t.modes = 0;
ret = adjtimex(&t) >= 0 && t.maxerror < 10000000;
return g_variant_new_boolean(ret);
}
static void reset_ntp_error(void)
{
struct timex txc;
txc.modes = ADJ_SETOFFSET;
txc.time.tv_sec = 0;
txc.time.tv_usec = 0;
if (adjtimex(&txc) < 0) {
perror("[FAIL] adjtimex");
ksft_exit_fail();
}
}
int main(int argc, char** argv)
{
struct timex tx;
int ret;
int i;
clear_time_state();
/* Set the leap second insert flag */
tx.modes = ADJ_SETOFFSET | ADJ_NANO;
printf("Testing ADJ_SETOFFSET: ");
for (i=0; i < NUM_VALID; i++) {
tx.time.tv_sec = valid_vals[i].tv_sec;
tx.time.tv_usec = valid_vals[i].tv_nsec;
ret = adjtimex(&tx);
if (ret < 0 ) {
printf("FAIL\n");
printf("Error: adjtimex(ADJ_SETOFFSET, %ld:%ld)\n",
valid_vals[i].tv_sec,valid_vals[i].tv_nsec);
return -1;
}
}
for (i=0; i < NUM_INVALID; i++) {
tx.time.tv_sec = invalid_vals[i].tv_sec;
tx.time.tv_usec = invalid_vals[i].tv_nsec;
ret = adjtimex(&tx);
if (ret >= 0 ) {
printf("FAIL\n");
printf("Error: invalid adjtimex(ADJ_SETOFFSET, %ld:%ld)\n",
invalid_vals[i].tv_sec,invalid_vals[i].tv_nsec);
return -1;
}
}
printf("PASS\n");
return 0;
}
static double
getFrequency (ClockDriver * self) {
struct timex tmx;
memset(&tmx, 0, sizeof(tmx));
if(adjtimex(&tmx) < 0) {
PERROR(THIS_COMPONENT"Could not get frequency of clock %s ", self->name);
return 0;
}
return((tmx.freq + 0.0) / 65.536);
}
/*
*cleanup() - performs all ONE TIME cleanup for this test at
* completion or premature exit.
*/
void cleanup(void)
{
tim_save.modes = SET_MODE;
/* Restore saved parameters */
if ((adjtimex(&tim_save)) == -1) {
tst_resm(TWARN, "Failed to restore saved parameters");
}
/*
* print timing stats if that option was specified.
* print errno log if that option was specified.
*/
TEST_CLEANUP;
}
Boolean adjFreq(Integer32 adj)
{
struct timex t;
if(adj > ADJ_FREQ_MAX)
adj = ADJ_FREQ_MAX;
else if(adj < -ADJ_FREQ_MAX)
adj = -ADJ_FREQ_MAX;
t.modes = MOD_FREQUENCY;
t.freq = adj*((1<<16)/1000);
return !adjtimex(&t);
}
static int get_current_freq(void)
{
/* OS dependent routine to get the current value of clock frequency.
*/
#ifdef __linux__
struct timex txc;
txc.modes=0;
if (adjtimex(&txc) < 0) {
perror("adjtimex"); exit(1);
}
return txc.freq;
#else
return 0;
#endif
}
static void setup(void)
{
tst_require_root(NULL);
tim_save.modes = 0;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
/* Save current parameters in tim_save */
if ((adjtimex(&tim_save)) == -1)
tst_brkm(TBROK | TERRNO, cleanup,
"failed to save current parameters");
}
static void set_frequency(double freq)
{
struct timex txc;
int tick_offset;
tick_offset = 1e6 * freq / user_hz;
txc.modes = ADJ_TICK | ADJ_FREQUENCY;
txc.tick = 1000000 / user_hz + tick_offset;
txc.freq = (1e6 * freq - user_hz * tick_offset) * (1 << 16);
if (adjtimex(&txc) < 0) {
perror("[FAIL] adjtimex");
ksft_exit_fail();
}
}
static int set_freq(int new_freq)
{
/* OS dependent routine to set a new value of clock frequency.
*/
#ifdef __linux__
struct timex txc;
txc.modes = ADJ_FREQUENCY;
txc.freq = new_freq;
if (adjtimex(&txc) < 0) {
perror("adjtimex"); exit(1);
}
return txc.freq;
#else
return 0;
#endif
}
static int get_current_freq(void)
{
/* OS dependent routine to get the current value of clock frequency.
*/
#ifdef __linux__
struct timex txc;
txc.modes=0;
if (adjtimex(&txc) < 0) {
logit(LOG_ERR, errno, "Failed adjtimex(GET)");
exit(1);
}
return txc.freq;
#else
return 0;
#endif
}
Bool
TimeSync_PLLSetFrequency(int64 ppmCorrection)
{
struct timex tx;
int error;
tx.modes = ADJ_FREQUENCY;
tx.freq = ppmCorrection;
error = adjtimex(&tx);
if (error == -1) {
g_debug("%s: adjtimex failed: %d %s\n", __FUNCTION__,
error, strerror(errno));
return FALSE;
}
TimeSyncLogPLLState(__FUNCTION__, &tx);
return TRUE;
}
/* setup() - performs all ONE TIME setup for this test */
void setup()
{
/* Check whether we are root */
if (geteuid() != 0) {
tst_brkm(TBROK, tst_exit, "Test must be run as root");
}
tim_save.modes = 0;
/* capture signals */
tst_sig(NOFORK, DEF_HANDLER, cleanup);
/* Pause if that option was specified */
TEST_PAUSE;
/* Save current parameters in tim_save */
if ((adjtimex(&tim_save)) == -1) {
tst_brkm(TBROK, cleanup, "Failed to save current parameters");
}
} /* End setup() */
int main(int ac, char **av)
{
int lc; /* loop counter */
char *msg; /* message returned from parse_opts */
/* parse standard options */
if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL))
!= (char *)NULL) {
tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg);
}
/* perform global setup for test */
setup();
/* check looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset Tst_count in case we are looping. */
Tst_count = 0;
/* Call adjtimex(2) */
tim_save.modes = SET_MODE;
TEST(adjtimex(&tim_save));
if ((TEST_RETURN >= 0) && (TEST_RETURN <= 5)) {
tst_resm(TPASS, "adjtimex() returned %ld", TEST_RETURN);
} else {
tst_resm(TFAIL|TTERRNO, "Test Failed, adjtimex()"
"returned %ld", TEST_RETURN);
}
} /* End for TEST_LOOPING */
/* cleanup and exit */
cleanup();
/*NOTREACHED*/ return 0;
} /* End main */
