1
0
mirror of https://github.com/topjohnwu/Magisk.git synced 2024-12-21 07:27:38 +00:00

195 lines
4.7 KiB
C++
Raw Normal View History

2021-08-12 03:26:54 -07:00
#include <sys/uio.h>
#include <android/log.h>
#include <magisk.hpp>
#include <utils.hpp>
#include <daemon.hpp>
#include <stream.hpp>
#include "core.hpp"
using namespace std;
struct log_meta {
int prio;
int len;
int pid;
int tid;
};
2021-08-21 03:52:59 -07:00
atomic<int> logd_fd = -1;
2021-08-12 03:26:54 -07:00
void setup_logfile(bool reset) {
if (logd_fd < 0)
return;
iovec iov{};
log_meta meta = {
.prio = -1,
.len = reset
};
iov.iov_base = &meta;
iov.iov_len = sizeof(meta);
writev(logd_fd, &iov, 1);
}
// Maximum message length for pipes to transfer atomically
#define MAX_MSG_LEN (PIPE_BUF - sizeof(log_meta))
2021-10-09 11:36:01 -07:00
static void *logfile_writer(void *arg) {
int pipefd = (long) arg;
2021-09-19 13:41:45 -07:00
run_finally close_pipes([=] {
2021-08-12 03:26:54 -07:00
// Close up all logging pipes when thread dies
close(pipefd);
close(logd_fd.exchange(-1));
});
struct {
void *data;
size_t len;
2021-09-19 13:41:45 -07:00
} tmp{};
stream_ptr strm = make_unique<byte_stream>(tmp.data, tmp.len);
bool switched = false;
2021-08-12 03:26:54 -07:00
log_meta meta{};
2021-08-13 02:08:56 -07:00
char buf[MAX_MSG_LEN];
char aux[64];
iovec iov[2];
iov[0].iov_base = aux;
iov[1].iov_base = buf;
2021-08-12 03:26:54 -07:00
for (;;) {
// Read meta data
2021-09-19 13:41:45 -07:00
if (read(pipefd, &meta, sizeof(meta)) != sizeof(meta))
2021-10-09 11:36:01 -07:00
return nullptr;
2021-08-12 03:26:54 -07:00
2021-09-19 13:41:45 -07:00
if (meta.prio < 0) {
if (!switched) {
run_finally free_tmp([&] {
free(tmp.data);
tmp.data = nullptr;
tmp.len = 0;
});
2021-08-12 03:26:54 -07:00
rename(LOGFILE, LOGFILE ".bak");
2021-09-19 13:41:45 -07:00
int fd = open(LOGFILE, O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC, 0644);
if (fd < 0)
2021-10-09 11:36:01 -07:00
return nullptr;
2021-09-19 13:41:45 -07:00
if (tmp.data)
write(fd, tmp.data, tmp.len);
strm = make_unique<fd_stream>(fd);
switched = true;
}
2021-08-12 03:26:54 -07:00
continue;
}
2021-08-13 02:08:56 -07:00
// Read message
2021-09-19 13:41:45 -07:00
if (read(pipefd, buf, meta.len) != meta.len)
2021-10-09 11:36:01 -07:00
return nullptr;
2021-08-13 02:08:56 -07:00
2021-08-12 03:26:54 -07:00
timeval tv;
tm tm;
gettimeofday(&tv, nullptr);
localtime_r(&tv.tv_sec, &tm);
// Format detailed info
char type;
switch (meta.prio) {
case ANDROID_LOG_DEBUG:
type = 'D';
break;
case ANDROID_LOG_INFO:
type = 'I';
break;
case ANDROID_LOG_WARN:
type = 'W';
break;
default:
type = 'E';
break;
}
2021-09-19 13:41:45 -07:00
long ms = tv.tv_usec / 1000;
2021-08-13 02:08:56 -07:00
size_t off = strftime(aux, sizeof(aux), "%m-%d %T", &tm);
off += snprintf(aux + off, sizeof(aux) - off,
2021-09-19 13:41:45 -07:00
".%03ld %5d %5d %c : ", ms, meta.pid, meta.tid, type);
2021-08-12 03:26:54 -07:00
2021-08-13 02:08:56 -07:00
iov[0].iov_len = off;
iov[1].iov_len = meta.len;
2021-08-13 00:13:44 -07:00
2021-08-13 02:08:56 -07:00
strm->writev(iov, 2);
2021-08-12 03:26:54 -07:00
}
}
2021-08-21 03:52:59 -07:00
int magisk_log(int prio, const char *fmt, va_list ap) {
2021-08-12 03:26:54 -07:00
char buf[MAX_MSG_LEN + 1];
int len = vsnprintf(buf, sizeof(buf), fmt, ap);
if (logd_fd >= 0) {
log_meta meta = {
.prio = prio,
.len = len,
.pid = getpid(),
.tid = gettid()
};
iovec iov[2];
iov[0].iov_base = &meta;
iov[0].iov_len = sizeof(meta);
iov[1].iov_base = buf;
iov[1].iov_len = len;
if (writev(logd_fd, iov, 2) < 0) {
// Stop trying to write to file
close(logd_fd.exchange(-1));
}
}
__android_log_write(prio, "Magisk", buf);
return len;
}
2021-08-21 00:58:51 -07:00
// Used to override external C library logging
extern "C" int magisk_log_print(int prio, const char *tag, const char *fmt, ...) {
char buf[4096];
auto len = strlcpy(buf, tag, sizeof(buf));
// Prevent format specifications in the tag
std::replace(buf, buf + len, '%', '_');
snprintf(buf + len, sizeof(buf) - len, ": %s", fmt);
va_list argv;
va_start(argv, fmt);
int ret = magisk_log(prio, buf, argv);
va_end(argv);
return ret;
}
2021-08-12 03:26:54 -07:00
#define mlog(prio) [](auto fmt, auto ap){ return magisk_log(ANDROID_LOG_##prio, fmt, ap); }
void magisk_logging() {
log_cb.d = mlog(DEBUG);
log_cb.i = mlog(INFO);
log_cb.w = mlog(WARN);
log_cb.e = mlog(ERROR);
log_cb.ex = nop_ex;
}
2021-08-21 03:52:59 -07:00
#define alog(prio) [](auto fmt, auto ap){ return __android_log_vprint(ANDROID_LOG_##prio, "Magisk", fmt, ap); }
void android_logging() {
log_cb.d = alog(DEBUG);
log_cb.i = alog(INFO);
log_cb.w = alog(WARN);
log_cb.e = alog(ERROR);
log_cb.ex = nop_ex;
}
2021-08-12 03:26:54 -07:00
void start_log_daemon() {
int fds[2];
if (pipe2(fds, O_CLOEXEC) == 0) {
logd_fd = fds[1];
2021-10-09 11:36:01 -07:00
long fd = fds[0];
new_daemon_thread(logfile_writer, (void *) fd);
2021-08-12 03:26:54 -07:00
}
}