Linux时间子系统1：gettimeofday和clock_gettime实现分析

1. Linux用户态获取时间的函数

a. 秒级别的时间函数：time和stime

time和stime函数的定义如下：

1. #include <time.h>

3. time_t time(time_t *t);

5. int stime(time_t *t);

        time函数返回了当前时间点到linux epoch的秒数（内核中timekeeper模块保存了这个值，timekeeper->xtime_sec）。stime是设定当前时间点到linux epoch的秒数。对于linux kernel，设定时间的进程必须拥有CAP_SYS_TIME的权利，否则会失败。

b. 微秒级别的时间函数：gettimeofday和settimeofday

1. #include <sys/time.h>

3. int gettimeofday(struct timeval *tv, struct timezone *tz);

5. int settimeofday(const struct timeval *tv, const struct timezone *tz);

        这两个函数和上一小节秒数的函数类似，只不过时间精度可以达到微秒级别。gettimeofday函数可以获取从linux epoch到当前时间点的秒数以及微秒数

        显然，sys_gettimeofday和sys_settimeofday这两个系统调用是用来支持上面两个函数功能的，值得一提的是：这些系统调用在新的POSIX标准中 gettimeofday和settimeofday接口函数被标注为obsolescent，取而代之的是clock_gettime和clock_settime接口函数

        实际上上面的说法并不完全准确，在《Linux多线程服务端编程》一书5.1节中提到过，在x86-64的Linux上，gettimeofday不是系统调用，不会陷入内核。这种说法也有问题，因为gettimeofday确实是个系统调用，但是linux的vdso（virtual dynamic shared object）机制帮我们做到了在调用这些系统调用时不陷入内核，从而提高了性能。我们后面分析代码时会看到。

c. 纳秒级别的时间函数：clock_gettime和clock_settime

1. #include <time.h>

3. int clock_getres(clockid_t clk_id, struct timespec *res);

5. int clock_gettime(clockid_t clk_id, struct timespec *tp);

7. int clock_settime(clockid_t clk_id, const struct timespec *tp);

        如果不是clk_id这个参数，clock_gettime和clock_settime基本上是不用解释的，其概念和gettimeofday和settimeofday接口函数是完全类似的，除了精度是纳秒。Linux 5.10 定义了如下的clkid

1. /*

2. * The IDs of the various system clocks (for POSIX.1b interval timers):

3. */

4. #define CLOCK_REALTIME 0

5. #define CLOCK_MONOTONIC 1

6. #define CLOCK_PROCESS_CPUTIME_ID 2

7. #define CLOCK_THREAD_CPUTIME_ID 3

8. #define CLOCK_MONOTONIC_RAW 4

9. #define CLOCK_REALTIME_COARSE 5

10. #define CLOCK_MONOTONIC_COARSE 6

11. #define CLOCK_BOOTTIME 7

12. #define CLOCK_REALTIME_ALARM 8

13. #define CLOCK_BOOTTIME_ALARM 9

        但是以上ID并没有包含全部的clock类型，时钟类型，以及时间与时钟源的关系，我们后面再来分析

2. gettimeofday和clock_gettime的实现

a. gettimeofday的实现

        我们先看gettimeofday的实现，使用gettimeofday的示例代码如下：
 

1. #include <sys/time.h>

2. #include <stdio.h>

3. #include <unistd.h>

5. int main(int argc, char* argv[])

6. {

7. struct timeval tv_begin, tv_end;

8. gettimeofday(&tv_begin, NULL);

9. printf("start tv_sec %ld tv_usec %ld\n", tv_begin.tv_sec, tv_begin.tv_usec);

11. usleep(1000);

13. gettimeofday(&tv_end, NULL);

14. printf("end tv_sec %ld tv_usec %ld\n", tv_end.tv_sec, tv_end.tv_usec);

15. }

在Linux kernel中，kernel/time/time.c目录下有如下代码：

1. SYSCALL_DEFINE2(gettimeofday, struct __kernel_old_timeval __user *, tv,

2. struct timezone __user *, tz)

3. {

4. if (likely(tv != NULL)) {

5. struct timespec64 ts;

7. ktime_get_real_ts64(&ts);

8. if (put_user(ts.tv_sec, &tv->tv_sec) ||

9. put_user(ts.tv_nsec / 1000, &tv->tv_usec))

10. return -EFAULT;

11. }

12. if (unlikely(tz != NULL)) {

13. if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))

14. return -EFAULT;

15. }

16. return 0;

17. }

如果不看gettimeofday的C库实现，肯定会认为gettimeofday就是直接使用上面的系统调用，实际上我一开始就是这么认为的。我们去glibc/musl看一下，这个函数在musl 1.2.3中的定义如下

1. int gettimeofday(struct timeval *restrict tv, void *restrict tz)

2. {

3. struct timespec ts;

4. if (!tv) return 0;

5. clock_gettime(CLOCK_REALTIME, &ts);

6. tv->tv_sec = ts.tv_sec;

7. tv->tv_usec = (int)ts.tv_nsec / 1000;

8. return 0;

9. }

gettimeofday并没有直接使用系统调用，而是调用了clock_gettime，并且clockid直接填写了CLOCK_REALTIME，那么接下来我们就要分析clock_gettime函数了。

b. clock_gettime的实现

再看musl 1.2.3中的clock_gettime的代码

1. int __clock_gettime(clockid_t clk, struct timespec *ts)

2. {

3. int r;

5. #ifdef VDSO_CGT_SYM

6. int (*f)(clockid_t, struct timespec *) =

7. (int (*)(clockid_t, struct timespec *))vdso_func;

8. if (f) {

9. r = f(clk, ts);

10. if (!r) return r;

11. if (r == -EINVAL) return __syscall_ret(r);

12. /* Fall through on errors other than EINVAL. Some buggy

13. * vdso implementations return ENOSYS for clocks they

14. * can't handle, rather than making the syscall. This

15. * also handles the case where cgt_init fails to find

16. * a vdso function to use. */

17. }

18. #endif

20. #ifdef SYS_clock_gettime64

21. r = -ENOSYS;

22. if (sizeof(time_t) > 4)

23. r = __syscall(SYS_clock_gettime64, clk, ts);

24. if (SYS_clock_gettime == SYS_clock_gettime64 || r!=-ENOSYS)

25. return __syscall_ret(r);

26. long ts32[2];

27. r = __syscall(SYS_clock_gettime, clk, ts32);

28. if (r==-ENOSYS && clk==CLOCK_REALTIME) {

29. r = __syscall(SYS_gettimeofday, ts32, 0);

30. ts32[1] *= 1000;

31. }

32. if (!r) {

33. ts->tv_sec = ts32[0];

34. ts->tv_nsec = ts32[1];

35. return r;

36. }

37. return __syscall_ret(r);

38. #else

39. r = __syscall(SYS_clock_gettime, clk, ts);

40. if (r == -ENOSYS) {

41. if (clk == CLOCK_REALTIME) {

42. __syscall(SYS_gettimeofday, ts, 0);

43. ts->tv_nsec = (int)ts->tv_nsec * 1000;

44. return 0;

45. }

46. r = -EINVAL;

47. }

48. return __syscall_ret(r);

49. #endif

50. }

52. weak_alias(__clock_gettime, clock_gettime);

很明显有2个分支，我们先看第一个分支，包含宏定义VDSO_CGT_SYM，这里不详细介绍vdso了，放在后面单独讲，vdso简而言之就是为了避免系统调用的开销，使用内存映射的办法，将内核数据映射到用户空间。

那么数据是如何更新到vdso数据的呢？在内核的时间更新函数timekeeping_update函数中调用update_vsyscall更新了vdso数据结构

那么clock_gettime是否在所有情况下都能从用户态获取到时间呢，其实并不是，即使在使能了vdso的情况下，也还是有一些场景需要trap进内核，比如访问phc clock的时间。所以内核还是支持正常的系统调用，内核实现如下：

1. SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,

2. struct __kernel_timespec __user *, tp)

3. {

4. const struct k_clock *kc = clockid_to_kclock(which_clock);

5. struct timespec64 kernel_tp;

6. int error;

8. if (!kc)

9. return -EINVAL;

11. error = kc->clock_get_timespec(which_clock, &kernel_tp);

13. if (!error && put_timespec64(&kernel_tp, tp))

14. error = -EFAULT;

16. return error;

17. }

同样，我们可以看到根据clockid的不同可以获取到不同的时间，如下：

1. static const struct k_clock * const posix_clocks[] = {

2. [CLOCK_REALTIME] = &clock_realtime,

3. [CLOCK_MONOTONIC] = &clock_monotonic,

4. [CLOCK_PROCESS_CPUTIME_ID] = &clock_process,

5. [CLOCK_THREAD_CPUTIME_ID] = &clock_thread,

6. [CLOCK_MONOTONIC_RAW] = &clock_monotonic_raw,

7. [CLOCK_REALTIME_COARSE] = &clock_realtime_coarse,

8. [CLOCK_MONOTONIC_COARSE] = &clock_monotonic_coarse,

9. [CLOCK_BOOTTIME] = &clock_boottime,

10. [CLOCK_REALTIME_ALARM] = &alarm_clock,

11. [CLOCK_BOOTTIME_ALARM] = &alarm_clock,

12. [CLOCK_TAI] = &clock_tai,

13. };

这里的时间的含义是什么，我们获取到的是什么时间，这个问题下面再讨论。

3. 遗留问题

a. vdso的机制：vdso是如何让用户态不必陷入到内核获取到时间的？

b. clock_gettime能够获取到的各类时间有什么不同？

这两个问题可参考下一篇：Linux时间子系统2： clock_gettime的VDSO机制分析-优快云博客

Linux时间子系统1：gettimeofday和clock_gettime实现分析_linux gettimeofday-优快云博客