1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 18/* 19 * System clock functions. 20 */ 21 22#ifdef HAVE_ANDROID_OS 23#include <linux/ioctl.h> 24#include <linux/rtc.h> 25#include <utils/Atomic.h> 26#include <linux/android_alarm.h> 27#endif 28 29#include <sys/time.h> 30#include <limits.h> 31#include <fcntl.h> 32#include <errno.h> 33#include <string.h> 34 35#include <utils/SystemClock.h> 36#include <utils/Timers.h> 37 38#define LOG_TAG "SystemClock" 39#include <utils/Log.h> 40 41namespace android { 42 43/* 44 * native public static long uptimeMillis(); 45 */ 46int64_t uptimeMillis() 47{ 48 int64_t when = systemTime(SYSTEM_TIME_MONOTONIC); 49 return (int64_t) nanoseconds_to_milliseconds(when); 50} 51 52/* 53 * native public static long elapsedRealtime(); 54 */ 55int64_t elapsedRealtime() 56{ 57 return nanoseconds_to_milliseconds(elapsedRealtimeNano()); 58} 59 60#define METHOD_CLOCK_GETTIME 0 61#define METHOD_IOCTL 1 62#define METHOD_SYSTEMTIME 2 63 64/* 65 * To debug/verify the timestamps returned by the kernel, change 66 * DEBUG_TIMESTAMP to 1 and call the timestamp routine from a single thread 67 * in the test program. b/10899829 68 */ 69#define DEBUG_TIMESTAMP 0 70 71static const char *gettime_method_names[] = { 72 "clock_gettime", 73 "ioctl", 74 "systemTime", 75}; 76 77#if DEBUG_TIMESTAMP 78static inline void checkTimeStamps(int64_t timestamp, 79 int64_t volatile *prevTimestampPtr, 80 int volatile *prevMethodPtr, 81 int curMethod) 82{ 83 /* 84 * Disable the check for SDK since the prebuilt toolchain doesn't contain 85 * gettid, and int64_t is different on the ARM platform 86 * (ie long vs long long). 87 */ 88#ifdef ARCH_ARM 89 int64_t prevTimestamp = *prevTimestampPtr; 90 int prevMethod = *prevMethodPtr; 91 92 if (timestamp < prevTimestamp) { 93 ALOGW("time going backwards: prev %lld(%s) vs now %lld(%s), tid=%d", 94 prevTimestamp, gettime_method_names[prevMethod], 95 timestamp, gettime_method_names[curMethod], 96 gettid()); 97 } 98 // NOTE - not atomic and may generate spurious warnings if the 64-bit 99 // write is interrupted or not observed as a whole. 100 *prevTimestampPtr = timestamp; 101 *prevMethodPtr = curMethod; 102#endif 103} 104#else 105#define checkTimeStamps(timestamp, prevTimestampPtr, prevMethodPtr, curMethod) 106#endif 107 108/* 109 * native public static long elapsedRealtimeNano(); 110 */ 111int64_t elapsedRealtimeNano() 112{ 113#ifdef HAVE_ANDROID_OS 114 struct timespec ts; 115 int result; 116 int64_t timestamp; 117#if DEBUG_TIMESTAMP 118 static volatile int64_t prevTimestamp; 119 static volatile int prevMethod; 120#endif 121 122#if 0 123 /* 124 * b/7100774 125 * clock_gettime appears to have clock skews and can sometimes return 126 * backwards values. Disable its use until we find out what's wrong. 127 */ 128 result = clock_gettime(CLOCK_BOOTTIME, &ts); 129 if (result == 0) { 130 timestamp = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec; 131 checkTimeStamps(timestamp, &prevTimestamp, &prevMethod, 132 METHOD_CLOCK_GETTIME); 133 return timestamp; 134 } 135#endif 136 137 // CLOCK_BOOTTIME doesn't exist, fallback to /dev/alarm 138 static int s_fd = -1; 139 140 if (s_fd == -1) { 141 int fd = open("/dev/alarm", O_RDONLY); 142 if (android_atomic_cmpxchg(-1, fd, &s_fd)) { 143 close(fd); 144 } 145 } 146 147 result = ioctl(s_fd, 148 ANDROID_ALARM_GET_TIME(ANDROID_ALARM_ELAPSED_REALTIME), &ts); 149 150 if (result == 0) { 151 timestamp = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec; 152 checkTimeStamps(timestamp, &prevTimestamp, &prevMethod, METHOD_IOCTL); 153 return timestamp; 154 } 155 156 // XXX: there was an error, probably because the driver didn't 157 // exist ... this should return 158 // a real error, like an exception! 159 timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 160 checkTimeStamps(timestamp, &prevTimestamp, &prevMethod, 161 METHOD_SYSTEMTIME); 162 return timestamp; 163#else 164 return systemTime(SYSTEM_TIME_MONOTONIC); 165#endif 166} 167 168}; // namespace android 169