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

** Warning: Cannot open xref database.
   #include <stdio.h>
   #include <unistd.h>
   #include <signal.h>
   #include <sched.h>
   #include <errno.h>
   #include <string.h>
   #include <sys/time.h>
   #include <sys/ptrace.h>
   #include <asm/ptrace.h>
  #include "user_util.h"
  #include "kern_util.h"
  #include "user.h"
  
  void stop_pid(int pid)
  {
    kill(pid, SIGSTOP);
  }
  
  void kill_pid(int pid)
  {
    kill(pid, SIGKILL);
  }
  
  void trap_pid(int pid)
  {
    kill(pid, SIGTRAP);
  }
  
  void usr1_pid(int pid)
  {
    kill(pid, SIGUSR1);
  }
  
  void cont_pid(int pid)
  {
    kill(pid, SIGCONT);
  }
  
  void exit_thread(void)
  {
  }
  
  void signal_handler(void *task, unsigned long h, int sig)
  {
    __sighandler_t handler, segv_handler;
  
    handler = (__sighandler_t) h;
    segv_handler = set_signal_handler(SIGSEGV, user_segv_handler);
    set_user_thread(task, 1);
    (*handler)(sig);
    set_user_thread(task, 0);
    set_signal_handler(SIGSEGV, segv_handler);
  }
  
  void set_sigstack(void *sig_stack, int sig, void (*handler)(int), 
                    int alt_stack, int nodefer, int mask_sig)
  {
    struct sigaction action;
    stack_t stack;
  
    action.sa_handler = handler;
    sigemptyset(&action.sa_mask);
    if(mask_sig != -1) sigaddset(&action.sa_mask, mask_sig);
    if(nodefer) action.sa_flags = SA_NODEFER;
    else action.sa_flags = 0;
    action.sa_restorer = NULL;
    if(alt_stack){
      stack.ss_sp = (__ptr_t) sig_stack;
      stack.ss_flags = 0;
      stack.ss_size = 2 * page_size() - sizeof(void *);
      if(sigaltstack(&stack, NULL) != 0)
        panic("sigaltstack failed");
      action.sa_flags |= SA_ONSTACK;
    }    
    if(sigaction(sig, &action, NULL) < 0)
      panic("sigaction failed");
  }
  
  void fork_handler(int sig)
  {  
    finish_fork();
  }
  
  static void io_handler(int sig)
  {
    printf("thread got SIGIO\n");
    stop();
  }
  
  int trampoline(void *sig_stack)
  {
    set_sigstack(sig_stack, SIGSEGV, user_segv_handler, 1, 0, SIGVTALRM);
    set_sigstack(sig_stack, SIGUSR1, fork_handler, 1, 0, SIGVTALRM);
    set_sigstack(NULL, SIGUSR2, syscall_handler, 0, 1, -1);
    set_sigstack(sig_stack, SIGVTALRM, timer_handler, 1, 0, -1);
    set_timers();
    if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0)
      panic("ptrace PTRACE_TRACEME failed");
    set_cmdline(current_cmd());
   kill(getpid(), SIGSTOP);
   kill(getpid(), SIGSTOP);
   return(0);
 }
 
 int start_fork_tramp(unsigned long *saved_regs, unsigned long sig_stack,
                      unsigned long temp_stack)
 {
   unsigned long sp;
   int new_pid;
 
   /* The trampoline will run on the temporary stack */
   sp = stack_sp(temp_stack);
 
   /* Start the process and wait for it to stop itself */
   new_pid = clone(trampoline, (void *) sp, CLONE_FILES | SIGCHLD, 
                   (void *) sig_stack);
   wait_for_stop(new_pid, SIGSTOP);
 
   /* Set the child return value to 0  */
   saved_regs[EAX] = 0;
 
   return(new_pid);
 }
 
 void trace_myself(void)
 {
   if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0)
     panic("ptrace failed in trace_myself");
 }
 
 struct reg_fd reg_fd[32];
 static int next_reg = 0;
 static fd_set input_fds;
 static int max_fd;
 static int shutting_down = 0;
 static int do_reboot = 0;
 
 extern void *input_task;
 
 static void handler(int sig)
 {
   void (*proc)(int);
   int op, new_fd, response_pid;
 
   op = get_input_request(input_task, &new_fd, &proc, &response_pid);
   switch(op){
   case INPUT_REBOOT:
     shutting_down = 1;
     do_reboot = 1;
     break;
   case INPUT_HALT:
     shutting_down = 1;
     do_reboot = 0;
     break;
   case INPUT_NEW_FD:
     if(next_reg == sizeof(reg_fd)/sizeof(reg_fd[0])){
       printk("fd registration overflow\n");
       return;
     }
     reg_fd[next_reg].fd = new_fd;
     reg_fd[next_reg++].proc = proc;
     FD_SET(new_fd, &input_fds);
     if(new_fd >= max_fd) max_fd = new_fd + 1;
     break;
   default:
     printk("Bogus input loop request : %d\n", op);
     break;
   }
   if(response_pid != -1) kill(response_pid, SIGUSR1);
 }
 
 int input_loop(void)
 {
   fd_set fds;
   int i, j, n;
 
   signal(SIGUSR1, handler);
   signal(SIGIO, io_handler);
   while(1){
     do {
       fds = input_fds;
       n = select(max_fd + 1, &fds, NULL, NULL, NULL);
     } while((n < 0) && (errno == EINTR) && (shutting_down == 0));
     if(n < 0){
       if(shutting_down) return(do_reboot);
       else continue;
     }
     for(i=0;i<max_fd;i++){
       if(FD_ISSET(i, &fds)){
         for(j=0;j<next_reg;j++){
           if(reg_fd[j].fd == i){
             input_notify(j);
             break;
           }
         }
       }
     }
   }
 }
 
 void usr1_and_wait(int pid)
 {
   sigset_t new_mask, old_mask;
 
   sigemptyset(&new_mask); 
   sigaddset(&new_mask, SIGUSR1);
   sigprocmask(SIG_BLOCK, &new_mask, &old_mask);
   usr1_pid(pid);
   sigsuspend(&old_mask);
   sigprocmask(SIG_SETMASK, &old_mask, NULL);
 }
 
 void (*set_signal_handler(int sig, void (*new_handler)(int)))(int)
 {
   struct sigaction action;
   void (*old_handler)(int);
 
   sigaction(sig, NULL, &action);
   old_handler = action.sa_handler;
   action.sa_handler = new_handler;
   sigaction(sig, &action, NULL);
   return(old_handler);
 }
 
 void continue_fork(int pid, unsigned long *regs)
 {
   if(ptrace(PTRACE_CONT, pid, 0, SIGUSR1) < 0)
     panic("Couldn't continue forked process");
   wait_for_stop(pid, SIGSTOP);
   if(ptrace(PTRACE_SETREGS, pid, 0, regs) < 0)
     panic("Couldn't save registers");
 }