static void *
pool_poolherder(void *priv)
{
unsigned nwq;
VTAILQ_HEAD(,pool) pools = VTAILQ_HEAD_INITIALIZER(pools);
struct pool *pp;
uint64_t u;
THR_SetName("pool_herder");
(void)priv;
nwq = 0;
while (1) {
if (nwq < cache_param->wthread_pools) {
pp = pool_mkpool(nwq);
if (pp != NULL) {
VTAILQ_INSERT_TAIL(&pools, pp, list);
VSC_C_main->pools++;
nwq++;
continue;
}
}
/* XXX: remove pools */
if (0)
SES_DeletePool(NULL);
(void)sleep(1);
u = 0;
VTAILQ_FOREACH(pp, &pools, list)
u += pp->lqueue;
VSC_C_main->thread_queue_len = u;
}
NEEDLESS_RETURN(NULL);
}
struct vmod {
unsigned magic;
#define VMOD_MAGIC 0xb750219c
VTAILQ_ENTRY(vmod) list;
int ref;
char *nm;
char *path;
void *hdl;
const void *funcs;
int funclen;
};
static VTAILQ_HEAD(,vmod) vmods = VTAILQ_HEAD_INITIALIZER(vmods);
void
VRT_Vmod_Init(void **hdl, void *ptr, int len, const char *nm, const char *path)
{
struct vmod *v;
void *x;
const int *i;
ASSERT_CLI();
VTAILQ_FOREACH(v, &vmods, list)
if (!strcmp(v->nm, nm))
break;
if (v == NULL) {
ALLOC_OBJ(v, VMOD_MAGIC);
int vtc_stop; /* Stops current test without error */
pthread_t vtc_thread;
static struct vtclog *vltop;
unsigned vtc_maxdur; /* Max duration of any test */
/**********************************************************************
* Macro facility
*/
struct macro {
VTAILQ_ENTRY(macro) list;
char *name;
char *val;
};
static VTAILQ_HEAD(,macro) macro_list = VTAILQ_HEAD_INITIALIZER(macro_list);
static pthread_mutex_t macro_mtx;
static void
init_macro(void)
{
AZ(pthread_mutex_init(¯o_mtx, NULL));
}
void
macro_def(struct vtclog *vl, const char *instance, const char *name,
const char *fmt, ...)
{
char buf1[256];
char buf2[256];
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include <port.h>
#include <sys/time.h>
#include "shmlog.h"
#include "cache.h"
#include "cache_waiter.h"
#define MAX_EVENTS 256
static pthread_t vca_ports_thread;
int solaris_dport = -1;
static VTAILQ_HEAD(,sess) sesshead = VTAILQ_HEAD_INITIALIZER(sesshead);
static inline void
vca_add(int fd, void *data)
{
/*
* POLLIN should be all we need here
*
*/
AZ(port_associate(solaris_dport, PORT_SOURCE_FD, fd, POLLIN, data));
}
static inline void
vca_del(int fd)
{
port_dissociate(solaris_dport, PORT_SOURCE_FD, fd);
int cli_fd;
int vcl_nbr;
char *workdir;
struct VSM_data *vd; /* vsc use */
unsigned vsl_tag_count[256];
unsigned vsl_sleep;
};
#define NONSENSE "%XJEIFLH|)Xspa8P"
#define VSL_SLEEP_USEC (50*1000)
static VTAILQ_HEAD(, varnish) varnishes =
VTAILQ_HEAD_INITIALIZER(varnishes);
/**********************************************************************
* Ask a question over CLI
*/
static enum VCLI_status_e
varnish_ask_cli(const struct varnish *v, const char *cmd, char **repl)
{
int i;
unsigned retval;
char *r;
if (cmd != NULL) {
vtc_dump(v->vl, 4, "CLI TX", cmd, -1);
i = write(v->cli_fd, cmd, strlen(cmd));
/*The constability of lck depends on platform pthreads implementation */
struct ilck {
unsigned magic;
#define ILCK_MAGIC 0x7b86c8a5
pthread_mutex_t mtx;
int held;
pthread_t owner;
VTAILQ_ENTRY(ilck) list;
const char *w;
struct VSC_C_lck *stat;
};
static pthread_mutexattr_t attr;
static VTAILQ_HEAD(, ilck) ilck_head = VTAILQ_HEAD_INITIALIZER(ilck_head);
static pthread_mutex_t lck_mtx;
/*--------------------------------------------------------------------*/
static void
Lck_Witness_Lock(const struct ilck *il, const char *p, int l, const char *try)
{
char *q, t[10];
int emit;
AN(p);
q = pthread_getspecific(witness_key);
if (q == NULL) {
q = calloc(1, 1024);
/*--------------------------------------------------------------------*/
struct sessmem {
unsigned magic;
#define SESSMEM_MAGIC 0x555859c5
struct sess sess;
unsigned workspace;
void *wsp;
struct http *http[2];
VTAILQ_ENTRY(sessmem) list;
struct sockaddr_storage sockaddr[2];
};
static VTAILQ_HEAD(,sessmem) ses_free_mem[2] = {
VTAILQ_HEAD_INITIALIZER(ses_free_mem[0]),
VTAILQ_HEAD_INITIALIZER(ses_free_mem[1]),
};
static unsigned ses_qp;
static struct lock ses_mem_mtx;
/*--------------------------------------------------------------------*/
static struct lock stat_mtx;
static volatile uint64_t n_sess_grab = 0;
static uint64_t n_sess_rel = 0;
/*--------------------------------------------------------------------*/
void
/*The constability of lck depends on platform pthreads implementation */
struct ilck {
unsigned magic;
#define ILCK_MAGIC 0x7b86c8a5
pthread_mutex_t mtx;
int held;
pthread_t owner;
VTAILQ_ENTRY(ilck) list;
const char *w;
struct VSC_C_lck *stat;
};
static VTAILQ_HEAD(, ilck) ilck_head =
VTAILQ_HEAD_INITIALIZER(ilck_head);
static pthread_mutex_t lck_mtx;
void __match_proto__()
Lck__Lock(struct lock *lck, const char *p, const char *f, int l)
{
struct ilck *ilck;
int r;
CAST_OBJ_NOTNULL(ilck, lck->priv, ILCK_MAGIC);
if (!(cache_param->diag_bitmap & 0x18)) {
AZ(pthread_mutex_lock(&ilck->mtx));
AZ(ilck->held);
ilck->stat->locks++;
ilck->owner = pthread_self();
/* Collected statistics */
#define BITMAP(n, c, t, b) uint64_t n;
#include "tbl/backend_poll.h"
#undef BITMAP
double last;
double avg;
double rate;
VTAILQ_ENTRY(vbp_target) list;
pthread_t thread;
};
static VTAILQ_HEAD(, vbp_target) vbp_list =
VTAILQ_HEAD_INITIALIZER(vbp_list);
/*--------------------------------------------------------------------
* Poke one backend, once, but possibly at both IPv4 and IPv6 addresses.
*
* We do deliberately not use the stuff in cache_backend.c, because we
* want to measure the backends response without local distractions.
*/
static void
vbp_poke(struct vbp_target *vt)
{
int s, tmo, i;
double t_start, t_now, t_end;
unsigned rlen, resp;
char buf[8192], *p;
#include "cache_varnishd.h"
#include "cache_ban.h"
#include "cache_objhead.h"
#include "vcli_serve.h"
#include "vend.h"
#include "vmb.h"
/* cache_ban_build.c */
void BAN_Build_Init(void);
void BAN_Build_Fini(void);
struct lock ban_mtx;
int ban_shutdown;
struct banhead_s ban_head = VTAILQ_HEAD_INITIALIZER(ban_head);
struct ban * volatile ban_start;
static pthread_t ban_thread;
static int ban_holds;
uint64_t bans_persisted_bytes;
uint64_t bans_persisted_fragmentation;
struct ban_test {
uint8_t oper;
uint8_t arg1;
const char *arg1_spec;
const char *arg2;
double arg2_double;
const void *arg2_spec;
};
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>
#include <sys/socket.h>
#include "shmlog.h"
#include "cache.h"
#include "cache_backend.h"
/*
* List of cached vbe_conns, used if enabled in params/heritage
*/
static VTAILQ_HEAD(,vbe_conn) vbe_conns = VTAILQ_HEAD_INITIALIZER(vbe_conns);
/*--------------------------------------------------------------------
* Create default Host: header for backend request
*/
void
VBE_AddHostHeader(const struct sess *sp)
{
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
CHECK_OBJ_NOTNULL(sp->wrk->bereq, HTTP_MAGIC);
CHECK_OBJ_NOTNULL(sp->vbe, VBE_CONN_MAGIC);
CHECK_OBJ_NOTNULL(sp->vbe->backend, BACKEND_MAGIC);
http_PrintfHeader(sp->wrk, sp->fd, sp->wrk->bereq,
"Host: %s", sp->vbe->backend->hosthdr);
}
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "mgt/mgt.h"
#include "common/heritage.h"
#include "vcli_serve.h"
#include "storage/storage.h"
static VTAILQ_HEAD(, stevedore) stevedores =
VTAILQ_HEAD_INITIALIZER(stevedores);
/* Name of transient storage */
#define TRANSIENT_STORAGE "Transient"
struct stevedore *stv_transient;
/*--------------------------------------------------------------------*/
int
STV__iter(struct stevedore ** const pp)
{
AN(pp);
CHECK_OBJ_ORNULL(*pp, STEVEDORE_MAGIC);
if (*pp != NULL)
/* Reverse CLI ("Master") connections --------------------------------*/
struct m_addr {
unsigned magic;
#define M_ADDR_MAGIC 0xbc6217ed
struct suckaddr *sa;
VTAILQ_ENTRY(m_addr) list;
};
static int M_fd = -1;
static struct vev *M_poker, *M_conn;
static double M_poll = 0.1;
static VTAILQ_HEAD(,m_addr) m_addr_list =
VTAILQ_HEAD_INITIALIZER(m_addr_list);
static void
Marg_closer(void *priv)
{
(void)priv;
(void)close(M_fd);
M_fd = -1;
}
static int __match_proto__(vev_cb_f)
Marg_connect(const struct vev *e, int what)
{
struct vsb *vsb;
struct m_addr *ma;
#include "vtcp.h"
#include "vtim.h"
#include "vct.h"
static const char *argv0;
struct buf {
unsigned magic;
#define BUF_MAGIC 0x39d1258a
VTAILQ_ENTRY(buf) list;
char *buf;
struct vsb *diag;
size_t bufsiz;
};
static VTAILQ_HEAD(, buf) free_bufs = VTAILQ_HEAD_INITIALIZER(free_bufs);
struct vtc_tst {
unsigned magic;
#define TST_MAGIC 0x618d8b88
VTAILQ_ENTRY(vtc_tst) list;
const char *filename;
char *script;
unsigned ntodo;
};
struct vtc_job {
unsigned magic;
#define JOB_MAGIC 0x1b5fc419
struct vtc_tst *tst;
pid_t child;
