Add the beginings of a SPARC port. Edit page-types to work on SPARC

6 files changed, 115 insertions, 58 deletions

diff --git a/Documentation/vm/page-types.c b/Documentation/vm/page-types.c
index 7445caa26d05..fe230def50d6 100644
--- a/Documentation/vm/page-types.c
+++ b/Documentation/vm/page-types.c
@@ -36,6 +36,8 @@
 #include <sys/statfs.h>
 #include "../../include/linux/magic.h"
 
+#define COLOR_MASK 0x1fULL
+
 
 #ifndef MAX_PATH
 # define MAX_PATH 256
@@ -181,13 +183,13 @@ static pid_t		opt_pid;	/* process to walk */
 
 #define MAX_ADDR_RANGES 1024
 static int              nr_addr_ranges;
-static unsigned long    opt_offset[MAX_ADDR_RANGES];
-static unsigned long    opt_size[MAX_ADDR_RANGES];
+static unsigned long long       opt_offset[MAX_ADDR_RANGES];
+static unsigned long long       opt_size[MAX_ADDR_RANGES];
 
 #define MAX_VMAS        10240
 static int              nr_vmas;
-static unsigned long    pg_start[MAX_VMAS];
-static unsigned long    pg_end[MAX_VMAS];
+static unsigned long long       pg_start[MAX_VMAS];
+static unsigned long long       pg_end[MAX_VMAS];
 
 #define MAX_BIT_FILTERS 64
 static int              nr_bit_filters;
@@ -259,21 +261,26 @@ static int checked_open(const char *pathname, int flags)
         return fd;
 }
 
+#define _LARGEFILE64_SOURCE
+
 /*
  * pagemap/kpageflags routines
  */
 
 static unsigned long do_u64_read(int fd, char *name,
                                  uint64_t *buf,
-                                 unsigned long index,
+                                 unsigned long long index,
                                  unsigned long count)
 {
         long bytes;
+        long long lseek_ret;
 
-        if (index > ULONG_MAX / 8)
-                fatal("index overflow: %lu\n", index);
+        if (index > ULLONG_MAX / 8)
+                fatal("index overflow: %llu\n", index);
 
-        if (lseek(fd, index * 8, SEEK_SET) < 0) {
+
+        lseek_ret = lseek64(fd, index * 8, SEEK_SET);
+        if (lseek_ret < 0) {
                 perror(name);
                 exit(EXIT_FAILURE);
         }
@@ -290,14 +297,14 @@ static unsigned long do_u64_read(int fd, char *name,
 }
 
 static unsigned long kpageflags_read(uint64_t *buf,
-                                     unsigned long index,
+                                     unsigned long long index,
                                      unsigned long pages)
 {
         return do_u64_read(kpageflags_fd, PROC_KPAGEFLAGS, buf, index, pages);
 }
 
 static unsigned long pagemap_read(uint64_t *buf,
-                                  unsigned long index,
+                                  unsigned long long index,
                                   unsigned long pages)
 {
         return do_u64_read(pagemap_fd, "/proc/pid/pagemap", buf, index, pages);
@@ -364,7 +371,7 @@ static char *page_flag_longname(uint64_t flags)
  */
 
 static void show_page_range(unsigned long voffset,
-                            unsigned long offset, uint64_t flags)
+                            unsigned long long offset, uint64_t flags)
 {
         static uint64_t      flags0;
         static unsigned long voff;
@@ -391,11 +398,11 @@ static void show_page_range(unsigned long voffset,
 }
 
 static void show_page(unsigned long voffset,
-                      unsigned long offset, uint64_t flags)
+                      unsigned long long offset, uint64_t flags)
 {
         if (opt_pid)
                 printf("%lx\t", voffset);
-        printf("%lx\t%s\n", offset, page_flag_name(flags));
+        printf("%llx (%llu)\t%s\n", offset, offset & COLOR_MASK, page_flag_name(flags));
 }
 
 static void show_summary(void)
@@ -640,7 +647,7 @@ static int hash_slot(uint64_t flags)
 }
 
 static void add_page(unsigned long voffset,
-                     unsigned long offset, uint64_t flags)
+                     unsigned long long offset, uint64_t flags)
 {
         flags = kpageflags_flags(flags);
 
@@ -663,7 +670,7 @@ static void add_page(unsigned long voffset,
 
 #define KPAGEFLAGS_BATCH        (64 << 10)      /* 64k pages */
 static void walk_pfn(unsigned long voffset,
-                     unsigned long index,
+                     unsigned long long index,
                      unsigned long count)
 {
         uint64_t buf[KPAGEFLAGS_BATCH];
@@ -686,10 +693,10 @@ static void walk_pfn(unsigned long voffset,
 }
 
 #define PAGEMAP_BATCH   (64 << 10)
-static void walk_vma(unsigned long index, unsigned long count)
+static void walk_vma(unsigned long long index, unsigned long count)
 {
         uint64_t buf[PAGEMAP_BATCH];
-        unsigned long batch;
+        unsigned long long batch;
         unsigned long pages;
         unsigned long pfn;
         unsigned long i;
@@ -711,10 +718,10 @@ static void walk_vma(unsigned long index, unsigned long count)
         }
 }
 
-static void walk_task(unsigned long index, unsigned long count)
+static void walk_task(unsigned long long index, unsigned long long count)
 {
-        const unsigned long end = index + count;
-        unsigned long start;
+        const unsigned long long end = index + count;
+        unsigned long long start;
         int i = 0;
 
         while (index < end) {
@@ -725,21 +732,21 @@ static void walk_task(unsigned long index, unsigned long count)
                 if (pg_start[i] >= end)
                         return;
 
-                start = max_t(unsigned long, pg_start[i], index);
-                index = min_t(unsigned long, pg_end[i], end);
+                start = max_t(unsigned long long, pg_start[i], index);
+                index = min_t(unsigned long long, pg_end[i], end);
 
                 assert(start < index);
                 walk_vma(start, index - start);
         }
 }
 
-static void add_addr_range(unsigned long offset, unsigned long size)
+static void add_addr_range(unsigned long long offset, unsigned long long size)
 {
         if (nr_addr_ranges >= MAX_ADDR_RANGES)
                 fatal("too many addr ranges\n");
 
         opt_offset[nr_addr_ranges] = offset;
-        opt_size[nr_addr_ranges] = min_t(unsigned long, size, ULONG_MAX-offset);
+        opt_size[nr_addr_ranges] = min_t(unsigned long long, size, ULLONG_MAX-offset);
         nr_addr_ranges++;
 }
 
@@ -750,7 +757,7 @@ static void walk_addr_ranges(void)
         kpageflags_fd = checked_open(PROC_KPAGEFLAGS, O_RDONLY);
 
         if (!nr_addr_ranges)
-                add_addr_range(0, ULONG_MAX);
+                add_addr_range(0, ULLONG_MAX);
 
         for (i = 0; i < nr_addr_ranges; i++)
                 if (!opt_pid)
@@ -857,15 +864,15 @@ static void parse_pid(const char *str)
         }
 
         while (fgets(buf, sizeof(buf), file) != NULL) {
-                unsigned long vm_start;
-                unsigned long vm_end;
+                unsigned long long vm_start;
+                unsigned long long vm_end;
                 unsigned long long pgoff;
                 int major, minor;
                 char r, w, x, s;
                 unsigned long ino;
                 int n;
 
-                n = sscanf(buf, "%lx-%lx %c%c%c%c %llx %x:%x %lu",
+                n = sscanf(buf, "%llx-%llx %c%c%c%c %llx %x:%x %lu",
                            &vm_start,
                            &vm_end,
                            &r, &w, &x, &s,
@@ -892,8 +899,8 @@ static void parse_file(const char *name)
 
 static void parse_addr_range(const char *optarg)
 {
-        unsigned long offset;
-        unsigned long size;
+        unsigned long long offset;
+        unsigned long long size;
         char *p;
 
         p = strchr(optarg, ',');
@@ -906,12 +913,12 @@ static void parse_addr_range(const char *optarg)
         } else if (p) {
                 offset = parse_number(optarg);
                 if (p[1] == '\0')
-                        size = ULONG_MAX;
+                        size = ULLONG_MAX;
                 else {
                         size = parse_number(p + 1);
                         if (*p == ',') {
                                 if (size < offset)
-                                        fatal("invalid range: %lu,%lu\n",
+                                        fatal("invalid range: %llu,%llu\n",
                                                         offset, size);
                                 size -= offset;
                         }
diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig
index 253986bd6bb6..6bc40d9e3007 100644
--- a/arch/sparc/Kconfig
+++ b/arch/sparc/Kconfig
@@ -606,3 +606,12 @@ source "security/Kconfig"
 source "crypto/Kconfig"
 
 source "lib/Kconfig"
+
+config ARCH_HAS_FEATHER_TRACE
+        def_bool n
+
+# Probably add these later
+config ARCH_HAS_SEND_PULL_TIMERS
+        def_bool n
+
+source "litmus/Kconfig"
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index b0b99e814314..ed9b7d20a763 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -74,7 +74,11 @@ struct control_page {
 
 #ifndef __KERNEL__
 /* XXX This is a terrible hack. */
+#if defined(CONFIG_X86)
 #define PAGE_SIZE 4096
+#elif defined(CONFIG_SPARC) || (ARCH == sparc64)
+#define PAGE_SIZE 8192
+#endif /* X86/SPARC */
 #endif
 typedef uint8_t color_t;
 #define COLORS_PER_CONTROL_PAGE (PAGE_SIZE / sizeof(color_t))
diff --git a/litmus/color.c b/litmus/color.c
index 7b23703f6206..dad2f07b154a 100644
--- a/litmus/color.c
+++ b/litmus/color.c
@@ -6,6 +6,7 @@
 #include <linux/sysctl.h>
 #include <linux/lockdep.h>
 #include <linux/sched.h> /* required by litmus.h */
+#include <asm/io.h> /* page_to_phys on SPARC */
 
 #include <litmus/color.h>
 #include <litmus/litmus.h> /* for in_list(...) */
@@ -37,7 +38,9 @@ static struct color_group *color_groups;
 
 /* non-static: extern'ed in various files */
 unsigned long nr_colors;
+#ifdef CONFIG_X86
 struct color_cache_info color_cache_info;
+#endif
 int color_sysctl_add_pages_data;
 int color_sysctl_reclaim_pages_data;
 
@@ -115,8 +118,14 @@ static int do_add_pages(void)
         int ret = 0;
 
         while (smallest_nr_pages() < PAGES_PER_COLOR) {
+#if defined(CONFIG_X86)
                 page = alloc_page(GFP_HIGHUSER | __GFP_ZERO |
                                 __GFP_MOVABLE);
+#elif defined(CONFIG_SPARC) /* X86 */
+                page = alloc_page(GFP_HIGHUSER | __GFP_MOVABLE);
+#else
+#error What architecture are you using?
+#endif
                 if (unlikely(!page)) {
                         printk(KERN_WARNING "Could not allocate pages.\n");
                         ret = -ENOMEM;
@@ -147,7 +156,11 @@ static int do_reclaim_pages(void)
                         ClearPageLRU(page);
                         add_page_to_color_list(page);
                         nr_reclaimed++;
+                        TRACE_CUR("reclaiming page (pa:0x%10llx, pfn:%8lu, "
+                                        "color:%3lu)\n", page_to_phys(page),
+                                        page_to_pfn(page), page_color(page));
                 }
+
         }
         spin_unlock(&alloced_pages.lock);
         TRACE_CUR("Reclaimed %lu pages.\n", nr_reclaimed);
@@ -212,6 +225,7 @@ out:
  * Initialization
 ***********************************************************/
 
+#if defined(CONFIG_X86)
 /* slowest possible way to find a log, but we only do this once on boot */
 static unsigned int __init slow_log(unsigned int v)
 {
@@ -221,9 +235,24 @@ static unsigned int __init slow_log(unsigned int v)
         return r;
 }
 
-static void __init init_mask(void)
+static int __init init_mask(void)
 {
-        const unsigned int line_size_log = slow_log(color_cache_info.line_size);
+        unsigned int line_size_log = slow_log(color_cache_info.line_size);
+        int err = 0;
+
+        BUG_ON(color_cache_info.size <= 1048576 ||
+                        color_cache_info.ways < 15 ||
+                        color_cache_info.line_size != 64);
+
+        printk("Cache size: %lu  line-size: %lu  ways: %lu  sets: %lu\n",
+                        color_cache_info.size, color_cache_info.line_size,
+                        color_cache_info.ways, color_cache_info.sets);
+        if (!color_cache_info.size) {
+                printk(KERN_WARNING "No cache information found.\n");
+                err = -EINVAL;
+                goto out;
+        }
+
 
         BUG_ON(color_cache_info.size / color_cache_info.line_size /
                         color_cache_info.ways != color_cache_info.sets);
@@ -231,21 +260,31 @@ static void __init init_mask(void)
         color_mask = ((color_cache_info.sets << line_size_log) - 1) ^
                 (PAGE_SIZE - 1);
         nr_colors = (color_mask >> PAGE_SHIFT) + 1;
-        printk("Color mask: 0x%lx  Total colors: %lu\n", color_mask,
-                        nr_colors);
-        BUG_ON(LOCKDEP_MAX_NR_COLORS < nr_colors);
+out:
+        return err;
+}
+#elif defined(CONFIG_SPARC) /* X86 */
+static int __init init_mask(void)
+{
+        /* bits 17:13 */
+        color_mask = 0x3e000UL;
+        nr_colors = (1 << hweight_long(color_mask));
+        return 0;
 }
+#endif /* SPARC/X86 */
+
+
 
 static int __init init_color_groups(void)
 {
         struct color_group *cgroup;
         unsigned long i;
-        int ret = 0;
+        int err = 0;
 
         color_groups = kmalloc(nr_colors * sizeof(struct color_group), GFP_KERNEL);
         if (!color_groups) {
                 printk(KERN_WARNING "Could not allocate color groups.\n");
-                ret = -ENOMEM;
+                err = -ENOMEM;
                 goto out;
         }
 
@@ -258,33 +297,24 @@ static int __init init_color_groups(void)
                                 cgroup->_lock_name, "color%lu", i);
         }
 out:
-        return ret;
+        return err;
 }
 
 static int __init init_color(void)
 {
-        int ret = 0;
+        int err = 0;
         printk("Initializing LITMUS^RT cache coloring.\n");
 
-        BUG_ON(color_cache_info.size <= 1048576 ||
-                        color_cache_info.ways < 15 ||
-                        color_cache_info.line_size != 64);
         INIT_LIST_HEAD(&alloced_pages.list);
         spin_lock_init(&alloced_pages.lock);
 
-        printk("Cache size: %lu  line-size: %lu  ways: %lu  sets: %lu\n",
-                        color_cache_info.size, color_cache_info.line_size,
-                        color_cache_info.ways, color_cache_info.sets);
-        if (!color_cache_info.size) {
-                printk(KERN_WARNING "No cache information found.\n");
-                ret = -EINVAL;
-                goto out;
-        }
+        err = init_mask();
+        printk("PAGE_SIZE: %lu  Color mask: 0x%lx  Total colors: %lu\n",
+                        PAGE_SIZE, color_mask, nr_colors);
 
-        init_mask();
-        ret = init_color_groups();
-out:
-        return ret;
+        BUG_ON(LOCKDEP_MAX_NR_COLORS < nr_colors);
+        err = init_color_groups();
+        return err;
 }
 
 module_init(init_color);
diff --git a/litmus/color_dev.c b/litmus/color_dev.c
index e1404142c18a..10ab1e6b1161 100644
--- a/litmus/color_dev.c
+++ b/litmus/color_dev.c
@@ -4,6 +4,8 @@
 #include <linux/miscdevice.h>
 #include <linux/spinlock.h>
 #include <linux/module.h>
+#include <linux/highmem.h>
+#include <asm/io.h> /* page_to_phys on SPARC */
 
 #include <litmus/litmus.h>
 #include <litmus/color.h>
@@ -168,8 +170,12 @@ static int do_map_colored_pages(struct vm_area_struct *vma)
                         TRACE_CUR(ALLOC_NAME ": Could not get page with "
                                         " color %lu.\n", this_color);
                         /* TODO unmap mapped pages */
+                        err = -ENOMEM;
                         break;
                 }
+#ifdef CONFIG_SPARC
+                clear_user_highpage(page, addr);
+#endif
                 TRACE_CUR(ALLOC_NAME ": insert page (pa:0x%10llx, pfn:%8lu, "
                                 "color:%3lu) at 0x%lx\n", page_to_phys(page),
                                 page_to_pfn(page), this_color, addr);
@@ -178,6 +184,7 @@ static int do_map_colored_pages(struct vm_area_struct *vma)
                         TRACE_CUR(ALLOC_NAME ": vm_insert_page() failed "
                                         "(%d)\n", err);
                         /* TODO unmap mapped pages */
+                        err = -EINVAL;
                         break;
                 }
                 add_page_to_alloced_list(page);
diff --git a/litmus/sched_litmus.c b/litmus/sched_litmus.c
index 5a15ce938984..6553948407de 100644
--- a/litmus/sched_litmus.c
+++ b/litmus/sched_litmus.c
@@ -102,9 +102,9 @@ litmus_schedule(struct rq *rq, struct task_struct *prev)
                         }
                 }
 #ifdef  __ARCH_WANT_UNLOCKED_CTXSW
-                if (next->oncpu)
+                if (next->on_cpu)
                         TRACE_TASK(next, "waiting for !oncpu");
-                while (next->oncpu) {
+                while (next->on_cpu) {
                         cpu_relax();
                         mb();
                 }