ref: 45f7b30244297a8bf87789793eec875246ed063c
dir: /sys/src/cmd/wikifs/io.c/
/*
* I/O for a Wiki document set.
*
* The files are kept in one flat directory.
* There are three files for each document:
* nnn - current version of the document
* nnn.hist - history (all old versions) of the document
* append-only
* L.nnn - write lock file for the document
*
* At the moment, since we don't have read/write locks
* in the file system, we use the L.nnn file as a read lock too.
* It's a hack but there aren't supposed to be many readers
* anyway.
*
* The nnn.hist file is in the format read by Brdwhist.
* The nnn file is in that format too, but only contains the
* last entry of the nnn.hist file.
*
* In addition to this set of files, there is an append-only
* map file that provides a mapping between numbers and titles.
* The map file is a sequence of lines of the form
* nnn Title Here
* The lock file L.map must be held to add to the end, to
* make sure that the numbers are allocated sequentially.
*
* We assume that writes to the map file will fit in one message,
* so that we don't have to read-lock the file.
*/
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <String.h>
#include <thread.h>
#include "wiki.h"
enum {
Nhash = 64,
Mcache = 128,
};
typedef struct Wcache Wcache;
struct Wcache {
int n;
ulong use;
RWLock;
ulong tcurrent;
ulong thist;
Whist *hist;
Whist *current;
Qid qid;
Qid qidhist;
Wcache *hash;
};
static RWLock cachelock;
static Wcache *tab[Nhash];
int ncache;
void
closewhist(Whist *wh)
{
int i;
if(wh && decref(wh) == 0){
free(wh->title);
for(i=0; i<wh->ndoc; i++){
free(wh->doc[i].author);
free(wh->doc[i].comment);
freepage(wh->doc[i].wtxt);
}
free(wh->doc);
free(wh);
}
}
void
freepage(Wpage *p)
{
Wpage *next;
for(; p; p=next){
next = p->next;
free(p->text);
free(p->url);
free(p);
}
}
static Wcache*
findcache(int n)
{
Wcache *w;
for(w=tab[n%Nhash]; w; w=w->hash)
if(w->n == n){
w->use = time(0);
return w;
}
return nil;
}
static int
getlock(char *lock)
{
char buf[ERRMAX];
int i, fd;
enum { SECS = 200 };
for(i=0; i<SECS*10; i++){
fd = wcreate(lock, ORDWR, DMEXCL|0666);
if(fd >= 0)
return fd;
buf[0] = '\0';
rerrstr(buf, sizeof buf);
if(strstr(buf, "locked") == nil)
break;
sleep(1000/10);
}
werrstr("couldn't acquire lock %s: %r", lock);
return -1;
}
static Whist*
readwhist(char *file, char *lock, Qid *qid)
{
int lfd;
Biobuf *b;
Dir *d;
Whist *wh;
if((lfd=getlock(lock)) < 0) // LOG?
return nil;
if(qid){
if((d = wdirstat(file)) == nil){
close(lfd);
return nil;
}
*qid = d->qid;
free(d);
}
if((b = wBopen(file, OREAD)) == nil){ //LOG?
close(lfd);
return nil;
}
wh = Brdwhist(b);
Bterm(b);
close(lfd);
return wh;
}
static void
gencurrent(Wcache *w, Qid *q, char *file, char *lock, ulong *t, Whist **wp, int n)
{
Dir *d;
Whist *wh;
if(*wp && *t+Tcache >= time(0))
return;
wlock(w);
if(*wp && *t+Tcache >= time(0)){
wunlock(w);
return;
}
if(((d = wdirstat(file)) == nil) || (d->qid.path==q->path && d->qid.vers==q->vers)){
*t = time(0);
wunlock(w);
free(d);
return;
}
free(d);
if(wh = readwhist(file, lock, q)){
wh->n = n;
*t = time(0);
closewhist(*wp);
*wp = wh;
}
else fprint(2, "error file=%s lock=%s %r\n", file, lock);
wunlock(w);
}
static void
current(Wcache *w)
{
char tmp[40];
char tmplock[40];
sprint(tmplock, "d/L.%d", w->n);
sprint(tmp, "d/%d", w->n);
gencurrent(w, &w->qid, tmp, tmplock, &w->tcurrent, &w->current, w->n);
}
static void
currenthist(Wcache *w)
{
char hist[40], lock[40];
sprint(hist, "d/%d.hist", w->n);
sprint(lock, "d/L.%d", w->n);
gencurrent(w, &w->qidhist, hist, lock, &w->thist, &w->hist, w->n);
}
void
voidcache(int n)
{
Wcache *c;
rlock(&cachelock);
if(c = findcache(n)){
wlock(c);
c->tcurrent = 0;
c->thist = 0;
/* aggressively free memory */
closewhist(c->hist);
c->hist = nil;
closewhist(c->current);
c->current = nil;
wunlock(c);
}
runlock(&cachelock);
}
static Whist*
getcache(int n, int hist)
{
int i, isw;
ulong t;
Wcache *c, **cp, **evict;
Whist *wh;
isw = 0;
rlock(&cachelock);
if(c = findcache(n)){
Found:
current(c);
if(hist)
currenthist(c);
rlock(c);
if(hist)
wh = c->hist;
else
wh = c->current;
if(wh)
incref(wh);
runlock(c);
if(isw)
wunlock(&cachelock);
else
runlock(&cachelock);
return wh;
}
runlock(&cachelock);
wlock(&cachelock);
if(c = findcache(n)){
isw = 1; /* better to downgrade lock but can't */
goto Found;
}
if(ncache < Mcache){
Alloc:
c = emalloc(sizeof *c);
ncache++;
}else{
/* find something to evict. */
t = ~0;
evict = nil;
for(i=0; i<Nhash; i++){
for(cp=&tab[i], c=*cp; c; cp=&c->hash, c=*cp){
if(c->use < t
&& (!c->hist || c->hist->ref==1)
&& (!c->current || c->current->ref==1)){
evict = cp;
t = c->use;
}
}
}
if(evict == nil){
fprint(2, "wikifs: nothing to evict\n");
goto Alloc;
}
c = *evict;
*evict = c->hash;
closewhist(c->current);
closewhist(c->hist);
memset(c, 0, sizeof *c);
}
c->n = n;
c->hash = tab[n%Nhash];
tab[n%Nhash] = c;
isw = 1;
goto Found;
}
Whist*
getcurrent(int n)
{
return getcache(n, 0);
}
Whist*
gethistory(int n)
{
return getcache(n, 1);
}
RWLock maplock;
Map *map;
static int
mapcmp(const void *va, const void *vb)
{
Mapel *a, *b;
a = (Mapel*)va;
b = (Mapel*)vb;
return strcmp(a->s, b->s);
}
void
closemap(Map *m)
{
if(decref(m)==0){
free(m->buf);
free(m->el);
free(m);
}
}
void
currentmap(int force)
{
char *p, *q, *r;
int lfd, fd, m, n;
Dir *d;
Map *nmap;
char *err = nil;
lfd = -1;
fd = -1;
d = nil;
nmap = nil;
if(!force && map && map->t+Tcache >= time(0))
return;
wlock(&maplock);
if(!force && map && map->t+Tcache >= time(0))
goto Return;
if((lfd = getlock("d/L.map")) < 0){
err = "can't lock";
goto Return;
}
if((d = wdirstat("d/map")) == nil)
goto Return;
if(map && d->qid.path == map->qid.path && d->qid.vers == map->qid.vers){
map->t = time(0);
goto Return;
}
if(d->length > Maxmap){
//LOG
err = "too long";
goto Return;
}
if((fd = wopen("d/map", OREAD)) < 0)
goto Return;
nmap = emalloc(sizeof *nmap);
nmap->buf = emalloc(d->length+1);
n = readn(fd, nmap->buf, d->length);
if(n != d->length){
err = "bad length";
goto Return;
}
nmap->buf[n] = '\0';
n = 0;
for(p=nmap->buf; p; p=strchr(p+1, '\n'))
n++;
nmap->el = emalloc(n*sizeof(nmap->el[0]));
m = 0;
for(p=nmap->buf; p && *p && m < n; p=q){
if(q = strchr(p+1, '\n'))
*q++ = '\0';
nmap->el[m].n = strtol(p, &r, 10);
if(*r == ' ')
r++;
else
{}//LOG?
nmap->el[m].s = strcondense(r, 1);
m++;
}
//LOG if m != n
nmap->qid = d->qid;
nmap->t = time(0);
nmap->nel = m;
qsort(nmap->el, nmap->nel, sizeof(nmap->el[0]), mapcmp);
if(map)
closemap(map);
map = nmap;
incref(map);
nmap = nil;
Return:
free(d);
if(nmap){
free(nmap->el);
free(nmap->buf);
free(nmap);
}
if(map == nil)
sysfatal("cannot get map: %s: %r", err);
if(fd >= 0)
close(fd);
if(lfd >= 0)
close(lfd);
wunlock(&maplock);
}
int
allocnum(char *title, int mustbenew)
{
char *p, *q;
int lfd, fd, n;
Biobuf b;
if(strcmp(title, "map")==0 || strcmp(title, "new")==0){
werrstr("reserved title name");
return -1;
}
if(title[0]=='\0' || strpbrk(title, "/<>:?")){
werrstr("invalid character in name");
return -1;
}
if((n = nametonum(title)) >= 0){
if(mustbenew){
werrstr("duplicate title");
return -1;
}
return n;
}
title = estrdup(title);
strcondense(title, 1);
strlower(title);
if(strchr(title, '\n') || strlen(title) > 200){
werrstr("bad title");
free(title);
return -1;
}
if((lfd = getlock("d/L.map")) < 0){
free(title);
return -1;
}
if((fd = wopen("d/map", ORDWR)) < 0){ // LOG?
close(lfd);
free(title);
return -1;
}
/*
* What we really need to do here is make sure the
* map is up-to-date, then make sure the title isn't
* taken, and then add it, all without dropping the locks.
*
* This turns out to be a mess when you start adding
* all the necessary dolock flags, so instead we just
* read through the file ourselves, and let our
* map catch up on its own.
*/
Binit(&b, fd, OREAD);
n = 0;
while(p = Brdline(&b, '\n')){
p[Blinelen(&b)-1] = '\0';
n = atoi(p)+1;
q = strchr(p, ' ');
if(q == nil)
continue;
if(strcmp(q+1, title) == 0){
free(title);
close(fd);
close(lfd);
if(mustbenew){
werrstr("duplicate title");
return -1;
}else
return n;
}
}
seek(fd, 0, 2); /* just in case it's not append only */
fprint(fd, "%d %s\n", n, title);
close(fd);
close(lfd);
free(title);
/* kick the map */
currentmap(1);
return n;
}
int
nametonum(char *s)
{
char *p;
int i, lo, hi, m, rv;
s = estrdup(s);
strlower(s);
for(p=s; *p; p++)
if(*p=='_')
*p = ' ';
currentmap(0);
rlock(&maplock);
lo = 0;
hi = map->nel;
while(hi-lo > 1){
m = (lo+hi)/2;
i = strcmp(s, map->el[m].s);
if(i < 0)
hi = m;
else
lo = m;
}
if(hi-lo == 1 && strcmp(s, map->el[lo].s)==0)
rv = map->el[lo].n;
else
rv = -1;
runlock(&maplock);
free(s);
return rv;
}
char*
numtoname(int n)
{
int i;
char *s;
currentmap(0);
rlock(&maplock);
for(i=0; i<map->nel; i++){
if(map->el[i].n==n)
break;
}
if(i==map->nel){
runlock(&maplock);
return nil;
}
s = estrdup(map->el[i].s);
runlock(&maplock);
return s;
}
Whist*
getcurrentbyname(char *s)
{
int n;
if((n = nametonum(s)) < 0)
return nil;
return getcache(n, 0);
}
static String*
Brdstring(Biobuf *b)
{
long len;
String *s;
Dir *d;
d = dirfstat(Bfildes(b));
if (d == nil) /* shouldn't happen, we just opened it */
len = 0;
else
len = d->length;
free(d);
s = s_newalloc(len);
s_read(b, s, len);
return s;
}
/*
* Attempt to install a new page. If t==0 we are creating.
* Otherwise, we are editing and t must be set to the current
* version (t is the version we started with) to avoid conflicting
* writes.
*
* If there is a conflicting write, we still write the page to
* the history file, but mark it as a failed write.
*/
int
writepage(int num, ulong t, String *s, char *title)
{
char tmp[40], tmplock[40], err[ERRMAX], hist[40], *p;
int conflict, lfd, fd;
Biobuf *b;
String *os;
sprint(tmp, "d/%d", num);
sprint(tmplock, "d/L.%d", num);
sprint(hist, "d/%d.hist", num);
if((lfd = getlock(tmplock)) < 0)
return -1;
conflict = 0;
if(b = wBopen(tmp, OREAD)){
Brdline(b, '\n'); /* title */
if(p = Brdline(b, '\n')) /* version */
p[Blinelen(b)-1] = '\0';
if(p==nil || p[0] != 'D'){
snprint(err, sizeof err, "bad format in extant file");
conflict = 1;
}else if(strtoul(p+1, 0, 0) != t){
os = Brdstring(b); /* why read the whole file? */
p = strchr(s_to_c(s), '\n');
if(p!=nil && strcmp(p+1, s_to_c(os))==0){ /* ignore dup write */
close(lfd);
s_free(os);
Bterm(b);
return 0;
}
s_free(os);
snprint(err, sizeof err, "update conflict %lud != %s", t, p+1);
conflict = 1;
}
Bterm(b);
}else{
if(t != 0){
close(lfd);
werrstr("did not expect to create");
return -1;
}
}
if((fd = wopen(hist, OWRITE)) < 0){
if((fd = wcreate(hist, OWRITE, 0666)) < 0){
close(lfd);
return -1;
}else
fprint(fd, "%s\n", title);
}
if(seek(fd, 0, 2) < 0
|| (conflict && write(fd, "X\n", 2) != 2)
|| write(fd, s_to_c(s), s_len(s)) != s_len(s)){
close(fd);
close(lfd);
return -1;
}
close(fd);
if(conflict){
close(lfd);
voidcache(num);
errstr(err, sizeof err);
return -1;
}
if((fd = wcreate(tmp, OWRITE, 0666)) < 0){
close(lfd);
voidcache(num);
return -1;
}
if(write(fd, title, strlen(title)) != strlen(title)
|| write(fd, "\n", 1) != 1
|| write(fd, s_to_c(s), s_len(s)) != s_len(s)){
close(fd);
close(lfd);
voidcache(num);
return -1;
}
close(fd);
close(lfd);
voidcache(num);
return 0;
}