xref: /titanic_50/usr/src/cmd/truss/listopts.c (revision d62bc4badc1c1f1549c961cfb8b420e650e1272b) 
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 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 #pragma ident	"%Z%%M%	%I%	%E% SMI"	/* SVr4.0 1.2	*/
31 
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <ctype.h>
36 #include <string.h>
37 #include <memory.h>
38 #include <sys/types.h>
39 #include <signal.h>
40 #include <libproc.h>
41 #include "ramdata.h"
42 #include "systable.h"
43 #include "proto.h"
44 
45 /* XXX A bug in the <string.h> header file requires this */
46 extern char *strtok_r(char *s1, const char *s2, char **lasts);
47 
48 /*
49  * option procesing ---
50  * Routines for scanning syscall, signal, fault
51  * and file descriptor lists.
52  */
53 
54 /*
55  * Function prototypes for static routines in this module.
56  */
57 void	upcase(char *);
58 
59 const char white[] = " \t\n";	/* white space characters */
60 const char sepr[] = " ,\t\n";	/* list separator characters */
61 const char csepr[] = " :,\t\n";	/* same, with ':' added */
62 
63 /*
64  * Scan list of syscall names.
65  * Return 0 on success, != 0 on any failure.
66  */
67 int
68 syslist(char *str,			/* string of syscall names */
69 	sysset_t *setp,			/* syscall set */
70 	int *fp)			/* first-time flag */
71 {
72 	char *name;
73 	int exclude = FALSE;
74 	int rc = 0;
75 	char *lasts;
76 
77 	name = strtok_r(str, sepr, &lasts);
78 
79 	if (name != NULL && *name == '!') {	/* exclude from set */
80 		exclude = TRUE;
81 		if (*++name == '\0')
82 			name = strtok_r(NULL, sepr, &lasts);
83 	} else if (!*fp) {	/* first time, clear the set */
84 		premptyset(setp);
85 		*fp = TRUE;
86 	}
87 
88 	for (; name; name = strtok_r(NULL, sepr, &lasts)) {
89 		int sys;
90 		int sysx;
91 		int sysxx;
92 		int sys64;
93 		char *next;
94 
95 		if (*name == '!') {	/* exclude remainder from set */
96 			exclude = TRUE;
97 			while (*++name == '!')
98 				/* empty */;
99 			if (*name == '\0')
100 				continue;
101 		}
102 
103 		sys = strtol(name, &next, 0);
104 		sysx = sysxx = sys64 = 0;
105 		if (sys < 0 || sys > PRMAXSYS || *next != '\0')
106 			sys = 0;
107 		if (sys == 0) {
108 			const struct systable *stp = systable;
109 			for (; sys == 0 && stp->nargs >= 0; stp++)
110 				if (stp->name && strcmp(stp->name, name) == 0)
111 					sys = stp-systable;
112 		}
113 		if (sys == 0) {
114 			const struct sysalias *sap = sysalias;
115 			for (; sys == 0 && sap->name; sap++)
116 				if (strcmp(sap->name, name) == 0)
117 					sys = sap->number;
118 		}
119 		if (sys > 0 && sys <= PRMAXSYS) {
120 			switch (sys) {
121 			case SYS_xstat:		/* set all if any */
122 			case SYS_stat:
123 			case SYS_stat64:
124 				sys = SYS_stat;
125 				sysx = SYS_xstat;
126 				sys64 = SYS_stat64;
127 				goto def;
128 
129 			case SYS_lxstat:	/* set all if any */
130 			case SYS_lstat:
131 			case SYS_lstat64:
132 				sys = SYS_lstat;
133 				sysx = SYS_lxstat;
134 				sys64 = SYS_lstat64;
135 				goto def;
136 
137 			case SYS_fxstat:	/* set all if any */
138 			case SYS_fstat:
139 			case SYS_fstat64:
140 				sys = SYS_fstat;
141 				sysx = SYS_fxstat;
142 				sys64 = SYS_fstat64;
143 				goto def;
144 
145 			case SYS_getdents:	/* set both if either */
146 			case SYS_getdents64:
147 				sys = SYS_getdents;
148 				sys64 = SYS_getdents64;
149 				goto def;
150 
151 			case SYS_mmap:		/* set both if either */
152 			case SYS_mmap64:
153 				sys = SYS_mmap;
154 				sys64 = SYS_mmap64;
155 				goto def;
156 
157 			case SYS_statvfs:	/* set both if either */
158 			case SYS_statvfs64:
159 				sys = SYS_statvfs;
160 				sys64 = SYS_statvfs64;
161 				goto def;
162 
163 			case SYS_fstatvfs:	/* set both if either */
164 			case SYS_fstatvfs64:
165 				sys = SYS_fstatvfs;
166 				sys64 = SYS_fstatvfs64;
167 				goto def;
168 
169 			case SYS_setrlimit:	/* set both if either */
170 			case SYS_setrlimit64:
171 				sys = SYS_setrlimit;
172 				sys64 = SYS_setrlimit64;
173 				goto def;
174 
175 			case SYS_getrlimit:	/* set both if either */
176 			case SYS_getrlimit64:
177 				sys = SYS_getrlimit;
178 				sys64 = SYS_getrlimit64;
179 				goto def;
180 
181 			case SYS_pread:		/* set both if either */
182 			case SYS_pread64:
183 				sys = SYS_pread;
184 				sys64 = SYS_pread64;
185 				goto def;
186 
187 			case SYS_pwrite:	/* set both if either */
188 			case SYS_pwrite64:
189 				sys = SYS_pwrite;
190 				sys64 = SYS_pwrite64;
191 				goto def;
192 
193 			case SYS_creat:		/* set both if either */
194 			case SYS_creat64:
195 				sys = SYS_creat;
196 				sys64 = SYS_creat64;
197 				goto def;
198 
199 			case SYS_open:		/* set both if either */
200 			case SYS_open64:
201 				sys = SYS_open;
202 				sys64 = SYS_open64;
203 				goto def;
204 
205 			case SYS_xmknod:	/* set both if either */
206 			case SYS_mknod:
207 				sysx = SYS_xmknod;
208 				sys = SYS_mknod;
209 				goto def;
210 
211 			case SYS_forkall:	/* set all if any */
212 			case SYS_fork1:
213 			case SYS_vfork:
214 			case SYS_forksys:
215 				sys = SYS_forkall;
216 				sysx = SYS_fork1;
217 				sys64 = SYS_vfork;
218 				sysxx = SYS_forksys;
219 				goto def;
220 
221 			case SYS_exec:		/* set both if either */
222 			case SYS_execve:
223 				sysx = SYS_exec;
224 				sys = SYS_execve;
225 				goto def;
226 
227 			case SYS_poll:		/* set both if either */
228 			case SYS_pollsys:
229 				sysx = SYS_poll;
230 				sys = SYS_pollsys;
231 				goto def;
232 
233 			case SYS_sigprocmask:	/* set both if either */
234 			case SYS_lwp_sigmask:
235 				sysx = SYS_sigprocmask;
236 				sys = SYS_lwp_sigmask;
237 				goto def;
238 
239 			case SYS_wait:		/* set both if either */
240 			case SYS_waitid:
241 				sysx = SYS_wait;
242 				sys = SYS_waitid;
243 				goto def;
244 
245 			case SYS_lseek:		/* set both if either */
246 			case SYS_llseek:
247 				sysx = SYS_lseek;
248 				sys = SYS_llseek;
249 				goto def;
250 
251 			case SYS_lwp_mutex_lock: /* set both if either */
252 			case SYS_lwp_mutex_timedlock:
253 				sysx = SYS_lwp_mutex_lock;
254 				sys = SYS_lwp_mutex_timedlock;
255 				goto def;
256 
257 			case SYS_lwp_sema_wait: /* set both if either */
258 			case SYS_lwp_sema_timedwait:
259 				sysx = SYS_lwp_sema_wait;
260 				sys = SYS_lwp_sema_timedwait;
261 				goto def;
262 
263 			default:
264 			def:
265 				if (exclude) {
266 					prdelset(setp, sys);
267 					if (sysx)
268 						prdelset(setp, sysx);
269 					if (sysxx)
270 						prdelset(setp, sysxx);
271 					if (sys64)
272 						prdelset(setp, sys64);
273 				} else {
274 					praddset(setp, sys);
275 					if (sysx)
276 						praddset(setp, sysx);
277 					if (sysxx)
278 						praddset(setp, sysxx);
279 					if (sys64)
280 						praddset(setp, sys64);
281 				}
282 				break;
283 			}
284 		} else if (strcmp(name, "all") == 0 ||
285 		    strcmp(name, "ALL") == 0) {
286 			if (exclude) {
287 				premptyset(setp);
288 			} else {
289 				prfillset(setp);
290 			}
291 		} else {
292 			(void) fprintf(stderr,
293 			    "%s: unrecognized syscall: %s\n",
294 			    command, name);
295 			rc = -1;
296 		}
297 	}
298 
299 	return (rc);
300 }
301 
302 /*
303  * List of signals to trace.
304  * Return 0 on success, != 0 on any failure.
305  */
306 int
307 siglist(private_t *pri,
308 	char *str,			/* string of signal names */
309 	sigset_t *setp,			/* signal set */
310 	int *fp)			/* first-time flag */
311 {
312 	char *name;
313 	int exclude = FALSE;
314 	int rc = 0;
315 	char *lasts;
316 
317 	upcase(str);
318 	name = strtok_r(str, sepr, &lasts);
319 
320 	if (name != NULL && *name == '!') {	/* exclude from set */
321 		exclude = TRUE;
322 		if (*++name == '\0')
323 			name = strtok_r(NULL, sepr, &lasts);
324 	} else if (!*fp) {	/* first time, clear the set */
325 		premptyset(setp);
326 		*fp = TRUE;
327 	}
328 
329 	for (; name; name = strtok_r(NULL, sepr, &lasts)) {
330 		int sig;
331 		char *next;
332 
333 		if (*name == '!') {	/* exclude remainder from set */
334 			exclude = TRUE;
335 			while (*++name == '!')
336 				/* empty */;
337 			if (*name == '\0')
338 				continue;
339 		}
340 
341 		sig = strtol(name, &next, 0);
342 		if (sig <= 0 || sig > PRMAXSIG || *next != '\0') {
343 			for (sig = 1; sig <= PRMAXSIG; sig++) {
344 				const char *sname = rawsigname(pri, sig);
345 				if (sname == NULL)
346 					continue;
347 				if (strcmp(sname, name) == 0 ||
348 				    strcmp(sname+3, name) == 0)
349 					break;
350 			}
351 			if (sig > PRMAXSIG)
352 				sig = 0;
353 		}
354 		if (sig > 0 && sig <= PRMAXSIG) {
355 			if (exclude) {
356 				prdelset(setp, sig);
357 			} else {
358 				praddset(setp, sig);
359 			}
360 		} else if (strcmp(name, "ALL") == 0) {
361 			if (exclude) {
362 				premptyset(setp);
363 			} else {
364 				prfillset(setp);
365 			}
366 		} else {
367 			(void) fprintf(stderr,
368 			    "%s: unrecognized signal name/number: %s\n",
369 			    command, name);
370 			rc = -1;
371 		}
372 	}
373 
374 	return (rc);
375 }
376 
377 /*
378  * List of faults to trace.
379  * return 0 on success, != 0 on any failure.
380  */
381 int
382 fltlist(char *str,			/* string of fault names */
383 	fltset_t *setp,			/* fault set */
384 	int *fp)			/* first-time flag */
385 {
386 	char *name;
387 	int exclude = FALSE;
388 	int rc = 0;
389 	char *lasts;
390 
391 	upcase(str);
392 	name = strtok_r(str, sepr, &lasts);
393 
394 	if (name != NULL && *name == '!') {	/* exclude from set */
395 		exclude = TRUE;
396 		if (*++name == '\0')
397 			name = strtok_r(NULL, sepr, &lasts);
398 	} else if (!*fp) {	/* first time, clear the set */
399 		premptyset(setp);
400 		*fp = TRUE;
401 	}
402 
403 	for (; name; name = strtok_r(NULL, sepr, &lasts)) {
404 		int flt;
405 		char *next;
406 
407 		if (*name == '!') {	/* exclude remainder from set */
408 			exclude = TRUE;
409 			while (*++name == '!')
410 				/* empty */;
411 			if (*name == '\0')
412 				continue;
413 		}
414 
415 		flt = strtol(name, &next, 0);
416 		if (flt <= 0 || flt > PRMAXFAULT || *next != '\0') {
417 			for (flt = 1; flt <= PRMAXFAULT; flt++) {
418 				char fname[32];
419 
420 				if (proc_fltname(flt, fname,
421 				    sizeof (fname)) == NULL)
422 					continue;
423 
424 				if (strcmp(fname, name) == 0 ||
425 				    strcmp(fname+3, name) == 0)
426 					break;
427 			}
428 			if (flt > PRMAXFAULT)
429 				flt = 0;
430 		}
431 		if (flt > 0 && flt <= PRMAXFAULT) {
432 			if (exclude) {
433 				prdelset(setp, flt);
434 			} else {
435 				praddset(setp, flt);
436 			}
437 		} else if (strcmp(name, "ALL") == 0) {
438 			if (exclude) {
439 				premptyset(setp);
440 			} else {
441 				prfillset(setp);
442 			}
443 		} else {
444 			(void) fprintf(stderr,
445 			    "%s: unrecognized fault name/number: %s\n",
446 			    command, name);
447 			rc = -1;
448 		}
449 	}
450 
451 	return (rc);
452 }
453 
454 /*
455  * Gather file descriptors to dump.
456  * Return 0 on success, != 0 on any failure.
457  */
458 int
459 fdlist(char *str,		/* string of filedescriptors */
460 	fileset_t *setp)	/* set of boolean flags */
461 {
462 	char *name;
463 	int exclude = FALSE;
464 	int rc = 0;
465 	char *lasts;
466 
467 	upcase(str);
468 	name = strtok_r(str, sepr, &lasts);
469 
470 	if (name != NULL && *name == '!') {	/* exclude from set */
471 		exclude = TRUE;
472 		if (*++name == '\0')
473 			name = strtok_r(NULL, sepr, &lasts);
474 	}
475 
476 	for (; name; name = strtok_r(NULL, sepr, &lasts)) {
477 		int fd;
478 		char *next;
479 
480 		if (*name == '!') {	/* exclude remainder from set */
481 			exclude = TRUE;
482 			while (*++name == '!')
483 				/* empty */;
484 			if (*name == '\0')
485 				continue;
486 		}
487 
488 		fd = strtol(name, &next, 0);
489 		if (fd >= 0 && fd < NOFILES_MAX && *next == '\0') {
490 			fd++;
491 			if (exclude) {
492 				prdelset(setp, fd);
493 			} else {
494 				praddset(setp, fd);
495 			}
496 		} else if (strcmp(name, "ALL") == 0) {
497 			if (exclude) {
498 				premptyset(setp);
499 			} else {
500 				prfillset(setp);
501 			}
502 		} else {
503 			(void) fprintf(stderr,
504 			    "%s: filedescriptor not in range[0..%d]: %s\n",
505 			    command, NOFILES_MAX-1, name);
506 			rc = -1;
507 		}
508 	}
509 
510 	return (rc);
511 }
512 
513 void
514 upcase(char *str)
515 {
516 	int c;
517 
518 	while ((c = *str) != '\0')
519 		*str++ = toupper(c);
520 }
521 
522 /*
523  * 'arg' points to a string like:
524  *	libc,libnsl,... : printf,read,write,...
525  * or
526  *	libc,libnsl,... :: printf,read,write,...
527  * with possible filename pattern-matching metacharacters.
528  *
529  * Assumption:  No library or function name can contain ',' or ':'.
530  */
531 int
532 liblist(char *arg, int hang)
533 {
534 	const char *star = "*";
535 	struct dynpat *Dyp;
536 	char *pat;
537 	char *fpat;
538 	char *lasts;
539 	uint_t maxpat;
540 
541 	/* append a new dynpat structure to the end of the Dynpat list */
542 	Dyp = my_malloc(sizeof (struct dynpat), NULL);
543 	Dyp->next = NULL;
544 	if (Lastpat == NULL)
545 		Dynpat = Lastpat = Dyp;
546 	else {
547 		Lastpat->next = Dyp;
548 		Lastpat = Dyp;
549 	}
550 	Dyp->flag = hang? BPT_HANG : 0;
551 	Dyp->exclude_lib = 0;
552 	Dyp->exclude = 0;
553 	Dyp->internal = 0;
554 	Dyp->Dp = NULL;
555 
556 	/*
557 	 * Find the beginning of the filename patterns
558 	 * and null-terminate the library name patterns.
559 	 */
560 	if ((fpat = strchr(arg, ':')) != NULL)
561 		*fpat++ = '\0';
562 
563 	/*
564 	 * Library name patterns.
565 	 */
566 	pat = strtok_r(arg, sepr, &lasts);
567 
568 	/* '!' introduces an exclusion list */
569 	if (pat != NULL && *pat == '!') {
570 		Dyp->exclude_lib = 1;
571 		pat += strspn(pat, "!");
572 		if (*pat == '\0')
573 			pat = strtok_r(NULL, sepr, &lasts);
574 		/* force exclusion of all functions as well */
575 		Dyp->exclude = 1;
576 		Dyp->internal = 1;
577 		fpat = NULL;
578 	}
579 
580 	if (pat == NULL) {
581 		/* empty list means all libraries */
582 		Dyp->libpat = my_malloc(sizeof (char *), NULL);
583 		Dyp->libpat[0] = star;
584 		Dyp->nlibpat = 1;
585 	} else {
586 		/*
587 		 * We are now at the library list.
588 		 * Generate the list and count the library name patterns.
589 		 */
590 		maxpat = 1;
591 		Dyp->libpat = my_malloc(maxpat * sizeof (char *), NULL);
592 		Dyp->nlibpat = 0;
593 		Dyp->libpat[Dyp->nlibpat++] = pat;
594 		while ((pat = strtok_r(NULL, sepr, &lasts)) != NULL) {
595 			if (Dyp->nlibpat == maxpat) {
596 				maxpat *= 2;
597 				Dyp->libpat = my_realloc(Dyp->libpat,
598 				    maxpat * sizeof (char *), NULL);
599 			}
600 			Dyp->libpat[Dyp->nlibpat++] = pat;
601 		}
602 	}
603 
604 	/*
605 	 * Function name patterns.
606 	 */
607 	if (fpat == NULL)
608 		pat = NULL;
609 	else {
610 		/*
611 		 * We have already seen a ':'.  Look for another.
612 		 * Double ':' means trace internal calls.
613 		 */
614 		fpat += strspn(fpat, white);
615 		if (*fpat == ':') {
616 			Dyp->internal = 1;
617 			*fpat++ = '\0';
618 		}
619 		pat = strtok_r(fpat, csepr, &lasts);
620 	}
621 
622 	/* '!' introduces an exclusion list */
623 	if (pat != NULL && *pat == '!') {
624 		Dyp->exclude = 1;
625 		Dyp->internal = 1;
626 		pat += strspn(pat, "!");
627 		if (*pat == '\0')
628 			pat = strtok_r(NULL, sepr, &lasts);
629 	}
630 
631 	if (pat == NULL) {
632 		/* empty function list means exclude all functions */
633 		Dyp->sympat = my_malloc(sizeof (char *), NULL);
634 		Dyp->sympat[0] = star;
635 		Dyp->nsympat = 1;
636 	} else {
637 		/*
638 		 * We are now at the function list.
639 		 * Generate the list and count the symbol name patterns.
640 		 */
641 		maxpat = 1;
642 		Dyp->sympat = my_malloc(maxpat * sizeof (char *), NULL);
643 		Dyp->nsympat = 0;
644 		Dyp->sympat[Dyp->nsympat++] = pat;
645 		while ((pat = strtok_r(NULL, sepr, &lasts)) != NULL) {
646 			if (Dyp->nsympat == maxpat) {
647 				maxpat *= 2;
648 				Dyp->sympat = my_realloc(Dyp->sympat,
649 				    maxpat * sizeof (char *), NULL);
650 			}
651 			Dyp->sympat[Dyp->nsympat++] = pat;
652 		}
653 	}
654 
655 	return (0);
656 }
657