void
threadmain(int argc, char *argv[])
{
ArenaPart *ap;
Part *part;
char *file;
u8int score[VtScoreSize];
int i, found;
ventifmtinstall();
ARGBEGIN{
case 'v':
verbose++;
break;
default:
usage();
break;
}ARGEND
readonly = 1;
if(argc != 2)
usage();
file = argv[0];
if(strscore(argv[1], score) < 0)
sysfatal("bad score %s", argv[1]);
part = initpart(file, OREAD|ODIRECT);
if(part == nil)
sysfatal("can't open partition %s: %r", file);
ap = initarenapart(part);
if(ap == nil)
sysfatal("can't initialize arena partition in %s: %r", file);
if(verbose > 1){
printarenapart(2, ap);
fprint(2, "\n");
}
initdcache(8 * MaxDiskBlock);
found = 0;
for(i = 0; i < ap->narenas; i++)
found += findscore(ap->arenas[i], score);
print("found %d occurrences of %V\n", found, score);
if(verbose > 1)
printstats();
threadexitsall(0);
}
int
i18n_subtitle_score(const char *str)
{
return findscore(str, lang_subtitle);
}
int
i18n_audio_score(const char *str)
{
return findscore(str, lang_audio);
}
void captureservermode::addscore(int base, const char *team, int n) {
if(!n) return;
score &cs = findscore(team);
cs.total += n;
sendf(-1, 1, "riisi", N_BASESCORE, base, team, cs.total);
}
static void
ventiserver(void *v)
{
Packet *p;
VtReq *r;
char err[ERRMAX];
uint ms;
int ok;
struct map *m;
USED(v);
threadsetname("ventiserver");
trace(TraceWork, "start");
while((r = vtgetreq(ventisrv)) != nil){
trace(TraceWork, "finish");
trace(TraceWork, "start request %F", &r->tx);
trace(TraceRpc, "<- %F", &r->tx);
r->rx.msgtype = r->tx.msgtype+1;
addstat(StatRpcTotal, 1);
if(0) print("req (arenas[0]=%p sects[0]=%p) %F\n",
mainindex->arenas[0], mainindex->sects[0], &r->tx);
switch(r->tx.msgtype){
default:
vtrerror(r, "unknown request");
break;
case VtTread:
ms = msec();
m = findscore(r->tx.score);
//fprint(2, "findscore says %p\n", m);
if (m) {
//fprint(2, "Found the block\n");
r->rx.data = packetalloc();
packetappend(r->rx.data, m->data, m->len);
r->rx.blocktype = m->blocktype;
} else {
r->rx.data = nil;
}
ms = msec() - ms;
addstat2(StatRpcRead, 1, StatRpcReadTime, ms);
if(r->rx.data == nil){
addstat(StatRpcReadFail, 1);
rerrstr(err, sizeof err);
vtrerror(r, err);
}else{
addstat(StatRpcReadBytes, packetsize(r->rx.data));
addstat(StatRpcReadOk, 1);
addstat2(StatRpcReadCached, 1, StatRpcReadCachedTime, ms);
r->rx.msgtype = VtRread;
r->rx.error = nil;
}
break;
case VtTwrite:
if(readonly){
vtrerror(r, "read only");
break;
}
p = r->tx.data;
r->tx.data = nil;
addstat(StatRpcWriteBytes, packetsize(p));
ms = msec();
/* todo: check for overflow of file */
ok = putscore(p, r->rx.score, r->tx.blocktype);
ms = msec() - ms;
addstat2(StatRpcWrite, 1, StatRpcWriteTime, ms);
if(ok < 0){
addstat(StatRpcWriteFail, 1);
rerrstr(err, sizeof err);
vtrerror(r, err);
} else {
r->rx.msgtype = VtRwrite;
r->rx.error = nil;
}
break;
case VtTsync:
/* nonsense. Write synchronously. For now. Later, have a helper thread and VtTsync will just write a Fence to it and wait for it to come back. */
break;
}
trace(TraceRpc, "-> %F", &r->rx);
vtrespond(r);
trace(TraceWork, "start");
}
threadexitsall(0);
}
