Merge pull request #16235 from HuKeping/oom-event

Events for OOM needs to be shift to an earlier time
Upstream-commit: 114612305c798735e7022274cc9db382f30aa174
Component: engine

components/engine/daemon/execdriver/driver.go

@@ -27,8 +27,9 @@ var (
 // DriverCallback defines a callback function which is used in "Run" and "Exec".
 // This allows work to be done in the parent process when the child is passing
 // through PreStart, Start and PostStop events.
-// Callbacks are provided a processConfig pointer and the pid of the child
-type DriverCallback func(processConfig *ProcessConfig, pid int) error
+// Callbacks are provided a processConfig pointer and the pid of the child.
+// The channel will be used to notify the OOM events.
+type DriverCallback func(processConfig *ProcessConfig, pid int, chOOM <-chan struct{}) error
 
 // Hooks is a struct containing function pointers to callbacks
 // used by any execdriver implementation exploiting hooks capabilities

components/engine/daemon/execdriver/lxc/driver.go

@@ -324,14 +324,15 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, hooks execd
 
 	c.ContainerPid = pid
 
-	if hooks.Start != nil {
-		logrus.Debugf("Invoking startCallback")
-		hooks.Start(&c.ProcessConfig, pid)
-	}
-
 	oomKill := false
 	oomKillNotification, err := notifyOnOOM(cgroupPaths)
 
+	if hooks.Start != nil {
+		logrus.Debugf("Invoking startCallback")
+		hooks.Start(&c.ProcessConfig, pid, oomKillNotification)
+
+	}
+
 	<-waitLock
 	exitCode := getExitCode(c)
 

components/engine/daemon/execdriver/native/create.go

@@ -146,7 +146,11 @@ func (d *Driver) createNetwork(container *configs.Config, c *execdriver.Command,
 			configs.NewFunctionHook(func(s configs.HookState) error {
 				if len(hooks.PreStart) > 0 {
 					for _, fnHook := range hooks.PreStart {
-						if err := fnHook(&c.ProcessConfig, s.Pid); err != nil {
+						// A closed channel for OOM is returned here as it will be
+						// non-blocking and return the correct result when read.
+						chOOM := make(chan struct{})
+						close(chOOM)
+						if err := fnHook(&c.ProcessConfig, s.Pid, chOOM); err != nil {
 							return err
 						}
 					}

components/engine/daemon/execdriver/native/driver.go

@@ -165,17 +165,18 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, hooks execd
 		return execdriver.ExitStatus{ExitCode: -1}, err
 	}
 
+	oom := notifyOnOOM(cont)
 	if hooks.Start != nil {
+
 		pid, err := p.Pid()
 		if err != nil {
 			p.Signal(os.Kill)
 			p.Wait()
 			return execdriver.ExitStatus{ExitCode: -1}, err
 		}
-		hooks.Start(&c.ProcessConfig, pid)
+		hooks.Start(&c.ProcessConfig, pid, oom)
 	}
 
-	oom := notifyOnOOM(cont)
 	waitF := p.Wait
 	if nss := cont.Config().Namespaces; !nss.Contains(configs.NEWPID) {
 		// we need such hack for tracking processes with inherited fds,

components/engine/daemon/execdriver/native/exec.go

@@ -52,7 +52,12 @@ func (d *Driver) Exec(c *execdriver.Command, processConfig *execdriver.ProcessCo
 			p.Wait()
 			return -1, err
 		}
-		hooks.Start(&c.ProcessConfig, pid)
+
+		// A closed channel for OOM is returned here as it will be
+		// non-blocking and return the correct result when read.
+		chOOM := make(chan struct{})
+		close(chOOM)
+		hooks.Start(&c.ProcessConfig, pid, chOOM)
 	}
 
 	ps, err := p.Wait()

components/engine/daemon/execdriver/windows/exec.go

@@ -70,7 +70,11 @@ func (d *Driver) Exec(c *execdriver.Command, processConfig *execdriver.ProcessCo
 
 	// Invoke the start callback
 	if hooks.Start != nil {
-		hooks.Start(&c.ProcessConfig, int(pid))
+		// A closed channel for OOM is returned here as it will be
+		// non-blocking and return the correct result when read.
+		chOOM := make(chan struct{})
+		close(chOOM)
+		hooks.Start(&c.ProcessConfig, int(pid), chOOM)
 	}
 
 	if exitCode, err = hcsshim.WaitForProcessInComputeSystem(c.ID, pid); err != nil {

components/engine/daemon/execdriver/windows/run.go

@@ -291,7 +291,11 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, hooks execd
 	d.Unlock()
 
 	if hooks.Start != nil {
-		hooks.Start(&c.ProcessConfig, int(pid))
+		// A closed channel for OOM is returned here as it will be
+		// non-blocking and return the correct result when read.
+		chOOM := make(chan struct{})
+		close(chOOM)
+		hooks.Start(&c.ProcessConfig, int(pid), chOOM)
 	}
 
 	var exitCode int32