void ferry_loop() { /* Start, check if the south flag is checked, if so we want to skip doing north and just go straight to south. Once we get to south we want to check if the flag was set and if so we want to redeposit passengers before we pick up again. The same goes for the second loop, we check to see if the north flag was checked, if so we want to skip the south and go straight back to north and pick up the queen there. If the flag is set and we return to a bank that we were travelling away from, we want to re-deposit the passengers currently on the ferry back onto the shore, then reload them in the correct order (queen first) */ if(queen_south_flag!=1) { if(queen_north_flag==1) { queen_north_flag=0; //redeposit passengers redeposit_north(); } arrive_north(); //Set bank to transit curr_ferry.curr_bank = 2; print_proc(); travel(); //We reset the south flag as to not deposit passengers that wanted //To go to south in the first place, then they get mixed up with north //Passengers and go back to where they came from queen_south_flag=0; } //if north has queen waiting skip south and go north if(queen_north_flag!=1) { //if south has queen we are already here so just reset flag if(queen_south_flag==1) { queen_south_flag=0; //reposit passengers redeposit_south(); } arrive_south(); //Set bank to transit curr_ferry.curr_bank = 2; print_proc(); travel(); queen_north_flag=0; } }
static void print_proc_depends(struct proc *pp, const int level) { struct proc *depproc = NULL; endpoint_t dep; #define COL { int i; for(i = 0; i < level; i++) printf("> "); } if(level >= NR_PROCS) { printf("loop??\n"); return; } COL print_proc(pp); COL proc_stacktrace(pp); dep = P_BLOCKEDON(pp); if(dep != NONE && dep != ANY) { int procno; if(isokendpt(dep, &procno)) { depproc = proc_addr(procno); if(isemptyp(depproc)) depproc = NULL; } if (depproc) print_proc_depends(depproc, level+1); } }
void netstats(void) { if (getuid() == 0) firemon_drop_privs(); pid_read(0); // include all processes printf("Displaying network statistics only for sandboxes using a new network namespace.\n"); // print processes while (1) { // set pid table int i; int itv = 5; // 5 second interval pid_read(0); // todo: preserve the last calculation if any, so we don't have to do get_stats() // start rx/tx measurements for (i = 0; i < MAX_PIDS; i++) { if (pids[i].level == 1) get_stats(i); } // wait 5 seconds firemon_sleep(itv); // grab screen size struct winsize sz; int row = 24; int col = 80; if (!ioctl(0, TIOCGWINSZ, &sz)) { col = sz.ws_col; row = sz.ws_row; } // start printing firemon_clrscr(); char *header = get_header(); if (strlen(header) > col) header[col] = '\0'; printf("%s\n", header); if (row > 0) row--; free(header); // start rx/tx measurements for (i = 0; i < MAX_PIDS; i++) { if (pids[i].level == 1) { get_stats(i); print_proc(i, itv, col); } } } }
void netstats(void) { pid_read(0); // include all processes printf("Displaying network statistics only for sandboxes using a new network namespace.\n"); // print processes while (1) { // set pid table int i; int itv = 5; // 5 second interval pid_read(0); // start rx/tx measurements for (i = 0; i < max_pids; i++) { if (pids[i].level == 1) get_stats(i); } // wait 5 seconds firemon_sleep(itv); // grab screen size struct winsize sz; int row = 24; int col = 80; if (!ioctl(0, TIOCGWINSZ, &sz)) { col = sz.ws_col; row = sz.ws_row; } // start printing firemon_clrscr(); char *header = get_header(); if (strlen(header) > (size_t)col) header[col] = '\0'; printf("%s\n", header); if (row > 0) row--; free(header); // start rx/tx measurements for (i = 0; i < max_pids; i++) { if (pids[i].level == 1) { get_stats(i); print_proc(i, itv, col); } } #ifdef HAVE_GCOV __gcov_flush(); #endif } }
PRIVATE void ser_dump_proc_cpu(void) { struct proc *pp; unsigned cpu; for (cpu = 0; cpu < ncpus; cpu++) { printf("CPU %d processes : \n", cpu); for (pp= BEG_USER_ADDR; pp < END_PROC_ADDR; pp++) { if (isemptyp(pp) || pp->p_cpu != cpu) continue; print_proc(pp); } } }
/* Print all procs */ void print_procs(Procs procs) { Proc first = procs->first; Procs rest = procs->rest; // Print all procs if (first) { print_proc(first); printf("\n"); } if (rest) { print_procs(rest); } }
void arch_proc_setcontext(struct proc *p, struct stackframe_s *state, int isuser, int trap_style) { if(isuser) { /* Restore user bits of psw from sc, maintain system bits * from proc. */ state->psw = (state->psw & X86_FLAGS_USER) | (p->p_reg.psw & ~X86_FLAGS_USER); } /* someone wants to totally re-initialize process state */ assert(sizeof(p->p_reg) == sizeof(*state)); memcpy(&p->p_reg, state, sizeof(*state)); /* further code is instructed to not touch the context * any more */ p->p_misc_flags |= MF_CONTEXT_SET; /* on x86 this requires returning using iret (KTS_INT) * so that the full context is restored instead of relying on * the userspace doing it (as it would do on SYSEXIT). * as ESP and EIP are also reset, userspace won't try to * restore bogus context after returning. * * if the process is not blocked, or the kernel will ignore * our trap style, we needn't panic but things will probably * not go well for the process (restored context will be ignored) * and the situation should be debugged. */ if(!(p->p_rts_flags)) { printf("WARNINIG: setting full context of runnable process\n"); print_proc(p); util_stacktrace(); } if(p->p_seg.p_kern_trap_style == KTS_NONE) printf("WARNINIG: setting full context of out-of-kernel process\n"); p->p_seg.p_kern_trap_style = trap_style; }
void procd_ps2(void) { proc_p p; int i; pgrp_p pg; session_p s; fprintf(stderr,"proc_table: %p, envid: %d\n",proc_table,proc_table->procd_envid); for (i = 0; i < MAXPROC; i++) { fprintf(stderr,"%d ",(bit_test(proc_table->procs_used,i)) ?1:0); p = &proc_table->procs[i]; print_proc(p); } for (i = 0; i < MAXPGRP; i++) { fprintf(stderr,"%d ",(bit_test(proc_table->pgrps_used,i)) ?1:0); pg = &proc_table->pgrps[i]; print_pgrp(pg); } for (i = 0; i < MAXSESSION; i++) { fprintf(stderr,"%d ",(bit_test(proc_table->sessions_used,i)) ?1:0); s = &proc_table->sessions[i]; print_session(s); } fprintf(stderr,"done\n"); }
void print_procs(int maxlines, struct proc *proc1, struct proc *proc2, struct mproc *mproc) { int p, nprocs, tot=0; u64_t idleticks = cvu64(0); u64_t kernelticks = cvu64(0); u64_t systemticks = cvu64(0); u64_t userticks = cvu64(0); u64_t total_ticks = cvu64(0); unsigned long tcyc; unsigned long tmp; int blockedseen = 0; struct tp tick_procs[PROCS]; for(p = nprocs = 0; p < PROCS; p++) { if(isemptyp(&proc2[p])) continue; tick_procs[nprocs].p = proc2 + p; if(proc1[p].p_endpoint == proc2[p].p_endpoint) { tick_procs[nprocs].ticks = sub64(proc2[p].p_cycles, proc1[p].p_cycles); } else { tick_procs[nprocs].ticks = proc2[p].p_cycles; } total_ticks = add64(total_ticks, tick_procs[nprocs].ticks); if(p-NR_TASKS == IDLE) { idleticks = tick_procs[nprocs].ticks; continue; } if(p-NR_TASKS == KERNEL) { kernelticks = tick_procs[nprocs].ticks; continue; } if(mproc[proc2[p].p_nr].mp_procgrp == 0) systemticks = add64(systemticks, tick_procs[nprocs].ticks); else if (p > NR_TASKS) userticks = add64(userticks, tick_procs[nprocs].ticks); nprocs++; } if (!cmp64u(total_ticks, 0)) return; qsort(tick_procs, nprocs, sizeof(tick_procs[0]), cmp_ticks); tcyc = div64u(total_ticks, SCALE); tmp = div64u(userticks, SCALE); printf("CPU states: %6.2f%% user, ", 100.0*(tmp)/tcyc); tmp = div64u(systemticks, SCALE); printf("%6.2f%% system, ", 100.0*tmp/tcyc); tmp = div64u(kernelticks, SCALE); printf("%6.2f%% kernel, ", 100.0*tmp/tcyc); tmp = div64u(idleticks, SCALE); printf("%6.2f%% idle", 100.0*tmp/tcyc); #define NEWLINE do { printf("\n"); if(--maxlines <= 0) { return; } } while(0) NEWLINE; NEWLINE; printf(" PID USERNAME PRI NICE SIZE STATE TIME CPU COMMAND"); NEWLINE; for(p = 0; p < nprocs; p++) { struct proc *pr; int pnr; int level = 0; pnr = tick_procs[p].p->p_nr; if(pnr < 0) { /* skip old kernel tasks as they don't run anymore */ continue; } pr = tick_procs[p].p; /* If we're in blocked verbose mode, indicate start of * blocked processes. */ if(blockedverbose && pr->p_rts_flags && !blockedseen) { NEWLINE; printf("Blocked processes:"); NEWLINE; blockedseen = 1; } print_proc(&tick_procs[p], &mproc[pnr], tcyc); NEWLINE; if(!blockedverbose) continue; /* Traverse dependency chain if blocked. */ while(pr->p_rts_flags) { endpoint_t dep = NONE; struct tp *tpdep; level += 5; if((dep = P_BLOCKEDON(pr)) == NONE) { printf("not blocked on a process"); NEWLINE; break; } if(dep == ANY) break; tpdep = lookup(dep, tick_procs, nprocs); pr = tpdep->p; printf("%*s> ", level, ""); print_proc(tpdep, &mproc[pr->p_nr], tcyc); NEWLINE; } } }
static void print_procs(int maxlines, struct proc *proc1, struct proc *proc2, int cputimemode) { int p, nprocs; u64_t idleticks = 0; u64_t kernelticks = 0; u64_t systemticks = 0; u64_t userticks = 0; u64_t total_ticks = 0; int blockedseen = 0; static struct tp *tick_procs = NULL; if (tick_procs == NULL) { tick_procs = malloc(nr_total * sizeof(tick_procs[0])); if (tick_procs == NULL) { fprintf(stderr, "Out of memory!\n"); exit(1); } } for(p = nprocs = 0; p < nr_total; p++) { u64_t uticks; if(!(proc2[p].p_flags & USED)) continue; tick_procs[nprocs].p = proc2 + p; tick_procs[nprocs].ticks = cputicks(&proc1[p], &proc2[p], cputimemode); uticks = cputicks(&proc1[p], &proc2[p], 1); total_ticks = total_ticks + uticks; if(p-NR_TASKS == IDLE) { idleticks = uticks; continue; } if(p-NR_TASKS == KERNEL) { kernelticks = uticks; } if(!(proc2[p].p_flags & IS_TASK)) { if(proc2[p].p_flags & IS_SYSTEM) systemticks = systemticks + tick_procs[nprocs].ticks; else userticks = userticks + tick_procs[nprocs].ticks; } nprocs++; } if (total_ticks == 0) return; qsort(tick_procs, nprocs, sizeof(tick_procs[0]), cmp_procs); printf("CPU states: %6.2f%% user, ", 100.0 * userticks / total_ticks); printf("%6.2f%% system, ", 100.0 * systemticks / total_ticks); printf("%6.2f%% kernel, ", 100.0 * kernelticks/ total_ticks); printf("%6.2f%% idle", 100.0 * idleticks / total_ticks); #define NEWLINE do { printf("\n"); if(--maxlines <= 0) { return; } } while(0) NEWLINE; printf("CPU time displayed ('%c' to cycle): %s; ", TIMECYCLEKEY, cputimemodename(cputimemode)); printf(" sort order ('%c' to cycle): %s", ORDERKEY, ordername(order)); NEWLINE; NEWLINE; printf(" PID USERNAME PRI NICE SIZE STATE TIME CPU COMMAND"); NEWLINE; for(p = 0; p < nprocs; p++) { struct proc *pr; int level = 0; pr = tick_procs[p].p; if((pr->p_flags & IS_TASK) && pr->p_pid != KERNEL) { /* skip old kernel tasks as they don't run anymore */ continue; } /* If we're in blocked verbose mode, indicate start of * blocked processes. */ if(blockedverbose && (pr->p_flags & BLOCKED) && !blockedseen) { NEWLINE; printf("Blocked processes:"); NEWLINE; blockedseen = 1; } print_proc(&tick_procs[p], total_ticks); NEWLINE; if(!blockedverbose) continue; /* Traverse dependency chain if blocked. */ while(pr->p_flags & BLOCKED) { endpoint_t dep = NONE; struct tp *tpdep; level += 5; if((dep = pr->p_blocked) == NONE) { printf("not blocked on a process"); NEWLINE; break; } if(dep == ANY) break; tpdep = lookup(dep, tick_procs, nprocs); pr = tpdep->p; printf("%*s> ", level, ""); print_proc(tpdep, total_ticks); NEWLINE; } } }
void arrive_south() { //lock mutex_lock_interruptible(&lock); printk("%s: **Locked**\n", __FUNCTION__); //arrive at south_bank printk("%s: Arrived at south bank\n", __FUNCTION__); curr_ferry.curr_bank = 1; print_proc(); release_passengers(); printk("%s: Passengers released, unlocking and waiting\n", __FUNCTION__); //release lock mutex_unlock(&lock); //Wait 2 seconds for any extra passengers msleep(2000); //Lock again and begin loading passengers mutex_lock_interruptible(&lock); printk("%s: Waiting over, locked and loading passengers\n", __FUNCTION__); //load passengers if(south_bank.queen == 1) { printk("%s: Picking up south queen\n", __FUNCTION__); curr_ferry.queen++; south_bank.queen--; curr_ferry.compartments+=5; curr_ferry_passengers++; total_ferried++; } if(south_bank.nobles > 0) { printk("%s: Picking up south nobles: %d\n", __FUNCTION__, south_bank.nobles); while((curr_ferry.compartments + 3) <= 15 && south_bank.nobles > 0) { curr_ferry.nobles++; south_bank.nobles--; curr_ferry.compartments+=3; curr_ferry_passengers++; total_ferried++; } } if(south_bank.peasants > 0) { printk("%s: Picking up south peasants: %d\n", __FUNCTION__, south_bank.peasants); while(curr_ferry.compartments < 15 && south_bank.peasants > 0) { curr_ferry.peasants++; south_bank.peasants--; curr_ferry.compartments++; curr_ferry_passengers++; total_ferried++; } } //release lock mutex_unlock(&lock); printk("%s: **Unlocked**\n", __FUNCTION__); }
int main (void) { int i, c; initscr (); noecho (); curs_set (0); if (has_colors () == FALSE) { fprintf (stderr, "Your terminal doesn't support colors.\n"); global.colors = 0; } else { global.colors = 1; start_color (); if (use_default_colors () == OK) bg = -1; color (GREEN, COLOR_GREEN); color (YELLOW, COLOR_YELLOW); color (RED, COLOR_RED); color (CYAN, COLOR_CYAN); } signal (SIGINT, &handler); signal (SIGTERM, &handler); signal (SIGSEGV, &handler); global.loadavg.file = fopen ("/proc/loadavg", "r"); global.cpu = fopen ("/proc/stat", "r"); global.mtab = fopen ("/etc/mtab", "r"); global.net = fopen ("/proc/net/dev", "r"); global.wireless = fopen ("/proc/net/wireless", "r"); /* Init global.battery */ global.battery.ok = 1; strncpy (global.battery.dir.location, "/proc/acpi/battery/", 128); global.battery.dir.dir = opendir (global.battery.dir.location); if (global.battery.dir.dir != NULL) { while (1) { global.battery.dir.content = readdir (global.battery.dir.dir); if (!strcmp (global.battery.dir.content->d_name, ".")) break; else if (!strcmp (global.battery.dir.content->d_name, "..")) break; } closedir (global.battery.dir.dir); if (global.battery.dir.content != NULL) { strcat (global.battery.dir.location, global.battery.dir.content->d_name); snprintf (global.battery.state.location, 128, "%s/state", global.battery.dir.location); snprintf (global.battery.info.location, 128, "%s/info", global.battery.dir.location); global.battery.state.file = fopen (global.battery.state.location, "r"); global.battery.info.file = fopen (global.battery.info.location, "r"); if (global.battery.state.file == NULL || global.battery.info.file == NULL) { fprintf (stderr, "Can't open %s/state or %s/info while %s is present, check your ACPI configuration or remove the directory %s.\n", global.battery.dir.location, global.battery.dir.location, global.battery.dir.location, global.battery.dir.location); global.battery.ok = 0; } } else { fprintf (stderr, "Nothing in /proc/acpi/battery or can't list directory while directory present.\n"); global.battery.ok = 0; } } else { fprintf (stderr, "No /proc/acpi/battery directory, skipping the battery part.\n"); global.battery.ok = 0; } /* Get static system informations */ global.nprocs = get_nprocs (); uname (&global.uname); { /* get processor */ FILE *f = fopen ("/proc/cpuinfo", "r"); char buf[256]; strncpy (global.processor, global.uname.machine, 256); if (f != NULL) { while (fgets (buf, sizeof buf, f)) { if (!strncmp (buf, "model name", 10)) { char *p = strchr (buf, ':'); strncpy (global.processor, &p[2], 256); p = strchr (global.processor, '\n'); *p = 0; break; } } fclose (f); } global.processor[255] = 0; } if (global.cpu != NULL) { extern struct cpu_t *ocpu, *ncpu; ocpu = malloc (global.nprocs * sizeof (struct cpu_t)); ncpu = malloc (global.nprocs * sizeof (struct cpu_t)); if (ocpu == NULL || ncpu == NULL) fclose (global.cpu), global.cpu = NULL; } halfdelay (1); while ((c = getch ()) != '\n') { global.line = 0; switch (c) { case 'r': clear (); break; } /* Check system informations */ if (0 != sysinfo (&global.sys)) continue; /* Print informations */ for (i = 0; show_fields[i] != EndOfFields; ++i) { if (show_fields[i] == Uname) { mvprintw (global.line++, 0, "%s %s\n%s\n", global.uname.nodename, global.uname.release, global.processor); global.line++; } if (global.loadavg.file != NULL && show_fields[i] == Loadavg) { char tmp[256]; loadavg (); snprintf (tmp, 256, "Load average: 1min: $4%.2f$0 / 5min: $4%.2f$0 / 15min: $4%.2f$0\n", global.loadavg.loads[0], global.loadavg.loads[1], global.loadavg.loads[2]); print_color (global.line++, 0, tmp); snprintf (tmp, 256, "Tasks: $4%d$0 running, $4%d$0 total, last PID used : $4%d$0\n", global.loadavg.prun, global.loadavg.ptotal, global.loadavg.pid); print_color (global.line++, 0, tmp); } refresh (); if (show_fields[i] == Date) /* Date */ { time_t timestamp= time (NULL); struct tm *t = localtime (×tamp); mvprintw (global.line, 0, "Time: %02d:%02d:%02d |", t->tm_hour, t->tm_min, t->tm_sec); refresh (); } if (show_fields[i] == Date) /* Uptime */ { int uptime = global.sys.uptime; int up, day, hour, min, sec; day = uptime / 86400; up = uptime - (day * 86400); hour = up / 3600; up -= hour * 3600; min = up / 60; sec = up - min * 60; mvprintw (global.line++, 17, "Uptime: %d day%s, %02d:%02d:%02d\n", day, (day > 1 ? "s" : ""), hour, min, sec); refresh (); } if (global.cpu != NULL && show_fields[i] == Cpu) { int i; for (i = 0; i < global.nprocs; ++i) cpubar (i); } if (show_fields[i] == Ram) rambar (); if (show_fields[i] == Swap) swapbar (); if (global.mtab != NULL && show_fields[i] == Disk) diskbar (); if (global.wireless != NULL && show_fields[i] == Wireless) wirelessbar (); if (global.net != NULL && show_fields[i] == Network) netbar (); if (global.battery.ok && show_fields[i] == Battery) batterybar (); if (show_fields[i] == Process) print_proc (); } sleep (1); } raise (SIGTERM); return 0; }
int main(int argc, char *argv[]) { arg_parse(argc, argv); page_shift = __getpageshift(); #if 0 choose_dimensions(); #endif if (!old_h_option) { const char *head; switch (ps_format) { default: /* can't happen */ case 0: head = " PID TTY TIME CMD"; break; case 'l': head = " F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD"; break; case 'f': head = " UID PID PPID C STIME TTY TIME CMD"; break; case 'j': head = " PID PGID SID TTY TIME CMD"; break; case 'u' | 0x80: head = " UID PID %CPU %MEM VSZ RSS TTY S START TIME COMMAND"; break; case 'v' | 0x80: head = " PID TTY S TIME MAJFL TRS DRS RSS %MEM COMMAND"; break; case 'j' | 0x80: head = " PPID PID PGID SID TTY TPGID S UID TIME COMMAND"; break; case 'l' | 0x80: head = " F UID PID PPID PRI NI VSZ RSS WCHAN S TTY TIME COMMAND"; break; } printf("%s\n", head); } if (want_one_pid) { if (stat2proc(want_one_pid)) print_proc(); else exit(1); } else { struct dirent *ent; /* dirent handle */ DIR *dir; int ouruid; int found_a_proc; found_a_proc = 0; ouruid = getuid(); dir = opendir("/proc"); if (!dir) exit(1); while ((ent = readdir(dir))) { if (*ent->d_name < '0' || *ent->d_name > '9') continue; if (!stat2proc(atoi(ent->d_name))) continue; if (want_one_command) { if (strcmp(want_one_command, P_cmd)) continue; } else { if (!select_notty && P_tty == -1) continue; if (!select_all && P_euid != ouruid) continue; } found_a_proc++; print_proc(); } closedir(dir); exit(!found_a_proc); } return 0; }
int main(){ queue *test = malloc(sizeof(queue)); test->head = NULL; test->tail = NULL; queue *priority = malloc(sizeof(queue)); priority->head = NULL; priority->tail = NULL; queue *secondary = malloc(sizeof(queue)); secondary->head = NULL; secondary->tail = NULL; // node_t *priority = NULL; //queue 1 // node_t *secondary = NULL; //queue 2 /* //start temp proc *p1 = (proc *)malloc(sizeof(proc)); strcpy(p1->name,"p1"); p1->priority = 0; p1->pid = 33; p1->runtime = 5; push(&test,*p1); proc *p2 = (proc *)malloc(sizeof(proc)); strcpy(p2->name,"p2"); p2->priority = 0; p2->pid = 33; p2->runtime = 5; push(&test,*p2); proc popped = pop(&test); // print_proc(&popped); push(&test,popped); print_list(test); // pop(&test); //end temp */ readFile(&priority,0);//loads all processes with priority == 0 readFile(&secondary,1);//loads all processes with priority != 0 print_list(priority); puts("----"); //print_list(secondary); //create an array of available memory int avail_mem[TOTAL_MEMORY] = {0}; //iterate through all priority processes node_t *temp = priority->head; while (temp != NULL){ pid_t pid = fork(); if (pid == 0){ //child process puts("child:"); execlp("./process",NULL); exit(0); }else if (pid >0){ //parent process temp->val.pid = pid; //set the pid of the process //allocate the required memory int i = 0; temp->val.address = i; for (i = 0; i < temp->val.memory; i++){ avail_mem[i] = 1; } printf("[parent] Executing process: %s, priority: %d, pid: %d, memory: %d, runtime: %d\n", temp->val.name,temp->val.priority,temp->val.pid,temp->val.memory, temp->val.runtime); printf("[parent] waiting %d seconds...:\n",temp->val.runtime); sleep(temp->val.runtime); //sleep for the needed runtime puts("[parent] Sending SIGINT..."); kill(pid,SIGINT); waitpid(pid,0,0); //free the allocated memory printf("[parent] Current available memory: %dMB\n",freeMemoryAmount(avail_mem,TOTAL_MEMORY)); printf("[parent] Freeing: %dMB of memory\n",temp->val.memory); for (int j = 0; j < temp->val.memory; j++){ avail_mem[j] = 0; } //print process to be deleted printf("[parent] Deleting process: %s, priority: %d, pid: %d, runtime: %d\n", temp->val.name,temp->val.priority,temp->val.pid,temp->val.runtime); //delete process from queue temp = temp->next; pop(&priority); puts("--------------------------------------------"); }else{ //fork failed } } //iterate through all the secondary processes print_list(secondary); puts("--------------------------------------------"); int memory_index = 0; temp = secondary->head; while(temp != NULL){//while items in queue proc popped_proc = pop(&secondary);//pop the next process //check if new process and available memory if (popped_proc.suspended == 0 && popped_proc.memory <= freeMemoryAmount(avail_mem,TOTAL_MEMORY)){ //create a new process pid_t pid = fork(); if (pid == 0){ //child execlp("./process",NULL); exit(0); }else if(pid > 0){ //parent printf("Creating new process: ");print_proc(&popped_proc); //allocate the needed memory printf("ALLOCATING memory from: %d, to %d\n",memory_index,memory_index + popped_proc.memory -1); //temp popped_proc.address = memory_index; for (int i = 0; i < popped_proc.memory; i++){ avail_mem[memory_index+i] = 1; } memory_index += popped_proc.memory; printf("MEMORY_INDEX: %d\n",memory_index); print_memory(avail_mem,TOTAL_MEMORY);//temp //new process to be created sleep(1); kill(pid,SIGTSTP); popped_proc.pid = pid; //set the process id [TODO: FIX PID] popped_proc.runtime -= 1; //decrement the runtime popped_proc.suspended = 1; //update the suspended boolean //add the process back on the queue push(&secondary, popped_proc); }else{ perror("Error forking\n"); } }else if(popped_proc.suspended == 1 && popped_proc.runtime != 1){ //must continue process printf("Resuming process: ");print_proc(&popped_proc); kill(popped_proc.pid,SIGCONT); sleep(1); //sleep for once second kill(popped_proc.pid,SIGTSTP); popped_proc.runtime -= 1; //add the process back on the queue push(&secondary, popped_proc); }else if (popped_proc.runtime == 1){ //only 1 second left on process printf("One second left on Process: ");print_proc(&popped_proc); //run for the remaining second //delocate the memory taken printf("DEALLOCATING memory from %d, to %d\n",memory_index - 1, memory_index - popped_proc.memory); for (int i = 1; i <= popped_proc.memory; i++){ avail_mem[memory_index - i] = 0; } memory_index -= popped_proc.memory; printf("MEMORY_INDEX: %d\n",memory_index); print_memory(avail_mem,TOTAL_MEMORY);//temp //run the process kill(popped_proc.pid,SIGCONT); sleep(1); //sleep for once second kill(popped_proc.pid,SIGINT); waitpid(popped_proc.pid,0,0); }else { //not enough memory, push back on the queue printf("Not enough memory for: ");print_proc(&popped_proc); push(&secondary, popped_proc); } temp = secondary->head;//go to next node } puts("---------------COMPLETE--------------------"); return 0; }