static void
processes_kill(int sig)
{
for (int i = 0; i < num_processes; i++) {
bench_process_t *p = processes + i;
if (process_running(p))
process_kill(p, sig);
}
}
struct thread *syscall_exit(struct thread *image) {
if (image->proc->pid == 1) {
debug_panic("init died");
}
process_switch(process_get(1));
process_kill(image->proc);
return thread_switch(image, schedule_next());
}
void program_scheduler_shutdown(ProgramScheduler *program_scheduler) {
if (program_scheduler->shutdown) {
return;
}
program_scheduler->shutdown = true;
program_scheduler_stop(program_scheduler, NULL);
if (program_scheduler->last_spawned_process != NULL &&
process_is_alive(program_scheduler->last_spawned_process)) {
process_kill(program_scheduler->last_spawned_process, PROCESS_SIGNAL_KILL);
}
}
static void system_sysc_exit(PSW* m) {
DEBUG_PRINTF(DEBUG_T_SYSC, "SYSCALL EXIT()\n");
Process* process = process_current();
if(process == NULL){
DEBUG_PUTS(DEBUG_T_SYSTEM, "Pas de processus courant");
return;
}
DEBUG_PRINTF(DEBUG_T_SYSTEM, "Suppr. proc %d\n", (int)process->number);
process_kill(process);
system_clock(m);
}
static int on_process(void* param, const char* name, pid_t pid)
{
const char* p;
const char* process = (const char*)param;
p = path_basename(name);
#if defined(OS_WINDOWS)
if(0 == stricmp(process, p))
#else
if(0 == strcmp(process, p))
#endif
{
process_kill(pid);
}
return 0;
}
static gboolean
on_transport_control (CockpitTransport *transport,
const char *command,
const gchar *channel_id,
JsonObject *options,
GBytes *message,
gpointer user_data)
{
CockpitRouter *self = user_data;
if (g_str_equal (command, "init"))
{
process_init (self, transport, options);
return TRUE;
}
if (!self->init_host)
{
g_warning ("caller did not send 'init' message first");
cockpit_transport_close (transport, "protocol-error");
return TRUE;
}
if (g_str_equal (command, "open"))
{
process_open (self, transport, channel_id, options, message);
return TRUE;
}
else if (g_str_equal (command, "kill"))
{
process_kill (self, options);
return TRUE;
}
else if (g_str_equal (command, "close"))
{
if (!channel_id)
{
g_warning ("Caller tried to close channel without an id");
cockpit_transport_close (transport, "protocol-error");
}
}
return FALSE;
}
void
alleyoop_kill (Alleyoop *grind)
{
vg_tool_view_disconnect ((VgToolView *) grind->view);
if (grind->gio) {
g_io_channel_close (grind->gio);
g_io_channel_unref (grind->gio);
grind->watch_id = 0;
grind->gio = NULL;
}
if (grind->pid != (pid_t) -1) {
process_kill (grind->pid);
grind->pid = (pid_t) -1;
}
gtk_widget_set_sensitive (grind->toolbar_run, TRUE);
gtk_widget_set_sensitive (grind->toolbar_kill, FALSE);
}
struct thread *syscall_exit(struct thread *image) {
struct thread *new_image;
uint16_t pid;
uint32_t parent;
pid = image->proc->pid;
if (pid == 1) {
debug_panic("init died");
}
parent = image->proc->parent->pid;
process_switch(process_get(1));
new_image = thread_send(image, parent, PORT_CHILD, NULL);
image->proc->status = image->eax;
process_kill(image->proc);
return new_image;
}
/*
* Stop a particular process given its process struct. This kills the
* process, waits for it to exit if possible (giving it at most five seconds),
* and then removes it from the global processes struct so that it isn't
* stopped again during global shutdown.
*/
void
process_stop(struct process *process)
{
int status;
unsigned long pid = process->pid;
/* Stop the process. */
status = process_kill(process);
/* Call diag to flush logs as well as provide exit status. */
if (process->is_child)
diag("stopped process %lu (exit status %d)", pid, status);
else
diag("stopped process %lu", pid);
/* Remove the log and PID file. */
diag_file_remove(process->logfile);
unlink(process->pidfile);
unlink(process->logfile);
/* Free resources. */
process_free(process);
}
int main(int argc, char *argv[]) {
SRunner *sr;
int_t failed = 0;
time_t prog_start, test_start, test_end;
if (process_kill(PLACER("magmad", 18), SIGTERM, 10) < 0) {
log_unit("Another instance of the Magma Daemon is already running and refuses to die.");
exit(EXIT_FAILURE);
}
// Setup
prog_start = time(NULL);
// Updates the location of the config file if it was specified on the command line.
check_args_parse(argc, argv);
if (do_virus_check && !virus_check_data_path) {
virus_check_data_path = ns_dupe(VIRUS_CHECK_DATA_PATH);
}
if (do_tank_check && !tank_check_data_path) {
tank_check_data_path = ns_dupe(TANK_CHECK_DATA_PATH);
}
if (do_dspam_check && !dspam_check_data_path) {
dspam_check_data_path = ns_dupe(DSPAM_CHECK_DATA_PATH);
}
/*if (do_virus_check) printf("doing virus check: [%s]\n", !virus_check_data_path ? "NONE" : virus_check_data_path); else printf ("skipping virus check\n");
if (do_tank_check) printf("doing tank check: [%s]\n", !tank_check_data_path ? "NONE" : tank_check_data_path); else printf ("skipping tank check\n");
if (do_dspam_check) printf("doing dspam check: [%s]\n", !dspam_check_data_path ? "NONE" : dspam_check_data_path); else printf ("skipping dspam check\n");
printf("config file: [%s]\n", magma.config.file);
exit(EXIT_SUCCESS);*/
if (!process_start()) {
log_unit("Initialization error. Exiting.\n");
status_set(-1);
process_stop();
exit(EXIT_FAILURE);
}
// Only during development...
cache_flush();
// Unit Test Config
sr = srunner_create(suite_check_magma());
// Add the suites.
srunner_add_suite(sr, suite_check_core());
srunner_add_suite(sr, suite_check_provide());
srunner_add_suite(sr, suite_check_network());
srunner_add_suite(sr, suite_check_objects());
srunner_add_suite(sr, suite_check_users());
// If were being run under Valgrind, we need to disable forking and increase the default timeout.
// Under Valgrind, forked checks appear to improperly timeout.
if (RUNNING_ON_VALGRIND == 0 && (failed = running_on_debugger()) == 0) {
log_unit("Not being traced or profiled...\n");
srunner_set_fork_status (sr, CK_FORK);
case_timeout = RUN_TEST_CASE_TIMEOUT;
}
else {
// Trace detection attempted was thwarted.
if (failed == -1) log_unit("Trace detection was thwarted.\n");
else log_unit("Tracing or debugging is active...\n");
srunner_set_fork_status (sr, CK_NOFORK);
case_timeout = PROFILE_TEST_CASE_TIMEOUT;
}
// Execute
log_unit("--------------------------------------------------------------------------\n");
test_start = time(NULL);
srunner_run_all(sr, CK_SILENT);
test_end = time(NULL);
// Output timing.
log_unit("--------------------------------------------------------------------------\n");
log_unit("%-63.63s %9lus\n", "TEST DURATION:", test_end - test_start);
log_unit("%-63.63s %9lus\n", "TOTAL DURATION:", test_end - prog_start);
// Summary
log_unit("--------------------------------------------------------------------------\n");
failed = srunner_ntests_failed(sr);
srunner_print(sr, CK_NORMAL);
// The Check Output Ending
log_unit("--------------------------------------------------------------------------\n");
// Cleanup and free the resources allocated by the check code.
status_set(-1);
srunner_free(sr);
ns_cleanup(virus_check_data_path);
ns_cleanup(tank_check_data_path);
ns_cleanup(dspam_check_data_path);
// Cleanup and free the resources allocated by the magma code.
process_stop();
system_init_umask();
exit((failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
}
static void
dispatch_inbound_command (CockpitWebService *self,
CockpitSocket *socket,
GBytes *payload)
{
const gchar *problem = "protocol-error";
const gchar *command;
const gchar *channel;
JsonObject *options = NULL;
gboolean valid = FALSE;
valid = cockpit_transport_parse_command (payload, &command, &channel, &options);
if (!valid)
goto out;
if (g_strcmp0 (command, "init") == 0)
{
problem = process_socket_init (self, socket, options);
valid = (problem == NULL);
goto out;
}
if (!socket->init_received)
{
g_message ("web socket did not send 'init' message first");
valid = FALSE;
goto out;
}
valid = TRUE;
if (g_strcmp0 (command, "open") == 0)
{
valid = process_and_relay_open (self, socket, channel, options);
}
else if (g_strcmp0 (command, "authorize") == 0)
{
valid = process_socket_authorize (self, socket, channel, options, payload);
}
else if (g_strcmp0 (command, "logout") == 0)
{
valid = process_logout (self, options);
if (valid)
{
/* logout is broadcast to everyone */
if (!self->sent_done)
cockpit_transport_send (self->transport, NULL, payload);
}
}
else if (g_strcmp0 (command, "close") == 0)
{
if (channel == NULL)
{
g_warning ("got close command without a channel");
valid = FALSE;
}
else
{
valid = process_and_relay_close (self, socket, channel, payload);
}
}
else if (g_strcmp0 (command, "kill") == 0)
{
valid = process_kill (self, socket, options, payload);
}
else if (!channel && g_strcmp0 (command, "ping") == 0)
{
valid = process_ping (self, socket, options);
}
else if (channel)
{
/* Relay anything with a channel by default */
if (!self->sent_done)
cockpit_transport_send (self->transport, NULL, payload);
}
out:
if (!valid)
inbound_protocol_error (self, socket->connection, problem);
if (options)
json_object_unref (options);
}
int process_exit(int exitcode)
{
return process_kill(process_current[smp_cpu_id()]->pid);
}
void Process::kill() {
process_kill(this->obj);
}
