Fixes race where we'd ignore a kmsg when halting
[akaros.git] / kern / src / testing.c
1
2 #ifdef __SHARC__
3 #pragma nosharc
4 #endif
5
6 #include <arch/mmu.h>
7 #include <arch/arch.h>
8 #include <bitmask.h>
9 #include <smp.h>
10
11 #include <ros/memlayout.h>
12 #include <ros/common.h>
13 #include <ros/bcq.h>
14 #include <ros/ucq.h>
15
16 #include <atomic.h>
17 #include <stdio.h>
18 #include <assert.h>
19 #include <string.h>
20 #include <testing.h>
21 #include <trap.h>
22 #include <arch/trap.h>
23 #include <process.h>
24 #include <syscall.h>
25 #include <time.h>
26 #include <kfs.h>
27 #include <multiboot.h>
28 #include <pmap.h>
29 #include <page_alloc.h>
30 #include <pmap.h>
31 #include <slab.h>
32 #include <kmalloc.h>
33 #include <hashtable.h>
34 #include <radix.h>
35 #include <monitor.h>
36 #include <kthread.h>
37 #include <schedule.h>
38 #include <umem.h>
39 #include <ucq.h>
40
41 #define l1 (available_caches.l1)
42 #define l2 (available_caches.l2)
43 #define l3 (available_caches.l3)
44
45 #ifdef __i386__
46
47 void test_ipi_sending(void)
48 {
49         extern handler_t (CT(NUM_INTERRUPT_HANDLERS) RO interrupt_handlers)[];
50         int8_t state = 0;
51
52         register_interrupt_handler(interrupt_handlers, I_TESTING,
53                                    test_hello_world_handler, NULL);
54         enable_irqsave(&state);
55         cprintf("\nCORE 0 sending broadcast\n");
56         send_broadcast_ipi(I_TESTING);
57         udelay(3000000);
58         cprintf("\nCORE 0 sending all others\n");
59         send_all_others_ipi(I_TESTING);
60         udelay(3000000);
61         cprintf("\nCORE 0 sending self\n");
62         send_self_ipi(I_TESTING);
63         udelay(3000000);
64         cprintf("\nCORE 0 sending ipi to physical 1\n");
65         send_ipi(get_hw_coreid(0x01), I_TESTING);
66         udelay(3000000);
67         cprintf("\nCORE 0 sending ipi to physical 2\n");
68         send_ipi(get_hw_coreid(0x02), I_TESTING);
69         udelay(3000000);
70         cprintf("\nCORE 0 sending ipi to physical 3\n");
71         send_ipi(get_hw_coreid(0x03), I_TESTING);
72         udelay(3000000);
73         cprintf("\nCORE 0 sending ipi to physical 15\n");
74         send_ipi(get_hw_coreid(0x0f), I_TESTING);
75         udelay(3000000);
76         cprintf("\nCORE 0 sending ipi to logical 2\n");
77         send_group_ipi(0x02, I_TESTING);
78         udelay(3000000);
79         cprintf("\nCORE 0 sending ipi to logical 1\n");
80         send_group_ipi(0x01, I_TESTING);
81         udelay(3000000);
82         cprintf("\nDone!\n");
83         disable_irqsave(&state);
84 }
85
86 // Note this never returns and will muck with any other timer work
87 void test_pic_reception(void)
88 {
89         register_interrupt_handler(interrupt_handlers, 0x20, test_hello_world_handler, NULL);
90         pit_set_timer(100,TIMER_RATEGEN); // totally arbitrary time
91         pic_unmask_irq(0);
92         cprintf("PIC1 Mask = 0x%04x\n", inb(PIC1_DATA));
93         cprintf("PIC2 Mask = 0x%04x\n", inb(PIC2_DATA));
94         unmask_lapic_lvt(LAPIC_LVT_LINT0);
95         cprintf("Core %d's LINT0: 0x%08x\n", core_id(), read_mmreg32(LAPIC_LVT_LINT0));
96         enable_irq();
97         while(1);
98 }
99
100 void test_ioapic_pit_reroute(void) 
101 {
102         register_interrupt_handler(interrupt_handlers, 0x20, test_hello_world_handler, NULL);
103         ioapic_route_irq(0, 3); 
104
105         cprintf("Starting pit on core 3....\n");
106         udelay(3000000);
107         pit_set_timer(0xFFFE,TIMER_RATEGEN); // totally arbitrary time
108         
109         udelay(3000000);
110         ioapic_unroute_irq(0);
111         udelay(300000);
112         cprintf("Masked pit. Waiting before return...\n");
113         udelay(3000000);
114 }
115
116 #endif // __i386__
117
118
119 void test_print_info(void)
120 {
121         cprintf("\nCORE 0 asking all cores to print info:\n");
122         smp_call_function_all(test_print_info_handler, NULL, 0);
123         cprintf("\nDone!\n");
124 }
125
126 void test_page_coloring(void) 
127 {
128 /*
129         //Print the different cache properties of our machine
130         print_cache_properties("L1", l1);
131         cprintf("\n");
132         print_cache_properties("L2", l2);
133         cprintf("\n");
134         print_cache_properties("L3", l3);
135         cprintf("\n");
136
137         //Print some stats about our memory
138         cprintf("Max Address: %llu\n", MAX_VADDR);
139         cprintf("Num Pages: %u\n", npages);
140
141         //Declare a local variable for allocating pages 
142         page_t* page;
143
144         cprintf("Contents of the page free list:\n");
145         for(int i=0; i<llc_cache->num_colors; i++) {
146                 cprintf("  COLOR %d:\n", i);
147                 LIST_FOREACH(page, &colored_page_free_list[i], pg_link) {
148                         cprintf("    Page: %d\n", page2ppn(page));
149                 }
150         }
151
152         //Run through and allocate all pages through l1_page_alloc
153         cprintf("Allocating from L1 page colors:\n");
154         for(int i=0; i<get_cache_num_page_colors(l1); i++) {
155                 cprintf("  COLOR %d:\n", i);
156                 while(colored_page_alloc(l1, &page, i) != -ENOMEM)
157                         cprintf("    Page: %d\n", page2ppn(page));
158         }
159
160         //Put all the pages back by reinitializing
161         page_init();
162         
163         //Run through and allocate all pages through l2_page_alloc
164         cprintf("Allocating from L2 page colors:\n");
165         for(int i=0; i<get_cache_num_page_colors(l2); i++) {
166                 cprintf("  COLOR %d:\n", i);
167                 while(colored_page_alloc(l2, &page, i) != -ENOMEM)
168                         cprintf("    Page: %d\n", page2ppn(page));
169         }
170
171         //Put all the pages back by reinitializing
172         page_init();
173         
174         //Run through and allocate all pages through l3_page_alloc
175         cprintf("Allocating from L3 page colors:\n");
176         for(int i=0; i<get_cache_num_page_colors(l3); i++) {
177                 cprintf("  COLOR %d:\n", i);
178                 while(colored_page_alloc(l3, &page, i) != -ENOMEM)
179                         cprintf("    Page: %d\n", page2ppn(page));
180         }
181         
182         //Put all the pages back by reinitializing
183         page_init();
184         
185         //Run through and allocate all pages through page_alloc
186         cprintf("Allocating from global allocator:\n");
187         while(upage_alloc(&page) != -ENOMEM)
188                 cprintf("    Page: %d\n", page2ppn(page));
189         
190         if(colored_page_alloc(l2, &page, 0) != -ENOMEM)
191                 cprintf("Should not get here, all pages should already be gone!\n");
192         cprintf("All pages gone for sure...\n");
193         
194         //Now lets put a few pages back using page_free..
195         cprintf("Reinserting pages via page_free and reallocating them...\n");
196         page_free(&pages[0]);
197         page_free(&pages[15]);
198         page_free(&pages[7]);
199         page_free(&pages[6]);
200         page_free(&pages[4]);
201
202         while(upage_alloc(&page) != -ENOMEM)
203                 cprintf("Page: %d\n", page2ppn(page));  
204         
205         page_init();
206 */
207 }
208
209 void test_color_alloc() {
210         size_t checkpoint = 0;
211         uint8_t* colors_map = kmalloc(BYTES_FOR_BITMASK(llc_cache->num_colors), 0);
212         cache_color_alloc(l2, colors_map);
213         cache_color_alloc(l3, colors_map);
214         cache_color_alloc(l3, colors_map);
215         cache_color_alloc(l2, colors_map);
216         cache_color_free(llc_cache, colors_map);
217         cache_color_free(llc_cache, colors_map);
218         cache_color_free(llc_cache, colors_map);
219         cache_color_free(llc_cache, colors_map);
220         cache_color_free(llc_cache, colors_map);
221         cache_color_free(llc_cache, colors_map);
222         cache_color_free(llc_cache, colors_map);
223         cache_color_free(llc_cache, colors_map);
224         cache_color_free(llc_cache, colors_map);
225         cache_color_free(llc_cache, colors_map);
226         cache_color_free(llc_cache, colors_map);
227         cache_color_free(llc_cache, colors_map);
228         cache_color_free(llc_cache, colors_map);
229         cache_color_free(llc_cache, colors_map);
230         cache_color_free(llc_cache, colors_map);
231         cache_color_free(llc_cache, colors_map);
232         cache_color_free(l2, colors_map);
233         cache_color_free(llc_cache, colors_map);
234         cache_color_free(llc_cache, colors_map);
235
236 print_cache_colors:
237         printk("L1 free colors, tot colors: %d\n", l1->num_colors);
238         PRINT_BITMASK(l1->free_colors_map, l1->num_colors);
239         printk("L2 free colors, tot colors: %d\n", l2->num_colors);
240         PRINT_BITMASK(l2->free_colors_map, l2->num_colors);
241         printk("L3 free colors, tot colors: %d\n", l3->num_colors);
242         PRINT_BITMASK(l3->free_colors_map, l3->num_colors);
243         printk("Process allocated colors\n");
244         PRINT_BITMASK(colors_map, llc_cache->num_colors);
245         printk("test_color_alloc() complete!\n");
246 }
247
248 barrier_t test_cpu_array;
249
250 void test_barrier(void)
251 {
252         cprintf("Core 0 initializing barrier\n");
253         init_barrier(&test_cpu_array, num_cpus);
254         cprintf("Core 0 asking all cores to print ids, barrier, rinse, repeat\n");
255         smp_call_function_all(test_barrier_handler, NULL, 0);
256 }
257
258 void test_interrupts_irqsave(void)
259 {
260         int8_t state = 0;
261         printd("Testing Nesting Enabling first, turning ints off:\n");
262         disable_irq();
263         printd("Interrupts are: %x\n", irq_is_enabled());
264         assert(!irq_is_enabled());
265         printd("Enabling IRQSave\n");
266         enable_irqsave(&state);
267         printd("Interrupts are: %x\n", irq_is_enabled());
268         assert(irq_is_enabled());
269         printd("Enabling IRQSave Again\n");
270         enable_irqsave(&state);
271         printd("Interrupts are: %x\n", irq_is_enabled());
272         assert(irq_is_enabled());
273         printd("Disabling IRQSave Once\n");
274         disable_irqsave(&state);
275         printd("Interrupts are: %x\n", irq_is_enabled());
276         assert(irq_is_enabled());
277         printd("Disabling IRQSave Again\n");
278         disable_irqsave(&state);
279         printd("Interrupts are: %x\n", irq_is_enabled());
280         assert(!irq_is_enabled());
281         printd("Done.  Should have been 0, 200, 200, 200, 0\n");
282
283         printd("Testing Nesting Disabling first, turning ints on:\n");
284         state = 0;
285         enable_irq();
286         printd("Interrupts are: %x\n", irq_is_enabled());
287         assert(irq_is_enabled());
288         printd("Disabling IRQSave Once\n");
289         disable_irqsave(&state);
290         printd("Interrupts are: %x\n", irq_is_enabled());
291         assert(!irq_is_enabled());
292         printd("Disabling IRQSave Again\n");
293         disable_irqsave(&state);
294         printd("Interrupts are: %x\n", irq_is_enabled());
295         assert(!irq_is_enabled());
296         printd("Enabling IRQSave Once\n");
297         enable_irqsave(&state);
298         printd("Interrupts are: %x\n", irq_is_enabled());
299         assert(!irq_is_enabled());
300         printd("Enabling IRQSave Again\n");
301         enable_irqsave(&state);
302         printd("Interrupts are: %x\n", irq_is_enabled());
303         assert(irq_is_enabled());
304         printd("Done.  Should have been 200, 0, 0, 0, 200 \n");
305
306         state = 0;
307         disable_irq();
308         printd("Ints are off, enabling then disabling.\n");
309         enable_irqsave(&state);
310         printd("Interrupts are: %x\n", irq_is_enabled());
311         assert(irq_is_enabled());
312         disable_irqsave(&state);
313         printd("Interrupts are: %x\n", irq_is_enabled());
314         assert(!irq_is_enabled());
315         printd("Done.  Should have been 200, 0\n");
316
317         state = 0;
318         enable_irq();
319         printd("Ints are on, enabling then disabling.\n");
320         enable_irqsave(&state);
321         printd("Interrupts are: %x\n", irq_is_enabled());
322         assert(irq_is_enabled());
323         disable_irqsave(&state);
324         printd("Interrupts are: %x\n", irq_is_enabled());
325         assert(irq_is_enabled());
326         printd("Done.  Should have been 200, 200\n");
327
328         state = 0;
329         disable_irq();
330         printd("Ints are off, disabling then enabling.\n");
331         disable_irqsave(&state);
332         printd("Interrupts are: %x\n", irq_is_enabled());
333         assert(!irq_is_enabled());
334         enable_irqsave(&state);
335         printd("Interrupts are: %x\n", irq_is_enabled());
336         assert(!irq_is_enabled());
337         printd("Done.  Should have been 0, 0\n");
338
339         state = 0;
340         enable_irq();
341         printd("Ints are on, disabling then enabling.\n");
342         disable_irqsave(&state);
343         printd("Interrupts are: %x\n", irq_is_enabled());
344         assert(!irq_is_enabled());
345         enable_irqsave(&state);
346         printd("Interrupts are: %x\n", irq_is_enabled());
347         assert(irq_is_enabled());
348         printd("Done.  Should have been 0, 200\n");
349
350         disable_irq();
351         cprintf("Passed enable_irqsave tests\n");
352 }
353
354 void test_bitmasks(void)
355 {
356 #define masksize 67
357         DECL_BITMASK(mask, masksize);
358         printk("size of mask %d\n", sizeof(mask));
359         CLR_BITMASK(mask, masksize);
360         PRINT_BITMASK(mask, masksize);
361         printk("cleared\n");
362         SET_BITMASK_BIT(mask, 0);
363         SET_BITMASK_BIT(mask, 11);
364         SET_BITMASK_BIT(mask, 17);
365         SET_BITMASK_BIT(mask, masksize-1);
366         printk("bits set\n");
367         PRINT_BITMASK(mask, masksize);
368         DECL_BITMASK(mask2, masksize);
369         COPY_BITMASK(mask2, mask, masksize);
370         printk("copy of original mask, should be the same as the prev\n");
371         PRINT_BITMASK(mask2, masksize);
372         CLR_BITMASK_BIT(mask, 11);
373         printk("11 cleared\n");
374         PRINT_BITMASK(mask, masksize);
375         printk("bit 17 is %d (should be 1)\n", GET_BITMASK_BIT(mask, 17));
376         printk("bit 11 is %d (should be 0)\n", GET_BITMASK_BIT(mask, 11));
377         FILL_BITMASK(mask, masksize);
378         PRINT_BITMASK(mask, masksize);
379         printk("should be all 1's, except for a few at the end\n");
380         printk("Is Clear?: %d (should be 0)\n", BITMASK_IS_CLEAR(mask,masksize));
381         CLR_BITMASK(mask, masksize);
382         PRINT_BITMASK(mask, masksize);
383         printk("Is Clear?: %d (should be 1)\n", BITMASK_IS_CLEAR(mask,masksize));
384         printk("should be cleared\n");
385 }
386
387 checklist_t *RO the_global_list;
388
389 void test_checklist_handler(trapframe_t *tf, void* data)
390 {
391         udelay(1000000);
392         cprintf("down_checklist(%x,%d)\n", the_global_list, core_id());
393         down_checklist(the_global_list);
394 }
395
396 void test_checklists(void)
397 {
398         INIT_CHECKLIST(a_list, MAX_NUM_CPUS);
399         the_global_list = &a_list;
400         printk("Checklist Build, mask size: %d\n", sizeof(a_list.mask.bits));
401         printk("mask\n");
402         PRINT_BITMASK(a_list.mask.bits, a_list.mask.size);
403         SET_BITMASK_BIT(a_list.mask.bits, 11);
404         printk("Set bit 11\n");
405         PRINT_BITMASK(a_list.mask.bits, a_list.mask.size);
406
407         CLR_BITMASK(a_list.mask.bits, a_list.mask.size);
408         INIT_CHECKLIST_MASK(a_mask, MAX_NUM_CPUS);
409         FILL_BITMASK(a_mask.bits, num_cpus);
410         //CLR_BITMASK_BIT(a_mask.bits, core_id());
411         //SET_BITMASK_BIT(a_mask.bits, 1);
412         //printk("New mask (1, 17, 25):\n");
413         printk("Created new mask, filled up to num_cpus\n");
414         PRINT_BITMASK(a_mask.bits, a_mask.size);
415         printk("committing new mask\n");
416         commit_checklist_wait(&a_list, &a_mask);
417         printk("Old mask (copied onto):\n");
418         PRINT_BITMASK(a_list.mask.bits, a_list.mask.size);
419         //smp_call_function_single(1, test_checklist_handler, 0, 0);
420
421         smp_call_function_all(test_checklist_handler, NULL, 0);
422
423         printk("Waiting on checklist\n");
424         waiton_checklist(&a_list);
425         printk("Done Waiting!\n");
426
427 }
428
429 atomic_t a, b, c;
430
431 #ifdef __IVY__
432 void test_incrementer_handler(trapframe_t *tf, atomic_t *data)
433 #else
434 void test_incrementer_handler(trapframe_t *tf, void *data)
435 #endif
436 {
437         assert(data);
438         atomic_inc(data);
439 }
440
441 void test_null_handler(trapframe_t *tf, void* data)
442 {
443         asm volatile("nop");
444 }
445
446 void test_smp_call_functions(void)
447 {
448         int i;
449         atomic_init(&a, 0);
450         atomic_init(&b, 0);
451         atomic_init(&c, 0);
452         handler_wrapper_t *waiter0 = 0, *waiter1 = 0, *waiter2 = 0, *waiter3 = 0,
453                           *waiter4 = 0, *waiter5 = 0;
454         uint8_t me = core_id();
455         printk("\nCore %d: SMP Call Self (nowait):\n", me);
456         printk("---------------------\n");
457         smp_call_function_self(test_hello_world_handler, NULL, 0);
458         printk("\nCore %d: SMP Call Self (wait):\n", me);
459         printk("---------------------\n");
460         smp_call_function_self(test_hello_world_handler, NULL, &waiter0);
461         smp_call_wait(waiter0);
462         printk("\nCore %d: SMP Call All (nowait):\n", me);
463         printk("---------------------\n");
464         smp_call_function_all(test_hello_world_handler, NULL, 0);
465         printk("\nCore %d: SMP Call All (wait):\n", me);
466         printk("---------------------\n");
467         smp_call_function_all(test_hello_world_handler, NULL, &waiter0);
468         smp_call_wait(waiter0);
469         printk("\nCore %d: SMP Call All-Else Individually, in order (nowait):\n", me);
470         printk("---------------------\n");
471         for(i = 1; i < num_cpus; i++)
472                 smp_call_function_single(i, test_hello_world_handler, NULL, 0);
473         printk("\nCore %d: SMP Call Self (wait):\n", me);
474         printk("---------------------\n");
475         smp_call_function_self(test_hello_world_handler, NULL, &waiter0);
476         smp_call_wait(waiter0);
477         printk("\nCore %d: SMP Call All-Else Individually, in order (wait):\n", me);
478         printk("---------------------\n");
479         for(i = 1; i < num_cpus; i++)
480         {
481                 smp_call_function_single(i, test_hello_world_handler, NULL, &waiter0);
482                 smp_call_wait(waiter0);
483         }
484         printk("\nTesting to see if any IPI-functions are dropped when not waiting:\n");
485         printk("A: %d, B: %d, C: %d (should be 0,0,0)\n", atomic_read(&a), atomic_read(&b), atomic_read(&c));
486         smp_call_function_all(test_incrementer_handler, &a, 0);
487         smp_call_function_all(test_incrementer_handler, &b, 0);
488         smp_call_function_all(test_incrementer_handler, &c, 0);
489         // if i can clobber a previous IPI, the interleaving might do it
490         smp_call_function_single(1 % num_cpus, test_incrementer_handler, &a, 0);
491         smp_call_function_single(2 % num_cpus, test_incrementer_handler, &b, 0);
492         smp_call_function_single(3 % num_cpus, test_incrementer_handler, &c, 0);
493         smp_call_function_single(4 % num_cpus, test_incrementer_handler, &a, 0);
494         smp_call_function_single(5 % num_cpus, test_incrementer_handler, &b, 0);
495         smp_call_function_single(6 % num_cpus, test_incrementer_handler, &c, 0);
496         smp_call_function_all(test_incrementer_handler, &a, 0);
497         smp_call_function_single(3 % num_cpus, test_incrementer_handler, &c, 0);
498         smp_call_function_all(test_incrementer_handler, &b, 0);
499         smp_call_function_single(1 % num_cpus, test_incrementer_handler, &a, 0);
500         smp_call_function_all(test_incrementer_handler, &c, 0);
501         smp_call_function_single(2 % num_cpus, test_incrementer_handler, &b, 0);
502         // wait, so we're sure the others finish before printing.
503         // without this, we could (and did) get 19,18,19, since the B_inc
504         // handler didn't finish yet
505         smp_call_function_self(test_null_handler, NULL, &waiter0);
506         // need to grab all 5 handlers (max), since the code moves to the next free.
507         smp_call_function_self(test_null_handler, NULL, &waiter1);
508         smp_call_function_self(test_null_handler, NULL, &waiter2);
509         smp_call_function_self(test_null_handler, NULL, &waiter3);
510         smp_call_function_self(test_null_handler, NULL, &waiter4);
511         smp_call_wait(waiter0);
512         smp_call_wait(waiter1);
513         smp_call_wait(waiter2);
514         smp_call_wait(waiter3);
515         smp_call_wait(waiter4);
516         printk("A: %d, B: %d, C: %d (should be 19,19,19)\n", atomic_read(&a), atomic_read(&b), atomic_read(&c));
517         printk("Attempting to deadlock by smp_calling with an outstanding wait:\n");
518         smp_call_function_self(test_null_handler, NULL, &waiter0);
519         printk("Sent one\n");
520         smp_call_function_self(test_null_handler, NULL, &waiter1);
521         printk("Sent two\n");
522         smp_call_wait(waiter0);
523         printk("Wait one\n");
524         smp_call_wait(waiter1);
525         printk("Wait two\n");
526         printk("\tMade it through!\n");
527         printk("Attempting to deadlock by smp_calling more than are available:\n");
528         printk("\tShould see an Insufficient message and a kernel warning.\n");
529         if (smp_call_function_self(test_null_handler, NULL, &waiter0))
530                 printk("\tInsufficient handlers to call function (0)\n");
531         if (smp_call_function_self(test_null_handler, NULL, &waiter1))
532                 printk("\tInsufficient handlers to call function (1)\n");
533         if (smp_call_function_self(test_null_handler, NULL, &waiter2))
534                 printk("\tInsufficient handlers to call function (2)\n");
535         if (smp_call_function_self(test_null_handler, NULL, &waiter3))
536                 printk("\tInsufficient handlers to call function (3)\n");
537         if (smp_call_function_self(test_null_handler, NULL, &waiter4))
538                 printk("\tInsufficient handlers to call function (4)\n");
539         if (smp_call_function_self(test_null_handler, NULL, &waiter5))
540                 printk("\tInsufficient handlers to call function (5)\n");
541         smp_call_wait(waiter0);
542         smp_call_wait(waiter1);
543         smp_call_wait(waiter2);
544         smp_call_wait(waiter3);
545         smp_call_wait(waiter4);
546         smp_call_wait(waiter5);
547         printk("\tMade it through!\n");
548
549         printk("Done\n");
550 }
551
552 #ifdef __i386__
553 void test_lapic_status_bit(void)
554 {
555         register_interrupt_handler(interrupt_handlers, I_TESTING,
556                                    test_incrementer_handler, &a);
557         #define NUM_IPI 100000
558         atomic_set(&a,0);
559         printk("IPIs received (should be 0): %d\n", a);
560         for(int i = 0; i < NUM_IPI; i++) {
561                 send_ipi(get_hw_coreid(7), I_TESTING);
562                 lapic_wait_to_send();
563         }
564         // need to wait a bit to let those IPIs get there
565         udelay(5000000);
566         printk("IPIs received (should be %d): %d\n", a, NUM_IPI);
567         // hopefully that handler never fires again.  leaving it registered for now.
568 }
569 #endif // __i386__
570
571 /************************************************************/
572 /* ISR Handler Functions */
573
574 void test_hello_world_handler(trapframe_t *tf, void* data)
575 {
576         int trapno;
577         #if defined(__i386__)
578         trapno = tf->tf_trapno;
579         #elif defined(__sparc_v8__)
580         trapno = (tf->tbr >> 4) & 0xFF;
581         #else
582         trapno = 0;
583         #endif
584
585         cprintf("Incoming IRQ, ISR: %d on core %d with tf at 0x%08x\n",
586                 trapno, core_id(), tf);
587 }
588
589 spinlock_t print_info_lock = SPINLOCK_INITIALIZER;
590
591 void test_print_info_handler(trapframe_t *tf, void* data)
592 {
593         uint64_t tsc = read_tsc();
594
595         spin_lock_irqsave(&print_info_lock);
596         cprintf("----------------------------\n");
597         cprintf("This is Core %d\n", core_id());
598         cprintf("Timestamp = %lld\n", tsc);
599 #ifdef __i386__
600         cprintf("Hardware core %d\n", hw_core_id());
601         cprintf("MTRR_DEF_TYPE = 0x%08x\n", read_msr(IA32_MTRR_DEF_TYPE));
602         cprintf("MTRR Phys0 Base = 0x%016llx, Mask = 0x%016llx\n",
603                 read_msr(0x200), read_msr(0x201));
604         cprintf("MTRR Phys1 Base = 0x%016llx, Mask = 0x%016llx\n",
605                 read_msr(0x202), read_msr(0x203));
606         cprintf("MTRR Phys2 Base = 0x%016llx, Mask = 0x%016llx\n",
607                 read_msr(0x204), read_msr(0x205));
608         cprintf("MTRR Phys3 Base = 0x%016llx, Mask = 0x%016llx\n",
609                 read_msr(0x206), read_msr(0x207));
610         cprintf("MTRR Phys4 Base = 0x%016llx, Mask = 0x%016llx\n",
611                 read_msr(0x208), read_msr(0x209));
612         cprintf("MTRR Phys5 Base = 0x%016llx, Mask = 0x%016llx\n",
613                 read_msr(0x20a), read_msr(0x20b));
614         cprintf("MTRR Phys6 Base = 0x%016llx, Mask = 0x%016llx\n",
615                 read_msr(0x20c), read_msr(0x20d));
616         cprintf("MTRR Phys7 Base = 0x%016llx, Mask = 0x%016llx\n",
617                 read_msr(0x20e), read_msr(0x20f));
618 #endif // __i386__
619         cprintf("----------------------------\n");
620         spin_unlock_irqsave(&print_info_lock);
621 }
622
623 void test_barrier_handler(trapframe_t *tf, void* data)
624 {
625         cprintf("Round 1: Core %d\n", core_id());
626         waiton_barrier(&test_cpu_array);
627         waiton_barrier(&test_cpu_array);
628         waiton_barrier(&test_cpu_array);
629         waiton_barrier(&test_cpu_array);
630         waiton_barrier(&test_cpu_array);
631         waiton_barrier(&test_cpu_array);
632         cprintf("Round 2: Core %d\n", core_id());
633         waiton_barrier(&test_cpu_array);
634         cprintf("Round 3: Core %d\n", core_id());
635         // uncomment to see it fucked up
636         //cprintf("Round 4: Core %d\n", core_id());
637 }
638
639 #ifdef __IVY__
640 static void test_waiting_handler(trapframe_t *tf, atomic_t *data)
641 #else
642 static void test_waiting_handler(trapframe_t *tf, void *data)
643 #endif
644 {
645         atomic_dec(data);
646 }
647
648 #ifdef __i386__
649 void test_pit(void)
650 {
651         cprintf("Starting test for PIT now (10s)\n");
652         udelay_pit(10000000);
653         cprintf("End now\n");
654         cprintf("Starting test for TSC (if stable) now (10s)\n");
655         udelay(10000000);
656         cprintf("End now\n");
657
658         cprintf("Starting test for LAPIC (if stable) now (10s)\n");
659         enable_irq();
660         lapic_set_timer(10000000, FALSE);
661
662         atomic_t waiting;
663         atomic_init(&waiting, 1);
664         register_interrupt_handler(interrupt_handlers, I_TESTING,
665                                    test_waiting_handler, &waiting);
666         while(atomic_read(&waiting))
667                 cpu_relax();
668         cprintf("End now\n");
669 }
670
671 void test_circ_buffer(void)
672 {
673         int arr[5] = {0, 1, 2, 3, 4};
674
675         for (int i = 0; i < 5; i++) {
676                 FOR_CIRC_BUFFER(i, 5, j)
677                         printk("Starting with current = %d, each value = %d\n", i, j);
678         }
679         return;
680 }
681
682 void test_km_handler(struct trapframe *tf, uint32_t srcid, long a0, long a1,
683                      long a2)
684 {
685         printk("Received KM on core %d from core %d: arg0= 0x%08x, arg1 = "
686                "0x%08x, arg2 = 0x%08x\n", core_id(), srcid, a0, a1, a2);
687         return;
688 }
689
690 void test_kernel_messages(void)
691 {
692         printk("Testing Kernel Messages\n");
693         /* Testing sending multiples, sending different types, alternating, and
694          * precendence (the immediates should trump the others) */
695         printk("sending 5 IMMED to core 1, sending (#,deadbeef,0)\n");
696         for (int i = 0; i < 5; i++)
697                 send_kernel_message(1, test_km_handler, (long)i, 0xdeadbeef, 0,
698                                     KMSG_IMMEDIATE);
699         udelay(5000000);
700         printk("sending 5 routine to core 1, sending (#,cafebabe,0)\n");
701         for (int i = 0; i < 5; i++)
702                 send_kernel_message(1, test_km_handler, (long)i, 0xcafebabe, 0,
703                                     KMSG_ROUTINE);
704         udelay(5000000);
705         printk("sending 10 routine and 3 immediate to core 2\n");
706         for (int i = 0; i < 10; i++)
707                 send_kernel_message(2, test_km_handler, (long)i, 0xcafebabe, 0,
708                                     KMSG_ROUTINE);
709         for (int i = 0; i < 3; i++)
710                 send_kernel_message(2, test_km_handler, (long)i, 0xdeadbeef, 0,
711                                     KMSG_IMMEDIATE);
712         udelay(5000000);
713         printk("sending 5 ea alternating to core 2\n");
714         for (int i = 0; i < 5; i++) {
715                 send_kernel_message(2, test_km_handler, (long)i, 0xdeadbeef, 0,
716                                     KMSG_IMMEDIATE);
717                 send_kernel_message(2, test_km_handler, (long)i, 0xcafebabe, 0,
718                                     KMSG_ROUTINE);
719         }
720         udelay(5000000);
721         return;
722 }
723 #endif // __i386__
724 static void test_single_cache(int iters, size_t size, int align, int flags,
725                               void (*ctor)(void *, size_t),
726                               void (*dtor)(void *, size_t))
727 {
728         struct kmem_cache *test_cache;
729         void *objects[iters];
730         test_cache = kmem_cache_create("test_cache", size, align, flags, ctor, dtor);
731         printk("Testing Kmem Cache:\n");
732         print_kmem_cache(test_cache);
733         for (int i = 0; i < iters; i++) {
734                 objects[i] = kmem_cache_alloc(test_cache, 0);
735                 printk("Buffer %d addr = %p\n", i, objects[i]);
736         }
737         for (int i = 0; i < iters; i++) {
738                 kmem_cache_free(test_cache, objects[i]);
739         }
740         kmem_cache_destroy(test_cache);
741         printk("\n\n\n\n");
742 }
743
744 void a_ctor(void *buf, size_t size)
745 {
746         printk("constructin tests\n");
747 }
748 void a_dtor(void *buf, size_t size)
749 {
750         printk("destructin tests\n");
751 }
752
753 void test_slab(void)
754 {
755         test_single_cache(10, 128, 512, 0, 0, 0);
756         test_single_cache(10, 128, 4, 0, a_ctor, a_dtor);
757         test_single_cache(10, 1024, 16, 0, 0, 0);
758 }
759
760 void test_kmalloc(void)
761 {
762         printk("Testing Kmalloc\n");
763         void *bufs[NUM_KMALLOC_CACHES + 1];     
764         size_t size;
765         for (int i = 0; i < NUM_KMALLOC_CACHES + 1; i++){
766                 size = (KMALLOC_SMALLEST << i) - KMALLOC_OFFSET;
767                 bufs[i] = kmalloc(size, 0);
768                 printk("Size %d, Addr = %p\n", size, bufs[i]);
769         }
770         for (int i = 0; i < NUM_KMALLOC_CACHES; i++) {
771                 printk("Freeing buffer %d\n", i);
772                 kfree(bufs[i]);
773         }
774         printk("Testing a large kmalloc\n");
775         size = (KMALLOC_LARGEST << 2);
776         bufs[0] = kmalloc(size, 0);
777         printk("Size %d, Addr = %p\n", size, bufs[0]);
778         kfree(bufs[0]);
779 }
780
781 static size_t test_hash_fn_col(void *k)
782 {
783         return (size_t)k % 2; // collisions in slots 0 and 1
784 }
785
786 void test_hashtable(void)
787 {
788         struct test {int x; int y;};
789         struct test tstruct[10];
790
791         struct hashtable *h;
792         uintptr_t k = 5;
793         struct test *v = &tstruct[0];
794
795         h = create_hashtable(32, __generic_hash, __generic_eq);
796         
797         // test inserting one item, then finding it again
798         printk("Tesing one item, insert, search, and removal\n");
799         if(!hashtable_insert(h, (void*)k, v))
800                 printk("Failed to insert to hashtable!\n");
801         v = NULL;
802         if (!(v = hashtable_search(h, (void*)k)))
803                 printk("Failed to find in hashtable!\n");
804         if (v != &tstruct[0])
805                 printk("Got the wrong item! (got %p, wanted %p)\n", v, &tstruct[0]);
806         v = NULL;
807         if (!(v = hashtable_remove(h, (void*)k)))
808                 printk("Failed to remove from hashtable!\n");
809         // shouldn't be able to find it again
810         if ((v = hashtable_search(h, (void*)k)))
811                 printk("Should not have been able to find in hashtable!\n");
812         
813         printk("Tesing a bunch of items, insert, search, and removal\n");
814         for (int i = 0; i < 10; i++) {
815                 k = i; // vary the key, we don't do KEY collisions
816                 if(!hashtable_insert(h, (void*)k, &tstruct[i]))
817                         printk("Failed to insert iter %d to hashtable!\n", i);
818         }
819         // read out the 10 items
820         for (int i = 0; i < 10; i++) {
821                 k = i;
822                 if (!(v = hashtable_search(h, (void*)k)))
823                         printk("Failed to find in hashtable!\n");
824                 if (v != &tstruct[i])
825                         printk("Got the wrong item! (got %p, wanted %p)\n", v, &tstruct[i]);
826         }
827         if (hashtable_count(h) != 10)
828                 printk("Wrong accounting of number of elements!\n");
829         // remove the 10 items
830         for (int i = 0; i < 10; i++) {
831                 k = i;
832                 if (!(v = hashtable_remove(h, (void*)k)))
833                         printk("Failed to remove from hashtable!\n");
834         }
835         // make sure they are all gone
836         for (int i = 0; i < 10; i++) {
837                 k = i;
838                 if ((v = hashtable_search(h, (void*)k)))
839                         printk("Should not have been able to find in hashtable!\n");
840         }
841         if (hashtable_count(h))
842                 printk("Wrong accounting of number of elements!\n");
843         hashtable_destroy(h);
844
845         // same test of a bunch of items, but with collisions.
846         printk("Tesing a bunch of items with collisions, etc.\n");
847         h = create_hashtable(32, test_hash_fn_col, __generic_eq);
848         // insert 10 items
849         for (int i = 0; i < 10; i++) {
850                 k = i; // vary the key, we don't do KEY collisions
851                 if(!hashtable_insert(h, (void*)k, &tstruct[i]))
852                         printk("Failed to insert iter %d to hashtable!\n", i);
853         }
854         // read out the 10 items
855         for (int i = 0; i < 10; i++) {
856                 k = i;
857                 if (!(v = hashtable_search(h, (void*)k)))
858                         printk("Failed to find in hashtable!\n");
859                 if (v != &tstruct[i])
860                         printk("Got the wrong item! (got %p, wanted %p)\n", v, &tstruct[i]);
861         }
862         if (hashtable_count(h) != 10)
863                 printk("Wrong accounting of number of elements!\n");
864         // remove the 10 items
865         for (int i = 0; i < 10; i++) {
866                 k = i;
867                 if (!(v = hashtable_remove(h, (void*)k)))
868                         printk("Failed to remove from hashtable!\n");
869         }
870         // make sure they are all gone
871         for (int i = 0; i < 10; i++) {
872                 k = i;
873                 if ((v = hashtable_search(h, (void*)k)))
874                         printk("Should not have been able to find in hashtable!\n");
875         }
876         if (hashtable_count(h))
877                 printk("Wrong accounting of number of elements!\n");
878         hashtable_destroy(h);
879 }
880
881 /* Ghetto test, only tests one prod or consumer at a time */
882 void test_bcq(void)
883 {
884         /* Tests a basic struct */
885         struct my_struct {
886                 int x;
887                 int y;
888         };
889         struct my_struct in_struct, out_struct;
890         
891         DEFINE_BCQ_TYPES(test, struct my_struct, 16);
892         struct test_bcq t_bcq;
893         bcq_init(&t_bcq, struct my_struct, 16);
894         
895         in_struct.x = 4;
896         in_struct.y = 5;
897         out_struct.x = 1;
898         out_struct.y = 2;
899         
900         bcq_enqueue(&t_bcq, &in_struct, 16, 5);
901         bcq_dequeue(&t_bcq, &out_struct, 16);
902         printk("out x %d. out y %d\n", out_struct.x, out_struct.y);
903         
904         /* Tests the BCQ a bit more, esp with overflow */
905         #define NR_ELEM_A_BCQ 8 /* NOTE: this must be a power of 2! */
906         DEFINE_BCQ_TYPES(my, int, NR_ELEM_A_BCQ);
907         struct my_bcq a_bcq;
908         bcq_init(&a_bcq, int, NR_ELEM_A_BCQ);
909         
910         int y = 2;
911         int output[100];
912         int retval[100];
913
914         /* Helpful debugger */
915         void print_a_bcq(struct my_bcq *bcq)
916         {
917                 printk("A BCQ (made of ints): %08p\n", bcq);
918                 printk("\tprod_idx: %08p\n", bcq->hdr.prod_idx);
919                 printk("\tcons_pub_idx: %08p\n", bcq->hdr.cons_pub_idx);
920                 printk("\tcons_pvt_idx: %08p\n", bcq->hdr.cons_pvt_idx);
921                 for (int i = 0; i < NR_ELEM_A_BCQ; i++) {
922                         printk("Element %d, rdy_for_cons: %02p\n", i,
923                                bcq->wraps[i].rdy_for_cons);
924                 }
925         }
926
927         /* Put in more than it can take */
928         for (int i = 0; i < 15; i++) {
929                 y = i;
930                 retval[i] = bcq_enqueue(&a_bcq, &y, NR_ELEM_A_BCQ, 10);
931                 printk("enqueued: %d, had retval %d \n", y, retval[i]);
932         }
933         //print_a_bcq(&a_bcq);
934         
935         /* Try to dequeue more than we put in */
936         for (int i = 0; i < 15; i++) {
937                 retval[i] = bcq_dequeue(&a_bcq, &output[i], NR_ELEM_A_BCQ);
938                 printk("dequeued: %d with retval %d\n", output[i], retval[i]);
939         }
940         //print_a_bcq(&a_bcq);
941         
942         /* Put in some it should be able to take */
943         for (int i = 0; i < 3; i++) {
944                 y = i;
945                 retval[i] = bcq_enqueue(&a_bcq, &y, NR_ELEM_A_BCQ, 10);
946                 printk("enqueued: %d, had retval %d \n", y, retval[i]);
947         }
948         
949         /* Take those, and then a couple extra */
950         for (int i = 0; i < 5; i++) {
951                 retval[i] = bcq_dequeue(&a_bcq, &output[i], NR_ELEM_A_BCQ);
952                 printk("dequeued: %d with retval %d\n", output[i], retval[i]);
953         }
954         
955         /* Try some one-for-one */
956         for (int i = 0; i < 5; i++) {
957                 y = i;
958                 retval[i] = bcq_enqueue(&a_bcq, &y, NR_ELEM_A_BCQ, 10);
959                 printk("enqueued: %d, had retval %d \n", y, retval[i]);
960                 retval[i] = bcq_dequeue(&a_bcq, &output[i], NR_ELEM_A_BCQ);
961                 printk("dequeued: %d with retval %d\n", output[i], retval[i]);
962         }
963 }
964
965 /* Test a simple concurrent send and receive (one prod, one cons).  We spawn a
966  * process that will go into _M mode on another core, and we'll do the test from
967  * an alarm handler run on our core.  When we start up the process, we won't
968  * return so we need to defer the work with an alarm. */
969 void test_ucq(void)
970 {
971         struct timer_chain *tchain = &per_cpu_info[core_id()].tchain;
972         struct alarm_waiter *waiter = kmalloc(sizeof(struct alarm_waiter), 0);
973
974         /* Alarm handler: what we want to do after the process is up */
975         void send_msgs(struct alarm_waiter *waiter)
976         {
977                 struct timer_chain *tchain;
978                 struct proc *old_proc, *p = waiter->data;
979                 struct ucq *ucq = (struct ucq*)USTACKTOP;
980                 struct event_msg msg;
981
982                 printk("Running the alarm handler!\n");
983                 /* might not be mmaped yet, if not, abort */
984                 if (!user_mem_check(p, ucq, PGSIZE, 1, PTE_USER_RW)) {
985                         printk("Not mmaped yet\n");
986                         goto abort;
987                 }
988                 /* load their address space */
989                 old_proc = switch_to(p);
990                 /* So it's mmaped, see if it is ready (note that this is dangerous) */
991                 if (!ucq->ucq_ready) {
992                         printk("Not ready yet\n");
993                         switch_back(p, old_proc);
994                         goto abort;
995                 }
996                 /* So it's ready, time to finally do the tests... */
997                 printk("[kernel] Finally starting the tests... \n");
998                 /* 1: Send a simple message */
999                 printk("[kernel] Sending simple message (7, deadbeef)\n");
1000                 msg.ev_type = 7;
1001                 msg.ev_arg2 = 0xdeadbeef;
1002                 send_ucq_msg(ucq, p, &msg);
1003                 /* 2: Send a bunch.  In a VM, this causes one swap, and then a bunch of
1004                  * mmaps. */
1005                 for (int i = 0; i < 5000; i++) {
1006                         msg.ev_type = i;
1007                         send_ucq_msg(ucq, p, &msg);
1008                 }
1009                 /* other things we could do:
1010                  *  - concurrent producers / consumers...  ugh.
1011                  */
1012                 /* done, switch back and free things */
1013                 switch_back(p, old_proc);
1014                 proc_decref(p);
1015                 kfree(waiter); /* since it was kmalloc()d */
1016                 return;
1017         abort:
1018                 tchain = &per_cpu_info[core_id()].tchain;
1019                 /* Set to run again */
1020                 set_awaiter_rel(waiter, 1000000);
1021                 set_alarm(tchain, waiter);
1022         }
1023         /* Set up a handler to run the real part of the test */
1024         init_awaiter(waiter, send_msgs);
1025         set_awaiter_rel(waiter, 1000000);       /* 1s should be long enough */
1026         set_alarm(tchain, waiter);
1027         /* Just spawn the program */
1028         struct file *program;
1029         program = do_file_open("/bin/ucq", 0, 0);
1030         if (!program) {
1031                 printk("Unable to find /bin/ucq!\n");
1032                 return;
1033         }
1034         char *p_envp[] = {"LD_LIBRARY_PATH=/lib", 0};
1035         struct proc *p = proc_create(program, 0, p_envp);
1036         spin_lock(&p->proc_lock);
1037         __proc_set_state(p, PROC_RUNNABLE_S);
1038         schedule_proc(p);
1039         spin_unlock(&p->proc_lock);
1040         /* instead of getting rid of the reference created in proc_create, we'll put
1041          * it in the awaiter */
1042         waiter->data = p;
1043         kref_put(&program->f_kref);
1044         /* Should never return from schedule (env_pop in there) also note you may
1045          * not get the process you created, in the event there are others floating
1046          * around that are runnable */
1047         schedule();
1048         assert(0);
1049 }
1050
1051 /* rudimentary tests.  does the basics, create, merge, split, etc.  Feel free to
1052  * add more, esp for the error conditions and finding free slots.  This is also
1053  * a bit lazy with setting the caller's fields (perm, flags, etc). */
1054 void test_vm_regions(void)
1055 {
1056         #define MAX_VMR_TESTS 10
1057         struct proc pr, *p = &pr;       /* too lazy to even create one */
1058         int n = 0;
1059         TAILQ_INIT(&p->vm_regions);
1060
1061         struct vmr_summary {
1062                 uintptr_t base; 
1063                 uintptr_t end; 
1064         };
1065         int check_vmrs(struct proc *p, struct vmr_summary *results, int len, int n)
1066         {
1067                 int count = 0;
1068                 struct vm_region *vmr;
1069                 TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
1070                         if (count >= len) {
1071                                 printk("More vm_regions than expected\n");
1072                                 break;
1073                         }
1074                         if ((vmr->vm_base != results[count].base) ||
1075                             (vmr->vm_end != results[count].end)) {
1076                                 printk("VM test case %d failed!\n", n);
1077                                 print_vmrs(p);
1078                                 return -1;
1079                         }
1080                         count++;
1081                 }
1082                 return count;
1083         }
1084         struct vm_region *vmrs[MAX_VMR_TESTS];
1085         struct vmr_summary results[MAX_VMR_TESTS];
1086
1087         memset(results, 0, sizeof(results));
1088         /* Make one */
1089         vmrs[0] = create_vmr(p, 0x2000, 0x1000);
1090         results[0].base = 0x2000;
1091         results[0].end = 0x3000;
1092         check_vmrs(p, results, 1, n++);
1093         /* Grow it */
1094         grow_vmr(vmrs[0], 0x4000);
1095         results[0].base = 0x2000;
1096         results[0].end = 0x4000;
1097         check_vmrs(p, results, 1, n++);
1098         /* Grow it poorly */
1099         if (-1 != grow_vmr(vmrs[0], 0x3000))
1100                 printk("Bad grow test failed\n");
1101         check_vmrs(p, results, 1, n++);
1102         /* Make another right next to it */
1103         vmrs[1] = create_vmr(p, 0x4000, 0x1000);
1104         results[1].base = 0x4000;
1105         results[1].end = 0x5000;
1106         check_vmrs(p, results, 2, n++);
1107         /* try to grow through it */
1108         if (-1 != grow_vmr(vmrs[0], 0x5000))
1109                 printk("Bad grow test failed\n");
1110         check_vmrs(p, results, 2, n++);
1111         /* Merge them */
1112         merge_vmr(vmrs[0], vmrs[1]);
1113         results[0].end = 0x5000;
1114         results[1].base = 0;
1115         results[1].end = 0;
1116         check_vmrs(p, results, 1, n++);
1117         vmrs[1]= create_vmr(p, 0x6000, 0x4000);
1118         results[1].base = 0x6000;
1119         results[1].end = 0xa000;
1120         check_vmrs(p, results, 2, n++);
1121         /* try to merge unmergables (just testing ranges) */
1122         if (-1 != merge_vmr(vmrs[0], vmrs[1]))
1123                 printk("Bad merge test failed\n");
1124         check_vmrs(p, results, 2, n++);
1125         vmrs[2] = split_vmr(vmrs[1], 0x8000);
1126         results[1].end = 0x8000;
1127         results[2].base = 0x8000;
1128         results[2].end = 0xa000;
1129         check_vmrs(p, results, 3, n++);
1130         /* destroy one */
1131         destroy_vmr(vmrs[1]);
1132         results[1].base = 0x8000;
1133         results[1].end = 0xa000;
1134         check_vmrs(p, results, 2, n++);
1135         /* shrink */
1136         shrink_vmr(vmrs[2], 0x9000);
1137         results[1].base = 0x8000;
1138         results[1].end = 0x9000;
1139         check_vmrs(p, results, 2, n++); /* 10 */
1140         if (vmrs[2] != find_vmr(p, 0x8500))
1141                 printk("Failed to find the right vmr!\n");
1142         if (vmrs[2] != find_first_vmr(p, 0x8500))
1143                 printk("Failed to find the right vmr!\n");
1144         if (vmrs[2] != find_first_vmr(p, 0x7500))
1145                 printk("Failed to find the right vmr!\n");
1146         if (find_first_vmr(p, 0x9500))
1147                 printk("Found a vmr when we shouldn't!\n");
1148         /* grow up to another */
1149         grow_vmr(vmrs[0], 0x8000);
1150         results[0].end = 0x8000;
1151         check_vmrs(p, results, 2, n++);
1152         vmrs[0]->vm_prot = 88;
1153         vmrs[2]->vm_prot = 77;
1154         /* should be unmergeable due to perms */
1155         if (-1 != merge_vmr(vmrs[0], vmrs[2]))
1156                 printk("Bad merge test failed\n");
1157         check_vmrs(p, results, 2, n++);
1158         /* should merge now */
1159         vmrs[2]->vm_prot = 88;
1160         merge_vmr(vmrs[0], vmrs[2]);
1161         results[0].end = 0x9000;
1162         check_vmrs(p, results, 1, n++);
1163         destroy_vmr(vmrs[0]);
1164         check_vmrs(p, results, 0, n++);
1165         /* Check the automerge function */
1166         vmrs[0] = create_vmr(p, 0x2000, 0x1000);
1167         vmrs[1] = create_vmr(p, 0x3000, 0x1000);
1168         vmrs[2] = create_vmr(p, 0x4000, 0x1000);
1169         for (int i = 0; i < 3; i++) {
1170                 vmrs[i]->vm_prot = PROT_READ;
1171                 vmrs[i]->vm_flags = 0;
1172                 vmrs[i]->vm_file = 0; /* would like to test this, it's a pain for now */
1173         }
1174         vmrs[0] = merge_me(vmrs[1]);
1175         results[0].base = 0x2000;
1176         results[0].end = 0x5000;
1177         check_vmrs(p, results, 1, n++);
1178         destroy_vmr(vmrs[0]);
1179         check_vmrs(p, results, 0, n++);
1180         /* Check unfixed creation requests */
1181         vmrs[0] = create_vmr(p, 0x0000, 0x1000);
1182         vmrs[1] = create_vmr(p, 0x0000, 0x1000);
1183         vmrs[2] = create_vmr(p, 0x0000, 0x1000);
1184         results[0].base = 0x0000;
1185         results[0].end  = 0x1000;
1186         results[1].base = 0x1000;
1187         results[1].end  = 0x2000;
1188         results[2].base = 0x2000;
1189         results[2].end  = 0x3000;
1190         check_vmrs(p, results, 3, n++);
1191
1192         printk("Finished vm_regions test!\n");
1193 }
1194
1195 void test_radix_tree(void)
1196 {
1197         struct radix_tree real_tree = RADIX_INITIALIZER;
1198         struct radix_tree *tree = &real_tree;
1199         void *retval;
1200
1201         if (radix_insert(tree, 0, (void*)0xdeadbeef))
1202                 printk("Failed to insert at 0!\n");
1203         radix_delete(tree, 0);
1204         if (radix_insert(tree, 0, (void*)0xdeadbeef))
1205                 printk("Failed to re-insert at 0!\n");
1206
1207         if (radix_insert(tree, 3, (void*)0xdeadbeef))
1208                 printk("Failed to insert first!\n");
1209         radix_insert(tree, 4, (void*)0x04040404);
1210         assert((void*)0xdeadbeef == radix_lookup(tree, 3));
1211         for (int i = 5; i < 100; i++)
1212                 if ((retval = radix_lookup(tree, i))) {
1213                         printk("Extra item %08p at slot %d in tree %08p\n", retval, i,
1214                                tree);
1215                         print_radix_tree(tree);
1216                         monitor(0);
1217                 }
1218         if (radix_insert(tree, 65, (void*)0xcafebabe))
1219                 printk("Failed to insert a two-tier!\n");
1220         if (!radix_insert(tree, 4, (void*)0x03030303))
1221                 printk("Should not let us reinsert\n");
1222         if (radix_insert(tree, 4095, (void*)0x4095))
1223                 printk("Failed to insert a two-tier boundary!\n");
1224         if (radix_insert(tree, 4096, (void*)0x4096))
1225                 printk("Failed to insert a three-tier!\n");
1226         //print_radix_tree(tree);
1227         radix_delete(tree, 65);
1228         radix_delete(tree, 3);
1229         radix_delete(tree, 4);
1230         radix_delete(tree, 4095);
1231         radix_delete(tree, 4096);
1232         //print_radix_tree(tree);
1233         printk("Finished radix tree tests!\n");
1234 }
1235
1236 /* Assorted FS tests, which were hanging around in init.c */
1237 void test_random_fs(void)
1238 {
1239         int retval = do_symlink("/dir1/sym", "/bin/hello", S_IRWXU);
1240         if (retval)
1241                 printk("symlink1 creation failed\n");
1242         retval = do_symlink("/symdir", "/dir1/dir1-1", S_IRWXU);
1243         if (retval)
1244                 printk("symlink1 creation failed\n");
1245         retval = do_symlink("/dir1/test.txt", "/dir2/test2.txt", S_IRWXU);
1246         if (retval)
1247                 printk("symlink2 creation failed\n");
1248         retval = do_symlink("/dir1/dir1-1/up", "../../", S_IRWXU);
1249         if (retval)
1250                 printk("symlink3 creation failed\n");
1251         retval = do_symlink("/bin/hello-sym", "hello", S_IRWXU);
1252         if (retval)
1253                 printk("symlink4 creation failed\n");
1254         
1255         struct dentry *dentry;
1256         struct nameidata nd_r = {0}, *nd = &nd_r;
1257         retval = path_lookup("/dir1/sym", 0, nd);
1258         if (retval)
1259                 printk("symlink lookup failed: %d\n", retval);
1260         char *symname = nd->dentry->d_inode->i_op->readlink(nd->dentry);
1261         printk("Pathlookup got %s (sym)\n", nd->dentry->d_name.name);
1262         if (!symname)
1263                 printk("symlink reading failed\n");
1264         else
1265                 printk("Symname: %s (/bin/hello)\n", symname);
1266         path_release(nd);
1267         /* try with follow */
1268         memset(nd, 0, sizeof(struct nameidata));
1269         retval = path_lookup("/dir1/sym", LOOKUP_FOLLOW, nd);
1270         if (retval)
1271                 printk("symlink lookup failed: %d\n", retval);
1272         printk("Pathlookup got %s (hello)\n", nd->dentry->d_name.name);
1273         path_release(nd);
1274         
1275         /* try with a directory */
1276         memset(nd, 0, sizeof(struct nameidata));
1277         retval = path_lookup("/symdir/f1-1.txt", 0, nd);
1278         if (retval)
1279                 printk("symlink lookup failed: %d\n", retval);
1280         printk("Pathlookup got %s (f1-1.txt)\n", nd->dentry->d_name.name);
1281         path_release(nd);
1282         
1283         /* try with a rel path */
1284         printk("Try with a rel path\n");
1285         memset(nd, 0, sizeof(struct nameidata));
1286         retval = path_lookup("/symdir/up/hello.txt", 0, nd);
1287         if (retval)
1288                 printk("symlink lookup failed: %d\n", retval);
1289         printk("Pathlookup got %s (hello.txt)\n", nd->dentry->d_name.name);
1290         path_release(nd);
1291         
1292         printk("Try for an ELOOP\n");
1293         memset(nd, 0, sizeof(struct nameidata));
1294         retval = path_lookup("/symdir/up/symdir/up/symdir/up/symdir/up/hello.txt", 0, nd);
1295         if (retval)
1296                 printk("Symlink lookup failed (it should): %d (-40)\n", retval);
1297         path_release(nd);
1298 }
1299
1300 /* simple test - start one, do something else, and resume it.  For lack of a
1301  * better infrastructure, we send ourselves a kmsg to run the kthread, which
1302  * we'll handle in smp_idle (which you may have to manually call).  Note this
1303  * doesn't test things like memory being leaked, or dealing with processes. */
1304 void test_kthreads(void)
1305 {
1306         /* Kernel message to restart our kthread */
1307         void test_up_sem(struct trapframe *tf, uint32_t srcid, long a0, long a1,
1308                          long a2)
1309         {
1310                 struct semaphore *sem = (struct semaphore*)a0;
1311                 struct kthread *kthread;
1312                 printk("[kmsg] Upping the sem to start the kthread, stacktop is %08p\n",
1313                        get_stack_top());
1314                 kthread = __up_sem(sem, FALSE);
1315                 if (!kthread) {
1316                         printk("[kmsg] Crap, the sem didn't have a kthread waiting!\n");
1317                         return;
1318                 }
1319                 printk("[kmsg] Restarting the kthread...\n");
1320                 restart_kthread(kthread);
1321                 panic("[kmsg] Damnit...");
1322         }
1323         struct semaphore sem;
1324         init_sem(&sem, 1);              /* set to 1 to test the unwind */
1325         printk("We're a kthread!  Stacktop is %08p.  Testing suspend, etc...\n",
1326                get_stack_top());
1327         /* So we have something that will wake us up.  Routine messages won't get
1328          * serviced in the kernel right away. */
1329         send_kernel_message(core_id(), test_up_sem, (long)&sem, 0, 0,
1330                             KMSG_ROUTINE);
1331         /* Actually block (or try to) */
1332         /* This one shouldn't block - but will test the unwind (if 1 above) */
1333         printk("About to sleep, but should unwind (signal beat us)\n");
1334         sleep_on(&sem);
1335         /* This one is for real, yo.  Run and tell that. */
1336         printk("About to sleep for real\n");
1337         sleep_on(&sem);
1338         printk("Kthread restarted!, Stacktop is %08p.\n", get_stack_top());
1339 }
1340
1341 /* Runs a simple test between core 0 (caller) and core 2 */
1342 void test_kref(void)
1343 {
1344         struct kref local_kref;
1345         bool done = FALSE;
1346         /* Second player's kmsg */
1347         void test_kref_2(struct trapframe *tf, uint32_t srcid, long a0, long a1,
1348                          long a2)
1349         {
1350                 struct kref *kref = (struct kref*)a0;
1351                 bool *done = (bool*)a1;
1352                 enable_irq();
1353                 for (int i = 0; i < 10000000; i++) {
1354                         kref_get(kref, 1);
1355                         set_core_timer(1, TRUE);
1356                         udelay(2);
1357                         kref_put(kref);
1358                 }
1359                 *done = TRUE;
1360         }
1361         
1362         kref_init(&local_kref, fake_release, 1);
1363         send_kernel_message(2, test_kref_2, (long)&local_kref, (long)&done, 0,
1364                             KMSG_ROUTINE);
1365         for (int i = 0; i < 10000000; i++) {
1366                 kref_get(&local_kref, 1);
1367                 udelay(2);
1368                 kref_put(&local_kref);
1369         }
1370         while (!done)
1371                 cpu_relax();
1372         assert(kref_refcnt(&local_kref) == 1);
1373         printk("[TEST-KREF] Simple 2-core getting/putting passed.\n");
1374 }
1375
1376 void test_atomics(void)
1377 {
1378         /* subtract_and_test */
1379         atomic_t num;
1380         /* Test subing to 0 */
1381         atomic_init(&num, 1);
1382         assert(atomic_sub_and_test(&num, 1) == 1);
1383         atomic_init(&num, 2);
1384         assert(atomic_sub_and_test(&num, 2) == 1);
1385         /* Test not getting to 0 */
1386         atomic_init(&num, 1);
1387         assert(atomic_sub_and_test(&num, 0) == 0);
1388         atomic_init(&num, 2);
1389         assert(atomic_sub_and_test(&num, 1) == 0);
1390         /* Test negatives */
1391         atomic_init(&num, -1);
1392         assert(atomic_sub_and_test(&num, 1) == 0);
1393         atomic_init(&num, -1);
1394         assert(atomic_sub_and_test(&num, -1) == 1);
1395         /* Test larger nums */
1396         atomic_init(&num, 265);
1397         assert(atomic_sub_and_test(&num, 265) == 1);
1398         atomic_init(&num, 265);
1399         assert(atomic_sub_and_test(&num, 2) == 0);
1400
1401         /* CAS */
1402         /* Simple test, make sure the bool retval of CAS handles failure */
1403         void test_cas_val(long init_val)
1404         {
1405                 atomic_t actual_num;
1406                 long old_num;
1407                 int attempt;
1408                 atomic_init(&actual_num, init_val);
1409                 attempt = 0;
1410                 do {
1411                         old_num = atomic_read(&actual_num);
1412                         /* First time, try to fail */
1413                         if (attempt == 0) 
1414                                 old_num++;
1415                         attempt++;      
1416                 } while (!atomic_cas(&actual_num, old_num, old_num + 10));
1417                 if (atomic_read(&actual_num) != init_val + 10)
1418                         printk("FUCK, CAS test failed for %d\n", init_val);
1419         }
1420         test_cas_val(257);
1421         test_cas_val(1);
1422 }
1423
1424 /* x86 test, making sure our cpu_halt() and irq_handler() work.  If you want to
1425  * see it fail, you'll probably need to put a nop in the asm for cpu_halt(), and
1426  * comment out abort_halt() in irq_handler(). */
1427 void test_abort_halt(void)
1428 {
1429 #ifdef __i386__
1430         /* Core 1 does this, while core 0 hammers it with interrupts */
1431         void test_try_halt(struct trapframe *tf, uint32_t srcid, long a0, long a1,
1432                            long a2)
1433         {
1434                 disable_irq();
1435                 /* wait 10 sec.  should have a bunch of ints pending */
1436                 udelay(10000000);
1437                 printk("Core 1 is about to halt\n");
1438                 cpu_halt();
1439                 printk("Returned from halting on core 1\n");
1440         }
1441         send_kernel_message(1, test_try_halt, 0, 0, 0, KMSG_ROUTINE);
1442         /* wait 1 sec, enough time to for core 1 to be in its KMSG */
1443         udelay(1000000);
1444         /* Send an IPI */
1445         send_ipi(get_hw_coreid(0x01), I_TESTING);
1446         printk("Core 0 sent the IPI\n");
1447 #endif /* __i386__ */
1448 }