Fixes elf panic
[akaros.git] / kern / src / colored_caches.c
index 38bcc12..bec3819 100644 (file)
 
 #include <ros/common.h>
 #include <arch/mmu.h>
-#include <arch/bitmask.h>
+#include <bitmask.h>
 #include <colored_caches.h>
 #include <stdio.h>
 #include <atomic.h>
 #include <kmalloc.h>
+#include <page_alloc.h>
 
 #define l1 (available_caches.l1)
 #define l2 (available_caches.l2)
 #define l3 (available_caches.l3)
 
-spinlock_t cache_colors_lock;
+spinlock_t cache_colors_lock = SPINLOCK_INITIALIZER_IRQSAVE;
 
 /************** Cache Related Functions  *****************/
 inline void init_cache_properties(cache_t *c, size_t sz_k, size_t wa, size_t clsz) {
@@ -30,9 +31,13 @@ inline void init_cache_properties(cache_t *c, size_t sz_k, size_t wa, size_t cls
        c->sz_k = SINIT(sz_k);
        c->clsz = SINIT(clsz);
 
+#ifdef CONFIG_PAGE_COLORING
        //Added as optimization (derived from above);
        size_t nc = get_cache_num_page_colors(c);
        c->num_colors = SINIT(nc);
+#else
+       c->num_colors = 1;
+#endif
 }
 
 inline void init_free_cache_colors_map(cache_t* c) 
@@ -42,9 +47,6 @@ inline void init_free_cache_colors_map(cache_t* c)
        FILL_BITMASK(c->free_colors_map, c->num_colors);
 }
 
-inline size_t get_page_color(uintptr_t page, cache_t *c) {
-    return (page % c->num_colors);
-}
 inline size_t get_offset_in_cache_line(uintptr_t addr, cache_t *c) {
     return (addr % get_cache_bytes_per_line(c));
 }
@@ -167,7 +169,7 @@ static inline void clr_color_range(uint16_t color, uint8_t* map,
 }
 
 static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c, 
-                                                              struct proc* p) 
+                                                         uint8_t* colors_map) 
 {
        if(!GET_BITMASK_BIT(c->free_colors_map, color))
                return -ENOCACHE;       
@@ -179,12 +181,11 @@ static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c,
        if(l3)
                clr_color_range(color, l3->free_colors_map, c, l3);
 
-       printk("I am here now three...\n");
-       set_color_range(color, p->cache_colors_map, c, llc_cache);
+       set_color_range(color, colors_map, c, llc_cache);
        return ESUCCESS;
 }
 
-static inline error_t __cache_color_alloc(cache_t* c, struct proc* p) 
+static inline error_t __cache_color_alloc(cache_t* c, uint8_t* colors_map) 
 {
        if(BITMASK_IS_CLEAR(c->free_colors_map, c->num_colors))
                return -ENOCACHE;       
@@ -195,18 +196,18 @@ static inline error_t __cache_color_alloc(cache_t* c, struct proc* p)
                        break;
        } while(++color);
 
-       return __cache_color_alloc_specific(color, c, p);       
+       return __cache_color_alloc_specific(color, c, colors_map);      
 }
 
 static inline void __cache_color_free_specific(size_t color, cache_t* c, 
-                                                          struct proc* p) 
+                                                     uint8_t* colors_map) 
 {
        if(GET_BITMASK_BIT(c->free_colors_map, color))
                return;
        else {
                size_t r = llc_cache->num_colors / c->num_colors;
                size_t base = color*r;
-               if(!BITMASK_IS_SET_IN_RANGE(p->cache_colors_map, base, base+r))
+               if(!BITMASK_IS_SET_IN_RANGE(colors_map, base, base+r))
                        return;
        }
 
@@ -217,10 +218,10 @@ static inline void __cache_color_free_specific(size_t color, cache_t* c,
        if(l1)
                set_color_range(color, l1->free_colors_map, c, l1);
 
-       clr_color_range(color, p->cache_colors_map, c, llc_cache);
+       clr_color_range(color, colors_map, c, llc_cache);
 }
 
-static inline void __cache_color_free(cache_t* c, struct proc* p) 
+static inline void __cache_color_free(cache_t* c, uint8_t* colors_map) 
 {
        if(BITMASK_IS_FULL(c->free_colors_map, c->num_colors))
                return; 
@@ -230,41 +231,58 @@ static inline void __cache_color_free(cache_t* c, struct proc* p)
                if(!GET_BITMASK_BIT(c->free_colors_map, color)) {
                        size_t r = llc_cache->num_colors / c->num_colors;
                        size_t base = color*r;
-                       if(BITMASK_IS_SET_IN_RANGE(p->cache_colors_map, base, base+r))
+                       if(BITMASK_IS_SET_IN_RANGE(colors_map, base, base+r))
                                break;
                }
        } while(++color < c->num_colors);
        if(color == c->num_colors)
                return;
 
-       __cache_color_free_specific(color, c, p);       
+       __cache_color_free_specific(color, c, colors_map);      
+}
+
+uint8_t* cache_colors_map_alloc() {
+#ifdef CONFIG_PAGE_COLORING
+       uint8_t* colors_map = kmalloc(llc_cache->num_colors, 0);
+       if(colors_map)
+               CLR_BITMASK(colors_map, llc_cache->num_colors);
+       return colors_map;
+#else
+       return global_cache_colors_map;
+#endif
+}
+
+void cache_colors_map_free(uint8_t* colors_map) {
+#ifdef CONFIG_PAGE_COLORING
+       kfree(colors_map);
+#endif
 }
 
-error_t cache_color_alloc(cache_t* c, struct proc* p) 
+error_t cache_color_alloc(cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       error_t e = __cache_color_alloc(c, p);
+       error_t e = __cache_color_alloc(c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
        return e;
 }
-error_t cache_color_alloc_specific(size_t color, cache_t* c, struct proc* p) 
+error_t cache_color_alloc_specific(size_t color, cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       error_t e = __cache_color_alloc_specific(color, c, p);
+       error_t e = __cache_color_alloc_specific(color, c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
        return e;
 }
 
-void cache_color_free(cache_t* c, struct proc* p) 
+void cache_color_free(cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       __cache_color_free(c, p);
+       __cache_color_free(c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
 }
-void cache_color_free_specific(size_t color, cache_t* c, struct proc* p) 
+void cache_color_free_specific(size_t color, cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       __cache_color_free_specific(color, c, p);
+       __cache_color_free_specific(color, c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
 }