pk_err_t setup_signal_handlers(void (*caught_handler)(int sig),
const int *caught_signals, const int *ignored_signals)
{
int i;
if (caught_signals != NULL) {
for (i=0; caught_signals[i] != 0; i++) {
if (set_signal_handler(caught_signals[i],
caught_handler)) {
pk_log(LOG_ERROR, "unable to register signal "
"handler for signal %d",
caught_signals[i]);
return PK_CALLFAIL;
}
}
}
if (ignored_signals != NULL) {
for (i=0; ignored_signals[i] != 0; i++) {
if (set_signal_handler(ignored_signals[i], SIG_IGN)) {
pk_log(LOG_ERROR, "unable to ignore signal %d",
ignored_signals[i]);
return PK_CALLFAIL;
}
}
}
return PK_SUCCESS;
}
void cs_exit(int32_t sig)
{
if (cs_dump_stack && (sig == SIGSEGV || sig == SIGBUS || sig == SIGQUIT))
cs_dumpstack(sig);
set_signal_handler(SIGHUP , 1, SIG_IGN);
set_signal_handler(SIGPIPE, 1, SIG_IGN);
struct s_client *cl = cur_client();
if (!cl)
return;
// this is very important - do not remove
if (cl->typ != 's') {
cs_debug_mask(D_TRACE, "thread %8lX ended!", (unsigned long)pthread_self());
free_client(cl);
//Restore signals before exiting thread
set_signal_handler(SIGPIPE , 0, cs_sigpipe);
set_signal_handler(SIGHUP , 1, cs_reload_config);
pthread_exit(NULL);
return;
}
if (!exit_oscam)
exit_oscam = sig?sig:1;
}
byte *
lizard_decompress_safe(const byte *in, struct lizard_buffer *buf, uns expected_length)
/* Decompresses in into buf, sets *ptr to the data, and returns the
* uncompressed length. If an error has occured, -1 is returned and errno is
* set. The buffer buf is automatically reallocated. SIGSEGV is caught in
* case of buffer-overflow. The function is not re-entrant because of a
* static longjmp handler. */
{
uns lock_offset = ALIGN_TO(expected_length + 3, CPU_PAGE_SIZE); // +3 due to the unaligned access
if (lock_offset > buf->len)
lizard_realloc(buf, lock_offset);
volatile ucw_sighandler_t old_handler = set_signal_handler(SIGSEGV, sigsegv_handler);
byte *ptr;
if (!setjmp(safe_decompress_jump))
{
ptr = buf->ptr + buf->len - lock_offset;
int len = lizard_decompress(in, ptr);
if (len != (int) expected_length)
{
ptr = NULL;
errno = EINVAL;
}
}
else
{
msg(L_ERROR, "SIGSEGV caught in lizard_decompress()");
ptr = NULL;
errno = EFAULT;
}
set_signal_handler(SIGSEGV, old_handler);
return ptr;
}
/* Sets signal handlers to ignore for early startup of OSCam because for example log
could cause SIGPIPE errors and the normal signal handlers can't be used at this point. */
static void init_signal_pre(void)
{
set_signal_handler(SIGPIPE , 1, SIG_IGN);
set_signal_handler(SIGWINCH, 1, SIG_IGN);
set_signal_handler(SIGALRM , 1, SIG_IGN);
set_signal_handler(SIGHUP , 1, SIG_IGN);
}
static int set_signal_handlers(void)
{
if ((set_signal_handler(SIGHUP, signal_handler) == -1)
|| (set_signal_handler(SIGINT, signal_handler) == -1)
|| (set_signal_handler(SIGTERM, signal_handler) == -1)
|| (set_signal_handler(SIGPIPE, SIG_IGN) == -1))
return -1;
return 0;
}
void
makedaemon(char *logname)
{
int uid = 32767;
int gid = 32767;
char *user = "******";
struct passwd *pwd;
int logfd;
logfd = open(logname, O_WRONLY | O_CREAT | O_APPEND);
if(logfd < 0) {
debug(DBG_GLOBAL, 0, "Could not open logfile '%s', exiting", logname);
exit(255);
}
if(getuid() == 0) {
pwd = getpwnam(user);
if(pwd) {
uid = pwd->pw_uid;
gid = pwd->pw_gid;
}
debug(DBG_GLOBAL, 0,
"Launched as root, trying to become %s (uid %d, gid %d)..",
user, uid, gid);
notminus(setgroups(0, (const gid_t *) 0), "setgroups");
initgroups(user, gid); // not critical if fails
notminus(setgid(gid), "setgid");
notminus(setegid(gid), "setegid");
notminus(setuid(uid), "setuid");
notminus(seteuid(gid), "seteuid");
debug(DBG_GLOBAL, 0, "now forking");
}
if(fork() != 0)
exit(0);
setsid();
set_signal_handler(SIGHUP, SIG_IGN);
set_signal_handler(SIGPIPE, SIG_IGN);
if(fork() != 0)
exit(0);
//chdir("/tmp");
//chroot("/tmp");
//umask(077);
close(0);
close(1);
close(2);
dup2(logfd, 1);
dup2(logfd, 2);
debug(DBG_GLOBAL, 0, "Started as a daemon");
}
int main(int argc, char **argv) {
int ret = EXIT_SUCCESS;
int opt;
kga_init();
set_signal_handler(SIGHUP, interrupted);
set_signal_handler(SIGINT, interrupted);
set_signal_handler(SIGTERM, interrupted);
try_scope {
while ((opt = getopt(argc, argv, "r:d:ti")) != -1) {
switch(opt) {
case 'i':
pkg_confirm = common_confirm;
break;
case 'r':
root = optarg;
break;
case 'd':
db_path = optarg;
break;
default:
throw(pkg_main_incorrect_cmd, 1, "unknown option", NULL);
break;
};
};
int real_argc = argc - optind;
char **real_argv = &argv[optind];
if (!real_argc) {
throw(pkg_main_incorrect_cmd, 1, "no subcommand", NULL);
} else if (!strcmp(real_argv[0], "install")) {
if (real_argc != 2) {
throw(pkg_main_incorrect_cmd, 1, "incorrect subcommand", NULL);
};
pkg_install(real_argv[1], root, db_path, 0, stderr);
} else if (!strcmp(real_argv[0], "upgrade")) {
if (real_argc != 2) {
throw(pkg_main_incorrect_cmd, 1, "incorrect subcommand", NULL);
};
pkg_install(real_argv[1], root, db_path, PKG_UPGRADE, stderr);
} else if (!strcmp(real_argv[0], "drop")) {
if (real_argc < 2 || real_argc > 3) {
throw(pkg_main_incorrect_cmd, 1, "incorrect subcommand", NULL);
};
char *slash;
if ((slash = strchr(real_argv[1], '/'))) {
*slash = '\0';
pkg_drop(root, db_path, real_argv[1], &slash[1], stderr);
} else {
pkg_drop(root, db_path, real_argv[1], real_argc == 2 ? NULL : real_argv[2], stderr);
}
} else {
throw(pkg_main_incorrect_cmd, 1, "unknown subcommand", NULL);
};
};
catch {
if (exception()->type == &pkg_main_incorrect_cmd) {
int SMTP_ehlo(int sock, char smtp_mode, const char *host, char *name, char *password, int *opt)
/* send a "EHLO" message to the SMTP listener, return extension status bits */
{
struct opt *hp;
char auth_response[511];
SIGHANDLERTYPE alrmsave;
const int tmout = (mytimeout >= TIMEOUT_HELO ? mytimeout : TIMEOUT_HELO);
SockPrintf(sock,"%cHLO %s\r\n", (smtp_mode == 'S') ? 'E' : smtp_mode, host);
if (outlevel >= O_MONITOR)
report(stdout, "%cMTP> %cHLO %s\n",
smtp_mode, (smtp_mode == 'S') ? 'E' : smtp_mode, host);
alrmsave = set_signal_handler(SIGALRM, null_signal_handler);
set_timeout(tmout);
*opt = 0;
while ((SockRead(sock, smtp_response, sizeof(smtp_response)-1)) != -1)
{
size_t n;
set_timeout(0);
(void)set_signal_handler(SIGALRM, alrmsave);
n = strlen(smtp_response);
if (n > 0 && smtp_response[n-1] == '\n')
smtp_response[--n] = '\0';
if (n > 0 && smtp_response[n-1] == '\r')
smtp_response[--n] = '\0';
if (n < 4)
return SM_ERROR;
smtp_response[n] = '\0';
if (outlevel >= O_MONITOR)
report(stdout, "%cMTP< %s\n", smtp_mode, smtp_response);
for (hp = extensions; hp->name; hp++)
if (!strncasecmp(hp->name, smtp_response+4, strlen(hp->name))) {
*opt |= hp->value;
if (strncmp(hp->name, "AUTH ", 5) == 0)
strncpy(auth_response, smtp_response, sizeof(auth_response));
auth_response[sizeof(auth_response)-1] = '\0';
}
if ((smtp_response[0] == '1' || smtp_response[0] == '2' || smtp_response[0] == '3') && smtp_response[3] == ' ') {
if (*opt & ESMTP_AUTH)
SMTP_auth(sock, smtp_mode, name, password, auth_response);
return SM_OK;
}
else if (smtp_response[3] != '-')
return SM_ERROR;
alrmsave = set_signal_handler(SIGALRM, null_signal_handler);
set_timeout(tmout);
}
return SM_UNRECOVERABLE;
}
int
main(int argc, char **argv)
{
int ret;
settings_init();
if (set_signal_handler(signals) == -1) {
return -1;
}
tc_time_init();
if (read_args(argc, argv) == -1) {
return -1;
}
if (srv_settings.log_path == NULL) {
srv_settings.log_path = "error_intercept.log";
}
if (tc_log_init(srv_settings.log_path) == -1) {
return -1;
}
ret = tc_event_loop_init(&s_event_loop, MAX_FD_NUM);
if (ret == TC_EVENT_ERROR) {
tc_log_info(LOG_ERR, 0, "event loop init failed");
return -1;
}
/* output debug info */
output_for_debug();
if (set_details() == -1) {
return -1;
}
if (interception_init(&s_event_loop, srv_settings.binded_ip,
srv_settings.port) == TC_ERROR)
{
return -1;
}
if (set_timer() == -1) {
return -1;
}
#if (INTERCEPT_COMBINED)
tc_event_timer_add(&s_event_loop, CHECK_INTERVAL, interception_push);
#endif
tc_event_timer_add(&s_event_loop, OUTPUT_INTERVAL,
interception_output_stat);
/* run now */
tc_event_process_cycle(&s_event_loop);
server_release_resources();
return 0;
}
void StackPrinter::initialize(const char* program_path, time_t startT)
{
/* store off program path so we can use it later */
icky_global_program_name = program_path;
startTime = startT;
set_signal_handler();
}
int
main( int argc, char **argv )
{
/* Save our program name - for error messages */
set_DeadPipe_handler(DeadPipe);
InitMyApp (CLASS_IDENT, argc, argv, NULL, NULL, 0 );
LinkAfterStepConfig();
set_signal_handler( SIGSEGV );
ConnectX( ASDefaultScr, 0 );
ConnectAfterStep (WINDOW_CONFIG_MASK |
WINDOW_NAME_MASK |
M_END_WINDOWLIST, 0);
Config = CreateIdentConfig ();
/* Request a list of all windows, while we load our config */
SendInfo ("Send_WindowList", 0);
LoadBaseConfig ( GetBaseOptions);
LoadColorScheme();
LoadConfig ("ident", GetOptions);
CheckConfigSanity();
ReloadASDatabase();
ReloadCategories(True);
if (MyArgs.src_window == 0)
MyArgs.src_window = get_target_window();
/* And at long last our main loop : */
HandleEvents();
return 0 ;
}
int main(int argc, char **argv) {
int y, x;
set_signal_handler();
initscr();
curs_set(0);
cbreak();
noecho();
keypad(stdscr, TRUE);
scrollok(stdscr, TRUE);
space.wormhole_y = rand() % (LINES - 1) + 1;
space.wormhole_x = rand() % (COLS - 1);
y = rand() % (LINES - 1) + 1;
x = rand() % (COLS - 1);
hud.moves = 0;
store.starcount = 0;
plot_stars_randomly();
mvprintw(y, x, aircraft.ship);
control_ship(y, x);
refresh();
endwin();
return(0);
}
int init(int argc, char *argv[])
{
mtn = mtn_init(MODULE_NAME);
ctx = calloc(1,sizeof(CTX));
if(!mtn){
return(-1);
}
if(!ctx){
mtnlogger(NULL, 0, "[error] %s: %s\n", __func__, strerror(errno));
return(-1);
}
mtn->mps_max = 512;
mtn->logtype = 0;
mtn->logmode = MTNLOG_STDERR;
ctx->afd = -1;
ctx->nobuf = 1;
ctx->text = 1;
ctx->delim = newstr(" ");
ctx->targets = newarg(0);
ctx->arg_max = sysconf(_SC_ARG_MAX);
ctx->cpu_num = sysconf(_SC_NPROCESSORS_ONLN);
ctx->job_max = sysconf(_SC_NPROCESSORS_ONLN);
ctx->cmdargs = parse(argc, argv);
gettimeofday(&(ctx->polltv), NULL);
if(init_pipe() == -1){
return(-1);
}
if(init_poll() == -1){
return(-1);
}
ctx->job = calloc(ctx->job_max, sizeof(MTNJOB));
set_signal_handler();
mtnlogger(mtn, 1, "LogLevel: %d\n", mtn->loglevel);
return(0);
}
/*
* Fork a child process and then kill the parent so make the calling
* program a daemon process.
*/
void
makedaemon(void)
{
if (fork() != 0)
exit(0);
setsid();
set_signal_handler(SIGHUP, SIG_IGN);
if (fork() != 0)
exit(0);
chdir("/");
umask(0177);
#if NDEBUG
/*
* When not in debugging mode, close the standard file
* descriptors.
*/
close(0);
close(1);
close(2);
#endif
}
/*
* main
*/
int main(int argc, char *argv[])
{
int ret;
char *user;
progname = argv[0] ? argv[0] : "lttng";
/* For Mathieu Desnoyers a.k.a. Dr. Tracing */
user = getenv("USER");
if (user != NULL && ((strncmp(progname, "drtrace", 7) == 0 ||
strncmp("compudj", user, 7) == 0))) {
MSG("%c[%d;%dmWelcome back Dr Tracing!%c[%dm\n", 27,1,33,27,0);
}
/* Thanks Mathieu */
ret = set_signal_handler();
if (ret < 0) {
clean_exit(ret);
}
ret = parse_args(argc, argv);
if (ret != 0) {
clean_exit(ret);
}
return 0;
}
/* set default values for intercept */
static void settings_init(void)
{
srv_settings.port = SERVER_PORT;
srv_settings.hash_size = 65536;
srv_settings.binded_ip = NULL;
set_signal_handler();
}
/*
* Fork a child "child" (or in our case a process) and then start up the
* child_main() function.
*/
static pid_t child_make (struct child_s *ptr)
{
pid_t pid;
if ((pid = fork ()) > 0)
return pid; /* parent */
/*
* Reset the SIGNALS so that the child can be reaped.
*/
set_signal_handler (SIGCHLD, SIG_DFL);
set_signal_handler (SIGTERM, SIG_DFL);
set_signal_handler (SIGHUP, child_sighup_handler);
child_main (ptr); /* never returns */
return -1;
}
/* Fork, and have the parent wait for the child to indicate that the parent
should exit. In the parent, this returns only on error. In the child, it
returns success and sets *status_fd. If the child writes a byte to the fd,
the parent will exit with that byte as its exit status. If the child closes
the fd without writing anything, the parent will exit(0). */
pk_err_t fork_and_wait(int *status_fd)
{
int fds[2];
pid_t pid;
char ret=1;
int status;
/* Make sure the child isn't killed if the parent dies */
if (set_signal_handler(SIGPIPE, SIG_IGN)) {
pk_log(LOG_ERROR, "Couldn't block SIGPIPE");
return PK_CALLFAIL;
}
if (pipe(fds)) {
pk_log(LOG_ERROR, "Can't create pipe");
return PK_CALLFAIL;
}
pid=fork();
if (pid == -1) {
pk_log(LOG_ERROR, "fork() failed");
return PK_CALLFAIL;
} else if (pid) {
/* Parent */
close(fds[1]);
if (read(fds[0], &ret, sizeof(ret)) == 0) {
exit(0);
} else {
if (waitpid(pid, &status, 0) == -1)
exit(ret);
if (WIFEXITED(status))
exit(WEXITSTATUS(status));
if (WIFSIGNALED(status)) {
set_signal_handler(WTERMSIG(status), SIG_DFL);
raise(WTERMSIG(status));
}
exit(ret);
}
} else {
/* Child */
close(fds[0]);
*status_fd=fds[1];
}
return PK_SUCCESS;
}
/*********************************
* main - this is where it begins
*********************************/
int main(int argc, char **argv)
{
std::cout << "********************************************" << std::endl;
std::cout << "*** cudapts - Nvidia PTS Pool Miner v" << VERSION_MAJOR << "." << VERSION_MINOR << " " << VERSION_EXT << std::endl;
std::cout << "*** by dga - based on ptsminer." << std::endl;
std::cout << "*** If you like this software, please consider sending tips to:" << std::endl;
std::cout << "*** PTS: Pr8cnhz5eDsUegBZD4VZmGDARcKaozWbBc" << std::endl;
std::cout << "*** BTC: 17sb5mcCnnt4xH3eEkVi6kHvhzQRjPRBtS" << std::endl;
std::cout << "*** Your donations will encourage further optimization and development" << std::endl;
std::cout << "***" << std::endl;
std::cout << "*** press CTRL+C to exit" << std::endl;
std::cout << "********************************************" << std::endl;
if (argc < 2 || argc > 4)
{
print_help(argv[0]);
return EXIT_FAILURE;
}
t_start = boost::posix_time::second_clock::local_time();
running = true;
#if defined(__MINGW32__) || defined(__MINGW64__)
SetConsoleCtrlHandler(ctrl_handler, TRUE);
#elif defined(__GNUG__) && !defined(__APPLE__)
set_signal_handler(SIGINT, ctrl_handler);
#endif
const int atexit_res = std::atexit(exit_handler);
if (atexit_res != 0)
std::cerr << "atexit registration failed, shutdown will be dirty!" << std::endl;
// init everything:
socket_to_server = NULL;
thread_num_max = 1;
gpu_device_id = atoi(argv[2]);
COLLISION_TABLE_BITS = 21;
fee_to_pay = 0; //GetArg("-poolfee", 3);
miner_id = 0; //GetArg("-minerid", 0);
pool_username = argv[1]; //GetArg("-pooluser", "");
pool_password = "******"; //GetArg("-poolpassword", "");
if (thread_num_max == 0 || thread_num_max > MAX_THREADS)
{
std::cerr << "usage: " << "current maximum supported number of threads = " << MAX_THREADS << std::endl;
return EXIT_FAILURE;
}
// ok, start mining:
CBlockProviderGW* bprovider = new CBlockProviderGW();
CMasterThread *mt = new CMasterThread(bprovider);
mt->run();
// end:
return EXIT_SUCCESS;
}
/**
* @author Petr Djakow
*/
void Utils::signalIgnore(const int signum)
{
#ifdef _GNU_SOURCE
if(sigignore(signum) == -1)
FATAL_ERROR(("sigignore(%d)", signum));
OUT_DEBUG(("Signal '%s' will be ignored", strsignal(signum)));
#else
set_signal_handler(signum, SIG_IGN);
OUT_DEBUG(("Signal '%d' will be ignored", signum));
#endif
}
/**
* register signal/interrupt handler for signal sig
*
* TODO: use appropriate data structure for signal
* handlers.
*/
int register_interrupt(int sig, _native_callback_t handler)
{
DEBUG("register_interrupt\n");
unsigned state = disableIRQ();
native_irq_handlers[sig] = handler;
set_signal_handler(sig, true);
restoreIRQ(state);
return 0;
}
int set_signal_handlers(void) {
if (set_signal_handler(SIGPIPE, SIG_IGN) == SIG_ERR) {
printf("Could not set \"SIGPIPE\" signal.\n");
return(EX_OSERR);
}
if (set_signal_handler(SIGCHLD, SIG_IGN) == SIG_ERR) {
printf("Could not set \"SIGCHLD\" signal.\n");
return(EX_OSERR);
}
if (set_signal_handler(SIGINT, signal_handler) == SIG_ERR) {
printf("Could not set \"SIGINT\" signal.\n");
return(EX_OSERR);
}
if (set_signal_handler(SIGHUP, signal_handler) == SIG_ERR) {
printf("Could not set \"SIGHUP\" signal.\n");
return(EX_OSERR);
}
if (set_signal_handler(SIGTERM, signal_handler) == SIG_ERR) {
printf("Could not set \"SIGTERM\" signal.\n");
return(EX_OSERR);
}
}
/**
* empty signal mask
*/
int unregister_interrupt(int sig)
{
DEBUG("unregister_interrupt\n");
unsigned state = disableIRQ();
set_signal_handler(sig, false);
native_irq_handlers[sig] = NULL;
restoreIRQ(state);
return 0;
}
void
initialize_traps ()
{
register int i;
trap_list[EXIT_TRAP] = trap_list[DEBUG_TRAP] = (char *)NULL;
sigmodes[EXIT_TRAP] = sigmodes[DEBUG_TRAP] = SIG_INHERITED;
original_signals[EXIT_TRAP] = IMPOSSIBLE_TRAP_HANDLER;
for (i = 1; i < NSIG; i++)
{
pending_traps[i] = 0;
trap_list[i] = (char *)DEFAULT_SIG;
sigmodes[i] = SIG_INHERITED;
original_signals[i] = IMPOSSIBLE_TRAP_HANDLER;
}
/* Show which signals are treated specially by the shell. */
#if defined (SIGCHLD)
original_signals[SIGCHLD] =
(SigHandler *) set_signal_handler (SIGCHLD, SIG_DFL);
set_signal_handler (SIGCHLD, original_signals[SIGCHLD]);
sigmodes[SIGCHLD] |= (SIG_SPECIAL | SIG_NO_TRAP);
#endif /* SIGCHLD */
original_signals[SIGINT] =
(SigHandler *) set_signal_handler (SIGINT, SIG_DFL);
set_signal_handler (SIGINT, original_signals[SIGINT]);
sigmodes[SIGINT] |= SIG_SPECIAL;
#if defined (__BEOS__)
/* BeOS sets SIGINT to SIG_IGN! */
original_signals[SIGINT] = SIG_DFL;
#endif
original_signals[SIGQUIT] =
(SigHandler *) set_signal_handler (SIGQUIT, SIG_DFL);
set_signal_handler (SIGQUIT, original_signals[SIGQUIT]);
sigmodes[SIGQUIT] |= SIG_SPECIAL;
if (interactive)
{
original_signals[SIGTERM] =
(SigHandler *)set_signal_handler (SIGTERM, SIG_DFL);
set_signal_handler (SIGTERM, original_signals[SIGTERM]);
sigmodes[SIGTERM] |= SIG_SPECIAL;
}
}
static void
initialize_shell_signals ()
{
if (interactive)
initialize_terminating_signals ();
#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
/* All shells use the signal mask they inherit, and pass it along
to child processes. Children will never block SIGCHLD, though. */
sigemptyset (&top_level_mask);
sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &top_level_mask);
sigdelset (&top_level_mask, SIGCHLD);
#endif /* JOB_CONTROL || HAVE_POSIX_SIGNALS */
/* And, some signals that are specifically ignored by the shell. */
set_signal_handler (SIGQUIT, SIG_IGN);
if (interactive)
{
set_signal_handler (SIGINT, sigint_sighandler);
set_signal_handler (SIGTERM, SIG_IGN);
}
}
/* set default values for TCPCopy client */
static void
settings_init()
{
/* init values */
clt_settings.mtu = DEFAULT_MTU;
clt_settings.max_rss = MAX_MEMORY_SIZE;
clt_settings.srv_port = SERVER_PORT;
clt_settings.percentage = 0;
clt_settings.session_timeout = DEFAULT_SESSION_TIMEOUT;
tc_raw_socket_out = TC_INVALID_SOCKET;
set_signal_handler();
}
/*
このプログラムではスタックアドレスの下半分をハンドリングする。
+-------------------+
| |
| |
| |
| |
| |
+------------------+
| |
| |
| |
+------------------+
| Glibc gurad page |
+------------------+
*/
int main(int argc, char** argv)
{
char* stackaddr;
size_t stacksize;
get_linux_stack_info((void**)&stackaddr, &stacksize);
/* 代替シグナルスタックのセット */
start_alternative_stack_addr = stackaddr + SYSTEM_GUARD_PAGE_SIZE;
end_alternative_stack_addr = start_alternative_stack_addr + ALT_STACK_SIZE;
if (mmap(start_alternative_stack_addr, ALT_STACK_SIZE,
PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) == (void*)-1){
fprintf(stderr, "faield mmap\n");
fflush(stderr);
exit(1);
}
set_alternative_signal_stack(start_alternative_stack_addr, ALT_STACK_SIZE);
/* シグナルハンドラのセット */
set_signal_handler();
printf( "Stack region: [%p, %p)\n", stackaddr, stackaddr + stacksize);
// Linux
start_new_guard = stackaddr + SYSTEM_GUARD_PAGE_SIZE + ALT_STACK_SIZE;
end_new_guard = stackaddr + (stacksize / 2);
start_new_guard = (char*)(((intptr_t)start_new_guard + VM_PAGE_SIZE -1) & (~(VM_PAGE_SIZE - 1)));
end_new_guard = (char*)(((intptr_t)end_new_guard) & (~(VM_PAGE_SIZE - 1)));
if (mmap(start_new_guard, end_new_guard - start_new_guard,
PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) == (void*)-1 ){
fprintf(stderr, "faield mmap\n");
fflush(stderr);
exit(1);
}
printf( "New guard area: [%p, %p)\n", start_new_guard, end_new_guard);
/* わざとスタックオーバーフローを発生させる */
cause_stack_overflow();
return 0;
}
void display_init(void)
{
scr = initscr();
start_color();
/* Assign default foreground/background colors to color number -1 */
use_default_colors();
init_pair(NO_COLOR, -1, -1);
init_pair(RED_ON_BLACK, COLOR_RED, COLOR_BLACK);
init_pair(BLACK_ON_CYAN, COLOR_BLACK, COLOR_CYAN);
init_pair(BLACK_ON_GREEN, COLOR_BLACK, COLOR_GREEN);
init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE);
init_pair(BLACK_ON_YELLOW, COLOR_BLACK, COLOR_YELLOW);
init_pair(YELLOW_ON_BLACK, COLOR_YELLOW, COLOR_BLACK);
init_pair(WHITE_ON_RED, COLOR_WHITE, COLOR_RED);
init_pair(YELLOW_ON_NOTHING, COLOR_YELLOW, -1);
init_pair(GREEN_ON_NOTHING, COLOR_GREEN, -1);
init_pair(RED_ON_NOTHING, COLOR_RED, -1);
init_pair(BLUE_ON_NOTHING, COLOR_BLUE, -1);
init_pair(CYAN_ON_NOTHING, COLOR_CYAN, -1);
init_pair(MAGENTA_ON_NOTHING, COLOR_MAGENTA, -1);
init_pair(WHITE_ON_NOTHING, COLOR_WHITE, -1);
/* nodelay(scr, TRUE); */
noecho();
curs_set(0);
/* Create fullscreen log window. When stats are displayed
later, it is recreated with appropriate dimensions. */
win_txt = create_subwindow(0, 0, 0, 0);
wbkgd(win_txt, COLOR_PAIR(0));
idlok(win_txt, FALSE);
/* Get scrolling */
scrollok(win_txt, TRUE);
/* Leave cursor where it was */
leaveok(win_txt, TRUE);
refresh();
set_signal_handler();
max_n_lines = (LINES - 5 - 2 - 3);
/* core_port_height = max_n_lines < stats_get_n_tasks_tot()? max_n_lines : stats_get_n_tasks_tot(); */
display_init_screens();
display_screen(0);
stats_display_layout(0);
}
int main(int argc, char **argv)
{
char cmdbuf[BUFSIZ];
int c;
whoami = argv[0];
interactive = (isatty(0) && isatty(1));
while ((c = getopt(argc, argv, "q")) != -1)
{
switch (c)
{
case 'q':
quote_output = 1;
break;
default:
fprintf(stderr, "Usage: mrtest [-q]\n");
exit (1);
}
}
#if defined(__APPLE__) && defined(__MACH__)
add_error_table(&et_sms_error_table);
add_error_table(&et_krb_error_table);
#else
initialize_sms_error_table();
initialize_krb_error_table();
#endif
#ifdef HAVE_READLINE
/* we don't want filename completion */
rl_bind_key('\t', rl_insert);
#endif
set_signal_handler(SIGINT, discard_input);
sigsetjmp(jb, 1);
while (!quit)
{
if (!mr_gets("moira: ", cmdbuf, BUFSIZ))
break;
execute_line(cmdbuf);
}
mr_disconnect();
exit(0);
}
/*
* main
*/
int main(int argc, char *argv[])
{
int ret;
progname = argv[0] ? argv[0] : "lttng";
ret = set_signal_handler();
if (ret < 0) {
clean_exit(ret);
}
ret = parse_args(argc, argv);
if (ret != 0) {
clean_exit(ret);
}
return 0;
}
