kern/src/manager.c

   1 /*
   2  * Copyright (c) 2009 The Regents of the University of California
   3  * Barret Rhoden <brho@cs.berkeley.edu>
   4  * See LICENSE for details.
   5  */
   6
   7
   8 #ifdef __SHARC__
   9 #pragma nosharc
  10 #endif
  11
  12 #include <ros/common.h>
  13 #include <smp.h>
  14 #include <arch/init.h>
  15 #include <mm.h>
  16 #include <elf.h>
  17 #include <frontend.h>
  18
  19 #include <kmalloc.h>
  20 #include <assert.h>
  21 #include <manager.h>
  22 #include <process.h>
  23 #include <schedule.h>
  24 #include <syscall.h>
  25 #include <testing.h>
  26 #include <kfs.h>
  27 #include <stdio.h>
  28 #include <time.h>
  29 #include <monitor.h>
  30 #include <colored_caches.h>
  31 #include <string.h>
  32 #include <pmap.h>
  33 #include <arch/console.h>
  34 #include <ros/time.h>
  35 #include <ros/arch/membar.h>
  36
  37 /*
  38  * Currently, if you leave this function by way of proc_run (process_workqueue
  39  * that proc_runs), you will never come back to where you left off, and the
  40  * function will start from the top.  Hence the hack 'progress'.
  41  */
  42 void manager(void)
  43 {
  44         #ifndef DEVELOPER_NAME
  45                 #define DEVELOPER_NAME brho
  46         #endif
  47
  48         // LoL
  49         #define PASTE(s1,s2) s1 ## s2
  50         #define MANAGER_FUNC(dev) PASTE(manager_,dev)
  51
  52         void MANAGER_FUNC(DEVELOPER_NAME)(void);
  53         MANAGER_FUNC(DEVELOPER_NAME)();
  54 }
  55
  56 char *p_argv[] = {0, 0, 0};
  57 char *p_envp[] = {"LD_LIBRARY_PATH=/lib", 0};
  58 /* Helper macro for quickly running a process.  Pass it a string, *file, and a
  59  * *proc. */
  60 #define quick_proc_run(x, p, f)                                                  \
  61         (f) = do_file_open((x), 0, 0);                                               \
  62         assert((f));                                                                 \
  63         p_argv[0] = file_name((f));                                                  \
  64         (p) = proc_create((f), p_argv, p_envp);                                      \
  65         kref_put(&(f)->f_kref);                                                      \
  66         spin_lock(&(p)->proc_lock);                                                  \
  67         __proc_set_state((p), PROC_RUNNABLE_S);                                      \
  68         spin_unlock(&(p)->proc_lock);                                                \
  69         proc_run_s((p));                                                             \
  70         proc_decref((p));
  71
  72 #define quick_proc_create(x, p, f)                                               \
  73         (f) = do_file_open((x), 0, 0);                                               \
  74         assert((f));                                                                 \
  75         p_argv[0] = file_name((f));                                                  \
  76         (p) = proc_create((f), p_argv, p_envp);                                      \
  77         kref_put(&(f)->f_kref);                                                      \
  78         spin_lock(&(p)->proc_lock);                                                  \
  79         __proc_set_state((p), PROC_RUNNABLE_S);                                      \
  80         spin_unlock(&(p)->proc_lock);
  81
  82 #define quick_proc_color_run(x, p, c, f)                                         \
  83         (f) = do_file_open((x), 0, 0);                                               \
  84         assert((f));                                                                 \
  85         p_argv[0] = file_name((f));                                                  \
  86         (p) = proc_create((f), p_argv, p_envp);                                      \
  87         kref_put(&(f)->f_kref);                                                      \
  88         spin_lock(&(p)->proc_lock);                                                  \
  89         __proc_set_state((p), PROC_RUNNABLE_S);                                      \
  90         spin_unlock(&(p)->proc_lock);                                                \
  91         p->cache_colors_map = cache_colors_map_alloc();                              \
  92         for (int i = 0; i < (c); i++)                                                \
  93                 cache_color_alloc(llc_cache, p->cache_colors_map);                       \
  94         proc_run_s((p));                                                             \
  95         proc_decref((p));
  96
  97 #define quick_proc_color_create(x, p, c, f)                                      \
  98         (f) = do_file_open((x), 0, 0);                                               \
  99         assert((f));                                                                 \
 100         p_argv[0] = file_name((f));                                                  \
 101         (p) = proc_create((f), p_argv, p_envp);                                      \
 102         kref_put(&(f)->f_kref);                                                      \
 103         spin_lock(&(p)->proc_lock);                                                  \
 104         __proc_set_state((p), PROC_RUNNABLE_S);                                      \
 105         spin_unlock(&(p)->proc_lock);                                                \
 106         p->cache_colors_map = cache_colors_map_alloc();                              \
 107         for (int i = 0; i < (c); i++)                                                \
 108                 cache_color_alloc(llc_cache, p->cache_colors_map);
 109
 110 void manager_brho(void)
 111 {
 112         static bool first = TRUE;
 113         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 114
 115         if (first) {
 116                 printk("*** Hit shift-g to get into the monitor. ***\n");
 117                 first = FALSE;
 118         }
 119         /* just idle, and deal with things via interrupts.  or via face. */
 120         smp_idle();
 121         /* whatever we do in the manager, keep in mind that we need to not do
 122          * anything too soon (like make processes), since we'll drop in here during
 123          * boot if the boot sequence required any I/O (like EXT2), and we need to
 124          * PRKM() */
 125         assert(0);
 126
 127 #if 0 /* ancient tests below: (keeping around til we ditch the manager) */
 128         // for testing taking cores, check in case 1 for usage
 129         uint32_t corelist[MAX_NUM_CPUS];
 130         uint32_t num = 3;
 131         struct file *temp_f;
 132         static struct proc *p;
 133
 134         static uint8_t RACY progress = 0;       /* this will wrap around. */
 135         switch (progress++) {
 136                 case 0:
 137                         printk("Top of the manager to ya!\n");
 138                         /* 124 is half of the available boxboro colors (with the kernel
 139                          * getting 8) */
 140                         //quick_proc_color_run("msr_dumb_while", p, 124, temp_f);
 141                         quick_proc_run("/bin/hello", p, temp_f);
 142                         #if 0
 143                         // this is how you can transition to a parallel process manually
 144                         // make sure you don't proc run first
 145                         __proc_set_state(p, PROC_RUNNING_S);
 146                         __proc_set_state(p, PROC_RUNNABLE_M);
 147                         p->resources[RES_CORES].amt_wanted = 5;
 148                         spin_unlock(&p->proc_lock);
 149                         core_request(p);
 150                         panic("This is okay");
 151                         #endif
 152                         break;
 153                 case 1:
 154                         #if 0
 155                         udelay(10000000);
 156                         // this is a ghetto way to test restarting an _M
 157                                 printk("\nattempting to ghetto preempt...\n");
 158                                 spin_lock(&p->proc_lock);
 159                                 proc_take_allcores(p, __death);
 160                                 __proc_set_state(p, PROC_RUNNABLE_M);
 161                                 spin_unlock(&p->proc_lock);
 162                                 udelay(5000000);
 163                                 printk("\nattempting to restart...\n");
 164                                 core_request(p); // proc still wants the cores
 165                         panic("This is okay");
 166                         // this tests taking some cores, and later killing an _M
 167                                 printk("taking 3 cores from p\n");
 168                                 for (int i = 0; i < num; i++)
 169                                         corelist[i] = 7-i; // 7, 6, and 5
 170                                 spin_lock(&p->proc_lock);
 171                                 proc_take_cores(p, corelist, &num, __death);
 172                                 spin_unlock(&p->proc_lock);
 173                                 udelay(5000000);
 174                                 printk("Killing p\n");
 175                                 enable_irq();
 176                                 proc_destroy(p);
 177                                 printk("Killed p\n");
 178                         panic("This is okay");
 179
 180                         envs[0] = kfs_proc_create(kfs_lookup_path("roslib_hello"));
 181                         __proc_set_state(envs[0], PROC_RUNNABLE_S);
 182                         proc_run(envs[0]);
 183                         warn("DEPRECATED");
 184                         break;
 185                         #endif
 186                 case 2:
 187                         /*
 188                         test_smp_call_functions();
 189                         test_checklists();
 190                         test_barrier();
 191                         test_print_info();
 192                         test_lapic_status_bit();
 193                         test_ipi_sending();
 194                         test_pit();
 195                         */
 196                 default:
 197                         printd("Manager Progress: %d\n", progress);
 198                         // delay if you want to test rescheduling an MCP that yielded
 199                         //udelay(15000000);
 200                         schedule();
 201         }
 202         panic("If you see me, then you probably screwed up");
 203         monitor(0);
 204
 205         /*
 206         printk("Servicing syscalls from Core 0:\n\n");
 207         while (1) {
 208                 process_generic_syscalls(&envs[0], 1);
 209                 cpu_relax();
 210         }
 211         */
 212         return;
 213 #endif
 214 }
 215
 216 void manager_klueska()
 217 {
 218         static struct proc *envs[256];
 219         static volatile uint8_t progress = 0;
 220
 221         if (progress == 0) {
 222                 progress++;
 223                 panic("what do you want to do?");
 224                 //envs[0] = kfs_proc_create(kfs_lookup_path("fillmeup"));
 225                 __proc_set_state(envs[0], PROC_RUNNABLE_S);
 226                 proc_run_s(envs[0]);
 227                 warn("DEPRECATED");
 228         }
 229         schedule();
 230
 231         panic("DON'T PANIC");
 232 }
 233
 234 void manager_waterman()
 235 {
 236         static bool first = true;
 237         if (first)
 238                 mon_bb(0, 0, 0);
 239         smp_idle();
 240         assert(0);
 241 }
 242
 243 void manager_yuzhu()
 244 {
 245
 246         static uint8_t RACY progress = 0;
 247         static struct proc *p;
 248
 249         // for testing taking cores, check in case 1 for usage
 250         uint32_t corelist[MAX_NUM_CPUS];
 251         uint32_t num = 3;
 252
 253         //create_server(init_num_cores, loop);
 254
 255         monitor(0);
 256
 257         // quick_proc_run("hello", p);
 258
 259 }
 260
 261 #ifdef __sparc_v8__
 262
 263 static char*
 264 itoa(int num, char* buf0, size_t base)
 265 {
 266         if(base > 16)
 267                 return NULL;
 268
 269         char* buf = buf0;
 270         int len = 0, i;
 271
 272         if(num < 0)
 273         {
 274                 *buf++ = '-';
 275                 num = -num;
 276         }
 277
 278         do {
 279                 buf[len++] = "0123456789abcdef"[num%base];
 280                 num /= base;
 281         } while(num);
 282
 283         for(i = 0; i < len/2; i++)
 284         {
 285                 char temp = buf[i];
 286                 buf[i] = buf[len-i-1];
 287                 buf[len-i-1] = temp;
 288         }
 289         buf[len] = 0;
 290
 291         return buf0;
 292 }
 293
 294 void gsf_set_frame_cycles(int cycles)
 295 {
 296         store_alternate(26*4,2,cycles);
 297 }
 298
 299 void gsf_set_partition_credits(int partition, int credits)
 300 {
 301         store_alternate((32+partition)*4,2,credits);
 302 }
 303
 304 void gsf_set_core_partition(int core, int partition)
 305 {
 306         store_alternate((64+core)*4,2,partition);
 307 }
 308
 309 #endif
 310