Home | History | Annotate | Line # | Download | only in rumpkern
vm.c revision 1.20 
      1 /*	$NetBSD: vm.c,v 1.20 2007/10/31 15:57:21 pooka Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2007 Antti Kantee.  All Rights Reserved.
      5  *
      6  * Development of this software was supported by Google Summer of Code.
      7  *
      8  * Redistribution and use in source and binary forms, with or without
      9  * modification, are permitted provided that the following conditions
     10  * are met:
     11  * 1. Redistributions of source code must retain the above copyright
     12  *    notice, this list of conditions and the following disclaimer.
     13  * 2. Redistributions in binary form must reproduce the above copyright
     14  *    notice, this list of conditions and the following disclaimer in the
     15  *    documentation and/or other materials provided with the distribution.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     20  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     23  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     27  * SUCH DAMAGE.
     28  */
     29 
     30 /*
     31  * Virtual memory emulation routines.  Contents:
     32  *  + UBC
     33  *  + anon objects & pager
     34  *  + vnode objects & pager
     35  *  + misc support routines
     36  *  + kmem
     37  */
     38 
     39 /*
     40  * XXX: we abuse pg->uanon for the virtual address of the storage
     41  * for each page.  phys_addr would fit the job description better,
     42  * except that it will create unnecessary lossage on some platforms
     43  * due to not being a pointer type.
     44  */
     45 
     46 #include <sys/param.h>
     47 #include <sys/null.h>
     48 #include <sys/vnode.h>
     49 #include <sys/buf.h>
     50 #include <sys/kmem.h>
     51 
     52 #include <uvm/uvm.h>
     53 #include <uvm/uvm_prot.h>
     54 #include <uvm/uvm_readahead.h>
     55 
     56 #include <machine/pmap.h>
     57 
     58 #include "rump_private.h"
     59 #include "rumpuser.h"
     60 
     61 /* dumdidumdum */
     62 #define len2npages(off, len)						\
     63   (((((len) + PAGE_MASK) & ~(PAGE_MASK)) >> PAGE_SHIFT)			\
     64     + (((off & PAGE_MASK) + (len & PAGE_MASK)) > PAGE_SIZE))
     65 
     66 struct uvm_pagerops uvm_vnodeops;
     67 struct uvm_pagerops aobj_pager;
     68 struct uvmexp uvmexp;
     69 struct uvm uvm;
     70 
     71 struct vmspace rump_vmspace;
     72 struct vm_map rump_vmmap;
     73 
     74 /*
     75  * vm pages
     76  */
     77 
     78 struct vm_page *
     79 rumpvm_makepage(struct uvm_object *uobj, voff_t off)
     80 {
     81 	struct vm_page *pg;
     82 
     83 	pg = rumpuser_malloc(sizeof(struct vm_page), 0);
     84 	memset(pg, 0, sizeof(struct vm_page));
     85 	TAILQ_INSERT_TAIL(&uobj->memq, pg, listq);
     86 	pg->offset = off;
     87 	pg->uobject = uobj;
     88 
     89 	pg->uanon = (void *)rumpuser_malloc(PAGE_SIZE, 0);
     90 	memset((void *)pg->uanon, 0, PAGE_SIZE);
     91 	pg->flags = PG_CLEAN;
     92 
     93 	return pg;
     94 }
     95 
     96 void
     97 rumpvm_freepage(struct vm_page *pg)
     98 {
     99 	struct uvm_object *uobj = pg->uobject;
    100 
    101 	TAILQ_REMOVE(&uobj->memq, pg, listq);
    102 	rumpuser_free((void *)pg->uanon);
    103 	rumpuser_free(pg);
    104 }
    105 
    106 struct rumpva {
    107 	vaddr_t addr;
    108 	struct vm_page *pg;
    109 
    110 	LIST_ENTRY(rumpva) entries;
    111 };
    112 static LIST_HEAD(, rumpva) rvahead = LIST_HEAD_INITIALIZER(rvahead);
    113 
    114 void
    115 rumpvm_enterva(vaddr_t addr, struct vm_page *pg)
    116 {
    117 	struct rumpva *rva;
    118 
    119 	rva = rumpuser_malloc(sizeof(struct rumpva), 0);
    120 	rva->addr = addr;
    121 	rva->pg = pg;
    122 	LIST_INSERT_HEAD(&rvahead, rva, entries);
    123 }
    124 
    125 void
    126 rumpvm_flushva()
    127 {
    128 	struct rumpva *rva;
    129 
    130 	while ((rva = LIST_FIRST(&rvahead)) != NULL) {
    131 		LIST_REMOVE(rva, entries);
    132 		rumpuser_free(rva);
    133 	}
    134 }
    135 
    136 /*
    137  * vnode pager
    138  */
    139 
    140 static int
    141 vn_get(struct uvm_object *uobj, voff_t off, struct vm_page **pgs,
    142 	int *npages, int centeridx, vm_prot_t access_type,
    143 	int advice, int flags)
    144 {
    145 	struct vnode *vp = (struct vnode *)uobj;
    146 
    147 	return VOP_GETPAGES(vp, off, pgs, npages, centeridx, access_type,
    148 	    advice, flags);
    149 }
    150 
    151 static int
    152 vn_put(struct uvm_object *uobj, voff_t offlo, voff_t offhi, int flags)
    153 {
    154 	struct vnode *vp = (struct vnode *)uobj;
    155 
    156 	return VOP_PUTPAGES(vp, offlo, offhi, flags);
    157 }
    158 
    159 /*
    160  * Anon object stuff
    161  */
    162 
    163 static int
    164 ao_get(struct uvm_object *uobj, voff_t off, struct vm_page **pgs,
    165 	int *npages, int centeridx, vm_prot_t access_type,
    166 	int advice, int flags)
    167 {
    168 	struct vm_page *pg;
    169 	int i;
    170 
    171 	if (centeridx)
    172 		panic("%s: centeridx != 0 not supported", __func__);
    173 
    174 	/* loop over pages */
    175 	off = trunc_page(off);
    176 	for (i = 0; i < *npages; i++) {
    177 		pg = uvm_pagelookup(uobj, off + (i << PAGE_SHIFT));
    178 		if (pg) {
    179 			pgs[i] = pg;
    180 		} else {
    181 			pg = rumpvm_makepage(uobj, off + (i << PAGE_SHIFT));
    182 			pgs[i] = pg;
    183 		}
    184 	}
    185 
    186 	return 0;
    187 
    188 }
    189 
    190 static int
    191 ao_put(struct uvm_object *uobj, voff_t start, voff_t stop, int flags)
    192 {
    193 	struct vm_page *pg;
    194 
    195 	/* we only free all pages for now */
    196 	if ((flags & PGO_FREE) == 0 || (flags & PGO_ALLPAGES) == 0)
    197 		return 0;
    198 
    199 	while ((pg = TAILQ_FIRST(&uobj->memq)) != NULL)
    200 		rumpvm_freepage(pg);
    201 
    202 	return 0;
    203 }
    204 
    205 struct uvm_object *
    206 uao_create(vsize_t size, int flags)
    207 {
    208 	struct uvm_object *uobj;
    209 
    210 	uobj = rumpuser_malloc(sizeof(struct uvm_object), 0);
    211 	memset(uobj, 0, sizeof(struct uvm_object));
    212 	uobj->pgops = &aobj_pager;
    213 	TAILQ_INIT(&uobj->memq);
    214 
    215 	return uobj;
    216 }
    217 
    218 void
    219 uao_detach(struct uvm_object *uobj)
    220 {
    221 
    222 	ao_put(uobj, 0, 0, PGO_ALLPAGES | PGO_FREE);
    223 	rumpuser_free(uobj);
    224 }
    225 
    226 /*
    227  * UBC
    228  */
    229 
    230 struct ubc_window {
    231 	struct uvm_object	*uwin_obj;
    232 	voff_t			uwin_off;
    233 	uint8_t			*uwin_mem;
    234 	size_t			uwin_mapsize;
    235 
    236 	LIST_ENTRY(ubc_window)	uwin_entries;
    237 };
    238 
    239 static LIST_HEAD(, ubc_window) uwinlst = LIST_HEAD_INITIALIZER(uwinlst);
    240 
    241 int
    242 rump_ubc_magic_uiomove(void *va, size_t n, struct uio *uio, int *rvp)
    243 {
    244 	struct ubc_window *uwinp;
    245 	struct vm_page **pgs;
    246 	int npages = len2npages(uio->uio_offset, n);
    247 	int i, rv;
    248 
    249 	LIST_FOREACH(uwinp, &uwinlst, uwin_entries)
    250 		if ((uint8_t *)va >= uwinp->uwin_mem
    251 		    && (uint8_t *)va < (uwinp->uwin_mem + uwinp->uwin_mapsize))
    252 			break;
    253 	if (uwinp == NULL) {
    254 		KASSERT(rvp != NULL);
    255 		return 0;
    256 	}
    257 
    258 	pgs = rumpuser_malloc(npages * sizeof(pgs), 0);
    259 	memset(pgs, 0, sizeof(pgs));
    260 	rv = uwinp->uwin_obj->pgops->pgo_get(uwinp->uwin_obj,
    261 	    uwinp->uwin_off + ((uint8_t *)va - uwinp->uwin_mem),
    262 	    pgs, &npages, 0, 0, 0, 0);
    263 	if (rv)
    264 		goto out;
    265 
    266 	for (i = 0; i < npages; i++) {
    267 		size_t xfersize;
    268 		off_t pageoff;
    269 
    270 		pageoff = uio->uio_offset & PAGE_MASK;
    271 		xfersize = MIN(MIN(n, PAGE_SIZE), PAGE_SIZE-pageoff);
    272 		uiomove((uint8_t *)pgs[i]->uanon + pageoff, xfersize, uio);
    273 		if (uio->uio_rw == UIO_WRITE)
    274 			pgs[i]->flags &= ~PG_CLEAN;
    275 		n -= xfersize;
    276 	}
    277 
    278  out:
    279 	rumpuser_free(pgs);
    280 	if (rvp)
    281 		*rvp = rv;
    282 	return 1;
    283 }
    284 
    285 void *
    286 ubc_alloc(struct uvm_object *uobj, voff_t offset, vsize_t *lenp, int advice,
    287 	int flags)
    288 {
    289 	struct ubc_window *uwinp; /* pronounced: you wimp! */
    290 
    291 	uwinp = kmem_alloc(sizeof(struct ubc_window), KM_SLEEP);
    292 	uwinp->uwin_obj = uobj;
    293 	uwinp->uwin_off = offset;
    294 	uwinp->uwin_mapsize = *lenp;
    295 	uwinp->uwin_mem = kmem_alloc(*lenp, KM_SLEEP);
    296 
    297 	LIST_INSERT_HEAD(&uwinlst, uwinp, uwin_entries);
    298 
    299 	DPRINTF(("UBC_ALLOC offset 0x%llx, uwin %p, mem %p\n",
    300 	    (unsigned long long)offset, uwinp, uwinp->uwin_mem));
    301 
    302 	return uwinp->uwin_mem;
    303 }
    304 
    305 void
    306 ubc_release(void *va, int flags)
    307 {
    308 	struct ubc_window *uwinp;
    309 
    310 	LIST_FOREACH(uwinp, &uwinlst, uwin_entries)
    311 		if ((uint8_t *)va >= uwinp->uwin_mem
    312 		    && (uint8_t *)va < (uwinp->uwin_mem + uwinp->uwin_mapsize))
    313 			break;
    314 	if (uwinp == NULL)
    315 		panic("%s: releasing invalid window at %p", __func__, va);
    316 
    317 	LIST_REMOVE(uwinp, uwin_entries);
    318 	kmem_free(uwinp->uwin_mem, uwinp->uwin_mapsize);
    319 	kmem_free(uwinp, sizeof(struct ubc_window));
    320 }
    321 
    322 int
    323 ubc_uiomove(struct uvm_object *uobj, struct uio *uio, vsize_t todo,
    324 	int advice, int flags)
    325 {
    326 	void *win;
    327 	vsize_t len;
    328 
    329 	while (todo > 0) {
    330 		len = todo;
    331 
    332 		win = ubc_alloc(uobj, uio->uio_offset, &len, 0, flags);
    333 		rump_ubc_magic_uiomove(win, len, uio, NULL);
    334 		ubc_release(win, 0);
    335 
    336 		todo -= len;
    337 	}
    338 	return 0;
    339 }
    340 
    341 
    342 /*
    343  * Misc routines
    344  */
    345 
    346 void
    347 rumpvm_init()
    348 {
    349 
    350 	uvm_vnodeops.pgo_get = vn_get;
    351 	uvm_vnodeops.pgo_put = vn_put;
    352 	aobj_pager.pgo_get = ao_get;
    353 	aobj_pager.pgo_put = ao_put;
    354 
    355 	uvmexp.free = 1024*1024; /* XXX */
    356 	uvm.pagedaemon_lwp = NULL; /* doesn't match curlwp */
    357 }
    358 
    359 void
    360 uvm_pageactivate(struct vm_page *pg)
    361 {
    362 
    363 	/* nada */
    364 }
    365 
    366 void
    367 uvm_page_unbusy(struct vm_page **pgs, int npgs)
    368 {
    369 
    370 	/* nada */
    371 }
    372 
    373 void
    374 uvm_pagewire(struct vm_page *pg)
    375 {
    376 
    377 	/* nada */
    378 }
    379 
    380 void
    381 uvm_pageunwire(struct vm_page *pg)
    382 {
    383 
    384 	/* nada */
    385 }
    386 
    387 vaddr_t
    388 uvm_pagermapin(struct vm_page **pps, int npages, int flags)
    389 {
    390 
    391 	panic("%s: unimplemented", __func__);
    392 }
    393 
    394 struct vm_page *
    395 uvm_pagelookup(struct uvm_object *uobj, voff_t off)
    396 {
    397 	struct vm_page *pg;
    398 
    399 	TAILQ_FOREACH(pg, &uobj->memq, listq)
    400 		if (pg->offset == off)
    401 			return pg;
    402 
    403 	return NULL;
    404 }
    405 
    406 struct vm_page *
    407 uvm_pageratop(vaddr_t va)
    408 {
    409 	struct rumpva *rva;
    410 
    411 	LIST_FOREACH(rva, &rvahead, entries)
    412 		if (rva->addr == va)
    413 			return rva->pg;
    414 
    415 	panic("%s: va %llu", __func__, (unsigned long long)va);
    416 }
    417 
    418 void
    419 uvm_estimatepageable(int *active, int *inactive)
    420 {
    421 
    422 	/* XXX: guessing game */
    423 	*active = 1024;
    424 	*inactive = 1024;
    425 }
    426 
    427 void
    428 uvm_aio_biodone1(struct buf *bp)
    429 {
    430 
    431 	panic("%s: unimplemented", __func__);
    432 }
    433 
    434 void
    435 uvm_aio_biodone(struct buf *bp)
    436 {
    437 
    438 	uvm_aio_aiodone(bp);
    439 }
    440 
    441 void
    442 uvm_aio_aiodone(struct buf *bp)
    443 {
    444 
    445 	if ((bp->b_flags & (B_READ | B_NOCACHE)) == 0 && bioopsp)
    446 		bioopsp->io_pageiodone(bp);
    447 }
    448 
    449 void
    450 uvm_vnp_setsize(struct vnode *vp, voff_t newsize)
    451 {
    452 
    453 	vp->v_size = vp->v_writesize = newsize;
    454 }
    455 
    456 void
    457 uvm_vnp_setwritesize(struct vnode *vp, voff_t newsize)
    458 {
    459 
    460 	vp->v_writesize = newsize;
    461 }
    462 
    463 void
    464 uvm_vnp_zerorange(struct vnode *vp, off_t off, size_t len)
    465 {
    466 	struct uvm_object *uobj = &vp->v_uobj;
    467 	struct vm_page **pgs;
    468 	int maxpages = MIN(32, round_page(len) >> PAGE_SHIFT);
    469 	int rv, npages, i;
    470 
    471 	pgs = rumpuser_malloc(maxpages * sizeof(pgs), 0);
    472 	while (len) {
    473 		npages = MIN(maxpages, round_page(len) >> PAGE_SHIFT);
    474 		memset(pgs, 0, npages * sizeof(struct vm_page *));
    475 		rv = uobj->pgops->pgo_get(uobj, off, pgs, &npages, 0, 0, 0, 0);
    476 		assert(npages > 0);
    477 
    478 		for (i = 0; i < npages; i++) {
    479 			uint8_t *start;
    480 			size_t chunkoff, chunklen;
    481 
    482 			chunkoff = off & PAGE_MASK;
    483 			chunklen = MIN(PAGE_SIZE - chunkoff, len);
    484 			start = (uint8_t *)pgs[i]->uanon + chunkoff;
    485 
    486 			memset(start, 0, chunklen);
    487 			pgs[i]->flags &= PG_CLEAN;
    488 
    489 			off += chunklen;
    490 			len -= chunklen;
    491 		}
    492 	}
    493 	rumpuser_free(pgs);
    494 
    495 	return;
    496 }
    497 
    498 struct uvm_ractx *
    499 uvm_ra_allocctx()
    500 {
    501 
    502 	return NULL;
    503 }
    504 
    505 void
    506 uvm_ra_freectx(struct uvm_ractx *ra)
    507 {
    508 
    509 	return;
    510 }
    511 
    512 bool
    513 uvn_clean_p(struct uvm_object *uobj)
    514 {
    515 	struct vnode *vp = (void *)uobj;
    516 
    517 	return (vp->v_iflag & VI_ONWORKLST) == 0;
    518 }
    519 
    520 /*
    521  * Kmem
    522  */
    523 
    524 void *
    525 kmem_alloc(size_t size, km_flag_t kmflag)
    526 {
    527 
    528 	return rumpuser_malloc(size, kmflag == KM_NOSLEEP);
    529 }
    530 
    531 void *
    532 kmem_zalloc(size_t size, km_flag_t kmflag)
    533 {
    534 	void *rv;
    535 
    536 	rv = kmem_alloc(size, kmflag);
    537 	if (rv)
    538 		memset(rv, 0, size);
    539 
    540 	return rv;
    541 }
    542 
    543 void
    544 kmem_free(void *p, size_t size)
    545 {
    546 
    547 	rumpuser_free(p);
    548 }
    549 
    550 /*
    551  * UVM km
    552  */
    553 
    554 vaddr_t
    555 uvm_km_alloc(struct vm_map *map, vsize_t size, vsize_t align, uvm_flag_t flags)
    556 {
    557 	void *rv;
    558 
    559 	rv = rumpuser_malloc(size, flags & (UVM_KMF_CANFAIL | UVM_KMF_NOWAIT));
    560 	if (rv && flags & UVM_KMF_ZERO)
    561 		memset(rv, 0, size);
    562 
    563 	return (vaddr_t)rv;
    564 }
    565 
    566 void
    567 uvm_km_free(struct vm_map *map, vaddr_t vaddr, vsize_t size, uvm_flag_t flags)
    568 {
    569 
    570 	rumpuser_free((void *)vaddr);
    571 }
    572 
    573 struct vm_map *
    574 uvm_km_suballoc(struct vm_map *map, vaddr_t *minaddr, vaddr_t *maxaddr,
    575 	vsize_t size, int pageable, bool fixed, struct vm_map_kernel *submap)
    576 {
    577 
    578 	return (struct vm_map *)417416;
    579 }
    580