Add clock attack support.

cmd/attack/attack.go

@@ -35,6 +35,7 @@ func NewAttackCommand() *cobra.Command {
 		NewDiskAttackCommand(&uid),
 		NewHostAttackCommand(&uid),
 		NewJVMAttackCommand(&uid),
+		NewClockAttackCommand(&uid),
 	)
 
 	return cmd

cmd/attack/clock.go

@@ -0,0 +1,68 @@
+// Copyright 2021 Chaos Mesh Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package attack
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"go.uber.org/fx"
+
+	"github.com/chaos-mesh/chaosd/cmd/server"
+	"github.com/chaos-mesh/chaosd/pkg/core"
+	"github.com/chaos-mesh/chaosd/pkg/server/chaosd"
+	"github.com/chaos-mesh/chaosd/pkg/utils"
+)
+
+func NewClockAttackCommand(uid *string) *cobra.Command {
+	options := core.NewClockOption()
+	dep := fx.Options(
+		server.Module,
+		fx.Provide(func() *core.ClockOption {
+			options.UID = *uid
+			return options
+		}),
+	)
+
+	cmd := &cobra.Command{
+		Use:   "clock attack",
+		Short: "clock skew",
+		Run: func(*cobra.Command, []string) {
+			options.Action = "Attack"
+			utils.FxNewAppWithoutLog(dep, fx.Invoke(processClockAttack)).Run()
+		},
+	}
+
+	cmd.Flags().IntVarP(&options.Pid, "pid", "p", 0, "Pid of target program.")
+	cmd.Flags().StringVarP(&options.TimeOffset, "time-offset", "t", "", "Specifies the length of time offset.")
+	cmd.Flags().StringVarP(&options.ClockIdsSlice, "clock-ids-slice", "c", "CLOCK_REALTIME",
+		"The identifier of the particular clock on which to act."+
+			"More clock description in linux kernel can be found in man page of clock_getres, clock_gettime, clock_settime."+
+			"Muti clock ids should be split with \",\"")
+	return cmd
+}
+
+func processClockAttack(options *core.ClockOption, chaos *chaosd.Server) {
+	err := options.PreProcess()
+	if err != nil {
+		utils.ExitWithError(utils.ExitBadArgs, err)
+	}
+
+	uid, err := chaos.ExecuteAttack(chaosd.ClockAttack, options, core.CommandMode)
+	if err != nil {
+		utils.ExitWithError(utils.ExitError, err)
+	}
+
+	utils.NormalExit(fmt.Sprintf("Clock attack %v successfully, uid: %s", options, uid))
+}

pkg/core/clock.go

@@ -0,0 +1,112 @@
+// Copyright 2021 Chaos Mesh Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package core
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/pingcap/log"
+	"go.uber.org/zap"
+
+	"github.com/chaos-mesh/chaos-mesh/pkg/time/utils"
+)
+
+type ClockOption struct {
+	CommonAttackConfig
+
+	Pid int
+
+	TimeOffset string
+	SecDelta   int64
+	NsecDelta  int64
+
+	ClockIdsSlice string
+
+	Store ClockFuncStore
+
+	ClockIdsMask uint64
+}
+
+type ClockFuncStore struct {
+	CodeOfGetClockFunc []byte
+	OriginAddress      uint64
+}
+
+func NewClockOption() *ClockOption {
+	return &ClockOption{
+		CommonAttackConfig: CommonAttackConfig{
+			Kind: ClockAttack,
+		},
+	}
+}
+
+func (opt *ClockOption) PreProcess() error {
+	clkIds := strings.Split(opt.ClockIdsSlice, ",")
+
+	offset, err := time.ParseDuration(opt.TimeOffset)
+	if err != nil {
+		return err
+	}
+	opt.SecDelta = int64(offset / time.Second)
+	opt.NsecDelta = int64(offset % time.Second)
+
+	clockIdsMask, err := utils.EncodeClkIds(clkIds)
+	if err != nil {
+		log.Error("error while converting clock ids to mask", zap.Error(err))
+		return err
+	}
+	if clockIdsMask == 0 {
+		log.Error("clock ids must not be empty")
+		return fmt.Errorf("clock ids must not be empty")
+	}
+	opt.ClockIdsMask = clockIdsMask
+
+	if uint64(opt.SecDelta) > 1<<31 {
+		log.Warn("Monotonic clock will be broken when sec delta is too large or too small.")
+		if uint64(opt.SecDelta) > 1<<56 {
+			log.Warn("Time zone info will be broken when sec delta is too large or too small.")
+		}
+	}
+
+	if uint64(opt.NsecDelta) > 1<<56 {
+		log.Warn("Time will be broken when nanosecond delta is too large or too small")
+	}
+
+	// Since os.FindProcess in unix systems will always succeed
+	// regardless of whether the process exists (https://pkg.go.dev/os#FindProcess),
+	// we need to use process.Signal to check if pid is accessible.
+	process, err := os.FindProcess(opt.Pid)
+	if err != nil {
+		log.Error("failed to find process", zap.Error(err))
+		return err
+	}
+
+	err = process.Signal(syscall.Signal(0))
+	if err != nil {
+		log.Error("pid may not be accessible", zap.Error(err))
+		return err
+	}
+	return nil
+}
+
+func (opt ClockOption) RecoverData() string {
+	data, _ := json.Marshal(opt)
+
+	return string(data)
+}

pkg/core/experiment.go

@@ -35,6 +35,7 @@ const (
 	NetworkAttack = "network"
 	StressAttack  = "stress"
 	DiskAttack    = "disk"
+	ClockAttack   = "clock"
 	HostAttack    = "host"
 	JVMAttack     = "jvm"
 )
@@ -104,6 +105,8 @@ func GetAttackByKind(kind string) *AttackConfig {
 		attackConfig = &DiskAttackConfig{}
 	case JVMAttack:
 		attackConfig = &JVMCommand{}
+	case ClockAttack:
+		attackConfig = &ClockOption{}
 	default:
 		return nil
 	}

pkg/server/chaosd/attack.go

@@ -30,7 +30,14 @@ type Environment struct {
 }
 
 type AttackType interface {
+	// Attack execute attack with options and env.
+	// ExecuteAttack will store the options ahead of Attack be executed
+	// and will store options again after Attack be executed.
+	// We can also use env.Chaos.expStore to touch the storage of chaosd.
+	// But do not update it with your own uid ,
+	// because it will be covered after Attack executed with options.
 	Attack(options core.AttackConfig, env Environment) error
+	// Recover can get marshaled options data from experiment and recover it.
 	Recover(experiment core.Experiment, env Environment) error
 }
 
@@ -59,25 +66,26 @@ func (s *Server) ExecuteAttack(attackType AttackType, options core.AttackConfig,
 		RecoverCommand: options.RecoverData(),
 		LaunchMode:     launchMode,
 	}
-	if err = s.exp.Set(context.Background(), exp); err != nil {
+	if err = s.expStore.Set(context.Background(), exp); err != nil {
 		err = perr.WithStack(err)
 		return
 	}
 
 	defer func() {
 		if err != nil {
-			if err := s.exp.Update(context.Background(), uid, core.Error, err.Error(), options.RecoverData()); err != nil {
+			if err := s.expStore.Update(context.Background(), uid, core.Error, err.Error(), options.RecoverData()); err != nil {
 				log.Error("failed to update experiment", zap.Error(err))
 			}
 			return
 		}
+
 		var newStatus string
 		if len(options.Cron()) > 0 {
 			newStatus = core.Scheduled
 		} else {
 			newStatus = core.Success
 		}
-		if err := s.exp.Update(context.Background(), uid, newStatus, "", options.RecoverData()); err != nil {
+		if err := s.expStore.Update(context.Background(), uid, newStatus, "", options.RecoverData()); err != nil {
 			log.Error("failed to update experiment", zap.Error(err))
 		}
 	}()