sys/miscfs/procfs/procfs_map.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (c) 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Jan-Simon Pendry.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)procfs_status.c     8.3 (Berkeley) 2/17/94
  35  *
  36  *      $FreeBSD: procfs_map.c,v 1.18 1998/12/04 22:54:51 archie Exp $
  37  */
  38
  39 /*
  40  * Copyright (c) 1993 Jan-Simon Pendry
  41  *
  42  * This code is derived from software contributed to Berkeley by
  43  * Jan-Simon Pendry.
  44  *
  45  * Redistribution and use in source and binary forms, with or without
  46  * modification, are permitted provided that the following conditions
  47  * are met:
  48  * 1. Redistributions of source code must retain the above copyright
  49  *    notice, this list of conditions and the following disclaimer.
  50  * 2. Redistributions in binary form must reproduce the above copyright
  51  *    notice, this list of conditions and the following disclaimer in the
  52  *    documentation and/or other materials provided with the distribution.
  53  * 3. All advertising materials mentioning features or use of this software
  54  *    must display the following acknowledgement:
  55  *      This product includes software developed by the University of
  56  *      California, Berkeley and its contributors.
  57  * 4. Neither the name of the University nor the names of its contributors
  58  *    may be used to endorse or promote products derived from this software
  59  *    without specific prior written permission.
  60  *
  61  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  62  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  63  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  64  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  65  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  66  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  67  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  68  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  69  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  70  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  71  * SUCH DAMAGE.
  72  *
  73  *      @(#)procfs_status.c     8.3 (Berkeley) 2/17/94
  74  *
  75  *      $FreeBSD: procfs_map.c,v 1.18 1998/12/04 22:54:51 archie Exp $
  76  */
  77
  78 #include <sys/cdefs.h>
  79 __KERNEL_RCSID(0, "$NetBSD$");
  80
  81 #include <sys/param.h>
  82 #include <sys/systm.h>
  83 #include <sys/proc.h>
  84 #include <sys/vnode.h>
  85 #include <sys/malloc.h>
  86 #include <sys/namei.h>
  87 #include <sys/filedesc.h>
  88 #include <miscfs/procfs/procfs.h>
  89
  90 #include <sys/lock.h>
  91
  92 #include <uvm/uvm.h>
  93
  94 #define BUFFERSIZE (64 * 1024)
  95 #define MAXBUFFERSIZE (256 * 1024)
  96
  97 /*
  98  * The map entries can *almost* be read with programs like cat.  However,
  99  * large maps need special programs to read.  It is not easy to implement
 100  * a program that can sense the required size of the buffer, and then
 101  * subsequently do a read with the appropriate size.  This operation cannot
 102  * be atomic.  The best that we can do is to allow the program to do a read
 103  * with an arbitrarily large buffer, and return as much as we can.  We can
 104  * return an error code if the buffer is too small (EFBIG), then the program
 105  * can try a bigger buffer.
 106  */
 107 int
 108 procfs_domap(struct lwp *curl, struct proc *p, struct pfsnode *pfs,
 109              struct uio *uio, int linuxmode)
 110 {
 111         int error;
 112         struct vmspace *vm;
 113         struct vm_map *map;
 114         struct vm_map_entry *entry;
 115         char *buffer = NULL;
 116         size_t bufsize = BUFFERSIZE;
 117         char *path;
 118         struct vnode *vp;
 119         struct vattr va;
 120         dev_t dev;
 121         long fileid;
 122         size_t pos;
 123
 124         if (uio->uio_rw != UIO_READ)
 125                 return EOPNOTSUPP;
 126
 127         if (uio->uio_offset != 0) {
 128                 /*
 129                  * we return 0 here, so that the second read returns EOF
 130                  * we don't support reading from an offset because the
 131                  * map could have changed between the two reads.
 132                  */
 133                 return 0;
 134         }
 135
 136         error = 0;
 137
 138         if (linuxmode != 0)
 139                 path = malloc(MAXPATHLEN * 4, M_TEMP, M_WAITOK);
 140         else
 141                 path = NULL;
 142
 143         if ((error = proc_vmspace_getref(p, &vm)) != 0)
 144                 goto out;
 145
 146         map = &vm->vm_map;
 147         vm_map_lock_read(map);
 148
 149 again:
 150         buffer = malloc(bufsize, M_TEMP, M_WAITOK);
 151         pos = 0;
 152         for (entry = map->header.next; entry != &map->header;
 153             entry = entry->next) {
 154
 155                 if (UVM_ET_ISSUBMAP(entry))
 156                         continue;
 157
 158                 if (linuxmode != 0) {
 159                         *path = 0;
 160                         dev = (dev_t)0;
 161                         fileid = 0;
 162                         if (UVM_ET_ISOBJ(entry) &&
 163                             UVM_OBJ_IS_VNODE(entry->object.uvm_obj)) {
 164                                 vp = (struct vnode *)entry->object.uvm_obj;
 165                                 error = VOP_GETATTR(vp, &va, curl->l_cred);
 166                                 if (error == 0 && vp != pfs->pfs_vnode) {
 167                                         fileid = va.va_fileid;
 168                                         dev = va.va_fsid;
 169                                         error = vnode_to_path(path,
 170                                             MAXPATHLEN * 4, vp, curl, p);
 171                                 }
 172                         }
 173                         pos += snprintf(buffer + pos, bufsize - pos,
 174                             "%0*lx-%0*lx %c%c%c%c %0*lx %llx:%llx %ld     %s\n",
 175                             (int)sizeof(void *) * 2,(unsigned long)entry->start,
 176                             (int)sizeof(void *) * 2,(unsigned long)entry->end,
 177                             (entry->protection & VM_PROT_READ) ? 'r' : '-',
 178                             (entry->protection & VM_PROT_WRITE) ? 'w' : '-',
 179                             (entry->protection & VM_PROT_EXECUTE) ? 'x' : '-',
 180                             (entry->etype & UVM_ET_COPYONWRITE) ? 'p' : 's',
 181                             (int)sizeof(void *) * 2,
 182                             (unsigned long)entry->offset,
 183                             (unsigned long long)major(dev),
 184                             (unsigned long long)minor(dev), fileid, path);
 185                 } else {
 186                         pos += snprintf(buffer + pos, bufsize - pos,
 187                             "0x%"PRIxVADDR"x 0x%"PRIxVADDR"x %c%c%c %c%c%c %s %s %d %d %d\n",
 188                             entry->start, entry->end,
 189                             (entry->protection & VM_PROT_READ) ? 'r' : '-',
 190                             (entry->protection & VM_PROT_WRITE) ? 'w' : '-',
 191                             (entry->protection & VM_PROT_EXECUTE) ? 'x' : '-',
 192                             (entry->max_protection & VM_PROT_READ) ? 'r' : '-',
 193                             (entry->max_protection & VM_PROT_WRITE) ? 'w' : '-',
 194                             (entry->max_protection & VM_PROT_EXECUTE) ?
 195                                 'x' : '-',
 196                             (entry->etype & UVM_ET_COPYONWRITE) ?
 197                                 "COW" : "NCOW",
 198                             (entry->etype & UVM_ET_NEEDSCOPY) ? "NC" : "NNC",
 199                             entry->inheritance, entry->wired_count,
 200                             entry->advice);
 201                 }
 202                 if (pos >= bufsize) {
 203                         bufsize <<= 1;
 204                         if (bufsize > MAXBUFFERSIZE) {
 205                                 error = ENOMEM;
 206                                 goto out;
 207                         }
 208                         free(buffer, M_TEMP);
 209                         goto again;
 210                 }
 211         }
 212
 213         vm_map_unlock_read(map);
 214         uvmspace_free(vm);
 215
 216         error = uiomove(buffer, pos, uio);
 217 out:
 218         if (path != NULL)
 219                 free(path, M_TEMP);
 220         if (buffer != NULL)
 221                 free(buffer, M_TEMP);
 222
 223         return error;
 224 }
 225
 226 int
 227 procfs_validmap(struct lwp *l, struct mount *mp)
 228 {
 229         return ((l->l_flag & LW_SYSTEM) == 0);
 230 }