usr/src/cmd/prstat/prutil.c

   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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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 *
 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 *
 237 Malloc(size_t size)
 238 {
 239         return (Realloc(NULL, size));
 240 }
 241
 242 void *
 243 Zalloc(size_t size)
 244 {
 245         return (memset(Realloc(NULL, size), 0, size));
 246 }
 247
 248 int
 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
 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
 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
 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
 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
 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
 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 }