sys/rump/librump/rumpvfs/vm_vfs.c

   1 /*      $NetBSD: vm_vfs.c,v 1.14 2009/11/10 16:55:12 pooka Exp $        */
   2
   3 /*
   4  * Copyright (c) 2008 Antti Kantee.  All Rights Reserved.
   5  *
   6  * Development of this software was supported by the
   7  * Finnish Cultural Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  19  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __KERNEL_RCSID(0, "$NetBSD: vm_vfs.c,v 1.14 2009/11/10 16:55:12 pooka Exp $");
  33
  34 #include <sys/param.h>
  35
  36 #include <sys/buf.h>
  37 #include <sys/vnode.h>
  38
  39 #include <uvm/uvm.h>
  40 #include <uvm/uvm_readahead.h>
  41
  42 /*
  43  * release resources held during async io.  this is almost the
  44  * same as uvm_aio_aiodone() from uvm_pager.c and only lacks the
  45  * call to uvm_aio_aiodone_pages(): unbusies pages directly here.
  46  */
  47 void
  48 uvm_aio_aiodone(struct buf *bp)
  49 {
  50         int i, npages = bp->b_bufsize >> PAGE_SHIFT;
  51         struct vm_page **pgs;
  52         vaddr_t va;
  53
  54         pgs = kmem_alloc(npages * sizeof(*pgs), KM_SLEEP);
  55         for (i = 0; i < npages; i++) {
  56                 va = (vaddr_t)bp->b_data + (i << PAGE_SHIFT);
  57                 pgs[i] = uvm_pageratop(va);
  58                 pgs[i]->flags &= ~PG_PAGEOUT;
  59         }
  60
  61         uvm_pagermapout((vaddr_t)bp->b_data, npages);
  62         uvm_page_unbusy(pgs, npages);
  63
  64         if (BUF_ISWRITE(bp) && (bp->b_cflags & BC_AGE) != 0) {
  65                 mutex_enter(bp->b_objlock);
  66                 vwakeup(bp);
  67                 mutex_exit(bp->b_objlock);
  68         }
  69
  70         putiobuf(bp);
  71
  72         kmem_free(pgs, npages * sizeof(*pgs));
  73 }
  74
  75 void
  76 uvm_aio_biodone(struct buf *bp)
  77 {
  78
  79         uvm_aio_aiodone(bp);
  80 }
  81
  82 /*
  83  * UBC
  84  */
  85
  86 void
  87 uvm_vnp_zerorange(struct vnode *vp, off_t off, size_t len)
  88 {
  89         struct uvm_object *uobj = &vp->v_uobj;
  90         struct vm_page **pgs;
  91         int maxpages = MIN(32, round_page(len) >> PAGE_SHIFT);
  92         int rv, npages, i;
  93
  94         if (maxpages == 0)
  95                 return;
  96
  97         pgs = kmem_zalloc(maxpages * sizeof(pgs), KM_SLEEP);
  98         while (len) {
  99                 npages = MIN(maxpages, round_page(len) >> PAGE_SHIFT);
 100                 memset(pgs, 0, npages * sizeof(struct vm_page *));
 101                 mutex_enter(&uobj->vmobjlock);
 102                 rv = uobj->pgops->pgo_get(uobj, off, pgs, &npages, 0,
 103                     VM_PROT_READ | VM_PROT_WRITE, 0, PGO_SYNCIO);
 104                 KASSERT(npages > 0);
 105
 106                 for (i = 0; i < npages; i++) {
 107                         uint8_t *start;
 108                         size_t chunkoff, chunklen;
 109
 110                         chunkoff = off & PAGE_MASK;
 111                         chunklen = MIN(PAGE_SIZE - chunkoff, len);
 112                         start = (uint8_t *)pgs[i]->uanon + chunkoff;
 113
 114                         memset(start, 0, chunklen);
 115                         pgs[i]->flags &= ~PG_CLEAN;
 116
 117                         off += chunklen;
 118                         len -= chunklen;
 119                 }
 120                 uvm_page_unbusy(pgs, npages);
 121         }
 122         kmem_free(pgs, maxpages * sizeof(pgs));
 123
 124         return;
 125 }
 126
 127 /* dumdidumdum */
 128 #define len2npages(off, len)                                            \
 129   (((((len) + PAGE_MASK) & ~(PAGE_MASK)) >> PAGE_SHIFT)                 \
 130     + (((off & PAGE_MASK) + (len & PAGE_MASK)) > PAGE_SIZE))
 131
 132 int
 133 ubc_uiomove(struct uvm_object *uobj, struct uio *uio, vsize_t todo,
 134         int advice, int flags)
 135 {
 136         struct vm_page **pgs;
 137         int npages = len2npages(uio->uio_offset, todo);
 138         size_t pgalloc;
 139         int i, rv, pagerflags;
 140
 141         pgalloc = npages * sizeof(pgs);
 142         pgs = kmem_zalloc(pgalloc, KM_SLEEP);
 143
 144         pagerflags = PGO_SYNCIO | PGO_NOBLOCKALLOC | PGO_NOTIMESTAMP;
 145         if (flags & UBC_WRITE)
 146                 pagerflags |= PGO_PASTEOF;
 147         if (flags & UBC_FAULTBUSY)
 148                 pagerflags |= PGO_OVERWRITE;
 149
 150         do {
 151                 mutex_enter(&uobj->vmobjlock);
 152                 rv = uobj->pgops->pgo_get(uobj, uio->uio_offset & ~PAGE_MASK,
 153                     pgs, &npages, 0, VM_PROT_READ | VM_PROT_WRITE, 0,
 154                     pagerflags);
 155                 if (rv)
 156                         goto out;
 157
 158                 for (i = 0; i < npages; i++) {
 159                         size_t xfersize;
 160                         off_t pageoff;
 161
 162                         pageoff = uio->uio_offset & PAGE_MASK;
 163                         xfersize = MIN(MIN(todo, PAGE_SIZE), PAGE_SIZE-pageoff);
 164                         KASSERT(xfersize > 0);
 165                         uiomove((uint8_t *)pgs[i]->uanon + pageoff,
 166                             xfersize, uio);
 167                         if (uio->uio_rw == UIO_WRITE)
 168                                 pgs[i]->flags &= ~(PG_CLEAN | PG_FAKE);
 169                         todo -= xfersize;
 170                 }
 171                 uvm_page_unbusy(pgs, npages);
 172         } while (todo);
 173
 174  out:
 175         kmem_free(pgs, pgalloc);
 176         return rv;
 177 }