static void handle_socket(struct clientsocket * C) { static char buffer[BUFFER_SIZE]; //since these are local sockets, we can safely assume we get whole messages at a time int r = socketRead(&C->sock, buffer, BUFFER_SIZE); if (r > 0) { switch (buffer[0]) { case 'S'://status if (bb_status.errors[0] != 0) { r = snprintf(buffer, BUFFER_SIZE, "Error (%s): %s\n", GITVERSION, bb_status.errors); } else { if (bb_is_running(bb_status.x_pid)) { r = snprintf(buffer, BUFFER_SIZE, "Ready (%s). X is PID %i, %i applications using bumblebeed.\n", GITVERSION, bb_status.x_pid, bb_status.appcount); } else { r = snprintf(buffer, BUFFER_SIZE, "Ready (%s). X inactive.\n", GITVERSION); } } socketWrite(&C->sock, buffer, r); //we assume the write is fully successful. break; case 'F'://force VirtualGL if possible case 'C'://check if VirtualGL is allowed /// \todo Handle power management cases and powering card on/off. //no X? attempt to start it if (!bb_is_running(bb_status.x_pid)) { start_secondary(); } if (bb_is_running(bb_status.x_pid)) { r = snprintf(buffer, BUFFER_SIZE, "Yes. X is active.\n"); if (C->inuse == 0) { C->inuse = 1; bb_status.appcount++; } } else { if (bb_status.errors[0] != 0) { r = snprintf(buffer, BUFFER_SIZE, "No - error: %s\n", bb_status.errors); } else { r = snprintf(buffer, BUFFER_SIZE, "No, secondary X is not active.\n"); } } socketWrite(&C->sock, buffer, r); //we assume the write is fully successful. break; case 'D'://done, close the socket. socketClose(&C->sock); break; default: bb_log(LOG_WARNING, "Unhandled message received: %*s\n", r, buffer); break; } } }
int main(int argc, char* argv[]) { /* Setup signal handling before anything else */ signal(SIGHUP, handle_signal); signal(SIGTERM, handle_signal); signal(SIGINT, handle_signal); signal(SIGQUIT, handle_signal); bb_init_log(); check_secondary(); init_config(argc, argv); /* Change GID and mask according to configuration */ if ((bb_config.gid_name != 0) && (bb_config.gid_name[0] != 0)){ bb_chgid(); } bb_log(LOG_DEBUG, "%s version %s starting...\n", bb_status.program_name, GITVERSION); /* Daemonized if daemon flag is activated */ if (bb_status.runmode == BB_RUN_DAEMON) { daemonize(); } /* Initialize communication socket, enter main loop */ bb_status.bb_socket = socketServer(bb_config.socket_path, SOCK_NOBLOCK); stop_secondary();//turn off card, nobody is connected right now. main_loop(); unlink(bb_config.socket_path); bb_status.runmode = BB_RUN_EXIT;//make sure all methods understand we are shutting down if (bb_config.card_shutdown_state) { //if shutdown state = 1, turn on card start_secondary(); } else { //if shutdown state = 0, turn off card stop_secondary(); } bb_closelog(); bb_stop_all(); //stop any started processes that are left return (EXIT_SUCCESS); }
asmlinkage void start_kernel(void) { char * command_line; /* * This little check will move. */ #ifdef __SMP__ static int first_cpu=1; if(!first_cpu) start_secondary(); first_cpu=0; #endif /* * Interrupts are still disabled. Do necessary setups, then * enable them */ setup_arch(&command_line, &memory_start, &memory_end); memory_start = paging_init(memory_start,memory_end); trap_init(); #ifndef CONFIG_OSFMACH3 init_IRQ(); #endif /* CONFIG_OSFMACH3 */ sched_init(); time_init(); parse_options(command_line); #ifdef CONFIG_MODULES init_modules(); #endif #ifdef CONFIG_PROFILE if (!prof_shift) #ifdef CONFIG_PROFILE_SHIFT prof_shift = CONFIG_PROFILE_SHIFT; #else prof_shift = 2; #endif #endif if (prof_shift) { prof_buffer = (unsigned int *) memory_start; /* only text is profiled */ prof_len = (unsigned long) &_etext - (unsigned long) &_stext; prof_len >>= prof_shift; memory_start += prof_len * sizeof(unsigned int); memset(prof_buffer, 0, prof_len * sizeof(unsigned int)); } memory_start = console_init(memory_start,memory_end); #ifdef CONFIG_PCI memory_start = pci_init(memory_start,memory_end); #endif memory_start = kmalloc_init(memory_start,memory_end); sti(); calibrate_delay(); memory_start = inode_init(memory_start,memory_end); memory_start = file_table_init(memory_start,memory_end); memory_start = name_cache_init(memory_start,memory_end); #ifndef CONFIG_OSFMACH3 #ifdef CONFIG_BLK_DEV_INITRD if (initrd_start && initrd_start < memory_start) { printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - " "disabling it.\n",initrd_start,memory_start); initrd_start = 0; } #endif #endif /* CONFIG_OSFMACH3 */ mem_init(memory_start,memory_end); buffer_init(); sock_init(); #if defined(CONFIG_SYSVIPC) || defined(CONFIG_KERNELD) ipc_init(); #endif dquot_init(); arch_syms_export(); sti(); check_bugs(); printk(linux_banner); #ifdef __SMP__ smp_init(); #endif sysctl_init(); /* * We count on the initial thread going ok * Like idlers init is an unlocked kernel thread, which will * make syscalls (and thus be locked). */ #ifdef CONFIG_OSFMACH3 osfmach3_start_init(argv_init, envp_init); #else /* CONFIG_OSFMACH3 */ kernel_thread(init, NULL, 0); #endif /* CONFIG_OSFMACH3 */ /* * task[0] is meant to be used as an "idle" task: it may not sleep, but * it might do some general things like count free pages or it could be * used to implement a reasonable LRU algorithm for the paging routines: * anything that can be useful, but shouldn't take time from the real * processes. * * Right now task[0] just does a infinite idle loop. */ cpu_idle(NULL); }