306 lines
8.3 KiB
Go
306 lines
8.3 KiB
Go
package vm
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
cbg "github.com/whyrusleeping/cbor-gen"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
actorstypes "github.com/filecoin-project/go-state-types/actors"
|
|
builtinst "github.com/filecoin-project/go-state-types/builtin"
|
|
"github.com/filecoin-project/go-state-types/exitcode"
|
|
"github.com/filecoin-project/go-state-types/network"
|
|
vmr "github.com/filecoin-project/specs-actors/v7/actors/runtime"
|
|
|
|
"github.com/filecoin-project/lotus/chain/actors"
|
|
"github.com/filecoin-project/lotus/chain/actors/aerrors"
|
|
"github.com/filecoin-project/lotus/chain/actors/builtin"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
)
|
|
|
|
type MethodMeta struct {
|
|
Name string
|
|
|
|
Params reflect.Type
|
|
Ret reflect.Type
|
|
}
|
|
|
|
type ActorRegistry struct {
|
|
actors map[cid.Cid]*actorInfo
|
|
|
|
Methods map[cid.Cid]map[abi.MethodNum]MethodMeta
|
|
}
|
|
|
|
// An ActorPredicate returns an error if the given actor is not valid for the given runtime environment (e.g., chain height, version, etc.).
|
|
type ActorPredicate func(vmr.Runtime, cid.Cid) error
|
|
|
|
func ActorsVersionPredicate(ver actorstypes.Version) ActorPredicate {
|
|
return func(rt vmr.Runtime, codeCid cid.Cid) error {
|
|
aver, err := actorstypes.VersionForNetwork(rt.NetworkVersion())
|
|
if err != nil {
|
|
return xerrors.Errorf("unsupported network version: %w", err)
|
|
}
|
|
if aver != ver {
|
|
return xerrors.Errorf("actor %s is a version %d actor; chain only supports actor version %d at height %d and nver %d", codeCid, ver, aver, rt.CurrEpoch(), rt.NetworkVersion())
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
type invokeFunc func(rt vmr.Runtime, params []byte) ([]byte, aerrors.ActorError)
|
|
type nativeCode map[abi.MethodNum]invokeFunc
|
|
|
|
type actorInfo struct {
|
|
methods nativeCode
|
|
vmActor builtin.RegistryEntry
|
|
// TODO: consider making this a network version range?
|
|
predicate ActorPredicate
|
|
}
|
|
|
|
func NewActorRegistry() *ActorRegistry {
|
|
return &ActorRegistry{
|
|
actors: make(map[cid.Cid]*actorInfo),
|
|
Methods: map[cid.Cid]map[abi.MethodNum]MethodMeta{},
|
|
}
|
|
}
|
|
|
|
func (ar *ActorRegistry) Invoke(codeCid cid.Cid, rt vmr.Runtime, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
|
|
act, ok := ar.actors[codeCid]
|
|
if !ok {
|
|
log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Receiver())
|
|
return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "no code for actor %s(%d)(%s)", codeCid, method, hex.EncodeToString(params))
|
|
}
|
|
if err := act.predicate(rt, codeCid); err != nil {
|
|
return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "unsupported actor: %s", err)
|
|
}
|
|
if act.methods[method] == nil {
|
|
return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "no method %d on actor", method)
|
|
}
|
|
return act.methods[method](rt, params)
|
|
|
|
}
|
|
|
|
func (ar *ActorRegistry) Register(av actorstypes.Version, pred ActorPredicate, vmactors []builtin.RegistryEntry) {
|
|
if pred == nil {
|
|
pred = func(vmr.Runtime, cid.Cid) error { return nil }
|
|
}
|
|
for _, a := range vmactors {
|
|
|
|
var code nativeCode
|
|
var err error
|
|
if av <= actorstypes.Version7 {
|
|
// register in the `actors` map (for the invoker)
|
|
code, err = ar.transform(a)
|
|
if err != nil {
|
|
panic(xerrors.Errorf("%s: %w", string(a.Code().Hash()), err))
|
|
}
|
|
}
|
|
|
|
ai := &actorInfo{
|
|
methods: code,
|
|
vmActor: a,
|
|
predicate: pred,
|
|
}
|
|
|
|
ac := a.Code()
|
|
ar.actors[ac] = ai
|
|
|
|
// necessary to make stuff work
|
|
var realCode cid.Cid
|
|
if av >= actorstypes.Version8 {
|
|
name := actors.CanonicalName(builtin.ActorNameByCode(ac))
|
|
|
|
var ok bool
|
|
realCode, ok = actors.GetActorCodeID(av, name)
|
|
if ok {
|
|
ar.actors[realCode] = ai
|
|
}
|
|
}
|
|
|
|
// register in the `Methods` map (used by statemanager utils)
|
|
exports := a.Exports()
|
|
methods := make(map[abi.MethodNum]MethodMeta, len(exports))
|
|
|
|
// Explicitly add send, it's special.
|
|
methods[builtin.MethodSend] = MethodMeta{
|
|
Name: "Send",
|
|
Params: reflect.TypeOf(new(abi.EmptyValue)),
|
|
Ret: reflect.TypeOf(new(abi.EmptyValue)),
|
|
}
|
|
|
|
// Iterate over exported methods. Some of these _may_ be nil and
|
|
// must be skipped.
|
|
for number, export := range exports {
|
|
if export.Method == nil {
|
|
continue
|
|
}
|
|
|
|
ev := reflect.ValueOf(export.Method)
|
|
et := ev.Type()
|
|
|
|
mm := MethodMeta{
|
|
Name: export.Name,
|
|
Ret: et.Out(0),
|
|
}
|
|
|
|
if av <= actorstypes.Version7 {
|
|
// methods exported from specs-actors have the runtime as the first param, so we want et.In(1)
|
|
mm.Params = et.In(1)
|
|
} else {
|
|
// methods exported from go-state-types do not, so we want et.In(0)
|
|
mm.Params = et.In(0)
|
|
}
|
|
|
|
methods[number] = mm
|
|
}
|
|
if realCode.Defined() {
|
|
ar.Methods[realCode] = methods
|
|
} else {
|
|
ar.Methods[a.Code()] = methods
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ar *ActorRegistry) Create(codeCid cid.Cid, rt vmr.Runtime) (*types.Actor, aerrors.ActorError) {
|
|
act, ok := ar.actors[codeCid]
|
|
if !ok {
|
|
return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Can only create built-in actors.")
|
|
}
|
|
|
|
if err := act.predicate(rt, codeCid); err != nil {
|
|
return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Cannot create actor: %w", err)
|
|
}
|
|
|
|
return &types.Actor{
|
|
Code: codeCid,
|
|
Head: EmptyObjectCid,
|
|
Nonce: 0,
|
|
Balance: abi.NewTokenAmount(0),
|
|
}, nil
|
|
}
|
|
|
|
type invokee interface {
|
|
Exports() map[abi.MethodNum]builtinst.MethodMeta
|
|
}
|
|
|
|
func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
|
|
itype := reflect.TypeOf(instance)
|
|
exports := instance.Exports()
|
|
runtimeType := reflect.TypeOf((*vmr.Runtime)(nil)).Elem()
|
|
for i, e := range exports {
|
|
i := i
|
|
m := e.Method
|
|
newErr := func(format string, args ...interface{}) error {
|
|
str := fmt.Sprintf(format, args...)
|
|
return fmt.Errorf("transform(%s) export(%d): %s", itype.Name(), i, str)
|
|
}
|
|
|
|
if m == nil {
|
|
continue
|
|
}
|
|
|
|
meth := reflect.ValueOf(m)
|
|
t := meth.Type()
|
|
if t.Kind() != reflect.Func {
|
|
return nil, newErr("is not a function")
|
|
}
|
|
if t.NumIn() != 2 {
|
|
return nil, newErr("wrong number of inputs should be: " +
|
|
"vmr.Runtime, <parameter>")
|
|
}
|
|
if !runtimeType.Implements(t.In(0)) {
|
|
return nil, newErr("first argument should be vmr.Runtime")
|
|
}
|
|
if t.In(1).Kind() != reflect.Ptr {
|
|
return nil, newErr("second argument should be of kind reflect.Ptr")
|
|
}
|
|
|
|
if t.NumOut() != 1 {
|
|
return nil, newErr("wrong number of outputs should be: " +
|
|
"cbg.CBORMarshaler")
|
|
}
|
|
o0 := t.Out(0)
|
|
if !o0.Implements(reflect.TypeOf((*cbg.CBORMarshaler)(nil)).Elem()) {
|
|
return nil, newErr("output needs to implement cgb.CBORMarshaler")
|
|
}
|
|
}
|
|
code := make(nativeCode, len(exports))
|
|
for id, e := range exports {
|
|
m := e.Method
|
|
if m == nil {
|
|
continue
|
|
}
|
|
meth := reflect.ValueOf(m)
|
|
code[id] = reflect.MakeFunc(reflect.TypeOf((invokeFunc)(nil)),
|
|
func(in []reflect.Value) []reflect.Value {
|
|
paramT := meth.Type().In(1).Elem()
|
|
param := reflect.New(paramT)
|
|
|
|
rt := in[0].Interface().(*Runtime)
|
|
inBytes := in[1].Interface().([]byte)
|
|
if err := DecodeParams(inBytes, param.Interface()); err != nil {
|
|
ec := exitcode.ErrSerialization
|
|
if rt.NetworkVersion() < network.Version7 {
|
|
ec = 1
|
|
}
|
|
aerr := aerrors.Absorb(err, ec, "failed to decode parameters")
|
|
return []reflect.Value{
|
|
reflect.ValueOf([]byte{}),
|
|
// Below is a hack, fixed in Go 1.13
|
|
// https://git.io/fjXU6
|
|
reflect.ValueOf(&aerr).Elem(),
|
|
}
|
|
}
|
|
rval, aerror := rt.shimCall(func() interface{} {
|
|
ret := meth.Call([]reflect.Value{
|
|
reflect.ValueOf(rt),
|
|
param,
|
|
})
|
|
return ret[0].Interface()
|
|
})
|
|
|
|
return []reflect.Value{
|
|
reflect.ValueOf(&rval).Elem(),
|
|
reflect.ValueOf(&aerror).Elem(),
|
|
}
|
|
}).Interface().(invokeFunc)
|
|
|
|
}
|
|
return code, nil
|
|
}
|
|
|
|
func DecodeParams(b []byte, out interface{}) error {
|
|
um, ok := out.(cbg.CBORUnmarshaler)
|
|
if !ok {
|
|
return fmt.Errorf("type %T does not implement UnmarshalCBOR", out)
|
|
}
|
|
|
|
return um.UnmarshalCBOR(bytes.NewReader(b))
|
|
}
|
|
|
|
func DumpActorState(i *ActorRegistry, act *types.Actor, b []byte) (interface{}, error) {
|
|
actInfo, ok := i.actors[act.Code]
|
|
if !ok {
|
|
return nil, xerrors.Errorf("state type for actor %s not found", act.Code)
|
|
}
|
|
|
|
um := actInfo.vmActor.State()
|
|
if um == nil {
|
|
if act.Head != EmptyObjectCid {
|
|
return nil, xerrors.Errorf("actor with code %s should only have empty object (%s) as its Head, instead has %s", act.Code, EmptyObjectCid, act.Head)
|
|
}
|
|
|
|
return nil, nil
|
|
}
|
|
if err := um.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
|
|
return nil, xerrors.Errorf("unmarshaling actor state: %w", err)
|
|
}
|
|
|
|
return um, nil
|
|
}
|