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

Subversion Repositories c0or1k

[/] [c0or1k/] [trunk/] [conts/] [test_suite0/] [src/] [api/] [map.c] - Blame information for rev 2

Details | Compare with Previous | View Log


/*
 * Test l4_map/unmap system call.
 *
 * Copyright (C) 2010 B Labs Ltd.
 *
 * Author: Bahadir Balban
 */
#include <l4lib/macros.h>
#include L4LIB_INC_ARCH(syscalls.h)
#include L4LIB_INC_ARCH(syslib.h)
#include INC_GLUE(memory.h)
#include <l4/api/errno.h>
#include <tests.h>
 
#define KERNEL_PAGE             0xF0000000UL
#define KIP_PAGE                0xFF000000UL
#define SYSCALL_PAGE            0xFFFFF000UL
#define VECTOR_PAGE             0xFFFF0000UL
 
int test_api_map(void)
{
        int err;
        unsigned int flags;
        l4id_t self = self_tid();
 
        /*
         * Make a valid mapping, a few pages below
         * the end of physical and virtual marks
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          MAP_USR_RW,
                          self)) < 0) {
                dbg_printf("sys_map failed on valid request. err=%d\n",
                           err);
                return err;
        }
 
        /*
         * Redo the same mapping. This should be valid.
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          MAP_USR_RW,
                          self)) < 0) {
                dbg_printf("sys_map failed on re-doing "
                           "valid request. err=%d\n", err);
                return err;
        }
 
        /*
         * Try mapping outside the virtual range
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded on invalid "
                           "virtual range ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try mapping outside the physical range
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded on invalid "
                           "physical range ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try having them both out of range
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END,
                          (void *)CONFIG_CONT0_VIRT0_END,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "physical and virtual ranges "
                           "supplied ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try out of range by off-by-one page size excess
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          6,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "physical and virtual ranges using "
                           "off-by-one page size."
                           "ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try invalid page size
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          0xFFFFFFFF,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "page size supplied ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try invalid flags
         */
        flags = 0;
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          flags,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "flags supplied flags=%u, ret=%d\n", flags, err);
                return -1;
        }
        flags = MAP_KERN_RWX;
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          0,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "flags supplied flags=%u, ret=%d\n", flags, err);
                return -1;
        }
        flags = MAP_KERN_IO;
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          0,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "flags supplied flags=%u, ret=%d\n", flags, err);
                return -1;
        }
 
        flags = MAP_KERN_RX;
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          0,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "flags supplied flags=%u, ret=%d\n", flags, err);
                return -1;
        }
 
        flags = 0xF0F0F01;
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          0,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "flags supplied flags=%u, ret=%d\n", flags, err);
                return -1;
        }
 
        /*
         * Try passing wraparound values
         */
        if ((err = l4_map((void *)0xFFFFFFFF,
                          (void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "wraparound ranges supplied ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try passing wraparound values
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)0xFFFFF000,
                          2,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when invalid "
                           "wraparound ranges supplied ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try mapping onto kernel
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)0xF0000000,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when trying to "
                           "map onto the kernel ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try mapping to vector page
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)0xFFFF0000,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when trying to "
                           "map to the vectors page ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try mapping to kip
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)0xFF000000,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when trying to "
                           "map to the kip page ret=%d\n", err);
                return -1;
        }
 
        /*
         * Try mapping to syscall page
         */
        if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END - PAGE_SIZE * 5,
                          (void *)0xFFFFF000,
                          1,
                          MAP_USR_RW,
                          self)) == 0) {
                dbg_printf("sys_map succeeded when trying to "
                           "map to the kip page ret=%d\n", err);
                return -1;
        }
 
        return 0;
}
 
 
int test_api_unmap(void)
{
        int err;
        l4id_t self = self_tid();
 
        /*
         * Try a valid unmap
         */
        if ((err = l4_unmap((void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                            1,
                            self)) < 0) {
                dbg_printf("sys_unmap failed on valid request. err=%d\n",
                           err);
                return err;
        }
 
        /*
         * Try the same unmap, should return ENOMAP
         */
        if ((err = l4_unmap((void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                            1,
                            self)) != -ENOMAP) {
                dbg_printf("sys_unmap did not return ENOMAP "
                           "on second unmap of same region. err=%d\n",
                           err);
                return -1;
        }
 
 
        /*
         * Try unmapping privileged areas
         */
        if ((err = l4_unmap((void *)KERNEL_PAGE, 1, self)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
 
        if ((err = l4_unmap((void *)VECTOR_PAGE, 1, self)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
 
        if ((err = l4_unmap((void *)SYSCALL_PAGE, 1, self)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
 
        /*
         * Try unmapping with range rollover
         */
        if ((err = l4_unmap((void *)KERNEL_PAGE, 0xFFFFFFFF, self)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
        if ((err = l4_unmap((void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                            0xFFFFFFFF, self)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
 
        /*
         * Try unmapping zero pages
         */
        if ((err = l4_unmap((void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                            0, self)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
 
        /*
         * Try unmapping with invalid id
         */
        if ((err = l4_unmap((void *)CONFIG_CONT0_VIRT0_END - PAGE_SIZE * 5,
                            1, 0xFFFFFFFF)) == 0) {
                dbg_printf("sys_unmap succeeded on invalid "
                           "unmap region. err=%d\n", err);
                return -1;
        }
 
        return 0;
}
 
int test_api_map_unmap(void)
{
        int err;
 
        if ((err = test_api_map()) < 0)
                goto out_err;
 
        if ((err = test_api_unmap()) < 0)
                goto out_err;
 
 
        printf("MAP/UNMAP:                     -- PASSED --\n");
        return 0;
 
out_err:
        printf("MAP/UNMAP:                     -- FAILED --\n");
        return err;
 
}
 

Browse

Tools

Subversion Repositories c0or1k

[/] [c0or1k/] [trunk/] [conts/] [test_suite0/] [src/] [api/] [map.c] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	drasko	`/*`
2			`* Test l4_map/unmap system call.`
3			`*`
4			`* Copyright (C) 2010 B Labs Ltd.`
5			`*`
6			`* Author: Bahadir Balban`
7			`*/`
8			`#include <l4lib/macros.h>`
9			`#include L4LIB_INC_ARCH(syscalls.h)`
10			`#include L4LIB_INC_ARCH(syslib.h)`
11			`#include INC_GLUE(memory.h)`
12			`#include <l4/api/errno.h>`
13			`#include <tests.h>`
14
15			`#define KERNEL_PAGE 0xF0000000UL`
16			`#define KIP_PAGE 0xFF000000UL`
17			`#define SYSCALL_PAGE 0xFFFFF000UL`
18			`#define VECTOR_PAGE 0xFFFF0000UL`
19
20			`int test_api_map(void)`
21			`{`
22			`int err;`
23			`unsigned int flags;`
24			`l4id_t self = self_tid();`
25
26			`/*`
27			`* Make a valid mapping, a few pages below`
28			`* the end of physical and virtual marks`
29			`*/`
30			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
31			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
32			`1,`
33			`MAP_USR_RW,`
34			`self)) < 0) {`
35			`dbg_printf("sys_map failed on valid request. err=%d\n",`
36			`err);`
37			`return err;`
38			`}`
39
40			`/*`
41			`* Redo the same mapping. This should be valid.`
42			`*/`
43			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
44			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
45			`1,`
46			`MAP_USR_RW,`
47			`self)) < 0) {`
48			`dbg_printf("sys_map failed on re-doing "`
49			`"valid request. err=%d\n", err);`
50			`return err;`
51			`}`
52
53			`/*`
54			`* Try mapping outside the virtual range`
55			`*/`
56			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
57			`(void *)CONFIG_CONT0_VIRT0_END,`
58			`1,`
59			`MAP_USR_RW,`
60			`self)) == 0) {`
61			`dbg_printf("sys_map succeeded on invalid "`
62			`"virtual range ret=%d\n", err);`
63			`return -1;`
64			`}`
65
66			`/*`
67			`* Try mapping outside the physical range`
68			`*/`
69			`if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END,`
70			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
71			`1,`
72			`MAP_USR_RW,`
73			`self)) == 0) {`
74			`dbg_printf("sys_map succeeded on invalid "`
75			`"physical range ret=%d\n", err);`
76			`return -1;`
77			`}`
78
79			`/*`
80			`* Try having them both out of range`
81			`*/`
82			`if ((err = l4_map((void *)CONFIG_CONT0_PHYS0_END,`
83			`(void *)CONFIG_CONT0_VIRT0_END,`
84			`1,`
85			`MAP_USR_RW,`
86			`self)) == 0) {`
87			`dbg_printf("sys_map succeeded when invalid "`
88			`"physical and virtual ranges "`
89			`"supplied ret=%d\n", err);`
90			`return -1;`
91			`}`
92
93			`/*`
94			`* Try out of range by off-by-one page size excess`
95			`*/`
96			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
97			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
98			`6,`
99			`MAP_USR_RW,`
100			`self)) == 0) {`
101			`dbg_printf("sys_map succeeded when invalid "`
102			`"physical and virtual ranges using "`
103			`"off-by-one page size."`
104			`"ret=%d\n", err);`
105			`return -1;`
106			`}`
107
108			`/*`
109			`* Try invalid page size`
110			`*/`
111			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
112			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
113			`0xFFFFFFFF,`
114			`MAP_USR_RW,`
115			`self)) == 0) {`
116			`dbg_printf("sys_map succeeded when invalid "`
117			`"page size supplied ret=%d\n", err);`
118			`return -1;`
119			`}`
120
121			`/*`
122			`* Try invalid flags`
123			`*/`
124			`flags = 0;`
125			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
126			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
127			`1,`
128			`flags,`
129			`self)) == 0) {`
130			`dbg_printf("sys_map succeeded when invalid "`
131			`"flags supplied flags=%u, ret=%d\n", flags, err);`
132			`return -1;`
133			`}`
134			`flags = MAP_KERN_RWX;`
135			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
136			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
137			`1,`
138			`0,`
139			`self)) == 0) {`
140			`dbg_printf("sys_map succeeded when invalid "`
141			`"flags supplied flags=%u, ret=%d\n", flags, err);`
142			`return -1;`
143			`}`
144			`flags = MAP_KERN_IO;`
145			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
146			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
147			`1,`
148			`0,`
149			`self)) == 0) {`
150			`dbg_printf("sys_map succeeded when invalid "`
151			`"flags supplied flags=%u, ret=%d\n", flags, err);`
152			`return -1;`
153			`}`
154
155			`flags = MAP_KERN_RX;`
156			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
157			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
158			`1,`
159			`0,`
160			`self)) == 0) {`
161			`dbg_printf("sys_map succeeded when invalid "`
162			`"flags supplied flags=%u, ret=%d\n", flags, err);`
163			`return -1;`
164			`}`
165
166			`flags = 0xF0F0F01;`
167			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
168			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
169			`1,`
170			`0,`
171			`self)) == 0) {`
172			`dbg_printf("sys_map succeeded when invalid "`
173			`"flags supplied flags=%u, ret=%d\n", flags, err);`
174			`return -1;`
175			`}`
176
177			`/*`
178			`* Try passing wraparound values`
179			`*/`
180			`if ((err = l4_map((void *)0xFFFFFFFF,`
181			`(void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
182			`1,`
183			`MAP_USR_RW,`
184			`self)) == 0) {`
185			`dbg_printf("sys_map succeeded when invalid "`
186			`"wraparound ranges supplied ret=%d\n", err);`
187			`return -1;`
188			`}`
189
190			`/*`
191			`* Try passing wraparound values`
192			`*/`
193			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
194			`(void *)0xFFFFF000,`
195			`2,`
196			`MAP_USR_RW,`
197			`self)) == 0) {`
198			`dbg_printf("sys_map succeeded when invalid "`
199			`"wraparound ranges supplied ret=%d\n", err);`
200			`return -1;`
201			`}`
202
203			`/*`
204			`* Try mapping onto kernel`
205			`*/`
206			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
207			`(void *)0xF0000000,`
208			`1,`
209			`MAP_USR_RW,`
210			`self)) == 0) {`
211			`dbg_printf("sys_map succeeded when trying to "`
212			`"map onto the kernel ret=%d\n", err);`
213			`return -1;`
214			`}`
215
216			`/*`
217			`* Try mapping to vector page`
218			`*/`
219			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
220			`(void *)0xFFFF0000,`
221			`1,`
222			`MAP_USR_RW,`
223			`self)) == 0) {`
224			`dbg_printf("sys_map succeeded when trying to "`
225			`"map to the vectors page ret=%d\n", err);`
226			`return -1;`
227			`}`
228
229			`/*`
230			`* Try mapping to kip`
231			`*/`
232			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
233			`(void *)0xFF000000,`
234			`1,`
235			`MAP_USR_RW,`
236			`self)) == 0) {`
237			`dbg_printf("sys_map succeeded when trying to "`
238			`"map to the kip page ret=%d\n", err);`
239			`return -1;`
240			`}`
241
242			`/*`
243			`* Try mapping to syscall page`
244			`*/`
245			`if ((err = l4_map((void )CONFIG_CONT0_PHYS0_END - PAGE_SIZE 5,`
246			`(void *)0xFFFFF000,`
247			`1,`
248			`MAP_USR_RW,`
249			`self)) == 0) {`
250			`dbg_printf("sys_map succeeded when trying to "`
251			`"map to the kip page ret=%d\n", err);`
252			`return -1;`
253			`}`
254
255			`return 0;`
256			`}`
257
258
259			`int test_api_unmap(void)`
260			`{`
261			`int err;`
262			`l4id_t self = self_tid();`
263
264			`/*`
265			`* Try a valid unmap`
266			`*/`
267			`if ((err = l4_unmap((void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
268			`1,`
269			`self)) < 0) {`
270			`dbg_printf("sys_unmap failed on valid request. err=%d\n",`
271			`err);`
272			`return err;`
273			`}`
274
275			`/*`
276			`* Try the same unmap, should return ENOMAP`
277			`*/`
278			`if ((err = l4_unmap((void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
279			`1,`
280			`self)) != -ENOMAP) {`
281			`dbg_printf("sys_unmap did not return ENOMAP "`
282			`"on second unmap of same region. err=%d\n",`
283			`err);`
284			`return -1;`
285			`}`
286
287
288			`/*`
289			`* Try unmapping privileged areas`
290			`*/`
291			`if ((err = l4_unmap((void *)KERNEL_PAGE, 1, self)) == 0) {`
292			`dbg_printf("sys_unmap succeeded on invalid "`
293			`"unmap region. err=%d\n", err);`
294			`return -1;`
295			`}`
296
297			`if ((err = l4_unmap((void *)VECTOR_PAGE, 1, self)) == 0) {`
298			`dbg_printf("sys_unmap succeeded on invalid "`
299			`"unmap region. err=%d\n", err);`
300			`return -1;`
301			`}`
302
303			`if ((err = l4_unmap((void *)SYSCALL_PAGE, 1, self)) == 0) {`
304			`dbg_printf("sys_unmap succeeded on invalid "`
305			`"unmap region. err=%d\n", err);`
306			`return -1;`
307			`}`
308
309			`/*`
310			`* Try unmapping with range rollover`
311			`*/`
312			`if ((err = l4_unmap((void *)KERNEL_PAGE, 0xFFFFFFFF, self)) == 0) {`
313			`dbg_printf("sys_unmap succeeded on invalid "`
314			`"unmap region. err=%d\n", err);`
315			`return -1;`
316			`}`
317			`if ((err = l4_unmap((void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
318			`0xFFFFFFFF, self)) == 0) {`
319			`dbg_printf("sys_unmap succeeded on invalid "`
320			`"unmap region. err=%d\n", err);`
321			`return -1;`
322			`}`
323
324			`/*`
325			`* Try unmapping zero pages`
326			`*/`
327			`if ((err = l4_unmap((void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
328			`0, self)) == 0) {`
329			`dbg_printf("sys_unmap succeeded on invalid "`
330			`"unmap region. err=%d\n", err);`
331			`return -1;`
332			`}`
333
334			`/*`
335			`* Try unmapping with invalid id`
336			`*/`
337			`if ((err = l4_unmap((void )CONFIG_CONT0_VIRT0_END - PAGE_SIZE 5,`
338			`1, 0xFFFFFFFF)) == 0) {`
339			`dbg_printf("sys_unmap succeeded on invalid "`
340			`"unmap region. err=%d\n", err);`
341			`return -1;`
342			`}`
343
344			`return 0;`
345			`}`
346
347			`int test_api_map_unmap(void)`
348			`{`
349			`int err;`
350
351			`if ((err = test_api_map()) < 0)`
352			`goto out_err;`
353
354			`if ((err = test_api_unmap()) < 0)`
355			`goto out_err;`
356
357
358			`printf("MAP/UNMAP: -- PASSED --\n");`
359			`return 0;`
360
361			`out_err:`
362			`printf("MAP/UNMAP: -- FAILED --\n");`
363			`return err;`
364
365			`}`
366