// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Package containermount implements the tests for ARC related mount points.
package containermount

import (
	"context"
	"io/ioutil"
	"path/filepath"
	"reflect"
	"regexp"
	"sort"
	"strconv"
	"strings"

	"chromiumos/tast/common/testexec"
	upstartcommon "chromiumos/tast/common/upstart"
	"chromiumos/tast/errors"
	"chromiumos/tast/local/arc"
	"chromiumos/tast/local/sysutil"
	"chromiumos/tast/local/upstart"
	"chromiumos/tast/testing"
)

// mountsForMinijail returns a list of mount points of the minijail'ed process
// whose PID file is at pidFile.
func mountsForMinijail(pidFile string) ([]sysutil.MountInfo, error) {
	b, err := ioutil.ReadFile(pidFile)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to read %s", pidFile)
	}
	pid, err := strconv.Atoi(strings.TrimSpace(string(b)))
	if err != nil {
		return nil, errors.Wrapf(err, "failed to parse %s", b)
	}
	return sysutil.MountInfoForPID(pid)
}

// arcMounts returns a list of mount point info for ARC's mount namespace.
func arcMounts() ([]sysutil.MountInfo, error) {
	pid, err := arc.InitPID()
	if err != nil {
		return nil, err
	}
	return sysutil.MountInfoForPID(int(pid))
}

// adbdMounts returns a list of mount point info for arc-adbd's mount namespace.
func adbdMounts(ctx context.Context) ([]sysutil.MountInfo, error) {
	goal, state, _, err := upstart.JobStatus(ctx, "arc-adbd")
	if err != nil {
		return nil, err
	}
	if goal == upstartcommon.StopGoal && state == upstartcommon.WaitingState {
		// On the current platform arc-adbd is not used.
		return nil, nil
	}
	return mountsForMinijail("/run/arc/adbd.pid")
}

// sdcardMounts returns a list of mount point info for sdcard.
// In ARC N, it returns a list of mount point info for sdcard daemon's mount
// namespace. In ARC P, it returns a list of esdfs typed mount points.
func sdcardMounts() ([]sysutil.MountInfo, error) {
	// In ARC P, esdfs is used. Returns the mount points of esdfs file
	// system type.
	global, err := sysutil.MountInfoForPID(sysutil.SelfPID)
	if err != nil {
		return nil, err
	}
	var ret []sysutil.MountInfo
	for _, m := range global {
		if strings.HasPrefix(m.Fstype, "esdfs") {
			ret = append(ret, m)
		}
	}
	return ret, nil
}

// mountPassthroughMounts returns a list of mount point info for
// mount-passthrough daemons. Currently there are 8 mount-passthrough daemon
// jobs for MyFiles and removable media.
// The name should be matched to the following regexp:
//   "arc-(myfiles|removable-media)(-(default|read|write))?
func mountPassthroughMounts(ctx context.Context) ([]sysutil.MountInfo, error) {
	var ret []sysutil.MountInfo
	for _, job := range []string{
		"arc-myfiles",
		"arc-myfiles-default",
		"arc-myfiles-read",
		"arc-myfiles-write",
		"arc-removable-media",
		"arc-removable-media-default",
		"arc-removable-media-read",
		"arc-removable-media-write",
	} {
		_, _, pid, err := upstart.JobStatus(ctx, job)
		if err != nil {
			return nil, err
		}
		if pid == 0 {
			testing.ContextLogf(ctx, "%s is not running, skipped", job)
			continue
		}
		// mount-passthrough runs as a child of the upstart job process.
		out, err := testexec.CommandContext(ctx, "pgrep", "--parent", strconv.Itoa(pid)).Output(testexec.DumpLogOnError)
		if err != nil {
			return nil, err
		}
		pid, err = strconv.Atoi(strings.TrimSpace(string(out)))
		if err != nil {
			return nil, errors.Wrapf(err, "failed to parse PID: %s", out)
		}
		mounts, err := sysutil.MountInfoForPID(pid)
		if err != nil {
			return nil, err
		}
		ret = append(ret, mounts...)
	}
	return ret, nil
}

// obbMounts returns a list of mount point info for obb-mounter's namespace.
func obbMounts(ctx context.Context) ([]sysutil.MountInfo, error) {
	out, err := testexec.CommandContext(ctx, "pgrep", "-f", "-u", "root", "^/usr/bin/arc-obb-mounter").Output(testexec.DumpLogOnError)
	if err != nil {
		return nil, err
	}
	pid, err := strconv.Atoi(strings.TrimSpace(string(out)))
	if err != nil {
		return nil, errors.Wrapf(err, "failed to parse PID: %s", out)
	}
	return sysutil.MountInfoForPID(pid)
}

func joinMounts(mss ...[]sysutil.MountInfo) []sysutil.MountInfo {
	var ret []sysutil.MountInfo
	for _, ms := range mss {
		ret = append(ret, ms...)
	}
	return ret
}

func testNoARCLeak(ctx context.Context, s *testing.State, global []sysutil.MountInfo) {
	s.Log("Running testNoARCLeak")

	const root = "/opt/google/containers/android/rootfs/"

	var paths []string
	for _, m := range global {
		if !strings.HasPrefix(m.MountPath, root) {
			// Not the mount point under the container root.
			continue
		}
		p, err := filepath.Rel(root, m.MountPath)
		if err != nil {
			s.Errorf("Couldn't take relative path of %s from %s: %v", m.MountPath, root, err)
			return
		}
		// system/lib/arm is only required when houdini is used.
		if p == "system/lib/arm" {
			continue
		}
		paths = append(paths, p)
	}
	sort.Strings(paths)

	expect := []string{
		"android-data",
		"root",
	}
	if !reflect.DeepEqual(paths, expect) {
		s.Errorf("Unexpected mount paths: got %v; want %v", paths, expect)
	}
}

func testNoARCSharedLeak(ctx context.Context, s *testing.State, arc, nonARC []sysutil.MountInfo) {
	s.Log("Running testNoARCSharedLeak")

	// Set of peer groups which are visible from outside of ARC container.
	visibles := make(map[int]struct{})
	for _, m := range nonARC {
		if m.Shared > 0 {
			visibles[m.Shared] = struct{}{}
		}
		// TODO(chavey): crbug/1126921 - replace master in structure.
		if m.Master > 0 {
			visibles[m.Master] = struct{}{}
		}
	}

	// Peer groups in ARC container must not be visible from outside of
	// ARC container.
	for _, m := range arc {
		if m.Shared == 0 {
			// Not shared. Skip.
			continue
		}
		if _, ok := visibles[m.Shared]; ok {
			s.Errorf("Peer group in ARC container is being leaked: %s:%d", m.MountPath, m.Shared)
		}
	}
}

func testDebugfsTracefs(ctx context.Context, s *testing.State, arc []sysutil.MountInfo) {
	s.Log("Running testDebugfsTracefs")

	// If debugfs/tracefs is mounted somewhere in the container,
	// - It should be mounted at /sys/kernel/debug/tracing, and
	// - It should be /tracing portion of debugfs (or the root of tracefs for kernels >= 4.4)
	// And there is at most one such mount.
	// Or there could be sync debugfs mounted.
	// And there can be zero or one sync mounts.

	var numTracing, numSync int
	for _, m := range arc {
		switch m.Fstype {
		case "debugfs":
			if m.Root == "/tracing" && m.MountPath == "/sys/kernel/debug/tracing" {
				numTracing++
			} else if m.Root == "/sync" && m.MountPath == "/sys/kernel/debug/sync" {
				numSync++
			} else {
				s.Errorf("Unexpected debugfs mount point at %s", m.MountPath)
			}
		case "tracefs":
			if m.Root == "/" && m.MountPath == "/sys/kernel/debug/tracing" {
				numTracing++
			} else {
				s.Errorf("Unexpected tracefs mount point at %s", m.MountPath)
			}
		}
	}

	if numTracing != 1 {
		s.Errorf("Unexpected debugfs/tracefs mount points: got %d; want 1", numTracing)
	}
	if numSync != 0 && numSync != 1 {
		s.Errorf("Unexpected sync debug fs mount points: got %d; want 0 or 1", numSync)
	}
}

func testCgroup(ctx context.Context, s *testing.State, arc []sysutil.MountInfo) {
	s.Log("Running testCgroup")

	var paths []string
	for _, m := range arc {
		if m.Fstype != "cgroup" {
			continue
		}
		// This device exists only on some ARM boards like kevin.
		if m.MountPath == "/dev/stune" {
			continue
		}
		paths = append(paths, m.MountPath)
	}
	sort.Strings(paths)
	expect := []string{"/acct", "/dev/cpuctl", "/dev/cpuset"}
	if !reflect.DeepEqual(paths, expect) {
		s.Errorf("Unexpected cgroup paths: got %v; want %v", paths, expect)
		return
	}
}

func testADBD(ctx context.Context, s *testing.State, adbd []sysutil.MountInfo) {
	s.Log("Running testADBD")

	re := regexp.MustCompile(`^/run/arc/adbd(/ep[12])?$`)
	for _, m := range adbd {
		if m.Master > 0 {
			s.Error("adbd proxy container has unknown slave mount at ", m.MountPath)
			continue
		}
		if m.Shared == 0 {
			continue
		}
		if !re.MatchString(m.MountPath) {
			s.Error("adbd proxy container exposes unknown mount point at ", m.MountPath)
		}
	}
}

func testSDCard(ctx context.Context, s *testing.State, sdcard []sysutil.MountInfo) {
	s.Log("Running testSDCard")

	ver, err := arc.SDKVersion()
	if err != nil {
		s.Error("Failed to get SDK version: ", err)
		return
	}

	// If the mount point is shared it should be either:
	// - /mnt/runtime
	// - /mnt/runtime/{default,read,write}/$label
	// In ARC P, the following points are also shared:
	// - /run/arc/sdcard
	// - /run/arc/sdcard/{default,read,write}/$label
	// In ARC Q, the follow points are also shared:
	// - /run/arc/sdcard/full/$label
	pat := `^/mnt/runtime(/(default|read|write)/[^/]+)?$`
	pat += `|^/run/arc/sdcard(/(default|read|write)/[^/]+)?$`
	if ver >= arc.SDKQ {
		pat += `|^/run/arc/sdcard/full/[^/]+$`
	}
	re := regexp.MustCompile(pat)

	for _, m := range sdcard {
		if m.Master > 0 {
			s.Errorf("Unexpected SDCard slave mount at %s", m.MountPath)
			continue
		}
		if m.Shared == 0 {
			continue
		}
		if !re.MatchString(m.MountPath) {
			s.Errorf("Unexpected SDCard shared mount at %s", m.MountPath)
		}
	}
}

func testMountPassthrough(ctx context.Context, s *testing.State, mountPassthrough []sysutil.MountInfo) {
	s.Log("Running testMountPassthrough")

	for _, m := range mountPassthrough {
		// The only shared mount point is /mnt/dest.
		// Note that there might be multiple shared mount points at
		// the exactly same path.
		if m.Shared > 0 && m.MountPath != "/mnt/dest" {
			s.Errorf("Unexpected mount-passthrough shared mount at %s", m.MountPath)
		}
	}
}

func testOBBMount(ctx context.Context, s *testing.State, obb []sysutil.MountInfo) {
	s.Log("Running testOBBMount")

	for _, m := range obb {
		// The only shared mount point is /var/run/arc/obb.
		if m.Shared > 0 && m.MountPath != "/var/run/arc/obb" {
			s.Errorf("Unexpected OBB shared mount at %s", m.MountPath)
		}
	}
}

func testMountShared(ctx context.Context, s *testing.State, arcMs, adbd, sdcard, mountPassthrough, obb []sysutil.MountInfo) {
	ignored := make(map[string]struct{})
	if adbd == nil {
		// ADBD proxy container does not run on all boards because it
		// needs to have hardware and kernel support.
		ignored["/dev/usb-ffs/adb"] = struct{}{}
	}

	// In ARC P or later, ignore initial tmpfs mount for /run/arc/sdcard
	// because it is slave mount but has the initns as its parent.
	ignored["/var/run/arc/sdcard"] = struct{}{}
	// Ignore unix domain socket for ADB communication.
	ignored["/var/run/arc/adb"] = struct{}{}
	// Ignore /data since this is a side-effect of /home/root in
	// the root mount namespace being marked MS_SHARED.
	// TODO(crbug.com/1069501): Remove once bug is fixed.
	ignored["/data"] = struct{}{}

	if len(ignored) > 0 {
		var paths []string
		for p := range ignored {
			paths = append(paths, p)
		}
		s.Log("Ignored mount paths: ", paths)
	}

	peerGroups := make(map[int]struct{})
	for _, ms := range [][]sysutil.MountInfo{arcMs, adbd, sdcard, mountPassthrough, obb} {
		for _, m := range ms {
			if m.Shared > 0 {
				peerGroups[m.Shared] = struct{}{}
			}
		}
	}
	for _, m := range arcMs {
		if _, ok := ignored[m.MountPath]; ok {
			continue
		}
		// Masters of all non-allowed SLAVE mount points in ARC
		// container must be in containers.
		if m.Master == 0 {
			continue
		}
		if _, ok := peerGroups[m.Master]; !ok {
			s.Error("Unexpected slave mount at ", m.MountPath)
		}
	}
}

// RunTest exercises the ARC related mount point conditions.
func RunTest(ctx context.Context, s *testing.State, a *arc.ARC) {
	global, err := sysutil.MountInfoForPID(sysutil.SelfPID)
	if err != nil {
		s.Fatal("Failed to get mountinfo list: ", err)
	}

	arc, err := arcMounts()
	if err != nil {
		s.Fatal("Failed to get mountinfo list for ARC: ", err)
	}

	adbd, err := adbdMounts(ctx)
	if err != nil {
		s.Fatal("Failed to get mountinfo list for arc-adbd: ", err)
	}

	sdcard, err := sdcardMounts()
	if err != nil {
		s.Fatal("Failed to get mountinfo list for sdcard: ", err)
	}

	mountPassthrough, err := mountPassthroughMounts(ctx)
	if err != nil {
		s.Fatal("Failed to get mountinfo list for mount-passthrough: ", err)
	}

	obb, err := obbMounts(ctx)
	if err != nil {
		s.Fatal("Failed to get mountinfo list for arc-obb-mounter: ", err)
	}

	testNoARCLeak(ctx, s, global)
	testNoARCSharedLeak(ctx, s, arc, joinMounts(global, adbd, sdcard, obb))
	testDebugfsTracefs(ctx, s, arc)
	testCgroup(ctx, s, arc)
	testADBD(ctx, s, adbd)
	testSDCard(ctx, s, sdcard)
	testMountPassthrough(ctx, s, mountPassthrough)
	testOBBMount(ctx, s, obb)
	testMountShared(ctx, s, arc, adbd, sdcard, mountPassthrough, obb)
}