* Copyright (C) 2022 Huawei Technologies Co., Ltd.
* Decription: TEE Logging Subsystem, read the tee os log from log memory
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "tlogger.h"
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/version.h>
#include <linux/delay.h>
#include <asm/ioctls.h>
#include <linux/syscalls.h>
#include <securec.h>
#include <asm/io.h>
#include "smc_smp.h"
#include "mailbox_mempool.h"
#include "teek_client_constants.h"
#include "tc_ns_client.h"
#include "teek_ns_client.h"
#include "log_cfg_api.h"
#include "tc_ns_log.h"
#include "ko_adapt.h"
#include "internal_functions.h"
#ifdef CONFIG_LOG_POOL
#include "shared_mem.h"
#endif
#ifdef CONFIG_TEE_REBOOT
#include "reboot.h"
#endif
#define LOG_ITEM_MAGIC 0x5A5A
#define LOG_ITEM_LEN_ALIGN 64
#define LOG_ITEM_MAX_LEN 1024
#define LOG_READ_STATUS_ERROR 0x000FFFF
#define LOGGER_LOG_TEEOS "teelog"
#define LOGGERIOCTL 0xBE
#define DUMP_START_MAGIC "Dump SPI notification"
#define DUMP_END_MAGIC "Dump task states END"
#define GET_VERSION_BASE 5
#define SET_READERPOS_CUR_BASE 6
#define SET_TLOGCAT_STAT_BASE 7
#define GET_TLOGCAT_STAT_BASE 8
#define MAX_TEE_VERSION_LEN 256
#define TEELOGGER_GET_VERSION \
_IOR(LOGGERIOCTL, GET_VERSION_BASE, char[MAX_TEE_VERSION_LEN])
#define TEELOGGER_SET_READERPOS_CUR \
_IO(LOGGERIOCTL, SET_READERPOS_CUR_BASE)
#define TEELOGGER_SET_TLOGCAT_STAT \
_IO(LOGGERIOCTL, SET_TLOGCAT_STAT_BASE)
#define TEELOGGER_GET_TLOGCAT_STAT \
_IO(LOGGERIOCTL, GET_TLOGCAT_STAT_BASE)
#ifdef CONFIG_LOG_POOL
struct teelogger_log_pool {
uint64_t addr;
uint64_t size;
};
#define GET_LOG_POOL_BASE 9
#define LOG_POOL_APPEND_BASE 10
#define TEELOGGER_GET_LOG_POOL \
_IOWR(LOGGERIOCTL, GET_LOG_POOL_BASE, uint64_t)
#define TEELOGGER_LOG_POOL_APPEND \
_IOWR(LOGGERIOCTL, LOG_POOL_APPEND_BASE, struct teelogger_log_pool)
#endif
int g_tlogcat_f = 0;
#ifndef CONFIG_TEE_LOG_ACHIVE_PATH
#define CONFIG_TEE_LOG_ACHIVE_PATH "/data/log/tee/last_teemsg"
#endif
#define TEE_LOG_FILE_NAME_MAX 256
uint32_t g_last_read_offset = 0;
#define NEVER_USED_LEN 32U
#define LOG_ITEM_RESERVED_LEN 1U
struct log_item {
unsigned char never_used[NEVER_USED_LEN];
unsigned short magic;
unsigned short reserved0;
uint32_t serial_no;
unsigned short real_len;
unsigned short buffer_len;
unsigned char uuid[UUID_LEN];
unsigned char log_source_type;
unsigned char reserved[LOG_ITEM_RESERVED_LEN];
unsigned char log_level;
unsigned char new_line;
unsigned char log_buffer[];
};
#define TEMP_LOG_MEM_SIZE (10 * SZ_1K)
#define LOG_BUFFER_RESERVED_LEN 11U
#define VERSION_INFO_LEN 156U
* Log's buffer flag info, size: 64 bytes head + 156 bytes's version info.
* For filed description:
* last_pos : current log's end position, last log's start position.
* write_loops: Write cyclically. Init value is 0, when memory is used
* up, the value add 1.
*/
struct log_buffer_flag {
uint32_t reserved0;
uint32_t last_pos;
uint32_t write_loops;
uint32_t log_level;
uint32_t reserved[LOG_BUFFER_RESERVED_LEN];
uint32_t max_len;
unsigned char version_info[VERSION_INFO_LEN];
};
struct log_buffer {
struct log_buffer_flag flag;
unsigned char buffer_start[];
};
static struct log_buffer *g_log_buffer = NULL;
struct tlogger_log {
unsigned char *buffer_info;
struct mutex mutex_info;
wait_queue_head_t wait_queue_head;
struct list_head logs;
struct miscdevice misc_device;
struct list_head readers;
};
static LIST_HEAD(m_log_list);
struct tlogger_reader {
struct tlogger_log *log;
struct list_head list;
uint32_t r_off;
uint32_t r_loops;
uint32_t r_sn;
uint32_t r_failtimes;
uint32_t r_from_cur;
uint32_t r_is_tlogf;
bool r_all;
uint32_t r_ver;
};
static uint32_t g_log_mem_len = 0;
static uint32_t g_tlogcat_count = 0;
static struct tlogger_log *g_log;
static struct tlogger_log *get_reader_log(const struct file *file)
{
struct tlogger_reader *reader = NULL;
reader = file->private_data;
if (!reader)
return NULL;
return reader->log;
}
static bool check_log_item_validite(const struct log_item *item,
uint32_t item_max_size)
{
bool con = (item && (item->magic == LOG_ITEM_MAGIC) &&
(item->buffer_len > 0) &&
(item->real_len > 0) &&
(item->buffer_len % LOG_ITEM_LEN_ALIGN == 0) &&
(item->real_len <= item->buffer_len) &&
((item->buffer_len - item->real_len) < LOG_ITEM_LEN_ALIGN) &&
(item->buffer_len + sizeof(*item) <= item_max_size));
return con;
}
static struct log_item *get_next_log_item(const unsigned char *buffer_start,
uint32_t max_len, uint32_t read_pos, uint32_t scope_len, uint32_t *pos)
{
uint32_t i = 0;
struct log_item *item = NULL;
uint32_t max_size;
if ((read_pos + scope_len) > max_len)
return NULL;
while ((i + sizeof(*item) + LOG_ITEM_LEN_ALIGN) <= scope_len) {
*pos = read_pos + i;
item = (struct log_item *)(uintptr_t)(buffer_start + read_pos + i);
max_size = (((scope_len - i) > LOG_ITEM_MAX_LEN) ?
LOG_ITEM_MAX_LEN : (scope_len - i));
if (check_log_item_validite(item, max_size))
break;
i += LOG_ITEM_LEN_ALIGN;
item = NULL;
}
return item;
}
struct reader_position {
const unsigned char *buffer_start;
uint32_t max_len;
uint32_t start_pos;
uint32_t end_pos;
};
static uint32_t parse_log_item(char __user *buf, size_t count,
struct reader_position *position, uint32_t *read_off,
bool *user_buffer_left)
{
struct log_item *next_item = NULL;
size_t buf_left;
uint32_t buf_written;
uint32_t item_len;
bool con = false;
uint32_t start_pos = position->start_pos;
buf_written = 0;
buf_left = count;
con = (!read_off || !position->buffer_start);
if (con)
return buf_written;
*user_buffer_left = true;
while (start_pos < position->end_pos) {
next_item = get_next_log_item(position->buffer_start,
position->max_len, start_pos,
position->end_pos - start_pos, &start_pos);
if (!next_item)
break;
item_len = next_item->buffer_len + sizeof(*next_item);
if (buf_left < item_len) {
*user_buffer_left = false;
break;
}
start_pos += item_len;
if (copy_to_user(buf + buf_written,
(void *)next_item, item_len) != 0)
tloge("copy failed, item len %u\n", item_len);
buf_written += item_len;
buf_left -= item_len;
}
*read_off = start_pos;
return buf_written;
}
static ssize_t get_buffer_info(struct tlogger_reader *reader,
struct log_buffer_flag *buffer_flag, struct log_buffer **log_buffer)
{
struct tlogger_log *log = NULL;
errno_t ret;
struct log_buffer *buffer_tmp = NULL;
log = reader->log;
if (!log)
return -EINVAL;
buffer_tmp = (struct log_buffer*)log->buffer_info;
if (!buffer_tmp)
return -EINVAL;
__asm__ volatile ("isb");
__asm__ volatile ("dsb sy");
mutex_lock(&log->mutex_info);
ret = memcpy_s(buffer_flag, sizeof(*buffer_flag), &buffer_tmp->flag,
sizeof(buffer_tmp->flag));
mutex_unlock(&log->mutex_info);
if (ret != 0) {
tloge("memcpy failed %d\n", ret);
return -EAGAIN;
}
*log_buffer = buffer_tmp;
return 0;
}
#define LOG_BUFFER_MAX_LEN 0x100000
static ssize_t get_last_read_pos(struct log_buffer_flag *log_flag,
const struct tlogger_reader *reader, uint32_t *log_last_pos, uint32_t *is_read)
{
uint32_t buffer_max_len = g_log_mem_len - sizeof(*g_log_buffer);
*is_read = 0;
if (buffer_max_len > LOG_BUFFER_MAX_LEN)
return -EINVAL;
*log_last_pos = log_flag->last_pos;
if (*log_last_pos == reader->r_off &&
log_flag->write_loops == reader->r_loops)
return 0;
if (log_flag->max_len < *log_last_pos ||
log_flag->max_len > buffer_max_len) {
tloge("invalid data maxlen %x pos %x\n",
log_flag->max_len, *log_last_pos);
return -EFAULT;
}
if (reader->r_off > log_flag->max_len) {
tloge("invalid data roff %x maxlen %x\n",
reader->r_off, log_flag->max_len);
return -EFAULT;
}
*is_read = 1;
return 0;
}
static void set_reader_position(struct reader_position *position,
const unsigned char *buffer_start, uint32_t max_len, uint32_t start_pos, uint32_t end_pos)
{
position->buffer_start = buffer_start;
position->max_len = max_len;
position->start_pos = start_pos;
position->end_pos = end_pos;
}
static ssize_t proc_read_ret(uint32_t buf_written,
const struct tlogger_reader *reader)
{
ssize_t ret;
if (buf_written == 0) {
ret = 0;
} else {
ret = buf_written;
tlogd("read length %u\n", buf_written);
g_last_read_offset = reader->r_off;
}
return ret;
}
static ssize_t check_read_params(const struct file *file,
const char __user *buf, size_t count)
{
if (count < LOG_ITEM_MAX_LEN)
return -EINVAL;
if (!file || !buf)
return -EINVAL;
return 0;
}
* If the sequence number of the last read position is smaller
* than the current minimum sequence number, the last read
* position is overwritten. And this time read data from
* minimum number, or read data from last position.
*/
static ssize_t trigger_parse_log(char __user *buf, size_t count,
uint32_t log_last_pos, struct log_buffer *log_buffer,
struct tlogger_reader *reader)
{
bool user_buffer_left = false;
uint32_t buf_written;
struct reader_position position = {0};
struct log_buffer_flag *buffer_flag = &(log_buffer->flag);
if (buffer_flag->write_loops == reader->r_loops) {
set_reader_position(&position, log_buffer->buffer_start,
buffer_flag->max_len, reader->r_off, log_last_pos);
buf_written = parse_log_item(buf, count, &position,
&reader->r_off, &user_buffer_left);
return proc_read_ret(buf_written, reader);
}
if (buffer_flag->write_loops > (reader->r_loops +1) ||
((buffer_flag->write_loops == (reader->r_loops + 1)) &&
(reader->r_off < log_last_pos))) {
reader->r_off = log_last_pos;
reader->r_loops = buffer_flag->write_loops - 1;
}
set_reader_position(&position, log_buffer->buffer_start,
buffer_flag->max_len, reader->r_off, buffer_flag->max_len);
buf_written = parse_log_item(buf, count, &position,
&reader->r_off, &user_buffer_left);
if (count > buf_written && user_buffer_left) {
set_reader_position(&position, log_buffer->buffer_start,
buffer_flag->max_len, 0, log_last_pos);
buf_written += parse_log_item(buf + buf_written,
count - buf_written, &position,
&reader->r_off, &user_buffer_left);
reader->r_loops = buffer_flag->write_loops;
}
return proc_read_ret(buf_written, reader);
}
static ssize_t process_tlogger_read(struct file *file,
char __user *buf, size_t count, loff_t *pos)
{
struct tlogger_reader *reader = NULL;
struct log_buffer *log_buffer = NULL;
ssize_t ret;
uint32_t last_pos;
uint32_t is_read;
struct log_buffer_flag buffer_flag;
(void)pos;
ret = check_read_params(file, buf, count);
if (ret != 0)
return ret;
reader = file->private_data;
if (!reader)
return -EINVAL;
ret = get_buffer_info(reader, &buffer_flag, &log_buffer);
if (ret != 0)
return ret;
ret = get_last_read_pos(&buffer_flag, reader, &last_pos, &is_read);
if (is_read == 0)
return ret;
return trigger_parse_log(buf, count, last_pos, log_buffer, reader);
}
void tz_log_write(void)
{
struct log_buffer *log_buffer = NULL;
if (!g_log)
return;
log_buffer = (struct log_buffer*)g_log->buffer_info;
if (!log_buffer)
return;
if (g_last_read_offset != log_buffer->flag.last_pos) {
tlogd("wake up write tz log\n");
wake_up_interruptible(&g_log->wait_queue_head);
}
return;
}
static struct tlogger_log *get_tlogger_log_by_minor(int minor)
{
struct tlogger_log *log = NULL;
list_for_each_entry(log, &m_log_list, logs) {
if (log->misc_device.minor == minor)
return log;
}
return NULL;
}
static int process_tlogger_open(struct inode *inode,
struct file *file)
{
struct tlogger_log *log = NULL;
int ret;
struct tlogger_reader *reader = NULL;
tlogd("open logger open ++\n");
ret = nonseekable_open(inode, file);
if (ret != 0)
return ret;
tlogd("Before get log from minor\n");
log = get_tlogger_log_by_minor(MINOR(inode->i_rdev));
if (!log)
return -ENODEV;
reader = kmalloc(sizeof(*reader), GFP_KERNEL);
if (ZERO_OR_NULL_PTR((unsigned long)(uintptr_t)reader))
return -ENOMEM;
reader->log = log;
reader->r_all = true;
reader->r_off = 0;
reader->r_loops = 0;
reader->r_sn = 0;
reader->r_failtimes = 0;
reader->r_is_tlogf = 0;
reader ->r_from_cur = 0;
INIT_LIST_HEAD(&reader->list);
mutex_lock(&log->mutex_info);
list_add_tail(&reader->list, &log->readers);
g_tlogcat_count++;
mutex_unlock(&log->mutex_info);
file->private_data = reader;
tlogd("tlogcat count %u\n", g_tlogcat_count);
#ifdef CONFIG_TEE_REBOOT
get_tlogcat_pid();
#endif
return 0;
}
static int process_tlogger_release(struct inode *ignored,
struct file *file)
{
struct tlogger_reader *reader = NULL;
struct tlogger_log *log = NULL;
(void)ignored;
tlogd("logger_release ++\n");
if (!file)
return -1;
reader = file->private_data;
if (!reader) {
tloge("reader is null\n");
return -1;
}
log = reader->log;
if (!log) {
tloge("log is null\n");
return -1;
}
mutex_lock(&log->mutex_info);
list_del(&reader->list);
if (g_tlogcat_count >= 1)
g_tlogcat_count--;
mutex_unlock(&log->mutex_info);
tlogd("logger_release r_is_tlogf-%u\n", reader->r_is_tlogf);
if (reader->r_is_tlogf != 0)
g_tlogcat_f = 0;
kfree(reader);
tlogd("tlogcat count %u\n", g_tlogcat_count);
return 0;
}
static unsigned int process_tlogger_poll(struct file *file,
poll_table *wait)
{
struct tlogger_reader *reader = NULL;
struct tlogger_log *log = NULL;
struct log_buffer *buffer = NULL;
uint32_t ret = POLLOUT | POLLWRNORM;
tlogd("logger_poll ++\n");
if (!file) {
tloge("file is null\n");
return ret;
}
reader = file->private_data;
if (!reader) {
tloge("the private data is null\n");
return ret;
}
log = reader->log;
if (!log) {
tloge("log is null\n");
return ret;
}
buffer = (struct log_buffer*)log->buffer_info;
if (!buffer) {
tloge("buffer is null\n");
return ret;
}
poll_wait(file, &log->wait_queue_head, wait);
if (buffer->flag.last_pos != reader->r_off)
ret |= POLLIN | POLLRDNORM;
return ret;
}
#define SET_READ_POS 1U
static void set_reader_cur_pos(const struct file *file)
{
struct tlogger_reader *reader = NULL;
struct tlogger_log *log = NULL;
struct log_buffer *buffer = NULL;
reader = file->private_data;
if (!reader)
return;
log = reader->log;
if (!log)
return;
buffer = (struct log_buffer*)log->buffer_info;
if (!buffer)
return;
reader->r_from_cur = SET_READ_POS;
reader->r_off = buffer->flag.last_pos;
reader->r_loops = buffer->flag.write_loops;
}
static void set_tlogcat_f_stat(const struct file *file)
{
struct tlogger_reader *reader = NULL;
if (!file)
return;
reader = file->private_data;
if (!reader)
return;
reader->r_is_tlogf = 1;
g_tlogcat_f = 1;
tlogi("set tlogcat_f-%d\n", g_tlogcat_f);
return;
}
static int get_tlogcat_f_stat(void)
{
tlogi("get tlogcat_f-%d\n", g_tlogcat_f);
return g_tlogcat_f;
}
static int check_user_arg(unsigned long arg, size_t arg_len)
{
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 18) || \
LINUX_VERSION_CODE == KERNEL_VERSION(4, 19, 71))
return (int)access_ok(VERIFY_READ,
(void __user *)(uintptr_t)arg, arg_len);
#else
return (int)access_ok((void __user *)(uintptr_t)arg, arg_len);
#endif
}
static int get_teeos_version(uint32_t cmd, unsigned long arg)
{
int ret;
if ((_IOC_DIR(cmd) & _IOC_READ) == 0) {
tloge("check get version cmd failed\n");
return -1;
}
ret = check_user_arg(arg,
sizeof(g_log_buffer->flag.version_info));
if (ret == 0) {
tloge("check version info arg failed\n");
return -1;
}
if (copy_to_user((void __user *)(uintptr_t)arg,
(void *)g_log_buffer->flag.version_info,
sizeof(g_log_buffer->flag.version_info)) != 0) {
tloge("version info copy failed\n");
return -1;
}
return 0;
}
#ifdef CONFIG_LOG_POOL
#define LOG_POOL_SIZE 0x80000UL
#define LOG_POOL_ITEM_MAX_LEN 384
#define HALF_DIV_NUM 2
static DEFINE_MUTEX(g_log_pool_lock);
static uint64_t g_log_pool_va = 0;
static uint64_t g_log_pool_size = 0;
static uint32_t g_logserialno = 0;
static int get_log_pool(void *argp)
{
uint64_t sz = 0;
if (argp == NULL) {
tloge("invalid params\n");
return -1;
}
sz = get_log_mem_size() / HALF_DIV_NUM;
if (sz != LOG_POOL_SIZE) {
tloge("log pool size error\n");
return -1;
}
if (copy_to_user(argp, &sz, sizeof(uint64_t)) != 0) {
tloge("copy to user failed\n");
return -1;
}
return 0;
}
static int log_pool_check(void)
{
if (g_log_pool_size != LOG_POOL_SIZE) {
tloge("log pool size error\n");
g_log_pool_size = 0;
return -1;
}
if (g_log_pool_va == 0 || (UINT64_MAX - g_log_pool_va) < g_log_pool_size) {
tloge("log pool addr error\n");
g_log_pool_va = 0;
return -1;
}
return 0;
}
static int log_pool_item_check(struct log_item *item, struct teelogger_log_pool pool_item)
{
if (item->magic != LOG_ITEM_MAGIC || item->buffer_len == 0 || item->real_len == 0||
item->buffer_len % LOG_ITEM_LEN_ALIGN != 0 || item->real_len > item->buffer_len ||
(item->buffer_len - item->real_len) >= (uint16_t)LOG_ITEM_LEN_ALIGN ||
(uint64_t)(item->buffer_len + sizeof(struct log_item)) > pool_item.size)
return -1;
return 0;
}
static int log_pool_append(void *argp)
{
struct teelogger_log_pool pool_item = {0};
struct log_buffer *pool_buffer = NULL;
struct log_item *item = NULL;
if (argp == NULL || log_pool_check() != 0) {
tloge("invalid params, g_log_pool_va or g_log_pool_size\n");
return -1;
}
if (copy_from_user((void *)&pool_item, argp, sizeof(struct teelogger_log_pool)) != 0) {
tloge("pool_item copy from user error\n");
return -1;
}
if ((uint64_t)LOG_POOL_ITEM_MAX_LEN < pool_item.size || pool_item.size < (uint64_t)sizeof(struct log_item) ||
pool_item.addr == 0 || UINT64_MAX - pool_item.addr < pool_item.size) {
tloge("pool_item addr or size error\n");
return -1;
}
mutex_lock(&g_log_pool_lock);
pool_buffer = (struct log_buffer *)(uintptr_t)g_log_pool_va;
if (pool_buffer == NULL || (uint64_t)(pool_buffer->flag).last_pos > g_log_pool_size ||
((uint64_t)sizeof(struct log_buffer) + (uint64_t)(pool_buffer->flag).last_pos) > g_log_pool_size) {
tloge("pool_buffer error\n");
mutex_unlock(&g_log_pool_lock);
return -1;
}
if (((uint64_t)sizeof(struct log_buffer) + (uint64_t)(pool_buffer->flag).last_pos +
pool_item.size) > g_log_pool_size) {
pool_buffer->flag.write_loops++;
pool_buffer->flag.last_pos = 0;
}
item = (struct log_item *)(uintptr_t)((uint64_t)(uintptr_t)pool_buffer->buffer_start +
(uint64_t)pool_buffer->flag.last_pos);
if (copy_from_user((void *)item, (void *)pool_item.addr, pool_item.size) != 0) {
tloge("item copy_from_user error\n");
mutex_unlock(&g_log_pool_lock);
return -1;
}
if (log_pool_item_check(item, pool_item) != 0) {
tloge("item check error\n");
mutex_unlock(&g_log_pool_lock);
return -1;
}
item->serial_no = ++g_logserialno;
if (item->serial_no == 0)
item->serial_no = ++g_logserialno;
item->new_line = (unsigned char)'\n';
pool_buffer->flag.reserved[1] = g_logserialno;
pool_buffer->flag.last_pos += (uint32_t)pool_item.size;
mutex_unlock(&g_log_pool_lock);
return 0;
}
static int init_log_pool(void)
{
struct log_buffer *pool_buffer = NULL;
uint64_t paddr = get_log_mem_paddr(0);
g_log_pool_size = get_log_mem_size();
if ((UINT64_MAX - paddr) < g_log_pool_size) {
tloge("log pool paddr error\n");
return -1;
}
g_log_pool_size /= HALF_DIV_NUM;
g_log_pool_va = (uint64_t)(uintptr_t)ioremap_cache(paddr + g_log_pool_size, g_log_pool_size);
if (log_pool_check() != 0) {
tloge("log pool addr or size error\n");
return -1;
}
pool_buffer = (struct log_buffer *)(uintptr_t)g_log_pool_va;
* the struct log_buffer magic field use for log retention feature,
* if hit the magic, will retain the old log before reset in log pool,
* or will memset log pool.
*/
if (pool_buffer->flag.reserved[0] != LOG_ITEM_MAGIC) {
(void)memset_s((void *)(uintptr_t)g_log_pool_va, g_log_pool_size, 0, g_log_pool_size);
pool_buffer->flag.reserved[0] = LOG_ITEM_MAGIC;
pool_buffer->flag.max_len = g_log_pool_size - sizeof(struct log_buffer);
} else {
g_logserialno = pool_buffer->flag.reserved[1];
}
return 0;
}
static void free_log_pool(void)
{
if (g_log_pool_va != 0)
iounmap((void __iomem *)(uintptr_t)g_log_pool_va);
g_log_pool_va = 0;
g_log_pool_size = 0;
g_logserialno = 0;
}
#endif
static long process_tlogger_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct tlogger_log *log = NULL;
long ret = -EINVAL;
if (!file)
return -1;
log = get_reader_log(file);
if (!log) {
tloge("log is null\n");
return -1;
}
tlogd("logger_ioctl start ++\n");
mutex_lock(&log->mutex_info);
switch (cmd) {
case TEELOGGER_GET_VERSION:
if (get_teeos_version(cmd, arg) == 0)
ret = 0;
break;
case TEELOGGER_SET_READERPOS_CUR:
set_reader_cur_pos(file);
ret = 0;
break;
case TEELOGGER_SET_TLOGCAT_STAT:
set_tlogcat_f_stat(file);
ret = 0;
break;
case TEELOGGER_GET_TLOGCAT_STAT:
ret = get_tlogcat_f_stat();
break;
#ifdef CONFIG_LOG_POOL
case TEELOGGER_GET_LOG_POOL:
ret = get_log_pool(arg);
break;
case TEELOGGER_LOG_POOL_APPEND:
ret = log_pool_append(arg);
break;
#endif
default:
tloge("ioctl error default\n");
break;
}
mutex_unlock(&log->mutex_info);
return ret;
}
#ifdef CONFIG_COMPAT
static long process_tlogger_compat_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
tlogd("logger_compat_ioctl ++\n");
arg = (unsigned long)(uintptr_t)compat_ptr(arg);
return process_tlogger_ioctl(file, cmd, arg);
}
#endif
static const struct file_operations g_logger_fops = {
.owner = THIS_MODULE,
.read = process_tlogger_read,
.poll = process_tlogger_poll,
.unlocked_ioctl = process_tlogger_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = process_tlogger_compat_ioctl,
#endif
.open = process_tlogger_open,
.release = process_tlogger_release,
};
static int __init register_device(const char *log_name,
uintptr_t addr, int size)
{
int ret;
struct tlogger_log *log = NULL;
unsigned char *buffer = (unsigned char *)addr;
(void)size;
log = kzalloc(sizeof(*log), GFP_KERNEL);
if (ZERO_OR_NULL_PTR((unsigned long)(uintptr_t)log)) {
tloge("kzalloc is failed\n");
return -ENOMEM;
}
log->buffer_info = buffer;
log->misc_device.minor = MISC_DYNAMIC_MINOR;
log->misc_device.name = kstrdup(log_name, GFP_KERNEL);
if (!log->misc_device.name) {
ret = -ENOMEM;
tloge("kstrdup is failed\n");
goto out_free_log;
}
log->misc_device.fops = &g_logger_fops;
log->misc_device.parent = NULL;
init_waitqueue_head(&log->wait_queue_head);
INIT_LIST_HEAD(&log->readers);
mutex_init(&log->mutex_info);
INIT_LIST_HEAD(&log->logs);
list_add_tail(&log->logs, &m_log_list);
ret = misc_register(&log->misc_device);
if (unlikely(ret)) {
tloge("failed to register misc device:%s\n",
log->misc_device.name);
goto out_free_log;
}
g_log = log;
return 0;
out_free_log:
if (log->misc_device.name)
kfree(log->misc_device.name);
kfree(log);
return ret;
}
static struct log_item *msg_get_next(unsigned char *buffer_start,
uint32_t read_pos, uint32_t scope_len, uint32_t max_len)
{
uint32_t i = 0;
struct log_item *item = NULL;
uint32_t item_max_size;
uint32_t len;
while (i <= scope_len &&
((read_pos + i + sizeof(*item)) < max_len)) {
len = (uint32_t)(scope_len - i);
item_max_size =
((len > LOG_ITEM_MAX_LEN) ? LOG_ITEM_MAX_LEN : len);
item = (struct log_item *)(buffer_start + read_pos + i);
if (check_log_item_validite(item, item_max_size)) {
if ((read_pos + i + sizeof(*item) +
item->buffer_len) > max_len) {
tloge("check item len error\n");
return NULL;
}
return item;
}
i += LOG_ITEM_LEN_ALIGN;
item = NULL;
}
return NULL;
}
#ifdef CONFIG_TZDRIVER_MODULE
static int tlogger_chown(const char *file_path, uint32_t file_path_len)
{
(void)file_path;
(void)file_path_len;
return 0;
}
#else
static int tlogger_chown(const char *file_path, uint32_t file_path_len)
{
(void)file_path_len;
uid_t user = ROOT_UID;
gid_t group = ROOT_GID;
int ret;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0))
mm_segment_t old_fs;
#endif
get_log_chown(&user, &group);
if (group == ROOT_GID && user == ROOT_UID)
return 0;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0))
old_fs = get_fs();
set_fs(KERNEL_DS);
#endif
#if (KERNEL_VERSION(5, 4, 0) <= LINUX_VERSION_CODE)
ret = (int)ksys_chown((const char __user *)file_path, user, group);
#else
ret = (int)sys_chown((const char __user *)file_path, user, group);
#endif
if (ret != 0) {
tloge("sys chown for last teemsg file error\n");
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0))
set_fs(old_fs);
#endif
return -1;
}
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0))
set_fs(old_fs);
#endif
return 0;
}
#endif
static int write_version_to_msg(struct file *filep,
loff_t *pos)
{
ssize_t write_len;
write_len = kernel_write(filep, g_log_buffer->flag.version_info,
strlen(g_log_buffer->flag.version_info), pos);
if (write_len < 0) {
tloge("Failed to write to last teemsg version\n");
return -1;
}
tlogd("Succeed to Write to last teemsg version, len=%zd\n", write_len);
return 0;
}
static int write_part_log_to_msg(struct file *filep,
unsigned char *buffer, uint32_t buffer_max_len, loff_t *pos,
uint32_t read_off, uint32_t read_off_end)
{
struct log_item *next_item = NULL;
uint32_t item_len;
uint32_t total_len = 0;
ssize_t write_len;
next_item = msg_get_next(buffer, read_off,
LOG_ITEM_MAX_LEN, buffer_max_len);
while (next_item && read_off <= read_off_end) {
item_len = next_item->buffer_len + sizeof(*next_item);
write_len = kernel_write(filep, next_item->log_buffer,
next_item->real_len, pos);
if (write_len < 0) {
tloge("Failed to write last teemsg %zd\n", write_len);
return -1;
}
tlogd("Succeed to Write last teemsg, len=%zd\n", write_len);
total_len += item_len;
read_off = (unsigned char *)next_item - buffer + item_len;
if (total_len >= buffer_max_len)
break;
next_item = msg_get_next(buffer, read_off,
LOG_ITEM_MAX_LEN, buffer_max_len);
}
return 0;
}
static int write_log_to_msg(struct file *filep,
unsigned char *buffer, uint32_t buffer_max_len, loff_t *pos,
uint32_t read_off, uint32_t read_off_end)
{
if (read_off < read_off_end) {
return write_part_log_to_msg(filep, buffer, buffer_max_len, pos,
read_off, read_off_end);
} else {
if (write_part_log_to_msg(filep, buffer, buffer_max_len, pos,
read_off, buffer_max_len) != 0)
return -1;
return write_part_log_to_msg(filep, buffer, buffer_max_len, pos,
0, read_off_end);
}
}
#ifdef CONFIG_TEE_LOG_DUMP_PATH
static void update_dumpmsg_offset(uint32_t *read_start, uint32_t *read_end,
uint32_t read_off, uint32_t read_off_end, uint32_t *dump_start_flag, uint32_t *dump_end_flag)
{
struct log_item *next_item = NULL;
unsigned char *buffer = g_log_buffer->buffer_start;
uint32_t buffer_max_len = g_log_mem_len - sizeof(*g_log_buffer);
ssize_t item_len;
ssize_t total_len = 0;
next_item = msg_get_next(buffer, read_off,
LOG_ITEM_MAX_LEN, buffer_max_len);
while (next_item && read_off <= read_off_end) {
item_len = next_item->buffer_len + sizeof(*next_item);
if (strstr(next_item->log_buffer, DUMP_START_MAGIC)) {
*read_start = read_off;
*dump_start_flag = 1;
} else if (strstr(next_item->log_buffer, DUMP_END_MAGIC)) {
*read_end = read_off;
*dump_end_flag = 1;
}
read_off = (unsigned char *)next_item - buffer + item_len;
total_len += item_len;
if (total_len >= buffer_max_len)
break;
next_item = msg_get_next(buffer, read_off,
LOG_ITEM_MAX_LEN, buffer_max_len);
}
}
#endif
#ifdef CONFIG_TEE_LOG_DUMP_PATH
static int get_dumpmsg_offset(uint32_t *read_start, uint32_t *read_end)
{
uint32_t read_off = *read_start;
uint32_t read_off_end = *read_end;
uint32_t buffer_max_len = g_log_mem_len - sizeof(*g_log_buffer);
uint32_t dump_start_flag = 0;
uint32_t dump_end_flag = 0;
if (read_off < read_off_end) {
update_dumpmsg_offset(read_start, read_end, read_off, read_off_end,
&dump_start_flag, &dump_end_flag);
} else {
update_dumpmsg_offset(read_start, read_end, read_off, buffer_max_len,
&dump_start_flag, &dump_end_flag);
update_dumpmsg_offset(read_start, read_end, 0, read_off_end,
&dump_start_flag, &dump_end_flag);
}
if (dump_start_flag == 0 || dump_end_flag == 0) {
tloge("can't find dump start or end\n");
return -1;
} else {
return 0;
}
}
#endif
static int get_msg_buffer(unsigned char **buffer, uint32_t *buffer_max_len,
uint32_t *read_start, uint32_t *read_end,
const char *file_path, uint32_t file_path_len)
{
errno_t rc;
int ret;
unsigned char *addr = NULL;
(void)file_path_len;
if (!g_log_buffer)
return -1;
*buffer_max_len = g_log_mem_len - sizeof(*g_log_buffer);
if (*buffer_max_len > LOG_BUFFER_MAX_LEN)
return 0;
*read_start = 0;
*read_end = *buffer_max_len;
#ifdef CONFIG_TEE_LOG_DUMP_PATH
if (strcmp(file_path, CONFIG_TEE_LOG_DUMP_PATH) == 0) {
*read_start = g_last_read_offset;
*read_end = ((struct log_buffer*)g_log->buffer_info)->flag.last_pos;
if (get_dumpmsg_offset(read_start, read_end) != 0) {
tloge("get dump offset failed\n");
return -1;
}
}
#else
(void)file_path;
#endif
addr = kmalloc(*buffer_max_len, GFP_KERNEL);
if (ZERO_OR_NULL_PTR((unsigned long)(uintptr_t)addr)) {
ret = -ENOMEM;
goto free_res;
}
rc = memcpy_s(addr, *buffer_max_len, g_log_buffer->buffer_start,
*buffer_max_len);
if (rc) {
tloge("memcpy failed %d\n", rc);
ret = -EAGAIN;
goto free_res;
}
*buffer = addr;
return 0;
free_res:
if (addr)
kfree(addr);
return ret;
}
static int open_msg_file(struct file **file,
const char *file_path, uint32_t file_path_len)
{
struct file *filep = NULL;
(void)file_path_len;
filep = filp_open(file_path, O_CREAT | O_RDWR | O_TRUNC, OPEN_FILE_MODE);
if (!filep || IS_ERR(filep)) {
tloge("open last teemsg file err %ld\n", PTR_ERR(filep));
return -1;
}
*file = filep;
return 0;
}
int tlogger_store_msg(const char *file_path, uint32_t file_path_len)
{
struct file *filep = NULL;
loff_t pos = 0;
int ret;
uint32_t buffer_max_len = 0;
unsigned char *buffer = NULL;
uint32_t read_start = 0;
uint32_t read_end = 0;
if (!file_path || file_path_len > TEE_LOG_FILE_NAME_MAX) {
tloge("file path is invalid\n");
return -1;
}
if (!g_tlogcat_count) {
tlogd("tlogcat count %u\n", g_tlogcat_count);
return 0;
}
ret = get_msg_buffer(&buffer, &buffer_max_len,
&read_start, &read_end, file_path, file_path_len);
if (ret != 0)
return ret;
ret = open_msg_file(&filep, file_path, file_path_len);
if (ret != 0)
goto free_res;
ret = tlogger_chown(file_path, file_path_len);
if (ret != 0)
goto free_res;
ret = write_version_to_msg(filep, &pos);
if (ret != 0)
goto free_res;
ret = write_log_to_msg(filep, buffer, buffer_max_len,
&pos, read_start, read_end);
free_res:
if (buffer) {
kfree(buffer);
buffer = NULL;
}
if (filep != NULL) {
vfs_fsync(filep, 0);
filp_close(filep, 0);
}
tz_log_write();
return ret;
}
#ifdef DEF_ENG
#define KERNEL_IMG_IS_ENG 1
#endif
int register_mem_to_teeos(uint64_t mem_addr, uint32_t mem_len, bool is_cache_mem)
{
struct tc_ns_smc_cmd smc_cmd = { {0}, 0 };
struct mb_cmd_pack *mb_pack = NULL;
int ret;
mb_pack = mailbox_alloc_cmd_pack();
if (!mb_pack) {
tloge("mailbox alloc failed\n");
return -ENOMEM;
}
smc_cmd.cmd_type = CMD_TYPE_GLOBAL;
smc_cmd.cmd_id = GLOBAL_CMD_ID_REGISTER_LOG_MEM;
mb_pack->operation.paramtypes = teec_param_types(
TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_NONE);
mb_pack->operation.params[0].value.a = mem_addr;
mb_pack->operation.params[0].value.b = mem_addr >> ADDR_TRANS_NUM;
mb_pack->operation.params[1].value.a = mem_len;
#ifdef DEF_ENG
mb_pack->operation.params[1].value.b = KERNEL_IMG_IS_ENG;
#endif
* is_cache_mem: true, teeos map this memory for cache
* style; or else map to no cache style
*/
mb_pack->operation.params[2].value.a = is_cache_mem;
smc_cmd.operation_phys = mailbox_virt_to_phys((uintptr_t)&mb_pack->operation);
smc_cmd.operation_h_phys =
(uint64_t)mailbox_virt_to_phys((uintptr_t)&mb_pack->operation) >> ADDR_TRANS_NUM;
if (is_tee_rebooting())
ret = send_smc_cmd_rebooting(TSP_REQUEST, 0, 0, &smc_cmd);
else
ret = tc_ns_smc(&smc_cmd);
mailbox_free(mb_pack);
if (ret != 0)
tloge("Send log mem info failed\n");
return ret;
}
static int register_mem_cfg(uint64_t *addr, uint32_t *len)
{
int ret;
ret = register_log_mem(addr, len);
if (ret != 0)
tloge("register log mem failed %x\n", ret);
ret = register_log_exception();
if (ret != 0)
tloge("teeos register exception to log module failed\n");
return ret;
}
static int check_log_mem(uint64_t mem_addr, uint32_t mem_len)
{
if (mem_len < TEMP_LOG_MEM_SIZE) {
tloge("log mem init error, too small len:0x%x\n", mem_len);
return -1;
}
if (!mem_addr) {
tloge("mem init failed!!! addr is 0\n");
return -1;
}
return 0;
}
int register_tloger_mem(void)
{
int ret;
uint64_t mem_addr = 0;
ret = register_mem_cfg(&mem_addr, &g_log_mem_len);
if (ret != 0)
return ret;
ret = check_log_mem(mem_addr, g_log_mem_len);
if (ret != 0)
return ret;
g_log_buffer =
(struct log_buffer *)map_log_mem(mem_addr, g_log_mem_len);
if (!g_log_buffer)
return -ENOMEM;
g_log_buffer->flag.max_len = g_log_mem_len - sizeof(*g_log_buffer);
return ret;
}
static int register_tloger_device(void)
{
int ret;
tlogi("tlogcat version 1.0.0\n");
ret = register_device(LOGGER_LOG_TEEOS, (uintptr_t)g_log_buffer,
sizeof(*g_log_buffer) + g_log_buffer->flag.max_len);
if (ret != 0) {
unmap_log_mem((int *)g_log_buffer);
g_log_buffer = NULL;
g_log_mem_len = 0;
}
return ret;
}
static int register_tloger(void)
{
int ret;
ret = register_tloger_mem();
if (ret != 0)
return ret;
#ifdef CONFIG_LOG_POOL
ret = init_log_pool();
if (ret != 0)
tloge("init_log_pool init failed\n");
#endif
ret = register_tloger_device();
return ret;
}
static void unregister_mem_cfg(void)
{
if (g_log_buffer)
unmap_log_mem((int *)g_log_buffer);
unregister_log_exception();
}
static void unregister_tlogger(void)
{
struct tlogger_log *current_log = NULL;
struct tlogger_log *next_log = NULL;
list_for_each_entry_safe(current_log, next_log, &m_log_list, logs) {
misc_deregister(¤t_log->misc_device);
kfree(current_log->misc_device.name);
list_del(¤t_log->logs);
kfree(current_log);
}
#ifdef CONFIG_LOG_POOL
free_log_pool();
#endif
unregister_mem_cfg();
g_log_buffer = NULL;
g_log_mem_len = 0;
}
#ifdef CONFIG_TZDRIVER_MODULE
int init_tlogger_service(void)
{
return register_tloger();
}
void free_tlogger_service(void)
{
unregister_tlogger();
}
#else
static int __init init_tlogger_service(void)
{
return register_tloger();
}
static void __exit free_tlogger_service(void)
{
unregister_tlogger();
}
#endif
#ifdef CONFIG_TZDRIVER
device_initcall(init_tlogger_service);
module_exit(free_tlogger_service);
MODULE_AUTHOR("iTrustee");
MODULE_DESCRIPTION("TrustCore Logger");
MODULE_VERSION("1.00");
#endif
