コード例 #1
0
ファイル: fs.c プロジェクト: AshishKumar4/seakernel
void fs_fsm_init(void)
{
	linkedlist_create(&fsdriverslist, LINKEDLIST_MUTEX);
	linkedlist_create(&fslist, LINKEDLIST_MUTEX);
	hash_create(&fsdrivershash, 0, 10);
	devfs = fs_filesystem_create();
	linkedlist_insert(&fslist, &devfs->listnode, devfs);
}
コード例 #2
0
ファイル: inode.c プロジェクト: AshishKumar4/seakernel
void vfs_icache_init(void)
{
	icache = hash_create(0, 0, 0x4000);

	ic_dirty = linkedlist_create(0, LINKEDLIST_MUTEX);
	ic_inuse = linkedlist_create(0, LINKEDLIST_MUTEX);
	ic_lru = queue_create(0, 0);
	ic_lock = mutex_create(0, 0);

	mm_reclaim_register(fs_inode_reclaim_lru, sizeof(struct inode));
}
コード例 #3
0
ファイル: nat.c プロジェクト: xHire/wrapsix
/**
 * Initialization of NAT tables.
 */
void nat_init(void)
{
	nat6_tcp  = radixtree_create();
	nat6_udp  = radixtree_create();
	nat6_icmp = radixtree_create();

	nat4_tcp  = radixtree_create();
	nat4_udp  = radixtree_create();
	nat4_icmp = radixtree_create();

	nat4_tcp_fragments = radixtree_create();

	timeout_icmp	  = linkedlist_create();
	timeout_udp	  = linkedlist_create();
	timeout_tcp_est	  = linkedlist_create();
	timeout_tcp_trans = linkedlist_create();
	timeout_tcp_fragments = linkedlist_create();
}
コード例 #4
0
ファイル: newhash.c プロジェクト: AshishKumar4/seakernel
int hash_insert(struct hash *h, const void *key, size_t keylen, struct hashelem *elem, void *data)
{
	__lock(h);
	size_t index = __hashfn(key, keylen, h->length);
	elem->ptr = data;
	elem->key = key;
	elem->keylen = keylen;
	if(h->table[index] == NULL) {
		/* lazy-init the buckets */
		h->table[index] = linkedlist_create(0, LINKEDLIST_LOCKLESS);
	} else {
		struct linkedentry *ent = linkedlist_find(h->table[index], __ll_check_exist, elem);
		if(ent) {
			__unlock(h);
			return -EEXIST;
		}
	}
	linkedlist_insert(h->table[index], &elem->entry, elem);
	h->count++;
	__unlock(h);
	return 0;
}
コード例 #5
0
ファイル: reclaim.c プロジェクト: AshishKumar4/seakernel
void mm_reclaim_init(void)
{
	linkedlist_create(&reclaimers, LINKEDLIST_MUTEX);
}
コード例 #6
0
int main()
{
    struct linkedlist *l;
    struct node *n, *before;

    printf("testing list create...");
    if ((l = linkedlist_create()) == NULL)
        goto fail;
    printf("[ok]\n");

    printf("testing node create...");
    if ((n = node_create('a')) == NULL)
        goto fail;
    printf("[ok]\n");

    printf("testing insert of 1st node...");
    linkedlist_insert_before(l, NULL, n);
    if (l->head != n)
        goto fail;
    printf("[ok]\n");

    printf("testing insert at head...");
    n = node_create('c');
    linkedlist_insert_before(l, l->head, n);
    if (l->head != n)
        goto fail;
    printf("[ok]\n");

    printf("testing get node...");
    before = linkedlist_get_node(l, 1);
    if (before->c != 'a')
        goto fail;
    printf("[ok]\n");

    printf("testing insert in middle...");
    n = node_create('b');
    linkedlist_insert_before(l, before, n);
    n = linkedlist_get_node(l, 1);
    if (n->c != 'b')
        goto fail;
    printf("[ok]\n");

    printf("testing count...");
    if (linkedlist_count(l) != 3)
        goto fail;
    printf("[ok]\n");

    printf("testing del...");
    linkedlist_del(l, n);
    printf("[ok]\n");

    printf("testing free...");
    linkedlist_free(l);
    printf("[ok]\n");

    return 0;

fail:
    printf("[failed]\n");
    return -1;
}
コード例 #7
0
ファイル: network.c プロジェクト: tjhsstgeek/MultiBT
int network_create() {
	struct network *n = malloc(sizeof(struct network));
	if (!n)
		return 1;
	n->users = linkedlist_create();
	if (!n->users) {
		free(n);
		return 1;
	}
	n->games = linkedlist_create();
	if (!n->games) {
		free(n->users);
		free(n);
		return 1;
	}
	n->m = SDL_CreateMutex();//I think this doesn't fail
	IPaddress ip;
	if (SDLNet_ResolveHost(&ip, 0, 3737)) {
		free(n->games);
		free(n->users);
		free(n);
		return 1;
	}
	TCPsocket m = SDLNet_TCP_Open(&ip);
	if (!m) {
		free(n->games);
		free(n->users);
		free(n);
		return 1;
	}
	while (1) {
		TCPsocket temp = SDLNet_TCP_Accept(m);
		if (temp) {
			struct network_client *nc = malloc(sizeof(struct network_client));
			if (!nc) {
				//No more memory
				SDLNet_TCP_Close(temp);
				continue;
			}
			memset(nc, 0, sizeof(struct network_client));
			nc->s = temp;
			nc->n = n;
			linkedlist_add_last(n->users,nc);
			//Send over the list of games, and their names
			linkedlist_node *ga = n->games->first;
			for (;ga;ga = ga->next) {
				struct game *g = ga->data;
				uint8_t name_len = 0;
				if (g->name) {
					uint32_t len = strlen(g->name);
					if (len > 0xff)
						name_len = 0xff;
					else
						name_len = len;
				}
				uint8_t data [262];//256 + 6
				*data = 5;
				*(data + 1) = name_len;
				//Copy the game identification
				*(uint32_t *)(data + 2) = htonl(g->ident);
				//Copy the name
				memcpy(data + 6, g->name, name_len);
				SDLNet_TCP_Send(temp, data, name_len + 6);
			}
			SDL_CreateThread(network_listen, nc);
		}
		SDL_Delay(500);
	}
	return 0;
}
コード例 #8
0
ファイル: task.c プロジェクト: AshishKumar4/seakernel
void tm_init_multitasking(void)
{
	printk(KERN_DEBUG, "[sched]: Starting multitasking system...\n");
	sysgate_page = mm_physical_allocate(PAGE_SIZE, true);
	mm_physical_memcpy((void *)sysgate_page,
				(void *)signal_return_injector, MEMMAP_SYSGATE_ADDRESS_SIZE, PHYS_MEMCPY_MODE_DEST);

	process_table = hash_create(0, 0, 128);

	process_list = linkedlist_create(0, LINKEDLIST_MUTEX);
	mutex_create(&process_refs_lock, 0);
	mutex_create(&thread_refs_lock, 0);
	
	thread_table = hash_create(0, 0, 128);

	struct thread *thread = kmalloc(sizeof(struct thread));
	struct process *proc = kernel_process = kmalloc(sizeof(struct process));

	proc->refs = 2;
	thread->refs = 1;
	hash_insert(process_table, &proc->pid, sizeof(proc->pid), &proc->hash_elem, proc);
	hash_insert(thread_table, &thread->tid, sizeof(thread->tid), &thread->hash_elem, thread);
	linkedlist_insert(process_list, &proc->listnode, proc);

	valloc_create(&proc->mmf_valloc, MEMMAP_MMAP_BEGIN, MEMMAP_MMAP_END, PAGE_SIZE, 0);
	linkedlist_create(&proc->threadlist, 0);
	mutex_create(&proc->map_lock, 0);
	mutex_create(&proc->stacks_lock, 0);
	mutex_create(&proc->fdlock, 0);
	hash_create(&proc->files, HASH_LOCKLESS, 64);
	proc->magic = PROCESS_MAGIC;
	blocklist_create(&proc->waitlist, 0, "process-waitlist");
	mutex_create(&proc->fdlock, 0);
	memcpy(&proc->vmm_context, &kernel_context, sizeof(kernel_context));
	thread->process = proc; /* we have to do this early, so that the vmm system can use the lock... */
	thread->state = THREADSTATE_RUNNING;
	thread->magic = THREAD_MAGIC;
	workqueue_create(&thread->resume_work, 0);
	thread->kernel_stack = (addr_t)&initial_kernel_stack;
	spinlock_create(&thread->status_lock);

	primary_cpu->active_queue = tqueue_create(0, 0);
	primary_cpu->idle_thread = thread;
	primary_cpu->numtasks=1;
	ticker_create(&primary_cpu->ticker, 0);
	workqueue_create(&primary_cpu->work, 0);
	tm_thread_add_to_process(thread, proc);
	tm_thread_add_to_cpu(thread, primary_cpu);
	atomic_fetch_add_explicit(&running_processes, 1, memory_order_relaxed);
	atomic_fetch_add_explicit(&running_threads, 1, memory_order_relaxed);
	set_ksf(KSF_THREADING);
	*(struct thread **)(thread->kernel_stack) = thread;
	primary_cpu->flags |= CPU_RUNNING;

#if CONFIG_MODULES
	loader_add_kernel_symbol(tm_thread_delay_sleep);
	loader_add_kernel_symbol(tm_thread_delay);
	loader_add_kernel_symbol(tm_timing_get_microseconds);
	loader_add_kernel_symbol(tm_thread_set_state);
	loader_add_kernel_symbol(tm_thread_exit);
	loader_add_kernel_symbol(tm_thread_poke);
	loader_add_kernel_symbol(tm_thread_block);
	loader_add_kernel_symbol(tm_thread_got_signal);
	loader_add_kernel_symbol(tm_thread_unblock);
	loader_add_kernel_symbol(tm_blocklist_wakeall);
	loader_add_kernel_symbol(kthread_create);
	loader_add_kernel_symbol(kthread_wait);
	loader_add_kernel_symbol(kthread_join);
	loader_add_kernel_symbol(kthread_kill);
	loader_add_kernel_symbol(tm_schedule);
	loader_add_kernel_symbol(arch_tm_get_current_thread);
#endif
}