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 (c) 2013 Gary Mills
23 *
24 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 *
27 * Portions Copyright 2009 Chad Mynhier
28 */
29
30 #include <sys/types.h>
31 #include <sys/param.h>
32 #include <sys/resource.h>
33 #include <sys/priocntl.h>
34 #include <sys/rtpriocntl.h>
35 #include <sys/tspriocntl.h>
36 #include <zone.h>
37
38 #include <libintl.h>
39 #include <limits.h>
40 #include <wchar.h>
41 #include <unistd.h>
42 #include <string.h>
43 #include <stdlib.h>
44 #include <stdarg.h>
45 #include <stdio.h>
46 #include <stdio_ext.h>
47 #include <errno.h>
48 #include <ctype.h>
49 #include <poll.h>
50 #include <project.h>
51
52 #include "prfile.h"
53 #include "prstat.h"
54 #include "prutil.h"
55
56 static char PRG_FMT[] = "%s: ";
57 static char ERR_FMT[] = ": %s\n";
58 static char *progname;
59 static char projbuf[PROJECT_BUFSZ];
60
61 #define RLIMIT_NOFILE_MAX 32767
62
63 /*PRINTFLIKE1*/
64 void
65 Warn(char *format, ...)
66 {
67 int err = errno;
68 va_list alist;
69
70 if (progname != NULL)
71 (void) fprintf(stderr, PRG_FMT, progname);
72 va_start(alist, format);
73 (void) vfprintf(stderr, format, alist);
74 va_end(alist);
75 if (strchr(format, '\n') == NULL)
76 (void) fprintf(stderr, gettext(ERR_FMT), strerror(err));
77 }
78
79 /*PRINTFLIKE1*/
80 void
81 Die(char *format, ...)
82 {
83 int err = errno;
84 va_list alist;
85
86 if (progname != NULL)
87 (void) fprintf(stderr, PRG_FMT, progname);
88 va_start(alist, format);
89 (void) vfprintf(stderr, format, alist);
90 va_end(alist);
91 if (strchr(format, '\n') == NULL)
92 (void) fprintf(stderr, gettext(ERR_FMT), strerror(err));
93 exit(1);
94 }
95
96 void
97 Progname(char *arg0)
98 {
99 char *p = strrchr(arg0, '/');
100 if (p == NULL)
101 p = arg0;
102 else
103 p++;
104 progname = p;
105 }
106
107 void
108 Usage()
109 {
110 (void) fprintf(stderr, gettext(
111 "Usage:\tprstat [-acHJLmrRtTvZ] [-u euidlist] [-U uidlist]\n"
112 "\t[-p pidlist] [-P cpulist] [-C psrsetlist] [-h lgrouplist]\n"
113 "\t[-j projidlist] [-k taskidlist] [-z zoneidlist]\n"
114 "\t[-s key | -S key] [-n nprocs[,nusers]] [-d d|u]\n"
115 "\t[interval [counter]]\n"));
116 exit(1);
117 }
118
119 int
120 Atoi(char *p)
121 {
122 int i;
123 char *q;
124 errno = 0;
125 i = (int)strtol(p, &q, 10);
126 if (errno != 0 || q == p || i < 0 || *q != '\0')
127 Die(gettext("illegal argument -- %s\n"), p);
128 /*NOTREACHED*/
129 else
130 return (i);
131 return (0); /* keep gcc happy */
132 }
133
134 void
135 Format_size(char *str, size_t size, int length)
136 {
137 char tag = 'K';
138 if (size >= 10000) {
139 size = (size + 512) / 1024;
140 tag = 'M';
141 if (size >= 10000) {
142 size = (size + 512) / 1024;
143 tag = 'G';
144 }
145 }
146 (void) snprintf(str, length, "%4d%c", (int)size, tag);
147 }
148
149 void
150 Format_time(char *str, ulong_t time, int length)
151 {
152 (void) snprintf(str, length, gettext("%3d:%2.2d:%2.2d"), /* hr:mm:ss */
153 (int)time/3600, (int)(time % 3600)/60, (int)time % 60);
154 }
155
156 void
157 Format_pct(char *str, float val, int length)
158 {
159 if (val > (float)100)
160 val = 100;
161 if (val < 0)
162 val = 0;
163
164 if (val < (float)9.95)
165 (void) snprintf(str, length, "%1.1f", val);
166 else
167 (void) snprintf(str, length, "%.0f", val);
168 }
169
170 void
171 Format_num(char *str, int num, int length)
172 {
173 if (num >= 100000) {
174 (void) snprintf(str, length, ".%1dM", num/100000);
175 } else {
176 if (num >= 1000)
177 (void) snprintf(str, length, "%2dK", num/1000);
178 else
179 (void) snprintf(str, length, "%3d", num);
180 }
181 }
182
183 void
184 Format_state(char *str, char state, processorid_t pr_id, int length)
185 {
186 switch (state) {
187 case 'S':
188 (void) strncpy(str, "sleep", length);
189 break;
190 case 'R':
191 (void) strncpy(str, "run", length);
192 break;
193 case 'Z':
194 (void) strncpy(str, "zombie", length);
195 break;
196 case 'T':
197 (void) strncpy(str, "stop", length);
198 break;
199 case 'I':
200 (void) strncpy(str, "idle", length);
201 break;
202 case 'W':
203 (void) strncpy(str, "wait", length);
204 break;
205 case 'O':
206 (void) snprintf(str, length, "cpu%-3d", (int)pr_id);
207 break;
208 default:
209 (void) strncpy(str, "?", length);
210 break;
211 }
212 }
213
214 void *
215 Realloc(void *ptr, size_t size)
216 {
217 int cnt = 0;
218 void *sav = ptr;
219
220 eagain: if ((ptr = realloc(ptr, size)))
221 return (ptr);
222
223 if ((++cnt <= 3) && (errno == EAGAIN)) {
224 Warn(gettext("realloc() failed, attempt %d"), cnt);
225 (void) poll(NULL, 0, 5000); /* wait for 5 seconds */
226 ptr = sav;
227 goto eagain;
228 }
229 ptr = sav;
230 Die(gettext("not enough memory"));
231 /*NOTREACHED*/
232 return (NULL); /* keep gcc happy */
233 }
234
235 void *
236 Malloc(size_t size)
237 {
238 return (Realloc(NULL, size));
239 }
240
241 void *
242 Zalloc(size_t size)
243 {
244 return (memset(Realloc(NULL, size), 0, size));
245 }
246
247 int
248 Setrlimit()
249 {
250 struct rlimit rlim;
251 int fd_limit;
252 if (getrlimit(RLIMIT_NOFILE, &rlim) == -1)
253 Die(gettext("getrlimit failed"));
254 fd_limit = rlim.rlim_cur;
255 rlim.rlim_max = MIN(rlim.rlim_max, RLIMIT_NOFILE_MAX);
256 rlim.rlim_cur = rlim.rlim_max;
257 (void) enable_extended_FILE_stdio(-1, -1);
258 if (setrlimit(RLIMIT_NOFILE, &rlim) == -1)
259 return (fd_limit);
260 else
261 return (rlim.rlim_cur);
262 }
263
264 void
265 Priocntl(char *class)
266 {
267 pcinfo_t pcinfo;
268 pcparms_t pcparms;
269 (void) strcpy(pcinfo.pc_clname, class);
270 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) {
271 Warn(gettext("cannot get real time class parameters"));
272 return;
273 }
274 pcparms.pc_cid = pcinfo.pc_cid;
275 ((rtparms_t *)pcparms.pc_clparms)->rt_pri = 0;
276 ((rtparms_t *)pcparms.pc_clparms)->rt_tqsecs = 0;
277 ((rtparms_t *)pcparms.pc_clparms)->rt_tqnsecs = RT_NOCHANGE;
278 if (priocntl(P_PID, getpid(), PC_SETPARMS, (caddr_t)&pcparms) == -1)
279 Warn(gettext("cannot enter the real time class"));
280 }
281
282 void
283 getprojname(projid_t projid, char *str, size_t len, int noresolve,
284 int termcap, size_t width)
285 {
286 struct project proj;
287 size_t n;
288
289 if (noresolve || getprojbyid(projid, &proj, projbuf, PROJECT_BUFSZ) ==
290 NULL) {
291 (void) snprintf(str, len, "%-6d", (int)projid);
292 } else {
293 n = strlen(proj.pj_name);
294 if (termcap && n > width)
295 (void) snprintf(str, len, "%.*s%c", width - 1,
296 proj.pj_name, '*');
297 else
298 (void) snprintf(str, len, "%-28s", proj.pj_name);
299 }
300 }
301
302 void
303 getzonename(zoneid_t zoneid, char *str, size_t len, int termcap, size_t width)
304 {
305 char zone_name[ZONENAME_MAX];
306 size_t n;
307
308 if (getzonenamebyid(zoneid, zone_name, sizeof (zone_name)) < 0) {
309 (void) snprintf(str, len, "%-6d", (int)zoneid);
310 } else {
311 n = strlen(zone_name);
312 if (termcap && n > width)
313 (void) snprintf(str, len, "%.*s%c", width - 1,
314 zone_name, '*');
315 else
316 (void) snprintf(str, len, "%-28s", zone_name);
317 }
318 }
319
320 /*
321 * Remove all unprintable characters from process name
322 */
323 void
324 stripfname(char *buf)
325 {
326 int bytesleft = PRFNSZ;
327 wchar_t wchar;
328 int length;
329 char *cp;
330
331 buf[bytesleft - 1] = '\0';
332
333 for (cp = buf; *cp != '\0'; cp += length) {
334 length = mbtowc(&wchar, cp, MB_LEN_MAX);
335 if (length <= 0) {
336 *cp = '\0';
337 break;
338 }
339 if (!iswprint(wchar)) {
340 if (bytesleft <= length) {
341 *cp = '\0';
342 break;
343 }
344 (void) memmove(cp, cp + length, bytesleft - length);
345 length = 0;
346 }
347 bytesleft -= length;
348 }
349 }