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 "scd_map.h"
      12              : #include "scd_log.h"
      13              : #include "adiag_utils.h"
      14              : 
      15            0 : uintptr_t ScdMapGetRelPc(ScdMap *map, uintptr_t absPc)
      16              : {
      17            0 :     return absPc - (map->start - map->offset) + map->dl.elf.memory->data + map->dl.elf.loadBias;
      18              : }
      19              : 
      20            0 : uintptr_t ScdMapGetBase(ScdMap *map)
      21              : {
      22            0 :     return map->start - (uintptr_t)map->offset;
      23              : }
      24              : 
      25              : /**
      26              :  * @brief       update map node based on start addr and end addr
      27              :  * @param [in]  map:        map node
      28              :  * @param [in]  start:      start addr
      29              :  * @param [in]  end:        end addr
      30              :  * @param [in]  offset:     offset
      31              :  * @return      NA
      32              :  */
      33         5356 : TraStatus ScdMapUpdata(ScdMap *map, uintptr_t start, uintptr_t end, size_t offset)
      34              : {
      35         5356 :     SCD_CHK_PTR_ACTION(map, return TRACE_FAILURE);
      36         5356 :     if ((map->end != start) && (map->start != end)) {
      37           46 :         return TRACE_FAILURE;
      38              :     }
      39              : 
      40         5310 :     map->start  = SCD_MIN(start, map->start);
      41         5310 :     map->end    = SCD_MAX(end, map->end);
      42         5310 :     map->offset = SCD_MIN(offset, map->offset);
      43         5310 :     return TRACE_SUCCESS;
      44              : }
      45              : 
      46          959 : STATIC TraStatus ScdMapInit(ScdMap *map, uintptr_t start, uintptr_t end, size_t offset, const char *name)
      47              : {
      48              :     // obtain the data from the file.
      49              :     // fault tolerance processing will be added later : if failed from the file, use the ptrace to obtain the data
      50          959 :     SCD_CHK_PTR_ACTION(name, return TRACE_FAILURE);
      51              : 
      52              :     // map
      53          959 :     map->name = strdup(name);
      54          959 :     SCD_CHK_PTR_ACTION(map->name, return TRACE_FAILURE);
      55              : 
      56          959 :     map->nameLength = strlen(name);
      57          959 :     map->start = start;
      58          959 :     map->end = end;
      59          959 :     map->offset = offset;
      60              : 
      61              :     // dl
      62          959 :     TraStatus ret = ScdDlInit(&map->dl);
      63          959 :     if (ret != TRACE_SUCCESS) {
      64           16 :         SCD_DLOG_ERR("dl[%s] init failed.", name);
      65           16 :         ADIAG_SAFE_FREE(map->name);
      66           16 :         return TRACE_FAILURE;
      67              :     }
      68          943 :     return TRACE_SUCCESS;
      69              : }
      70              : 
      71          943 : STATIC void ScdMapUninit(ScdMap *map)
      72              : {
      73          943 :     SCD_CHK_PTR_ACTION(map, return);
      74          943 :     ScdDlUninit(&map->dl);
      75          943 :     ADIAG_SAFE_FREE(map->name);
      76              : }
      77              : 
      78              : /**
      79              :  * @brief       create map node
      80              :  * @param [in]  start:      start addr
      81              :  * @param [in]  end:        end addr
      82              :  * @param [in]  offset:     offset
      83              :  * @param [in]  name:       dynamic library name
      84              :  * @return      ScdMap *
      85              :  */
      86          959 : ScdMap *ScdMapCreate(uintptr_t start, uintptr_t end, size_t offset, const char *name)
      87              : {
      88          959 :     ScdMap *map = (ScdMap *)AdiagMalloc(sizeof(ScdMap)); 
      89          959 :     if (map != NULL) {
      90          959 :         TraStatus ret = ScdMapInit(map, start, end, offset, name);
      91          959 :         if (ret != TRACE_SUCCESS) {
      92           16 :             SCD_DLOG_ERR("init map in %s failed, ret = %d", name, ret);
      93           16 :             ADIAG_SAFE_FREE(map);
      94              :         }
      95              :     }
      96          959 :     return map;
      97              : }
      98              : 
      99              : /**
     100              :  * @brief       destroy a map node
     101              :  * @param [in]  map:        a map node
     102              :  * @return      NA
     103              :  */
     104          943 : void ScdMapDestroy(ScdMap **map)
     105              : {
     106          943 :     SCD_CHK_PTR_ACTION(map, return);
     107          943 :     ScdMapUninit(*map);
     108          943 :     ADIAG_SAFE_FREE(*map);
     109              : }