URL https://opencores.org/ocsvn/c0or1k/c0or1k/trunk

Subversion Repositories c0or1k

[/] [c0or1k/] [trunk/] [conts/] [posix/] [mm0/] [main.c] - Blame information for rev 2

Details | Compare with Previous | View Log


/*
 * mm0. Pager for all tasks.
 *
 * Copyright (C) 2007 Bahadir Balban
 */
#include <stdio.h>
#include <init.h>
#include L4LIB_INC_ARCH(utcb.h)
#include L4LIB_INC_ARCH(syscalls.h)
#include L4LIB_INC_ARCH(syslib.h)
#include <l4lib/kip.h>
#include <l4lib/utcb.h>
#include <l4lib/ipcdefs.h>
#include <l4lib/types.h>
#include <l4/api/thread.h>
#include <l4/api/space.h>
#include <l4/api/ipc.h>
#include <l4/api/errno.h>
#include <vm_area.h>
#include <syscalls.h>
#include <file.h>
#include <shm.h>
#include <mmap.h>
#include <test.h>
#include <capability.h>
#include <globals.h>
 
/* Receives all registers and origies back */
int ipc_test_full_sync(l4id_t senderid)
{
        for (int i = MR_UNUSED_START; i < MR_TOTAL + MR_REST; i++) {
        //      printf("%s/%s: MR%d: %d\n", __TASKNAME__, __FUNCTION__,
        //             i, read_mr(i));
                /* Reset it to 0 */
                write_mr(i, 0);
        }
 
        /* Send a full origy */
        l4_send_full(senderid, 0);
        return 0;
}
 
void handle_requests(void)
{
        /* Generic ipc data */
        u32 mr[MR_UNUSED_TOTAL];
        l4id_t senderid;
        struct tcb *sender;
        u32 tag;
        int ret;
 
        // printf("%s: Initiating ipc.\n", __TASKNAME__);
        if ((ret = l4_receive(L4_ANYTHREAD)) < 0) {
                printf("%s: %s: IPC Error: %d. Quitting...\n", __TASKNAME__,
                       __FUNCTION__, ret);
                BUG();
        }
 
        /* Syslib conventional ipc data which uses first few mrs. */
        tag = l4_get_tag();
        senderid = l4_get_sender();
 
        if (!(sender = find_task(senderid))) {
                l4_ipc_return(-ESRCH);
                return;
        }
 
        /* Read mrs not used by syslib */
        for (int i = 0; i < MR_UNUSED_TOTAL; i++)
                mr[i] = read_mr(MR_UNUSED_START + i);
 
        switch(tag) {
        case L4_IPC_TAG_SYNC_FULL:
                ret = ipc_test_full_sync(senderid);
                return;
        case L4_IPC_TAG_SYNC:
                mm0_test_global_vm_integrity();
                // printf("%s: Synced with waiting thread.\n", __TASKNAME__);
                /* This has no receive phase */
                return;
 
        case L4_IPC_TAG_UNDEF_FAULT:
                /* Undefined instruction fault. Ignore. */
                // printf("Undefined instruction fault caught.\n");
                ret = 0;
                break;
        case L4_IPC_TAG_PFAULT: {
                struct page *p;
 
                /* Handle page fault. */
                if (IS_ERR(p = page_fault_handler(sender, (fault_kdata_t *)&mr[0])))
                        ret = (int)p;
                else
                        ret = 0;
                break;
        }
        case L4_REQUEST_CAPABILITY: {
                ret = sys_request_cap(sender, (struct capability *)mr[0]);
                break;
        }
        case L4_IPC_TAG_SHMGET: {
                ret = sys_shmget((key_t)mr[0], (int)mr[1], (int)mr[2]);
                break;
        }
 
        case L4_IPC_TAG_SHMAT: {
                ret = (int)sys_shmat(sender, (l4id_t)mr[0], (void *)mr[1], (int)mr[2]);
                break;
        }
 
        case L4_IPC_TAG_SHMDT:
                ret = sys_shmdt(sender, (void *)mr[0]);
                break;
 
        case L4_IPC_TAG_READ:
                ret = sys_read(sender, (int)mr[0], (void *)mr[1], (int)mr[2]);
                break;
 
        case L4_IPC_TAG_WRITE:
                ret = sys_write(sender, (int)mr[0], (void *)mr[1], (int)mr[2]);
                break;
 
        case L4_IPC_TAG_CLOSE:
                ret = sys_close(sender, (int)mr[0]);
                break;
 
        case L4_IPC_TAG_FSYNC:
                ret = sys_fsync(sender, (int)mr[0]);
                break;
 
        case L4_IPC_TAG_LSEEK:
                ret = sys_lseek(sender, (int)mr[0], (off_t)mr[1], (int)mr[2]);
                break;
 
        case L4_IPC_TAG_MMAP: {
                struct sys_mmap_args *args = (struct sys_mmap_args *)mr[0];
                ret = (int)sys_mmap(sender, args);
                break;
        }
        case L4_IPC_TAG_MUNMAP: {
                ret = sys_munmap(sender, (void *)mr[0], (unsigned long)mr[1]);
                break;
        }
        case L4_IPC_TAG_MSYNC: {
                ret = sys_msync(sender, (void *)mr[0],
                                (unsigned long)mr[1], (int)mr[2]);
                break;
        }
        case L4_IPC_TAG_FORK: {
                ret = sys_fork(sender);
                break;
        }
        case L4_IPC_TAG_CLONE: {
                ret = sys_clone(sender, (void *)mr[0], (unsigned int)mr[1]);
                break;
        }
        case L4_IPC_TAG_EXIT: {
                /* Pager exit test
                struct task_ids ids;
                l4_getid(&ids);
                printf("\n%s: Destroying self (%d), along with any tasks.\n", __TASKNAME__, self_tid());
                l4_thread_control(THREAD_DESTROY, &ids);
                */
 
                /* An exiting task has no receive phase */
                sys_exit(sender, (int)mr[0]);
                return;
        }
        case L4_IPC_TAG_EXECVE: {
                ret = sys_execve(sender, (char *)mr[0],
                                 (char **)mr[1], (char **)mr[2]);
                if (ret < 0)
                        break;  /* We reply for errors */
                else
                        return; /* else we're done */
        }
 
        /* FS0 System calls */
        case L4_IPC_TAG_OPEN:
                ret = sys_open(sender, utcb_full_buffer(), (int)mr[0], (unsigned int)mr[1]);
                break;
        case L4_IPC_TAG_MKDIR:
                ret = sys_mkdir(sender, utcb_full_buffer(), (unsigned int)mr[0]);
                break;
        case L4_IPC_TAG_CHDIR:
                ret = sys_chdir(sender, utcb_full_buffer());
                break;
        case L4_IPC_TAG_READDIR: {
                char dirbuf[L4_IPC_EXTENDED_MAX_SIZE];
                ret = sys_readdir(sender, (int)mr[0], (int)mr[1], dirbuf);
                l4_return_extended(ret, L4_IPC_EXTENDED_MAX_SIZE, dirbuf, ret < 0);
                return;
        }
        default:
                printf("%s: Unrecognised ipc tag (%d) "
                       "received from (%d). Full mr reading: "
                       "%u, %u, %u, %u, %u, %u. Ignoring.\n",
                       __TASKNAME__, tag, senderid, read_mr(0),
                       read_mr(1), read_mr(2), read_mr(3), read_mr(4),
                       read_mr(5));
        }
 
        /* Reply */
        if ((ret = l4_ipc_return(ret)) < 0) {
                printf("%s: L4 IPC Error: %d.\n", __FUNCTION__, ret);
                BUG();
        }
}
 
void main(void)
{
 
        printf("\n%s: Started with thread id %x\n", __TASKNAME__, __raw_self_tid());
 
        init();
 
        printf("%s: Memory/Process manager initialized. Listening requests.\n", __TASKNAME__);
        while (1) {
                handle_requests();
        }
}
 

Browse

Tools

Subversion Repositories c0or1k

[/] [c0or1k/] [trunk/] [conts/] [posix/] [mm0/] [main.c] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	drasko	`/*`
2			`* mm0. Pager for all tasks.`
3			`*`
4			`* Copyright (C) 2007 Bahadir Balban`
5			`*/`
6			`#include <stdio.h>`
7			`#include <init.h>`
8			`#include L4LIB_INC_ARCH(utcb.h)`
9			`#include L4LIB_INC_ARCH(syscalls.h)`
10			`#include L4LIB_INC_ARCH(syslib.h)`
11			`#include <l4lib/kip.h>`
12			`#include <l4lib/utcb.h>`
13			`#include <l4lib/ipcdefs.h>`
14			`#include <l4lib/types.h>`
15			`#include <l4/api/thread.h>`
16			`#include <l4/api/space.h>`
17			`#include <l4/api/ipc.h>`
18			`#include <l4/api/errno.h>`
19			`#include <vm_area.h>`
20			`#include <syscalls.h>`
21			`#include <file.h>`
22			`#include <shm.h>`
23			`#include <mmap.h>`
24			`#include <test.h>`
25			`#include <capability.h>`
26			`#include <globals.h>`
27
28			`/* Receives all registers and origies back */`
29			`int ipc_test_full_sync(l4id_t senderid)`
30			`{`
31			`for (int i = MR_UNUSED_START; i < MR_TOTAL + MR_REST; i++) {`
32			`// printf("%s/%s: MR%d: %d\n", __TASKNAME__, __FUNCTION__,`
33			`// i, read_mr(i));`
34			`/* Reset it to 0 */`
35			`write_mr(i, 0);`
36			`}`
37
38			`/* Send a full origy */`
39			`l4_send_full(senderid, 0);`
40			`return 0;`
41			`}`
42
43			`void handle_requests(void)`
44			`{`
45			`/* Generic ipc data */`
46			`u32 mr[MR_UNUSED_TOTAL];`
47			`l4id_t senderid;`
48			`struct tcb *sender;`
49			`u32 tag;`
50			`int ret;`
51
52			`// printf("%s: Initiating ipc.\n", __TASKNAME__);`
53			`if ((ret = l4_receive(L4_ANYTHREAD)) < 0) {`
54			`printf("%s: %s: IPC Error: %d. Quitting...\n", __TASKNAME__,`
55			`__FUNCTION__, ret);`
56			`BUG();`
57			`}`
58
59			`/* Syslib conventional ipc data which uses first few mrs. */`
60			`tag = l4_get_tag();`
61			`senderid = l4_get_sender();`
62
63			`if (!(sender = find_task(senderid))) {`
64			`l4_ipc_return(-ESRCH);`
65			`return;`
66			`}`
67
68			`/* Read mrs not used by syslib */`
69			`for (int i = 0; i < MR_UNUSED_TOTAL; i++)`
70			`mr[i] = read_mr(MR_UNUSED_START + i);`
71
72			`switch(tag) {`
73			`case L4_IPC_TAG_SYNC_FULL:`
74			`ret = ipc_test_full_sync(senderid);`
75			`return;`
76			`case L4_IPC_TAG_SYNC:`
77			`mm0_test_global_vm_integrity();`
78			`// printf("%s: Synced with waiting thread.\n", __TASKNAME__);`
79			`/* This has no receive phase */`
80			`return;`
81
82			`case L4_IPC_TAG_UNDEF_FAULT:`
83			`/* Undefined instruction fault. Ignore. */`
84			`// printf("Undefined instruction fault caught.\n");`
85			`ret = 0;`
86			`break;`
87			`case L4_IPC_TAG_PFAULT: {`
88			`struct page *p;`
89
90			`/* Handle page fault. */`
91			`if (IS_ERR(p = page_fault_handler(sender, (fault_kdata_t *)&mr[0])))`
92			`ret = (int)p;`
93			`else`
94			`ret = 0;`
95			`break;`
96			`}`
97			`case L4_REQUEST_CAPABILITY: {`
98			`ret = sys_request_cap(sender, (struct capability *)mr[0]);`
99			`break;`
100			`}`
101			`case L4_IPC_TAG_SHMGET: {`
102			`ret = sys_shmget((key_t)mr[0], (int)mr[1], (int)mr[2]);`
103			`break;`
104			`}`
105
106			`case L4_IPC_TAG_SHMAT: {`
107			`ret = (int)sys_shmat(sender, (l4id_t)mr[0], (void *)mr[1], (int)mr[2]);`
108			`break;`
109			`}`
110
111			`case L4_IPC_TAG_SHMDT:`
112			`ret = sys_shmdt(sender, (void *)mr[0]);`
113			`break;`
114
115			`case L4_IPC_TAG_READ:`
116			`ret = sys_read(sender, (int)mr[0], (void *)mr[1], (int)mr[2]);`
117			`break;`
118
119			`case L4_IPC_TAG_WRITE:`
120			`ret = sys_write(sender, (int)mr[0], (void *)mr[1], (int)mr[2]);`
121			`break;`
122
123			`case L4_IPC_TAG_CLOSE:`
124			`ret = sys_close(sender, (int)mr[0]);`
125			`break;`
126
127			`case L4_IPC_TAG_FSYNC:`
128			`ret = sys_fsync(sender, (int)mr[0]);`
129			`break;`
130
131			`case L4_IPC_TAG_LSEEK:`
132			`ret = sys_lseek(sender, (int)mr[0], (off_t)mr[1], (int)mr[2]);`
133			`break;`
134
135			`case L4_IPC_TAG_MMAP: {`
136			`struct sys_mmap_args args = (struct sys_mmap_args )mr[0];`
137			`ret = (int)sys_mmap(sender, args);`
138			`break;`
139			`}`
140			`case L4_IPC_TAG_MUNMAP: {`
141			`ret = sys_munmap(sender, (void *)mr[0], (unsigned long)mr[1]);`
142			`break;`
143			`}`
144			`case L4_IPC_TAG_MSYNC: {`
145			`ret = sys_msync(sender, (void *)mr[0],`
146			`(unsigned long)mr[1], (int)mr[2]);`
147			`break;`
148			`}`
149			`case L4_IPC_TAG_FORK: {`
150			`ret = sys_fork(sender);`
151			`break;`
152			`}`
153			`case L4_IPC_TAG_CLONE: {`
154			`ret = sys_clone(sender, (void *)mr[0], (unsigned int)mr[1]);`
155			`break;`
156			`}`
157			`case L4_IPC_TAG_EXIT: {`
158			`/* Pager exit test`
159			`struct task_ids ids;`
160			`l4_getid(&ids);`
161			`printf("\n%s: Destroying self (%d), along with any tasks.\n", __TASKNAME__, self_tid());`
162			`l4_thread_control(THREAD_DESTROY, &ids);`
163			`*/`
164
165			`/* An exiting task has no receive phase */`
166			`sys_exit(sender, (int)mr[0]);`
167			`return;`
168			`}`
169			`case L4_IPC_TAG_EXECVE: {`
170			`ret = sys_execve(sender, (char *)mr[0],`
171			`(char )mr[1], (char )mr[2]);`
172			`if (ret < 0)`
173			`break; /* We reply for errors */`
174			`else`
175			`return; /* else we're done */`
176			`}`
177
178			`/* FS0 System calls */`
179			`case L4_IPC_TAG_OPEN:`
180			`ret = sys_open(sender, utcb_full_buffer(), (int)mr[0], (unsigned int)mr[1]);`
181			`break;`
182			`case L4_IPC_TAG_MKDIR:`
183			`ret = sys_mkdir(sender, utcb_full_buffer(), (unsigned int)mr[0]);`
184			`break;`
185			`case L4_IPC_TAG_CHDIR:`
186			`ret = sys_chdir(sender, utcb_full_buffer());`
187			`break;`
188			`case L4_IPC_TAG_READDIR: {`
189			`char dirbuf[L4_IPC_EXTENDED_MAX_SIZE];`
190			`ret = sys_readdir(sender, (int)mr[0], (int)mr[1], dirbuf);`
191			`l4_return_extended(ret, L4_IPC_EXTENDED_MAX_SIZE, dirbuf, ret < 0);`
192			`return;`
193			`}`
194			`default:`
195			`printf("%s: Unrecognised ipc tag (%d) "`
196			`"received from (%d). Full mr reading: "`
197			`"%u, %u, %u, %u, %u, %u. Ignoring.\n",`
198			`__TASKNAME__, tag, senderid, read_mr(0),`
199			`read_mr(1), read_mr(2), read_mr(3), read_mr(4),`
200			`read_mr(5));`
201			`}`
202
203			`/* Reply */`
204			`if ((ret = l4_ipc_return(ret)) < 0) {`
205			`printf("%s: L4 IPC Error: %d.\n", __FUNCTION__, ret);`
206			`BUG();`
207			`}`
208			`}`
209
210			`void main(void)`
211			`{`
212
213			`printf("\n%s: Started with thread id %x\n", __TASKNAME__, __raw_self_tid());`
214
215			`init();`
216
217			`printf("%s: Memory/Process manager initialized. Listening requests.\n", __TASKNAME__);`
218			`while (1) {`
219			`handle_requests();`
220			`}`
221			`}`
222