1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "nstackx_event.h"
16 #include "nstackx_log.h"
17 #include "nstackx_error.h"
18 #include "nstackx_util.h"
19 #include "nstackx_epoll.h"
20 #include "securec.h"
21
22 #define TAG "nStackXEvent"
23
24 typedef struct {
25 EventHandle handle;
26 void *arg;
27 } EventInfo;
28
29 EventNode *SearchEventNode(const List *eventNodeChain, EpollDesc epollfd);
30
CloseNodePipe(const EventNode * node)31 void CloseNodePipe(const EventNode *node)
32 {
33 CloseDesc(node->pipeFd[PIPE_OUT]);
34 CloseDesc(node->pipeFd[PIPE_IN]);
35 }
36
EventProcessHandle(void * arg)37 static void EventProcessHandle(void *arg)
38 {
39 int32_t ret;
40 EventInfo event = {0};
41 EpollTask *task = arg;
42 EventNode *node = container_of(task, EventNode, task);
43
44 #ifdef NSTACKX_WITH_LITEOS_M
45 ret = (int32_t)recvfrom(node->pipeFd[PIPE_OUT], &event, sizeof(event), 0, NULL, NULL);
46 #else
47 ret = (int32_t)read(node->pipeFd[PIPE_OUT], &event, sizeof(event));
48 #endif
49 if (ret != (int32_t)sizeof(event)) {
50 LOGE(TAG, "failed to read from pipe: %d", GetErrno());
51 return;
52 }
53
54 if (event.handle != NULL) {
55 event.handle(event.arg);
56 }
57 }
58
PostEvent(const List * eventNodeChain,EpollDesc epollfd,EventHandle handle,void * arg)59 int32_t PostEvent(const List *eventNodeChain, EpollDesc epollfd, EventHandle handle, void *arg)
60 {
61 int32_t ret;
62 EventNode *node = NULL;
63 EventInfo event = {
64 .handle = handle,
65 .arg = arg,
66 };
67
68 if (eventNodeChain == NULL || handle == NULL) {
69 return NSTACKX_EINVAL;
70 }
71
72 node = SearchEventNode(eventNodeChain, epollfd);
73 if (node == NULL) {
74 LOGE(TAG, "Cannot find event node for %d", epollfd->recvFd);
75 return NSTACKX_EFAILED;
76 }
77 #ifdef NSTACKX_WITH_LITEOS_M
78 ret = (int32_t)sendto(node->pipeFd[PIPE_IN], &event, sizeof(event), 0, NULL, 0);
79 #else
80 ret = (int32_t)write(node->pipeFd[PIPE_IN], &event, sizeof(event));
81 #endif
82 if (ret != (int32_t)sizeof(event)) {
83 LOGE(TAG, "failed to write to pipe: %d", errno);
84 return NSTACKX_EFAILED;
85 }
86
87 return NSTACKX_EOK;
88 }
89
ClearEvent(const List * eventNodeChain,EpollDesc epollfd)90 void ClearEvent(const List *eventNodeChain, EpollDesc epollfd)
91 {
92 EventNode *node = NULL;
93 EventInfo event = {0};
94 int32_t eventLen = (int32_t)sizeof(event);
95 if (eventNodeChain == NULL) {
96 LOGE(TAG, "eventNodeChain is null");
97 return;
98 }
99
100 node = SearchEventNode(eventNodeChain, epollfd);
101 if (node == NULL) {
102 return;
103 }
104
105 int32_t ret = eventLen;
106 while (ret == eventLen) {
107 #ifdef NSTACKX_WITH_LITEOS_M
108 ret = (int32_t)recvfrom(node->pipeFd[PIPE_OUT], &event, sizeof(event), 0, NULL, NULL);
109 #else
110 ret = (int32_t)read(node->pipeFd[PIPE_OUT], &event, sizeof(event));
111 #endif
112 if (ret != eventLen) {
113 break;
114 }
115
116 if (event.handle != NULL) {
117 event.handle(event.arg);
118 }
119 }
120 }
121
CreateNonBlockPipe(EventNode * node)122 static int32_t CreateNonBlockPipe(EventNode *node)
123 {
124 struct EpollDescStr fds;
125
126 if (CreateEpollFdPair(&fds) != NSTACKX_EOK) {
127 LOGE(TAG, "CreateEpollFdPair failed");
128 return NSTACKX_EFAILED;
129 }
130
131 node->pipeFd[PIPE_OUT] = fds.recvFd;
132 node->pipeFd[PIPE_IN] = fds.sendFd;
133
134 return NSTACKX_EOK;
135 }
136
EventModuleInit(List * eventNodeChain,EpollDesc epollfd)137 int32_t EventModuleInit(List *eventNodeChain, EpollDesc epollfd)
138 {
139 List *pos = NULL;
140 EventNode *node = NULL;
141 if (eventNodeChain == NULL) {
142 LOGE(TAG, "eventNodeChain is null");
143 return NSTACKX_EINVAL;
144 }
145 LIST_FOR_EACH(pos, eventNodeChain) {
146 node = (EventNode *)pos;
147 if (IsEpollDescEqual(node->epollfd, epollfd)) {
148 return NSTACKX_EOK;
149 }
150 }
151
152 node = calloc(1, sizeof(EventNode));
153 if (node == NULL) {
154 LOGE(TAG, "calloc failed");
155 return NSTACKX_ENOMEM;
156 }
157
158 if (CreateNonBlockPipe(node) != NSTACKX_EOK) {
159 LOGE(TAG, "create pipe failed");
160 goto L_ERR_FAILED;
161 }
162
163 node->task.taskfd = node->pipeFd[PIPE_OUT];
164 node->task.epollfd = epollfd;
165 node->task.readHandle = EventProcessHandle;
166
167 node->epollfd = epollfd;
168 if (RegisterEpollTask(&node->task, EPOLLIN) != NSTACKX_EOK) {
169 LOGE(TAG, "RegisterEpollTask failed");
170 CloseNodePipe(node);
171 goto L_ERR_FAILED;
172 }
173
174 ListInsertTail(eventNodeChain, &(node->list));
175 return NSTACKX_EOK;
176 L_ERR_FAILED:
177 free(node);
178 return NSTACKX_EFAILED;
179 }
180
DeleteEventNode(EventNode * node)181 void DeleteEventNode(EventNode *node)
182 {
183 ListRemoveNode(&node->list);
184 if (DeRegisterEpollTask(&node->task) != NSTACKX_EOK) {
185 LOGE(TAG, "DeRegisterEpollTask failed");
186 }
187 CloseNodePipe(node);
188 free(node);
189 }
190