Fix rootfs by cgroup, clean file name, etc.

**1. about root fs**

The setns is used by a process(for example, process 12345), to enter
a namespace of another process(also, process 12000). Process 12345
opens visual file /proc/12000/ns/xxx, gets a fd, then setns(fd, nstype).
Here xxx represents for special type of namespace such as mnt/ipc.
Param nstype can be found out in manual.

In short, switching namespace uses not fileName but file descriptor,
which makes it too hard to listen to setns, because the fd info may
have been lost on the road, or it's still on road, not in db. This
would make significant error!

So, in this commit, I check /proc/pid/cgroup. Although it has nothing
to do with root filesystem, it contains docker id. Record it, and
deal with it in the filter: For each process that has pivot_root, it
records its docker id, we remember the map from docker id to rootfs;
then check all processes on the tree, if it has docker id, add the
corresponding rootfs.

**2. Exit time of pids to be zero**

Besides, I fix the exit time of pid in this commit. After merging
the same processes, sort them in ascending order, so that in each
tgid node, the main pid is always the first thread. Then, check
other pids' exit time, if is zero, assumpt that exit time is the
same as main pid, which means the process exit while the thread is
running.

**3. Wrong parent**

I fix the ppid of threads. For example, process 10 has a child
process 20, 20 has threads 20 and 23. When pid 20 is recvd, the ppid
and parentTgid in message must be 10. But then, 10 exits, and the parent
process of 20 comes to be 1, then 20 makes thread 23. When pid 23 is
recvd, the ppid and parentTgid is 1, that's totally wrong!

Also, using the sorted process array, we can easily find the main
thread, so get the real parent, and check the ppid of other threads.

**4. Clean file name**

The original file name in database may be complex(such as
"/1/2/./../3"). Clean it with go pkg "path"

**5. Next step**

TODO: Fix the netlink connector, may it usable immediately after
powering on. Then the view.

3 files changed, 32 insertions, 7 deletions

diff --git a/listener/deal.go b/listener/deal.go
index 8225224..70c2827 100644
--- a/listener/deal.go
+++ b/listener/deal.go
@@ -79,19 +79,19 @@ func deal() {
 
                 switch cooked.tag {
                 case NEWPID:
-                        go dealNewPid(cooked)
+                        dealNewPid(cooked)
                 case EXECVE:
-                        go dealExecve(cooked)
+                        dealExecve(cooked)
                 case PIDEXIT:
-                        go deletePid(cooked)
+                        deletePid(cooked)
                 case FILEOPEN:
-                        go fileOpen(cooked)
+                        fileOpen(cooked)
                 case FILEWRITE:
-                        go fileWrite(cooked)
+                        fileWrite(cooked)
                 case FILECLOSE:
-                        go fileClose(cooked)
+                        fileClose(cooked)
                 case PIVOTROOT:
-                        go pivotRoot(cooked)
+                        pivotRoot(cooked)
                 }
         }
 }
@@ -131,6 +131,7 @@ func dealNewPid(cooked Event) {
                 docRes[0].Cwd = cooked.cwd
                 docRes[0].Comm = cooked.comm
                 docRes[0].Args = cooked.argv
+                docRes[0].DockerId = cooked.cgroup
 
                 err := pidCol.ReplaceOne(bson.M{"pid": cooked.pid}, docRes[0])
                 if err != nil {
@@ -149,6 +150,7 @@ func dealNewPid(cooked Event) {
                         Cwd:            cooked.cwd,
                         Execve:         make([]Exec, 0),
                         Children:       make([]int, 0),
+                        DockerId:       cooked.cgroup,
                 })
                 if err != nil {
                         fmt.Fprintf(os.Stderr, "Err inserting: %v\n", err)
diff --git a/listener/global.go b/listener/global.go
index 11b18bf..b782284 100644
--- a/listener/global.go
+++ b/listener/global.go
@@ -37,6 +37,7 @@ type Event struct {
         argv             []string
         comm             string
         cwd              string
+        cgroup           string
         exit_code        int
         exit_signal      int
         srcPath          string
@@ -67,6 +68,7 @@ type Process struct {
         RootFS         string    `bson:"rootfs"`
         Cwd            string    `bson:"cwd"`
         Children       []int     `bson:"children"`
+        DockerId       string    `bson:"docker_id"`
         Execve         []Exec    `bson:"execve"`
         ExitCode       int       `bson:"exit_code"`
         ExitSignal     int       `bson:"exit_signal"`
diff --git a/listener/godo.go b/listener/godo.go
index 87e9446..8d82231 100644
--- a/listener/godo.go
+++ b/listener/godo.go
@@ -8,6 +8,7 @@ import (
         "netlink"
         "os"
         "os/exec"
+        "regexp"
         "strings"
         "syscall"
         "time"
@@ -176,4 +177,24 @@ func checkProc(pCooked *Event) {
                 fmt.Fprintf(os.Stderr, "Err: %v\n", err)
                 pCooked.cwd = ""
         }
+
+        fd, err = os.Open(fileName + "cgroup")
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Err: %v\n", err)
+                // cgroup记空，即没赶上
+                return
+        }
+        scanner = bufio.NewScanner(fd)
+        cgroupRegex := regexp.MustCompile(`/docker/([0-9a-f]+)$`)
+        scanner.Split(bufio.ScanLines)
+        for scanner.Scan() {
+                line := scanner.Text()
+                if cgroupRegex.MatchString(line) {
+                        match := cgroupRegex.FindStringSubmatch(line)
+                        pCooked.cgroup = match[1]
+                        return
+                }
+        }
+        fd.Close()
+        pCooked.cgroup = ""
 }