summaryrefslogtreecommitdiff
path: root/appl/cmd/rawdbfs.b
diff options
context:
space:
mode:
Diffstat (limited to 'appl/cmd/rawdbfs.b')
-rw-r--r--appl/cmd/rawdbfs.b813
1 files changed, 813 insertions, 0 deletions
diff --git a/appl/cmd/rawdbfs.b b/appl/cmd/rawdbfs.b
new file mode 100644
index 00000000..cb2daf2c
--- /dev/null
+++ b/appl/cmd/rawdbfs.b
@@ -0,0 +1,813 @@
+implement Dbfs;
+
+#
+# Copyright © 1999, 2002 Vita Nuova Limited. All rights reserved.
+#
+
+# Enhanced to include record locking, index field generation and update notification
+
+# TO DO:
+# make writing & reading more like real files; don't ignore offsets.
+# open with OTRUNC should work.
+# provide some way of compacting a dbfs file.
+
+include "sys.m";
+ sys: Sys;
+ Qid: import Sys;
+
+include "draw.m";
+
+include "arg.m";
+
+include "styx.m";
+ styx: Styx;
+ Rmsg, Tmsg: import styx;
+
+include "styxservers.m";
+ styxservers: Styxservers;
+ Styxserver, Fid, Navigator, Navop: import styxservers;
+ Enotfound, Eperm, Ebadfid, Ebadarg: import styxservers;
+
+include "string.m";
+ str: String;
+
+include "bufio.m";
+ bufio: Bufio;
+ Iobuf: import bufio;
+
+include "sh.m";
+ sh: Sh;
+
+Record: adt {
+ id: int; # file number in directory (if block is allocated)
+ offset: int; # start of data
+ count: int; # length of block (excluding header)
+ datalen: int; # length of data (-1 if block is free)
+ vers: int; # version
+
+ new: fn(offset: int, length: int): ref Record;
+ qid: fn(r: self ref Record): Sys->Qid;
+};
+
+# Record lock
+Lock: adt {
+ qpath: big;
+ fid: int;
+};
+
+HEADLEN: con 10;
+MINSIZE: con 20;
+
+Database: adt {
+ file: ref Iobuf;
+ records: array of ref Record;
+ maxid: int;
+ locking: int;
+ locklist: list of Lock;
+ indexing: int;
+ stats: int;
+ index: int;
+ s_reads: int;
+ s_writes: int;
+ s_creates: int;
+ s_removes: int;
+ updcmd: string;
+ vers: int;
+
+ build: fn(f: ref Iobuf, locking, indexing: int, stats: int, updcmd: string): (ref Database, string);
+ write: fn(db: self ref Database, n: int, data: array of byte): int;
+ read: fn(db: self ref Database, n: int): array of byte;
+ remove: fn(db: self ref Database, n: int);
+ create: fn(db: self ref Database, data: array of byte): ref Record;
+ updated: fn(db: self ref Database);
+ lock: fn(db: self ref Database, c: ref Styxservers->Fid): int;
+ unlock: fn(db: self ref Database, c: ref Styxservers->Fid);
+ ownlock: fn(db: self ref Database, c: ref Styxservers->Fid): int;
+};
+
+Dbfs: module
+{
+ init: fn(ctxt: ref Draw->Context, nil: list of string);
+};
+
+Qdir, Qnew, Qdata, Qindex, Qstats: con iota;
+
+stderr: ref Sys->FD;
+database: ref Database;
+context: ref Draw->Context;
+user: string;
+Eremoved: con "file removed";
+Egreg: con "thermal problems";
+Elocked: con "open/create -- file is locked";
+
+usage()
+{
+ sys->fprint(stderr, "Usage: dbfs [-abcelrxD][-u cmd] file mountpoint\n");
+ raise "fail:usage";
+}
+
+nomod(s: string)
+{
+ sys->fprint(stderr, "dbfs: can't load %s: %r\n", s);
+ raise "fail:load";
+}
+
+init(ctxt: ref Draw->Context, args: list of string)
+{
+ sys = load Sys Sys->PATH;
+ stderr = sys->fildes(2);
+ context = ctxt;
+ sys->pctl(Sys->FORKFD|Sys->NEWPGRP, nil);
+ 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);
+ str = load String String->PATH;
+ if(str == nil)
+ nomod(String->PATH);
+ 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;
+ locking := 0;
+ stats := 0;
+ indexing := 0;
+ updcmd := "";
+ while((o := arg->opt()) != 0)
+ case o {
+ 'a' => flags = Sys->MAFTER;
+ 'b' => flags = Sys->MBEFORE;
+ 'r' => flags = Sys->MREPL;
+ 'c' => copt = 1;
+ 'e' => empty = 1;
+ 'l' => locking = 1;
+ 'u' => updcmd = arg->arg();
+ if(updcmd == nil)
+ usage();
+ 'x' => indexing = 1;
+ stats = 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;
+
+ if(updcmd != nil){
+ sh = load Sh Sh->PATH;
+ if(sh == nil)
+ nomod(Sh->PATH);
+ }
+
+ df := bufio->open(file, Sys->ORDWR);
+ if(df == nil && empty){
+ (rc, d) := sys->stat(file);
+ if(rc < 0)
+ df = bufio->create(file, Sys->ORDWR, 8r600);
+ }
+ if(df == nil){
+ sys->fprint(stderr, "dbfs: can't open %s: %r\n", file);
+ raise "fail:cannot open file";
+ }
+ (db, err) := Database.build(df, locking, indexing, stats, updcmd);
+ if(db == nil){
+ sys->fprint(stderr, "dbfs: can't read %s: %s\n", file, err);
+ raise "fail:cannot read 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:bad 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];
+}
+
+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, stderr.fd::1::2::database.file.fd.fd::srv.fd.fd::nil);
+# stderr = sys->fildes(stderr.fd);
+ database.file.fd = sys->fildes(database.file.fd.fd);
+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);
+ open(srv, m);
+ 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);
+ break;
+ }
+ case TYPE(c.path) {
+ Qindex =>
+ if(database.index < 0) {
+ srv.reply(ref Rmsg.Error(m.tag, Eperm));
+ break;
+ }
+ if (m.offset > big 0) {
+ srv.reply(ref Rmsg.Read(m.tag, nil));
+ break;
+ }
+ reply := array of byte string ++database.index;
+ if(m.count < len reply)
+ reply = reply[:m.count];
+ srv.reply(ref Rmsg.Read(m.tag, reply));
+ Qstats =>
+ if (m.offset > big 0) {
+ srv.reply(ref Rmsg.Read(m.tag, nil));
+ break;
+ }
+ reply := array of byte sys->sprint("%d %d %d %d", database.s_reads, database.s_writes,
+ database.s_creates, database.s_removes);
+ if(m.count < len reply) reply = reply[:m.count];
+ srv.reply(ref Rmsg.Read(m.tag, reply));
+ Qdata =>
+ recno := id2recno(FILENO(c.path));
+ if(recno == -1)
+ srv.reply(ref Rmsg.Error(m.tag, Eremoved));
+ else
+ srv.reply(styxservers->readbytes(m, database.read(recno)));
+ * =>
+ srv.reply(ref Rmsg.Error(m.tag, Egreg));
+ }
+ Write =>
+ (c, err) := srv.canwrite(m);
+ if(c == nil){
+ srv.reply(ref Rmsg.Error(m.tag, err));
+ break;
+ }
+ if(!database.ownlock(c)) {
+ # shouldn't happen: open checks
+ srv.reply(ref Rmsg.Error(m.tag, Elocked));
+ break;
+ }
+ case TYPE(c.path) {
+ Qindex =>
+ if(database.index >= 0) {
+ srv.reply(ref Rmsg.Error(m.tag, Eperm));
+ break;
+ }
+ database.index = int string m.data;
+ srv.reply(ref Rmsg.Write(m.tag, len m.data));
+ Qdata =>
+ recno := id2recno(FILENO(c.path));
+ if(recno == -1)
+ srv.reply(ref Rmsg.Error(m.tag, "phase error"));
+ else {
+ changed := 1;
+ if(database.updcmd != nil){
+ oldrec := database.read(recno);
+ changed = !eqbytes(m.data, oldrec);
+ }
+ if(changed && database.write(recno, m.data) == -1){
+ srv.reply(ref Rmsg.Error(m.tag, sys->sprint("%r")));
+ break;
+ }
+ if(changed)
+ database.updated(); # run the command before reply
+ srv.reply(ref Rmsg.Write(m.tag, len m.data));
+ }
+ * =>
+ srv.reply(ref Rmsg.Error(m.tag, Eperm));
+ }
+ Clunk =>
+ c := srv.getfid(m.fid);
+ if(c != nil)
+ database.unlock(c);
+ srv.clunk(m);
+ Remove =>
+ c := srv.getfid(m.fid);
+ database.unlock(c);
+ if(c == nil || c.qtype & Sys->QTDIR || TYPE(c.path) != Qdata){
+ # let it diagnose all the errors
+ srv.remove(m);
+ break;
+ }
+ recno := id2recno(FILENO(c.path));
+ if(recno == -1)
+ srv.reply(ref Rmsg.Error(m.tag, "phase error"));
+ else {
+ database.remove(recno);
+ database.updated();
+ srv.reply(ref Rmsg.Remove(m.tag));
+ }
+ srv.delfid(c);
+ * =>
+ srv.default(gm);
+ }
+ }
+ navops <-= nil; # shut down navigator
+}
+
+eqbytes(a, b: array of byte): int
+{
+ if(len a != len b)
+ return 0;
+ for(i := 0; i < len a; i++)
+ if(a[i] != b[i])
+ return 0;
+ return 1;
+}
+
+id2recno(id: int): int
+{
+ recs := database.records;
+ for(i := 0; i < len recs; i++)
+ if(recs[i].datalen >= 0 && recs[i].id == id)
+ return i;
+ return -1;
+}
+
+open(srv: ref Styxserver, m: ref Tmsg.Open): ref Fid
+{
+ (c, mode, d, err) := srv.canopen(m);
+ if(c == nil){
+ srv.reply(ref Rmsg.Error(m.tag, err));
+ return nil;
+ }
+ if(TYPE(c.path) == Qnew){
+ # generate new file
+ if(c.uname != user){
+ srv.reply(ref Rmsg.Error(m.tag, Eperm));
+ return nil;
+ }
+ r := database.create(array[0] of byte);
+ if(r == nil) {
+ srv.reply(ref Rmsg.Error(m.tag, "create -- i/o error"));
+ return nil;
+ }
+ (d, nil) = dirgen(QPATH(r.id, Qdata));
+ }
+ if(m.mode & Sys->OTRUNC) {
+ # TO DO
+ }
+ c.open(mode, d.qid);
+ if(database.locking && TYPE(c.path) == Qdata && (m.mode & (Sys->OWRITE|Sys->ORDWR))) {
+ if(!database.lock(c)) {
+ srv.reply(ref Rmsg.Error(m.tag, Elocked));
+ return nil;
+ }
+ }
+ srv.reply(ref Rmsg.Open(m.tag, d.qid, srv.iounit()));
+ return c;
+}
+
+dirslot(n: int): int
+{
+ for(i := 0; i < len database.records; i++){
+ r := database.records[i];
+ if(r != nil && r.datalen >= 0){
+ 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);
+ Qindex =>
+ return (dir(Qid(QPATH(0, Qindex),0,Sys->QTFILE), "index", big 0, user, 8r600), nil);
+ Qstats =>
+ return (dir(Qid(QPATH(0, Qstats),0,Sys->QTFILE), "stats", big 0, user, 8r400), nil);
+ * =>
+ n := id2recno(FILENO(p));
+ if(n < 0 || n >= len database.records)
+ return (nil, nil);
+ r := database.records[n];
+ if(r == nil || r.datalen < 0)
+ return (nil, Enotfound);
+ l := r.datalen;
+ if(l < 0)
+ l = 0;
+ return (dir(r.qid(), sys->sprint("%d", r.id), big l, 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);
+ "stats" =>
+ if(!database.indexing){
+ n.reply <-= (nil, Enotfound);
+ continue;
+ }
+ n.path = QPATH(0, Qstats);
+ "index" =>
+ if(!database.indexing){
+ n.reply <-= (nil, Enotfound);
+ continue;
+ }
+ n.path = QPATH(0, Qindex);
+ * =>
+ if(len n.name < 1 || !(n.name[0]>='0' && n.name[0]<='9')){ # weak test for now
+ n.reply <-= (nil, Enotfound);
+ continue;
+ }
+ n.path = QPATH(int n.name, Qdata);
+ }
+ n.reply <-= dirgen(n.path);
+ Readdir =>
+ if(int m.path != Qdir){
+ n.reply <-= (nil, "not a directory");
+ break;
+ }
+ o := 1; # Qnew;
+ stats := -1;
+ indexing := -1;
+ if(database.indexing)
+ indexing = o++;
+ if(database.stats)
+ stats = o++;
+ Dread:
+ for(i := n.offset; --n.count >= 0; i++){
+ case i {
+ 0 =>
+ n.reply <-= dirgen(QPATH(0,Qnew));
+ * =>
+ if(i == indexing)
+ n.reply <-= dirgen(QPATH(0, Qindex));
+ if(i == stats)
+ n.reply <-= dirgen(QPATH(0, Qstats));
+ j := dirslot(i-o); # n² but fine if the file will be small
+ if(j < 0)
+ break Dread;
+ r := database.records[j];
+ n.reply <-= dirgen(QPATH(r.id,Qdata));
+ }
+ }
+ 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;
+}
+
+Database.build(f: ref Iobuf, locking, indexing, stats: int, updcmd: string): (ref Database, string)
+{
+ rl: list of ref Record;
+ offset := 0;
+ maxid := 0;
+ for(;;) {
+ d := array[HEADLEN] of byte;
+ n := f.read(d, HEADLEN);
+ if(n < HEADLEN)
+ break;
+ orig := s := string d;
+ if(len s != HEADLEN)
+ return (nil, "found bad header");
+ r := ref Record;
+ r.vers = 0;
+ (r.count, s) = str->toint(s, 10);
+ (r.datalen, s) = str->toint(s, 10);
+ if(s != "\n")
+ return (nil, sys->sprint("found bad header '%s'\n", orig));
+ r.offset = offset + HEADLEN;
+ offset += r.count + HEADLEN;
+ f.seek(big offset, Bufio->SEEKSTART);
+ r.id = maxid++;
+ rl = r :: rl;
+ }
+ db := ref Database(f, array[maxid] of ref Record, maxid, locking, nil, indexing, stats, -1, 0, 0, 0, 0, updcmd, 0);
+ for(i := len db.records - 1; i >= 0; i--) {
+ db.records[i] = hd rl;
+ rl = tl rl;
+ }
+ return (db, nil);
+}
+
+Database.write(db: self ref Database, recno: int, data: array of byte): int
+{
+ db.s_writes++;
+ r := db.records[recno];
+ r.vers++;
+ if(len data <= r.count) {
+ if(r.count - len data >= HEADLEN + MINSIZE)
+ splitrec(db, recno, len data);
+ writerec(db, recno, data);
+ db.file.flush();
+ } else {
+ freerec(db, recno);
+ n := allocrec(db, len data);
+ if(n == -1)
+ return -1; # BUG: we lose the original data in this case.
+ db.records[n].id = r.id;
+ db.write(n, data);
+ }
+ return 0;
+}
+
+Database.create(db: self ref Database, data: array of byte): ref Record
+{
+ db.s_creates++;
+ db.vers++;
+ n := allocrec(db, len data);
+ if(n < 0)
+ return nil;
+ if(db.write(n, data) < 0){
+ freerec(db, n);
+ return nil;
+ }
+ r := db.records[n];
+ r.id = db.maxid++;
+ return r;
+}
+
+Database.read(db: self ref Database, recno: int): array of byte
+{
+ db.s_reads++;
+ r := db.records[recno];
+ if(r.datalen <= 0)
+ return nil;
+ db.file.seek(big r.offset, Bufio->SEEKSTART);
+ d := array[r.datalen] of byte;
+ n := db.file.read(d, r.datalen);
+ if(n != r.datalen) {
+ sys->fprint(stderr, "dbfs: only read %d bytes (expected %d)\n", n, r.datalen);
+ return nil;
+ }
+ return d;
+}
+
+Database.remove(db: self ref Database, recno: int)
+{
+ db.s_removes++;
+ db.vers++;
+ freerec(db, recno);
+ db.file.flush();
+}
+
+Database.updated(db: self ref Database)
+{
+ if(db.updcmd != nil)
+ sh->system(context, db.updcmd);
+}
+
+# Locking - try to lock a record
+
+Database.lock(db: self ref Database, c: ref Styxservers->Fid): int
+{
+ if(TYPE(c.path) != Qdata || !db.locking)
+ return 1;
+ for(ll := db.locklist; ll != nil; ll = tl ll) {
+ lock := hd ll;
+ if(lock.qpath == c.path)
+ return lock.fid == c.fid;
+ }
+ db.locklist = (c.path, c.fid) :: db.locklist;
+ return 1;
+}
+
+
+# Locking - unlock a record
+
+Database.unlock(db: self ref Database, c: ref Styxservers->Fid)
+{
+ if(TYPE(c.path) != Qdata || !db.locking)
+ return;
+ ll := db.locklist;
+ db.locklist = nil;
+ for(; ll != nil; ll = tl ll){
+ lock := hd ll;
+ if(lock.qpath == c.path && lock.fid == c.fid){
+ # not replaced on list
+ }else
+ db.locklist = hd ll :: db.locklist;
+ }
+}
+
+
+# Locking - check if Fid c has the lock on its record
+
+Database.ownlock(db: self ref Database, c: ref Styxservers->Fid): int
+{
+ if(TYPE(c.path) != Qdata || !db.locking)
+ return 1;
+ for(ll := db.locklist; ll != nil; ll = tl ll) {
+ lock := hd ll;
+ if(lock.qpath == c.path)
+ return lock.fid == c.fid;
+ }
+ return 0;
+}
+
+Record.new(offset: int, length: int): ref Record
+{
+ return ref Record(-1, offset, length, -1, 0);
+}
+
+Record.qid(r: self ref Record): Qid
+{
+ return Qid(QPATH(r.id,Qdata), r.vers, Sys->QTFILE);
+}
+
+freerec(db: ref Database, recno: int)
+{
+ nr := len db.records;
+ db.records[recno].datalen = -1;
+ for(i := recno; i >= 0; i--)
+ if(db.records[i].datalen != -1)
+ break;
+ f := i + 1;
+ nb := 0;
+ for(i = f; i < nr; i++) {
+ if(db.records[i].datalen != -1)
+ break;
+ nb += db.records[i].count + HEADLEN;
+ }
+ db.records[f].count = nb - HEADLEN;
+ writeheader(db.file, db.records[f]);
+ # could blank out freed entries here if we cared.
+ if(i < nr && f < i)
+ db.records[f+1:] = db.records[i:];
+ db.records = db.records[0:nr - (i - f - 1)];
+}
+
+splitrec(db: ref Database, recno: int, pos: int)
+{
+ a := array[len db.records + 1] of ref Record;
+ a[0:] = db.records[0:recno+1];
+ if(recno < len db.records - 1)
+ a[recno+2:] = db.records[recno+1:];
+ db.records = a;
+ r := a[recno];
+ a[recno+1] = Record.new(r.offset + pos + HEADLEN, r.count - HEADLEN - pos);
+ r.count = pos;
+ writeheader(db.file, a[recno+1]);
+}
+
+writerec(db: ref Database, recno: int, data: array of byte): int
+{
+ db.records[recno].datalen = len data;
+ if(writeheader(db.file, db.records[recno]) == -1)
+ return -1;
+ if(db.file.write(data, len data) == Bufio->ERROR)
+ return -1;
+ return 0;
+}
+
+writeheader(f: ref Iobuf, r: ref Record): int
+{
+ f.seek(big r.offset - big HEADLEN, Bufio->SEEKSTART);
+ if(f.puts(sys->sprint("%4d %4d\n", r.count, r.datalen)) == Bufio->ERROR) {
+ sys->fprint(stderr, "dbfs: error writing header (id %d, offset %d, count %d, datalen %d): %r\n",
+ r.id, r.offset, r.count, r.datalen);
+ return -1;
+ }
+ return 0;
+}
+
+# finds or creates a record of the requisite size; does not mark it as allocated.
+allocrec(db: ref Database, nb: int): int
+{
+ if(nb < MINSIZE)
+ nb = MINSIZE;
+ best := -1;
+ n := -1;
+ for(i := 0; i < len db.records; i++) {
+ r := db.records[i];
+ if(r.datalen == -1) {
+ avail := r.count - nb;
+ if(avail >= 0 && (n == -1 || avail < best)) {
+ best = avail;
+ n = i;
+ }
+ }
+ }
+ if(n != -1)
+ return n;
+ nr := len db.records;
+ a := array[nr + 1] of ref Record;
+ a[0:] = db.records[0:];
+ offset := 0;
+ if(nr > 0)
+ offset = a[nr-1].offset + a[nr-1].count;
+ db.file.seek(big offset, Bufio->SEEKSTART);
+ if(db.file.write(array[nb + HEADLEN] of {* => byte(0)}, nb + HEADLEN) == Bufio->ERROR
+ || db.file.flush() == Bufio->ERROR) {
+ sys->fprint(stderr, "dbfs: write of new entry failed: %r\n");
+ return -1;
+ }
+ a[nr] = Record.new(offset + HEADLEN, nb);
+ db.records = a;
+ return nr;
+}
+
+now(fd: ref Sys->FD): int
+{
+ if(fd == nil)
+ return 0;
+ buf := array[128] of byte;
+ sys->seek(fd, big 0, 0);
+ n := sys->read(fd, buf, len buf);
+ if(n < 0)
+ return 0;
+ t := (big string buf[0:n]) / big 1000000;
+ return int t;
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 20:47:09 +0000