blob: 0a74a771476655ff4e5bd3dbc9d3ca42da018d64 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright 2024-2025, Amlal El Mahrouss (amlal@nekernel.org)
// Licensed under the Apache License, Version 2.0 (see LICENSE file)
// Official repository: https://github.com/nekernel-org/nekernel
#ifndef KERNELKIT_TLS_H
#define KERNELKIT_TLS_H
/// @author Amlal El Mahrouss
/// @file Semaphore.h
/// @brief Semaphore structure and functions for synchronization in the kernel.
#include <CompilerKit/CompilerKit.h>
#include <KernelKit/Timer.h>
#include <NeKit/Config.h>
#define kSemaphoreOwnerIndex (0U)
#define kSemaphoreCountIndex (1U)
#define kSemaphoreCount (2U)
#define kSemaphoreIncrementOwner(sem) (sem[kSemaphoreOwnerIndex]++)
#define kSemaphoreDecrementOwner(sem) (sem[kSemaphoreOwnerIndex]--)
namespace Kernel {
/// @brief Semaphore structure used for synchronization.
using SemaphoreArr = UInt64[kSemaphoreCount];
/// @brief Checks if the semaphore is valid.
inline bool rtl_sem_is_valid(const SemaphoreArr& sem, UInt64 owner = 0) {
return sem[kSemaphoreOwnerIndex] == owner && sem[kSemaphoreCountIndex] > 0;
}
/// @brief Releases the semaphore, resetting its owner and count.
/// @param sem
/// @return
inline bool rtl_sem_release(SemaphoreArr& sem) {
sem[kSemaphoreOwnerIndex] = 0;
sem[kSemaphoreCountIndex] = 0;
return true;
}
/// @brief Initializes the semaphore with an owner and a count of zero.
/// @param sem the semaphore array to use.
/// @param owner the owner to set, could be anything identifitable.
/// @return
inline bool rtl_sem_acquire(SemaphoreArr& sem, const UInt64 owner) {
if (!owner) {
err_global_get() = kErrorInvalidData;
return false; // Invalid owner
}
sem[kSemaphoreOwnerIndex] = owner;
sem[kSemaphoreCountIndex] = 0;
return true;
}
/// @brief Waits for the semaphore to be available, blocking until it is.
/// @param sem
/// @param timeout
/// @param condition condition pointer.
/// @return
inline bool rtl_sem_wait(SemaphoreArr& sem, const UInt64 owner, const UInt64 timeout,
bool& condition) {
if (!rtl_sem_is_valid(sem, owner)) {
return false;
}
if (timeout < 1) {
err_global_get() = kErrorTimeout;
return false;
}
if (!condition) {
if (sem[kSemaphoreCountIndex] == 0) {
err_global_get() = kErrorUnavailable;
return false;
}
err_global_get() = kErrorSuccess;
sem[kSemaphoreCountIndex]--;
return true;
}
HardwareTimer timer(timeout);
bool ret = timer.Wait();
if (ret) {
if (!condition) {
if (sem[kSemaphoreCountIndex] == 0) {
err_global_get() = kErrorUnavailable;
return false;
}
err_global_get() = kErrorSuccess;
sem[kSemaphoreCountIndex]--;
return true;
}
}
err_global_get() = kErrorTimeout;
return false; // Failed to acquire semaphore
}
} // namespace Kernel
#endif // !KERNELKIT_TLS_H
|
