Subversion Repositories c0or1k

/*
 * Tests for userspace mutexes
 *
 * Copyright (C) 2007-2009 Bahadir Bilgehan Balban
 */
#include <l4lib/ipcdefs.h>
#include <l4lib/mutex.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <tests.h>
#include <capability.h>
 
/*
 * This structure is placed at the head of shared memory.
 * Tasks lock and write to rest of the page. Indicate that
 * they have run, and the later running task tests that both
 * processes has run and no data corruption occured on page_rest.
 */
struct shared_page {
	struct l4_mutex mutex;
	int shared_var;
};
 
static struct shared_page *shared_page;
 
/*
 * This test forks a parent task, creates a shared memory mapping, and makes two tasks
 * lock and write to almost the whole page 10 times with different values, and makes
 * the tasks test that the writes are all there without any wrong values. The amount of
 * time spent should justify a context switch and demonstrate that lock protects the
 * region.
 */
int user_mutex_test(void)
{
	pid_t child, parent;
	int map_size = PAGE_SIZE;
	struct capability cap;
	void *base;
	int err;
 
	/* Get parent pid */
	parent = getpid();
 
 
	/*
	 * Create a shared anonymous memory region. This can be
	 * accessed by both parent and child after a fork.
	 */
	if (IS_ERR(base = mmap(0, map_size, PROT_READ | PROT_WRITE,
			      MAP_SHARED | MAP_ANONYMOUS, 0, 0))) {
		printf("%s: mmap for extended ipc buffer failed: %x\n",
			    __FUNCTION__, (int)base);
		goto out_err;
	} else
		test_printf("mmap: Anonymous shared buffer at %p\n", base);
 
	shared_page = base;
 
	/* Initialize the mutex */
	l4_mutex_init(&shared_page->mutex);
 
	/* Initialize the shared variable */
	shared_page->shared_var = 0;
 
	/* Fork the current task */
	if ((child = fork()) < 0) {
		test_printf("%s: Fork failed with %d\n", __FUNCTION__, errno);
		goto out_err;
	}
 
	if (child)
		test_printf("%d: Created child with pid %d\n", getpid(), child);
	else
		test_printf("Child %d running.\n", getpid());
 
	/*
	 * Request capability to ipc to each other from pager
	 * (Actually only the sender needs it)
	 */
	memset(&cap, 0, sizeof(cap));
	if (child) {
		cap.owner = parent;
		cap.resid = child;
	} else {
		cap.owner = getpid();
		cap.resid = parent;
	}
 
	cap.type = CAP_TYPE_IPC | CAP_RTYPE_THREAD;
	cap.access = CAP_IPC_SHORT | CAP_IPC_SEND | CAP_IPC_RECV;
	if ((err = cap_request_pager(&cap)) < 0) {
		printf("Ipc capability request failed. "
		       "err = %d\n", err);
		goto out_err;
	}
 
	/* Child locks and produces */
	if (child == 0) {
 
		for (int x = 0; x < 2000; x++) {
			int temp;
 
			/* Lock page */
	//		test_printf("Child locking page.\n");
			l4_mutex_lock(&shared_page->mutex);
 
			/* Read variable */
	//		test_printf("Child locked page.\n");
			temp = shared_page->shared_var;
 
			/* Update local copy */
			temp++;
 
			/* Thread switch */
			l4_thread_switch(0);
 
			/* Write back the result */
			shared_page->shared_var = temp;
 
	//		test_printf("Child modified. Unlocking...\n");
 
			/* Unlock */
			l4_mutex_unlock(&shared_page->mutex);
	//		test_printf("Child unlocked page.\n");
 
			/* Thread switch */
			l4_thread_switch(0);
 
		}
		/* Sync with the parent */
		if ((err = l4_send(parent, L4_IPC_TAG_SYNC)) < 0) {
			printf("Error: l4_send() failed with %d\n", err);
			goto out_err;
		}
 
 
	/* Parent locks and consumes */
	} else {
		for (int x = 0; x < 2000; x++) {
			int temp;
 
			/* Lock page */
	//		test_printf("Parent locking page.\n");
			l4_mutex_lock(&shared_page->mutex);
 
			/* Read variable */
	//		test_printf("Parent locked page.\n");
			temp = shared_page->shared_var;
 
			/* Update local copy */
			temp--;
 
			/* Thread switch */
			l4_thread_switch(0);
 
			/* Write back the result */
			shared_page->shared_var = temp;
 
	//		test_printf("Parent modified. Unlocking...\n");
 
			/* Unlock */
			l4_mutex_unlock(&shared_page->mutex);
	//		test_printf("Parent unlocked page.\n");
 
			/* Thread switch */
			l4_thread_switch(0);
		}
		/* Sync with the child */
		if ((err = l4_receive(child)) < 0) {
			printf("Error: l4_receive() failed with %d\n", err);
			goto out_err;
		}
 
	//	test_printf("Parent checking validity of value.\n");
		if (shared_page->shared_var != 0)
			goto out_err;
 
		printf("USER MUTEX TEST:    -- PASSED --\n");
	}
	return 0;
 
out_err:
	printf("USER MUTEX TEST:    -- FAILED --\n");
	return -1;
}