vendor/github.com/opencontainers/runc/libcontainer/restored_process.go

   1 // +build linux
   2
   3 package libcontainer
   4
   5 import (
   6         "fmt"
   7         "os"
   8
   9         "github.com/opencontainers/runc/libcontainer/system"
  10 )
  11
  12 func newRestoredProcess(pid int, fds []string) (*restoredProcess, error) {
  13         var (
  14                 err error
  15         )
  16         proc, err := os.FindProcess(pid)
  17         if err != nil {
  18                 return nil, err
  19         }
  20         started, err := system.GetProcessStartTime(pid)
  21         if err != nil {
  22                 return nil, err
  23         }
  24         return &restoredProcess{
  25                 proc:             proc,
  26                 processStartTime: started,
  27                 fds:              fds,
  28         }, nil
  29 }
  30
  31 type restoredProcess struct {
  32         proc             *os.Process
  33         processStartTime string
  34         fds              []string
  35 }
  36
  37 func (p *restoredProcess) start() error {
  38         return newGenericError(fmt.Errorf("restored process cannot be started"), SystemError)
  39 }
  40
  41 func (p *restoredProcess) pid() int {
  42         return p.proc.Pid
  43 }
  44
  45 func (p *restoredProcess) terminate() error {
  46         err := p.proc.Kill()
  47         if _, werr := p.wait(); err == nil {
  48                 err = werr
  49         }
  50         return err
  51 }
  52
  53 func (p *restoredProcess) wait() (*os.ProcessState, error) {
  54         // TODO: how do we wait on the actual process?
  55         // maybe use --exec-cmd in criu
  56         st, err := p.proc.Wait()
  57         if err != nil {
  58                 return nil, err
  59         }
  60         return st, nil
  61 }
  62
  63 func (p *restoredProcess) startTime() (string, error) {
  64         return p.processStartTime, nil
  65 }
  66
  67 func (p *restoredProcess) signal(s os.Signal) error {
  68         return p.proc.Signal(s)
  69 }
  70
  71 func (p *restoredProcess) externalDescriptors() []string {
  72         return p.fds
  73 }
  74
  75 func (p *restoredProcess) setExternalDescriptors(newFds []string) {
  76         p.fds = newFds
  77 }
  78
  79 // nonChildProcess represents a process where the calling process is not
  80 // the parent process.  This process is created when a factory loads a container from
  81 // a persisted state.
  82 type nonChildProcess struct {
  83         processPid       int
  84         processStartTime string
  85         fds              []string
  86 }
  87
  88 func (p *nonChildProcess) start() error {
  89         return newGenericError(fmt.Errorf("restored process cannot be started"), SystemError)
  90 }
  91
  92 func (p *nonChildProcess) pid() int {
  93         return p.processPid
  94 }
  95
  96 func (p *nonChildProcess) terminate() error {
  97         return newGenericError(fmt.Errorf("restored process cannot be terminated"), SystemError)
  98 }
  99
 100 func (p *nonChildProcess) wait() (*os.ProcessState, error) {
 101         return nil, newGenericError(fmt.Errorf("restored process cannot be waited on"), SystemError)
 102 }
 103
 104 func (p *nonChildProcess) startTime() (string, error) {
 105         return p.processStartTime, nil
 106 }
 107
 108 func (p *nonChildProcess) signal(s os.Signal) error {
 109         proc, err := os.FindProcess(p.processPid)
 110         if err != nil {
 111                 return err
 112         }
 113         return proc.Signal(s)
 114 }
 115
 116 func (p *nonChildProcess) externalDescriptors() []string {
 117         return p.fds
 118 }
 119
 120 func (p *nonChildProcess) setExternalDescriptors(newFds []string) {
 121         p.fds = newFds
 122 }