tipc_ns.c - trusty/app/storage - Git at Google

 /*
  * 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.
  */

 #include <assert.h>
 #include <lk/compiler.h>
 #include <stdint.h>
 #include <string.h>
 #include <trusty_ipc.h>
 #include <uapi/err.h>

 #include <interface/storage/storage.h>

 #include "ipc.h"
 #include "rpmb.h"
 #include "tipc_ns.h"

 #define SS_ERR(args...) fprintf(stderr, "ss: " args)
 #define SS_WARN(args...) fprintf(stderr, "ss: " args)
 #define SS_DBG_IO(args...)

 static inline int translate_error(enum storage_err err) {
     switch (err) {
     case STORAGE_NO_ERROR:
         return NO_ERROR;
     case STORAGE_ERR_NOT_VALID:
         return ERR_NOT_VALID;
     case STORAGE_ERR_SYNC_FAILURE:
         return ERR_IO;
     case STORAGE_ERR_UNIMPLEMENTED:
         return ERR_NOT_IMPLEMENTED;
     case STORAGE_ERR_GENERIC:
     default:
         return ERR_GENERIC;
     }
 }

 static inline int check_response(enum storage_cmd cmd,
                                  struct storage_msg* msg,
                                  size_t read_len) {
     if (read_len < sizeof(*msg)) {
         SS_ERR("%s: invalid response size %zu\n", __func__, read_len);
         return ERR_IO;
     }

     if ((enum storage_cmd)msg->cmd != (cmd | STORAGE_RESP_BIT)) {
         SS_ERR("%s: invalid response (%d) for cmd (%d)\n", __func__, msg->cmd,
                cmd);
         return ERR_IO;
     }

     return translate_error(msg->result);
 }

 int rpmb_send(void* handle_,
               void* reliable_write_buf,
               size_t reliable_write_size,
               void* write_buf,
               size_t write_size,
               void* read_buf,
               size_t read_size,
               bool sync,
               bool sync_checkpoint) {
     SS_DBG_IO(
             "%s: handle %p, rel_write size %zu, write size %zu, read size %zu\n",
             __func__, handle_, reliable_write_size, write_size, read_size);

     int rc;
     handle_t* handlep = handle_;
     handle_t handle = *handlep;

     struct storage_rpmb_send_req req = {
             .read_size = read_size,
             .reliable_write_size = reliable_write_size,
             .write_size = write_size,
     };

     struct storage_msg msg = {
             .cmd = STORAGE_RPMB_SEND,
             .flags = sync ? (STORAGE_MSG_FLAG_PRE_COMMIT |
                              STORAGE_MSG_FLAG_POST_COMMIT)
                           : 0,
             .size = sizeof(msg) + sizeof(req) + reliable_write_size +
                     write_size,
     };

     if (sync_checkpoint) {
         msg.flags |= STORAGE_MSG_FLAG_PRE_COMMIT_CHECKPOINT;
     }

     struct iovec rx_iov[] = {
             {.iov_base = &msg, .iov_len = sizeof(msg)},
             {.iov_base = read_buf, .iov_len = read_size},
     };

     struct iovec tx_iov[] = {
             {.iov_base = &msg, .iov_len = sizeof(msg)},
             {.iov_base = &req, .iov_len = sizeof(req)},
             {.iov_base = reliable_write_buf, .iov_len = reliable_write_size},
             {.iov_base = write_buf, .iov_len = write_size},
     };

     rc = sync_ipc_send_msg(handle, tx_iov, countof(tx_iov), rx_iov,
                            countof(rx_iov));
     if (rc < 0) {
         SS_ERR("%s: rpmb send failed, ipc failure: %d\n", __func__, rc);
         return rc;
     }

     size_t bytes_read = (size_t)rc;

     rc = check_response(STORAGE_RPMB_SEND, &msg, bytes_read);
     if (rc != NO_ERROR) {
         return rc;
     }

     if (bytes_read != sizeof(msg) + read_size) {
         SS_ERR("%s: rpmb send failed, invalid response size (%zu !=  %zu + %zu)\n",
                __func__, bytes_read, sizeof(msg), read_size);
         return ERR_NOT_VALID;
     }

     return NO_ERROR;
 }

 int ns_open_file(handle_t ipc_handle,
                  const char* fname,
                  ns_handle_t* handlep,
                  bool create) {
     SS_DBG_IO("%s: open %s create: %d\n", __func__, fname, create);

     size_t fname_size = strlen(fname);
     struct storage_file_open_resp resp;

     struct storage_file_open_req req = {
             .flags = create ? STORAGE_FILE_OPEN_CREATE : 0,
     };

     struct storage_msg msg = {
             .cmd = STORAGE_FILE_OPEN,
             .size = sizeof(msg) + sizeof(req) + fname_size,
     };

     struct iovec tx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
                              {.iov_base = &req, .iov_len = sizeof(req)},
                              {.iov_base = (char*)fname, .iov_len = fname_size}};

     struct iovec rx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
                              {.iov_base = &resp, .iov_len = sizeof(resp)}};

     int rc = sync_ipc_send_msg(ipc_handle, tx_iov, countof(tx_iov), rx_iov,
                                countof(rx_iov));
     if (rc < 0) {
         SS_ERR("%s: open failed, %d\n", __func__, rc);
         return rc;
     }

     size_t bytes_read = (size_t)rc;

     rc = check_response(STORAGE_FILE_OPEN, &msg, bytes_read);
     if (rc != NO_ERROR) {
         return rc;
     }

     if (bytes_read != sizeof(msg) + sizeof(resp)) {
         SS_ERR("%s: open failed, invalid response size (%zu !=  %zu)\n",
                __func__, bytes_read, sizeof(resp));
         return ERR_NOT_VALID;
     }

     *handlep = resp.handle;

     return NO_ERROR;
 }

 void ns_close_file(handle_t ipc_handle, ns_handle_t handle) {
     SS_DBG_IO("close handle: %llu\n", handle);
     struct storage_file_close_req req = {
             .handle = handle,
     };

     struct storage_msg msg = {
             .cmd = STORAGE_FILE_CLOSE,
             .size = sizeof(msg) + sizeof(req),
     };

     struct iovec iov[] = {
             {.iov_base = &msg, .iov_len = sizeof(msg)},
             {.iov_base = &req, .iov_len = sizeof(req)},
     };

     int rc = sync_ipc_send_msg(ipc_handle, iov, countof(iov), iov, 1);
     if (rc < 0) {
         SS_ERR("%s: close failed, %d\n", __func__, rc);
         return;
     }

     rc = check_response(STORAGE_FILE_CLOSE, &msg, rc);
     if (rc < 0) {
         SS_ERR("%s: close failed, %d\n", __func__, rc);
     }
 }

 int ns_get_max_size(handle_t ipc_handle,
                     ns_handle_t handle,
                     data_block_t* size) {
     assert(size != NULL);

     SS_DBG_IO("get max size: %llu\n", handle);
     struct storage_file_get_max_size_req req = {
             .handle = handle,
     };

     struct storage_file_get_max_size_resp resp = {0};

     struct storage_msg msg = {
             .cmd = STORAGE_FILE_GET_MAX_SIZE,
             .size = sizeof(msg) + sizeof(req),
     };

     struct iovec tx_iov[] = {
             {.iov_base = &msg, .iov_len = sizeof(msg)},
             {.iov_base = &req, .iov_len = sizeof(req)},
     };

     struct iovec rx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
                              {.iov_base = &resp, .iov_len = sizeof(resp)}};

     int rc = sync_ipc_send_msg(ipc_handle, tx_iov, countof(tx_iov), rx_iov,
                                countof(rx_iov));
     if (rc < 0) {
         SS_ERR("%s: read failed, %d\n", __func__, rc);
         return rc;
     }

     size_t bytes_read = (size_t)rc;

     rc = check_response(STORAGE_FILE_GET_MAX_SIZE, &msg, bytes_read);
     if (rc != NO_ERROR) {
         return rc;
     }

     if (bytes_read != sizeof(msg) + sizeof(resp)) {
         SS_ERR("%s: get_max_size failed, invalid response size (%zu != %zu)\n",
                __func__, bytes_read, sizeof(msg) + sizeof(resp));
         return ERR_NOT_VALID;
     }

     *size = resp.max_size;
     return rc;
 }

 /**
  * ns_read_pos - Read a block of data from a non-secure file
  * @ipc_handle:         Handle of non-secure connection
  * @handle:             Handle of file to read from
  * @pos:                Offset to start reading at
  * @data:               Pointer to output buffer
  * @data_size:          Number of bytes to attempt to read
  *
  * Return value: Number of bytes read, or a negative error code if an error
  * occurred. Note: zero is a valid number of bytes read to return if @pos is
  * past the end of the file.
  */
 int ns_read_pos(handle_t ipc_handle,
                 ns_handle_t handle,
                 ns_off_t pos,
                 void* data,
                 int data_size) {
     SS_DBG_IO("%s: handle %llu, pos %llu, size %d\n", __func__, handle, pos,
               data_size);

     struct storage_file_read_req req = {
             .handle = handle,
             .offset = pos,
             .size = data_size,
     };

     struct storage_msg msg = {
             .cmd = STORAGE_FILE_READ,
             .size = sizeof(msg) + sizeof(req),
     };

     struct iovec tx_iov[] = {
             {.iov_base = &msg, .iov_len = sizeof(msg)},
             {.iov_base = &req, .iov_len = sizeof(req)},
     };

     struct iovec rx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
                              {.iov_base = data, .iov_len = data_size}};

     int rc = sync_ipc_send_msg(ipc_handle, tx_iov, countof(tx_iov), rx_iov,
                                countof(rx_iov));
     if (rc < 0) {
         SS_ERR("%s: read failed, %d\n", __func__, rc);
         return rc;
     }

     size_t data_len = rc;
     assert(data_len <= sizeof(msg) + data_size);

     rc = check_response(STORAGE_FILE_READ, &msg, data_len);
     if (rc != NO_ERROR) {
         return rc;
     }

     assert(data_len >= sizeof(msg));
     return data_len - sizeof(msg);
 }

 int ns_write_pos(handle_t ipc_handle,
                  ns_handle_t handle,
                  ns_off_t pos,
                  const void* data,
                  int data_size,
                  bool is_userdata,
                  bool sync) {
     uint32_t flags = 0;
     SS_DBG_IO("%s: handle %llu, pos %llu, size %d\n", __func__, handle, pos,
               data_size);

     if (is_userdata) {
         flags |= STORAGE_MSG_FLAG_PRE_COMMIT_CHECKPOINT;
     }

     if (sync) {
         flags |= STORAGE_MSG_FLAG_PRE_COMMIT | STORAGE_MSG_FLAG_POST_COMMIT;
     }

     struct storage_file_write_req req = {
             .handle = handle,
             .offset = pos,
     };

     struct storage_msg msg = {
             .cmd = STORAGE_FILE_WRITE,
             .flags = flags,
             .size = sizeof(msg) + sizeof(req) + data_size,
     };

     struct iovec iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
                           {.iov_base = &req, .iov_len = sizeof(req)},
                           {.iov_base = (void*)data, .iov_len = data_size}};

     int rc = sync_ipc_send_msg(ipc_handle, iov, countof(iov), iov, 1);
     if (rc < 0) {
         SS_ERR("%s: write failed, %d\n", __func__, rc);
         return rc;
     }

     rc = check_response(STORAGE_FILE_WRITE, &msg, rc);
     if (rc != NO_ERROR) {
         return rc;
     }

     return data_size;
 }
	/*
	* 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.
	*/

	#include <assert.h>
	#include <lk/compiler.h>
	#include <stdint.h>
	#include <string.h>
	#include <trusty_ipc.h>
	#include <uapi/err.h>

	#include <interface/storage/storage.h>

	#include "ipc.h"
	#include "rpmb.h"
	#include "tipc_ns.h"

	#define SS_ERR(args...) fprintf(stderr, "ss: " args)
	#define SS_WARN(args...) fprintf(stderr, "ss: " args)
	#define SS_DBG_IO(args...)

	static inline int translate_error(enum storage_err err) {
	switch (err) {
	case STORAGE_NO_ERROR:
	return NO_ERROR;
	case STORAGE_ERR_NOT_VALID:
	return ERR_NOT_VALID;
	case STORAGE_ERR_SYNC_FAILURE:
	return ERR_IO;
	case STORAGE_ERR_UNIMPLEMENTED:
	return ERR_NOT_IMPLEMENTED;
	case STORAGE_ERR_GENERIC:
	default:
	return ERR_GENERIC;
	}
	}

	static inline int check_response(enum storage_cmd cmd,
	struct storage_msg* msg,
	size_t read_len) {
	if (read_len < sizeof(*msg)) {
	SS_ERR("%s: invalid response size %zu\n", __func__, read_len);
	return ERR_IO;
	}

	if ((enum storage_cmd)msg->cmd != (cmd \| STORAGE_RESP_BIT)) {
	SS_ERR("%s: invalid response (%d) for cmd (%d)\n", __func__, msg->cmd,
	cmd);
	return ERR_IO;
	}

	return translate_error(msg->result);
	}

	int rpmb_send(void* handle_,
	void* reliable_write_buf,
	size_t reliable_write_size,
	void* write_buf,
	size_t write_size,
	void* read_buf,
	size_t read_size,
	bool sync,
	bool sync_checkpoint) {
	SS_DBG_IO(
	"%s: handle %p, rel_write size %zu, write size %zu, read size %zu\n",
	__func__, handle_, reliable_write_size, write_size, read_size);

	int rc;
	handle_t* handlep = handle_;
	handle_t handle = *handlep;

	struct storage_rpmb_send_req req = {
	.read_size = read_size,
	.reliable_write_size = reliable_write_size,
	.write_size = write_size,
	};

	struct storage_msg msg = {
	.cmd = STORAGE_RPMB_SEND,
	.flags = sync ? (STORAGE_MSG_FLAG_PRE_COMMIT \|
	STORAGE_MSG_FLAG_POST_COMMIT)
	: 0,
	.size = sizeof(msg) + sizeof(req) + reliable_write_size +
	write_size,
	};

	if (sync_checkpoint) {
	msg.flags \|= STORAGE_MSG_FLAG_PRE_COMMIT_CHECKPOINT;
	}

	struct iovec rx_iov[] = {
	{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = read_buf, .iov_len = read_size},
	};

	struct iovec tx_iov[] = {
	{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &req, .iov_len = sizeof(req)},
	{.iov_base = reliable_write_buf, .iov_len = reliable_write_size},
	{.iov_base = write_buf, .iov_len = write_size},
	};

	rc = sync_ipc_send_msg(handle, tx_iov, countof(tx_iov), rx_iov,
	countof(rx_iov));
	if (rc < 0) {
	SS_ERR("%s: rpmb send failed, ipc failure: %d\n", __func__, rc);
	return rc;
	}

	size_t bytes_read = (size_t)rc;

	rc = check_response(STORAGE_RPMB_SEND, &msg, bytes_read);
	if (rc != NO_ERROR) {
	return rc;
	}

	if (bytes_read != sizeof(msg) + read_size) {
	SS_ERR("%s: rpmb send failed, invalid response size (%zu != %zu + %zu)\n",
	__func__, bytes_read, sizeof(msg), read_size);
	return ERR_NOT_VALID;
	}

	return NO_ERROR;
	}

	int ns_open_file(handle_t ipc_handle,
	const char* fname,
	ns_handle_t* handlep,
	bool create) {
	SS_DBG_IO("%s: open %s create: %d\n", __func__, fname, create);

	size_t fname_size = strlen(fname);
	struct storage_file_open_resp resp;

	struct storage_file_open_req req = {
	.flags = create ? STORAGE_FILE_OPEN_CREATE : 0,
	};

	struct storage_msg msg = {
	.cmd = STORAGE_FILE_OPEN,
	.size = sizeof(msg) + sizeof(req) + fname_size,
	};

	struct iovec tx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &req, .iov_len = sizeof(req)},
	{.iov_base = (char*)fname, .iov_len = fname_size}};

	struct iovec rx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &resp, .iov_len = sizeof(resp)}};

	int rc = sync_ipc_send_msg(ipc_handle, tx_iov, countof(tx_iov), rx_iov,
	countof(rx_iov));
	if (rc < 0) {
	SS_ERR("%s: open failed, %d\n", __func__, rc);
	return rc;
	}

	size_t bytes_read = (size_t)rc;

	rc = check_response(STORAGE_FILE_OPEN, &msg, bytes_read);
	if (rc != NO_ERROR) {
	return rc;
	}

	if (bytes_read != sizeof(msg) + sizeof(resp)) {
	SS_ERR("%s: open failed, invalid response size (%zu != %zu)\n",
	__func__, bytes_read, sizeof(resp));
	return ERR_NOT_VALID;
	}

	*handlep = resp.handle;

	return NO_ERROR;
	}

	void ns_close_file(handle_t ipc_handle, ns_handle_t handle) {
	SS_DBG_IO("close handle: %llu\n", handle);
	struct storage_file_close_req req = {
	.handle = handle,
	};

	struct storage_msg msg = {
	.cmd = STORAGE_FILE_CLOSE,
	.size = sizeof(msg) + sizeof(req),
	};

	struct iovec iov[] = {
	{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &req, .iov_len = sizeof(req)},
	};

	int rc = sync_ipc_send_msg(ipc_handle, iov, countof(iov), iov, 1);
	if (rc < 0) {
	SS_ERR("%s: close failed, %d\n", __func__, rc);
	return;
	}

	rc = check_response(STORAGE_FILE_CLOSE, &msg, rc);
	if (rc < 0) {
	SS_ERR("%s: close failed, %d\n", __func__, rc);
	}
	}

	int ns_get_max_size(handle_t ipc_handle,
	ns_handle_t handle,
	data_block_t* size) {
	assert(size != NULL);

	SS_DBG_IO("get max size: %llu\n", handle);
	struct storage_file_get_max_size_req req = {
	.handle = handle,
	};

	struct storage_file_get_max_size_resp resp = {0};

	struct storage_msg msg = {
	.cmd = STORAGE_FILE_GET_MAX_SIZE,
	.size = sizeof(msg) + sizeof(req),
	};

	struct iovec tx_iov[] = {
	{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &req, .iov_len = sizeof(req)},
	};

	struct iovec rx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &resp, .iov_len = sizeof(resp)}};

	int rc = sync_ipc_send_msg(ipc_handle, tx_iov, countof(tx_iov), rx_iov,
	countof(rx_iov));
	if (rc < 0) {
	SS_ERR("%s: read failed, %d\n", __func__, rc);
	return rc;
	}

	size_t bytes_read = (size_t)rc;

	rc = check_response(STORAGE_FILE_GET_MAX_SIZE, &msg, bytes_read);
	if (rc != NO_ERROR) {
	return rc;
	}

	if (bytes_read != sizeof(msg) + sizeof(resp)) {
	SS_ERR("%s: get_max_size failed, invalid response size (%zu != %zu)\n",
	__func__, bytes_read, sizeof(msg) + sizeof(resp));
	return ERR_NOT_VALID;
	}

	*size = resp.max_size;
	return rc;
	}

	/**
	* ns_read_pos - Read a block of data from a non-secure file
	* @ipc_handle: Handle of non-secure connection
	* @handle: Handle of file to read from
	* @pos: Offset to start reading at
	* @data: Pointer to output buffer
	* @data_size: Number of bytes to attempt to read
	*
	* Return value: Number of bytes read, or a negative error code if an error
	* occurred. Note: zero is a valid number of bytes read to return if @pos is
	* past the end of the file.
	*/
	int ns_read_pos(handle_t ipc_handle,
	ns_handle_t handle,
	ns_off_t pos,
	void* data,
	int data_size) {
	SS_DBG_IO("%s: handle %llu, pos %llu, size %d\n", __func__, handle, pos,
	data_size);

	struct storage_file_read_req req = {
	.handle = handle,
	.offset = pos,
	.size = data_size,
	};

	struct storage_msg msg = {
	.cmd = STORAGE_FILE_READ,
	.size = sizeof(msg) + sizeof(req),
	};

	struct iovec tx_iov[] = {
	{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &req, .iov_len = sizeof(req)},
	};

	struct iovec rx_iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = data, .iov_len = data_size}};

	int rc = sync_ipc_send_msg(ipc_handle, tx_iov, countof(tx_iov), rx_iov,
	countof(rx_iov));
	if (rc < 0) {
	SS_ERR("%s: read failed, %d\n", __func__, rc);
	return rc;
	}

	size_t data_len = rc;
	assert(data_len <= sizeof(msg) + data_size);

	rc = check_response(STORAGE_FILE_READ, &msg, data_len);
	if (rc != NO_ERROR) {
	return rc;
	}

	assert(data_len >= sizeof(msg));
	return data_len - sizeof(msg);
	}

	int ns_write_pos(handle_t ipc_handle,
	ns_handle_t handle,
	ns_off_t pos,
	const void* data,
	int data_size,
	bool is_userdata,
	bool sync) {
	uint32_t flags = 0;
	SS_DBG_IO("%s: handle %llu, pos %llu, size %d\n", __func__, handle, pos,
	data_size);

	if (is_userdata) {
	flags \|= STORAGE_MSG_FLAG_PRE_COMMIT_CHECKPOINT;
	}

	if (sync) {
	flags \|= STORAGE_MSG_FLAG_PRE_COMMIT \| STORAGE_MSG_FLAG_POST_COMMIT;
	}

	struct storage_file_write_req req = {
	.handle = handle,
	.offset = pos,
	};

	struct storage_msg msg = {
	.cmd = STORAGE_FILE_WRITE,
	.flags = flags,
	.size = sizeof(msg) + sizeof(req) + data_size,
	};

	struct iovec iov[] = {{.iov_base = &msg, .iov_len = sizeof(msg)},
	{.iov_base = &req, .iov_len = sizeof(req)},
	{.iov_base = (void*)data, .iov_len = data_size}};

	int rc = sync_ipc_send_msg(ipc_handle, iov, countof(iov), iov, 1);
	if (rc < 0) {
	SS_ERR("%s: write failed, %d\n", __func__, rc);
	return rc;
	}

	rc = check_response(STORAGE_FILE_WRITE, &msg, rc);
	if (rc != NO_ERROR) {
	return rc;
	}

	return data_size;
	}