riscv/riscv32_htif_semihost.cc - mpact-riscv - Git at Google

 // Copyright 2023 Google LLC
 //
 // 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
 //
 //     https://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 "riscv/riscv32_htif_semihost.h"

 #include <fcntl.h>
 #include <unistd.h>

 #include <cstdint>
 #include <cstring>
 #include <utility>

 #include "absl/functional/bind_front.h"
 #include "absl/strings/str_cat.h"
 #include "mpact/sim/generic/data_buffer.h"
 #include "mpact/sim/util/memory/memory_interface.h"
 #include "mpact/sim/util/memory/memory_watcher.h"

 namespace mpact {
 namespace sim {
 namespace riscv {

 constexpr int kRiscvAtFdCwd = -100;

 using AddressRange = mpact::sim::util::MemoryWatcher::AddressRange;

 RiscV32HtifSemiHost::RiscV32HtifSemiHost(
     util::MemoryWatcher* watcher, util::MemoryInterface* memory,
     const SemiHostAddresses& magic_addresses)
     : RiscV32HtifSemiHost(watcher, memory, magic_addresses, nullptr, nullptr) {}

 RiscV32HtifSemiHost::RiscV32HtifSemiHost(
     util::MemoryWatcher* watcher, util::MemoryInterface* memory,
     const SemiHostAddresses& magic_addresses, HaltCallback halt_callback,
     ErrorCallback error_callback)
     : halt_callback_(std::move(halt_callback)),
       error_callback_(std::move(error_callback)),
       watcher_(watcher),
       memory_(memory) {
   magic_addresses_ = magic_addresses;
   (void)watcher_->SetStoreWatchCallback(
       AddressRange(magic_addresses_.tohost_ready),
       absl::bind_front(&RiscV32HtifSemiHost::StoreEvent, this));

   // Initialize fd_map_.
   fd_map_.emplace(0, 0);
   fd_map_.emplace(1, 1);
   fd_map_.emplace(2, 2);
   fd_map_.emplace(kRiscvAtFdCwd, AT_FDCWD);
 }

 RiscV32HtifSemiHost::~RiscV32HtifSemiHost() {
   // Ignore any error when clearing the previous watchpoint.
   (void)watcher_->ClearStoreWatchCallback(magic_addresses_.tohost_ready);
 }

 void RiscV32HtifSemiHost::SetMagicAddresses(
     const SemiHostAddresses& magic_addresses) {
   // Clear any previous store watchpoint. Ignore any error.
   (void)watcher_->ClearStoreWatchCallback(magic_addresses_.tohost_ready);
   magic_addresses_ = magic_addresses;
   (void)watcher_->SetStoreWatchCallback(
       AddressRange(magic_addresses_.tohost_ready),
       absl::bind_front(&RiscV32HtifSemiHost::StoreEvent, this));
 }

 void RiscV32HtifSemiHost::SetHaltCallback(HaltCallback callback) {
   halt_callback_ = std::move(callback);
 }

 void RiscV32HtifSemiHost::SetErrorCallback(ErrorCallback callback) {
   error_callback_ = std::move(callback);
 }

 void RiscV32HtifSemiHost::StoreEvent(uint64_t address, int size) {
   // Return if the ready byte isn't part of the store event.
   if ((address > magic_addresses_.tohost_ready) ||
       (address + size - 1 < magic_addresses_.tohost_ready))
     return;

   // Read the value of the ready_db, if not 1, then the tohost location
   // does not contain data, and there's nothing to do.
   auto* ready_db = db_factory_.Allocate<uint8_t>(1);
   memory_->Load(magic_addresses_.tohost_ready, ready_db, nullptr, nullptr);
   if (ready_db->Get<uint8_t>(0) != 1) {
     ready_db->DecRef();
     return;
   }

   // Get the payload double word. Extract the command.
   auto* payload_db = db_factory_.Allocate<uint64_t>(1);
   memory_->Load(magic_addresses_.tohost, payload_db, nullptr, nullptr);
   uint64_t payload = payload_db->Get<uint64_t>(0);
   uint8_t device = payload >> 56;
   uint8_t command = (payload >> 48) & 0xff;
   // If it's not the syscall device and command, just return.
   if ((device != 0) || (command != 0)) return;

   // If the payload lsb is 1, then it's the end of the run. Halt (but don't
   // catch fire!).
   if (payload & 0x1) {
     if (halt_callback_ != nullptr) halt_callback_();
     payload_db->DecRef();
     ready_db->DecRef();
     return;
   }
   // The payload contains a pointer to an 8 double word parameter block. Load
   // that block.
   auto* parameter_db = db_factory_.Allocate<uint64_t>(8);
   memory_->Load(payload, parameter_db, nullptr, nullptr);
   auto parameter_span = parameter_db->Get<uint64_t>();
   int64_t return_value = 0;
   // The first parameter specifies the syscall.
   switch (parameter_span[0]) {
     // TODO: Add other semihosting calls.
     case 56:  // sys_openat
     {
       int dirfd = parameter_span[1];
       auto iter = fd_map_.find(dirfd);
       if (iter == fd_map_.end()) {
         dirfd = -1;
       } else {
         dirfd = iter->second;
       }
       auto* db = db_factory_.Allocate(parameter_span[3]);
       auto address = parameter_span[2];
       memory_->Load(address, db, nullptr, nullptr);
       char* name = static_cast<char*>(db->raw_ptr());
       return_value = openat(dirfd, name, parameter_span[4], parameter_span[5]);
       db->DecRef();
     } break;
     case 57:  // sys_close
     {
       auto fd_iter = fd_map_.find(parameter_span[1]);
       if (fd_iter == fd_map_.end()) {
         return_value = -1;
         break;
       }
       fd_map_.erase(fd_iter);
       return_value = 0;
     } break;
     case 62:  // sys_lseek
     {
       auto iter = fd_map_.find(parameter_span[1]);
       int fd = iter == fd_map_.end() ? -1 : iter->second;
       off_t offset = static_cast<off_t>(parameter_span[2]);
       int whence = static_cast<int>(parameter_span[3]);
       return_value = lseek(fd, offset, whence);
     } break;
     case 63:  // sys_read
     {
       auto iter = fd_map_.find(parameter_span[1]);
       int fd = iter == fd_map_.end() ? -1 : iter->second;
       size_t len = static_cast<size_t>(parameter_span[3]);
       auto* data_db = db_factory_.Allocate<uint8_t>(len);
       int res = read(fd, data_db->raw_ptr(), len);
       if (res > 0) {
         generic::DataBuffer* db = nullptr;
         // Need to see if fewer bytes were read than there was space for. If so
         // need to use a different db for the store.
         if (res == len) {
           db = data_db;
         } else {
           db = db_factory_.Allocate<uint8_t>(res);
           std::memcpy(db->raw_ptr(), data_db->raw_ptr(), res);
           data_db->DecRef();
         }
         memory_->Store(parameter_span[2], db);
         db->DecRef();
       }
       return_value = res;
     } break;
     case 64:  // sys_write
     {
       auto iter = fd_map_.find(parameter_span[1]);
       int fd = iter == fd_map_.end() ? -1 : iter->second;
       auto* data_db = db_factory_.Allocate<uint8_t>(parameter_span[3]);
       memory_->Load(parameter_span[2], data_db, nullptr, nullptr);
       size_t len = static_cast<size_t>(parameter_span[3]);
       return_value = write(fd, data_db->raw_ptr(), len);
       data_db->DecRef();
     } break;
     case 67:  // sys_pread
     {
       auto iter = fd_map_.find(parameter_span[1]);
       int fd = iter == fd_map_.end() ? -1 : iter->second;
       size_t len = static_cast<size_t>(parameter_span[3]);
       off_t offset = static_cast<off_t>(parameter_span[4]);
       auto* data_db = db_factory_.Allocate<uint8_t>(len);
       int res = pread(fd, data_db->raw_ptr(), len, offset);
       if (res > 0) {
         generic::DataBuffer* db = nullptr;
         // Need to see if fewer bytes were read than there was space for. If so
         // need to use a different db for the store.
         if (res == len) {
           db = data_db;
         } else {
           db = db_factory_.Allocate<uint8_t>(res);
           std::memcpy(db->raw_ptr(), data_db->raw_ptr(), res);
           data_db->DecRef();
         }
         memory_->Store(parameter_span[2], db);
         db->DecRef();
       }
       return_value = res;
     } break;
     case 68:  // sys_pwrite
     {
       auto iter = fd_map_.find(parameter_span[1]);
       int fd = iter == fd_map_.end() ? -1 : iter->second;
       auto* data_db = db_factory_.Allocate<uint8_t>(parameter_span[3]);
       memory_->Load(parameter_span[2], data_db, nullptr, nullptr);
       size_t len = static_cast<size_t>(parameter_span[3]);
       off_t offset = static_cast<off_t>(parameter_span[4]);
       return_value = pwrite(fd, data_db->raw_ptr(), len, offset);
       data_db->DecRef();
     } break;
     case 93:  // sys_exit
       if (halt_callback_ != nullptr) halt_callback_();
       break;
     default:
       // For now, ignore the others.
       parameter_db->DecRef();
       payload_db->DecRef();
       ready_db->DecRef();
       error_callback_(absl::StrCat("Unhandled syscall: ", parameter_span[0]));
       return;
   }
   parameter_db->DecRef();
   // Write the response packets.
   payload_db->Set<uint64_t>(0, return_value);
   memory_->Store(payload, payload_db);
   payload_db->DecRef();
   ready_db->Set<uint8_t>(0, 1);
   // Signal that the response is ready.
   memory_->Store(magic_addresses_.fromhost_ready, ready_db);
   ready_db->DecRef();
 }

 }  // namespace riscv
 }  // namespace sim
 }  // namespace mpact
	// Copyright 2023 Google LLC
	//
	// 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
	//
	// https://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 "riscv/riscv32_htif_semihost.h"

	#include <fcntl.h>
	#include <unistd.h>

	#include <cstdint>
	#include <cstring>
	#include <utility>

	#include "absl/functional/bind_front.h"
	#include "absl/strings/str_cat.h"
	#include "mpact/sim/generic/data_buffer.h"
	#include "mpact/sim/util/memory/memory_interface.h"
	#include "mpact/sim/util/memory/memory_watcher.h"

	namespace mpact {
	namespace sim {
	namespace riscv {

	constexpr int kRiscvAtFdCwd = -100;

	using AddressRange = mpact::sim::util::MemoryWatcher::AddressRange;

	RiscV32HtifSemiHost::RiscV32HtifSemiHost(
	util::MemoryWatcher* watcher, util::MemoryInterface* memory,
	const SemiHostAddresses& magic_addresses)
	: RiscV32HtifSemiHost(watcher, memory, magic_addresses, nullptr, nullptr) {}

	RiscV32HtifSemiHost::RiscV32HtifSemiHost(
	util::MemoryWatcher* watcher, util::MemoryInterface* memory,
	const SemiHostAddresses& magic_addresses, HaltCallback halt_callback,
	ErrorCallback error_callback)
	: halt_callback_(std::move(halt_callback)),
	error_callback_(std::move(error_callback)),
	watcher_(watcher),
	memory_(memory) {
	magic_addresses_ = magic_addresses;
	(void)watcher_->SetStoreWatchCallback(
	AddressRange(magic_addresses_.tohost_ready),
	absl::bind_front(&RiscV32HtifSemiHost::StoreEvent, this));

	// Initialize fd_map_.
	fd_map_.emplace(0, 0);
	fd_map_.emplace(1, 1);
	fd_map_.emplace(2, 2);
	fd_map_.emplace(kRiscvAtFdCwd, AT_FDCWD);
	}

	RiscV32HtifSemiHost::~RiscV32HtifSemiHost() {
	// Ignore any error when clearing the previous watchpoint.
	(void)watcher_->ClearStoreWatchCallback(magic_addresses_.tohost_ready);
	}

	void RiscV32HtifSemiHost::SetMagicAddresses(
	const SemiHostAddresses& magic_addresses) {
	// Clear any previous store watchpoint. Ignore any error.
	(void)watcher_->ClearStoreWatchCallback(magic_addresses_.tohost_ready);
	magic_addresses_ = magic_addresses;
	(void)watcher_->SetStoreWatchCallback(
	AddressRange(magic_addresses_.tohost_ready),
	absl::bind_front(&RiscV32HtifSemiHost::StoreEvent, this));
	}

	void RiscV32HtifSemiHost::SetHaltCallback(HaltCallback callback) {
	halt_callback_ = std::move(callback);
	}

	void RiscV32HtifSemiHost::SetErrorCallback(ErrorCallback callback) {
	error_callback_ = std::move(callback);
	}

	void RiscV32HtifSemiHost::StoreEvent(uint64_t address, int size) {
	// Return if the ready byte isn't part of the store event.
	if ((address > magic_addresses_.tohost_ready) \|\|
	(address + size - 1 < magic_addresses_.tohost_ready))
	return;

	// Read the value of the ready_db, if not 1, then the tohost location
	// does not contain data, and there's nothing to do.
	auto* ready_db = db_factory_.Allocate<uint8_t>(1);
	memory_->Load(magic_addresses_.tohost_ready, ready_db, nullptr, nullptr);
	if (ready_db->Get<uint8_t>(0) != 1) {
	ready_db->DecRef();
	return;
	}

	// Get the payload double word. Extract the command.
	auto* payload_db = db_factory_.Allocate<uint64_t>(1);
	memory_->Load(magic_addresses_.tohost, payload_db, nullptr, nullptr);
	uint64_t payload = payload_db->Get<uint64_t>(0);
	uint8_t device = payload >> 56;
	uint8_t command = (payload >> 48) & 0xff;
	// If it's not the syscall device and command, just return.
	if ((device != 0) \|\| (command != 0)) return;

	// If the payload lsb is 1, then it's the end of the run. Halt (but don't
	// catch fire!).
	if (payload & 0x1) {
	if (halt_callback_ != nullptr) halt_callback_();
	payload_db->DecRef();
	ready_db->DecRef();
	return;
	}
	// The payload contains a pointer to an 8 double word parameter block. Load
	// that block.
	auto* parameter_db = db_factory_.Allocate<uint64_t>(8);
	memory_->Load(payload, parameter_db, nullptr, nullptr);
	auto parameter_span = parameter_db->Get<uint64_t>();
	int64_t return_value = 0;
	// The first parameter specifies the syscall.
	switch (parameter_span[0]) {
	// TODO: Add other semihosting calls.
	case 56: // sys_openat
	{
	int dirfd = parameter_span[1];
	auto iter = fd_map_.find(dirfd);
	if (iter == fd_map_.end()) {
	dirfd = -1;
	} else {
	dirfd = iter->second;
	}
	auto* db = db_factory_.Allocate(parameter_span[3]);
	auto address = parameter_span[2];
	memory_->Load(address, db, nullptr, nullptr);
	char* name = static_cast<char*>(db->raw_ptr());
	return_value = openat(dirfd, name, parameter_span[4], parameter_span[5]);
	db->DecRef();
	} break;
	case 57: // sys_close
	{
	auto fd_iter = fd_map_.find(parameter_span[1]);
	if (fd_iter == fd_map_.end()) {
	return_value = -1;
	break;
	}
	fd_map_.erase(fd_iter);
	return_value = 0;
	} break;
	case 62: // sys_lseek
	{
	auto iter = fd_map_.find(parameter_span[1]);
	int fd = iter == fd_map_.end() ? -1 : iter->second;
	off_t offset = static_cast<off_t>(parameter_span[2]);
	int whence = static_cast<int>(parameter_span[3]);
	return_value = lseek(fd, offset, whence);
	} break;
	case 63: // sys_read
	{
	auto iter = fd_map_.find(parameter_span[1]);
	int fd = iter == fd_map_.end() ? -1 : iter->second;
	size_t len = static_cast<size_t>(parameter_span[3]);
	auto* data_db = db_factory_.Allocate<uint8_t>(len);
	int res = read(fd, data_db->raw_ptr(), len);
	if (res > 0) {
	generic::DataBuffer* db = nullptr;
	// Need to see if fewer bytes were read than there was space for. If so
	// need to use a different db for the store.
	if (res == len) {
	db = data_db;
	} else {
	db = db_factory_.Allocate<uint8_t>(res);
	std::memcpy(db->raw_ptr(), data_db->raw_ptr(), res);
	data_db->DecRef();
	}
	memory_->Store(parameter_span[2], db);
	db->DecRef();
	}
	return_value = res;
	} break;
	case 64: // sys_write
	{
	auto iter = fd_map_.find(parameter_span[1]);
	int fd = iter == fd_map_.end() ? -1 : iter->second;
	auto* data_db = db_factory_.Allocate<uint8_t>(parameter_span[3]);
	memory_->Load(parameter_span[2], data_db, nullptr, nullptr);
	size_t len = static_cast<size_t>(parameter_span[3]);
	return_value = write(fd, data_db->raw_ptr(), len);
	data_db->DecRef();
	} break;
	case 67: // sys_pread
	{
	auto iter = fd_map_.find(parameter_span[1]);
	int fd = iter == fd_map_.end() ? -1 : iter->second;
	size_t len = static_cast<size_t>(parameter_span[3]);
	off_t offset = static_cast<off_t>(parameter_span[4]);
	auto* data_db = db_factory_.Allocate<uint8_t>(len);
	int res = pread(fd, data_db->raw_ptr(), len, offset);
	if (res > 0) {
	generic::DataBuffer* db = nullptr;
	// Need to see if fewer bytes were read than there was space for. If so
	// need to use a different db for the store.
	if (res == len) {
	db = data_db;
	} else {
	db = db_factory_.Allocate<uint8_t>(res);
	std::memcpy(db->raw_ptr(), data_db->raw_ptr(), res);
	data_db->DecRef();
	}
	memory_->Store(parameter_span[2], db);
	db->DecRef();
	}
	return_value = res;
	} break;
	case 68: // sys_pwrite
	{
	auto iter = fd_map_.find(parameter_span[1]);
	int fd = iter == fd_map_.end() ? -1 : iter->second;
	auto* data_db = db_factory_.Allocate<uint8_t>(parameter_span[3]);
	memory_->Load(parameter_span[2], data_db, nullptr, nullptr);
	size_t len = static_cast<size_t>(parameter_span[3]);
	off_t offset = static_cast<off_t>(parameter_span[4]);
	return_value = pwrite(fd, data_db->raw_ptr(), len, offset);
	data_db->DecRef();
	} break;
	case 93: // sys_exit
	if (halt_callback_ != nullptr) halt_callback_();
	break;
	default:
	// For now, ignore the others.
	parameter_db->DecRef();
	payload_db->DecRef();
	ready_db->DecRef();
	error_callback_(absl::StrCat("Unhandled syscall: ", parameter_span[0]));
	return;
	}
	parameter_db->DecRef();
	// Write the response packets.
	payload_db->Set<uint64_t>(0, return_value);
	memory_->Store(payload, payload_db);
	payload_db->DecRef();
	ready_db->Set<uint8_t>(0, 1);
	// Signal that the response is ready.
	memory_->Store(magic_addresses_.fromhost_ready, ready_db);
	ready_db->DecRef();
	}

	} // namespace riscv
	} // namespace sim
	} // namespace mpact