Source Jam - httpd-2.2.8

00085              {
00086     SB_NOT_SHARED = 1,
00087     SB_SHARED = 2
00088 } ap_scoreboard_e;

00250 {
00251     if (ap_scoreboard_image == NULL) {
00252         return APR_SUCCESS;
00253     }
00254     if (ap_scoreboard_image->global->sb_type == SB_SHARED) {
00255         ap_cleanup_shared_mem(NULL);
00256     }
00257     else {
00258         free(ap_scoreboard_image->global);
00259         free(ap_scoreboard_image);
00260         ap_scoreboard_image = NULL;
00261     }
00262     return APR_SUCCESS;
00263 }

00269 {
00270     int running_gen = 0;
00271     int i;
00272 #if APR_HAS_SHARED_MEMORY
00273     apr_status_t rv;
00274 #endif
00275 
00276     if (ap_scoreboard_image) {
00277         running_gen = ap_scoreboard_image->global->running_generation;
00278         ap_scoreboard_image->global->restart_time = apr_time_now();
00279         memset(ap_scoreboard_image->parent, 0,
00280                sizeof(process_score) * server_limit);
00281         for (i = 0; i < server_limit; i++) {
00282             memset(ap_scoreboard_image->servers[i], 0,
00283                    sizeof(worker_score) * thread_limit);
00284         }
00285         /* Clean up the lb workers data */
00286         if (lb_limit) {
00287             memset(ap_scoreboard_image->balancers, 0,
00288                    sizeof(lb_score) * lb_limit);
00289         }
00290         return OK;
00291     }
00292 
00293     ap_calc_scoreboard_size();
00294 #if APR_HAS_SHARED_MEMORY
00295     if (sb_type == SB_SHARED) {
00296         void *sb_shared;
00297         rv = open_scoreboard(p);
00298         if (rv || !(sb_shared = apr_shm_baseaddr_get(ap_scoreboard_shm))) {
00299             return HTTP_INTERNAL_SERVER_ERROR;
00300         }
00301         memset(sb_shared, 0, scoreboard_size);
00302         ap_init_scoreboard(sb_shared);
00303     }
00304     else
00305 #endif
00306     {
00307         /* A simple malloc will suffice */
00308         void *sb_mem = calloc(1, scoreboard_size);
00309         if (sb_mem == NULL) {
00310             ap_log_error(APLOG_MARK, APLOG_CRIT, 0, NULL,
00311                          "(%d)%s: cannot allocate scoreboard",
00312                          errno, strerror(errno));
00313             return HTTP_INTERNAL_SERVER_ERROR;
00314         }
00315         ap_init_scoreboard(sb_mem);
00316     }
00317 
00318     ap_scoreboard_image->global->sb_type = sb_type;
00319     ap_scoreboard_image->global->running_generation = running_gen;
00320     ap_scoreboard_image->global->restart_time = apr_time_now();
00321 
00322     apr_pool_cleanup_register(p, NULL, ap_cleanup_scoreboard, apr_pool_cleanup_null);
00323 
00324     return OK;
00325 }

00115 {
00116     char *more_storage;
00117     int i;
00118 
00119     ap_calc_scoreboard_size();
00120     ap_scoreboard_image =
00121         calloc(1, sizeof(scoreboard) + server_limit * sizeof(worker_score *) +
00122                server_limit * lb_limit * sizeof(lb_score *));
00123     more_storage = shared_score;
00124     ap_scoreboard_image->global = (global_score *)more_storage;
00125     more_storage += sizeof(global_score);
00126     ap_scoreboard_image->parent = (process_score *)more_storage;
00127     more_storage += sizeof(process_score) * server_limit;
00128     ap_scoreboard_image->servers =
00129         (worker_score **)((char*)ap_scoreboard_image + sizeof(scoreboard));
00130     for (i = 0; i < server_limit; i++) {
00131         ap_scoreboard_image->servers[i] = (worker_score *)more_storage;
00132         more_storage += thread_limit * sizeof(worker_score);
00133     }
00134     if (lb_limit) {
00135         ap_scoreboard_image->balancers = (lb_score *)more_storage;
00136         more_storage += lb_limit * sizeof(lb_score);
00137     }
00138     ap_assert(more_storage == (char*)shared_score + scoreboard_size);
00139     ap_scoreboard_image->global->server_limit = server_limit;
00140     ap_scoreboard_image->global->thread_limit = thread_limit;
00141     ap_scoreboard_image->global->lb_limit     = lb_limit;
00142 }

00229 {
00230 #if APR_HAS_SHARED_MEMORY
00231     if (!detached) {
00232         return APR_SUCCESS;
00233     }
00234     if (apr_shm_size_get(ap_scoreboard_shm) < scoreboard_size) {
00235         ap_log_error(APLOG_MARK, APLOG_CRIT, 0, NULL,
00236                      "Fatal error: shared scoreboard too small for child!");
00237         apr_shm_detach(ap_scoreboard_shm);
00238         ap_scoreboard_shm = NULL;
00239         return APR_EINVAL;
00240     }
00241     /* everything will be cleared shortly */
00242     if (*shm) {
00243         *shm = ap_scoreboard_shm;
00244     }
00245 #endif
00246     return APR_SUCCESS;
00247 }

00479 {
00480     worker_score *ws;
00481 
00482     if (sbh->child_num < 0) {
00483         return;
00484     }
00485 
00486     ws = &ap_scoreboard_image->servers[sbh->child_num][sbh->thread_num];
00487 
00488     if (status == START_PREQUEST) {
00489         ws->start_time = apr_time_now();
00490     }
00491     else if (status == STOP_PREQUEST) {
00492         ws->stop_time = apr_time_now();
00493     }
00494 }

00361 {
00362     int i;
00363     int max_daemons_limit;
00364 
00365     ap_mpm_query(AP_MPMQ_MAX_DAEMONS, &max_daemons_limit);
00366 
00367     for (i = 0; i < max_daemons_limit; ++i) {
00368         if (ap_scoreboard_image->parent[i].pid == pid->pid) {
00369             return i;
00370         }
00371     }
00372 
00373     return -1;
00374 }


Classes
struct	worker_score
struct	global_score
struct	process_score
struct	lb_score
struct	scoreboard
Defines
#define	DEFAULT_SCOREBOARD "logs/apache_runtime_status"
#define	SERVER_DEAD 0
#define	SERVER_STARTING 1
#define	SERVER_READY 2
#define	SERVER_BUSY_READ 3
#define	SERVER_BUSY_WRITE 4
#define	SERVER_BUSY_KEEPALIVE 5
#define	SERVER_BUSY_LOG 6
#define	SERVER_BUSY_DNS 7
#define	SERVER_CLOSING 8
#define	SERVER_GRACEFUL 9
#define	SERVER_IDLE_KILL 10
#define	SERVER_NUM_STATUS 11
#define	SB_WORKING 0
#define	SB_IDLE_DIE 1
#define	START_PREQUEST 1
#define	STOP_PREQUEST 2
Typedefs
typedef int	ap_generation_t
typedef worker_score	worker_score
typedef process_score	process_score
typedef lb_score	lb_score
typedef ap_sb_handle_t	ap_sb_handle_t
Enumerations
enum	ap_scoreboard_e { SB_NOT_SHARED = 1, SB_SHARED = 2 }
Functions
	AP_DECLARE (int) ap_exists_scoreboard_image(void)
int	ap_create_scoreboard (apr_pool_t *p, ap_scoreboard_e t)
apr_status_t	ap_reopen_scoreboard (apr_pool_t p, apr_shm_t *shm, int detached)
void	ap_init_scoreboard (void *shared_score)
apr_status_t	ap_cleanup_scoreboard (void *d)
int	find_child_by_pid (apr_proc_t *pid)
void	ap_time_process_request (ap_sb_handle_t *sbh, int status)
	AP_DECLARE_HOOK (int, pre_mpm,(apr_pool_t *p, ap_scoreboard_e sb_type)) APR_DECLARE_OPTIONAL_FN(int
Variables
request_rec *	r
apr_pool_t *	p
apr_pool_t int	child_num
apr_pool_t int int	thread_num
int	status
int	y
AP_DECLARE_DATA scoreboard *	ap_scoreboard_image
AP_DECLARE_DATA const char *	ap_scoreboard_fname
AP_DECLARE_DATA int	ap_extended_status
AP_DECLARE_DATA int	ap_mod_status_reqtail
AP_DECLARE_DATA ap_generation_t volatile	ap_my_generation
	ap_proxy_lb_workers
	void

scoreboard.h File Reference

Classes

Defines

Typedefs

Enumerations

Functions

Variables

Detailed Description

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation