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() { return IDE_DAEMON_OK; }
      33            4 : int32_t AdxSockEpoll::EpollCtl(EpollHandle handle, EpollEvent& event, int32_t op)
      34              : {
      35            4 :     if (ep_ == -1 || handle == ADX_INVALID_HANDLE) {
      36            1 :         IDE_LOGE("sock epoll ctl input error");
      37            1 :         return IDE_DAEMON_ERROR;
      38              :     }
      39              : 
      40            3 :     auto fd = static_cast<int32_t>(handle);
      41            3 :     if (fd < 0) {
      42            0 :         IDE_LOGE("sock epoll ctl handle error");
      43            0 :         return IDE_DAEMON_ERROR;
      44              :     }
      45            3 :     struct epoll_event ev = {0};
      46            3 :     ev.events = EpollEventToHdcEvent(event.events);
      47            3 :     ev.data.fd = fd;
      48            3 :     int32_t ret = epoll_ctl(ep_, op, fd, &ev);
      49            3 :     if (ret < 0) {
      50            0 :         IDE_LOGE("sock epoll ctl process error %d", ret);
      51              :     }
      52            3 :     return IDE_DAEMON_OK;
      53              : }
      54              : 
      55            1 : int32_t AdxSockEpoll::EpollAdd(EpollHandle target, EpollEvent& event) { return EpollCtl(target, event, EPOLL_CTL_ADD); }
      56              : 
      57            1 : int32_t AdxSockEpoll::EpollDel(EpollHandle target, EpollEvent& event) { return EpollCtl(target, event, EPOLL_CTL_DEL); }
      58              : 
      59            3 : int32_t AdxSockEpoll::EpollWait(std::vector<EpollEvent>& events, int32_t size, int32_t timeout)
      60              : {
      61            3 :     if (ep_ < 0) {
      62            0 :         IDE_LOGW("epoll wait init");
      63            0 :         return IDE_DAEMON_ERROR;
      64              :     }
      65              : 
      66            3 :     struct epoll_event epEvent[DEFAULT_EPOLL_SIZE] = {{0}};
      67            3 :     int32_t ret = epoll_wait(ep_, epEvent, size, timeout);
      68            3 :     if (ret < 0) {
      69            2 :         IDE_LOGE("epoll wait process error");
      70            2 :         return IDE_DAEMON_ERROR;
      71              :     }
      72              : 
      73            2 :     for (int32_t i = 0; i < ret && i < epMaxSize_; i++) {
      74            1 :         events[i].events = HdcEventToEpollEvent(epEvent[i].events);
      75            1 :         events[i].data = epEvent[i].data.fd;
      76              :     }
      77              : 
      78            1 :     return ret;
      79              : }
      80              : 
      81            1 : int32_t AdxSockEpoll::EpollErrorHandle() { return IDE_DAEMON_OK; }
      82              : 
      83            1 : int32_t AdxSockEpoll::EpollGetSize() { return epMaxSize_; }
      84              : 
      85            3 : uint32_t AdxSockEpoll::EpollEventToHdcEvent(uint32_t events) const
      86              : {
      87            3 :     uint32_t transed = ((events & ADX_EPOLL_DATA_IN) != 0) ? EPOLLIN : 0;
      88            3 :     transed |= ((events & ADX_EPOLL_CONN_IN) != 0) ? EPOLLIN : 0;
      89            3 :     transed |= ((events & ADX_EPOLL_HANG_UP) != 0) ? EPOLLHUP : 0;
      90            3 :     return transed;
      91              : }
      92              : 
      93            1 : uint32_t AdxSockEpoll::HdcEventToEpollEvent(uint32_t events) const
      94              : {
      95            1 :     uint32_t transed = ((events & EPOLLIN) != 0) ? ADX_EPOLL_DATA_IN : 0;
      96            1 :     transed |= ((events & EPOLLIN) != 0) ? ADX_EPOLL_CONN_IN : 0;
      97            1 :     transed |= ((events & EPOLLHUP) != 0) ? ADX_EPOLL_HANG_UP : 0;
      98              : 
      99            1 :     return transed;
     100              : }
     101              : } // namespace Adx