Lines Matching refs:aflt
141 static void cpu_scrubphys(struct async_flt *aflt);
145 static void cpu_ereport_init(struct async_flt *aflt);
147 static uint8_t cpu_flt_bit_to_plat_error(struct async_flt *aflt);
154 static int cpu_error_to_resource_type(struct async_flt *aflt);
1188 struct async_flt *aflt;
1214 aflt = (struct async_flt *)&ch_flt;
1215 aflt->flt_id = gethrtime_waitfree();
1218 aflt->flt_stat = t_afsr;
1219 aflt->flt_addr = t_afar;
1220 aflt->flt_bus_id = cpuid;
1221 aflt->flt_inst = cpuid;
1222 aflt->flt_pc = tpc;
1223 aflt->flt_prot = AFLT_PROT_NONE;
1224 aflt->flt_class = CPU_FAULT;
1225 aflt->flt_priv = ((t_afsr & C_AFSR_PRIV) != 0);
1226 aflt->flt_tl = tl;
1227 aflt->flt_status = ecc_type;
1228 aflt->flt_panic = C_AFSR_PANIC(t_afsr_errs);
1238 aflt->flt_panic);
1342 struct async_flt *aflt;
1382 aflt = (struct async_flt *)&ch_flt;
1383 aflt->flt_id = gethrtime_waitfree();
1386 aflt->flt_stat = t_afsr;
1387 aflt->flt_addr = t_afar;
1388 aflt->flt_bus_id = getprocessorid();
1389 aflt->flt_inst = CPU->cpu_id;
1390 aflt->flt_pc = tpc;
1391 aflt->flt_prot = AFLT_PROT_NONE;
1392 aflt->flt_class = CPU_FAULT;
1393 aflt->flt_priv = priv;
1394 aflt->flt_tl = tl;
1395 aflt->flt_status = ECC_F_TRAP;
1396 aflt->flt_panic = C_AFSR_PANIC(t_afsr_errs);
1420 aflt->flt_panic == 0 && aflt->flt_priv != 0 &&
1424 aflt->flt_panic |=
1428 aflt->flt_panic |= ((clop == NULL) &&
1432 aflt->flt_panic |=
1435 aflt->flt_panic |= ((clop == NULL) &&
1450 aflt->flt_panic);
1476 aflt->flt_panic |= ((ch_flt.afsr_errs &
1483 * Panic here if aflt->flt_panic has been set. Enqueued errors will
1486 if (aflt->flt_panic)
1631 struct async_flt *aflt;
1675 aflt = (struct async_flt *)&ch_flt;
1678 aflt->flt_stat = t_afsr;
1679 aflt->flt_addr = t_afar;
1680 aflt->flt_pc = (caddr_t)rp->r_pc;
1681 aflt->flt_priv = (rp->r_tstate & TSTATE_PRIV) ? 1 : 0;
1682 aflt->flt_tl = 0;
1683 aflt->flt_panic = C_AFSR_PANIC(t_afsr_errs);
1691 !aflt->flt_panic)
1717 * Panic here if aflt->flt_panic has been set. Enqueued errors will
1720 if (aflt->flt_panic)
1741 struct async_flt *aflt;
1810 aflt = (struct async_flt *)&ch_flt;
1811 aflt->flt_id = gethrtime_waitfree();
1812 aflt->flt_bus_id = getprocessorid();
1813 aflt->flt_inst = CPU->cpu_id;
1816 aflt->flt_stat = t_afsr;
1817 aflt->flt_addr = t_afar;
1818 aflt->flt_pc = (caddr_t)rp->r_pc;
1819 aflt->flt_prot = AFLT_PROT_NONE;
1820 aflt->flt_class = CPU_FAULT;
1821 aflt->flt_priv = (rp->r_tstate & TSTATE_PRIV) ? 1 : 0;
1822 aflt->flt_tl = (uchar_t)tl;
1823 aflt->flt_panic = ((tl != 0) || (aft_testfatal != 0) ||
1825 aflt->flt_core = (pflag & SDOCORE) ? 1 : 0;
1826 aflt->flt_status = ((ttype == T_DATA_ERROR) ? ECC_D_TRAP : ECC_I_TRAP);
1834 if (aflt->flt_priv && tl == 0) {
1839 aflt->flt_prot = AFLT_PROT_EC;
1848 aflt->flt_prot = AFLT_PROT_ACCESS;
1865 aflt->flt_prot = AFLT_PROT_COPY;
1882 if (!aflt->flt_priv || aflt->flt_prot == AFLT_PROT_COPY) {
1886 aflt->flt_panic |= aft_panic;
1888 aflt->flt_panic = 1;
1902 } else if (!aflt->flt_priv) {
1921 aflt->flt_panic);
1938 cpu_run_bus_error_handlers(aflt, expected);
1953 aflt->flt_panic = 1;
1960 if (aflt->flt_panic && cpu_flt_in_memory(&ch_flt, C_AFSR_UE)) {
1961 panic_aflt = *aflt;
1976 cpu_run_bus_error_handlers(aflt, expected);
1991 aflt->flt_panic = 1;
1998 if (aflt->flt_panic && cpu_flt_in_memory(&ch_flt, C_AFSR_UE)) {
1999 panic_aflt = *aflt;
2031 aflt->flt_panic |= ((ch_flt.afsr_errs &
2039 * Panic here if aflt->flt_panic has been set. Enqueued errors will
2042 if (aflt->flt_panic)
2051 if (!aflt->flt_priv || aflt->flt_prot == AFLT_PROT_COPY) {
2086 struct async_flt *aflt;
2106 aflt = (struct async_flt *)&ch_flt;
2107 aflt->flt_id = gethrtime_waitfree();
2108 aflt->flt_bus_id = getprocessorid();
2109 aflt->flt_inst = CPU->cpu_id;
2110 aflt->flt_pc = tpc;
2111 aflt->flt_addr = iparity ? (uint64_t)tpc : AFLT_INV_ADDR;
2112 aflt->flt_prot = AFLT_PROT_NONE;
2113 aflt->flt_class = CPU_FAULT;
2114 aflt->flt_priv = (tl || (rp->r_tstate & TSTATE_PRIV)) ? 1 : 0;
2115 aflt->flt_tl = tl;
2116 aflt->flt_panic = panic;
2117 aflt->flt_status = iparity ? ECC_IP_TRAP : ECC_DP_TRAP;
2128 aflt->flt_payload = FM_EREPORT_PAYLOAD_ICACHE_PE;
2183 aflt->flt_payload = FM_EREPORT_PAYLOAD_DCACHE_PE;
2191 aflt->flt_payload =
2198 sizeof (ch_async_flt_t), ue_queue, aflt->flt_panic);
2261 * Panic here if aflt->flt_panic has been set. Enqueued errors will
2264 if (aflt->flt_panic)
2288 struct async_flt *aflt = (struct async_flt *)ch_flt;
2296 if (IS_PANTHER(cpunodes[aflt->flt_inst].implementation))
2311 if (IS_PANTHER(cpunodes[aflt->flt_inst].implementation))
2382 struct async_flt *aflt = (struct async_flt *)flt;
2393 if ((aflt->flt_status & ECC_C_TRAP) &&
2394 (!(aflt->flt_stat & C_AFSR_MASK)))
2405 cpu_log_err(aflt);
2432 aflt->flt_prot == AFLT_PROT_EC) {
2434 if (page_retire_check(aflt->flt_addr, NULL) == 0) {
2442 (void *)(uintptr_t)aflt->flt_inst,
2472 if (page_retire_check(aflt->flt_addr, &errors) == EINVAL) {
2473 CE_XDIAG_SETSKIPCODE(aflt->flt_disp,
2477 CE_XDIAG_SETSKIPCODE(aflt->flt_disp,
2479 } else if (ce_scrub_xdiag_recirc(aflt, ce_queue, eqep,
2493 cpu_log_err(aflt);
2507 aflt->flt_prot == AFLT_PROT_EC) {
2508 if (page_retire_check(aflt->flt_addr, NULL) == 0) {
2510 softcall(ecc_page_zero, (void *)aflt->flt_addr);
2519 cpu_log_err(aflt);
2540 (void *)aflt, ch_flt->flt_type);
2547 if (aflt->flt_addr != AFLT_INV_ADDR && aflt->flt_in_memory) {
2556 cpu_clearphys(aflt);
2570 struct async_flt *aflt = (struct async_flt *)ch_flt;
2571 (void) page_retire(aflt->flt_addr, PR_UE);
2603 cpu_log_err(struct async_flt *aflt)
2607 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
2609 if (cpu_error_is_ecache_data(aflt->flt_inst, ch_flt->flt_bit))
2610 aflt->flt_status |= ECC_ECACHE;
2612 aflt->flt_status &= ~ECC_ECACHE;
2616 synd_status = afsr_to_synd_status(aflt->flt_inst,
2622 if (pf_is_memory(aflt->flt_addr >> MMU_PAGESHIFT))
2629 aflt->flt_synd, ch_flt->flt_bit);
2635 (void) cpu_get_mem_unum_synd(synd_code, aflt, unum);
2650 plat_log_fruid_error(synd_code, aflt, unum,
2654 if (aflt->flt_func != NULL)
2655 aflt->flt_func(aflt, unum);
2670 (void *)(uintptr_t)aflt->flt_inst,
2702 cpu_ce_log_err(struct async_flt *aflt, errorq_elem_t *eqep)
2707 switch (aflt->flt_class) {
2709 cpu_ereport_init(aflt);
2710 if (cpu_async_log_err(aflt, eqep))
2711 cpu_ereport_post(aflt);
2715 if (aflt->flt_func != NULL) {
2716 (void) cpu_get_mem_unum_aflt(AFLT_STAT_VALID, aflt,
2718 aflt->flt_func(aflt, unum);
2723 aflt->flt_class = CPU_FAULT;
2724 cpu_log_err(aflt);
2725 cpu_ereport_post(aflt);
2729 ASSERT(aflt->flt_class != RECIRC_BUS_FAULT);
2733 "fault class (0x%x)", (void *)aflt, aflt->flt_class);
2974 * aflt->flt_inst; we might not be running on the detecting cpu.
3000 ce_ptnr_select(struct async_flt *aflt, int flags, int *typep)
3007 dtcr = cpu[aflt->flt_inst];
3169 ce_ptnrchk_xc(struct async_flt *aflt, uchar_t *dispp)
3171 *dispp = cpu_ce_scrub_mem_err_common(aflt, B_FALSE);
3185 struct async_flt *aflt = cbarg->lkycb_aflt;
3191 if (cp = ce_ptnr_select(aflt, PTNR_SIBLINGOK | PTNR_SELFOK,
3193 xc_one(cp->cpu_id, (xcfunc_t *)ce_ptnrchk_xc, (uint64_t)aflt,
3195 CE_XDIAG_SETLKYINFO(aflt->flt_disp, disp);
3196 CE_XDIAG_SETPTNRID(aflt->flt_disp, cp->cpu_id);
3197 CE_XDIAG_SETPTNRTYPE(aflt->flt_disp, ptnrtype);
3201 CE_XDIAG_SETSKIPCODE(aflt->flt_disp,
3237 ce_scrub_xdiag_recirc(struct async_flt *aflt, errorq_t *eqp,
3248 } else if (!aflt->flt_in_memory) {
3250 CE_XDIAG_SETSKIPCODE(aflt->flt_disp, CE_XDIAG_SKIP_NOTMEM);
3254 dtcrinfo = CE_XDIAG_DTCRINFO(aflt->flt_disp);
3263 CE_XDIAG_SETSKIPCODE(aflt->flt_disp, CE_XDIAG_SKIP_NOSCRUB);
3289 CE_XDIAG_SETSKIPCODE(aflt->flt_disp,
3312 if ((cp = ce_ptnr_select(aflt, 0, &ptnrtype)) != NULL) {
3314 (uint64_t)aflt, (uint64_t)&disp);
3315 CE_XDIAG_SETPTNRINFO(aflt->flt_disp, disp);
3316 CE_XDIAG_SETPTNRID(aflt->flt_disp, cp->cpu_id);
3317 CE_XDIAG_SETPTNRTYPE(aflt->flt_disp, ptnrtype);
3320 CE_XDIAG_SETSKIPCODE(aflt->flt_disp,
3324 CE_XDIAG_SETSKIPCODE(aflt->flt_disp,
3339 CE_XDIAG_SETSKIPCODE(aflt->flt_disp, CE_XDIAG_SKIP_ACTBAD);
3350 cpu_ue_log_err(struct async_flt *aflt)
3352 switch (aflt->flt_class) {
3354 cpu_ereport_init(aflt);
3355 if (cpu_async_log_err(aflt, NULL))
3356 cpu_ereport_post(aflt);
3360 bus_async_log_err(aflt);
3365 "fault class (0x%x)", (void *)aflt, aflt->flt_class);
3377 struct async_flt *aflt;
3389 aflt = (struct async_flt *)&ch_flt;
3390 aflt->flt_id = gethrtime_waitfree();
3391 aflt->flt_bus_id = getprocessorid();
3392 aflt->flt_inst = CPU->cpu_id;
3393 aflt->flt_stat = cpu_error_regs.afsr;
3394 aflt->flt_addr = cpu_error_regs.afar;
3395 aflt->flt_prot = AFLT_PROT_NONE;
3396 aflt->flt_class = CPU_FAULT;
3397 aflt->flt_priv = ((cpu_error_regs.afsr & C_AFSR_PRIV) != 0);
3398 aflt->flt_panic = 1;
3517 cpu_get_mem_unum_aflt(int synd_status, struct async_flt *aflt,
3521 * If we come thru here for an IO bus error aflt->flt_stat will
3525 return (cpu_get_mem_unum(synd_status, aflt->flt_synd,
3526 (aflt->flt_class == BUS_FAULT) ?
3527 (uint64_t)-1 : ((ch_async_flt_t *)aflt)->flt_bit,
3528 aflt->flt_addr, aflt->flt_bus_id, aflt->flt_in_memory,
3529 aflt->flt_status, buf, buflen, lenp));
3537 cpu_get_mem_unum_synd(int synd_code, struct async_flt *aflt, char *buf)
3548 if ((ret = plat_get_mem_unum(synd_code, aflt->flt_addr,
3549 aflt->flt_bus_id, aflt->flt_in_memory,
3550 aflt->flt_status, buf, UNUM_NAMLEN, &len)) != 0) {
3698 read_ecc_data(struct async_flt *aflt, short verbose, short ce_err)
3710 struct async_flt *aflt = (struct async_flt *)ch_flt;
3716 aflt->flt_stat = cpu_error_regs.afsr & C_AFSR_MASK;
3717 aflt->flt_addr = cpu_error_regs.afar;
3749 clear_ecc(struct async_flt *aflt)
3763 return ((cpu_error_regs.afsr & (C_AFSR_MEMORY & aflt->flt_stat)) != 0 &&
3764 cpu_error_regs.afar == aflt->flt_addr);
3835 struct async_flt *aflt = (struct async_flt *)ch_flt;
3838 ecache_flush_line(aflt->flt_addr, ec_set_size);
3847 cpu_scrubphys(struct async_flt *aflt)
3851 scrubphys(aflt->flt_addr, ec_set_size);
3860 cpu_clearphys(struct async_flt *aflt)
3866 clearphys(aflt->flt_addr, ec_set_size, lsize);
3877 struct async_flt *aflt = (struct async_flt *)ch_flt;
3886 (aflt->flt_addr & P2ALIGN(C_AFAR_PA, ec_set_size)) ==
4135 struct async_flt *aflt = (struct async_flt *)ch_flt;
4163 flt_index = P2ALIGN(aflt->flt_addr % ic_set_size, ic_linesize);
4322 cpu_payload_add_dcache(struct async_flt *aflt, nvlist_t *nvl)
4324 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
4369 cpu_payload_add_icache(struct async_flt *aflt, nvlist_t *nvl)
4371 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
4418 cpu_payload_add_ecache(struct async_flt *aflt, nvlist_t *nvl)
4420 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
4444 if (IS_PANTHER(cpunodes[aflt->flt_inst].implementation)) {
4505 cpu_error_to_resource_type(struct async_flt *aflt)
4507 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
4520 if (cpu_error_is_ecache_data(aflt->flt_inst,
4551 cpu_payload_add_aflt(struct async_flt *aflt, nvlist_t *payload,
4554 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
4558 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_AFSR) {
4560 DATA_TYPE_UINT64, aflt->flt_stat, NULL);
4563 if ((aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_AFSR_EXT) &&
4564 IS_PANTHER(cpunodes[aflt->flt_inst].implementation)) {
4569 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_AFAR_STATUS) {
4576 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_AFAR) {
4578 DATA_TYPE_UINT64, aflt->flt_addr, NULL);
4581 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_PC) {
4583 DATA_TYPE_UINT64, (uint64_t)aflt->flt_pc, NULL);
4586 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_TL) {
4588 DATA_TYPE_UINT8, (uint8_t)aflt->flt_tl, NULL);
4591 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_TT) {
4593 DATA_TYPE_UINT8, flt_to_trap_type(aflt), NULL);
4596 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_PRIV) {
4599 (aflt->flt_priv ? B_TRUE : B_FALSE), NULL);
4602 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_ME) {
4605 (aflt->flt_stat & C_AFSR_ME) ? B_TRUE : B_FALSE, NULL);
4608 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_SYND_STATUS) {
4609 *synd_status = afsr_to_synd_status(aflt->flt_inst,
4615 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_SYND) {
4617 DATA_TYPE_UINT16, (uint16_t)aflt->flt_synd, NULL);
4620 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_ERR_TYPE) {
4622 DATA_TYPE_STRING, flt_to_error_type(aflt), NULL);
4625 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_ERR_DISP) {
4627 DATA_TYPE_UINT64, aflt->flt_disp, NULL);
4630 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAGS_L2)
4631 cpu_payload_add_ecache(aflt, payload);
4633 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_COPYFUNCTION) {
4635 DATA_TYPE_UINT8, (uint8_t)aflt->flt_status & 0xff, NULL);
4638 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_HOWDETECTED) {
4640 DATA_TYPE_UINT8, (uint8_t)(aflt->flt_status >> 8), NULL);
4643 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_INSTRBLOCK) {
4650 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAGS_L1D)
4651 cpu_payload_add_dcache(aflt, payload);
4652 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAGS_L1I)
4653 cpu_payload_add_icache(aflt, payload);
4657 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAGS_L1P)
4658 cpu_payload_add_pcache(aflt, payload);
4659 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAGS_TLB)
4660 cpu_payload_add_tlb(aflt, payload);
4666 if (aflt->flt_payload & FM_EREPORT_PAYLOAD_FLAG_RESOURCE) {
4672 rtype = cpu_error_to_resource_type(aflt);
4685 aflt->flt_status |= ECC_ECACHE;
4687 aflt->flt_status &= ~ECC_ECACHE;
4690 aflt->flt_synd, ch_flt->flt_bit);
4692 if (cpu_get_mem_unum_synd(synd_code, aflt, unum) != 0)
4699 (void) cpu_get_mem_offset(aflt->flt_addr,
4714 cpu_fmri_cpu_set(resource, aflt->flt_inst);
4727 cpu_ereport_init(struct async_flt *aflt)
4729 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
4753 struct async_flt *aflt = (struct async_flt *)ch_flt;
4758 pf_is_memory(aflt->flt_addr >> MMU_PAGESHIFT));
4768 struct async_flt *aflt = (struct async_flt *)ch_flt;
4773 !pf_is_memory(aflt->flt_addr >> MMU_PAGESHIFT))
4815 struct async_flt *aflt = (struct async_flt *)ch_flt;
4846 if (CH_DCTAG_MATCH(dcp->dc_tag, aflt->flt_addr)) {
4851 if (CH_ICTAG_MATCH(icp, aflt->flt_addr)) {
4852 if (IS_PANTHER(cpunodes[aflt->flt_inst].implementation))
4927 struct async_flt *aflt = (struct async_flt *)ch_flt;
4940 aflt->flt_in_memory =
4944 aflt->flt_synd = GET_M_SYND(aflt->flt_stat);
4946 aflt->flt_synd = GET_E_SYND(aflt->flt_stat);
4948 aflt->flt_synd = 0;
4950 aflt->flt_payload = eccp->ec_err_payload;
4952 if (aflt->flt_panic || (eccp->ec_afsr_bit &
4956 aflt->flt_panic);
4960 aflt->flt_panic);
4972 struct async_flt *aflt = (struct async_flt *)ch_flt;
4975 uint64_t primary_afar = aflt->flt_addr, primary_afsr = aflt->flt_stat;
4999 aflt->flt_addr = ch_flt->flt_sdw_afar = cdp->chd_afar;
5000 aflt->flt_stat = ch_flt->flt_sdw_afsr = cdp->chd_afsr;
5011 aflt->flt_stat |= (1ull << C_AFSR_FIRSTFLT_SHIFT);
5023 ((eccp->ec_flags & aflt->flt_status) != 0)) {
5051 (eccp->ec_flags & aflt->flt_status) != 0) {
5061 aflt->flt_addr = ch_flt->afar2;
5065 aflt->flt_addr = primary_afar;
5068 aflt->flt_addr = primary_afar;
5070 aflt->flt_stat = primary_afsr;
5095 aflt->flt_addr = ch_flt->afar2;
5099 aflt->flt_addr = primary_afar;
5102 aflt->flt_addr = primary_afar;
5104 aflt->flt_stat = primary_afsr;
5120 flt_to_trap_type(struct async_flt *aflt)
5122 if (aflt->flt_status & ECC_I_TRAP)
5124 if (aflt->flt_status & ECC_D_TRAP)
5126 if (aflt->flt_status & ECC_F_TRAP)
5128 if (aflt->flt_status & ECC_C_TRAP)
5130 if (aflt->flt_status & ECC_DP_TRAP)
5132 if (aflt->flt_status & ECC_IP_TRAP)
5134 if (aflt->flt_status & ECC_ITLB_TRAP)
5136 if (aflt->flt_status & ECC_DTLB_TRAP)
5158 flt_to_error_type(struct async_flt *aflt)
5168 if (!ce_disp_inited || !aflt->flt_in_memory || aflt->flt_disp == 0)
5171 dtcrinfo = CE_XDIAG_DTCRINFO(aflt->flt_disp);
5209 lkyinfo = CE_XDIAG_LKYINFO(aflt->flt_disp);
5226 ptnrinfo = CE_XDIAG_PTNRINFO(aflt->flt_disp);
5480 cpu_check_allcpus(struct async_flt *aflt)
6320 struct async_flt *aflt;
6325 aflt = (struct async_flt *)&ch_flt;
6326 aflt->flt_stat = cpu_error_regs->afsr & C_AFSR_MASK;
6330 aflt->flt_addr = cpu_error_regs->afar;
6334 aflt->flt_pc = NULL;
6335 aflt->flt_priv = ((cpu_error_regs->afsr & C_AFSR_PRIV) != 0);
6336 aflt->flt_tl = 0;
6337 aflt->flt_panic = 0;
6356 struct async_flt *aflt;
6362 aflt = (struct async_flt *)ch_flt;
6363 afsr = aflt->flt_stat;
6365 aflt->flt_id = gethrtime_waitfree();
6366 aflt->flt_bus_id = getprocessorid();
6367 aflt->flt_inst = CPU->cpu_id;
6368 aflt->flt_prot = AFLT_PROT_NONE;
6369 aflt->flt_class = CPU_FAULT;
6370 aflt->flt_status = ECC_C_TRAP;
6422 cpu_ce_scrub_mem_err(aflt, B_TRUE);
6433 cpu_ce_scrub_mem_err(aflt, B_TRUE);
6443 aflt->flt_prot = AFLT_PROT_EC;
6453 aflt->flt_panic);
6486 struct async_flt *aflt;
6490 aflt = (struct async_flt *)ch_flt;
6491 afsr = aflt->flt_stat;
6664 cpu_ereport_post(struct async_flt *aflt)
6670 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;
6676 if (aflt->flt_panic || panicstr) {
6691 switch (cpunodes[aflt->flt_inst].implementation) {
6715 cpu_fmri_cpu_set(detector, aflt->flt_inst);
6721 FM_ERROR_CPU, cpu_type, aflt->flt_erpt_class);
6724 fm_ena_generate_cpu(aflt->flt_id, aflt->flt_inst, FM_ENA_FMT1),
6731 cpu_payload_add_aflt(aflt, ereport, resource,
6735 if (aflt->flt_panic || panicstr) {
6750 msg_type = cpu_flt_bit_to_plat_error(aflt);
6759 aflt->flt_synd, ch_flt->flt_bit);
6761 aflt, unum);
6772 plat_log_fruid_error2(msg_type, unum, aflt,
6779 cpu_run_bus_error_handlers(struct async_flt *aflt, int expected)
6787 de.fme_ena = fm_ena_generate_cpu(aflt->flt_id, aflt->flt_inst,
6790 de.fme_bus_specific = (void *)aflt->flt_addr;
6792 if ((aflt->flt_prot == AFLT_PROT_NONE) && (status == DDI_FM_FATAL))
6793 aflt->flt_panic = 1;
6800 struct async_flt *aflt = (struct async_flt *)payload;
6802 aflt->flt_erpt_class = error_class;
6988 struct async_flt *aflt = (struct async_flt *)&ch_flt;
7008 aflt->flt_id = gethrtime_waitfree();
7009 aflt->flt_class = CPU_FAULT;
7010 aflt->flt_inst = CPU->cpu_id;
7011 aflt->flt_status = (how << 8) | op;
7012 aflt->flt_payload = FM_EREPORT_PAYLOAD_FPU_HWCOPY;
7020 aflt->flt_panic = (curthread->t_lofault == NULL);
7039 sizeof (ch_async_flt_t), ue_queue, aflt->flt_panic);
7041 if (aflt->flt_panic)
7154 struct async_flt *aflt = (struct async_flt *)ch_flt;
7193 if (P2ALIGN(aflt->flt_addr, 64) != P2ALIGN(t_afar, 64))
7210 cpu_flt_bit_to_plat_error(struct async_flt *aflt)
7218 ch_async_flt_t *ch_flt = (ch_async_flt_t *)aflt;