void iwl_dump_nic_error_log(struct iwl_priv *priv)
{
u32 data2, line;
u32 desc, time, count, base, data1;
u32 blink1, blink2, ilink1, ilink2;
int ret;
if (priv->ucode_type == UCODE_INIT)
base = le32_to_cpu(priv->card_alive_init.error_event_table_ptr);
else
base = le32_to_cpu(priv->card_alive.error_event_table_ptr);
if (!priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
IWL_ERROR("Not valid error log pointer 0x%08X\n", base);
return;
}
ret = iwl_grab_nic_access(priv);
if (ret) {
IWL_WARNING("Can not read from adapter at this time.\n");
return;
}
count = iwl_read_targ_mem(priv, base);
if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
IWL_ERROR("Start IWL Error Log Dump:\n");
IWL_ERROR("Status: 0x%08lX, count: %d\n", priv->status, count);
}
desc = iwl_read_targ_mem(priv, base + 1 * sizeof(u32));
blink1 = iwl_read_targ_mem(priv, base + 3 * sizeof(u32));
blink2 = iwl_read_targ_mem(priv, base + 4 * sizeof(u32));
ilink1 = iwl_read_targ_mem(priv, base + 5 * sizeof(u32));
ilink2 = iwl_read_targ_mem(priv, base + 6 * sizeof(u32));
data1 = iwl_read_targ_mem(priv, base + 7 * sizeof(u32));
data2 = iwl_read_targ_mem(priv, base + 8 * sizeof(u32));
line = iwl_read_targ_mem(priv, base + 9 * sizeof(u32));
time = iwl_read_targ_mem(priv, base + 11 * sizeof(u32));
IWL_ERROR("Desc Time "
"data1 data2 line\n");
IWL_ERROR("%-13s (#%d) %010u 0x%08X 0x%08X %u\n",
desc_lookup(desc), desc, time, data1, data2, line);
IWL_ERROR("blink1 blink2 ilink1 ilink2\n");
IWL_ERROR("0x%05X 0x%05X 0x%05X 0x%05X\n", blink1, blink2,
ilink1, ilink2);
iwl_release_nic_access(priv);
}
static void iwl_dump_nic_error_log(struct iwl_trans *trans)
{
u32 base;
struct iwl_error_event_table table;
struct iwl_priv *priv = priv(trans);
struct iwl_trans_pcie *trans_pcie =
IWL_TRANS_GET_PCIE_TRANS(trans);
base = priv->device_pointers.error_event_table;
if (priv->ucode_type == IWL_UCODE_INIT) {
if (!base)
base = priv->init_errlog_ptr;
} else {
if (!base)
base = priv->inst_errlog_ptr;
}
if (!iwlagn_hw_valid_rtc_data_addr(base)) {
IWL_ERR(trans,
"Not valid error log pointer 0x%08X for %s uCode\n",
base,
(priv->ucode_type == IWL_UCODE_INIT)
? "Init" : "RT");
return;
}
iwl_read_targ_mem_words(bus(priv), base, &table, sizeof(table));
if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
IWL_ERR(trans, "Start IWL Error Log Dump:\n");
IWL_ERR(trans, "Status: 0x%08lX, count: %d\n",
trans->shrd->status, table.valid);
}
trans_pcie->isr_stats.err_code = table.error_id;
trace_iwlwifi_dev_ucode_error(priv, table.error_id, table.tsf_low,
table.data1, table.data2, table.line,
table.blink1, table.blink2, table.ilink1,
table.ilink2, table.bcon_time, table.gp1,
table.gp2, table.gp3, table.ucode_ver,
table.hw_ver, table.brd_ver);
IWL_ERR(trans, "0x%08X | %-28s\n", table.error_id,
desc_lookup(table.error_id));
IWL_ERR(trans, "0x%08X | uPc\n", table.pc);
IWL_ERR(trans, "0x%08X | branchlink1\n", table.blink1);
IWL_ERR(trans, "0x%08X | branchlink2\n", table.blink2);
IWL_ERR(trans, "0x%08X | interruptlink1\n", table.ilink1);
IWL_ERR(trans, "0x%08X | interruptlink2\n", table.ilink2);
IWL_ERR(trans, "0x%08X | data1\n", table.data1);
IWL_ERR(trans, "0x%08X | data2\n", table.data2);
IWL_ERR(trans, "0x%08X | line\n", table.line);
IWL_ERR(trans, "0x%08X | beacon time\n", table.bcon_time);
IWL_ERR(trans, "0x%08X | tsf low\n", table.tsf_low);
IWL_ERR(trans, "0x%08X | tsf hi\n", table.tsf_hi);
IWL_ERR(trans, "0x%08X | time gp1\n", table.gp1);
IWL_ERR(trans, "0x%08X | time gp2\n", table.gp2);
IWL_ERR(trans, "0x%08X | time gp3\n", table.gp3);
IWL_ERR(trans, "0x%08X | uCode version\n", table.ucode_ver);
IWL_ERR(trans, "0x%08X | hw version\n", table.hw_ver);
IWL_ERR(trans, "0x%08X | board version\n", table.brd_ver);
IWL_ERR(trans, "0x%08X | hcmd\n", table.hcmd);
}
static
void print_message(struct debug_hdr_t *req)
{
struct in_addr in_addr;
struct bproc_message_hdr_t *hdr;
hdr = bproc_debug_msg(req);
printf(" %d.%03d:%4d: ", (int)req->time.tv_sec,
(int)req->time.tv_usec / 1000, hdr->size);
if (req->tofrom == BPROC_DEBUG_OTHER) {
switch (hdr->req) {
case 1000:{
struct bproc_debug_1000_msg_t *msg;
msg = bproc_debug_msg(req);
printf("Process move %d %d -> %d", msg->pid,
msg->last, msg->node);
} break;
default:
printf(" ???? ");
}
} else {
/* Routing */
printf("%8p %s %4d %c%5d->%c%5d\t",
hdr->id, msg_dst_names[req->tofrom], req->node,
(hdr->fromtype == BPROC_ROUTE_REAL) ? 'R' :
(hdr->fromtype == BPROC_ROUTE_NODE) ? 'N' :
(hdr->fromtype == BPROC_ROUTE_GHOST) ? 'G' : '?',
hdr->from,
(hdr->totype == BPROC_ROUTE_REAL) ? 'R' :
(hdr->totype == BPROC_ROUTE_NODE) ? 'N' :
(hdr->totype == BPROC_ROUTE_GHOST) ? 'G' : '?', hdr->to);
printf("%-13s %c %4ld\t",
desc_lookup(descs, BPROC_REQUEST(hdr->req)),
BPROC_ISRESPONSE(hdr->req) ? 'R' : ' ', hdr->result);
/* Misc message details */
switch (hdr->req) {
case BPROC_VERSION:{
struct bproc_version_msg_t *msg;
msg = bproc_debug_msg(req);
printf("%s-%u-%d %Ld",
msg->vers.version_string,
(int)msg->vers.magic,
(int)msg->vers.arch,
(long long)msg->cookie);
} break;
case BPROC_NODE_CONF:{
struct bproc_conf_msg_t *msg;
msg = bproc_debug_msg(req);
printf("time=%ld.%06ld ping=%d masters=%d@%d",
msg->time_sec, msg->time_usec,
msg->ping_timeout, msg->masters_size,
msg->masters);
} break;
case BPROC_NODE_PING:{
struct bproc_ping_msg_t *msg;
msg = bproc_debug_msg(req);
printf("time=%ld.%06ld", msg->time_sec,
msg->time_usec);
} break;
case BPROC_RUN:{
struct bproc_move_msg_t *msg;
msg = bproc_debug_msg(req);
in_addr.s_addr = msg->addr;
printf
("pid=%d ppid=%d addr=%s:%d chld=%d o/ppid=%d/%d",
msg->pid, msg->ppid, inet_ntoa(in_addr),
(int)ntohs(msg->port), msg->children,
msg->ppid, msg->oppid);
if (verbose_moves) {
printf(" exit signal = %d\n",
msg->exit_signal);
printf("\n");
printf(" call_creds (@%d)\n",
msg->call_creds);
print_creds(hdr, msg->call_creds);
printf(" proc_creds (@%d)\n",
msg->proc_creds);
print_creds(hdr, msg->proc_creds);
}
}
break;
case BPROC_EXEC:{
#if 0
in_addr.s_addr = req->req.bpr_move_addr;
printf("addr=%s:%d chld=%d o/ppid=%d/%d",
inet_ntoa(in_addr),
(int)ntohs(req->req.bpr_move_port),
req->req.bpr_move_children,
req->req.bpr_move_ppid,
req->req.bpr_move_oppid);
#endif
} break;
case BPROC_RESPONSE(BPROC_RUN):{
struct bproc_move_msg_t *msg;
msg = bproc_debug_msg(req);
/* Move responses can be small... */
if (msg->hdr.size >= sizeof(*msg)) {
in_addr.s_addr = msg->addr;
printf("addr=%s:%d",
inet_ntoa(in_addr),
(int)ntohs(msg->port));
if (verbose_moves) {
printf("\n");
printf
(" call_creds (@%d)\n",
msg->call_creds);
print_creds(hdr,
msg->call_creds);
printf
(" proc_creds (@%d)\n",
msg->proc_creds);
print_creds(hdr,
msg->proc_creds);
}
}
}
break;
case BPROC_SYS_FORK:{
struct bproc_rsyscall_msg_t *msg;
msg = bproc_debug_msg(req);
printf("flags=0x%lx", msg->arg[0]);
} break;
case BPROC_RESPONSE(BPROC_SYS_FORK):{
struct bproc_fork_resp_t *msg;
msg = bproc_debug_msg(req);
printf("oppid=%d ppid=%d", msg->oppid,
msg->ppid);
} break;
case BPROC_SYS_WAIT:{
struct bproc_rsyscall_msg_t *msg;
msg = bproc_debug_msg(req);
printf("pid=%ld options=0x%lx", msg->arg[0],
msg->arg[1]);
} break;
case BPROC_PTRACE:{
struct bproc_ptrace_msg_t *msg =
bproc_debug_msg(req);
printf("%-8.8s pid=%d addr=0x%lx data=0x%lx",
desc_lookup(descs_ptrace, msg->request),
msg->hdr.to, msg->addr,
msg->data.data[0]);
if (msg->request == PTRACE_ATTACH) {
printf(" uid=%d gid=%d ce=0x%x",
msg->uid, msg->gid,
msg->cap_effective);
}
}
break;
case BPROC_RESPONSE(BPROC_PTRACE):{
struct bproc_ptrace_msg_t *msg =
bproc_debug_msg(req);
printf("%-8.8s",
desc_lookup(descs_ptrace, msg->request));
if (msg->request == PTRACE_ATTACH) {
printf(" nlchild_adj=%d",
msg->data.data ? 1 : 0);
}
if (msg->request == PTRACE_PEEKDATA ||
msg->request == PTRACE_PEEKTEXT) {
int i;
printf(" addr=0x%0*lx bytes=%d",
(int)sizeof(long) * 2, msg->addr,
msg->bytes);
/* ah fun. Cast depends on architecture type. I really love gcc */
for (i = 0;
i < msg->bytes / sizeof(int); i++)
printf(" %0*lx",
(int)sizeof(int) * 2,
((long unsigned int *)
msg->data.data)[i]);
}
} break;
case BPROC_REPARENT:{
struct bproc_reparent_msg_t *msg =
bproc_debug_msg(req);
printf("ptrace=0x%x new_parent=%d", msg->ptrace,
msg->new_parent);
} break;
case BPROC_FWD_SIG:{
struct bproc_signal_msg_t *sig =
bproc_debug_msg(req);
printf("sig = %d kill: pid=%d uid=%d",
sig->info.si_signo,
sig->info._sifields._kill._pid,
sig->info._sifields._kill._uid);
} break;
case BPROC_SYS_SETPGID:{
struct bproc_rsyscall_msg_t *msg =
bproc_debug_msg(req);
printf("pid=%ld pgid=%ld", msg->arg[0],
msg->arg[1]);
} break;
case BPROC_SYS_GETPGID:{
struct bproc_rsyscall_msg_t *msg =
bproc_debug_msg(req);
printf("pid=%ld", msg->arg[0]);
} break;
case BPROC_PGRP_CHANGE:{
struct bproc_pgrp_msg_t *msg =
bproc_debug_msg(req);
printf("pgid=%d", msg->pgid);
} break;
case BPROC_SYS_KILL:{
struct bproc_signal_msg_t *msg =
bproc_debug_msg(req);
printf("pid=%d sig=%d", msg->pid,
msg->info.si_signo);
} break;
case BPROC_STOP:
case BPROC_CONT:
case BPROC_RESPONSE(BPROC_GET_STATUS):{
struct bproc_status_msg_t *msg =
bproc_debug_msg(req);
printf("state=%d exit_code=0x%x (vm=%ld %ld)",
msg->state, msg->exit_code,
msg->vm.statm.size,
msg->vm.status.total_vm);
} break;
}
}
printf("\n");
fflush(stdout);
}
