On Mon, Feb 27, 2012 at 4:25 AM, Michael Felt <[email protected]> wrote: > The patch impaired me moved the file to ./include and rebuilt. > Similiar issues: > > httpd: Syntax error on line 143 of /etc/httpd/httpd.conf: Cannot load > /opt/httpd/libexec/mod_mpm_worker.so into server: > rtld: 0712-001 Symbol ap_fatal_signal_child_setup was referenced > > from module /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime definition > of the symbol was not found. > rtld: 0712-001 Symbol ap_reopen_scoreboard was referenced > > from module /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime definition > of the symbol was not found. > rtld: 0712-001 Symbol ap_mpm_set_graceful_shutdown was referenced > > from module /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime definition > of the symbol was not found.
getting much closer AFAICT please try with the pdated mpm_common.h and scoreboard.h attached > > rtld is"runtime linker/loader", for those wondering... > > > On Sun, Feb 26, 2012 at 11:13 PM, Jeff Trawick <[email protected]> wrote: >> >> On Sun, Feb 26, 2012 at 5:09 PM, Michael Felt <[email protected]> wrote: >> > patched manually, building... >> >> ouch... maybe you have GNU patch installed as gpatch from the AIX >> Toolbox? >> >> anyway, in a subsequent e-mail I noticed other missing symbols... >> that's in the latest patch and, for the patch impaired, updated >> mpm_common.h, both attached >> >> >> > >> > >> > On Sun, Feb 26, 2012 at 10:56 PM, Michael Felt <[email protected]> >> > wrote: >> >> >> >> er, almost working: >> >> michael@x054:[/data/prj/httpd-2.4.1]patch -p0 -i *.patch >> >> Processing... Looks like a unified context diff... >> >> The text leading up to this was: >> >> -------------------------- >> >> |Index: include/mpm_common.h >> >> |=================================================================== >> >> |--- include/mpm_common.h (revision 1293841) >> >> |+++ include/mpm_common.h (working copy) >> >> -------------------------- >> >> Patching file include/mpm_common.h using Plan A... >> >> patch: 3016-037 Malformed patch at line 9: -void >> >> ap_reclaim_child_processes(int terminate, >> >> >> >> >> >> >> >> On Sun, Feb 26, 2012 at 10:53 PM, Michael Felt <[email protected]> >> >> wrote: >> >>> >> >>> :) patch from AIX 6.1 works, starting build. >> >>> >> >>> >> >>> On Sun, Feb 26, 2012 at 10:52 PM, Michael Felt <[email protected]> >> >>> wrote: >> >>>> >> >>>> re: not exported... They are not in the .o files either (or is that >> >>>> because they are not exported?) >> >>>> >> >>>> >> >>>> On Sun, Feb 26, 2012 at 10:51 PM, Michael Felt <[email protected]> >> >>>> wrote: >> >>>>> >> >>>>> I am not so smart I fear, and still no svm installed (working on >> >>>>> building gnudiff, but not done yet... >> >>>>> >> >>>>> root@x105:[/data/prj/httpd-2.4.1]patch -i *patch >> >>>>> Processing... I cannot find a patch in there anywhere. >> >>>>> >> >>>>> >> >>>>> >> >>>>> On Sun, Feb 26, 2012 at 10:44 PM, Jeff Trawick <[email protected]> >> >>>>> wrote: >> >>>>>> >> >>>>>> On Sun, Feb 26, 2012 at 3:30 PM, Michael Felt <[email protected]> >> >>>>>> wrote: >> >>>>>> > Unfortunately, although it builds fine, it does not start: >> >>>>>> > >> >>>>>> > httpd: Syntax error on line 143 of /etc/httpd/httpd.conf: Cannot >> >>>>>> > load >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so into server: rtld: 0712-001 >> >>>>>> > Symbol >> >>>>>> > ap_fatal_signal_setup was referenced\n from module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime >> >>>>>> > definition\n of >> >>>>>> > the symbol was not found.\nrtld: 0712-001 Symbol ap_pid_fname was >> >>>>>> > referenced\n from module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), but a >> >>>>>> > runtime definition\n of the symbol was not found.\nrtld: >> >>>>>> > 0712-001 >> >>>>>> > Symbol ap_reclaim_child_processes was referenced\n from >> >>>>>> > module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime >> >>>>>> > definition\n of >> >>>>>> > the symbol was not found.\nrtld: 0712-001 Symbol >> >>>>>> > ap_relieve_child_processes >> >>>>>> > was referenced\n from module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), >> >>>>>> > but a runtime definition\n of the symbol was not >> >>>>>> > found.\nrtld: >> >>>>>> > 0712-001 >> >>>>>> > Symbol ap_graceful_shutdown_timeout was referenced\n from >> >>>>>> > module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime >> >>>>>> > definition\n of >> >>>>>> > the symbol was not found.\nrtld: 0712-001 Symbol ap_mpm_safe_kill >> >>>>>> > was >> >>>>>> > referenced\n from module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), but a >> >>>>>> > runtime definition\n of the symbol was not found.\nrtld: >> >>>>>> > 0712-001 >> >>>>>> > Symbol ap_wait_or_timeout was referenced\n from module >> >>>>>> > /opt/httpd/libexec/mod_mpm_worker.so(), but a runtime >> >>>>>> > definition\n of >> >>>>>> > the symbol was not found.\n\t0509-021 Additional errors occurred >> >>>>>> > but >> >>>>>> > are not >> >>>>>> > reported. >> >>>>>> > >> >>>>>> > I have been able to find a few of these routines in source code, >> >>>>>> > e,g, >> >>>>>> > server/mpm_unix.c, but the routines are not included in >> >>>>>> > server/mpm_worker.o, >> >>>>>> > hence .... >> >>>>>> > >> >>>>>> > Suggestions welcome (other than filing a bug report). >> >>>>>> >> >>>>>> I guess the problem is that those MPM APIs are not decorated with >> >>>>>> AP_DECLARE() so they don't get added to httpd.exp so they don't get >> >>>>>> exported from httpd on AIX. >> >>>>>> >> >>>>>> Can you try the attached patch to mpm_common.h? >> >>>>> >> >>>>> >> >>>> >> >>> >> >> >> > >> >> >> >> -- >> Born in Roswell... married an alien... > > -- Born in Roswell... married an alien...
/* 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. */ /* The purpose of this file is to store the code that MOST mpm's will need * this does not mean a function only goes into this file if every MPM needs * it. It means that if a function is needed by more than one MPM, and * future maintenance would be served by making the code common, then the * function belongs here. * * This is going in src/main because it is not platform specific, it is * specific to multi-process servers, but NOT to Unix. Which is why it * does not belong in src/os/unix */ /** * @file mpm_common.h * @brief Multi-Processing Modules functions * * @defgroup APACHE_MPM Multi-Processing Modules * @ingroup APACHE * @{ */ #ifndef APACHE_MPM_COMMON_H #define APACHE_MPM_COMMON_H #include "ap_config.h" #include "ap_mpm.h" #include "scoreboard.h" #if APR_HAVE_NETINET_TCP_H #include <netinet/tcp.h> /* for TCP_NODELAY */ #endif #include "apr_proc_mutex.h" #ifdef __cplusplus extern "C" { #endif /* The maximum length of the queue of pending connections, as defined * by listen(2). Under some systems, it should be increased if you * are experiencing a heavy TCP SYN flood attack. * * It defaults to 511 instead of 512 because some systems store it * as an 8-bit datatype; 512 truncated to 8-bits is 0, while 511 is * 255 when truncated. */ #ifndef DEFAULT_LISTENBACKLOG #define DEFAULT_LISTENBACKLOG 511 #endif /* Signal used to gracefully restart */ #define AP_SIG_GRACEFUL SIGUSR1 /* Signal used to gracefully restart (without SIG prefix) */ #define AP_SIG_GRACEFUL_SHORT USR1 /* Signal used to gracefully restart (as a quoted string) */ #define AP_SIG_GRACEFUL_STRING "SIGUSR1" /* Signal used to gracefully stop */ #define AP_SIG_GRACEFUL_STOP SIGWINCH /* Signal used to gracefully stop (without SIG prefix) */ #define AP_SIG_GRACEFUL_STOP_SHORT WINCH /* Signal used to gracefully stop (as a quoted string) */ #define AP_SIG_GRACEFUL_STOP_STRING "SIGWINCH" /** * Callback function used for ap_reclaim_child_processes() and * ap_relieve_child_processes(). The callback function will be * called for each terminated child process. */ typedef void ap_reclaim_callback_fn_t(int childnum, pid_t pid, ap_generation_t gen); /** * Make sure all child processes that have been spawned by the parent process * have died. This includes process registered as "other_children". * * @param terminate Either 1 or 0. If 1, send the child processes SIGTERM * each time through the loop. If 0, give the process time to die * on its own before signalling it. * @param mpm_callback Callback invoked for each dead child process * * @note The MPM child processes which are reclaimed are those listed * in the scoreboard as well as those currently registered via * ap_register_extra_mpm_process(). */ AP_DECLARE(void) ap_reclaim_child_processes(int terminate, ap_reclaim_callback_fn_t *mpm_callback); /** * Catch any child processes that have been spawned by the parent process * which have exited. This includes processes registered as "other_children". * * @param mpm_callback Callback invoked for each dead child process * @note The MPM child processes which are relieved are those listed * in the scoreboard as well as those currently registered via * ap_register_extra_mpm_process(). */ AP_DECLARE(void) ap_relieve_child_processes(ap_reclaim_callback_fn_t *mpm_callback); /** * Tell ap_reclaim_child_processes() and ap_relieve_child_processes() about * an MPM child process which has no entry in the scoreboard. * @param pid The process id of an MPM child process which should be * reclaimed when ap_reclaim_child_processes() is called. * @param gen The generation of this MPM child process. * * @note If an extra MPM child process terminates prior to calling * ap_reclaim_child_processes(), remove it from the list of such processes * by calling ap_unregister_extra_mpm_process(). */ AP_DECLARE(void) ap_register_extra_mpm_process(pid_t pid, ap_generation_t gen); /** * Unregister an MPM child process which was previously registered by a * call to ap_register_extra_mpm_process(). * @param pid The process id of an MPM child process which no longer needs to * be reclaimed. * @param old_gen Set to the server generation of the process, if found. * @return 1 if the process was found and removed, 0 otherwise */ AP_DECLARE(int) ap_unregister_extra_mpm_process(pid_t pid, ap_generation_t *old_gen); /** * Pool cleanup for end-generation hook implementation */ apr_status_t ap_mpm_end_gen_helper(void *unused); /** * Safely signal an MPM child process, if the process is in the * current process group. Otherwise fail. * @param pid the process id of a child process to signal * @param sig the signal number to send * @return APR_SUCCESS if signal is sent, otherwise an error as per kill(3); * APR_EINVAL is returned if passed either an invalid (< 1) pid, or if * the pid is not in the current process group */ AP_DECLARE(apr_status_t) ap_mpm_safe_kill(pid_t pid, int sig); /** * Run the monitor hook (once every ten calls), determine if any child * process has died and, if none died, sleep one second. * @param status The return code if a process has died * @param exitcode The returned exit status of the child, if a child process * dies, or the signal that caused the child to die. * @param ret The process id of the process that died * @param p The pool to allocate out of * @param s The server_rec to pass */ AP_DECLARE(void) ap_wait_or_timeout(apr_exit_why_e *status, int *exitcode, apr_proc_t *ret, apr_pool_t *p, server_rec *s); /** * Log why a child died to the error log, if the child died without the * parent signalling it. * @param pid The child that has died * @param why The return code of the child process * @param status The status returned from ap_wait_or_timeout * @return 0 on success, APEXIT_CHILDFATAL if MPM should terminate */ AP_DECLARE(int) ap_process_child_status(apr_proc_t *pid, apr_exit_why_e why, int status); #if defined(TCP_NODELAY) /** * Turn off the nagle algorithm for the specified socket. The nagle algorithm * says that we should delay sending partial packets in the hopes of getting * more data. There are bad interactions between persistent connections and * Nagle's algorithm that have severe performance penalties. * @param s The socket to disable nagle for. */ void ap_sock_disable_nagle(apr_socket_t *s); #else #define ap_sock_disable_nagle(s) /* NOOP */ #endif #ifdef HAVE_GETPWNAM /** * Convert a username to a numeric ID * @param name The name to convert * @return The user id corresponding to a name * @fn uid_t ap_uname2id(const char *name) */ AP_DECLARE(uid_t) ap_uname2id(const char *name); #endif #ifdef HAVE_GETGRNAM /** * Convert a group name to a numeric ID * @param name The name to convert * @return The group id corresponding to a name * @fn gid_t ap_gname2id(const char *name) */ AP_DECLARE(gid_t) ap_gname2id(const char *name); #endif #ifndef HAVE_INITGROUPS /** * The initgroups() function initializes the group access list by reading the * group database /etc/group and using all groups of which user is a member. * The additional group basegid is also added to the list. * @param name The user name - must be non-NULL * @param basegid The basegid to add * @return returns 0 on success * @fn int initgroups(const char *name, gid_t basegid) */ int initgroups(const char *name, gid_t basegid); #endif #if !defined(WIN32) || defined(DOXYGEN) typedef struct ap_pod_t ap_pod_t; struct ap_pod_t { apr_file_t *pod_in; apr_file_t *pod_out; apr_pool_t *p; }; /** * Open the pipe-of-death. The pipe of death is used to tell all child * processes that it is time to die gracefully. * @param p The pool to use for allocating the pipe * @param pod the pipe-of-death that is created. */ AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t *p, ap_pod_t **pod); /** * Check the pipe to determine if the process has been signalled to die. */ AP_DECLARE(apr_status_t) ap_mpm_pod_check(ap_pod_t *pod); /** * Close the pipe-of-death * * @param pod the pipe-of-death to close. */ AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t *pod); /** * Write data to the pipe-of-death, signalling that one child process * should die. * @param pod the pipe-of-death to write to. */ AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t *pod); /** * Write data to the pipe-of-death, signalling that all child process * should die. * @param pod The pipe-of-death to write to. * @param num The number of child processes to kill */ AP_DECLARE(void) ap_mpm_pod_killpg(ap_pod_t *pod, int num); #endif /* !WIN32 || DOXYGEN */ /** * Check that exactly one MPM is loaded * Returns NULL if yes, error string if not. */ AP_DECLARE(const char *) ap_check_mpm(void); /* * These data members are common to all mpms. Each new mpm * should either use the appropriate ap_mpm_set_* function * in their command table or create their own for custom or * OS specific needs. These should work for most. */ /** * The maximum number of requests each child thread or * process handles before dying off */ extern int ap_max_requests_per_child; const char *ap_mpm_set_max_requests(cmd_parms *cmd, void *dummy, const char *arg); /** * The filename used to store the process id. */ AP_DECLARE_DATA extern const char *ap_pid_fname; const char *ap_mpm_set_pidfile(cmd_parms *cmd, void *dummy, const char *arg); void ap_mpm_dump_pidfile(apr_pool_t *p, apr_file_t *out); /* * The directory that the server changes directory to dump core. */ extern char ap_coredump_dir[MAX_STRING_LEN]; extern int ap_coredumpdir_configured; const char *ap_mpm_set_coredumpdir(cmd_parms *cmd, void *dummy, const char *arg); /** * Set the timeout period for a graceful shutdown. */ AP_DECLARE_DATA extern int ap_graceful_shutdown_timeout; AP_DECLARE(const char *)ap_mpm_set_graceful_shutdown(cmd_parms *cmd, void *dummy, const char *arg); #define AP_GRACEFUL_SHUTDOWN_TIMEOUT_COMMAND \ AP_INIT_TAKE1("GracefulShutdownTimeout", ap_mpm_set_graceful_shutdown, NULL, \ RSRC_CONF, "Maximum time in seconds to wait for child " \ "processes to complete transactions during shutdown") int ap_signal_server(int *, apr_pool_t *); void ap_mpm_rewrite_args(process_rec *); AP_DECLARE_DATA extern apr_uint32_t ap_max_mem_free; extern const char *ap_mpm_set_max_mem_free(cmd_parms *cmd, void *dummy, const char *arg); extern apr_size_t ap_thread_stacksize; extern const char *ap_mpm_set_thread_stacksize(cmd_parms *cmd, void *dummy, const char *arg); AP_DECLARE(apr_status_t) ap_fatal_signal_setup(server_rec *s, apr_pool_t *pconf); AP_DECLARE(apr_status_t) ap_fatal_signal_child_setup(server_rec *s); /* core's implementation of child_status hook */ extern void ap_core_child_status(server_rec *s, pid_t pid, ap_generation_t gen, int slot, mpm_child_status status); #if AP_ENABLE_EXCEPTION_HOOK extern const char *ap_mpm_set_exception_hook(cmd_parms *cmd, void *dummy, const char *arg); #endif AP_DECLARE_HOOK(int,monitor,(apr_pool_t *p, server_rec *s)) /* register modules that undertake to manage system security */ AP_DECLARE(int) ap_sys_privileges_handlers(int inc); AP_DECLARE_HOOK(int, drop_privileges, (apr_pool_t * pchild, server_rec * s)) /* implement the ap_mpm_query() function * The MPM should return OK+APR_ENOTIMPL for any unimplemented query codes; * modules which intercede for specific query codes should DECLINE for others. */ AP_DECLARE_HOOK(int, mpm_query, (int query_code, int *result, apr_status_t *rv)) /* register the specified callback */ AP_DECLARE_HOOK(apr_status_t, mpm_register_timed_callback, (apr_time_t t, ap_mpm_callback_fn_t *cbfn, void *baton)) /* get MPM name (e.g., "prefork" or "event") */ AP_DECLARE_HOOK(const char *,mpm_get_name,(void)) /* mutex type string for accept mutex, if any; MPMs should use the * same mutex type for ease of configuration */ #define AP_ACCEPT_MUTEX_TYPE "mpm-accept" /* internal pre-config logic for MPM-related settings, callable only from * core's pre-config hook */ void mpm_common_pre_config(apr_pool_t *pconf); #ifdef __cplusplus } #endif #endif /* !APACHE_MPM_COMMON_H */ /** @} */
/* 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. */ /** * @file scoreboard.h * @brief Apache scoreboard library */ #ifndef APACHE_SCOREBOARD_H #define APACHE_SCOREBOARD_H #ifdef __cplusplus extern "C" { #endif #ifdef HAVE_SYS_TIMES_H #include <sys/time.h> #include <sys/times.h> #endif #include "ap_config.h" #include "http_config.h" #include "apr_thread_proc.h" #include "apr_portable.h" #include "apr_shm.h" #include "apr_optional.h" /* Scoreboard file, if there is one */ #ifndef DEFAULT_SCOREBOARD #define DEFAULT_SCOREBOARD "logs/apache_runtime_status" #endif /* Scoreboard info on a process is, for now, kept very brief --- * just status value and pid (the latter so that the caretaker process * can properly update the scoreboard when a process dies). We may want * to eventually add a separate set of long_score structures which would * give, for each process, the number of requests serviced, and info on * the current, or most recent, request. * * Status values: */ #define SERVER_DEAD 0 #define SERVER_STARTING 1 /* Server Starting up */ #define SERVER_READY 2 /* Waiting for connection (or accept() lock) */ #define SERVER_BUSY_READ 3 /* Reading a client request */ #define SERVER_BUSY_WRITE 4 /* Processing a client request */ #define SERVER_BUSY_KEEPALIVE 5 /* Waiting for more requests via keepalive */ #define SERVER_BUSY_LOG 6 /* Logging the request */ #define SERVER_BUSY_DNS 7 /* Looking up a hostname */ #define SERVER_CLOSING 8 /* Closing the connection */ #define SERVER_GRACEFUL 9 /* server is gracefully finishing request */ #define SERVER_IDLE_KILL 10 /* Server is cleaning up idle children. */ #define SERVER_NUM_STATUS 11 /* number of status settings */ /* Type used for generation indicies. Startup and every restart cause a * new generation of children to be spawned. Children within the same * generation share the same configuration information -- pointers to stuff * created at config time in the parent are valid across children. However, * this can't work effectively with non-forked architectures. So while the * arrays in the scoreboard never change between the parent and forked * children, so they do not require shm storage, the contents of the shm * may contain no pointers. */ typedef int ap_generation_t; /* Is the scoreboard shared between processes or not? * Set by the MPM when the scoreboard is created. */ typedef enum { SB_NOT_SHARED = 1, SB_SHARED = 2 } ap_scoreboard_e; /* stuff which is worker specific */ typedef struct worker_score worker_score; struct worker_score { #if APR_HAS_THREADS apr_os_thread_t tid; #endif int thread_num; /* With some MPMs (e.g., worker), a worker_score can represent * a thread in a terminating process which is no longer * represented by the corresponding process_score. These MPMs * should set pid and generation fields in the worker_score. */ pid_t pid; ap_generation_t generation; unsigned char status; unsigned short conn_count; apr_off_t conn_bytes; unsigned long access_count; apr_off_t bytes_served; unsigned long my_access_count; apr_off_t my_bytes_served; apr_time_t start_time; apr_time_t stop_time; apr_time_t last_used; #ifdef HAVE_TIMES struct tms times; #endif char client[32]; /* Keep 'em small... */ char request[64]; /* We just want an idea... */ char vhost[32]; /* What virtual host is being accessed? */ }; typedef struct { int server_limit; int thread_limit; ap_generation_t running_generation; /* the generation of children which * should still be serving requests. */ apr_time_t restart_time; } global_score; /* stuff which the parent generally writes and the children rarely read */ typedef struct process_score process_score; struct process_score { pid_t pid; ap_generation_t generation; /* generation of this child */ char quiescing; /* the process whose pid is stored above is * going down gracefully */ char not_accepting; /* the process is busy and is not accepting more * connections (for async MPMs) */ apr_uint32_t connections; /* total connections (for async MPMs) */ apr_uint32_t write_completion; /* async connections doing write completion */ apr_uint32_t lingering_close; /* async connections in lingering close */ apr_uint32_t keep_alive; /* async connections in keep alive */ apr_uint32_t suspended; /* connections suspended by some module */ }; /* Scoreboard is now in 'local' memory, since it isn't updated once created, * even in forked architectures. Child created-processes (non-fork) will * set up these indicies into the (possibly relocated) shmem records. */ typedef struct { global_score *global; process_score *parent; worker_score **servers; } scoreboard; typedef struct ap_sb_handle_t ap_sb_handle_t; AP_DECLARE(int) ap_exists_scoreboard_image(void); AP_DECLARE(void) ap_increment_counts(ap_sb_handle_t *sbh, request_rec *r); int ap_create_scoreboard(apr_pool_t *p, ap_scoreboard_e t); AP_DECLARE(apr_status_t) ap_reopen_scoreboard(apr_pool_t *p, apr_shm_t **shm, int detached); void ap_init_scoreboard(void *shared_score); AP_DECLARE(int) ap_calc_scoreboard_size(void); apr_status_t ap_cleanup_scoreboard(void *d); AP_DECLARE(void) ap_create_sb_handle(ap_sb_handle_t **new_sbh, apr_pool_t *p, int child_num, int thread_num); AP_DECLARE(int) ap_find_child_by_pid(apr_proc_t *pid); AP_DECLARE(int) ap_update_child_status(ap_sb_handle_t *sbh, int status, request_rec *r); AP_DECLARE(int) ap_update_child_status_from_indexes(int child_num, int thread_num, int status, request_rec *r); AP_DECLARE(int) ap_update_child_status_from_conn(ap_sb_handle_t *sbh, int status, conn_rec *c); AP_DECLARE(void) ap_time_process_request(ap_sb_handle_t *sbh, int status); AP_DECLARE(worker_score *) ap_get_scoreboard_worker(ap_sb_handle_t *sbh); AP_DECLARE(worker_score *) ap_get_scoreboard_worker_from_indexes(int child_num, int thread_num); AP_DECLARE(process_score *) ap_get_scoreboard_process(int x); AP_DECLARE(global_score *) ap_get_scoreboard_global(void); AP_DECLARE_DATA extern scoreboard *ap_scoreboard_image; AP_DECLARE_DATA extern const char *ap_scoreboard_fname; AP_DECLARE_DATA extern int ap_extended_status; AP_DECLARE_DATA extern int ap_mod_status_reqtail; /* * Command handlers [internal] */ const char *ap_set_scoreboard(cmd_parms *cmd, void *dummy, const char *arg); const char *ap_set_extended_status(cmd_parms *cmd, void *dummy, int arg); const char *ap_set_reqtail(cmd_parms *cmd, void *dummy, int arg); /* Hooks */ /** * Hook for post scoreboard creation, pre mpm. * @param p Apache pool to allocate from. * @param sb_type * @ingroup hooks * @return OK or DECLINE on success; anything else is a error */ AP_DECLARE_HOOK(int, pre_mpm, (apr_pool_t *p, ap_scoreboard_e sb_type)) /* for time_process_request() in http_main.c */ #define START_PREQUEST 1 #define STOP_PREQUEST 2 #ifdef __cplusplus } #endif #endif /* !APACHE_SCOREBOARD_H */
