ref: db46e826c23973ee2cdc93a2fcbe465fc022d0ff
dir: /sys/src/cmd/cfs/file.c/
#include <u.h>
#include <libc.h>
#include "cformat.h"
#include "lru.h"
#include "bcache.h"
#include "disk.h"
#include "inode.h"
#include "file.h"
/*
* merge data with that which already exists in a block
*
* we allow only one range per block, always use the new
* data if the ranges don't overlap.
*/
void
fmerge(Dptr *p, char *to, char *from, int start, int len)
{
int end;
end = start + len;
memmove(to+start, from, end-start);
/*
* if ranges do not overlap...
*/
if(start>p->end || p->start>end){
/*
* just use the new data
*/
p->start = start;
p->end = end;
} else {
/*
* merge ranges
*/
if(start < p->start)
p->start = start;
if(end > p->end)
p->end = end;
}
}
/*
* write a block (or less) of data onto a disk, follow it with any necessary
* pointer writes.
*
* N.B. ordering is everything
*/
int
fbwrite(Icache *ic, Ibuf *b, char *a, ulong off, int len)
{
int wrinode;
ulong fbno;
Bbuf *dbb; /* data block */
Bbuf *ibb; /* indirect block */
Dptr *p;
Dptr t;
fbno = off / ic->bsize;
p = &b->inode.ptr;
ibb = 0;
wrinode = 0;
/*
* are there any pages for this inode?
*/
if(p->bno == Notabno){
wrinode = 1;
goto dowrite;
}
/*
* is it an indirect block?
*/
if(p->bno & Indbno){
ibb = bcread(ic, p->bno);
if(ibb == 0)
return -1;
p = (Dptr*)ibb->data;
p += fbno % ic->p2b;
goto dowrite;
}
/*
* is it the wrong direct block?
*/
if((p->fbno%ic->p2b) != (fbno%ic->p2b)){
/*
* yes, make an indirect block
*/
t = *p;
dpalloc(ic, p);
if(p->bno == Notabno){
*p = t;
return -1;
}
ibb = bcalloc(ic, p->bno);
if(ibb == 0){
*p = t;
return -1;
}
p = (Dptr*)ibb->data;
p += t.fbno % ic->p2b;
*p = t;
p = (Dptr*)ibb->data;
p += fbno % ic->p2b;
}
wrinode = 1;
dowrite:
/*
* get the data block into the block cache
*/
if(p->bno == Notabno){
/*
* create a new block
*/
dalloc(ic, p);
if(p->bno == Notabno)
return -1; /* no blocks left (maybe) */
dbb = bcalloc(ic, p->bno);
} else {
/*
* use what's there
*/
dbb = bcread(ic, p->bno);
}
if(dbb == 0)
return -1;
/*
* merge in the new data
*/
if(p->fbno != fbno){
p->start = p->end = 0;
p->fbno = fbno;
}
fmerge(p, dbb->data, a, off % ic->bsize, len);
/*
* write changed blocks back in the
* correct order
*/
bcmark(ic, dbb);
if(ibb)
bcmark(ic, ibb);
if(wrinode)
if(iwrite(ic, b) < 0)
return -1;
return len;
}
/*
* write `n' bytes to the cache
*
* return number of bytes written
*/
long
fwrite(Icache *ic, Ibuf *b, char *a, ulong off, long n)
{
int len;
long sofar;
for(sofar = 0; sofar < n; sofar += len){
len = ic->bsize - ((off+sofar)%ic->bsize);
if(len > n - sofar)
len = n - sofar;
if(fbwrite(ic, b, a+sofar, off+sofar, len) < 0)
return sofar;
}
return sofar;
}
/*
* get a pointer to the next valid data at or after `off'
*/
Dptr *
fpget(Icache *ic, Ibuf *b, ulong off)
{
ulong fbno;
long doff;
Bbuf *ibb; /* indirect block */
Dptr *p, *p0, *pf;
fbno = off / ic->bsize;
p = &b->inode.ptr;
/*
* are there any pages for this inode?
*/
if(p->bno == Notabno)
return 0;
/*
* if it's a direct block, life is easy?
*/
if(!(p->bno & Indbno)){
/*
* a direct block, return p if it's at least past what we want
*/
if(p->fbno > fbno)
return p;
if(p->fbno < fbno)
return 0;
doff = off % ic->bsize;
if(doff>=p->start && doff<p->end)
return p;
else
return 0;
}
/*
* read the indirect block
*/
ibb = bcread(ic, p->bno);
if(ibb == 0)
return 0;
/*
* find the next valid pointer
*/
p0 = (Dptr*)ibb->data;
pf = p0 + (fbno % ic->p2b);
if(pf->bno!=Notabno && pf->fbno==fbno){
doff = off % ic->bsize;
if(doff<pf->end)
return pf;
}
for(p = pf+1; p < p0 + ic->p2b; p++){
fbno++;
if(p->fbno==fbno && p->bno!=Notabno && p->start<p->end)
return p;
}
for(p = p0; p < pf; p++){
fbno++;
if(p->fbno==fbno && p->bno!=Notabno && p->start<p->end)
return p;
}
return 0;
}
/*
* read `n' bytes from the cache.
*
* if we hit a gap and we've read something,
* return number of bytes read so far.
*
* if we start with a gap, return minus the number of bytes
* to the next data.
*
* if there are no bytes cached, return 0.
*/
long
fread(Icache *ic, Ibuf *b, char *a, ulong off, long n)
{
int len, start;
long sofar, gap;
Dptr *p;
Bbuf *bb;
for(sofar = 0; sofar < n; sofar += len, off += len){
/*
* get pointer to next data
*/
len = n - sofar;
p = fpget(ic, b, off);
/*
* if no more data, return what we have so far
*/
if(p == 0)
return sofar;
/*
* if there's a gap, return the size of the gap
*/
gap = (ic->bsize*p->fbno + p->start) - off;
if(gap>0)
if(sofar == 0)
return -gap;
else
return sofar;
/*
* return what we have
*/
bb = bcread(ic, p->bno);
if(bb == 0)
return sofar;
start = p->start - gap;
if(p->end - start < len)
len = p->end - start;
memmove(a + sofar, bb->data + start, len);
}
return sofar;
}