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 [-acHJLmrRtTvWZ] [-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 trunc, 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 (trunc && 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 trunc, 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 (trunc && 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 }