From 0dcf66744f533e160232072bd03273ca1c448879 Mon Sep 17 00:00:00 2001 From: Ismael Luceno Date: Mon, 5 Mar 2012 06:43:49 -0200 Subject: librt: add posix_spawn support Signed-off-by: Ismael Luceno Signed-off-by: Mike Frysinger --- include/spawn.h | 266 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+) create mode 100644 include/spawn.h (limited to 'include/spawn.h') diff --git a/include/spawn.h b/include/spawn.h new file mode 100644 index 000000000..8b07bb800 --- /dev/null +++ b/include/spawn.h @@ -0,0 +1,266 @@ +/* Definitions for POSIX spawn interface. + Copyright (C) 2000,2003,2004,2009,2011,2012 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SPAWN_H +#define _SPAWN_H 1 + +#include +#include +#include + +#include +#include +#define __need_sigset_t +#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]; +} 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]; +} posix_spawn_file_actions_t; + + +/* Flags to be set in the `posix_spawnattr_t'. */ +#define POSIX_SPAWN_RESETIDS 0x01 +#define POSIX_SPAWN_SETPGROUP 0x02 +#define POSIX_SPAWN_SETSIGDEF 0x04 +#define POSIX_SPAWN_SETSIGMASK 0x08 +#define POSIX_SPAWN_SETSCHEDPARAM 0x10 +#define POSIX_SPAWN_SETSCHEDULER 0x20 +#define POSIX_SPAWN_USEVFORK 0x40 /* GNU extension */ + + +#define __POSIX_SPAWN_MASK (POSIX_SPAWN_RESETIDS \ + | POSIX_SPAWN_SETPGROUP \ + | POSIX_SPAWN_SETSIGDEF \ + | POSIX_SPAWN_SETSIGMASK \ + | POSIX_SPAWN_SETSCHEDPARAM \ + | POSIX_SPAWN_SETSCHEDULER \ + | POSIX_SPAWN_USEVFORK) + +__BEGIN_DECLS + +/* Spawn a new process executing PATH with the attributes describes in *ATTRP. + Before running the process perform the actions described in FILE-ACTIONS. + + 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]); + +/* 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) +{ + memset(attr, 0, sizeof(*attr)); + return 0; +} + +/* Free resources associated with ATTR. */ +inline static int +posix_spawnattr_destroy(posix_spawnattr_t *attr) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + 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) +{ + *flags = attr->__flags; + return 0; +} + +/* Store flags in the attribute structure. */ +inline static int +posix_spawnattr_setflags(posix_spawnattr_t *attr, short int flags) +{ + /* Check no invalid bits are set. */ + if (flags & ~__POSIX_SPAWN_MASK) + return EINVAL; + + 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) +{ + *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) +{ + 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) +{ + *schedpolicy = attr->__policy; + return 0; +} + +/* Store scheduling policy in the attribute structure. */ +inline static 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; +} + +/* Get scheduling parameters from the attribute structure. */ +static inline int +posix_spawnattr_getschedparam(const posix_spawnattr_t *attr, + struct sched_param *schedparam) +{ + 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) +{ + 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) +{ + 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) +{ + 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) + __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) + __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; + +__END_DECLS + +#endif /* spawn.h */ -- cgit v1.2.3