自学教程：C++ vos_mem_malloc函数代码示例

eHalStatus csrTdlsProcessDelSta( tpAniSirGlobal pMac, tSmeCmd *cmd ){    tTdlsDelStaCmdInfo *tdlsDelStaCmdInfo = &cmd->u.tdlsCmd.u.tdlsDelStaCmdInfo ;    tSirTdlsDelStaReq *tdlsDelStaReq = NULL ;    tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );    eHalStatus status = eHAL_STATUS_FAILURE;    if (NULL == pSession)    {        smsLog( pMac, LOGE, FL("pSession is NULL"));        return eHAL_STATUS_FAILURE;    }    if (NULL == pSession->pConnectBssDesc)    {        smsLog( pMac, LOGE, FL("BSS description is not present") );        return eHAL_STATUS_FAILURE;    }    tdlsDelStaReq = vos_mem_malloc(sizeof(tSirTdlsDelStaReq));    if ( NULL == tdlsDelStaReq )        status = eHAL_STATUS_FAILURE;    else        status = eHAL_STATUS_SUCCESS;    if (!HAL_STATUS_SUCCESS( status ) )    {        smsLog( pMac, LOGE, FL("alloc failed") );        VOS_ASSERT(0) ;        return status ;    }    tdlsDelStaReq->sessionId = cmd->sessionId;    //Using dialog as transactionId. This can be used to match response with request    tdlsDelStaReq->transactionId = 0;    vos_mem_copy( tdlsDelStaReq->bssid,                  pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));    vos_mem_copy( tdlsDelStaReq->peerMac,            tdlsDelStaCmdInfo->peerMac, sizeof(tSirMacAddr)) ;    // Send the request to PE.#ifdef WLAN_FEATURE_TDLS_DEBUG    smsLog( pMac, LOGE,#else    smsLog( pMac, LOG1,#endif        "sending TDLS Del Sta "MAC_ADDRESS_STR" req to PE",         MAC_ADDR_ARRAY(tdlsDelStaCmdInfo->peerMac));    status = tdlsSendMessage(pMac, eWNI_SME_TDLS_DEL_STA_REQ,             (void *)tdlsDelStaReq , sizeof(tSirTdlsDelStaReq)) ;    if(!HAL_STATUS_SUCCESS( status ) )    {        smsLog( pMac, LOGE, FL("Failed to send request to MAC"));    }    return status;}

/** * aniSsmReplayCtrCreate * * Creates a replay counter and initializes it for first time * use. The initialization can be done randomly or with a passed in * value like 0. In case this is going to be used on the RX side, it * doesn't matter what the initialization is and can be optimized to * a fixed value so as to avoid the overhead of obtaining a random * value. * * @param ctrPtr a pointer that will be set to the newly allocated * counter if the operation succeeds * @param size the number of bytes that are desired in the counter * @param initValue if this is negative and size is greater than 4, * the initialization is done randomly. Otherwise, these bytes are * copied into the least significant four or less octets of the * counter, depending on the size of the counter. i.e., if the counter * is only 2B, then the least significant 2B of initValue will be * copied over. * * @return ANI_OK if the operation succeeds */intaniSsmReplayCtrCreate(v_U32_t cryptHandle, tAniSsmReplayCtr **ctrPtr,                       v_U8_t size,                      int initValue){    tAniSsmReplayCtr *ctr;    ctr = vos_mem_malloc( sizeof(tAniSsmReplayCtr) );    if( NULL == ctr )    {        return ANI_E_MALLOC_FAILED;    }    ctr->buf = vos_mem_malloc( size );    if (ctr->buf == NULL)     {        VOS_ASSERT( 0 );        vos_mem_free(ctr);        return ANI_E_MALLOC_FAILED;    }    ctr->size = size;    // We cannot randomly generate the most significant bytes if the    // total number of bytes is not greater than 4 (sizeof ANI_U32).    if (initValue < 0 && ctr->size <= 4)        initValue = 0;    // If initValue is negative, initialize the ctr randomly, else    // initialize it to what the user specified.    if (initValue < 0)     {        if( !VOS_IS_STATUS_SUCCESS( vos_rand_get_bytes(cryptHandle, ctr->buf, ctr->size) ) )        {            return ANI_ERROR;        }    }     else {        ctr->currentValue = initValue - 1;    }    *ctrPtr = ctr;    return ANI_OK;}

/*------------------------------------------------------------------ * * Below function is called if pMac->fP2pListenOffload enabled and hdd * requests a remain on channel. * *------------------------------------------------------------------*/static eHalStatus limSendHalReqRemainOnChanOffload(tpAniSirGlobal pMac,                                      tSirRemainOnChnReq *pRemOnChnReq){    tSirScanOffloadReq *pScanOffloadReq;    tSirMsgQ msg;    tSirRetStatus rc = eSIR_SUCCESS;    tANI_U8 bssid[SIR_MAC_ADDR_LENGTH] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};    pScanOffloadReq = vos_mem_malloc(sizeof(tSirScanOffloadReq));    if (NULL == pScanOffloadReq)    {        limLog(pMac, LOGE,                FL("Memory allocation failed for pScanOffloadReq"));        return eHAL_STATUS_FAILURE;    }    vos_mem_zero(pScanOffloadReq, sizeof(tSirScanOffloadReq));    msg.type = WDA_START_SCAN_OFFLOAD_REQ;    msg.bodyptr = pScanOffloadReq;    msg.bodyval = 0;    vos_mem_copy((tANI_U8 *) pScanOffloadReq->selfMacAddr,                 (tANI_U8 *) pRemOnChnReq->selfMacAddr,                 sizeof(tSirMacAddr));    vos_mem_copy((tANI_U8 *) pScanOffloadReq->bssId,                 (tANI_U8 *) bssid,                 sizeof(tSirMacAddr));    pScanOffloadReq->scanType = eSIR_PASSIVE_SCAN;    pScanOffloadReq->p2pScanType = P2P_SCAN_TYPE_LISTEN;    pScanOffloadReq->minChannelTime = pRemOnChnReq->duration;    pScanOffloadReq->maxChannelTime = pRemOnChnReq->duration;    pScanOffloadReq->sessionId = pRemOnChnReq->sessionId;    pScanOffloadReq->channelList.numChannels = 1;    pScanOffloadReq->channelList.channelNumber[0] = pRemOnChnReq->chnNum;    limLog(pMac, LOG1,            FL("Req-rem-on-channel: duration %u, session %hu, chan %hu"),            pRemOnChnReq->duration, pRemOnChnReq->sessionId,            pRemOnChnReq->chnNum);    rc = wdaPostCtrlMsg(pMac, &msg);    if (rc != eSIR_SUCCESS)    {        limLog(pMac, LOGE, FL("wdaPostCtrlMsg() return failure %u"),                rc);        vos_mem_free(pScanOffloadReq);        return eHAL_STATUS_FAILURE;    }    pMac->lim.fOffloadScanPending = 1;    pMac->lim.fOffloadScanP2PListen = 1;    return eHAL_STATUS_SUCCESS;}

eHalStatus csrTdlsProcessLinkEstablish( tpAniSirGlobal pMac, tSmeCmd *cmd ){    tTdlsLinkEstablishCmdInfo *tdlsLinkEstablishCmdInfo = &cmd->u.tdlsCmd.u.tdlsLinkEstablishCmdInfo ;    tSirTdlsLinkEstablishReq *tdlsLinkEstablishReq = NULL ;    eHalStatus status = eHAL_STATUS_FAILURE;    tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );    if (NULL == pSession)    {        smsLog( pMac, LOGE, FL("pSession is NULL"));        return eHAL_STATUS_FAILURE;    }    tdlsLinkEstablishReq = vos_mem_malloc(sizeof(tSirTdlsLinkEstablishReq));    if (tdlsLinkEstablishReq == NULL)    {        smsLog( pMac, LOGE, FL("alloc failed /n") );        VOS_ASSERT(0) ;        return status ;    }    tdlsLinkEstablishReq->sessionId = cmd->sessionId;    //Using dialog as transactionId. This can be used to match response with request    tdlsLinkEstablishReq->transactionId = 0;    vos_mem_copy(tdlsLinkEstablishReq->peerMac,                  tdlsLinkEstablishCmdInfo->peerMac, sizeof(tSirMacAddr));    vos_mem_copy(tdlsLinkEstablishReq->bssid, pSession->pConnectBssDesc->bssId,                  sizeof (tSirMacAddr));    vos_mem_copy(tdlsLinkEstablishReq->supportedChannels,                  tdlsLinkEstablishCmdInfo->supportedChannels,                  tdlsLinkEstablishCmdInfo->supportedChannelsLen);    tdlsLinkEstablishReq->supportedChannelsLen =                      tdlsLinkEstablishCmdInfo->supportedChannelsLen;    vos_mem_copy(tdlsLinkEstablishReq->supportedOperClasses,                  tdlsLinkEstablishCmdInfo->supportedOperClasses,                  tdlsLinkEstablishCmdInfo->supportedOperClassesLen);    tdlsLinkEstablishReq->supportedOperClassesLen =                      tdlsLinkEstablishCmdInfo->supportedOperClassesLen;    tdlsLinkEstablishReq->isBufSta = tdlsLinkEstablishCmdInfo->isBufSta;    tdlsLinkEstablishReq->isResponder= tdlsLinkEstablishCmdInfo->isResponder;    tdlsLinkEstablishReq->uapsdQueues= tdlsLinkEstablishCmdInfo->uapsdQueues;    tdlsLinkEstablishReq->maxSp= tdlsLinkEstablishCmdInfo->maxSp;    tdlsLinkEstablishReq->isOffChannelSupported =        tdlsLinkEstablishCmdInfo->isOffChannelSupported;    // Send the request to PE.    smsLog( pMac, LOGE, "sending TDLS Link Establish Request to PE /n" );    status = tdlsSendMessage(pMac, eWNI_SME_TDLS_LINK_ESTABLISH_REQ,                             (void *)tdlsLinkEstablishReq,                             sizeof(tSirTdlsLinkEstablishReq));    if (!HAL_STATUS_SUCCESS( status ) )    {        smsLog( pMac, LOGE, FL("Failed to send request to MAC/n"));    }    return status;}

tSirRetStatus schSetFixedBeaconFields(tpAniSirGlobal pMac,tpPESession psessionEntry){    tpAniBeaconStruct pBeacon = (tpAniBeaconStruct)                                   pMac->sch.schObject.gSchBeaconFrameBegin;    tpSirMacMgmtHdr mac;    tANI_U16        offset;    tANI_U8        *ptr;    tDot11fBeacon1 *pBcn1;    tDot11fBeacon2 *pBcn2;    tANI_U32        i, nStatus, nBytes;    tANI_U32        wpsApEnable=0, tmp;    tDot11fIEWscProbeRes      *pWscProbeRes;    tANI_U8  *pExtraIe = NULL;    tANI_U32 extraIeLen =0;    tANI_U16 extraIeOffset = 0;    tANI_U16 p2pIeOffset = 0;    tSirRetStatus status = eSIR_SUCCESS;    pBcn1 = vos_mem_malloc(sizeof(tDot11fBeacon1));    if ( NULL == pBcn1 )    {        schLog(pMac, LOGE, FL("Failed to allocate memory") );        return eSIR_FAILURE;    }    pBcn2 = vos_mem_malloc(sizeof(tDot11fBeacon2));    if ( NULL == pBcn2 )    {        schLog(pMac, LOGE, FL("Failed to allocate memory") );        vos_mem_free(pBcn1);        return eSIR_FAILURE;    }    pWscProbeRes = vos_mem_malloc(sizeof(tDot11fIEWscProbeRes));    if ( NULL == pWscProbeRes )    {        schLog(pMac, LOGE, FL("Failed to allocate memory") );        vos_mem_free(pBcn1);        vos_mem_free(pBcn2);        return eSIR_FAILURE;    }    PELOG1(schLog(pMac, LOG1, FL("Setting fixed beacon fields"));)

/** * aniAsfPacketAllocateExplicit * * FUNCTION: * Create a packet of the desired size and position the head of the * packet at the desired offset in the internal raw data buffer. An * application would normally set this offset to the expected length * of the protocol header, then append the payload, and finally, * prepend the header. The allocated storage can be free with a call * to aniAsfPacketFree. * * LOGIC: * Allocates storage for tAniPacket and its internal raw data * buffer. Positions the head and tail pointers at the given offset in * the internal raw data buffer. * * @param packetPtr pointer that will be set to newly allocated * tAniPacket if the operation succeeds. * @param size the size of the internal raw data buffer * @param offset the offset in the internal raw data buffer where the * head of the packet will be positioned initially * * @return ANI_OK if the operation succeeds; ANI_E_MALLOC_FAILED if * memory could not be allocated. * @see aniAsfPacketFree */intaniAsfPacketAllocateExplicit(tAniPacket **packetPtr,                             v_U32_t size,                             v_U32_t offset){  tAniPacket *packet = NULL;  v_U32_t maxHead = size;  *packetPtr = NULL;  if (size == 0)    return ANI_E_ILLEGAL_ARG;  VOS_ASSERT(ANI_CHECK_RANGE(offset, maxHead));  if (!ANI_CHECK_RANGE(offset, maxHead))    return ANI_E_ILLEGAL_ARG;  packet = (tAniPacket *) vos_mem_malloc( sizeof(tAniPacket) );  if (packet == NULL)   {      VOS_ASSERT( 0 );      return ANI_E_MALLOC_FAILED;  }  // transparently add one to the size since last byte is wasted  size = (size + 4) & 0xfffffffc;  packet->buf = (v_U8_t *)vos_mem_malloc( sizeof(v_U8_t) * size );  if (packet->buf == NULL)   {      vos_mem_free( packet );      VOS_ASSERT( 0 );      return ANI_E_MALLOC_FAILED;  }  packet->size = size; // Should not be visible to the user  packet->head = packet->buf + offset;  packet->tail = packet->head;  packet->len = 0;  *packetPtr = packet;  return ANI_OK;}

eHalStatus p2pProcessRemainOnChannelCmd(tpAniSirGlobal pMac, tSmeCmd *p2pRemainonChn){    eHalStatus status = eHAL_STATUS_FAILURE;    tSirRemainOnChnReq* pMsg;    tANI_U32 len;    tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, p2pRemainonChn->sessionId );    if(!pSession)    {       smsLog(pMac, LOGE, FL("  session %d not found "), p2pRemainonChn->sessionId);       goto error;    }    if(!pSession->sessionActive)    {       smsLog(pMac, LOGE, FL("  session %d is invalid or listen is disabled "),            p2pRemainonChn->sessionId);       goto error;    }    len = sizeof(tSirRemainOnChnReq) + pMac->p2pContext.probeRspIeLength;    if( len > 0xFFFF )    {       /*In coming len for Msg is more then 16bit value*/       smsLog(pMac, LOGE, FL("  Message length is very large, %d"),            len);       goto error;    }    pMsg = vos_mem_malloc(len);    if ( NULL == pMsg )        goto error;    else    {        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO, "%s call", __func__);        vos_mem_set(pMsg, sizeof(tSirRemainOnChnReq), 0);        pMsg->messageType = eWNI_SME_REMAIN_ON_CHANNEL_REQ;        pMsg->length = (tANI_U16)len;        vos_mem_copy(pMsg->selfMacAddr, pSession->selfMacAddr, sizeof(tSirMacAddr));        pMsg->chnNum = p2pRemainonChn->u.remainChlCmd.chn;        pMsg->phyMode = p2pRemainonChn->u.remainChlCmd.phyMode;        pMsg->duration = p2pRemainonChn->u.remainChlCmd.duration;        pMsg->sessionId = p2pRemainonChn->sessionId;        pMsg->isProbeRequestAllowed = p2pRemainonChn->u.remainChlCmd.isP2PProbeReqAllowed;        if( pMac->p2pContext.probeRspIeLength )           vos_mem_copy((void *)pMsg->probeRspIe, (void *)pMac->p2pContext.probeRspIe,                        pMac->p2pContext.probeRspIeLength);        status = palSendMBMessage(pMac->hHdd, pMsg);    }error:    if (eHAL_STATUS_FAILURE == status)       csr_release_roc_req_cmd(pMac);    return status;}

VOS_STATUS vos_timer_init_debug( vos_timer_t *timer, VOS_TIMER_TYPE timerType,                            vos_timer_callback_t callback, v_PVOID_t userData,                            char* fileName, v_U32_t lineNum ){   VOS_STATUS vosStatus;    unsigned long flags;   // Check for invalid pointer   if ((timer == NULL) || (callback == NULL))    {      VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,                 "%s: Null params being passed",__func__);      VOS_ASSERT(0);      return VOS_STATUS_E_FAULT;   }   timer->ptimerNode = vos_mem_malloc(sizeof(timer_node_t));   if(timer->ptimerNode == NULL)   {      VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,                 "%s: Not able to allocate memory for timeNode",__func__);      VOS_ASSERT(0);      return VOS_STATUS_E_FAULT;   }   vos_mem_set(timer->ptimerNode, sizeof(timer_node_t), 0);    timer->ptimerNode->fileName = fileName;    timer->ptimerNode->lineNum   = lineNum;    timer->ptimerNode->vosTimer = timer;    spin_lock_irqsave(&vosTimerList.lock, flags);    vosStatus = hdd_list_insert_front(&vosTimerList, &timer->ptimerNode->pNode);    spin_unlock_irqrestore(&vosTimerList.lock, flags);    if(VOS_STATUS_SUCCESS != vosStatus)    {         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,              "%s: Unable to insert node into List vosStatus %d", __func__, vosStatus);    }      // set the various members of the timer structure    // with arguments passed or with default values   spin_lock_init(&timer->platformInfo.spinlock);   init_timer(&(timer->platformInfo.Timer));   timer->platformInfo.Timer.function = vos_linux_timer_callback;   timer->platformInfo.Timer.data = (unsigned long)timer;   timer->callback = callback;   timer->userData = userData;   timer->type = timerType;   timer->platformInfo.cookie = LINUX_TIMER_COOKIE;   timer->platformInfo.threadID = 0;   timer->state = VOS_TIMER_STATE_STOPPED;      return VOS_STATUS_SUCCESS;}

eHalStatus palAllocateMemory( tHddHandle hHdd, void **ppMemory, tANI_U32 numBytes ){    eHalStatus halStatus = eHAL_STATUS_SUCCESS;    *ppMemory = vos_mem_malloc( numBytes );    if ( NULL == *ppMemory )    {        halStatus = eHAL_STATUS_FAILURE;    }    return( halStatus );}

static voidibss_coalesce_save(    tpAniSirGlobal      pMac,    tpSirMacMgmtHdr     pHdr,    tpSchBeaconStruct   pBeacon){        ibss_coalesce_free(pMac);    pMac->lim.ibssInfo.pHdr = vos_mem_malloc(sizeof(*pHdr));    if (NULL == pMac->lim.ibssInfo.pHdr)    {        PELOGE(limLog(pMac, LOGE, FL("ibbs-save: Failed malloc pHdr"));)        return;

intaagPrf(v_U32_t cryptHandle,       v_U8_t result[AAG_PRF_MAX_OUTPUT_SIZE],       v_U8_t *key, v_U8_t keyLen,       v_U8_t *a, v_U8_t aLen,       v_U8_t *b, v_U8_t bLen,       v_U32_t prfLen){    static v_U8_t y;    v_U8_t *hmacText = NULL;    v_U8_t *resultOffset = result;    int numLoops;    int loopCtrPos;    int i, retVal=0;    hmacText = vos_mem_malloc( aLen + bLen + 2 );    if( NULL == hmacText )    {        return ANI_E_NULL_VALUE;    }    vos_mem_copy(hmacText + 0, a, aLen);    hmacText[aLen] = y;    vos_mem_copy(hmacText + aLen + 1, b, bLen);    loopCtrPos = aLen + 1 + bLen;    numLoops = prfLen + AAG_PTK_PRF_ADD_PARAM;    numLoops /= AAG_PTK_PRF_DIV_PARAM;    for (i = 0; i < numLoops; i++)     {        VOS_ASSERT((resultOffset - result + VOS_DIGEST_SHA1_SIZE)               <= AAG_PRF_MAX_OUTPUT_SIZE);        hmacText[loopCtrPos] = i;        if( VOS_IS_STATUS_SUCCESS( vos_sha1_hmac_str(cryptHandle, hmacText, loopCtrPos + 1, key, keyLen, resultOffset) ) )        {            resultOffset += VOS_DIGEST_SHA1_SIZE;            retVal = ANI_OK;        }        else        {            retVal = ANI_ERROR;        }    }    vos_mem_free(hmacText);    return retVal;}

tSirRetStatus macOpen(tHalHandle *pHalHandle, tHddHandle hHdd, tMacOpenParameters *pMacOpenParms){    tpAniSirGlobal pMac = NULL;    if(pHalHandle == NULL)        return eSIR_FAILURE;    /*     * Make sure this adapter is not already opened. (Compare pAdapter pointer in already     * allocated pMac structures.)     * If it is opened just return pointer to previously allocated pMac pointer.     * Or should this result in error?     */    /* Allocate pMac */    pMac = vos_mem_malloc(sizeof(tAniSirGlobal));    if ( NULL == pMac )        return eSIR_FAILURE;    /* Initialize the pMac structure */    vos_mem_set(pMac, sizeof(tAniSirGlobal), 0);    /** Store the Driver type in pMac Global.*/    //pMac->gDriverType = pMacOpenParms->driverType;    /*     * Set various global fields of pMac here     * (Could be platform dependant as some variables in pMac are platform     * dependant)     */    pMac->hHdd      = hHdd;    pMac->pAdapter  = hHdd; //This line wil be removed    *pHalHandle     = (tHalHandle)pMac;    {        /* Call various PE (and other layer init here) */        if( eSIR_SUCCESS != logInit(pMac))           return eSIR_FAILURE;        /* Call routine to initialize CFG data structures */        if( eSIR_SUCCESS != cfgInit(pMac) )            return eSIR_FAILURE;        sysInitGlobals(pMac);    }    return peOpen(pMac, pMacOpenParms);}

tSirRetStatus macStart(tHalHandle hHal, void* pHalMacStartParams){   tSirRetStatus status = eSIR_SUCCESS;   tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;   if (NULL == pMac)   {      VOS_ASSERT(0);      status = eSIR_FAILURE;      return status;   }   pMac->gDriverType = ((tHalMacStartParameters*)pHalMacStartParams)->driverType;   sysLog(pMac, LOG2, FL("called/n"));   do   {#if defined(TRACE_RECORD)      //Enable Tracing      macTraceInit(pMac);#endif      pMac->pResetMsg = vos_mem_malloc(sizeof(tSirMbMsg));      if ( NULL == pMac->pResetMsg )      {         sysLog(pMac, LOGE, FL("pMac->pResetMsg is NULL/n"));         status = eSIR_FAILURE;         break;      }      else      {         vos_mem_set(pMac->pResetMsg, sizeof(tSirMbMsg), 0);      }      if (pMac->gDriverType != eDRIVER_TYPE_MFG)      {         status = peStart(pMac);      }   } while(0);   pMac->sys.abort = false;   return status;}

/* * save TDLS peer info, this will be called after successfull completion * of TDLS discovery procedure. */static eHalStatus tdlsSaveTdlsPeerInfo(tpAniSirGlobal pMac,                                           tSirTdlsPeerInfo *disPeerInfo){    tCsrTdlsPeerLinkinfo *peerInfo = NULL ;     tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;    eHalStatus status = eHAL_STATUS_FAILURE ;    /*      * Ok, allocate memory for peer info here     * we allocate memory for each peer here and free his memory     * at the time the peer node is getting deleted, possible case is      * teardown     */    peerInfo = vos_mem_malloc(sizeof(tCsrTdlsPeerLinkinfo));    if ( NULL = peerInfo )        status = eHAL_STATUS_FAILURE;    else        status = eHAL_STATUS_SUCCESS;    /*      * go ahead and copy peerInfo and insert this node info discovery rsp     * database.     */     if (HAL_STATUS_SUCCESS(status))    {        vos_mem_set( &peerInfo->tdlsDisPeerInfo,                                            sizeof(tSirTdlsPeerInfo), 0);        vos_mem_copy( &peerInfo->tdlsDisPeerInfo, disPeerInfo,                                             sizeof(tSirTdlsPeerInfo));        /*         * update TDLS client count to indicate there is tdls client         * in tdls potential peer list.         */        disInfo->tdlsPeerCount++ ;        /*         * finally insert this tdls peer info into tdls potential peer list         */        csrLLInsertTail( &disInfo->tdlsPotentialPeerList,                                  &peerInfo->tdlsPeerStaLink, LL_ACCESS_LOCK );    }    return status ;}

eHalStatus csrTdlsProcessLinkEstablish( tpAniSirGlobal pMac, tSmeCmd *cmd ){    tTdlsLinkEstablishCmdInfo *tdlsLinkEstablishCmdInfo = &cmd->u.tdlsCmd.u.tdlsLinkEstablishCmdInfo ;    tSirTdlsLinkEstablishReq *tdlsLinkEstablishReq = NULL ;    eHalStatus status = eHAL_STATUS_FAILURE;    tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );    if (NULL == pSession)    {        smsLog( pMac, LOGE, FL("pSession is NULL"));        return eHAL_STATUS_FAILURE;    }    tdlsLinkEstablishReq = vos_mem_malloc(sizeof(tSirTdlsLinkEstablishReq));    if (tdlsLinkEstablishReq == NULL)    {        smsLog( pMac, LOGE, FL("alloc failed /n") );        VOS_ASSERT(0) ;        return status ;    }    tdlsLinkEstablishReq->sessionId = cmd->sessionId;        tdlsLinkEstablishReq->transactionId = 0;    palCopyMemory(pMac->hHdd, tdlsLinkEstablishReq->peerMac,                  tdlsLinkEstablishCmdInfo->peerMac, sizeof(tSirMacAddr));    palCopyMemory(pMac->hHdd, tdlsLinkEstablishReq->bssid, pSession->pConnectBssDesc->bssId,                  sizeof (tSirMacAddr));    tdlsLinkEstablishReq->isBufSta = tdlsLinkEstablishCmdInfo->isBufSta;    tdlsLinkEstablishReq->isResponder= tdlsLinkEstablishCmdInfo->isResponder;    tdlsLinkEstablishReq->uapsdQueues= tdlsLinkEstablishCmdInfo->uapsdQueues;    tdlsLinkEstablishReq->maxSp= tdlsLinkEstablishCmdInfo->maxSp;        smsLog( pMac, LOGE, "sending TDLS Link Establish Request to PE /n" );    status = tdlsSendMessage(pMac, eWNI_SME_TDLS_LINK_ESTABLISH_REQ,                             (void *)tdlsLinkEstablishReq,                             sizeof(tSirTdlsLinkEstablishReq));    if (!HAL_STATUS_SUCCESS( status ) )    {        smsLog( pMac, LOGE, FL("Failed to send request to MAC/n"));    }    return status;}

// tdlsoffchaneHalStatus csrTdlsProcessChanSwitchReq( tpAniSirGlobal pMac, tSmeCmd *cmd ){    tTdlsChanSwitchCmdInfo *tdlsChanSwitchCmdInfo = &cmd->u.tdlsCmd.u.tdlsChanSwitchCmdInfo ;    tSirTdlsChanSwitch *tdlsChanSwitch = NULL ;    eHalStatus status = eHAL_STATUS_FAILURE;    tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );    if (NULL == pSession)    {        smsLog( pMac, LOGE, FL("pSession is NULL"));        return eHAL_STATUS_FAILURE;    }    tdlsChanSwitch = vos_mem_malloc(sizeof(tSirTdlsChanSwitch));    if (tdlsChanSwitch == NULL)    {        smsLog( pMac, LOGE, FL("alloc failed /n") );        VOS_ASSERT(0) ;        return status ;    }    tdlsChanSwitch->sessionId = cmd->sessionId;    //Using dialog as transactionId. This can be used to match response with request    tdlsChanSwitch->transactionId = 0;    vos_mem_copy( tdlsChanSwitch->peerMac,                  tdlsChanSwitchCmdInfo->peerMac, sizeof(tSirMacAddr));    vos_mem_copy(tdlsChanSwitch->bssid, pSession->pConnectBssDesc->bssId,                 sizeof (tSirMacAddr));    tdlsChanSwitch->tdlsOffCh = tdlsChanSwitchCmdInfo->tdlsOffCh;    tdlsChanSwitch->tdlsOffChBwOffset = tdlsChanSwitchCmdInfo->tdlsOffChBwOffset;    tdlsChanSwitch->tdlsSwMode = tdlsChanSwitchCmdInfo->tdlsSwMode;    // Send the request to PE.    smsLog( pMac, LOGE, "sending TDLS Channel Switch to PE /n" );    status = tdlsSendMessage(pMac, eWNI_SME_TDLS_CHANNEL_SWITCH_REQ,                             (void *)tdlsChanSwitch,                             sizeof(tSirTdlsChanSwitch));    if (!HAL_STATUS_SUCCESS( status ) )    {        smsLog( pMac, LOGE, FL("Failed to send request to MAC/n"));    }    return status;}

static tCfgReq * allocateCfgReq(tHddHandle hHdd, tANI_U32 type, tANI_S32 length){    tCfgReq *req ;    tANI_S32 alloc_len = sizeof(tCfgReq) ;    if (type == CCM_STRING_TYPE)    {        alloc_len += length ;    }    req = vos_mem_malloc(alloc_len);    if ( NULL == req )    {        return NULL ;    }    req->ccmPtr = (req+1);    return req ;}

voidlimProcessProbeRspFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo,tpPESession psessionEntry){    tANI_U8                 *pBody;    tANI_U32                frameLen = 0;    tSirMacAddr             currentBssId;    tpSirMacMgmtHdr         pHdr;    tSirProbeRespBeacon    *pProbeRsp;    tANI_U8 qosEnabled =    false;    tANI_U8 wmeEnabled =    false;    if (!psessionEntry)    {        limLog(pMac, LOGE, FL("psessionEntry is NULL") );        return;    }    limLog(pMac,LOG1,"SessionId:%d ProbeRsp Frame is received",                psessionEntry->peSessionId);    pProbeRsp = vos_mem_malloc(sizeof(tSirProbeRespBeacon));    if ( NULL == pProbeRsp )    {        limLog(pMac, LOGE, FL("Unable to allocate memory in limProcessProbeRspFrame") );        return;    }    pProbeRsp->ssId.length              = 0;    pProbeRsp->wpa.length               = 0;    pProbeRsp->propIEinfo.apName.length = 0;    pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);   PELOG2(limLog(pMac, LOG2,             FL("Received Probe Response frame with length=%d from "),             WDA_GET_RX_MPDU_LEN(pRxPacketInfo));    limPrintMacAddr(pMac, pHdr->sa, LOG2);)   if (!pMac->fScanOffload)

/*==========================================================================  FUNCTION    sapChanSelInit  DESCRIPTION     Function sapChanSelInit allocates the memory, intializes the         structures used by the channel selection algorithm  DEPENDENCIES     NA.   PARAMETERS     IN    *pSpectInfoParams  : Pointer to tSapChSelSpectInfo structure     RETURN VALUE    v_BOOL_t:  Success or FAIL    SIDE EFFECTS ============================================================================*/v_BOOL_t sapChanSelInit(tHalHandle halHandle, tSapChSelSpectInfo *pSpectInfoParams){    tSapSpectChInfo *pSpectCh = NULL;    v_U8_t *pChans = NULL;    v_U16_t channelnum = 0;    tpAniSirGlobal pMac = PMAC_STRUCT(halHandle);    VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO_HIGH, "In %s", __FUNCTION__);    // Channels for that 2.4GHz band    //Considered only for 2.4GHz need to change in future to support 5GHz support    pSpectInfoParams->numSpectChans = pMac->scan.base20MHzChannels.numChannels;           // Allocate memory for weight computation of 2.4GHz    pSpectCh = (tSapSpectChInfo *)vos_mem_malloc((pSpectInfoParams->numSpectChans) * sizeof(*pSpectCh));    if(pSpectCh == NULL) {        VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_ERROR, "In %s, VOS_MALLOC_ERR", __FUNCTION__);        return eSAP_FALSE;    }    vos_mem_zero(pSpectCh, (pSpectInfoParams->numSpectChans) * sizeof(*pSpectCh));    // Initialize the pointers in the DfsParams to the allocated memory    pSpectInfoParams->pSpectCh = pSpectCh;    pChans = pMac->scan.base20MHzChannels.channelList;    // Fill the channel number in the spectrum in the operating freq band    for (channelnum = 0; channelnum < pSpectInfoParams->numSpectChans; channelnum++) {        if(*pChans == 14 ) //OFDM rates are not supported on channel 14            continue;        pSpectCh->chNum = *pChans;        pSpectCh->valid = eSAP_TRUE;        pSpectCh->rssiAgr = SOFTAP_MIN_RSSI;// Initialise for all channels        pSpectCh++;        pChans++;    }    return eSAP_TRUE;}

eHalStatus p2pSetPs(tHalHandle hHal, tP2pPsConfig *pNoA){    tpP2pPsConfig pNoAParam;    tSirMsgQ msg;    eHalStatus status = eHAL_STATUS_SUCCESS;    tpAniSirGlobal pMac = PMAC_STRUCT( hHal );    pNoAParam = vos_mem_malloc(sizeof(tP2pPsConfig));    if ( NULL == pNoAParam )       status = eHAL_STATUS_FAILURE;    else    {        vos_mem_set(pNoAParam, sizeof(tP2pPsConfig), 0);        vos_mem_copy(pNoAParam, pNoA, sizeof(tP2pPsConfig));        msg.type = eWNI_SME_UPDATE_NOA;        msg.bodyval = 0;        msg.bodyptr = pNoAParam;        limPostMsgApi(pMac, &msg);    }    return status;}

/* * CCM_STRING_TYPE                       CCM_INTEGER_TYPE * |<--------  4   ----->|               |<--------  4   ----->|                           * +----------+            <-- msg  -->  +----------+                                  * |type      |                          |type      |            * +----------+                          +----------+            * |msgLen=24 |                          |msgLen=16 |            * +----------+----------+               +----------+----------+ * | cfgId               |               | cfgId               |   * +---------------------+               +---------------------+ * | length=11           |               | length=4            |   * +---------------------+               +---------------------+ * |                     |               | value               |   * |                     |               +---------------------+   * |                     | * |                +----+ * |                |////| <- padding to 4-byte boundary * +----------------+----+ */static eHalStatus sendCfg(tpAniSirGlobal pMac, tHddHandle hHdd, tCfgReq *req, tANI_BOOLEAN fRsp){    tSirMbMsg *msg;    eHalStatus status;    tANI_S16 msgLen = (tANI_U16)(4 +    /* 4 bytes for msg header */                                 CFGOBJ_ID_SIZE +                                 CFGOBJ_LEN_SIZE +                                 CFGOBJ_ALIGN(req->length)) ;    msg = vos_mem_malloc(msgLen);    if ( NULL != msg )    {        if( fRsp )        {            msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ);        }        else        {            msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ_NO_RSP);        }        msg->msgLen = pal_cpu_to_be16(msgLen);        (void)encodeCfgReq(hHdd, msg->data, req->cfgId, req->length, req->ccmPtr, req->ccmValue, req->type) ;        status = palSendMBMessage(hHdd, msg) ;        if (status != eHAL_STATUS_SUCCESS)        {            smsLog( pMac, LOGW, FL("palSendMBMessage() failed"));            //No need to free msg. palSendMBMessage frees it.            status = eHAL_STATUS_FAILURE ;        }    }    else    {        smsLog( pMac, LOGW, FL("failed to allocate memory(len=%d)"), msgLen );        status = eHAL_STATUS_FAILURE;    }    return status ;}

static ssize_t ath_procfs_diag_read(struct file *file, char __user *buf,					size_t count, loff_t *pos){	hif_handle_t            hif_hdl;	int rv;	A_UINT8 *read_buffer = NULL;	read_buffer = (A_UINT8 *)vos_mem_malloc(count);	if (NULL == read_buffer) {		pr_debug("%s: vos_mem_alloc failed/n", __func__);		return -EINVAL;	}	hif_hdl = get_hif_hdl_from_file(file);	pr_debug("rd buff 0x%p cnt %zu offset 0x%x buf 0x%p/n",			read_buffer,count,			(int)*pos, buf);	if ((count == 4) && ((((A_UINT32)(*pos)) & 3) == 0)) {		/* reading a word? */		rv = HIFDiagReadAccess(hif_hdl, (A_UINT32)(*pos),					(A_UINT32 *)read_buffer);	} else {		rv = HIFDiagReadMem(hif_hdl, (A_UINT32)(*pos),					(A_UINT8 *)read_buffer, count);	}	if(copy_to_user(buf, read_buffer, count)) {		vos_mem_free(read_buffer);		return -EFAULT;	} else		vos_mem_free(read_buffer);	if (rv == 0) {		return count;	} else {		return -EIO;	}}

static ssize_t ath_procfs_diag_write(struct file *file, const char __user *buf,					size_t count, loff_t *pos){	hif_handle_t            hif_hdl;	int rv;	A_UINT8 *write_buffer = NULL;	write_buffer = (A_UINT8 *)vos_mem_malloc(count);	if (NULL == write_buffer) {		pr_debug("%s: vos_mem_alloc failed/n", __func__);		return -EINVAL;	}	if(copy_from_user(write_buffer, buf, count)) {		vos_mem_free(write_buffer);		return -EFAULT;	}	hif_hdl = get_hif_hdl_from_file(file);	pr_debug("wr buff 0x%p buf 0x%p cnt %zu offset 0x%x value 0x%x/n",			write_buffer, buf, count,			(int)*pos, *((A_UINT32 *)write_buffer));	if ((count == 4) && ((((A_UINT32)(*pos)) & 3) == 0)) {		/* reading a word? */		A_UINT32 value = *((A_UINT32 *)write_buffer);		rv = HIFDiagWriteAccess(hif_hdl,					(A_UINT32)(*pos), value);	} else {		rv = HIFDiagWriteMem(hif_hdl, (A_UINT32)(*pos),					(A_UINT8 *)write_buffer, count);	}	vos_mem_free(write_buffer);	if (rv == 0) {		return count;	} else {		return -EIO;	}}

tSirRetStatus macOpen(tHalHandle *pHalHandle, tHddHandle hHdd, tMacOpenParameters *pMacOpenParms){    tpAniSirGlobal pMac = NULL;    if(pHalHandle == NULL)        return eSIR_FAILURE;        pMac = vos_mem_malloc(sizeof(tAniSirGlobal));    if ( NULL == pMac )        return eSIR_FAILURE;        vos_mem_set(pMac, sizeof(tAniSirGlobal), 0);            pMac->hHdd      = hHdd;    pMac->pAdapter  = hHdd;     *pHalHandle     = (tHalHandle)pMac;    {                if( eSIR_SUCCESS != logInit(pMac))           return eSIR_FAILURE;                if( eSIR_SUCCESS != cfgInit(pMac) )            return eSIR_FAILURE;        sysInitGlobals(pMac);    }    return peOpen(pMac, pMacOpenParms);}

tSirRetStatus macPreStart(tHalHandle hHal){   tSirRetStatus status = eSIR_SUCCESS;   tANI_BOOLEAN memAllocFailed = eANI_BOOLEAN_FALSE;   tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;   tANI_U8 i;   for(i=0; i<MAX_DUMP_TABLE_ENTRY; i++)   {      pMac->dumpTableEntry[i] = vos_mem_malloc(sizeof(tDumpModuleEntry));      if ( NULL == pMac->dumpTableEntry[i] )      {         memAllocFailed = eANI_BOOLEAN_TRUE;         break;      }      else      {         vos_mem_set(pMac->dumpTableEntry[i], sizeof(tSirMbMsg), 0);      }   }   if( memAllocFailed )   {      while(i>0)      {         i--;         vos_mem_free(pMac->dumpTableEntry[i]);      }      sysLog(pMac, LOGE, FL("pMac->dumpTableEntry is NULL/n"));      status = eSIR_FAILURE;   }#if defined(ANI_LOGDUMP)   //logDumpInit must be called before any module starts   logDumpInit(pMac);#endif //#if defined(ANI_LOGDUMP)   return status;}

eHalStatus palTimerAlloc_debug( tHddHandle hHdd, tPalTimerHandle *phPalTimer,                           palTimerCallback pCallback, void *pContext, char* fileName, v_U32_t lineNum  ){   eHalStatus halStatus = eHAL_STATUS_FAILURE;   tPalTimer *pPalTimer = NULL;   VOS_STATUS vosStatus;       do   {      // allocate the internal timer structure.      pPalTimer = vos_mem_malloc( sizeof( tPalTimer ) );      if ( NULL == pPalTimer ) break;             // initialize the vos Timer that underlies the pal Timer.      vosStatus = vos_timer_init_debug( &pPalTimer->vosTimer, VOS_TIMER_TYPE_SW,                                    internalTimerCallback, pPalTimer, fileName, lineNum );      if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) )      {         // if fail to init the vos timer, free the memory and bail out.         vos_mem_free( pPalTimer );         break;      }            // initialize the info in the internal palTimer struct so we can       pPalTimer->timerCallback = pCallback;      pPalTimer->pContext      = pContext;      pPalTimer->hHdd          = hHdd;            // return a 'handle' to the caller.      *phPalTimer = pPalTimer;            halStatus = eHAL_STATUS_SUCCESS;         } while( 0 );              return( halStatus );}

eHalStatus p2pCancelRemainOnChannel(tHalHandle hHal, tANI_U8 sessionId){    eHalStatus status = eHAL_STATUS_SUCCESS;    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);    tSirMbMsgP2p *pMsg;    tANI_U16 msgLen;    //Need to check session ID to support concurrency    msgLen = (tANI_U16)(sizeof( tSirMbMsg ));    pMsg = vos_mem_malloc(msgLen);    if ( NULL == pMsg )       status = eHAL_STATUS_FAILURE;    else    {        vos_mem_set((void *)pMsg, msgLen, 0);        pMsg->type = pal_cpu_to_be16((tANI_U16)eWNI_SME_ABORT_REMAIN_ON_CHAN_IND);        pMsg->msgLen = pal_cpu_to_be16(msgLen);        pMsg->sessionId = sessionId;        status = palSendMBMessage(pMac->hHdd, pMsg);    }    return( status );}

/****************************************************************************** * Function: sme_NanRequest * * Description: * This function gets called when HDD receives NAN vendor command * from user space * * Args: * Nan Request structure ptr * * Returns: * VOS_STATUS *****************************************************************************/VOS_STATUS sme_NanRequest(tpNanRequestReq input){	 vos_msg_t msg;	 tpNanRequest data;	 size_t data_len;	 data_len = sizeof(tNanRequest) + input->request_data_len;	 data = vos_mem_malloc(data_len);	 if (data == NULL) {		 VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,				FL("Memory allocation failure"));		 return VOS_STATUS_E_FAULT;	 }	 vos_mem_zero(data, data_len);	 data->request_data_len = input->request_data_len;	 if (input->request_data_len) {		 vos_mem_copy(data->request_data,				input->request_data, input->request_data_len);	 }	 msg.type = WDA_NAN_REQUEST;	 msg.reserved = 0;	 msg.bodyptr = data;	 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MODULE_ID_WDA,					 &msg)) {	 VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,		FL("Not able to post WDA_NAN_REQUEST message to WDA"));		vos_mem_free(data);	 return VOS_STATUS_SUCCESS;	 }	 return VOS_STATUS_SUCCESS;}

/** * limSendBeaconParams() * *FUNCTION: * This function is called to send beacnon interval, short preamble or other * parameters to WDA, which are changed and indication is received in beacon. * *LOGIC: * *ASSUMPTIONS: * NA * *NOTE: * NA * * @param pMac  pointer to Global Mac structure. * @param tpUpdateBeaconParams pointer to the structure,                which contains the beacon parameters which are changed. * * @return success if message send is ok, else false. */tSirRetStatus limSendBeaconParams(tpAniSirGlobal pMac,                                   tpUpdateBeaconParams pUpdatedBcnParams,                                  tpPESession  psessionEntry ){    tpUpdateBeaconParams pBcnParams = NULL;    tSirRetStatus   retCode = eSIR_SUCCESS;    tSirMsgQ msgQ;    pBcnParams = vos_mem_malloc(sizeof(*pBcnParams));    if ( NULL == pBcnParams )    {        limLog( pMac, LOGP,            FL( "Unable to allocate memory during Update Beacon Params" ));        return eSIR_MEM_ALLOC_FAILED;    }    vos_mem_copy((tANI_U8 *) pBcnParams,  pUpdatedBcnParams, sizeof(*pBcnParams));    msgQ.type = WDA_UPDATE_BEACON_IND;    msgQ.reserved = 0;    msgQ.bodyptr = pBcnParams;    msgQ.bodyval = 0;    PELOG3(limLog( pMac, LOG3,                FL( "Sending WDA_UPDATE_BEACON_IND, paramChangeBitmap in hex = %x" ),                    pUpdatedBcnParams->paramChangeBitmap);)    if(NULL == psessionEntry)

/** * limSendCFParams() * *FUNCTION: * This function is called to send CFP Parameters to WDA, when they are changed. * *LOGIC: * *ASSUMPTIONS: * NA * *NOTE: * NA * * @param pMac  pointer to Global Mac structure. * @param bssIdx Bss Index of the BSS to which STA is associated. * @param cfpCount CFP Count, if that is changed. * @param cfpPeriod CFP Period if that is changed. * * @return success if message send is ok, else false. */tSirRetStatus limSendCFParams(tpAniSirGlobal pMac, tANI_U8 bssIdx, tANI_U8 cfpCount, tANI_U8 cfpPeriod){    tpUpdateCFParams pCFParams = NULL;    tSirRetStatus   retCode = eSIR_SUCCESS;    tSirMsgQ msgQ;    pCFParams = vos_mem_malloc(sizeof( tUpdateCFParams ));    if ( NULL == pCFParams )      {        limLog( pMac, LOGP,            FL( "Unable to allocate memory during Update CF Params" ));        retCode = eSIR_MEM_ALLOC_FAILED;        goto returnFailure;      }    vos_mem_set( (tANI_U8 *) pCFParams, sizeof(tUpdateCFParams), 0);    pCFParams->cfpCount = cfpCount;    pCFParams->cfpPeriod = cfpPeriod;    pCFParams->bssIdx     = bssIdx;    msgQ.type = WDA_UPDATE_CF_IND;    msgQ.reserved = 0;    msgQ.bodyptr = pCFParams;    msgQ.bodyval = 0;    limLog( pMac, LOG3,                FL( "Sending WDA_UPDATE_CF_IND..." ));    MTRACE(macTraceMsgTx(pMac, NO_SESSION, msgQ.type));    if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))    {        vos_mem_free(pCFParams);        limLog( pMac, LOGP,                    FL("Posting  WDA_UPDATE_CF_IND to WDA failed, reason=%X"),                    retCode );    }returnFailure:    return retCode;}