pimd/pim_time.c

   1 /*
   2   PIM for Quagga
   3   Copyright (C) 2008  Everton da Silva Marques
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful, but
  11   WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13   General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; see the file COPYING; if not, write to the
  17   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  18   MA 02110-1301 USA
  19 */
  20
  21 #include <zebra.h>
  22
  23 #include <string.h>
  24 #include <sys/time.h>
  25 #include <time.h>
  26
  27 #include "log.h"
  28 #include "thread.h"
  29
  30 #include "pim_time.h"
  31
  32 static int gettime_monotonic(struct timeval *tv)
  33 {
  34   int result;
  35
  36   result = gettimeofday(tv, 0);
  37   if (result) {
  38     zlog_err("%s: gettimeofday() failure: errno=%d: %s",
  39              __PRETTY_FUNCTION__,
  40              errno, safe_strerror(errno));
  41   }
  42
  43   return result;
  44 }
  45
  46 /*
  47   pim_time_monotonic_sec():
  48   number of seconds since some unspecified starting point
  49 */
  50 int64_t pim_time_monotonic_sec()
  51 {
  52   struct timeval now_tv;
  53
  54   if (gettime_monotonic(&now_tv)) {
  55     zlog_err("%s: gettime_monotonic() failure: errno=%d: %s",
  56              __PRETTY_FUNCTION__,
  57              errno, safe_strerror(errno));
  58     return -1;
  59   }
  60
  61   return now_tv.tv_sec;
  62 }
  63
  64 /*
  65   pim_time_monotonic_dsec():
  66   number of deciseconds since some unspecified starting point
  67 */
  68 int64_t pim_time_monotonic_dsec()
  69 {
  70   struct timeval now_tv;
  71   int64_t        now_dsec;
  72
  73   if (gettime_monotonic(&now_tv)) {
  74     zlog_err("%s: gettime_monotonic() failure: errno=%d: %s",
  75              __PRETTY_FUNCTION__,
  76              errno, safe_strerror(errno));
  77     return -1;
  78   }
  79
  80   now_dsec = ((int64_t) now_tv.tv_sec) * 10 + ((int64_t) now_tv.tv_usec) / 100000;
  81
  82   return now_dsec;
  83 }
  84
  85 int64_t
  86 pim_time_monotonic_usec (void)
  87 {
  88   struct timeval now_tv;
  89   int64_t        now_dsec;
  90
  91   if (gettime_monotonic(&now_tv)) {
  92     zlog_err("%s: gettime_monotonic() failure: errno=%d: %s",
  93              __PRETTY_FUNCTION__,
  94              errno, safe_strerror(errno));
  95     return -1;
  96   }
  97
  98   now_dsec = ((int64_t) now_tv.tv_sec) * 1000000 + ((int64_t) now_tv.tv_usec);
  99
 100   return now_dsec;
 101
 102 }
 103
 104 int pim_time_mmss(char *buf, int buf_size, long sec)
 105 {
 106   long mm;
 107   int wr;
 108
 109   zassert(buf_size >= 5);
 110
 111   mm = sec / 60;
 112   sec %= 60;
 113
 114   wr = snprintf(buf, buf_size, "%02ld:%02ld", mm, sec);
 115
 116   return wr != 8;
 117 }
 118
 119 static int pim_time_hhmmss(char *buf, int buf_size, long sec)
 120 {
 121   long hh;
 122   long mm;
 123   int wr;
 124
 125   zassert(buf_size >= 8);
 126
 127   hh = sec / 3600;
 128   sec %= 3600;
 129   mm = sec / 60;
 130   sec %= 60;
 131
 132   wr = snprintf(buf, buf_size, "%02ld:%02ld:%02ld", hh, mm, sec);
 133
 134   return wr != 8;
 135 }
 136
 137 void pim_time_timer_to_mmss(char *buf, int buf_size, struct thread *t_timer)
 138 {
 139   if (t_timer) {
 140     pim_time_mmss(buf, buf_size,
 141                   thread_timer_remain_second(t_timer));
 142   }
 143   else {
 144     snprintf(buf, buf_size, "--:--");
 145   }
 146 }
 147
 148 void pim_time_timer_to_hhmmss(char *buf, int buf_size, struct thread *t_timer)
 149 {
 150   if (t_timer) {
 151     pim_time_hhmmss(buf, buf_size,
 152                     thread_timer_remain_second(t_timer));
 153   }
 154   else {
 155     snprintf(buf, buf_size, "--:--:--");
 156   }
 157 }
 158
 159 void pim_time_uptime(char *buf, int buf_size, int64_t uptime_sec)
 160 {
 161   zassert(buf_size >= 8);
 162
 163   pim_time_hhmmss(buf, buf_size, uptime_sec);
 164 }
 165
 166 void pim_time_uptime_begin(char *buf, int buf_size, int64_t now, int64_t begin)
 167 {
 168   if (begin > 0)
 169     pim_time_uptime(buf, buf_size, now - begin);
 170   else
 171     snprintf(buf, buf_size, "--:--:--");
 172 }
 173
 174 long pim_time_timer_remain_msec(struct thread *t_timer)
 175 {
 176   /* FIXME: Actually fetch msec resolution from thread */
 177
 178   /* no timer thread running means timer has expired: return 0 */
 179
 180   return t_timer ?
 181     1000 * thread_timer_remain_second(t_timer) :
 182     0;
 183 }