libs/common_time/diag_thread.cpp

   1 /*
   2  * Copyright (C) 2011 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 #define LOG_TAG "common_time"
  18 #include <utils/Log.h>
  19
  20 #include <fcntl.h>
  21 #include <linux/in.h>
  22 #include <linux/tcp.h>
  23 #include <poll.h>
  24 #include <sys/socket.h>
  25 #include <sys/types.h>
  26 #include <unistd.h>
  27 #include <utils/Errors.h>
  28 #include <utils/misc.h>
  29
  30 #include <common_time/local_clock.h>
  31
  32 #include "common_clock.h"
  33 #include "diag_thread.h"
  34
  35 #define kMaxEvents 16
  36 #define kListenPort 9876
  37
  38 static bool setNonblocking(int fd) {
  39     int flags = fcntl(fd, F_GETFL);
  40     if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
  41         ALOGE("Failed to set socket (%d) to non-blocking mode (errno %d)",
  42              fd, errno);
  43         return false;
  44     }
  45
  46     return true;
  47 }
  48
  49 static bool setNodelay(int fd) {
  50     int tmp = 1;
  51     if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &tmp, sizeof(tmp)) < 0) {
  52         ALOGE("Failed to set socket (%d) to no-delay mode (errno %d)",
  53              fd, errno);
  54         return false;
  55     }
  56
  57     return true;
  58 }
  59
  60 namespace android {
  61
  62 DiagThread::DiagThread(CommonClock* common_clock, LocalClock* local_clock) {
  63     common_clock_ = common_clock;
  64     local_clock_ = local_clock;
  65     listen_fd_ = -1;
  66     data_fd_ = -1;
  67     kernel_logID_basis_known_ = false;
  68     discipline_log_ID_ = 0;
  69 }
  70
  71 DiagThread::~DiagThread() {
  72 }
  73
  74 status_t DiagThread::startWorkThread() {
  75     status_t res;
  76     stopWorkThread();
  77     res = run("Diag");
  78
  79     if (res != OK)
  80         ALOGE("Failed to start work thread (res = %d)", res);
  81
  82     return res;
  83 }
  84
  85 void DiagThread::stopWorkThread() {
  86     status_t res;
  87     res = requestExitAndWait(); // block until thread exit.
  88     if (res != OK)
  89         ALOGE("Failed to stop work thread (res = %d)", res);
  90 }
  91
  92 bool DiagThread::openListenSocket() {
  93     bool ret = false;
  94     int flags;
  95     cleanupListenSocket();
  96
  97     if ((listen_fd_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  98         ALOGE("Socket failed.");
  99         goto bailout;
 100     }
 101
 102     // Set non-blocking operation
 103     if (!setNonblocking(listen_fd_))
 104         goto bailout;
 105
 106     struct sockaddr_in addr;
 107     memset(&addr, 0, sizeof(addr));
 108     addr.sin_family = AF_INET;
 109     addr.sin_addr.s_addr = INADDR_ANY;
 110     addr.sin_port = htons(kListenPort);
 111
 112     if (bind(listen_fd_, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 113         ALOGE("Bind failed.");
 114         goto bailout;
 115     }
 116
 117     if (listen(listen_fd_, 1) < 0) {
 118         ALOGE("Listen failed.");
 119         goto bailout;
 120     }
 121
 122     ret = true;
 123 bailout:
 124     if (!ret)
 125         cleanupListenSocket();
 126
 127     return ret;
 128 }
 129
 130 void DiagThread::cleanupListenSocket() {
 131     if (listen_fd_ >= 0) {
 132         int res;
 133
 134         struct linger l;
 135         l.l_onoff  = 1;
 136         l.l_linger = 0;
 137
 138         setsockopt(listen_fd_, SOL_SOCKET, SO_LINGER, &l, sizeof(l));
 139         shutdown(listen_fd_, SHUT_RDWR);
 140         close(listen_fd_);
 141         listen_fd_ = -1;
 142     }
 143 }
 144
 145 void DiagThread::cleanupDataSocket() {
 146     if (data_fd_ >= 0) {
 147         int res;
 148
 149         struct linger l;
 150         l.l_onoff  = 1;
 151         l.l_linger = 0;
 152
 153         setsockopt(data_fd_, SOL_SOCKET, SO_LINGER, &l, sizeof(l));
 154         shutdown(data_fd_, SHUT_RDWR);
 155         close(data_fd_);
 156         data_fd_ = -1;
 157     }
 158 }
 159
 160 void DiagThread::resetLogIDs() {
 161     // Drain and discard all of the events from the kernel
 162     struct local_time_debug_event events[kMaxEvents];
 163     while(local_clock_->getDebugLog(events, kMaxEvents) > 0)
 164         ;
 165
 166     {
 167         Mutex::Autolock lock(&discipline_log_lock_);
 168         discipline_log_.clear();
 169         discipline_log_ID_ = 0;
 170     }
 171
 172     kernel_logID_basis_known_ = false;
 173 }
 174
 175 void DiagThread::pushDisciplineEvent(int64_t observed_local_time,
 176                                      int64_t observed_common_time,
 177                                      int64_t nominal_common_time,
 178                                      int32_t total_correction,
 179                                      int32_t rtt) {
 180     Mutex::Autolock lock(&discipline_log_lock_);
 181
 182     DisciplineEventRecord evt;
 183
 184     evt.event_id = discipline_log_ID_++;
 185
 186     evt.action_local_time = local_clock_->getLocalTime();
 187     common_clock_->localToCommon(evt.action_local_time,
 188             &evt.action_common_time);
 189
 190     evt.observed_local_time  = observed_local_time;
 191     evt.observed_common_time = observed_common_time;
 192     evt.nominal_common_time  = nominal_common_time;
 193     evt.total_correction     = total_correction;
 194     evt.rtt                  = rtt;
 195
 196     discipline_log_.push_back(evt);
 197     while (discipline_log_.size() > kMaxDisciplineLogSize)
 198         discipline_log_.erase(discipline_log_.begin());
 199 }
 200
 201 bool DiagThread::threadLoop() {
 202     struct pollfd poll_fds[1];
 203
 204     if (!openListenSocket()) {
 205         ALOGE("Failed to open listen socket");
 206         goto bailout;
 207     }
 208
 209     while (!exitPending()) {
 210         memset(&poll_fds, 0, sizeof(poll_fds));
 211
 212         if (data_fd_ < 0) {
 213             poll_fds[0].fd     = listen_fd_;
 214             poll_fds[0].events = POLLIN;
 215         } else {
 216             poll_fds[0].fd     = data_fd_;
 217             poll_fds[0].events = POLLRDHUP | POLLIN;
 218         }
 219
 220         int poll_res = poll(poll_fds, NELEM(poll_fds), 50);
 221         if (poll_res < 0) {
 222             ALOGE("Fatal error (%d,%d) while waiting on events",
 223                  poll_res, errno);
 224             goto bailout;
 225         }
 226
 227         if (exitPending())
 228             break;
 229
 230         if (poll_fds[0].revents) {
 231             if (poll_fds[0].fd == listen_fd_) {
 232                 data_fd_ = accept(listen_fd_, NULL, NULL);
 233
 234                 if (data_fd_ < 0) {
 235                     ALOGW("Failed accept on socket %d with err %d",
 236                          listen_fd_, errno);
 237                 } else {
 238                     if (!setNonblocking(data_fd_))
 239                         cleanupDataSocket();
 240                     if (!setNodelay(data_fd_))
 241                         cleanupDataSocket();
 242                 }
 243             } else
 244                 if (poll_fds[0].fd == data_fd_) {
 245                     if (poll_fds[0].revents & POLLRDHUP) {
 246                         // Connection hung up; time to clean up.
 247                         cleanupDataSocket();
 248                     } else
 249                         if (poll_fds[0].revents & POLLIN) {
 250                             uint8_t cmd;
 251                             if (read(data_fd_, &cmd, sizeof(cmd)) > 0) {
 252                                 switch(cmd) {
 253                                     case 'r':
 254                                     case 'R':
 255                                         resetLogIDs();
 256                                         break;
 257                                 }
 258                             }
 259                         }
 260                 }
 261         }
 262
 263         struct local_time_debug_event events[kMaxEvents];
 264         int amt = local_clock_->getDebugLog(events, kMaxEvents);
 265
 266         if (amt > 0) {
 267             for (int i = 0; i < amt; i++) {
 268                 struct local_time_debug_event& e = events[i];
 269
 270                 if (!kernel_logID_basis_known_) {
 271                     kernel_logID_basis_ = e.local_timesync_event_id;
 272                     kernel_logID_basis_known_ = true;
 273                 }
 274
 275                 char buf[1024];
 276                 int64_t common_time;
 277                 status_t res = common_clock_->localToCommon(e.local_time,
 278                                                             &common_time);
 279                 snprintf(buf, sizeof(buf), "E,%lld,%lld,%lld,%d\n",
 280                          e.local_timesync_event_id - kernel_logID_basis_,
 281                          e.local_time,
 282                          common_time,
 283                          (OK == res) ? 1 : 0);
 284                 buf[sizeof(buf) - 1] = 0;
 285
 286                 if (data_fd_ >= 0)
 287                     write(data_fd_, buf, strlen(buf));
 288             }
 289         }
 290
 291         { // scope for autolock pattern
 292             Mutex::Autolock lock(&discipline_log_lock_);
 293
 294             while (discipline_log_.size() > 0) {
 295                 char buf[1024];
 296                 DisciplineEventRecord& e = *discipline_log_.begin();
 297                 snprintf(buf, sizeof(buf),
 298                          "D,%lld,%lld,%lld,%lld,%lld,%lld,%d,%d\n",
 299                          e.event_id,
 300                          e.action_local_time,
 301                          e.action_common_time,
 302                          e.observed_local_time,
 303                          e.observed_common_time,
 304                          e.nominal_common_time,
 305                          e.total_correction,
 306                          e.rtt);
 307                 buf[sizeof(buf) - 1] = 0;
 308
 309                 if (data_fd_ >= 0)
 310                     write(data_fd_, buf, strlen(buf));
 311
 312                 discipline_log_.erase(discipline_log_.begin());
 313             }
 314         }
 315     }
 316
 317 bailout:
 318     cleanupDataSocket();
 319     cleanupListenSocket();
 320     return false;
 321 }
 322
 323 }  // namespace android