From 5a835d7baaf03751c32d2dad045fdc161dce8dfe Mon Sep 17 00:00:00 2001 From: Natanael Copa Date: Fri, 7 Mar 2014 13:41:38 +0000 Subject: main/libc0.9.32: backport posix_spawn fix This should fix the following error when compiling posix-spawn ruby gem: In file included from posix-spawn.c:9:0: /usr/include/spawn.h:80:34: error: expected ';', ',' or ')' before 'pid' int posix_spawn(pid_t * restrict pid, const char * restrict path, ^ /usr/include/spawn.h:248:10: error: expected ';', ',' or ')' before 'file_actions' file_actions, int fd, ^ --- ...-use-glibc-style-to-keep-differences-down.patch | 399 +++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch (limited to 'main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch') diff --git a/main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch b/main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch new file mode 100644 index 0000000000..170c23840c --- /dev/null +++ b/main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch @@ -0,0 +1,399 @@ +From 54935c23e92c7f948ea3c561b3fac7cd4deac22a Mon Sep 17 00:00:00 2001 +From: Mike Frysinger +Date: Tue, 27 Mar 2012 03:34:37 +0000 +Subject: spawn: use glibc style to keep differences down + +There's no point in reformatting the code style when we're sourcing +most of it from glibc. Further, the changed style breaks with older +compilers, and pollutes the namespace with non-double leading under- +scores. + +Signed-off-by: Mike Frysinger +--- +(limited to 'include/spawn.h') + +diff --git a/include/spawn.h b/include/spawn.h +index 8b07bb8..95fff35 100644 +--- a/include/spawn.h ++++ b/include/spawn.h +@@ -19,36 +19,39 @@ + #ifndef _SPAWN_H + #define _SPAWN_H 1 + +-#include +-#include +-#include +- + #include + #include + #define __need_sigset_t + #include + #include + ++/* For the tiny inlines (errno/free/memset). */ ++#include ++#include ++#include ++ + + /* Data structure to contain attributes for thread creation. */ +-typedef struct { +- short int __flags; +- pid_t __pgrp; +- sigset_t __sd; +- sigset_t __ss; +- struct sched_param __sp; +- int __policy; +- int __pad[16]; ++typedef struct ++{ ++ short int __flags; ++ pid_t __pgrp; ++ sigset_t __sd; ++ sigset_t __ss; ++ struct sched_param __sp; ++ int __policy; ++ int __pad[16]; + } posix_spawnattr_t; + + + /* Data structure to contain information about the actions to be + performed in the new process with respect to file descriptors. */ +-typedef struct { +- int __allocated; +- int __used; +- struct __spawn_action *__actions; +- int __pad[16]; ++typedef struct ++{ ++ int __allocated; ++ int __used; ++ struct __spawn_action *__actions; ++ int __pad[16]; + } posix_spawn_file_actions_t; + + +@@ -59,7 +62,9 @@ typedef struct { + #define POSIX_SPAWN_SETSIGMASK 0x08 + #define POSIX_SPAWN_SETSCHEDPARAM 0x10 + #define POSIX_SPAWN_SETSCHEDULER 0x20 +-#define POSIX_SPAWN_USEVFORK 0x40 /* GNU extension */ ++#ifdef __USE_GNU ++# define POSIX_SPAWN_USEVFORK 0x40 ++#endif + + + #define __POSIX_SPAWN_MASK (POSIX_SPAWN_RESETIDS \ +@@ -77,189 +82,207 @@ __BEGIN_DECLS + + This function is a possible cancellation point and therefore not + marked with __THROW. */ +-int posix_spawn(pid_t * restrict pid, const char * restrict path, +- const posix_spawn_file_actions_t * restrict file_actions, +- const posix_spawnattr_t * restrict attrp, +- char * const argv[restrict], +- char * const envp[restrict]); ++extern int posix_spawn (pid_t *__restrict __pid, ++ const char *__restrict __path, ++ const posix_spawn_file_actions_t *__restrict ++ __file_actions, ++ const posix_spawnattr_t *__restrict __attrp, ++ char *const __argv[__restrict_arr], ++ char *const __envp[__restrict_arr]); + + /* Similar to `posix_spawn' but search for FILE in the PATH. + + This function is a possible cancellation point and therefore not + marked with __THROW. */ +-int posix_spawnp(pid_t *pid, const char *file, +- const posix_spawn_file_actions_t *file_actions, +- const posix_spawnattr_t *attrp, +- char * const argv[], char * const envp[]); +- +-/* Initialize data structure with attributes for `spawn' to default values. */ +-inline static int +-posix_spawnattr_init(posix_spawnattr_t *attr) ++extern int posix_spawnp (pid_t *__pid, const char *__file, ++ const posix_spawn_file_actions_t *__file_actions, ++ const posix_spawnattr_t *__attrp, ++ char *const __argv[], char *const __envp[]); ++ ++ ++/* Initialize data structure with attributes for `spawn' to default values. */ ++static inline ++int posix_spawnattr_init (posix_spawnattr_t *__attr) + { +- memset(attr, 0, sizeof(*attr)); +- return 0; ++ memset (__attr, 0, sizeof (*__attr)); ++ return 0; + } + + /* Free resources associated with ATTR. */ +-inline static int +-posix_spawnattr_destroy(posix_spawnattr_t *attr) ++static inline ++int posix_spawnattr_destroy (posix_spawnattr_t *__attr) + { +- return 0; ++ return 0; + } + + /* Store signal mask for signals with default handling from ATTR in + SIGDEFAULT. */ +-inline static int +-posix_spawnattr_getsigdefault(const posix_spawnattr_t *attr, +- sigset_t *sigdefault) ++static inline ++int posix_spawnattr_getsigdefault (const posix_spawnattr_t * ++ __restrict __attr, ++ sigset_t *__restrict __sigdefault) + { +- memcpy(sigdefault, &attr->__sd, sizeof(sigset_t)); +- return 0; ++ memcpy (__sigdefault, &__attr->__sd, sizeof (sigset_t)); ++ return 0; + } + +- + /* Set signal mask for signals with default handling in ATTR to SIGDEFAULT. */ +-inline static int +-posix_spawnattr_setsigdefault(posix_spawnattr_t *attr, +- const sigset_t *sigdefault) ++static inline ++int posix_spawnattr_setsigdefault (posix_spawnattr_t *__restrict __attr, ++ const sigset_t *__restrict ++ __sigdefault) + { +- memcpy(&attr->__sd, sigdefault, sizeof(sigset_t)); +- return 0; ++ memcpy (&__attr->__sd, __sigdefault, sizeof (sigset_t)); ++ return 0; + } + + /* Store signal mask for the new process from ATTR in SIGMASK. */ +-inline static int +-posix_spawnattr_getsigmask(const posix_spawnattr_t *attr, +- sigset_t *sigmask) ++static inline ++int posix_spawnattr_getsigmask (const posix_spawnattr_t *__restrict ++ __attr, ++ sigset_t *__restrict __sigmask) + { +- memcpy(sigmask, &attr->__ss, sizeof(sigset_t)); +- return 0; ++ memcpy (__sigmask, &__attr->__ss, sizeof (sigset_t)); ++ return 0; + } + +- + /* Set signal mask for the new process in ATTR to SIGMASK. */ +-inline static int +-posix_spawnattr_setsigmask(posix_spawnattr_t *attr, +- const sigset_t *sigmask) ++static inline ++int posix_spawnattr_setsigmask (posix_spawnattr_t *__restrict __attr, ++ const sigset_t *__restrict __sigmask) + { +- memcpy(&attr->__ss, sigmask, sizeof(sigset_t)); +- return 0; ++ memcpy (&__attr->__ss, __sigmask, sizeof (sigset_t)); ++ return 0; + } + + /* Get flag word from the attribute structure. */ +-inline static int +-posix_spawnattr_getflags(const posix_spawnattr_t *attr, short int *flags) ++static inline ++int posix_spawnattr_getflags (const posix_spawnattr_t *__restrict ++ __attr, ++ short int *__restrict __flags) + { +- *flags = attr->__flags; +- return 0; ++ *__flags = __attr->__flags; ++ return 0; + } + + /* Store flags in the attribute structure. */ +-inline static int +-posix_spawnattr_setflags(posix_spawnattr_t *attr, short int flags) ++static inline ++int posix_spawnattr_setflags (posix_spawnattr_t *_attr, ++ short int __flags) + { +- /* Check no invalid bits are set. */ +- if (flags & ~__POSIX_SPAWN_MASK) +- return EINVAL; ++ /* Check no invalid bits are set. */ ++ if (__flags & ~__POSIX_SPAWN_MASK) ++ return EINVAL; + +- attr->__flags = flags; +- return 0; ++ _attr->__flags = __flags; ++ return 0; + } + + /* Get process group ID from the attribute structure. */ +-inline static int +-posix_spawnattr_getpgroup(const posix_spawnattr_t *attr, pid_t *pgroup) ++static inline ++int posix_spawnattr_getpgroup (const posix_spawnattr_t *__restrict ++ __attr, pid_t *__restrict __pgroup) + { +- *pgroup = attr->__pgrp; +- return 0; ++ *__pgroup = __attr->__pgrp; ++ return 0; + } + + /* Store process group ID in the attribute structure. */ +-inline static int +-posix_spawnattr_setpgroup(posix_spawnattr_t *attr, pid_t pgroup) ++static inline ++int posix_spawnattr_setpgroup (posix_spawnattr_t *__attr, ++ pid_t __pgroup) + { +- attr->__pgrp = pgroup; +- return 0; ++ __attr->__pgrp = __pgroup; ++ return 0; + } + + /* Get scheduling policy from the attribute structure. */ +-inline static int +-posix_spawnattr_getschedpolicy(const posix_spawnattr_t *attr, +- int *schedpolicy) ++static inline ++int posix_spawnattr_getschedpolicy (const posix_spawnattr_t * ++ __restrict __attr, ++ int *__restrict __schedpolicy) + { +- *schedpolicy = attr->__policy; +- return 0; ++ *__schedpolicy = __attr->__policy; ++ return 0; + } + + /* Store scheduling policy in the attribute structure. */ +-inline static int +-posix_spawnattr_setschedpolicy(posix_spawnattr_t *attr, int schedpolicy) ++static inline ++int posix_spawnattr_setschedpolicy (posix_spawnattr_t *__attr, ++ int __schedpolicy) + { +- switch (schedpolicy) { +- case SCHED_OTHER: +- case SCHED_FIFO: +- case SCHED_RR: +- break; +- default: +- return EINVAL; +- } +- +- attr->__policy = schedpolicy; +- return 0; ++ switch (__schedpolicy) { ++ case SCHED_OTHER: ++ case SCHED_FIFO: ++ case SCHED_RR: ++ break; ++ default: ++ return EINVAL; ++ } ++ ++ __attr->__policy = __schedpolicy; ++ return 0; + } + + /* Get scheduling parameters from the attribute structure. */ +-static inline int +-posix_spawnattr_getschedparam(const posix_spawnattr_t *attr, +- struct sched_param *schedparam) ++static inline ++int posix_spawnattr_getschedparam (const posix_spawnattr_t * ++ __restrict __attr, ++ struct sched_param *__restrict ++ __schedparam) + { +- memcpy(schedparam, &attr->__sp, sizeof(attr->__sp)); +- return 0; ++ memcpy (__schedparam, &__attr->__sp, sizeof (__attr->__sp)); ++ return 0; + } + + /* Store scheduling parameters in the attribute structure. */ +-static inline int +-posix_spawnattr_setschedparam(posix_spawnattr_t *attr, +- const struct sched_param *schedparam) ++static inline ++int posix_spawnattr_setschedparam (posix_spawnattr_t *__restrict __attr, ++ const struct sched_param * ++ __restrict __schedparam) + { +- attr->__sp = *schedparam; +- return 0; ++ __attr->__sp = *__schedparam; ++ return 0; + } + + /* Initialize data structure for file attribute for `spawn' call. */ +-inline static int +-posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions) ++static inline ++int posix_spawn_file_actions_init (posix_spawn_file_actions_t * ++ __file_actions) + { +- memset(file_actions, 0, sizeof(*file_actions)); +- return 0; ++ memset (__file_actions, 0, sizeof (*__file_actions)); ++ return 0; + } + + /* Free resources associated with FILE-ACTIONS. */ +-inline static int +-posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions) ++static inline ++int posix_spawn_file_actions_destroy (posix_spawn_file_actions_t * ++ __file_actions) + { +- free(file_actions->__actions); +- return 0; ++ free (__file_actions->__actions); ++ return 0; + } + + /* Add an action to FILE-ACTIONS which tells the implementation to call + `open' for the given file during the `spawn' call. */ +-int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t * restrict +- file_actions, int fd, +- const char * restrict path, +- int oflag, mode_t mode) ++extern int posix_spawn_file_actions_addopen (posix_spawn_file_actions_t * ++ __restrict __file_actions, ++ int __fd, ++ const char *__restrict __path, ++ int __oflag, mode_t __mode) + __THROW; + + /* Add an action to FILE-ACTIONS which tells the implementation to call + `close' for the given file descriptor during the `spawn' call. */ +-int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *file_actions, +- int fd) ++extern int posix_spawn_file_actions_addclose (posix_spawn_file_actions_t * ++ __file_actions, int __fd) + __THROW; + + /* Add an action to FILE-ACTIONS which tells the implementation to call + `dup2' for the given file descriptors during the `spawn' call. */ +-int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *file_actions, +- int fd, int newfd) __THROW; ++extern int posix_spawn_file_actions_adddup2 (posix_spawn_file_actions_t * ++ __file_actions, ++ int __fd, int __newfd) __THROW; + + __END_DECLS + +-- +cgit v0.9.1 -- cgit v1.2.3