static int ascii_init(void) { void *ptr_err; major = register_chrdev(0, DEVICE_NAME, &fops ); if(major < 0){ printk(KERN_INFO "Char device registering failed\n"); return major; } printk(KERN_INFO "Device successfully created with major number: %d.\n", major); class_ascii = class_create(THIS_MODULE, DEVICE_NAME); if(IS_ERR(ptr_err = class_ascii)){ printk(KERN_INFO "Creating class failed. Unregistering device.\n"); unregister_chrdev(major, DEVICE_NAME); return PTR_ERR(ptr_err); } dev_ascii = device_create(class_ascii, NULL, MKDEV(major, 0), NULL, DEVICE_NAME); if(IS_ERR(ptr_err = dev_ascii)){ printk(KERN_INFO "Creating Device failed. Unregistering device.\n"); class_destroy(class_ascii); unregister_chrdev(major, DEVICE_NAME); return PTR_ERR(ptr_err); } init_semaphores(); queue_init(); initEmptyArray(); timer_init(); return 0; }
main(void) { set_eflags(); /* Define the kernel segment registers and a stack to execute the 'main' code */ // It is necessary to use a global static array for the stack, because the // compiler will know its final memory location. Otherwise it will try to use the // 'ds' register to access the address... but we are not ready for that yet // (we are still in real mode). set_seg_regs(__KERNEL_DS, __KERNEL_DS, (DWord) &protected_tasks[5]); printk("Kernel Loaded! "); /* Initialize hardware data */ setGdt(); /* Definicio de la taula de segments de memoria */ setIdt(); /* Definicio del vector de interrupcions */ setTSS(); /* Definicio de la TSS */ /* Initialize Memory */ init_mm(); /* Initialize an address space to be used for the monoprocess version of ZeOS */ monoprocess_init_addr_space(); /* TO BE DELETED WHEN ADDED THE PROCESS MANAGEMENT CODE TO BECOME MULTIPROCESS */ /* Initialize Scheduling */ init_sched(); /* Initialize idle task data */ init_idle(); /* Initialize task 1 data */ init_task1(); /* Initialize semaphores */ init_semaphores(); /* Move user code/data now (after the page table initialization) */ copy_data((void *) KERNEL_START + *p_sys_size, usr_main, *p_usr_size); printk("Entering user mode..."); enable_int(); /* * We return from a 'theorical' call to a 'call gate' to reduce our privileges * and going to execute 'magically' at 'usr_main'... */ return_gate(__USER_DS, __USER_DS, USER_ESP, __USER_CS, L_USER_START); /* The execution never arrives to this point */ return 0; }
/* Slurmctld and slurmd do not really build shared memory but they use that one built by sim_mgr */ int building_shared_memory(){ int fd; fd = shm_open(SLURM_SIM_SHM, O_RDWR, S_IRUSR | S_IWUSR); if(fd < 0){ printf("Error opening %s\n", SLURM_SIM_SHM); return -1; } ftruncate(fd, 8192); timemgr_data = mmap(0, 8192, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if(!timemgr_data){ printf("mmaping %s file can not be done\n", SLURM_SIM_SHM); return -1; } /* Initializing pointers to shared memory */ current_sim = timemgr_data + SIM_SECONDS_OFFSET; current_micro = timemgr_data + SIM_MICROSECONDS_OFFSET; threads_data = timemgr_data + SIM_SYNC_ARRAY_OFFSET; current_threads = timemgr_data + SIM_THREADS_COUNT_OFFSET; proto_threads = timemgr_data + SIM_PROTO_THREADS_OFFSET; sleep_map_array = timemgr_data + SIM_SLEEP_ARRAY_MAP_OFFSET; thread_exit_array = timemgr_data + SIM_THREAD_EXIT_MAP_OFFSET; thread_new_array = timemgr_data + SIM_THREAD_NEW_MAP_OFFSET; fast_threads_counter = timemgr_data + SIM_FAST_THREADS_OFFSET; pthread_create_counter = timemgr_data + SIM_PTHREAD_CREATE_COUNTER; pthread_exit_counter = timemgr_data + SIM_PTHREAD_EXIT_COUNTER; slurmctl_pid = timemgr_data + SIM_PTHREAD_SLURMCTL_PID; slurmd_pid = timemgr_data + SIM_PTHREAD_SLURMD_PID; if((slurmctl_pid[0] == 0) || (slurmd_pid[0] == 0)){ register_program(); if(init_semaphores() < 0){ printf("semaphores initialization failed\n"); return 1; } } return 0; }
/******************************************************************************* * NOME: main * FUNÇÃO: Chama as funcoes que iniciam as threads * * Tipo Descrição * pthread_t* Thread servidor declarada na main * pthread_t* Thread cliente declarada na main * * RETORNO: int (0 se threads foram criadas com sucesso, 1 se nao foram) *******************************************************************************/ int main(int argc,char **argv){ int erro = 0; prog_end = 0; client_add = 0; client_send = 0; numdecontatos = 0; char filename[25]; pthread_t serverthread, clientthread, menuthread; printf("Digite o numero da porta da aplicacao: "); scanf("%d", &PORTA); __fpurge(stdin); printf("Digite o seu endereco de IP: "); fgets(filename, 16, stdin); strtok(filename, "\n"); __fpurge(stdin); strcat(filename, "chat.txt"); chat_log = fopen(filename, "w+b"); if(chat_log == NULL){ printf("Erro na abertura do arquivo"); } else{ fputc('0', chat_log); } init_semaphores(); erro = init_threads(&serverthread, &clientthread, &menuthread); if (erro == 1){ //Significa que as threads nao foram criadas. Logo o programa nao pode prosseguir. return 1; } else{ pthread_join(menuthread, NULL); pthread_join(clientthread, NULL); return 0; } }
int main(void) { IntMasterDisable(); /* Set up hardware */ hardware_setup(); init_semaphores(); init_queues(); /* Module initialization */ if (spi_init() && uart_init_task() && uart_protocol_init_task() && status_led_task_init() && uart_echo_init() && par_updater_init() && (xTaskCreate(dreh_task, NAME("Dreh"), DEFAULT_STACK, NULL, PRIORITY_LOW, &task_handles[DREH_T])) == pdPASS && (xTaskCreate(lcd_task, NAME("LCD"), DEFAULT_STACK, NULL, PRIORITY_LOW, &task_handles[LCD_T])) == pdPASS && (xTaskCreate(menu_task, NAME("Menu"), LARGE_STACK, NULL, PRIORITY_LOW, &task_handles[MENU_T])) == pdPASS && (xTaskCreate(numpad_task, NAME("Numpad"), DEFAULT_STACK, NULL, PRIORITY_LOW, &task_handles[NUMPAD_T])) == pdPASS && (xTaskCreate(control_task, NAME("Control"), DEFAULT_STACK, NULL, PRIORITY_HIGH, &task_handles[CONTROL_T])) == pdPASS && (xTaskCreate(blink_task, NAME("Blink"), DEFAULT_STACK, NULL, PRIORITY_LOW, &task_handles[BLINK_T])) == pdPASS && uart_to_spi_init() && step_response_init() && itc_init_uartprinter() #ifdef DEBUG && spi_test_init() && runtimestats_init() #endif /* DEBUG */ ) { vTaskStartScheduler(); } while (1) { /* Will only get here if initialization went wrong. */ } return 1; }
/******************************************************************************* * NOME: main * FUNÇÃO: Chama as funcoes que iniciam as threads * * Tipo Descrição * pthread_t* Thread servidor declarada na main * pthread_t* Thread cliente declarada na main * * RETORNO: int (0 se threads foram criadas com sucesso, 1 se nao foram) *******************************************************************************/ int main(int argc,char **argv){ int erro = 0; prog_end = 0; client_add = 0; client_send = 0; numdecontatos = 0; pthread_t serverthread, clientthread, menuthread; init_semaphores(); erro = init_threads(&serverthread, &clientthread, &menuthread); if (erro == 1){ //Significa que as threads nao foram criadas. Logo o programa nao pode prosseguir. return 1; } else{ pthread_join(menuthread, NULL); pthread_join(clientthread, NULL); pthread_join(serverthread, NULL); return 0; } }
int main(int argc, char **argv) { int server_fd, port_number, max_fd, file_descriptors[MAX_NUMBER_USERS], i; int temp_fd, select_result, timer_is_active = FALSE, status_code; char *validation; fd_set file_descriptor_set; check_incorrect_usage(argc, argv); set_log_method(argv); set_lock(); port_number = extract_port_number(argv); server_fd = create_server(port_number, MAX_NUMBER_USERS); log_message("Streams server created", LOG_INFO); register_signal_handlers(); for (i = 0; i < MAX_NUMBER_USERS; i++) { file_descriptors[i] = 0; } // -- SHARED MEMORY AND SEMAPHORES -- shmid = create_shared_memory(); shared_mem_ptr = attach_memory(shmid); init_semaphores(); log_message("Shared memory and semaphores created", LOG_DEBUG); // -- SERVER LOOP -- while (TRUE) { FD_ZERO(&file_descriptor_set); FD_SET(server_fd, &file_descriptor_set); max_fd = server_fd; for (i = 0; i < MAX_NUMBER_USERS; i++) { temp_fd = file_descriptors[i]; if (temp_fd > 0) { FD_SET(temp_fd, &file_descriptor_set); } if (temp_fd > max_fd) { max_fd = temp_fd; } } select_result = select(max_fd + 1, &file_descriptor_set, NULL, NULL, NULL); if (select_result < 0 && errno != EINTR) { log_error("Select call error", LOG_WARNING, errno); continue; } if (FD_ISSET(server_fd, &file_descriptor_set)) { if ((temp_fd = accept(server_fd, NULL, 0)) < 0) { log_error("Could not accept incoming connection", LOG_ALERT, errno); exit(EXIT_FAILURE); } log_client_connection(temp_fd); for (i = 0; i < MAX_NUMBER_USERS; i++) { if (file_descriptors[i] != 0) continue; file_descriptors[i] = temp_fd; break; } } for (i = 0; i < MAX_NUMBER_USERS; i++) { temp_fd = file_descriptors[i]; if (!FD_ISSET(temp_fd, &file_descriptor_set)) continue; char *message = NULL; if ((message = (char *) calloc(MESSAGE_LENGTH, sizeof(char))) == NULL) { log_error("Memory allocation error", LOG_ALERT, errno); exit(EXIT_FAILURE); } if (recv(temp_fd, message, MESSAGE_LENGTH, 0) <= 0) // Disconnected { log_message("Client disconnected", LOG_INFO); close(temp_fd); file_descriptors[i] = 0; } else // Message sent to server { struct message_t mess=decode(message); if( (status_code = mess.type) == ERROR_MESSAGE) { continue; } if (get_game_phase() == REGISTER_PHASE) { if (status_code != 1) { // TODO Send message back to user? log_message("Currently register phase. User can only register", LOG_DEBUG); continue; } if (!timer_is_active) { log_message("Starting register timer", LOG_DEBUG); alarm(WAIT_TIME); timer_is_active = TRUE; } char *new_user = (char *) malloc(MAX_ARRAY_SIZE * sizeof(char)); sprintf(new_user, "User '%s' asks for registration. Adding user in memory.", (char *) mess.payload); log_message(new_user, LOG_INFO); // Add a player to the shared memory semaphore_down(SEMAPHORE_ACCESS); strncpy(shared_mem_ptr->players->name, (char *) mess.payload, strlen(mess.payload)); shared_mem_ptr->players[i].fd = temp_fd; shared_mem_ptr->players[i].score = 15; // TODO A supprimer semaphore_up(SEMAPHORE_ACCESS); validation = encode(VALID_REGISTRATION, "1"); send(temp_fd, validation, strlen(validation), 0); } else // GAME PHASE { log_message("Game phase. Not yet implemented.", LOG_INFO); } } } } return 0; }
int main(int argc, char **argv) { int n, m, k, shmid, semid, producers; key_t ipckey; char filepath[PATH_MAX]; union semun ignored; printf("Synchronizacja procesow z wykorzystaniem semaforow\n"); if(argc != 4) { printf( "Uzycie: %s n m k\n" "n - liczba producentow\n" "m - rozmiar kolejki\n" "k - liczba jednostek towaru, czyli liczb, ktore powinien wstawic kazdy producent do bufora\n", argv[0]); return 1; } n = atoi(argv[1]); m = atoi(argv[2]); k = atoi(argv[3]); /* sprawdamy wszystkie warunki niezbedne do przejscia dalej. */ if(n <= 0) return die("n <= 0"); if(m <= 0) return die("m <= 0"); if(k <= 0) return die("k <= 0"); if((getpagesize()!=4096) || (sizeof(int)!=4)) return die("Ten program nie zadziala na tym komputerze ze wzgledu na egzotyczne rozmiary zmiennych."); if(n>1022) return die("Ta wersja obsluguje kolejki do 1022 elementow."); producers = n; /* Do dziela - zdobadzmy klucz */ //w manie prosza o accessible filepath, takze zdobadzmy je: realpath(argv[0], filepath); ipckey = ftok(filepath, n); if(ipckey == -1) return die("ftok zwrocilo blad"); /* alokacja pamieci wspoldzielonej & semaforow. */ shmid = shmget(ipckey, getpagesize(), IPC_CREAT | S_IRUSR | S_IWUSR | IPC_EXCL); //flagi: tworzenie, uprawnienia do czytania&pisania, wylacznosc. if(shmid == -1) return die("shmget zwrocilo blad"); semid = semget(ipckey, SEM_NR, IPC_CREAT | S_IRUSR | S_IWUSR | IPC_EXCL); if(semid == -1) return die("semget zwrocilo blad"); if(init_semaphores(semid, m)==-1) return die("init_sempahores zwrocilo blad"); if(init_shared_memory(shmid, m)==-1) return die("init_shared_memory zwrocilo blad"); //puts("Przerwa techniczna. Wcisnij enter, aby kontynuowac."); //getchar(); while(--producers>=0) if(spawn(producers, n, m, k, shmid, semid)==0) return 0; //void Client(int shmid, int semid, int m,int elem_to_process) Client(shmid, semid, m, n*k); shmctl(shmid, IPC_RMID, 0); semctl(semid, SEM_NR, IPC_RMID, ignored); }