ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

*: Use fprintf between qemu_log_trylock/unlock 

Inside qemu_log, we perform qemu_log_trylock/unlock, which need
not be done if we have already performed the lock beforehand.

Always check the result of qemu_log_trylock -- only checking
qemu_loglevel_mask races with the acquisition of the lock on
the logfile.

Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220417183019.755276-10-richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2022-04-17 11:29:49 -07:00
parent 6fef222971
commit 78b548583e
9 changed files with 162 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
accel/tcg/cpu-exec.c
View File

@ -215,6 +215,7 @@ static inline void log_cpu_exec(target_ulong pc, CPUState *cpu,
#if defined(DEBUG_DISAS) #if defined(DEBUG_DISAS)
if (qemu_loglevel_mask(CPU_LOG_TB_CPU)) { if (qemu_loglevel_mask(CPU_LOG_TB_CPU)) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
if (logfile) {
int flags = 0; int flags = 0;
if (qemu_loglevel_mask(CPU_LOG_TB_FPU)) { if (qemu_loglevel_mask(CPU_LOG_TB_FPU)) {
@ -226,6 +227,7 @@ static inline void log_cpu_exec(target_ulong pc, CPUState *cpu,
log_cpu_state(cpu, flags); log_cpu_state(cpu, flags);
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif /* DEBUG_DISAS */ #endif /* DEBUG_DISAS */
} }
} }

29
accel/tcg/translate-all.c
View File

@ -1528,6 +1528,7 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM) && if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM) &&
qemu_log_in_addr_range(tb->pc)) { qemu_log_in_addr_range(tb->pc)) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
if (logfile) {
int code_size, data_size; int code_size, data_size;
const tcg_target_ulong *rx_data_gen_ptr; const tcg_target_ulong *rx_data_gen_ptr;
size_t chunk_start; size_t chunk_start;
@ -1544,11 +1545,12 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
} }
/* Dump header and the first instruction */ /* Dump header and the first instruction */
qemu_log("OUT: [size=%d]\n", gen_code_size); fprintf(logfile, "OUT: [size=%d]\n", gen_code_size);
qemu_log(" -- guest addr 0x" TARGET_FMT_lx " + tb prologue\n", fprintf(logfile,
" -- guest addr 0x" TARGET_FMT_lx " + tb prologue\n",
tcg_ctx->gen_insn_data[insn][0]); tcg_ctx->gen_insn_data[insn][0]);
chunk_start = tcg_ctx->gen_insn_end_off[insn]; chunk_start = tcg_ctx->gen_insn_end_off[insn];
log_disas(tb->tc.ptr, chunk_start); disas(logfile, tb->tc.ptr, chunk_start);
/* /*
* Dump each instruction chunk, wrapping up empty chunks into * Dump each instruction chunk, wrapping up empty chunks into
@ -1558,39 +1560,44 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
while (insn < tb->icount) { while (insn < tb->icount) {
size_t chunk_end = tcg_ctx->gen_insn_end_off[insn]; size_t chunk_end = tcg_ctx->gen_insn_end_off[insn];
if (chunk_end > chunk_start) { if (chunk_end > chunk_start) {
qemu_log(" -- guest addr 0x" TARGET_FMT_lx "\n", fprintf(logfile, " -- guest addr 0x" TARGET_FMT_lx "\n",
tcg_ctx->gen_insn_data[insn][0]); tcg_ctx->gen_insn_data[insn][0]);
log_disas(tb->tc.ptr + chunk_start, chunk_end - chunk_start); disas(logfile, tb->tc.ptr + chunk_start,
chunk_end - chunk_start);
chunk_start = chunk_end; chunk_start = chunk_end;
} }
insn++; insn++;
} }
if (chunk_start < code_size) { if (chunk_start < code_size) {
qemu_log(" -- tb slow paths + alignment\n"); fprintf(logfile, " -- tb slow paths + alignment\n");
log_disas(tb->tc.ptr + chunk_start, code_size - chunk_start); disas(logfile, tb->tc.ptr + chunk_start,
code_size - chunk_start);
} }
/* Finally dump any data we may have after the block */ /* Finally dump any data we may have after the block */
if (data_size) { if (data_size) {
int i; int i;
qemu_log(" data: [size=%d]\n", data_size); fprintf(logfile, " data: [size=%d]\n", data_size);
for (i = 0; i < data_size / sizeof(tcg_target_ulong); i++) { for (i = 0; i < data_size / sizeof(tcg_target_ulong); i++) {
if (sizeof(tcg_target_ulong) == 8) { if (sizeof(tcg_target_ulong) == 8) {
qemu_log("0x%08" PRIxPTR ": .quad 0x%016" TCG_PRIlx "\n", fprintf(logfile,
"0x%08" PRIxPTR ": .quad 0x%016" TCG_PRIlx "\n",
(uintptr_t)&rx_data_gen_ptr[i], rx_data_gen_ptr[i]); (uintptr_t)&rx_data_gen_ptr[i], rx_data_gen_ptr[i]);
} else if (sizeof(tcg_target_ulong) == 4) { } else if (sizeof(tcg_target_ulong) == 4) {
qemu_log("0x%08" PRIxPTR ": .long 0x%08" TCG_PRIlx "\n", fprintf(logfile,
"0x%08" PRIxPTR ": .long 0x%08" TCG_PRIlx "\n",
(uintptr_t)&rx_data_gen_ptr[i], rx_data_gen_ptr[i]); (uintptr_t)&rx_data_gen_ptr[i], rx_data_gen_ptr[i]);
} else { } else {
qemu_build_not_reached(); qemu_build_not_reached();
} }
} }
} }
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_flush(); qemu_log_flush();
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif #endif
qatomic_set(&tcg_ctx->code_gen_ptr, (void *) qatomic_set(&tcg_ctx->code_gen_ptr, (void *)

6
accel/tcg/translator.c
View File

@ -140,11 +140,13 @@ void translator_loop(const TranslatorOps *ops, DisasContextBase *db,
if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)
&& qemu_log_in_addr_range(db->pc_first)) { && qemu_log_in_addr_range(db->pc_first)) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("----------------\n"); if (logfile) {
fprintf(logfile, "----------------\n");
ops->disas_log(db, cpu); ops->disas_log(db, cpu);
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif #endif
} }

10
cpu.c
View File

@ -400,12 +400,14 @@ void cpu_abort(CPUState *cpu, const char *fmt, ...)
cpu_dump_state(cpu, stderr, CPU_DUMP_FPU | CPU_DUMP_CCOP); cpu_dump_state(cpu, stderr, CPU_DUMP_FPU | CPU_DUMP_CCOP);
if (qemu_log_separate()) { if (qemu_log_separate()) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("qemu: fatal: "); if (logfile) {
qemu_log_vprintf(fmt, ap2); fprintf(logfile, "qemu: fatal: ");
qemu_log("\n"); vfprintf(logfile, fmt, ap2);
log_cpu_state(cpu, CPU_DUMP_FPU | CPU_DUMP_CCOP); fprintf(logfile, "\n");
cpu_dump_state(cpu, logfile, CPU_DUMP_FPU | CPU_DUMP_CCOP);
qemu_log_flush(); qemu_log_flush();
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
}
qemu_log_close(); qemu_log_close();
} }
va_end(ap2); va_end(ap2);

8
hw/net/can/can_sja1000.c
View File

@ -249,7 +249,8 @@ static void can_display_msg(const char *prefix, const qemu_can_frame *msg)
int i; int i;
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("%s%03X [%01d] %s %s", if (logfile) {
fprintf(logfile, "%s%03X [%01d] %s %s",
prefix, prefix,
msg->can_id & QEMU_CAN_EFF_MASK, msg->can_id & QEMU_CAN_EFF_MASK,
msg->can_dlc, msg->can_dlc,
@ -257,11 +258,12 @@ static void can_display_msg(const char *prefix, const qemu_can_frame *msg)
msg->can_id & QEMU_CAN_RTR_FLAG ? "RTR" : "DAT"); msg->can_id & QEMU_CAN_RTR_FLAG ? "RTR" : "DAT");
for (i = 0; i < msg->can_dlc; i++) { for (i = 0; i < msg->can_dlc; i++) {
qemu_log(" %02X", msg->data[i]); fprintf(logfile, " %02X", msg->data[i]);
} }
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_flush(); qemu_log_flush();
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
}
} }
static void buff2frame_pel(const uint8_t *buff, qemu_can_frame *frame) static void buff2frame_pel(const uint8_t *buff, qemu_can_frame *frame)

2
include/exec/log.h
View File

@ -73,7 +73,7 @@ static inline void log_page_dump(const char *operation)
{ {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
if (logfile) { if (logfile) {
qemu_log("page layout changed following %s\n", operation); fprintf(logfile, "page layout changed following %s\n", operation);
page_dump(logfile); page_dump(logfile);
} }
qemu_log_unlock(logfile); qemu_log_unlock(logfile);

9
net/can/can_socketcan.c
View File

@ -77,18 +77,21 @@ static void can_host_socketcan_display_msg(struct qemu_can_frame *msg)
{ {
int i; int i;
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("[cansocketcan]: %03X [%01d] %s %s",
if (logfile) {
fprintf(logfile, "[cansocketcan]: %03X [%01d] %s %s",
msg->can_id & QEMU_CAN_EFF_MASK, msg->can_id & QEMU_CAN_EFF_MASK,
msg->can_dlc, msg->can_dlc,
msg->can_id & QEMU_CAN_EFF_FLAG ? "EFF" : "SFF", msg->can_id & QEMU_CAN_EFF_FLAG ? "EFF" : "SFF",
msg->can_id & QEMU_CAN_RTR_FLAG ? "RTR" : "DAT"); msg->can_id & QEMU_CAN_RTR_FLAG ? "RTR" : "DAT");
for (i = 0; i < msg->can_dlc; i++) { for (i = 0; i < msg->can_dlc; i++) {
qemu_log(" %02X", msg->data[i]); fprintf(logfile, " %02X", msg->data[i]);
} }
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_flush(); qemu_log_flush();
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
}
} }
static void can_host_socketcan_read(void *opaque) static void can_host_socketcan_read(void *opaque)

8
target/i386/tcg/translate.c
View File

@ -2581,15 +2581,17 @@ static void gen_unknown_opcode(CPUX86State *env, DisasContext *s)
if (qemu_loglevel_mask(LOG_UNIMP)) { if (qemu_loglevel_mask(LOG_UNIMP)) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
if (logfile) {
target_ulong pc = s->pc_start, end = s->pc; target_ulong pc = s->pc_start, end = s->pc;
qemu_log("ILLOPC: " TARGET_FMT_lx ":", pc); fprintf(logfile, "ILLOPC: " TARGET_FMT_lx ":", pc);
for (; pc < end; ++pc) { for (; pc < end; ++pc) {
qemu_log(" %02x", cpu_ldub_code(env, pc)); fprintf(logfile, " %02x", cpu_ldub_code(env, pc));
} }
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
} }
/* an interrupt is different from an exception because of the /* an interrupt is different from an exception because of the

34
tcg/tcg.c
View File

@ -757,32 +757,36 @@ void tcg_prologue_init(TCGContext *s)
#ifdef DEBUG_DISAS #ifdef DEBUG_DISAS
if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("PROLOGUE: [size=%zu]\n", prologue_size); if (logfile) {
fprintf(logfile, "PROLOGUE: [size=%zu]\n", prologue_size);
if (s->data_gen_ptr) { if (s->data_gen_ptr) {
size_t code_size = s->data_gen_ptr - s->code_gen_ptr; size_t code_size = s->data_gen_ptr - s->code_gen_ptr;
size_t data_size = prologue_size - code_size; size_t data_size = prologue_size - code_size;
size_t i; size_t i;
log_disas(s->code_gen_ptr, code_size); disas(logfile, s->code_gen_ptr, code_size);
for (i = 0; i < data_size; i += sizeof(tcg_target_ulong)) { for (i = 0; i < data_size; i += sizeof(tcg_target_ulong)) {
if (sizeof(tcg_target_ulong) == 8) { if (sizeof(tcg_target_ulong) == 8) {
qemu_log("0x%08" PRIxPTR ": .quad 0x%016" PRIx64 "\n", fprintf(logfile,
"0x%08" PRIxPTR ": .quad 0x%016" PRIx64 "\n",
(uintptr_t)s->data_gen_ptr + i, (uintptr_t)s->data_gen_ptr + i,
*(uint64_t *)(s->data_gen_ptr + i)); *(uint64_t *)(s->data_gen_ptr + i));
} else { } else {
qemu_log("0x%08" PRIxPTR ": .long 0x%08x\n", fprintf(logfile,
"0x%08" PRIxPTR ": .long 0x%08x\n",
(uintptr_t)s->data_gen_ptr + i, (uintptr_t)s->data_gen_ptr + i,
*(uint32_t *)(s->data_gen_ptr + i)); *(uint32_t *)(s->data_gen_ptr + i));
} }
} }
} else { } else {
log_disas(s->code_gen_ptr, prologue_size); disas(logfile, s->code_gen_ptr, prologue_size);
} }
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_flush(); qemu_log_flush();
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif #endif
#ifndef CONFIG_TCG_INTERPRETER #ifndef CONFIG_TCG_INTERPRETER
@ -4201,11 +4205,13 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb)
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP) if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)
&& qemu_log_in_addr_range(tb->pc))) { && qemu_log_in_addr_range(tb->pc))) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("OP:\n"); if (logfile) {
fprintf(logfile, "OP:\n");
tcg_dump_ops(s, false); tcg_dump_ops(s, false);
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif #endif
#ifdef CONFIG_DEBUG_TCG #ifdef CONFIG_DEBUG_TCG
@ -4246,11 +4252,13 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb)
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_IND) if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_IND)
&& qemu_log_in_addr_range(tb->pc))) { && qemu_log_in_addr_range(tb->pc))) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("OP before indirect lowering:\n"); if (logfile) {
fprintf(logfile, "OP before indirect lowering:\n");
tcg_dump_ops(s, false); tcg_dump_ops(s, false);
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif #endif
/* Replace indirect temps with direct temps. */ /* Replace indirect temps with direct temps. */
if (liveness_pass_2(s)) { if (liveness_pass_2(s)) {
@ -4267,11 +4275,13 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb)
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT) if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT)
&& qemu_log_in_addr_range(tb->pc))) { && qemu_log_in_addr_range(tb->pc))) {
FILE *logfile = qemu_log_trylock(); FILE *logfile = qemu_log_trylock();
qemu_log("OP after optimization and liveness analysis:\n"); if (logfile) {
fprintf(logfile, "OP after optimization and liveness analysis:\n");
tcg_dump_ops(s, true); tcg_dump_ops(s, true);
qemu_log("\n"); fprintf(logfile, "\n");
qemu_log_unlock(logfile); qemu_log_unlock(logfile);
} }
}
#endif #endif
tcg_reg_alloc_start(s); tcg_reg_alloc_start(s);