Apache Portable Runtime
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
apr_thread_proc.h
Go to the documentation of this file.
1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2  * contributor license agreements. See the NOTICE file distributed with
3  * this work for additional information regarding copyright ownership.
4  * The ASF licenses this file to You under the Apache License, Version 2.0
5  * (the "License"); you may not use this file except in compliance with
6  * the License. You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef APR_THREAD_PROC_H
18 #define APR_THREAD_PROC_H
19 
20 /**
21  * @file apr_thread_proc.h
22  * @brief APR Thread and Process Library
23  */
24 
25 #include "apr.h"
26 #include "apr_file_io.h"
27 #include "apr_pools.h"
28 #include "apr_errno.h"
29 
30 #if APR_HAVE_STRUCT_RLIMIT
31 #include <sys/time.h>
32 #include <sys/resource.h>
33 #endif
34 
35 #ifdef __cplusplus
36 extern "C" {
37 #endif /* __cplusplus */
38 
39 /**
40  * @defgroup apr_thread_proc Threads and Process Functions
41  * @ingroup APR
42  * @{
43  */
44 
45 typedef enum {
46  APR_SHELLCMD, /**< use the shell to invoke the program */
47  APR_PROGRAM, /**< invoke the program directly, no copied env */
48  APR_PROGRAM_ENV, /**< invoke the program, replicating our environment */
49  APR_PROGRAM_PATH, /**< find program on PATH, use our environment */
50  APR_SHELLCMD_ENV /**< use the shell to invoke the program,
51  * replicating our environment
52  */
54 
55 typedef enum {
56  APR_WAIT, /**< wait for the specified process to finish */
57  APR_NOWAIT /**< do not wait -- just see if it has finished */
59 
60 /* I am specifically calling out the values so that the macros below make
61  * more sense. Yes, I know I don't need to, but I am hoping this makes what
62  * I am doing more clear. If you want to add more reasons to exit, continue
63  * to use bitmasks.
64  */
65 typedef enum {
66  APR_PROC_EXIT = 1, /**< process exited normally */
67  APR_PROC_SIGNAL = 2, /**< process exited due to a signal */
68  APR_PROC_SIGNAL_CORE = 4 /**< process exited and dumped a core file */
70 
71 /** did we exit the process */
72 #define APR_PROC_CHECK_EXIT(x) (x & APR_PROC_EXIT)
73 /** did we get a signal */
74 #define APR_PROC_CHECK_SIGNALED(x) (x & APR_PROC_SIGNAL)
75 /** did we get core */
76 #define APR_PROC_CHECK_CORE_DUMP(x) (x & APR_PROC_SIGNAL_CORE)
77 
78 /** @see apr_procattr_io_set */
79 #define APR_NO_PIPE 0
80 /** @see apr_procattr_io_set and apr_file_pipe_create_ex */
81 #define APR_FULL_BLOCK 1
82 /** @see apr_procattr_io_set and apr_file_pipe_create_ex */
83 #define APR_FULL_NONBLOCK 2
84 /** @see apr_procattr_io_set */
85 #define APR_PARENT_BLOCK 3
86 /** @see apr_procattr_io_set */
87 #define APR_CHILD_BLOCK 4
88 /** @see apr_procattr_io_set */
89 #define APR_NO_FILE 8
90 
91 /** @see apr_file_pipe_create_ex */
92 #define APR_READ_BLOCK 3
93 /** @see apr_file_pipe_create_ex */
94 #define APR_WRITE_BLOCK 4
95 
96 /** @see apr_procattr_io_set
97  * @note Win32 only effective with version 1.2.12, portably introduced in 1.3.0
98  */
99 #define APR_NO_FILE 8
100 
101 /** @see apr_procattr_limit_set */
102 #define APR_LIMIT_CPU 0
103 /** @see apr_procattr_limit_set */
104 #define APR_LIMIT_MEM 1
105 /** @see apr_procattr_limit_set */
106 #define APR_LIMIT_NPROC 2
107 /** @see apr_procattr_limit_set */
108 #define APR_LIMIT_NOFILE 3
109 
110 /**
111  * @defgroup APR_OC Other Child Flags
112  * @{
113  */
114 #define APR_OC_REASON_DEATH 0 /**< child has died, caller must call
115  * unregister still */
116 #define APR_OC_REASON_UNWRITABLE 1 /**< write_fd is unwritable */
117 #define APR_OC_REASON_RESTART 2 /**< a restart is occurring, perform
118  * any necessary cleanup (including
119  * sending a special signal to child)
120  */
121 #define APR_OC_REASON_UNREGISTER 3 /**< unregister has been called, do
122  * whatever is necessary (including
123  * kill the child) */
124 #define APR_OC_REASON_LOST 4 /**< somehow the child exited without
125  * us knowing ... buggy os? */
126 #define APR_OC_REASON_RUNNING 5 /**< a health check is occurring,
127  * for most maintainence functions
128  * this is a no-op.
129  */
130 /** @} */
131 
132 /** The APR process type */
133 typedef struct apr_proc_t {
134  /** The process ID */
135  pid_t pid;
136  /** Parent's side of pipe to child's stdin */
137  apr_file_t *in;
138  /** Parent's side of pipe to child's stdout */
139  apr_file_t *out;
140  /** Parent's side of pipe to child's stdouterr */
141  apr_file_t *err;
142 #if APR_HAS_PROC_INVOKED || defined(DOXYGEN)
143  /** Diagnositics/debugging string of the command invoked for
144  * this process [only present if APR_HAS_PROC_INVOKED is true]
145  * @remark Only enabled on Win32 by default.
146  * @bug This should either always or never be present in release
147  * builds - since it breaks binary compatibility. We may enable
148  * it always in APR 1.0 yet leave it undefined in most cases.
149  */
150  char *invoked;
151 #endif
152 #if defined(WIN32) || defined(DOXYGEN)
153  /** (Win32 only) Creator's handle granting access to the process
154  * @remark This handle is closed and reset to NULL in every case
155  * corresponding to a waitpid() on Unix which returns the exit status.
156  * Therefore Win32 correspond's to Unix's zombie reaping characteristics
157  * and avoids potential handle leaks.
158  */
159  HANDLE hproc;
160 #endif
161 } apr_proc_t;
162 
163 /**
164  * The prototype for APR child errfn functions. (See the description
165  * of apr_procattr_child_errfn_set() for more information.)
166  * It is passed the following parameters:
167  * @param pool Pool associated with the apr_proc_t. If your child
168  * error function needs user data, associate it with this
169  * pool.
170  * @param err APR error code describing the error
171  * @param description Text description of type of processing which failed
172  */
173 typedef void (apr_child_errfn_t)(apr_pool_t *proc, apr_status_t err,
174  const char *description);
175 
176 /** Opaque Thread structure. */
177 typedef struct apr_thread_t apr_thread_t;
178 
179 /** Opaque Thread attributes structure. */
180 typedef struct apr_threadattr_t apr_threadattr_t;
181 
182 /** Opaque Process attributes structure. */
184 
185 /** Opaque control variable for one-time atomic variables. */
186 typedef struct apr_thread_once_t apr_thread_once_t;
188 /** Opaque thread private address space. */
189 typedef struct apr_threadkey_t apr_threadkey_t;
191 /** Opaque record of child process. */
194 /**
195  * The prototype for any APR thread worker functions.
196  */
197 typedef void *(APR_THREAD_FUNC *apr_thread_start_t)(apr_thread_t*, void*);
198 
199 typedef enum {
200  APR_KILL_NEVER, /**< process is never killed (i.e., never sent
201  * any signals), but it will be reaped if it exits
202  * before the pool is cleaned up */
203  APR_KILL_ALWAYS, /**< process is sent SIGKILL on apr_pool_t cleanup */
204  APR_KILL_AFTER_TIMEOUT, /**< SIGTERM, wait 3 seconds, SIGKILL */
205  APR_JUST_WAIT, /**< wait forever for the process to complete */
206  APR_KILL_ONLY_ONCE /**< send SIGTERM and then wait */
208 
209 /* Thread Function definitions */
211 #if APR_HAS_THREADS
212 
213 /**
214  * Create and initialize a new threadattr variable
215  * @param new_attr The newly created threadattr.
216  * @param cont The pool to use
217  */
219  apr_pool_t *cont);
220 
221 /**
222  * Set if newly created threads should be created in detached state.
223  * @param attr The threadattr to affect
224  * @param on Non-zero if detached threads should be created.
225  */
227  apr_int32_t on);
228 
229 /**
230  * Get the detach state for this threadattr.
231  * @param attr The threadattr to reference
232  * @return APR_DETACH if threads are to be detached, or APR_NOTDETACH
233  * if threads are to be joinable.
234  */
236 
237 /**
238  * Set the stack size of newly created threads.
239  * @param attr The threadattr to affect
240  * @param stacksize The stack size in bytes
241  */
243  apr_size_t stacksize);
244 
245 /**
246  * Set the stack guard area size of newly created threads.
247  * @param attr The threadattr to affect
248  * @param guardsize The stack guard area size in bytes
249  * @note Thread library implementations commonly use a "guard area"
250  * after each thread's stack which is not readable or writable such that
251  * stack overflows cause a segfault; this consumes e.g. 4K of memory
252  * and increases memory management overhead. Setting the guard area
253  * size to zero hence trades off reliable behaviour on stack overflow
254  * for performance. */
256  apr_size_t guardsize);
257 
258 /**
259  * Create a new thread of execution
260  * @param new_thread The newly created thread handle.
261  * @param attr The threadattr to use to determine how to create the thread
262  * @param func The function to start the new thread in
263  * @param data Any data to be passed to the starting function
264  * @param cont The pool to use
265  */
267  apr_threadattr_t *attr,
268  apr_thread_start_t func,
269  void *data, apr_pool_t *cont);
270 
271 /**
272  * stop the current thread
273  * @param thd The thread to stop
274  * @param retval The return value to pass back to any thread that cares
275  */
277  apr_status_t retval);
278 
279 /**
280  * block until the desired thread stops executing.
281  * @param retval The return value from the dead thread.
282  * @param thd The thread to join
283  */
285  apr_thread_t *thd);
286 
287 /**
288  * force the current thread to yield the processor
289  */
290 APR_DECLARE(void) apr_thread_yield(void);
291 
292 /**
293  * Initialize the control variable for apr_thread_once. If this isn't
294  * called, apr_initialize won't work.
295  * @param control The control variable to initialize
296  * @param p The pool to allocate data from.
297  */
299  apr_pool_t *p);
300 
301 /**
302  * Run the specified function one time, regardless of how many threads
303  * call it.
304  * @param control The control variable. The same variable should
305  * be passed in each time the function is tried to be
306  * called. This is how the underlying functions determine
307  * if the function has ever been called before.
308  * @param func The function to call.
309  */
311  void (*func)(void));
312 
313 /**
314  * detach a thread
315  * @param thd The thread to detach
316  */
318 
319 /**
320  * Return user data associated with the current thread.
321  * @param data The user data associated with the thread.
322  * @param key The key to associate with the data
323  * @param thread The currently open thread.
324  */
325 APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key,
326  apr_thread_t *thread);
327 
328 /**
329  * Set user data associated with the current thread.
330  * @param data The user data to associate with the thread.
331  * @param key The key to use for associating the data with the thread
332  * @param cleanup The cleanup routine to use when the thread is destroyed.
333  * @param thread The currently open thread.
334  */
335 APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key,
336  apr_status_t (*cleanup) (void *),
337  apr_thread_t *thread);
338 
339 /**
340  * Create and initialize a new thread private address space
341  * @param key The thread private handle.
342  * @param dest The destructor to use when freeing the private memory.
343  * @param cont The pool to use
344  */
346  void (*dest)(void *),
347  apr_pool_t *cont);
348 
349 /**
350  * Get a pointer to the thread private memory
351  * @param new_mem The data stored in private memory
352  * @param key The handle for the desired thread private memory
353  */
355  apr_threadkey_t *key);
356 
357 /**
358  * Set the data to be stored in thread private memory
359  * @param priv The data to be stored in private memory
360  * @param key The handle for the desired thread private memory
361  */
363  apr_threadkey_t *key);
364 
365 /**
366  * Free the thread private memory
367  * @param key The handle for the desired thread private memory
368  */
370 
371 /**
372  * Return the pool associated with the current threadkey.
373  * @param data The user data associated with the threadkey.
374  * @param key The key associated with the data
375  * @param threadkey The currently open threadkey.
376  */
377 APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key,
378  apr_threadkey_t *threadkey);
379 
380 /**
381  * Return the pool associated with the current threadkey.
382  * @param data The data to set.
383  * @param key The key to associate with the data.
384  * @param cleanup The cleanup routine to use when the file is destroyed.
385  * @param threadkey The currently open threadkey.
386  */
387 APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key,
388  apr_status_t (*cleanup) (void *),
389  apr_threadkey_t *threadkey);
390 
391 #endif
392 
393 /**
394  * Create and initialize a new procattr variable
395  * @param new_attr The newly created procattr.
396  * @param cont The pool to use
397  */
399  apr_pool_t *cont);
400 
401 /**
402  * Determine if any of stdin, stdout, or stderr should be linked to pipes
403  * when starting a child process.
404  * @param attr The procattr we care about.
405  * @param in Should stdin be a pipe back to the parent?
406  * @param out Should stdout be a pipe back to the parent?
407  * @param err Should stderr be a pipe back to the parent?
408  * @note If APR_NO_PIPE, there will be no special channel, the child
409  * inherits the parent's corresponding stdio stream. If APR_NO_FILE is
410  * specified, that corresponding stream is closed in the child (and will
411  * be INVALID_HANDLE_VALUE when inspected on Win32). This can have ugly
412  * side effects, as the next file opened in the child on Unix will fall
413  * into the stdio stream fd slot!
414  */
416  apr_int32_t in, apr_int32_t out,
417  apr_int32_t err);
418 
419 /**
420  * Set the child_in and/or parent_in values to existing apr_file_t values.
421  * @param attr The procattr we care about.
422  * @param child_in apr_file_t value to use as child_in. Must be a valid file.
423  * @param parent_in apr_file_t value to use as parent_in. Must be a valid file.
424  * @remark This is NOT a required initializer function. This is
425  * useful if you have already opened a pipe (or multiple files)
426  * that you wish to use, perhaps persistently across multiple
427  * process invocations - such as a log file. You can save some
428  * extra function calls by not creating your own pipe since this
429  * creates one in the process space for you.
430  * @bug Note that calling this function with two NULL files on some platforms
431  * creates an APR_FULL_BLOCK pipe, but this behavior is neither portable nor
432  * is it supported. @see apr_procattr_io_set instead for simple pipes.
433  */
435  apr_file_t *child_in,
436  apr_file_t *parent_in);
437 
438 /**
439  * Set the child_out and parent_out values to existing apr_file_t values.
440  * @param attr The procattr we care about.
441  * @param child_out apr_file_t value to use as child_out. Must be a valid file.
442  * @param parent_out apr_file_t value to use as parent_out. Must be a valid file.
443  * @remark This is NOT a required initializer function. This is
444  * useful if you have already opened a pipe (or multiple files)
445  * that you wish to use, perhaps persistently across multiple
446  * process invocations - such as a log file.
447  * @bug Note that calling this function with two NULL files on some platforms
448  * creates an APR_FULL_BLOCK pipe, but this behavior is neither portable nor
449  * is it supported. @see apr_procattr_io_set instead for simple pipes.
450  */
452  apr_file_t *child_out,
453  apr_file_t *parent_out);
454 
455 /**
456  * Set the child_err and parent_err values to existing apr_file_t values.
457  * @param attr The procattr we care about.
458  * @param child_err apr_file_t value to use as child_err. Must be a valid file.
459  * @param parent_err apr_file_t value to use as parent_err. Must be a valid file.
460  * @remark This is NOT a required initializer function. This is
461  * useful if you have already opened a pipe (or multiple files)
462  * that you wish to use, perhaps persistently across multiple
463  * process invocations - such as a log file.
464  * @bug Note that calling this function with two NULL files on some platforms
465  * creates an APR_FULL_BLOCK pipe, but this behavior is neither portable nor
466  * is it supported. @see apr_procattr_io_set instead for simple pipes.
467  */
469  apr_file_t *child_err,
470  apr_file_t *parent_err);
471 
472 /**
473  * Set which directory the child process should start executing in.
474  * @param attr The procattr we care about.
475  * @param dir Which dir to start in. By default, this is the same dir as
476  * the parent currently resides in, when the createprocess call
477  * is made.
478  */
480  const char *dir);
481 
482 /**
483  * Set what type of command the child process will call.
484  * @param attr The procattr we care about.
485  * @param cmd The type of command. One of:
486  * <PRE>
487  * APR_SHELLCMD -- Anything that the shell can handle
488  * APR_PROGRAM -- Executable program (default)
489  * APR_PROGRAM_ENV -- Executable program, copy environment
490  * APR_PROGRAM_PATH -- Executable program on PATH, copy env
491  * </PRE>
492  */
494  apr_cmdtype_e cmd);
495 
496 /**
497  * Determine if the child should start in detached state.
498  * @param attr The procattr we care about.
499  * @param detach Should the child start in detached state? Default is no.
500  */
502  apr_int32_t detach);
503 
504 #if APR_HAVE_STRUCT_RLIMIT
505 /**
506  * Set the Resource Utilization limits when starting a new process.
507  * @param attr The procattr we care about.
508  * @param what Which limit to set, one of:
509  * <PRE>
510  * APR_LIMIT_CPU
511  * APR_LIMIT_MEM
512  * APR_LIMIT_NPROC
513  * APR_LIMIT_NOFILE
514  * </PRE>
515  * @param limit Value to set the limit to.
516  */
518  apr_int32_t what,
519  struct rlimit *limit);
520 #endif
521 
522 /**
523  * Specify an error function to be called in the child process if APR
524  * encounters an error in the child prior to running the specified program.
525  * @param attr The procattr describing the child process to be created.
526  * @param errfn The function to call in the child process.
527  * @remark At the present time, it will only be called from apr_proc_create()
528  * on platforms where fork() is used. It will never be called on other
529  * platforms, on those platforms apr_proc_create() will return the error
530  * in the parent process rather than invoke the callback in the now-forked
531  * child process.
532  */
534  apr_child_errfn_t *errfn);
535 
536 /**
537  * Specify that apr_proc_create() should do whatever it can to report
538  * failures to the caller of apr_proc_create(), rather than find out in
539  * the child.
540  * @param attr The procattr describing the child process to be created.
541  * @param chk Flag to indicate whether or not extra work should be done
542  * to try to report failures to the caller.
543  * @remark This flag only affects apr_proc_create() on platforms where
544  * fork() is used. This leads to extra overhead in the calling
545  * process, but that may help the application handle such
546  * errors more gracefully.
547  */
549  apr_int32_t chk);
550 
551 /**
552  * Determine if the child should start in its own address space or using the
553  * current one from its parent
554  * @param attr The procattr we care about.
555  * @param addrspace Should the child start in its own address space? Default
556  * is no on NetWare and yes on other platforms.
557  */
559  apr_int32_t addrspace);
560 
561 /**
562  * Set the username used for running process
563  * @param attr The procattr we care about.
564  * @param username The username used
565  * @param password User password if needed. Password is needed on WIN32
566  * or any other platform having
567  * APR_PROCATTR_USER_SET_REQUIRES_PASSWORD set.
568  */
570  const char *username,
571  const char *password);
572 
573 /**
574  * Set the group used for running process
575  * @param attr The procattr we care about.
576  * @param groupname The group name used
577  */
579  const char *groupname);
580 
581 
582 #if APR_HAS_FORK
583 /**
584  * This is currently the only non-portable call in APR. This executes
585  * a standard unix fork.
586  * @param proc The resulting process handle.
587  * @param cont The pool to use.
588  * @remark returns APR_INCHILD for the child, and APR_INPARENT for the parent
589  * or an error.
590  */
592 #endif
593 
594 /**
595  * Create a new process and execute a new program within that process.
596  * @param new_proc The resulting process handle.
597  * @param progname The program to run
598  * @param args the arguments to pass to the new program. The first
599  * one should be the program name.
600  * @param env The new environment table for the new process. This
601  * should be a list of NULL-terminated strings. This argument
602  * is ignored for APR_PROGRAM_ENV, APR_PROGRAM_PATH, and
603  * APR_SHELLCMD_ENV types of commands.
604  * @param attr the procattr we should use to determine how to create the new
605  * process
606  * @param pool The pool to use.
607  * @note This function returns without waiting for the new process to terminate;
608  * use apr_proc_wait for that.
609  */
611  const char *progname,
612  const char * const *args,
613  const char * const *env,
614  apr_procattr_t *attr,
615  apr_pool_t *pool);
616 
617 /**
618  * Wait for a child process to die
619  * @param proc The process handle that corresponds to the desired child process
620  * @param exitcode The returned exit status of the child, if a child process
621  * dies, or the signal that caused the child to die.
622  * On platforms that don't support obtaining this information,
623  * the status parameter will be returned as APR_ENOTIMPL.
624  * @param exitwhy Why the child died, the bitwise or of:
625  * <PRE>
626  * APR_PROC_EXIT -- process terminated normally
627  * APR_PROC_SIGNAL -- process was killed by a signal
628  * APR_PROC_SIGNAL_CORE -- process was killed by a signal, and
629  * generated a core dump.
630  * </PRE>
631  * @param waithow How should we wait. One of:
632  * <PRE>
633  * APR_WAIT -- block until the child process dies.
634  * APR_NOWAIT -- return immediately regardless of if the
635  * child is dead or not.
636  * </PRE>
637  * @remark The child's status is in the return code to this process. It is one of:
638  * <PRE>
639  * APR_CHILD_DONE -- child is no longer running.
640  * APR_CHILD_NOTDONE -- child is still running.
641  * </PRE>
642  */
644  int *exitcode, apr_exit_why_e *exitwhy,
645  apr_wait_how_e waithow);
646 
647 /**
648  * Wait for any current child process to die and return information
649  * about that child.
650  * @param proc Pointer to NULL on entry, will be filled out with child's
651  * information
652  * @param exitcode The returned exit status of the child, if a child process
653  * dies, or the signal that caused the child to die.
654  * On platforms that don't support obtaining this information,
655  * the status parameter will be returned as APR_ENOTIMPL.
656  * @param exitwhy Why the child died, the bitwise or of:
657  * <PRE>
658  * APR_PROC_EXIT -- process terminated normally
659  * APR_PROC_SIGNAL -- process was killed by a signal
660  * APR_PROC_SIGNAL_CORE -- process was killed by a signal, and
661  * generated a core dump.
662  * </PRE>
663  * @param waithow How should we wait. One of:
664  * <PRE>
665  * APR_WAIT -- block until the child process dies.
666  * APR_NOWAIT -- return immediately regardless of if the
667  * child is dead or not.
668  * </PRE>
669  * @param p Pool to allocate child information out of.
670  * @bug Passing proc as a *proc rather than **proc was an odd choice
671  * for some platforms... this should be revisited in 1.0
672  */
674  int *exitcode,
675  apr_exit_why_e *exitwhy,
676  apr_wait_how_e waithow,
677  apr_pool_t *p);
678 
679 #define APR_PROC_DETACH_FOREGROUND 0 /**< Do not detach */
680 #define APR_PROC_DETACH_DAEMONIZE 1 /**< Detach */
681 
682 /**
683  * Detach the process from the controlling terminal.
684  * @param daemonize set to non-zero if the process should daemonize
685  * and become a background process, else it will
686  * stay in the foreground.
687  */
690 /**
691  * Register an other_child -- a child associated to its registered
692  * maintence callback. This callback is invoked when the process
693  * dies, is disconnected or disappears.
694  * @param proc The child process to register.
695  * @param maintenance maintenance is a function that is invoked with a
696  * reason and the data pointer passed here.
697  * @param data Opaque context data passed to the maintenance function.
698  * @param write_fd An fd that is probed for writing. If it is ever unwritable
699  * then the maintenance is invoked with reason
700  * OC_REASON_UNWRITABLE.
701  * @param p The pool to use for allocating memory.
702  * @bug write_fd duplicates the proc->out stream, it's really redundant
703  * and should be replaced in the APR 1.0 API with a bitflag of which
704  * proc->in/out/err handles should be health checked.
705  * @bug no platform currently tests the pipes health.
706  */
708  void (*maintenance) (int reason,
709  void *,
710  int status),
711  void *data, apr_file_t *write_fd,
712  apr_pool_t *p);
713 
714 /**
715  * Stop watching the specified other child.
716  * @param data The data to pass to the maintenance function. This is
717  * used to find the process to unregister.
718  * @warning Since this can be called by a maintenance function while we're
719  * scanning the other_children list, all scanners should protect
720  * themself by loading ocr->next before calling any maintenance
721  * function.
722  */
724 
725 /**
726  * Notify the maintenance callback of a registered other child process
727  * that application has detected an event, such as death.
728  * @param proc The process to check
729  * @param reason The reason code to pass to the maintenance function
730  * @param status The status to pass to the maintenance function
731  * @remark An example of code using this behavior;
732  * <pre>
733  * rv = apr_proc_wait_all_procs(&proc, &exitcode, &status, APR_WAIT, p);
734  * if (APR_STATUS_IS_CHILD_DONE(rv)) {
735  * \#if APR_HAS_OTHER_CHILD
736  * if (apr_proc_other_child_alert(&proc, APR_OC_REASON_DEATH, status)
737  * == APR_SUCCESS) {
738  * ; (already handled)
739  * }
740  * else
741  * \#endif
742  * [... handling non-otherchild processes death ...]
743  * </pre>
744  */
746  int reason,
747  int status);
748 
749 /**
750  * Test one specific other child processes and invoke the maintenance callback
751  * with the appropriate reason code, if still running, or the appropriate reason
752  * code if the process is no longer healthy.
753  * @param ocr The registered other child
754  * @param reason The reason code (e.g. APR_OC_REASON_RESTART) if still running
755  */
757  int reason);
758 
759 /**
760  * Test all registered other child processes and invoke the maintenance callback
761  * with the appropriate reason code, if still running, or the appropriate reason
762  * code if the process is no longer healthy.
763  * @param reason The reason code (e.g. APR_OC_REASON_RESTART) to running processes
764  */
766 
767 /**
768  * Terminate a process.
769  * @param proc The process to terminate.
770  * @param sig How to kill the process.
771  */
773 
774 /**
775  * Register a process to be killed when a pool dies.
776  * @param a The pool to use to define the processes lifetime
777  * @param proc The process to register
778  * @param how How to kill the process, one of:
779  * <PRE>
780  * APR_KILL_NEVER -- process is never sent any signals
781  * APR_KILL_ALWAYS -- process is sent SIGKILL on apr_pool_t cleanup
782  * APR_KILL_AFTER_TIMEOUT -- SIGTERM, wait 3 seconds, SIGKILL
783  * APR_JUST_WAIT -- wait forever for the process to complete
784  * APR_KILL_ONLY_ONCE -- send SIGTERM and then wait
785  * </PRE>
786  */
789 
790 #if APR_HAS_THREADS
791 
792 #if (APR_HAVE_SIGWAIT || APR_HAVE_SIGSUSPEND) && !defined(OS2)
793 
794 /**
795  * Setup the process for a single thread to be used for all signal handling.
796  * @warning This must be called before any threads are created
797  */
799 
800 /**
801  * Make the current thread listen for signals. This thread will loop
802  * forever, calling a provided function whenever it receives a signal. That
803  * functions should return 1 if the signal has been handled, 0 otherwise.
804  * @param signal_handler The function to call when a signal is received
805  * apr_status_t apr_signal_thread((int)(*signal_handler)(int signum))
806  */
807 APR_DECLARE(apr_status_t) apr_signal_thread(int(*signal_handler)(int signum));
808 
809 #endif /* (APR_HAVE_SIGWAIT || APR_HAVE_SIGSUSPEND) && !defined(OS2) */
810 
811 /**
812  * Get the child-pool used by the thread from the thread info.
813  * @return apr_pool_t the pool
814  */
816 
817 #endif /* APR_HAS_THREADS */
818 
819 /** @} */
820 
821 #ifdef __cplusplus
822 }
823 #endif
824 
825 #endif /* ! APR_THREAD_PROC_H */
826