xref: /illumos-gate/usr/src/cmd/prstat/prutil.c (revision ab618543)
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  * Copyright 2018 Joyent, Inc.  All rights reserved.
29  */
30 
31 #include <sys/types.h>
32 #include <sys/param.h>
33 #include <sys/resource.h>
34 #include <sys/priocntl.h>
35 #include <sys/rtpriocntl.h>
36 #include <sys/tspriocntl.h>
37 #include <zone.h>
38 
39 #include <libintl.h>
40 #include <limits.h>
41 #include <wchar.h>
42 #include <unistd.h>
43 #include <string.h>
44 #include <stdlib.h>
45 #include <stdarg.h>
46 #include <stdio.h>
47 #include <stdio_ext.h>
48 #include <errno.h>
49 #include <ctype.h>
50 #include <poll.h>
51 #include <project.h>
52 
53 #include "prfile.h"
54 #include "prstat.h"
55 #include "prutil.h"
56 
57 static char PRG_FMT[] = "%s: ";
58 static char ERR_FMT[] = ": %s\n";
59 static char *progname;
60 static char projbuf[PROJECT_BUFSZ];
61 
62 #define	RLIMIT_NOFILE_MAX	32767
63 
64 /*PRINTFLIKE1*/
65 void
Warn(char * format,...)66 Warn(char *format, ...)
67 {
68 	int err = errno;
69 	va_list alist;
70 
71 	if (progname != NULL)
72 		(void) fprintf(stderr, PRG_FMT, progname);
73 	va_start(alist, format);
74 	(void) vfprintf(stderr, format, alist);
75 	va_end(alist);
76 	if (strchr(format, '\n') == NULL)
77 		(void) fprintf(stderr, gettext(ERR_FMT), strerror(err));
78 }
79 
80 /*PRINTFLIKE1*/
81 void
Die(char * format,...)82 Die(char *format, ...)
83 {
84 	int err = errno;
85 	va_list alist;
86 
87 	if (progname != NULL)
88 		(void) fprintf(stderr, PRG_FMT, progname);
89 	va_start(alist, format);
90 	(void) vfprintf(stderr, format, alist);
91 	va_end(alist);
92 	if (strchr(format, '\n') == NULL)
93 		(void) fprintf(stderr, gettext(ERR_FMT), strerror(err));
94 	exit(1);
95 }
96 
97 void
Progname(char * arg0)98 Progname(char *arg0)
99 {
100 	char *p = strrchr(arg0, '/');
101 	if (p == NULL)
102 		p = arg0;
103 	else
104 		p++;
105 	progname = p;
106 }
107 
108 void
Usage()109 Usage()
110 {
111 	(void) fprintf(stderr, gettext(
112 	    "Usage:\tprstat [-acHJLmrRtTvWZ] [-u euidlist] [-U uidlist]\n"
113 	    "\t[-p pidlist] [-P cpulist] [-C psrsetlist] [-h lgrouplist]\n"
114 	    "\t[-j projidlist] [-k taskidlist] [-z zoneidlist]\n"
115 	    "\t[-s key | -S key] [-n nprocs[,nusers]] [-d d|u]\n"
116 	    "\t[interval [counter]]\n"));
117 	exit(1);
118 }
119 
120 int
Atoi(char * p)121 Atoi(char *p)
122 {
123 	int i;
124 	char *q;
125 	errno = 0;
126 	i = (int)strtol(p, &q, 10);
127 	if (errno != 0 || q == p || i < 0 || *q != '\0')
128 		Die(gettext("illegal argument -- %s\n"), p);
129 		/*NOTREACHED*/
130 	else
131 		return (i);
132 	return (0);	/* keep gcc happy */
133 }
134 
135 void
Format_size(char * str,size_t size,int length)136 Format_size(char *str, size_t size, int length)
137 {
138 	char tag = 'K';
139 	if (size >= 10000) {
140 		size = (size + 512) / 1024;
141 		tag = 'M';
142 		if (size >= 10000) {
143 			size = (size + 512) / 1024;
144 			tag = 'G';
145 		}
146 	}
147 	(void) snprintf(str, length, "%4d%c", (int)size, tag);
148 }
149 
150 void
Format_time(char * str,ulong_t time,int length)151 Format_time(char *str, ulong_t time, int length)
152 {
153 	(void) snprintf(str, length, gettext("%3d:%2.2d:%2.2d"), /* hr:mm:ss */
154 	    (int)time/3600, (int)(time % 3600)/60, (int)time % 60);
155 }
156 
157 void
Format_pct(char * str,float val,int length)158 Format_pct(char *str, float val, int length)
159 {
160 	if (val > (float)100)
161 		val = 100;
162 	if (val < 0)
163 		val = 0;
164 
165 	if (val < (float)9.95)
166 		(void) snprintf(str, length, "%1.1f", val);
167 	else
168 		(void) snprintf(str, length, "%.0f", val);
169 }
170 
171 void
Format_num(char * str,int num,int length)172 Format_num(char *str, int num, int length)
173 {
174 	if (num >= 100000) {
175 		(void) snprintf(str, length, ".%1dM", num/100000);
176 	} else {
177 		if (num >= 1000)
178 			(void) snprintf(str, length, "%2dK", num/1000);
179 		else
180 			(void) snprintf(str, length, "%3d", num);
181 	}
182 }
183 
184 void
Format_state(char * str,char state,processorid_t pr_id,int length)185 Format_state(char *str, char state, processorid_t pr_id, int length)
186 {
187 	switch (state) {
188 	case 'S':
189 		(void) strncpy(str, "sleep", length);
190 		break;
191 	case 'R':
192 		(void) strncpy(str, "run", length);
193 		break;
194 	case 'Z':
195 		(void) strncpy(str, "zombie", length);
196 		break;
197 	case 'T':
198 		(void) strncpy(str, "stop", length);
199 		break;
200 	case 'I':
201 		(void) strncpy(str, "idle", length);
202 		break;
203 	case 'W':
204 		(void) strncpy(str, "wait", length);
205 		break;
206 	case 'O':
207 		(void) snprintf(str, length, "cpu%-3d", (int)pr_id);
208 		break;
209 	default:
210 		(void) strncpy(str, "?", length);
211 		break;
212 	}
213 }
214 
215 void *
Realloc(void * ptr,size_t size)216 Realloc(void *ptr, size_t size)
217 {
218 	int	cnt = 0;
219 	void	*sav = ptr;
220 
221 eagain:	if ((ptr = realloc(ptr, size)))
222 		return (ptr);
223 
224 	if ((++cnt <= 3) && (errno == EAGAIN)) {
225 		Warn(gettext("realloc() failed, attempt %d"), cnt);
226 		(void) poll(NULL, 0, 5000); /* wait for 5 seconds */
227 		ptr = sav;
228 		goto eagain;
229 	}
230 	ptr = sav;
231 	Die(gettext("not enough memory"));
232 	/*NOTREACHED*/
233 	return (NULL);	/* keep gcc happy */
234 }
235 
236 void *
Malloc(size_t size)237 Malloc(size_t size)
238 {
239 	return (Realloc(NULL, size));
240 }
241 
242 void *
Zalloc(size_t size)243 Zalloc(size_t size)
244 {
245 	return (memset(Realloc(NULL, size), 0, size));
246 }
247 
248 int
Setrlimit()249 Setrlimit()
250 {
251 	struct rlimit rlim;
252 	int fd_limit;
253 	if (getrlimit(RLIMIT_NOFILE, &rlim) == -1)
254 		Die(gettext("getrlimit failed"));
255 	fd_limit = rlim.rlim_cur;
256 	rlim.rlim_max = MIN(rlim.rlim_max, RLIMIT_NOFILE_MAX);
257 	rlim.rlim_cur = rlim.rlim_max;
258 	(void) enable_extended_FILE_stdio(-1, -1);
259 	if (setrlimit(RLIMIT_NOFILE, &rlim) == -1)
260 		return (fd_limit);
261 	else
262 		return (rlim.rlim_cur);
263 }
264 
265 void
Priocntl(char * class)266 Priocntl(char *class)
267 {
268 	pcinfo_t pcinfo;
269 	pcparms_t pcparms;
270 	(void) strcpy(pcinfo.pc_clname, class);
271 	if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) {
272 		Warn(gettext("cannot get real time class parameters"));
273 		return;
274 	}
275 	pcparms.pc_cid = pcinfo.pc_cid;
276 	((rtparms_t *)pcparms.pc_clparms)->rt_pri = 0;
277 	((rtparms_t *)pcparms.pc_clparms)->rt_tqsecs = 0;
278 	((rtparms_t *)pcparms.pc_clparms)->rt_tqnsecs = RT_NOCHANGE;
279 	if (priocntl(P_PID, getpid(), PC_SETPARMS, (caddr_t)&pcparms) == -1)
280 		Warn(gettext("cannot enter the real time class"));
281 }
282 
283 void
getprojname(projid_t projid,char * str,size_t len,int noresolve,int trunc,size_t width)284 getprojname(projid_t projid, char *str, size_t len, int noresolve,
285     int trunc, size_t width)
286 {
287 	struct project proj;
288 	size_t n;
289 
290 	if (noresolve || getprojbyid(projid, &proj, projbuf, PROJECT_BUFSZ) ==
291 	    NULL) {
292 		(void) snprintf(str, len, "%-6d", (int)projid);
293 	} else {
294 		n = mbstowcs(NULL, proj.pj_name, 0);
295 		if (n == (size_t)-1)
296 			(void) snprintf(str, len, "%-28s", "ERROR");
297 		else if (trunc && n > width)
298 			(void) snprintf(str, len, "%.*s%c", width - 1,
299 			    proj.pj_name, '*');
300 		else
301 			(void) snprintf(str, len, "%-28s", proj.pj_name);
302 	}
303 }
304 
305 void
getzonename(zoneid_t zoneid,char * str,size_t len,int trunc,size_t width)306 getzonename(zoneid_t zoneid, char *str, size_t len, int trunc, size_t width)
307 {
308 	char zone_name[ZONENAME_MAX];
309 	size_t n;
310 
311 	if (getzonenamebyid(zoneid, zone_name, sizeof (zone_name)) < 0) {
312 		(void) snprintf(str, len, "%-6d", (int)zoneid);
313 	} else {
314 		n = mbstowcs(NULL, zone_name, 0);
315 		if (n == (size_t)-1)
316 			(void) snprintf(str, len, "%-28s", "ERROR");
317 		else if (trunc && n > width)
318 			(void) snprintf(str, len, "%.*s%c", width - 1,
319 			    zone_name, '*');
320 		else
321 			(void) snprintf(str, len, "%-28s", zone_name);
322 	}
323 }
324 
325 /*
326  * Remove all unprintable characters from process name
327  */
328 static void
stripfname(char * buf,size_t bufsize,const char * pname)329 stripfname(char *buf, size_t bufsize, const char *pname)
330 {
331 	int bytesleft = PRFNSZ;
332 	wchar_t wchar;
333 	int length;
334 	char *cp;
335 
336 	(void) strlcpy(buf, pname, bufsize);
337 
338 	buf[bytesleft - 1] = '\0';
339 
340 	for (cp = buf; *cp != '\0'; cp += length) {
341 		length = mbtowc(&wchar, cp, MB_LEN_MAX);
342 		if (length <= 0) {
343 			*cp = '\0';
344 			break;
345 		}
346 		if (!iswprint(wchar)) {
347 			if (bytesleft <= length) {
348 				*cp = '\0';
349 				break;
350 			}
351 			(void) memmove(cp, cp + length, bytesleft - length);
352 			length = 0;
353 		}
354 		bytesleft -= length;
355 	}
356 }
357 
358 
359 /*
360  * prstat has always implicitly wanted a terminal width of at least 80 columns
361  * (when a TTY is present).  If run in a terminal narrower than 80 columns,
362  * prstat output may wrap.  For wider terminals, we allow the last column to use
363  * the additional space.
364  *
365  * We never truncate if using -c, or not outputting to a TTY.
366  */
367 static int
format_namewidth(void)368 format_namewidth(void)
369 {
370 	int prefixlen = 0;
371 
372 	if (opts.o_cols == 0 || !(opts.o_outpmode & (OPT_TERMCAP | OPT_TRUNC)))
373 		return (0);
374 
375 	if (opts.o_outpmode & OPT_PSINFO) {
376 		if (opts.o_outpmode & OPT_LGRP)
377 			prefixlen = 64;
378 		else
379 			prefixlen = 59;
380 	} else if (opts.o_outpmode & OPT_MSACCT) {
381 		prefixlen = 64;
382 	}
383 
384 	return (opts.o_cols - prefixlen);
385 }
386 
387 void
format_name(lwp_info_t * lwp,char * buf,size_t buflen)388 format_name(lwp_info_t *lwp, char *buf, size_t buflen)
389 {
390 	int pname_width = PRFNSZ;
391 	char nr_suffix[20];
392 	char pname[PRFNSZ];
393 	int width;
394 	int n;
395 
396 	stripfname(pname, sizeof (pname), lwp->li_info.pr_fname);
397 
398 	if (opts.o_outpmode & OPT_LWPS) {
399 		n = snprintf(nr_suffix, sizeof (nr_suffix), "%d",
400 		    lwp->li_info.pr_lwp.pr_lwpid);
401 	} else {
402 		n = snprintf(nr_suffix, sizeof (nr_suffix), "%d",
403 		    lwp->li_info.pr_nlwp + lwp->li_info.pr_nzomb);
404 	}
405 
406 	width = format_namewidth();
407 
408 	/* If we're over budget, truncate the process name not the LWP part. */
409 	if (strlen(pname) > (width - n - 1)) {
410 		pname_width = width - n - 1;
411 		pname[pname_width - 1] = '*';
412 	}
413 
414 	if ((opts.o_outpmode & OPT_LWPS) && lwp->li_lwpname[0] != '\0') {
415 		n = snprintf(buf, buflen, "%.*s/%s [%s]", pname_width,
416 		    pname, nr_suffix, lwp->li_lwpname);
417 	} else {
418 		n = snprintf(buf, buflen, "%.*s/%s", pname_width,
419 		    pname, nr_suffix);
420 	}
421 
422 	if (width > 0 && strlen(buf) > width)
423 		buf[width] = '\0';
424 }
425