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 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright 2015, Joyent, Inc.
27 */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <string.h>
34 #include <limits.h>
35
36 #include "Pcontrol.h"
37
38 /*
39 * These several routines simply get the indicated /proc structures
40 * for a process identified by process ID. They are convenience
41 * functions for one-time operations. They do the mechanics of
42 * open() / read() / close() of the necessary /proc files so the
43 * caller's code can look relatively less cluttered.
44 */
45
46 /*
47 * 'ngroups' is the number of supplementary group entries allocated in
48 * the caller's cred structure. It should equal zero or one unless extra
49 * space has been allocated for the group list by the caller, like this:
50 * credp = malloc(sizeof (prcred_t) + (ngroups - 1) * sizeof (gid_t));
51 */
52 int
53 proc_get_cred(pid_t pid, prcred_t *credp, int ngroups)
54 {
55 char fname[PATH_MAX];
56 int fd;
57 int rv = -1;
58 ssize_t minsize = sizeof (*credp) - sizeof (gid_t);
59 size_t size = minsize + ngroups * sizeof (gid_t);
60
61 (void) snprintf(fname, sizeof (fname), "%s/%d/cred",
62 procfs_path, (int)pid);
63 if ((fd = open(fname, O_RDONLY)) >= 0) {
64 if (read(fd, credp, size) >= minsize)
65 rv = 0;
66 (void) close(fd);
67 }
68 return (rv);
69 }
70
71 void
72 proc_free_priv(prpriv_t *prv)
73 {
74 free(prv);
75 }
76
77 /*
78 * Malloc and return a properly sized structure.
79 */
80 prpriv_t *
81 proc_get_priv(pid_t pid)
82 {
83 char fname[PATH_MAX];
84 int fd;
85 struct stat statb;
86 prpriv_t *rv = NULL;
87
88 (void) snprintf(fname, sizeof (fname), "%s/%d/priv",
89 procfs_path, (int)pid);
90 if ((fd = open(fname, O_RDONLY)) >= 0) {
91 if (fstat(fd, &statb) != 0 ||
92 (rv = malloc(statb.st_size)) == NULL ||
93 read(fd, rv, statb.st_size) != statb.st_size) {
94 free(rv);
95 rv = NULL;
96 }
97 (void) close(fd);
98 }
99 return (rv);
100 }
101
102 #if defined(__i386) || defined(__amd64)
103 /*
104 * Fill in a pointer to a process LDT structure.
105 * The caller provides a buffer of size 'nldt * sizeof (struct ssd)';
106 * If pldt == NULL or nldt == 0, we return the number of existing LDT entries.
107 * Otherwise we return the actual number of LDT entries fetched (<= nldt).
108 */
109 int
110 proc_get_ldt(pid_t pid, struct ssd *pldt, int nldt)
111 {
112 char fname[PATH_MAX];
113 int fd;
114 struct stat statb;
115 size_t size;
116 ssize_t ssize;
117
118 (void) snprintf(fname, sizeof (fname), "%s/%d/ldt",
119 procfs_path, (int)pid);
120 if ((fd = open(fname, O_RDONLY)) < 0)
121 return (-1);
122
123 if (pldt == NULL || nldt == 0) {
124 nldt = 0;
125 if (fstat(fd, &statb) == 0)
126 nldt = statb.st_size / sizeof (struct ssd);
127 (void) close(fd);
128 return (nldt);
129 }
130
131 size = nldt * sizeof (struct ssd);
132 if ((ssize = read(fd, pldt, size)) < 0)
133 nldt = -1;
134 else
135 nldt = ssize / sizeof (struct ssd);
136
137 (void) close(fd);
138 return (nldt);
139 }
140 #endif /* __i386 || __amd64 */
141
142 int
143 proc_get_psinfo(pid_t pid, psinfo_t *psp)
144 {
145 char fname[PATH_MAX];
146 int fd;
147 int rv = -1;
148
149 (void) snprintf(fname, sizeof (fname), "%s/%d/psinfo",
150 procfs_path, (int)pid);
151 if ((fd = open(fname, O_RDONLY)) >= 0) {
152 if (read(fd, psp, sizeof (*psp)) == sizeof (*psp))
153 rv = 0;
154 (void) close(fd);
155 }
156 return (rv);
157 }
158
159 int
160 proc_get_status(pid_t pid, pstatus_t *psp)
161 {
162 char fname[PATH_MAX];
163 int fd;
164 int rv = -1;
165
166 (void) snprintf(fname, sizeof (fname), "%s/%d/status",
167 procfs_path, (int)pid);
168 if ((fd = open(fname, O_RDONLY)) >= 0) {
169 if (read(fd, psp, sizeof (*psp)) == sizeof (*psp))
170 rv = 0;
171 (void) close(fd);
172 }
173 return (rv);
174 }
175
176 /*
177 * Get the process's aux vector.
178 * 'naux' is the number of aux entries in the caller's buffer.
179 * We return the number of aux entries actually fetched from
180 * the process (less than or equal to 'naux') or -1 on failure.
181 */
182 int
183 proc_get_auxv(pid_t pid, auxv_t *pauxv, int naux)
184 {
185 char fname[PATH_MAX];
186 int fd;
187 int rv = -1;
188
189 (void) snprintf(fname, sizeof (fname), "%s/%d/auxv",
190 procfs_path, (int)pid);
191 if ((fd = open(fname, O_RDONLY)) >= 0) {
192 if ((rv = read(fd, pauxv, naux * sizeof (auxv_t))) >= 0)
193 rv /= sizeof (auxv_t);
194 (void) close(fd);
195 }
196 return (rv);
197 }