kernel/os/urw.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29 #include <sys/atomic.h>
  30 #include <sys/errno.h>
  31 #include <sys/stat.h>
  32 #include <sys/modctl.h>
  33 #include <sys/conf.h>
  34 #include <sys/systm.h>
  35 #include <sys/ddi.h>
  36 #include <sys/sunddi.h>
  37 #include <sys/cpuvar.h>
  38 #include <sys/kmem.h>
  39 #include <sys/strsubr.h>
  40 #include <sys/sysmacros.h>
  41 #include <sys/frame.h>
  42 #include <sys/stack.h>
  43 #include <sys/proc.h>
  44 #include <sys/priv.h>
  45 #include <sys/policy.h>
  46 #include <sys/ontrap.h>
  47 #include <sys/vmsystm.h>
  48 #include <sys/prsystm.h>
  49
  50 #include <vm/as.h>
  51 #include <vm/seg.h>
  52 #include <vm/seg_dev.h>
  53 #include <vm/seg_vn.h>
  54 #include <vm/seg_spt.h>
  55 #include <vm/seg_kmem.h>
  56
  57 extern const struct seg_ops segdev_ops; /* needs a header file */
  58 extern const struct seg_ops segspt_shmops;      /* needs a header file */
  59
  60 static int
  61 page_valid(struct seg *seg, caddr_t addr)
  62 {
  63         struct segvn_data *svd;
  64         vnode_t *vp;
  65         vattr_t vattr;
  66
  67         /*
  68          * Fail if the page doesn't map to a page in the underlying
  69          * mapped file, if an underlying mapped file exists.
  70          */
  71         vattr.va_mask = AT_SIZE;
  72         if (seg->s_ops == &segvn_ops &&
  73             segop_getvp(seg, addr, &vp) == 0 &&
  74             vp != NULL && vp->v_type == VREG &&
  75             fop_getattr(vp, &vattr, 0, CRED(), NULL) == 0) {
  76                 uoff_t size = roundup(vattr.va_size, (uoff_t)PAGESIZE);
  77                 uoff_t offset = segop_getoffset(seg, addr);
  78
  79                 if (offset >= size)
  80                         return (0);
  81         }
  82
  83         /*
  84          * Fail if this is an ISM shared segment and the address is
  85          * not within the real size of the spt segment that backs it.
  86          */
  87         if (seg->s_ops == &segspt_shmops &&
  88             addr >= seg->s_base + spt_realsize(seg))
  89                 return (0);
  90
  91         /*
  92          * Fail if the segment is mapped from /dev/null.
  93          * The key is that the mapping comes from segdev and the
  94          * type is neither MAP_SHARED nor MAP_PRIVATE.
  95          */
  96         if (seg->s_ops == &segdev_ops &&
  97             ((segop_gettype(seg, addr) & (MAP_SHARED | MAP_PRIVATE)) == 0))
  98                 return (0);
  99
 100         /*
 101          * Fail if the page is a MAP_NORESERVE page that has
 102          * not actually materialized.
 103          * We cheat by knowing that segvn is the only segment
 104          * driver that supports MAP_NORESERVE.
 105          */
 106         if (seg->s_ops == &segvn_ops &&
 107             (svd = (struct segvn_data *)seg->s_data) != NULL &&
 108             (svd->vp == NULL || svd->vp->v_type != VREG) &&
 109             (svd->flags & MAP_NORESERVE)) {
 110                 /*
 111                  * Guilty knowledge here.  We know that
 112                  * segvn_incore returns more than just the
 113                  * low-order bit that indicates the page is
 114                  * actually in memory.  If any bits are set,
 115                  * then there is backing store for the page.
 116                  */
 117                 char incore = 0;
 118                 (void) segop_incore(seg, addr, PAGESIZE, &incore);
 119                 if (incore == 0)
 120                         return (0);
 121         }
 122         return (1);
 123 }
 124
 125 /*
 126  * Map address "addr" in address space "as" into a kernel virtual address.
 127  * The memory is guaranteed to be resident and locked down.
 128  */
 129 static caddr_t
 130 mapin(struct as *as, caddr_t addr, int writing)
 131 {
 132         page_t *pp;
 133         caddr_t kaddr;
 134         pfn_t pfnum;
 135
 136         /*
 137          * NB: Because of past mistakes, we have bits being returned
 138          * by getpfnum that are actually the page type bits of the pte.
 139          * When the object we are trying to map is a memory page with
 140          * a page structure everything is ok and we can use the optimal
 141          * method, ppmapin.  Otherwise, we have to do something special.
 142          */
 143         pfnum = hat_getpfnum(as->a_hat, addr);
 144         if (pf_is_memory(pfnum)) {
 145                 pp = page_numtopp_nolock(pfnum);
 146                 if (pp != NULL) {
 147                         ASSERT(PAGE_LOCKED(pp));
 148                         kaddr = ppmapin(pp, writing ?
 149                             (PROT_READ | PROT_WRITE) : PROT_READ, (caddr_t)-1);
 150                         return (kaddr + ((uintptr_t)addr & PAGEOFFSET));
 151                 }
 152         }
 153
 154         /*
 155          * Oh well, we didn't have a page struct for the object we were
 156          * trying to map in; ppmapin doesn't handle devices, but allocating a
 157          * heap address allows ppmapout to free virutal space when done.
 158          */
 159         kaddr = vmem_alloc(heap_arena, PAGESIZE, VM_SLEEP);
 160
 161         hat_devload(kas.a_hat, kaddr, PAGESIZE, pfnum,
 162             writing ? (PROT_READ | PROT_WRITE) : PROT_READ, HAT_LOAD_LOCK);
 163
 164         return (kaddr + ((uintptr_t)addr & PAGEOFFSET));
 165 }
 166
 167 /*ARGSUSED*/
 168 static void
 169 mapout(struct as *as, caddr_t addr, caddr_t vaddr, int writing)
 170 {
 171         vaddr = (caddr_t)(uintptr_t)((uintptr_t)vaddr & PAGEMASK);
 172         ppmapout(vaddr);
 173 }
 174
 175 /*
 176  * Perform I/O to a given process. This will return EIO if we detect
 177  * corrupt memory and ENXIO if there is no such mapped address in the
 178  * user process's address space.
 179  */
 180 static int
 181 urw(proc_t *p, int writing, void *buf, size_t len, uintptr_t a)
 182 {
 183         caddr_t addr = (caddr_t)a;
 184         caddr_t page;
 185         caddr_t vaddr;
 186         struct seg *seg;
 187         int error = 0;
 188         int err = 0;
 189         uint_t prot;
 190         uint_t prot_rw = writing ? PROT_WRITE : PROT_READ;
 191         int protchanged;
 192         on_trap_data_t otd;
 193         int retrycnt;
 194         struct as *as = p->p_as;
 195         enum seg_rw rw;
 196
 197         /*
 198          * Locate segment containing address of interest.
 199          */
 200         page = (caddr_t)(uintptr_t)((uintptr_t)addr & PAGEMASK);
 201         retrycnt = 0;
 202         AS_LOCK_ENTER(as, RW_WRITER);
 203 retry:
 204         if ((seg = as_segat(as, page)) == NULL ||
 205             !page_valid(seg, page)) {
 206                 AS_LOCK_EXIT(as);
 207                 return (ENXIO);
 208         }
 209         (void) segop_getprot(seg, page, 0, &prot);
 210
 211         protchanged = 0;
 212         if ((prot & prot_rw) == 0) {
 213                 protchanged = 1;
 214                 err = segop_setprot(seg, page, PAGESIZE, prot | prot_rw);
 215
 216                 if (err == IE_RETRY) {
 217                         protchanged = 0;
 218                         ASSERT(retrycnt == 0);
 219                         retrycnt++;
 220                         goto retry;
 221                 }
 222
 223                 if (err != 0) {
 224                         AS_LOCK_EXIT(as);
 225                         return (ENXIO);
 226                 }
 227         }
 228
 229         /*
 230          * segvn may do a copy-on-write for F_SOFTLOCK/S_READ case to break
 231          * sharing to avoid a copy on write of a softlocked page by another
 232          * thread. But since we locked the address space as a writer no other
 233          * thread can cause a copy on write. S_READ_NOCOW is passed as the
 234          * access type to tell segvn that it's ok not to do a copy-on-write
 235          * for this SOFTLOCK fault.
 236          */
 237         if (writing)
 238                 rw = S_WRITE;
 239         else if (seg->s_ops == &segvn_ops)
 240                 rw = S_READ_NOCOW;
 241         else
 242                 rw = S_READ;
 243
 244         if (segop_fault(as->a_hat, seg, page, PAGESIZE, F_SOFTLOCK, rw)) {
 245                 if (protchanged)
 246                         (void) segop_setprot(seg, page, PAGESIZE, prot);
 247                 AS_LOCK_EXIT(as);
 248                 return (ENXIO);
 249         }
 250         CPU_STATS_ADD_K(vm, softlock, 1);
 251
 252         /*
 253          * Make sure we're not trying to read or write off the end of the page.
 254          */
 255         ASSERT(len <= page + PAGESIZE - addr);
 256
 257         /*
 258          * Map in the locked page, copy to our local buffer,
 259          * then map the page out and unlock it.
 260          */
 261         vaddr = mapin(as, addr, writing);
 262
 263         /*
 264          * Since we are copying memory on behalf of the user process,
 265          * protect against memory error correction faults.
 266          */
 267         if (!on_trap(&otd, OT_DATA_EC)) {
 268                 if (seg->s_ops == &segdev_ops) {
 269                         /*
 270                          * Device memory can behave strangely; invoke
 271                          * a segdev-specific copy operation instead.
 272                          */
 273                         if (writing) {
 274                                 if (segdev_copyto(seg, addr, buf, vaddr, len))
 275                                         error = ENXIO;
 276                         } else {
 277                                 if (segdev_copyfrom(seg, addr, vaddr, buf, len))
 278                                         error = ENXIO;
 279                         }
 280                 } else {
 281                         if (writing)
 282                                 bcopy(buf, vaddr, len);
 283                         else
 284                                 bcopy(vaddr, buf, len);
 285                 }
 286         } else {
 287                 error = EIO;
 288         }
 289         no_trap();
 290
 291         /*
 292          * If we're writing to an executable page, we may need to sychronize
 293          * the I$ with the modifications we made through the D$.
 294          */
 295         if (writing && (prot & PROT_EXEC))
 296                 sync_icache(vaddr, (uint_t)len);
 297
 298         mapout(as, addr, vaddr, writing);
 299
 300         if (rw == S_READ_NOCOW)
 301                 rw = S_READ;
 302
 303         (void) segop_fault(as->a_hat, seg, page, PAGESIZE, F_SOFTUNLOCK, rw);
 304
 305         if (protchanged)
 306                 (void) segop_setprot(seg, page, PAGESIZE, prot);
 307
 308         AS_LOCK_EXIT(as);
 309
 310         return (error);
 311 }
 312
 313 int
 314 uread(proc_t *p, void *buf, size_t len, uintptr_t a)
 315 {
 316         return (urw(p, 0, buf, len, a));
 317 }
 318
 319 int
 320 uwrite(proc_t *p, void *buf, size_t len, uintptr_t a)
 321 {
 322         return (urw(p, 1, buf, len, a));
 323 }