mbgsvcd.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: mbgsvcd.c 1.6 2019/02/11 09:57:20 martin TRASH $
 *
 *  Description:
 *    Main file for mbgsvcd which compares the system time to a PCI card's
 *    time and transfers this data pair to the SHM driver of the ntpd.
 *
 * -----------------------------------------------------------------------
 *  $Log: mbgsvcd.c $
 *  Revision 1.6  2019/02/11 09:57:20  martin
 *  Account for renamed library symbols.
 *  Use an individual filter for each device.
 *  Revision 1.5  2018/11/15 12:12:33  martin
 *  Individual MBG_MICRO_VERSION codes are now obsolete.
 *  Revision 1.4  2017/07/05 18:45:29  martin
 *  New way to maintain version information.
 *  Print PC cycles counter frequency at program start.
 *  Use /var/run as directory for the lockfile.
 *  Using generic MBG_SYS_TIME with nanosecond resolution.
 *  Workaround in case cycle frequency can not be determined.
 *  Compute execution time limit in cycles instead of us so this can also
 *  be done if the cycle counter clock rate can not be determined.
 *  Skip devices which don't support HR time immediately at startup.
 *  Log reasons for error if function calls fail.
 *  Combined printf() and syslog() to mbg_log().
 *  Added leap second support.
 *  Moved some code to some extra modules which can be shared.
 *  Use seconds for the trust time.
 *  Support options -q and -r.
 *  Use more functions from common library modules.
 *  Use codes and inline functions from mbgerror.h.
 *  Patch submitted by <juergen.perlinger@t-online.de>:
 *  Support variable number of SHM units and number
 *  of the first unit to use.
 *  Proper return codes and exit codes.
 *  Revision 1.3  2010/03/03 14:59:36  martin
 *  Support -p parameter to pretend sync.
 *  Revision 1.2  2010/02/03 16:15:09  daniel
 *  Revision 1.1  2010/02/03 16:07:18  daniel
 *
 **************************************************************************/

// include Meinberg headers
#include <mbgdevio.h>
#include <pcpsutil.h>
#include <toolutil.h>  // common utility functions
#include <mbgerror.h>
#include <pcpsmktm.h>
#include <chk_time_info.h>
#include <ntp_shm.h>

// include system headers
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <syslog.h>
#include <stdarg.h>
#include <time.h>
#include <sys/time.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define RUNNING_DIR                "/var/run"
#define LOCK_FILE                  "mbgsvcd.pid"

#define MBG_FIRST_COPYRIGHT_YEAR   2010
#define MBG_LAST_COPYRIGHT_YEAR    0      // use default

static const char *pname = "mbgsvcd";

static int foreground;                    // -f
static int quiet;                         // -q
static int pretend_sync;                  // -p
static int print_raw;                     // -r
static int sleep_intv = 1;                // -s
static unsigned long trust_time_seconds;  // -t
static int n_unit0 = 0;                   // -o
static int n_units = MAX_SHM_REFCLOCKS;   // -n
static int frac_digits = 9;

MBG_PC_CYCLES_FREQUENCY cyc_freq;


static struct shmTime *shmTime[MAX_SHM_REFCLOCKS];
static CYCLES_FILTER_DATA filter[MAX_SHM_REFCLOCKS];

static int has_synced_after_reset[MAX_SHM_REFCLOCKS] = { 0 };
static long int ref_trust_time_start[MAX_SHM_REFCLOCKS] = { 0 };
static long int ref_trust_time_expire[MAX_SHM_REFCLOCKS] = { 0 };



/*HDR*/
void mbg_log( int lvl, const char *fmt, ... )
{
  char ws[256];
  va_list ap;

  va_start( ap, fmt );
  vsnprintf( ws, sizeof( ws ), fmt, ap );
  va_end( ap );

  syslog( lvl, "%s", ws );
  fprintf( stdout, "%s\n", ws );

}  // mbg_log



static /*HDR*/
int do_mbgsvctasks( void )
{
  char ws[256];
  int rc = 0;
  int n_devices_found;
  int n_devices;
  MBG_DEV_HANDLE dhs[MAX_SHM_REFCLOCKS];
  PCPS_DEV devs[MAX_SHM_REFCLOCKS];
  int i;

  n_devices_found = mbg_find_devices();

  for ( i = 0, n_devices = 0; i < n_devices_found; i++ )
  {
    MBG_DEV_HANDLE dh = mbg_open_device( i );
    PCPS_DEV dev_info;

    rc = mbg_get_device_info( dh, &dev_info );

    if ( rc < 0 )
    {
      mbg_log( LOG_WARNING, "Failed to read device info from device #%i.", i );
      mbg_close_device( &dh );
      continue;
    }

    if ( !_pcps_has_hr_time( &dev_info ) )
    {
      mbg_log( LOG_WARNING, "Device %s does not support HR time stamps.",
               _pcps_type_name( &dev_info ) );
      mbg_close_device( &dh );
      continue;
    }

    dhs[n_devices] = dh;
    devs[n_devices] = dev_info;

    if ( ++n_devices >= n_units )
      break;
  }

  if ( n_devices == 0 )
  {
    mbg_log( LOG_WARNING, "No usable device found!" );
    goto done;
  }


  // Search for devices up to the maximum of supported number of NTP SHM refclocks
  if ( n_devices > MAX_SHM_REFCLOCKS )
    n_devices = MAX_SHM_REFCLOCKS;

  mbg_log( LOG_INFO, "Found %d devices usable for the NTP daemon", n_devices );  //##++++

  rc = mbg_get_default_cycles_frequency_from_dev( dhs[0], &cyc_freq );

  if ( mbg_cond_err_msg( rc, "mbg_get_default_cycles_frequency_from_dev" ) )
    goto done;


  mbg_log( LOG_INFO, "%sPC cycles counter clock frequency: %Lu Hz",
           ( cyc_freq == 0 ) ? "*** Warning: " : "",
           (unsigned long long) cyc_freq );

  // Initialize NTP shared memory area
  ntpshm_init( shmTime, n_devices, n_unit0 );

  for (;;)
  {
    for ( i = 0; i < n_devices; i++ )
    {
      MBG_CHK_TIME_INFO cti;
      const char *cp;
      int leap;

      rc = mbg_chk_time_info( dhs[i], &cti, &filter[i], 0 );

      if ( mbg_cond_err_msg( rc, "mbg_chk_time_info" ) )
        continue;

      cp = "";
      leap = 0;

      if ( ( has_synced_after_reset[i] == 1 ) && ( ( ( cti.hrti.ref_hr_time_cycles.t.status & PCPS_FREER ) == 1 )
          || ( ( cti.hrti.ref_hr_time_cycles.t.status & PCPS_SYNCD ) == 0 ) ))
      {
        struct timespec ts;

        clock_gettime(CLOCK_MONOTONIC, &ts);

        if (ref_trust_time_start[i] == 0 )
        {
          mbg_log( LOG_WARNING, "Device #%i, entering holdover mode", i );
          ref_trust_time_start[i] = ts.tv_sec;
          ref_trust_time_expire[i] = ts.tv_sec + trust_time_seconds;
        }

        if ( ts.tv_sec > ref_trust_time_expire[i] )
        {
          mbg_log( LOG_WARNING, "Device #%i, trust time expired", i );
          has_synced_after_reset[i] = 0;
          ref_trust_time_start[i]   = 0;
          ref_trust_time_expire[i]  = 0;
        }
      }

      // check if refclock is sync and if exec time of the system time call was fast enough
      if ( ( cti.exec_cyc <= cti.exec_cyc_limit ) && ( pretend_sync || has_synced_after_reset[i] || (
           ( ( cti.hrti.ref_hr_time_cycles.t.status & PCPS_FREER ) == 0 ) &&
           ( ( cti.hrti.ref_hr_time_cycles.t.status & PCPS_SYNCD ) != 0 ) ) ) )
      {
        struct shmTime *p = shmTime[i];

        has_synced_after_reset[i] = 1;

        if ( p )
        {
          MBG_SYS_TIME_CYCLES *p_sys_tic = &cti.hrti.sys_time_cycles;
          cp = " *";

          // fill SHM structure
          p->count++;
          p->clockTimeStampSec = (time_t) cti.d_ref_comp;
          p->clockTimeStampUSec = (int) ( ( cti.d_ref_comp - p->clockTimeStampSec ) * 1e6 ); // get microseconds from d_ref
          p->receiveTimeStampSec = (time_t) p_sys_tic->sys_time.secs;
          p->receiveTimeStampUSec = (int) ( p_sys_tic->sys_time.nano_secs / 1000 );

          // These fields are only supported by newer versions of ntpd //##++++++++++++++++++ which versions ?
          p->clockTimeStampNSec = (int) ( ( cti.d_ref_comp - p->clockTimeStampSec ) * 1e9 ); // get nanoseconds from d_ref
          p->receiveTimeStampNSec = (int) ( p_sys_tic->sys_time.nano_secs );

          // patch precision value according to the ref time accuracy
          if ( _pcps_is_lwr( &devs[i] ) )
            p->precision = -8;
          else
          {
            if ( _pcps_is_irig_rx( &devs[i] ) )
            {
              if ( _pcps_is_usb( &devs[i] ) )
                p->precision = -10;
              else
                p->precision = -18;
            }
            else
              p->precision = -20;
          }

          if ( cti.hrti.ref_hr_time_cycles.t.status & PCPS_LS_ANN_NEG )
            p->leap = LEAP_DELSECOND;
          else
            if ( cti.hrti.ref_hr_time_cycles.t.status & PCPS_LS_ANN )
              p->leap = LEAP_ADDSECOND;
            else
              p->leap = LEAP_NOWARNING;

          leap = p->leap;  //##+++

          p->count++;
          p->valid = 1;
        }
      }

      if ( !quiet )
      {
        snprint_chk_time_info( ws, sizeof( ws ), &cti, &devs[i], frac_digits, print_raw );
        printf( "%s, leap: %02X%s\n", ws, leap, cp );
      }

      usleep( 10 );
    }

    if ( n_devices > 1 )
      printf( "\n" );

    if ( sleep_intv )
      sleep( sleep_intv );
  }

done:
  for ( i = 0; i < n_devices; i++ )
    mbg_close_device( &dhs[i] );

  return rc;

}  // do_mbgsvctasks



static /*HDR*/
void usage( void )
{
  mbg_print_usage_intro( pname,
    "This program periodically reads a reference time stamp and an associated\n"
    "system time stamp from every mbgclock device, and feeds the time stamp pairs\n"
    "to the NTP daemon's shared memory refclock driver.\n"
    "It usually runs as daemon but can also be run in the foreground to monitor the\n"
    "time stamps and offsets.\n"
    "This works only for cards supporting high resolution time stamps.\n"
  );
  mbg_print_help_options();
  mbg_print_opt_info( "-f", "run program in foreground" );
  mbg_print_opt_info( "-q", "quiet, don't print time differences on stdout" );
  mbg_print_opt_info( "-r", "print raw time stamps when printing on stdout" );
  mbg_print_opt_info( "-s num", "sleep num seconds between calls" );
  mbg_print_opt_info( "-p", "pretend device is always synchronized" );
  mbg_print_opt_info( "-t num", "set num seconds for refclock trust time, default 4 days (345600 seconds)" );
  mbg_print_opt_info( "-n num", "number of SHM segments to use" );
  mbg_print_opt_info( "-o num", "SHM segment number offset (default 0)" );
  mbg_print_device_options();
  puts( "" );

}  // usage



static /*HDR*/
void startup_daemon( void )
{
  int i;
  int lfp;
  int rc;
  char str[1024];

  if ( getppid() == 1 )
    return; /* already a daemon */

  mbg_log( LOG_INFO, "Daemon mode, backgrounding" );
  i = fork();

  if ( i < 0 )
    exit( 1 );  /* fork error */

  if ( i > 0 )
    exit( 0 );  /* parent exits */


  /* child (daemon) continues */
  setsid(); /* obtain a new process group */

  for ( i = getdtablesize(); i >= 0; --i )
    close( i ); /* close all descriptors */

  /* handle standard I/O */
  i = open( "/dev/null", O_RDWR );
  rc = dup( i );
  rc = dup( i );

  umask( 027 );  /* set newly created file permissions */
  rc = chdir( RUNNING_DIR ); /* change running directory */

  lfp = open( LOCK_FILE, O_RDWR | O_CREAT, 0640 );

  if ( lfp < 0 )
    exit( 1 );  /* unable to open lock file */

  if ( lockf( lfp, F_TLOCK, 0 ) < 0 )
  {
    mbg_log( LOG_ERR, "Lock file already exists, another instance of this daemon seems to be running" );
    closelog();
    exit( 0 );  /* can not lock */
  }

  /* first instance continues */
  snprintf( str, sizeof( str ), "%d\n", getpid() );
  rc = write( lfp, str, strlen( str ) );  /* record pid to lockfile */

  (void) rc;  // avoid warning "set but not used"

  signal( SIGCHLD, SIG_IGN ); /* ignore child */
  signal( SIGTSTP, SIG_IGN ); /* ignore tty signals */
  signal( SIGTTOU, SIG_IGN );
  signal( SIGTTIN, SIG_IGN );

}  // startup_daemon



int main( int argc, char *argv[] )
{
  int rc;
  int c;

  mbg_print_program_info( pname, MBG_FIRST_COPYRIGHT_YEAR, MBG_LAST_COPYRIGHT_YEAR );

  // check command line parameters
  while ( ( c = getopt( argc, argv, "fpqrst:n:o:h?" ) ) != -1 )
  {
    switch ( c )
    {
      case 'f':
        foreground = 1;
        break;

      case 'p':
        pretend_sync = 1;
        break;

      case 'q':
        quiet++;
        break;

      case 'r':
        print_raw = 1;
        break;

      case 's':
        sleep_intv = atoi( optarg );
        break;

      case 't':
      {
        long tt = atol( optarg );

        if ( tt > 0 )
          trust_time_seconds = tt;

        break;
      }

      case 'n':
        n_units = atoi( optarg );

        if ( n_units < 0 || n_units > MAX_SHM_REFCLOCKS )
        {
          mbg_log( LOG_WARNING, "Configured number of SHM units %i out of range, truncating to %i",
                   n_units, MAX_SHM_REFCLOCKS );
          n_units = MAX_SHM_REFCLOCKS;
        }

        break;

      case 'o':
        n_unit0 = atoi( optarg );

        if ( n_unit0 < 0 || n_unit0 >= MAX_SHM_UNIT_OFFSET )
        {
          mbg_log( LOG_WARNING, "Configured SHM unit offset %i out of range %i to %i, truncating to %i",
                   n_unit0, 0, MAX_SHM_UNIT_OFFSET, 0 );
          n_unit0 = 0;
        }

        break;

      case 'h':
      case '?':
      default:
        must_print_usage = 1;
    }
  }

  if ( must_print_usage )
  {
    usage();
    return MBG_EXIT_CODE_USAGE;
  }

  if ( foreground == 0 )
  {
    char ws[256];

    mbg_program_info_str( ws, sizeof( ws ), pname, MBG_FIRST_COPYRIGHT_YEAR,
                          MBG_LAST_COPYRIGHT_YEAR );

    mbg_log( LOG_INFO, "Starting Meinberg Service Daemon %s", ws );

    startup_daemon();
  }

  if ( trust_time_seconds )
    mbg_log( LOG_INFO, "refclock trust time: %ul seconds", trust_time_seconds );

  rc = do_mbgsvctasks();

  return mbg_rc_is_success( rc ) ? MBG_EXIT_CODE_SUCCESS : MBG_EXIT_CODE_FAIL;
}