summaryrefslogtreecommitdiff
path: root/include/spawn.h
blob: 8b07bb800128d06d1e3ae02854b86dbcc44f651a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
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
   <http://www.gnu.org/licenses/>.  */

#ifndef	_SPAWN_H
#define	_SPAWN_H	1

#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include <features.h>
#include <sched.h>
#define __need_sigset_t
#include <signal.h>
#include <sys/types.h>


/* 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 */