static int
linux_read(int fd)
{
struct str_message msg;
struct intercept_pid *icpid;
const char *sysname;
u_int16_t seqnr;
pid_t pid;
int code;
if (read(fd, &msg, sizeof(msg)) != sizeof(msg))
return (-1);
icpid = linux_getpid(msg.msg_pid);
if (icpid == NULL)
return (-1);
seqnr = msg.msg_seqnr;
pid = msg.msg_pid;
switch (msg.msg_type) {
case SYSTR_MSG_ASK:
code = msg.msg_data.msg_ask.code;
sysname = linux_syscall_name(pid, code);
intercept_syscall(fd, pid, seqnr, msg.msg_policy,
sysname, code, "linux",
(void *)msg.msg_data.msg_ask.args,
msg.msg_data.msg_ask.argsize);
break;
case SYSTR_MSG_RES:
code = msg.msg_data.msg_ask.code;
sysname = linux_syscall_name(pid, code);
intercept_syscall_result(fd, pid, seqnr, msg.msg_policy,
sysname, code, "linux",
(void *)msg.msg_data.msg_ask.args,
msg.msg_data.msg_ask.argsize,
msg.msg_data.msg_ask.result,
msg.msg_data.msg_ask.rval);
break;
case SYSTR_MSG_UGID: {
struct str_msg_ugid *msg_ugid = &msg.msg_data.msg_ugid;
intercept_ugid(icpid, msg_ugid->uid, msg_ugid->uid);
if (linux_answer(fd, pid, seqnr, 0, 0, 0, NULL) == -1)
err(1, "%s:%d: answer", __func__, __LINE__);
break;
}
case SYSTR_MSG_CHILD:
intercept_child_info(msg.msg_pid, msg.msg_data.msg_child.new_pid);
break;
#ifdef SYSTR_MSG_POLICYFREE
case SYSTR_MSG_POLICYFREE:
intercept_policy_free(msg.msg_policy);
break;
#endif
}
return (0);
}
/*-----------------------------------------------------------------------
* resched -- reschedule processor to highest priority ready process
*
* Notes: Upon entry, currpid gives current process id.
* Proctab[currpid].pstate gives correct NEXT state for
* current process if other than PRREADY.
*------------------------------------------------------------------------
*/
int resched()
{
register struct pentry *optr; /* pointer to old process entry */
register struct pentry *nptr; /* pointer to new process entry */
int rand_num,temp_currpid,i;
/* no switch needed if current process priority higher than next*/
if(used_scheduler == RANDOMSCHED)
{
optr= &proctab[currpid];
}
else if(used_scheduler == LINUXSCHED)
{
optr= &proctab[currpid];
}
else
{
if ( ( (optr= &proctab[currpid])->pstate == PRCURR) &&
(lastkey(rdytail)<optr->pprio))
{
return(OK);
}
}
/* force context switch */
if (optr->pstate == PRCURR)
{
optr->pstate = PRREADY;
optr->arrival_time = ctr1000;
if(preempt >= 0)
optr->quantum_left = preempt;
insert(currpid,rdyhead,optr->pprio);
}
/* remove highest priority process at end of ready list */
if(used_scheduler != LINUXSCHED)
{
execution_time[currpid]+=(QUANTUM-preempt);
}
else
execution_time[currpid]+= (proctab[currpid].quantum_left -preempt);
//kprintf("\nPreempt: %d",preempt);
if(used_scheduler == RANDOMSCHED)
{
if(q[rdyhead].qnext == rdytail)
return(OK);
do
{
rand_num = rand()%100;
// kprintf("Random Number: %d",rand_num);
if(rand_num >=80)
temp_currpid = random_getpid(1);
else if(rand_num <80 && rand_num >=50)
temp_currpid = random_getpid(2);
else
temp_currpid = random_getpid(3);
}while(temp_currpid == -1);
currpid = temp_currpid;
nptr = &proctab[currpid];
dequeue(currpid);
//kprintf("\n Current PID : %d",currpid);
}
else if(used_scheduler == LINUXSCHED)
{
temp_currpid = linux_getpid();
if(temp_currpid == -1)
{
new_epoch();
temp_currpid = linux_getpid();
if(temp_currpid == -1)
{
temp_currpid=0;;
}
}
currpid = temp_currpid;
nptr = &proctab[currpid];
dequeue(currpid);
}
else
{
nptr = &proctab[ (currpid = getlast(rdytail)) ];
}
nptr->pstate = PRCURR; /* mark it currently running */
#ifdef RTCLOCK
if(used_scheduler != LINUXSCHED)
preempt = QUANTUM; /* reset preemption counter */
else
{ preempt = proctab[currpid].quantum_left;
}
#endif
ctxsw((int)&optr->pesp, (int)optr->pirmask, (int)&nptr->pesp, (int)nptr->pirmask);
/* The OLD process returns here when resumed. */
return OK;
}
