1/* Definitions for POSIX spawn interface. 2 Copyright (C) 2000, 2003-2004, 2008-2012 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 5 This program is free software: you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 17 18#ifndef _@GUARD_PREFIX@_SPAWN_H 19 20#if __GNUC__ >= 3 21@PRAGMA_SYSTEM_HEADER@ 22#endif 23@PRAGMA_COLUMNS@ 24 25/* The include_next requires a split double-inclusion guard. */ 26#if @HAVE_SPAWN_H@ 27# @INCLUDE_NEXT@ @NEXT_SPAWN_H@ 28#endif 29 30#ifndef _@GUARD_PREFIX@_SPAWN_H 31#define _@GUARD_PREFIX@_SPAWN_H 32 33/* Get definitions of 'struct sched_param' and 'sigset_t'. 34 But avoid namespace pollution on glibc systems. */ 35#if !(defined __GLIBC__ && !defined __UCLIBC__) 36# include <sched.h> 37# include <signal.h> 38#endif 39 40#include <sys/types.h> 41 42#ifndef __THROW 43# define __THROW 44#endif 45 46/* GCC 2.95 and later have "__restrict"; C99 compilers have 47 "restrict", and "configure" may have defined "restrict". 48 Other compilers use __restrict, __restrict__, and _Restrict, and 49 'configure' might #define 'restrict' to those words, so pick a 50 different name. */ 51#ifndef _Restrict_ 52# if 199901L <= __STDC_VERSION__ 53# define _Restrict_ restrict 54# elif 2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__) 55# define _Restrict_ __restrict 56# else 57# define _Restrict_ 58# endif 59#endif 60/* gcc 3.1 and up support the [restrict] syntax. Don't trust 61 sys/cdefs.h's definition of __restrict_arr, though, as it 62 mishandles gcc -ansi -pedantic. */ 63#ifndef _Restrict_arr_ 64# if ((199901L <= __STDC_VERSION__ \ 65 || ((3 < __GNUC__ || (3 == __GNUC__ && 1 <= __GNUC_MINOR__)) \ 66 && !defined __STRICT_ANSI__)) \ 67 && !defined __GNUG__) 68# define _Restrict_arr_ _Restrict_ 69# else 70# define _Restrict_arr_ 71# endif 72#endif 73 74/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 75 76/* The definition of _GL_ARG_NONNULL is copied here. */ 77 78/* The definition of _GL_WARN_ON_USE is copied here. */ 79 80 81/* Data structure to contain attributes for thread creation. */ 82#if @REPLACE_POSIX_SPAWN@ 83# define posix_spawnattr_t rpl_posix_spawnattr_t 84#endif 85#if @REPLACE_POSIX_SPAWN@ || !@HAVE_POSIX_SPAWNATTR_T@ 86# if !GNULIB_defined_posix_spawnattr_t 87typedef struct 88{ 89 short int _flags; 90 pid_t _pgrp; 91 sigset_t _sd; 92 sigset_t _ss; 93 struct sched_param _sp; 94 int _policy; 95 int __pad[16]; 96} posix_spawnattr_t; 97# define GNULIB_defined_posix_spawnattr_t 1 98# endif 99#endif 100 101 102/* Data structure to contain information about the actions to be 103 performed in the new process with respect to file descriptors. */ 104#if @REPLACE_POSIX_SPAWN@ 105# define posix_spawn_file_actions_t rpl_posix_spawn_file_actions_t 106#endif 107#if @REPLACE_POSIX_SPAWN@ || !@HAVE_POSIX_SPAWN_FILE_ACTIONS_T@ 108# if !GNULIB_defined_posix_spawn_file_actions_t 109typedef struct 110{ 111 int _allocated; 112 int _used; 113 struct __spawn_action *_actions; 114 int __pad[16]; 115} posix_spawn_file_actions_t; 116# define GNULIB_defined_posix_spawn_file_actions_t 1 117# endif 118#endif 119 120 121/* Flags to be set in the 'posix_spawnattr_t'. */ 122#if @HAVE_POSIX_SPAWN@ 123/* Use the values from the system, but provide the missing ones. */ 124# ifndef POSIX_SPAWN_SETSCHEDPARAM 125# define POSIX_SPAWN_SETSCHEDPARAM 0 126# endif 127# ifndef POSIX_SPAWN_SETSCHEDULER 128# define POSIX_SPAWN_SETSCHEDULER 0 129# endif 130#else 131# if @REPLACE_POSIX_SPAWN@ 132/* Use the values from the system, for better compatibility. */ 133/* But this implementation does not support AIX extensions. */ 134# undef POSIX_SPAWN_FORK_HANDLERS 135# else 136# define POSIX_SPAWN_RESETIDS 0x01 137# define POSIX_SPAWN_SETPGROUP 0x02 138# define POSIX_SPAWN_SETSIGDEF 0x04 139# define POSIX_SPAWN_SETSIGMASK 0x08 140# define POSIX_SPAWN_SETSCHEDPARAM 0x10 141# define POSIX_SPAWN_SETSCHEDULER 0x20 142# endif 143#endif 144/* A GNU extension. Use the next free bit position. */ 145#define POSIX_SPAWN_USEVFORK \ 146 ((POSIX_SPAWN_RESETIDS | (POSIX_SPAWN_RESETIDS - 1) \ 147 | POSIX_SPAWN_SETPGROUP | (POSIX_SPAWN_SETPGROUP - 1) \ 148 | POSIX_SPAWN_SETSIGDEF | (POSIX_SPAWN_SETSIGDEF - 1) \ 149 | POSIX_SPAWN_SETSIGMASK | (POSIX_SPAWN_SETSIGMASK - 1) \ 150 | POSIX_SPAWN_SETSCHEDPARAM \ 151 | (POSIX_SPAWN_SETSCHEDPARAM > 0 ? POSIX_SPAWN_SETSCHEDPARAM - 1 : 0) \ 152 | POSIX_SPAWN_SETSCHEDULER \ 153 | (POSIX_SPAWN_SETSCHEDULER > 0 ? POSIX_SPAWN_SETSCHEDULER - 1 : 0)) \ 154 + 1) 155#if !GNULIB_defined_verify_POSIX_SPAWN_USEVFORK_no_overlap 156typedef int verify_POSIX_SPAWN_USEVFORK_no_overlap 157 [(((POSIX_SPAWN_RESETIDS | POSIX_SPAWN_SETPGROUP 158 | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK 159 | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER) 160 & POSIX_SPAWN_USEVFORK) 161 == 0) 162 ? 1 : -1]; 163# define GNULIB_defined_verify_POSIX_SPAWN_USEVFORK_no_overlap 1 164#endif 165 166 167#if @GNULIB_POSIX_SPAWN@ 168/* Spawn a new process executing PATH with the attributes describes in *ATTRP. 169 Before running the process perform the actions described in FILE-ACTIONS. 170 171 This function is a possible cancellation points and therefore not 172 marked with __THROW. */ 173# if @REPLACE_POSIX_SPAWN@ 174# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 175# define posix_spawn rpl_posix_spawn 176# endif 177_GL_FUNCDECL_RPL (posix_spawn, int, 178 (pid_t *_Restrict_ __pid, 179 const char *_Restrict_ __path, 180 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 181 const posix_spawnattr_t *_Restrict_ __attrp, 182 char *const argv[_Restrict_arr_], 183 char *const envp[_Restrict_arr_]) 184 _GL_ARG_NONNULL ((2, 5, 6))); 185_GL_CXXALIAS_RPL (posix_spawn, int, 186 (pid_t *_Restrict_ __pid, 187 const char *_Restrict_ __path, 188 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 189 const posix_spawnattr_t *_Restrict_ __attrp, 190 char *const argv[_Restrict_arr_], 191 char *const envp[_Restrict_arr_])); 192# else 193# if !@HAVE_POSIX_SPAWN@ 194_GL_FUNCDECL_SYS (posix_spawn, int, 195 (pid_t *_Restrict_ __pid, 196 const char *_Restrict_ __path, 197 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 198 const posix_spawnattr_t *_Restrict_ __attrp, 199 char *const argv[_Restrict_arr_], 200 char *const envp[_Restrict_arr_]) 201 _GL_ARG_NONNULL ((2, 5, 6))); 202# endif 203_GL_CXXALIAS_SYS (posix_spawn, int, 204 (pid_t *_Restrict_ __pid, 205 const char *_Restrict_ __path, 206 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 207 const posix_spawnattr_t *_Restrict_ __attrp, 208 char *const argv[_Restrict_arr_], 209 char *const envp[_Restrict_arr_])); 210# endif 211_GL_CXXALIASWARN (posix_spawn); 212#elif defined GNULIB_POSIXCHECK 213# undef posix_spawn 214# if HAVE_RAW_DECL_POSIX_SPAWN 215_GL_WARN_ON_USE (posix_spawn, "posix_spawn is unportable - " 216 "use gnulib module posix_spawn for portability"); 217# endif 218#endif 219 220#if @GNULIB_POSIX_SPAWNP@ 221/* Similar to 'posix_spawn' but search for FILE in the PATH. 222 223 This function is a possible cancellation points and therefore not 224 marked with __THROW. */ 225# if @REPLACE_POSIX_SPAWN@ 226# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 227# define posix_spawnp rpl_posix_spawnp 228# endif 229_GL_FUNCDECL_RPL (posix_spawnp, int, 230 (pid_t *__pid, const char *__file, 231 const posix_spawn_file_actions_t *__file_actions, 232 const posix_spawnattr_t *__attrp, 233 char *const argv[], char *const envp[]) 234 _GL_ARG_NONNULL ((2, 5, 6))); 235_GL_CXXALIAS_RPL (posix_spawnp, int, 236 (pid_t *__pid, const char *__file, 237 const posix_spawn_file_actions_t *__file_actions, 238 const posix_spawnattr_t *__attrp, 239 char *const argv[], char *const envp[])); 240# else 241# if !@HAVE_POSIX_SPAWN@ 242_GL_FUNCDECL_SYS (posix_spawnp, int, 243 (pid_t *__pid, const char *__file, 244 const posix_spawn_file_actions_t *__file_actions, 245 const posix_spawnattr_t *__attrp, 246 char *const argv[], char *const envp[]) 247 _GL_ARG_NONNULL ((2, 5, 6))); 248# endif 249_GL_CXXALIAS_SYS (posix_spawnp, int, 250 (pid_t *__pid, const char *__file, 251 const posix_spawn_file_actions_t *__file_actions, 252 const posix_spawnattr_t *__attrp, 253 char *const argv[], char *const envp[])); 254# endif 255_GL_CXXALIASWARN (posix_spawnp); 256#elif defined GNULIB_POSIXCHECK 257# undef posix_spawnp 258# if HAVE_RAW_DECL_POSIX_SPAWNP 259_GL_WARN_ON_USE (posix_spawnp, "posix_spawnp is unportable - " 260 "use gnulib module posix_spawnp for portability"); 261# endif 262#endif 263 264 265#if @GNULIB_POSIX_SPAWNATTR_INIT@ 266/* Initialize data structure with attributes for 'spawn' to default values. */ 267# if @REPLACE_POSIX_SPAWN@ 268# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 269# define posix_spawnattr_init rpl_posix_spawnattr_init 270# endif 271_GL_FUNCDECL_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr) 272 __THROW _GL_ARG_NONNULL ((1))); 273_GL_CXXALIAS_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr)); 274# else 275# if !@HAVE_POSIX_SPAWN@ 276_GL_FUNCDECL_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr) 277 __THROW _GL_ARG_NONNULL ((1))); 278# endif 279_GL_CXXALIAS_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr)); 280# endif 281_GL_CXXALIASWARN (posix_spawnattr_init); 282#elif defined GNULIB_POSIXCHECK 283# undef posix_spawnattr_init 284# if HAVE_RAW_DECL_POSIX_SPAWNATTR_INIT 285_GL_WARN_ON_USE (posix_spawnattr_init, "posix_spawnattr_init is unportable - " 286 "use gnulib module posix_spawnattr_init for portability"); 287# endif 288#endif 289 290#if @GNULIB_POSIX_SPAWNATTR_DESTROY@ 291/* Free resources associated with ATTR. */ 292# if @REPLACE_POSIX_SPAWN@ 293# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 294# define posix_spawnattr_destroy rpl_posix_spawnattr_destroy 295# endif 296_GL_FUNCDECL_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr) 297 __THROW _GL_ARG_NONNULL ((1))); 298_GL_CXXALIAS_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr)); 299# else 300# if !@HAVE_POSIX_SPAWN@ 301_GL_FUNCDECL_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr) 302 __THROW _GL_ARG_NONNULL ((1))); 303# endif 304_GL_CXXALIAS_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr)); 305# endif 306_GL_CXXALIASWARN (posix_spawnattr_destroy); 307#elif defined GNULIB_POSIXCHECK 308# undef posix_spawnattr_destroy 309# if HAVE_RAW_DECL_POSIX_SPAWNATTR_DESTROY 310_GL_WARN_ON_USE (posix_spawnattr_destroy, 311 "posix_spawnattr_destroy is unportable - " 312 "use gnulib module posix_spawnattr_destroy for portability"); 313# endif 314#endif 315 316#if @GNULIB_POSIX_SPAWNATTR_GETSIGDEFAULT@ 317/* Store signal mask for signals with default handling from ATTR in 318 SIGDEFAULT. */ 319# if @REPLACE_POSIX_SPAWN@ 320# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 321# define posix_spawnattr_getsigdefault rpl_posix_spawnattr_getsigdefault 322# endif 323_GL_FUNCDECL_RPL (posix_spawnattr_getsigdefault, int, 324 (const posix_spawnattr_t *_Restrict_ __attr, 325 sigset_t *_Restrict_ __sigdefault) 326 __THROW _GL_ARG_NONNULL ((1, 2))); 327_GL_CXXALIAS_RPL (posix_spawnattr_getsigdefault, int, 328 (const posix_spawnattr_t *_Restrict_ __attr, 329 sigset_t *_Restrict_ __sigdefault)); 330# else 331# if !@HAVE_POSIX_SPAWN@ 332_GL_FUNCDECL_SYS (posix_spawnattr_getsigdefault, int, 333 (const posix_spawnattr_t *_Restrict_ __attr, 334 sigset_t *_Restrict_ __sigdefault) 335 __THROW _GL_ARG_NONNULL ((1, 2))); 336# endif 337_GL_CXXALIAS_SYS (posix_spawnattr_getsigdefault, int, 338 (const posix_spawnattr_t *_Restrict_ __attr, 339 sigset_t *_Restrict_ __sigdefault)); 340# endif 341_GL_CXXALIASWARN (posix_spawnattr_getsigdefault); 342#elif defined GNULIB_POSIXCHECK 343# undef posix_spawnattr_getsigdefault 344# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSIGDEFAULT 345_GL_WARN_ON_USE (posix_spawnattr_getsigdefault, 346 "posix_spawnattr_getsigdefault is unportable - " 347 "use gnulib module posix_spawnattr_getsigdefault for portability"); 348# endif 349#endif 350 351#if @GNULIB_POSIX_SPAWNATTR_SETSIGDEFAULT@ 352/* Set signal mask for signals with default handling in ATTR to SIGDEFAULT. */ 353# if @REPLACE_POSIX_SPAWN@ 354# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 355# define posix_spawnattr_setsigdefault rpl_posix_spawnattr_setsigdefault 356# endif 357_GL_FUNCDECL_RPL (posix_spawnattr_setsigdefault, int, 358 (posix_spawnattr_t *_Restrict_ __attr, 359 const sigset_t *_Restrict_ __sigdefault) 360 __THROW _GL_ARG_NONNULL ((1, 2))); 361_GL_CXXALIAS_RPL (posix_spawnattr_setsigdefault, int, 362 (posix_spawnattr_t *_Restrict_ __attr, 363 const sigset_t *_Restrict_ __sigdefault)); 364# else 365# if !@HAVE_POSIX_SPAWN@ 366_GL_FUNCDECL_SYS (posix_spawnattr_setsigdefault, int, 367 (posix_spawnattr_t *_Restrict_ __attr, 368 const sigset_t *_Restrict_ __sigdefault) 369 __THROW _GL_ARG_NONNULL ((1, 2))); 370# endif 371_GL_CXXALIAS_SYS (posix_spawnattr_setsigdefault, int, 372 (posix_spawnattr_t *_Restrict_ __attr, 373 const sigset_t *_Restrict_ __sigdefault)); 374# endif 375_GL_CXXALIASWARN (posix_spawnattr_setsigdefault); 376#elif defined GNULIB_POSIXCHECK 377# undef posix_spawnattr_setsigdefault 378# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSIGDEFAULT 379_GL_WARN_ON_USE (posix_spawnattr_setsigdefault, 380 "posix_spawnattr_setsigdefault is unportable - " 381 "use gnulib module posix_spawnattr_setsigdefault for portability"); 382# endif 383#endif 384 385#if @GNULIB_POSIX_SPAWNATTR_GETSIGMASK@ 386/* Store signal mask for the new process from ATTR in SIGMASK. */ 387# if @REPLACE_POSIX_SPAWN@ 388# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 389# define posix_spawnattr_getsigmask rpl_posix_spawnattr_getsigmask 390# endif 391_GL_FUNCDECL_RPL (posix_spawnattr_getsigmask, int, 392 (const posix_spawnattr_t *_Restrict_ __attr, 393 sigset_t *_Restrict_ __sigmask) 394 __THROW _GL_ARG_NONNULL ((1, 2))); 395_GL_CXXALIAS_RPL (posix_spawnattr_getsigmask, int, 396 (const posix_spawnattr_t *_Restrict_ __attr, 397 sigset_t *_Restrict_ __sigmask)); 398# else 399# if !@HAVE_POSIX_SPAWN@ 400_GL_FUNCDECL_SYS (posix_spawnattr_getsigmask, int, 401 (const posix_spawnattr_t *_Restrict_ __attr, 402 sigset_t *_Restrict_ __sigmask) 403 __THROW _GL_ARG_NONNULL ((1, 2))); 404# endif 405_GL_CXXALIAS_SYS (posix_spawnattr_getsigmask, int, 406 (const posix_spawnattr_t *_Restrict_ __attr, 407 sigset_t *_Restrict_ __sigmask)); 408# endif 409_GL_CXXALIASWARN (posix_spawnattr_getsigmask); 410#elif defined GNULIB_POSIXCHECK 411# undef posix_spawnattr_getsigmask 412# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSIGMASK 413_GL_WARN_ON_USE (posix_spawnattr_getsigmask, 414 "posix_spawnattr_getsigmask is unportable - " 415 "use gnulib module posix_spawnattr_getsigmask for portability"); 416# endif 417#endif 418 419#if @GNULIB_POSIX_SPAWNATTR_SETSIGMASK@ 420/* Set signal mask for the new process in ATTR to SIGMASK. */ 421# if @REPLACE_POSIX_SPAWN@ 422# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 423# define posix_spawnattr_setsigmask rpl_posix_spawnattr_setsigmask 424# endif 425_GL_FUNCDECL_RPL (posix_spawnattr_setsigmask, int, 426 (posix_spawnattr_t *_Restrict_ __attr, 427 const sigset_t *_Restrict_ __sigmask) 428 __THROW _GL_ARG_NONNULL ((1, 2))); 429_GL_CXXALIAS_RPL (posix_spawnattr_setsigmask, int, 430 (posix_spawnattr_t *_Restrict_ __attr, 431 const sigset_t *_Restrict_ __sigmask)); 432# else 433# if !@HAVE_POSIX_SPAWN@ 434_GL_FUNCDECL_SYS (posix_spawnattr_setsigmask, int, 435 (posix_spawnattr_t *_Restrict_ __attr, 436 const sigset_t *_Restrict_ __sigmask) 437 __THROW _GL_ARG_NONNULL ((1, 2))); 438# endif 439_GL_CXXALIAS_SYS (posix_spawnattr_setsigmask, int, 440 (posix_spawnattr_t *_Restrict_ __attr, 441 const sigset_t *_Restrict_ __sigmask)); 442# endif 443_GL_CXXALIASWARN (posix_spawnattr_setsigmask); 444#elif defined GNULIB_POSIXCHECK 445# undef posix_spawnattr_setsigmask 446# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSIGMASK 447_GL_WARN_ON_USE (posix_spawnattr_setsigmask, 448 "posix_spawnattr_setsigmask is unportable - " 449 "use gnulib module posix_spawnattr_setsigmask for portability"); 450# endif 451#endif 452 453#if @GNULIB_POSIX_SPAWNATTR_GETFLAGS@ 454/* Get flag word from the attribute structure. */ 455# if @REPLACE_POSIX_SPAWN@ 456# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 457# define posix_spawnattr_getflags rpl_posix_spawnattr_getflags 458# endif 459_GL_FUNCDECL_RPL (posix_spawnattr_getflags, int, 460 (const posix_spawnattr_t *_Restrict_ __attr, 461 short int *_Restrict_ __flags) 462 __THROW _GL_ARG_NONNULL ((1, 2))); 463_GL_CXXALIAS_RPL (posix_spawnattr_getflags, int, 464 (const posix_spawnattr_t *_Restrict_ __attr, 465 short int *_Restrict_ __flags)); 466# else 467# if !@HAVE_POSIX_SPAWN@ 468_GL_FUNCDECL_SYS (posix_spawnattr_getflags, int, 469 (const posix_spawnattr_t *_Restrict_ __attr, 470 short int *_Restrict_ __flags) 471 __THROW _GL_ARG_NONNULL ((1, 2))); 472# endif 473_GL_CXXALIAS_SYS (posix_spawnattr_getflags, int, 474 (const posix_spawnattr_t *_Restrict_ __attr, 475 short int *_Restrict_ __flags)); 476# endif 477_GL_CXXALIASWARN (posix_spawnattr_getflags); 478#elif defined GNULIB_POSIXCHECK 479# undef posix_spawnattr_getflags 480# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETFLAGS 481_GL_WARN_ON_USE (posix_spawnattr_getflags, 482 "posix_spawnattr_getflags is unportable - " 483 "use gnulib module posix_spawnattr_getflags for portability"); 484# endif 485#endif 486 487#if @GNULIB_POSIX_SPAWNATTR_SETFLAGS@ 488/* Store flags in the attribute structure. */ 489# if @REPLACE_POSIX_SPAWN@ 490# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 491# define posix_spawnattr_setflags rpl_posix_spawnattr_setflags 492# endif 493_GL_FUNCDECL_RPL (posix_spawnattr_setflags, int, 494 (posix_spawnattr_t *__attr, short int __flags) 495 __THROW _GL_ARG_NONNULL ((1))); 496_GL_CXXALIAS_RPL (posix_spawnattr_setflags, int, 497 (posix_spawnattr_t *__attr, short int __flags)); 498# else 499# if !@HAVE_POSIX_SPAWN@ 500_GL_FUNCDECL_SYS (posix_spawnattr_setflags, int, 501 (posix_spawnattr_t *__attr, short int __flags) 502 __THROW _GL_ARG_NONNULL ((1))); 503# endif 504_GL_CXXALIAS_SYS (posix_spawnattr_setflags, int, 505 (posix_spawnattr_t *__attr, short int __flags)); 506# endif 507_GL_CXXALIASWARN (posix_spawnattr_setflags); 508#elif defined GNULIB_POSIXCHECK 509# undef posix_spawnattr_setflags 510# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETFLAGS 511_GL_WARN_ON_USE (posix_spawnattr_setflags, 512 "posix_spawnattr_setflags is unportable - " 513 "use gnulib module posix_spawnattr_setflags for portability"); 514# endif 515#endif 516 517#if @GNULIB_POSIX_SPAWNATTR_GETPGROUP@ 518/* Get process group ID from the attribute structure. */ 519# if @REPLACE_POSIX_SPAWN@ 520# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 521# define posix_spawnattr_getpgroup rpl_posix_spawnattr_getpgroup 522# endif 523_GL_FUNCDECL_RPL (posix_spawnattr_getpgroup, int, 524 (const posix_spawnattr_t *_Restrict_ __attr, 525 pid_t *_Restrict_ __pgroup) 526 __THROW _GL_ARG_NONNULL ((1, 2))); 527_GL_CXXALIAS_RPL (posix_spawnattr_getpgroup, int, 528 (const posix_spawnattr_t *_Restrict_ __attr, 529 pid_t *_Restrict_ __pgroup)); 530# else 531# if !@HAVE_POSIX_SPAWN@ 532_GL_FUNCDECL_SYS (posix_spawnattr_getpgroup, int, 533 (const posix_spawnattr_t *_Restrict_ __attr, 534 pid_t *_Restrict_ __pgroup) 535 __THROW _GL_ARG_NONNULL ((1, 2))); 536# endif 537_GL_CXXALIAS_SYS (posix_spawnattr_getpgroup, int, 538 (const posix_spawnattr_t *_Restrict_ __attr, 539 pid_t *_Restrict_ __pgroup)); 540# endif 541_GL_CXXALIASWARN (posix_spawnattr_getpgroup); 542#elif defined GNULIB_POSIXCHECK 543# undef posix_spawnattr_getpgroup 544# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETPGROUP 545_GL_WARN_ON_USE (posix_spawnattr_getpgroup, 546 "posix_spawnattr_getpgroup is unportable - " 547 "use gnulib module posix_spawnattr_getpgroup for portability"); 548# endif 549#endif 550 551#if @GNULIB_POSIX_SPAWNATTR_SETPGROUP@ 552/* Store process group ID in the attribute structure. */ 553# if @REPLACE_POSIX_SPAWN@ 554# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 555# define posix_spawnattr_setpgroup rpl_posix_spawnattr_setpgroup 556# endif 557_GL_FUNCDECL_RPL (posix_spawnattr_setpgroup, int, 558 (posix_spawnattr_t *__attr, pid_t __pgroup) 559 __THROW _GL_ARG_NONNULL ((1))); 560_GL_CXXALIAS_RPL (posix_spawnattr_setpgroup, int, 561 (posix_spawnattr_t *__attr, pid_t __pgroup)); 562# else 563# if !@HAVE_POSIX_SPAWN@ 564_GL_FUNCDECL_SYS (posix_spawnattr_setpgroup, int, 565 (posix_spawnattr_t *__attr, pid_t __pgroup) 566 __THROW _GL_ARG_NONNULL ((1))); 567# endif 568_GL_CXXALIAS_SYS (posix_spawnattr_setpgroup, int, 569 (posix_spawnattr_t *__attr, pid_t __pgroup)); 570# endif 571_GL_CXXALIASWARN (posix_spawnattr_setpgroup); 572#elif defined GNULIB_POSIXCHECK 573# undef posix_spawnattr_setpgroup 574# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETPGROUP 575_GL_WARN_ON_USE (posix_spawnattr_setpgroup, 576 "posix_spawnattr_setpgroup is unportable - " 577 "use gnulib module posix_spawnattr_setpgroup for portability"); 578# endif 579#endif 580 581#if @GNULIB_POSIX_SPAWNATTR_GETSCHEDPOLICY@ 582/* Get scheduling policy from the attribute structure. */ 583# if @REPLACE_POSIX_SPAWN@ 584# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 585# define posix_spawnattr_getschedpolicy rpl_posix_spawnattr_getschedpolicy 586# endif 587_GL_FUNCDECL_RPL (posix_spawnattr_getschedpolicy, int, 588 (const posix_spawnattr_t *_Restrict_ __attr, 589 int *_Restrict_ __schedpolicy) 590 __THROW _GL_ARG_NONNULL ((1, 2))); 591_GL_CXXALIAS_RPL (posix_spawnattr_getschedpolicy, int, 592 (const posix_spawnattr_t *_Restrict_ __attr, 593 int *_Restrict_ __schedpolicy)); 594# else 595# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDULER == 0 596_GL_FUNCDECL_SYS (posix_spawnattr_getschedpolicy, int, 597 (const posix_spawnattr_t *_Restrict_ __attr, 598 int *_Restrict_ __schedpolicy) 599 __THROW _GL_ARG_NONNULL ((1, 2))); 600# endif 601_GL_CXXALIAS_SYS (posix_spawnattr_getschedpolicy, int, 602 (const posix_spawnattr_t *_Restrict_ __attr, 603 int *_Restrict_ __schedpolicy)); 604# endif 605_GL_CXXALIASWARN (posix_spawnattr_getschedpolicy); 606#elif defined GNULIB_POSIXCHECK 607# undef posix_spawnattr_getschedpolicy 608# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSCHEDPOLICY 609_GL_WARN_ON_USE (posix_spawnattr_getschedpolicy, 610 "posix_spawnattr_getschedpolicy is unportable - " 611 "use gnulib module posix_spawnattr_getschedpolicy for portability"); 612# endif 613#endif 614 615#if @GNULIB_POSIX_SPAWNATTR_SETSCHEDPOLICY@ 616/* Store scheduling policy in the attribute structure. */ 617# if @REPLACE_POSIX_SPAWN@ 618# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 619# define posix_spawnattr_setschedpolicy rpl_posix_spawnattr_setschedpolicy 620# endif 621_GL_FUNCDECL_RPL (posix_spawnattr_setschedpolicy, int, 622 (posix_spawnattr_t *__attr, int __schedpolicy) 623 __THROW _GL_ARG_NONNULL ((1))); 624_GL_CXXALIAS_RPL (posix_spawnattr_setschedpolicy, int, 625 (posix_spawnattr_t *__attr, int __schedpolicy)); 626# else 627# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDULER == 0 628_GL_FUNCDECL_SYS (posix_spawnattr_setschedpolicy, int, 629 (posix_spawnattr_t *__attr, int __schedpolicy) 630 __THROW _GL_ARG_NONNULL ((1))); 631# endif 632_GL_CXXALIAS_SYS (posix_spawnattr_setschedpolicy, int, 633 (posix_spawnattr_t *__attr, int __schedpolicy)); 634# endif 635_GL_CXXALIASWARN (posix_spawnattr_setschedpolicy); 636#elif defined GNULIB_POSIXCHECK 637# undef posix_spawnattr_setschedpolicy 638# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSCHEDPOLICY 639_GL_WARN_ON_USE (posix_spawnattr_setschedpolicy, 640 "posix_spawnattr_setschedpolicy is unportable - " 641 "use gnulib module posix_spawnattr_setschedpolicy for portability"); 642# endif 643#endif 644 645#if @GNULIB_POSIX_SPAWNATTR_GETSCHEDPARAM@ 646/* Get scheduling parameters from the attribute structure. */ 647# if @REPLACE_POSIX_SPAWN@ 648# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 649# define posix_spawnattr_getschedparam rpl_posix_spawnattr_getschedparam 650# endif 651_GL_FUNCDECL_RPL (posix_spawnattr_getschedparam, int, 652 (const posix_spawnattr_t *_Restrict_ __attr, 653 struct sched_param *_Restrict_ __schedparam) 654 __THROW _GL_ARG_NONNULL ((1, 2))); 655_GL_CXXALIAS_RPL (posix_spawnattr_getschedparam, int, 656 (const posix_spawnattr_t *_Restrict_ __attr, 657 struct sched_param *_Restrict_ __schedparam)); 658# else 659# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDPARAM == 0 660_GL_FUNCDECL_SYS (posix_spawnattr_getschedparam, int, 661 (const posix_spawnattr_t *_Restrict_ __attr, 662 struct sched_param *_Restrict_ __schedparam) 663 __THROW _GL_ARG_NONNULL ((1, 2))); 664# endif 665_GL_CXXALIAS_SYS (posix_spawnattr_getschedparam, int, 666 (const posix_spawnattr_t *_Restrict_ __attr, 667 struct sched_param *_Restrict_ __schedparam)); 668# endif 669_GL_CXXALIASWARN (posix_spawnattr_getschedparam); 670#elif defined GNULIB_POSIXCHECK 671# undef posix_spawnattr_getschedparam 672# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSCHEDPARAM 673_GL_WARN_ON_USE (posix_spawnattr_getschedparam, 674 "posix_spawnattr_getschedparam is unportable - " 675 "use gnulib module posix_spawnattr_getschedparam for portability"); 676# endif 677#endif 678 679#if @GNULIB_POSIX_SPAWNATTR_SETSCHEDPARAM@ 680/* Store scheduling parameters in the attribute structure. */ 681# if @REPLACE_POSIX_SPAWN@ 682# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 683# define posix_spawnattr_setschedparam rpl_posix_spawnattr_setschedparam 684# endif 685_GL_FUNCDECL_RPL (posix_spawnattr_setschedparam, int, 686 (posix_spawnattr_t *_Restrict_ __attr, 687 const struct sched_param *_Restrict_ __schedparam) 688 __THROW _GL_ARG_NONNULL ((1, 2))); 689_GL_CXXALIAS_RPL (posix_spawnattr_setschedparam, int, 690 (posix_spawnattr_t *_Restrict_ __attr, 691 const struct sched_param *_Restrict_ __schedparam)); 692# else 693# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDPARAM == 0 694_GL_FUNCDECL_SYS (posix_spawnattr_setschedparam, int, 695 (posix_spawnattr_t *_Restrict_ __attr, 696 const struct sched_param *_Restrict_ __schedparam) 697 __THROW _GL_ARG_NONNULL ((1, 2))); 698# endif 699_GL_CXXALIAS_SYS (posix_spawnattr_setschedparam, int, 700 (posix_spawnattr_t *_Restrict_ __attr, 701 const struct sched_param *_Restrict_ __schedparam)); 702# endif 703_GL_CXXALIASWARN (posix_spawnattr_setschedparam); 704#elif defined GNULIB_POSIXCHECK 705# undef posix_spawnattr_setschedparam 706# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSCHEDPARAM 707_GL_WARN_ON_USE (posix_spawnattr_setschedparam, 708 "posix_spawnattr_setschedparam is unportable - " 709 "use gnulib module posix_spawnattr_setschedparam for portability"); 710# endif 711#endif 712 713 714#if @GNULIB_POSIX_SPAWN_FILE_ACTIONS_INIT@ 715/* Initialize data structure for file attribute for 'spawn' call. */ 716# if @REPLACE_POSIX_SPAWN@ 717# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 718# define posix_spawn_file_actions_init rpl_posix_spawn_file_actions_init 719# endif 720_GL_FUNCDECL_RPL (posix_spawn_file_actions_init, int, 721 (posix_spawn_file_actions_t *__file_actions) 722 __THROW _GL_ARG_NONNULL ((1))); 723_GL_CXXALIAS_RPL (posix_spawn_file_actions_init, int, 724 (posix_spawn_file_actions_t *__file_actions)); 725# else 726# if !@HAVE_POSIX_SPAWN@ 727_GL_FUNCDECL_SYS (posix_spawn_file_actions_init, int, 728 (posix_spawn_file_actions_t *__file_actions) 729 __THROW _GL_ARG_NONNULL ((1))); 730# endif 731_GL_CXXALIAS_SYS (posix_spawn_file_actions_init, int, 732 (posix_spawn_file_actions_t *__file_actions)); 733# endif 734_GL_CXXALIASWARN (posix_spawn_file_actions_init); 735#elif defined GNULIB_POSIXCHECK 736# undef posix_spawn_file_actions_init 737# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_INIT 738_GL_WARN_ON_USE (posix_spawn_file_actions_init, 739 "posix_spawn_file_actions_init is unportable - " 740 "use gnulib module posix_spawn_file_actions_init for portability"); 741# endif 742#endif 743 744#if @GNULIB_POSIX_SPAWN_FILE_ACTIONS_DESTROY@ 745/* Free resources associated with FILE-ACTIONS. */ 746# if @REPLACE_POSIX_SPAWN@ 747# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 748# define posix_spawn_file_actions_destroy rpl_posix_spawn_file_actions_destroy 749# endif 750_GL_FUNCDECL_RPL (posix_spawn_file_actions_destroy, int, 751 (posix_spawn_file_actions_t *__file_actions) 752 __THROW _GL_ARG_NONNULL ((1))); 753_GL_CXXALIAS_RPL (posix_spawn_file_actions_destroy, int, 754 (posix_spawn_file_actions_t *__file_actions)); 755# else 756# if !@HAVE_POSIX_SPAWN@ 757_GL_FUNCDECL_SYS (posix_spawn_file_actions_destroy, int, 758 (posix_spawn_file_actions_t *__file_actions) 759 __THROW _GL_ARG_NONNULL ((1))); 760# endif 761_GL_CXXALIAS_SYS (posix_spawn_file_actions_destroy, int, 762 (posix_spawn_file_actions_t *__file_actions)); 763# endif 764_GL_CXXALIASWARN (posix_spawn_file_actions_destroy); 765#elif defined GNULIB_POSIXCHECK 766# undef posix_spawn_file_actions_destroy 767# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_DESTROY 768_GL_WARN_ON_USE (posix_spawn_file_actions_destroy, 769 "posix_spawn_file_actions_destroy is unportable - " 770 "use gnulib module posix_spawn_file_actions_destroy for portability"); 771# endif 772#endif 773 774#if @GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN@ 775/* Add an action to FILE-ACTIONS which tells the implementation to call 776 'open' for the given file during the 'spawn' call. */ 777# if @REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN@ 778# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 779# define posix_spawn_file_actions_addopen rpl_posix_spawn_file_actions_addopen 780# endif 781_GL_FUNCDECL_RPL (posix_spawn_file_actions_addopen, int, 782 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 783 int __fd, 784 const char *_Restrict_ __path, int __oflag, mode_t __mode) 785 __THROW _GL_ARG_NONNULL ((1, 3))); 786_GL_CXXALIAS_RPL (posix_spawn_file_actions_addopen, int, 787 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 788 int __fd, 789 const char *_Restrict_ __path, int __oflag, mode_t __mode)); 790# else 791# if !@HAVE_POSIX_SPAWN@ 792_GL_FUNCDECL_SYS (posix_spawn_file_actions_addopen, int, 793 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 794 int __fd, 795 const char *_Restrict_ __path, int __oflag, mode_t __mode) 796 __THROW _GL_ARG_NONNULL ((1, 3))); 797# endif 798_GL_CXXALIAS_SYS (posix_spawn_file_actions_addopen, int, 799 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 800 int __fd, 801 const char *_Restrict_ __path, int __oflag, mode_t __mode)); 802# endif 803_GL_CXXALIASWARN (posix_spawn_file_actions_addopen); 804#elif defined GNULIB_POSIXCHECK 805# undef posix_spawn_file_actions_addopen 806# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN 807_GL_WARN_ON_USE (posix_spawn_file_actions_addopen, 808 "posix_spawn_file_actions_addopen is unportable - " 809 "use gnulib module posix_spawn_file_actions_addopen for portability"); 810# endif 811#endif 812 813#if @GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE@ 814/* Add an action to FILE-ACTIONS which tells the implementation to call 815 'close' for the given file descriptor during the 'spawn' call. */ 816# if @REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE@ 817# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 818# define posix_spawn_file_actions_addclose rpl_posix_spawn_file_actions_addclose 819# endif 820_GL_FUNCDECL_RPL (posix_spawn_file_actions_addclose, int, 821 (posix_spawn_file_actions_t *__file_actions, int __fd) 822 __THROW _GL_ARG_NONNULL ((1))); 823_GL_CXXALIAS_RPL (posix_spawn_file_actions_addclose, int, 824 (posix_spawn_file_actions_t *__file_actions, int __fd)); 825# else 826# if !@HAVE_POSIX_SPAWN@ 827_GL_FUNCDECL_SYS (posix_spawn_file_actions_addclose, int, 828 (posix_spawn_file_actions_t *__file_actions, int __fd) 829 __THROW _GL_ARG_NONNULL ((1))); 830# endif 831_GL_CXXALIAS_SYS (posix_spawn_file_actions_addclose, int, 832 (posix_spawn_file_actions_t *__file_actions, int __fd)); 833# endif 834_GL_CXXALIASWARN (posix_spawn_file_actions_addclose); 835#elif defined GNULIB_POSIXCHECK 836# undef posix_spawn_file_actions_addclose 837# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE 838_GL_WARN_ON_USE (posix_spawn_file_actions_addclose, 839 "posix_spawn_file_actions_addclose is unportable - " 840 "use gnulib module posix_spawn_file_actions_addclose for portability"); 841# endif 842#endif 843 844#if @GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2@ 845/* Add an action to FILE-ACTIONS which tells the implementation to call 846 'dup2' for the given file descriptors during the 'spawn' call. */ 847# if @REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2@ 848# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 849# define posix_spawn_file_actions_adddup2 rpl_posix_spawn_file_actions_adddup2 850# endif 851_GL_FUNCDECL_RPL (posix_spawn_file_actions_adddup2, int, 852 (posix_spawn_file_actions_t *__file_actions, 853 int __fd, int __newfd) 854 __THROW _GL_ARG_NONNULL ((1))); 855_GL_CXXALIAS_RPL (posix_spawn_file_actions_adddup2, int, 856 (posix_spawn_file_actions_t *__file_actions, 857 int __fd, int __newfd)); 858# else 859# if !@HAVE_POSIX_SPAWN@ 860_GL_FUNCDECL_SYS (posix_spawn_file_actions_adddup2, int, 861 (posix_spawn_file_actions_t *__file_actions, 862 int __fd, int __newfd) 863 __THROW _GL_ARG_NONNULL ((1))); 864# endif 865_GL_CXXALIAS_SYS (posix_spawn_file_actions_adddup2, int, 866 (posix_spawn_file_actions_t *__file_actions, 867 int __fd, int __newfd)); 868# endif 869_GL_CXXALIASWARN (posix_spawn_file_actions_adddup2); 870#elif defined GNULIB_POSIXCHECK 871# undef posix_spawn_file_actions_adddup2 872# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 873_GL_WARN_ON_USE (posix_spawn_file_actions_adddup2, 874 "posix_spawn_file_actions_adddup2 is unportable - " 875 "use gnulib module posix_spawn_file_actions_adddup2 for portability"); 876# endif 877#endif 878 879 880#endif /* _@GUARD_PREFIX@_SPAWN_H */ 881#endif /* _@GUARD_PREFIX@_SPAWN_H */ 882