Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0
       2             : /* 
       3             :  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
       4             :  */
       5             : 
       6             : #include <linux/sched/signal.h>
       7             : #include <linux/sched/task.h>
       8             : #include <linux/sched/mm.h>
       9             : #include <linux/spinlock.h>
      10             : #include <linux/slab.h>
      11             : #include <linux/oom.h>
      12             : #include <kern_util.h>
      13             : #include <os.h>
      14             : #include <skas.h>
      15             : 
      16             : void (*pm_power_off)(void);
      17             : EXPORT_SYMBOL(pm_power_off);
      18             : 
      19           1 : static void kill_off_processes(void)
      20             : {
      21             :         struct task_struct *p;
      22             :         int pid;
      23             : 
      24           1 :         read_lock(&tasklist_lock);
      25          17 :         for_each_process(p) {
      26             :                 struct task_struct *t;
      27             : 
      28          15 :                 t = find_lock_task_mm(p);
      29          15 :                 if (!t)
      30          15 :                         continue;
      31           0 :                 pid = t->mm->context.id.u.pid;
      32           0 :                 task_unlock(t);
      33           0 :                 os_kill_ptraced_process(pid, 1);
      34             :         }
      35           1 :         read_unlock(&tasklist_lock);
      36           1 : }
      37             : 
      38           0 : void uml_cleanup(void)
      39             : {
      40           1 :         kmalloc_ok = 0;
      41           1 :         do_uml_exitcalls();
      42           1 :         kill_off_processes();
      43           0 : }
      44             : 
      45           0 : void machine_restart(char * __unused)
      46             : {
      47             :         uml_cleanup();
      48           0 :         reboot_skas();
      49           0 : }
      50             : 
      51           0 : void machine_power_off(void)
      52             : {
      53             :         uml_cleanup();
      54           1 :         halt_skas();
      55           0 : }
      56             : 
      57           1 : void machine_halt(void)
      58             : {
      59             :         machine_power_off();
      60           0 : }