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-2014, 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; 212 tp : access timespec) return int; 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 size_t; 321 function Get_Page_Size return Address; 322 pragma Import (C, Get_Page_Size, "_getpagesize"); 323 -- Returns the size of a page 324 325 PROT_NONE : constant := 0; 326 PROT_READ : constant := 1; 327 PROT_WRITE : constant := 2; 328 PROT_EXEC : constant := 4; 329 PROT_ALL : constant := PROT_READ + PROT_WRITE + PROT_EXEC; 330 PROT_ON : constant := PROT_READ; 331 PROT_OFF : constant := PROT_ALL; 332 333 function mprotect (addr : Address; len : size_t; prot : int) return int; 334 pragma Import (C, mprotect); 335 336 --------------------------------------- 337 -- Nonstandard Thread Initialization -- 338 --------------------------------------- 339 340 procedure pthread_init is null; 341 -- This is a dummy procedure to share some GNULLI files 342 343 ------------------------- 344 -- POSIX.1c Section 3 -- 345 ------------------------- 346 347 function sigwait (set : access sigset_t; sig : access Signal) return int; 348 pragma Import (C, sigwait, "sigwait"); 349 350 function pthread_kill (thread : pthread_t; sig : Signal) return int; 351 pragma Import (C, pthread_kill, "pthread_kill"); 352 353 function pthread_sigmask 354 (how : int; 355 set : access sigset_t; 356 oset : access sigset_t) return int; 357 pragma Import (C, pthread_sigmask, "sigprocmask"); 358 -- pthread_sigmask maybe be broken due to mismatch between sigset_t and 359 -- kernel_sigset_t, substitute sigprocmask temporarily. ??? 360 -- pragma Import (C, pthread_sigmask, "pthread_sigmask"); 361 362 -------------------------- 363 -- POSIX.1c Section 11 -- 364 -------------------------- 365 366 function pthread_mutexattr_init 367 (attr : access pthread_mutexattr_t) return int; 368 pragma Import (C, pthread_mutexattr_init, "pthread_mutexattr_init"); 369 370 function pthread_mutexattr_destroy 371 (attr : access pthread_mutexattr_t) return int; 372 pragma Import (C, pthread_mutexattr_destroy, "pthread_mutexattr_destroy"); 373 374 function pthread_mutex_init 375 (mutex : access pthread_mutex_t; 376 attr : access pthread_mutexattr_t) return int; 377 pragma Import (C, pthread_mutex_init, "pthread_mutex_init"); 378 379 function pthread_mutex_destroy (mutex : access pthread_mutex_t) return int; 380 pragma Import (C, pthread_mutex_destroy, "pthread_mutex_destroy"); 381 382 function pthread_mutex_lock (mutex : access pthread_mutex_t) return int; 383 pragma Import (C, pthread_mutex_lock, "pthread_mutex_lock"); 384 385 function pthread_mutex_unlock (mutex : access pthread_mutex_t) return int; 386 pragma Import (C, pthread_mutex_unlock, "pthread_mutex_unlock"); 387 388 function pthread_condattr_init 389 (attr : access pthread_condattr_t) return int; 390 pragma Import (C, pthread_condattr_init, "pthread_condattr_init"); 391 392 function pthread_condattr_destroy 393 (attr : access pthread_condattr_t) return int; 394 pragma Import (C, pthread_condattr_destroy, "pthread_condattr_destroy"); 395 396 function pthread_cond_init 397 (cond : access pthread_cond_t; 398 attr : access pthread_condattr_t) return int; 399 pragma Import (C, pthread_cond_init, "pthread_cond_init"); 400 401 function pthread_cond_destroy (cond : access pthread_cond_t) return int; 402 pragma Import (C, pthread_cond_destroy, "pthread_cond_destroy"); 403 404 function pthread_cond_signal (cond : access pthread_cond_t) return int; 405 pragma Import (C, pthread_cond_signal, "pthread_cond_signal"); 406 407 function pthread_cond_wait 408 (cond : access pthread_cond_t; 409 mutex : access pthread_mutex_t) return int; 410 pragma Import (C, pthread_cond_wait, "pthread_cond_wait"); 411 412 function pthread_cond_timedwait 413 (cond : access pthread_cond_t; 414 mutex : access pthread_mutex_t; 415 abstime : access timespec) return int; 416 pragma Import (C, pthread_cond_timedwait, "pthread_cond_timedwait"); 417 418 Relative_Timed_Wait : constant Boolean := False; 419 -- pthread_cond_timedwait requires an absolute delay time 420 421 -------------------------- 422 -- POSIX.1c Section 13 -- 423 -------------------------- 424 425 PTHREAD_PRIO_PROTECT : constant := 0; 426 PTHREAD_PRIO_INHERIT : constant := 1; 427 428 function pthread_mutexattr_setprotocol 429 (attr : access pthread_mutexattr_t; 430 protocol : int) return int is (0); 431 432 function pthread_mutexattr_setprioceiling 433 (attr : access pthread_mutexattr_t; 434 prioceiling : int) return int is (0); 435 436 type struct_sched_param is record 437 sched_priority : int; -- scheduling priority 438 end record; 439 pragma Convention (C, struct_sched_param); 440 441 function pthread_setschedparam 442 (thread : pthread_t; 443 policy : int; 444 param : access struct_sched_param) return int; 445 pragma Import (C, pthread_setschedparam, "pthread_setschedparam"); 446 447 function pthread_attr_setscope 448 (attr : access pthread_attr_t; 449 scope : int) return int; 450 pragma Import (C, pthread_attr_setscope, "pthread_attr_setscope"); 451 452 function pthread_attr_setschedpolicy 453 (attr : access pthread_attr_t; 454 policy : int) return int; 455 pragma Import 456 (C, pthread_attr_setschedpolicy, "pthread_attr_setschedpolicy"); 457 458 function sched_yield return int; 459 pragma Import (C, sched_yield, "sched_yield"); 460 461 --------------------------- 462 -- P1003.1c - Section 16 -- 463 --------------------------- 464 465 function pthread_attr_init 466 (attributes : access pthread_attr_t) return int; 467 pragma Import (C, pthread_attr_init, "pthread_attr_init"); 468 469 function pthread_attr_destroy 470 (attributes : access pthread_attr_t) return int; 471 pragma Import (C, pthread_attr_destroy, "pthread_attr_destroy"); 472 473 function pthread_attr_setdetachstate 474 (attr : access pthread_attr_t; 475 detachstate : int) return int; 476 pragma Import 477 (C, pthread_attr_setdetachstate, "pthread_attr_setdetachstate"); 478 479 function pthread_attr_setstacksize 480 (attr : access pthread_attr_t; 481 stacksize : size_t) return int; 482 pragma Import (C, pthread_attr_setstacksize, "pthread_attr_setstacksize"); 483 484 function pthread_create 485 (thread : access pthread_t; 486 attributes : access pthread_attr_t; 487 start_routine : Thread_Body; 488 arg : System.Address) return int; 489 pragma Import (C, pthread_create, "pthread_create"); 490 491 procedure pthread_exit (status : System.Address); 492 pragma Import (C, pthread_exit, "pthread_exit"); 493 494 function pthread_self return pthread_t; 495 pragma Import (C, pthread_self, "pthread_self"); 496 497 function lwp_self return System.Address; 498 pragma Import (C, lwp_self, "__gnat_lwp_self"); 499 500 -------------------------- 501 -- POSIX.1c Section 17 -- 502 -------------------------- 503 504 function pthread_setspecific 505 (key : pthread_key_t; 506 value : System.Address) return int; 507 pragma Import (C, pthread_setspecific, "pthread_setspecific"); 508 509 function pthread_getspecific (key : pthread_key_t) return System.Address; 510 pragma Import (C, pthread_getspecific, "pthread_getspecific"); 511 512 type destructor_pointer is access procedure (arg : System.Address); 513 pragma Convention (C, destructor_pointer); 514 515 function pthread_key_create 516 (key : access pthread_key_t; 517 destructor : destructor_pointer) return int; 518 pragma Import (C, pthread_key_create, "pthread_key_create"); 519 520 CPU_SETSIZE : constant := 1_024; 521 -- Size of the cpu_set_t mask on most linux systems (SUSE 11 uses 4_096). 522 -- This is kept for backward compatibility (System.Task_Info uses it), but 523 -- the run-time library does no longer rely on static masks, using 524 -- dynamically allocated masks instead. 525 526 type bit_field is array (1 .. CPU_SETSIZE) of Boolean; 527 for bit_field'Size use CPU_SETSIZE; 528 pragma Pack (bit_field); 529 pragma Convention (C, bit_field); 530 531 type cpu_set_t is record 532 bits : bit_field; 533 end record; 534 pragma Convention (C, cpu_set_t); 535 536 type cpu_set_t_ptr is access all cpu_set_t; 537 -- In the run-time library we use this pointer because the size of type 538 -- cpu_set_t varies depending on the glibc version. Hence, objects of type 539 -- cpu_set_t are allocated dynamically using the number of processors 540 -- available in the target machine (value obtained at execution time). 541 542 function CPU_ALLOC (count : size_t) return cpu_set_t_ptr; 543 pragma Import (C, CPU_ALLOC, "__gnat_cpu_alloc"); 544 -- Wrapper around the CPU_ALLOC C macro 545 546 function CPU_ALLOC_SIZE (count : size_t) return size_t; 547 pragma Import (C, CPU_ALLOC_SIZE, "__gnat_cpu_alloc_size"); 548 -- Wrapper around the CPU_ALLOC_SIZE C macro 549 550 procedure CPU_FREE (cpuset : cpu_set_t_ptr); 551 pragma Import (C, CPU_FREE, "__gnat_cpu_free"); 552 -- Wrapper around the CPU_FREE C macro 553 554 procedure CPU_ZERO (count : size_t; cpuset : cpu_set_t_ptr); 555 pragma Import (C, CPU_ZERO, "__gnat_cpu_zero"); 556 -- Wrapper around the CPU_ZERO_S C macro 557 558 procedure CPU_SET (cpu : int; count : size_t; cpuset : cpu_set_t_ptr); 559 pragma Import (C, CPU_SET, "__gnat_cpu_set"); 560 -- Wrapper around the CPU_SET_S C macro 561 562 function pthread_setaffinity_np 563 (thread : pthread_t; 564 cpusetsize : size_t; 565 cpuset : cpu_set_t_ptr) return int; 566 pragma Import (C, pthread_setaffinity_np, "pthread_setaffinity_np"); 567 pragma Weak_External (pthread_setaffinity_np); 568 -- Use a weak symbol because this function may be available or not, 569 -- depending on the version of the system. 570 571 function pthread_attr_setaffinity_np 572 (attr : access pthread_attr_t; 573 cpusetsize : size_t; 574 cpuset : cpu_set_t_ptr) return int; 575 pragma Import (C, pthread_attr_setaffinity_np, 576 "pthread_attr_setaffinity_np"); 577 pragma Weak_External (pthread_attr_setaffinity_np); 578 -- Use a weak symbol because this function may be available or not, 579 -- depending on the version of the system. 580 581private 582 583 type sigset_t is new Interfaces.C.unsigned_long; 584 pragma Convention (C, sigset_t); 585 for sigset_t'Alignment use Interfaces.C.unsigned_long'Alignment; 586 587 pragma Warnings (Off); 588 for struct_sigaction use record 589 sa_handler at Linux.sa_handler_pos range 0 .. Standard'Address_Size - 1; 590 sa_mask at Linux.sa_mask_pos range 0 .. sigset_t'Size - 1; 591 sa_flags at Linux.sa_flags_pos 592 range 0 .. Interfaces.C.unsigned_long'Size - 1; 593 end record; 594 -- We intentionally leave sa_restorer unspecified and let the compiler 595 -- append it after the last field, so disable corresponding warning. 596 pragma Warnings (On); 597 598 type pid_t is new int; 599 600 type time_t is new long; 601 602 type timespec is record 603 tv_sec : time_t; 604 tv_nsec : long; 605 end record; 606 pragma Convention (C, timespec); 607 608 type unsigned_long_long_t is mod 2 ** 64; 609 -- Local type only used to get the alignment of this type below 610 611 subtype char_array is Interfaces.C.char_array; 612 613 type pthread_attr_t is record 614 Data : char_array (1 .. OS_Constants.PTHREAD_ATTR_SIZE); 615 end record; 616 pragma Convention (C, pthread_attr_t); 617 for pthread_attr_t'Alignment use Interfaces.C.unsigned_long'Alignment; 618 619 type pthread_condattr_t is record 620 Data : char_array (1 .. OS_Constants.PTHREAD_CONDATTR_SIZE); 621 end record; 622 pragma Convention (C, pthread_condattr_t); 623 for pthread_condattr_t'Alignment use Interfaces.C.int'Alignment; 624 625 type pthread_mutexattr_t is record 626 Data : char_array (1 .. OS_Constants.PTHREAD_MUTEXATTR_SIZE); 627 end record; 628 pragma Convention (C, pthread_mutexattr_t); 629 for pthread_mutexattr_t'Alignment use Interfaces.C.int'Alignment; 630 631 type pthread_mutex_t is record 632 Data : char_array (1 .. OS_Constants.PTHREAD_MUTEX_SIZE); 633 end record; 634 pragma Convention (C, pthread_mutex_t); 635 for pthread_mutex_t'Alignment use Interfaces.C.unsigned_long'Alignment; 636 637 type pthread_cond_t is record 638 Data : char_array (1 .. OS_Constants.PTHREAD_COND_SIZE); 639 end record; 640 pragma Convention (C, pthread_cond_t); 641 for pthread_cond_t'Alignment use unsigned_long_long_t'Alignment; 642 643 type pthread_key_t is new unsigned; 644 645end System.OS_Interface; 646