int
main(int argc, char *argv[])
{
struct pstat st_before, st_after;
int lowpriorityrun = 0, highpriorityrun = 0;
printf(1, "1 - PID #%d\n", getpid());
int rc = fork();
int i;
int pid = getpid();
if(rc == 0)
{
printf(1, "2 - PID #%d (bout to spin 1)\n", getpid());
spin();
printf(1, "2 - PID #%d (bout to sleep)\n", getpid());
sleep(200);
printf(1, "2 - PID #%d (bout to spin 2)\n", getpid());
spin();
exit();
}
check(setpri(2) == 0, "setpri");
if(fork() == 0)
{
printf(1, "3 - PID #%d (bout to sleep 1)\n", getpid());
sleep(200);
printf(1, "3 - PID #%d (bout to spin)\n", getpid());
spin();
printf(1, "3 - PID #%d (bout to sleep 2)\n", getpid());
sleep(100);
printf(1, " then 2");
exit();
}
printf(1, "4 - PID #%d (bout to sleep)\n", getpid());
sleep(200);
printf(1, "5 - PID #%d\n", getpid());
check(getpinfo(&st_before) == 0, "getpinfo");
printf(1, "\n ****PInfo before**** \n");
print(&st_before);
printf(1, "5 - PID #%d (bout to spin 1)\n", getpid());
spin();
printf(1, "5 - PID #%d (bout to spin 2)\n", getpid());
spin();
check(getpinfo(&st_after) == 0, "getpinfo");
printf(1, "\n ****PInfo after**** \n");
print(&st_after);
for(i = 0; i < NPROC; ++i)
{
if(st_before.pid[i] != pid && st_before.lticks[i] < st_after.lticks[i] && st_before.hticks[i] < st_after.hticks[i])
lowpriorityrun++;
if(st_before.hticks[i] < st_after.hticks[i])
highpriorityrun++;
}
check(lowpriorityrun == 0, "Expected only the high priority process to run once it is awake");
check(highpriorityrun == 1, "Expected one high priority process to run once it is awake");
printf(1, "Should print 1");
wait();
wait();
exit();
}
int
main(int argc, char *argv[])
{
struct pstat st_before, st_after;
int pid = getpid();
int lowpriorityrun = 0;
int highpriorityrun = 0;
int i;
check(setpri(2) == 0, "setpri");
// check if process run in high priority mode once set to high
check(getpinfo(&st_before) == 0, "getpinfo");
printf(1, "\n ****PInfo before**** \n");
print(&st_before);
spin();
check(getpinfo(&st_after) == 0, "getpinfo");
printf(1, "\n ****PInfo after**** \n");
print(&st_after);
for(i = 0; i < NPROC; ++i)
{
if(st_before.pid[i] == pid && st_after.pid[i] == pid)
{
if(st_before.hticks[i] < st_after.hticks[i] && st_before.lticks[i] == st_after.lticks[i])
highpriorityrun = 1;
}
}
check(highpriorityrun == 1, "Expected process to have run in high priority mode once priority changed to high");
check(setpri(1) == 0, "setpri");
// check if process run in low priority mode once changed back
check(getpinfo(&st_before) == 0, "getpinfo");
printf(1, "\n ****PInfo before**** \n");
print(&st_before);
spin();
check(getpinfo(&st_after) == 0, "getpinfo");
printf(1, "\n ****PInfo after**** \n");
print(&st_after);
for(i = 0; i < NPROC; ++i)
{
if(st_before.pid[i] == pid && st_after.pid[i] == pid)
{
if(st_before.lticks[i] < st_after.lticks[i] && st_before.hticks[i] == st_after.hticks[i])
lowpriorityrun = 1;
}
}
check(lowpriorityrun == 1, "Expected process to have run in low priority mode once priority changed back to low");
printf(1, "Should print 1 then 2");
exit();
}
int
main(int argc, char *argv[])
{
struct pstat st;
sleep(10);
int count = 0;
int i, j = 0;
for(i = 0; i < 50000000; i++)
j += i * j + 1;
check(getpinfo(&st) == 0, "getpinfo");
int pid = getpid();
// a weak test, only show whether if the current process gets run once
for(i = 0; i < NPROC; i++) {
if (st.inuse[i]) {
count++;
if (pid == st.pid[i]) {
printf(1, "pid: %d priority: %d\n ", st.pid[i], st.priority[i]);
for (j = 0; j < 4; j++)
printf(1, "\t level %d ticks used %d\n", j, st.ticks[i][j]);
check(st.ticks[i][0] > 0, "current process must run at least once");
}
}
}
check(count == 3, "should be three processes: init, sh, tester");
printf(1, "TEST PASSED");
exit();
}
int
main(int argc, char *argv[])
{
int x = settickets(23);
struct pstat *stat1;
stat1 = malloc(sizeof(*stat1));
int y = getpinfo(stat1);
int counter = 0;
for(counter = 0; counter < NPROC; counter++){
printf(1, "PID %d, \n", stat1->pid[counter]);
printf(1, "INUSE %d, \n", stat1->inuse[counter]);
printf(1, "TICKS %d, \n", stat1->ticks[counter]);
}
// = malloc(sizeof(stat1));
y = y+0;
//printf(1, x);
printf(1, "hello world %d, \n", x);
exit();
}
int
main(int argc, char *argv[])
{
//int x = settickets(23);
//const clock_t start = clock();
// do stuff here
//clock_t now = clock();
//clock_t delta = now - start;
//return (int) start;
struct pstat *stat1;
stat1 = malloc(sizeof(*stat1));
//int y = getpinfo(stat1);
int y = getpinfo(NULL);
int z = setpri(1);
printf(stdout, "SETPRI, %d\n", z);
int counter = 0;
//for(counter = 0; counter < NPROCS; counter++){
printf(stdout, "aux %s, \n", stat1->aux[counter]);
printf(stdout, "PID %d, \n", stat1->pid[counter]);
printf(stdout, "INUSE %d, \n", stat1->inuse[counter]);
printf(stdout, "LTICKS %d, \n", stat1->hticks[counter]);
printf(stdout, "HTICKS %d, \n", stat1->lticks[counter]);
//}
// = malloc(sizeof(stat1));
//y = y+0;
//printf(1, x);
printf(stdout, "hello you, %d\n", y);
//return 0;
exit();
}
int main(int argc, char *argvv[]) {
//int tickettest;
struct pstat * stats;
stats = (struct pstat *) malloc(sizeof(struct pstat) * 64);
int i;
// (settickets(0) == -1) ? printf(1,"fail\n") : printf(1,"pass\n"); //you f****d
// (settickets(10) == -1) ? printf(1,"fail\n") : printf(1,"pass\n"); //you good
// (settickets(40) == -1) ? printf(1,"fail\n") : printf(1,"pass\n"); //you good
// (settickets(38) == -1) ? printf(1,"fail\n") : printf(1,"pass\n"); //you f****d
settickets(20); //you good
// (settickets(160) == -1) ? printf(1,"fail\n") : printf(1,"fpass\n"); //you f****d
//printf(1, "\n");
int runtime;
fork_kids();
printf(1,",10,30,60,90,120,150\n");
for(runtime = 0; runtime < 119 ;runtime++) {
getpinfo(stats);
printf(1,"%d,", runtime);
for(i = 0; i < 64; i++) {
if(stats[i].inuse == 1 && (stats[i].pid != 1 && stats[i].pid != 2 && stats[i].pid != 3)) {
printf(1,"%d,", stats[i].n_schedule);
}
}
printf(1, "\n");
sleep(100);
}
exit();
}
int
main(int argc, char *argv[])
{
struct pstat st;
int highpriority = 0;
int pid = getpid();
int defaultpriorityrun = 0;
spin();
check(getpinfo(&st) == 0, "getpinfo");
int i;
printf(1, "\n **** PInfo **** \n");
for(i = 0; i < NPROC; i++) {
if (st.inuse[i]) {
if(st.hticks[i] != 0)
highpriority++;
if(st.pid[i] == pid && st.lticks[i] > 20)
defaultpriorityrun = 1;
printf(1, "pid: %d hticks: %d lticks: %d\n", st.pid[i], st.hticks[i], st.lticks[i]);
}
}
check(highpriority == 0, "getpinfo shouldn't return any process with hticks not equal to 0, default priority should be low(1) ");
check(defaultpriorityrun == 1, "getpinfo should return a process having run with default priority");
printf(1, "Should print 1 then 2");
exit();
}
int
main(int argc, char *argv[])
{
int pids[2];
int ppid = getpid();
int r, i, j;
pids[0] = fork();
if (pids[0] == 0) {
r = settickets(2);
if (r != 0) {
printf(1, "settickets failed");
kill(ppid);
}
spin();
}
pids[1] = fork();
if (pids[1] == 0) {
r = settickets(4);
if (r != 0) {
printf(1, "settickets failed");
kill(ppid);
}
spin();
}
sleep(1000);
int lticks[] = {-1, -1};
int hticks[] = {-1, -1};
struct pstat st;
check(getpinfo(&st) == 0, "getpinfo");
for(i = 0; i < NPROC; i++) {
for(j = 0; j < 2; j++) {
if (st.inuse[i] && st.pid[i] == pids[j]) {
lticks[j] = st.lticks[i];
hticks[j] = st.hticks[i];
}
}
}
for (i = 0; i < 2; i++) {
kill(pids[i]);
wait();
}
for (i = 0; i < 2; i++) {
check(hticks[i] > 0 && lticks[i] > 0, "each process should have some hticks and lticks");
}
float ratio = (float)lticks[0] / (float)lticks[1];
printf(1, "lticks child 1: %d\n", lticks[0]);
printf(1, "lticks child 2: %d\n", lticks[1]);
check(ratio > .25 && ratio < .75, "ratio should be about 1/2");
printf(1, "TEST PASSED\n");
exit();
}
//another added syscall
int
sys_getpinfo(void)
{
struct pstat *info;
if(argptr(0, (void*)&info, sizeof(info)) < 0){
return -1;
}
getpinfo(info);
return 0;
}
int
sys_getpinfo(void)
{
struct pstat pstatVariable;
struct pstat *pointer=&pstatVariable;
if(argptr(0,(char**)(&pointer),sizeof(struct pstat*))<0)
return -1;
return getpinfo(pointer);
}
int main(int argc, char *argv[]){
struct pstat pstatt = {{0},{0},{0},{0}};
if(getpinfo(&pstatt)==0){
}
exit();
// return 0;
}
int
main(int argc, char *argv[])
{
struct pstat st_before, st_after;
int lowpriorityrun = 0;
int highpriorityrun = 0;
int rc = fork();
int i;
if(rc == 0)
{
spin();
spin();
sleep(500);
exit();
}
sleep(100);
check(setpri(2) == 0, "setpri");
check(getpinfo(&st_before) == 0, "getpinfo");
printf(1, "\n ****PInfo before**** \n");
print(&st_before);
sleep(500);
check(getpinfo(&st_after) == 0, "getpinfo");
printf(1, "\n ****PInfo after**** \n");
print(&st_after);
for(i = 0; i < NPROC; ++i)
{
if(st_before.pid[i] == rc && st_after.pid[i] == rc)
{
if(st_before.lticks[i] < st_after.lticks[i])
lowpriorityrun = 1;
if(st_before.hticks[i] < st_after.hticks[i])
highpriorityrun = 1;
}
}
check(highpriorityrun == 0, "Expected no high priority ticks when low priority running");
check(lowpriorityrun == 1, "Expected low priority process to have run when high priority process was put to sleep");
wait();
printf(1, "Should print 1 then 2");
exit();
}
int
main(void)
{
//Adde
struct pstat ptr;
//Testing tickets syscall
if (settickets(1) == 0) {
printf(0,"Set tickets success!\r\n");
} else {
printf(0,"Set tickets failed!\r\n");
}
//Testing getpinfo
// getpinfo(ptr);
int inval = getpinfo(&ptr);
if (inval == 0) {
int i;
int max = 64;
for(i=0;i<max;i++) {
if ((ptr.inuse[i] == 0)&&(i < 10)) {
printf(0,"Proc %d not in use pid=%d, hticks = %d, lticks = %d\r\n"
,i,ptr.pid[i],ptr.hticks[i],ptr.lticks[i]);
}
if(ptr.inuse[i] == 1) {
printf(0,"Proc %d running!!! pid=%d, hticks = %d, lticks = %d\r\n"
,i,ptr.pid[i],ptr.hticks[i],ptr.lticks[i]);
} else {
//printf(0,"Proc %d not in use pid=%d, hticks = %d, lticks = %d\r\n"
// ,i,ptr.pid[i],ptr.hticks[i],ptr.lticks[i]);
}
if (i == 60) printf(0,"lotto = %d\r\n",ptr.lticks[i]);
if (i == 61) printf(0,"qlevel = %d\r\n",ptr.lticks[i]);
if (i == 62) printf(0,"tix = %d\r\n",ptr.lticks[i]);
if (i == 63) printf(0,"lo_tix= %d\r\n",ptr.lticks[i]);
if (i == 59) printf(0,"hi_tix = %d\r\n",ptr.lticks[i]);
if (i == 58) printf(0,"Second loop ran %d times\r\n",ptr.lticks[i]);
if (i == 57) printf(0,"First loop ran %d times\r\n",ptr.lticks[i]);
}
printf(0,"\r\n");
printf(0,"Print out finished \r\n");
} else {
printf(0,"Failed to call getpinfo!! \r\n");
printf(0,"fail val= %d \r\n",inval);
}
if(fork() > 0)
sleep(5); // Let child exit before parent.
exit();
}
int
main(int argc, char *argv[])
{
if(fork() == 0)
{
struct pstat st_before, st_after;
check(setpri(2) == 0, "setpri");
check(getpinfo(&st_before) == 0, "getpinfo");
printf(1, "\n ****PInfo before**** \n");
print(&st_before);
spin();
spin();
check(getpinfo(&st_after) == 0, "getpinfo");
printf(1, "\n ****PInfo after**** \n");
print(&st_after);
compare(&st_before, &st_after);
printf(1, "Should print 1");
exit();
}
spin();
printf(1, " then 2");
exit();
}
// print usage info of all procresses
void
printinfo()
{
struct pstat st;
int r = getpinfo(&st);
if (r != 0) {
exit();
}
int i;
for(i = 1; i < NPROC; i++) {
if (st.inuse[i]) {
printf(1, "pid: %d ticks: %d\n", st.pid[i], st.ticks[i]);
}
}
}
int
main(int argc, char *argv[])
{
struct pstat st;
check(getpinfo(&st) == 0, "getpinfo");
int i, j;
for(i = 0; i < NPROC; i++) {
if (st.inuse[i]) {
printf(1, "pid: %d priority: %d\n ", st.pid[i], st.priority[i]);
for (j = 0; j < 4; j++)
printf(1, "\t level %d ticks used %d\n", j, st.ticks[i][j]);
}
}
printf(1, "TEST PASSED");
exit();
}
int
getprocessinfo(void)
{
struct pstat p;
int i;
for(i = 0; i < N; i++)
{
p.inuse[i] = 0;
p.pid[i] = -1; // the PID of each process
p.hticks[i] = 0; // the number of ticks each process has accumulated at HIGH priority
p.lticks[i] = 0; // the number of ticks each process has accumulated at LOW priority
p.runTimes[i] = 0;
p.queue[i] = -1;
}
int va = getpinfo(&p);
printf(2, "Here is the list of process stat: ");
for(i = 0; i < N; i++)
{
printf(2, "Process: pid %d, inuse %d, hticks %d, lticks %d\n", p.inuse[i], p.pid[i], p.hticks[i], p.lticks[i]);
}
return va;
}
int
main(int argc, char *argv[])
{
struct pstat st;
check(getpinfo(&st) == 0, "getpinfo");
int count = 0;
int i;
for(i = 0; i < NPROC; i++) {
if (st.inuse[i]) {
count++;
printf(1, "pid: %d ticks: %d\n", st.pid[i], st.ticks[i]);
check(st.ticks[i] > 0, "all processes must have run at least once");
}
}
check(count == 3, "should be three processes: init, sh, tester");
printf(1, "TEST PASSED");
exit();
}
int
main(int argc, char *argv[])
{
struct pstat p;
if(getpinfo(&p) < 0)
{
printf(1, "getpinfo failed!\n");
exit();
}
int i;
printf(1, "slot\tpid\t#chosen\truntime\tcharge\n");
for(i = 0; i < NPROC; i++)
{
if(p.inuse[i])
{
printf(1, "%d\t%d\t%d\t%d\t%d\n", i, p.pid[i], p.chosen[i], p.time[i], p.charge[i]);
}
}
exit();
}
/*
* The out of control system call
* This is audit kitchen sink aka auditadm, aka auditon
*/
int
auditctl(
int cmd,
caddr_t data,
int length)
{
int result;
switch (cmd) {
case A_GETAMASK:
case A_GETCOND:
case A_GETCAR:
case A_GETCLASS:
case A_GETCWD:
case A_GETKAUDIT:
case A_GETKMASK:
case A_GETPINFO:
case A_GETPINFO_ADDR:
case A_GETPOLICY:
case A_GETQCTRL:
case A_GETSTAT:
if (secpolicy_audit_getattr(CRED(), B_FALSE) != 0)
return (EPERM);
break;
default:
if (secpolicy_audit_config(CRED()) != 0)
return (EPERM);
break;
}
switch (cmd) {
case A_GETPOLICY:
result = getpolicy(data);
break;
case A_SETPOLICY:
result = setpolicy(data);
break;
case A_GETAMASK:
result = getamask(data);
break;
case A_SETAMASK:
result = setamask(data);
break;
case A_GETKMASK:
result = getkmask(data);
break;
case A_SETKMASK:
result = setkmask(data);
break;
case A_GETKAUDIT:
result = getkaudit(data, length);
break;
case A_SETKAUDIT:
result = setkaudit(data, length);
break;
case A_GETQCTRL:
result = getqctrl(data);
break;
case A_SETQCTRL:
result = setqctrl(data);
break;
case A_GETCWD:
result = getcwd(data, length);
break;
case A_GETCAR:
result = getcar(data, length);
break;
case A_GETSTAT:
result = getstat(data);
break;
case A_SETSTAT:
result = setstat(data);
break;
case A_SETUMASK:
result = setumask(data);
break;
case A_SETSMASK:
result = setsmask(data);
break;
case A_GETCOND:
result = getcond(data);
break;
case A_SETCOND:
result = setcond(data);
break;
case A_GETCLASS:
result = getclass(data);
break;
case A_SETCLASS:
result = setclass(data);
break;
case A_GETPINFO:
result = getpinfo(data);
break;
case A_GETPINFO_ADDR:
result = getpinfo_addr(data, length);
break;
case A_SETPMASK:
result = setpmask(data);
break;
default:
result = EINVAL;
break;
}
return (result);
}
int
sys_getpinfo(void)
{
int y = getpinfo();
return y;
}
int main(int argc, char *argv[]) {
//Initialize the shell
init_shell();
int numofpipes[MAXCMD];
//Initialize jobs array
init_jobsarray();
//Holds the command
char wholecommand[MAXNUM];
char dupwholecommand[MAXNUM];
char *cmdarr[MAXCMD][MAXOP]; //The rows hold commands separated by ;
//while the columns hold the command and its options separated by " " or \t
char *pipecmdarr[MAXCMD][MAXCMD][MAXOP];
char maincmd[MAXNUM];
//For prompt
char username[MAXNUM],sysname[MAXNUM],cwdir[MAXNUM];
char homedir[MAXNUM];
getcwd(homedir,MAXNUM);
char duphomedir[MAXNUM];
duphomedir[0] = '\0';
strcat(duphomedir,homedir);
//For tokenizing
char *str1 = NULL;
char *token = NULL;
//Counters
int i;
//Initializing background process array
for(i=0; i<(MAXNUM*MAXOP); i++) {
bgrounds[i].used = 0;
}
//Initializing ends
//Initialize to NULL
initarray(cmdarr);
char *hdir[MAXNUM];
//Tokenize home directory
tokenize(str1,hdir,token,duphomedir);
//Tokenize home directory done
while(1) {
if(signal(SIGINT,signal_handler)==SIG_ERR)
perror("Signal not caught!!");
if(signal(SIGCHLD,signal_handler)==SIG_ERR)
perror("Signal not caught!!");
for(i=0; i<MAXCMD; i++)
numofpipes[i] = 0;
rectifyjobsarray();
//Printing message on background process completion
for(i=0; i<(MAXNUM*MAXOP); i++) {
if(bgrounds[i].used == 0)
continue;
bgrounds[i].used = 0;
if(bgrounds[i].status == 1) {
//printf("Process %s with pid %d terminated normally\n",bgrounds[i].name,bgrounds[i].pid);
}
else {
//printf("Process %s with pid %d terminated with status %d\n",bgrounds[i].name,bgrounds[i].pid,bgrounds[i].status);
}
}
//Renitializing background process array
for(i=0; i<(MAXNUM*MAXOP); i++) {
bgrounds[i].used = 0;
}
//Renitializing ends
//Initialize to NULL
initarray(cmdarr);
initpipecmd(pipecmdarr);
//For prompt
username[0] = '\0';
cwdir[0] = '\0';
strcat(username,getlogin());
gethostname(sysname,MAXNUM);
getcwd(cwdir,MAXNUM);
char dupcwdir[MAXNUM];
dupcwdir[0] = '\0';
strcat(dupcwdir,cwdir);
directorysettings(cwdir,homedir,dupcwdir,hdir);
//Prompt settings done
//Take commands
printf("<%s@%s:%s>",username,sysname,cwdir);
wholecommand[0] = '\0';
dupwholecommand[0] = '\0';
readLine(wholecommand);
wholecommand[strlen(wholecommand)-1]='\0';
strcpy(dupwholecommand,wholecommand);
//Done taking commands
//Tokenize
maintokenize(cmdarr,dupwholecommand);
//tokentest(cmdarr);
pipetokenize(cmdarr,pipecmdarr,numofpipes);
//pipetokenizetest(cmdarr,pipecmdarr,numofpipes);
//exit(EXIT_SUCCESS);
//continue;
//Tokenize done
//Executing each ; separated command
for(i = 0; i< MAXCMD; i++) {
if(cmdarr[i][0] == NULL)
continue;
maincmd[0] = '\0';
strcat(maincmd,cmdarr[i][0]);
strcpy(infile,"\0");
strcpy(outfile,"\0");
if(numofpipes[i] != 0) { //Execute piped commands
pipesexecute(cmdarr, pipecmdarr, numofpipes, i);
continue;
}
if((strcmp(maincmd,"echo") == 0) || (strcmp(maincmd,"pwd") == 0) || (strcmp(maincmd,"cd") == 0)\
|| (strcmp(maincmd,"clear") == 0) || (strcmp(maincmd,"quit") == 0) || (strcmp(maincmd,"pinfo") == 0) ||
strcmp(maincmd,"jobs") == 0 || strcmp(maincmd,"overkill") == 0 || strcmp(maincmd,"kjob") == 0
|| strcmp(maincmd,"fg") == 0 ) {
int dupstdout = dup(1);
int dupstdin = dup(0);
if(checkinfile(cmdarr,i) == 1) {
if(strcmp(infile,"\0") != 0) {
int in=open(infile,O_RDONLY);
dup2(in,0);
close(in);
}
}
int outretval = checkoutfile(cmdarr,i);
if(outretval == 1 || outretval == 2) {
if(strcmp(outfile,"\0") != 0) {
if(outretval == 1) {
int out=open(outfile,O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR);
dup2(out,1);
close(out);
}
else {
if(fopen(outfile,"r") == NULL) {
int out=open(outfile,O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR);
dup2(out,1);
close(out);
}
else {
int out=open(outfile,O_WRONLY | O_APPEND, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR);
dup2(out,1);
close(out);
}
}
}
}
//echo execution
if(strcmp (maincmd,"echo") == 0) {
exececho(wholecommand,cmdarr,i);
}
//echo done
//pwd execution
if(strcmp (maincmd,"pwd") == 0) {
execpwd();
}
//pwd done
//chdir execution
if(strcmp (maincmd,"cd") == 0) {
execcd(cmdarr,homedir,i);
}
//chdir done
//clear execution
if(strcmp (maincmd,"clear") == 0) {
printf("\e[1;1H\e[2J");
}
//clear done
//terminal quit
if(strcmp (maincmd,"quit") == 0) {
exit(EXIT_SUCCESS);
}
//terminal quit done
//jobs
if(strcmp (maincmd,"jobs") == 0) {
execjobs();
}
//jobs done
//overkill
if(strcmp (maincmd,"overkill") == 0) {
execoverkill();
}
//overkill done
//kjob
if(strcmp (maincmd,"kjob") == 0) {
execkjob(cmdarr,i);
}
//kjob done
//fg
if(strcmp (maincmd,"fg") == 0) {
execfg(cmdarr,i);
}
//fg done
//pinfo
if(strcmp (maincmd,"pinfo") == 0) {
pid_t proid;
int flag = 0;
if(cmdarr[i][1] == NULL) //pinfo of shell
proid = getpid();
else { //pinfo of given pid
char temps[MAXNUM];
strcpy(temps,cmdarr[i][1]);
proid = atoi(temps);
if(kill(proid,0) == (-1)) {
printf("No such process exists\n");
continue;
}
flag = 1;
}
getpinfo(proid, flag, homedir);
}
//pinfo done
dup2(dupstdin,0);
dup2(dupstdout,1);
}
else {
int
main(int argc, char *argv[])
{
const int KERNEL_NPROC = 64;
const int CHILD_STARTUP_SLEEP = 100;
const int MIN_UPTIME = 1000;
if(argc!=2) {
printf(1, "%s", "USAGE: graphs.c <int testnum>\n");
exit();
}
int option = atoi(argv[1]);
if(option == 0) {
//SAME PERCENT RESERVE
//Make this reserve 50
int returnval = reserve(50);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test 4 reserve procs with 50% reserve
//Expect ~same number of times chosen
const int NUM_PROC = 3;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
returnval = reserve(50);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
break;
}
else {
//parent
pids[i+1] = pid;
}
}
if(pid == 0) {
sleep(CHILD_STARTUP_SLEEP*2);
while(1) {
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i] || getpid() == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}
/*else if(option == 2) {
//DIFF BID SPOT
//Make this spot with bid 50
int returnval;
returnval = spot(50);
if(returnval < 0) {
printf(1, "ERROR: spot failed\n");
}
//Expect significant difference in number of times chosen between bid levels
const int NUM_PROC = 10;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
int bid = 20;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
returnval = spot(bid);
if(returnval < 0) {
printf(1, "ERROR: spot failed\n");
}
break;
}
else {
//parent
if(i==4) {
bid+=10;
}
pids[i+1] = pid;
}
}
if(pid == 0) {
sleep(CHILD_STARTUP_SLEEP);
while(1) {
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
printf(1, "getpinfo failed\n");
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}
else if(option == 3) {
//DIFF PERCENT RESERVE
//Make this reserve with 10 percent
int returnval;
returnval = reserve(10);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test different reservation sizes
//Sizes are 10 (parent proc), 20, 30, 40, 50, 50
const int NUM_PROC = 5;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
int percent = 20;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
returnval = reserve(percent);
if(returnval < 0) {
printf(1, "ERROR: spot failed\n");
}
break;
}
else {
//parent
if(i<NUM_PROC-2) {
percent+=10;
}
pids[i+1] = pid;
}
}
if(pid == 0) {
sleep(CHILD_STARTUP_SLEEP);
while(1){
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
//Find pid in pstat
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}*/
/*else if(option == 4) {
//RESERVE CALL TOO LOW
//Test user attempting to reserve a percentage < 0
//Expect -1 to be returned from the reserve call
int flag = reserve(-1);
if(flag < 0) {
printf(1, "Test succeeded, reserve call failed.\n");
}
else {
printf(1, "ERROR: test failed. Reserve call did not fail when percentage < 0 was input.");
}
exit();
}
else if(option == 5) {
//RESERVE CALL TOO HIGH
//Test user attempting to reserve a percentage > 100
//Expect -1 to be returned from the reserve call
int flag = reserve(101);
if(flag < 0) {
printf(1, "Test succeeded, reserve call failed.\n");
}
else {
printf(1, "ERROR: test failed. Reserve call did not fail when a percantage > 100 was input.");
}
exit();
}
else if(option == 6) {
//RESERVE SUM TOO HIGH
//Make this reserve of 100
int returnval = reserve(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test user attempting to reserve too much cpu (currentreservation + newreservation > 200)
//Expect -1 to be returned from second child's reserve call
const int NUM_PROC = 2;
int pids[NUM_PROC];
int i;
int pid;
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
int flag = reserve(100);
if(i==0 && flag < 0) {
printf(1, "ERROR: incorrect reserve failed\n");
}
if(i==1 && flag < 0) {
printf(1, "Test succeeded, reserve call failed.\n");
}
else if(i==1) {
printf(1, "ERROR: test failed. Reserve call did not fail when the total process percent exceeded 200.");
}
break;
}
else {
pids[i] = pid;
sleep(100);
}
}
if(pid == 0) {
while(1);
}
else {
sleep(500);
for(i=0; i<NUM_PROC; i++) {
kill(pids[i]);
wait();
}
exit();
}
}*/
else if(option == 7) {
//CHARGE TEST
//Make this reserve with 100
int returnval = reserve(100);
if(returnval < 0) {
printf(1,"ERROR: spot call failed\n");
}
//Test charge in dollars
//Expecting time*bid/nanodollars = charge
//NOTE: ADD 10 to time and 1 to chosen to insure no error
struct pstat p;
struct pstat *stats = &p;
//returnval = getpinfo(stats);
int prevchosen = 0;
int prevtime = 0;
int i;
int pid = fork();
if(pid == 0) {
returnval = spot(100);
if(returnval < 0) {
printf(1,"ERROR: reserve call failed\n");
}
while(1) {
}
}
sleep(MIN_UPTIME);
returnval = getpinfo(stats);
if(returnval >= 0) {
for(i=0; i<KERNEL_NPROC; i++) {
if(pid == stats->pid[i]) {
printf(1, "%d,%d,%d,%d\n", stats->pid[i], stats->chosen[i]-prevchosen, stats->time[i]-prevtime, stats->charge[i]);
}
}
}
else {
printf(1, "ERROR: getpinfo failed\n");
}
while(1);
}
else if(option == 9) {
//STARVATION TEST EXTRA CREDIT
int returnval = reserve(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test starvation
//Expect ~same number of times chosen
const int NUM_PROC = 4;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
if(i==0) {
returnval = reserve(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
}
else {
returnval = spot(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
}
break;
}
else {
//parent
if(i==0) {
sleep(20);
}
pids[i+1] = pid;
}
}
if(pid == 0) {
while(1) {
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i] || getpid() == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}
return 0;
}
int
main(int argc, char **argv)
{
/*//printf(1,"getsyscallinfo is returning %d\n", getsyscallinfo()); //User program calling system call
int i;
for(i=-2; i<10; i+=1)
{
// printf(1,"Set tickets is returning %d as and we are setting %d\n", settickets(i),i);
//printf(1,"Ticket was set to %d\n")i
//
getpinfo(pt);
}
*/
struct p_info
{
int pids;
int tk;
};
struct p_info p_table[N];
int i,r,j,k;
int ppid = getpid();
for(i = 0; i < N; i++)
{
p_table[i].pids = fork();
if (p_table[i].pids == 0)
{
p_table[i].tk = i * N + N;
r = settickets(i * N + N);
if (r != 0)
{
printf(1, "settickets failed");
kill(ppid);
}
spin();
}
}
//sleep(10);
int lticks[10] ;
int hticks[10];
struct pstat st;
getpinfo(&st);
for(k = 0; i < NPROC; k++)
{
for(j = 0; j < N; j++)
{
if (st.inuse[i] && (st.pid[i] == p_table[j].pids)) {
lticks[j] = st.lticks[i];
hticks[j] = st.hticks[i];
printf(1,"pid: %d\t tickets: %d\t ltick: %d\t hticks: %d\n",p_table[j].pids, p_table[j].tk, hticks[j], lticks[j]);
}
}
}
for (i = 0; i < N; i++) {
kill(p_table[i].pids);
wait();
}
exit();
}
