void
initicachewrite(void)
{
int i;
Index *ix;
initround(&iwrite.round, "icache", 120*60*1000);
ix = mainindex;
for(i=0; i<ix->nsects; i++){
ix->sects[i]->writechan = chancreate(sizeof(ulong), 1);
ix->sects[i]->writedonechan = chancreate(sizeof(ulong), 1);
vtproc(icachewriteproc, ix->sects[i]);
}
vtproc(icachewritecoord, nil);
vtproc(delaykickroundproc, &iwrite.round);
}
int
httpdinit(char *address, char *dir)
{
fmtinstall('D', hdatefmt);
/* fmtinstall('H', httpfmt); */
fmtinstall('U', hurlfmt);
if(address == nil)
address = "tcp!*!http";
webroot = dir;
httpdobj("/stats", estats);
httpdobj("/index", dindex);
httpdobj("/storage", sindex);
httpdobj("/xindex", xindex);
httpdobj("/flushicache", hicacheflush);
httpdobj("/flushdcache", hdcacheflush);
httpdobj("/kickicache", hicachekick);
httpdobj("/kickdcache", hdcachekick);
httpdobj("/graph", xgraph);
httpdobj("/set", xset);
httpdobj("/log", xlog);
httpdobj("/empty", hempty);
httpdobj("/emptyicache", hicacheempty);
httpdobj("/emptylumpcache", hlcacheempty);
httpdobj("/emptydcache", hdcacheempty);
httpdobj("/disk", hdisk);
httpdobj("/debug", hdebug);
httpdobj("/proc/", hproc);
if(vtproc(listenproc, address) < 0)
return -1;
return 0;
}
void
startbloomproc(Bloom *b)
{
b->writechan = chancreate(sizeof(void*), 0);
b->writedonechan = chancreate(sizeof(ulong), 0);
vtproc(bloomwriteproc, b);
}
int
initarenasum(void)
{
needzeroscore(); /* OS X */
sumwait.l = &sumlock;
if(vtproc(sumproc, nil) < 0){
seterr(EOk, "can't start arena checksum slave: %r");
return -1;
}
return 0;
}
void
kickjob(Job *j)
{
int i;
int fd[3];
int p[2];
VtLog *l;
if((fd[0] = open("/dev/null", ORDWR)) < 0) {
vtlogprint(errlog, "%T open /dev/null: %r\n");
return;
}
if(pipe(p) < 0) {
vtlogprint(errlog, "%T pipe: %r\n");
close(fd[0]);
return;
}
qlock(&j->lk);
l = j->oldlog;
j->oldlog = j->newlog;
j->newlog = l;
qlock(&l->lk);
for(i=0; i<l->nchunk; i++)
l->chunk[i].wp = l->chunk[i].p;
qunlock(&l->lk);
j->oldok = j->newok;
j->newok = -1;
qunlock(&j->lk);
fd[1] = p[1];
fd[2] = p[1];
j->pid = threadspawn(fd, j->argv[0], j->argv);
if(j->pid < 0) {
vtlogprint(errlog, "%T exec %s: %r\n", j->argv[0]);
close(fd[0]);
close(fd[1]);
close(p[0]);
}
// fd[0], fd[1], fd[2] are closed now
j->pipe = p[0];
j->nrun++;
vtproc(piper, j);
}
static void
listenproc(void *vaddress)
{
HConnect *c;
char *address, ndir[NETPATHLEN], dir[NETPATHLEN];
int ctl, nctl, data;
address = vaddress;
ctl = announce(address, dir);
if(ctl < 0){
fprint(2, "venti: httpd can't announce on %s: %r\n", address);
return;
}
if(0) print("announce ctl %d dir %s\n", ctl, dir);
for(;;){
/*
* wait for a call (or an error)
*/
nctl = listen(dir, ndir);
if(0) print("httpd listen %d %s...\n", nctl, ndir);
if(nctl < 0){
fprint(2, "venti: httpd can't listen on %s: %r\n", address);
return;
}
data = accept(ctl, ndir);
if(0) print("httpd accept %d...\n", data);
if(data < 0){
fprint(2, "venti: httpd accept: %r\n");
close(nctl);
continue;
}
if(0) print("httpd close nctl %d\n", nctl);
close(nctl);
c = mkconnect();
hinit(&c->hin, data, Hread);
hinit(&c->hout, data, Hwrite);
vtproc(httpproc, c);
}
}
int
initlumpqueues(int nq)
{
LumpQueue *q;
int i;
nqs = nq;
lumpqs = MKNZ(LumpQueue, nq);
for(i = 0; i < nq; i++){
q = &lumpqs[i];
q->full.l = &q->lock;
q->empty.l = &q->lock;
q->flush.l = &q->lock;
if(vtproc(queueproc, q) < 0){
seterr(EOk, "can't start write queue slave: %r");
return -1;
}
}
return 0;
}
void
threadmain(int argc, char *argv[])
{
int i;
char *file;
Arena *arena;
u64int offset, aoffset;
Part *part;
uchar buf[8192];
ArenaHead head;
ZClump zerocl;
ventifmtinstall();
qlock(&godot);
aoffset = 0;
ARGBEGIN{
case 'f':
fast = 1;
ventidoublechecksha1 = 0;
break;
case 'h':
host = EARGF(usage());
break;
case 'o':
haveaoffset = 1;
aoffset = strtoull(EARGF(usage()), 0, 0);
break;
case 'M':
maxwrites = atoi(EARGF(usage()));
break;
case 'v':
verbose = 1;
break;
default:
usage();
break;
}ARGEND
offset = ~(u64int)0;
switch(argc) {
default:
usage();
case 2:
offset = strtoull(argv[1], 0, 0);
/* fall through */
case 1:
file = argv[0];
}
fmtinstall('V', vtscorefmt);
statsinit();
part = initpart(file, OREAD);
if(part == nil)
sysfatal("can't open file %s: %r", file);
if(readpart(part, aoffset, buf, sizeof buf) < 0)
sysfatal("can't read file %s: %r", file);
if(unpackarenahead(&head, buf) < 0)
sysfatal("corrupted arena header: %r");
if(aoffset+head.size > part->size)
sysfatal("arena is truncated: want %llud bytes have %llud",
head.size, part->size);
partblocksize(part, head.blocksize);
initdcache(8 * MaxDiskBlock);
arena = initarena(part, aoffset, head.size, head.blocksize);
if(arena == nil)
sysfatal("initarena: %r");
z = nil;
if(host==nil || strcmp(host, "/dev/null") != 0){
z = vtdial(host);
if(z == nil)
sysfatal("could not connect to server: %r");
if(vtconnect(z) < 0)
sysfatal("vtconnect: %r");
}
c = chancreate(sizeof(ZClump), 0);
for(i=0; i<12; i++)
vtproc(vtsendthread, nil);
rdarena(arena, offset);
if(vtsync(z) < 0)
sysfatal("executing sync: %r");
memset(&zerocl, 0, sizeof zerocl);
for(i=0; i<12; i++)
send(c, &zerocl);
if(z){
vthangup(z);
}
threadexitsall(0);
}
void
threadmain(int argc, char *argv[])
{
char *haddr, *vaddr, *webroot, *file;
traceinit();
threadsetname("main");
vaddr = nil;
haddr = "tcp!*!9000";
webroot = nil;
ARGBEGIN{
case 'a':
vaddr = EARGF(usage());
break;
case 'D':
settrace(EARGF(usage()));
break;
case 'd':
debug = 1;
nofork = 1;
break;
case 'h':
haddr = EARGF(usage());
break;
case 'L':
ventilogging = 1;
break;
case 'r':
readonly = 1;
break;
case 's':
nofork = 1;
break;
case 'W':
webroot = EARGF(usage());
break;
default:
usage();
}ARGEND
if(argc < 1)
usage();
file = argv[0];
if(!nofork)
rfork(RFNOTEG);
#ifdef PLAN9PORT
{
/* sigh - needed to avoid signals when writing to hungup networks */
struct sigaction sa;
memset(&sa, 0, sizeof sa);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, nil);
}
#endif
ventifmtinstall();
trace(TraceQuiet, "venti started");
fprint(2, "%T venti: ");
statsinit();
mminit(file, readonly ? OREAD : ORDWR);
/*
* default other configuration-file parameters
*/
if(vaddr == nil)
vaddr = "tcp!*!venti";
if(haddr){
fprint(2, "httpd %s...", haddr);
if(httpdinit(haddr, webroot) < 0)
fprint(2, "warning: can't start http server: %r");
}
fprint(2, "init...");
fprint(2, "announce %s...", vaddr);
ventisrv = vtlisten(vaddr);
if(ventisrv == nil)
sysfatal("can't announce %s: %r", vaddr);
fprint(2, "serving.\n");
if(nofork)
ventiserver(nil);
else
vtproc(ventiserver, nil);
threadexits(nil);
}
void
threadmain(int argc, char **argv)
{
int i;
int nofork;
char *prog;
Job *j;
ventilogging = 1;
ventifmtinstall();
#ifdef PLAN9PORT
bin = unsharp("#9/bin/venti");
#else
bin = "/bin/venti";
#endif
nofork = 0;
ARGBEGIN{
case 'b':
bin = EARGF(usage());
break;
case 's':
nofork = 1;
break;
default:
usage();
}ARGEND
if(argc != 1)
usage();
if(rdconf(argv[0], &conf) < 0)
sysfatal("reading config: %r");
if(conf.httpaddr == nil)
sysfatal("config has no httpaddr");
if(conf.smtp != nil && conf.mailfrom == nil)
sysfatal("config has smtp but no mailfrom");
if(conf.smtp != nil && conf.mailto == nil)
sysfatal("config has smtp but no mailto");
if((mirrorprog = regcomp(mirrorregexp)) == nil)
sysfatal("mirrorregexp did not complete");
if((verifyprog = regcomp(verifyregexp)) == nil)
sysfatal("verifyregexp did not complete");
if(conf.nverify > 0 && conf.verifyfreq == 0)
sysfatal("config has no verifyfreq");
if(conf.nmirror > 0 && conf.mirrorfreq == 0)
sysfatal("config has no mirrorfreq");
time0 = time(0);
// sendmail("startup", "mgr is starting\n");
logbuf = vtmalloc(LogSize+1); // +1 for NUL
errlog = vtlogopen("errors", LogSize);
job = vtmalloc((conf.nmirror+conf.nverify)*sizeof job[0]);
prog = smprint("%s/mirrorarenas", bin);
for(i=0; i<conf.nmirror; i++) {
// job: /bin/venti/mirrorarenas -v src dst
// filter output
j = &job[njob++];
mkjob(j, prog, "-v", conf.mirror[i].src, conf.mirror[i].dst, nil);
j->name = smprint("mirror %s %s", conf.mirror[i].src, conf.mirror[i].dst);
j->ok = mirrorok;
j->freq = conf.mirrorfreq; // 4 hours // TODO: put in config
j->offset = (double)i/conf.nmirror;
}
prog = smprint("%s/verifyarena", bin);
for(i=0; i<conf.nverify; i++) {
// job: /bin/venti/verifyarena -b 64M -s 1000 -v arena
// filter output
j = &job[njob++];
mkjob(j, prog, "-b64M", "-s1000", conf.verify[i], nil);
j->name = smprint("verify %s", conf.verify[i]);
j->ok = verifyok;
j->freq = conf.verifyfreq;
j->offset = (double)i/conf.nverify;
}
httpdobj("/mgr", hmanager);
httpdobj("/log", xlog);
vtproc(httpdproc, conf.httpaddr);
vtproc(waitproc, threadwaitchan());
if(nofork)
manager(nil);
else
vtproc(manager, nil);
}
void
threadmain(int argc, char *argv[])
{
char *configfile, *haddr, *vaddr, *webroot;
u32int mem, icmem, bcmem, minbcmem, mempcnt, stfree;
Allocs allocs;
Config config;
traceinit();
threadsetname("main");
mempcnt = 0;
vaddr = nil;
haddr = nil;
configfile = nil;
webroot = nil;
mem = Unspecified;
icmem = 0;
bcmem = 0;
ARGBEGIN{
case 'a':
vaddr = EARGF(usage());
break;
case 'B':
bcmem = unittoull(EARGF(usage()));
break;
case 'c':
configfile = EARGF(usage());
break;
case 'C':
mem = unittoull(EARGF(usage()));
break;
case 'D':
settrace(EARGF(usage()));
break;
case 'd':
debug = 1;
nofork = 1;
break;
case 'h':
haddr = EARGF(usage());
break;
case 'm':
mempcnt = atoi(EARGF(usage()));
if (mempcnt <= 0 || mempcnt >= 100)
usage();
break;
case 'I':
icmem = unittoull(EARGF(usage()));
break;
case 'L':
ventilogging = 1;
break;
case 'r':
readonly = 1;
break;
case 's':
nofork = 1;
break;
case 'w': /* compatibility with old venti */
queuewrites = 1;
break;
case 'W':
webroot = EARGF(usage());
break;
default:
usage();
}ARGEND
if(argc)
usage();
if(!nofork)
rfork(RFNOTEG);
#ifdef PLAN9PORT
{
/* sigh - needed to avoid signals when writing to hungup networks */
struct sigaction sa;
memset(&sa, 0, sizeof sa);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, nil);
}
#endif
ventifmtinstall();
trace(TraceQuiet, "venti started");
fprint(2, "%T venti: ");
if(configfile == nil)
configfile = "venti.conf";
/* remember free memory before initventi & loadbloom, for auto-sizing */
stfree = freemem();
fprint(2, "conf...");
if(initventi(configfile, &config) < 0)
sysfatal("can't init server: %r");
/*
* load bloom filter
*/
if(mainindex->bloom && loadbloom(mainindex->bloom) < 0)
sysfatal("can't load bloom filter: %r");
/*
* size memory allocations; assumes bloom filter is loaded
*/
allocs = sizeallocs((Allocs){mem, bcmem, icmem, stfree, mempcnt},
&config);
mem = allocs.mem;
bcmem = allocs.bcmem;
icmem = allocs.icmem;
fprint(2, "%s: mem %,ud bcmem %,ud icmem %,ud...",
argv0, mem, bcmem, icmem);
/*
* default other configuration-file parameters
*/
if(haddr == nil)
haddr = config.haddr;
if(vaddr == nil)
vaddr = config.vaddr;
if(vaddr == nil)
vaddr = "tcp!*!venti";
if(webroot == nil)
webroot = config.webroot;
if(queuewrites == 0)
queuewrites = config.queuewrites;
if(haddr){
fprint(2, "httpd %s...", haddr);
if(httpdinit(haddr, webroot) < 0)
fprint(2, "warning: can't start http server: %r");
}
fprint(2, "init...");
/*
* lump cache
*/
if(0) fprint(2, "initialize %d bytes of lump cache for %d lumps\n",
mem, mem / (8 * 1024));
initlumpcache(mem, mem / (8 * 1024));
/*
* index cache
*/
initicache(icmem);
initicachewrite();
/*
* block cache: need a block for every arena and every process
*/
minbcmem = maxblocksize *
(mainindex->narenas + mainindex->nsects*4 + 16);
if(bcmem < minbcmem)
bcmem = minbcmem;
if(0) fprint(2, "initialize %d bytes of disk block cache\n", bcmem);
initdcache(bcmem);
if(mainindex->bloom)
startbloomproc(mainindex->bloom);
fprint(2, "sync...");
if(!readonly && syncindex(mainindex) < 0)
sysfatal("can't sync server: %r");
if(!readonly && queuewrites){
fprint(2, "queue...");
if(initlumpqueues(mainindex->nsects) < 0){
fprint(2, "can't initialize lump queues,"
" disabling write queueing: %r");
queuewrites = 0;
}
}
if(initarenasum() < 0)
fprint(2, "warning: can't initialize arena summing process: %r");
fprint(2, "announce %s...", vaddr);
ventisrv = vtlisten(vaddr);
if(ventisrv == nil)
sysfatal("can't announce %s: %r", vaddr);
fprint(2, "serving.\n");
if(nofork)
ventiserver(nil);
else
vtproc(ventiserver, nil);
threadexits(nil);
}
