LCOV - code coverage report
Current view: top level - lkbce/include/linux - time.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 4 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _LINUX_TIME_H
       2             : #define _LINUX_TIME_H
       3             : 
       4             : #include <linux/types.h>
       5             : 
       6             : #ifdef __KERNEL__
       7             : # include <linux/cache.h>
       8             : # include <linux/seqlock.h>
       9             : # include <linux/math64.h>
      10             : #endif
      11             : 
      12             : #ifndef _STRUCT_TIMESPEC
      13             : #define _STRUCT_TIMESPEC
      14             : struct timespec {
      15             :         __kernel_time_t tv_sec;                 /* seconds */
      16             :         long            tv_nsec;                /* nanoseconds */
      17             : };
      18             : #endif
      19             : 
      20             : struct timeval {
      21             :         __kernel_time_t         tv_sec;         /* seconds */
      22             :         __kernel_suseconds_t    tv_usec;        /* microseconds */
      23             : };
      24           1 : 
      25             : struct timezone {
      26             :         int     tz_minuteswest; /* minutes west of Greenwich */
      27             :         int     tz_dsttime;     /* type of dst correction */
      28             : };
      29             : 
      30             : #ifdef __KERNEL__
      31             : 
      32           1 : extern struct timezone sys_tz;
      33             : 
      34             : /* Parameters used to convert the timespec values: */
      35             : #define MSEC_PER_SEC    1000L
      36             : #define USEC_PER_MSEC   1000L
      37             : #define NSEC_PER_USEC   1000L
      38             : #define NSEC_PER_MSEC   1000000L
      39             : #define USEC_PER_SEC    1000000L
      40             : #define NSEC_PER_SEC    1000000000L
      41             : #define FSEC_PER_SEC    1000000000000000L
      42             : 
      43             : #define TIME_T_MAX      (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
      44             : 
      45             : static inline int timespec_equal(const struct timespec *a,
      46             :                                  const struct timespec *b)
      47             : {
      48             :         return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
      49             : }
      50             : 
      51             : /*
      52             :  * lhs < rhs:  return <0
      53             :  * lhs == rhs: return 0
      54             :  * lhs > rhs:  return >0
      55             :  */
      56             : static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
      57             : {
      58             :         if (lhs->tv_sec < rhs->tv_sec)
      59             :                 return -1;
      60             :         if (lhs->tv_sec > rhs->tv_sec)
      61             :                 return 1;
      62             :         return lhs->tv_nsec - rhs->tv_nsec;
      63             : }
      64             : 
      65             : static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
      66             : {
      67             :         if (lhs->tv_sec < rhs->tv_sec)
      68             :                 return -1;
      69             :         if (lhs->tv_sec > rhs->tv_sec)
      70             :                 return 1;
      71             :         return lhs->tv_usec - rhs->tv_usec;
      72             : }
      73             : 
      74             : extern unsigned long mktime(const unsigned int year, const unsigned int mon,
      75             :                             const unsigned int day, const unsigned int hour,
      76             :                             const unsigned int min, const unsigned int sec);
      77             : 
      78             : extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
      79             : extern struct timespec timespec_add_safe(const struct timespec lhs,
      80             :                                          const struct timespec rhs);
      81             : 
      82             : /*
      83             :  * sub = lhs - rhs, in normalized form
      84             :  */
      85             : static inline struct timespec timespec_sub(struct timespec lhs,
      86             :                                                 struct timespec rhs)
      87             : {
      88             :         struct timespec ts_delta;
      89             :         set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
      90             :                                 lhs.tv_nsec - rhs.tv_nsec);
      91             :         return ts_delta;
      92             : }
      93             : 
      94             : /*
      95             :  * Returns true if the timespec is norm, false if denorm:
      96             :  */
      97             : #define timespec_valid(ts) \
      98             :         (((ts)->tv_sec >= 0) && (((unsigned long) (ts)->tv_nsec) < NSEC_PER_SEC))
      99             : 
     100             : extern struct timespec xtime;
     101             : extern struct timespec wall_to_monotonic;
     102             : extern seqlock_t xtime_lock;
     103             : 
     104             : extern void read_persistent_clock(struct timespec *ts);
     105             : extern void read_boot_clock(struct timespec *ts);
     106             : extern int update_persistent_clock(struct timespec now);
     107             : extern int no_sync_cmos_clock __read_mostly;
     108             : void timekeeping_init(void);
     109             : extern int timekeeping_suspended;
     110             : 
     111             : unsigned long get_seconds(void);
     112             : struct timespec current_kernel_time(void);
     113             : struct timespec __current_kernel_time(void); /* does not hold xtime_lock */
     114             : struct timespec get_monotonic_coarse(void);
     115             : 
     116             : #define CURRENT_TIME            (current_kernel_time())
     117             : #define CURRENT_TIME_SEC        ((struct timespec) { get_seconds(), 0 })
     118             : 
     119             : /* Some architectures do not supply their own clocksource.
     120             :  * This is mainly the case in architectures that get their
     121             :  * inter-tick times by reading the counter on their interval
     122             :  * timer. Since these timers wrap every tick, they're not really
     123             :  * useful as clocksources. Wrapping them to act like one is possible
     124             :  * but not very efficient. So we provide a callout these arches
     125             :  * can implement for use with the jiffies clocksource to provide
     126             :  * finer then tick granular time.
     127             :  */
     128             : #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
     129             : extern u32 arch_gettimeoffset(void);
     130             : #else
     131             : static inline u32 arch_gettimeoffset(void) { return 0; }
     132             : #endif
     133             : 
     134             : extern void do_gettimeofday(struct timeval *tv);
     135             : extern int do_settimeofday(struct timespec *tv);
     136             : extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
     137             : #define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
     138             : extern long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags);
     139             : struct itimerval;
     140             : extern int do_setitimer(int which, struct itimerval *value,
     141             :                         struct itimerval *ovalue);
     142             : extern unsigned int alarm_setitimer(unsigned int seconds);
     143             : extern int do_getitimer(int which, struct itimerval *value);
     144             : extern void getnstimeofday(struct timespec *tv);
     145             : extern void getrawmonotonic(struct timespec *ts);
     146             : extern void getboottime(struct timespec *ts);
     147             : extern void monotonic_to_bootbased(struct timespec *ts);
     148             : 
     149             : extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
     150             : extern int timekeeping_valid_for_hres(void);
     151             : extern u64 timekeeping_max_deferment(void);
     152             : extern void update_wall_time(void);
     153             : extern void update_xtime_cache(u64 nsec);
     154             : extern void timekeeping_leap_insert(int leapsecond);
     155             : 
     156             : struct tms;
     157             : extern void do_sys_times(struct tms *);
     158           1 : 
     159             : /*
     160             :  * Similar to the struct tm in userspace <time.h>, but it needs to be here so
     161             :  * that the kernel source is self contained.
     162             :  */
     163             : struct tm {
     164             :         /*
     165             :          * the number of seconds after the minute, normally in the range
     166             :          * 0 to 59, but can be up to 60 to allow for leap seconds
     167             :          */
     168             :         int tm_sec;
     169             :         /* the number of minutes after the hour, in the range 0 to 59*/
     170             :         int tm_min;
     171             :         /* the number of hours past midnight, in the range 0 to 23 */
     172             :         int tm_hour;
     173             :         /* the day of the month, in the range 1 to 31 */
     174             :         int tm_mday;
     175             :         /* the number of months since January, in the range 0 to 11 */
     176             :         int tm_mon;
     177             :         /* the number of years since 1900 */
     178             :         long tm_year;
     179             :         /* the number of days since Sunday, in the range 0 to 6 */
     180             :         int tm_wday;
     181             :         /* the number of days since January 1, in the range 0 to 365 */
     182             :         int tm_yday;
     183             : };
     184             : 
     185             : void time_to_tm(time_t totalsecs, int offset, struct tm *result);
     186             : 
     187             : /**
     188             :  * timespec_to_ns - Convert timespec to nanoseconds
     189             :  * @ts:         pointer to the timespec variable to be converted
     190             :  *
     191             :  * Returns the scalar nanosecond representation of the timespec
     192             :  * parameter.
     193             :  */
     194             : static inline s64 timespec_to_ns(const struct timespec *ts)
     195             : {
     196             :         return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
     197             : }
     198             : 
     199             : /**
     200             :  * timeval_to_ns - Convert timeval to nanoseconds
     201             :  * @ts:         pointer to the timeval variable to be converted
     202             :  *
     203             :  * Returns the scalar nanosecond representation of the timeval
     204             :  * parameter.
     205             :  */
     206             : static inline s64 timeval_to_ns(const struct timeval *tv)
     207             : {
     208             :         return ((s64) tv->tv_sec * NSEC_PER_SEC) +
     209             :                 tv->tv_usec * NSEC_PER_USEC;
     210             : }
     211             : 
     212             : /**
     213             :  * ns_to_timespec - Convert nanoseconds to timespec
     214             :  * @nsec:       the nanoseconds value to be converted
     215             :  *
     216             :  * Returns the timespec representation of the nsec parameter.
     217             :  */
     218             : extern struct timespec ns_to_timespec(const s64 nsec);
     219             : 
     220             : /**
     221             :  * ns_to_timeval - Convert nanoseconds to timeval
     222             :  * @nsec:       the nanoseconds value to be converted
     223             :  *
     224             :  * Returns the timeval representation of the nsec parameter.
     225             :  */
     226             : extern struct timeval ns_to_timeval(const s64 nsec);
     227             : 
     228             : /**
     229             :  * timespec_add_ns - Adds nanoseconds to a timespec
     230             :  * @a:          pointer to timespec to be incremented
     231             :  * @ns:         unsigned nanoseconds value to be added
     232             :  *
     233             :  * This must always be inlined because its used from the x86-64 vdso,
     234             :  * which cannot call other kernel functions.
     235             :  */
     236             : static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
     237             : {
     238             :         a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
     239             :         a->tv_nsec = ns;
     240             : }
     241             : #endif /* __KERNEL__ */
     242             : 
     243             : #define NFDBITS                 __NFDBITS
     244             : 
     245             : #define FD_SETSIZE              __FD_SETSIZE
     246             : #define FD_SET(fd,fdsetp)       __FD_SET(fd,fdsetp)
     247             : #define FD_CLR(fd,fdsetp)       __FD_CLR(fd,fdsetp)
     248             : #define FD_ISSET(fd,fdsetp)     __FD_ISSET(fd,fdsetp)
     249             : #define FD_ZERO(fdsetp)         __FD_ZERO(fdsetp)
     250             : 
     251             : /*
     252             :  * Names of the interval timers, and structure
     253             :  * defining a timer setting:
     254             :  */
     255             : #define ITIMER_REAL             0
     256             : #define ITIMER_VIRTUAL          1
     257             : #define ITIMER_PROF             2
     258             : 
     259             : struct itimerspec {
     260             :         struct timespec it_interval;    /* timer period */
     261             :         struct timespec it_value;       /* timer expiration */
     262             : };
     263             : 
     264             : struct itimerval {
     265             :         struct timeval it_interval;     /* timer interval */
     266             :         struct timeval it_value;        /* current value */
     267             : };
     268           1 : 
     269             : /*
     270             :  * The IDs of the various system clocks (for POSIX.1b interval timers):
     271             :  */
     272             : #define CLOCK_REALTIME                  0
     273             : #define CLOCK_MONOTONIC                 1
     274             : #define CLOCK_PROCESS_CPUTIME_ID        2
     275             : #define CLOCK_THREAD_CPUTIME_ID         3
     276             : #define CLOCK_MONOTONIC_RAW             4
     277             : #define CLOCK_REALTIME_COARSE           5
     278             : #define CLOCK_MONOTONIC_COARSE          6
     279             : 
     280             : /*
     281             :  * The IDs of various hardware clocks:
     282             :  */
     283             : #define CLOCK_SGI_CYCLE                 10
     284             : #define MAX_CLOCKS                      16
     285             : #define CLOCKS_MASK                     (CLOCK_REALTIME | CLOCK_MONOTONIC)
     286             : #define CLOCKS_MONO                     CLOCK_MONOTONIC
     287             : 
     288             : /*
     289             :  * The various flags for setting POSIX.1b interval timers:
     290             :  */
     291             : #define TIMER_ABSTIME                   0x01
     292             : 
     293             : #endif

Generated by: LCOV version 1.10