1 /*
2 * Copyright (C) 2012 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 * A service that exchanges time synchronization information between
19 * a master that defines a timeline and clients that follow the timeline.
20 */
21
22 #define LOG_TAG "common_time"
23 #include <utils/Log.h>
24
25 #include <binder/IServiceManager.h>
26 #include <binder/IPCThreadState.h>
27
28 #include "common_time_server.h"
29
30 #include <inttypes.h>
31
32 namespace android {
33
34 //
35 // Clock API
36 //
getTimelineID()37 uint64_t CommonTimeServer::getTimelineID() {
38 AutoMutex _lock(&mLock);
39 return mTimelineID;
40 }
41
getState()42 ICommonClock::State CommonTimeServer::getState() {
43 AutoMutex _lock(&mLock);
44 return mState;
45 }
46
getMasterAddr(struct sockaddr_storage * addr)47 status_t CommonTimeServer::getMasterAddr(struct sockaddr_storage* addr) {
48 AutoMutex _lock(&mLock);
49 if (mMasterEPValid) {
50 memcpy(addr, &mMasterEP, sizeof(*addr));
51 return OK;
52 }
53
54 return UNKNOWN_ERROR;
55 }
56
getEstimatedError()57 int32_t CommonTimeServer::getEstimatedError() {
58 AutoMutex _lock(&mLock);
59
60 if (ICommonClock::STATE_MASTER == mState)
61 return 0;
62
63 if (!mClockSynced)
64 return ICommonClock::kErrorEstimateUnknown;
65
66 return mClockRecovery.getLastErrorEstimate();
67 }
68
isCommonTimeValid(bool * valid,uint32_t * timelineID)69 status_t CommonTimeServer::isCommonTimeValid(bool* valid,
70 uint32_t* timelineID) {
71 AutoMutex _lock(&mLock);
72 *valid = mCommonClock.isValid();
73 *timelineID = mTimelineID;
74 return OK;
75 }
76
77 //
78 // Config API
79 //
getMasterElectionPriority(uint8_t * priority)80 status_t CommonTimeServer::getMasterElectionPriority(uint8_t *priority) {
81 AutoMutex _lock(&mLock);
82 *priority = mMasterPriority;
83 return OK;
84 }
85
setMasterElectionPriority(uint8_t priority)86 status_t CommonTimeServer::setMasterElectionPriority(uint8_t priority) {
87 AutoMutex _lock(&mLock);
88
89 if (priority > 0x7F)
90 return BAD_VALUE;
91
92 mMasterPriority = priority;
93 return OK;
94 }
95
getMasterElectionEndpoint(struct sockaddr_storage * addr)96 status_t CommonTimeServer::getMasterElectionEndpoint(
97 struct sockaddr_storage *addr) {
98 AutoMutex _lock(&mLock);
99 memcpy(addr, &mMasterElectionEP, sizeof(*addr));
100 return OK;
101 }
102
setMasterElectionEndpoint(const struct sockaddr_storage * addr)103 status_t CommonTimeServer::setMasterElectionEndpoint(
104 const struct sockaddr_storage *addr) {
105 AutoMutex _lock(&mLock);
106
107 if (!addr)
108 return BAD_VALUE;
109
110 // TODO: add proper support for IPv6
111 if (addr->ss_family != AF_INET)
112 return BAD_VALUE;
113
114 // Only multicast and broadcast endpoints with explicit ports are allowed.
115 uint16_t ipv4Port = ntohs(
116 reinterpret_cast<const struct sockaddr_in*>(addr)->sin_port);
117 if (!ipv4Port)
118 return BAD_VALUE;
119
120 uint32_t ipv4Addr = ntohl(
121 reinterpret_cast<const struct sockaddr_in*>(addr)->sin_addr.s_addr);
122 if ((ipv4Addr != 0xFFFFFFFF) && (0xE0000000 != (ipv4Addr & 0xF0000000)))
123 return BAD_VALUE;
124
125 memcpy(&mMasterElectionEP, addr, sizeof(mMasterElectionEP));
126
127 // Force a rebind in order to change election enpoints.
128 mBindIfaceDirty = true;
129 wakeupThread_l();
130 return OK;
131 }
132
getMasterElectionGroupId(uint64_t * id)133 status_t CommonTimeServer::getMasterElectionGroupId(uint64_t *id) {
134 AutoMutex _lock(&mLock);
135 *id = mSyncGroupID;
136 return OK;
137 }
138
setMasterElectionGroupId(uint64_t id)139 status_t CommonTimeServer::setMasterElectionGroupId(uint64_t id) {
140 AutoMutex _lock(&mLock);
141 mSyncGroupID = id;
142 return OK;
143 }
144
getInterfaceBinding(String8 & ifaceName)145 status_t CommonTimeServer::getInterfaceBinding(String8& ifaceName) {
146 AutoMutex _lock(&mLock);
147 if (!mBindIfaceValid)
148 return INVALID_OPERATION;
149 ifaceName = mBindIface;
150 return OK;
151 }
152
setInterfaceBinding(const String8 & ifaceName)153 status_t CommonTimeServer::setInterfaceBinding(const String8& ifaceName) {
154 AutoMutex _lock(&mLock);
155
156 mBindIfaceDirty = true;
157 if (ifaceName.size()) {
158 mBindIfaceValid = true;
159 mBindIface = ifaceName;
160 } else {
161 mBindIfaceValid = false;
162 mBindIface.clear();
163 }
164
165 wakeupThread_l();
166 return OK;
167 }
168
getMasterAnnounceInterval(int * interval)169 status_t CommonTimeServer::getMasterAnnounceInterval(int *interval) {
170 AutoMutex _lock(&mLock);
171 *interval = mMasterAnnounceIntervalMs;
172 return OK;
173 }
174
setMasterAnnounceInterval(int interval)175 status_t CommonTimeServer::setMasterAnnounceInterval(int interval) {
176 AutoMutex _lock(&mLock);
177
178 if (interval > (6 *3600000)) // Max interval is once every 6 hrs
179 return BAD_VALUE;
180
181 if (interval < 500) // Min interval is once per 0.5 seconds
182 return BAD_VALUE;
183
184 mMasterAnnounceIntervalMs = interval;
185 if (ICommonClock::STATE_MASTER == mState) {
186 int pendingTimeout = mCurTimeout.msecTillTimeout();
187 if ((kInfiniteTimeout == pendingTimeout) ||
188 (pendingTimeout > interval)) {
189 mCurTimeout.setTimeout(mMasterAnnounceIntervalMs);
190 wakeupThread_l();
191 }
192 }
193
194 return OK;
195 }
196
getClientSyncInterval(int * interval)197 status_t CommonTimeServer::getClientSyncInterval(int *interval) {
198 AutoMutex _lock(&mLock);
199 *interval = mSyncRequestIntervalMs;
200 return OK;
201 }
202
setClientSyncInterval(int interval)203 status_t CommonTimeServer::setClientSyncInterval(int interval) {
204 AutoMutex _lock(&mLock);
205
206 if (interval > (3600000)) // Max interval is once every 60 min
207 return BAD_VALUE;
208
209 if (interval < 250) // Min interval is once per 0.25 seconds
210 return BAD_VALUE;
211
212 mSyncRequestIntervalMs = interval;
213 if (ICommonClock::STATE_CLIENT == mState) {
214 int pendingTimeout = mCurTimeout.msecTillTimeout();
215 if ((kInfiniteTimeout == pendingTimeout) ||
216 (pendingTimeout > interval)) {
217 mCurTimeout.setTimeout(mSyncRequestIntervalMs);
218 wakeupThread_l();
219 }
220 }
221
222 return OK;
223 }
224
getPanicThreshold(int * threshold)225 status_t CommonTimeServer::getPanicThreshold(int *threshold) {
226 AutoMutex _lock(&mLock);
227 *threshold = mPanicThresholdUsec;
228 return OK;
229 }
230
setPanicThreshold(int threshold)231 status_t CommonTimeServer::setPanicThreshold(int threshold) {
232 AutoMutex _lock(&mLock);
233
234 if (threshold < 1000) // Min threshold is 1mSec
235 return BAD_VALUE;
236
237 mPanicThresholdUsec = threshold;
238 return OK;
239 }
240
getAutoDisable(bool * autoDisable)241 status_t CommonTimeServer::getAutoDisable(bool *autoDisable) {
242 AutoMutex _lock(&mLock);
243 *autoDisable = mAutoDisable;
244 return OK;
245 }
246
setAutoDisable(bool autoDisable)247 status_t CommonTimeServer::setAutoDisable(bool autoDisable) {
248 AutoMutex _lock(&mLock);
249 mAutoDisable = autoDisable;
250 wakeupThread_l();
251 return OK;
252 }
253
forceNetworklessMasterMode()254 status_t CommonTimeServer::forceNetworklessMasterMode() {
255 AutoMutex _lock(&mLock);
256
257 // Can't force networkless master mode if we are currently bound to a
258 // network.
259 if (mSocket >= 0)
260 return INVALID_OPERATION;
261
262 becomeMaster("force networkless");
263
264 return OK;
265 }
266
reevaluateAutoDisableState(bool commonClockHasClients)267 void CommonTimeServer::reevaluateAutoDisableState(bool commonClockHasClients) {
268 AutoMutex _lock(&mLock);
269 bool needWakeup = (mAutoDisable && mMasterEPValid &&
270 (commonClockHasClients != mCommonClockHasClients));
271
272 mCommonClockHasClients = commonClockHasClients;
273
274 if (needWakeup) {
275 ALOGI("Waking up service, auto-disable is engaged and service now has%s"
276 " clients", mCommonClockHasClients ? "" : " no");
277 wakeupThread_l();
278 }
279 }
280
281 #define dump_printf(a, b...) do { \
282 int res; \
283 res = snprintf(buffer, sizeof(buffer), a, b); \
284 buffer[sizeof(buffer) - 1] = 0; \
285 if (res > 0) \
286 write(fd, buffer, res); \
287 } while (0)
288 #define checked_percentage(a, b) ((0 == (b)) ? 0.0f : ((100.0f * (a)) / (b)))
289
dumpClockInterface(int fd,const Vector<String16> &,size_t activeClients)290 status_t CommonTimeServer::dumpClockInterface(int fd,
291 const Vector<String16>& /* args */,
292 size_t activeClients) {
293 AutoMutex _lock(&mLock);
294 const size_t SIZE = 256;
295 char buffer[SIZE];
296
297 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
298 snprintf(buffer, SIZE, "Permission Denial: "
299 "can't dump CommonClockService from pid=%d, uid=%d\n",
300 IPCThreadState::self()->getCallingPid(),
301 IPCThreadState::self()->getCallingUid());
302 write(fd, buffer, strlen(buffer));
303 } else {
304 int64_t commonTime;
305 int64_t localTime;
306 bool synced;
307 char maStr[64];
308
309 localTime = mLocalClock.getLocalTime();
310 synced = (OK == mCommonClock.localToCommon(localTime, &commonTime));
311 sockaddrToString(mMasterEP, mMasterEPValid, maStr, sizeof(maStr));
312
313 dump_printf("Common Clock Service Status\nLocal time : %" PRId64 "\n",
314 localTime);
315
316 if (synced)
317 dump_printf("Common time : %" PRId64 "\n", commonTime);
318 else
319 dump_printf("Common time : %s\n", "not synced");
320
321 dump_printf("Timeline ID : %016" PRIu64 "\n", mTimelineID);
322 dump_printf("State : %s\n", stateToString(mState));
323 dump_printf("Master Addr : %s\n", maStr);
324
325
326 if (synced) {
327 int32_t est = (ICommonClock::STATE_MASTER != mState)
328 ? mClockRecovery.getLastErrorEstimate()
329 : 0;
330 dump_printf("Error Est. : %.3f msec\n",
331 static_cast<float>(est) / 1000.0);
332 } else {
333 dump_printf("Error Est. : %s\n", "unknown");
334 }
335
336 dump_printf("Syncs TXes : %u\n", mClient_SyncsSentToCurMaster);
337 dump_printf("Syncs RXes : %u (%.2f%%)\n",
338 mClient_SyncRespsRXedFromCurMaster,
339 checked_percentage(
340 mClient_SyncRespsRXedFromCurMaster,
341 mClient_SyncsSentToCurMaster));
342 dump_printf("RXs Expired : %u (%.2f%%)\n",
343 mClient_ExpiredSyncRespsRXedFromCurMaster,
344 checked_percentage(
345 mClient_ExpiredSyncRespsRXedFromCurMaster,
346 mClient_SyncsSentToCurMaster));
347
348 if (!mClient_LastGoodSyncRX) {
349 dump_printf("Last Good RX : %s\n", "unknown");
350 } else {
351 int64_t localDelta, usecDelta;
352 localDelta = localTime - mClient_LastGoodSyncRX;
353 usecDelta = mCommonClock.localDurationToCommonDuration(localDelta);
354 dump_printf("Last Good RX : %" PRId64 " uSec ago\n", usecDelta);
355 }
356
357 dump_printf("Active Clients : %zu\n", activeClients);
358 mClient_PacketRTTLog.dumpLog(fd, mCommonClock);
359 mStateChangeLog.dumpLog(fd);
360 mElectionLog.dumpLog(fd);
361 mBadPktLog.dumpLog(fd);
362 }
363
364 return NO_ERROR;
365 }
366
dumpConfigInterface(int fd,const Vector<String16> &)367 status_t CommonTimeServer::dumpConfigInterface(int fd,
368 const Vector<String16>& /* args */) {
369 AutoMutex _lock(&mLock);
370 const size_t SIZE = 256;
371 char buffer[SIZE];
372
373 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
374 snprintf(buffer, SIZE, "Permission Denial: "
375 "can't dump CommonTimeConfigService from pid=%d, uid=%d\n",
376 IPCThreadState::self()->getCallingPid(),
377 IPCThreadState::self()->getCallingUid());
378 write(fd, buffer, strlen(buffer));
379 } else {
380 char meStr[64];
381
382 sockaddrToString(mMasterElectionEP, true, meStr, sizeof(meStr));
383
384 dump_printf("Common Time Config Service Status\n"
385 "Bound Interface : %s\n",
386 mBindIfaceValid ? mBindIface.string() : "<unbound>");
387 dump_printf("Master Election Endpoint : %s\n", meStr);
388 dump_printf("Master Election Group ID : %016" PRIu64 "\n", mSyncGroupID);
389 dump_printf("Master Announce Interval : %d mSec\n",
390 mMasterAnnounceIntervalMs);
391 dump_printf("Client Sync Interval : %d mSec\n",
392 mSyncRequestIntervalMs);
393 dump_printf("Panic Threshold : %d uSec\n",
394 mPanicThresholdUsec);
395 dump_printf("Base ME Prio : 0x%02x\n",
396 static_cast<uint32_t>(mMasterPriority));
397 dump_printf("Effective ME Prio : 0x%02x\n",
398 static_cast<uint32_t>(effectivePriority()));
399 dump_printf("Auto Disable Allowed : %s\n",
400 mAutoDisable ? "yes" : "no");
401 dump_printf("Auto Disable Engaged : %s\n",
402 shouldAutoDisable() ? "yes" : "no");
403 }
404
405 return NO_ERROR;
406 }
407
dumpLog(int fd,const CommonClock & cclk)408 void CommonTimeServer::PacketRTTLog::dumpLog(int fd, const CommonClock& cclk) {
409 const size_t SIZE = 256;
410 char buffer[SIZE];
411 uint32_t avail = !logFull ? wrPtr : RTT_LOG_SIZE;
412
413 if (!avail)
414 return;
415
416 dump_printf("\nPacket Log (%d entries)\n", avail);
417
418 uint32_t ndx = 0;
419 uint32_t i = logFull ? wrPtr : 0;
420 do {
421 if (rxTimes[i]) {
422 int64_t delta = rxTimes[i] - txTimes[i];
423 int64_t deltaUsec = cclk.localDurationToCommonDuration(delta);
424 dump_printf("pkt[%2d] : localTX %12" PRId64 " localRX %12" PRId64 " "
425 "(%.3f msec RTT)\n",
426 ndx, txTimes[i], rxTimes[i],
427 static_cast<float>(deltaUsec) / 1000.0);
428 } else {
429 dump_printf("pkt[%2d] : localTX %12" PRId64 " localRX never\n",
430 ndx, txTimes[i]);
431 }
432 i = (i + 1) % RTT_LOG_SIZE;
433 ndx++;
434 } while (i != wrPtr);
435 }
436
437 #undef dump_printf
438 #undef checked_percentage
439
440 } // namespace android
441