ref: 44ce0097b612a1fefd754065bdf8d9d2e5ef60c8
dir: /appl/cmd/dbfs.b/
implement Dbfs;
#
# Copyright © 1999 Vita Nuova Limited. All rights reserved.
# Revisions copyright © 2002 Vita Nuova Holdings Limited. All rights reserved.
#
include "sys.m";
sys: Sys;
Qid: import Sys;
include "draw.m";
include "arg.m";
include "styx.m";
styx: Styx;
Tmsg, Rmsg: import styx;
include "styxservers.m";
styxservers: Styxservers;
Fid, Styxserver, Navigator, Navop: import styxservers;
Enotfound, Eperm, Ebadarg: import styxservers;
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
Record: adt {
id: int; # file number in directory
x: int; # index in file
dirty: int; # modified but not written
vers: int; # version
data: array of byte;
new: fn(x: array of byte): ref Record;
print: fn(r: self ref Record, fd: ref Sys->FD);
qid: fn(r: self ref Record): Sys->Qid;
};
Database: adt {
name: string;
file: ref Iobuf;
records: array of ref Record;
dirty: int;
vers: int;
nextid: int;
findrec: fn(db: self ref Database, id: int): ref Record;
};
Dbfs: module
{
init: fn(nil: ref Draw->Context, nil: list of string);
};
Qdir, Qnew, Qdata: con iota;
clockfd: ref Sys->FD;
stderr: ref Sys->FD;
database: ref Database;
user: string;
Eremoved: con "file removed";
usage()
{
sys->fprint(stderr, "Usage: dbfs [-a|-b|-ac|-bc] [-D] file mountpoint\n");
raise "fail:usage";
}
nomod(s: string)
{
sys->fprint(stderr, "dbfs: can't load %s: %r\n", s);
raise "fail:load";
}
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
sys->pctl(Sys->FORKFD|Sys->NEWPGRP, nil);
stderr = sys->fildes(2);
styx = load Styx Styx->PATH;
if(styx == nil)
nomod(Styx->PATH);
styx->init();
styxservers = load Styxservers Styxservers->PATH;
if(styxservers == nil)
nomod(Styxservers->PATH);
styxservers->init(styx);
bufio = load Bufio Bufio->PATH;
if(bufio == nil)
nomod(Bufio->PATH);
arg := load Arg Arg->PATH;
if(arg == nil)
nomod(Arg->PATH);
arg->init(args);
flags := Sys->MREPL;
copt := 0;
empty := 0;
while((o := arg->opt()) != 0)
case o {
'a' => flags = Sys->MAFTER;
'b' => flags = Sys->MBEFORE;
'c' => copt = 1;
'e' => empty = 1;
'D' => styxservers->traceset(1);
* => usage();
}
args = arg->argv();
arg = nil;
if(len args != 2)
usage();
if(copt)
flags |= Sys->MCREATE;
file := hd args;
args = tl args;
mountpt := hd args;
df := bufio->open(file, Sys->OREAD);
if(df == nil && empty){
(rc, nil) := sys->stat(file);
if(rc < 0)
df = bufio->create(file, Sys->OREAD, 8r600);
}
if(df == nil){
sys->fprint(stderr, "dbfs: can't open %s: %r\n", file);
raise "fail:open";
}
(db, err) := dbread(ref Database(file, df, nil, 0, 0, 0));
if(db == nil){
sys->fprint(stderr, "dbfs: can't read %s: %s\n", file, err);
raise "fail:dbread";
}
db.file = nil;
# dbprint(db);
database = db;
sys->pctl(Sys->FORKFD, nil);
user = rf("/dev/user");
if(user == nil)
user = "inferno";
fds := array[2] of ref Sys->FD;
if(sys->pipe(fds) < 0){
sys->fprint(stderr, "dbfs: can't create pipe: %r\n");
raise "fail:pipe";
}
navops := chan of ref Navop;
spawn navigator(navops);
(tchan, srv) := Styxserver.new(fds[0], Navigator.new(navops), big Qdir);
fds[0] = nil;
pidc := chan of int;
spawn serveloop(tchan, srv, pidc, navops);
<-pidc;
if(sys->mount(fds[1], nil, mountpt, flags, nil) < 0) {
sys->fprint(stderr, "dbfs: mount failed: %r\n");
raise "fail:mount";
}
}
rf(f: string): string
{
fd := sys->open(f, Sys->OREAD);
if(fd == nil)
return nil;
b := array[Sys->NAMEMAX] of byte;
n := sys->read(fd, b, len b);
if(n < 0)
return nil;
return string b[0:n];
}
dbread(db: ref Database): (ref Database, string)
{
db.file.seek(big 0, Sys->SEEKSTART);
rl: list of ref Record;
n := 0;
for(;;){
(r, err) := getrec(db);
if(err != nil)
return (nil, err); # could press on without it, or make it the `file' contents
if(r == nil)
break;
rl = r :: rl;
n++;
}
db.nextid = n;
db.records = array[n] of ref Record;
for(; rl != nil; rl = tl rl){
r := hd rl;
n--;
r.id = n;
r.x = n;
db.records[n] = r;
}
return (db, nil);
}
#
# a record is (.+\n)*\n
#
getrec(db: ref Database): (ref Record, string)
{
r := ref Record(-1, -1, 0, 0, nil);
data := "";
for(;;){
s := db.file.gets('\n');
if(s == nil){
if(data == nil)
return (nil, nil); # BUG: distinguish i/o error from EOF?
break;
}
if(s[len s - 1] != '\n')
# return (nil, "file missing newline"); # possibly truncated
s += "\n";
if(s == "\n")
break;
data += s;
}
r.data = array of byte data;
return (r, nil);
}
dbsync(db: ref Database): int
{
if(db.dirty){
db.file = bufio->create(db.name, Sys->OWRITE, 8r666);
if(db.file == nil)
return -1;
for(i := 0; i < len db.records; i++){
r := db.records[i];
if(r != nil && r.data != nil){
if(db.file.write(r.data, len r.data) != len r.data)
return -1;
db.file.putc('\n');
}
}
if(db.file.flush())
return -1;
db.file = nil;
db.dirty = 0;
}
return 0;
}
dbprint(db: ref Database)
{
stdout := sys->fildes(1);
for(i := 0; i < len db.records; i++){
db.records[i].print(stdout);
sys->print("\n");
}
}
Database.findrec(db: self ref Database, id: int): ref Record
{
for(i:=0; i<len db.records; i++)
if((r := db.records[i]) != nil && r.id == id)
return r;
return nil;
}
Record.new(fields: array of byte): ref Record
{
n := len database.records;
r := ref Record(n, n, 0, 0, fields);
a := array[n+1] of ref Record;
if(n)
a[0:] = database.records[0:];
a[n] = r;
database.records = a;
database.vers++;
return r;
}
Record.print(r: self ref Record, fd: ref Sys->FD)
{
if(r.data != nil)
sys->write(fd, r.data, len r.data);
}
Record.qid(r: self ref Record): Sys->Qid
{
return Sys->Qid(QPATH(r.x, Qdata), r.vers, Sys->QTFILE);
}
serveloop(tchan: chan of ref Tmsg, srv: ref Styxserver, pidc: chan of int, navops: chan of ref Navop)
{
pidc <-= sys->pctl(Sys->FORKNS|Sys->NEWFD, 1::2::srv.fd.fd::nil);
Serve:
while((gm := <-tchan) != nil){
pick m := gm {
Readerror =>
sys->fprint(stderr, "dbfs: fatal read error: %s\n", m.error);
break Serve;
Open =>
c := srv.getfid(m.fid);
if(c == nil || TYPE(c.path) != Qnew){
srv.open(m); # default action
break;
}
if(c.uname != user) {
srv.reply(ref Rmsg.Error(m.tag, Eperm));
break;
}
mode := styxservers->openmode(m.mode);
if(mode < 0) {
srv.reply(ref Rmsg.Error(m.tag, Ebadarg));
break;
}
# generate new file, change Fid's qid to match
r := Record.new(array[0] of byte);
qid := r.qid();
c.open(mode, qid);
srv.reply(ref Rmsg.Open(m.tag, qid, srv.iounit()));
Read =>
(c, err) := srv.canread(m);
if(c == nil){
srv.reply(ref Rmsg.Error(m.tag, err));
break;
}
if(c.qtype & Sys->QTDIR){
srv.read(m); # does readdir
break;
}
r := database.records[FILENO(c.path)];
if(r == nil)
srv.reply(ref Rmsg.Error(m.tag, Eremoved));
else
srv.reply(styxservers->readbytes(m, r.data));
Write =>
(c, merr) := srv.canwrite(m);
if(c == nil){
srv.reply(ref Rmsg.Error(m.tag, merr));
break;
}
(value, err) := data2rec(m.data);
if(err != nil){
srv.reply(ref Rmsg.Error(m.tag, err));
break;
}
fno := FILENO(c.path);
r := database.records[fno];
if(r == nil){
srv.reply(ref Rmsg.Error(m.tag, Eremoved));
break;
}
r.data = value;
r.vers++;
database.dirty++;
if(dbsync(database) == 0)
srv.reply(ref Rmsg.Write(m.tag, len m.data));
else
srv.reply(ref Rmsg.Error(m.tag, sys->sprint("%r")));
Clunk =>
# a transaction-oriented dbfs could delay updating the record until clunk
srv.clunk(m);
Remove =>
c := srv.getfid(m.fid);
if(c == nil || c.qtype & Sys->QTDIR || TYPE(c.path) != Qdata){
# let it diagnose all the errors
srv.remove(m);
break;
}
r := database.records[FILENO(c.path)];
if(r != nil)
r.data = nil;
database.dirty++;
srv.delfid(c);
if(dbsync(database) == 0)
srv.reply(ref Rmsg.Remove(m.tag));
else
srv.reply(ref Rmsg.Error(m.tag, sys->sprint("%r")));
Wstat =>
srv.default(gm); # TO DO?
* =>
srv.default(gm);
}
}
navops <-= nil; # shut down navigator
}
dirslot(n: int): int
{
for(i := 0; i < len database.records; i++){
r := database.records[i];
if(r != nil && r.data != nil){
if(n == 0)
return i;
n--;
}
}
return -1;
}
dir(qid: Sys->Qid, name: string, length: big, uid: string, perm: int): ref Sys->Dir
{
d := ref sys->zerodir;
d.qid = qid;
if(qid.qtype & Sys->QTDIR)
perm |= Sys->DMDIR;
d.mode = perm;
d.name = name;
d.uid = uid;
d.gid = uid;
d.length = length;
return d;
}
dirgen(p: big): (ref Sys->Dir, string)
{
case TYPE(p) {
Qdir =>
return (dir(Qid(QPATH(0, Qdir),database.vers,Sys->QTDIR), "/", big 0, user, 8r700), nil);
Qnew =>
return (dir(Qid(QPATH(0, Qnew),0,Sys->QTFILE), "new", big 0, user, 8r600), nil);
* =>
n := FILENO(p);
if(n < 0 || n >= len database.records)
return (nil, nil);
r := database.records[n];
if(r == nil || r.data == nil)
return (nil, Enotfound);
return (dir(r.qid(), sys->sprint("%d", r.id), big len r.data, user, 8r600), nil);
}
}
navigator(navops: chan of ref Navop)
{
while((m := <-navops) != nil){
pick n := m {
Stat =>
n.reply <-= dirgen(n.path);
Walk =>
if(int n.path != Qdir){
n.reply <-= (nil, "not a directory");
break;
}
case n.name {
".." =>
; # nop
"new" =>
n.path = QPATH(0, Qnew);
* =>
if(len n.name < 1 || !(n.name[0]>='0' && n.name[0]<='9')){ # weak test for now
n.reply <-= (nil, Enotfound);
continue;
}
r := database.findrec(int n.name);
if(r == nil){
n.reply <-= (nil, Enotfound);
continue;
}
n.path = QPATH(r.x, Qdata);
}
n.reply <-= dirgen(n.path);
Readdir =>
if(int m.path != Qdir){
n.reply <-= (nil, "not a directory");
break;
}
i := n.offset;
if(i == 0)
n.reply <-= dirgen(QPATH(0,Qnew));
for(; --n.count >= 0 && (j := dirslot(i)) >= 0; i++)
n.reply <-= dirgen(QPATH(j,Qdata)); # n² but the file will be small
n.reply <-= (nil, nil);
}
}
}
QPATH(w, q: int): big
{
return big ((w<<8)|q);
}
TYPE(path: big): int
{
return int path & 16rFF;
}
FILENO(path: big) : int
{
return (int path >> 8) & 16rFFFFFF;
}
#
# a record is (.+\n)*, without final empty line
#
data2rec(data: array of byte): (array of byte, string)
{
s: string;
for(b := data; len b > 0;){
(b, s) = getline(b);
if(s == nil || s[len s - 1] != '\n' || s == "\n")
return (nil, "partial or malformed record"); # possibly truncated
}
return (data, nil);
}
getline(b: array of byte): (array of byte, string)
{
n := len b;
for(i := 0; i < n; i++){
(ch, l, nil) := sys->byte2char(b, i);
i += l;
if(l == 0 || ch == '\n')
break;
}
return (b[i:], string b[0:i]);
}