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              : #include "adx_sock_epoll.h"
      11              : #include <sys/epoll.h>
      12              : #include "hdc_log.h"
      13              : #include "extra_config.h"
      14              : namespace Adx {
      15            7 : int32_t AdxSockEpoll::EpollCreate(const int32_t size)
      16              : {
      17            7 :     if (size <= 0) {
      18            1 :         IDE_LOGE("epoll create size(%d) input error", size);
      19            1 :         return IDE_DAEMON_ERROR;
      20              :     }
      21              : 
      22            6 :     epMaxSize_ = size;
      23            6 :     int32_t fd = epoll_create(DEFAULT_EPOLL_SIZE);
      24            6 :     if (fd < 0) {
      25            1 :         return IDE_DAEMON_ERROR;
      26              :     }
      27              : 
      28            5 :     ep_ = fd;
      29            5 :     return IDE_DAEMON_OK;
      30              : }
      31              : 
      32            1 : int32_t AdxSockEpoll::EpollDestroy()
      33              : {
      34            1 :     return IDE_DAEMON_OK;
      35              : }
      36            4 : int32_t AdxSockEpoll::EpollCtl(EpollHandle handle, EpollEvent &event, int32_t op)
      37              : {
      38            4 :     if (ep_ == -1 || handle == ADX_INVALID_HANDLE) {
      39            1 :         IDE_LOGE("sock epoll ctl input error");
      40            1 :         return IDE_DAEMON_ERROR;
      41              :     }
      42              : 
      43            3 :     auto fd = static_cast<int32_t>(handle);
      44            3 :     if (fd < 0) {
      45            0 :         IDE_LOGE("sock epoll ctl handle error");
      46            0 :         return IDE_DAEMON_ERROR;
      47              :     }
      48            3 :     struct epoll_event ev = {0};
      49            3 :     ev.events = EpollEventToHdcEvent(event.events);
      50            3 :     ev.data.fd = fd;
      51            3 :     int32_t ret = epoll_ctl(ep_, op, fd, &ev);
      52            3 :     if (ret < 0) {
      53            0 :         IDE_LOGE("sock epoll ctl process error %d", ret);
      54              :     }
      55            3 :     return IDE_DAEMON_OK;
      56              : }
      57              : 
      58            1 : int32_t AdxSockEpoll::EpollAdd(EpollHandle target, EpollEvent &event)
      59              : {
      60            1 :     return EpollCtl(target, event, EPOLL_CTL_ADD);
      61              : }
      62              : 
      63            1 : int32_t AdxSockEpoll::EpollDel(EpollHandle target, EpollEvent &event)
      64              : {
      65            1 :     return EpollCtl(target, event, EPOLL_CTL_DEL);
      66              : }
      67              : 
      68            3 : int32_t AdxSockEpoll::EpollWait(std::vector<EpollEvent> &events, int32_t size, int32_t timeout)
      69              : {
      70            3 :     if (ep_ < 0) {
      71            0 :         IDE_LOGW("epoll wait init");
      72            0 :         return IDE_DAEMON_ERROR;
      73              :     }
      74              : 
      75            3 :     struct epoll_event epEvent[DEFAULT_EPOLL_SIZE] = { {0} };
      76            3 :     int32_t ret = epoll_wait(ep_, epEvent, size, timeout);
      77            3 :     if (ret < 0) {
      78            2 :         IDE_LOGE("epoll wait process error");
      79            2 :         return IDE_DAEMON_ERROR;
      80              :     }
      81              : 
      82            2 :     for (int32_t i = 0; i < ret && i < epMaxSize_; i++) {
      83            1 :         events[i].events = HdcEventToEpollEvent(epEvent[i].events);
      84            1 :         events[i].data = epEvent[i].data.fd;
      85              :     }
      86              : 
      87            1 :     return ret;
      88              : }
      89              : 
      90            1 : int32_t AdxSockEpoll::EpollErrorHandle()
      91              : {
      92            1 :     return IDE_DAEMON_OK;
      93              : }
      94              : 
      95            1 : int32_t AdxSockEpoll::EpollGetSize()
      96              : {
      97            1 :     return epMaxSize_;
      98              : }
      99              : 
     100            3 : uint32_t AdxSockEpoll::EpollEventToHdcEvent(uint32_t events) const
     101              : {
     102            3 :     uint32_t transed = ((events & ADX_EPOLL_DATA_IN) != 0) ? EPOLLIN : 0;
     103            3 :     transed |= ((events & ADX_EPOLL_CONN_IN) != 0) ? EPOLLIN : 0;
     104            3 :     transed |= ((events & ADX_EPOLL_HANG_UP) != 0) ? EPOLLHUP : 0;
     105            3 :     return transed;
     106              : }
     107              : 
     108            1 : uint32_t AdxSockEpoll::HdcEventToEpollEvent(uint32_t events) const
     109              : {
     110            1 :     uint32_t transed = ((events & EPOLLIN) != 0) ? ADX_EPOLL_DATA_IN : 0;
     111            1 :     transed |= ((events & EPOLLIN) != 0) ? ADX_EPOLL_CONN_IN : 0;
     112            1 :     transed |= ((events & EPOLLHUP) != 0) ? ADX_EPOLL_HANG_UP : 0;
     113              : 
     114            1 :     return transed;
     115              : }
     116              : }