OpenSolaris_b135/lib/libtnfctl/util.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 (c) 1994, by Sun Microsytems, Inc.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Utility functions to initialize tnfctl handle, find functions that
* can be plugged into probes, find trace file information, and create
* a trace file for process tracing.
*/
#ifndef DEBUG
#define NDEBUG 1
#endif
#include "tnfctl_int.h"
#include "dbg.h"
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/param.h>
#include "tnf_buf.h"
/*
* Defines - Project private interfaces in libtnfprobe.so
*/
#define TRACEFILE_NAME "tnf_trace_file_name"
#define TRACEFILE_SIZE "tnf_trace_file_size"
#define TRACEFILE_MIN "tnf_trace_file_min"
#define TRACE_ERROR "_tnfw_b_control"
#define TRACE_ALLOC "tnf_trace_alloc"
#define TRACE_COMMIT "tnf_trace_commit"
#define TRACE_ROLLBACK "tnf_trace_rollback"
#define DEBUG_ENTRY "tnf_probe_debug"
#define PROBE_LIST_HEAD "__tnf_probe_list_head"
#define PROBE_LIST_VALID "__tnf_probe_list_valid"
#define NONTHREAD_TEST "tnf_non_threaded_test_addr"
#define THREAD_TEST "tnf_threaded_test_addr"
#define PROBE_THR_SYNC "__tnf_probe_thr_sync"
#define MEMSEG_PTR "__tnf_probe_memseg_p"
/* Project private interfaces in libthread.so */
#define LIBTHREAD_PRESENT "thr_probe_getfunc_addr"
/*
* Local declarations
*/
static tnfctl_errcode_t find_test_func(tnfctl_handle_t *hndl);
static tnfctl_errcode_t find_target_syms(tnfctl_handle_t *hndl);
static tnfctl_errcode_t find_trace_file_info(tnfctl_handle_t *hndl);
static tnfctl_errcode_t check_trace_error(tnfctl_handle_t *hndl);
/*
* _tnfctl_refresh_process() - search for new shared objects. If any
* found, discover probes in new shared objects.
* NOT to be called in kernel mode.
*/
tnfctl_errcode_t
_tnfctl_refresh_process(tnfctl_handle_t *hndl, boolean_t *lmap_ok,
enum event_op_t *dl_evt)
{
tnfctl_errcode_t prexstat = TNFCTL_ERR_NONE;
boolean_t release_lock;
assert(hndl->mode != KERNEL_MODE);
/*LINTED statement has no consequent: else*/
LOCK(hndl, prexstat, release_lock);
prexstat = check_trace_error(hndl);
if (prexstat)
goto finish_func;
/*
* update the link map. caller decides what to do on
* inconsistent link map
*/
prexstat = _tnfctl_lmap_update(hndl, lmap_ok, dl_evt);
if (prexstat)
goto finish_func;
/* link map is ok now */
prexstat = find_test_func(hndl);
if (prexstat)
goto finish_func;
if (*dl_evt != EVT_NONE) {
prexstat = _tnfctl_find_all_probes(hndl);
if (prexstat)
goto finish_func;
}
finish_func:
/*LINTED statement has no consequent: else*/
UNLOCK(hndl, release_lock);
return (prexstat);
}
/*
* initialize tnfctl handle for a new target
*/
tnfctl_errcode_t
_tnfctl_set_state(tnfctl_handle_t *hndl)
{
tnfctl_errcode_t prexstat = TNFCTL_ERR_NONE;
boolean_t lmap_ok;
enum event_op_t dl_evt;
boolean_t release_lock;
hndl->targ_pid = hndl->p_getpid(hndl->proc_p);
/*LINTED statement has no consequent: else*/
LOCK(hndl, prexstat, release_lock);
/*
* initialize the link map table. If link map is not ok, it is an
* error.
*/
prexstat = _tnfctl_lmap_update(hndl, &lmap_ok, &dl_evt);
if (prexstat)
goto end_func;
/* find the needed target symbols */
prexstat = find_target_syms(hndl);
if (prexstat) {
/* is libtnfprobe.so loaded in target ? */
goto end_func;
}
prexstat = find_trace_file_info(hndl);
if (prexstat)
goto end_func;
prexstat = find_test_func(hndl);
if (prexstat)
goto end_func;
prexstat = _tnfctl_find_all_probes(hndl);
if (prexstat)
goto end_func;
prexstat = check_trace_error(hndl);
/* fall into end_func */
end_func:
/*LINTED statement has no consequent: else*/
UNLOCK(hndl, release_lock);
return (prexstat);
}
/*
* find the test function for a probe. The test function could change
* with time, so we have to repeatedly check for the test function to use
*/
static tnfctl_errcode_t
find_test_func(tnfctl_handle_t *hndl)
{
long thr_sync;
int miscstat;
if (hndl->mt_target == B_FALSE) {
/* no libthread linked in */
hndl->testfunc = hndl->nonthread_test;
} else {
/*
* check whether libthread/libtnfw have synced up.
* If not yet synced up, use non-threaded test function
*/
/* assume we are going to use threaded test */
hndl->testfunc = hndl->thread_test;
miscstat = hndl->p_read(hndl->proc_p, hndl->thread_sync,
&thr_sync, sizeof (thr_sync));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
/* if not yet synced up, change test func to non-threaded one */
if (thr_sync == 0) {
hndl->testfunc = hndl->nonthread_test;
}
}
/*
* Note: the testfunc in the target can change underneath us because
* in an MT program the init section of libthread changes all the
* test functions from the non-threaded one to the threaded one.
* So, every time we write out a probe, we have to make sure that
* we are using the correct test function by not trusting the test
* function in our copy of the probe. A more fool-proof solution
* which will allow other fields in the probe to change internally
* is to refresh every probe on a _tnfctl_refresh_process()
*/
return (TNFCTL_ERR_NONE);
}
/*
* check_trace_error() - checks whether there was an error in tracing
* side effects trace_buf_state and trace_state in hndl
* note: call this function only after trace_file_name is set up
* in hndl
*/
tnfctl_errcode_t
check_trace_error(tnfctl_handle_t *hndl)
{
int miscstat;
uintptr_t trace_error_ptr;
TNFW_B_CONTROL trace_error_rec;
/* read in the value of the control structure pointer */
miscstat = hndl->p_read(hndl->proc_p, hndl->trace_error,
&trace_error_ptr, sizeof (trace_error_ptr));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
/* read in the value of the control structure */
miscstat = hndl->p_read(hndl->proc_p, trace_error_ptr, &trace_error_rec,
sizeof (trace_error_rec));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
if (trace_error_rec.tnf_state == TNFW_B_NOBUFFER) {
/*
* massage into correct state for caller - the target might
* not have hit the first probe and hence we got "no buffer".
* So, if the user had given a file name, return BUF_OK.
*/
if (hndl->trace_file_name == NULL)
hndl->trace_buf_state = TNFCTL_BUF_NONE;
else
hndl->trace_buf_state = TNFCTL_BUF_OK;
} else if (trace_error_rec.tnf_state == TNFW_B_BROKEN) {
hndl->trace_buf_state = TNFCTL_BUF_BROKEN;
} else {
hndl->trace_buf_state = TNFCTL_BUF_OK;
}
if (TNFW_B_IS_STOPPED(trace_error_rec.tnf_state))
hndl->trace_state = B_FALSE;
else
hndl->trace_state = B_TRUE;
return (TNFCTL_ERR_NONE);
} /* end find_alloc_func */
/*
* find_target_syms() - finds needed target functions
* sideffects allocfunc, commitfunc, endfunc, rollbackfunc in hndl
*/
static tnfctl_errcode_t
find_target_syms(tnfctl_handle_t *hndl)
{
tnfctl_errcode_t prexstat;
uintptr_t temp_addr;
int miscstat;
prexstat = _tnfctl_sym_find(hndl, TRACE_ALLOC, &hndl->allocfunc);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, TRACE_COMMIT, &hndl->commitfunc);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, TRACE_END_FUNC, &hndl->endfunc);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, TRACE_ROLLBACK, &hndl->rollbackfunc);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, PROBE_LIST_HEAD,
&hndl->probelist_head);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, TRACE_ERROR, &hndl->trace_error);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, MEMSEG_PTR, &temp_addr);
if (prexstat)
goto end_of_func;
/* dereference to get the actual address of structure */
miscstat = hndl->p_read(hndl->proc_p, temp_addr, &hndl->memseg_p,
sizeof (hndl->memseg_p));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
prexstat = _tnfctl_sym_find(hndl, PROBE_LIST_VALID,
&hndl->probelist_valid);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, NONTHREAD_TEST, &temp_addr);
if (prexstat)
goto end_of_func;
/* dereference to get the actual function address */
miscstat = hndl->p_read(hndl->proc_p, temp_addr, &hndl->nonthread_test,
sizeof (hndl->nonthread_test));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
prexstat = _tnfctl_sym_find(hndl, THREAD_TEST, &temp_addr);
if (prexstat)
goto end_of_func;
/* dereference to get the actual function address */
miscstat = hndl->p_read(hndl->proc_p, temp_addr, &hndl->thread_test,
sizeof (hndl->thread_test));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
prexstat = _tnfctl_sym_find(hndl, PROBE_THR_SYNC, &hndl->thread_sync);
if (prexstat)
goto end_of_func;
prexstat = _tnfctl_sym_find(hndl, LIBTHREAD_PRESENT, &temp_addr);
if (prexstat) {
if (prexstat == TNFCTL_ERR_BADARG) {
/* no libthread linked in */
hndl->mt_target = B_FALSE;
/* this is not an error condition */
prexstat = TNFCTL_ERR_NONE;
} else {
return (prexstat);
}
} else {
hndl->mt_target = B_TRUE;
}
end_of_func:
if (prexstat == TNFCTL_ERR_BADARG)
prexstat = TNFCTL_ERR_NOLIBTNFPROBE;
return (prexstat);
}
/*
* _tnfctl_create_tracefile() - initializes tracefile, sets the tracefile name
* and size
* side effects trace_file_name and trace_buf_size in hndl
*/
#define ZBUFSZ (64 * 1024)
tnfctl_errcode_t
_tnfctl_create_tracefile(tnfctl_handle_t *hndl, const char *trace_file_name,
uint_t trace_file_size)
{
char *preexisting;
tnfctl_errcode_t prexstat;
int miscstat;
char path[MAXPATHLEN];
uintptr_t name_addr, size_addr;
uint_t outsize;
char zerobuf[ZBUFSZ];
int fd, sz, i;
/* find the neccessary symbols in the target */
prexstat = _tnfctl_sym_find(hndl, TRACEFILE_NAME, &name_addr);
if (prexstat) {
if (prexstat == TNFCTL_ERR_BADARG)
prexstat = TNFCTL_ERR_INTERNAL;
return (prexstat);
}
prexstat = _tnfctl_sym_find(hndl, TRACEFILE_SIZE, &size_addr);
if (prexstat) {
if (prexstat == TNFCTL_ERR_BADARG)
prexstat = TNFCTL_ERR_INTERNAL;
return (prexstat);
}
/* Double check that a file name doesn't already exist */
preexisting = NULL;
prexstat = _tnfctl_readstr_targ(hndl, name_addr, &preexisting);
if (prexstat) {
if (preexisting)
free(preexisting);
return (prexstat);
}
/* There better not be a file name there yet */
assert(preexisting[0] == '\0');
/* paranoia - for optimized compilation */
if (preexisting[0] != '\0')
return (TNFCTL_ERR_BUFEXISTS);
/* free memory in preexisting string */
if (preexisting)
free(preexisting);
if (trace_file_size < hndl->trace_min_size) {
return (TNFCTL_ERR_SIZETOOSMALL);
}
/* do we have an absolute, relative or no pathname specified? */
if (trace_file_name == NULL) {
return (TNFCTL_ERR_BADARG);
}
if (trace_file_name[0] == '/') {
/* absolute path to tracefile specified */
if ((strlen(trace_file_name) + 1) > (size_t) MAXPATHLEN) {
/* directory specification too long */
return (TNFCTL_ERR_BADARG);
}
(void) strcpy(path, trace_file_name);
} else {
char *cwd;
/* relative path to tracefile specified */
cwd = getcwd(NULL, MAXPATHLEN);
if (!cwd) {
return (tnfctl_status_map(errno));
}
if ((strlen(cwd) + 1 + strlen(trace_file_name) + 1) >
(size_t) MAXPATHLEN) {
/* path name too long */
return (TNFCTL_ERR_BADARG);
}
(void) sprintf(path, "%s/%s", cwd, trace_file_name);
free(cwd);
}
outsize = trace_file_size;
DBG_TNF_PROBE_2(_tnfctl_create_tracefile_1, "libtnfctl",
"sunw%verbosity 1; sunw%debug 'setting trace file name'",
tnf_string, tracefile_name, path,
tnf_long, tracefile_size, outsize);
/* unlink a previous tracefile (if one exists) */
(void) unlink(path);
/* create the new tracefile */
fd = open(path, O_CREAT | O_RDWR | O_TRUNC, 0644);
if (fd < 0) {
return (tnfctl_status_map(errno));
}
/* zero fill the file */
(void) memset(zerobuf, 0, ZBUFSZ);
sz = ZBUFSZ;
for (i = 0; i < outsize; i += sz) {
ulong_t retval;
sz = ((outsize - i) > ZBUFSZ) ? ZBUFSZ : (outsize - i);
retval = write(fd, zerobuf, sz);
if (retval != sz) {
/* trouble zeroing tracefile */
return (tnfctl_status_map(errno));
}
}
/* close the file */
(void) close(fd);
/* write the tracefile name and size into the target process */
miscstat = hndl->p_write(hndl->proc_p, name_addr, path,
strlen(path) + 1);
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
miscstat = hndl->p_write(hndl->proc_p, size_addr, &outsize,
sizeof (outsize));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
hndl->trace_file_name = strdup(path);
if (hndl->trace_file_name == NULL)
return (TNFCTL_ERR_ALLOCFAIL);
hndl->trace_buf_size = outsize;
hndl->trace_buf_state = TNFCTL_BUF_OK;
return (TNFCTL_ERR_NONE);
} /* end _tnfctl_create_tracefile */
/*
* find_trace_file_info()
* finds out information about the trace file.
* side effects trace_buf_size, trace_min_size, trace_file_name in hndl
*/
static tnfctl_errcode_t
find_trace_file_info(tnfctl_handle_t *hndl)
{
tnfctl_errcode_t prexstat;
int miscstat;
char *preexisting;
uintptr_t name_addr, size_addr, min_addr;
uint_t outsize, minoutsize;
/* find the neccessary symbols in the target */
prexstat = _tnfctl_sym_find(hndl, TRACEFILE_NAME, &name_addr);
if (prexstat) {
if (prexstat == TNFCTL_ERR_BADARG)
prexstat = TNFCTL_ERR_INTERNAL;
return (prexstat);
}
prexstat = _tnfctl_sym_find(hndl, TRACEFILE_SIZE, &size_addr);
if (prexstat) {
if (prexstat == TNFCTL_ERR_BADARG)
prexstat = TNFCTL_ERR_INTERNAL;
return (prexstat);
}
prexstat = _tnfctl_sym_find(hndl, TRACEFILE_MIN, &min_addr);
if (prexstat) {
if (prexstat == TNFCTL_ERR_BADARG)
prexstat = TNFCTL_ERR_INTERNAL;
return (prexstat);
}
/* read file name */
preexisting = NULL;
prexstat = _tnfctl_readstr_targ(hndl, name_addr, &preexisting);
if (prexstat) {
if (preexisting)
free(preexisting);
return (prexstat);
}
/* read the minimum file size from the target */
miscstat = hndl->p_read(hndl->proc_p, min_addr, &minoutsize,
sizeof (minoutsize));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
hndl->trace_min_size = minoutsize;
/* if there is no filename, we are done */
if (preexisting[0] == '\0') {
hndl->trace_file_name = NULL;
hndl->trace_buf_size = 0;
} else {
hndl->trace_file_name = preexisting;
/* read size of file */
miscstat = hndl->p_read(hndl->proc_p, size_addr,
&outsize, sizeof (outsize));
if (miscstat != 0)
return (TNFCTL_ERR_INTERNAL);
hndl->trace_buf_size = outsize;
}
return (TNFCTL_ERR_NONE);
} /* end find_trace_file_info */
/*
* wrapper functions over native /proc functions implemented by proc
* layer
*/
int
_tnfctl_read_targ(void *proc_p, uintptr_t addr, void *buf, size_t size)
{
return (prb_proc_read(proc_p, addr, buf, size));
}
int
_tnfctl_write_targ(void *proc_p, uintptr_t addr, void *buf, size_t size)
{
return (prb_proc_write(proc_p, addr, buf, size));
}
int
_tnfctl_loadobj_iter(void *proc_p, tnfctl_ind_obj_f *func, void *client_data)
{
prb_loadobj_f *same_func = (prb_loadobj_f *) func;
return (prb_loadobj_iter(proc_p, same_func, client_data));
}
pid_t
_tnfctl_pid_get(void *proc_p)
{
return (prb_proc_pid_get(proc_p));
}
/*
* _tnfctl_readstr_targ() - dereferences a string in the target
* NOTE: There is a similar routine called prb_proc_readstr()
* used by proc layer. It would be better if there was only
* one of these functions defined.
*/
#define BUFSZ 256
tnfctl_errcode_t
_tnfctl_readstr_targ(tnfctl_handle_t *hndl, uintptr_t addr, char **outstr_pp)
{
int retstat;
int bufsz = BUFSZ;
char buffer[BUFSZ + 1];
offset_t offset;
char *ptr, *orig_ptr;
*outstr_pp = NULL;
offset = 0;
/* allocate an inital return buffer */
ptr = (char *) malloc(BUFSZ);
if (!ptr) {
DBG((void) fprintf(stderr,
"_tnfctl_readstr_targ: malloc failed\n"));
return (TNFCTL_ERR_ALLOCFAIL);
}
/*LINTED constant in conditional context*/
while (1) {
int i;
/* read a chunk into our buffer */
retstat = hndl->p_read(hndl->proc_p, addr + offset, buffer,
bufsz);
if (retstat != 0) {
/*
* if we get into trouble with a large read, try again
* with a single byte. Subsequent failiure is real ...
*/
if (bufsz > 1) {
bufsz = 1;
continue;
}
DBG((void) fprintf(stderr,
"_tnfctl_readstr_targ: target read failed: \n"));
free(ptr);
return (TNFCTL_ERR_INTERNAL);
}
/* copy the chracters into the return buffer */
for (i = 0; i < bufsz; i++) {
char c = buffer[i];
ptr[offset + i] = c;
if (c == '\0') {
/* hooray! we saw the end of the string */
*outstr_pp = ptr;
return (TNFCTL_ERR_NONE);
}
}
/* bummer, need to grab another bufsz characters */
offset += bufsz;
orig_ptr = ptr;
ptr = (char *) realloc(ptr, offset + bufsz);
if (!ptr) {
free(orig_ptr);
DBG((void) fprintf(stderr,
"_tnfctl_readstr_targ: realloc failed\n"));
return (TNFCTL_ERR_ALLOCFAIL);
}
}
#if defined(lint)
return (TNFCTL_ERR_NONE);
#endif
}