Line data    Source code

       1              : /**
       2              :  * Copyright (c) 2025 Huawei Technologies Co., Ltd.
       3              :  * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
       4              :  * CANN Open Software License Agreement Version 2.0 (the "License").
       5              :  * Please refer to the License for details. You may not use this file except in compliance with the License.
       6              :  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
       7              :  * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
       8              :  * See LICENSE in the root of the software repository for the full text of the License.
       9              :  */
      10              : 
      11              : #include "cann_error_reporter.h"
      12              : #include <cstdio>
      13              : #include "log.h"
      14              : 
      15              : namespace dfx {
      16              : constexpr uint64_t DEFAULT_SENSOR_HANDLE = 0xFFFFFFFF;
      17              : 
      18              : 
      19            2 : CannErrorReporter::CannErrorReporter()
      20            4 :     : sensorHandle_(DEFAULT_SENSOR_HANDLE), devId_(0)
      21              : {
      22            2 : }
      23              : 
      24            2 : CannErrorReporter::~CannErrorReporter()
      25              : {
      26            2 :     status2Event_.clear();
      27              :     void Clear();
      28            2 : }
      29              : 
      30          140 : CannErrorReporter& CannErrorReporter::GetInstance()
      31              : {
      32          140 :     static CannErrorReporter instance;
      33          140 :     return instance;
      34              : }
      35              : 
      36            0 : HcclResult CannErrorReporter::Init(uint32_t deviceId)
      37              : {
      38            0 :     if (sensorHandle_ != DEFAULT_SENSOR_HANDLE && devId_ == deviceId) {
      39            0 :         return HCCL_SUCCESS;
      40              :     }
      41              : 
      42            0 :     if (sensorHandle_ != DEFAULT_SENSOR_HANDLE) {
      43              :         void Clear();
      44              :     }
      45              : 
      46            0 :     CHK_PRT_RET(RegisterSensorNode(deviceId, &sensorHandle_) != HCCL_SUCCESS,
      47              :         HCCL_RUN_WARNING("[CannErrorReporter][Init] init sensor node fail, deviceId[%u].",
      48              :         deviceId), HCCL_E_INTERNAL);
      49            0 :     devId_ = deviceId;
      50            0 :     return HCCL_SUCCESS;
      51              : }
      52              : 
      53          140 : HcclResult CannErrorReporter::Clear()
      54              : {
      55          140 :     if (sensorHandle_ != DEFAULT_SENSOR_HANDLE) {
      56            0 :         HcclResult ret = UnRegisterSensorNode(devId_, sensorHandle_);
      57            0 :         if (ret != HCCL_SUCCESS) {
      58            0 :             HCCL_RUN_WARNING("[CannErrorReporter][Clear] unregister sensor node fail, handle[%llu], deviceId[%u].",
      59              :                 sensorHandle_, devId_);
      60              :         } else {
      61            0 :             HCCL_INFO("[CannErrorReporter][Clear] unregister sensor node success, handle[%llu], devId[%u].",
      62              :                 sensorHandle_, devId_);
      63              :         }
      64              :     }
      65          140 :     sensorHandle_ = DEFAULT_SENSOR_HANDLE;
      66          140 :     devId_ = 0;
      67          140 :     return HCCL_SUCCESS;
      68              : }
      69              : 
      70            0 : HcclResult CannErrorReporter::UpdateSensorNode(uint32_t deviceId, ReportStatus reportStatus)
      71              : {
      72            0 :     if (sensorHandle_ == DEFAULT_SENSOR_HANDLE || devId_ != deviceId) {
      73            0 :         CHK_PRT_RET(Init(deviceId) != HCCL_SUCCESS,
      74              :             HCCL_RUN_WARNING("[CannErrorReporter][UpdateSensorNode] fail to get a valid node sensor."),
      75              :             HCCL_E_INTERNAL);
      76              :     }
      77            0 :     uint64_t handle = sensorHandle_;
      78              : 
      79            0 :     auto iter = status2Event_.find(reportStatus);
      80            0 :     if (iter == status2Event_.end()) {
      81            0 :         HCCL_RUN_WARNING("[CannErrorReporter][UpdateSensorNode] "
      82              :             "unknown reportStatus[%u], fail to find corresponding event type, update node sensor fail.",
      83              :             reportStatus);
      84            0 :         return HCCL_E_NOT_SUPPORT;
      85              :     }
      86            0 :     int32_t eventType = static_cast<int32_t>(iter->second.first);
      87            0 :     HcclGeneralEventType eventAssert = iter->second.second;
      88              : 
      89            0 :     HCCL_INFO("[CannErrorReporter][UpdateSensorNode]updating sensor, "
      90              :         "deviceId[%u], reportStatus[%u], event val[%u], event assert[%u].",
      91              :         deviceId, reportStatus, eventType, eventAssert);
      92              : 
      93            0 :     CHK_PRT_RET(hrtHalSensorNodeUpdateState(deviceId, handle, eventType, eventAssert) != HCCL_SUCCESS,
      94              :         HCCL_RUN_WARNING("[CannErrorReporter][UpdateSensorNode] "
      95              :             "update sensor node fail, deviceId[%u], reportStatus[%u], val[%d], handle[%llu].",
      96              :             deviceId, reportStatus, eventType, handle),
      97              :         HCCL_E_INTERNAL);
      98              : 
      99            0 :     HCCL_RUN_INFO("[CannErrorReporter][UpdateSensorNode] send report success, "
     100              :         "deviceId[%u], reportStatus[%u], val[%d], handle[%llu].",
     101              :         deviceId, reportStatus, eventType, handle);
     102            0 :     return HCCL_SUCCESS;
     103              : }
     104              : 
     105            0 : HcclResult CannErrorReporter::RegisterSensorNode(uint32_t deviceId, uint64_t *handle)
     106              : {
     107            0 :     HcclResult ret = hrtHalSensorNodeRegister(deviceId, handle);
     108            0 :     CHK_PRT_RET(ret != HCCL_SUCCESS,
     109              :         HCCL_RUN_WARNING("[CannErrorReporter][RegisterSensorNode] register sensor node fail, device id[%u].", deviceId),
     110              :         HCCL_E_INTERNAL);
     111              : 
     112            0 :     HCCL_INFO("[CannErrorReporter][RegisterSensorNode] register node sensor success, deviceId[%u], handle[%llu].",
     113              :         deviceId, *handle);
     114            0 :     return HCCL_SUCCESS;
     115              : }
     116              : 
     117            0 : HcclResult CannErrorReporter::UnRegisterSensorNode(uint32_t deviceId, uint64_t handle)
     118              : {
     119            0 :     HcclResult ret = hrtHalSensorNodeUnregister(deviceId, handle);
     120            0 :     CHK_PRT_RET(ret != HCCL_SUCCESS,
     121              :         HCCL_RUN_WARNING("[CannErrorReporter][UnRegisterSensorNode] "
     122              :         "unregister sensor node fail, device id[%u], handle[%llu].", deviceId, handle), HCCL_E_INTERNAL);
     123            0 :     HCCL_INFO("[CannErrorReporter][UpdateSensorNode]unregister sensor success, device id[%u], handle[%llu].",
     124              :         deviceId, handle);
     125              : 
     126            0 :     return HCCL_SUCCESS;
     127              : }
     128              : 
     129              : } // namespace