/*
* memtoy.c -- toy/tool for investigating Linux [Numa] VM behavior
*/
/*
* Copyright (c) 2005 Hewlett-Packard, Inc
* All rights reserved.
*/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdio.h>
#include "config.h"
#include "tst_res_flags.h"
#if HAVE_NUMA_H
#include <numa.h>
#endif
#ifdef HAVE_NUMA_V2
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <libgen.h>
#include <errno.h>
#include <numa.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "memtoy.h"
/*
* global context
*/
glctx_t glctx; /* global context */
/*
* command line options:
*
* -v = verbose
* -V = display version
* -h|x = display help.
*/
#define OPTIONS "Vhvx"
/*
* usage/help message
*/
char *USAGE = "\nUsage: %s [-v] [-V] [-{h|x}]\n\n\
Where:\n\
\t-v enable verbosity\n\
\t-V display version info\n\
\t-h|x show this usage/help message\n\
\n\
More info - TODO\n\
";
/*
* die() - emit error message and exit w/ specified return code.
* if exit_code < 0, save current errno, and fetch associated
* error string. Print error string after app error message.
* Then exit with abs(exit_code).
*/
void die(int exit_code, char *format, ...)
{
va_list ap;
char *errstr;
int saverrno;
va_start(ap, format);
if (exit_code < 0) {
saverrno = errno;
errstr = strerror(errno);
}
(void)vfprintf(stderr, format, ap);
va_end(ap);
if (exit_code < 0)
fprintf(stderr, "Error = (%d) %s\n", saverrno, errstr);
exit(abs(exit_code));
}
void usage(char *mesg)
{
if (mesg != NULL) {
fprintf(stderr, "%s\n", mesg);
}
fprintf(stderr, USAGE, glctx.program_name);
exit(1);
}
#ifdef _DEBUG
/*
* This function is a wrapper around "fprintf(stderr, ...)" so that we
* can use the DPRINTF(<flag>, (<[f]printf arguments>)) macro for debug
* prints. See the definition of DPRINTF in XXX.h
*/
int _dvprintf(char *format, ...)
{
va_list ap;
int retval;
va_start(ap, format);
retval = vfprintf(stderr, format, ap);
va_end(ap);
fflush(stderr);
return (retval);
}
#endif
void vprint(char *format, ...)
{
va_list ap;
glctx_t *gcp = &glctx;
va_start(ap, format);
if (!is_option(VERBOSE))
goto out;
(void)vfprintf(stderr, format, ap);
fflush(stderr);
out:
va_end(ap);
return;
}
/*
* =========================================================================
*/
static int signals_to_handle[] = {
SIGINT, SIGQUIT, SIGSEGV, SIGBUS,
SIGUSR1, SIGUSR2, 0
};
static char *sig_names[] = {
"SIGINT", "SIGQUIT", "SIGSEGV", "SIGBUS",
"SIGUSR1", "SIGUSR2", "unknown", 0
};
/*
* signal_handler()
*
* save siginfo and name in global context
*/
void signal_handler(int sig, siginfo_t * info, void *vcontext)
{
glctx_t *gcp = &glctx;
int isig = 0, *sigp = signals_to_handle;
static siginfo_t infocopy;
/*
* static copy of signal info.
* Note, additional signals, before use, can overwrite
*/
infocopy = *info;
gcp->siginfo = &infocopy;
while (*sigp) {
if (*sigp == sig)
break;
++isig;
++sigp;
}
gcp->signame = sig_names[isig];
vprint("signal hander entered for sig %s\n", gcp->signame);
switch (sig) {
case SIGSEGV:
case SIGBUS:
if (gcp->sigjmp) {
gcp->sigjmp = false;
siglongjmp(gcp->sigjmp_env, 1);
}
die(8, "\n%s: signal %s, but siglongjmp not armed\n",
gcp->program_name, gcp->signame);
break;
case SIGINT:
case SIGQUIT:
break;
default:
die(8, "\n%s: Unexpected signal: %d\n",
gcp->program_name, sig);
break;
}
}
/*
* set_signals()
*
* Setup signal dispositions to catch selected signals
*/
void set_signals()
{
glctx_t *gcp = &glctx;
int *sigp = signals_to_handle;
char **namep = sig_names;
struct sigaction act = {
.sa_sigaction = signal_handler,
.sa_flags = SA_SIGINFO
};
(void)sigfillset(&(act.sa_mask));
while (*sigp) {
char *sig_name = *(namep++);
int sig = *(sigp++);
if (0 != sigaction(sig, &act, NULL)) {
die(-1, "%s: Failed to set sigaction for %s\n",
gcp->program_name, sig_name);
} else
#if 0
vprint("%s: established handler for %s\n",
gcp->program_name, sig_name)
#endif
;
}
return;
}
void reset_signal(void)
{
//TODO: free siginfo if/when malloc'd
glctx.siginfo = NULL;
glctx.sigjmp = false;
}
void wait_for_signal(const char *mesg)
{
printf("%s ... ", mesg);
fflush(stdout);
pause();
vprint("%s: wakened by signal %s\n", __FUNCTION__, glctx.signame);
reset_signal();
printf("\n");
fflush(stdout);
}
void show_siginfo()
{
glctx_t *gcp = &glctx;
siginfo_t *info = gcp->siginfo;
void *badaddr = info->si_addr;
char *sigcode;
switch (info->si_signo) {
case SIGSEGV:
switch (info->si_code) {
case SEGV_MAPERR:
sigcode = "address not mapped";
break;
case SEGV_ACCERR:
sigcode = "invalid access error";
break;
default:
sigcode = "unknown";
break;
}
break;
case SIGBUS:
switch (info->si_code) {
case BUS_ADRALN:
sigcode = "invalid address alignment";
break;
case BUS_ADRERR:
sigcode = "non-existent physical address";
break;
default:
sigcode = "unknown";
break;
}
break;
default:
/*
* ignore SIGINT/SIGQUIT
*/
return;
}
printf("Signal %s @ 0x%lx - %s\n", gcp->signame, badaddr, sigcode);
}
/*
* =========================================================================
*/
void touch_memory(bool rw, unsigned long *memp, size_t memlen)
{
glctx_t *gcp = &glctx;
unsigned long *memend, *pp, sink;
unsigned long longs_in_page = gcp->pagesize / sizeof(unsigned long);
memend = memp + memlen / sizeof(unsigned long);
vprint("!!!%s from 0x%lx thru 0x%lx\n",
rw ? "Writing" : "Reading", memp, memend);
for (pp = memp; pp < memend; pp += longs_in_page) {
// vprint("%s: touching 0x%lx\n", __FUNCTION__, pp);
if (!sigsetjmp(gcp->sigjmp_env, true)) {
gcp->sigjmp = true;
/*
* Mah-ahm! He's touching me!
*/
if (rw)
*pp = (unsigned long)pp;
else
sink = *pp;
gcp->sigjmp = false;
} else {
show_siginfo();
reset_signal();
break;
}
/*
* Any [handled] signal breaks the loop
*/
if (gcp->siginfo != NULL) {
reset_signal();
break;
}
}
}
/*
* =========================================================================
*/
void init_glctx(glctx_t * gcp)
{
bzero(gcp, sizeof(glctx_t));
gcp->pagesize = (size_t) sysconf(_SC_PAGESIZE);
if (numa_available() >= 0) {
gcp->numa_max_node = numa_max_node();
} else
gcp->numa_max_node = -1;
segment_init(gcp);
if (isatty(fileno(stdin)))
set_option(INTERACTIVE);
}
/*
* cleanup() - at exit cleanup routine
*/
static void cleanup()
{
glctx_t *gcp = &glctx;
segment_cleanup(gcp);
} /* cleanup() */
int parse_command_line_args(int argc, char *argv[])
{
extern int optind;
extern char *optarg;
glctx_t *gcp = &glctx;
int argval;
int error = 0;
char c;
gcp->program_name = basename(argv[0]);
/*
* process command line options.
*/
while ((c = getopt(argc, argv, OPTIONS)) != (char)EOF) {
char *next;
switch (c) {
case 'v':
set_option(VERBOSE);
break;
case 'h':
case 'x':
usage(NULL);
break;
case 'V':
printf("memtoy " MEMTOY_VERSION " built "
__DATE__ " @ " __TIME__ "\n");
exit(0);
break;
#ifdef _DEBUG
case '0':
argval = strtoul(optarg, &next, 0);
if (*next != '\0') {
fprintf(stderr,
"-D <debug-mask> must be unsigned hex/decimal integer\n");
++error;
} else
gcp->debug = argval;
break;
#endif
default:
error = 1;
break;
}
}
done:
return (error);
}
int main(int argc, char *argv[])
{
glctx_t *gcp = &glctx;
bool user_is_super;
int error;
init_glctx(gcp);
if (!is_option(INTERACTIVE))
setbuf(stdout, NULL);
/*
* Register cleanup handler
*/
if (atexit(cleanup) != 0) {
die(-1, "%s: atexit(cleanup) registration failed\n", argv[0]);
}
user_is_super = (geteuid() == 0);
error = parse_command_line_args(argc, argv);
if (error /* || argc==1 */ ) {
usage(NULL);
}
/*
* actual program logic starts here
*/
printf("memtoy pid: %d\n", getpid());
vprint("%s: pagesize = %d\n", gcp->program_name, gcp->pagesize);
if (gcp->numa_max_node >= 0)
vprint("%s: NUMA available - max node: %d\n",
gcp->program_name, gcp->numa_max_node);
set_signals();
process_commands();
return 0;
}
#else
int main(void)
{
fprintf(stderr, "test requires libnuma >= 2 and it's development packages\n");
return TCONF;
}
#endif