void init_scheduler()
{
if(num_Thread==0)
{
th_t *mainThread, *scheduleThread;
if((mainThread = thread_alloc()) == NULL)
abort();
if((scheduleThread = thread_alloc()) == NULL)
abort();
init_sigaction();
if((ready_queueHead = queueHead_alloc()) == NULL)
abort();
if((sched_queueHead = queueHead_alloc()) == NULL)
abort();
th_queue_init(ready_queueHead);
th_queue_init(sched_queueHead);
//th_queue_init(&kernel_queue);
mainThread->mctx.status = TH_WAITING;
mainThread->mctx.stackAddr = NULL;
mainThread->tid = num_Thread++;
scheduleThread->mctx.status = TH_SCHED;
//scheduleThread->tid = num_kernel_thread++;
main_kernel_id = scheduleThread->tid = getpid();
num_kernel_thread++;
if((scheduleThread->mctx.stackAddr = stack_alloc()) == NULL)
abort();
if((mainThread->mctx.stackAddr = stack_alloc()) == NULL)
abort();
//create machine context
void (*fnptr)(void*) = (void(*)(void*))scheduler;
mctx_create(&(scheduleThread->mctx), fnptr, NULL, scheduleThread->mctx.stackAddr, STACK_SIZE);
// mctx_create(&mctx_list[0],fnptr,NULL,mctx_list[0].stackAddr,STACK_SIZE);
th_queue_insert(sched_queueHead, PRIORITY_SCHEDULER, scheduleThread);
th_queue_insert(ready_queueHead, PRIORITY_NORMAL, mainThread);
init_sigaction();
init_mutex();
//th_queue_insert(&kernel_queue, PRIORITY_SCHEDULER, scheduleThread);
switch_to_scheduler(); //jump to scheduler
}
}
void*
OS_timer_setup(int deltaTimer, int repeated, OS_timer_expired pfunction,
const void* pdata)
{
struct itimerval value;
int sec = 0, usec = 0;
int repsec = 0, repusec = 0;
if (deltaTimer < 0 || repeated < 0 || pfunction == NULL) {
return NULL;
}
init_sigaction(SIGALRM, pfunction);
sec = deltaTimer/(1000);
usec = (deltaTimer%(1000)) * 1000;
repsec = repeated/(1000);
repusec = (repeated%(1000)) * 1000;
memset(&value, 0, sizeof(value));
value.it_interval.tv_sec = repsec;
value.it_interval.tv_usec = repusec;
value.it_value.tv_sec = sec;
value.it_value.tv_usec = usec;
setitimer(ITIMER_REAL, &value, NULL);
return (void *)pfunction;
}
void SetPollingTimer()
{
#ifndef WIN32
init_sigaction();
init_time();
#endif
}
int main() {
len = strlen(prompt);
init_sigaction();
init_time();
while(1);
exit(0);
}
/**------------------------
* Name: init_timer_for_snake
* Purpose: Testing entrance
* Date of Creating:
* Notes
*-------------------------**/
int init_timer_for_snake()
{
init_sigaction();
init_timer();
return SNK_OK;
}
int main(int argc, char **argv)
{
int opt = 0, i = 0, pstat, nremoved;
struct sigaction sig;
pid_t pid;
char buf[BUFFSIZE];
if (argc == 1) {
fprintf(stderr, "Usage: cclean [OPTION] [FILE] ...\n");
exit(1);
}
/* Init signal handlers */
init_sigaction(&sig);
/* Handle options */
while ((opt = getopt(argc, argv, "hv")) != -1) {
switch (opt) {
case 'h':
show_help();
exit(0);
case 'v':
printf("cclean %s, compiled on %s %s.\n", VERSION, __TIME__, __DATE__);
exit(0);
default:
fprintf(stderr, "Use -h for more information.\n");
exit(1);
}
}
/* Create child processes for input file */
for (i = 1; i < argc; i++) {
if ((pid = fork()) < 0)
perror(argv[0]);
/* Child process */
if (pid == 0) {
if ((nremoved = clean_file(argv[i], buf, BUFFSIZE)) < 0)
perror(argv[i]);
else
printf("%s: Cleaned; %d characters removed\n",
argv[i], nremoved);
exit(i);
}
}
/* Wait for child processes */
while ((pid = wait(&pstat)) >= 0);
puts("byebye.");
return 0;
}
int* start_kernel_thread(void* p)
{
th_queue_t* queueSche;
if((queueSche = find_thread_by_tid(sched_queueHead, (int)p)) == NULL)
abort();
queueSche->thread->tid = getpid();
init_sigaction();
//printf("Comes a new %d\n", getpid());fflush(stdout);
scheduler(NULL);
printf("thread end %d\n", getpid());fflush(stdout);
abort();
exit(0);
}
int main(int argc, const char *argv[])
{
#define SLEEP_TIME 1
len = strlen(msg);
init_sigaction();
init_time();
while (1) {
sleep(SLEEP_TIME);
printf("[%ds have elapsed or a signal arrives which is not ignored.]\n", SLEEP_TIME);
}
exit(0);
}
int main(int argc, char* argv[]){
if(argc < 2){
fprintf(stdout, "%s Version %d.%d\n",argv[0],
Tutorial_VERSION_MAJOR,
Tutorial_VERSION_MINOR);
fprintf(stdout, "Usage: %s number\n", argv[0]);
return 1;
}
inputValue = atof(argv[1]);
init_sigaction();
init_time();
while(true) sleep(1);
return 0;
}
void signal_handler_init()
{
// Create a signalling mechanism for SIGALRM.
int s[2];
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, s) == -1) {
printf("socketpair failed: %s\n", strerror(errno));
exit(1);
}
signal_write_fd = s[0];
signal_read_fd = s[1];
// Write to signal_write_fd if we catch SIGALRM.
init_sigaction(SIGALRM_handler);
register_epoll_handler(signal_read_fd, handle_signal);
}
alphabet_game_t *init_alphabet_game(void)
{
//printf("I'm %s() at %d in %s\n",__func__,__LINE__,__FILE__);
alphabet_game_t *ag=NULL;
int ret=RET_FAILED;
ag=(alphabet_game_t *)malloc(sizeof(alphabet_game_t));
if(NULL==ag){
return NULL;
}
set_cur_status(ag,MAIN_STATUS);
set_last_status(ag,OTHER_STATUS);
set_cur_level(ag,LEVEL_ONE);
set_total_time(ag,ALPHABET_GAME_START_TIME_ONE);
//set_remain_time(ag,get_total_time(ag));
set_total_alphabet_num(ag,ALPHABET_GAME_START_LEVEL_ONE_ALPHABET_NUM);
set_remain_alphabet_num(ag,get_total_alphabet_num(ag));
//set_enter_next_level(ag,TRUE);
set_enter_next_level(ag,FALSE);
set_delay_time(ag,DELAY_TIME);
ret=init_screen(&ag->scr);
if(RET_FAILED==ret){
free(ag);
ag=NULL;
return NULL;
}
ag->main_status=ctrl_tool_init(ALPHABET_GAME_WIDGET_NUM,alphabet_game_res,&alphabet_game_event);
if(NULL==ag->main_status){
free(ag);
ag=NULL;
return NULL;
}
ag->child_status_start=ctrl_tool_init(get_total_alphabet_num(ag),alphabet_game_start_res,&alphabet_game_start_event);
if(NULL==ag->child_status_start){
ctrl_tool_free(ag->main_status);
ag->main_status=NULL;
free(ag);
ag=NULL;
}
ag->child_status_help=ctrl_tool_init(ALPHABET_GAME_HELP_WIDGET_NUM,alphabet_game_help_res,&alphabet_game_help_event);
if(NULL==ag->child_status_help){
ctrl_tool_free(ag->child_status_start);
ag->child_status_start=NULL;
ctrl_tool_free(ag->main_status);
ag->main_status=NULL;
free(ag);
ag=NULL;
}
produce_random_alphabet_sequence(ag,get_total_alphabet_num(ag));//init alphabet_sequence
set_point_to_alphabet_game_t(ag);
//init_sigaction(&signal_process);
init_sigaction(signal_process);
init_timer();
return ag;
}
