73cb78fae3
This should ensure that we don't kill a different process after a restore (once supported) Signed-off-by: Kenfe-Mickael Laventure <mickael.laventure@gmail.com>
105 lines
2.2 KiB
Go
105 lines
2.2 KiB
Go
package oci
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"syscall"
|
|
|
|
"github.com/crosbymichael/go-runc"
|
|
"github.com/docker/containerd/execution"
|
|
starttime "github.com/opencontainers/runc/libcontainer/system"
|
|
)
|
|
|
|
func newProcess(c *execution.Container, id, stateDir string) (execution.Process, error) {
|
|
pid, err := runc.ReadPidFile(filepath.Join(stateDir, PidFilename))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
status := execution.Running
|
|
if err := syscall.Kill(pid, 0); err != nil {
|
|
if err == syscall.ESRCH {
|
|
status = execution.Stopped
|
|
} else {
|
|
return nil, err
|
|
}
|
|
}
|
|
if status == execution.Running {
|
|
stime, err := starttime.GetProcessStartTime(pid)
|
|
switch {
|
|
case os.IsNotExist(err):
|
|
status = execution.Stopped
|
|
case err != nil:
|
|
return nil, err
|
|
default:
|
|
b, err := ioutil.ReadFile(filepath.Join(stateDir, StartTimeFilename))
|
|
switch {
|
|
case os.IsNotExist(err):
|
|
err = ioutil.WriteFile(filepath.Join(stateDir, StartTimeFilename), []byte(stime), 0600)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
case err != nil:
|
|
return nil, err
|
|
case string(b) != stime:
|
|
status = execution.Stopped
|
|
}
|
|
}
|
|
}
|
|
return &process{
|
|
c: c,
|
|
id: id,
|
|
pid: pid,
|
|
status: status,
|
|
}, nil
|
|
}
|
|
|
|
type process struct {
|
|
c *execution.Container
|
|
id string
|
|
pid int
|
|
status execution.Status
|
|
}
|
|
|
|
func (p *process) Container() *execution.Container {
|
|
return p.c
|
|
}
|
|
|
|
func (p *process) ID() string {
|
|
return p.id
|
|
}
|
|
|
|
func (p *process) Pid() int64 {
|
|
return int64(p.pid)
|
|
}
|
|
|
|
func (p *process) Wait() (uint32, error) {
|
|
if p.status == execution.Running {
|
|
var wstatus syscall.WaitStatus
|
|
_, err := syscall.Wait4(p.pid, &wstatus, 0, nil)
|
|
if err != nil {
|
|
return 255, nil
|
|
}
|
|
// TODO: implement kill-all if we are the init pid
|
|
p.status = execution.Stopped
|
|
return uint32(wstatus.ExitStatus()), nil
|
|
}
|
|
|
|
return 255, execution.ErrProcessNotFound
|
|
}
|
|
|
|
func (p *process) Signal(s os.Signal) error {
|
|
if p.status == execution.Running {
|
|
sig, ok := s.(syscall.Signal)
|
|
if !ok {
|
|
return fmt.Errorf("invalid signal %v", s)
|
|
}
|
|
return syscall.Kill(p.pid, sig)
|
|
}
|
|
return execution.ErrProcessNotFound
|
|
}
|
|
|
|
func (p *process) Status() execution.Status {
|
|
return p.status
|
|
}
|