DO NOT MERGE: common_time: Turn the logging up to 11

Actually, despite the CL title, no addition log messages are being
sent to logcat.  Generally speaking, the common_time service tends to
be rather quiet from a log perspective.  Events related to master
election and arbitration as well as state changes tend to be
infrequent in steady state operation.  Unfortunately, if there is a
problem with the system, it frequently gets pushed out of logcat by
other messages and is missing from the logs when a bugreport is
finally taken.

This change adds a utility class which can be used to store the last N
log message in a ring buffer to be dumped later during a dumpsys
operation.  Three internal log buffers were added to the system.  One
to record messages having to do with state transitions.  Another was
added to record traffic relating to master election, and one final
buffer to record basic data on packets which were received but
discarded for any reason.  During a bugreport, these common_time.clock
service will be able to dump these messages regardless of the amt of
other logcat activity, which should assist in debugging long running
issues.

Change-Id: Ic3bbf7480c8978f9bf82bafaba04cf4586db60cf
Signed-off-by: John Grossman <johngro@google.com>

Author: johngro

services/common_time/clock_recovery.cpp

@@ -225,6 +225,9 @@ bool ClockRecoveryLoop::pushDisciplineEvent(int64_t local_time,
     if (current_point == min_rtt || rtt < control_thresh_) {
         delta_f = delta = nominal_common_time - observed_common;
 
+        last_error_est_valid_ = true;
+        last_error_est_usec_ = delta;
+
         // Compute the error then clamp to the panic threshold.  If we ever
         // exceed this amt of error, its time to panic and reset the system.
         // Given that the error in the measurement of the error could be as
@@ -258,7 +261,6 @@ bool ClockRecoveryLoop::pushDisciplineEvent(int64_t local_time,
 
     // Save error terms for later.
     last_delta_f_ = delta_f;
-    last_delta_ = delta;
 
     // Clamp CO to +/- 100ppm.
     if (CO < COmin)
@@ -295,8 +297,8 @@ bool ClockRecoveryLoop::pushDisciplineEvent(int64_t local_time,
 int32_t ClockRecoveryLoop::getLastErrorEstimate() {
     Mutex::Autolock lock(&lock_);
 
-    if (last_delta_valid_)
-        return last_delta_;
+    if (last_error_est_valid_)
+        return last_error_est_usec_;
     else
         return ICommonClock::kErrorEstimateUnknown;
 }
@@ -310,8 +312,8 @@ void ClockRecoveryLoop::reset_l(bool position, bool frequency) {
     }
 
     if (frequency) {
-        last_delta_valid_ = false;
-        last_delta_ = 0;
+        last_error_est_valid_ = false;
+        last_error_est_usec_ = 0;
         last_delta_f_ = 0.0;
         CO = 0.0f;
         lastCObias = CObias = 0.0f;

services/common_time/clock_recovery.h

@@ -108,8 +108,8 @@ class ClockRecoveryLoop {
 
     // parameters maintained while running and reset during a reset
     // of the frequency correction.
-    bool    last_delta_valid_;
-    int32_t last_delta_;
+    bool    last_error_est_valid_;
+    int32_t last_error_est_usec_;
     float last_delta_f_;
     int32_t integrated_error_;
     int32_t tgt_correction_;