ref: 511421003a44633d8907828aef280acc762cc56b
dir: /sys/src/cmd/cwfs/dentry.c/
#include "all.h"
Dentry*
getdir(Iobuf *p, int slot)
{
if(!p)
return 0;
return (Dentry*)p->iobuf + slot%DIRPERBUF;
}
void
accessdir(Iobuf *p, Dentry *d, int f, int uid)
{
Timet t;
if(p == nil || p->dev->type == Devro)
return;
f &= FREAD|FWRITE;
if(f != FWRITE && noatime)
return;
p->flags |= Bmod;
t = time(nil);
d->atime = t;
if(f & FWRITE){
d->mtime = t;
d->muid = uid;
d->qid.version++;
}
}
void
preread(Device *d, Off addr)
{
Rabuf *rb;
if(addr == 0)
return;
if(raheadq->count+10 >= raheadq->size) /* ugly knowing layout */
return;
lock(&rabuflock);
rb = rabuffree;
if(rb == 0) {
unlock(&rabuflock);
return;
}
rabuffree = rb->link;
unlock(&rabuflock);
rb->dev = d;
rb->addr = addr;
fs_send(raheadq, rb);
}
Off
rel2abs(Iobuf *p, Dentry *d, Off a, int tag, int putb, int uid)
{
int i;
Off addr, qpath, indaddrs = 1, div;
Device *dev;
if(a < 0) {
fprint(2, "rel2abs: neg offset\n");
if(putb)
putbuf(p);
return 0;
}
dev = p->dev;
qpath = d->qid.path;
if(d->mode & DDIR)
qpath ^= QPDIR;
/* is `a' a direct block? */
if(a < NDBLOCK) {
addr = d->dblock[a];
if(!addr && tag) {
addr = bufalloc(dev, tag, qpath, uid);
d->dblock[a] = addr;
p->flags |= Bmod|Bimm;
}
if(putb)
putbuf(p);
return addr;
}
a -= NDBLOCK;
/*
* loop through indirect block depths.
*/
for (i = 0; i < NIBLOCK; i++) {
indaddrs *= INDPERBUF;
/* is a's disk addr in this indir block or one of its kids? */
if (a < indaddrs) {
addr = d->iblocks[i];
if(!addr && tag) {
addr = bufalloc(dev, Tind1+i, qpath, uid);
d->iblocks[i] = addr;
p->flags |= Bmod|Bimm;
}
if(putb)
putbuf(p);
div = indaddrs;
for (; i >= 0; i--) {
div /= INDPERBUF;
if (div <= 0)
panic("rel2abs: non-positive divisor");
addr = indfetch(dev, qpath, addr,
(a/div)%INDPERBUF, Tind1+i,
(i == 0? tag: Tind1+i-1), uid);
}
return addr;
}
a -= indaddrs;
}
if(putb)
putbuf(p);
/* quintuple-indirect blocks not implemented. */
fprint(2, "rel2abs: no %d-deep indirect\n", NIBLOCK+1);
return 0;
}
/*
* read-ahead strategy
* on second block, read RAGAP blocks,
* thereafter, read RAGAP ahead of current pos
*/
Off
dbufread(Iobuf *p, Dentry *d, Off a, Off ra, int uid)
{
Off addr;
if(a == 0)
return 1;
if(a == 1 && ra == 1) {
while(ra < a+RAGAP) {
ra++;
addr = rel2abs(p, d, ra, 0, 0, uid);
if(!addr)
return 0;
preread(p->dev, addr);
}
return ra+1;
}
if(ra == a+RAGAP) {
addr = rel2abs(p, d, ra, 0, 0, uid);
if(!addr)
return 0;
preread(p->dev, addr);
return ra+1;
}
return ra;
}
Iobuf*
dnodebuf(Iobuf *p, Dentry *d, Off a, int tag, int uid)
{
Off addr;
addr = rel2abs(p, d, a, tag, 0, uid);
if(addr)
return getbuf(p->dev, addr, Brd);
return 0;
}
/*
* same as dnodebuf but it calls putbuf(p)
* to reduce interference.
*/
Iobuf*
dnodebuf1(Iobuf *p, Dentry *d, Off a, int tag, int uid)
{
Off addr;
Device *dev;
dev = p->dev;
addr = rel2abs(p, d, a, tag, 1, uid);
if(addr)
return getbuf(dev, addr, Brd);
return 0;
}
Off
indfetch(Device* d, Off qpath, Off addr, Off a, int itag, int tag, int uid)
{
Iobuf *bp;
if(!addr)
return 0;
bp = getbuf(d, addr, Brd);
if(!bp || checktag(bp, itag, qpath)) {
if(!bp) {
fprint(2, "ind fetch bp = 0\n");
return 0;
}
fprint(2, "ind fetch tag\n");
putbuf(bp);
return 0;
}
addr = ((Off *)bp->iobuf)[a];
if(!addr && tag) {
addr = bufalloc(d, tag, qpath, uid);
if(addr) {
((Off *)bp->iobuf)[a] = addr;
bp->flags |= Bmod;
if(tag == Tdir)
bp->flags |= Bimm;
settag(bp, itag, qpath);
}
}
putbuf(bp);
return addr;
}
/* return INDPERBUF^exp */
Off
ibbpow(int exp)
{
static Off pows[] = {
1,
INDPERBUF,
(Off)INDPERBUF*INDPERBUF,
(Off)INDPERBUF*(Off)INDPERBUF*INDPERBUF,
(Off)INDPERBUF*(Off)INDPERBUF*(Off)INDPERBUF*INDPERBUF,
};
if (exp < 0)
return 0;
else if (exp >= nelem(pows)) { /* not in table? do it long-hand */
Off indpow = 1;
while (exp-- > 0 && indpow > 0)
indpow *= INDPERBUF;
return indpow;
} else
return pows[exp];
}
/* return sum of INDPERBUF^n for 1 ≤ n ≤ exp */
Off
ibbpowsum(int exp)
{
Off indsum = 0;
for (; exp > 0; exp--)
indsum += ibbpow(exp);
return indsum;
}
/* zero bytes past new file length; return an error code */
int
trunczero(Truncstate *ts)
{
int blkoff = ts->newsize % BUFSIZE;
Iobuf *pd;
pd = dnodebuf(ts->p, ts->d, ts->lastblk, Tfile, ts->uid);
if (pd == nil || checktag(pd, Tfile, QPNONE)) {
if (pd != nil)
putbuf(pd);
ts->err = Ephase;
return Ephase;
}
memset(pd->iobuf+blkoff, 0, BUFSIZE - blkoff);
putbuf(pd);
return 0;
}
/*
* truncate d (in p) to length `newsize'.
* if larger, just increase size.
* if smaller, deallocate blocks after last one
* still in file at new size. last byte to keep
* is newsize-1, due to zero origin.
* we free in forward order because it's simpler to get right.
* if the final block at the new size is partially-filled,
* zero the remainder.
*/
int
dtrunclen(Iobuf *p, Dentry *d, Off newsize, int uid)
{
int i, pastlast;
Truncstate trunc;
if (newsize <= 0) {
dtrunc(p, d, uid);
return 0;
}
memset(&trunc, 0, sizeof trunc);
trunc.d = d;
trunc.p = p;
trunc.uid = uid;
trunc.newsize = newsize;
trunc.lastblk = newsize/BUFSIZE;
if (newsize % BUFSIZE == 0)
trunc.lastblk--;
else
trunczero(&trunc);
for (i = 0; i < NDBLOCK; i++)
if (trunc.pastlast) {
trunc.relblk = i;
buffree(p->dev, d->dblock[i], 0, &trunc);
d->dblock[i] = 0;
} else if (i == trunc.lastblk)
trunc.pastlast = 1;
trunc.relblk = NDBLOCK;
for (i = 0; i < NIBLOCK; i++) {
pastlast = trunc.pastlast;
buffree(p->dev, d->iblocks[i], i+1, &trunc);
if (pastlast)
d->iblocks[i] = 0;
}
d->size = newsize;
p->flags |= Bmod|Bimm;
accessdir(p, d, FWRITE, uid);
return trunc.err;
}
/*
* truncate d (in p) to zero length.
* freeing blocks in reverse order is traditional, from Unix,
* in an attempt to keep the free list contiguous.
*/
void
dtrunc(Iobuf *p, Dentry *d, int uid)
{
int i;
for (i = NIBLOCK-1; i >= 0; i--) {
buffree(p->dev, d->iblocks[i], i+1, nil);
d->iblocks[i] = 0;
}
for (i = NDBLOCK-1; i >= 0; i--) {
buffree(p->dev, d->dblock[i], 0, nil);
d->dblock[i] = 0;
}
d->size = 0;
p->flags |= Bmod|Bimm;
accessdir(p, d, FWRITE, uid);
}