/*
 * Copyright (c) 1994 John S. Dyson
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice immediately at the beginning of the file, without modification,
 *    this list of conditions, and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Absolutely no warranty of function or purpose is made by the author
 *    John S. Dyson.
 * 4. Modifications may be freely made to this file if the above conditions
 *    are met.
 *
 * $Id$
 */
/*
 * THIS IS PRELIMINARY, BUGGY AND NON-WORKING CODE
 * WHEN THIS NOTICE IS REMOVED -- IT WILL WORK... :-).
 *
 * THINGS TO DO:
 *	COMMENTS, THE SYSTEM ALMOST RUNS WITH IT.  THIS IS CURRENTLY MEANT
 *	ONLY AS A PLACEHOLDER!!!
 */
#define VMIO
#include "param.h"
#include "proc.h"
#include "malloc.h"
#include "vm_param.h"
#include "vm.h"
#include "lock.h"
#include "queue.h"
#include "vm_prot.h"
#include "vm_object.h"
#include "vm_page.h"
#include "vnode_pager.h"
#include "vm_map.h"
#include "vm_pageout.h"
#include "vnode.h"
#include "uio.h"
#include "mount.h"

/* #include "buf.h" */
#include "miscfs/specfs/specdev.h"
/* #include "vmio.h" */

int vnode_pager_initialized;
extern vm_map_t pager_map;

struct buf * getpbuf();
void relpbuf(struct buf *bp);

/*
 * map an object into kva
 * return 1 if all are in memory, and 0 if any are fake.
 */
int
vmio_alloc_pages( vm_object_t object, vm_offset_t start,
		vm_offset_t size, vm_page_t *ms) {

	int pagecount;
	vm_page_t m;
	int i,j;
	int s;
	vm_offset_t kva;
	struct buf *bp;
	int ioneeded=0;
	
	pagecount = size / PAGE_SIZE;
	
	for(i=0;i<pagecount;i++) {
		vm_page_t m;
		m = vm_page_lookup( object, start + i * PAGE_SIZE);
		if( m) {
			/*
			 * See if something else has already gotten this page
			 */
			if( m->busy || (m->flags & (PG_VMIO|PG_BUSY))) {
				/*
				 * Something has the page, so we have to
				 * release all the pages we've gotten to
				 * this point, wait for the page to unbusy
				 * and then start over.
				 */
				int j;
				for(j = 0; j < i; j++) {
					vm_page_t n;
					n = ms[j];
					if( n) {
						/*
						 * unbusy the page.
						 */
						PAGE_WAKEUP(n);
						if( n->flags & PG_FAKE)
							vm_page_free(n);
					}
				}
				m->flags |= PG_WANTED;
				tsleep((caddr_t)m, PVM, "vngpwt", 0);
				return -1;
			}
			m->flags |= PG_REFERENCED;
		} else {
			m = (vm_page_t) vm_page_alloc( object,
				start + i * PAGE_SIZE);
			if( !m) {
				VM_WAIT;
				for(j=0;j<i;j++) {
					vm_page_t n;
					n = ms[j];
					if( n) {
						PAGE_WAKEUP(n);
						if( n->flags & PG_FAKE)
							vm_page_free(n);
					}
				}
				return -1;
			}
		}
		ms[i] = m;
	}
	/*
	 * hold the pages and assign them to the mapping
	 */
	for(i=0;i<pagecount;i++) {
		m = ms[i];
		vm_page_hold(m);
		if( m->flags & PG_FAKE)
			++ioneeded;

		vm_page_deactivate(m);
		if( (m->flags & PG_ACTIVE) == 0)
			vm_page_activate(m);
		m->flags |= PG_VMIO;
		m->flags &= ~PG_BUSY;
		++m->act_count;
		pmap_page_protect( VM_PAGE_TO_PHYS(m), VM_PROT_READ);
	}
	return ioneeded;

}

void
vmio_rawiodone( struct buf *bp) {
	int s;
	int i;
	vm_object_t object;
	vm_page_t m;

	if( bp->b_bufsize != bp->b_bcount)
		bzero( bp->b_data + bp->b_bcount, bp->b_bufsize - bp->b_bcount);
	printf("rawdone: (blk: %d, count: %d)\n",
		bp->b_blkno, bp->b_bcount);
	s = splbio();
	object = bp->b_pages[0]->object;
	for( i = 0; i < bp->b_npages; i++) {
		m = bp->b_pages[i];
		if( m) {
			--m->busy;
			if( m->busy == 0) {
				m->flags |= PG_CLEAN;
				m->flags &= ~(PG_LAUNDRY|PG_FAKE);
				PAGE_WAKEUP(m);
			}
		} else {
			panic("vmio_rawiodone: page is gone!!!");
		}
	}
	HOLDRELE(bp->b_vp);
	relpbuf(bp);
	--object->paging_in_progress;
	if( object->paging_in_progress == 0)
		wakeup((caddr_t)object);
	splx(s);
	return;
}

void
vmio_get_pager(struct vnode *vp) {
	if( vp->v_type == VREG) {
		vm_object_t object;
		vm_pager_t pager;
		if((vp->v_vmdata == NULL) || (vp->v_flag & VVMIO) == 0) {
			pager = (vm_pager_t) vnode_pager_alloc(vp, 0, 0, 0);
			object = (vm_object_t) vp->v_vmdata;
			if( object->pager != pager)
				panic("vmio_get_pager: pager/object mismatch");
			(void) vm_object_lookup( pager);
			pager_cache( object, TRUE);
			vp->v_flag |= VVMIO;
		} else {
			object = (vm_object_t) vp->v_vmdata;
			pager = object->pager;
			if( pager == NULL) {
				panic("vmio_get_pager: pager missing");
			}
			(void) vm_object_lookup( pager);
		}
	}
}

void
vmio_free_pager( struct vnode *vp) {
	if( vp->v_vmdata == NULL)
		panic("vmio_free_pager: object missing");
	vm_object_deallocate( (vm_object_t) vp->v_vmdata);
}

void
vmio_aread( struct buf *lbp) {
	struct vnode *vp, *dp;
	vm_object_t object;
	vm_offset_t offset;
	vm_offset_t size;
	vm_offset_t off;
	int forcemore;
	int runp;
	int s;

	s = splbio();
	vp = lbp->b_vp;
	object = (vm_object_t) vp->v_vmdata;
	offset = trunc_page(lbp->b_lblkno * vp->v_mount->mnt_stat.f_iosize);
	size = round_page(lbp->b_bcount);
	forcemore = 0;
	printf("queueing read: iosize: %d, b_lblkno: %d, offset: %d, size: %d:",
		vp->v_mount->mnt_stat.f_iosize,
		lbp->b_lblkno, offset, size);

	for(off = 0; off < size; ) {
		vm_offset_t curoff;
		int pgidx, pgcnt, i;
		struct buf *bp;
		pgidx = off / PAGE_SIZE;
		if( !forcemore) {
			while( (off < size) &&
				(lbp->b_pages[pgidx]->flags & PG_FAKE) == 0) {
				off = trunc_page(off) + PAGE_SIZE;
				pgidx += 1;
			}
		}
		if( off >= size)
			break;
		bp = getpbuf();

		++object->paging_in_progress;

		curoff = offset + off;
		VOP_BMAP( vp, curoff / vp->v_mount->mnt_stat.f_iosize,
			&dp, &bp->b_blkno, &runp);
		
		bp->b_bcount = (runp + 1) * vp->v_mount->mnt_stat.f_iosize;
		if( off + bp->b_bcount > size)
			bp->b_bcount = size - off;
		bp->b_bufsize = round_page(bp->b_bcount);
			
		pgcnt = bp->b_bufsize / PAGE_SIZE;
		for(i=0;i<pgcnt;i++) {
			++lbp->b_pages[pgidx+i]->busy;
			bp->b_pages[i] = lbp->b_pages[pgidx+i];
			bp->b_pages[i]->flags |= PG_BUSY;
		}
		bp->b_npages = pgcnt;
		pmap_qenter((vm_offset_t) bp->b_data, &lbp->b_pages[pgidx], pgcnt);
		bp->b_data += curoff - trunc_page(curoff);
		off += bp->b_bcount;
		if( off & (PAGE_SIZE - 1))
			forcemore = 1;
		else
			forcemore = 0;
		/*
		 * round up physical size for real devices
		 */
		if( dp->v_type == VBLK || dp->v_type == VCHR) {
			bp->b_bcount = (bp->b_bcount + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
		}
		/*
		 * and map the pages to be read into the kva
		 */
		VHOLD(vp);
		/* build a minimal buffer header */
		bp->b_flags = B_BUSY | B_READ | B_CALL | B_ASYNC;
		bp->b_iodone = vmio_rawiodone;
		/* B_PHYS is not set, but it is nice to fill this in */
		bp->b_proc = curproc;
		bp->b_rcred = bp->b_wcred = bp->b_proc->p_ucred;
		if( bp->b_rcred != NOCRED)
			crhold(bp->b_rcred);
		if( bp->b_wcred != NOCRED)
			crhold(bp->b_wcred);
		bp->b_lblkno = bp->b_blkno;
/*		bp->b_vp = dp; */
		bgetvp( dp, bp);
		printf(" p: (blk: %d, coff: %d, off: %d, count: %d)",
			bp->b_blkno, curoff, off, bp->b_bcount);

		/* Should be a BLOCK or character DEVICE if we get here */
		bp->b_dev = dp->v_rdev;

		/* do the input */
		VOP_STRATEGY(bp);
	}
	printf("\n");
	splx(s);
}

int
vmio_getblk( struct buf *bp) {
	struct vnode *vp;
	vm_object_t object;
	vm_offset_t offset;
	vm_offset_t size;
	vm_page_t ms[(MAXBSIZE + PAGE_SIZE - 1)/PAGE_SIZE];
	int rtval;

	vp = bp->b_vp;
	if( (object = (vm_object_t) vp->v_vmdata) == NULL)
		panic("vmio_build_bp: object missing");

	offset = trunc_page(bp->b_lblkno * vp->v_mount->mnt_stat.f_iosize);
	size = round_page(bp->b_bcount);
	printf("vmio_getblk: off:%d(0x%x) blk: %d, size: %d",
		offset, offset, bp->b_lblkno, size);
		
	bp->b_flags &= ~B_CACHE;
	if( (rtval = vmio_alloc_pages( object, offset, size, ms)) == 0) {
		bp->b_flags |= B_CACHE;
		printf("(cached)\n");
	} else {
		printf("(ioneeded:%d)\n", rtval);
	}

	if( rtval < 0) {
		printf("vmio_getblk: vmio_alloc_pages busy\n");
		return 0;
	}

	bp->b_npages = size / PAGE_SIZE;
	pmap_qenter((vm_offset_t) bp->b_data, ms, bp->b_npages);
	bp->b_flags |= B_VMIO;
	bp->b_bufsize = size;
	bcopy( ms, bp->b_pages, bp->b_npages * sizeof(vm_page_t));
	return 1;
}

int
vmio_biowait( struct buf *lbp) {
	int i;
	int s;
	printf("vmio_biowait -->");
restart:
	s = splbio();
	for(i=lbp->b_npages-1;i >= 0; --i) {
		if( lbp->b_pages[i]->busy || (lbp->b_pages[i]->flags & PG_BUSY)) {
			lbp->b_pages[i]->flags |= PG_WANTED;
			printf(" waiting on page %d of xfer at %d, flags: 0x%x\n",
				i, lbp->b_blkno, lbp->b_pages[i]->flags);
			tsleep( (caddr_t) lbp->b_pages[i], PVM, "vbiowt", 0);
			splx(s);
			goto restart;
		}
	}
	splx(s);
	printf("vmio_biowait: finished\n");
	return 1;
}

void
vmio_brelse( struct buf *lbp) {
	int i;
	int nfullpages = lbp->b_bcount / PAGE_SIZE;
	pmap_qremove((vm_offset_t) lbp->b_data, lbp->b_npages);
	for(i=0;i<lbp->b_npages;i++) {
		if( (i < nfullpages) && ((lbp->b_flags & B_DELWRI) == 0))
			lbp->b_pages[i]->flags |= PG_CLEAN;
		if( lbp->b_flags & B_DELWRI)
			lbp->b_pages[i]->flags &= ~PG_CLEAN;
		lbp->b_pages[i]->flags &= ~PG_VMIO;
		vm_page_unhold(lbp->b_pages[i]);
		PAGE_WAKEUP(lbp->b_pages[i]);
	}
	lbp->b_flags &= ~B_VMIO;
	lbp->b_flags |= B_INVAL;
	lbp->b_bufsize = 0;
}