path: root/usr/src/lib/libproc/common/proc_arg.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include <sys/stat.h>

#include <libgen.h>
#include <limits.h>
#include <alloca.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <errno.h>
#include <dirent.h>

#include "libproc.h"

static int
open_psinfo(const char *arg, int *perr)
{
	/*
	 * Allocate enough space for "/proc/" + arg + "/psinfo"
	 */
	char *path = alloca(strlen(arg) + 14);

	struct stat64 st;
	int fd;

	if (strchr(arg, '/') == NULL) {
		(void) strcpy(path, "/proc/");
		(void) strcat(path, arg);
	} else
		(void) strcpy(path, arg);

	(void) strcat(path, "/psinfo");

	/*
	 * Attempt to open the psinfo file, and return the fd if we can
	 * confirm this is a regular file provided by /proc.
	 */
	if ((fd = open64(path, O_RDONLY)) >= 0) {
		if (fstat64(fd, &st) != 0 || !S_ISREG(st.st_mode) ||
		    strcmp(st.st_fstype, "proc") != 0) {
			(void) close(fd);
			fd = -1;
		}
	} else if (errno == EACCES || errno == EPERM)
		*perr = G_PERM;

	return (fd);
}

static int
open_core(const char *arg, int *perr)
{
#ifdef _BIG_ENDIAN
	uchar_t order = ELFDATA2MSB;
#else
	uchar_t order = ELFDATA2LSB;
#endif
	GElf_Ehdr ehdr;
	int fd;
	int is_noelf = -1;

	/*
	 * Attempt to open the core file, and return the fd if we can confirm
	 * this is an ELF file of type ET_CORE.
	 */
	if ((fd = open64(arg, O_RDONLY)) >= 0) {
		if (read(fd, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) {
			(void) close(fd);
			fd = -1;
		} else if ((is_noelf = memcmp(&ehdr.e_ident[EI_MAG0], ELFMAG,
			    SELFMAG)) != 0 || ehdr.e_type != ET_CORE) {
				(void) close(fd);
				fd = -1;
				if (is_noelf == 0 &&
				    ehdr.e_ident[EI_DATA] != order)
					*perr = G_ISAINVAL;
		}
	} else if (errno == EACCES || errno == EPERM)
		*perr = G_PERM;

	return (fd);
}

/*
 * Make the error message precisely match the type of arguments the caller
 * wanted to process.  This ensures that a tool which only accepts pids does
 * not produce an error message saying "no such process or core file 'foo'".
 */
static int
open_error(int oflag)
{
	if ((oflag & PR_ARG_ANY) == PR_ARG_PIDS)
		return (G_NOPROC);

	if ((oflag & PR_ARG_ANY) == PR_ARG_CORES)
		return (G_NOCORE);

	return (G_NOPROCORCORE);
}

static void *
proc_grab_common(const char *arg, const char *path, int oflag, int gflag,
    int *perr, const char **lwps, psinfo_t *psp)
{
	psinfo_t psinfo;
	char *core;
	int fd;
	char *slash;
	struct ps_prochandle *Pr;

	*perr = 0;
	if (lwps)
		*lwps = NULL;

	if (lwps != NULL && (slash = strrchr(arg, '/')) != NULL) {
		/*
		 * Check to see if the user has supplied an lwp range.  First,
		 * try to grab it as a pid/lwp combo.
		 */
		*slash = '\0';
		if ((oflag & PR_ARG_PIDS) &&
		    (fd = open_psinfo(arg, perr)) != -1) {
			if (read(fd, &psinfo,
			    sizeof (psinfo_t)) == sizeof (psinfo_t)) {
				(void) close(fd);
				*lwps = slash + 1;
				*slash = '/';
				if (proc_lwp_range_valid(*lwps) != 0) {
					*perr = G_BADLWPS;
					return (NULL);
				}
				if (psp) {
					*psp = psinfo;
					return (psp);
				} else  {
					return (Pgrab(psinfo.pr_pid, gflag,
					    perr));
				}
			}
			(void) close(fd);
		}

		/*
		 * Next, try grabbing it as a corefile.
		 */
		if ((oflag & PR_ARG_CORES) &&
		    (fd = open_core(arg, perr)) != -1) {
			*lwps = slash + 1;
			*slash = '/';
			if (proc_lwp_range_valid(*lwps) != 0) {
				*perr = G_BADLWPS;
				return (NULL);
			}
			core = alloca(strlen(arg) + 1);
			(void) strcpy(core, arg);
			if ((Pr = Pfgrab_core(fd, path == NULL ?
			    dirname(core) : path, perr)) != NULL) {
				if (psp) {
					(void) memcpy(psp, Ppsinfo(Pr),
					    sizeof (psinfo_t));
					Prelease(Pr, 0);
					return (psp);
				} else {
					return (Pr);
				}
			}
		}

		*slash = '/';
	}

	if ((oflag & PR_ARG_PIDS) && (fd = open_psinfo(arg, perr)) != -1) {
		if (read(fd, &psinfo, sizeof (psinfo_t)) == sizeof (psinfo_t)) {
			(void) close(fd);
			if (psp) {
				*psp = psinfo;
				return (psp);
			} else {
				return (Pgrab(psinfo.pr_pid, gflag, perr));
			}
		}
		/*
		 * If the read failed, the process may have gone away;
		 * we continue checking for core files or fail with G_NOPROC
		 */
		(void) close(fd);
	}

	if ((oflag & PR_ARG_CORES) && (fd = open_core(arg, perr)) != -1) {
		core = alloca(strlen(arg) + 1);
		(void) strcpy(core, arg);
		if ((Pr = Pfgrab_core(fd, path == NULL ? dirname(core) : path,
		    perr)) != NULL) {
			if (psp) {
				(void) memcpy(psp, Ppsinfo(Pr),
				    sizeof (psinfo_t));
				Prelease(Pr, 0);
				return (psp);
			} else {
				return (Pr);
			}
		}
	}

	/*
	 * We were unable to open the corefile.  If we have no meaningful
	 * information, report the (ambiguous) error from open_error().
	 */

	if (*perr == 0)
		*perr = open_error(oflag);

	return (NULL);
}

struct ps_prochandle *
proc_arg_xgrab(const char *arg, const char *path, int oflag, int gflag,
    int *perr, const char **lwps)
{
	return (proc_grab_common(arg, path, oflag, gflag, perr, lwps, NULL));
}

struct ps_prochandle *
proc_arg_grab(const char *arg, int oflag, int gflag, int *perr)
{
	return (proc_grab_common(arg, NULL, oflag, gflag, perr, NULL, NULL));
}

pid_t
proc_arg_psinfo(const char *arg, int oflag, psinfo_t *psp, int *perr)
{
	psinfo_t psinfo;

	if (psp == NULL)
		psp = &psinfo;

	if (proc_grab_common(arg, NULL, oflag, 0, perr, NULL, psp) == NULL)
		return (-1);
	else
		return (psp->pr_pid);
}

pid_t
proc_arg_xpsinfo(const char *arg, int oflag, psinfo_t *psp, int *perr,
    const char **lwps)
{
	psinfo_t psinfo;

	if (psp == NULL)
		psp = &psinfo;

	if (proc_grab_common(arg, NULL, oflag, 0, perr, lwps, psp) == NULL)
		return (-1);
	else
		return (psp->pr_pid);
}

/*
 * Convert psinfo_t.pr_psargs string into itself, replacing unprintable
 * characters with space along the way.  Stop on a null character.
 */
void
proc_unctrl_psinfo(psinfo_t *psp)
{
	char *s = &psp->pr_psargs[0];
	size_t n = PRARGSZ;
	int c;

	while (n-- != 0 && (c = (*s & UCHAR_MAX)) != '\0') {
		if (!isprint(c))
			c = ' ';
		*s++ = (char)c;
	}

	*s = '\0';
}

static int
proc_lwp_get_range(char *range, id_t *low, id_t *high)
{
	if (*range == '-')
		*low = 0;
	else
		*low = (id_t)strtol(range, &range, 10);

	if (*range == '\0' || *range == ',') {
		*high = *low;
		return (0);
	}
	if (*range != '-') {
		return (-1);
	}
	range++;

	if (*range == '\0')
		*high = INT_MAX;
	else
		*high = (id_t)strtol(range, &range, 10);

	if (*range != '\0' && *range != ',') {
		return (-1);
	}

	if (*high < *low) {
		id_t tmp = *high;
		*high = *low;
		*low = tmp;
	}

	return (0);
}

/*
 * Determine if the specified lwpid is in the given set of lwpids.
 * The set can include multiple lwpid ranges separated by commas
 * and has the following syntax:
 *
 * 	lwp_range[,lwp_range]*
 *
 * where lwp_range is specifed as:
 *
 * 	-n			lwpid <= n
 * 	n-m			n <= lwpid <= m
 * 	n-			lwpid >= n
 * 	n			lwpid == n
 */
int
proc_lwp_in_set(const char *set, lwpid_t lwpid)
{
	id_t low, high;
	id_t id = (id_t)lwpid;
	char *comma;
	char *range = (char *)set;

	/*
	 * A NULL set indicates that all LWPs are valid.
	 */
	if (set == NULL)
		return (1);

	while (range != NULL) {
		comma = strchr(range, ',');
		if (comma != NULL)
			*comma = '\0';
		if (proc_lwp_get_range(range, &low, &high) != 0) {
			if (comma != NULL)
				*comma = ',';
			return (0);
		}
		if (comma != NULL) {
			*comma = ',';
			range = comma + 1;
		} else {
			range = NULL;
		}
		if (id >= low && id <= high)
			return (1);
	}

	return (0);
}

int
proc_lwp_range_valid(const char *set)
{
	char *comma;
	char *range = (char *)set;
	id_t low, high;
	int ret;

	if (range == NULL || *range == '\0' || *range == ',')
		return (-1);

	while (range != NULL) {
		comma = strchr(range, ',');
		if (comma != NULL)
			*comma = '\0';
		if ((ret = proc_lwp_get_range(range, &low, &high)) != 0) {
			if (comma != NULL)
				*comma = ',';
			return (ret);
		}
		if (comma != NULL) {
			*comma = ',';
			range = comma + 1;
		} else {
			range = NULL;
		}
	}

	return (0);
}

/*
 * Walk all processes or LWPs in /proc and call func() for each.
 * Stop calling func() if it returns non 0 value and return it.
 */
int
proc_walk(proc_walk_f *func, void *arg, int flag)
{
	DIR *procdir;
	struct dirent *dirent;
	char *errptr;
	char pidstr[80];
	psinfo_t psinfo;
	lwpsinfo_t *lwpsinfo;
	prheader_t prheader;
	void *buf;
	char *ptr;
	int bufsz;
	id_t pid;
	int fd, i;
	int ret = 0;

	if (flag != PR_WALK_PROC && flag != PR_WALK_LWP) {
		errno = EINVAL;
		return (-1);
	}
	if ((procdir = opendir("/proc")) == NULL)
		return (-1);
	while (dirent = readdir(procdir)) {
		if (dirent->d_name[0] == '.')	/* skip . and .. */
			continue;
		pid = (id_t)strtol(dirent->d_name, &errptr, 10);
		if (errptr != NULL && *errptr != '\0')
			continue;
		/* PR_WALK_PROC case */
		(void) snprintf(pidstr, sizeof (pidstr),
		    "/proc/%ld/psinfo", pid);
		fd = open(pidstr, O_RDONLY);
		if (fd < 0)
			continue;
		if (read(fd, &psinfo, sizeof (psinfo)) != sizeof (psinfo)) {
			(void) close(fd);
			continue;
		}
		(void) close(fd);
		if (flag == PR_WALK_PROC) {
			if ((ret = func(&psinfo, &psinfo.pr_lwp, arg)) != 0)
				break;
			continue;
		}
		/* PR_WALK_LWP case */
		(void) snprintf(pidstr, sizeof (pidstr),
		    "/proc/%ld/lpsinfo", pid);
		fd = open(pidstr, O_RDONLY);
		if (fd < 0)
			continue;
		if (read(fd, &prheader, sizeof (prheader)) !=
		    sizeof (prheader)) {
			(void) close(fd);
			continue;
		}
		bufsz = prheader.pr_nent * prheader.pr_entsize;
		if ((buf = malloc(bufsz)) == NULL) {
			(void) close(fd);
			ret = -1;
			break;
		}
		ptr = buf;
		if (pread(fd, buf, bufsz, sizeof (prheader)) != bufsz) {
			free(buf);
			(void) close(fd);
			continue;
		}
		(void) close(fd);
		for (i = 0; i < prheader.pr_nent;
		    i++, ptr += prheader.pr_entsize) {
			/*LINTED ALIGNMENT*/
			lwpsinfo = (lwpsinfo_t *)ptr;
			if ((ret = func(&psinfo, lwpsinfo, arg)) != 0) {
				free(buf);
				break;
			}
		}
		free(buf);
	}
	(void) closedir(procdir);
	return (ret);
}