Getting iOS system uptime, that doesn't pause when asleep

I think I worked it out.

time() carries on incrementing while the device is asleep, but of course can be manipulated by the operating system or user. However, the Kernel boottime (a timestamp of when the system last booted) also changes when the system clock is changed, therefore even though both these values are not fixed, the offset between them is.

#include <sys/sysctl.h>- (time_t)uptime{    struct timeval boottime;    int mib[2] = {CTL_KERN, KERN_BOOTTIME};    size_t size = sizeof(boottime);    time_t now;    time_t uptime = -1;    (void)time(&now);    if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 && boottime.tv_sec != 0) {        uptime = now - boottime.tv_sec;    }    return uptime;}

As said in one of the comments, POSIX's clock_gettime() was implemented in iOS 10 and macOS 10.12. When used with the CLOCK_MONOTONIC argument, it does seem to return the uptime value. However, this is not guaranteed by the documentation:

For this clock, the value returned by clock_gettime() represents the amount of time (in seconds and nanoseconds) since an unspecified point in the past (for example, system start-up time, or the Epoch). This point does not change after system start-up time.

And an extract from the corresponding macOS man page:

CLOCK_MONOTONIC clock that increments monotonically, tracking the time since an arbitrary point, and will continue to increment while the system is asleep.

CLOCK_MONOTONIC_RAW clock that increments monotonically, tracking the time since an arbitrary point like CLOCK_MONOTONIC. However, this clock is unaffected by frequency or time adjustments. It should not be compared to other system time sources.

CLOCK_MONOTONIC_RAW_APPROX like CLOCK_MONOTONIC_RAW, but reads a value cached by the system at context switch. This can be read faster, but at a loss of accuracy as it may return values that are milliseconds old.

CLOCK_UPTIME_RAW clock that increments monotonically, in the same manner as CLOCK_MONOTONIC_RAW, but that does not increment while the system is asleep. The returned value is identical to the result of mach_absolute_time() after the appropriate mach_timebase conversion is applied.

Note that CLOCK_MONOTONIC returns with microsecond precision while CLOCK_MONOTONIC_RAW with nanosecond precision.

Swift code:

func uptime() -> timespec {    var uptime = timespec()    if 0 != clock_gettime(CLOCK_MONOTONIC_RAW, &uptime) {        fatalError("Could not execute clock_gettime, errno: \(errno)")    }    return uptime}print(uptime()) // timespec(tv_sec: 636705, tv_nsec: 750700397)

For those still interested in getting the kernel's boot time in Swift:

func kernelBootTime() -> timeval {    var mib = [ CTL_KERN, KERN_BOOTTIME ]    var bootTime = timeval()    var bootTimeSize = MemoryLayout<timeval>.size    if 0 != sysctl(&mib, UInt32(mib.count), &bootTime, &bootTimeSize, nil, 0) {        fatalError("Could not get boot time, errno: \(errno)")    }    return bootTime}print(kernelBootTime()) // timeval(tv_sec: 1499259206, tv_usec: 122778)

There's a race condition in all examples listed: if there's a time change (NTP or user-modified), the code will race and the clock is no longer monotonic.

The correct implementation is:

#include <sys/sysctl.h>static int64_t us_since_boot() {    struct timeval boottime;    int mib[2] = {CTL_KERN, KERN_BOOTTIME};    size_t size = sizeof(boottime);    int rc = sysctl(mib, 2, &boottime, &size, NULL, 0);    if (rc != 0) {      return 0;    }    return (int64_t)boottime.tv_sec * 1000000 + (int64_t)boottime.tv_usec;}- (int64_t)us_uptime{    int64_t before_now;    int64_t after_now;    struct timeval now;    after_now = us_since_boot();    do {        before_now = after_now;        gettimeofday(&now, NULL);        after_now = us_since_boot();    } while (after_now != before_now);    return (int64_t)now.tv_sec * 1000000 + (int64_t)now.tv_usec - before_now;}