POSIX.1-2003: Changing the group ID is permitted to a process with an
[dragonfly.git] / 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. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by the University of
20  *      California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *      @(#)procfs_status.c     8.3 (Berkeley) 2/17/94
38  *
39  * $FreeBSD: src/sys/miscfs/procfs/procfs_map.c,v 1.24.2.1 2001/08/04 13:12:24 rwatson Exp $
40  * $DragonFly: src/sys/vfs/procfs/procfs_map.c,v 1.4 2004/05/02 03:05:11 cpressey Exp $
41  */
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/proc.h>
46 #include <sys/vnode.h>
47 #include <vfs/procfs/procfs.h>
48
49 #include <vm/vm.h>
50 #include <sys/lock.h>
51 #include <vm/pmap.h>
52 #include <vm/vm_map.h>
53 #include <vm/vm_page.h>
54 #include <vm/vm_object.h>
55
56
57 #define MEBUFFERSIZE 256
58
59 /*
60  * The map entries can *almost* be read with programs like cat.  However,
61  * large maps need special programs to read.  It is not easy to implement
62  * a program that can sense the required size of the buffer, and then
63  * subsequently do a read with the appropriate size.  This operation cannot
64  * be atomic.  The best that we can do is to allow the program to do a read
65  * with an arbitrarily large buffer, and return as much as we can.  We can
66  * return an error code if the buffer is too small (EFBIG), then the program
67  * can try a bigger buffer.
68  */
69 int
70 procfs_domap(struct proc *curp, struct proc *p, struct pfsnode *pfs,
71              struct uio *uio)
72 {
73         int len;
74         int error;
75         vm_map_t map = &p->p_vmspace->vm_map;
76         pmap_t pmap = vmspace_pmap(p->p_vmspace);
77         vm_map_entry_t entry;
78         char mebuffer[MEBUFFERSIZE];
79
80         if (uio->uio_rw != UIO_READ)
81                 return (EOPNOTSUPP);
82
83         if (uio->uio_offset != 0)
84                 return (0);
85         
86         error = 0;
87         if (map != &curproc->p_vmspace->vm_map)
88                 vm_map_lock_read(map);
89         for (entry = map->header.next;
90                 ((uio->uio_resid > 0) && (entry != &map->header));
91                 entry = entry->next) {
92                 vm_object_t obj, tobj, lobj;
93                 int ref_count, shadow_count, flags;
94                 vm_offset_t addr;
95                 int resident, privateresident;
96                 char *type;
97
98                 if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
99                         continue;
100
101                 obj = entry->object.vm_object;
102                 if (obj && (obj->shadow_count == 1))
103                         privateresident = obj->resident_page_count;
104                 else
105                         privateresident = 0;
106
107                 resident = 0;
108                 addr = entry->start;
109                 while (addr < entry->end) {
110                         if (pmap_extract( pmap, addr))
111                                 resident++;
112                         addr += PAGE_SIZE;
113                 }
114
115                 for( lobj = tobj = obj; tobj; tobj = tobj->backing_object)
116                         lobj = tobj;
117
118                 if (lobj) {
119                         switch(lobj->type) {
120
121 default:
122 case OBJT_DEFAULT:
123                                 type = "default";
124                                 break;
125 case OBJT_VNODE:
126                                 type = "vnode";
127                                 break;
128 case OBJT_SWAP:
129                                 type = "swap";
130                                 break;
131 case OBJT_DEVICE:
132                                 type = "device";
133                                 break;
134                         }
135                         
136                         flags = obj->flags;
137                         ref_count = obj->ref_count;
138                         shadow_count = obj->shadow_count;
139                 } else {
140                         type = "none";
141                         flags = 0;
142                         ref_count = 0;
143                         shadow_count = 0;
144                 }
145                         
146
147                 /*
148                  * format:
149                  *  start, end, resident, private resident, cow, access, type.
150                  */
151                 snprintf(mebuffer, sizeof(mebuffer),
152                     "0x%lx 0x%lx %d %d %p %s%s%s %d %d 0x%x %s %s %s\n",
153                         (u_long)entry->start, (u_long)entry->end,
154                         resident, privateresident, obj,
155                         (entry->protection & VM_PROT_READ)?"r":"-",
156                         (entry->protection & VM_PROT_WRITE)?"w":"-",
157                         (entry->protection & VM_PROT_EXECUTE)?"x":"-",
158                         ref_count, shadow_count, flags,
159                         (entry->eflags & MAP_ENTRY_COW)?"COW":"NCOW",
160                         (entry->eflags & MAP_ENTRY_NEEDS_COPY)?"NC":"NNC",
161                         type);
162
163                 len = strlen(mebuffer);
164                 if (len > uio->uio_resid) {
165                         error = EFBIG;
166                         break;
167                 }
168                 error = uiomove(mebuffer, len, uio);
169                 if (error)
170                         break;
171         }
172         if (map != &curproc->p_vmspace->vm_map)
173                 vm_map_unlock_read(map);
174
175         return error;
176 }
177
178 int
179 procfs_validmap(struct proc *p)
180 {
181         return ((p->p_flag & P_SYSTEM) == 0);
182 }