| /* | |
| * Copyright (C) 2012 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #ifndef ANDROID_COMMON_TIME_SERVER_H | |
| #define ANDROID_COMMON_TIME_SERVER_H | |
| #include <arpa/inet.h> | |
| #include <stdint.h> | |
| #include <sys/socket.h> | |
| #include <common_time/ICommonClock.h> | |
| #include <common_time/local_clock.h> | |
| #include <utils/String8.h> | |
| #include "clock_recovery.h" | |
| #include "common_clock.h" | |
| #include "common_time_server_packets.h" | |
| #include "utils.h" | |
| #define RTT_LOG_SIZE 30 | |
| namespace android { | |
| class CommonClockService; | |
| class CommonTimeConfigService; | |
| /***** time service implementation *****/ | |
| class CommonTimeServer : public Thread { | |
| public: | |
| CommonTimeServer(); | |
| ~CommonTimeServer(); | |
| bool startServices(); | |
| // Common Clock API methods | |
| CommonClock& getCommonClock() { return mCommonClock; } | |
| LocalClock& getLocalClock() { return mLocalClock; } | |
| uint64_t getTimelineID(); | |
| int32_t getEstimatedError(); | |
| ICommonClock::State getState(); | |
| status_t getMasterAddr(struct sockaddr_storage* addr); | |
| status_t isCommonTimeValid(bool* valid, uint32_t* timelineID); | |
| // Config API methods | |
| status_t getMasterElectionPriority(uint8_t *priority); | |
| status_t setMasterElectionPriority(uint8_t priority); | |
| status_t getMasterElectionEndpoint(struct sockaddr_storage *addr); | |
| status_t setMasterElectionEndpoint(const struct sockaddr_storage *addr); | |
| status_t getMasterElectionGroupId(uint64_t *id); | |
| status_t setMasterElectionGroupId(uint64_t id); | |
| status_t getInterfaceBinding(String8& ifaceName); | |
| status_t setInterfaceBinding(const String8& ifaceName); | |
| status_t getMasterAnnounceInterval(int *interval); | |
| status_t setMasterAnnounceInterval(int interval); | |
| status_t getClientSyncInterval(int *interval); | |
| status_t setClientSyncInterval(int interval); | |
| status_t getPanicThreshold(int *threshold); | |
| status_t setPanicThreshold(int threshold); | |
| status_t getAutoDisable(bool *autoDisable); | |
| status_t setAutoDisable(bool autoDisable); | |
| status_t forceNetworklessMasterMode(); | |
| // Method used by the CommonClockService to notify the core service about | |
| // changes in the number of active common clock clients. | |
| void reevaluateAutoDisableState(bool commonClockHasClients); | |
| status_t dumpClockInterface(int fd, const Vector<String16>& args, | |
| size_t activeClients); | |
| status_t dumpConfigInterface(int fd, const Vector<String16>& args); | |
| private: | |
| class PacketRTTLog { | |
| public: | |
| PacketRTTLog() { | |
| resetLog(); | |
| } | |
| void resetLog() { | |
| wrPtr = 0; | |
| logFull = 0; | |
| } | |
| void logTX(int64_t txTime); | |
| void logRX(int64_t txTime, int64_t rxTime); | |
| void dumpLog(int fd, const CommonClock& cclk); | |
| private: | |
| uint32_t wrPtr; | |
| bool logFull; | |
| int64_t txTimes[RTT_LOG_SIZE]; | |
| int64_t rxTimes[RTT_LOG_SIZE]; | |
| }; | |
| bool threadLoop(); | |
| bool runStateMachine_l(); | |
| bool setupSocket_l(); | |
| void assignTimelineID(); | |
| bool assignDeviceID(); | |
| static bool arbitrateMaster(uint64_t deviceID1, uint8_t devicePrio1, | |
| uint64_t deviceID2, uint8_t devicePrio2); | |
| bool handlePacket(); | |
| bool handleWhoIsMasterRequest (const WhoIsMasterRequestPacket* request, | |
| const sockaddr_storage& srcAddr); | |
| bool handleWhoIsMasterResponse(const WhoIsMasterResponsePacket* response, | |
| const sockaddr_storage& srcAddr); | |
| bool handleSyncRequest (const SyncRequestPacket* request, | |
| const sockaddr_storage& srcAddr); | |
| bool handleSyncResponse (const SyncResponsePacket* response, | |
| const sockaddr_storage& srcAddr); | |
| bool handleMasterAnnouncement (const MasterAnnouncementPacket* packet, | |
| const sockaddr_storage& srcAddr); | |
| bool handleTimeout(); | |
| bool handleTimeoutInitial(); | |
| bool handleTimeoutClient(); | |
| bool handleTimeoutMaster(); | |
| bool handleTimeoutRonin(); | |
| bool handleTimeoutWaitForElection(); | |
| bool sendWhoIsMasterRequest(); | |
| bool sendSyncRequest(); | |
| bool sendMasterAnnouncement(); | |
| bool becomeClient(const sockaddr_storage& masterAddr, | |
| uint64_t masterDeviceID, | |
| uint8_t masterDevicePriority, | |
| uint64_t timelineID, | |
| const char* cause); | |
| bool becomeMaster(const char* cause); | |
| bool becomeRonin(const char* cause); | |
| bool becomeWaitForElection(const char* cause); | |
| bool becomeInitial(const char* cause); | |
| void notifyClockSync(); | |
| void notifyClockSyncLoss(); | |
| ICommonClock::State mState; | |
| void setState(ICommonClock::State s); | |
| void clearPendingWakeupEvents_l(); | |
| void wakeupThread_l(); | |
| void cleanupSocket_l(); | |
| void shutdownThread(); | |
| inline uint8_t effectivePriority() const { | |
| return (mMasterPriority & 0x7F) | | |
| (mForceLowPriority ? 0x00 : 0x80); | |
| } | |
| inline bool shouldAutoDisable() const { | |
| return (mAutoDisable && !mCommonClockHasClients); | |
| } | |
| inline void resetSyncStats() { | |
| mClient_SyncRequestPending = false; | |
| mClient_SyncRequestTimeouts = 0; | |
| mClient_SyncsSentToCurMaster = 0; | |
| mClient_SyncRespsRXedFromCurMaster = 0; | |
| mClient_ExpiredSyncRespsRXedFromCurMaster = 0; | |
| mClient_FirstSyncTX = 0; | |
| mClient_LastGoodSyncRX = 0; | |
| mClient_PacketRTTLog.resetLog(); | |
| } | |
| bool shouldPanicNotGettingGoodData(); | |
| // Helper to keep track of the state machine's current timeout | |
| Timeout mCurTimeout; | |
| // common clock, local clock abstraction, and clock recovery loop | |
| CommonClock mCommonClock; | |
| LocalClock mLocalClock; | |
| ClockRecoveryLoop mClockRecovery; | |
| // implementation of ICommonClock | |
| sp<CommonClockService> mICommonClock; | |
| // implementation of ICommonTimeConfig | |
| sp<CommonTimeConfigService> mICommonTimeConfig; | |
| // UDP socket for the time sync protocol | |
| int mSocket; | |
| // eventfd used to wakeup the work thread in response to configuration | |
| // changes. | |
| int mWakeupThreadFD; | |
| // timestamp captured when a packet is received | |
| int64_t mLastPacketRxLocalTime; | |
| // ID of the timeline that this device is following | |
| uint64_t mTimelineID; | |
| // flag for whether the clock has been synced to a timeline | |
| bool mClockSynced; | |
| // flag used to indicate that clients should be considered to be lower | |
| // priority than all of their peers during elections. This flag is set and | |
| // cleared by the state machine. It is set when the client joins a new | |
| // network. If the client had been a master in the old network (or an | |
| // isolated master with no network connectivity) it should defer to any | |
| // masters which may already be on the network. It will be cleared whenever | |
| // the state machine transitions to the master state. | |
| bool mForceLowPriority; | |
| inline void setForceLowPriority(bool val) { | |
| mForceLowPriority = val; | |
| if (mState == ICommonClock::STATE_MASTER) | |
| mClient_MasterDevicePriority = effectivePriority(); | |
| } | |
| // Lock to synchronize access to internal state and configuration. | |
| Mutex mLock; | |
| // Flag updated by the common clock service to indicate that it does or does | |
| // not currently have registered clients. When the the auto disable flag is | |
| // cleared on the common time service, the service will participate in | |
| // network synchronization whenever it has a valid network interface to bind | |
| // to. When the auto disable flag is set on the common time service, it | |
| // will only participate in network synchronization when it has both a valid | |
| // interface AND currently active common clock clients. | |
| bool mCommonClockHasClients; | |
| // Internal logs used for dumpsys. | |
| LogRing mStateChangeLog; | |
| LogRing mElectionLog; | |
| LogRing mBadPktLog; | |
| // Configuration info | |
| struct sockaddr_storage mMasterElectionEP; // Endpoint over which we conduct master election | |
| String8 mBindIface; // Endpoint for the service to bind to. | |
| bool mBindIfaceValid; // whether or not the bind Iface is valid. | |
| bool mBindIfaceDirty; // whether or not the bind Iface is valid. | |
| struct sockaddr_storage mMasterEP; // Endpoint of our current master (if any) | |
| bool mMasterEPValid; | |
| uint64_t mDeviceID; // unique ID of this device | |
| uint64_t mSyncGroupID; // synchronization group ID of this device. | |
| uint8_t mMasterPriority; // Priority of this device in master election. | |
| uint32_t mMasterAnnounceIntervalMs; | |
| uint32_t mSyncRequestIntervalMs; | |
| uint32_t mPanicThresholdUsec; | |
| bool mAutoDisable; | |
| // Config defaults. | |
| static const char* kDefaultMasterElectionAddr; | |
| static const uint16_t kDefaultMasterElectionPort; | |
| static const uint64_t kDefaultSyncGroupID; | |
| static const uint8_t kDefaultMasterPriority; | |
| static const uint32_t kDefaultMasterAnnounceIntervalMs; | |
| static const uint32_t kDefaultSyncRequestIntervalMs; | |
| static const uint32_t kDefaultPanicThresholdUsec; | |
| static const bool kDefaultAutoDisable; | |
| // Priority mask and shift fields. | |
| static const uint64_t kDeviceIDMask; | |
| static const uint8_t kDevicePriorityMask; | |
| static const uint8_t kDevicePriorityHiLowBit; | |
| static const uint32_t kDevicePriorityShift; | |
| // Unconfgurable constants | |
| static const int kSetupRetryTimeoutMs; | |
| static const int64_t kNoGoodDataPanicThresholdUsec; | |
| static const uint32_t kRTTDiscardPanicThreshMultiplier; | |
| /*** status while in the Initial state ***/ | |
| int mInitial_WhoIsMasterRequestTimeouts; | |
| static const int kInitial_NumWhoIsMasterRetries; | |
| static const int kInitial_WhoIsMasterTimeoutMs; | |
| /*** status while in the Client state ***/ | |
| uint64_t mClient_MasterDeviceID; | |
| uint8_t mClient_MasterDevicePriority; | |
| bool mClient_SyncRequestPending; | |
| int mClient_SyncRequestTimeouts; | |
| uint32_t mClient_SyncsSentToCurMaster; | |
| uint32_t mClient_SyncRespsRXedFromCurMaster; | |
| uint32_t mClient_ExpiredSyncRespsRXedFromCurMaster; | |
| int64_t mClient_FirstSyncTX; | |
| int64_t mClient_LastGoodSyncRX; | |
| PacketRTTLog mClient_PacketRTTLog; | |
| static const int kClient_NumSyncRequestRetries; | |
| /*** status while in the Master state ***/ | |
| static const uint32_t kDefaultMaster_AnnouncementIntervalMs; | |
| /*** status while in the Ronin state ***/ | |
| int mRonin_WhoIsMasterRequestTimeouts; | |
| static const int kRonin_NumWhoIsMasterRetries; | |
| static const int kRonin_WhoIsMasterTimeoutMs; | |
| /*** status while in the WaitForElection state ***/ | |
| static const int kWaitForElection_TimeoutMs; | |
| static const int kInfiniteTimeout; | |
| static const char* stateToString(ICommonClock::State s); | |
| static void sockaddrToString(const sockaddr_storage& addr, bool addrValid, | |
| char* buf, size_t bufLen); | |
| static bool sockaddrMatch(const sockaddr_storage& a1, | |
| const sockaddr_storage& a2, | |
| bool matchAddressOnly); | |
| }; | |
| } // namespace android | |
| #endif // ANDROID_COMMON_TIME_SERVER_H |