| /* |
| * |
| * Copyright (c) 2021 Project CHIP Authors |
| * |
| * 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. |
| */ |
| |
| /** |
| * @file |
| * Provides an implementation of the DiagnosticDataProvider object |
| * for qpg platform. |
| */ |
| |
| #include <platform/internal/CHIPDeviceLayerInternal.h> |
| |
| #include <platform/DiagnosticDataProvider.h> |
| #include <platform/OpenThread/GenericThreadStackManagerImpl_OpenThread.h> |
| #include <platform/PlatformManager.h> |
| #include <platform/qpg/DiagnosticDataProviderImpl.h> |
| |
| namespace chip { |
| namespace DeviceLayer { |
| |
| DiagnosticDataProviderImpl & DiagnosticDataProviderImpl::GetDefaultInstance() |
| { |
| static DiagnosticDataProviderImpl sInstance; |
| return sInstance; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapFree(uint64_t & currentHeapFree) |
| { |
| size_t freeHeapSize; |
| size_t usedHeapSize; |
| size_t highWatermarkHeapSize; |
| |
| qvCHIP_GetHeapStats(&freeHeapSize, &usedHeapSize, &highWatermarkHeapSize); |
| currentHeapFree = static_cast<uint64_t>(freeHeapSize); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapUsed(uint64_t & currentHeapUsed) |
| { |
| size_t freeHeapSize; |
| size_t usedHeapSize; |
| size_t highWatermarkHeapSize; |
| |
| qvCHIP_GetHeapStats(&freeHeapSize, &usedHeapSize, &highWatermarkHeapSize); |
| currentHeapUsed = static_cast<uint64_t>(usedHeapSize); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapHighWatermark(uint64_t & currentHeapHighWatermark) |
| { |
| size_t freeHeapSize; |
| size_t usedHeapSize; |
| size_t highWatermarkHeapSize; |
| |
| qvCHIP_GetHeapStats(&freeHeapSize, &usedHeapSize, &highWatermarkHeapSize); |
| currentHeapHighWatermark = static_cast<uint64_t>(highWatermarkHeapSize); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::ResetWatermarks() |
| { |
| qvCHIP_ResetHeapStats(); |
| return CHIP_NO_ERROR; |
| } |
| |
| DiagnosticDataProvider & GetDiagnosticDataProviderImpl() |
| { |
| return DiagnosticDataProviderImpl::GetDefaultInstance(); |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetRebootCount(uint16_t & rebootCount) |
| { |
| uint32_t count = 0; |
| CHIP_ERROR err = ConfigurationMgr().GetRebootCount(count); |
| |
| if (err == CHIP_NO_ERROR) |
| { |
| VerifyOrReturnError(count <= UINT16_MAX, CHIP_ERROR_INVALID_INTEGER_VALUE); |
| rebootCount = static_cast<uint16_t>(count); |
| } |
| |
| return err; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetBootReason(BootReasonType & bootReason) |
| { |
| uint32_t reason = 0; |
| CHIP_ERROR err = ConfigurationMgr().GetBootReason(reason); |
| |
| if (err == CHIP_NO_ERROR) |
| { |
| VerifyOrReturnError(reason <= UINT8_MAX, CHIP_ERROR_INVALID_INTEGER_VALUE); |
| bootReason = static_cast<BootReasonType>(reason); |
| } |
| |
| return err; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetUpTime(uint64_t & upTime) |
| { |
| System::Clock::Timestamp currentTime = System::SystemClock().GetMonotonicTimestamp(); |
| System::Clock::Timestamp startTime = PlatformMgrImpl().GetStartTime(); |
| |
| if (currentTime >= startTime) |
| { |
| upTime = std::chrono::duration_cast<System::Clock::Seconds64>(currentTime - startTime).count(); |
| return CHIP_NO_ERROR; |
| } |
| |
| return CHIP_ERROR_INVALID_TIME; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours) |
| { |
| uint32_t totalHours = 0; |
| if (ConfigurationMgr().GetTotalOperationalHours(totalHours) == CHIP_NO_ERROR) |
| { |
| totalOperationalHours = totalHours; |
| return CHIP_NO_ERROR; |
| } |
| |
| return CHIP_ERROR_INVALID_TIME; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetActiveHardwareFaults(GeneralFaults<kMaxHardwareFaults> & hardwareFaults) |
| { |
| ChipLogProgress(DeviceLayer, "GetActiveHardwareFaults"); |
| |
| #if CHIP_CONFIG_TEST |
| using app::Clusters::GeneralDiagnostics::HardwareFaultEnum; |
| |
| ReturnErrorOnFailure(hardwareFaults.add(to_underlying(HardwareFaultEnum::kRadio))); |
| ReturnErrorOnFailure(hardwareFaults.add(to_underlying(HardwareFaultEnum::kSensor))); |
| ReturnErrorOnFailure(hardwareFaults.add(to_underlying(HardwareFaultEnum::kPowerSource))); |
| ReturnErrorOnFailure(hardwareFaults.add(to_underlying(HardwareFaultEnum::kUserInterfaceFault))); |
| #endif |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetActiveRadioFaults(GeneralFaults<kMaxRadioFaults> & radioFaults) |
| { |
| ChipLogProgress(DeviceLayer, "GetActiveRadioFaults"); |
| #if CHIP_CONFIG_TEST |
| ReturnErrorOnFailure(radioFaults.add(to_underlying(RadioFaultEnum::kThreadFault))); |
| ReturnErrorOnFailure(radioFaults.add(to_underlying(RadioFaultEnum::kBLEFault))); |
| #endif |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetActiveNetworkFaults(GeneralFaults<kMaxNetworkFaults> & networkFaults) |
| { |
| ChipLogProgress(DeviceLayer, "GetActiveNetworkFaults"); |
| #if CHIP_CONFIG_TEST |
| using app::Clusters::GeneralDiagnostics::NetworkFaultEnum; |
| |
| ReturnErrorOnFailure(networkFaults.add(to_underlying(NetworkFaultEnum::kHardwareFailure))); |
| ReturnErrorOnFailure(networkFaults.add(to_underlying(NetworkFaultEnum::kNetworkJammed))); |
| ReturnErrorOnFailure(networkFaults.add(to_underlying(NetworkFaultEnum::kConnectionFailed))); |
| #endif |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR DiagnosticDataProviderImpl::GetNetworkInterfaces(NetworkInterface ** netifpp) |
| { |
| NetworkInterface * ifp = new NetworkInterface(); |
| |
| #if CHIP_DEVICE_CONFIG_ENABLE_THREAD |
| const char * threadNetworkName = otThreadGetNetworkName(ThreadStackMgrImpl().OTInstance()); |
| ifp->name = Span<const char>(threadNetworkName, strlen(threadNetworkName)); |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kThread; |
| ifp->isOperational = ThreadStackMgrImpl().IsThreadAttached(); |
| ifp->offPremiseServicesReachableIPv4.SetNull(); |
| ifp->offPremiseServicesReachableIPv6.SetNull(); |
| |
| TEMPORARY_RETURN_IGNORED ThreadStackMgrImpl().GetPrimary802154MACAddress(ifp->MacAddress); |
| ifp->hardwareAddress = ByteSpan(ifp->MacAddress, kMaxHardwareAddrSize); |
| |
| // The Thread implementation has only 1 interface and is IPv6-only |
| Inet::InterfaceAddressIterator interfaceAddressIterator; |
| uint8_t ipv6AddressesCount = 0; |
| while (interfaceAddressIterator.HasCurrent() && ipv6AddressesCount < kMaxIPv6AddrCount) |
| { |
| Inet::IPAddress ipv6Address; |
| if (interfaceAddressIterator.GetAddress(ipv6Address) == CHIP_NO_ERROR) |
| { |
| memcpy(ifp->Ipv6AddressesBuffer[ipv6AddressesCount], ipv6Address.Addr, kMaxIPv6AddrSize); |
| ifp->Ipv6AddressSpans[ipv6AddressesCount] = ByteSpan(ifp->Ipv6AddressesBuffer[ipv6AddressesCount]); |
| ipv6AddressesCount++; |
| } |
| interfaceAddressIterator.Next(); |
| } |
| |
| ifp->IPv6Addresses = app::DataModel::List<ByteSpan>(ifp->Ipv6AddressSpans, ipv6AddressesCount); |
| |
| *netifpp = ifp; |
| #else |
| NetworkInterface * head = NULL; |
| for (Inet::InterfaceIterator interfaceIterator; interfaceIterator.HasCurrent(); interfaceIterator.Next()) |
| { |
| interfaceIterator.GetInterfaceName(ifp->Name, Inet::InterfaceId::kMaxIfNameLength); |
| ifp->name = CharSpan::fromCharString(ifp->Name); |
| ifp->isOperational = true; |
| app::Clusters::GeneralDiagnostics::InterfaceTypeEnum interfaceType; |
| CHIP_ERROR err = interfaceIterator.GetInterfaceType(interfaceType); |
| if (err == CHIP_NO_ERROR || err == CHIP_ERROR_NOT_IMPLEMENTED) |
| { |
| switch (interfaceType) |
| { |
| case Inet::InterfaceType::Unknown: |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kUnspecified; |
| break; |
| case Inet::InterfaceType::WiFi: |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kWiFi; |
| break; |
| case Inet::InterfaceType::Ethernet: |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kEthernet; |
| break; |
| case Inet::InterfaceType::Thread: |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kThread; |
| break; |
| case Inet::InterfaceType::Cellular: |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kCellular; |
| break; |
| default: |
| ifp->type = app::Clusters::GeneralDiagnostics::InterfaceTypeEnum::kWiFi; |
| break; |
| } |
| } |
| else |
| { |
| ChipLogError(DeviceLayer, "Failed to get interface type"); |
| } |
| |
| ifp->offPremiseServicesReachableIPv4.SetNull(); |
| ifp->offPremiseServicesReachableIPv6.SetNull(); |
| |
| uint8_t addressSize; |
| if (interfaceIterator.GetHardwareAddress(ifp->MacAddress, addressSize, sizeof(ifp->MacAddress)) != CHIP_NO_ERROR) |
| { |
| ChipLogError(DeviceLayer, "Failed to get network hardware address"); |
| } |
| else |
| { |
| ifp->hardwareAddress = ByteSpan(ifp->MacAddress, addressSize); |
| } |
| |
| // Assuming IPv6-only support |
| Inet::InterfaceAddressIterator interfaceAddressIterator; |
| uint8_t ipv6AddressesCount = 0; |
| while (interfaceAddressIterator.HasCurrent() && ipv6AddressesCount < kMaxIPv6AddrCount) |
| { |
| if (interfaceAddressIterator.GetInterfaceId() == interfaceIterator.GetInterfaceId()) |
| { |
| chip::Inet::IPAddress ipv6Address; |
| if (interfaceAddressIterator.GetAddress(ipv6Address) == CHIP_NO_ERROR) |
| { |
| memcpy(ifp->Ipv6AddressesBuffer[ipv6AddressesCount], ipv6Address.Addr, kMaxIPv6AddrSize); |
| ifp->Ipv6AddressSpans[ipv6AddressesCount] = ByteSpan(ifp->Ipv6AddressesBuffer[ipv6AddressesCount]); |
| ipv6AddressesCount++; |
| } |
| } |
| interfaceAddressIterator.Next(); |
| } |
| |
| ifp->IPv6Addresses = chip::app::DataModel::List<chip::ByteSpan>(ifp->Ipv6AddressSpans, ipv6AddressesCount); |
| head = ifp; |
| } |
| *netifpp = head; |
| #endif |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| void DiagnosticDataProviderImpl::ReleaseNetworkInterfaces(NetworkInterface * netifp) |
| { |
| while (netifp) |
| { |
| NetworkInterface * del = netifp; |
| netifp = netifp->Next; |
| delete del; |
| } |
| } |
| |
| } // namespace DeviceLayer |
| } // namespace chip |
