bio.c

// Buffer cache.
//
// The buffer cache is a linked list of buf structures holding
// cached copies of disk block contents.  Caching disk blocks
// in memory reduces the number of disk reads and also provides
// a synchronization point for disk blocks used by multiple processes.
// 
// Interface:
// * To get a buffer for a particular disk block, call bread.
// * After changing buffer data, call bwrite to write it to disk.
// * When done with the buffer, call brelse.
// * Do not use the buffer after calling brelse.
// * Only one process at a time can use a buffer,
//     so do not keep them longer than necessary.
// 
// The implementation uses three state flags internally:
// * B_BUSY: the block has been returned from bread
//     and has not been passed back to brelse.  
// * B_VALID: the buffer data has been read from the disk.
// * B_DIRTY: the buffer data has been modified
//     and needs to be written to disk.

#include "types.h"
#include "defs.h"
#include "param.h"
#include "spinlock.h"
#include "fs.h"
#include "buf.h"
#include "errstr.h"
#include "file.h"
#include "x86.h"
#include "mmu.h"
#include "proc.h"

struct {
	struct spinlock lock;
	struct buf buf[NBUF];

	// Linked list of all buffers, through prev/next.
	// head.next is most recently used.
	struct buf head;
} bcache;

int bdisk_read(struct inode*, char*, int, int);
int bdisk_write(struct inode*, char*, int, int);

void
binit(void)
{
	struct buf *b;

	initlock(&bcache.lock, "bcache");

//PAGEBREAK!
	cprintf("cpu%d: system: starting bcache\n", cpu->id);
	// Create linked list of buffers
	bcache.head.prev = &bcache.head;
	bcache.head.next = &bcache.head;
	for(b = bcache.buf; b < bcache.buf+NBUF; b++){
		b->next = bcache.head.next;
		b->prev = &bcache.head;
		b->dev = -1;
		bcache.head.next->prev = b;
		bcache.head.next = b;
	}
	devsw[7].read = bdisk_read;
	devsw[7].write = bdisk_write;
}

// Look through buffer cache for block on device dev.
// If not found, allocate a buffer.
// In either case, return B_BUSY buffer.
static struct buf*
bget(uint dev, uint blockno)
{
	struct buf *b;

	acquire(&bcache.lock);

 loop:
	// Is the block already cached?
	for(b = bcache.head.next; b != &bcache.head; b = b->next){
		if(b->dev == dev && b->blockno == blockno){
			if(!(b->flags & B_BUSY)){
				b->flags |= B_BUSY;
				release(&bcache.lock);
				return b;
			}
			sleep(b, &bcache.lock);
			goto loop;
		}
	}

	// Not cached; recycle some non-busy and clean buffer.
	// "clean" because B_DIRTY and !B_BUSY means log.c
	// hasn't yet committed the changes to the buffer.
	for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
		if((b->flags & B_BUSY) == 0 && (b->flags & B_DIRTY) == 0){
			b->dev = dev;
			b->blockno = blockno;
			b->flags = B_BUSY;
			release(&bcache.lock);
			return b;
		}
	}
	panic("bget: no buffers");
}

// Return a B_BUSY buf with the contents of the indicated block.
struct buf*
bread(uint dev, uint blockno)
{
	struct buf *b;

	b = bget(dev, blockno);
	if(!(b->flags & B_VALID)) {
		diskrw(b);
	}
	return b;
}

// Write b's contents to disk.  Must be B_BUSY.
void
bwrite(struct buf *b)
{
	if((b->flags & B_BUSY) == 0)
		panic("bwrite");
	b->flags |= B_DIRTY;
	diskrw(b);
}

// Release a B_BUSY buffer.
// Move to the head of the MRU list.
void
brelse(struct buf *b)
{
	if((b->flags & B_BUSY) == 0)
		panic("brelse");

	acquire(&bcache.lock);

	b->next->prev = b->prev;
	b->prev->next = b->next;
	b->next = bcache.head.next;
	b->prev = &bcache.head;
	bcache.head.next->prev = b;
	bcache.head.next = b;

	b->flags &= ~B_BUSY;
	wakeup(b);

	release(&bcache.lock);
}
//PAGEBREAK!
// Blank page.

//TODO: implement bdisk_read, bdisk_write, and bdisk_init to allow reads and writes
//TODO: to disks.

// oddities with bdisk_*: They can only read or write a block at a time. The reasons
// for this are a) i'm only going to do block i/o with it and b) its a slight pita to
// do anything else. I'll probably change this in the future.
int
bdisk_read(struct inode *ip, char *bf, int nbytes, int off)
{
	struct buf *b;
	uint bnum, boff, dev;
	char *src;

	dev = ip->minor;
	bnum = off/BSIZE;
	boff = off%BSIZE;
	if(boff+nbytes > BSIZE){
		seterr(EDTOOLONG);
		return -1;
	}
	b = bread(dev, bnum);
	if(!(b->flags & B_VALID)){
		seterr(EDNOTEXIST);
		return -1;
	}
	src = (char*)((b->data)+boff);
	memmove(bf, src, nbytes);
	brelse(b);
	return nbytes;
}

int
bdisk_write(struct inode *ip, char *bf, int nbytes, int off)
{
	struct buf *b;
	uint bnum, boff, dev;
	char *dst;

	dev = ip->minor;
	bnum = off/BSIZE;
	boff = off%BSIZE;
	if(boff+nbytes > BSIZE){
		seterr(EDTOOLONG);
		return -1;
	}
	b = bread(dev, bnum);
	if(!(b->flags & B_VALID)){
		seterr(EDNOTEXIST);
		return -1;
	}
	dst = (char*)((b->data)+boff);
	memmove(dst, bf, nbytes);
	bwrite(b);
	brelse(b);
	return nbytes;
}