usr/src/cmd/latencytop/common/util.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) 2008-2009, Intel Corporation.
  23  * All Rights Reserved.
  24  */
  25
  26 #include <unistd.h>
  27 #include <libintl.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include <procfs.h>
  33 #include <fcntl.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36
  37 #include "latencytop.h"
  38
  39 /* Pipe that breaks the event loop (and exits early) */
  40 static int signal_pipe[2];
  41
  42 /*
  43  * Get current system time in milliseconds (1e-3).
  44  */
  45 uint64_t
  46 lt_millisecond(void)
  47 {
  48         struct timeval p;
  49         (void) gettimeofday(&p, NULL);
  50         return ((uint64_t)p.tv_sec * 1000 + p.tv_usec / 1000);
  51 }
  52
  53 /*
  54  * Check if we are out of memory.
  55  */
  56 void
  57 lt_check_null(void *p)
  58 {
  59         if (p == NULL) {
  60                 (void) fprintf(stderr, "Out of memory!\n");
  61                 g_assert(0);
  62                 exit(2);
  63         }
  64 }
  65
  66 /*
  67  * Safe malloc.
  68  */
  69 void *
  70 lt_malloc(size_t size)
  71 {
  72         void *ret = malloc(size);
  73
  74         lt_check_null(ret);
  75
  76         return (ret);
  77 }
  78
  79 /*
  80  * Safe alloc with memory cleared.
  81  * It is named "zalloc" because its signature is different from
  82  * calloc() in stdlib.
  83  */
  84 void *
  85 lt_zalloc(size_t size)
  86 {
  87         void *ret = calloc(size, 1);
  88
  89         lt_check_null(ret);
  90
  91         return (ret);
  92 }
  93
  94 /*
  95  * Safe strdup.
  96  */
  97 char *
  98 lt_strdup(const char *str)
  99 {
 100         char *ret = strdup(str);
 101
 102         lt_check_null(ret);
 103
 104         return (ret);
 105 }
 106
 107 /*
 108  * Get string for current time, e.g. YYYY-MM-DD
 109  */
 110 void
 111 lt_time_str(char *buffer, int len)
 112 {
 113         struct tm tms;
 114         time_t t;
 115         int i;
 116
 117         (void) time(&t);
 118         (void) gmtime_r(&t, &tms);
 119         (void) asctime_r(&tms, buffer, len);
 120
 121         for (i = strlen(buffer)-1; i > 0; --i) {
 122
 123                 if (isspace(buffer[i])) {
 124                         buffer[i] = '\0';
 125                 } else {
 126                         break;
 127                 }
 128         }
 129 }
 130
 131 /*
 132  * Retrieves the process's executable name and arguments from /proc.
 133  */
 134 char *
 135 lt_get_proc_field(pid_t pid, lt_field_t field)
 136 {
 137         char name[PATH_MAX];
 138         int fd;
 139         int ret;
 140         psinfo_t psinfo;
 141
 142         (void) snprintf(name, PATH_MAX, "/proc/%d/psinfo", (int)pid);
 143         fd = open(name, O_RDONLY);
 144
 145         if (fd == -1) {
 146                 return (NULL);
 147         }
 148
 149         ret = read(fd, (char *)&psinfo, sizeof (psinfo_t));
 150         (void) close(fd);
 151
 152         if (ret < 0) {
 153                 return (NULL);
 154         }
 155
 156         switch (field) {
 157         case LT_FIELD_FNAME:
 158                 return (lt_strdup(psinfo.pr_fname));
 159         case LT_FIELD_PSARGS:
 160                 return (lt_strdup(psinfo.pr_psargs));
 161         }
 162         return (NULL);
 163 }
 164
 165 /*
 166  * Helper function to update the data structure.
 167  */
 168 void
 169 lt_update_stat_value(lt_stat_data_t *entry,
 170     lt_stat_type_t type, uint64_t value)
 171 {
 172         switch (type) {
 173         case LT_STAT_COUNT:
 174                 entry->lt_s_count += value;
 175                 break;
 176         case LT_STAT_SUM:
 177                 entry->lt_s_total += value;
 178                 break;
 179         case LT_STAT_MAX:
 180                 if (value > entry->lt_s_max) {
 181                         entry->lt_s_max = value;
 182                 }
 183                 break;
 184         default:
 185                 break;
 186         }
 187 }
 188
 189 /*
 190  * Helper function to sort on total.
 191  */
 192 int
 193 lt_sort_by_total_desc(lt_stat_entry_t *a, lt_stat_entry_t *b)
 194 {
 195         g_assert(a != NULL && b != NULL);
 196         /*
 197          * lt_s_total is of type int64_t, so we can't simply return
 198          * (b->lt_se_data.lt_s_total - a->lt_se_data.lt_s_total).
 199          */
 200         if (b->lt_se_data.lt_s_total > a->lt_se_data.lt_s_total) {
 201                 return (1);
 202         } else if (b->lt_se_data.lt_s_total < a->lt_se_data.lt_s_total) {
 203                 return (-1);
 204         } else {
 205                 return (0);
 206         }
 207 }
 208
 209 /*
 210  * Helper function to sort on max.
 211  */
 212 int
 213 lt_sort_by_max_desc(lt_stat_entry_t *a, lt_stat_entry_t *b)
 214 {
 215         g_assert(a != NULL && b != NULL);
 216
 217         if (b->lt_se_data.lt_s_max > a->lt_se_data.lt_s_max) {
 218                 return (1);
 219         } else if (b->lt_se_data.lt_s_max < a->lt_se_data.lt_s_max) {
 220                 return (-1);
 221         } else {
 222                 return (0);
 223         }
 224 }
 225
 226 /*
 227  * Helper function to sort on count.
 228  */
 229 int
 230 lt_sort_by_count_desc(lt_stat_entry_t *a, lt_stat_entry_t *b)
 231 {
 232         g_assert(a != NULL && b != NULL);
 233
 234         if (b->lt_se_data.lt_s_count > a->lt_se_data.lt_s_count) {
 235                 return (1);
 236         } else if (b->lt_se_data.lt_s_count < a->lt_se_data.lt_s_count) {
 237                 return (-1);
 238         } else {
 239                 return (0);
 240         }
 241 }
 242
 243 /*
 244  * Helper function to sort on average.
 245  */
 246 int
 247 lt_sort_by_avg_desc(lt_stat_entry_t *a, lt_stat_entry_t *b)
 248 {
 249         double avg_a, avg_b;
 250
 251         g_assert(a != NULL && b != NULL);
 252
 253         avg_a = (double)a->lt_se_data.lt_s_total / a->lt_se_data.lt_s_count;
 254         avg_b = (double)b->lt_se_data.lt_s_total / b->lt_se_data.lt_s_count;
 255
 256         if (avg_b > avg_a) {
 257                 return (1);
 258         } else if (avg_b < avg_a) {
 259                 return (-1);
 260         } else {
 261                 return (0);
 262         }
 263 }
 264
 265 /*
 266  * Create pipe for signal handler and wakeup.
 267  */
 268 void
 269 lt_gpipe_init(void)
 270 {
 271         (void) pipe(signal_pipe);
 272 }
 273
 274 /*
 275  * Close the pipe used in signal handler.
 276  */
 277 void
 278 lt_gpipe_deinit(void)
 279 {
 280         (void) close(signal_pipe[0]);
 281         (void) close(signal_pipe[1]);
 282 }
 283
 284 /*
 285  * Break early from the main loop.
 286  */
 287 void
 288 lt_gpipe_break(const char *ch)
 289 {
 290         (void) write(signal_pipe[1], ch, 1);
 291 }
 292
 293 int
 294 lt_gpipe_readfd(void)
 295 {
 296         return (signal_pipe[0]);
 297 }
 298
 299 /*
 300  * Check if the given file exists.
 301  */
 302 int
 303 lt_file_exist(const char *name)
 304 {
 305         struct stat64 st;
 306
 307         if (stat64(name, &st) == 0) {
 308                 return (1);
 309         } else {
 310                 return (0);
 311         }
 312 }