int main() { char* argumentos[MAX_ARGS + 1]; char buffer[BUFFER_SIZE]; list = lst_new(); int pid; pthread_t tid; pthread_mutex_init(&mutex, NULL); // Criar tarefa para monitorizar os filhos if(pthread_create(&tid, 0, tarefa_monitor,NULL) != 0) { perror("Erro no pthread_create: "); exit(EXIT_FAILURE); } while(1){ if(readLineArguments(argumentos,MAX_ARGS,buffer,BUFFER_SIZE) <= 0){ continue; } if(strcmp(argumentos[0],"exit")==0) { // exit - esperar pela tarefa monitora e imprimir as informacoes dos filhos pthread_mutex_lock(&mutex); exit_ative = true; pthread_mutex_unlock(&mutex); pthread_join(tid,NULL); lst_print(list); pthread_mutex_destroy(&mutex); exit(EXIT_SUCCESS); } else { pid = fork(); time_t starttime = time(NULL); if (pid < 0) { perror("Erro no fork"); continue; } if (pid == 0) { // Codigo do filho execv(argumentos[0], argumentos); perror("Erro no execv:"); exit(EXIT_FAILURE); } // Codigo do pai pthread_mutex_lock(&mutex); nfilhos++; insert_new_process(list,pid,starttime); pthread_mutex_unlock(&mutex); } } return 0; }
int main(int argc, char **argv) { FILE *fp; pid_t pid; process_t *psVector; int i, status, child_processes = 0; char *argVector[MAX_ARGS + 1]; while(TRUE) { readLineArguments(argVector, MAX_ARGS + 1); if(argVector[0] == NULL) continue; if(strcmp(argVector[0], "exit") == 0) break; else if((fp = fopen(argVector[0], "r")) == NULL) perror(argVector[0]); else { fclose(fp); if((pid = fork()) < 0) perror("fork"); else if(pid == 0) { execv(argVector[0],argVector); perror("execv"); exit(EXIT_FAILURE); } else child_processes++; } } psVector = (process_t*)malloc(sizeof(process_t)*child_processes); for(i = 0; i < child_processes; i++) psVector[i].pid = wait(&(psVector[i].status)); for(i = 0; i < child_processes; i++) { pid = psVector[i].pid; status = psVector[i].status; if(WIFEXITED(status)) fprintf(stderr, "Process %d exited expectedly (status = %d)\n", pid, WEXITSTATUS(status)); else if(WIFSIGNALED(status)) fprintf(stderr, "Process %d received a signal (%s, signal = %d)\n", pid, strsignal(status), WTERMSIG(status)); else fprintf(stderr, "Process %d exited abnormally (status = 0x%x)\n", pid, status); } free(psVector); return EXIT_SUCCESS; }
int main(int argc, char **argv){ char buffer[BUFFER_SIZE]; int numArgs; char *arg_vector[VECTOR_SIZE]; time_t starttime; int child_pid; pthread_t monitor_thread; pthread_t writer_thread; lst = lst_new(); writing_queue = new_queue(); /* Initialize synchronization objects */ pthread_mutex_init_(&mutex, NULL); pthread_cond_init_(&write_cond, 0); pthread_cond_init_(&max_par, NULL); pthread_cond_init_(&new_child, NULL); if ((log_fd = fopen("./log.txt", "a+")) == NULL){ perror("[ERROR] opening log file"); exit(EXIT_FAILURE); } read_log(); /* assign total time and iteration values for this execution */ pthread_create_(&monitor_thread, NULL, (void *)&monitor, NULL); /* Create Monitor Thread */ pthread_create_(&writer_thread, NULL, (void *)&writer, NULL); /* Create Writer Thread */ while (1) { numArgs = readLineArguments(arg_vector, VECTOR_SIZE, buffer, BUFFER_SIZE); if (numArgs <= 0)continue; if (strcmp(arg_vector[0], EXIT_COMMAND) == 0 ) { /* signal exit command */ exit_command = 1; /* wait for monitor thread to end */ pthread_cond_signal_(&new_child); /* must signal to catch exit flag */ pthread_join_(monitor_thread, NULL); pthread_join_(writer_thread, NULL); /* print all the elements in the list */ lst_print(lst); /* terminate sync objects */ pthread_mutex_destroy_(&mutex); pthread_cond_destroy_(&write_cond); pthread_cond_destroy_(&max_par); pthread_cond_destroy_(&new_child); fclose(log_fd); lst_destroy(lst); exit(EXIT_SUCCESS); } /* while there are child process slots available launch new child process, * else wait here */ pthread_mutex_lock_(&mutex); while (child_count >= MAXPAR) pthread_cond_wait_(&max_par, &mutex); pthread_mutex_unlock_(&mutex); child_pid = fork(); if (child_pid < 0){ /* test for error in fork */ perror("[ERROR] forking process"); continue; } if (child_pid == 0){ /* execute on child */ if (execv(arg_vector[0], arg_vector) == -1) { perror("[ERROR] executing program."); exit(EXIT_FAILURE); } } else { /* execute on parent */ /* Main thread * * Child processes are inserted into the process list saving their pid * and their start time. * Child counter is incremented. * The condition variable waiting for a new child process is signaled. */ time(&starttime); /* get start time of child process */ pthread_mutex_lock_(&mutex); insert_new_process(lst, child_pid, starttime); child_count++; pthread_cond_signal_(&new_child); pthread_mutex_unlock_(&mutex); } } }
/*//////////////////////////////////////////// /////////////// MAIN FUNCTION //////////////// ////////////////////////////////////////////*/ int main() { char* arg[7]; char buffer[100], filename[100], fnamePipeStats[100]; int vectorSize = 7, pid, numargs, fd, fDescPIPE, fDescPIPE_S; pthread_t waitChild; pid_t pidChild; terminalLst* terminals = new_terminal_lst(); l = lst_new(); if (pthread_mutex_lock(&mutex) != 0) { perror(error_mutex_lock); } if (pthread_mutex_unlock(&mutex) != 0) { perror(error_mutex_unlock); } if (pthread_mutex_init(&mutex, NULL) != 0){ perror(error_mutex); } if (pthread_cond_init(&can_wait, NULL) != 0) { perror(error_cond_init_wait); } if (pthread_cond_init(&can_execute, NULL) != 0) { perror(error_cond_init_execute); } if (pthread_create(&waitChild, NULL, waitThread, NULL) != 0) { perror(error_thread_create); exit(EXIT_FAILURE); } if (signal(SIGINT, CTRLC) == SIG_ERR) { perror(error_signal); } unlink(PIPE); /*-------------------------------------------------*/ if (mkfifo(PIPE, 0777) != 0) { perror(error_mkfifo); exit(EXIT_FAILURE); } if ((fDescPIPE = open(PIPE, O_RDONLY)) == -1) { perror(error_pipe_open); exit(EXIT_FAILURE); } close(0); dup2(fDescPIPE, 0); while (1) { numargs = readLineArguments(arg, vectorSize, buffer, 100); if(flag_signal) break; if (numargs <= 1) { continue; } if (pthread_mutex_lock(&mutex) != 0) { perror(error_mutex_lock); } while (numChildren == MAXPAR) { if (pthread_cond_wait(&can_execute, &mutex) != 0) { perror(error_cond_wait); } } if (pthread_mutex_unlock(&mutex) != 0) { perror(error_mutex_unlock); } else if (strcmp(arg[0], EXIT) != 0) { if (strcmp(arg[0], starter) == 0) { int pid_terminal = atoi(arg[1]); insert_terminal(terminals, pid_terminal); continue; } if (strcmp(arg[0], stats) == 0) { /*tratar o PID e meter na lista*/ sprintf(fnamePipeStats, "%s-%s", PIPE_S, arg[1]); while((fDescPIPE_S = open(fnamePipeStats, O_WRONLY)) < 0); if(fDescPIPE < 0) { perror(error_pipe_open); exit(EXIT_FAILURE); } if (pthread_mutex_lock(&mutex) != 0) { perror(error_mutex_lock); } sprintf (buffer, "Number of active children: %d\nTotal execution time to the moment: %d", numChildren, timeTotal); write(fDescPIPE_S, buffer, strlen(buffer)); if (pthread_mutex_unlock(&mutex) != 0) { perror(error_mutex_unlock); } close(fDescPIPE_S); continue; } if (strcmp(arg[0], EXITGLOBAL) == 0) { /* SONFOILULDNILDEFNC*/ printf("1\n"); CTRLC(SIGINT); } else { pid = fork(); if (pid < 0) { perror(error_fork); } if (pthread_mutex_lock(&mutex) != 0) { perror(error_mutex_lock); } insert_new_process(l, pid, time(NULL)); numChildren++; if (pthread_cond_signal(&can_wait) != 0) { perror(error_cond_wait); } if (pthread_mutex_unlock(&mutex) != 0) { perror(error_mutex_unlock); } if (pid == 0) { pidChild = getpid(); sprintf(filename, "par-shell-%d.txt", pidChild); fd = open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); close(1); dup(fd); close(fd); if (execv(arg[0], arg) < 0) { perror(error_execv); exit(EXIT_FAILURE); } } else { sprintf(filename, "par-shell-%d.txt", pid); } } } else { break; } } isExit = true; if (pthread_cond_signal(&can_wait) != 0) { perror(error_cond_wait); } if (pthread_mutex_unlock(&mutex) != 0) { perror(error_mutex_unlock); } if (pthread_join(waitChild, NULL) != 0) { perror(error_thread_join); } lst_print(l); lst_destroy(l); while(remove_terminal(terminals)!= -1){ } if (pthread_cond_destroy(&can_wait) != 0) { perror(error_cond_destroy_wait); } if (pthread_cond_destroy(&can_execute) != 0) { perror(error_cond_destroy_execute); } exit(EXIT_SUCCESS); return 0; }
int main(int argc, char **argv) { pid_t child_pid; /* child process id */ pthread_t monitor_thread; /* monitor thread */ char *args[CMD_ARGS_MAX+1], buffer_cmd[LINE_COMMAND_MAX]; /* cmd related */ char buffer_log[LINE_LOGFILE_MAX]; /* log related */ if((g_lst_children = lst_new()) == NULL) { if(fprintf(stderr, "lst_new: couldn't create list\n") < 0) handle_error("fprintf"); exit(EXIT_FAILURE); } g_log_file = f_open(PATH_LOGFILE_STR, "a+"); while(!feof(g_log_file)) { f_gets(buffer_log, LINE_LOGFILE_MAX, g_log_file); /* NULL or iteracao # */ if(feof(g_log_file)) break; if(sscanf(buffer_log, "%*s %d", &g_iterations) != 1) handle_error("sscanf"); f_gets(buffer_log, LINE_LOGFILE_MAX, g_log_file); /* PID: # time: # s */ f_gets(buffer_log, LINE_LOGFILE_MAX, g_log_file); /* total time: # s */ if(sscanf(buffer_log, "%*[^0-9] %d", &g_total_time) != 1) handle_error("sscanf"); } ++g_iterations; cond_init(&g_child_cv); cond_init(&g_monitoring_cv); mutex_init(&g_mutex); pcreate(&monitor_thread, process_monitor, NULL); while(true) { int numargs = readLineArguments(args, CMD_ARGS_MAX + 1, buffer_cmd, LINE_COMMAND_MAX); if(args[0] == NULL) continue; if(numargs < 0 || (numargs > 0 && !strcmp(args[0], COMMAND_EXIT_STR))) { mutex_lock(&g_mutex); g_monitoring = false; cond_signal(&g_monitoring_cv); mutex_unlock(&g_mutex); pjoin(monitor_thread); lst_print(g_lst_children); destroySharedResources(); f_close(g_log_file); return EXIT_SUCCESS; } else { FILE *fp; /* To check file existance */ if ((fp = fopen(args[0], "r")) == NULL) perror(args[0]); else { f_close(fp); mutex_lock(&g_mutex); while(g_num_children == MAXPAR) cond_wait(&g_child_cv, &g_mutex); mutex_unlock(&g_mutex); if((child_pid = fork()) < 0) perror("fork"); else if(child_pid == 0) { execv(args[0],args); destroySharedResources(); handle_error("execv"); } else { mutex_lock(&g_mutex); if(insert_new_process(g_lst_children, child_pid, time(NULL)) != 0) { fprintf(stderr, "insert_new_process: failed to insert new process\n"); exit(EXIT_FAILURE); } ++g_num_children; cond_signal(&g_monitoring_cv); mutex_unlock(&g_mutex); } } } } }
int main() { int inputPipe; char buffer[BUFFER_LEN]; char mktemp_filename[PATH_MAX]; char mktemp_dir[PATH_MAX]; int ret; int terminalPid; TerminalList * termlist = lst_new(); pthread_t threadMonitor; char *args[N_ARGS]; if (signal(SIGINT, handleSIGINT)) { fprintf(stderr, "Could not set sigint handler!\n"); exit(EXIT_FAILURE); } if (pthread_mutex_init(&mutexRunningProcesses, NULL)) { fprintf(stderr, "Could not create runningProcesses mutex\n"); exit(EXIT_FAILURE); } if (pthread_cond_init(&condRunningProcesses, NULL)) { fprintf(stderr, "Could not create runningProcesses cond\n"); exit(EXIT_FAILURE); } if (pthread_cond_init(&condFreeSlots, NULL)) { fprintf(stderr, "Could not create FreeSlots cond\n"); exit(EXIT_FAILURE); } strcpy(mktemp_dir, MKTEMP_TEMPLATE); TESTTRUE(mkdtemp(mktemp_dir)!=NULL, "Erro na criação do diretorio temporário (" _AT_ ")\n"); strncpy(mktemp_filename, mktemp_dir, PATH_MAX); strncpy(mktemp_filename+strlen(mktemp_filename), "/" INPUT_FILE, PATH_MAX-strlen(mktemp_filename)); fprintf(stdin, "Ficheiro de input: '%s'\n", mktemp_filename); if (mkfifo(mktemp_filename, 0660) <0) { fprintf(stderr, "Could not create fifo %s\n", mktemp_filename); exit(EXIT_FAILURE); } printf("A abrir o pipe %s para leitura...\n", mktemp_filename); if ((inputPipe = open(mktemp_filename, O_RDONLY)) < 0) { fprintf(stderr, "Could not create fifo " INPUT_FILE "\n"); exit(EXIT_FAILURE); } printf("A abrir o pipe %s para escrita...\n", mktemp_filename); if ((outPipe = open(mktemp_filename, O_WRONLY|O_NONBLOCK)) < 0) { fprintf(stderr, "Erro ao abrir o ficheiro de output" INPUT_FILE "\n"); exit(EXIT_FAILURE); } initProcessList(); if(pthread_create(&threadMonitor, 0,processMonitor, NULL)!= 0) { printf("Erro na criação da tarefa\n"); exit(EXIT_FAILURE); } while(1) { if (exitCalled) break; if (readFromPipe(inputPipe, buffer, &terminalPid, termlist)!=0) continue; printf("Comando: %s\n", buffer); ret = readLineArguments(args, N_ARGS, buffer, BUFFER_LEN); if (!ret) continue; processesWaitingToRun++; newProcess(args, terminalPid); } //Mata todos os processos de terminal lst_destroy(termlist); C_SIGNAL(&condRunningProcesses); pthread_join(threadMonitor, NULL); //The following function is called after all threads have joined, therefore there aren't used any mutexes exitParShell(); endProcessList(); pthread_mutex_destroy(&mutexRunningProcesses); pthread_cond_destroy(&condRunningProcesses); pthread_cond_destroy(&condFreeSlots); close(inputPipe); //aqui nao faz sentido testar o return destas funcoes close(outPipe); //aqui nao faz sentido testar o return destas funcoes unlink(INPUT_FILE); //aqui nao faz sentido testar o return destas funcoes return EXIT_SUCCESS; }