void
bcm_assert_log(char *str)
{
bcm_assert_info_t *g_assert_hdl = &g_assert_info;
assert_record_t *cur_record;
if (g_assert_hdl->ref_cnt == 0)
return;
ASSERT_LOCK(g_assert_hdl);
cur_record = &g_assert_hdl->assert_table[g_assert_hdl->cur_idx];
cur_record->time = OSL_SYSUPTIME();
cur_record->seq_num = g_assert_hdl->seq_num++;
if (str) {
memset(cur_record->str, 0, MAX_ASSRTSTR_LEN);
memcpy(cur_record->str, str, MAX_ASSRTSTR_LEN - 1);
}
g_assert_hdl->cur_idx = MODINC(g_assert_hdl->cur_idx, MAX_ASSERT_NUM);
ASSERT_UNLOCK(g_assert_hdl);
return;
}
static char *getTimestamp(traceLevelE level)
{
static char buffer[32] = {0};
#if !defined(BCMDRIVER)
struct timeval tv;
struct tm tm;
#endif /* !BCMDRIVER */
if (level == TRACE_PRINTF) {
/* no timestamp for printf */
buffer[0] = 0;
}
else {
#if !defined(BCMDRIVER)
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, &tm);
snprintf(buffer, sizeof(buffer), "%d:%02d:%02d.%03d - ",
tm.tm_hour, tm.tm_min, tm.tm_sec, (int)tv.tv_usec / 1000);
#else
uint32 uptime = OSL_SYSUPTIME();
uint32 ms, sec, min, hour;
ms = uptime % 1000;
uptime /= 1000;
sec = uptime % 60;
uptime /= 60;
min = uptime % 60;
hour = uptime / 60;
sprintf(buffer, "%d:%02d:%02d.%03d - ",
hour, min, sec, ms);
#endif /* !BCMDRIVER */
}
return buffer;
}
bool
dhd_tcpdata_info_get(dhd_pub_t *dhdp, void *pkt)
{
uint8 *ether_hdr; /* Ethernet header of the new packet */
uint16 ether_type; /* Ethernet type of the new packet */
uint8 *ip_hdr; /* IP header of the new packet */
uint8 *tcp_hdr; /* TCP header of the new packet */
uint32 ip_hdr_len; /* IP header length of the new packet */
uint32 cur_framelen;
uint16 ip_total_len; /* Total length of IP packet for the new packet */
uint32 tcp_hdr_len; /* TCP header length of the new packet */
uint32 tcp_seq_num; /* TCP sequence number of the new packet */
uint16 tcp_data_len; /* TCP DATA length that excludes IP and TCP headers */
uint32 end_tcp_seq_num; /* TCP seq number of the last byte in the new packet */
tcpack_sup_module_t *tcpack_sup_mod;
tcpdata_info_t *tcpdata_info = NULL;
tdata_psh_info_t *tdata_psh_info;
int i;
bool ret = FALSE;
if (dhdp->tcpack_sup_mode != TCPACK_SUP_DELAYTX)
goto exit;
ether_hdr = PKTDATA(dhdp->osh, pkt);
cur_framelen = PKTLEN(dhdp->osh, pkt);
ether_type = ether_hdr[12] << 8 | ether_hdr[13];
if (ether_type != ETHER_TYPE_IP) {
DHD_TRACE(("%s %d: Not a IP packet 0x%x\n",
__FUNCTION__, __LINE__, ether_type));
goto exit;
}
DHD_TRACE(("%s %d: IP pkt! 0x%x\n", __FUNCTION__, __LINE__, ether_type));
ip_hdr = ether_hdr + ETHER_HDR_LEN;
cur_framelen -= ETHER_HDR_LEN;
ASSERT(cur_framelen >= IPV4_MIN_HEADER_LEN);
ip_hdr_len = IPV4_HLEN(ip_hdr);
if (IP_VER(ip_hdr) != IP_VER_4 || IPV4_PROT(ip_hdr) != IP_PROT_TCP) {
DHD_TRACE(("%s %d: Not IPv4 nor TCP! ip ver %d, prot %d\n",
__FUNCTION__, __LINE__, IP_VER(ip_hdr), IPV4_PROT(ip_hdr)));
goto exit;
}
tcp_hdr = ip_hdr + ip_hdr_len;
cur_framelen -= ip_hdr_len;
ASSERT(cur_framelen >= TCP_MIN_HEADER_LEN);
DHD_TRACE(("%s %d: TCP pkt!\n", __FUNCTION__, __LINE__));
ip_total_len = ntoh16_ua(&ip_hdr[IPV4_PKTLEN_OFFSET]);
tcp_hdr_len = 4 * TCP_HDRLEN(tcp_hdr[TCP_HLEN_OFFSET]);
/* This packet is mere TCP ACK, so do nothing */
if (ip_total_len == ip_hdr_len + tcp_hdr_len) {
DHD_TRACE(("%s %d: Do nothing for no data TCP ACK\n", __FUNCTION__, __LINE__));
goto exit;
}
ASSERT(ip_total_len > ip_hdr_len + tcp_hdr_len);
if ((tcp_hdr[TCP_FLAGS_OFFSET] & TCP_FLAG_PSH) == 0) {
DHD_TRACE(("%s %d: Not interested TCP DATA packet\n", __FUNCTION__, __LINE__));
goto exit;
}
DHD_TRACE(("%s %d: TCP DATA with nonzero DATA length"
" IP addr "IPV4_ADDR_STR" "IPV4_ADDR_STR" TCP port %d %d, flag 0x%x\n",
__FUNCTION__, __LINE__,
IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET]),
tcp_hdr[TCP_FLAGS_OFFSET]));
dhd_os_tcpacklock(dhdp);
tcpack_sup_mod = dhdp->tcpack_sup_module;
if (!tcpack_sup_mod) {
DHD_ERROR(("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
ret = BCME_ERROR;
dhd_os_tcpackunlock(dhdp);
goto exit;
}
/* Look for tcpdata_info that has the same ip src/dst addrs and tcp src/dst ports */
i = 0;
while (i < tcpack_sup_mod->tcpdata_info_cnt) {
tcpdata_info_t *tdata_info_tmp = &tcpack_sup_mod->tcpdata_info_tbl[i];
uint32 now_in_ms = OSL_SYSUPTIME();
DHD_TRACE(("%s %d: data info[%d], IP addr "IPV4_ADDR_STR" "IPV4_ADDR_STR
" TCP port %d %d\n", __FUNCTION__, __LINE__, i,
IPV4_ADDR_TO_STR(ntoh32_ua(tdata_info_tmp->src_ip_addr)),
IPV4_ADDR_TO_STR(ntoh32_ua(tdata_info_tmp->dst_ip_addr)),
ntoh16_ua(tdata_info_tmp->src_tcp_port),
ntoh16_ua(tdata_info_tmp->dst_tcp_port)));
/* If both IP address and TCP port number match, we found it so break. */
if (memcmp(&ip_hdr[IPV4_SRC_IP_OFFSET],
tdata_info_tmp->src_ip_addr, IPV4_ADDR_LEN * 2) == 0 &&
memcmp(&tcp_hdr[TCP_SRC_PORT_OFFSET],
tdata_info_tmp->src_tcp_port, TCP_PORT_LEN * 2) == 0) {
tcpdata_info = tdata_info_tmp;
tcpdata_info->last_used_time = now_in_ms;
break;
}
if (now_in_ms - tdata_info_tmp->last_used_time > TCPDATA_INFO_TIMEOUT) {
tdata_psh_info_t *tdata_psh_info_tmp;
tcpdata_info_t *last_tdata_info;
while ((tdata_psh_info_tmp = tdata_info_tmp->tdata_psh_info_head)) {
tdata_info_tmp->tdata_psh_info_head = tdata_psh_info_tmp->next;
tdata_psh_info_tmp->next = NULL;
DHD_TRACE(("%s %d: Clean tdata_psh_info(end_seq %u)!\n",
__FUNCTION__, __LINE__, tdata_psh_info_tmp->end_seq));
_tdata_psh_info_pool_enq(tcpack_sup_mod, tdata_psh_info_tmp);
}
#ifdef DHDTCPACK_SUP_DBG
DHD_ERROR(("%s %d: PSH INFO ENQ %d\n",
__FUNCTION__, __LINE__, tcpack_sup_mod->psh_info_enq_num));
#endif /* DHDTCPACK_SUP_DBG */
tcpack_sup_mod->tcpdata_info_cnt--;
ASSERT(tcpack_sup_mod->tcpdata_info_cnt >= 0);
last_tdata_info =
&tcpack_sup_mod->tcpdata_info_tbl[tcpack_sup_mod->tcpdata_info_cnt];
if (i < tcpack_sup_mod->tcpdata_info_cnt) {
ASSERT(last_tdata_info != tdata_info_tmp);
bcopy(last_tdata_info, tdata_info_tmp, sizeof(tcpdata_info_t));
}
bzero(last_tdata_info, sizeof(tcpdata_info_t));
DHD_TRACE(("%s %d: tcpdata_info(idx %d) is aged out. ttl cnt is now %d\n",
__FUNCTION__, __LINE__, i, tcpack_sup_mod->tcpdata_info_cnt));
/* Don't increase "i" here, so that the prev last tcpdata_info is checked */
} else
i++;
}
tcp_seq_num = ntoh32_ua(&tcp_hdr[TCP_SEQ_NUM_OFFSET]);
tcp_data_len = ip_total_len - ip_hdr_len - tcp_hdr_len;
end_tcp_seq_num = tcp_seq_num + tcp_data_len;
if (tcpdata_info == NULL) {
ASSERT(i == tcpack_sup_mod->tcpdata_info_cnt);
if (i >= TCPDATA_INFO_MAXNUM) {
DHD_TRACE(("%s %d: tcp_data_info_tbl FULL! %d %d"
" IP addr "IPV4_ADDR_STR" "IPV4_ADDR_STR" TCP port %d %d\n",
__FUNCTION__, __LINE__, i, tcpack_sup_mod->tcpdata_info_cnt,
IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET])));
dhd_os_tcpackunlock(dhdp);
goto exit;
}
tcpdata_info = &tcpack_sup_mod->tcpdata_info_tbl[i];
/* No TCP flow with the same IP addr and TCP port is found
* in tcp_data_info_tbl. So add this flow to the table.
*/
DHD_TRACE(("%s %d: Add data info to tbl[%d]: IP addr "IPV4_ADDR_STR" "IPV4_ADDR_STR
" TCP port %d %d\n",
__FUNCTION__, __LINE__, tcpack_sup_mod->tcpdata_info_cnt,
IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET])));
bcopy(&ip_hdr[IPV4_SRC_IP_OFFSET], tcpdata_info->src_ip_addr,
IPV4_ADDR_LEN * 2);
bcopy(&tcp_hdr[TCP_SRC_PORT_OFFSET], tcpdata_info->src_tcp_port,
TCP_PORT_LEN * 2);
tcpdata_info->last_used_time = OSL_SYSUPTIME();
tcpack_sup_mod->tcpdata_info_cnt++;
}
ASSERT(tcpdata_info != NULL);
tdata_psh_info = _tdata_psh_info_pool_deq(tcpack_sup_mod);
#ifdef DHDTCPACK_SUP_DBG
DHD_TRACE(("%s %d: PSH INFO ENQ %d\n",
__FUNCTION__, __LINE__, tcpack_sup_mod->psh_info_enq_num));
#endif /* DHDTCPACK_SUP_DBG */
if (tdata_psh_info == NULL) {
DHD_ERROR(("%s %d: No more free tdata_psh_info!!\n", __FUNCTION__, __LINE__));
ret = BCME_ERROR;
dhd_os_tcpackunlock(dhdp);
goto exit;
}
tdata_psh_info->end_seq = end_tcp_seq_num;
#if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
tack_tbl.cnt[4]++;
#endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
DHD_TRACE(("%s %d: TCP PSH DATA recvd! end seq %u\n",
__FUNCTION__, __LINE__, tdata_psh_info->end_seq));
ASSERT(tdata_psh_info->next == NULL);
if (tcpdata_info->tdata_psh_info_head == NULL)
tcpdata_info->tdata_psh_info_head = tdata_psh_info;
else {
ASSERT(tcpdata_info->tdata_psh_info_tail);
tcpdata_info->tdata_psh_info_tail->next = tdata_psh_info;
}
tcpdata_info->tdata_psh_info_tail = tdata_psh_info;
dhd_os_tcpackunlock(dhdp);
exit:
return ret;
}