VOS_VOID RNIC_ShowDataFromIpStack(
struct sk_buff *pstSkb
)
{
VOS_UINT32 i;
PS_PRINTF("RNIC_ShowDataFromIpStack: data len is %d. \r\n", pstSkb->len);
PS_PRINTF("RNIC_ShowDataFromIpStack: data content is: \r\n");
for (i = 0; i < pstSkb->len; i++)
{
if (pstSkb->data[i] > 0xf)
{
PS_PRINTF("%x", pstSkb->data[i]);
}
else
{
PS_PRINTF("0%x", pstSkb->data[i]);
}
}
PS_PRINTF("\r\n");
return;
}
VOS_VOID RNIC_Help(VOS_VOID)
{
PS_PRINTF("********************RNIC调试信息************************\n");
PS_PRINTF("RNIC_ShowULProcStats ucRmNetId 显示指定RNIC网卡上行统计信息\n");
PS_PRINTF("RNIC_ShowDLProcStats ucRmNetId 显示指定RNIC网卡下行统计信息\n");
PS_PRINTF("RNIC_ShowRnicPdpStats ucRmNetId 显示指定RNIC网卡PDP激活信息\n");
PS_PRINTF("RNIC_ShowResetStats 显示指定RNIC复位状态信息\n");
return;
}
VOS_VOID RNIC_ShowRmnetConfigCheckInfo(VOS_VOID)
{
PS_PRINTF("Totla req %d\n", g_stRnicRmnetConfigCheckInfo.ucTotlaCnt);
PS_PRINTF("Modem type err %d\n", g_stRnicRmnetConfigCheckInfo.ucModemTypeErrCnt);
PS_PRINTF("Rmnet id err %d\n", g_stRnicRmnetConfigCheckInfo.ucRmNetIdErrCnt);
PS_PRINTF("Modem ID err %d\n", g_stRnicRmnetConfigCheckInfo.ucModemIdErrCnt);
PS_PRINTF("Pdn ID err %d\n", g_stRnicRmnetConfigCheckInfo.ucPdnIdErrCnt);
PS_PRINTF("Rab ID err %d\n", g_stRnicRmnetConfigCheckInfo.ucRabIdErrCnt);
PS_PRINTF("Rmnet status err %d\n", g_stRnicRmnetConfigCheckInfo.ucRmnetStatusErrCnt);
PS_PRINTF("IP type err %d\n", g_stRnicRmnetConfigCheckInfo.ucIpTypeErrCnt);
PS_PRINTF("Send err %d\n", g_stRnicRmnetConfigCheckInfo.ucSendErrCnt);
PS_PRINTF("Success %d\n", g_stRnicRmnetConfigCheckInfo.ucSuccCnt);
}
static int
ps_attach(struct socket *so, int proto, struct thread *td) {
struct pspcb *psp = sotopspcb(so);
int error;
PS_PRINTF(PS_DEBUG_SOCKET, "so = %p, proto=%d\n", so, proto);
if (NULL != psp)
return (EISCONN);
error = soreserve(so, ps_sendspace, ps_recvspace);
if (error)
return (error);
psp = malloc(sizeof(struct pspcb), M_PCB, M_WAITOK | M_ZERO);
rw_init(&psp->psp_lock, "psp_lock");
psp->psp_ifp = NULL;
so->so_pcb = (caddr_t)psp;
psp->psp_socket = so;
mtx_lock(pspcb_lock);
LIST_INSERT_HEAD(pspcbhead, psp, psp_list);
mtx_unlock(pspcb_lock);
return (0);
}
static int
dir_scope2dents(struct psfs_node *pnode, struct uio *uio, u_long *cookies,
off_t cnt, int *eofflag, boolean_t only_sids)
{
int error = 0;
off_t off;
int index;
struct dir_iter arg;
KASSERT(0 == uio->uio_offset % DIRSIZ_RID && uio->uio_offset >= DIRSIZ_RID,
("Invalid uio_offset %ld", uio->uio_offset));
off = uio->uio_offset;
/* XXX: Move from zero based indeces to 1 based indeces for scope_iter? */
index = (uio->uio_offset / DIRSIZ_RID) - 1;
arg.di_uio = uio;
arg.di_cookies = cookies;
arg.di_count = 0;
arg.di_type = pnode->pn_type;
arg.di_only_sids = only_sids;
error = ps_scope_iterate(pnode->pn_pubi, dir_scopeiter, index, cnt, &arg, eofflag);
if (cnt != arg.di_count) {
/* XXX: We cannot KASSERT this (can we), as it may change due to other activity? */
PS_PRINTF(PS_DEBUG_DIR | PS_DEBUG_WARNING,
"WARNING: count changed during runtime: %ld != %ld, error=%d\n",
cnt, arg.di_count, error);
}
KASSERT((0 == uio->uio_offset % DIRSIZ_RID && uio->uio_offset >= DIRSIZ_RID),
("Invalid uio_offset %ld", uio->uio_offset));
return error;
}
int
psfs_dir_cntdents(struct psfs_node *pnode, off_t *cntp)
{
int error = 0;
off_t cnt = 0;
ps_pubi_t pi;
PS_PRINTF(PS_DEBUG_DIR, "pnode=%p\n", pnode);
switch (pnode->pn_type) {
case VROOT:
error = ps_scope_get_rid_count(pnode->pn_pubi, &cnt, TRUE);
if (error)
return error;
cnt += sizeof(des_root)/sizeof(des_root[0]);
break;
case VSCOPE:
error = ps_scope_get_rid_count(pnode->pn_pubi, &cnt, FALSE);
if (error)
return error;
cnt += sizeof(des_scope)/sizeof(des_scope[0]);
break;
case VPUB:
case VVER:
error = ps_pit_get(pnode->pn_rid, &pi);
if (error) return error;
PS_OBJ_PUBI_ASSERT_OWNED(pi);
error = ps_obj_get_version_count(pi, &cnt);
PS_OBJ_PUBI_UNLOCK(pi);
cnt += sizeof(des_long)/sizeof(des_long[0]);
break;
case VPAGE:
cnt = sizeof(des_long)/sizeof(des_long[0]);
break;
default:
panic("psfs_dir_cntents: attempt to readdir a non-directory: pnode=%p", pnode);
}
*cntp = cnt;
PS_PRINTF(PS_DEBUG_DIR, "pnode=%p -> cnt=%ld, error=%d\n", pnode, cnt, error);
return error;
}
VOS_VOID RNIC_ShowResetStats(VOS_VOID)
{
PS_PRINTF("模块初始化标识 %d\n", g_astRnicStats[0].ulSemInitFlg);
PS_PRINTF("当前的二进制信号量 %p\n", g_stRnicCtx.hResetSem);
PS_PRINTF("创建的二进制信号量 %p\n", g_astRnicStats[0].hBinarySemId);
PS_PRINTF("创建二进制信号量失败次数 %d\n", g_astRnicStats[0].ulCreateBinarySemFailNum);
PS_PRINTF("锁二进制信号量失败次数 %d\n", g_astRnicStats[0].ulLockBinarySemFailNum);
PS_PRINTF("最后一次锁二进制信号量失败原因 %x\n", g_astRnicStats[0].ulLastBinarySemErrRslt);
PS_PRINTF("复位成功的次数 %d\n", g_astRnicStats[0].ulResetSucessNum);
}
VOS_UINT32 Fc_BufferReportDiscount( VOS_UINT32 ulBufferSize )
{
VOS_UINT8 ulTmpCurrPos;
if(PS_FALSE == g_ulUlDowngradeFlag)
{
ulTmpCurrPos = g_stFcLteTemperatureCtrl.ucCurrPos;
}
else
{
if (g_stFcLteTemperatureCtrl.ucBsrThresCnt > 0)
{
ulTmpCurrPos = g_stFcLteTemperatureCtrl.ucBsrThresCnt - 1;
}
else
{
ulTmpCurrPos = FC_UL_THROUGHPUT_THRES_CNT;
}
}
if(ulTmpCurrPos < FC_UL_THROUGHPUT_THRES_CNT)
{
if(ulBufferSize > g_stFcLteTemperatureCtrl.ulTemperSteps[ulTmpCurrPos])
{
ulBufferSize = g_stFcLteTemperatureCtrl.ulTemperSteps[ulTmpCurrPos];
}
}
/* CPU或温控减速 */
/* 0.9999浮点逼近 1 */
if((g_dBsrCpuModu < 0.9999) && (g_stFcLteCpuCtrl.ulUlMinBsr < ulBufferSize))
{
ulBufferSize = (VOS_UINT32)(ulBufferSize * g_dBsrCpuModu);
if(g_stFcLteCpuCtrl.ulUlMinBsr > ulBufferSize)
{
FC_CL_BSR_BELOW_MIN_STAT(1);
ulBufferSize = g_stFcLteCpuCtrl.ulUlMinBsr;
}
}
if(g_BsrCheck)
{
if(977 == PS_RAND(3000))
{
PS_PRINTF("BSR value: %d\r\n", ulBufferSize);
}
}
return ulBufferSize;
}
static void
ps_detach(struct socket *so) {
struct pspcb *psp = sotopspcb(so);
PS_PRINTF(PS_DEBUG_SOCKET, "so = %p\n", so);
KASSERT(psp != NULL, ("ps_detach: psp == NULL"));
mtx_lock(pspcb_lock);
rw_wlock(&psp->psp_lock);
LIST_REMOVE(psp, psp_list);
mtx_unlock(pspcb_lock);
if (psp->psp_ifp)
IFP2AC(psp->psp_ifp)->ac_netgraph = NULL;
psp->psp_socket->so_pcb = NULL;
free(psp, M_PCB);
}
VOS_VOID Fc_ShowLteResult(VOS_VOID)
{
PS_PRINTF("C核LTE流控结果 :\r\n");
/*lint -e960*/
PS_PRINTF("\r\n");
PS_PRINTF("CPU乘数 (*10000) %05d\r\n", (VOS_UINT32)(g_dBsrCpuModu * 10000));
PS_PRINTF("HARQ丢包率 %d\r\n", (100 - g_ulHarqKeepRate));
PS_PRINTF("温保流控当前位置 %d\r\n", g_stFcLteTemperatureCtrl.ucCurrPos);
PS_PRINTF("温保入口控制状态 %d\r\n", g_ulUlDowngradeFlag);
PS_PRINTF("\r\n");
/*lint +e960*/
return;
}
VOS_UINT32 FC_CdsConfigcheck(VOS_VOID)
{
if(g_stFcCdsConfig.stFcCdsDlConfig.ulDiscardRate >= 100)
{
PS_PRINTF("FC_CdsConfigcheck Error config stFcCdsDlConfig.ulDiscardRate over 100:%d\n", g_stFcCdsConfig.stFcCdsDlConfig.ulDiscardRate);
return PS_FAIL;
}
if(g_stFcCdsConfig.stQosFcConfig.ulDiscardRate >= 100)
{
PS_PRINTF("FC_CdsConfigcheck Error config stQosFcConfig.ulDiscardRate over 100:%d\n", g_stFcCdsConfig.stQosFcConfig.ulDiscardRate);
return PS_FAIL;
}
if(g_stFcCdsConfig.stQosFcConfig.ulRandomDiscardRate >= g_stFcCdsConfig.stQosFcConfig.ulDiscardRate)
{
PS_PRINTF("FC_CdsConfigcheck Error config stQosFcConfig.ulRandomDiscardRate greater than stQosFcConfig.ulDiscardRate:%d,%d\n", g_stFcCdsConfig.stQosFcConfig.ulRandomDiscardRate, g_stFcCdsConfig.stQosFcConfig.ulDiscardRate);
return PS_FAIL;
}
if(g_stFcCdsConfig.stQosFcConfig.ulWarningThres >= g_stFcCdsConfig.stQosFcConfig.ulDiscardThres)
{
PS_PRINTF("FC_CdsConfigcheck Error config stQosFcConfig.ulWarningThres greater than stQosFcConfig.ulDiscardThres:%d,%d\n", g_stFcCdsConfig.stQosFcConfig.ulWarningThres, g_stFcCdsConfig.stQosFcConfig.ulDiscardThres);
return PS_FAIL;
}
if(g_stFcCdsConfig.stQosFcConfig.ulDiscardThres >= g_stFcCdsConfig.stQosFcConfig.ulRandomDiscardThres)
{
PS_PRINTF("FC_CdsConfigcheck Error config stQosFcConfig.ulDiscardThres greater than stQosFcConfig.ulRandomDiscardThres:%d,%d\n", g_stFcCdsConfig.stQosFcConfig.ulDiscardThres, g_stFcCdsConfig.stQosFcConfig.ulRandomDiscardThres);
return PS_FAIL;
}
if(g_stFcCdsConfig.stQosFcConfig.ulRandomDiscardThres >= g_stFcCdsConfig.stQosFcConfig.ulRestoreThres)
{
PS_PRINTF("FC_CdsConfigcheck Error config stQosFcConfig.ulRandomDiscardThres greater than stQosFcConfig.ulRestoreThres:%d,%d\n", g_stFcCdsConfig.stQosFcConfig.ulRandomDiscardThres, g_stFcCdsConfig.stQosFcConfig.ulRestoreThres);
return PS_FAIL;
}
return PS_SUCC;
}
static int
dir_vers2dents(struct psfs_node *pnode, struct uio *uio, u_long *cookies,
off_t maxcount, int *eofflag)
{
int error = 0;
off_t off;
ps_pubi_t pi;
ps_meta_t meta;
int index, i;
KASSERT(0 == uio->uio_offset % DIRSIZ_RID && uio->uio_offset >= DIRSIZ_RID,
("Invalid uio_offset %ld", uio->uio_offset));
off = uio->uio_offset;
PS_PRINTF(PS_DEBUG_DIR, "off=%ld, maxcount=%ld, eofflag=%p\n", off, maxcount, eofflag);
error = ps_pit_get(pnode->pn_rid, &pi);
if (error)
return error;
error = ps_obj_get_page(pi, VMO_META, 0, (void **)&meta);
if (error) {
PS_OBJ_PUBI_UNLOCK(pi);
return error;
}
#ifdef INVARIANTS
PS_PRINTF(PS_DEBUG_DIR, "meta->pm_interlock=%p:\n", meta->pm_interlock);
if (ps_debug_mask & PS_DEBUG_DIR) {
db_show_mtx(meta->pm_interlock);
}
#endif
PS_OBJ_META_LOCK(meta);
PS_OBJ_PUBI_UNLOCK(pi);
index = (uio->uio_offset / DIRSIZ_RID) - 1;
for (i = index; i < meta->pm_vers_count; i++) {
ps_pubi_t vpi;
struct dirent dent;
error = ps_pit_get(meta->pm_sub_object[i], &vpi);
if (error) {
PS_PRINTF(PS_DEBUG_WARNING, "version %s not found in pit\n",
psfs_id2str(meta->pm_sub_object[i], NULL));
error = 0;
continue;
}
dent.d_fileno = vpi->pi_ino + IPUB;
dent.d_type = DT_DIR;
dent.d_namlen = PSIRP_ID_LEN * 2;
dent.d_reclen = GENERIC_DIRSIZ(&dent);
PS_OBJ_PUBI_UNLOCK(vpi);
psfs_id2str(meta->pm_sub_object[i], dent.d_name);
error = uiomove(&dent, dent.d_reclen, uio);
if (cookies)
*cookies++ = uio->uio_offset;
if (error)
break;
}
if (eofflag && i >= meta->pm_vers_count)
*eofflag = TRUE;
/*
* Note that we have to unlock meta first, before locking pi,
* as the locking order is always pi->meta->...
*/
PS_OBJ_META_UNLOCK(meta);
/* XXX: Is there any possibility for some race condition here? */
PS_OBJ_PUBI_LOCK(pi);
ps_obj_put_page(pi, VMO_META, FALSE);
PS_OBJ_PUBI_UNLOCK(pi);
if (error)
return error;
PS_PRINTF(PS_DEBUG_DIR, "i=%d, *eofflag=%d -> %d\n", i, eofflag? *eofflag: 4077, error);
KASSERT((0 == uio->uio_offset % DIRSIZ_RID && uio->uio_offset >= DIRSIZ_RID),
("Invalid uio_offset %ld", uio->uio_offset));
return error;
}
VOS_VOID RNIC_ShowDLProcStats(VOS_UINT8 ucRmNetId)
{
if (ucRmNetId >= RNIC_NET_ID_MAX_NUM)
{
PS_PRINTF("RNIC_ShowDLProcStats: NetId overtop, ucRmNetId = %d\n", ucRmNetId);
return;
}
/* 下行统计量 */
PS_PRINTF("RNIC %d收到下行IPV4数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlRecvIpv4PktNum);
PS_PRINTF("RNIC %d收到下行IPV6数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlRecvIpv6PktNum);
PS_PRINTF("RNIC %d发送下行数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlSendPktNum);
PS_PRINTF("RNIC %d发送下行数据失败的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlSendPktFailNum);
PS_PRINTF("RNIC %d收到下行数据包大于MTU的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlRecvBigPktNum);
PS_PRINTF("RNIC %d网卡未激活丢弃的数据个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlDiscardPktNum);
PS_PRINTF("RNIC %d下行加MAC头失败的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlAddMacHdFailNum);
PS_PRINTF("RNIC %d网卡私有数据错误丢掉下行数据包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlNetCardDiscardNum);
PS_PRINTF("RNIC %d网卡ID错误丢掉下行数据包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlNetIdDiscardNum);
PS_PRINTF("RNIC %d收到错误数据包的个数非ipv4ipv6包 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulDlRecvErrPktNum);
PS_PRINTF("\r\n");
return;
}
int
psfs_dir_getdents(struct psfs_node *pnode, struct uio *uio,
u_long *cookies, off_t cnt, int *eofflag)
{
ps_pubi_t pi;
int error = 0;
off_t off;
struct dirent *des;
int i, des_cnt;
PS_PRINTF(PS_DEBUG_DIR, "uio_offset %ld\n", uio->uio_offset);
error = ps_pit_get(pnode->pn_rid, &pi);
if (error)
return error;
switch (pnode->pn_type) {
case VROOT:
des = des_root;
des_cnt = sizeof(des_root)/sizeof(des_root[0]);
break;
case VSCOPE:
des = des_scope;
des_cnt = sizeof(des_scope)/sizeof(des_scope[0]);
break;
case VPUB:
case VVER:
case VPAGE:
des = des_long;
des_cnt = sizeof(des_long)/sizeof(des_long[0]);
break;
default:
panic("psfs_dir_cntents: attempt to readdir a non-directory: pnode=%p", pnode);
}
PS_OBJ_PUBI_ASSERT_OWNED(pi);
if (uio->uio_offset < DIRSIZ_RID) {
/*
* Offsets < DIRSIZ_RID are used for the special files.
*/
off = 0;
for (i = 0; i < des_cnt; i++) {
if (uio->uio_offset == off)
break;
off += des[i].d_reclen;
}
while (0 == error && uio->uio_resid > 0 && i < des_cnt && 0 < cnt--) {
des[i].d_fileno = pi->pi_ino + pnode->pn_type;
error = uiomove(&des[i], des[i].d_reclen, uio);
if (cookies)
*cookies++ = uio->uio_offset;
i++;
}
}
PS_OBJ_PUBI_UNLOCK(pi);
if (0 != uio->uio_offset % DIRSIZ_RID || DIRSIZ_RID > uio->uio_offset) {
PS_PRINTF(PS_DEBUG_DIR | PS_DEBUG_ERROR,
"bad uio_offset %ld\n", uio->uio_offset);
return EINVAL;
}
switch (pnode->pn_type) {
case VROOT:
error = dir_scope2dents(pnode, uio, cookies, cnt, eofflag, TRUE);
break;
case VSCOPE:
error = dir_scope2dents(pnode, uio, cookies, cnt, eofflag, FALSE);
break;
case VPUB:
case VVER:
error = dir_vers2dents(pnode, uio, cookies, cnt, eofflag);
break;
case VPAGE:
if (eofflag)
*eofflag = TRUE;
break;
default:
panic("psfs_dir_getdents: unimplemented pnode type %d\n", pnode->pn_type);
}
return error;
}
VOS_VOID RNIC_ShowRnicPdpStats(VOS_UINT8 ucRmNetId)
{
RNIC_PDP_CTX_STRU *pstPdpCtx;
if (ucRmNetId >= RNIC_NET_ID_MAX_NUM)
{
PS_PRINTF("RNIC_ShowRnicPdpStats: NetId overtop, ucRmNetId = %d\n", ucRmNetId);
return;
}
pstPdpCtx = RNIC_GetPdpCtxAddr(ucRmNetId);
PS_PRINTF("RNIC %d IPV4 PDP STATUS %d\n", ucRmNetId, pstPdpCtx->stIpv4PdpInfo.enRegStatus);
PS_PRINTF("RNIC %d IPV4 PDP RABID %d\n", ucRmNetId, pstPdpCtx->stIpv4PdpInfo.ucRabId);
PS_PRINTF("RNIC %d IPV4 PDP PDNID %d\n", ucRmNetId, pstPdpCtx->stIpv4PdpInfo.ucPdnId);
PS_PRINTF("RNIC %d IPV4 PDP IPV4ADDR %d\n\n", ucRmNetId, pstPdpCtx->stIpv4PdpInfo.ulIpv4Addr);
PS_PRINTF("RNIC %d IPV6 PDP STATUS %d\n", ucRmNetId, pstPdpCtx->stIpv6PdpInfo.enRegStatus);
PS_PRINTF("RNIC %d IPV6 PDP RABID %d\n", ucRmNetId, pstPdpCtx->stIpv6PdpInfo.ucRabId);
PS_PRINTF("RNIC %d IPV6 PDP PDNID %d\n", ucRmNetId, pstPdpCtx->stIpv6PdpInfo.ucPdnId);
PS_PRINTF("RNIC %d IPV6 PDP IPV6ADDR %s\n\n", ucRmNetId, pstPdpCtx->stIpv6PdpInfo.aucIpv6Addr);
PS_PRINTF("RNIC %d IPV4V6 PDP STATUS %d\n", ucRmNetId, pstPdpCtx->stIpv4v6PdpInfo.enRegStatus);
PS_PRINTF("RNIC %d IPV4V6 PDP RABID %d\n", ucRmNetId, pstPdpCtx->stIpv4v6PdpInfo.ucRabId);
PS_PRINTF("RNIC %d IPV4V6 PDP PDNID %d\n", ucRmNetId, pstPdpCtx->stIpv4v6PdpInfo.ucPdnId);
PS_PRINTF("RNIC %d IPV4V6 PDP IPV4ADDR %d\n", ucRmNetId, pstPdpCtx->stIpv4v6PdpInfo.ulIpv4Addr);
PS_PRINTF("RNIC %d IPV4V6 PDP IPV6ADDR %s\n", ucRmNetId, pstPdpCtx->stIpv4v6PdpInfo.aucIpv6Addr);
}
VOS_VOID RNIC_ShowULProcStats(VOS_UINT8 ucRmNetId)
{
PS_PRINTF("NET TX RMNETID ERR NUM %d\n", g_stRnicMntnStats.ulNetTxRmNetIdErrNum);
PS_PRINTF("SPE TX PORTID ERR NUM %d\n", g_stRnicMntnStats.ulSpeTxPortIdErrNum);
if (ucRmNetId >= RNIC_NET_ID_MAX_NUM)
{
PS_PRINTF("RNIC_ShowUlProcStats: NetId overtop, ucRmNetId = %d\n", ucRmNetId);
return;
}
/* 上行统计量 */
PS_PRINTF("RNIC %d流控状态 %d\n", ucRmNetId, g_stRnicCtx.astSpecCtx[ucRmNetId].enFlowCtrlStatus);
PS_PRINTF("RNIC %d收到上行IPV4数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRecvIpv4PktNum);
PS_PRINTF("RNIC %d收到上行IPV6数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRecvIpv6PktNum);
PS_PRINTF("IPV4V6类型激活时RNIC %d收到上行数据的个数IPV4IPV6 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRecvIpv4v6PktNum);
PS_PRINTF("RNIC %d未激活时收到上行数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRecvUndiaPktNum);
PS_PRINTF("RNIC %d上行发送给ADS数据的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlSendPktNum);
PS_PRINTF("RNIC %d调ADS发送上行数据失败的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlSendPktFailNum);
PS_PRINTF("RNIC %d未拨上号前上行收到IPV4广播包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlIpv4BrdcstPktNum);
PS_PRINTF("RNIC %d上行转换为IMM_ZC失败的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlImmzcFailPktNum);
PS_PRINTF("RNIC %d上行去除MAC头失败的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRmvMacHdrFailPktNum);
PS_PRINTF("RNIC %d网卡私有数据错误丢掉上行数据包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlNetCardDiscardNum);
PS_PRINTF("RNIC %d网卡ID错误丢掉上行数据包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlNetIdDiscardNum);
PS_PRINTF("RNIC %dModem ID错误丢掉上行数据包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlModemIdDiscardNum);
PS_PRINTF("RNIC %d流控丢掉上行数据包的个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlFlowCtrlDiscardNum);
PS_PRINTF("RNIC %d收到错误数据包的个数非ipv4ipv6包 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRecvErrPktNum);
PS_PRINTF("RNIC %d成功上报APP按需拨号 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlSendAppDialUpSucc);
PS_PRINTF("RNIC %d上报APP按需拨号失败 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlSendAppDialUpFail);
PS_PRINTF("RNIC %d成功上报APP断开拨号 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlSendAppDialDownSucc);
PS_PRINTF("RNIC %d上报APP断开拨号失败 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlSendAppDialDownFail);
if (RNIC_RMNET_ID_0 == ucRmNetId)
{
PS_PRINTF("拨号模式 %d\n", g_stRnicCtx.stDialMode.enDialMode);
PS_PRINTF("按需拨号是否上报事件 %d\n", g_stRnicCtx.stDialMode.enEventReportFlag);
PS_PRINTF("按需拨号断开时间 %d\n", g_stRnicCtx.stDialMode.ulIdleTime);
}
PS_PRINTF("RNIC %d RAB ID错误，RNIC丢弃的数据包个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlRabIdErr);
PS_PRINTF("RNIC %d PDN ID错误，RNIC丢弃的数据包个数 %d\n", ucRmNetId, g_astRnicStats[ucRmNetId].ulUlPdnIdErr);
PS_PRINTF("\r\n");
return;
}
VOS_VOID Fc_LteHelp(VOS_VOID)
{
PS_PRINTF("LTE流控软调命令 :\r\n");
PS_PRINTF("\r\n");
PS_PRINTF("Fc_ShowLtePara :显示LTE流控参数\r\n");
PS_PRINTF("Fc_ShowLteStats :显示LTE流控统计量\r\n");
PS_PRINTF("Fc_ResetLteStats :复位LTE流控统计量\r\n");
PS_PRINTF("Fc_ShowLteResult :显示C核LTE流控结果\r\n");
PS_PRINTF("QosFc_ShowPara :显示QoS流控参数\r\n");
PS_PRINTF("QosFc_ShowStats :显示QoS流控统计量\r\n");
PS_PRINTF("QosFc_ResetStats :复位QoS流控统计量\r\n");
PS_PRINTF("QosFc_ShowState :显示QoS流控状态\r\n");
PS_PRINTF("QosFc_ShowRabState :显示QoS流控承载状态\r\n");
PS_PRINTF("QosFc_ShowEntity :显示Qos流控实体状态\r\n");
PS_PRINTF("QosFc_ShowChannel :显示Qos流控通道状态\r\n");
PS_PRINTF("\r\n");
return;
}
VOS_VOID Fc_ShowLteStats(VOS_VOID)
{
PS_PRINTF("C核LTE流控统计 :\r\n");
PS_PRINTF("\r\n");
PS_PRINTF("切为LTE模次数 %d\r\n", g_stFcCLStats.ulToLteNum);
PS_PRINTF("切为GU模次数 %d\r\n", g_stFcCLStats.ulToGUNum);
PS_PRINTF("进入NULL模式次数 %d\r\n", g_stFcCLStats.ulToNullNum);
PS_PRINTF("进入LOOPBACK次数 %d\r\n", g_stFcCLStats.ulToLBNum);
PS_PRINTF("LTE温控降速次数 %d\r\n", g_stFcCLStats.ulTemperatureDownNum);
PS_PRINTF("LTE温控升速次数 %d\r\n", g_stFcCLStats.ulTemperatureUpNum);
PS_PRINTF("LTE温控直接恢复次数 %d\r\n", g_stFcCLStats.ulTemperatureRecoverNum);
PS_PRINTF("LTE温控降速到下限次数 %d\r\n", g_stFcCLStats.ulTemperatureToLimitNum);
PS_PRINTF("LTE温控恢复到正常次数 %d\r\n", g_stFcCLStats.ulTemperatureToNormalNum);
PS_PRINTF("LTE CPU过载降速次数 %d\r\n", g_stFcCLStats.ulCpuDownNum);
PS_PRINTF("LTE CPU恢复升速次数 %d\r\n", g_stFcCLStats.ulCpuUpNum);
PS_PRINTF("LTE CPU进入降速状态数 %d\r\n", g_stFcCLStats.ulCpuToDownNum);
PS_PRINTF("LTE CPU恢复到正常次数 %d\r\n", g_stFcCLStats.ulCpuToNormalNum);
PS_PRINTF("LTE HARQ过载降速次数 %d\r\n", g_stFcCLStats.ulHqDownNum);
PS_PRINTF("LTE HARQ恢复升速次数 %d\r\n", g_stFcCLStats.ulHqUpNum);
PS_PRINTF("LTE HARQ降到底次数 %d\r\n", g_stFcCLStats.ulHqToDownNum);
PS_PRINTF("LTE HARQ恢复到正常次数 %d\r\n", g_stFcCLStats.ulHqToNormalNum);
PS_PRINTF("LTE上报缓存低于下限 %d\r\n", g_stFcCLStats.ulBelowMinBsr);
PS_PRINTF("\r\n");
return;
}
VOS_VOID Fc_ShowLtePara(VOS_VOID)
{
PS_PRINTF("LTE流控参数 :\r\n");
PS_PRINTF("\r\n");
PS_PRINTF("下行CDS流控是否使能 %s\r\n", g_stFcCdsDlCtrl.bDlCdsFcEnable?"Yes":"No");
PS_PRINTF("下行CDS丢包门限 %d\r\n", g_stFcCdsDlCtrl.ulDiscardThres);
PS_PRINTF("下行CDS丢包率 %d\r\n", g_stFcCdsDlCtrl.ulDiscardRate);
PS_PRINTF("\r\n");
PS_PRINTF("CPU过载流控延迟进入 %d\r\n", g_stFcLteCpuCtrl.ulFirstDelay);
PS_PRINTF("CPU升速步长百分比 %d\r\n", g_stFcLteCpuCtrl.ulUlUpRate);
PS_PRINTF("CPU降速步长百分比 %d\r\n", g_stFcLteCpuCtrl.ulUlDownRate);
PS_PRINTF("CPU降速下限 BSR %d\r\n", g_stFcLteCpuCtrl.ulUlMinBsr);
PS_PRINTF("HARQ升速步长百分比 %d\r\n", g_stFcLteCpuCtrl.ulHqUpRate);
PS_PRINTF("HARQ降速步长百分比 %d\r\n", g_stFcLteCpuCtrl.ulHqDownRate);
PS_PRINTF("HARQ丢包降速上限 %d\r\n", g_stFcLteCpuCtrl.ulHqMaxDiscardRate);
PS_PRINTF("CPU降速阈值 %d\r\n", g_stFcLteCpuCtrl.ulDowngradeThres);
PS_PRINTF("CPU升速阈值 %d\r\n", g_stFcLteCpuCtrl.ulUpgradeThres);
PS_PRINTF("\r\n");
PS_PRINTF("降速起始位置 %d\r\n", g_stFcLteTemperatureCtrl.ucInitialPos);
PS_PRINTF("温保总流控阶数 %d\r\n", g_stFcLteTemperatureCtrl.ucAvailCnt);
PS_PRINTF("BSR降速阶数 %d\r\n", g_stFcLteTemperatureCtrl.ucBsrThresCnt);
PS_PRINTF("温保入口控制参数 %d %d %d %d\r\n", g_stFcLteTemperatureCtrl.ulTemperSteps[0],
g_stFcLteTemperatureCtrl.ulTemperSteps[1],
g_stFcLteTemperatureCtrl.ulTemperSteps[2],
g_stFcLteTemperatureCtrl.ulTemperSteps[3]);
PS_PRINTF(" %d %d %d %d\r\n",
g_stFcLteTemperatureCtrl.ulTemperSteps[4],
g_stFcLteTemperatureCtrl.ulTemperSteps[5],
g_stFcLteTemperatureCtrl.ulTemperSteps[6],
g_stFcLteTemperatureCtrl.ulTemperSteps[7]);
PS_PRINTF(" %d %d %d %d\r\n",
g_stFcLteTemperatureCtrl.ulTemperSteps[8],
g_stFcLteTemperatureCtrl.ulTemperSteps[9],
g_stFcLteTemperatureCtrl.ulTemperSteps[10],
g_stFcLteTemperatureCtrl.ulTemperSteps[11]);
PS_PRINTF(" %d\r\n", g_stFcLteTemperatureCtrl.ulTemperSteps[12]);
PS_PRINTF("BSR周期 %d\r\n", g_stFcLteTemperatureCtrl.ulBsrTimerLen);
PS_PRINTF("\r\n");
return;
}
/*
* Caveat: Called from interrupt context
*/
static void
ps_ether_input(struct ifnet *ifp, struct mbuf **mp) {
struct pspcb *psp = NULL, *psp_next;
struct ether_header *eh;
struct sockaddr esa;
struct socket *so = NULL;
u_short etype;
eh = mtod(*mp, struct ether_header *);
etype = ntohs(eh->ether_type);
if (PS_ETHER_TYPE != etype)
return;
/*
* We currently place the mbuf to a bound socket's rcv.
*
* However,this is not the long term plan. Instead, in the
* longer term we should fill in a page, place the page at
* the local cache, and then wake up the network receiver.
* through the bound socket.
*/
PS_PRINTF(PS_DEBUG_SOCKET, "m = %p\n", *mp);
LIST_FOREACH_SAFE(psp, pspcbhead, psp_list, psp_next) {
#if __FreeBSD_version >= 701000
if (!rw_try_rlock(&psp->psp_lock)) {
PS_PRINTF(PS_DEBUG_SOCKET | PS_DEBUG_WARNING,
"psp is w-locked, discard data\n");
/* Simply discard data if the psp happens to be w-locked */
continue;
}
#endif
if (ifp == psp->psp_ifp) {
so = psp->psp_socket;
#if __FreeBSD_version >= 701000
rw_runlock(&psp->psp_lock);
#endif
break;
}
#if __FreeBSD_version >= 701000
rw_runlock(&psp->psp_lock);
#endif
}
if (so) {
/*
* XXX: We don't understand why simple sbappend
* doesn't work. But spappendaddr does. So be it.
*/
esa.sa_family = AF_LINK;
esa.sa_len = 0;
m_adj(*mp, sizeof(*eh)); /* Remove ethernet header */
if (!sbappendaddr(&so->so_rcv, &esa, *mp, NULL)) {
PS_PRINTF(PS_DEBUG_SOCKET | PS_DEBUG_WARNING,
"sbappendaddr() failed. "
"Probably not enough buffer space. "
"Packet lost.\n");
}
sorwakeup(so);
*mp = NULL;
return;
}
#ifdef NOTYET
/* We could free *mp here, but we don't. It gets discarded anyway */
m_freem(*mp);
*mp = NULL;
#endif
return;
}
VOS_VOID Fc_LteInit(VOS_VOID)
{
VOS_UINT32 ulReturnCode;
#if (CDS_FEATURE_ON == CDS_FEATURE_LTE)
VOS_UINT32 i;
/* 从NV读取流控配置信息 */
/*lint -e718*/
/*lint -e746*/
/*lint -e732*/
/*lint -e830*/
ulReturnCode = LPs_NvimItem_Read(EN_NV_ID_FLOWCTRL_CONFIG,\
(VOS_VOID *)(&g_stFcLteConfig),\
sizeof(FLOWCTRL_LTE_CONFIG_STRU));
/*lint +e830*/
/*lint +e732*/
/*lint +e746*/
/*lint +e718*/
if (PS_SUCC != ulReturnCode)
{
PS_PRINTF("Fc_LteInit,LPs_NvimItem_Read FLOWCTRL_LTE_CONFIG fail:%d\n", ulReturnCode);
/* 初始化为默认值 */
Fc_LteConfig2Default();
}
if(PS_SUCC != FC_LteConfigcheck())
{
/* 初始化为默认值 */
Fc_LteConfig2Default();
}
g_stFcLteCpuCtrl.ulFirstDelay = g_stFcLteConfig.stFcCpuConfig.usFirstDelay;
g_stFcLteCpuCtrl.ulUlDownRate = g_stFcLteConfig.stFcCpuConfig.usUlDownRate;
g_stFcLteCpuCtrl.ulUlUpRate = g_stFcLteConfig.stFcCpuConfig.usUlUpRate;
g_stFcLteCpuCtrl.ulHqDownRate = g_stFcLteConfig.stFcCpuConfig.usHqDownRate;
g_stFcLteCpuCtrl.ulHqUpRate = g_stFcLteConfig.stFcCpuConfig.usHqUpRate;
g_stFcLteCpuCtrl.ulHqMaxDiscardRate = g_stFcLteConfig.stFcCpuConfig.usHqMaxDiscardRate;
g_stFcLteCpuCtrl.ulDowngradeThres = g_stFcLteConfig.stFcCpuConfig.usDowngradeThres;
g_stFcLteCpuCtrl.ulUpgradeThres = g_stFcLteConfig.stFcCpuConfig.usUpgradeThres;
g_stFcLteTemperatureCtrl.ucInitialPos = g_stFcLteConfig.stFcTemperatureConfig.ucInitialPos;
g_stFcLteTemperatureCtrl.ulBsrTimerLen = 10; /* 默认BSR周期10ms */
g_stFcLteTemperatureCtrl.ucAvailCnt = 0;
g_stFcLteTemperatureCtrl.ucBsrThresCnt = 0;
g_stFcLteTemperatureCtrl.ucCurrPos = FC_UL_THROUGHPUT_THRES_CNT;
for(i = 0; i < FC_UL_THROUGHPUT_THRES_CNT_NV; i++)
{
if(0 == g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps[i])
{
break;
}
if(g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps[i] < g_stFcLteConfig.stFcTemperatureConfig.ulMinBsrThr)
{
g_stFcLteTemperatureCtrl.ucAvailCnt++;
/* 周期折算，NV设置为kbps，入口流控基于100ms字节数 */
g_stFcLteTemperatureCtrl.ulTemperSteps[i] = g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps[i]*100 / 8;
}
else
{
g_stFcLteTemperatureCtrl.ucBsrThresCnt++;
}
}
/* 入口流控紧随BSR流控 */
g_stFcLteTemperatureCtrl.ucAvailCnt += g_stFcLteTemperatureCtrl.ucBsrThresCnt;
for(; i < FC_UL_THROUGHPUT_THRES_CNT; i++)
{
g_stFcLteTemperatureCtrl.ulTemperSteps[i] = 0;
}
if(g_stFcLteConfig.stFcTemperatureConfig.ucZeroSupport > 0)
{
g_stFcLteTemperatureCtrl.ucAvailCnt++;
}
g_ulUlDowngradeFlag = PS_FALSE;
Fc_KbpsToBsr();
#endif
/* 从GU NV读取流控配置信息 */
/*lint -e718*/
/*lint -e746*/
/*lint -e732*/
ulReturnCode = NV_ReadEx(MODEM_ID_0,EN_NV_ITEM_CDS_FC_CONFIG,\
(&g_stFcCdsConfig),\
sizeof(FLOWCTRL_CDS_CONFIG_STRU));
/*lint +e732*/
/*lint +e746*/
/*lint +e718*/
if (PS_SUCC != ulReturnCode)
{
PS_PRINTF("Fc_LteInit,NV_Read FLOWCTRL_CDS_CONFIG fail:%d\n", ulReturnCode);
/* 初始化为默认值 */
Fc_CdsConfig2Default();
}
if(PS_SUCC != FC_CdsConfigcheck())
{
/* 初始化为默认值 */
Fc_CdsConfig2Default();
}
/* 基于NV填充控制结构 */
if(0 == (FC_CDS_DL_ENABLED_MASK & g_stFcCdsConfig.ulFcEnableMask))
{
g_stFcCdsDlCtrl.bDlCdsFcEnable = VOS_FALSE;
}
else
{
g_stFcCdsDlCtrl.bDlCdsFcEnable = VOS_TRUE;
}
g_stFcCdsDlCtrl.ulDiscardThres = g_stFcCdsConfig.stFcCdsDlConfig.ulDiscardThres;
g_stFcCdsDlCtrl.ulDiscardRate = g_stFcCdsConfig.stFcCdsDlConfig.ulDiscardRate;
return;
}
VOS_UINT32 FC_LteConfigcheck(VOS_VOID)
{
VOS_UINT32 i = 0;
if(g_stFcLteConfig.stFcCpuConfig.usUlDownRate >= 100)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcCpuConfig.usUlDownRate over 100:%d\n", g_stFcLteConfig.stFcCpuConfig.usUlDownRate);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcCpuConfig.usUlUpRate >= 100)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcCpuConfig.usUlUpRate over 100:%d\n", g_stFcLteConfig.stFcCpuConfig.usUlUpRate);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcCpuConfig.usHqDownRate >= 100)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcCpuConfig.usHqDownRate over 100:%d\n", g_stFcLteConfig.stFcCpuConfig.usHqDownRate);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcCpuConfig.usHqUpRate >= 100)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcCpuConfig.usHqUpRate over 100:%d\n", g_stFcLteConfig.stFcCpuConfig.usHqUpRate);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcCpuConfig.usDowngradeThres >= 100)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcCpuConfig.usDowngradeThres over 100:%d\n", g_stFcLteConfig.stFcCpuConfig.usDowngradeThres);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcCpuConfig.usUpgradeThres >= g_stFcLteConfig.stFcCpuConfig.usDowngradeThres)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcCpuConfig.usUpgradeThres greater than stFcCpuConfig.usDowngradeThres:%d,%d\n",
g_stFcLteConfig.stFcCpuConfig.usUpgradeThres,
g_stFcLteConfig.stFcCpuConfig.usDowngradeThres);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcTemperatureConfig.ucInitialPos >= FC_UL_THROUGHPUT_THRES_CNT_NV)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcTemperatureConfig.ucInitialPos beyond :%d,%d\n", g_stFcLteConfig.stFcTemperatureConfig.ucInitialPos, FC_UL_THROUGHPUT_THRES_CNT_NV);
return PS_FAIL;
}
if(g_stFcLteConfig.stFcTemperatureConfig.ucZeroSupport > 1)
{
PS_PRINTF("FC_LteConfigcheck Error config stFcTemperatureConfig.ucZeroSupport over 1:%d\n", g_stFcLteConfig.stFcTemperatureConfig.ucZeroSupport);
return PS_FAIL;
}
for(i = 0; i < FC_UL_THROUGHPUT_THRES_CNT_NV-1; i++)
{
if(0 == g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps[i])
{
break;
}
if(g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps[i] < g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps[i+1])
{
PS_PRINTF("FC_LteConfigcheck: g_stFcLteConfig.stFcTemperatureConfig.ulTemperSteps must be descending order!");
return PS_FAIL;
}
}
return PS_SUCC;
}
