ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

trusty: storage: add trusty interface header

Browse source 
Change-Id: I9885cc8d4204690690b384bbf209f82cb64f9265
This commit is contained in:
Andres Morales 2015-10-01 23:55:08 -07:00 • committed by Michael Ryleev
parent 826c2d2834
commit eb970794dc
2 changed files with 310 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
trusty/storage/interface/Android.mk Normal file
View file

@ -0,0 +1,25 @@
#
# Copyright (C) 2015 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.
#
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libtrustystorageinterface
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
include $(BUILD_STATIC_LIBRARY)

285
trusty/storage/interface/include/trusty/interface/storage.h Normal file
View file

@ -0,0 +1,285 @@
/*
* Copyright (C) 2015-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.
*/
#pragma once
#include <stdint.h>
/*
* Storage port names
* @STORAGE_CLIENT_TD_PORT: Port used by clients that require tamper and
* rollback detection.
* @STORAGE_CLIENT_TDEA_PORT: Port used by clients that require storage before
* the non-secure os has booted.
* @STORAGE_CLIENT_TP_PORT: Port used by clients that require tamper proof
* storage. Note that non-secure code can prevent
read and write operations from succeeding, but
it cannot modify on-disk data.
* @STORAGE_DISK_PROXY_PORT: Port used by non-secure proxy server
*/
#define STORAGE_CLIENT_TD_PORT "com.android.trusty.storage.client.td"
#define STORAGE_CLIENT_TDEA_PORT "com.android.trusty.storage.client.tdea"
#define STORAGE_CLIENT_TP_PORT "com.android.trusty.storage.client.tp"
#define STORAGE_DISK_PROXY_PORT "com.android.trusty.storage.proxy"
enum storage_cmd {
STORAGE_REQ_SHIFT = 1,
STORAGE_RESP_BIT = 1,
STORAGE_RESP_MSG_ERR = STORAGE_RESP_BIT,
STORAGE_FILE_DELETE = 1 << STORAGE_REQ_SHIFT,
STORAGE_FILE_OPEN = 2 << STORAGE_REQ_SHIFT,
STORAGE_FILE_CLOSE = 3 << STORAGE_REQ_SHIFT,
STORAGE_FILE_READ = 4 << STORAGE_REQ_SHIFT,
STORAGE_FILE_WRITE = 5 << STORAGE_REQ_SHIFT,
STORAGE_FILE_GET_SIZE = 6 << STORAGE_REQ_SHIFT,
STORAGE_FILE_SET_SIZE = 7 << STORAGE_REQ_SHIFT,
STORAGE_RPMB_SEND = 8 << STORAGE_REQ_SHIFT,
/* transaction support */
STORAGE_END_TRANSACTION = 9 << STORAGE_REQ_SHIFT,
};
/**
* enum storage_err - error codes for storage protocol
* @STORAGE_NO_ERROR: all OK
* @STORAGE_ERR_GENERIC: unknown error. Can occur when there's an internal server
* error, e.g. the server runs out of memory or is in a bad state.
* @STORAGE_ERR_NOT_VALID: input not valid. May occur if the arguments passed
* into the command are not valid, for example if the file handle
* passed in is not a valid one.
* @STORAGE_ERR_UNIMPLEMENTED: the command passed in is not recognized
* @STORAGE_ERR_ACCESS: the file is not accessible in the requested mode
* @STORAGE_ERR_NOT_FOUND: the file was not found
* @STORAGE_ERR_EXIST the file exists when it shouldn't as in with OPEN_CREATE | OPEN_EXCLUSIVE.
* @STORAGE_ERR_TRANSACT returned by various operations to indicate that current transaction
* is in error state. Such state could be only cleared by sending
* STORAGE_END_TRANSACTION message.
*/
enum storage_err {
STORAGE_NO_ERROR = 0,
STORAGE_ERR_GENERIC = 1,
STORAGE_ERR_NOT_VALID = 2,
STORAGE_ERR_UNIMPLEMENTED = 3,
STORAGE_ERR_ACCESS = 4,
STORAGE_ERR_NOT_FOUND = 5,
STORAGE_ERR_EXIST = 6,
STORAGE_ERR_TRANSACT = 7,
};
/**
* storage_delete_flag - flags for controlling delete semantics
*/
enum storage_file_delete_flag {
STORAGE_FILE_DELETE_MASK = 0,
};
/**
* storage_file_flag - Flags to control 'open' semantics.
* @STORAGE_FILE_OPEN_CREATE: if this file does not exist, create it.
* @STORAGE_FILE_OPEN_CREATE_EXCLUSIVE: causes STORAGE_FILE_OPEN_CREATE to fail if the file
* already exists. Only meaningful if used in combination
* with STORAGE_FILE_OPEN_CREATE.
* @STORAGE_FILE_OPEN_TRUNCATE: if this file already exists, discard existing content
* and open it as a new file. No change in semantics if the
* file does not exist.
* @STORAGE_FILE_OPEN_MASK: mask for all open flags supported in current protocol.
* All other bits must be set to 0.
*/
enum storage_file_open_flag {
STORAGE_FILE_OPEN_CREATE = (1 << 0),
STORAGE_FILE_OPEN_CREATE_EXCLUSIVE = (1 << 1),
STORAGE_FILE_OPEN_TRUNCATE = (1 << 2),
STORAGE_FILE_OPEN_MASK = STORAGE_FILE_OPEN_CREATE |
STORAGE_FILE_OPEN_TRUNCATE |
STORAGE_FILE_OPEN_CREATE_EXCLUSIVE,
};
/**
* enum storage_msg_flag - protocol-level flags in struct storage_msg
* @STORAGE_MSG_FLAG_BATCH: if set, command belongs to a batch transaction.
* No response will be sent by the server until
* it receives a command with this flag unset, at
* which point a cummulative result for all messages
* sent with STORAGE_MSG_FLAG_BATCH will be sent.
* This is only supported by the non-secure disk proxy
* server.
* @STORAGE_MSG_FLAG_PRE_COMMIT: if set, indicates that server need to commit
* pending changes before processing this message.
* @STORAGE_MSG_FLAG_POST_COMMIT: if set, indicates that server need to commit
* pending changes after processing this message.
* @STORAGE_MSG_FLAG_TRANSACT_COMPLETE: if set, indicates that server need to commit
* current transaction after processing this message.
* It is an alias for STORAGE_MSG_FLAG_POST_COMMIT.
*/
enum storage_msg_flag {
STORAGE_MSG_FLAG_BATCH = 0x1,
STORAGE_MSG_FLAG_PRE_COMMIT = 0x2,
STORAGE_MSG_FLAG_POST_COMMIT = 0x4,
STORAGE_MSG_FLAG_TRANSACT_COMPLETE = STORAGE_MSG_FLAG_POST_COMMIT,
};
/*
* The following declarations are the message-specific contents of
* the 'payload' element inside struct storage_msg.
*/
/**
* struct storage_file_delete_req - request format for STORAGE_FILE_DELETE
* @flags: currently unused, must be set to 0.
* @name: the name of the file
*/
struct storage_file_delete_req {
uint32_t flags;
char name[0];
};
/**
* struct storage_file_open_req - request format for STORAGE_FILE_OPEN
* @flags: any of enum storage_file_flag or'ed together
* @name: the name of the file
*/
struct storage_file_open_req {
uint32_t flags;
char name[0];
};
/**
* struct storage_file_open_resp - response format for STORAGE_FILE_OPEN
* @handle: opaque handle to the opened file. Only present on success.
*/
struct storage_file_open_resp {
uint32_t handle;
};
/**
* struct storage_file_close_req - request format for STORAGE_FILE_CLOSE
* @handle: the handle for the file to close
*/
struct storage_file_close_req {
uint32_t handle;
};
/**
* struct storage_file_read_req - request format for STORAGE_FILE_READ
* @handle: the handle for the file from which to read
* @size: the quantity of bytes to read from the file
* @offset: the offset in the file from whence to read
*/
struct storage_file_read_req {
uint32_t handle;
uint32_t size;
uint64_t offset;
};
/**
* struct storage_file_read_resp - response format for STORAGE_FILE_READ
* @data: beginning of data retrieved from file
*/
struct storage_file_read_resp {
uint8_t data[0];
};
/**
* struct storage_file_write_req - request format for STORAGE_FILE_WRITE
* @handle: the handle for the file to write to
* @offset: the offset in the file from whence to write
* @__reserved: unused, must be set to 0.
* @data: beginning of the data to be written
*/
struct storage_file_write_req {
uint64_t offset;
uint32_t handle;
uint32_t __reserved;
uint8_t data[0];
};
/**
* struct storage_file_get_size_req - request format for STORAGE_FILE_GET_SIZE
* @handle: handle for which the size is requested
*/
struct storage_file_get_size_req {
uint32_t handle;
};
/**
* struct storage_file_get_size_resp - response format for STORAGE_FILE_GET_SIZE
* @size: the size of the file
*/
struct storage_file_get_size_resp {
uint64_t size;
};
/**
* struct storage_file_set_size_req - request format for STORAGE_FILE_SET_SIZE
* @handle: the file handle
* @size: the desired size of the file
*/
struct storage_file_set_size_req {
uint64_t size;
uint32_t handle;
};
/**
* struct storage_rpmb_send_req - request format for STORAGE_RPMB_SEND
* @reliable_write_size: size in bytes of reliable write region
* @write_size: size in bytes of write region
* @read_size: number of bytes to read for a read request
* @__reserved: unused, must be set to 0
* @payload: start of reliable write region, followed by
* write region.
*
* Only used in proxy<->server interface.
*/
struct storage_rpmb_send_req {
uint32_t reliable_write_size;
uint32_t write_size;
uint32_t read_size;
uint32_t __reserved;
uint8_t payload[0];
};
/**
* struct storage_rpmb_send_resp: response type for STORAGE_RPMB_SEND
* @data: the data frames frames retrieved from the MMC.
*/
struct storage_rpmb_send_resp {
uint8_t data[0];
};
/**
* struct storage_msg - generic req/resp format for all storage commands
* @cmd: one of enum storage_cmd
* @op_id: client chosen operation identifier for an instance
* of a command or atomic grouping of commands (transaction).
* @flags: one or many of enum storage_msg_flag or'ed together.
* @size: total size of the message including this header
* @result: one of enum storage_err
* @__reserved: unused, must be set to 0.
* @payload: beginning of command specific message format
*/
struct storage_msg {
uint32_t cmd;
uint32_t op_id;
uint32_t flags;
uint32_t size;
int32_t result;
uint32_t __reserved;
uint8_t payload[0];
};