FreeRDP
Loading...
Searching...
No Matches
interlocked.c
1
20#include <winpr/config.h>
21
22#include <winpr/assert.h>
23#include <winpr/wlog.h>
24#include <winpr/platform.h>
25#include <winpr/synch.h>
26#include <winpr/handle.h>
27
28#include <winpr/interlocked.h>
29
30/* Singly-Linked List */
31
32#ifndef _WIN32
33
34#include <stdio.h>
35#include <stdlib.h>
36
37VOID InitializeSListHead(WINPR_PSLIST_HEADER ListHead)
38{
39 WINPR_ASSERT(ListHead);
40#ifdef _WIN64
41 ListHead->s.Alignment = 0;
42 ListHead->s.Region = 0;
43 ListHead->Header8.Init = 1;
44#else
45 ListHead->Alignment = 0;
46#endif
47}
48
49WINPR_PSLIST_ENTRY InterlockedPushEntrySList(WINPR_PSLIST_HEADER ListHead,
50 WINPR_PSLIST_ENTRY ListEntry)
51{
52 WINPR_SLIST_HEADER old = { 0 };
53 WINPR_SLIST_HEADER newHeader = { 0 };
54
55 WINPR_ASSERT(ListHead);
56 WINPR_ASSERT(ListEntry);
57#ifdef _WIN64
58 newHeader.HeaderX64.NextEntry = (((ULONG_PTR)ListEntry) >> 4);
59
60 while (1)
61 {
62 old = *ListHead;
63
64 ListEntry->Next = (PSLIST_ENTRY)(((ULONG_PTR)old.HeaderX64.NextEntry) << 4);
65
66 newHeader.HeaderX64.Depth = old.HeaderX64.Depth + 1;
67 newHeader.HeaderX64.Sequence = old.HeaderX64.Sequence + 1;
68
69 if (InterlockedCompareExchange64((LONGLONG*)ListHead, newHeader).Alignment, old).Alignment))
70 {
71 InterlockedCompareExchange64(&((LONGLONG*)ListHead)[1], newHeader).Region,
72 old).Region);
73 break;
74 }
75 }
76
77 return (PSLIST_ENTRY)((ULONG_PTR)old.HeaderX64.NextEntry << 4);
78#else
79 newHeader.s.Next.Next = ListEntry;
80
81 do
82 {
83 old = *ListHead;
84 ListEntry->Next = old.s.Next.Next;
85 newHeader.s.Depth = old.s.Depth + 1;
86 newHeader.s.Sequence = old.s.Sequence + 1;
87 if (old.Alignment > INT64_MAX)
88 return NULL;
89 if (newHeader.Alignment > INT64_MAX)
90 return NULL;
91 if (ListHead->Alignment > INT64_MAX)
92 return NULL;
93 } while (InterlockedCompareExchange64((LONGLONG*)&ListHead->Alignment,
94 (LONGLONG)newHeader.Alignment,
95 (LONGLONG)old.Alignment) != (LONGLONG)old.Alignment);
96
97 return old.s.Next.Next;
98#endif
99}
100
101WINPR_PSLIST_ENTRY InterlockedPushListSListEx(WINPR_ATTR_UNUSED WINPR_PSLIST_HEADER ListHead,
102 WINPR_ATTR_UNUSED WINPR_PSLIST_ENTRY List,
103 WINPR_ATTR_UNUSED WINPR_PSLIST_ENTRY ListEnd,
104 WINPR_ATTR_UNUSED ULONG Count)
105{
106 WINPR_ASSERT(ListHead);
107 WINPR_ASSERT(List);
108 WINPR_ASSERT(ListEnd);
109
110 WLog_ERR("TODO", "TODO: implement");
111#ifdef _WIN64
112
113#else
114
115#endif
116 return NULL;
117}
118
119WINPR_PSLIST_ENTRY InterlockedPopEntrySList(WINPR_PSLIST_HEADER ListHead)
120{
121 WINPR_SLIST_HEADER old = { 0 };
122 WINPR_SLIST_HEADER newHeader = { 0 };
123 WINPR_PSLIST_ENTRY entry = NULL;
124
125 WINPR_ASSERT(ListHead);
126
127#ifdef _WIN64
128 while (1)
129 {
130 old = *ListHead;
131
132 entry = (PSLIST_ENTRY)(((ULONG_PTR)old.HeaderX64.NextEntry) << 4);
133
134 if (!entry)
135 return NULL;
136
137 newHeader.HeaderX64.NextEntry = ((ULONG_PTR)entry->Next) >> 4;
138 newHeader.HeaderX64.Depth = old.HeaderX64.Depth - 1;
139 newHeader.HeaderX64.Sequence = old.HeaderX64.Sequence - 1;
140
141 if (InterlockedCompareExchange64((LONGLONG*)ListHead, newHeader).Alignment, old).Alignment))
142 {
143 InterlockedCompareExchange64(&((LONGLONG*)ListHead)[1], newHeader).Region,
144 old).Region);
145 break;
146 }
147 }
148#else
149 do
150 {
151 old = *ListHead;
152
153 entry = old.s.Next.Next;
154
155 if (!entry)
156 return NULL;
157
158 newHeader.s.Next.Next = entry->Next;
159 newHeader.s.Depth = old.s.Depth - 1;
160 newHeader.s.Sequence = old.s.Sequence + 1;
161
162 if (old.Alignment > INT64_MAX)
163 return NULL;
164 if (newHeader.Alignment > INT64_MAX)
165 return NULL;
166 if (ListHead->Alignment > INT64_MAX)
167 return NULL;
168 } while (InterlockedCompareExchange64((LONGLONG*)&ListHead->Alignment,
169 (LONGLONG)newHeader.Alignment,
170 (LONGLONG)old.Alignment) != (LONGLONG)old.Alignment);
171#endif
172 return entry;
173}
174
175WINPR_PSLIST_ENTRY InterlockedFlushSList(WINPR_PSLIST_HEADER ListHead)
176{
177 WINPR_SLIST_HEADER old = { 0 };
178 WINPR_SLIST_HEADER newHeader = { 0 };
179
180 WINPR_ASSERT(ListHead);
181 if (!QueryDepthSList(ListHead))
182 return NULL;
183
184#ifdef _WIN64
185 newHeader).Alignment = 0;
186 newHeader).Region = 0;
187 newHeader.HeaderX64.HeaderType = 1;
188
189 while (1)
190 {
191 old = *ListHead;
192 newHeader.HeaderX64.Sequence = old.HeaderX64.Sequence + 1;
193
194 if (InterlockedCompareExchange64((LONGLONG*)ListHead, newHeader).Alignment, old).Alignment))
195 {
196 InterlockedCompareExchange64(&((LONGLONG*)ListHead)[1], newHeader).Region,
197 old).Region);
198 break;
199 }
200 }
201
202 return (PSLIST_ENTRY)(((ULONG_PTR)old.HeaderX64.NextEntry) << 4);
203#else
204 newHeader.Alignment = 0;
205
206 do
207 {
208 old = *ListHead;
209 newHeader.s.Sequence = old.s.Sequence + 1;
210
211 if (old.Alignment > INT64_MAX)
212 return NULL;
213 if (newHeader.Alignment > INT64_MAX)
214 return NULL;
215 if (ListHead->Alignment > INT64_MAX)
216 return NULL;
217 } while (InterlockedCompareExchange64((LONGLONG*)&ListHead->Alignment,
218 (LONGLONG)newHeader.Alignment,
219 (LONGLONG)old.Alignment) != (LONGLONG)old.Alignment);
220
221 return old.s.Next.Next;
222#endif
223}
224
225USHORT QueryDepthSList(WINPR_PSLIST_HEADER ListHead)
226{
227 WINPR_ASSERT(ListHead);
228
229#ifdef _WIN64
230 return ListHead->HeaderX64.Depth;
231#else
232 return ListHead->s.Depth;
233#endif
234}
235
236LONG InterlockedIncrement(LONG volatile* Addend)
237{
238 WINPR_ASSERT(Addend);
239
240#if defined(__GNUC__) || defined(__clang__)
241 WINPR_PRAGMA_DIAG_PUSH
242 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
243 return __sync_add_and_fetch(Addend, 1);
244 WINPR_PRAGMA_DIAG_POP
245#else
246 return 0;
247#endif
248}
249
250LONG InterlockedDecrement(LONG volatile* Addend)
251{
252 WINPR_ASSERT(Addend);
253
254#if defined(__GNUC__) || defined(__clang__)
255 WINPR_PRAGMA_DIAG_PUSH
256 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
257 return __sync_sub_and_fetch(Addend, 1);
258 WINPR_PRAGMA_DIAG_POP
259#else
260 return 0;
261#endif
262}
263
264LONG InterlockedExchange(LONG volatile* Target, LONG Value)
265{
266 WINPR_ASSERT(Target);
267
268#if defined(__GNUC__) || defined(__clang__)
269 WINPR_PRAGMA_DIAG_PUSH
270 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
271 return __sync_val_compare_and_swap(Target, *Target, Value);
272 WINPR_PRAGMA_DIAG_POP
273#else
274 return 0;
275#endif
276}
277
278LONG InterlockedExchangeAdd(LONG volatile* Addend, LONG Value)
279{
280 WINPR_ASSERT(Addend);
281
282#if defined(__GNUC__) || defined(__clang__)
283 WINPR_PRAGMA_DIAG_PUSH
284 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
285 return __sync_fetch_and_add(Addend, Value);
286 WINPR_PRAGMA_DIAG_POP
287#else
288 return 0;
289#endif
290}
291
292LONG InterlockedCompareExchange(LONG volatile* Destination, LONG Exchange, LONG Comperand)
293{
294 WINPR_ASSERT(Destination);
295
296#if defined(__GNUC__) || defined(__clang__)
297 WINPR_PRAGMA_DIAG_PUSH
298 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
299 return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
300 WINPR_PRAGMA_DIAG_POP
301#else
302 return 0;
303#endif
304}
305
306PVOID InterlockedCompareExchangePointer(PVOID volatile* Destination, PVOID Exchange,
307 PVOID Comperand)
308{
309 WINPR_ASSERT(Destination);
310
311#if defined(__GNUC__) || defined(__clang__)
312 WINPR_PRAGMA_DIAG_PUSH
313 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
314 return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
315 WINPR_PRAGMA_DIAG_POP
316#else
317 return 0;
318#endif
319}
320
321#endif /* _WIN32 */
322
323#if defined(_WIN32) && !defined(WINPR_INTERLOCKED_COMPARE_EXCHANGE64)
324
325/* InterlockedCompareExchange64 already defined */
326
327#elif defined(_WIN32) && defined(WINPR_INTERLOCKED_COMPARE_EXCHANGE64)
328
329static volatile HANDLE mutex = NULL;
330
331BOOL static_mutex_lock(volatile HANDLE* static_mutex)
332{
333 if (*static_mutex == NULL)
334 {
335 HANDLE handle;
336
337 if (!(handle = CreateMutex(NULL, FALSE, NULL)))
338 return FALSE;
339
340 if (InterlockedCompareExchangePointer((PVOID*)static_mutex, (PVOID)handle, NULL) != NULL)
341 (void)CloseHandle(handle);
342 }
343
344 return (WaitForSingleObject(*static_mutex, INFINITE) == WAIT_OBJECT_0);
345}
346
347LONGLONG InterlockedCompareExchange64(LONGLONG volatile* Destination, LONGLONG Exchange,
348 LONGLONG Comperand)
349{
350 LONGLONG previousValue = 0;
351 BOOL locked = static_mutex_lock(&mutex);
352
353 previousValue = *Destination;
354
355 if (*Destination == Comperand)
356 *Destination = Exchange;
357
358 if (locked)
359 (void)ReleaseMutex(mutex);
360 else
361 (void)fprintf(stderr,
362 "WARNING: InterlockedCompareExchange64 operation might have failed\n");
363
364 return previousValue;
365}
366
367#elif (defined(ANDROID) && ANDROID) || \
368 (defined(__GNUC__) && !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8))
369
370#include <pthread.h>
371
372static pthread_mutex_t mutex;
373
374LONGLONG InterlockedCompareExchange64(LONGLONG volatile* Destination, LONGLONG Exchange,
375 LONGLONG Comperand)
376{
377 LONGLONG previousValue = 0;
378
379 pthread_mutex_lock(&mutex);
380
381 previousValue = *Destination;
382
383 if (*Destination == Comperand)
384 *Destination = Exchange;
385
386 pthread_mutex_unlock(&mutex);
387
388 return previousValue;
389}
390
391#else
392
393LONGLONG InterlockedCompareExchange64(LONGLONG volatile* Destination, LONGLONG Exchange,
394 LONGLONG Comperand)
395{
396 WINPR_ASSERT(Destination);
397
398#if defined(__GNUC__) || defined(__clang__)
399 WINPR_PRAGMA_DIAG_PUSH
400 WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST
401 return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
402 WINPR_PRAGMA_DIAG_POP
403#else
404 return 0;
405#endif
406}
407
408#endif
409
410/* Doubly-Linked List */
411
420VOID InitializeListHead(WINPR_PLIST_ENTRY ListHead)
421{
422 WINPR_ASSERT(ListHead);
423 ListHead->Flink = ListHead->Blink = ListHead;
424}
425
426BOOL IsListEmpty(const WINPR_LIST_ENTRY* ListHead)
427{
428 WINPR_ASSERT(ListHead);
429 return (BOOL)(ListHead->Flink == ListHead);
430}
431
432BOOL RemoveEntryList(WINPR_PLIST_ENTRY Entry)
433{
434 WINPR_ASSERT(Entry);
435 WINPR_PLIST_ENTRY OldFlink = Entry->Flink;
436 WINPR_ASSERT(OldFlink);
437
438 WINPR_PLIST_ENTRY OldBlink = Entry->Blink;
439 WINPR_ASSERT(OldBlink);
440
441 OldFlink->Blink = OldBlink;
442 OldBlink->Flink = OldFlink;
443
444 return (BOOL)(OldFlink == OldBlink);
445}
446
447VOID InsertHeadList(WINPR_PLIST_ENTRY ListHead, WINPR_PLIST_ENTRY Entry)
448{
449 WINPR_ASSERT(ListHead);
450 WINPR_ASSERT(Entry);
451
452 WINPR_PLIST_ENTRY OldFlink = ListHead->Flink;
453 WINPR_ASSERT(OldFlink);
454
455 Entry->Flink = OldFlink;
456 Entry->Blink = ListHead;
457 OldFlink->Blink = Entry;
458 ListHead->Flink = Entry;
459}
460
461WINPR_PLIST_ENTRY RemoveHeadList(WINPR_PLIST_ENTRY ListHead)
462{
463 WINPR_ASSERT(ListHead);
464
465 WINPR_PLIST_ENTRY Entry = ListHead->Flink;
466 WINPR_ASSERT(Entry);
467
468 WINPR_PLIST_ENTRY Flink = Entry->Flink;
469 WINPR_ASSERT(Flink);
470
471 ListHead->Flink = Flink;
472 Flink->Blink = ListHead;
473
474 return Entry;
475}
476
477VOID InsertTailList(WINPR_PLIST_ENTRY ListHead, WINPR_PLIST_ENTRY Entry)
478{
479 WINPR_ASSERT(ListHead);
480 WINPR_ASSERT(Entry);
481
482 WINPR_PLIST_ENTRY OldBlink = ListHead->Blink;
483 WINPR_ASSERT(OldBlink);
484
485 Entry->Flink = ListHead;
486 Entry->Blink = OldBlink;
487 OldBlink->Flink = Entry;
488 ListHead->Blink = Entry;
489}
490
491WINPR_PLIST_ENTRY RemoveTailList(WINPR_PLIST_ENTRY ListHead)
492{
493 WINPR_ASSERT(ListHead);
494
495 WINPR_PLIST_ENTRY Entry = ListHead->Blink;
496 WINPR_ASSERT(Entry);
497
498 WINPR_PLIST_ENTRY Blink = Entry->Blink;
499 WINPR_ASSERT(Blink);
500
501 ListHead->Blink = Blink;
502 Blink->Flink = ListHead;
503
504 return Entry;
505}
506
507VOID AppendTailList(WINPR_PLIST_ENTRY ListHead, WINPR_PLIST_ENTRY ListToAppend)
508{
509 WINPR_ASSERT(ListHead);
510 WINPR_ASSERT(ListToAppend);
511
512 WINPR_PLIST_ENTRY ListEnd = ListHead->Blink;
513
514 ListHead->Blink->Flink = ListToAppend;
515 ListHead->Blink = ListToAppend->Blink;
516 ListToAppend->Blink->Flink = ListHead;
517 ListToAppend->Blink = ListEnd;
518}
519
520VOID PushEntryList(WINPR_PSINGLE_LIST_ENTRY ListHead, WINPR_PSINGLE_LIST_ENTRY Entry)
521{
522 WINPR_ASSERT(ListHead);
523 WINPR_ASSERT(Entry);
524
525 Entry->Next = ListHead->Next;
526 ListHead->Next = Entry;
527}
528
529WINPR_PSINGLE_LIST_ENTRY PopEntryList(WINPR_PSINGLE_LIST_ENTRY ListHead)
530{
531 WINPR_ASSERT(ListHead);
532 WINPR_PSINGLE_LIST_ENTRY FirstEntry = ListHead->Next;
533
534 if (FirstEntry != NULL)
535 ListHead->Next = FirstEntry->Next;
536
537 return FirstEntry;
538}
WINPR_SLIST_HEADER
Definition interlocked.h:126