1 /*
2 * Copyright (C) 2022 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
16 #include "hks_condition.h"
17
18 #include "hks_mem.h"
19 #include "hks_template.h"
20
21 #include <errno.h>
22 #include <pthread.h>
23 #include <stdatomic.h>
24 #include <stdbool.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 struct HksCondition {
33 volatile atomic_bool notified;
34 pthread_mutex_t mutex;
35 pthread_cond_t cond;
36 };
37
38 #define HKS_LOG_ERRNO(msg, ret) ({ int currentErrno = errno; \
39 HKS_LOG_E(msg " %" LOG_PUBLIC "d, errno %" LOG_PUBLIC "d, strerror %" LOG_PUBLIC "s", \
40 (ret), currentErrno, strerror(currentErrno)); })
41
HksConditionWait(HksCondition * condition)42 int32_t HksConditionWait(HksCondition *condition)
43 {
44 HKS_IF_NULL_LOGE_RETURN(condition, -1, "HksConditionWait condition is NULL!")
45
46 int32_t ret = pthread_mutex_lock(&condition->mutex);
47 if (ret != 0) {
48 HKS_LOG_ERRNO("HksConditionWait pthread_mutex_lock fail!", ret);
49 return ret;
50 }
51 if (atomic_load(&condition->notified)) {
52 int unlockRet = pthread_mutex_unlock(&condition->mutex);
53 if (unlockRet != 0) {
54 HKS_LOG_ERRNO("HksConditionWait notified pthread_mutex_unlock fail!", unlockRet);
55 }
56 return 0;
57 } else {
58 HKS_LOG_I("HksConditionWait begin wait...");
59 ret = pthread_cond_wait(&condition->cond, &condition->mutex);
60 if (ret != 0) {
61 HKS_LOG_ERRNO("HksConditionWait pthread_cond_wait fail!", ret);
62 }
63 int unlockRet = pthread_mutex_unlock(&condition->mutex);
64 if (unlockRet != 0) {
65 HKS_LOG_ERRNO("HksConditionWait waited pthread_mutex_unlock fail!", unlockRet);
66 }
67 return ret;
68 }
69 }
70
HksConditionNotify(HksCondition * condition)71 int32_t HksConditionNotify(HksCondition *condition)
72 {
73 HKS_IF_NULL_LOGE_RETURN(condition, -1, "HksConditionNotify condition is NULL!")
74
75 int32_t ret = pthread_mutex_lock(&condition->mutex);
76 if (ret != 0) {
77 HKS_LOG_ERRNO("HksConditionNotify pthread_mutex_lock fail!", ret);
78 return ret;
79 }
80
81 bool flag = false;
82 if (atomic_compare_exchange_strong(&condition->notified, &flag, true)) {
83 HKS_LOG_I("never pthread_cond_signal before, first time notify!");
84 } else {
85 HKS_LOG_W("do pthread_cond_signal again!");
86 }
87
88 ret = pthread_cond_signal(&condition->cond);
89 if (ret != 0) {
90 HKS_LOG_ERRNO("HksConditionNotify pthread_cond_signal fail!", ret);
91 }
92 int unlockRet = pthread_mutex_unlock(&condition->mutex);
93 if (unlockRet != 0) {
94 HKS_LOG_ERRNO("HksConditionNotify pthread_mutex_unlock fail!", unlockRet);
95 }
96 return ret;
97 }
98
HksConditionNotifyAll(HksCondition * condition)99 int32_t HksConditionNotifyAll(HksCondition *condition)
100 {
101 HKS_IF_NULL_LOGE_RETURN(condition, -1, "HksConditionNotifyAll condition is NULL!")
102
103 int32_t ret = pthread_mutex_lock(&condition->mutex);
104 if (ret != 0) {
105 HKS_LOG_ERRNO("HksConditionNotifyAll pthread_mutex_lock fail!", ret);
106 return ret;
107 }
108
109 bool flag = false;
110 if (atomic_compare_exchange_strong(&condition->notified, &flag, true)) {
111 HKS_LOG_I("never pthread_cond_broadcast before, first time notify!");
112 } else {
113 HKS_LOG_W("do pthread_cond_broadcast again!");
114 }
115
116 ret = pthread_cond_broadcast(&condition->cond);
117 if (ret != 0) {
118 HKS_LOG_ERRNO("HksConditionNotifyAll pthread_cond_broadcast fail!", ret);
119 }
120 int unlockRet = pthread_mutex_unlock(&condition->mutex);
121 if (unlockRet != 0) {
122 HKS_LOG_ERRNO("HksConditionNotifyAll pthread_mutex_unlock fail!", unlockRet);
123 }
124 return ret;
125 }
126
HksConditionCreate(void)127 HksCondition *HksConditionCreate(void)
128 {
129 HksCondition *condition = (HksCondition *)HksMalloc(sizeof(HksCondition));
130 HKS_IF_NULL_RETURN(condition, NULL)
131 atomic_store(&condition->notified, false);
132 int32_t ret = pthread_mutex_init(&condition->mutex, NULL);
133 if (ret != 0) {
134 HKS_LOG_ERRNO("HksConditionCreate pthread_mutex_init fail!", ret);
135 HKS_FREE(condition);
136 return NULL;
137 }
138
139 pthread_condattr_t attr;
140 int attrRet = pthread_condattr_init(&attr);
141 if (attrRet != 0) {
142 HKS_LOG_ERRNO("HksConditionCreate pthread_condattr_init fail!", attrRet);
143 }
144 ret = pthread_cond_init(&condition->cond, &attr);
145 attrRet = pthread_condattr_destroy(&attr);
146 if (attrRet != 0) {
147 HKS_LOG_ERRNO("HksConditionCreate pthread_condattr_destroy fail!", attrRet);
148 }
149 if (ret != 0) {
150 HKS_LOG_ERRNO("HksConditionCreate pthread_cond_init fail!", ret);
151 pthread_mutex_destroy(&condition->mutex);
152 HKS_FREE(condition);
153 return NULL;
154 }
155 return condition;
156 }
157
HksConditionDestroy(HksCondition * condition)158 void HksConditionDestroy(HksCondition* condition)
159 {
160 if (condition == NULL) {
161 HKS_LOG_E("HksConditionDestroy condition is NULL!");
162 return;
163 }
164 int ret = pthread_mutex_destroy(&condition->mutex);
165 if (ret != 0) {
166 HKS_LOG_ERRNO("HksConditionDestroy pthread_mutex_destroy fail!", ret);
167 }
168 ret = pthread_cond_destroy(&condition->cond);
169 if (ret != 0) {
170 HKS_LOG_ERRNO("HksConditionDestroy pthread_cond_destroy fail!", ret);
171 }
172 HKS_FREE(condition);
173 }
174
175 #ifdef __cplusplus
176 }
177 #endif