/* module init function is called from finit_module() system call */
static int dummy_load(void)
{
printk(KERN_INFO "%s\n", __func__);
print_process_info();
return 0;
}
static void
process_killer(void)
{
int i, j, max = erts_ptab_max(&erts_proc);
Process* rp;
erts_printf("\n\nProcess Information\n\n");
erts_printf("--------------------------------------------------\n");
for (i = max-1; i >= 0; i--) {
rp = erts_pix2proc(i);
if (rp && rp->i != ENULL) {
int br;
print_process_info(ERTS_PRINT_STDOUT, NULL, rp);
erts_printf("(k)ill (n)ext (r)eturn:\n");
while(1) {
if ((j = sys_get_key(0)) <= 0)
erts_exit(0, "");
switch(j) {
case 'k': {
ErtsProcLocks rp_locks = ERTS_PROC_LOCKS_XSIG_SEND;
erts_aint32_t state;
erts_proc_inc_refc(rp);
erts_smp_proc_lock(rp, rp_locks);
state = erts_smp_atomic32_read_acqb(&rp->state);
if (state & (ERTS_PSFLG_FREE
| ERTS_PSFLG_EXITING
| ERTS_PSFLG_ACTIVE
| ERTS_PSFLG_ACTIVE_SYS
| ERTS_PSFLG_IN_RUNQ
| ERTS_PSFLG_RUNNING
| ERTS_PSFLG_RUNNING_SYS
| ERTS_PSFLG_DIRTY_RUNNING
| ERTS_PSFLG_DIRTY_RUNNING_SYS)) {
erts_printf("Can only kill WAITING processes this way\n");
}
else {
(void) erts_send_exit_signal(NULL,
NIL,
rp,
&rp_locks,
am_kill,
NIL,
NULL,
0);
}
erts_smp_proc_unlock(rp, rp_locks);
erts_proc_dec_refc(rp);
}
case 'n': br = 1; break;
case 'r': return;
default: return;
}
if (br == 1) break;
}
}
}
}
void
process_info(int to, void *to_arg)
{
int i;
for (i = 0; i < erts_max_processes; i++) {
Process *p = erts_pix2proc(i);
if (p && p->i != ENULL) {
if (!ERTS_PROC_IS_EXITING(p))
print_process_info(to, to_arg, p);
}
}
port_info(to, to_arg);
}
long test_syscall(long size, long *num_filled){
struct process_info *info_array = NULL;
if (size > 0){
info_array = malloc(sizeof(struct process_info)*size);
}
long ret = syscall(_PROCESS_ANCESTORS_, info_array, size, num_filled);
printf("size=%ld, num_filled=%ld, ret=%ld\n", size, *num_filled, ret);
if (info_array != NULL){
print_process_info(info_array, *num_filled);
free(info_array);
}
printf("\n");
return ret;
}
void
process_info(int to, void *to_arg)
{
int i, max = erts_ptab_max(&erts_proc);
for (i = 0; i < max; i++) {
Process *p = erts_pix2proc(i);
if (p && p->i != ENULL) {
/* Do not include processes with no heap,
* they are most likely just created and has invalid data
*/
if (!ERTS_PROC_IS_EXITING(p) && p->heap != NULL)
print_process_info(to, to_arg, p);
}
}
port_info(to, to_arg);
}
int main(int argc, const char* argv[])
{
int status, bg_pipes[2], num_pipes, flags;
struct sigaction act_bg_term, act_int_old, act_int_new;
/* Define handler for SIGINT (ignore) */
act_int_new.sa_handler = SIG_IGN;
act_int_new.sa_flags = 0;
if (sigaction(SIGINT, &act_int_new, &act_int_old))
perror("Failed to change handler for SIGINT");
/* Define handler for detecting background process termination */
if (SIGNAL_DETECTION == 1)
{
if (sigaction(SIGUSR1, NULL, &act_bg_term))
perror("Failed to get handler for SIGUSR1");
act_bg_term.sa_handler = sig_bg_handler;
act_bg_term.sa_flags = SA_RESTART;
if (sigaction(SIGUSR1, &act_bg_term, NULL))
perror("Failed to set handler for SIGUSR1");
}
/* Create pipe for printing background process info */
num_pipes = 1;
create_pipes(bg_pipes, num_pipes);
/* Configure pipe to be non-blocking on read end */
flags = fcntl(bg_pipes[0], F_GETFL, 0);
fcntl(bg_pipes[0], F_SETFL, flags | O_NONBLOCK);
while (1)
{
char input[80], cmd[80];
int i;
/* Wait for all defunct children */
/* Continue even if no child has exited */
if (!(SIGNAL_DETECTION == 1))
while (waitpid(-1, &status, WNOHANG | WUNTRACED) > 0);
/* Print prompt */
if (!print_prompt()) continue;
/* Exit if error occurs */
if (!fgets(input, 80, stdin))
{
perror("Failed to get input");
continue;
}
/* Remove newline, if present */
i = strlen(input) - 1;
if (input[i] == '\n') input[i] = '\0';
/* Read given commands */
i = 0; /* Input index */
i = read_cmd(cmd, input, i);
if (strcmp(cmd, "exit") == 0)
break;
else if (strcmp(cmd, "cd") == 0)
cd(input, cmd, i);
else if (strcmp(cmd, "checkEnv") == 0)
check_env(input, i);
else if (cmd[0] == '\0') {} /* Just print process info */
else
general_cmd(input, &act_int_old, bg_pipes);
/* Print accumulated process information */
print_process_info(bg_pipes);
}
/* Close pipe for printing background process info */
close_pipes(bg_pipes, num_pipes);
exit_shell();
return 0;
}
void *consumer_function(void *arg){
int cpu_num = (int) arg;
consumer_t *cpu = &cpus[cpu_num];
cpu_queue_t *cpu_queue;
process_info_t task;
long start_time, end_time;
int execution_time;
int sleep_avg;
printf("Hi i'm the consumer %d\n", cpu_num);
while(!thread_finished || cpu->size !=0){
//CRITICAL SECTION
pthread_mutex_lock(&cpu->mutex);
if (cpu->ready_queue[0].size > 0) {
cpu_queue = &cpu->ready_queue[0];
task = cpu_queue->queue[cpu_queue->head];
cpu_queue->head = (cpu_queue->head + 1) % Q_CAPACITY;
cpu_queue->size--;
} else if (cpu->ready_queue[1].size > 0) {
task = get_max_priority(&cpu->ready_queue[1]);
} else if (cpu->ready_queue[2].size > 0) {
task = get_max_priority(&cpu->ready_queue[2]);
} else {
pthread_mutex_unlock(&cpu->mutex);
sleep(1);
continue;
}
cpu->size--;
pthread_mutex_unlock(&cpu->mutex);
if (task.scheduling_type == NORM) {
start_time = time_in_millis();
sleep_avg = (start_time - task.last_execution) / 200;
task.sleep_avg = min(10, sleep_avg + task.sleep_avg);
}
if (task.scheduling_type == FIFO)
execution_time = task.expected_execution_time;
else
execution_time = min(quantum(task.static_priority), task.expected_execution_time - task.accumulated_execution_time);
int io_operation = task.scheduling_type == RR && rand() % 2;
if (io_operation) execution_time = 10; // I/O Wait
start_time = time_in_millis();
usleep(execution_time * 1000);
end_time = time_in_millis();
task.accumulated_execution_time += end_time - start_time;
printf("The following process was selected by cpu: %d to run for %dms\n", cpu_num, execution_time);
print_process_info(task);
if (io_operation) {
printf("I/O Operation In Progress for process %d\n", task.pid);
usleep(1200 * 1000); // I/O Wait
}
sleep(1); // Prevents rediculous output speeds.
task.last_cpu = cpu_num;
if (task.accumulated_execution_time < task.expected_execution_time) {
if (task.scheduling_type == NORM) {
printf("Process %d updated the dynamic priority from %d to ", task.pid, task.dynamic_priority);
sleep_avg = (end_time - start_time) / 200;
task.sleep_avg = max(0, task.sleep_avg - sleep_avg);
task.dynamic_priority = max(100, min(139, task.dynamic_priority - task.sleep_avg + 5));
printf("%d.\n", task.dynamic_priority);
}
//CRITICAL SECTION
pthread_mutex_lock(&cpu->mutex);
if (task.dynamic_priority < 100)
cpu_queue = &cpu->ready_queue[0];
else if (task.dynamic_priority < 130)
cpu_queue = &cpu->ready_queue[1];
else
cpu_queue = &cpu->ready_queue[2];
cpu_queue->queue[cpu_queue->tail] = task;
cpu_queue->tail = (cpu_queue->tail + 1) % Q_CAPACITY;
cpu_queue-> size++;
cpu->size++;
pthread_mutex_unlock(&cpu->mutex);
continue;
}
printf("CPU %d finished process %d in %d ms\n",
cpu_num,
task.pid,
task.accumulated_execution_time);
}
thread_finished += 1;
printf("CPU %d Exiting\n", cpu_num);
pthread_exit(NULL);
}
