blob: 57b702510da72bb2419fd8de355971cafa489e02 [file] [log] [blame]
/*
* Copyright (C) 2023 The Android Open Sourete 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.
*/
#define LOG_TAG "line-coverage"
#include <BufferAllocator/BufferAllocator.h>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
#include <assert.h>
#include <log/log.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/uio.h>
#include <trusty/line-coverage/coverage.h>
#include <trusty/line-coverage/tipc.h>
#include <trusty/tipc.h>
#include <iostream>
#define LINE_COVERAGE_CLIENT_PORT "com.android.trusty.linecoverage.client"
struct control {
/* Written by controller, read by instrumented TA */
uint64_t cntrl_flags;
/* Written by instrumented TA, read by controller */
uint64_t oper_flags;
uint64_t write_buffer_start_count;
uint64_t write_buffer_complete_count;
};
namespace android {
namespace trusty {
namespace line_coverage {
using ::android::base::ErrnoError;
using ::android::base::Error;
using ::std::string;
static inline uintptr_t RoundPageUp(uintptr_t val) {
return (val + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
}
CoverageRecord::CoverageRecord(string tipc_dev, struct uuid* uuid)
: tipc_dev_(std::move(tipc_dev)),
coverage_srv_fd_(-1),
uuid_(*uuid),
record_len_(0),
shm_(NULL),
shm_len_(0) {}
CoverageRecord::~CoverageRecord() {
if (shm_) {
munmap((void*)shm_, shm_len_);
}
}
volatile void *CoverageRecord::getShm() {
if(!IsOpen()) {
fprintf(stderr, "Warning! SHM is NULL!\n");
}
return shm_;
}
Result<void> CoverageRecord::Rpc(struct line_coverage_client_req* req, \
int req_fd, \
struct line_coverage_client_resp* resp) {
int rc;
if (req_fd < 0) {
rc = write(coverage_srv_fd_, req, sizeof(*req));
} else {
iovec iov = {
.iov_base = req,
.iov_len = sizeof(*req),
};
trusty_shm shm = {
.fd = req_fd,
.transfer = TRUSTY_SHARE,
};
rc = tipc_send(coverage_srv_fd_, &iov, 1, &shm, 1);
}
if (rc != (int)sizeof(*req)) {
return ErrnoError() << "failed to send request to coverage server: ";
}
rc = read(coverage_srv_fd_, resp, sizeof(*resp));
if (rc != (int)sizeof(*resp)) {
return ErrnoError() << "failed to read reply from coverage server: ";
}
if (resp->hdr.cmd != (req->hdr.cmd | LINE_COVERAGE_CLIENT_CMD_RESP_BIT)) {
return ErrnoError() << "unknown response cmd: " << resp->hdr.cmd;
}
return {};
}
Result<void> CoverageRecord::Open(int fd) {
struct line_coverage_client_req req;
struct line_coverage_client_resp resp;
if (shm_) {
return {}; /* already initialized */
}
coverage_srv_fd_= fd;
req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_OPEN;
req.open_args.uuid = uuid_;
auto ret = Rpc(&req, -1, &resp);
if (!ret.ok()) {
return Error() << "failed to open coverage client: " << ret.error();
}
record_len_ = resp.open_args.record_len;
shm_len_ = RoundPageUp(record_len_);
BufferAllocator allocator;
fd = allocator.Alloc("system", shm_len_);
if (fd < 0) {
return ErrnoError() << "failed to create dmabuf of size " << shm_len_
<< " err code: " << fd;
}
unique_fd dma_buf(fd);
void* shm = mmap(0, shm_len_, PROT_READ | PROT_WRITE, MAP_SHARED, dma_buf, 0);
if (shm == MAP_FAILED) {
return ErrnoError() << "failed to map memfd: ";
}
req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_SHARE_RECORD;
req.share_record_args.shm_len = shm_len_;
ret = Rpc(&req, dma_buf, &resp);
if (!ret.ok()) {
return Error() << "failed to send shared memory: " << ret.error();
}
shm_ = shm;
req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_OPEN;
req.open_args.uuid = uuid_;
ret = Rpc(&req, -1, &resp);
if (!ret.ok()) {
return Error() << "failed to open coverage client: " << ret.error();
}
return {};
}
bool CoverageRecord::IsOpen() {
return shm_;
}
Result<void> CoverageRecord::SaveFile(const std::string& filename) {
if(!IsOpen()) {
return ErrnoError() << "Warning! SHM is NULL!";
}
android::base::unique_fd output_fd(TEMP_FAILURE_RETRY(creat(filename.c_str(), 00644)));
if (!output_fd.ok()) {
return ErrnoError() << "Could not open output file";
}
uintptr_t* begin = (uintptr_t*)((char *)shm_ + sizeof(struct control));
bool ret = WriteFully(output_fd, begin, record_len_);
if(!ret) {
fprintf(stderr, "Coverage write to file failed\n");
}
return {};
}
} // namespace line_coverage
} // namespace trusty
} // namespace android