/*
* This test creates a sender and a receiver process. The sender process
* has the higher priority and will be scheduled first.
* The execution sequence is as follow:
* 1. The sender executes a send(). Since the receiver is not RECEIVE_BLOCKED,
* the sender will be SEND_BLOCKED.
* 2. Execution resumes with the receiver. The receiver executes a receive(),
* which will return immediately, and change the sender to state
* REPLY_BLOCKED.
* 3. The receivers does a reply(), and put the sender back on the ready queue.
* The resign() in the reply() will therefore transfer the control back to
* the sender.
* 4. The sender executes a message(). Since the receiver is not
* RECEIVE_BLOCKED, the sender will be MESSAGE_BLOCKED.
* 5. Execution resumes with the receiver. The receiver executes a receive(),
* which will return immediately, and change the sender to STATE_READY.
* 6. The receiver does a resign() and pass the execution back to the sender.
* This test send() and message() in the case that the receiver is not
* ready to receive. It also test receive() in the case that there are messages
* pending.
*/
void test_ipc_2 ()
{
PORT new_port;
test_reset();
new_port = create_process (test_ipc_2_receiver_process, 5, 0, "Receiver");
create_process (test_ipc_2_sender_process, 6, (PARAM) new_port, "Sender");
check_num_proc_on_ready_queue(3);
check_process("Sender", STATE_READY, TRUE);
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0)
test_failed(test_result);
resign();
}
void * verify_black_proces_activity(void *arg)
{
while (1) {
check_process(arg);
}
return NULL;
}
void test_ipc_6_sender_process_1(PROCESS self, PARAM param)
{
PORT receiver_port = (PORT) param;
int data = 11;
check_process("Receiver", STATE_RECEIVE_BLOCKED, FALSE);
check_process("Sender 3", STATE_MESSAGE_BLOCKED, FALSE);
check_process("Sender 2", STATE_MESSAGE_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: sending a message to port 1...", self->name);
send(receiver_port, &data);
test_failed(40);
}
void test_ipc_6_sender_process_3(PROCESS self, PARAM param)
{
PORT receiver_port = (PORT) param;
int data = 33;
check_process("Receiver", STATE_RECEIVE_BLOCKED, FALSE);
check_process("Sender 2", STATE_READY, TRUE);
check_process("Sender 1", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: sending a message to port 3...\n", self->name);
message(receiver_port, &data);
test_failed(37);
}
void test_ipc_3_sender_process(PROCESS self, PARAM param)
{
PORT receiver_port = (PORT) param;
int data1= 42;
int data2= 24;
check_sum += 1;
/*
* send the first message
*/
check_process("Receiver", STATE_RECEIVE_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(48);
}
kprintf("%s: sending a message using send()...\n",
self->name);
send(receiver_port, &data1);
if (check_sum != 3)
test_failed(49);
check_sum += 4;
kprintf("%s: received = %d\n", self->name, data1);
if (data1 != 11)
test_failed(41);
/*
* send the second message
*/
kprintf("%s: sending a message using message()...\n",
self->name);
message(receiver_port, &data2);
if (check_sum != 15)
test_failed(54);
kprintf("%s: woken up from message()\n", self->name);
return_to_boot();
}
void child_handler(int signum)
{
int pid;
pid = waitpid(-1, NULL, WNOHANG);
if(pid != -1)
{
int p = check_process(pid),i;
if(proc[p].proc_run)
{
printf("\n%s ",proc[p].proc_name);
for(i=1;i<proc[p].proc_num_args-1;i++)
printf("%s ",proc[p].proc_args[i]);
printf("%d exited normally\n",proc[p].proc_pid);
proc[p].proc_run = 0;
}
}
signal(SIGCHLD, child_handler);
return;
}
int main(int argc, char **argv)
{
int rc = 0;
parse_options(argc, argv);
check_process();
check_libelf_version();
setup_signals();
if (!stack_size)
setup_stack_size();
rc = !opt_ptrace ?
backtrace_snapshot(pid, tid_list, tid_index, nr_tids) :
backtrace_ptrace(pid, tid_list, tid_index, nr_tids);
summary();
return (rc != 0);
}
int get_list(t_list_proc** list, const char* process_name)
{
DIR* dir;
struct dirent* dirent;
int ret;
delete_list(*list);
*list = 0;
dir = opendir("/proc/");
if (dir == 0)
return fatal(2, strerror(errno), 1);
dirent = (struct dirent*)1;
while (dirent != 0)
{
dirent = readdir(dir);
if (dirent != 0 && (dirent->d_name[0] >= '0' && dirent->d_name[0] <= '9'))
{
ret = check_process(dirent->d_name, process_name);
if (ret == -1)
break;
else if (ret == 0)
{
if (add_proc_to_list(list, dirent->d_name))
{
ret = 1;
break;
}
}
}
else if (errno != 0 && errno != ENOENT)
ret = fatal(2, strerror(errno), -1);
else
ret = 0;
}
if (closedir(dir))
ret = fatal(2, strerror(errno), -1);
return ret;
}
/*
* We don't explicitly create a new process, but because of init_process()
* and init_dispatcher(), the main thread should be initialized as a process
* and be added to the ready queue.
* This also test print_all_processes()
*/
void test_create_process_1()
{
test_reset();
print_all_processes(kernel_window);
//check if the boot process is initialized correctly.
check_create_process(boot_name, 1, NULL, 0);
if (test_result != 0)
test_failed(test_result);
check_num_of_pcb_entries(1);
if (test_result != 0)
test_failed(test_result);
check_process(boot_name, STATE_READY, TRUE);
if (test_result != 0)
test_failed(test_result);
check_num_proc_on_ready_queue(1);
if (test_result != 0)
test_failed(test_result);
}
void test_ipc_3_receiver_process(PROCESS self, PARAM param)
{
PROCESS sender;
int* data;
check_sum = 0;
/*
* receive the first message
*/
check_process("Sender", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: receiving the first message...\n", self->name);
data = (int*) receive (&sender);
if (check_sum != 1)
test_failed(47);
kprintf("%s: received a message from %s, parameter = %d\n",
self->name, sender->name, *data);
check_sum += 2;
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(53);
}
// Sender should now be REPLY_BLOCKED and off ready queue
check_process("Sender", STATE_REPLY_BLOCKED, FALSE);
if (test_result == 13) {
print_all_processes(kernel_window);
test_failed(50);
}
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(51);
}
if (*data != 42)
test_failed(41);
*data = 11;
reply(sender);
/*
* receive the sencond message
*/
kprintf("%s: receiving the second message...\n", self->name);
data = (int*) receive(&sender);
if (check_sum != 7)
test_failed(47);
kprintf("%s: received a message from %s, parameter = %d\n",
self->name, sender->name, *data);
check_sum += 8;
// Sender should now be STATE_READY and on ready queue
check_process("Sender", STATE_READY, TRUE);
if (test_result == 13) {
print_all_processes(kernel_window);
test_failed(55);
}
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(57);
}
if (*data == 11)
test_failed(44);
if (*data != 24)
test_failed(41);
/* We do the third receive. Since there is no message pending,
* this process will become RECEIVE_BLOCKED so that the sender
* will continue to run. */
data = (int*) receive(&sender);
test_failed(47);
}
/*
* proc_listpidspath
*
* in : type
* : typeinfo
* : path
* : pathflags
* : buffer
* : buffersize
* out : buffer filled with process IDs that have open file
* references that match the specified path or volume;
* return value is the bytes of the returned buffer
* that contains valid information.
*/
int
proc_listpidspath(uint32_t type,
uint32_t typeinfo,
const char *path,
uint32_t pathflags,
void *buffer,
int buffersize)
{
int buf_used;
int *buf_next = (int *)buffer;
int i;
fdOpenInfoRef info;
int status = -1;
if (buffer == NULL) {
// if this is a sizing request
return proc_listpids(type, typeinfo, NULL, 0);
}
buffersize -= (buffersize % sizeof(int)); // make whole number of ints
if (buffersize < sizeof(int)) {
// if we can't even return a single PID
errno = ENOMEM;
return -1;
}
// init
info = check_init(path, pathflags);
if (info == NULL) {
return -1;
}
// get list of processes
buf_used = proc_listpids(type, typeinfo, NULL, 0);
if (buf_used <= 0) {
goto done;
}
while (1) {
if (buf_used > info->pids_size) {
// if we need to allocate [more] space
while (buf_used > info->pids_size) {
info->pids_size += (sizeof(int) * 32);
}
if (info->pids == NULL) {
info->pids = malloc(info->pids_size);
} else {
info->pids = reallocf(info->pids, info->pids_size);
}
if (info->pids == NULL) {
goto done;
}
}
buf_used = proc_listpids(type, typeinfo, info->pids, info->pids_size);
if (buf_used <= 0) {
goto done;
}
if ((buf_used + sizeof(int)) >= info->pids_size) {
// if not enough room in the buffer for an extra pid
buf_used = info->pids_size + sizeof(int);
continue;
}
info->pids_count = buf_used / sizeof(int);
break;
}
// iterate through each process
buf_used = 0;
for (i = info->pids_count - 1; i >= 0; i--) {
int pid;
int status;
pid = info->pids[i];
if (pid == 0) {
continue;
}
status = check_process(info, pid);
if (status != 1) {
// if not a match
continue;
}
*buf_next++ = pid;
buf_used += sizeof(int);
if (buf_used >= buffersize) {
// if we have filled the buffer
break;
}
}
status = buf_used;
done :
// cleanup
check_free(info);
return status;
}
void test_ipc_2_receiver_process (PROCESS self, PARAM param)
{
PROCESS sender;
int* data;
/*
* receiving the first message
*/
check_sum += 1;
// Sender should now be SEND_BLOCKED and off read queue
check_process("Sender", STATE_SEND_BLOCKED, FALSE);
if (test_result == 13) {
print_all_processes(kernel_window);
test_failed(35);
}
if (test_result == 14) {
print_all_processes(kernel_window);
test_failed(36);
}
kprintf("%s: receiving first message...\n", self->name);
data = (int*) receive (&sender);
// check the processes
// Sender should now be REPLY_BLOCKED and off read queue
check_process("Sender", STATE_REPLY_BLOCKED, FALSE);
if (test_result == 13) {
print_all_processes(kernel_window);
test_failed(38);
}
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: received a message from %s, parameter = %d\n",
self->name, sender->name, *data);
if (*data != 42)
test_failed(41);
*data = 11;
kprintf("%s: replying to %s.\n", self->name, sender->name);
reply(sender);
if (check_sum != 3)
test_failed(40);
/*
* receiving the second message
*/
check_sum += 4;
// Sender should now be MESSAGE_BLOCKED and off read queue
check_process("Sender", STATE_MESSAGE_BLOCKED, FALSE);
if (test_result == 13) {
print_all_processes(kernel_window);
test_failed(43);
}
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(36);
}
kprintf("%s: receiving second message...\n", self->name);
data = (int*) receive (&sender);
if (*data == 11)
test_failed(44); //the first message is received again
// Sender should now be STATE_READY and on read queue
check_process("Sender", STATE_READY, TRUE);
if (test_result == 13) {
print_all_processes(kernel_window);
test_failed(45);
}
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(46);
}
kprintf("%s: received a message from %s, parameter = %d\n",
self->name, sender->name, *data);
if (*data != 24)
test_failed(41);
resign();
test_failed(46);
}
void test_ipc_2_sender_process(PROCESS self, PARAM param)
{
PORT receiver_port = (PORT) param;
int data1 = 42;
int data2 = 24;
check_sum = 0;
/*
* send first message
*/
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: sending a message using send()...\n",
self->name);
send(receiver_port, &data1);
if (check_sum != 1)
test_failed(37);
kprintf("%s: received data = %d\n", self->name, data1);
if (data1 != 11)
test_failed(42);
/*
* send second message
*/
check_sum += 2;
check_process("Sender", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(39);
}
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: sending a message using message()...\n",
self->name);
message(receiver_port, &data2);
if (check_sum != 7)
test_failed(37);
kprintf("%s: woken up from message().\n", self->name);
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0)
test_failed(test_result);
check_sum += 8;
return_to_boot();
}
void test_ipc_6_receiver(PROCESS self, PARAM param)
{
PORT port1;
PORT port2;
PORT port3;
PROCESS sender_1;
PROCESS sender_2;
PROCESS sender_3;
int second_sender;
int *data1;
int *data2;
int *data3;
check_sum += 1;
port1 = self->first_port;
kprintf("%s: creating port 3 and port 2...\n", self->name);
port3 = create_port();
port2 = create_port();
kprintf("%s: closing port 3 and port 2...\n", self->name);
close_port(port2);
close_port(port3);
check_port(port1, self->name, TRUE);
check_port(port2, self->name, FALSE);
check_port(port3, self->name, FALSE);
if (test_result != 0)
test_failed(test_result);
create_process(test_ipc_6_sender_process_3, 5, (PARAM) port3, "Sender 3");
create_process(test_ipc_6_sender_process_2, 5, (PARAM) port2, "Sender 2");
create_process(test_ipc_6_sender_process_1, 4, (PARAM) port1, "Sender 1");
/*
* receive first message
*/
kprintf("%s: receiving first message...\n", self->name);
data1 = (int*) receive(&sender_1);
kprintf("\n%s: received a message from %s, parameter = %d.\n",
self->name, sender_1->name, * data1);
if (string_compare(sender_1->name, "Sender 2") == 1)
test_failed(60);
if (string_compare(sender_1->name, "Sender 3") == 1)
test_failed(60);
if (string_compare(sender_1->name, "Sender 1") != 1)
test_failed(58);
check_process("Sender 3", STATE_MESSAGE_BLOCKED, FALSE);
check_process("Sender 2", STATE_MESSAGE_BLOCKED, FALSE);
check_process("Sender 1", STATE_REPLY_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
/*
* receive second message
*/
kprintf("%s: opening port 2 and port 3...\n", self->name);
open_port(port2);
open_port(port3);
check_sum += 2; // to check that first message is receiverd.
kprintf("%s: receiving second message...\n", self->name);
data2 = (int*) receive (&sender_2);
kprintf("%s: received a message from %s, parameter = %d.\n",
self->name, sender_2->name, * data2);
// second message can be from either sender 2 or sender 3, depending
// on implementation of create_port().
second_sender = 0;
if (string_compare(sender_2->name, "Sender 2") == 1) {
check_process("Sender 2", STATE_READY, TRUE);
check_process("Sender 3", STATE_MESSAGE_BLOCKED, FALSE);
second_sender = 2;
} else if (string_compare(sender_2->name, "Sender 3") == 1) {
check_process("Sender 3", STATE_READY, TRUE);
check_process("Sender 2", STATE_MESSAGE_BLOCKED, FALSE);
second_sender = 3;
} else
test_failed(44);
check_sum += 4; // to check that second message is received.
/*
* receive third message
*/
kprintf("%s: receiving third message...\n", self->name);
data3 = (int*) receive(&sender_3);
kprintf("%s: received a message from %s, parameter = %d.\n",
self->name, sender_3->name, * data3);
if (string_compare(sender_3->name, "Sender 1") == 1)
test_failed(44);
if (second_sender == 2) {
if (string_compare(sender_3->name, "Sender 2") == 1)
test_failed(44);
if (string_compare(sender_3->name, "Sender 3") != 1)
test_failed(58);
} else {
if (string_compare(sender_3->name, "Sender 3") == 1)
test_failed(44);
if (string_compare(sender_3->name, "Sender 2") != 1)
test_failed(58);
}
check_process("Sender 3", STATE_READY, TRUE);
check_process("Sender 2", STATE_READY, TRUE);
check_process("Sender 1", STATE_REPLY_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
check_sum += 8; // to check that third message is received.
return_to_boot();
}
