Home | History | Annotate | Line # | Download | only in rumpkern
vm.c revision 1.19 
      1 /*	$NetBSD: vm.c,v 1.19 2007/10/28 18:54:17 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 static int ubc_winvalid;
     67 static struct uvm_object *ubc_uobj;
     68 static off_t ubc_offset;
     69 static int ubc_flags;
     70 
     71 struct uvm_pagerops uvm_vnodeops;
     72 struct uvm_pagerops aobj_pager;
     73 struct uvmexp uvmexp;
     74 struct uvm uvm;
     75 
     76 struct vmspace rump_vmspace;
     77 struct vm_map rump_vmmap;
     78 
     79 /*
     80  * vm pages
     81  */
     82 
     83 struct vm_page *
     84 rumpvm_makepage(struct uvm_object *uobj, voff_t off)
     85 {
     86 	struct vm_page *pg;
     87 
     88 	pg = rumpuser_malloc(sizeof(struct vm_page), 0);
     89 	memset(pg, 0, sizeof(struct vm_page));
     90 	TAILQ_INSERT_TAIL(&uobj->memq, pg, listq);
     91 	pg->offset = off;
     92 	pg->uobject = uobj;
     93 
     94 	pg->uanon = (void *)rumpuser_malloc(PAGE_SIZE, 0);
     95 	memset((void *)pg->uanon, 0, PAGE_SIZE);
     96 	pg->flags = PG_CLEAN;
     97 
     98 	return pg;
     99 }
    100 
    101 void
    102 rumpvm_freepage(struct vm_page *pg)
    103 {
    104 	struct uvm_object *uobj = pg->uobject;
    105 
    106 	TAILQ_REMOVE(&uobj->memq, pg, listq);
    107 	rumpuser_free((void *)pg->uanon);
    108 	rumpuser_free(pg);
    109 }
    110 
    111 struct rumpva {
    112 	vaddr_t addr;
    113 	struct vm_page *pg;
    114 
    115 	LIST_ENTRY(rumpva) entries;
    116 };
    117 static LIST_HEAD(, rumpva) rvahead = LIST_HEAD_INITIALIZER(rvahead);
    118 
    119 void
    120 rumpvm_enterva(vaddr_t addr, struct vm_page *pg)
    121 {
    122 	struct rumpva *rva;
    123 
    124 	rva = rumpuser_malloc(sizeof(struct rumpva), 0);
    125 	rva->addr = addr;
    126 	rva->pg = pg;
    127 	LIST_INSERT_HEAD(&rvahead, rva, entries);
    128 }
    129 
    130 void
    131 rumpvm_flushva()
    132 {
    133 	struct rumpva *rva;
    134 
    135 	while ((rva = LIST_FIRST(&rvahead)) != NULL) {
    136 		LIST_REMOVE(rva, entries);
    137 		rumpuser_free(rva);
    138 	}
    139 }
    140 
    141 /*
    142  * vnode pager
    143  */
    144 
    145 static int
    146 vn_get(struct uvm_object *uobj, voff_t off, struct vm_page **pgs,
    147 	int *npages, int centeridx, vm_prot_t access_type,
    148 	int advice, int flags)
    149 {
    150 	struct vnode *vp = (struct vnode *)uobj;
    151 
    152 	return VOP_GETPAGES(vp, off, pgs, npages, centeridx, access_type,
    153 	    advice, flags);
    154 }
    155 
    156 static int
    157 vn_put(struct uvm_object *uobj, voff_t offlo, voff_t offhi, int flags)
    158 {
    159 	struct vnode *vp = (struct vnode *)uobj;
    160 
    161 	return VOP_PUTPAGES(vp, offlo, offhi, flags);
    162 }
    163 
    164 /*
    165  * Anon object stuff
    166  */
    167 
    168 static int
    169 ao_get(struct uvm_object *uobj, voff_t off, struct vm_page **pgs,
    170 	int *npages, int centeridx, vm_prot_t access_type,
    171 	int advice, int flags)
    172 {
    173 	struct vm_page *pg;
    174 	int i;
    175 
    176 	if (centeridx)
    177 		panic("%s: centeridx != 0 not supported", __func__);
    178 
    179 	/* loop over pages */
    180 	off = trunc_page(off);
    181 	for (i = 0; i < *npages; i++) {
    182 		pg = uvm_pagelookup(uobj, off + (i << PAGE_SHIFT));
    183 		if (pg) {
    184 			pgs[i] = pg;
    185 		} else {
    186 			pg = rumpvm_makepage(uobj, off + (i << PAGE_SHIFT));
    187 			pgs[i] = pg;
    188 		}
    189 	}
    190 
    191 	return 0;
    192 
    193 }
    194 
    195 static int
    196 ao_put(struct uvm_object *uobj, voff_t start, voff_t stop, int flags)
    197 {
    198 	struct vm_page *pg;
    199 
    200 	/* we only free all pages for now */
    201 	if ((flags & PGO_FREE) == 0 || (flags & PGO_ALLPAGES) == 0)
    202 		return 0;
    203 
    204 	while ((pg = TAILQ_FIRST(&uobj->memq)) != NULL)
    205 		rumpvm_freepage(pg);
    206 
    207 	return 0;
    208 }
    209 
    210 struct uvm_object *
    211 uao_create(vsize_t size, int flags)
    212 {
    213 	struct uvm_object *uobj;
    214 
    215 	uobj = rumpuser_malloc(sizeof(struct uvm_object), 0);
    216 	memset(uobj, 0, sizeof(struct uvm_object));
    217 	uobj->pgops = &aobj_pager;
    218 	TAILQ_INIT(&uobj->memq);
    219 
    220 	return uobj;
    221 }
    222 
    223 void
    224 uao_detach(struct uvm_object *uobj)
    225 {
    226 
    227 	ao_put(uobj, 0, 0, PGO_ALLPAGES | PGO_FREE);
    228 	rumpuser_free(uobj);
    229 }
    230 
    231 /*
    232  * UBC
    233  */
    234 
    235 int
    236 rump_ubc_magic_uiomove(size_t n, struct uio *uio)
    237 {
    238 	struct vm_page **pgs;
    239 	int npages = len2npages(uio->uio_offset, n);
    240 	int i, rv;
    241 
    242 	if (ubc_winvalid == 0)
    243 		panic("%s: ubc window not allocated", __func__);
    244 
    245 	pgs = rumpuser_malloc(npages * sizeof(pgs), 0);
    246 	memset(pgs, 0, sizeof(pgs));
    247 	rv = ubc_uobj->pgops->pgo_get(ubc_uobj, ubc_offset,
    248 	    pgs, &npages, 0, 0, 0, 0);
    249 	if (rv)
    250 		goto out;
    251 
    252 	for (i = 0; i < npages; i++) {
    253 		size_t xfersize;
    254 		off_t pageoff;
    255 
    256 		pageoff = uio->uio_offset & PAGE_MASK;
    257 		xfersize = MIN(MIN(n, PAGE_SIZE), PAGE_SIZE-pageoff);
    258 		uiomove((uint8_t *)pgs[i]->uanon + pageoff, xfersize, uio);
    259 		if (uio->uio_rw == UIO_WRITE)
    260 			pgs[i]->flags &= ~PG_CLEAN;
    261 		ubc_offset += xfersize;
    262 		n -= xfersize;
    263 	}
    264 
    265  out:
    266 	rumpuser_free(pgs);
    267 	return rv;
    268 }
    269 
    270 void *
    271 ubc_alloc(struct uvm_object *uobj, voff_t offset, vsize_t *lenp, int advice,
    272 	int flags)
    273 {
    274 	vsize_t reallen;
    275 
    276 	/* XXX: only one window, but that's ok for now */
    277 	if (ubc_winvalid == 1)
    278 		panic("%s: ubc window already allocated", __func__);
    279 
    280 	printf("UBC_ALLOC offset 0x%x\n", (int)offset);
    281 	ubc_uobj = uobj;
    282 	ubc_offset = offset;
    283 	reallen = round_page(*lenp);
    284 	ubc_flags = flags;
    285 
    286 	ubc_winvalid = 1;
    287 
    288 	return RUMP_UBC_MAGIC_WINDOW;
    289 }
    290 
    291 void
    292 ubc_release(void *va, int flags)
    293 {
    294 
    295 	ubc_winvalid = 0;
    296 }
    297 
    298 int
    299 ubc_uiomove(struct uvm_object *uobj, struct uio *uio, vsize_t todo,
    300 	int advice, int flags)
    301 {
    302 	void *win;
    303 	vsize_t len;
    304 
    305 	while (todo > 0) {
    306 		len = todo;
    307 
    308 		win = ubc_alloc(uobj, uio->uio_offset, &len, 0, flags);
    309 		rump_ubc_magic_uiomove(len, uio);
    310 		ubc_release(win, 0);
    311 
    312 		todo -= len;
    313 	}
    314 	return 0;
    315 }
    316 
    317 
    318 /*
    319  * Misc routines
    320  */
    321 
    322 void
    323 rumpvm_init()
    324 {
    325 
    326 	uvm_vnodeops.pgo_get = vn_get;
    327 	uvm_vnodeops.pgo_put = vn_put;
    328 	aobj_pager.pgo_get = ao_get;
    329 	aobj_pager.pgo_put = ao_put;
    330 
    331 	uvmexp.free = 1024*1024; /* XXX */
    332 	uvm.pagedaemon_lwp = NULL; /* doesn't match curlwp */
    333 }
    334 
    335 void
    336 uvm_pageactivate(struct vm_page *pg)
    337 {
    338 
    339 	/* nada */
    340 }
    341 
    342 void
    343 uvm_page_unbusy(struct vm_page **pgs, int npgs)
    344 {
    345 
    346 	/* nada */
    347 }
    348 
    349 void
    350 uvm_pagewire(struct vm_page *pg)
    351 {
    352 
    353 	/* nada */
    354 }
    355 
    356 void
    357 uvm_pageunwire(struct vm_page *pg)
    358 {
    359 
    360 	/* nada */
    361 }
    362 
    363 vaddr_t
    364 uvm_pagermapin(struct vm_page **pps, int npages, int flags)
    365 {
    366 
    367 	panic("%s: unimplemented", __func__);
    368 }
    369 
    370 struct vm_page *
    371 uvm_pagelookup(struct uvm_object *uobj, voff_t off)
    372 {
    373 	struct vm_page *pg;
    374 
    375 	TAILQ_FOREACH(pg, &uobj->memq, listq)
    376 		if (pg->offset == off)
    377 			return pg;
    378 
    379 	return NULL;
    380 }
    381 
    382 struct vm_page *
    383 uvm_pageratop(vaddr_t va)
    384 {
    385 	struct rumpva *rva;
    386 
    387 	LIST_FOREACH(rva, &rvahead, entries)
    388 		if (rva->addr == va)
    389 			return rva->pg;
    390 
    391 	panic("%s: va %llu", __func__, (unsigned long long)va);
    392 }
    393 
    394 void
    395 uvm_estimatepageable(int *active, int *inactive)
    396 {
    397 
    398 	/* XXX: guessing game */
    399 	*active = 1024;
    400 	*inactive = 1024;
    401 }
    402 
    403 void
    404 uvm_aio_biodone1(struct buf *bp)
    405 {
    406 
    407 	panic("%s: unimplemented", __func__);
    408 }
    409 
    410 void
    411 uvm_aio_biodone(struct buf *bp)
    412 {
    413 
    414 	uvm_aio_aiodone(bp);
    415 }
    416 
    417 void
    418 uvm_aio_aiodone(struct buf *bp)
    419 {
    420 
    421 	if ((bp->b_flags & (B_READ | B_NOCACHE)) == 0 && bioopsp)
    422 		bioopsp->io_pageiodone(bp);
    423 }
    424 
    425 void
    426 uvm_vnp_setsize(struct vnode *vp, voff_t newsize)
    427 {
    428 
    429 	vp->v_size = vp->v_writesize = newsize;
    430 }
    431 
    432 void
    433 uvm_vnp_setwritesize(struct vnode *vp, voff_t newsize)
    434 {
    435 
    436 	vp->v_writesize = newsize;
    437 }
    438 
    439 void
    440 uvm_vnp_zerorange(struct vnode *vp, off_t off, size_t len)
    441 {
    442 	struct uvm_object *uobj = &vp->v_uobj;
    443 	struct vm_page **pgs;
    444 	int maxpages = MIN(32, round_page(len) >> PAGE_SHIFT);
    445 	int rv, npages, i;
    446 
    447 	pgs = rumpuser_malloc(maxpages * sizeof(pgs), 0);
    448 	while (len) {
    449 		npages = MIN(maxpages, round_page(len) >> PAGE_SHIFT);
    450 		memset(pgs, 0, npages * sizeof(struct vm_page *));
    451 		rv = uobj->pgops->pgo_get(uobj, off, pgs, &npages, 0, 0, 0, 0);
    452 		assert(npages > 0);
    453 
    454 		for (i = 0; i < npages; i++) {
    455 			uint8_t *start;
    456 			size_t chunkoff, chunklen;
    457 
    458 			chunkoff = off & PAGE_MASK;
    459 			chunklen = MIN(PAGE_SIZE - chunkoff, len);
    460 			start = (uint8_t *)pgs[i]->uanon + chunkoff;
    461 
    462 			memset(start, 0, chunklen);
    463 			pgs[i]->flags &= PG_CLEAN;
    464 
    465 			off += chunklen;
    466 			len -= chunklen;
    467 		}
    468 	}
    469 	rumpuser_free(pgs);
    470 
    471 	return;
    472 }
    473 
    474 struct uvm_ractx *
    475 uvm_ra_allocctx()
    476 {
    477 
    478 	return NULL;
    479 }
    480 
    481 void
    482 uvm_ra_freectx(struct uvm_ractx *ra)
    483 {
    484 
    485 	return;
    486 }
    487 
    488 bool
    489 uvn_clean_p(struct uvm_object *uobj)
    490 {
    491 	struct vnode *vp = (void *)uobj;
    492 
    493 	return (vp->v_iflag & VI_ONWORKLST) == 0;
    494 }
    495 
    496 /*
    497  * Kmem
    498  */
    499 
    500 void *
    501 kmem_alloc(size_t size, km_flag_t kmflag)
    502 {
    503 
    504 	return rumpuser_malloc(size, kmflag == KM_NOSLEEP);
    505 }
    506 
    507 void *
    508 kmem_zalloc(size_t size, km_flag_t kmflag)
    509 {
    510 	void *rv;
    511 
    512 	rv = kmem_alloc(size, kmflag);
    513 	if (rv)
    514 		memset(rv, 0, size);
    515 
    516 	return rv;
    517 }
    518 
    519 void
    520 kmem_free(void *p, size_t size)
    521 {
    522 
    523 	rumpuser_free(p);
    524 }
    525 
    526 /*
    527  * UVM km
    528  */
    529 
    530 vaddr_t
    531 uvm_km_alloc(struct vm_map *map, vsize_t size, vsize_t align, uvm_flag_t flags)
    532 {
    533 	void *rv;
    534 
    535 	rv = rumpuser_malloc(size, flags & (UVM_KMF_CANFAIL | UVM_KMF_NOWAIT));
    536 	if (rv && flags & UVM_KMF_ZERO)
    537 		memset(rv, 0, size);
    538 
    539 	return (vaddr_t)rv;
    540 }
    541 
    542 void
    543 uvm_km_free(struct vm_map *map, vaddr_t vaddr, vsize_t size, uvm_flag_t flags)
    544 {
    545 
    546 	rumpuser_free((void *)vaddr);
    547 }
    548 
    549 struct vm_map *
    550 uvm_km_suballoc(struct vm_map *map, vaddr_t *minaddr, vaddr_t *maxaddr,
    551 	vsize_t size, int pageable, bool fixed, struct vm_map_kernel *submap)
    552 {
    553 
    554 	return (struct vm_map *)417416;
    555 }
    556