void init_unix()
{
signal(SIGPIPE, SIG_IGN);
prf_heap = allocate_rolling(pages, sstring("prf"));
select_init();
init_processes();
}
/**
* @brief: Handles all the initilization of the OS
* @param: stack_start the start of free memory
*/
void init(void* memory_start) {
#ifdef INIT_DEBUG
rtx_dbug_outs("Initilizating memory...");
#endif
init_memory(memory_start);
#ifdef INIT_DEBUG
rtx_dbug_outs("done\r\nInitilizating processes...");
#endif
init_processes(memory_head);
#ifdef INIT_DEBUG
rtx_dbug_outs(" done\r\nInitializing priority queues...");
#endif
init_priority_queues();
#ifdef INIT_DEBUG
rtx_dbug_outs(" done\r\nInitilizating interrupts...");
#endif
init_interrupts();
g_profiler.timer = &timer;
#ifdef INIT_DEBUG
rtx_dbug_outs(" done\r\n");
#endif
}
int main()
{
int i;
printf("Starting.....!\n");
time_initialize();
initialize_table();
// printf("Initialization Table created and initialised!\n");
init_env();
init_timeout_Q();
init_blkOnRsc_Q();
init_blkOnEnv_Q();
// printf("All Queues and Envelope Queues Initialized!\n");
init_TraceArrays();
init_helperprocess();
init_ioBuffers();
init_signals();
printf("Initializing Signals!\n");
init_processes();
// printf("Initialising Processes!\n");
// printf("KBD and CRT Processes initialized and forked!\n");
return 0;
}
int main(void)
{
status c_program;
init_processes();
ipc_open(endif_process->params, O_RDONLY);
while(1)
if (ipc_receive(endif_process->params, &c_program, sizeof(struct status)) > 0)
run_process(&c_program, &execute_endif);
return 0;
}
int main(void)
{
status c_program;
init_processes(FALSE);
signal(SIGINT, end_process);
ipc_open(if_process->params, O_RDONLY);
while(1)
if (ipc_receive(if_process->params, &c_program, sizeof(struct status)) > 0)
run_process(&c_program, &execute_if);
return 0;
}
int main(int argc, char ** argv){
char * program_name;
struct status cl_program;
int i;
ipc_params_t client_params;
init_processes();
if(argc > 1){
program_name = argv[1];
}else{
printf("Entrada incorrecta\n");
return 0;
}
client_params = get_params_from_pid(getpid(), PROGRAM_STATUS, sizeof(struct status));
client_header_t header = calloc(1, sizeof(struct client_header));
header->program_size = strlen(program_name);
header->client_id = getpid();
ipc_open(server_params, O_WRONLY);
server_params->msg_type = PRE_HEADER;
ipc_send(server_params, header, sizeof(struct client_header));
server_params->msg_type = PROGRAM_STRING;
ipc_send(server_params, program_name, header->program_size);
ipc_close(server_params);
ipc_create(client_params);
ipc_open(client_params, O_RDONLY);
while (!ipc_receive(client_params, &cl_program, sizeof(struct status)));
ipc_close(client_params);
ipc_destroy(client_params);
for (i = 0; i < MEM_SIZE; i++){
printf("%d ", cl_program.mem[i]);
}
printf("\n");
return 0;
}
int
main(void)
{
char * read_string;
int aux_size;
pthread_t thread_id, receive_thread_id;
thread_status_t thread_info;
signal(SIGINT, server_close);
init_processes(TRUE);
init();
client_header_t header = calloc(1, sizeof(struct client_header));
pthread_create(&receive_thread_id, NULL, &run_server_receive, NULL);
printf("Running server...\n");
while(1)
{
server_params->msg_type = PRE_HEADER;
if(ipc_receive(server_params, header, sizeof (struct client_header)) > 0)
{
read_string = calloc(1, header->program_size);
server_params->msg_type = PROGRAM_STRING;
while(ipc_receive(server_params, read_string, header->program_size) == 0)
sleep(1);
printf("Received program from client: %d, program name: %s\n",
header->client_id, read_string);
thread_info = calloc(1, sizeof(struct thread_status));
thread_info->file = read_string;
thread_info->client_id = header->client_id;
pthread_create(&thread_id, NULL, &run_program, thread_info);
pthread_join(thread_id, NULL);
free(read_string);
free(thread_info);
}
sleep(1);
}
return 0;
}
int
main(void)
{
char * read_string;
int aux_size;
pthread_t thread_id;
thread_status_t thread_info;
init_processes();
init();
client_header_t header = calloc(1, sizeof(struct client_header));
printf("Running server...\n");
while(1)
{
server_params->msg_type = PRE_HEADER;
if(ipc_receive(server_params, header, sizeof (struct client_header)) > 0)
{
read_string = calloc(1, header->program_size);
printf("%d %d\n", header->client_id, header->program_size);
server_params->msg_type = PROGRAM_STRING;
while(ipc_receive(server_params, read_string, header->program_size) == 0)
sleep(1);
printf("Recibi programa del cliente: %d, programa: %s\n",
header->client_id, read_string);
thread_info = calloc(1, sizeof(struct thread_status));
thread_info->file = read_string;
thread_info->client_id = header->client_id;
pthread_create(&thread_id, NULL, &run_program, thread_info);
}
}
return 0;
}
void init_workers(void)
{
if (process_mode)
init_processes();
}
int main(int argc, char **argv)
{
const double sim_time = 200; ///< Total simulation time
static int show_usage = 0; ///< Flag to indicate if it is necessary to show usage options
static int pnum = 0; ///< Number of processes in the system
int event, ///< Current event
pid, ///< ID of the process executing the event
num_requests = 0, ///< Total number of requests in the simulation (used as stop criterion)
p0_time = 0, ///< Time at which process 0 will request the critical region
p1_time = 0, ///< Time at which process 1 will request the critical region
p2_time = 0; ///< Time at which process 2 will request the critical region
struct timeval tp;
queue_item recvd_msg;
print_header();
if (argc < 3) {
print_usage(argv[0]);
exit(1);
}
// parse parameters
int c;
while (1) {
static struct option long_options[] = {
{"help", no_argument, &show_usage, 1},
{"nproc", required_argument, 0, 'n'},
{"rc0", required_argument, 0, 'p'},
{"rc1", required_argument, 0, 'q'},
{"rc2", required_argument, 0, 'r'},
{0, 0, 0, 0}
};
/* getopt_long stores the option index here. */
int option_index = 0;
c = getopt_long(argc, argv, "n:p:q:r:", long_options, &option_index);
/* Detect the end of the options. */
if (c == -1) break;
switch (c) {
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
break;
printf ("option %s", long_options[option_index].name);
if (optarg)
printf (" with arg %s", optarg);
printf ("\n");
break;
case 'n':
pnum = (int) strtol(optarg, NULL, 10);
break;
case 'p':
p0_time = (int) strtol(optarg, NULL, 10);
++num_requests;
break;
case 'q':
p1_time = (int) strtol(optarg, NULL, 10);
++num_requests;
break;
case 'r':
p2_time = (int) strtol(optarg, NULL, 10);
++num_requests;
break;
case '?':
/* getopt_long already printed an error message. */
break;
default:
abort();
}
}
if (show_usage) {
print_usage(argv[0]);
exit(0);
}
if (pnum < 2) {
printf("Error: Invalid number of processes! Please, specify at least 2 processes using the --nproc option.\n\n");
print_usage(argv[0]);
exit(1);
} else if (pnum < 2 && p2_time != 0) {
printf("Error: You have specified a time for process 2 (starting from 0) on a simulation with only 2 processes!\n\n");
print_usage(argv[0]);
exit(1);
} else if (p0_time == 0 && p1_time == 0 && p2_time == 0) {
printf("You have not specified any critical region requests in your simulation!\n\n");
print_usage(argv[0]);
exit(1);
}
// initialize PRNG
gettimeofday(&tp, NULL);
srand(tp.tv_sec + tp.tv_usec / 1000);
seed(tp.tv_sec + tp.tv_usec / 1000, 1);
smpl(0, "Ricart-Agrawala");
stream(1);
process plist = init_processes(pnum);
printf("-- BEGIN PARAMETERS --\n");
printf("Number of processes: %d\n", pnum);
printf("Number of critical region requests: %d\n", num_requests);
printf("Starting events:\n");
if (p0_time != 0) {
printf(" - Process 0 will request the critical region at time %d\n", p0_time);
schedule(EV_REQUEST, p0_time, 0);
}
if (p1_time != 0) {
printf(" - Process 1 will request the critical region at time %d\n", p1_time);
schedule(EV_REQUEST, p1_time, 1);
}
if (p2_time != 0) {
printf(" - Process 2 will request the critical region at time %d\n", p2_time);
schedule(EV_REQUEST, p2_time, 2);
}
printf("-- END PARAMETERS --\n\n");
printf("-- SIMULATION BEGIN --\n");
while(time() < sim_time) {
cause(&event, &pid);
switch(event) {
case EV_REQUEST:
printf("Process %d has executed a critical region REQUEST at time %g\n", pid, time());
plist[pid].state = ST_WANTED;
// update pid's logical clock
plist[pid].timestamp++;
plist[pid].request_timestamp = plist[pid].timestamp;
// broadcast REQUEST to all processes in the system
broadcast(plist, pnum, pid);
break;
case EV_RECV:
// remove next message to be received by pid
recvd_msg = remove_max_pqueue(plist[pid].recvd_from);
// synchronize pid's logical clock on receive before processing the message
plist[pid].timestamp = (plist[pid].timestamp > recvd_msg->timestamp) ?
plist[pid].timestamp : recvd_msg->timestamp;
plist[pid].timestamp++;
printf("Process %d received %s from %d at time %g\n", pid, (recvd_msg->type == MSG_REQUEST) ? "REQUEST" : "REPLY", recvd_msg->pid, time());
recv(plist, pnum, pid, recvd_msg->pid, recvd_msg->timestamp, recvd_msg->type);
free(recvd_msg);
break;
case EV_RELEASE:
printf("Process %d released the critical region at time %g\n", pid, time());
releasecr(plist, pnum, pid);
num_requests--;
break;
}
// no more requests to simulate, simulation ended
if (num_requests == 0) break;
}
printf("-- SIMULATION END --\n");
destroy_processes(plist, pnum);
return 0;
}
int main ( int argc, char *argv[] )
{
int s;
struct epoll_event *events;
signal ( SIGABRT, &sighandler );
signal ( SIGTERM, &sighandler );
signal ( SIGINT, &sighandler );
if ( argc != 3 )
{
fprintf ( stderr, "Usage: %s [port] [doc root]\n", argv[0] );
exit ( EXIT_FAILURE );
}
init_processes();
listen_sock = create_and_bind ( argv[1] );
doc_root = argv[2];
if ( listen_sock == -1 )
abort ();
s = setNonblocking ( listen_sock );
if ( s == -1 )
abort ();
s = listen ( listen_sock, SOMAXCONN );
if ( s == -1 )
{
perror ( "listen" );
abort ();
}
efd = epoll_create1 ( 0 );
if ( efd == -1 )
{
perror ( "epoll_create" );
abort ();
}
event.data.fd = listen_sock;
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl ( efd, EPOLL_CTL_ADD, listen_sock, &event );
if ( s == -1 )
{
perror ( "epoll_ctl" );
abort ();
}
/* Buffer where events are returned */
events = calloc ( MAXEVENTS, sizeof event );
/* The event loop */
while ( 1 )
{
int n, i;
n = epoll_wait ( efd, events, MAXEVENTS, -1 );
if ( n == -1 )
{
perror ( "epoll_wait" );
}
for ( i = 0; i < n; i++ )
{
if ( ( events[i].events & EPOLLERR ) ||
( events[i].events & EPOLLHUP ) )
{
/* An error has occured on this fd, or the socket is not
ready for reading (why were we notified then?) */
fprintf ( stderr, "epoll error\n" );
close ( events[i].data.fd );
continue;
}
handle_request ( events[i].data.fd );
}
}
free ( events );
close ( listen_sock );
return EXIT_SUCCESS;
}
