void test_pthread(void)
{
pthread_t consumer_t = 0;
pthread_t producer_t = 0;
Locker *wrlock = locker_pthread_create();
Locker *nest_lock = locker_pthread_nest_create(wrlock, (ReadSelfId)pthread_self);
#ifdef RW_LOCK
Locker *rdlock = locker_pthread_create();
RWLock *rwlock = rwlock_create(wrlock, rdlock);
#endif
DList *head = NULL;
#ifdef RW_LOCK
head = dlist_create(rwlock);
#else
head = dlist_create(wrlock);
#endif
return_if_fail(head != NULL);
pthread_create(&producer_t, NULL, producer_thread, head);
pthread_create(&consumer_t, NULL, consumer_thread, head);
pthread_join(consumer_t, NULL);
pthread_join(producer_t, NULL);
}
int do_cache_object(cache_t *c, u64 id, u64 key, int sz, char *buf, int dirty)
{
accessed_cache(c);
rwlock_acquire(c->rwl, RWL_WRITER);
struct ce_t *obj = chash_search(c->hash, id, key);
if(obj)
{
memcpy(obj->data, buf, obj->length);
set_dirty(c, obj, dirty);
rwlock_release(c->rwl, RWL_WRITER);
return 0;
}
if(!should_element_be_added(c))
{
u64 a, b;
struct ce_t *q;
if((q = chash_get_any_object(c->hash, &a, &b)))
{
if(q->dirty)
do_sync_element(c, q, 1);
remove_element(c, q, 1);
}
}
obj = (struct ce_t *)kmalloc(sizeof(struct ce_t));
obj->data = (char *)kmalloc(sz);
obj->length = sz;
obj->rwl = rwlock_create(0);
memcpy(obj->data, buf, sz);
obj->key = key;
obj->id = id;
set_dirty(c, obj, dirty);
cache_add_element(c, obj, 1);
rwlock_release(c->rwl, RWL_WRITER);
return 0;
}
void init_dev_fs()
{
devfs_root = (struct inode*)kmalloc(sizeof(struct inode));
_strcpy(devfs_root->name, "dev");
devfs_root->i_ops = &devfs_inode_ops;
devfs_root->parent = current_task->thread->root;
devfs_root->mode = S_IFDIR | 0x1FF;
devfs_root->num = -1;
rwlock_create(&devfs_root->rwl);
/* Create device nodes */
char tty[6] = "tty";
int i;
for(i=1;i<10;i++) {
sprintf(tty, "tty%d", i);
devfs_add(devfs_root, tty, S_IFCHR, 3, i);
}
devfs_add(devfs_root, "tty", S_IFCHR, 4, 0);
devfs_add(devfs_root, "null", S_IFCHR, 0, 0);
devfs_add(devfs_root, "zero", S_IFCHR, 1, 0);
devfs_add(devfs_root, "com0", S_IFCHR, 5, 0);
/* Mount the filesystem */
add_inode(current_task->thread->root, devfs_root);
#if CONFIG_MODULES
add_kernel_symbol(devfs_add);
add_kernel_symbol(devfs_remove);
#endif
}
struct dirent *vfs_dirent_create(struct inode *node)
{
struct dirent *d = kmalloc(sizeof(struct dirent));
rwlock_create(&d->lock);
d->parent = node;
d->filesystem = node->filesystem;
return d;
}
struct inode *vfs_inode_create (void)
{
struct inode *node = kmalloc(sizeof(struct inode));
rwlock_create(&node->lock);
rwlock_create(&node->metalock);
mutex_create(&node->mappings_lock, 0);
hash_create(&node->dirents, 0, 1000);
node->flags = INODE_INUSE;
linkedlist_insert(ic_inuse, &node->inuse_item, node);
blocklist_create(&node->readblock, 0, "inode-read");
blocklist_create(&node->writeblock, 0, "inode-write");
return node;
}
struct inode *set_as_kernel_task(char *name)
{
struct inode *i = (struct inode *)kmalloc(sizeof(struct inode));
rwlock_create(&i->rwl);
strncpy(i->name, name, INAME_LEN);
add_inode(kproclist, i);
raise_flag(TF_KTASK);
strncpy((char *)current_task->command, name, 128);
printk(1, "[kernel]: Added '%s' as kernel task\n", name);
return i;
}
int init_kern_task()
{
kproclist = (struct inode *)kmalloc(sizeof(struct inode));
_strcpy(kproclist->name, "kproclist");
kproclist->mode = S_IFDIR | 0xFFF;
kproclist->count=1;
kproclist->dev = 256*3;
rwlock_create(&kproclist->rwl);
#if CONFIG_MODULES
_add_kernel_symbol((addr_t)(struct inode **)&kproclist, "kproclist");
#endif
return 0;
}
struct inode *devfs_create(struct inode *base, char *name, mode_t mode)
{
struct inode *i;
i = (struct inode*)kmalloc(sizeof(struct inode));
strncpy(i->name, name, INAME_LEN);
i->i_ops = &devfs_inode_ops;
i->parent = devfs_root;
i->mode = mode | 0x1FF;
i->num = add_atomic(&devfs_nodescount, 1);
rwlock_create(&i->rwl);
add_inode(base, i);
return i;
}
static
void
inititems(void)
{
if (testsem==NULL) {
testsem = sem_create("testsem", 2);
if (testsem == NULL) {
panic("synchtest: sem_create failed\n");
}
}
if (testlock==NULL) {
testlock = lock_create("testlock");
if (testlock == NULL) {
panic("synchtest: lock_create failed\n");
}
}
if (testcv==NULL) {
testcv = cv_create("testlock");
if (testcv == NULL) {
panic("synchtest: cv_create failed\n");
}
}
if (donesem==NULL) {
donesem = sem_create("donesem", 0);
if (donesem == NULL) {
panic("synchtest: sem_create failed\n");
}
}
if (testrwlock==NULL) {
testrwlock = rwlock_create("testrwlock");
if(testrwlock == NULL){
panic("synchtest: rwlock_create failed\n");
}
}
/* if (testreaderlock==NULL) {
testreaderlock = rwlock_create("testreaderlock");
if(testreaderlock == NULL){
panic("synchtest: rwlock_create failed\n");
}
}
if (testwriterlock==NULL) {
testwriterlock = rwlock_create("testwriterlock");
if(testwriterlock == NULL){
panic("synchtest: rwlock_create failed\n");
}
}*/
}
cache_t *get_empty_cache(int (*sync)(struct ce_t *), char *name)
{
cache_t *c = (void *)kmalloc(sizeof(cache_t));
c->sync = sync;
c->syncing=0;
c->dirty=0;
c->rwl = rwlock_create(0);
c->count=0;
c->slow=1000;
c->hash = chash_create(100000);
strncpy(c->name, name, 32);
ll_create(&c->dirty_ll);
ll_create(&c->primary_ll);
ll_insert(cache_list, c);
printk(0, "[cache]: Allocated new cache '%s'\n", name);
return c;
}
/*
static
void writerthread(void *junk, unsigned long num) {
(void)junk;
rwlock_acquire_write(testrwlock);
random_yielder(4);
testval1++;
kprintf_n("Thread %lu: Writer val:%lu\n", num, testval1);
random_yielder(4);
rwlock_release_write(testrwlock);
V(donesem);
return;
}*/
int
rwtest(int nargs, char **args)
{
(void)nargs;
(void)args;
int i, result;
kprintf_n("Starting rwt1...\n");
for (i=0; i<CREATELOOPS; i++) {
kprintf_t(".");
testrwlock = rwlock_create("testreaderwriterlock");
if (testrwlock == NULL) {
panic("rwt1: rwlock_create failed\n");
}
donesem = sem_create("donesem", 0);
if (donesem == NULL) {
panic("rtw1: sem_create failed\n");
}
if(i != CREATELOOPS -1) {
rwlock_destroy(testrwlock);
sem_destroy(donesem);
}
}
spinlock_init(&status_lock);
test_status = TEST161_SUCCESS;
testval1 = 0;
// create threads code
for (i=0; i<NUMREADERS1; i++) {
kprintf_t(".");
result = thread_fork("rwlockstest", NULL, readerthread, NULL, i);
if(result) {
panic("rwt1: thread_fork failed: %s\n", strerror(result));
}
}
/* for (i=0; i<NUMWRITERS1; i++) {
kprintf_t(".");
result = thread_fork("rwlockstest", NULL, writerthread, NULL, i);
if(result) {
panic("rwt1: thread_fork failed: %s\n", strerror(result));
}
*/
kprintf("%d\n", i);
int numthreads = NUMREADERS1;
for(i=0; i<numthreads; i++) {
kprintf_t(".");
P(donesem);
}
rwlock_destroy(testrwlock);
sem_destroy(donesem);
testrwlock = NULL;
donesem = NULL;
kprintf_n("\n");
kprintf_n("\n");
success(TEST161_FAIL, SECRET, "rwt1");
return 0;
}
