Merge pull request #220 from rst0git/task-state-parsing

crit: Add support for TaskState decoding

Author: adrianreber

crit/explore.go

@@ -13,6 +13,25 @@ import (
 	"github.com/checkpoint-restore/go-criu/v8/crit/images/pstree"
 )
 
+// CRIU uses 4 task states to represent the state of a process. A process can be
+// Alive, Dead, Stopped or Zombie. Only Alive and Stopped processes have
+// associated state (memory pages, file descriptors, sockets, etc). The function
+// checks whether a process with the given pID has associated state.
+func (c *crit) taskHasState(pID uint32) (bool, error) {
+	coreImg, err := getImg(
+		filepath.Join(c.inputDirPath, fmt.Sprintf("core-%d.img", pID)),
+		&criu_core.CoreEntry{},
+	)
+	if err != nil {
+		return false, err
+	}
+
+	coreData := coreImg.Entries[0].Message.(*criu_core.CoreEntry)
+	state := TaskState(coreData.GetTc().GetTaskState())
+
+	return state.IsAliveOrStopped(), nil
+}
+
 // PsTree represents the process tree
 type PsTree struct {
 	PID      uint32               `json:"pid"`
@@ -97,6 +116,15 @@ func (c *crit) ExploreFds() ([]*Fd, error) {
 	for _, entry := range psTreeImg.Entries {
 		process := entry.Message.(*pstree.PstreeEntry)
 		pID := process.GetPid()
+
+		ok, err := c.taskHasState(pID)
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
+			continue
+		}
+
 		// Get file with object IDs
 		idsImg, err := getImg(filepath.Join(c.inputDirPath, fmt.Sprintf("ids-%d.img", pID)), &criu_core.TaskKobjIdsEntry{})
 		if err != nil {
@@ -199,6 +227,15 @@ func (c *crit) ExploreMems() ([]*MemMap, error) {
 	for _, entry := range psTreeImg.Entries {
 		process := entry.Message.(*pstree.PstreeEntry)
 		pID := process.GetPid()
+
+		ok, err := c.taskHasState(pID)
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
+			continue
+		}
+
 		// Get memory mappings
 		mmImg, err := getImg(filepath.Join(c.inputDirPath, fmt.Sprintf("mm-%d.img", pID)), &mm.MmEntry{})
 		if err != nil {
@@ -318,6 +355,15 @@ func (c *crit) ExploreRss() ([]*RssMap, error) {
 	for _, entry := range psTreeImg.Entries {
 		process := entry.Message.(*pstree.PstreeEntry)
 		pID := process.GetPid()
+
+		ok, err := c.taskHasState(pID)
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
+			continue
+		}
+
 		// Get virtual memory addresses
 		mmImg, err := getImg(filepath.Join(c.inputDirPath, fmt.Sprintf("mm-%d.img", pID)), &mm.MmEntry{})
 		if err != nil {
@@ -418,6 +464,15 @@ func (c *crit) ExploreSk() ([]*Sk, error) {
 	for _, entry := range psTreeImg.Entries {
 		process := entry.Message.(*pstree.PstreeEntry)
 		pID := process.GetPid()
+
+		ok, err := c.taskHasState(pID)
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
+			continue
+		}
+
 		// Get file with object IDs
 		idsImg, err := getImg(filepath.Join(c.inputDirPath, fmt.Sprintf("ids-%d.img", pID)), &criu_core.TaskKobjIdsEntry{})
 		if err != nil {

crit/task_state.go

@@ -0,0 +1,40 @@
+package crit
+
+type TaskState uint32
+
+// Task state constants from CRIU (compel/include/uapi/task-state.h)
+const (
+	TaskAlive   TaskState = 0x01
+	TaskDead    TaskState = 0x02
+	TaskStopped TaskState = 0x03
+	TaskZombie  TaskState = 0x06
+)
+
+func (s TaskState) String() string {
+	if v, ok := map[TaskState]string{
+		TaskAlive:   "Alive",
+		TaskDead:    "Dead",
+		TaskStopped: "Stopped",
+		TaskZombie:  "Zombie",
+	}[s]; ok {
+		return v
+	}
+	return "Unknown"
+}
+
+// A checkpointed process has state (memory pages, file descriptors, sockets),
+// only if it is "alive" or "stopped". Note that "dead" means the task has
+// exited during checkpointing and CRIU observed the exit reported by waitpid().
+func (s TaskState) IsAliveOrStopped() bool {
+	switch s {
+	case TaskAlive, TaskStopped:
+		return true
+	default:
+		return false
+	}
+}
+
+func (s TaskState) IsAlive() bool   { return s == TaskAlive }
+func (s TaskState) IsDead() bool    { return s == TaskDead }
+func (s TaskState) IsStopped() bool { return s == TaskStopped }
+func (s TaskState) IsZombie() bool  { return s == TaskZombie }

crit/task_state_test.go

@@ -0,0 +1,74 @@
+package crit
+
+import "testing"
+
+func TestTaskStateString(t *testing.T) {
+	tests := []struct {
+		state TaskState
+		want  string
+	}{
+		{TaskAlive, "Alive"},
+		{TaskDead, "Dead"},
+		{TaskStopped, "Stopped"},
+		{TaskZombie, "Zombie"},
+		{TaskState(0xFF), "Unknown"}, // Unknown state
+	}
+
+	for _, test := range tests {
+		got := test.state.String()
+		if got != test.want {
+			t.Errorf("TaskState(%d).String() = %q, want %q", test.state, got, test.want)
+		}
+	}
+}
+
+func TestTaskStateIsAliveOrStopped(t *testing.T) {
+	tests := []struct {
+		state TaskState
+		want  bool
+	}{
+		{TaskAlive, true},
+		{TaskDead, false},
+		{TaskStopped, true},
+		{TaskZombie, false},
+		{TaskState(0xFF), false}, // Unknown state
+	}
+
+	for _, test := range tests {
+		got := test.state.IsAliveOrStopped()
+		if got != test.want {
+			t.Errorf("TaskState(%d).IsAliveOrStopped() = %v, want %v", test.state, got, test.want)
+		}
+	}
+}
+
+func TestTaskStateChecks(t *testing.T) {
+	tests := []struct {
+		state     TaskState
+		isAlive   bool
+		isDead    bool
+		isStopped bool
+		isZombie  bool
+	}{
+		{TaskAlive, true, false, false, false},
+		{TaskDead, false, true, false, false},
+		{TaskStopped, false, false, true, false},
+		{TaskZombie, false, false, false, true},
+		{TaskState(0xFF), false, false, false, false}, // Unknown
+	}
+
+	for _, test := range tests {
+		if got := test.state.IsAlive(); got != test.isAlive {
+			t.Errorf("TaskState(%d).IsAlive() = %v, want %v", test.state, got, test.isAlive)
+		}
+		if got := test.state.IsDead(); got != test.isDead {
+			t.Errorf("TaskState(%d).IsDead() = %v, want %v", test.state, got, test.isDead)
+		}
+		if got := test.state.IsStopped(); got != test.isStopped {
+			t.Errorf("TaskState(%d).IsStopped() = %v, want %v", test.state, got, test.isStopped)
+		}
+		if got := test.state.IsZombie(); got != test.isZombie {
+			t.Errorf("TaskState(%d).IsZombie() = %v, want %v", test.state, got, test.isZombie)
+		}
+	}
+}

test/loop/loop.c

@@ -54,6 +54,10 @@ int main(void)
 		write(start_pipe[1], &res, sizeof(res));
 		close(start_pipe[1]);
 
+		/* Create a process with task_state="dead" */
+		if (fork() == 0)
+			_exit(0);
+
 		while (1) {
 			sleep(1);
 		}