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 along
  16  * with this program; see the file COPYING; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include <string.h>
  23 #include <sys/time.h>
  24 #include <time.h>
  25
  26 #include "log.h"
  27 #include "thread.h"
  28 #include "lib_errors.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                 flog_err_sys(EC_LIB_SYSTEM_CALL,
  39                              "%s: gettimeofday() failure: errno=%d: %s",
  40                              __PRETTY_FUNCTION__, 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                 flog_err_sys(EC_LIB_SYSTEM_CALL,
  56                              "%s: gettime_monotonic() failure: errno=%d: %s",
  57                              __PRETTY_FUNCTION__, 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                 flog_err_sys(EC_LIB_SYSTEM_CALL,
  75                              "%s: gettime_monotonic() failure: errno=%d: %s",
  76                              __PRETTY_FUNCTION__, errno, safe_strerror(errno));
  77                 return -1;
  78         }
  79
  80         now_dsec = ((int64_t)now_tv.tv_sec) * 10
  81                    + ((int64_t)now_tv.tv_usec) / 100000;
  82
  83         return now_dsec;
  84 }
  85
  86 int64_t pim_time_monotonic_usec(void)
  87 {
  88         struct timeval now_tv;
  89         int64_t now_dsec;
  90
  91         if (gettime_monotonic(&now_tv)) {
  92                 flog_err_sys(EC_LIB_SYSTEM_CALL,
  93                              "%s: gettime_monotonic() failure: errno=%d: %s",
  94                              __PRETTY_FUNCTION__, errno, safe_strerror(errno));
  95                 return -1;
  96         }
  97
  98         now_dsec =
  99                 ((int64_t)now_tv.tv_sec) * 1000000 + ((int64_t)now_tv.tv_usec);
 100
 101         return now_dsec;
 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         } else {
 143                 snprintf(buf, buf_size, "--:--");
 144         }
 145 }
 146
 147 void pim_time_timer_to_hhmmss(char *buf, int buf_size, struct thread *t_timer)
 148 {
 149         if (t_timer) {
 150                 pim_time_hhmmss(buf, buf_size,
 151                                 thread_timer_remain_second(t_timer));
 152         } else {
 153                 snprintf(buf, buf_size, "--:--:--");
 154         }
 155 }
 156
 157 void pim_time_uptime(char *buf, int buf_size, int64_t uptime_sec)
 158 {
 159         zassert(buf_size >= 8);
 160
 161         pim_time_hhmmss(buf, buf_size, uptime_sec);
 162 }
 163
 164 void pim_time_uptime_begin(char *buf, int buf_size, int64_t now, int64_t begin)
 165 {
 166         if (begin > 0)
 167                 pim_time_uptime(buf, buf_size, now - begin);
 168         else
 169                 snprintf(buf, buf_size, "--:--:--");
 170 }
 171
 172 long pim_time_timer_remain_msec(struct thread *t_timer)
 173 {
 174         /* FIXME: Actually fetch msec resolution from thread */
 175
 176         /* no timer thread running means timer has expired: return 0 */
 177
 178         return t_timer ? 1000 * thread_timer_remain_second(t_timer) : 0;
 179 }