blob: c473e6a9a9518f638f3b5b81f85a35c9cced8d99 [file] [log] [blame]
// Copyright 2016 The Android Open Source Project
//
// 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,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto2";
package android.vts;
// Class of a target component.
enum ComponentClass {
UNKNOWN_CLASS = 0;
// For a HAL shared library.
HAL_CONVENTIONAL = 1;
// For a submodule of a shared library HAL .
HAL_CONVENTIONAL_SUBMODULE = 2;
// For a legacy HAL.
HAL_LEGACY = 3;
// For a HAL which uses HIDL (HAL Interface Definition Language).
HAL_HIDL = 4;
// For a HAL which uses HIDL (HAL Interface Definition Language).
HAL_HIDL_WRAPPED_CONVENTIONAL = 5;
// For a shared library which is not a HAL (e.g., standard library).
LIB_SHARED = 11;
// For an OS kernel.
KERNEL = 21;
// For an OS kernel module.
KERNEL_MODULE = 22;
}
// Type of a target component.
enum ComponentType {
UNKNOWN_TYPE = 0;
// For an audio submodule.
AUDIO = 1;
// For a camera submodule.
CAMERA = 2;
// For a GPS submodule.
GPS = 3;
// For a Lights sensor submodule.
LIGHT = 4;
// For a WiFi submodule.
WIFI = 5;
// For a mobile networking submodule.
MOBILE = 6;
// For a WiFi submodule.
BLUETOOTH = 7;
// For a NFC submodule
NFC = 8;
// For a power HAL.
POWER = 9;
// For a mem track HAL.
MEMTRACK = 10;
// For a biometrics fingerprint HAL.
BFP = 11;
// for bionic's libm
BIONIC_LIBM = 1001;
// for bionic's libc
BIONIC_LIBC = 1002;
// for VNDK's libcutils
VNDK_LIBCUTILS = 1101;
// for OS kernel's system call.
SYSCALL = 2001;
}
// Type of a variable.
enum VariableType {
UNKNOWN_VARIABLE_TYPE = 0;
TYPE_PREDEFINED = 1;
TYPE_SCALAR = 2;
TYPE_STRING = 3;
TYPE_ENUM = 4;
TYPE_ARRAY = 5;
TYPE_VECTOR = 6;
TYPE_STRUCT = 7;
// for conventional HALs, to keep a data structure with one or multiple
// callback functions.
TYPE_FUNCTION_POINTER = 8;
TYPE_VOID = 9;
TYPE_HIDL_CALLBACK = 10;
TYPE_SUBMODULE = 11;
}
// Type of a target processor architecture.
enum TargetArch {
UNKNOWN_TARGET_ARCH = 0;
TARGET_ARCH_ARM = 1;
TARGET_ARCH_ARM64 = 2;
}
// To specify a call flow event.
message CallFlowSpecificationMessage {
// true if for a function call event.
optional bool entry = 1 [default = false];
// true if for an exit event from a function.
optional bool exit = 2 [default = false];
// a list of functions that can be called right after this event.
repeated bytes next = 11;
// a list of functions that can be called right before this event.
repeated bytes prev = 12;
}
// To specify the measured native code coverage raw data.
message NativeCodeCoverageRawDataMessage {
// gcno file path.
optional bytes file_path = 1;
// content of a gcda file.
optional bytes gcda = 11;
}
// To specify a function.
message FunctionSpecificationMessage {
// the function name.
optional bytes name = 1;
// the submodule name.
optional bytes submodule_name = 2;
// data type of the return value (for legacy HALs and shared libraries).
optional VariableSpecificationMessage return_type = 11;
// data type of the return value (for HIDL HALs).
repeated VariableSpecificationMessage return_type_hidl = 12;
// used to pass the spec of a found HAL_CONVENTIONAL_SUBMODULE to the host.
optional ComponentSpecificationMessage return_type_submodule_spec = 13;
// a list of arguments.
repeated VariableSpecificationMessage arg = 21;
// a specification of the call flows of the function.
repeated CallFlowSpecificationMessage callflow = 31;
// whether it is a callback.
optional bool is_callback = 41;
// when it is a callback.
optional FunctionPointerSpecificationMessage function_pointer = 42;
// profiling data.
repeated float profiling_data = 101;
// measured processed coverage data.
repeated uint32 processed_coverage_data = 201;
// measured raw coverage data.
repeated NativeCodeCoverageRawDataMessage raw_coverage_data = 202;
// not a user-provided variable. used by the frameworks to tell the sub
// struct hierarchy.
optional bytes parent_path = 301;
// to specify a syscall number.
optional uint32 syscall_number = 401;
}
// To keep the value of a scalar variable.
message ScalarDataValueMessage {
optional int32 bool_t = 1;
optional int32 int8_t = 11;
optional uint32 uint8_t = 12;
optional int32 char = 13;
optional uint32 uchar = 14;
optional int32 int16_t = 21;
optional uint32 uint16_t = 22;
optional int32 int32_t = 31;
optional uint32 uint32_t = 32;
optional int64 int64_t = 41;
optional uint64 uint64_t = 42;
optional float float_t = 101;
optional double double_t = 102;
optional uint32 pointer = 201;
optional uint32 opaque = 202;
optional uint32 void_pointer = 211;
optional uint32 char_pointer = 212;
optional uint32 uchar_pointer = 213;
optional uint32 pointer_pointer = 251;
// for scalar attributes in a union data structure,
// to specify the number of used bits.
optional uint32 bits = 1001;
}
// To keep the value of a vector variable.
message VectorDataValueMessage {
optional VariableType type = 1;
// mainly for an array, and also can be used at runtime if this's for a vector.
optional uint32 size = 2;
// when it's for a scalar vector.
optional bytes scalar_type = 11;
repeated ScalarDataValueMessage value = 12;
// when it's for a struct vector.
optional bytes struct_type = 21;
repeated VariableSpecificationMessage struct_value = 22;
}
// To keep the specification and value of a function pointer.
message FunctionPointerSpecificationMessage {
// used for a function pointer to keep its function name.
optional bytes function_name = 1;
// actual pointer value.
optional uint32 address = 11;
// ID used for VTS RMI (remote method invocation).
optional bytes id = 21;
// argument(s)
repeated VariableSpecificationMessage arg = 101;
// data type of the return value (for legacy HALs and shared libraries).
optional VariableSpecificationMessage return_type = 111;
}
// To keep the value of a string variable.
message StringDataValueMessage {
// for actual contents.
optional bytes message = 1;
// for length in bytes, and usually not required.
optional uint32 length = 11;
}
// To keep the value of an enum type variable.
message EnumDataValueMessage {
// for the enumerator names.
repeated bytes enumerator = 1;
// for the corresponding values.
repeated uint32 value = 2;
}
// To specify a function argument or an attribute in general.
message VariableSpecificationMessage {
// the variable name. empty if for a type definition.
optional bytes name = 1;
// the variable type which is one of:
// TYPE_SCALAR, TYPE_STRING, TYPE_ENUM, TYPE_ARRAY,
// TYPE_VECTOR, TYPE_STRUCT, TYPE_UNION
//
// not yet supported:
// "template", "typedef", "handle", "binder", "parcelable".
optional VariableType type = 2;
// the number of used bits (only for variables of a TYPE_UNION variable).
optional int32 used_bits = 11;
// the actual value(s) for an scalar data type.
// repeated values for a vector.
optional ScalarDataValueMessage scalar_value = 101;
optional bytes scalar_type = 102;
optional StringDataValueMessage string_value = 111;
optional EnumDataValueMessage enum_value = 121;
// for both TYPE_ARRAY (using size field) and TYPE_VECTOR.
repeated VectorDataValueMessage vector_value = 131;
// for sub variables when this's a struct type.
repeated VariableSpecificationMessage struct_value = 141;
// the type name of this struct.
optional bytes struct_type = 142;
// for sub variables when this's a union type.
repeated VariableSpecificationMessage union_value = 151;
// for non HIDL HAL, to use a custom type defined in C/C++.
optional bytes predefined_type = 201;
// for non HIDL HAL, to set function pointer(s).
repeated FunctionPointerSpecificationMessage function_pointer = 221;
// for HIDL HAL, to use a HIDL callback instance.
optional bytes hidl_callback_type = 231;
// true if the argument is an input (valid only for the top-level message).
optional bool is_input = 301 [default = true];
// true if the argument is an output.
optional bool is_output = 302 [default = false];
// true if the argument is a constant variable.
optional bool is_const = 303 [default = false];
// true if the argument is a struct with one or multiple function pointers.
optional bool is_callback = 304 [default = false];
}
// To specify a sub-structure.
message StructSpecificationMessage {
// the sub-structure's variable name in its parent data structure.
optional bytes name = 1;
// whether itself a pointer varaible in its parent data structure.
optional bool is_pointer = 2 [default = false];
// a list of functions contained in the struct.
repeated FunctionSpecificationMessage api = 1001;
// a list of structures contained in the component.
repeated StructSpecificationMessage sub_struct = 2001;
// The definitions of custom-defined aggregate types.
repeated VariableSpecificationMessage attribute = 3001;
}
// To specify an interface of a component
message InterfaceSpecificationMessage {
// a list of functions exposed by the component.
repeated FunctionSpecificationMessage api = 2001;
// The definitions of custom-defined aggregate types.
repeated VariableSpecificationMessage attribute = 3001;
// a list of structures contained in the component.
repeated StructSpecificationMessage sub_struct = 4001;
}
// To specify a module (which is logically equivalent to a .hal file in case
// of a HIDL HAL).
message ComponentSpecificationMessage {
// Class, type, and version of a target component.
optional ComponentClass component_class = 1;
optional ComponentType component_type = 2;
optional float component_type_version = 3 [default = 1.0];
// The name of a target component (used for HIDL HALs).
optional bytes component_name = 4;
// for the target processor architecture.
optional TargetArch target_arch = 5;
// The package path of a target component (e.g., android.hardware.name).
// name implies the component_type field.
optional bytes package = 11;
// The modules to import (e.g., package_path.component_name).
repeated bytes import = 12;
// The name of original C/C++ data structure
// (used for conventional and legacy HALs).
optional bytes original_data_structure_name = 1001;
// a list of headers that need to be imported in order to use the component.
repeated bytes header = 1002;
// For a .hal file which actually defines an interface.
optional InterfaceSpecificationMessage interface = 2001;
// For a .hal file which does not defines an interface (e.g., types.hal).
repeated VariableSpecificationMessage attribute = 2101;
}