Gecko [ www.bigdataconsulting.fr ]

Name	Size	Permission	Date
events	[ DIR ]	drwxrwxr-x	2022-10-31 11:36
fpm.c	2.78 KB	-rw-rw-r--	2022-10-31 11:36
fpm.h	1.07 KB	-rw-rw-r--	2022-10-31 11:36
fpm_arrays.h	1.76 KB	-rw-rw-r--	2022-10-31 11:36
fpm_atomic.h	3.9 KB	-rw-rw-r--	2022-10-31 11:36
fpm_children.c	11.38 KB	-rw-rw-r--	2022-10-31 11:36
fpm_children.h	857 B	-rw-rw-r--	2022-10-31 11:36
fpm_cleanup.c	782 B	-rw-rw-r--	2022-10-31 11:36
fpm_cleanup.h	452 B	-rw-rw-r--	2022-10-31 11:36
fpm_clock.c	2.17 KB	-rw-rw-r--	2022-10-31 11:36
fpm_clock.h	175 B	-rw-rw-r--	2022-10-31 11:36
fpm_conf.c	51.25 KB	-rw-rw-r--	2022-10-31 11:36
fpm_conf.h	2.5 KB	-rw-rw-r--	2022-10-31 11:36
fpm_config.h	2.04 KB	-rw-rw-r--	2022-10-31 11:36
fpm_env.c	5.39 KB	-rw-rw-r--	2022-10-31 11:36
fpm_env.h	428 B	-rw-rw-r--	2022-10-31 11:36
fpm_events.c	12.4 KB	-rw-rw-r--	2022-10-31 11:36
fpm_events.h	1.53 KB	-rw-rw-r--	2022-10-31 11:36
fpm_log.c	11.46 KB	-rw-rw-r--	2022-10-31 11:36
fpm_log.h	227 B	-rw-rw-r--	2022-10-31 11:36
fpm_main.c	59.7 KB	-rw-rw-r--	2022-10-31 11:36
fpm_php.c	6.03 KB	-rw-rw-r--	2022-10-31 11:36
fpm_php.h	1.14 KB	-rw-rw-r--	2022-10-31 11:36
fpm_php_trace.c	4.67 KB	-rw-rw-r--	2022-10-31 11:36
fpm_php_trace.h	162 B	-rw-rw-r--	2022-10-31 11:36
fpm_process_ctl.c	13.81 KB	-rw-rw-r--	2022-10-31 11:36
fpm_process_ctl.h	1.16 KB	-rw-rw-r--	2022-10-31 11:36
fpm_request.c	7.94 KB	-rw-rw-r--	2022-10-31 11:36
fpm_request.h	1.13 KB	-rw-rw-r--	2022-10-31 11:36
fpm_scoreboard.c	8.05 KB	-rw-rw-r--	2022-10-31 11:36
fpm_scoreboard.h	2.45 KB	-rw-rw-r--	2022-10-31 11:36
fpm_shm.c	1.17 KB	-rw-rw-r--	2022-10-31 11:36
fpm_shm.h	200 B	-rw-rw-r--	2022-10-31 11:36
fpm_signals.c	7.02 KB	-rw-rw-r--	2022-10-31 11:36
fpm_signals.h	361 B	-rw-rw-r--	2022-10-31 11:36
fpm_sockets.c	12.96 KB	-rw-rw-r--	2022-10-31 11:36
fpm_sockets.h	1009 B	-rw-rw-r--	2022-10-31 11:36
fpm_status.c	17.63 KB	-rw-rw-r--	2022-10-31 11:36
fpm_status.h	1.05 KB	-rw-rw-r--	2022-10-31 11:36
fpm_stdio.c	9.02 KB	-rw-rw-r--	2022-10-31 11:36
fpm_stdio.h	604 B	-rw-rw-r--	2022-10-31 11:36
fpm_str.h	421 B	-rw-rw-r--	2022-10-31 11:36
fpm_systemd.c	3.1 KB	-rw-rw-r--	2022-10-31 11:36
fpm_systemd.h	274 B	-rw-rw-r--	2022-10-31 11:36
fpm_trace.c	524 B	-rw-rw-r--	2022-10-31 11:36
fpm_trace.h	313 B	-rw-rw-r--	2022-10-31 11:36
fpm_trace_mach.c	1.92 KB	-rw-rw-r--	2022-10-31 11:36
fpm_trace_pread.c	1.1 KB	-rw-rw-r--	2022-10-31 11:36
fpm_trace_ptrace.c	1.53 KB	-rw-rw-r--	2022-10-31 11:36
fpm_unix.c	16.22 KB	-rw-rw-r--	2022-10-31 11:36
fpm_unix.h	454 B	-rw-rw-r--	2022-10-31 11:36
fpm_worker_pool.c	1.74 KB	-rw-rw-r--	2022-10-31 11:36
fpm_worker_pool.h	1.23 KB	-rw-rw-r--	2022-10-31 11:36
zlog.c	21.7 KB	-rw-rw-r--	2022-10-31 11:36
zlog.h	3.58 KB	-rw-rw-r--	2022-10-31 11:36

Rename

#include "php.h"
#include "SAPI.h"
#include <stdio.h>
#include <time.h>

#include "fpm_config.h"
#include "fpm_children.h"
#include "fpm_scoreboard.h"
#include "fpm_shm.h"
#include "fpm_sockets.h"
#include "fpm_worker_pool.h"
#include "fpm_clock.h"
#include "zlog.h"

static struct fpm_scoreboard_s *fpm_scoreboard = NULL;
static int fpm_scoreboard_i = -1;
#ifdef HAVE_TIMES
static float fpm_scoreboard_tick;
#endif

int fpm_scoreboard_init_main() /* {{{ */
{
	struct fpm_worker_pool_s *wp;

#ifdef HAVE_TIMES
#if (defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK))
	fpm_scoreboard_tick = sysconf(_SC_CLK_TCK);
#else /* _SC_CLK_TCK */
#ifdef HZ
	fpm_scoreboard_tick = HZ;
#else /* HZ */
	fpm_scoreboard_tick = 100;
#endif /* HZ */
#endif /* _SC_CLK_TCK */
	zlog(ZLOG_DEBUG, "got clock tick '%.0f'", fpm_scoreboard_tick);
#endif /* HAVE_TIMES */

for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
		size_t scoreboard_procs_size;
		void *shm_mem;

if (wp->config->pm_max_children < 1) {
			zlog(ZLOG_ERROR, "[pool %s] Unable to create scoreboard SHM because max_client is not set", wp->config->name);
			return -1;
		}

if (wp->scoreboard) {
			zlog(ZLOG_ERROR, "[pool %s] Unable to create scoreboard SHM because it already exists", wp->config->name);
			return -1;
		}

scoreboard_procs_size = sizeof(struct fpm_scoreboard_proc_s) * wp->config->pm_max_children;
		shm_mem = fpm_shm_alloc(sizeof(struct fpm_scoreboard_s) + scoreboard_procs_size);

if (!shm_mem) {
			return -1;
		}
		wp->scoreboard = shm_mem;
		wp->scoreboard->pm = wp->config->pm;
		wp->scoreboard->nprocs = wp->config->pm_max_children;
		wp->scoreboard->start_epoch = time(NULL);
		strlcpy(wp->scoreboard->pool, wp->config->name, sizeof(wp->scoreboard->pool));
	}
	return 0;
}
/* }}} */

void fpm_scoreboard_update(int idle, int active, int lq, int lq_len, int requests, int max_children_reached, int slow_rq, int action, struct fpm_scoreboard_s *scoreboard) /* {{{ */
{
	if (!scoreboard) {
		scoreboard = fpm_scoreboard;
	}
	if (!scoreboard) {
		zlog(ZLOG_WARNING, "Unable to update scoreboard: the SHM has not been found");
		return;
	}

fpm_spinlock(&scoreboard->lock, 0);
	if (action == FPM_SCOREBOARD_ACTION_SET) {
		if (idle >= 0) {
			scoreboard->idle = idle;
		}
		if (active >= 0) {
			scoreboard->active = active;
		}
		if (lq >= 0) {
			scoreboard->lq = lq;
		}
		if (lq_len >= 0) {
			scoreboard->lq_len = lq_len;
		}
#ifdef HAVE_FPM_LQ /* prevent unnecessary test */
		if (scoreboard->lq > scoreboard->lq_max) {
			scoreboard->lq_max = scoreboard->lq;
		}
#endif
		if (requests >= 0) {
			scoreboard->requests = requests;
		}

if (max_children_reached >= 0) {
			scoreboard->max_children_reached = max_children_reached;
		}
		if (slow_rq > 0) {
			scoreboard->slow_rq = slow_rq;
		}
	} else {
		if (scoreboard->idle + idle > 0) {
			scoreboard->idle += idle;
		} else {
			scoreboard->idle = 0;
		}

if (scoreboard->active + active > 0) {
			scoreboard->active += active;
		} else {
			scoreboard->active = 0;
		}

if (scoreboard->requests + requests > 0) {
			scoreboard->requests += requests;
		} else {
			scoreboard->requests = 0;
		}

if (scoreboard->max_children_reached + max_children_reached > 0) {
			scoreboard->max_children_reached += max_children_reached;
		} else {
			scoreboard->max_children_reached = 0;
		}

if (scoreboard->slow_rq + slow_rq > 0) {
			scoreboard->slow_rq += slow_rq;
		} else {
			scoreboard->slow_rq = 0;
		}
	}

if (scoreboard->active > scoreboard->active_max) {
		scoreboard->active_max = scoreboard->active;
	}

fpm_unlock(scoreboard->lock);
}
/* }}} */

struct fpm_scoreboard_s *fpm_scoreboard_get() /* {{{*/
{
	return fpm_scoreboard;
}
/* }}} */

static inline struct fpm_scoreboard_proc_s *fpm_scoreboard_proc_get_ex(
		struct fpm_scoreboard_s *scoreboard, int child_index, unsigned int nprocs) /* {{{*/
{
	if (!scoreboard) {
		return NULL;
	}

if (child_index < 0 || (unsigned int)child_index >= nprocs) {
		return NULL;
	}

return &scoreboard->procs[child_index];
}
/* }}} */

struct fpm_scoreboard_proc_s *fpm_scoreboard_proc_get(
		struct fpm_scoreboard_s *scoreboard, int child_index) /* {{{*/
{
	if (!scoreboard) {
		scoreboard = fpm_scoreboard;
	}

if (child_index < 0) {
		child_index = fpm_scoreboard_i;
	}

return fpm_scoreboard_proc_get_ex(scoreboard, child_index, scoreboard->nprocs);
}
/* }}} */

struct fpm_scoreboard_proc_s *fpm_scoreboard_proc_get_from_child(struct fpm_child_s *child) /* {{{*/
{
	struct fpm_worker_pool_s *wp = child->wp;
	unsigned int nprocs = wp->config->pm_max_children;
	struct fpm_scoreboard_s *scoreboard = wp->scoreboard;
	int child_index = child->scoreboard_i;

return fpm_scoreboard_proc_get_ex(scoreboard, child_index, nprocs);
}
/* }}} */

struct fpm_scoreboard_s *fpm_scoreboard_acquire(struct fpm_scoreboard_s *scoreboard, int nohang) /* {{{ */
{
	struct fpm_scoreboard_s *s;

s = scoreboard ? scoreboard : fpm_scoreboard;
	if (!s) {
		return NULL;
	}

if (!fpm_spinlock(&s->lock, nohang)) {
		return NULL;
	}
	return s;
}
/* }}} */

void fpm_scoreboard_release(struct fpm_scoreboard_s *scoreboard) {
	if (!scoreboard) {
		return;
	}

scoreboard->lock = 0;
}

struct fpm_scoreboard_proc_s *fpm_scoreboard_proc_acquire(struct fpm_scoreboard_s *scoreboard, int child_index, int nohang) /* {{{ */
{
	struct fpm_scoreboard_proc_s *proc;

proc = fpm_scoreboard_proc_get(scoreboard, child_index);
	if (!proc) {
		return NULL;
	}

if (!fpm_spinlock(&proc->lock, nohang)) {
		return NULL;
	}

return proc;
}
/* }}} */

void fpm_scoreboard_proc_release(struct fpm_scoreboard_proc_s *proc) /* {{{ */
{
	if (!proc) {
		return;
	}

proc->lock = 0;
}

void fpm_scoreboard_free(struct fpm_worker_pool_s *wp) /* {{{ */
{
	size_t scoreboard_procs_size;
	struct fpm_scoreboard_s *scoreboard = wp->scoreboard;

if (!scoreboard) {
		zlog(ZLOG_ERROR, "**scoreboard is NULL");
		return;
	}

scoreboard_procs_size = sizeof(struct fpm_scoreboard_proc_s) * wp->config->pm_max_children;

fpm_shm_free(scoreboard, sizeof(struct fpm_scoreboard_s) + scoreboard_procs_size);
}
/* }}} */

void fpm_scoreboard_child_use(struct fpm_child_s *child, pid_t pid) /* {{{ */
{
	struct fpm_scoreboard_proc_s *proc;
	fpm_scoreboard = child->wp->scoreboard;
	fpm_scoreboard_i = child->scoreboard_i;
	proc = fpm_scoreboard_proc_get_from_child(child);
	if (!proc) {
		return;
	}
	proc->pid = pid;
	proc->start_epoch = time(NULL);
}
/* }}} */

void fpm_scoreboard_proc_free(struct fpm_child_s *child) /* {{{ */
{
	struct fpm_worker_pool_s *wp = child->wp;
	struct fpm_scoreboard_s *scoreboard = wp->scoreboard;
	int child_index = child->scoreboard_i;

if (!scoreboard) {
		return;
	}

if (child_index < 0 || child_index >= wp->config->pm_max_children) {
		return;
	}

if (scoreboard->procs[child_index].used > 0) {
		memset(&scoreboard->procs[child_index], 0, sizeof(struct fpm_scoreboard_proc_s));
	}

/* set this slot as free to avoid search on next alloc */
	scoreboard->free_proc = child_index;
}
/* }}} */

int fpm_scoreboard_proc_alloc(struct fpm_child_s *child) /* {{{ */
{
	int i = -1;
	struct fpm_worker_pool_s *wp = child->wp;
	struct fpm_scoreboard_s *scoreboard = wp->scoreboard;
	int nprocs = wp->config->pm_max_children;

if (!scoreboard) {
		return -1;
	}

/* first try the slot which is supposed to be free */
	if (scoreboard->free_proc >= 0 && scoreboard->free_proc < nprocs) {
		if (!scoreboard->procs[scoreboard->free_proc].used) {
			i = scoreboard->free_proc;
		}
	}

if (i < 0) { /* the supposed free slot is not, let's search for a free slot */
		zlog(ZLOG_DEBUG, "[pool %s] the proc->free_slot was not free. Let's search", scoreboard->pool);
		for (i = 0; i < nprocs; i++) {
			if (!scoreboard->procs[i].used) { /* found */
				break;
			}
		}
	}

/* no free slot */
	if (i < 0 || i >= nprocs) {
		zlog(ZLOG_ERROR, "[pool %s] no free scoreboard slot", scoreboard->pool);
		return -1;
	}

scoreboard->procs[i].used = 1;
	child->scoreboard_i = i;

/* supposed next slot is free */
	if (i + 1 >= nprocs) {
		scoreboard->free_proc = 0;
	} else {
		scoreboard->free_proc = i + 1;
	}

return 0;
}
/* }}} */

#ifdef HAVE_TIMES
float fpm_scoreboard_get_tick() /* {{{ */
{
	return fpm_scoreboard_tick;
}
/* }}} */
#endif