services/common_time/common_time_server.h

   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 #ifndef ANDROID_COMMON_TIME_SERVER_H
  18 #define ANDROID_COMMON_TIME_SERVER_H
  19
  20 #include <arpa/inet.h>
  21 #include <stdint.h>
  22 #include <sys/socket.h>
  23
  24 #include <common_time/ICommonClock.h>
  25 #include <common_time/local_clock.h>
  26 #include <utils/String8.h>
  27
  28 #include "clock_recovery.h"
  29 #include "common_clock.h"
  30 #include "common_time_server_packets.h"
  31 #include "utils.h"
  32
  33 #define RTT_LOG_SIZE 30
  34
  35 namespace android {
  36
  37 class CommonClockService;
  38 class CommonTimeConfigService;
  39
  40 /***** time service implementation *****/
  41
  42 class CommonTimeServer : public Thread {
  43   public:
  44     CommonTimeServer();
  45     ~CommonTimeServer();
  46
  47     bool startServices();
  48
  49     // Common Clock API methods
  50     CommonClock&        getCommonClock()        { return mCommonClock; }
  51     LocalClock&         getLocalClock()         { return mLocalClock; }
  52     uint64_t            getTimelineID();
  53     int32_t             getEstimatedError();
  54     ICommonClock::State getState();
  55     status_t            getMasterAddr(struct sockaddr_storage* addr);
  56     status_t            isCommonTimeValid(bool* valid, uint32_t* timelineID);
  57
  58     // Config API methods
  59     status_t getMasterElectionPriority(uint8_t *priority);
  60     status_t setMasterElectionPriority(uint8_t priority);
  61     status_t getMasterElectionEndpoint(struct sockaddr_storage *addr);
  62     status_t setMasterElectionEndpoint(const struct sockaddr_storage *addr);
  63     status_t getMasterElectionGroupId(uint64_t *id);
  64     status_t setMasterElectionGroupId(uint64_t id);
  65     status_t getInterfaceBinding(String8& ifaceName);
  66     status_t setInterfaceBinding(const String8& ifaceName);
  67     status_t getMasterAnnounceInterval(int *interval);
  68     status_t setMasterAnnounceInterval(int interval);
  69     status_t getClientSyncInterval(int *interval);
  70     status_t setClientSyncInterval(int interval);
  71     status_t getPanicThreshold(int *threshold);
  72     status_t setPanicThreshold(int threshold);
  73     status_t getAutoDisable(bool *autoDisable);
  74     status_t setAutoDisable(bool autoDisable);
  75     status_t forceNetworklessMasterMode();
  76
  77     // Method used by the CommonClockService to notify the core service about
  78     // changes in the number of active common clock clients.
  79     void reevaluateAutoDisableState(bool commonClockHasClients);
  80
  81     status_t dumpClockInterface(int fd, const Vector<String16>& args,
  82                                 size_t activeClients);
  83     status_t dumpConfigInterface(int fd, const Vector<String16>& args);
  84
  85   private:
  86     class PacketRTTLog {
  87       public:
  88         PacketRTTLog() {
  89             resetLog();
  90         }
  91
  92         void resetLog() {
  93             wrPtr = 0;
  94             logFull = 0;
  95         }
  96
  97         void logTX(int64_t txTime);
  98         void logRX(int64_t txTime, int64_t rxTime);
  99         void dumpLog(int fd, const CommonClock& cclk);
 100
 101       private:
 102         uint32_t wrPtr;
 103         bool logFull;
 104         int64_t txTimes[RTT_LOG_SIZE];
 105         int64_t rxTimes[RTT_LOG_SIZE];
 106     };
 107
 108     bool threadLoop();
 109
 110     bool runStateMachine_l();
 111     bool setupSocket_l();
 112
 113     void assignTimelineID();
 114     bool assignDeviceID();
 115
 116     static bool arbitrateMaster(uint64_t deviceID1, uint8_t devicePrio1,
 117                                 uint64_t deviceID2, uint8_t devicePrio2);
 118
 119     bool handlePacket();
 120     bool handleWhoIsMasterRequest (const WhoIsMasterRequestPacket* request,
 121                                    const sockaddr_storage& srcAddr);
 122     bool handleWhoIsMasterResponse(const WhoIsMasterResponsePacket* response,
 123                                    const sockaddr_storage& srcAddr);
 124     bool handleSyncRequest        (const SyncRequestPacket* request,
 125                                    const sockaddr_storage& srcAddr);
 126     bool handleSyncResponse       (const SyncResponsePacket* response,
 127                                    const sockaddr_storage& srcAddr);
 128     bool handleMasterAnnouncement (const MasterAnnouncementPacket* packet,
 129                                    const sockaddr_storage& srcAddr);
 130
 131     bool handleTimeout();
 132     bool handleTimeoutInitial();
 133     bool handleTimeoutClient();
 134     bool handleTimeoutMaster();
 135     bool handleTimeoutRonin();
 136     bool handleTimeoutWaitForElection();
 137
 138     bool sendWhoIsMasterRequest();
 139     bool sendSyncRequest();
 140     bool sendMasterAnnouncement();
 141
 142     bool becomeClient(const sockaddr_storage& masterAddr,
 143                       uint64_t masterDeviceID,
 144                       uint8_t  masterDevicePriority,
 145                       uint64_t timelineID,
 146                       const char* cause);
 147     bool becomeMaster(const char* cause);
 148     bool becomeRonin(const char* cause);
 149     bool becomeWaitForElection(const char* cause);
 150     bool becomeInitial(const char* cause);
 151
 152     void notifyClockSync();
 153     void notifyClockSyncLoss();
 154
 155     ICommonClock::State mState;
 156     void setState(ICommonClock::State s);
 157
 158     void clearPendingWakeupEvents_l();
 159     void wakeupThread_l();
 160     void cleanupSocket_l();
 161     void shutdownThread();
 162
 163     inline uint8_t effectivePriority() const {
 164         return (mMasterPriority & 0x7F) |
 165                (mForceLowPriority ? 0x00 : 0x80);
 166     }
 167
 168     inline bool shouldAutoDisable() const {
 169         return (mAutoDisable && !mCommonClockHasClients);
 170     }
 171
 172     inline void resetSyncStats() {
 173         mClient_SyncRequestPending = false;
 174         mClient_SyncRequestTimeouts = 0;
 175         mClient_SyncsSentToCurMaster = 0;
 176         mClient_SyncRespsRXedFromCurMaster = 0;
 177         mClient_ExpiredSyncRespsRXedFromCurMaster = 0;
 178         mClient_FirstSyncTX = 0;
 179         mClient_LastGoodSyncRX = 0;
 180         mClient_PacketRTTLog.resetLog();
 181     }
 182
 183     bool shouldPanicNotGettingGoodData();
 184
 185     // Helper to keep track of the state machine's current timeout
 186     Timeout mCurTimeout;
 187
 188     // common clock, local clock abstraction, and clock recovery loop
 189     CommonClock mCommonClock;
 190     LocalClock mLocalClock;
 191     ClockRecoveryLoop mClockRecovery;
 192
 193     // implementation of ICommonClock
 194     sp<CommonClockService> mICommonClock;
 195
 196     // implementation of ICommonTimeConfig
 197     sp<CommonTimeConfigService> mICommonTimeConfig;
 198
 199     // UDP socket for the time sync protocol
 200     int mSocket;
 201
 202     // eventfd used to wakeup the work thread in response to configuration
 203     // changes.
 204     int mWakeupThreadFD;
 205
 206     // timestamp captured when a packet is received
 207     int64_t mLastPacketRxLocalTime;
 208
 209     // ID of the timeline that this device is following
 210     uint64_t mTimelineID;
 211
 212     // flag for whether the clock has been synced to a timeline
 213     bool mClockSynced;
 214
 215     // flag used to indicate that clients should be considered to be lower
 216     // priority than all of their peers during elections.  This flag is set and
 217     // cleared by the state machine.  It is set when the client joins a new
 218     // network.  If the client had been a master in the old network (or an
 219     // isolated master with no network connectivity) it should defer to any
 220     // masters which may already be on the network.  It will be cleared whenever
 221     // the state machine transitions to the master state.
 222     bool mForceLowPriority;
 223     inline void setForceLowPriority(bool val) {
 224         mForceLowPriority = val;
 225         if (mState == ICommonClock::STATE_MASTER)
 226             mClient_MasterDevicePriority = effectivePriority();
 227     }
 228
 229     // Lock to synchronize access to internal state and configuration.
 230     Mutex mLock;
 231
 232     // Flag updated by the common clock service to indicate that it does or does
 233     // not currently have registered clients.  When the the auto disable flag is
 234     // cleared on the common time service, the service will participate in
 235     // network synchronization whenever it has a valid network interface to bind
 236     // to.  When the auto disable flag is set on the common time service, it
 237     // will only participate in network synchronization when it has both a valid
 238     // interface AND currently active common clock clients.
 239     bool mCommonClockHasClients;
 240
 241     // Internal logs used for dumpsys.
 242     LogRing                 mStateChangeLog;
 243     LogRing                 mElectionLog;
 244     LogRing                 mBadPktLog;
 245
 246     // Configuration info
 247     struct sockaddr_storage mMasterElectionEP;          // Endpoint over which we conduct master election
 248     String8                 mBindIface;                 // Endpoint for the service to bind to.
 249     bool                    mBindIfaceValid;            // whether or not the bind Iface is valid.
 250     bool                    mBindIfaceDirty;            // whether or not the bind Iface is valid.
 251     struct sockaddr_storage mMasterEP;                  // Endpoint of our current master (if any)
 252     bool                    mMasterEPValid;
 253     uint64_t                mDeviceID;                  // unique ID of this device
 254     uint64_t                mSyncGroupID;               // synchronization group ID of this device.
 255     uint8_t                 mMasterPriority;            // Priority of this device in master election.
 256     uint32_t                mMasterAnnounceIntervalMs;
 257     uint32_t                mSyncRequestIntervalMs;
 258     uint32_t                mPanicThresholdUsec;
 259     bool                    mAutoDisable;
 260
 261     // Config defaults.
 262     static const char*      kDefaultMasterElectionAddr;
 263     static const uint16_t   kDefaultMasterElectionPort;
 264     static const uint64_t   kDefaultSyncGroupID;
 265     static const uint8_t    kDefaultMasterPriority;
 266     static const uint32_t   kDefaultMasterAnnounceIntervalMs;
 267     static const uint32_t   kDefaultSyncRequestIntervalMs;
 268     static const uint32_t   kDefaultPanicThresholdUsec;
 269     static const bool       kDefaultAutoDisable;
 270
 271     // Priority mask and shift fields.
 272     static const uint64_t kDeviceIDMask;
 273     static const uint8_t  kDevicePriorityMask;
 274     static const uint8_t  kDevicePriorityHiLowBit;
 275     static const uint32_t kDevicePriorityShift;
 276
 277     // Unconfgurable constants
 278     static const int      kSetupRetryTimeoutMs;
 279     static const int64_t  kNoGoodDataPanicThresholdUsec;
 280     static const uint32_t kRTTDiscardPanicThreshMultiplier;
 281
 282     /*** status while in the Initial state ***/
 283     int mInitial_WhoIsMasterRequestTimeouts;
 284     static const int kInitial_NumWhoIsMasterRetries;
 285     static const int kInitial_WhoIsMasterTimeoutMs;
 286
 287     /*** status while in the Client state ***/
 288     uint64_t mClient_MasterDeviceID;
 289     uint8_t mClient_MasterDevicePriority;
 290     bool mClient_SyncRequestPending;
 291     int mClient_SyncRequestTimeouts;
 292     uint32_t mClient_SyncsSentToCurMaster;
 293     uint32_t mClient_SyncRespsRXedFromCurMaster;
 294     uint32_t mClient_ExpiredSyncRespsRXedFromCurMaster;
 295     int64_t mClient_FirstSyncTX;
 296     int64_t mClient_LastGoodSyncRX;
 297     PacketRTTLog mClient_PacketRTTLog;
 298     static const int kClient_NumSyncRequestRetries;
 299
 300
 301     /*** status while in the Master state ***/
 302     static const uint32_t kDefaultMaster_AnnouncementIntervalMs;
 303
 304     /*** status while in the Ronin state ***/
 305     int mRonin_WhoIsMasterRequestTimeouts;
 306     static const int kRonin_NumWhoIsMasterRetries;
 307     static const int kRonin_WhoIsMasterTimeoutMs;
 308
 309     /*** status while in the WaitForElection state ***/
 310     static const int kWaitForElection_TimeoutMs;
 311
 312     static const int kInfiniteTimeout;
 313
 314     static const char* stateToString(ICommonClock::State s);
 315     static void sockaddrToString(const sockaddr_storage& addr, bool addrValid,
 316                                  char* buf, size_t bufLen);
 317     static bool sockaddrMatch(const sockaddr_storage& a1,
 318                               const sockaddr_storage& a2,
 319                               bool matchAddressOnly);
 320 };
 321
 322 }  // namespace android
 323
 324 #endif  // ANDROID_COMMON_TIME_SERVER_H