Linux Cross Reference
Linux/arch/um/kernel/um_arch.c

** Warning: Cannot open xref database.
   #include "linux/sched.h"
   #include "linux/mm.h"
   #include "linux/types.h"
   #include "linux/tty.h"
   #include "linux/init.h"
   #include "linux/bootmem.h"
   #include "linux/spinlock.h"
   #include "asm/page.h"
   #include "asm/pgtable.h"
  #include "asm/ptrace.h"
  #include "asm/elf.h"
  #include "asm/user.h"
  #include "asm/fhd_user.h"
  #include "asm/current.h"
  #include "proc_arch.h"
  #include "user_util.h"
  #include "kern_util.h"
  #include "kern.h"
  #include "mprot.h"
  
  unsigned long _stext;
  
  #define COMMAND_LINE_SIZE 256
  #define DEFAULT_COMMAND_LINE "root=/dev/fhd0"
  
  char saved_command_line[COMMAND_LINE_SIZE];
  
  unsigned long thread_saved_pc(struct thread_struct *thread)
  {
    KERN_UNTESTED();
    return(0);
  }
  
  int get_cpuinfo(char * buffer){
    sprintf(buffer, "processor: user-mode\n");
    return(strlen(buffer));
  }
  
  
  UNDEFINED(get_irq_list)
  
  pte_t * __bad_pagetable(void)
  {
    KERN_UNTESTED();
    return(NULL);
  }
  
  extern void start_kernel(void);
  
  static int start_kernel_proc(void *unused)
  {
    int pid;
  
    pid = getpid();
    set_extern_pid(0, pid);
    add_signal_handler(SIGSEGV, kern_segv_handler);
    signal_init();
    printk("idle thread pid = %d\n", pid);
    block_signals(NULL);
  #ifdef __SMP__
    cpu_tasks[0].pid = pid;
    cpu_tasks[0].task = current;
    smp_num_cpus = 1;
  #else
    current_task = &init_task_union.task;
  #endif
    start_kernel();
    return(0);
  }
  
  int physmem_fd = -1;
  
  extern unsigned long high_physmem;
  extern void *high_memory;
  
  unsigned long physmem;
  unsigned long start_vm;
  unsigned long end_vm;
  int physmem_inode;
  
  int ncpus = 1;
  
  static unsigned long __init memparse(char *ptr)
  {
          char *retptr;
          unsigned long ret;
  
          ret = simple_strtoul(ptr, &retptr, 0);
  
          if (*retptr == 'K' || *retptr == 'k') {
                  ret <<= 10;
          }
          else if (*retptr == 'M' || *retptr == 'm') {
                  ret <<= 20;
          }
          return ret;
  } /* memparse */
  
  static void add_arg(char *cmd_line, char *arg)
 {
           if (strlen(cmd_line) + strlen(arg) + 1 > COMMAND_LINE_SIZE) {
                   printf("add_arg: Too much command line!\n");
                   exit(1);
           }
           if(strlen(cmd_line) > 0) strcat(cmd_line, " ");
           strcat(cmd_line, arg);
 }
 
 #define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
 #define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
 #define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 
 static char *argv1_begin = NULL;
 static char *argv1_end = NULL;
 
 void set_cmdline(char *cmd)
 {
   strcpy(argv1_begin, "[");
   strncat(argv1_begin, cmd, argv1_end - argv1_begin - strlen("[]"));
   strcat(argv1_begin, "]");
   memset(argv1_begin + strlen(argv1_begin), '\0', 
          argv1_end - argv1_begin - strlen(argv1_begin));  
 }
 
 int linux_main(int argc, char **argv)
 {
   unsigned long start_pfn, end_pfn, bootmap_size, signal_stack;
   unsigned long physmem_size, virtmem_size;
   struct init_thread init_info;
   unsigned int i, have_root;
 
   remap_data("rw-");
   remap_data("rwx");
   block_shlib_mem();
   register_pid(getpid(), 1);
 
   /* Create fake command line from argv[]. */
   have_root = 0;
   physmem_size = 16 * 1024 * 1024;
   virtmem_size = physmem_size;
   for (i = 1; i < argc; i++){
           if((i == argc - 1) && (argv[i][0] == ' ')) break;
           add_arg(saved_command_line, argv[i]);
           if(!strncmp(argv[i], "root=", strlen("root="))) have_root = 1;
           else if(!strncmp(argv[i], "mem=", strlen("mem="))) 
             physmem_size = memparse(argv[i] + strlen("mem="));
 #ifdef __SMP__
           else if(!strncmp(argv[i], "ncpus=", strlen("ncpus=")))
             ncpus = strtoul(argv[i] + strlen("ncpus="), NULL, 10);
 #endif
   }
   if(have_root == 0) add_arg(saved_command_line, DEFAULT_COMMAND_LINE);
   argv1_begin = argv[1];
   argv1_end = &argv[argc - 1][strlen(argv[argc - 1])];
   
   unblock_shlib_mem();
   physmem = setup_memory(physmem_size + VMALLOC_OFFSET + virtmem_size,
                          physmem_size, &physmem_fd, &physmem_inode);
   high_memory = (void *) (physmem + physmem_size);
   high_physmem = (unsigned long) high_memory;
   start_vm = physmem + physmem_size + VMALLOC_OFFSET;
   end_vm = start_vm + virtmem_size;
 
   start_pfn = PFN_UP(__pa(physmem));
   end_pfn = PFN_DOWN(__pa(high_physmem));
   bootmap_size = init_bootmem(start_pfn, end_pfn - start_pfn);
   free_bootmem(__pa(physmem) + bootmap_size, 
                high_physmem - physmem - bootmap_size);
 
   /*
   init_task_ptr = alloc_bootmem_low_pages(2 * PAGE_SIZE);
   *((struct task_struct *) init_task_ptr) = 
     ((struct task_struct) INIT_TASK(init_task_u.task));
   */
   init_task.thread.kernel_stack = (unsigned long) &init_task;
 #ifndef __SMP__
   current = &init_task;
 #endif
   stack_protections(init_task.thread.kernel_stack, 2 * PAGE_SIZE);
   signal_stack = (unsigned long) alloc_bootmem_low_pages(PAGE_SIZE);
   stack_protections(signal_stack, PAGE_SIZE);
   init_info.proc = start_kernel_proc;
   init_info.sp = (void *) init_task.thread.kernel_stack +  2 * PAGE_SIZE -
     sizeof(unsigned long);
   clone(signals, (void *) signal_stack + PAGE_SIZE - sizeof(unsigned long), 
         CLONE_FILES | SIGCHLD, &init_info);
   set_cmdline("(input thread)");
   return(input_loop());
 }
 
 static struct mm_struct init_real_mm = EMPTY_MM;
 
 void setup_arch(char **cmdline_p)
 {
   *cmdline_p = saved_command_line;
   current->thread.real_mm = &init_real_mm;
 }
 
 void init_IRQ(void)
 {
   return;
 }
 
 void check_bugs(void)
 {
   return;
 }
 
 spinlock_t pid_lock = SPIN_LOCK_UNLOCKED;
 
 void lock_pid(void)
 {
   spin_lock(&pid_lock);
 }
 
 void unlock_pid(void)
 {
   spin_unlock(&pid_lock);
 }