xref: /titanic_52/usr/src/cmd/latencytop/common/util.c (revision 49d3bc91e27cd871b950d56c01398fa2f2e12ab4)
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 }
313