apr_thread_proc.h

Go to the documentation of this file.

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef APR_THREAD_PROC_H
#define APR_THREAD_PROC_H
 
#include "apr.h"
#include "apr_file_io.h"
#include "apr_pools.h"
#include "apr_errno.h"
#include "apr_perms_set.h"
 
#if APR_HAVE_STRUCT_RLIMIT
#include <sys/time.h>
#include <sys/resource.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
typedef enum {
    APR_SHELLCMD,           
    APR_PROGRAM,            
    APR_PROGRAM_ENV,        
    APR_PROGRAM_PATH,       
    APR_SHELLCMD_ENV        
} apr_cmdtype_e;
 
typedef enum {
    APR_WAIT,           
    APR_NOWAIT          
} apr_wait_how_e;
 
/* I am specifically calling out the values so that the macros below make
 * more sense.  Yes, I know I don't need to, but I am hoping this makes what
 * I am doing more clear.  If you want to add more reasons to exit, continue
 * to use bitmasks.
 */
typedef enum {
    APR_PROC_EXIT = 1,          
    APR_PROC_SIGNAL = 2,        
    APR_PROC_SIGNAL_CORE = 4    
} apr_exit_why_e;
 
#define APR_PROC_CHECK_EXIT(x)        (x & APR_PROC_EXIT)
#define APR_PROC_CHECK_SIGNALED(x)    (x & APR_PROC_SIGNAL)
#define APR_PROC_CHECK_CORE_DUMP(x)   (x & APR_PROC_SIGNAL_CORE)
 
#define APR_NO_PIPE          0
#define APR_FULL_BLOCK       1
#define APR_FULL_NONBLOCK    2
#define APR_PARENT_BLOCK     3
#define APR_CHILD_BLOCK      4
#define APR_NO_FILE          8
 
#define APR_READ_BLOCK       3
#define APR_WRITE_BLOCK      4
 
#define APR_NO_FILE          8
 
#define APR_LIMIT_CPU        0
#define APR_LIMIT_MEM        1
#define APR_LIMIT_NPROC      2
#define APR_LIMIT_NOFILE     3
 
#define APR_OC_REASON_DEATH         0     
#define APR_OC_REASON_UNWRITABLE    1     
#define APR_OC_REASON_RESTART       2     
#define APR_OC_REASON_UNREGISTER    3     
#define APR_OC_REASON_LOST          4     
#define APR_OC_REASON_RUNNING       5     
typedef struct apr_proc_t {
    pid_t pid;
    apr_file_t *in;
    apr_file_t *out;
    apr_file_t *err;
#if APR_HAS_PROC_INVOKED || defined(DOXYGEN)
    char *invoked;
#endif
#if defined(WIN32) || defined(DOXYGEN)
    HANDLE hproc;
#endif
} apr_proc_t;
 
typedef void (apr_child_errfn_t)(apr_pool_t *proc, apr_status_t err,
                                 const char *description);
 
typedef struct apr_thread_t           apr_thread_t;
 
typedef struct apr_threadattr_t       apr_threadattr_t;
 
typedef struct apr_procattr_t         apr_procattr_t;
 
typedef struct apr_thread_once_t      apr_thread_once_t;
 
typedef struct apr_threadkey_t        apr_threadkey_t;
 
typedef struct apr_other_child_rec_t  apr_other_child_rec_t;
 
typedef void *(APR_THREAD_FUNC *apr_thread_start_t)(apr_thread_t*, void*);
 
typedef enum {
    APR_KILL_NEVER,             
    APR_KILL_ALWAYS,            
    APR_KILL_AFTER_TIMEOUT,     
    APR_JUST_WAIT,              
    APR_KILL_ONLY_ONCE          
} apr_kill_conditions_e;
 
/* Thread Function definitions */
 
#if APR_HAS_THREADS
 
#if defined(__cplusplus) && __cplusplus >= 201103L
#define APR_THREAD_LOCAL thread_local
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112 && \
      (!defined(__GNUC__) || \
      __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
#define APR_THREAD_LOCAL _Thread_local
#elif defined(__GNUC__) /* works for clang too */
#define APR_THREAD_LOCAL __thread
#elif defined(WIN32) && defined(_MSC_VER)
#define APR_THREAD_LOCAL __declspec(thread)
#endif
 
#ifdef APR_THREAD_LOCAL
#define APR_HAS_THREAD_LOCAL 1
#else
#define APR_HAS_THREAD_LOCAL 0
#endif
 
APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new_attr,
                                                apr_pool_t *cont);
 
APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr,
                                                    apr_int32_t on);
 
APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr);
 
APR_DECLARE(apr_status_t) apr_threadattr_stacksize_set(apr_threadattr_t *attr,
                                                       apr_size_t stacksize);
 
APR_DECLARE(apr_status_t) apr_threadattr_guardsize_set(apr_threadattr_t *attr,
                                                       apr_size_t guardsize);
 
APR_DECLARE(apr_status_t) apr_threadattr_max_free_set(apr_threadattr_t *attr,
                                                      apr_size_t size);
 
APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new_thread,
                                            apr_threadattr_t *attr,
                                            apr_thread_start_t func,
                                            void *data, apr_pool_t *cont);
 
APR_DECLARE(apr_status_t) apr_thread_current_create(apr_thread_t **current,
                                                    apr_threadattr_t *attr,
                                                    apr_pool_t *pool);
 
APR_DECLARE(void) apr_thread_current_after_fork(void);
 
APR_DECLARE(apr_thread_t *) apr_thread_current(void);
 
APR_DECLARE(void) apr_thread_exit(apr_thread_t *thd, apr_status_t retval)
    __attribute__((noreturn));
 
APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval,
                                          apr_thread_t *thd);
 
APR_DECLARE(apr_status_t) apr_thread_name_get(char **name,
                                              apr_thread_t *thread,
                                              apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_thread_name_set(const char *name,
                                              apr_thread_t *thread,
                                              apr_pool_t *pool);
 
APR_DECLARE(void) apr_thread_yield(void);
 
APR_DECLARE(apr_status_t) apr_thread_once_init(apr_thread_once_t **control,
                                               apr_pool_t *p);
 
APR_DECLARE(apr_status_t) apr_thread_once(apr_thread_once_t *control,
                                          void (*func)(void));
 
APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd);
 
APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key,
                                             apr_thread_t *thread);
 
APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key,
                                             apr_status_t (*cleanup) (void *),
                                             apr_thread_t *thread);
 
APR_DECLARE(apr_status_t) apr_threadkey_private_create(apr_threadkey_t **key,
                                                    void (*dest)(void *),
                                                    apr_pool_t *cont);
 
APR_DECLARE(apr_status_t) apr_threadkey_private_get(void **new_mem,
                                                 apr_threadkey_t *key);
 
APR_DECLARE(apr_status_t) apr_threadkey_private_set(void *priv,
                                                 apr_threadkey_t *key);
 
APR_DECLARE(apr_status_t) apr_threadkey_private_delete(apr_threadkey_t *key);
 
APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key,
                                                apr_threadkey_t *threadkey);
 
APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key,
                                                apr_status_t (*cleanup) (void *),
                                                apr_threadkey_t *threadkey);
 
#else  /* APR_HAS_THREADS */
 
#define APR_HAS_THREAD_LOCAL 0
 
#endif /* APR_HAS_THREADS */
 
APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new_attr,
                                                  apr_pool_t *cont);
 
APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr,
                                             apr_int32_t in, apr_int32_t out,
                                             apr_int32_t err);
 
APR_DECLARE(apr_status_t) apr_procattr_child_in_set(struct apr_procattr_t *attr,
                                                  apr_file_t *child_in,
                                                  apr_file_t *parent_in);
 
APR_DECLARE(apr_status_t) apr_procattr_child_out_set(struct apr_procattr_t *attr,
                                                   apr_file_t *child_out,
                                                   apr_file_t *parent_out);
 
APR_DECLARE(apr_status_t) apr_procattr_child_err_set(struct apr_procattr_t *attr,
                                                   apr_file_t *child_err,
                                                   apr_file_t *parent_err);
 
APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr,
                                              const char *dir);
 
APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr,
                                                  apr_cmdtype_e cmd);
 
APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr,
                                                 apr_int32_t detach);
 
#if APR_HAVE_STRUCT_RLIMIT
APR_DECLARE(apr_status_t) apr_procattr_limit_set(apr_procattr_t *attr,
                                                apr_int32_t what,
                                                struct rlimit *limit);
#endif
 
APR_DECLARE(apr_status_t) apr_procattr_child_errfn_set(apr_procattr_t *attr,
                                                       apr_child_errfn_t *errfn);
 
APR_DECLARE(apr_status_t) apr_procattr_error_check_set(apr_procattr_t *attr,
                                                       apr_int32_t chk);
 
APR_DECLARE(apr_status_t) apr_procattr_addrspace_set(apr_procattr_t *attr,
                                                       apr_int32_t addrspace);
 
APR_DECLARE(apr_status_t) apr_procattr_user_set(apr_procattr_t *attr,
                                                const char *username,
                                                const char *password);
 
APR_DECLARE(apr_status_t) apr_procattr_group_set(apr_procattr_t *attr,
                                                 const char *groupname);
 
 
APR_DECLARE(apr_status_t) apr_procattr_perms_set_register(apr_procattr_t *attr,
                                                 apr_perms_setfn_t *perms_set_fn,
                                                 void *data,
                                                 apr_fileperms_t perms);
 
#if APR_HAS_FORK
APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont);
#endif
 
APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new_proc,
                                          const char *progname,
                                          const char * const *args,
                                          const char * const *env,
                                          apr_procattr_t *attr,
                                          apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc,
                                        int *exitcode, apr_exit_why_e *exitwhy,
                                        apr_wait_how_e waithow);
 
APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc,
                                                  int *exitcode,
                                                  apr_exit_why_e *exitwhy,
                                                  apr_wait_how_e waithow,
                                                  apr_pool_t *p);
 
#define APR_PROC_DETACH_FOREGROUND 0    
#define APR_PROC_DETACH_DAEMONIZE 1     
APR_DECLARE(apr_status_t) apr_proc_detach(int daemonize);
 
APR_DECLARE(void) apr_proc_other_child_register(apr_proc_t *proc,
                                           void (*maintenance) (int reason,
                                                                void *,
                                                                int status),
                                           void *data, apr_file_t *write_fd,
                                           apr_pool_t *p);
 
APR_DECLARE(void) apr_proc_other_child_unregister(void *data);
 
APR_DECLARE(apr_status_t) apr_proc_other_child_alert(apr_proc_t *proc,
                                                     int reason,
                                                     int status);
 
APR_DECLARE(void) apr_proc_other_child_refresh(apr_other_child_rec_t *ocr,
                                               int reason);
 
APR_DECLARE(void) apr_proc_other_child_refresh_all(int reason);
 
APR_DECLARE(apr_status_t) apr_proc_kill(apr_proc_t *proc, int sig);
 
APR_DECLARE(void) apr_pool_note_subprocess(apr_pool_t *a, apr_proc_t *proc,
                                           apr_kill_conditions_e how);
 
#if APR_HAS_THREADS
 
#if (APR_HAVE_SIGWAIT || APR_HAVE_SIGSUSPEND) && !defined(OS2)
 
APR_DECLARE(apr_status_t) apr_setup_signal_thread(void);
 
APR_DECLARE(apr_status_t) apr_signal_thread(int(*signal_handler)(int signum));
 
#endif /* (APR_HAVE_SIGWAIT || APR_HAVE_SIGSUSPEND) && !defined(OS2) */
 
APR_POOL_DECLARE_ACCESSOR(thread);
 
#endif /* APR_HAS_THREADS */
 
#ifdef __cplusplus
}
#endif
 
#endif  /* ! APR_THREAD_PROC_H */