]>
Commit | Line | Data |
---|---|---|
84481f76 RK |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3084fecd | 3 | -- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS -- |
84481f76 RK |
4 | -- -- |
5 | -- S Y S T E M . O S _ I N T E R F A C E -- | |
6 | -- -- | |
7 | -- S p e c -- | |
8 | -- -- | |
8a7988f5 | 9 | -- Copyright (C) 1991-1994, Florida State University -- |
6b81741c | 10 | -- Copyright (C) 1995-2011, Free Software Foundation, Inc. -- |
84481f76 | 11 | -- -- |
607d0635 | 12 | -- GNAT is free software; you can redistribute it and/or modify it under -- |
84481f76 | 13 | -- terms of the GNU General Public License as published by the Free Soft- -- |
607d0635 AC |
14 | -- ware Foundation; either version 3, or (at your option) any later ver- -- |
15 | -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |
84481f76 | 16 | -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
607d0635 AC |
17 | -- or FITNESS FOR A PARTICULAR PURPOSE. -- |
18 | -- -- | |
19 | -- As a special exception under Section 7 of GPL version 3, you are granted -- | |
20 | -- additional permissions described in the GCC Runtime Library Exception, -- | |
21 | -- version 3.1, as published by the Free Software Foundation. -- | |
22 | -- -- | |
23 | -- You should have received a copy of the GNU General Public License and -- | |
24 | -- a copy of the GCC Runtime Library Exception along with this program; -- | |
25 | -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- | |
26 | -- <http://www.gnu.org/licenses/>. -- | |
84481f76 | 27 | -- -- |
71ff80dc | 28 | -- GNARL was developed by the GNARL team at Florida State University. -- |
4f9335cd | 29 | -- Extensive contributions were provided by Ada Core Technologies, Inc. -- |
84481f76 RK |
30 | -- -- |
31 | ------------------------------------------------------------------------------ | |
32 | ||
8a7988f5 | 33 | -- This is a GNU/Linux (GNU/LinuxThreads) version of this package |
84481f76 RK |
34 | |
35 | -- This package encapsulates all direct interfaces to OS services | |
366b8af7 | 36 | -- that are needed by the tasking run-time (libgnarl). |
84481f76 | 37 | |
8a7988f5 AC |
38 | -- PLEASE DO NOT add any with-clauses to this package or remove the pragma |
39 | -- Preelaborate. This package is designed to be a bottom-level (leaf) package. | |
84481f76 | 40 | |
df862408 | 41 | with Ada.Unchecked_Conversion; |
366b8af7 | 42 | with Interfaces.C; |
770db697 | 43 | with System.Linux; |
366b8af7 | 44 | |
84481f76 RK |
45 | package System.OS_Interface is |
46 | pragma Preelaborate; | |
47 | ||
48 | pragma Linker_Options ("-lpthread"); | |
49 | ||
50 | subtype int is Interfaces.C.int; | |
51 | subtype char is Interfaces.C.char; | |
52 | subtype short is Interfaces.C.short; | |
53 | subtype long is Interfaces.C.long; | |
54 | subtype unsigned is Interfaces.C.unsigned; | |
55 | subtype unsigned_short is Interfaces.C.unsigned_short; | |
56 | subtype unsigned_long is Interfaces.C.unsigned_long; | |
57 | subtype unsigned_char is Interfaces.C.unsigned_char; | |
58 | subtype plain_char is Interfaces.C.plain_char; | |
59 | subtype size_t is Interfaces.C.size_t; | |
60 | ||
61 | ----------- | |
62 | -- Errno -- | |
63 | ----------- | |
64 | ||
65 | function errno return int; | |
66 | pragma Import (C, errno, "__get_errno"); | |
67 | ||
770db697 EB |
68 | EAGAIN : constant := System.Linux.EAGAIN; |
69 | EINTR : constant := System.Linux.EINTR; | |
70 | EINVAL : constant := System.Linux.EINVAL; | |
71 | ENOMEM : constant := System.Linux.ENOMEM; | |
72 | EPERM : constant := System.Linux.EPERM; | |
73 | ETIMEDOUT : constant := System.Linux.ETIMEDOUT; | |
84481f76 RK |
74 | |
75 | ------------- | |
76 | -- Signals -- | |
77 | ------------- | |
78 | ||
79 | Max_Interrupt : constant := 63; | |
80 | type Signal is new int range 0 .. Max_Interrupt; | |
81 | for Signal'Size use int'Size; | |
82 | ||
770db697 EB |
83 | SIGHUP : constant := System.Linux.SIGHUP; |
84 | SIGINT : constant := System.Linux.SIGINT; | |
85 | SIGQUIT : constant := System.Linux.SIGQUIT; | |
86 | SIGILL : constant := System.Linux.SIGILL; | |
87 | SIGTRAP : constant := System.Linux.SIGTRAP; | |
88 | SIGIOT : constant := System.Linux.SIGIOT; | |
89 | SIGABRT : constant := System.Linux.SIGABRT; | |
90 | SIGFPE : constant := System.Linux.SIGFPE; | |
91 | SIGKILL : constant := System.Linux.SIGKILL; | |
92 | SIGBUS : constant := System.Linux.SIGBUS; | |
93 | SIGSEGV : constant := System.Linux.SIGSEGV; | |
94 | SIGPIPE : constant := System.Linux.SIGPIPE; | |
95 | SIGALRM : constant := System.Linux.SIGALRM; | |
96 | SIGTERM : constant := System.Linux.SIGTERM; | |
97 | SIGUSR1 : constant := System.Linux.SIGUSR1; | |
98 | SIGUSR2 : constant := System.Linux.SIGUSR2; | |
99 | SIGCLD : constant := System.Linux.SIGCLD; | |
100 | SIGCHLD : constant := System.Linux.SIGCHLD; | |
101 | SIGPWR : constant := System.Linux.SIGPWR; | |
102 | SIGWINCH : constant := System.Linux.SIGWINCH; | |
103 | SIGURG : constant := System.Linux.SIGURG; | |
104 | SIGPOLL : constant := System.Linux.SIGPOLL; | |
105 | SIGIO : constant := System.Linux.SIGIO; | |
106 | SIGLOST : constant := System.Linux.SIGLOST; | |
107 | SIGSTOP : constant := System.Linux.SIGSTOP; | |
108 | SIGTSTP : constant := System.Linux.SIGTSTP; | |
109 | SIGCONT : constant := System.Linux.SIGCONT; | |
110 | SIGTTIN : constant := System.Linux.SIGTTIN; | |
111 | SIGTTOU : constant := System.Linux.SIGTTOU; | |
112 | SIGVTALRM : constant := System.Linux.SIGVTALRM; | |
113 | SIGPROF : constant := System.Linux.SIGPROF; | |
114 | SIGXCPU : constant := System.Linux.SIGXCPU; | |
115 | SIGXFSZ : constant := System.Linux.SIGXFSZ; | |
116 | SIGUNUSED : constant := System.Linux.SIGUNUSED; | |
117 | SIGSTKFLT : constant := System.Linux.SIGSTKFLT; | |
118 | SIGLTHRRES : constant := System.Linux.SIGLTHRRES; | |
119 | SIGLTHRCAN : constant := System.Linux.SIGLTHRCAN; | |
120 | SIGLTHRDBG : constant := System.Linux.SIGLTHRDBG; | |
84481f76 RK |
121 | |
122 | SIGADAABORT : constant := SIGABRT; | |
1089a00a AC |
123 | -- Change this to use another signal for task abort. SIGTERM might be a |
124 | -- good one. | |
84481f76 RK |
125 | |
126 | type Signal_Set is array (Natural range <>) of Signal; | |
127 | ||
1089a00a | 128 | Unmasked : constant Signal_Set := ( |
84481f76 RK |
129 | SIGTRAP, |
130 | -- To enable debugging on multithreaded applications, mark SIGTRAP to | |
131 | -- be kept unmasked. | |
132 | ||
133 | SIGBUS, | |
134 | ||
135 | SIGTTIN, SIGTTOU, SIGTSTP, | |
1089a00a AC |
136 | -- Keep these three signals unmasked so that background processes and IO |
137 | -- behaves as normal "C" applications | |
84481f76 RK |
138 | |
139 | SIGPROF, | |
140 | -- To avoid confusing the profiler | |
141 | ||
142 | SIGKILL, SIGSTOP, | |
1089a00a | 143 | -- These two signals actually can't be masked (POSIX won't allow it) |
84481f76 RK |
144 | |
145 | SIGLTHRRES, SIGLTHRCAN, SIGLTHRDBG); | |
1089a00a AC |
146 | -- These three signals are used by GNU/LinuxThreads starting from glibc |
147 | -- 2.1 (future 2.2). | |
84481f76 | 148 | |
1089a00a AC |
149 | Reserved : constant Signal_Set := (SIGVTALRM, SIGUNUSED); |
150 | -- Not clear why these two signals are reserved. Perhaps they are not | |
151 | -- supported by this version of GNU/Linux ??? | |
84481f76 RK |
152 | |
153 | type sigset_t is private; | |
154 | ||
155 | function sigaddset (set : access sigset_t; sig : Signal) return int; | |
156 | pragma Import (C, sigaddset, "sigaddset"); | |
157 | ||
158 | function sigdelset (set : access sigset_t; sig : Signal) return int; | |
159 | pragma Import (C, sigdelset, "sigdelset"); | |
160 | ||
161 | function sigfillset (set : access sigset_t) return int; | |
162 | pragma Import (C, sigfillset, "sigfillset"); | |
163 | ||
164 | function sigismember (set : access sigset_t; sig : Signal) return int; | |
165 | pragma Import (C, sigismember, "sigismember"); | |
166 | ||
167 | function sigemptyset (set : access sigset_t) return int; | |
168 | pragma Import (C, sigemptyset, "sigemptyset"); | |
169 | ||
170 | type union_type_3 is new String (1 .. 116); | |
171 | type siginfo_t is record | |
172 | si_signo : int; | |
173 | si_code : int; | |
174 | si_errno : int; | |
175 | X_data : union_type_3; | |
176 | end record; | |
177 | pragma Convention (C, siginfo_t); | |
178 | ||
179 | type struct_sigaction is record | |
770db697 EB |
180 | sa_handler : System.Address; |
181 | sa_mask : sigset_t; | |
182 | sa_flags : Interfaces.C.unsigned_long; | |
183 | sa_restorer : System.Address; | |
84481f76 RK |
184 | end record; |
185 | pragma Convention (C, struct_sigaction); | |
770db697 | 186 | |
84481f76 RK |
187 | type struct_sigaction_ptr is access all struct_sigaction; |
188 | ||
189 | type Machine_State is record | |
190 | eip : unsigned_long; | |
191 | ebx : unsigned_long; | |
192 | esp : unsigned_long; | |
193 | ebp : unsigned_long; | |
194 | esi : unsigned_long; | |
195 | edi : unsigned_long; | |
196 | end record; | |
197 | type Machine_State_Ptr is access all Machine_State; | |
198 | ||
770db697 EB |
199 | SA_SIGINFO : constant := System.Linux.SA_SIGINFO; |
200 | SA_ONSTACK : constant := System.Linux.SA_ONSTACK; | |
5b4994bc | 201 | |
84481f76 RK |
202 | SIG_BLOCK : constant := 0; |
203 | SIG_UNBLOCK : constant := 1; | |
204 | SIG_SETMASK : constant := 2; | |
205 | ||
206 | SIG_DFL : constant := 0; | |
207 | SIG_IGN : constant := 1; | |
208 | ||
209 | function sigaction | |
210 | (sig : Signal; | |
211 | act : struct_sigaction_ptr; | |
212 | oact : struct_sigaction_ptr) return int; | |
213 | pragma Import (C, sigaction, "sigaction"); | |
214 | ||
215 | ---------- | |
216 | -- Time -- | |
217 | ---------- | |
218 | ||
219 | type timespec is private; | |
220 | ||
221 | function To_Duration (TS : timespec) return Duration; | |
222 | pragma Inline (To_Duration); | |
223 | ||
224 | function To_Timespec (D : Duration) return timespec; | |
225 | pragma Inline (To_Timespec); | |
226 | ||
4f9335cd LG |
227 | function sysconf (name : int) return long; |
228 | pragma Import (C, sysconf); | |
229 | ||
b41ab480 PO |
230 | SC_CLK_TCK : constant := 2; |
231 | SC_NPROCESSORS_ONLN : constant := 84; | |
4f9335cd | 232 | |
84481f76 RK |
233 | ------------------------- |
234 | -- Priority Scheduling -- | |
235 | ------------------------- | |
236 | ||
237 | SCHED_OTHER : constant := 0; | |
238 | SCHED_FIFO : constant := 1; | |
239 | SCHED_RR : constant := 2; | |
240 | ||
ec946d18 AC |
241 | function To_Target_Priority |
242 | (Prio : System.Any_Priority) return Interfaces.C.int; | |
b41ab480 | 243 | -- Maps System.Any_Priority to a POSIX priority |
ec946d18 | 244 | |
84481f76 RK |
245 | ------------- |
246 | -- Process -- | |
247 | ------------- | |
248 | ||
249 | type pid_t is private; | |
250 | ||
251 | function kill (pid : pid_t; sig : Signal) return int; | |
252 | pragma Import (C, kill, "kill"); | |
253 | ||
254 | function getpid return pid_t; | |
255 | pragma Import (C, getpid, "getpid"); | |
256 | ||
257 | ------------- | |
258 | -- Threads -- | |
259 | ------------- | |
260 | ||
261 | type Thread_Body is access | |
262 | function (arg : System.Address) return System.Address; | |
b41ab480 | 263 | pragma Convention (C, Thread_Body); |
8a7988f5 AC |
264 | |
265 | function Thread_Body_Access is new | |
df862408 | 266 | Ada.Unchecked_Conversion (System.Address, Thread_Body); |
8a7988f5 | 267 | |
8a6a52dc | 268 | type pthread_t is new unsigned_long; |
1089a00a | 269 | subtype Thread_Id is pthread_t; |
84481f76 | 270 | |
1089a00a AC |
271 | function To_pthread_t is |
272 | new Ada.Unchecked_Conversion (unsigned_long, pthread_t); | |
8a6a52dc | 273 | |
84481f76 RK |
274 | type pthread_mutex_t is limited private; |
275 | type pthread_cond_t is limited private; | |
276 | type pthread_attr_t is limited private; | |
277 | type pthread_mutexattr_t is limited private; | |
278 | type pthread_condattr_t is limited private; | |
279 | type pthread_key_t is private; | |
280 | ||
281 | PTHREAD_CREATE_DETACHED : constant := 1; | |
282 | ||
283 | ----------- | |
284 | -- Stack -- | |
285 | ----------- | |
286 | ||
770db697 EB |
287 | type stack_t is record |
288 | ss_sp : System.Address; | |
289 | ss_flags : int; | |
290 | ss_size : size_t; | |
291 | end record; | |
292 | pragma Convention (C, stack_t); | |
293 | ||
294 | function sigaltstack | |
295 | (ss : not null access stack_t; | |
296 | oss : access stack_t) return int; | |
297 | pragma Import (C, sigaltstack, "sigaltstack"); | |
298 | ||
299 | Alternate_Stack : aliased System.Address; | |
300 | pragma Import (C, Alternate_Stack, "__gnat_alternate_stack"); | |
301 | -- The alternate signal stack for stack overflows | |
302 | ||
303 | Alternate_Stack_Size : constant := 16 * 1024; | |
304 | -- This must be in keeping with init.c:__gnat_alternate_stack | |
305 | ||
84481f76 RK |
306 | function Get_Stack_Base (thread : pthread_t) return Address; |
307 | pragma Inline (Get_Stack_Base); | |
308 | -- This is a dummy procedure to share some GNULLI files | |
309 | ||
310 | --------------------------------------- | |
311 | -- Nonstandard Thread Initialization -- | |
312 | --------------------------------------- | |
313 | ||
314 | procedure pthread_init; | |
315 | pragma Inline (pthread_init); | |
316 | -- This is a dummy procedure to share some GNULLI files | |
317 | ||
318 | ------------------------- | |
319 | -- POSIX.1c Section 3 -- | |
320 | ------------------------- | |
321 | ||
322 | function sigwait (set : access sigset_t; sig : access Signal) return int; | |
323 | pragma Import (C, sigwait, "sigwait"); | |
324 | ||
325 | function pthread_kill (thread : pthread_t; sig : Signal) return int; | |
326 | pragma Import (C, pthread_kill, "pthread_kill"); | |
327 | ||
84481f76 RK |
328 | function pthread_sigmask |
329 | (how : int; | |
1dd5ad55 AC |
330 | set : access sigset_t; |
331 | oset : access sigset_t) return int; | |
84481f76 RK |
332 | pragma Import (C, pthread_sigmask, "pthread_sigmask"); |
333 | ||
334 | -------------------------- | |
335 | -- POSIX.1c Section 11 -- | |
336 | -------------------------- | |
337 | ||
338 | function pthread_mutexattr_init | |
339 | (attr : access pthread_mutexattr_t) return int; | |
340 | pragma Import (C, pthread_mutexattr_init, "pthread_mutexattr_init"); | |
341 | ||
342 | function pthread_mutexattr_destroy | |
343 | (attr : access pthread_mutexattr_t) return int; | |
344 | pragma Import (C, pthread_mutexattr_destroy, "pthread_mutexattr_destroy"); | |
345 | ||
346 | function pthread_mutex_init | |
347 | (mutex : access pthread_mutex_t; | |
348 | attr : access pthread_mutexattr_t) return int; | |
349 | pragma Import (C, pthread_mutex_init, "pthread_mutex_init"); | |
350 | ||
351 | function pthread_mutex_destroy (mutex : access pthread_mutex_t) return int; | |
352 | pragma Import (C, pthread_mutex_destroy, "pthread_mutex_destroy"); | |
353 | ||
354 | function pthread_mutex_lock (mutex : access pthread_mutex_t) return int; | |
355 | pragma Import (C, pthread_mutex_lock, "pthread_mutex_lock"); | |
356 | ||
357 | function pthread_mutex_unlock (mutex : access pthread_mutex_t) return int; | |
358 | pragma Import (C, pthread_mutex_unlock, "pthread_mutex_unlock"); | |
359 | ||
360 | function pthread_condattr_init | |
361 | (attr : access pthread_condattr_t) return int; | |
362 | pragma Import (C, pthread_condattr_init, "pthread_condattr_init"); | |
363 | ||
364 | function pthread_condattr_destroy | |
365 | (attr : access pthread_condattr_t) return int; | |
366 | pragma Import (C, pthread_condattr_destroy, "pthread_condattr_destroy"); | |
367 | ||
368 | function pthread_cond_init | |
369 | (cond : access pthread_cond_t; | |
370 | attr : access pthread_condattr_t) return int; | |
371 | pragma Import (C, pthread_cond_init, "pthread_cond_init"); | |
372 | ||
373 | function pthread_cond_destroy (cond : access pthread_cond_t) return int; | |
374 | pragma Import (C, pthread_cond_destroy, "pthread_cond_destroy"); | |
375 | ||
376 | function pthread_cond_signal (cond : access pthread_cond_t) return int; | |
377 | pragma Import (C, pthread_cond_signal, "pthread_cond_signal"); | |
378 | ||
379 | function pthread_cond_wait | |
380 | (cond : access pthread_cond_t; | |
381 | mutex : access pthread_mutex_t) return int; | |
382 | pragma Import (C, pthread_cond_wait, "pthread_cond_wait"); | |
383 | ||
384 | function pthread_cond_timedwait | |
385 | (cond : access pthread_cond_t; | |
386 | mutex : access pthread_mutex_t; | |
387 | abstime : access timespec) return int; | |
388 | pragma Import (C, pthread_cond_timedwait, "pthread_cond_timedwait"); | |
389 | ||
390 | -------------------------- | |
391 | -- POSIX.1c Section 13 -- | |
392 | -------------------------- | |
393 | ||
394 | type struct_sched_param is record | |
395 | sched_priority : int; -- scheduling priority | |
396 | end record; | |
397 | pragma Convention (C, struct_sched_param); | |
398 | ||
399 | function pthread_setschedparam | |
400 | (thread : pthread_t; | |
401 | policy : int; | |
402 | param : access struct_sched_param) return int; | |
403 | pragma Import (C, pthread_setschedparam, "pthread_setschedparam"); | |
404 | ||
405 | function pthread_attr_setschedpolicy | |
406 | (attr : access pthread_attr_t; | |
407 | policy : int) return int; | |
408 | pragma Import | |
409 | (C, pthread_attr_setschedpolicy, "pthread_attr_setschedpolicy"); | |
410 | ||
411 | function sched_yield return int; | |
412 | pragma Import (C, sched_yield, "sched_yield"); | |
413 | ||
414 | --------------------------- | |
415 | -- P1003.1c - Section 16 -- | |
416 | --------------------------- | |
417 | ||
418 | function pthread_attr_init | |
419 | (attributes : access pthread_attr_t) return int; | |
420 | pragma Import (C, pthread_attr_init, "pthread_attr_init"); | |
421 | ||
422 | function pthread_attr_destroy | |
423 | (attributes : access pthread_attr_t) return int; | |
424 | pragma Import (C, pthread_attr_destroy, "pthread_attr_destroy"); | |
425 | ||
426 | function pthread_attr_setdetachstate | |
427 | (attr : access pthread_attr_t; | |
428 | detachstate : int) return int; | |
429 | pragma Import | |
430 | (C, pthread_attr_setdetachstate, "pthread_attr_setdetachstate"); | |
431 | ||
432 | function pthread_attr_setstacksize | |
433 | (attr : access pthread_attr_t; | |
434 | stacksize : size_t) return int; | |
435 | pragma Import (C, pthread_attr_setstacksize, "pthread_attr_setstacksize"); | |
436 | ||
437 | function pthread_create | |
438 | (thread : access pthread_t; | |
439 | attributes : access pthread_attr_t; | |
440 | start_routine : Thread_Body; | |
441 | arg : System.Address) return int; | |
442 | pragma Import (C, pthread_create, "pthread_create"); | |
443 | ||
444 | procedure pthread_exit (status : System.Address); | |
445 | pragma Import (C, pthread_exit, "pthread_exit"); | |
446 | ||
447 | function pthread_self return pthread_t; | |
448 | pragma Import (C, pthread_self, "pthread_self"); | |
449 | ||
442dd5fb NR |
450 | function lwp_self return System.Address; |
451 | pragma Import (C, lwp_self, "__gnat_lwp_self"); | |
452 | ||
84481f76 RK |
453 | -------------------------- |
454 | -- POSIX.1c Section 17 -- | |
455 | -------------------------- | |
456 | ||
457 | function pthread_setspecific | |
458 | (key : pthread_key_t; | |
459 | value : System.Address) return int; | |
460 | pragma Import (C, pthread_setspecific, "pthread_setspecific"); | |
461 | ||
462 | function pthread_getspecific (key : pthread_key_t) return System.Address; | |
463 | pragma Import (C, pthread_getspecific, "pthread_getspecific"); | |
464 | ||
465 | type destructor_pointer is access procedure (arg : System.Address); | |
b41ab480 | 466 | pragma Convention (C, destructor_pointer); |
84481f76 RK |
467 | |
468 | function pthread_key_create | |
469 | (key : access pthread_key_t; | |
470 | destructor : destructor_pointer) return int; | |
471 | pragma Import (C, pthread_key_create, "pthread_key_create"); | |
472 | ||
b41ab480 | 473 | CPU_SETSIZE : constant := 1_024; |
9d1e0e72 JR |
474 | -- Size of the cpu_set_t mask on most linux systems (SUSE 11 uses 4_096). |
475 | -- This is kept for backward compatibility (System.Task_Info uses it), but | |
476 | -- the run-time library does no longer rely on static masks, using | |
477 | -- dynamically allocated masks instead. | |
b41ab480 PO |
478 | |
479 | type bit_field is array (1 .. CPU_SETSIZE) of Boolean; | |
480 | for bit_field'Size use CPU_SETSIZE; | |
481 | pragma Pack (bit_field); | |
482 | pragma Convention (C, bit_field); | |
483 | ||
484 | type cpu_set_t is record | |
485 | bits : bit_field; | |
486 | end record; | |
487 | pragma Convention (C, cpu_set_t); | |
488 | ||
9d1e0e72 JR |
489 | type cpu_set_t_ptr is access all cpu_set_t; |
490 | -- In the run-time library we use this pointer because the size of type | |
491 | -- cpu_set_t varies depending on the glibc version. Hence, objects of type | |
492 | -- cpu_set_t are allocated dynamically using the number of processors | |
493 | -- available in the target machine (value obtained at execution time). | |
494 | ||
495 | function CPU_ALLOC (count : size_t) return cpu_set_t_ptr; | |
496 | pragma Import (C, CPU_ALLOC, "__gnat_cpu_alloc"); | |
497 | -- Wrapper around the CPU_ALLOC C macro | |
498 | ||
499 | function CPU_ALLOC_SIZE (count : size_t) return size_t; | |
500 | pragma Import (C, CPU_ALLOC_SIZE, "__gnat_cpu_alloc_size"); | |
501 | -- Wrapper around the CPU_ALLOC_SIZE C macro | |
502 | ||
503 | procedure CPU_FREE (cpuset : cpu_set_t_ptr); | |
504 | pragma Import (C, CPU_FREE, "__gnat_cpu_free"); | |
505 | -- Wrapper around the CPU_FREE C macro | |
506 | ||
507 | procedure CPU_ZERO (count : size_t; cpuset : cpu_set_t_ptr); | |
6b81741c | 508 | pragma Import (C, CPU_ZERO, "__gnat_cpu_zero"); |
9d1e0e72 | 509 | -- Wrapper around the CPU_ZERO_S C macro |
6b81741c | 510 | |
9d1e0e72 | 511 | procedure CPU_SET (cpu : int; count : size_t; cpuset : cpu_set_t_ptr); |
6b81741c | 512 | pragma Import (C, CPU_SET, "__gnat_cpu_set"); |
9d1e0e72 | 513 | -- Wrapper around the CPU_SET_S C macro |
6b81741c | 514 | |
b41ab480 PO |
515 | function pthread_setaffinity_np |
516 | (thread : pthread_t; | |
517 | cpusetsize : size_t; | |
9d1e0e72 | 518 | cpuset : cpu_set_t_ptr) return int; |
0ae44446 JR |
519 | pragma Import (C, pthread_setaffinity_np, "pthread_setaffinity_np"); |
520 | pragma Weak_External (pthread_setaffinity_np); | |
521 | -- Use a weak symbol because this function may be available or not, | |
522 | -- depending on the version of the system. | |
8918fe18 AC |
523 | |
524 | function pthread_attr_setaffinity_np | |
525 | (attr : access pthread_attr_t; | |
526 | cpusetsize : size_t; | |
9d1e0e72 | 527 | cpuset : cpu_set_t_ptr) return int; |
8918fe18 | 528 | pragma Import (C, pthread_attr_setaffinity_np, |
0ae44446 JR |
529 | "pthread_attr_setaffinity_np"); |
530 | pragma Weak_External (pthread_attr_setaffinity_np); | |
531 | -- Use a weak symbol because this function may be available or not, | |
532 | -- depending on the version of the system. | |
b41ab480 | 533 | |
84481f76 RK |
534 | private |
535 | ||
5e2e42ba | 536 | type sigset_t is array (0 .. 127) of unsigned_char; |
84481f76 | 537 | pragma Convention (C, sigset_t); |
770db697 EB |
538 | for sigset_t'Alignment use Interfaces.C.unsigned_long'Alignment; |
539 | ||
540 | pragma Warnings (Off); | |
541 | for struct_sigaction use record | |
e84efdce LG |
542 | sa_handler at Linux.sa_handler_pos range 0 .. Standard'Address_Size - 1; |
543 | sa_mask at Linux.sa_mask_pos range 0 .. 1023; | |
544 | sa_flags at Linux.sa_flags_pos range 0 .. Standard'Address_Size - 1; | |
770db697 EB |
545 | end record; |
546 | -- We intentionally leave sa_restorer unspecified and let the compiler | |
547 | -- append it after the last field, so disable corresponding warning. | |
548 | pragma Warnings (On); | |
84481f76 RK |
549 | |
550 | type pid_t is new int; | |
551 | ||
552 | type time_t is new long; | |
553 | ||
554 | type timespec is record | |
555 | tv_sec : time_t; | |
556 | tv_nsec : long; | |
557 | end record; | |
558 | pragma Convention (C, timespec); | |
559 | ||
84481f76 RK |
560 | type pthread_attr_t is record |
561 | detachstate : int; | |
562 | schedpolicy : int; | |
563 | schedparam : struct_sched_param; | |
564 | inheritsched : int; | |
565 | scope : int; | |
566 | guardsize : size_t; | |
567 | stackaddr_set : int; | |
568 | stackaddr : System.Address; | |
569 | stacksize : size_t; | |
570 | end record; | |
4f9335cd | 571 | pragma Convention (C, pthread_attr_t); |
84481f76 RK |
572 | |
573 | type pthread_condattr_t is record | |
574 | dummy : int; | |
575 | end record; | |
576 | pragma Convention (C, pthread_condattr_t); | |
577 | ||
578 | type pthread_mutexattr_t is record | |
579 | mutexkind : int; | |
580 | end record; | |
581 | pragma Convention (C, pthread_mutexattr_t); | |
582 | ||
770db697 | 583 | type pthread_mutex_t is new System.Linux.pthread_mutex_t; |
84481f76 | 584 | |
5e2e42ba | 585 | type unsigned_long_long_t is mod 2 ** 64; |
cb7fa356 | 586 | -- Local type only used to get it's 'Alignment below |
5e2e42ba | 587 | |
4f9335cd | 588 | type pthread_cond_t is array (0 .. 47) of unsigned_char; |
84481f76 | 589 | pragma Convention (C, pthread_cond_t); |
5e2e42ba | 590 | for pthread_cond_t'Alignment use unsigned_long_long_t'Alignment; |
84481f76 RK |
591 | |
592 | type pthread_key_t is new unsigned; | |
593 | ||
594 | end System.OS_Interface; |