static int
ao_get(struct uvm_object *uobj, voff_t off, struct vm_page **pgs,
int *npages, int centeridx, vm_prot_t access_type,
int advice, int flags)
{
struct vm_page *pg;
int i;
if (centeridx)
panic("%s: centeridx != 0 not supported", __func__);
/* loop over pages */
off = trunc_page(off);
for (i = 0; i < *npages; i++) {
retrylookup:
pg = uvm_pagelookup(uobj, off + (i << PAGE_SHIFT));
if (pg) {
if (pg->flags & PG_BUSY) {
pg->flags |= PG_WANTED;
UVM_UNLOCK_AND_WAIT(pg, &uobj->vmobjlock, 0,
"aogetpg", 0);
goto retrylookup;
}
pg->flags |= PG_BUSY;
pgs[i] = pg;
} else {
pg = rumpvm_makepage(uobj, off + (i << PAGE_SHIFT));
pgs[i] = pg;
}
}
mutex_exit(&uobj->vmobjlock);
return 0;
}
/*
* miscfs/genfs getpages routine. This is a fair bit simpler than the
* kernel counterpart since we're not being executed from a fault handler
* and generally don't need to care about PGO_LOCKED or other cruft.
* We do, however, need to care about page locking and we keep trying until
* we get all the pages within the range. The object locking protocol
* is the same as for the kernel: enter with the object lock held,
* return with it released.
*/
int
genfs_getpages(void *v)
{
struct vop_getpages_args /* {
struct vnode *a_vp;
voff_t a_offset;
struct vm_page **a_m;
int *a_count;
int a_centeridx;
vm_prot_t a_access_type;
int a_advice;
int a_flags;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct uvm_object *uobj = (struct uvm_object *)vp;
struct vm_page *pg;
voff_t curoff, endoff;
off_t diskeof;
size_t bufsize, remain, bufoff, xfersize;
uint8_t *tmpbuf;
int bshift = vp->v_mount->mnt_fs_bshift;
int bsize = 1<<bshift;
int count = *ap->a_count;
int async;
int i, error;
/*
* Ignore async for now, the structure of this routine
* doesn't exactly allow for it ...
*/
async = 0;
if (ap->a_centeridx != 0)
panic("%s: centeridx != not supported", __func__);
if (ap->a_access_type & VM_PROT_WRITE)
vp->v_iflag |= VI_ONWORKLST;
curoff = ap->a_offset & ~PAGE_MASK;
for (i = 0; i < count; i++, curoff += PAGE_SIZE) {
retrylookup:
pg = uvm_pagelookup(uobj, curoff);
if (pg == NULL)
break;
/* page is busy? we need to wait until it's released */
if (pg->flags & PG_BUSY) {
pg->flags |= PG_WANTED;
UVM_UNLOCK_AND_WAIT(pg, &uobj->vmobjlock, 0, "getpg",0);
mutex_enter(&uobj->vmobjlock);
goto retrylookup;
}
pg->flags |= PG_BUSY;
if (pg->flags & PG_FAKE)
break;
ap->a_m[i] = pg;
}
/* got everything? if so, just return */
if (i == count) {
mutex_exit(&uobj->vmobjlock);
return 0;
}
/*
* didn't? Ok, allocate backing pages. Start from the first
* one we missed.
*/
for (; i < count; i++, curoff += PAGE_SIZE) {
retrylookup2:
pg = uvm_pagelookup(uobj, curoff);
/* found? busy it and be happy */
if (pg) {
if (pg->flags & PG_BUSY) {
pg->flags = PG_WANTED;
UVM_UNLOCK_AND_WAIT(pg, &uobj->vmobjlock, 0,
"getpg2", 0);
mutex_enter(&uobj->vmobjlock);
goto retrylookup2;
} else {
pg->flags |= PG_BUSY;
}
/* not found? make a new page */
} else {
pg = rumpvm_makepage(uobj, curoff);
}
ap->a_m[i] = pg;
}
/*
* We have done all the clerical work and have all pages busied.
* Release the vm object for other consumers.
*/
mutex_exit(&uobj->vmobjlock);
/*
* Now, we have all the pages here & busy. Transfer the range
* starting from the missing offset and transfer into the
* page buffers.
*/
GOP_SIZE(vp, vp->v_size, &diskeof, 0);
/* align to boundaries */
endoff = trunc_page(ap->a_offset) + (count << PAGE_SHIFT);
endoff = MIN(endoff, ((vp->v_writesize+bsize-1) & ~(bsize-1)));
curoff = ap->a_offset & ~(MAX(bsize,PAGE_SIZE)-1);
remain = endoff - curoff;
if (diskeof > curoff)
remain = MIN(remain, diskeof - curoff);
DPRINTF(("a_offset: %llx, startoff: 0x%llx, endoff 0x%llx\n",
(unsigned long long)ap->a_offset, (unsigned long long)curoff,
(unsigned long long)endoff));
/* read everything into a buffer */
bufsize = round_page(remain);
tmpbuf = kmem_zalloc(bufsize, KM_SLEEP);
for (bufoff = 0; remain; remain -= xfersize, bufoff+=xfersize) {
struct buf *bp;
struct vnode *devvp;
daddr_t lbn, bn;
int run;
lbn = (curoff + bufoff) >> bshift;
/* XXX: assume eof */
error = VOP_BMAP(vp, lbn, &devvp, &bn, &run);
if (error)
panic("%s: VOP_BMAP & lazy bum: %d", __func__, error);
DPRINTF(("lbn %d (off %d) -> bn %d run %d\n", (int)lbn,
(int)(curoff+bufoff), (int)bn, run));
xfersize = MIN(((lbn+1+run)<<bshift)-(curoff+bufoff), remain);
/* hole? */
if (bn == -1) {
memset(tmpbuf + bufoff, 0, xfersize);
continue;
}
bp = getiobuf(vp, true);
bp->b_data = tmpbuf + bufoff;
bp->b_bcount = xfersize;
bp->b_blkno = bn;
bp->b_lblkno = 0;
bp->b_flags = B_READ;
bp->b_cflags = BC_BUSY;
if (async) {
bp->b_flags |= B_ASYNC;
bp->b_iodone = uvm_aio_biodone;
}
VOP_STRATEGY(devvp, bp);
if (bp->b_error)
panic("%s: VOP_STRATEGY, lazy bum", __func__);
if (!async)
putiobuf(bp);
}
/* skip to beginning of pages we're interested in */
bufoff = 0;
while (round_page(curoff + bufoff) < trunc_page(ap->a_offset))
bufoff += PAGE_SIZE;
DPRINTF(("first page offset 0x%x\n", (int)(curoff + bufoff)));
for (i = 0; i < count; i++, bufoff += PAGE_SIZE) {
/* past our prime? */
if (curoff + bufoff >= endoff)
break;
pg = uvm_pagelookup(&vp->v_uobj, curoff + bufoff);
KASSERT(pg);
DPRINTF(("got page %p (off 0x%x)\n", pg, (int)(curoff+bufoff)));
if (pg->flags & PG_FAKE) {
memcpy((void *)pg->uanon, tmpbuf+bufoff, PAGE_SIZE);
pg->flags &= ~PG_FAKE;
pg->flags |= PG_CLEAN;
}
ap->a_m[i] = pg;
}
*ap->a_count = i;
kmem_free(tmpbuf, bufsize);
return 0;
}
