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

** Warning: Cannot open xref database.
   #include "linux/sched.h"
   #include "linux/interrupt.h"
   #include "linux/mm.h"
   #include "linux/malloc.h"
   #include "linux/utsname.h"
   #include "linux/fs.h"
   #include "linux/utime.h"
   #include "linux/smp_lock.h"
   #include "asm/unistd.h"
  #include "asm/mman.h"
  #include "asm/segment.h"
  #include "asm/stat.h"
  #include "asm/pgtable.h"
  #include "asm/pgalloc.h"
  #include "asm/spinlock.h"
  #include "user_util.h"
  #include "kern_util.h"
  #include "kern.h"
  
  struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
  
  struct task_struct *get_task(int pid, int require)
  {
    struct task_struct *task, *ret;
  
    ret = NULL;
    read_lock(&tasklist_lock);
    for_each_task(task){
      if(task->pid == pid){
        ret = task;
        break;
      }
    }
    read_unlock(&tasklist_lock);
    if(require && (ret == NULL)) panic("get_task couldn't find a task\n");
    return(ret);
  }
  
  int external_pid(struct task_struct *task)
  {
    if(task == NULL) task = current;
    return(task->thread.extern_pid);
  }
  
  int current_external_pid(void)
  {
    return(external_pid(NULL));
  }
  
  void free_stack(unsigned long stack)
  {
    free_page(stack);
  }
  
  void set_extern_pid(int task_pid, int pid)
  {
    struct task_struct *task;
  
    if(task_pid == 0) task = &init_task;
    else task = get_task(task_pid, 1);
    task->thread.extern_pid = pid;
  }
  
  int set_user_thread(void *t, int on)
  {
    struct task_struct *task;
    int ret, sigs;
  
    if(t == NULL) task = current;
    else task = t;
    if(on == task->thread.tracing) return(on);
    sigs = set_signals(task, 1);
    ret = task->thread.tracing;
    task->thread.want_tracing = on;
    if(on) trap_pid(getpid());
    else getpid();
    set_signals(task, sigs);
    return(ret);
  }
  
  void set_tracing(void *task, int tracing)
  {
    ((struct task_struct *) task)->thread.tracing = tracing;
    ((struct task_struct *) task)->thread.want_tracing = tracing;
  }
  
  int is_tracing(void *task)
  {
    return(((struct task_struct *) task)->thread.tracing);
  }
  
  int get_want_tracing(void *task)
  {
    return(((struct task_struct *) task)->thread.want_tracing);
  }
  
  extern void schedule_tail(struct task_struct *prev);
  
  static int new_thread_proc(void *t)
 {
   struct task_struct *task;
   int (*fn)(void *), pid;
   void *arg;
 
   task = t;
   trace_myself();
   set_sigstack(t, SIGSEGV, kern_segv_handler, 1, 0, SIGVTALRM);
   pid = getpid();
   fn = task->thread.request.u.thread.proc;
   arg = task->thread.request.u.thread.arg;
   task->thread.extern_pid = pid;
   stop_pid(pid);
   set_cmdline("(kernel thread)");
   if(current->thread.request.u.cswitch.from != NULL)
     schedule_tail(current->thread.request.u.cswitch.from);
   return((*fn)(arg));
 }
 
 unsigned long alloc_stack(void)
 {
   unsigned long page;
 
   if((page = __get_free_page(GFP_KERNEL)) == 0)
     panic("Couldn't allocate new stack");
   stack_protections(page, PAGE_SIZE);
   return(page);
 }
 
 extern int inited_cpus;
 
 static int start_kernel_thread(struct task_struct *task, int (*fn)(void *),
                                void *arg, unsigned long flags, int cpu)
 {
   int extern_pid;
   unsigned long sp;
   int clone_flags;
 
   sp = ((unsigned long) task) + 2 * PAGE_SIZE - sizeof(void *);
   clone_flags = flags | CLONE_FILES | SIGCHLD;
   task->thread.request.u.thread.proc = fn;
   task->thread.request.u.thread.arg = arg;
   task->thread.extern_pid = -1;
   extern_pid = clone_and_wait(new_thread_proc, task, (void *) sp, clone_flags);
   if(task->thread.extern_pid == -1) panic("task didn't set its pid");
   atomic_inc(&init_mm.mm_count);
   task->mm = &init_mm;
   task->active_mm = &init_mm;
 #ifdef __SMP__
   if(cpu != -1){
     cpu_tasks[cpu].pid = extern_pid;
     cpu_tasks[cpu].task = task;
     inited_cpus++;
     init_tasks[cpu] = task;
     cpu_number_map[cpu] = cpu;
     task->processor = cpu;
     cont_pid(extern_pid);
   }
 #endif
   return(extern_pid);
 }
 
 int kernel_thread1(int (*fn)(void *), void * arg, unsigned long flags, 
                    int cpu, int *extern_pid_out)
 {
   struct task_struct *new_task;
   int pid;
 
   pid = do_fork(CLONE_VM | flags, 0, NULL);
   if(pid < 0) panic("do_fork failed in kernel_thread");
   new_task = get_task(pid, 1);
   current->thread.request.op = OP_THREAD;
   current->thread.request.u.thread.proc = fn;
   current->thread.request.u.thread.arg = arg;
   current->thread.request.u.thread.flags = flags;
   current->thread.request.u.thread.new_task = new_task;
   current->thread.request.u.thread.cpu = cpu;
   usr1_pid(getpid());
   if(extern_pid_out != NULL) 
     *extern_pid_out = current->thread.request.u.thread.new_pid;
   current->thread.request.u.cswitch.from = NULL;
   return(pid);
 }
 
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
   return(kernel_thread1(fn, arg, flags, -1, NULL));
 }
 
 void switch_mm(struct mm_struct *prev, struct mm_struct *next, 
                struct task_struct *tsk, unsigned cpu)
 {
         if (prev != next) 
                 clear_bit(cpu, &prev->cpu_vm_mask);
         set_bit(cpu, &next->cpu_vm_mask);
 }
 
 void *_switch_to(void *prev, void *next)
 {
   struct task_struct *from, *to;
 
   from = prev;
   to = next;
   current->thread.request.op = OP_SWITCH;
   current->thread.request.u.cswitch.to = next;
   usr1_pid(getpid());
   flush_tlb_kernel_vm();
   return(current->thread.request.u.cswitch.from);
 }
 
 void do_bh(void)
 {
 #ifndef __SMP__
         if (softirq_state[0].active&softirq_state[0].mask)
                 do_softirq();
 #else
         #error Need to update do_bh
 #endif
 }
 
 int ret_from_sys_call(void *t)
 {
   struct task_struct *task;
 
   task = t;
   if(task == NULL) task = current;
   do_bh();
   if(task->sigpending != 0) do_signal(task, NULL, NULL);
   return(task->need_resched);
 }
 
 void release_thread(struct task_struct *task)
 {
   pgd_t *pgd;
   pmd_t *pmd;
   int i;
 
   pgd = (pgd_t *) task->thread.real_mm->pgd;
   for(i=0;i<USER_PGD_PTRS;i++){
     pmd = pmd_offset(&pgd[i], 0);
     if(pmd_present(*pmd)) free_page(pmd_page(*pmd));
   }
   free_page((unsigned long) task->thread.real_mm->pgd);
   kfree(task->thread.real_mm);
   kill_pid(task->thread.extern_pid);
 }
 
 int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
                  struct task_struct * p, struct pt_regs * regs)
 {
   p->thread = (struct thread_struct) INIT_THREAD;
   p->thread.kernel_stack = (unsigned long) p;
   p->thread.tracing = current->thread.forking;
   p->thread.real_mm = kmalloc(sizeof(*p->thread.real_mm), GFP_KERNEL);
   *p->thread.real_mm = ((struct mm_struct) EMPTY_MM);
   if(current->thread.forking){
     p->thread.tracing = 0;
     p->thread.want_tracing = 0;
     current->thread.request.op = OP_FORK;
     current->thread.request.u.fork.task = p;
     current->thread.request.u.fork.tramp_stack = alloc_stack();
     usr1_pid(getpid());
   }
   current->need_resched = 1;
   return(0);
 }
 
 void add_input_request(int op, int fd, void (*proc)(int))
 {
   if((current->thread.request.op == OP_INPUT) && 
      (current->thread.request.u.input_request.op != INPUT_NONE))
     panic("Unfinished input request");
   current->thread.request.op = OP_INPUT;
   current->thread.request.u.input_request.op = op;
   current->thread.request.u.input_request.fd = fd;
   current->thread.request.u.input_request.proc = proc;
   usr1_pid(getpid());
 }
 
 struct {
   struct task_struct *from;
   struct task_struct *to;
   int processor;
 } switch_record[1024];
 
 int switch_index = 0;
 
 DECLARE_MUTEX(input_sem);
 void *input_task;
 
 int do_proc_op(void *t, int proc_id)
 {
   struct task_struct *task, *to, *new;
   int op, new_pid;
 
   task = t;
   op = task->thread.request.op;
   switch(op){
   case OP_NONE:
     break;
   case OP_EXEC:
     kern_finish_exec(task, task->thread.request.u.exec.ip,
                      task->thread.request.u.exec.sp, task->thread.extern_pid);
     break;
   case OP_SWITCH:
     to = task->thread.request.u.cswitch.to;
     switch_record[switch_index].from = task;
     switch_record[switch_index].to = to;
     switch_record[switch_index++].processor = to->processor;
     if(switch_index == 1024) switch_index = 0;
 #ifdef __SMP__
     cpu_tasks[proc_id].task = to;
     cpu_tasks[proc_id].pid = to->thread.extern_pid;
     if(cpu_tasks[0].pid == cpu_tasks[1].pid)
       panic("Scheduled a process on two processors");
 #else
     current = to;
 #endif
     if(to->thread.request.op == OP_FORK_FINISH){
       to->thread.request.u.fork_finish.from = task;
       continue_fork(to->thread.extern_pid, 
                     to->thread.request.u.fork_finish.regs);
       to->thread.request.op = OP_NONE;
       set_tracing(to, 1);
     }
     else to->thread.request.u.cswitch.from = task;
     cont_pid(to->thread.extern_pid);
     break;
   case OP_THREAD:
     new_pid = start_kernel_thread(task->thread.request.u.thread.new_task,
                                   task->thread.request.u.thread.proc,
                                   task->thread.request.u.thread.arg,
                                   task->thread.request.u.thread.flags,
                                   task->thread.request.u.thread.cpu);
     task->thread.request.u.thread.new_pid = new_pid;
     break;
   case OP_INPUT:
     task->thread.request.u.input_request.pid = getpid();
     down(&input_sem);
     input_task = task;
     usr1_and_wait(get_main_pid());
     input_task = NULL;
     up(&input_sem);
     break;
   case OP_FORK:
     new = task->thread.request.u.fork.task;
     new_pid = start_fork_tramp(task->thread.request.u.fork.regs,
                                new->thread.kernel_stack,
                                task->thread.request.u.fork.tramp_stack);
     new->thread.extern_pid = new_pid;
     new->thread.request.op = OP_FORK_FINISH;
     new->thread.request.u.fork_finish.stack = 
       task->thread.request.u.fork.tramp_stack;
     memcpy(new->thread.request.u.fork_finish.regs,
            task->thread.request.u.fork.regs,
            sizeof(task->thread.request.u.fork.regs));
     break;
   default:
     panic("Bad op in do_proc_op");
     break;
   }
   task->thread.request.op = OP_NONE;
   return(op);
 }
 
 unsigned long stack_sp(unsigned long page)
 {
   return(page + PAGE_SIZE - sizeof(void *));
 }
 
 int current_pid(void *t)
 {
   struct task_struct *task;
 
   if(t == NULL) task = current;
   else task = t;
   return(task->pid);
 }
 
 static void do_idle(void)
 {
   while(1){
         /* endless idle loop with no priority at all */
         current->priority = 0;
         current->counter = -100;
 
                 /*
                  * although we are an idle CPU, we do not want to
                  * get into the scheduler unnecessarily.
                  */
         if (current->need_resched) {
                 schedule();
                 check_pgt_cache();
         }
   }
 }
 
 static int idle_proc(void *unused)
 {
   del_from_runqueue(current);
   init_idle();
 #ifdef __SMP__
   smp_num_cpus++;
 #endif
   do_idle();
   return(0);
 }
 
 int cpu_idle(void)
 {
   int i, pid;
 
   if(ncpus > 1){
     printk("Starting up other processors:\n");
     for(i=1;i<ncpus;i++){
       kernel_thread1(idle_proc, NULL, 0, i, &pid);
       printk("\t#%d - idle thread pid = %d\n", i, pid);
     }
   }
   do_idle();
   return(0);
 }
 
 unsigned long *fork_regs(void *task)
 {
   return(((struct task_struct *) task)->thread.request.u.fork.regs);
 }
 
 int page_size(void)
 {
   return(PAGE_SIZE);
 }
 
 int get_input_request(void *t, int *fd_out, 
                       void (**proc_out)(int), int *pid_out)
 {
   struct task_struct *task;
   int op;
 
   task = t;
   op = task->thread.request.u.input_request.op;
   *pid_out = -1;
   if(op == INPUT_NEW_FD){
     *fd_out = task->thread.request.u.input_request.fd;
     *proc_out = task->thread.request.u.input_request.proc;
     *pid_out = task->thread.request.u.input_request.pid;
   }
   task->thread.request.op = OP_NONE;
   task->thread.request.u.input_request.op = INPUT_NONE;
   return(op);
 }
 
 static unsigned long input_mask = 0;
 static spinlock_t input_mask_lock = SPIN_LOCK_UNLOCKED;
 
 extern struct tasklet_struct input_tasklet;
 
 void input_notify(int index)
 {
   tasklet_schedule(&input_tasklet);
   spin_lock(&input_mask_lock);
   input_mask |= (1 << index);
   spin_unlock(&input_mask_lock);
 }
 
 void input_handler(unsigned long ignored)
 {
   int i;
   unsigned long mask;
 
   spin_lock(&input_mask_lock);
   mask = input_mask;
   input_mask = 0;
   spin_unlock(&input_mask_lock);
   for(i=0;i<sizeof(mask) * 8;i++){
     if(mask & (1 << i)){
       (*reg_fd[i].proc)(reg_fd[i].fd);
     }
   }
 }
 
 char *current_comm(void)
 {
   return(current->comm);
 }
 
 void *current_sigstack(void *t)
 {
   struct task_struct *task;
 
   if(t == NULL) task = current;
   else task = t;
   return((void *) task->thread.kernel_stack);
 }
 
 unsigned long forced_fault(void)
 {
   unsigned long ret;
 
   ret = current->thread.forced_fault;
   current->thread.forced_fault = 0;
   return(ret);
 }
 
 void set_forced_fault(void *task, unsigned long addr)
 {
   ((struct task_struct *) task)->thread.forced_fault = addr;
 }
 
 char *current_cmd(void)
 {
   return("(Unknown)");
 #ifdef notdef
   pgd_t *pgd;
   pmd_t *pmd;
   pte_t *pte;
   unsigned long arg;
   
   pgd = pgd_offset(current->mm, current->mm->arg_start);
   pmd = pmd_offset(pgd, current->mm->arg_start);
   if(!pmd_present(*pmd)) return("(unknown)");
   pte = pte_offset(pmd, current->mm->arg_start);
   if(!pte_present(*pte)) return("(unknown)");
   arg = (pte_val(*pte) & PAGE_MASK) + (current->mm->arg_start & ~PAGE_MASK);
   return((char *) arg);
 #endif
 }
 
 void force_sigbus(void)
 {
   printk("Killing pid %d because of a lack of memory\n", current->pid);
   lock_kernel();
   sigaddset(&current->signal, SIGBUS);
   recalc_sigpending(current);
   current->flags |= PF_SIGNALED;
   do_exit(SIGBUS | 0x80);
 }
 
 void finish_fork(void)
 {
   free_page(current->thread.request.u.fork_finish.stack);
   schedule_tail(current->thread.request.u.fork_finish.from);
 }
 
 void *get_current_task(void)
 {
   return(current);
 }