Merge pull request #1 from yperess/zephyr

Pull latest changes from ToT

Author: yperess

apps/test/common/chre_cross_validator_sensor/Makefile

@@ -18,7 +18,7 @@ endif
 NANOAPP_NAME = chre_cross_validator_sensor
 NANOAPP_ID = 0x476f6f6754000002
 NANOAPP_NAME_STRING = \"Chre\ Cross\ Validator\ Sensor\"
-NANOAPP_VERSION = 0x00000001
+NANOAPP_VERSION = 0x00000002
 
 NANOAPP_PATH = $(CHRE_PREFIX)/apps/test/common/chre_cross_validator_sensor
 

apps/test/common/chre_cross_validator_sensor/inc/chre_cross_validator_sensor_manager.h

@@ -32,6 +32,9 @@ namespace cross_validator_sensor {
 // TODO(b/154271551): Break up the Manager class into more fine-grained classes
 // to avoid it becoming to complex.
 
+//! The maximum size of a sensor name.
+constexpr size_t kMaxSensorNameSize = 128;
+
 /**
  * Class to manage a CHRE cross validator nanoapp.
  */
@@ -99,6 +102,9 @@ class Manager {
   //! message.
   chre::Optional<CrossValidatorState> mCrossValidatorState;
 
+  //! A temporary global buffer where the sensor name is stored.
+  char mSensorNameArray[kMaxSensorNameSize];
+
   /**
    * Make a SensorDatapoint proto message.
    *
@@ -383,6 +389,16 @@ class Manager {
    * during validation.
    */
   void cleanup();
+
+  /**
+   * @param sensorType The CHRE sensor type.
+   * @param sensorIndex The CHRE sensor index as defined in chreSensorFind.
+   * @param handle A non-null pointer where the sensor handle is stored, if
+   * found.
+   *
+   * @return true if the sensor corresponding to the input is available.
+   */
+  bool getSensor(uint32_t sensorType, uint32_t sensorIndex, uint32_t *handle);
 };
 
 // The chre cross validator manager singleton.

apps/test/common/chre_cross_validator_sensor/src/chre_cross_validator_sensor_manager.cc

@@ -29,12 +29,29 @@
 #include "chre/util/time.h"
 #include "chre_cross_validation_sensor.nanopb.h"
 
-#define LOG_TAG "ChreCrossValidator"
+#define LOG_TAG "[ChreCrossValidator]"
 
 namespace chre {
 
 namespace cross_validator_sensor {
 
+namespace {
+
+bool decodeSensorName(pb_istream_t *stream, const pb_field_s *field,
+                      void **arg) {
+  unsigned char *name = static_cast<unsigned char *>(*arg);
+
+  if (stream->bytes_left > kMaxSensorNameSize - 1) return false;
+
+  size_t bytesToCopy = stream->bytes_left;
+  if (!pb_read(stream, name, stream->bytes_left)) return false;
+  name[bytesToCopy] = '\0';
+
+  return true;
+}
+
+}  // namespace
+
 Manager::~Manager() {
   cleanup();
 }
@@ -98,6 +115,9 @@ void Manager::handleEvent(uint32_t senderInstanceId, uint16_t eventType,
       handleStepCounterData(
           static_cast<const chreSensorUint64Data *>(eventData));
       break;
+    case CHRE_EVENT_SENSOR_SAMPLING_CHANGE:
+      // Ignore sampling state changes
+      break;
     default:
       LOGE("Got unknown event type from senderInstanceId %" PRIu32
            " and with eventType %" PRIu16,
@@ -312,11 +332,17 @@ bool Manager::handleStartSensorMessage(
   uint64_t latencyInNs =
       startSensorCommand.latencyInMs * kOneMillisecondInNanoseconds;
   bool isContinuous = startSensorCommand.isContinuous;
+  uint32_t sensorIndex = startSensorCommand.sensorIndex;
+
   uint32_t handle;
-  if (!chreSensorFindDefault(sensorType, &handle)) {
-    LOGE("Could not find default sensor for sensorType %" PRIu8, sensorType);
+  if (!getSensor(sensorType, sensorIndex, &handle)) {
+    LOGE("Could not find default sensor for sensorType %" PRIu8
+         " index %" PRIu32,
+         sensorType, sensorIndex);
     // TODO(b/146052784): Test other sensor configure modes
   } else {
+    LOGI("Starting x-validation for sensor type %" PRIu8 " index %" PRIu32,
+         sensorType, sensorIndex);
     chreSensorInfo sensorInfo;
     if (!chreGetSensorInfo(handle, &sensorInfo)) {
       LOGE("Error getting sensor info for sensor");
@@ -391,6 +417,10 @@ void Manager::handleInfoMessage(uint16_t hostEndpoint,
       static_cast<const pb_byte_t *>(hostData->message), hostData->messageSize);
   chre_cross_validation_sensor_SensorInfoCommand infoCommand =
       chre_cross_validation_sensor_SensorInfoCommand_init_default;
+
+  infoCommand.sensorName.funcs.decode = decodeSensorName;
+  infoCommand.sensorName.arg = mSensorNameArray;
+
   if (!pb_decode(&istream,
                  chre_cross_validation_sensor_SensorInfoCommand_fields,
                  &infoCommand)) {
@@ -400,8 +430,31 @@ void Manager::handleInfoMessage(uint16_t hostEndpoint,
     infoResponse.has_chreSensorType = true;
     infoResponse.chreSensorType = infoCommand.chreSensorType;
     infoResponse.has_isAvailable = true;
-    infoResponse.isAvailable =
-        chreSensorFindDefault(infoResponse.chreSensorType, &handle);
+    infoResponse.isAvailable = false;
+    infoResponse.has_sensorIndex = false;
+
+    bool supportsMultiSensors =
+        chreSensorFind(infoCommand.chreSensorType, 1, &handle);
+    for (uint8_t i = 0; chreSensorFind(infoCommand.chreSensorType, i, &handle);
+         i++) {
+      struct chreSensorInfo info;
+      if (!chreGetSensorInfo(handle, &info)) {
+        LOGE("Failed to get sensor info");
+      } else {
+        bool equal = true;
+        if (supportsMultiSensors) {
+          equal = (strcmp(info.sensorName, mSensorNameArray) == 0);
+          LOGI("Got sensor name %s in-name %s, equal %d", info.sensorName,
+               mSensorNameArray, equal);
+        }
+        if (equal) {
+          infoResponse.isAvailable = true;
+          infoResponse.has_sensorIndex = true;
+          infoResponse.sensorIndex = i;
+          break;
+        }
+      }
+    }
   }
 
   sendInfoResponse(hostEndpoint, infoResponse);
@@ -609,6 +662,22 @@ bool Manager::sensorTypeIsValid(uint8_t sensorType) {
   return sensorType == mCrossValidatorState->sensorType;
 }
 
+bool Manager::getSensor(uint32_t sensorType, uint32_t sensorIndex,
+                        uint32_t *handle) {
+  bool success = false;
+
+  bool supportsMultiSensor = (chreGetApiVersion() >= CHRE_API_VERSION_1_5);
+  if (sensorIndex > UINT8_MAX) {
+    LOGE("CHRE only supports max of 255 sensor indices");
+  } else if (!supportsMultiSensor && sensorIndex != 0) {
+    LOGW("CHRE API does not support multi-sensors");
+  } else {
+    success = chreSensorFind(sensorType, sensorIndex, handle);
+  }
+
+  return success;
+}
+
 }  // namespace cross_validator_sensor
 
 }  // namespace chre

apps/test/common/proto/chre_cross_validation_sensor.proto

@@ -43,13 +43,16 @@ message StartSensorCommand {
   optional uint64 intervalInMs = 2;
   optional uint64 latencyInMs = 3;
   optional bool isContinuous = 4;
+  optional uint32 sensorIndex = 5;
 }
 
 /*
  * Asks for the nanoapp to provide stats about the provided CHRE sensor type.
  */
 message SensorInfoCommand {
   optional uint32 chreSensorType = 1;
+  // The sensor name given by android.hardware.Sensor#getSensorName()
+  optional bytes sensorName = 2;
 }
 
 /*
@@ -58,6 +61,7 @@ message SensorInfoCommand {
 message SensorInfoResponse {
   optional uint32 chreSensorType = 1;
   optional bool isAvailable = 2;
+  optional uint32 sensorIndex = 3;
 }
 
 message Data {

chpp/Android.bp

@@ -56,6 +56,7 @@ cc_library_static {
         "-DCHPP_SERVICE_ENABLED_TRANSPORT_LOOPBACK",
         "-DCHPP_MAX_REGISTERED_CLIENTS=3",
         "-DCHPP_MAX_REGISTERED_SERVICES=3",
+        "-DCHPP_ENABLE_WORK_MONITOR",
         "-DCHPP_DEBUG_ASSERT_ENABLED",
         // clock_gettime() requires _POSIX_C_SOURCE >= 199309L
         "-D_POSIX_C_SOURCE=199309L",
@@ -114,6 +115,7 @@ cc_test_host {
         "-DCHPP_CHECKSUM_ENABLED",
         "-DCHPP_MAX_REGISTERED_CLIENTS=3",
         "-DCHPP_MAX_REGISTERED_SERVICES=3",
+        "-DCHPP_ENABLE_WORK_MONITOR",
     ],
     srcs: [
         "test/app_test_base.cpp",

chpp/clients/wifi.c

@@ -497,6 +497,20 @@ static void chppWifiRequestScanResult(struct ChppWifiClientState *clientContext,
   } else {
     struct ChppWifiRequestScanResponseParameters *result =
         &((struct ChppWifiRequestScanResponse *)buf)->params;
+
+    // TODO(b/193540354): Remove when resolved
+    {
+      static uint32_t sNumConsecutiveError = 0;
+      if (result->errorCode != CHRE_ERROR_NONE) {
+        sNumConsecutiveError++;
+      } else {
+        sNumConsecutiveError = 0;
+      }
+      if (sNumConsecutiveError > 20) {
+        CHPP_ASSERT("Too many consecutive WiFi scan errors");
+      }
+    }
+
     CHPP_LOGI("Scan request success=%d (at service)", result->pending);
     gCallbacks->scanResponseCallback(result->pending, result->errorCode);
   }

chpp/include/chpp/transport.h

@@ -27,6 +27,7 @@
 #include "chpp/mutex.h"
 #include "chpp/notifier.h"
 #include "chpp/transport_signals.h"
+#include "chpp/work_monitor.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -444,6 +445,10 @@ struct ChppTransportState {
   struct ChppConditionVariable
       resetCondVar;  // Condvar specifically to wait for resetState
 
+#ifdef CHPP_ENABLE_WORK_MONITOR
+  struct ChppWorkMonitor workMonitor;  // Monitor used for the transport thread
+#endif
+
   //! This MUST be the last field in the ChppTransportState structure, otherwise
   //! chppResetTransportContext() will not work properly.
   struct ChppPlatformLinkParameters linkParams;  // For corresponding link layer

chpp/include/chpp/work_monitor.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+/*
+ * Implementation Notes
+ * Platforms must only supply chpp/platform/platform_work_monitor.h if they
+ * set the CHPP_ENABLE_WORK_MONITOR macro in their builds.
+ */
+
+#ifndef CHPP_WORK_MONITOR_H_
+#define CHPP_WORK_MONITOR_H_
+
+#ifdef CHPP_ENABLE_WORK_MONITOR
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Platform-specific work monitor struct, defined in the platform's
+ * platform_work_monitor.h file.
+ */
+struct ChppWorkMonitor;
+
+/*
+ * Initializes a specified platform-specific work monitor.
+ *
+ * @param workMonitor points to the ChppWorkMonitor mutex struct.
+ */
+static void chppWorkMonitorInit(struct ChppWorkMonitor *workMonitor);
+
+/*
+ * Deinitializes a specified platform-specific work monitor.
+ *
+ * @param workMonitor points to the ChppWorkMonitor mutex struct.
+ */
+static void chppWorkMonitorDeinit(struct ChppWorkMonitor *workMonitor);
+
+/*
+ * Called before CHPP starts doing work on the transport thread. This allows
+ * platforms to start something like a watchdog to ensure the CHPP thread
+ * is caught if it gets stuck.
+ *
+ * @param workMonitor points to the ChppWorkMonitor mutex struct.
+ */
+static void chppWorkMonitorPreProcess(struct ChppWorkMonitor *workMonitor);
+
+/*
+ * Called after CHPP finished doing work on the transport thread. This allows
+ * platforms to stop any watchdog tracking the thread.
+ *
+ * @param workMonitor points to the ChppWorkMonitor mutex struct.
+ */
+static void chppWorkMonitorPostProcess(struct ChppWorkMonitor *workMonitor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "chpp/platform/platform_work_monitor.h"
+
+#endif  // CHPP_ENABLE_WORK_MONITOR
+#endif  // CHPP_WORK_MONITOR_H_

chpp/platform/linux/include/chpp/platform/platform_work_monitor.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2021 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 CHPP_PLATFORM_WORK_MONITOR_H_
+#define CHPP_PLATFORM_WORK_MONITOR_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ChppWorkMonitor {
+  uint32_t numPreProcessCalls;
+  uint32_t numPostProcessCalls;
+};
+
+static inline void chppWorkMonitorInit(struct ChppWorkMonitor *workMonitor) {
+  workMonitor->numPreProcessCalls = 0;
+  workMonitor->numPostProcessCalls = 0;
+}
+
+static inline void chppWorkMonitorDeinit(struct ChppWorkMonitor *workMonitor) {
+  UNUSED_VAR(workMonitor);
+}
+
+static inline void chppWorkMonitorPreProcess(
+    struct ChppWorkMonitor *workMonitor) {
+  ++workMonitor->numPreProcessCalls;
+}
+
+static inline void chppWorkMonitorPostProcess(
+    struct ChppWorkMonitor *workMonitor) {
+  ++workMonitor->numPostProcessCalls;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHPP_PLATFORM_WORK_MONITOR_H_