sys/vfs/procfs/procfs_map.c

   1 /*
   2  * Copyright (c) 1993 Jan-Simon Pendry
   3  * Copyright (c) 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Jan-Simon Pendry.
   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  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)procfs_status.c     8.3 (Berkeley) 2/17/94
  34  *
  35  * $FreeBSD: src/sys/miscfs/procfs/procfs_map.c,v 1.24.2.1 2001/08/04 13:12:24 rwatson Exp $
  36  * $DragonFly: src/sys/vfs/procfs/procfs_map.c,v 1.7 2007/02/19 01:14:24 corecode Exp $
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/proc.h>
  42 #include <sys/vnode.h>
  43 #include <sys/sbuf.h>
  44 #include <vfs/procfs/procfs.h>
  45
  46 #include <vm/vm.h>
  47 #include <sys/lock.h>
  48 #include <vm/pmap.h>
  49 #include <vm/vm_map.h>
  50 #include <vm/vm_page.h>
  51 #include <vm/vm_object.h>
  52
  53 #include <machine/limits.h>
  54
  55 int
  56 procfs_domap(struct proc *curp, struct lwp *lp, struct pfsnode *pfs,
  57              struct uio *uio)
  58 {
  59         struct proc *p = lp->lwp_proc;
  60         ssize_t buflen = uio->uio_offset + uio->uio_resid;
  61         struct vnode *vp;
  62         char *fullpath, *freepath;
  63         int error;
  64         vm_map_t map = &p->p_vmspace->vm_map;
  65         vm_map_entry_t entry;
  66         struct sbuf *sb = NULL;
  67         unsigned int last_timestamp;
  68
  69         if (uio->uio_rw != UIO_READ)
  70                 return (EOPNOTSUPP);
  71
  72         error = 0;
  73
  74         if (uio->uio_offset < 0 || uio->uio_resid < 0 || buflen >= INT_MAX)
  75                 return EINVAL;
  76         sb = sbuf_new (sb, NULL, buflen+1, 0);
  77         if (sb == NULL)
  78                 return EIO;
  79
  80         /*
  81          * Lock the map so we can access it.  Release the process token
  82          * to avoid unnecessary token stalls while we are processing the
  83          * map.
  84          */
  85         vm_map_lock_read(map);
  86         lwkt_reltoken(&p->p_token);
  87
  88         for (entry = map->header.next; entry != &map->header;
  89                 entry = entry->next) {
  90                 vm_object_t obj, tobj, lobj;
  91                 int ref_count, shadow_count, flags;
  92                 vm_offset_t e_start, e_end;
  93                 vm_eflags_t e_eflags;
  94                 vm_prot_t e_prot;
  95                 int resident, privateresident;
  96                 char *type;
  97
  98                 privateresident = 0;
  99                 switch(entry->maptype) {
 100                 case VM_MAPTYPE_NORMAL:
 101                 case VM_MAPTYPE_VPAGETABLE:
 102                         obj = entry->object.vm_object;
 103                         if (obj != NULL) {
 104                                 vm_object_hold(obj);
 105                                 if (obj->shadow_count == 1)
 106                                         privateresident = obj->resident_page_count;
 107                         }
 108                         break;
 109                 case VM_MAPTYPE_UKSMAP:
 110                         obj = NULL;
 111                         break;
 112                 default:
 113                         /* ignore entry */
 114                         continue;
 115                 }
 116
 117                 e_eflags = entry->eflags;
 118                 e_prot = entry->protection;
 119                 e_start = entry->start;
 120                 e_end = entry->end;
 121
 122                 /*
 123                  * Don't count resident pages, its impossible on 64-bit.
 124                  * A single mapping could be gigabytes or terrabytes.
 125                  */
 126                 resident = -1;
 127 #if 0
 128                 pmap_t pmap = vmspace_pmap(p->p_vmspace);
 129                 vm_offset_t addr;
 130
 131                 resident = 0;
 132                 addr = entry->start;
 133                 while (addr < entry->end) {
 134                         if (pmap_extract(pmap, addr, NULL))
 135                                 resident++;
 136                         addr += PAGE_SIZE;
 137                 }
 138 #endif
 139                 if (obj) {
 140                         lobj = obj;
 141                         while ((tobj = lobj->backing_object) != NULL) {
 142                                 KKASSERT(tobj != obj);
 143                                 vm_object_hold(tobj);
 144                                 if (tobj == lobj->backing_object) {
 145                                         if (lobj != obj) {
 146                                                 vm_object_lock_swap();
 147                                                 vm_object_drop(lobj);
 148                                         }
 149                                         lobj = tobj;
 150                                 } else {
 151                                         vm_object_drop(tobj);
 152                                 }
 153                         }
 154                 } else {
 155                         lobj = NULL;
 156                 }
 157                 last_timestamp = map->timestamp;
 158                 vm_map_unlock(map);
 159
 160                 freepath = NULL;
 161                 fullpath = "-";
 162                 if (lobj) {
 163                         switch(lobj->type) {
 164                         default:
 165                         case OBJT_DEFAULT:
 166                                 type = "default";
 167                                 vp = NULL;
 168                                 break;
 169                         case OBJT_VNODE:
 170                                 type = "vnode";
 171                                 vp = lobj->handle;
 172                                 vref(vp);
 173                                 break;
 174                         case OBJT_SWAP:
 175                                 type = "swap";
 176                                 vp = NULL;
 177                                 break;
 178                         case OBJT_DEVICE:
 179                                 type = "device";
 180                                 vp = NULL;
 181                                 break;
 182                         case OBJT_MGTDEVICE:
 183                                 type = "mgtdevice";
 184                                 vp = NULL;
 185                                 break;
 186                         }
 187                         if (lobj != obj)
 188                                 vm_object_drop(lobj);
 189
 190                         flags = obj->flags;
 191                         ref_count = obj->ref_count;
 192                         shadow_count = obj->shadow_count;
 193                         vm_object_drop(obj);
 194                         if (vp != NULL) {
 195                                 vn_fullpath(p, vp, &fullpath, &freepath, 1);
 196                                 vrele(vp);
 197                         }
 198                 } else {
 199                         flags = 0;
 200                         ref_count = 0;
 201                         shadow_count = 0;
 202                         switch(entry->maptype) {
 203                         case VM_MAPTYPE_UNSPECIFIED:
 204                                 type = "unspec";
 205                                 break;
 206                         case VM_MAPTYPE_NORMAL:
 207                                 type = "none";
 208                                 break;
 209                         case VM_MAPTYPE_VPAGETABLE:
 210                                 type = "vpgtbl";
 211                                 break;
 212                         case VM_MAPTYPE_SUBMAP:
 213                                 type = "submap";
 214                                 break;
 215                         case VM_MAPTYPE_UKSMAP:
 216                                 type = "uksmap";
 217                                 break;
 218                         default:
 219                                 type = "unknown";
 220                                 break;
 221                         }
 222                 }
 223
 224                 /*
 225                  * format:
 226                  *  start, end, res, priv res, cow, access, type, (fullpath).
 227                  */
 228                 error = sbuf_printf(sb,
 229 #if LONG_BIT == 64
 230                           "0x%016lx 0x%016lx %d %d %p %s%s%s %d %d "
 231 #else
 232                           "0x%08lx 0x%08lx %d %d %p %s%s%s %d %d "
 233 #endif
 234                           "0x%04x %s %s %s %s\n",
 235                         (u_long)e_start, (u_long)e_end,
 236                         resident, privateresident, obj,
 237                         (e_prot & VM_PROT_READ)?"r":"-",
 238                         (e_prot & VM_PROT_WRITE)?"w":"-",
 239                         (e_prot & VM_PROT_EXECUTE)?"x":"-",
 240                         ref_count, shadow_count, flags,
 241                         (e_eflags & MAP_ENTRY_COW)?"COW":"NCOW",
 242                         (e_eflags & MAP_ENTRY_NEEDS_COPY)?"NC":"NNC",
 243                         type, fullpath);
 244
 245                 if (freepath != NULL) {
 246                         kfree(freepath, M_TEMP);
 247                         freepath = NULL;
 248                 }
 249
 250                 vm_map_lock_read(map);
 251                 if (error == -1) {
 252                         error = 0;
 253                         break;
 254                 }
 255
 256                 if (last_timestamp != map->timestamp) {
 257                         vm_map_entry_t reentry;
 258                         vm_map_lookup_entry(map, e_start, &reentry);
 259                         entry = reentry;
 260                 }
 261         }
 262         vm_map_unlock_read(map);
 263         if (sbuf_finish(sb) == 0)
 264                 buflen = sbuf_len(sb);
 265         error = uiomove_frombuf(sbuf_data(sb), buflen, uio);
 266         sbuf_delete(sb);
 267
 268         lwkt_gettoken(&p->p_token);     /* re-acquire */
 269
 270         return error;
 271 }
 272
 273 int
 274 procfs_validmap(struct lwp *lp)
 275 {
 276         return ((lp->lwp_proc->p_flags & P_SYSTEM) == 0);
 277 }