| /* | |
| * 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. | |
| */ | |
| #define DEBUG false // STOPSHIP if true | |
| #define LOG_TAG "StatsAidl" | |
| #define VLOG(...) \ | |
| if (DEBUG) ALOGD(__VA_ARGS__); | |
| #include "StatsAidl.h" | |
| #include <Counter.h> | |
| #include <log/log.h> | |
| #include <stats_annotations.h> | |
| #include <stats_event.h> | |
| #include <statslog.h> | |
| #include <unordered_map> | |
| namespace { | |
| static const char* g_AtomErrorMetricName = | |
| "statsd_errors.value_report_vendor_atom_errors_count"; | |
| } | |
| namespace aidl { | |
| namespace android { | |
| namespace frameworks { | |
| namespace stats { | |
| using ::android::expresslog::Counter; | |
| template <typename E> | |
| constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept { | |
| return static_cast<typename std::underlying_type<E>::type>(e); | |
| } | |
| StatsHal::StatsHal() { | |
| } | |
| bool write_annotation(AStatsEvent* event, const Annotation& annotation) { | |
| switch (annotation.value.getTag()) { | |
| case AnnotationValue::boolValue: { | |
| AStatsEvent_addBoolAnnotation(event, to_underlying(annotation.annotationId), | |
| annotation.value.get<AnnotationValue::boolValue>()); | |
| break; | |
| } | |
| case AnnotationValue::intValue: { | |
| AStatsEvent_addInt32Annotation(event, to_underlying(annotation.annotationId), | |
| annotation.value.get<AnnotationValue::intValue>()); | |
| break; | |
| } | |
| default: { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| bool write_atom_annotations(AStatsEvent* event, | |
| const std::vector<std::optional<Annotation>>& annotations) { | |
| for (const auto& atomAnnotation : annotations) { | |
| if (!atomAnnotation) { | |
| return false; | |
| } | |
| if (!write_annotation(event, *atomAnnotation)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| bool write_field_annotations(AStatsEvent* event, const std::vector<Annotation>& annotations) { | |
| for (const auto& fieldAnnotation : annotations) { | |
| if (!write_annotation(event, fieldAnnotation)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| ndk::ScopedAStatus StatsHal::reportVendorAtom(const VendorAtom& vendorAtom) { | |
| if (vendorAtom.atomId < 100000 || vendorAtom.atomId >= 200000) { | |
| ALOGE("Atom ID %ld is not a valid vendor atom ID", (long)vendorAtom.atomId); | |
| Counter::logIncrement(g_AtomErrorMetricName); | |
| return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage( | |
| -1, "Not a valid vendor atom ID"); | |
| } | |
| if (vendorAtom.reverseDomainName.length() > 50) { | |
| ALOGE("Vendor atom reverse domain name %s is too long.", | |
| vendorAtom.reverseDomainName.c_str()); | |
| Counter::logIncrement(g_AtomErrorMetricName); | |
| return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage( | |
| -1, "Vendor atom reverse domain name is too long"); | |
| } | |
| AStatsEvent* event = AStatsEvent_obtain(); | |
| AStatsEvent_setAtomId(event, vendorAtom.atomId); | |
| if (vendorAtom.atomAnnotations) { | |
| if (!write_atom_annotations(event, *vendorAtom.atomAnnotations)) { | |
| AStatsEvent_release(event); | |
| ALOGE("Atom ID %ld has incompatible atom level annotation", (long)vendorAtom.atomId); | |
| Counter::logIncrement(g_AtomErrorMetricName); | |
| return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage( | |
| -1, "invalid atom annotation"); | |
| } | |
| } | |
| // populate map for quickier access for VendorAtomValue associated annotations by value index | |
| std::unordered_map<int, int> fieldIndexToAnnotationSetMap; | |
| if (vendorAtom.valuesAnnotations) { | |
| const std::vector<std::optional<AnnotationSet>>& valuesAnnotations = | |
| *vendorAtom.valuesAnnotations; | |
| for (int i = 0; i < valuesAnnotations.size(); i++) { | |
| if (valuesAnnotations[i]) { | |
| fieldIndexToAnnotationSetMap[valuesAnnotations[i]->valueIndex] = i; | |
| } | |
| } | |
| } | |
| AStatsEvent_writeString(event, vendorAtom.reverseDomainName.c_str()); | |
| size_t atomValueIdx = 0; | |
| for (const auto& atomValue : vendorAtom.values) { | |
| switch (atomValue.getTag()) { | |
| case VendorAtomValue::intValue: | |
| AStatsEvent_writeInt32(event, atomValue.get<VendorAtomValue::intValue>()); | |
| break; | |
| case VendorAtomValue::longValue: | |
| AStatsEvent_writeInt64(event, atomValue.get<VendorAtomValue::longValue>()); | |
| break; | |
| case VendorAtomValue::floatValue: | |
| AStatsEvent_writeFloat(event, atomValue.get<VendorAtomValue::floatValue>()); | |
| break; | |
| case VendorAtomValue::stringValue: | |
| AStatsEvent_writeString(event, | |
| atomValue.get<VendorAtomValue::stringValue>().c_str()); | |
| break; | |
| case VendorAtomValue::boolValue: | |
| AStatsEvent_writeBool(event, atomValue.get<VendorAtomValue::boolValue>()); | |
| break; | |
| case VendorAtomValue::repeatedIntValue: { | |
| const std::optional<std::vector<int>>& repeatedIntValue = | |
| atomValue.get<VendorAtomValue::repeatedIntValue>(); | |
| if (!repeatedIntValue) { | |
| AStatsEvent_writeInt32Array(event, {}, 0); | |
| break; | |
| } | |
| AStatsEvent_writeInt32Array(event, repeatedIntValue->data(), | |
| repeatedIntValue->size()); | |
| break; | |
| } | |
| case VendorAtomValue::repeatedLongValue: { | |
| const std::optional<std::vector<int64_t>>& repeatedLongValue = | |
| atomValue.get<VendorAtomValue::repeatedLongValue>(); | |
| if (!repeatedLongValue) { | |
| AStatsEvent_writeInt64Array(event, {}, 0); | |
| break; | |
| } | |
| AStatsEvent_writeInt64Array(event, repeatedLongValue->data(), | |
| repeatedLongValue->size()); | |
| break; | |
| } | |
| case VendorAtomValue::repeatedFloatValue: { | |
| const std::optional<std::vector<float>>& repeatedFloatValue = | |
| atomValue.get<VendorAtomValue::repeatedFloatValue>(); | |
| if (!repeatedFloatValue) { | |
| AStatsEvent_writeFloatArray(event, {}, 0); | |
| break; | |
| } | |
| AStatsEvent_writeFloatArray(event, repeatedFloatValue->data(), | |
| repeatedFloatValue->size()); | |
| break; | |
| } | |
| case VendorAtomValue::repeatedStringValue: { | |
| const std::optional<std::vector<std::optional<std::string>>>& repeatedStringValue = | |
| atomValue.get<VendorAtomValue::repeatedStringValue>(); | |
| if (!repeatedStringValue) { | |
| AStatsEvent_writeStringArray(event, {}, 0); | |
| break; | |
| } | |
| const std::vector<std::optional<std::string>>& repeatedStringVector = | |
| *repeatedStringValue; | |
| const char* cStringArray[repeatedStringVector.size()]; | |
| for (int i = 0; i < repeatedStringVector.size(); ++i) { | |
| cStringArray[i] = repeatedStringVector[i].has_value() | |
| ? repeatedStringVector[i]->c_str() | |
| : ""; | |
| } | |
| AStatsEvent_writeStringArray(event, cStringArray, repeatedStringVector.size()); | |
| break; | |
| } | |
| case VendorAtomValue::repeatedBoolValue: { | |
| const std::optional<std::vector<bool>>& repeatedBoolValue = | |
| atomValue.get<VendorAtomValue::repeatedBoolValue>(); | |
| if (!repeatedBoolValue) { | |
| AStatsEvent_writeBoolArray(event, {}, 0); | |
| break; | |
| } | |
| const std::vector<bool>& repeatedBoolVector = *repeatedBoolValue; | |
| bool boolArray[repeatedBoolValue->size()]; | |
| for (int i = 0; i < repeatedBoolVector.size(); ++i) { | |
| boolArray[i] = repeatedBoolVector[i]; | |
| } | |
| AStatsEvent_writeBoolArray(event, boolArray, repeatedBoolVector.size()); | |
| break; | |
| } | |
| case VendorAtomValue::byteArrayValue: { | |
| const std::optional<std::vector<uint8_t>>& byteArrayValue = | |
| atomValue.get<VendorAtomValue::byteArrayValue>(); | |
| if (!byteArrayValue) { | |
| AStatsEvent_writeByteArray(event, {}, 0); | |
| break; | |
| } | |
| AStatsEvent_writeByteArray(event, byteArrayValue->data(), byteArrayValue->size()); | |
| break; | |
| } | |
| default: { | |
| AStatsEvent_release(event); | |
| ALOGE("Atom ID %ld has invalid atomValue.getTag", (long)vendorAtom.atomId); | |
| Counter::logIncrement(g_AtomErrorMetricName); | |
| return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage( | |
| -1, "invalid atomValue.getTag"); | |
| break; | |
| } | |
| } | |
| const auto& valueAnnotationIndex = fieldIndexToAnnotationSetMap.find(atomValueIdx); | |
| if (valueAnnotationIndex != fieldIndexToAnnotationSetMap.end()) { | |
| const std::vector<Annotation>& fieldAnnotations = | |
| (*vendorAtom.valuesAnnotations)[valueAnnotationIndex->second]->annotations; | |
| VLOG("Atom ID %ld has %ld annotations for field #%ld", (long)vendorAtom.atomId, | |
| (long)fieldAnnotations.size(), (long)atomValueIdx + 2); | |
| if (!write_field_annotations(event, fieldAnnotations)) { | |
| AStatsEvent_release(event); | |
| ALOGE("Atom ID %ld has incompatible field level annotation for field #%ld", | |
| (long)vendorAtom.atomId, (long)atomValueIdx + 2); | |
| Counter::logIncrement(g_AtomErrorMetricName); | |
| return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage( | |
| -1, "invalid atom field annotation"); | |
| } | |
| } | |
| atomValueIdx++; | |
| } | |
| AStatsEvent_build(event); | |
| const int ret = AStatsEvent_write(event); | |
| AStatsEvent_release(event); | |
| if (ret <= 0) { | |
| ALOGE("Error writing Atom ID %ld. Result: %d", (long)vendorAtom.atomId, ret); | |
| Counter::logIncrement(g_AtomErrorMetricName); | |
| } | |
| return ret <= 0 ? ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(ret, | |
| "report atom failed") | |
| : ndk::ScopedAStatus::ok(); | |
| } | |
| } // namespace stats | |
| } // namespace frameworks | |
| } // namespace android | |
| } // namespace aidl |