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