github.com/bamzi/go-ethereum@v1.6.7-0.20170704111104-138f26c93af1/core/vm/logger.go (about)

     1  // Copyright 2015 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package vm
    18  
    19  import (
    20  	"encoding/hex"
    21  	"fmt"
    22  	"io"
    23  	"math/big"
    24  	"time"
    25  
    26  	"github.com/ethereum/go-ethereum/common"
    27  	"github.com/ethereum/go-ethereum/common/hexutil"
    28  	"github.com/ethereum/go-ethereum/common/math"
    29  	"github.com/ethereum/go-ethereum/core/types"
    30  )
    31  
    32  type Storage map[common.Hash]common.Hash
    33  
    34  func (self Storage) Copy() Storage {
    35  	cpy := make(Storage)
    36  	for key, value := range self {
    37  		cpy[key] = value
    38  	}
    39  
    40  	return cpy
    41  }
    42  
    43  // LogConfig are the configuration options for structured logger the EVM
    44  type LogConfig struct {
    45  	DisableMemory  bool // disable memory capture
    46  	DisableStack   bool // disable stack capture
    47  	DisableStorage bool // disable storage capture
    48  	FullStorage    bool // show full storage (slow)
    49  	Limit          int  // maximum length of output, but zero means unlimited
    50  }
    51  
    52  //go:generate gencodec -type StructLog -field-override structLogMarshaling -out gen_structlog.go
    53  
    54  // StructLog is emitted to the EVM each cycle and lists information about the current internal state
    55  // prior to the execution of the statement.
    56  type StructLog struct {
    57  	Pc         uint64                      `json:"pc"`
    58  	Op         OpCode                      `json:"op"`
    59  	Gas        uint64                      `json:"gas"`
    60  	GasCost    uint64                      `json:"gasCost"`
    61  	Memory     []byte                      `json:"memory"`
    62  	MemorySize int                         `json:"memSize"`
    63  	Stack      []*big.Int                  `json:"stack"`
    64  	Storage    map[common.Hash]common.Hash `json:"-"`
    65  	Depth      int                         `json:"depth"`
    66  	Err        error                       `json:"error"`
    67  }
    68  
    69  // overrides for gencodec
    70  type structLogMarshaling struct {
    71  	Stack   []*math.HexOrDecimal256
    72  	Gas     math.HexOrDecimal64
    73  	GasCost math.HexOrDecimal64
    74  	Memory  hexutil.Bytes
    75  	OpName  string `json:"opName"`
    76  }
    77  
    78  func (s *StructLog) OpName() string {
    79  	return s.Op.String()
    80  }
    81  
    82  // Tracer is used to collect execution traces from an EVM transaction
    83  // execution. CaptureState is called for each step of the VM with the
    84  // current VM state.
    85  // Note that reference types are actual VM data structures; make copies
    86  // if you need to retain them beyond the current call.
    87  type Tracer interface {
    88  	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
    89  	CaptureEnd(output []byte, gasUsed uint64, t time.Duration) error
    90  }
    91  
    92  // StructLogger is an EVM state logger and implements Tracer.
    93  //
    94  // StructLogger can capture state based on the given Log configuration and also keeps
    95  // a track record of modified storage which is used in reporting snapshots of the
    96  // contract their storage.
    97  type StructLogger struct {
    98  	cfg LogConfig
    99  
   100  	logs          []StructLog
   101  	changedValues map[common.Address]Storage
   102  }
   103  
   104  // NewStructLogger returns a new logger
   105  func NewStructLogger(cfg *LogConfig) *StructLogger {
   106  	logger := &StructLogger{
   107  		changedValues: make(map[common.Address]Storage),
   108  	}
   109  	if cfg != nil {
   110  		logger.cfg = *cfg
   111  	}
   112  	return logger
   113  }
   114  
   115  // CaptureState logs a new structured log message and pushes it out to the environment
   116  //
   117  // CaptureState also tracks SSTORE ops to track dirty values.
   118  func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
   119  	// check if already accumulated the specified number of logs
   120  	if l.cfg.Limit != 0 && l.cfg.Limit <= len(l.logs) {
   121  		return ErrTraceLimitReached
   122  	}
   123  
   124  	// initialise new changed values storage container for this contract
   125  	// if not present.
   126  	if l.changedValues[contract.Address()] == nil {
   127  		l.changedValues[contract.Address()] = make(Storage)
   128  	}
   129  
   130  	// capture SSTORE opcodes and determine the changed value and store
   131  	// it in the local storage container. NOTE: we do not need to do any
   132  	// range checks here because that's already handler prior to calling
   133  	// this function.
   134  	switch op {
   135  	case SSTORE:
   136  		var (
   137  			value   = common.BigToHash(stack.data[stack.len()-2])
   138  			address = common.BigToHash(stack.data[stack.len()-1])
   139  		)
   140  		l.changedValues[contract.Address()][address] = value
   141  	}
   142  
   143  	// copy a snapstot of the current memory state to a new buffer
   144  	var mem []byte
   145  	if !l.cfg.DisableMemory {
   146  		mem = make([]byte, len(memory.Data()))
   147  		copy(mem, memory.Data())
   148  	}
   149  
   150  	// copy a snapshot of the current stack state to a new buffer
   151  	var stck []*big.Int
   152  	if !l.cfg.DisableStack {
   153  		stck = make([]*big.Int, len(stack.Data()))
   154  		for i, item := range stack.Data() {
   155  			stck[i] = new(big.Int).Set(item)
   156  		}
   157  	}
   158  
   159  	// Copy the storage based on the settings specified in the log config. If full storage
   160  	// is disabled (default) we can use the simple Storage.Copy method, otherwise we use
   161  	// the state object to query for all values (slow process).
   162  	var storage Storage
   163  	if !l.cfg.DisableStorage {
   164  		if l.cfg.FullStorage {
   165  			storage = make(Storage)
   166  			// Get the contract account and loop over each storage entry. This may involve looping over
   167  			// the trie and is a very expensive process.
   168  
   169  			env.StateDB.ForEachStorage(contract.Address(), func(key, value common.Hash) bool {
   170  				storage[key] = value
   171  				// Return true, indicating we'd like to continue.
   172  				return true
   173  			})
   174  		} else {
   175  			// copy a snapshot of the current storage to a new container.
   176  			storage = l.changedValues[contract.Address()].Copy()
   177  		}
   178  	}
   179  	// create a new snaptshot of the EVM.
   180  	log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, storage, depth, err}
   181  
   182  	l.logs = append(l.logs, log)
   183  	return nil
   184  }
   185  
   186  func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration) error {
   187  	fmt.Printf("0x%x", output)
   188  	return nil
   189  }
   190  
   191  // StructLogs returns a list of captured log entries
   192  func (l *StructLogger) StructLogs() []StructLog {
   193  	return l.logs
   194  }
   195  
   196  // WriteTrace writes a formatted trace to the given writer
   197  func WriteTrace(writer io.Writer, logs []StructLog) {
   198  	for _, log := range logs {
   199  		fmt.Fprintf(writer, "%-10spc=%08d gas=%v cost=%v", log.Op, log.Pc, log.Gas, log.GasCost)
   200  		if log.Err != nil {
   201  			fmt.Fprintf(writer, " ERROR: %v", log.Err)
   202  		}
   203  		fmt.Fprintf(writer, "\n")
   204  
   205  		for i := len(log.Stack) - 1; i >= 0; i-- {
   206  			fmt.Fprintf(writer, "%08d  %x\n", len(log.Stack)-i-1, math.PaddedBigBytes(log.Stack[i], 32))
   207  		}
   208  
   209  		fmt.Fprint(writer, hex.Dump(log.Memory))
   210  
   211  		for h, item := range log.Storage {
   212  			fmt.Fprintf(writer, "%x: %x\n", h, item)
   213  		}
   214  		fmt.Fprintln(writer)
   215  	}
   216  }
   217  
   218  // WriteLogs writes vm logs in a readable format to the given writer
   219  func WriteLogs(writer io.Writer, logs []*types.Log) {
   220  	for _, log := range logs {
   221  		fmt.Fprintf(writer, "LOG%d: %x bn=%d txi=%x\n", len(log.Topics), log.Address, log.BlockNumber, log.TxIndex)
   222  
   223  		for i, topic := range log.Topics {
   224  			fmt.Fprintf(writer, "%08d  %x\n", i, topic)
   225  		}
   226  
   227  		fmt.Fprint(writer, hex.Dump(log.Data))
   228  		fmt.Fprintln(writer)
   229  	}
   230  }