espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-03 20:54:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Optimize debug log

Browse Source 
1. optimize wifi debug log
2. optimize lwip debug log
This commit is contained in:
liu zhifu
2020-04-28 15:57:18 +08:00
committed by maojianxin
parent 79db8df354
commit 2e5ea3a51b
14 changed files with 2413 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

466
components/esp32/include/wifi_debug.h Normal file
View File

@@ -0,0 +1,466 @@
// Copyright 2020-2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* All the APIs declared here are internal only APIs, it can only be used by
* espressif internal modules, such as SSC, LWIP, TCPIP adapter etc, espressif
* customers are not recommended to use them.
*
* If someone really want to use specified APIs declared in here, please contact
* espressif AE/developer to make sure you know the limitations or risk of
* the API, otherwise you may get unexpected behavior!!!
*
*/
#ifndef __ESP_WIFI_DEBUG_H__
#define __ESP_WIFI_DEBUG_H__
typedef struct {
uint32_t diag0;
uint32_t diag1;
uint32_t diag2;
uint32_t diag3;
uint32_t diag4;
uint32_t diag5;
uint32_t diag6;
uint32_t diag7;
uint32_t diag8;
uint32_t diag9;
uint32_t diag10;
uint32_t diag12;
uint32_t diag_sel;
} wifi_stats_reg_diag_t;
typedef struct {
uint32_t rx_data_suc;
uint32_t rx_end;
uint32_t rx_full;
uint32_t rx_full1;
uint32_t rx_bufbk;
uint32_t rx_cck_err;
uint32_t rx_ofdm_err;
uint32_t rx_agc_err;
uint32_t rx_sf;
uint32_t rx_abort;
uint32_t rx_fcs_err;
uint32_t rx_fifo_overflow;
uint32_t rx_apentrybuf_ful;
uint32_t rx_other_uc;
uint32_t rx_tkip_err;
uint32_t rx_samebm_err;
uint32_t rx_ack_int;
uint32_t rx_rts_int;
uint32_t rx_cts_int;
uint32_t rx_rifs_int;
uint32_t rx_block_err;
uint32_t rx_freqhop_err;
uint32_t txrts_int;
uint32_t txcts_int;
uint32_t txrxack_int;
uint32_t txrxcts_int;
uint32_t rxtrigger;
uint32_t rxtxhung;
uint32_t rxtxpanic;
} wifi_stats_reg_cnt_t;
typedef struct {
} wifi_stats_reg_filter_t;
typedef struct {
} wifi_stats_reg_crypto_t;
typedef struct {
} wifi_stats_reg_ba_t;
typedef struct {
uint32_t bbst;
uint32_t bbwd;
uint32_t frd;
uint32_t frd0;
uint32_t frd1;
uint32_t frd2;
uint32_t frd3;
uint32_t frd4;
uint32_t int_st;
} wifi_stats_reg_misc_t;
typedef struct {
uint32_t max;
uint32_t alloc;
uint32_t avail;
uint32_t total_free;
uint32_t total_alloc;
uint32_t total_fail;
} wifi_stats_one_buf_t;
#define WIFI_STATS_BUF_MAX 9
typedef struct {
wifi_stats_one_buf_t buf[WIFI_STATS_BUF_MAX];
} wifi_stats_buf_t;
typedef struct {
wifi_stats_reg_diag_t diag;
wifi_stats_reg_misc_t misc;
wifi_stats_reg_cnt_t cnt;
} wifi_stats_reg_t;
typedef struct {
uint32_t rx_suc;
uint32_t rx_hung;
uint32_t tx_complete;
uint32_t tx_enable;
uint32_t tx_collision;
uint32_t panic_reset;
uint32_t bb_wdt;
uint32_t tbtt;
uint32_t pp_post_fail;
uint32_t rx_sniffer_pingpong_full;
uint32_t rx_sniffer_null;
uint32_t rx_sniffer_reset_retry;
uint32_t rx_sniffer_reset_succ;
uint32_t rx_sniffer_reset;
uint32_t rx_sniffer_oversize;
uint32_t rx_sniffer_mimo;
uint32_t rx_sniffer_non_mimo;
uint32_t bb_wdt_bt;
uint32_t bb_wdt_wifi_rst;
uint32_t bb_wdt_wifi_not_rst;
} wifi_stats_int_t;
typedef struct {
wifi_stats_reg_t reg;
wifi_stats_buf_t buf;
wifi_stats_int_t interrupt;
} wifi_stats_mandatory_t;
#define WIFI_LMAC_AC_NUM 6
#define WIFI_LMAC_QUEUE_NUM 16
typedef struct {
uint32_t tx_data_all;
uint32_t tx_arp;
uint32_t tx_raw;
uint32_t tx_dhcp;
uint32_t tx_ps_q;
uint32_t tx_drop_data_arg;
uint32_t tx_drop_data_if;
uint32_t tx_drop_data_all;
uint32_t tx_drop_data_conn_null;
uint32_t tx_drop_data_not_run;
uint32_t tx_drop_data_not_assoc;
uint32_t tx_drop_data_not_auth;
uint32_t tx_drop_data_no_mem;
uint32_t tx_drop_data_qfull;
uint32_t tx_drop_data_post_fail;
uint32_t tx_drop_data_buf;
uint32_t tx_drop_data_ps;
uint32_t tx_task_yield;
uint32_t tx_buffer_not_home_chan;
uint32_t tx_buffer_not_home_chan_free;
uint32_t tx_buffer_not_home_chan_scan;
} wifi_stats_hmac_tx_t;
typedef struct {
uint32_t r1_all;
uint32_t r1_ampdu;
uint32_t r1_mutiple_blocks;
uint32_t r1_data_mpdu;
uint32_t r1_mgmt;
uint32_t r1_mgmt_probe_req;
uint32_t r1_mgmt_beacon;
uint32_t r1_ctrl_bar;
uint32_t r1_ctrl_ba;
uint32_t r1_ctrl_pspoll;
uint32_t r1_ctrl_others;
uint32_t r1_sniffer_mimo;
uint32_t r1_drop;
uint32_t r1_drop_if_mismatch;
uint32_t r1_drop_sniffer_state;
uint32_t r1_drop_type_err;
uint32_t r1_drop_mpdu_multiple_blocks;
uint32_t r2_drop_multiple_blocks;
uint32_t r2_drop_mpdu_no_mem;
uint32_t r3_drop_ampdu_too_long;
uint32_t r3_drop_ampdu_too_short;
uint32_t r3_drop_ampdu_state;
uint32_t r3_drop_ampdu_no_mem;
uint32_t r3_drop_ampdu_len;
uint32_t r3_drop_ampdu_ds;
uint32_t r4_drop_ampdu_proc;
uint32_t r4_drop_mpdu_proc;
uint32_t r4_drop_frag;
uint32_t r4_drop_state;
uint32_t r4_drop_tkipmic;
uint32_t r4_drop_sta_if;
uint32_t r4_drop_ap_if;
uint32_t r4_drop_if_mismatch;
uint32_t r5_sniffer_ampdu;
uint32_t r5_drop_sniffer_filter;
uint32_t r5_drop_sniffer_no_mem;
uint32_t r5_drop_sniffer_q_fail;
uint32_t r6_sniffer_mimo;
uint32_t r6_sniffer_single_block;
uint32_t r6_sniffer_multiple_blocks;
uint32_t r6_drop_sniffer_filter;
uint32_t r6_drop_sniffer_no_mem;
uint32_t r6_drop_sniffer_q_fail;
uint32_t r7_sniffer_mimo;
uint32_t r7_drop_sniffer_no_mem;
uint32_t r7_drop_sniffer_post;
uint32_t r7_drop_sniffer_others;
uint32_t r8_reset_rx_base;
uint32_t r8_reload;
uint32_t rh1_sta_drop_conn_null;
uint32_t rh1_sta_drop_too_short;
uint32_t rh1_sta_drop_wrong_version;
uint32_t rh1_sta_drop_not_my_bss;
uint32_t rh1_sta_drop_mgmt_too_short1;
uint32_t rh1_sta_drop_mgmt_probe_inq;
uint32_t rh1_sta_drop_dup;
uint32_t rh1_sta_drop_data_not_assoc;
uint32_t rh1_sta_drop_data_too_short;
uint32_t rh1_sta_drop_data_not_fromds;
uint32_t rh1_sta_drop_data_invalid_key;
uint32_t rh1_sta_drop_data_frag;
uint32_t rh1_sta_drop_data_mic;
uint32_t rh1_sta_drop_data_encap;
uint32_t rh1_sta_drop_data_null_key;
uint32_t rh1_sta_drop_data_unencrypt;
uint32_t rh1_sta_data_to_lwip;
uint32_t rh1_sta_mgmt;
uint32_t rh1_sta_drop_mgmt_not_nods;
uint32_t rh1_sta_drop_mgmt_too_short2;
uint32_t rh1_sta_drop_mgmt_bip_check;
uint32_t rh1_sta_ctrl;
uint32_t rh2_sta_eapol_wps_succ;
uint32_t rh2_sta_eapol_wps_fail;
uint32_t rh2_sta_eapol_wps_null_handle;
uint32_t rh2_sta_drop_not_8021x_auth;
uint32_t rh2_sta_drop_not_allow_eapol;
uint32_t rh2_sta_eapol_wpa2e_succ;
uint32_t rh2_sta_drop_eapol_wpa2e_null_handle;
uint32_t rh2_sta_drop_eapol_wpa2e_state;
uint32_t rh2_sta_eapol_wpa_succ;
uint32_t rh2_sta_drop_eapol_wpa_fail;
uint32_t rh2_sta_drop_eapol_wpa_null_handle;
uint32_t rh3_data_amsdu;
uint32_t rh3_drop_data_amsdu_too_short;
uint32_t rh3_drop_data_amsdu_no_mem;
uint32_t rh3_drop_data_amsdu_remain_too_short;
uint32_t rh3_sta_data_amsdu_mpdu;
uint32_t rh3_ap_data_amsdu_mpdu;
uint32_t rh4_sta_mgmt_beacon;
uint32_t rh4_sta_mgmt_probe_resp;
uint32_t rh4_sta_mgmt_auth;
uint32_t rh4_sta_mgmt_deauth;
uint32_t rh4_sta_mgmt_assoc;
uint32_t rh4_sta_mgmt_action;
uint32_t rh4_sta_drop_mgmt_disassoc_unencrypt;
uint32_t rh4_sta_drop_mgmt_disassoc_not_my;
uint32_t rh4_sta_drop_mgmt_unencrypt;
uint32_t rh4_sta_mgmt_disassoc;
uint32_t rh4_sta_drop_mgmt_unexpected;
uint32_t rh5_sta_beacon_csa;
uint32_t rh5_sta_drop_beacon_out_of_reg;
uint32_t rh1_ap_data_fwd;
uint32_t rh1_ap_drop_data_null_cb;
uint32_t rh1_ap_data_to_lwip;
uint32_t rh1_ap_drop_data_rxcb_null;
uint32_t rh1_ap_drop_wrong_version;
uint32_t rh1_ap_drop_ds2ds;
uint32_t rh1_ap_drop_data_null_bss;
uint32_t rh1_ap_drop_nondata_null_bss;
uint32_t rh1_ap_drop_null_bss;
uint32_t rh1_ap_drop_bcast_null_bss;
uint32_t rh1_ap_drop_not_my_bss1;
uint32_t rh1_ap_drop_not_my_bss2;
uint32_t rh1_ap_drop_too_short1;
uint32_t rh1_ap_drop_too_short2;
uint32_t rh1_ap_drop_mgmt_too_short1;
uint32_t rh1_ap_drop_mgmt_too_short2;
uint32_t rh1_ap_drop_data_too_short;
uint32_t rh1_ap_drop_data_not_tods;
uint32_t rh1_ap_drop_data_not_assoc;
uint32_t rh1_ap_drop_data_wep;
uint32_t rh1_ap_drop_data_key;
uint32_t rh1_ap_drop_data_decap;
uint32_t rh1_ap_drop_data_8021x_auth;
uint32_t rh1_ap_eapol_succ1;
uint32_t rh1_ap_eapol_succ2;
uint32_t rh1_ap_drop_eapol_null_handle1;
uint32_t rh1_ap_drop_eapol_null_handle2;
uint32_t rh1_ap_drop_data_unencrypt;
uint32_t rh1_ap_mgmt;
uint32_t rh1_ap_drop_mgmt_nods;
uint32_t rh1_ap_drop_mgmt_mcast;
uint32_t rh1_ap_drop_mgmt_encrypted;
uint32_t rh1_ap_drop_mgmt_privacy;
uint32_t rh1_ap_drop_mgmt_key;
uint32_t rh1_ap_ctrl;
uint32_t rh1_ap_drop_unknow_type;
uint32_t rh1_ap_drop_dup;
uint32_t rh2_ap_mgmt_beacon;
uint32_t rh2_ap_mgmt_probe_resp;
uint32_t rh2_ap_mgmt_probe_req;
uint32_t rh2_ap_mgmt_auth;
uint32_t rh2_ap_mgmt_assoc;
uint32_t rh2_ap_mgmt_deauth_deassoc;
uint32_t rh2_ap_mgmt_action;
uint32_t rh2_ap_mgmt_other;
uint32_t rh5_drop_ampdu_oos1;
uint32_t rh5_drop_ampdu_oos2;
uint32_t rh5_drop_ampdu_tid;
uint32_t rh5_drop_ampdu_frag;
uint32_t rh5_drop_ampdu_dup;
uint32_t pm_bcn_interval;
uint32_t pm_dtim_period;
uint32_t pm_listen_interval;
uint32_t pm_tbtt;
uint32_t pm_rx_bcn;
uint32_t pm_active_timeout;
uint32_t pm_wake_tx;
uint32_t pm_wake_tbtt;
uint32_t pm_wake_tim;
uint32_t pm_wake_dtim;
uint32_t pm_sleep_null;
uint32_t pm_wake_null;
uint32_t pm_sleep;
uint32_t pm_wake;
uint32_t pm_bcn_delay_time;
uint32_t pm_max_bcn_delay_time;
uint32_t pm_avg_bcn_delay_time;
uint64_t pm_sleep_time;
uint64_t pm_wake_time;
uint64_t pm_total_time;
uint32_t t1_en_waitq;
uint32_t t1_drop_sec;
uint32_t t1_drop_enq_fail;
uint32_t t1_drop_stop;
uint32_t t2_ampdu_to_mpdu;
uint32_t t3_en_waitq;
uint16_t t4_doneq_len;
uint16_t t4_waitq0_len;
uint16_t t4_waitq1_len;
uint16_t t4_rxq_len;
uint16_t t4_qlen[WIFI_LMAC_QUEUE_NUM];
uint32_t t5_drop_aged[WIFI_LMAC_AC_NUM];
uint16_t t6_succ[WIFI_LMAC_AC_NUM];
uint32_t t7_drop_src[WIFI_LMAC_AC_NUM];
uint32_t t7_drop_lrc[WIFI_LMAC_AC_NUM];
uint32_t t7_drop_others[WIFI_LMAC_AC_NUM];
uint32_t t8_drop_src[WIFI_LMAC_AC_NUM];
uint32_t t8_drop_lrc[WIFI_LMAC_AC_NUM];
uint32_t t8_drop_others[WIFI_LMAC_AC_NUM];
uint32_t t9_drop_src[WIFI_LMAC_AC_NUM];
uint32_t t9_drop_lrc[WIFI_LMAC_AC_NUM];
uint32_t t9_drop_others[WIFI_LMAC_AC_NUM];
uint32_t t10_complete_invalid_state;
uint32_t t10_complete_succ[WIFI_LMAC_AC_NUM];
uint32_t t10_complete_cts_err[WIFI_LMAC_AC_NUM];
uint32_t t10_complete_ack_err[WIFI_LMAC_AC_NUM];
uint32_t t10_complete_data_err[WIFI_LMAC_AC_NUM];
uint32_t t10_complete_other_err[WIFI_LMAC_AC_NUM];
uint32_t t11_timeout[WIFI_LMAC_AC_NUM];
uint32_t t12_collision[WIFI_LMAC_AC_NUM];
uint32_t t13_complete_rts_collision_err[WIFI_LMAC_AC_NUM];
uint32_t t13_complete_rts_seckid_err[WIFI_LMAC_AC_NUM];
uint32_t t14_complete_data_collision_err[WIFI_LMAC_AC_NUM];
uint32_t t14_complete_data_seckid_err[WIFI_LMAC_AC_NUM];
uint32_t t14_complete_data_zero_err[WIFI_LMAC_AC_NUM];
uint32_t t14_complete_data_other_err[WIFI_LMAC_AC_NUM];
uint32_t t15_send_bar[WIFI_LMAC_AC_NUM];
uint32_t t16_txq_free_len;
uint32_t t16_txq_forward_len;
uint32_t t16_txq_wait_len;
wifi_stats_hmac_tx_t tx[2];
uint32_t pp_post_overflow;
uint32_t pp_post_fail;
uint32_t ap_alloc;
uint32_t ap_free;
uint32_t sta_alloc;
uint32_t sta_free;
uint32_t bss_alloc;
uint32_t bss_free;
uint32_t tap_alloc;
uint32_t tap_free;
uint32_t rap_alloc;
uint32_t rap_free;
uint32_t rap_eb_alloc;
uint32_t rap_eb_free;
uint32_t scan_bss_alloc;
uint32_t scan_bss_free;
} wifi_stats_optional_t;
typedef struct {
wifi_stats_mandatory_t mandatory;
wifi_stats_optional_t optional;
} wifi_stats_t;
//WiFi Internal Statistics
#define WIFI_MODULE_HW_DIAG (1)
#define WIFI_MODULE_HW_COUNTERS (1<<1)
#define WIFI_MODULE_HW_MISC (1<<2)
#define WIFI_MODULE_INT_COUNTERS (1<<3)
#define WIFI_MODULE_BUFFER_COUNTERS (1<<4)
#define WIFI_MODULE_RX_COUNTERS (1<<5)
#define WIFI_MODULE_TX_COUNTERS (1<<6)
#define WIFI_MODULE_SLEEP (1<<7)
#define WIFI_MODULE_EVENT_COUNTERS (1<<8)
#define WIFI_MODULE_NVS (1<<9)
#define WIFI_MODULE_STA (1<<10)
#define WIFI_MODULE_AP (1<<11)
#define WIFI_MODULE_TRC (1<<12)
esp_err_t esp_wifi_stats_get(wifi_stats_t *stats);
void esp_wifi_dump_stats(const wifi_stats_t *stats, uint64_t modules);
void esp_wifi_dump_info(uint64_t modules);
esp_err_t esp_wifi_stats_init(void);
esp_err_t esp_wifi_stats_deinit(void);
void esp_wifi_dump(uint64_t modules);
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
#endif /* __ESP_WIFI_DEBUG_H__ */

2
components/esp32/lib

Submodule components/esp32/lib updated: 45c8df5abd...eee4eae632

366
components/esp32/wifi_debug.c Normal file
View File

@@ -0,0 +1,366 @@
// Copyright 2020-2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <esp_event.h>
#include <esp_wifi.h>
#include "esp_log.h"
#include "esp_wifi_internal.h"
#include "wifi_debug.h"
#include "esp_wifi_os_adapter.h"
#define TAG "wifid"
static void wifi_debug_dump_diag(const wifi_stats_reg_diag_t *diag)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>hardware diag");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"diag0", "diag1", "diag2", "diag3", "diag4", "diag5", "diag6", "diag7", "diag8", "diag9", "diag10", "diag12", "sel");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
diag->diag0, diag->diag1, diag->diag2, diag->diag3, diag->diag4, diag->diag5, diag->diag6, diag->diag7, diag->diag8,
diag->diag9, diag->diag10, diag->diag12, diag->diag_sel);
}
static void wifi_debug_dump_cnt(const wifi_stats_reg_cnt_t *cnt)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>hardware counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"rx_succ", "rx_end", "rx_full", "rx_full1", "rx_bufbk", "cck_err", "ofdm_err", "agc_err",
"rx_sf", "rx_abort", "fcs_err", "fifo_of", "apbufful", "other_uc", "tkip_err");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
cnt->rx_data_suc, cnt->rx_end, cnt->rx_full, cnt->rx_full1, cnt->rx_bufbk, cnt->rx_cck_err, cnt->rx_ofdm_err, cnt->rx_agc_err, cnt->rx_sf, cnt->rx_abort,
cnt->rx_fcs_err, cnt->rx_fifo_overflow, cnt->rx_apentrybuf_ful, cnt->rx_other_uc, cnt->rx_tkip_err);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"same_err", "ack_int", "rts_int", "cts_int", "rifs_int", "blok_err", "fh_err",
"trts_int", "tcts_int", "track_in", "trcts_in", "trigger", "hung", "panic");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
cnt->rx_samebm_err, cnt->rx_ack_int, cnt->rx_rts_int, cnt->rx_cts_int, cnt->rx_rifs_int, cnt->rx_block_err, cnt->rx_freqhop_err,
cnt->txrts_int, cnt->txcts_int, cnt->txrxack_int, cnt->txrxcts_int, cnt->rxtrigger, cnt->rxtxhung, cnt->rxtxpanic);
}
static void wifi_debug_dump_misc(const wifi_stats_reg_misc_t *misc)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>hardware misc");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s",
"bbst", "bbwd", "frd", "frd0", "frd1", "frd2", "frd3", "frd4", "int_st");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x",
misc->bbst, misc->bbwd, misc->frd, misc->frd0, misc->frd1, misc->frd2, misc->frd3, misc->frd4, misc->int_st);
}
static void wifi_debug_dump_int(const wifi_stats_int_t *interrupt)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>interrupt counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s", "rx_suc", "rx_hung", "tx_com", "tx_ena", "tx_col", "panic", "bb_wdt", "tbtt", "post");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x",
interrupt->rx_suc, interrupt->rx_hung, interrupt->tx_complete, interrupt->tx_enable,
interrupt->tx_collision, interrupt->panic_reset, interrupt->bb_wdt, interrupt->tbtt, interrupt->pp_post_fail);
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"sni_full", "sni_null", "sni_rtry", "sni_succ", "sni_ovsz", "sni_mimo", "sni_nomi", "bb_wdt", "bb_brst", "bb_wrst", "bb_nwrst");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
interrupt->rx_sniffer_pingpong_full, interrupt->rx_sniffer_null, interrupt->rx_sniffer_reset_retry, interrupt->rx_sniffer_reset_succ, interrupt->rx_sniffer_oversize,
interrupt->rx_sniffer_mimo, interrupt->rx_sniffer_non_mimo, interrupt->bb_wdt, interrupt->bb_wdt_bt, interrupt->bb_wdt_wifi_rst, interrupt->bb_wdt_wifi_not_rst);
}
static void wifi_debug_dump_buf(const wifi_stats_t *stats)
{
const wifi_stats_buf_t *buf = &stats->mandatory.buf;
const wifi_stats_optional_t *mem = &stats->optional;
int i=0;
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>buf counter");
ESP_LOGI(TAG, "%1s %3s %5s %5s %8s %8s %8s", "t", "max", "alloc", "avail", "t_free", "t_alloc", "t_fail");
for (i=0; i<WIFI_STATS_BUF_MAX; i++) {
ESP_LOGI(TAG, "%1x %3x %5x %5x %8x %8x %8x", i, buf->buf[i].max, buf->buf[i].alloc, buf->buf[i].avail,
buf->buf[i].total_free, buf->buf[i].total_alloc, buf->buf[i].total_fail);
}
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>hmac memory counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s",
"op", "ap", "sta", "bss", "tap", "rap", "rap_eb", "scan_bss");
ESP_LOGI(TAG, "%8s %8x %8x %8x %8x %8x %8x %8x",
"alloc", mem->ap_alloc, mem->sta_alloc, mem->bss_alloc, mem->tap_alloc, mem->rap_alloc, mem->rap_eb_alloc, mem->scan_bss_alloc);
ESP_LOGI(TAG, "%8s %8x %8x %8x %8x %8x %8x %8x",
"free", mem->ap_free, mem->sta_free, mem->bss_free, mem->tap_free, mem->rap_free, mem->rap_eb_free, mem->scan_bss_free);
}
static void wifi_debug_dump_rx(const wifi_stats_optional_t *rx)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>lmac rx counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"r1_all", "r1_ampdu", "r1_mblk", "r1_dmpdu", "r1_mgmt", "r1_preq", "r1_bcn", "r1_bar", "r1_ba", "r1_psp");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->r1_all, rx->r1_ampdu, rx->r1_mutiple_blocks, rx->r1_data_mpdu, rx->r1_mgmt, rx->r1_mgmt_probe_req,
rx->r1_mgmt_beacon, rx->r1_ctrl_bar, rx->r1_ctrl_ba, rx->r1_ctrl_pspoll);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"r1_other","r1_mimo", "r1_drop", "r1d_if", "r1d_st", "r1d_type", "r1d_mblk", "r2d_mblk", "r2d_nmem", "r3d_tlon");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->r1_ctrl_others, rx->r1_sniffer_mimo, rx->r1_drop, rx->r1_drop_if_mismatch, rx->r1_drop_sniffer_state, rx->r1_drop_type_err,
rx->r1_drop_mpdu_multiple_blocks, rx->r2_drop_multiple_blocks, rx->r2_drop_mpdu_no_mem, rx->r3_drop_ampdu_too_long);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"r3d_tsht", "r3d_st", "r3d_nmem", "r3d_len", "r3d_ds", "r4d_apro", "r4d_mpro", "r4d_frag", "r4d_st", "r4d_tkip");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->r3_drop_ampdu_too_short, rx->r3_drop_ampdu_state, rx->r3_drop_ampdu_no_mem, rx->r3_drop_ampdu_len, rx->r3_drop_ampdu_ds,
rx->r4_drop_ampdu_proc, rx->r4_drop_mpdu_proc, rx->r4_drop_frag, rx->r4_drop_state, rx->r4_drop_tkipmic);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"r4d_sif", "r4d_aif", "r4d_if", "r5_amdu", "r5d_filt", "r5d_nmem", "r5d_qfai", "r6_mimo", "r6_sblk", "r6_mblk");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->r4_drop_sta_if, rx->r4_drop_ap_if, rx->r4_drop_if_mismatch, rx->r5_sniffer_ampdu, rx->r5_drop_sniffer_filter,
rx->r5_drop_sniffer_no_mem, rx->r5_drop_sniffer_q_fail, rx->r6_sniffer_mimo, rx->r6_sniffer_single_block, rx->r6_sniffer_multiple_blocks);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"r6d_flt", "r6d_nmem", "r6d_qfai", "r7_mimo", "r7d_nmem", "rd7_post", "r7d_oth", "r8_reset", "r8_relo", "h1d_cnul");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->r6_drop_sniffer_filter, rx->r6_drop_sniffer_no_mem, rx->r6_drop_sniffer_q_fail, rx->r7_sniffer_mimo, rx->r7_drop_sniffer_no_mem,
rx->r7_drop_sniffer_post, rx->r7_drop_sniffer_others, rx->r8_reset_rx_base, rx->r8_reload, rx->rh1_sta_drop_conn_null);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>sta hmac rx counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"h1d_ts", "h1d_ver", "h1d_bss", "h1d_mts", "h1d_inq",
"h1d_dup", "h1d_nass", "h1d_dtsh", "h1d_ds", "h1d_key");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->rh1_sta_drop_too_short, rx->rh1_sta_drop_wrong_version, rx->rh1_sta_drop_not_my_bss, rx->rh1_sta_drop_mgmt_too_short1, rx->rh1_sta_drop_mgmt_probe_inq,
rx->rh1_sta_drop_dup, rx->rh1_sta_drop_data_not_assoc, rx->rh1_sta_drop_data_too_short, rx->rh1_sta_drop_data_not_fromds, rx->rh1_sta_drop_data_invalid_key);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"h1d_frag", "h1d_mic", "h1d_enc", "h1d_nkey", "h1d_unen", "h1d_lwip", "h1_mgmt", "h1d_nods", "h1d_mts2", "h1d_bip");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->rh1_sta_drop_data_frag, rx->rh1_sta_drop_data_mic, rx->rh1_sta_drop_data_encap, rx->rh1_sta_drop_data_null_key, rx->rh1_sta_drop_data_unencrypt,
rx->rh1_sta_data_to_lwip, rx->rh1_sta_mgmt, rx->rh1_sta_drop_mgmt_not_nods, rx->rh1_sta_drop_mgmt_too_short2, rx->rh1_sta_drop_mgmt_bip_check);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"h2_wpss", "h2_wpsf", "h2d_wpsn", "h2d_1x", "h2d_neap",
"h2d_2eok", "h2d_2enl", "h2d_2est", "h2_wpas", "h2d_wpaf");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->rh2_sta_eapol_wps_succ, rx->rh2_sta_eapol_wps_fail, rx->rh2_sta_eapol_wps_null_handle, rx->rh2_sta_drop_not_8021x_auth, rx->rh2_sta_drop_not_allow_eapol,
rx->rh2_sta_eapol_wpa2e_succ, rx->rh2_sta_drop_eapol_wpa2e_null_handle, rx->rh2_sta_drop_eapol_wpa2e_state, rx->rh2_sta_eapol_wpa_succ, rx->rh2_sta_drop_eapol_wpa_fail);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"h2d_wpan", "h3_amsdu", "h3d_ts", "h3d_nmem", "h3d_rts",
"h3_samsdu", "h3_aamsdu", "h4_bcn", "h4_prsp", "h4_auth");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->rh2_sta_drop_eapol_wpa_null_handle, rx->rh3_data_amsdu, rx->rh3_drop_data_amsdu_too_short, rx->rh3_drop_data_amsdu_no_mem, rx->rh3_drop_data_amsdu_remain_too_short,
rx->rh3_sta_data_amsdu_mpdu, rx->rh3_ap_data_amsdu_mpdu, rx->rh4_sta_mgmt_beacon, rx->rh4_sta_mgmt_probe_resp, rx->rh4_sta_mgmt_auth);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"h4_death", "h4_assoc", "h4_ation", "h4d_unen", "h4d_nmy",
"h4d_munen", "h4d_disa", "h4d_munex", "h5_csa", "h5d_reg");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
rx->rh4_sta_mgmt_deauth, rx->rh4_sta_mgmt_assoc, rx->rh4_sta_mgmt_action, rx->rh4_sta_drop_mgmt_disassoc_unencrypt, rx->rh4_sta_drop_mgmt_disassoc_not_my,
rx->rh4_sta_drop_mgmt_unencrypt, rx->rh4_sta_mgmt_disassoc, rx->rh4_sta_drop_mgmt_unexpected, rx->rh5_sta_beacon_csa, rx->rh5_sta_drop_beacon_out_of_reg);
ESP_LOGI(TAG, "========>ap hmac rx counter");
}
static void wifi_debug_dump_tx(const wifi_stats_optional_t *tx)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========>ap hmac rx counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"t1_enwq", "t1d_sec", "t1d_eqf", "t1d_stop", "t2_atm",
"t3_ewq", "t4_dql", "t4_wql", "t4_wq1l", "t4_rxql", "post_of", "post_f");
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
tx->t1_en_waitq, tx->t1_drop_sec, tx->t1_drop_enq_fail, tx->t1_drop_stop, tx->t2_ampdu_to_mpdu,
tx->t3_en_waitq, tx->t4_doneq_len, tx->t4_waitq0_len, tx->t4_waitq1_len, tx->t4_rxq_len,
tx->pp_post_overflow, tx->pp_post_fail, tx->t10_complete_invalid_state);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%3s %3s %3s %3s %3s %3s %3s %3s %3s %3s %3s %3s %3s %3s %3s %3s",
"q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15");
ESP_LOGI(TAG, "%3x %3x %3x %3x %3x %3x %3x %3x %3x %3x %3x %3x %3x %3x %3x %3x",
tx->t4_qlen[0], tx->t4_qlen[1], tx->t4_qlen[2], tx->t4_qlen[3], tx->t4_qlen[4], tx->t4_qlen[5], tx->t4_qlen[6], tx->t4_qlen[7],
tx->t4_qlen[8], tx->t4_qlen[9], tx->t4_qlen[10], tx->t4_qlen[11], tx->t4_qlen[12], tx->t4_qlen[13], tx->t4_qlen[14], tx->t4_qlen[15]);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%16s %8s %8s %8s %8s %8s %8s",
"type", "ac0", "ac1", "ac2", "ac3", "ac4", "ac5");
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t5_drop_aged", tx->t5_drop_aged[0], tx->t5_drop_aged[1], tx->t5_drop_aged[2], tx->t5_drop_aged[3], tx->t5_drop_aged[4], tx->t5_drop_aged[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t6_succ", tx->t6_succ[0], tx->t6_succ[1], tx->t6_succ[2], tx->t6_succ[3], tx->t6_succ[4], tx->t6_succ[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t7_drop_src", tx->t7_drop_src[0], tx->t7_drop_src[1], tx->t7_drop_src[2], tx->t7_drop_src[3], tx->t7_drop_src[4], tx->t7_drop_src[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t7_drop_lrc", tx->t7_drop_lrc[0], tx->t7_drop_lrc[1], tx->t7_drop_lrc[2], tx->t7_drop_lrc[3], tx->t7_drop_lrc[4], tx->t7_drop_lrc[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t7_drop_others", tx->t7_drop_others[0], tx->t7_drop_others[1], tx->t7_drop_others[2], tx->t7_drop_others[3], tx->t7_drop_others[4], tx->t7_drop_others[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t8_drop_src", tx->t8_drop_src[0], tx->t8_drop_src[1], tx->t8_drop_src[2], tx->t8_drop_src[3], tx->t8_drop_src[4], tx->t8_drop_src[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t8_drop_lrc", tx->t8_drop_lrc[0], tx->t8_drop_lrc[1], tx->t8_drop_lrc[2], tx->t8_drop_lrc[3], tx->t8_drop_lrc[4], tx->t8_drop_lrc[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t8_drop_others", tx->t8_drop_others[0], tx->t8_drop_others[1], tx->t8_drop_others[2], tx->t8_drop_others[3], tx->t8_drop_others[4], tx->t8_drop_others[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t9_drop_src", tx->t9_drop_src[0], tx->t9_drop_src[1], tx->t9_drop_src[2], tx->t9_drop_src[3], tx->t9_drop_src[4], tx->t9_drop_src[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t9_drop_lrc", tx->t9_drop_lrc[0], tx->t9_drop_lrc[1], tx->t9_drop_lrc[2], tx->t9_drop_lrc[3], tx->t9_drop_lrc[4], tx->t9_drop_lrc[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t9_drop_others", tx->t9_drop_others[0], tx->t9_drop_others[1], tx->t9_drop_others[2], tx->t9_drop_others[3], tx->t9_drop_others[4], tx->t9_drop_others[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t10_com_succ", tx->t10_complete_succ[0], tx->t10_complete_succ[1], tx->t10_complete_succ[2], tx->t10_complete_succ[3], tx->t10_complete_succ[4], tx->t10_complete_succ[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t10_com_cts", tx->t10_complete_cts_err[0], tx->t10_complete_cts_err[1], tx->t10_complete_cts_err[2], tx->t10_complete_cts_err[3], tx->t10_complete_cts_err[4], tx->t10_complete_cts_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t10_com_ack", tx->t10_complete_ack_err[0], tx->t10_complete_ack_err[1], tx->t10_complete_ack_err[2], tx->t10_complete_ack_err[3], tx->t10_complete_ack_err[4], tx->t10_complete_ack_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t10_com_data", tx->t10_complete_data_err[0], tx->t10_complete_data_err[1], tx->t10_complete_data_err[2], tx->t10_complete_data_err[3], tx->t10_complete_data_err[4], tx->t10_complete_data_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t10_com_other", tx->t10_complete_other_err[0], tx->t10_complete_other_err[1], tx->t10_complete_other_err[2], tx->t10_complete_other_err[3], tx->t10_complete_other_err[4], tx->t10_complete_other_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t11_timeout", tx->t11_timeout[0], tx->t11_timeout[1], tx->t11_timeout[2], tx->t11_timeout[3], tx->t11_timeout[4], tx->t11_timeout[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t12_collision", tx->t12_collision[0], tx->t12_collision[1], tx->t12_collision[2], tx->t12_collision[3], tx->t12_collision[4], tx->t12_collision[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t13_com_rts", tx->t13_complete_rts_collision_err[0], tx->t13_complete_rts_collision_err[1], tx->t13_complete_rts_collision_err[2], tx->t13_complete_rts_collision_err[3], tx->t13_complete_rts_collision_err[4], tx->t13_complete_rts_collision_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t13_com_rtsseck", tx->t13_complete_rts_seckid_err[0], tx->t13_complete_rts_seckid_err[1], tx->t13_complete_rts_seckid_err[2], tx->t13_complete_rts_seckid_err[3], tx->t13_complete_rts_seckid_err[4], tx->t13_complete_rts_seckid_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t14_com_data", tx->t14_complete_data_collision_err[0], tx->t14_complete_data_collision_err[1], tx->t14_complete_data_collision_err[2], tx->t14_complete_data_collision_err[3], tx->t14_complete_data_collision_err[4], tx->t14_complete_data_collision_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t14_com_dseckid", tx->t14_complete_data_seckid_err[0], tx->t14_complete_data_seckid_err[1], tx->t14_complete_data_seckid_err[2], tx->t14_complete_data_seckid_err[3], tx->t14_complete_data_seckid_err[4], tx->t14_complete_data_seckid_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t14_com_dzero", tx->t14_complete_data_zero_err[0], tx->t14_complete_data_zero_err[1], tx->t14_complete_data_zero_err[2], tx->t14_complete_data_zero_err[3], tx->t14_complete_data_zero_err[4], tx->t14_complete_data_zero_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t14_com_dother", tx->t14_complete_data_other_err[0], tx->t14_complete_data_other_err[1], tx->t14_complete_data_other_err[2], tx->t14_complete_data_other_err[3], tx->t14_complete_data_other_err[4], tx->t14_complete_data_other_err[5]);
ESP_LOGI(TAG, "%16s %8x %8x %8x %8x %8x %8x",
"t15_send_bar", tx->t15_send_bar[0], tx->t15_send_bar[1], tx->t15_send_bar[2], tx->t15_send_bar[3], tx->t15_send_bar[4], tx->t15_send_bar[5]);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"ifx", "data_all", "arp", "raw", "dhcp", "ps_q",
"drop_arg", "drop_if", "drop_all", "drop_nul", "drop_run");
ESP_LOGI(TAG, "%8s %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
"sta", tx->tx[0].tx_data_all, tx->tx[0].tx_arp, tx->tx[0].tx_raw, tx->tx[0].tx_dhcp, tx->tx[0].tx_ps_q,
tx->tx[0].tx_drop_data_arg, tx->tx[0].tx_drop_data_if, tx->tx[0].tx_drop_data_all, tx->tx[0].tx_drop_data_conn_null, tx->tx[0].tx_drop_data_not_run);
ESP_LOGI(TAG, "%8s %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
"ap", tx->tx[1].tx_data_all, tx->tx[1].tx_arp, tx->tx[1].tx_raw, tx->tx[1].tx_dhcp, tx->tx[1].tx_ps_q,
tx->tx[1].tx_drop_data_arg, tx->tx[1].tx_drop_data_if, tx->tx[1].tx_drop_data_all, tx->tx[1].tx_drop_data_conn_null, tx->tx[1].tx_drop_data_not_run);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"ifx", "drop_asso", "drop_ath", "drop_nme", "drop_qfu", "drop_pfl", "drop_buf",
"drop_ps", "yield", "not_home", "nh_free", "nh_scan");
ESP_LOGI(TAG, "%8s %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
"sta", tx->tx[0].tx_drop_data_not_assoc, tx->tx[0].tx_drop_data_not_auth, tx->tx[0].tx_drop_data_no_mem,
tx->tx[0].tx_drop_data_qfull, tx->tx[0].tx_drop_data_post_fail, tx->tx[0].tx_drop_data_buf, tx->tx[0].tx_drop_data_ps,
tx->tx[0].tx_task_yield, tx->tx[0].tx_buffer_not_home_chan, tx->tx[0].tx_buffer_not_home_chan_free, tx->tx[0].tx_buffer_not_home_chan_scan);
ESP_LOGI(TAG, "%8s %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
"ap", tx->tx[1].tx_drop_data_not_assoc, tx->tx[1].tx_drop_data_not_auth, tx->tx[1].tx_drop_data_no_mem,
tx->tx[1].tx_drop_data_qfull, tx->tx[1].tx_drop_data_post_fail, tx->tx[1].tx_drop_data_buf, tx->tx[1].tx_drop_data_ps,
tx->tx[1].tx_task_yield, tx->tx[1].tx_buffer_not_home_chan, tx->tx[1].tx_buffer_not_home_chan_free, tx->tx[1].tx_buffer_not_home_chan_scan);
}
static void wifi_debug_dump_sleep(const wifi_stats_optional_t *pm)
{
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "========> PM counter");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %8s %8s %8s",
"bnc_invl", "dtim", "listen", "tbtt", "rx_bcn", "act_to", "wake_tx", "wake_tbt", "wake_tim", "wake_dtim");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %8x %8x %8x",
pm->pm_bcn_interval, pm->pm_dtim_period, pm->pm_listen_interval, pm->pm_tbtt, pm->pm_rx_bcn,
pm->pm_active_timeout, pm->pm_wake_tx, pm->pm_wake_tbtt, pm->pm_wake_tim, pm->pm_wake_dtim);
ESP_LOGI(TAG, "");
ESP_LOGI(TAG, "%8s %8s %8s %8s %8s %8s %8s %16s %16s %16s",
"slp_null", "wake_nul", "sleep", "wake", "bcn_dlay",
"maxb_dl", "avgb_dl", "sleep_t", "wake_t", "total_t");
ESP_LOGI(TAG, "%8x %8x %8x %8x %8x %8x %8x %16llx %16llx %16llx",
pm->pm_sleep_null, pm->pm_wake_null, pm->pm_sleep, pm->pm_wake, pm->pm_bcn_delay_time,
pm->pm_max_bcn_delay_time, pm->pm_avg_bcn_delay_time, pm->pm_sleep_time, pm->pm_wake_time, pm->pm_total_time);
}
void esp_wifi_dump_stats(const wifi_stats_t *stats, uint64_t modules)
{
if (modules & WIFI_MODULE_HW_DIAG) {
wifi_debug_dump_diag(&stats->mandatory.reg.diag);
}
if (modules & WIFI_MODULE_HW_COUNTERS) {
wifi_debug_dump_cnt(&stats->mandatory.reg.cnt);
}
if (modules & WIFI_MODULE_HW_MISC) {
wifi_debug_dump_misc(&stats->mandatory.reg.misc);
}
if (modules & WIFI_MODULE_INT_COUNTERS) {
wifi_debug_dump_int(&stats->mandatory.interrupt);
}
if (modules & WIFI_MODULE_BUFFER_COUNTERS) {
wifi_debug_dump_buf(stats);
}
if (modules & WIFI_MODULE_RX_COUNTERS) {
wifi_debug_dump_rx(&stats->optional);
}
if (modules & WIFI_MODULE_TX_COUNTERS) {
wifi_debug_dump_tx(&stats->optional);
}
if (modules & WIFI_MODULE_SLEEP) {
wifi_debug_dump_sleep(&stats->optional);
}
if (modules & WIFI_MODULE_SLEEP) {
wifi_debug_dump_sleep(&stats->optional);
}
}
void esp_wifi_dump(uint64_t modules)
{
if (modules == 0) {
return;
}
wifi_stats_t *stats = (wifi_stats_t*)wifi_malloc(sizeof(wifi_stats_t));
if (!stats) {
ESP_LOGE(TAG, "poll request: fail allocate wifi stats");
return;
}
esp_wifi_stats_get(stats);
esp_wifi_dump_stats(stats, modules);
free(stats);
}

2
components/esp32/wifi_init.c
View File

@@ -19,6 +19,7 @@
#include "esp_pm.h"
#include "soc/rtc.h"
#include "esp_mesh.h"
#include "esp_debug.h"
#if (CONFIG_ESP32_WIFI_RX_BA_WIN > CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM)
#error "WiFi configuration check: WARNING, WIFI_RX_BA_WIN should not be larger than WIFI_DYNAMIC_RX_BUFFER_NUM!"
@@ -120,6 +121,7 @@ esp_err_t esp_wifi_init(const wifi_init_config_t *config)
s_wifi_mac_time_update_cb = esp_wifi_internal_update_mac_time;
}
esp_debug_init();
return result;
}

13
components/esp_debug/CMakeLists.txt Normal file
View File

@@ -0,0 +1,13 @@
idf_build_get_property(target IDF_TARGET)
set(srcs "src/esp_debug.c")
set(include_dirs
lwip/port/esp32/include
)
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS include
PRIV_INCLUDE_DIRS
REQUIRES esp_event lwip
PRIV_REQUIRES "${target}")

228
components/esp_debug/Kconfig Normal file
View File

@@ -0,0 +1,228 @@
menu "ESP DEBUG"
config ESP32_WIFI_DEBUG_COUNTER
bool "Enable WiFi Debug Counter"
default n
help
Select this option to enable more debug counters
config ESP32_WIFI_DEBUG_PKT_FILTER_ENABLE
bool "Enable WiFi Packet Filter "
default n
help
Select this option to enable WiFi packet filter
menu "WiFi Packet Filter Type"
depends on ESP32_WIFI_DEBUG_PKT_FILTER_ENABLE
config ESP32_WIFI_DEBUG_PKT_FILTER_TCP
bool "Filter TCP Packets"
default n
help
Select this option to filter TCP packets.
config ESP32_WIFI_DEBUG_PKT_FILTER_UDP
bool "Filter UDP Packets"
default n
help
Select this option to filter UDP packets.
config ESP32_WIFI_DEBUG_PKT_FILTER_ARP
bool "Filter ARP Packets"
default n
help
Select this option to filter ARP packets.
config ESP32_WIFI_DEBUG_PKT_FILTER_DHCP
bool "Filter DHCP Packets"
default n
help
Select this option to filter DHCP packets.
config ESP32_WIFI_DEBUG_PKT_FILTER_DNS
bool "Filter DNS Packets"
default n
help
Select this option to filter DNS packets.
config ESP32_WIFI_DEBUG_PKT_FILTER_MDNS
bool "Filter MDNS Packets"
default n
help
Select this option to filter DNS packets.
endmenu
config ESP32_DEBUG_TASK_ENABLE
bool "Enable Debug Polling Task"
default n
help
Select this option to create debug task.
config ESP32_DEBUG_TASK_PRIORITY
int "Debug Task priority"
depends on ESP32_DEBUG_TASK_ENABLE
range 1 23
default 10
help
Set WiFi debug task priority
config ESP32_DEBUG_TASK_STACK_SIZE
int "Debug Task Stack Size"
depends on ESP32_DEBUG_TASK_ENABLE
default 3072
range 1024 65536
help
Configure WiFi debug task stack size.
config ESP32_DEBUG_TASK_POLLING_ENABLE
bool "Enable Debug Task Polling"
depends on ESP32_DEBUG_TASK_ENABLE
default n
help
Select this option to enable Debug Task Polling.
When the polling is enabled, the Debug Task query and dump the specified counters periodically.
config ESP32_DEBUG_TASK_POLLING_PERIOD
int "Debug Task Polling Period (seconds)"
depends on ESP32_DEBUG_TASK_POLLING_ENABLE
range 1 65535
default 30
help
Select this option to enable Debug Task Polling
menu "WiFi Polling Modules"
depends on ESP32_DEBUG_TASK_POLLING_ENABLE
config ESP32_DEBUG_TASK_POLLING_WIFI_HARDWARE_DIAG
bool "Polling WiFi hardware diag registers"
default n
help
Select this option to polling WiFi hardware diag registers
config ESP32_DEBUG_TASK_POLLING_WIFI_HARDWARE_COUNTERS
bool "Polling WiFi hardware counters"
default n
help
Select this option to polling WiFi hardware counters
config ESP32_DEBUG_TASK_POLLING_WIFI_HARDWARE_MISC
bool "Polling WiFi hardware misc registers"
default n
help
Select this option to polling WiFi hardware misc registers
config ESP32_DEBUG_TASK_POLLING_WIFI_BUFFER_COUNTERS
bool "Polling WiFi buffer counters"
default y
help
Select this option to polling WiFi buffer counters
config ESP32_DEBUG_TASK_POLLING_WIFI_INT_COUNTERS
bool "Polling WiFi interrupt counters"
default y
help
Select this option to polling WiFi interrupt counters
config ESP32_DEBUG_TASK_POLLING_WIFI_RX_COUNTERS
bool "Polling WiFi receiving packet counters"
default y
help
Select this option to polling WiFi receiving packet counters
config ESP32_DEBUG_TASK_POLLING_WIFI_TX_COUNTERS
bool "Polling WiFi transmitting packet counters"
default y
help
Select this option to polling WiFi transmitting packet counters
config ESP32_DEBUG_TASK_POLLING_WIFI_BUFFER_COUNTERS
bool "Polling WiFi buffer counters"
default y
help
Select this option to polling WiFi buffer counters
config ESP32_DEBUG_TASK_POLLING_WIFI_SLEEP_COUNTERS
bool "Polling WiFi sleep counters"
default y
help
Select this option to polling WiFi sleep counters
config ESP32_DEBUG_TASK_POLLING_WIFI_EVENT_COUNTERS
bool "Polling WiFi event counters"
default n
help
Select this option to polling WiFi key event counters
config ESP32_DEBUG_TASK_POLLING_WIFI_NVS_INFO
bool "Polling WiFi NVS info"
default n
help
Select this option to polling WiFi NVS info
config ESP32_DEBUG_TASK_POLLING_WIFI_STA_INFO
bool "Polling WiFi station internal info"
default n
help
Select this option to polling WiFi station internal info
config ESP32_DEBUG_TASK_POLLING_WIFI_AP_INFO
bool "Polling WiFi soft-AP internal info"
default n
help
Select this option to polling WiFi soft-AP internal info
config ESP32_DEBUG_TASK_POLLING_WIFI_TRC_INFO
bool "Polling WiFi rate control info"
default n
help
Select this option to polling WiFi rate control info
config ESP32_DEBUG_TASK_POLLING_WIFI_MEMORY_INFO
bool "Polling WiFi memory info"
default n
help
Select this option to polling WiFi memory info
endmenu
menu "LWIP Polling Modules"
depends on ESP32_DEBUG_TASK_POLLING_ENABLE
config ESP32_DEBUG_TASK_POLLING_LWIP_SOCKETS
bool "Polling LWIP sockets info"
default n
help
Select this option to polling WiFi memory info
config ESP32_DEBUG_TASK_POLLING_LWIP_PKT_COUNTER
bool "Polling LWIP packet counters"
default n
help
Select this option to polling LWIP packet counters
endmenu
menu "System Polling Modules"
depends on ESP32_DEBUG_TASK_POLLING_ENABLE
config ESP32_DEBUG_TASK_POLLING_TASK_INFO
bool "Polling task info"
default n
help
Select this option to polling LWIP packet counters
config ESP32_DEBUG_TASK_POLLING_MEMORY_INFO
bool "Polling memory info"
default n
help
Select this option to polling memory info
endmenu
endmenu

0
components/esp_debug/Makefile.projbuild Normal file
View File

5
components/esp_debug/component.mk Normal file
View File

@@ -0,0 +1,5 @@
#
# Component Makefile
#
COMPONENT_SRCDIRS := src
COMPONENT_PRIV_INCLUDEDIRS := private_include

100
components/esp_debug/include/esp_debug.h Normal file
View File

@@ -0,0 +1,100 @@
// Copyright 2020-2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* All the APIs declared here are internal only APIs, it can only be used by
* espressif internal modules, such as SSC, LWIP, TCPIP adapter etc, espressif
* customers are not recommended to use them.
*
* If someone really want to use specified APIs declared in here, please contact
* espressif AE/developer to make sure you know the limitations or risk of
* the API, otherwise you may get unexpected behavior!!!
*
*/
#ifndef __ESP_DEBUG_H__
#define __ESP_DEBUG_H__
#include <stdint.h>
#include <stdbool.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "sys/queue.h"
#include "esp_err.h"
#include "esp_event.h"
#include "esp_wifi.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
uint32_t diag;
} wifi_hardware_diag_t;
void esp_wifi_debug_get_hardare_diag(wifi_hardware_diag_t *reg);
void esp_wifi_debug_dump_hardware_diag(const wifi_hardware_diag_t *reg);
typedef struct {
} wifi_int_counter_t;
void esp_wifi_debug_get_int_counter(wifi_int_counter_t *cnt);
void esp_wifi_debug_dump_int_counter(const wifi_int_counter_t *cnt);
/* Polling type definition
* - bit0 is for debug task deleting
* - bit1~15 is for system info polling
* - bit16~31 is for LWIP info polling
* - bit32~63 is for WiFi info polling
*/
#define DEBUG_MODULE_TASK_DELETE 1
#define DEBUG_MODULE_SYS_MEM (1ULL<<1)
#define DEBUG_MODULE_SYS_TASK (1ULL<<2)
#define DEBUG_MODULE_LWIP_SOCKETS (1ULL<<16)
#define DEBUG_MODULE_LWIP_STATS (1ULL<<17)
#define DEBUG_MODULE_WIFI_HW_DIAG (1ULL<<32)
#define DEBUG_MODULE_WIFI_HW_COUNTERS (1ULL<<33)
#define DEBUG_MODULE_WIFI_HW_MISC (1ULL<<34)
#define DEBUG_MODULE_WIFI_INT_COUNTERS (1ULL<<35)
#define DEBUG_MODULE_WIFI_RX_COUNTERS (1ULL<<36)
#define DEBUG_MODULE_WIFI_TX_COUNTERS (1ULL<<37)
#define DEBUG_MODULE_WIFI_BUFFER_COUNTERS (1ULL<<38)
#define DEBUG_MODULE_WIFI_SLEEP_COUNTERS (1ULL<<39)
#define DEBUG_MODULE_WIFI_EVENT_COUNTERS (1ULL<<40)
#define DEBUG_MODULE_WIFI_NVS (1ULL<<41)
#define DEBUG_MODULE_WIFI_STA (1ULL<<42)
#define DEBUG_MODULE_WIFI_AP (1ULL<<43)
#define DEBUG_MODULE_WIFI_TRC (1ULL<<44)
#define DEBUG_MODULE_ALL (0xFFFFFFFFFFFFFFFE)
typedef uint64_t wifi_polling_request_t;
void esp_lwip_debug_dump_sockets(void);
void esp_lwip_debug_dump_stats(void);
void esp_lwip_dump(uint64_t modules);
esp_err_t esp_debug_init(void);
esp_err_t esp_debug_deinit(void);
esp_err_t esp_debug_poll(wifi_polling_request_t request);
#ifdef __cplusplus
}
#endif
#endif /* __WIFI_DEBUG_H__ */

359
components/esp_debug/src/esp_debug.c Normal file
View File

@@ -0,0 +1,359 @@
// Copyright 2015-2017 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <esp_event.h>
#include <esp_wifi.h>
#include "esp_log.h"
#include "esp_wifi_internal.h"
#include "esp_debug.h"
#include "wifi_debug.h"
#define TAG "wdbg"
static bool s_debug_init = false;
#if CONFIG_ESP32_DEBUG_TASK_ENABLE
#define WIFI_DEBUG_TASK_QUEUE_SIZE 5
static SemaphoreHandle_t s_debug_mutex = NULL;
static QueueHandle_t s_debug_task_queue = NULL;
static bool s_debug_task_init = false;
void debug_lock(void)
{
if (s_debug_mutex) {
xSemaphoreTake(s_debug_mutex, portMAX_DELAY);
} else {
s_debug_mutex = xSemaphoreCreateMutex();
if (!s_debug_mutex) {
ESP_LOGE(TAG, "fail to create mutex");
abort();
} else {
xSemaphoreTake(s_debug_mutex, portMAX_DELAY);
}
}
}
void debug_unlock(void)
{
if (s_debug_mutex) {
xSemaphoreGive(s_debug_mutex);
} else {
ESP_LOGE(TAG, "unlock null mutex");
abort();
}
}
static uint64_t debug_periodical_request(void)
{
uint64_t request = 0;
#if CONFIG_ESP32_DEBUG_TASK_POLLING_LWIP_SOCKETS
request |= DEBUG_MODULE_LWIP_SOCKETS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_LWIP_STATS
request |= DEBUG_MODULE_LWIP_STATISTICS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_HARDWARE_DIAG
request |= DEBUG_MODULE_WIFI_HW_DIAG;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_HARDWARE_COUNTERS
request |= DEBUG_MODULE_WIFI_HW_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_HARDWARE_MISC
request |= DEBUG_MODULE_WIFI_HW_MISC;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_INT_COUNTERS
request |= DEBUG_MODULE_WIFI_INT_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_RX_COUNTERS
request |= DEBUG_MODULE_WIFI_RX_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_TX_COUNTERS
request |= DEBUG_MODULE_WIFI_TX_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_BUFFER_COUNTERS
request |= DEBUG_MODULE_WIFI_BUFFER_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_SLEEP_COUNTERS
request |= DEBUG_MODULE_WIFI_SLEEP_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_EVENT_COUNTERS
request |= DEBUG_MODULE_WIFI_EVENT_COUNTERS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_NVS_INFO
request |= DEBUG_MODULE_WIFI_NVS;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_STA_INFO
request |= DEBUG_MODULE_WIFI_STA;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_AP_INFO
request |= DEBUG_MODULE_WIFI_AP;
#endif
#if CONFIG_ESP32_DEBUG_TASK_POLLING_WIFI_TRC_INFO
request |= DEBUG_MODULE_WIFI_TRC;
#endif
return request;
}
static uint64_t debug_modules_to_lwip_modules(uint64_t modules)
{
uint64_t lwip_modules = 0;
if (modules & DEBUG_MODULE_LWIP_SOCKETS) {
lwip_modules |= 1;//LWIP_MODULE_SOCKETS;
}
if (modules & DEBUG_MODULE_LWIP_STATS) {
lwip_modules |= 1<<1;//LWIP_MODULE_STATS;
}
return lwip_modules;
}
static uint64_t debug_modules_to_wifi_modules(uint64_t modules)
{
uint64_t wifi_modules = 0;
if (modules & DEBUG_MODULE_WIFI_HW_DIAG) {
wifi_modules |= WIFI_MODULE_HW_DIAG;
}
if (modules & DEBUG_MODULE_WIFI_HW_COUNTERS) {
wifi_modules |= WIFI_MODULE_HW_COUNTERS;
}
if (modules & DEBUG_MODULE_WIFI_INT_COUNTERS) {
wifi_modules |= WIFI_MODULE_INT_COUNTERS;
}
if (modules & DEBUG_MODULE_WIFI_RX_COUNTERS) {
wifi_modules |= WIFI_MODULE_RX_COUNTERS;
}
if (modules & DEBUG_MODULE_WIFI_TX_COUNTERS) {
wifi_modules |= WIFI_MODULE_TX_COUNTERS;
}
if (modules & DEBUG_MODULE_WIFI_BUFFER_COUNTERS) {
wifi_modules |= WIFI_MODULE_BUFFER_COUNTERS;
}
if (modules & DEBUG_MODULE_WIFI_SLEEP_COUNTERS) {
wifi_modules |= WIFI_MODULE_SLEEP;
}
if (modules & DEBUG_MODULE_WIFI_EVENT_COUNTERS) {
wifi_modules |= WIFI_MODULE_EVENT_COUNTERS;
}
if (modules & DEBUG_MODULE_WIFI_NVS) {
wifi_modules |= WIFI_MODULE_NVS;
}
if (modules & DEBUG_MODULE_WIFI_STA) {
wifi_modules |= WIFI_MODULE_STA;
}
if (modules & DEBUG_MODULE_WIFI_AP) {
wifi_modules |= WIFI_MODULE_AP;
}
if (modules & DEBUG_MODULE_WIFI_TRC) {
wifi_modules |= WIFI_MODULE_TRC;
}
return wifi_modules;
}
static void debug_process_request(wifi_polling_request_t request)
{
uint64_t modules = 0;
ESP_LOGI(TAG, "poll begin, type=%llx, ram=%d mini=%d", request, esp_get_free_heap_size(), esp_get_minimum_free_heap_size());
modules = debug_modules_to_lwip_modules(request);
esp_lwip_dump(modules);
modules = debug_modules_to_wifi_modules(request);
esp_wifi_dump(modules);
ESP_LOGI(TAG, "poll end, ram=%d mini=%d", esp_get_free_heap_size(), esp_get_minimum_free_heap_size());
}
static void debug_task(void *param)
{
wifi_polling_request_t request = 0;
uint32_t timeout = portMAX_DELAY;
#if CONFIG_ESP32_DEBUG_TASK_POLLING_ENABLE
timeout = (CONFIG_ESP32_DEBUG_TASK_POLLING_PERIOD * 1000) / portTICK_RATE_MS;
#endif
while (1) {
if (pdTRUE != xQueueReceive(s_debug_task_queue, &request, timeout)) {
request = debug_periodical_request();
}
debug_process_request(request);
if (request == DEBUG_MODULE_TASK_DELETE) {
break;
}
}
vQueueDelete(s_debug_task_queue);
s_debug_task_queue = NULL;
vTaskDelete(NULL);
}
esp_err_t debug_task_create(void)
{
int ret;
debug_lock();
if (s_debug_task_init == true) {
ESP_LOGE(TAG, "wifi init task already created");
debug_unlock();
return ESP_OK;
}
s_debug_task_queue = xQueueCreate(WIFI_DEBUG_TASK_QUEUE_SIZE, sizeof(wifi_polling_request_t));
if (!s_debug_task_queue) {
ESP_LOGE(TAG, "fail to create debug task queue");
debug_unlock();
return ESP_FAIL;
}
ret = xTaskCreate(debug_task, "wifi_debug", CONFIG_ESP32_DEBUG_TASK_STACK_SIZE, NULL, CONFIG_ESP32_DEBUG_TASK_PRIORITY, NULL);
if (pdTRUE != ret) {
ESP_LOGE(TAG, "fail to create debug task");
vQueueDelete(s_debug_task_queue);
s_debug_task_queue = NULL;
debug_unlock();
return ESP_FAIL;
}
s_debug_task_init = true;
debug_unlock();
ESP_LOGI(TAG, "wifi debug task created");
return ESP_OK;
}
static void debug_task_delete(void)
{
wifi_polling_request_t request = DEBUG_MODULE_TASK_DELETE;
debug_lock();
if (false == s_debug_task_init) {
ESP_LOGI(TAG, "wifi debug task already deleted");
debug_unlock();
return;
}
//post delete event to WiFi debug task with blocking
xQueueSend(s_debug_task_queue, &request, portMAX_DELAY);
/* Wait until debug task is deleted */
do {
vTaskDelay(1);
} while (s_debug_task_queue);
s_debug_task_init = false;
debug_unlock();
ESP_LOGI(TAG, "wifi debug task deleted");
return;
}
esp_err_t esp_debug_poll(wifi_polling_request_t request)
{
debug_lock();
if (false == s_debug_task_init) {
ESP_LOGE(TAG, "wifi debug task not created");
debug_unlock();
return ESP_FAIL;
}
//post event to WiFi debug task without any blocking
if (pdTRUE != xQueueSend(s_debug_task_queue, &request, 0) ) {
ESP_LOGW(TAG, "failed to post polling event=%llx", request);
}
debug_unlock();
return ESP_OK;
}
#else
esp_err_t esp_debug_poll(wifi_polling_request_t request)
{
ESP_LOGE(TAG, "poll disabled");
return ESP_OK;
}
#endif
esp_err_t esp_debug_init(void)
{
esp_err_t ret = ESP_OK;
if (true == s_debug_init) {
return ESP_OK;
}
// TODO Set Packets Filter
ret = esp_wifi_stats_init();
if (ESP_OK != ret) {
return ESP_FAIL;
}
#if CONFIG_ESP32_DEBUG_TASK_ENABLE
//Create polling task
ret = debug_task_create();
if (ESP_OK != ret) {
esp_wifi_stats_deinit();
return ESP_FAIL;
}
#endif
s_debug_init = true;
return ESP_OK;
}
esp_err_t esp_debug_deinit(void)
{
if (false == s_debug_init) {
return ESP_OK;
}
esp_wifi_stats_deinit();
#if CONFIG_ESP32_DEBUG_TASK_ENABLE
debug_task_delete();
#endif
s_debug_init = false;
return ESP_OK;
}

2
components/lwip/lwip

Submodule components/lwip/lwip updated: f8e38d3f60...68ba3db3f1

1030
components/lwip/port/esp32/debug/lwip_debug.c
View File

File diff suppressed because it is too large Load Diff

4
components/lwip/port/esp32/freertos/sys_arch.c
View File

@@ -40,6 +40,7 @@
#include "arch/sys_arch.h"
#include "lwip/stats.h"
#include "esp_log.h"
#include "debug/lwip_debug.h"
/* This is the number of threads that can be started with sys_thread_new() */
#define SYS_THREAD_MAX 4
@@ -249,6 +250,7 @@ sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
} else {
LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("trypost mbox=%p fail\n", (*mbox)->os_mbox));
xReturn = ERR_MEM;
SYS_ARCH_INC_WITH_LOCK(trypost_fail);
}
return xReturn;
@@ -304,6 +306,7 @@ sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
ulReturn = Elapsed;
} else { // timed out blocking for message
SYS_ARCH_INC_WITH_LOCK(fetch_fail);
ulReturn = SYS_ARCH_TIMEOUT;
}
@@ -325,6 +328,7 @@ sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
ulReturn = ERR_OK;
} else {
ulReturn = SYS_MBOX_EMPTY;
SYS_ARCH_INC_WITH_LOCK(tryfetch_fail);
}
return ulReturn;

25
components/lwip/port/esp32/include/debug/lwip_debug.h
View File

@@ -16,10 +16,25 @@
#ifndef _LWIP_DEBUG_H
#define _LWIP_DEBUG_H
void dbg_lwip_tcp_pcb_show(void);
void dbg_lwip_udp_pcb_show(void);
void dbg_lwip_tcp_rxtx_show(void);
void dbg_lwip_udp_rxtx_show(void);
void dbg_lwip_mem_cnt_show(void);
#include "esp_log.h"
typedef struct {
uint32_t trypost_fail;
uint32_t fetch_fail;
uint32_t tryfetch_fail;
} esp_lwip_stats_t;
extern esp_lwip_stats_t g_esp_lwip_stats;
#define SYS_ARCH_INC_WITH_LOCK(_f) do {\
sys_arch_protect();\
g_esp_lwip_stats._f ++;\
sys_arch_unprotect(0);\
}while(0)
#define LWIP_MODULE_SOCKETS 1
#define LWIP_MODULE_STATS (1<<1)
void esp_lwip_dump(uint64_t modules);
#endif