static MIBool
start_itimer_timer (int timer_type)
{
profile_itimer_type = timer_type;
if (!reset_itimer_timer ())
return MI_FALSE;
init_sighandler (timer_type == ITIMER_PROF ? SIGPROF : SIGALRM);
return MI_TRUE;
}
int main(ATTRIBUTE_UNUSED int argc, ATTRIBUTE_UNUSED char *argv[])
{
initialize_control_c();
init_sighandler();
printf("Initialized\n");
while (run == true)
{
sleep(1);
}
cleanup_control_c();
printf("Stopped\n");
return 0;
}
static MIBool
start_rtc_timer (void)
{
int flags;
int irq_rate;
MI_DEBUG (("Turning on RTC timer\n"));
if ((timer_fd = open ("/dev/rtc", O_RDONLY)) < 0) {
mi_perror ("Error opening /dev/rtc");
return MI_FALSE;
}
flags = fcntl (timer_fd, F_GETFL);
if (fcntl (timer_fd, F_SETFL, flags | FASYNC) < 0) {
mi_perror ("Error setting FASYNC");
goto bail;
}
if (fcntl (timer_fd, F_SETOWN, getpid ()) < 0) {
mi_perror ("Error setting owner for SIGIO");
goto bail;
}
if (fcntl (timer_fd, F_SETSIG, SIGPROF) < 0) {
mi_perror ("Error setting signal for /dev/rtc");
goto bail;
}
irq_rate = 1;
while (1000000 / irq_rate > profile_interval &&
irq_rate < 8192)
irq_rate *= 2;
if (ioctl (timer_fd, RTC_IRQP_SET, irq_rate) < 0) {
mi_perror ("Error setting interrupt rate");
goto bail;
}
if (ioctl (timer_fd, RTC_PIE_ON) < 0) {
mi_perror ("Error turning on interrupts");
goto bail;
}
init_sighandler (SIGPROF);
return MI_TRUE;
bail:
close (timer_fd);
return MI_FALSE;
}
int main(int argc, char **argv){
GtkBuilder *builder = NULL;
GError *error = NULL;
GtkWidget *main_window = NULL;
GtkWidget *main_screen = NULL;
GtkWidget *button_list[MAX_BUTTON];
GtkWidget *led_list[MAX_LEDS];
#ifndef TRUE_COLOR
guint32 virtual_color[256];
#endif
//
init_sighandler();
//init gtk context
gtk_init(&argc, &argv);
gdk_rgb_init();
//init color palette
#ifndef TRUE_COLOR
virtual_palette_set((unsigned int *)virtual_color);
V_CPU.cmap = gdk_rgb_cmap_new(virtual_color, 256);
#endif
builder = gtk_builder_new();
//load UI from file. If error occurs, report it and quit application.
if(!gtk_builder_add_from_file(builder, UI_FILE, &error)) {
g_warning("%s", error->message);
g_free(error);
return -1;
}
//
gtk_builder_connect_signals(builder,NULL);
//create main_window and configure it main_screen an buttonq
main_window = GTK_WIDGET(gtk_builder_get_object(builder,"main_window"));
gtk_signal_connect(GTK_OBJECT (main_window), "delete_event",
GTK_SIGNAL_FUNC(destroy),NULL);
//create main screen and configure it
main_screen = GTK_WIDGET(gtk_builder_get_object(builder,"main_screen"));
//gtk_drawing_area_size(GTK_DRAWING_AREA(main_screen), SCREEN_XRES, SCREEN_YRES);
gtk_signal_connect(GTK_OBJECT (main_screen), "expose_event",
GTK_SIGNAL_FUNC(on_darea_expose),NULL);
//refresh screen rate 75 ms
gtk_timeout_add(75, Repaint,(gpointer)main_screen);
//read kb layout provide by user interface
virtual_kb_create_button(builder,button_list,MAX_BUTTON,kb_layout,read_kb);
//create radio button provide by user interface
virtual_leds_create_radio_button(builder,led_list,MAX_LEDS);
//add stdin in watch descriptor
V_CPU.gui_event = gio_watch;
V_CPU.gui_event[0].watch = (void*)g_io_channel_unix_new(0);
g_io_add_watch((GIOChannel *)V_CPU.gui_event[0].watch,G_IO_IN, (GIOFunc)gio_watch[0].func,0);
gtk_widget_add_events(main_screen,
GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
gtk_widget_show(main_window);
//destroy builder, since we don't need it anymore
g_object_unref(G_OBJECT(builder));
//init hardware
init_hardware((void *)&V_CPU);
//wait for pipe ready
if(load_pipe()<0) {
return -1;
}
//main gtk loop
gtk_main();
return 0;
}
int main(int argc, char **argv) {
int rc;
pid_t pid;
int i;
options_t *opts = get_options(argc, argv);
char *fullname = NULL;
asprintf(&fullname, "%s:", opts->name ? opts->name : argv[0]);
argv[0] = fullname;
if(opts->detached) {
pid = fork();
if(pid == 0) {
rc = setsid();
if(rc == -1) {
perror("setsid");
return EXIT_FAILURE;
}
} else if(pid == -1) {
perror("fork");
return EXIT_FAILURE;
} else {
return EXIT_SUCCESS;
}
}
if(opts->group) {
struct group *grp = getgrnam(opts->group);
if(grp == NULL) {
fprintf(stderr, "getgrnam(%s): Couldn't find group\n", opts->group);
return EXIT_FAILURE;
}
rc = setgid(grp->gr_gid);
if(rc != 0) {
fprintf(stderr, "setgid(%d): Couldn't set the group ID\n", grp->gr_gid);
return EXIT_FAILURE;
}
rc = initgroups(opts->group, grp->gr_gid);
if(rc == -1) {
fprintf(stderr, "initgroups(%s, %d): You must run the program as root\n",
opts->group, grp->gr_gid);
return EXIT_FAILURE;
}
}
if(opts->user) {
struct passwd *pwd = getpwnam(opts->user);
if(pwd == NULL) {
fprintf(stderr, "getpwnam(%s): Couldn't find user\n", opts->user);
return EXIT_FAILURE;
}
rc = setuid(pwd->pw_uid);
if(rc != 0) {
fprintf(stderr, "setuid(%d): Couldn't set the user ID\n", pwd->pw_uid);
return EXIT_FAILURE;
}
}
char **versions;
numver = get_versions(opts->dir, &versions);
pids = (pid_t*)calloc(numver, sizeof(pid_t));
for(i = 0; i < numver; i++) {
pid = fork();
switch(pid) {
case -1:
perror("fork");
kill_processes(SIGTERM);
return EXIT_FAILURE;
case 0:
rc = start_process(opts, versions[i]);
if(rc == -1) {
/* This is in a child process that might have a "smaller" version of the
* list of PIDs. Some processes might then not be killed here.
* This is probably good enough corresponding the scope of this program.
*/
kill_processes(SIGTERM);
return EXIT_FAILURE;
}
default:
pids[i] = pid;
}
}
init_sighandler();
asprintf(&argv[1], "%i/%i remaining processes", numver, numver);
argv[2] = NULL;
int status;
while((pid = wait(&status)) != -1 || errno == EINTR) {
if(WIFEXITED(status) || WIFSIGNALED(status)) {
int nrem = 0;
for(i = 0; i < numver; i++) {
if(pids[i] == pid) { pids[i] = 0; }
if(pids[i] != 0) { nrem++; }
}
asprintf(&argv[1], "%i/%i remaining processes", nrem, numver);
if(nrem == 0) {
break;
}
}
}
free(fullname);
free_options(opts);
return EXIT_SUCCESS;
}
