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

intncvarget(    int		ncid,    int		varid,    const long*	start,    const long*	count,     void*	value){	NDIMS_DECL	A_DECL(stp, size_t, ndims, start);	A_DECL(cntp, size_t, ndims, count);	A_INIT(stp, size_t, ndims, start);	A_INIT(cntp, size_t, ndims, count);	{	const int status = nc_get_vara(ncid, varid, stp, cntp, value);	A_FREE(cntp);	A_FREE(stp);	if(status != NC_NOERR)	{		nc_advise("ncvarget", status, "ncid %d; varid %d", ncid, varid);		return -1;	}	}	return 0;}

/* cleanup the HTC instance */static void HTCCleanup(HTC_TARGET *target){    A_INT32 i;    DevCleanup(&target->Device);        for (i = 0;i < NUM_CONTROL_BUFFERS;i++) {        if (target->HTCControlBuffers[i].Buffer) {            A_FREE(target->HTCControlBuffers[i].Buffer);        }    }        if (A_IS_MUTEX_VALID(&target->HTCLock)) {        A_MUTEX_DELETE(&target->HTCLock);    }    if (A_IS_MUTEX_VALID(&target->HTCRxLock)) {        A_MUTEX_DELETE(&target->HTCRxLock);    }    if (A_IS_MUTEX_VALID(&target->HTCTxLock)) {        A_MUTEX_DELETE(&target->HTCTxLock);    }        /* free our instance */    A_FREE(target);}

A_STATUSBMIDone(A_VOID *pCxt){    A_STATUS status;    A_UINT32 cid;    if (bmiDone) {        return A_OK;    }    bmiDone = TRUE;    cid = A_CPU2LE32(BMI_DONE);    status = bmiBufferSend(pCxt, (A_UCHAR *)&cid, sizeof(cid));    if (status != A_OK) {        return A_ERROR;    }    if (pBMICmdCredits) {        A_FREE(pBMICmdCredits, MALLOC_ID_TEMPORARY);        pBMICmdCredits = NULL;    }    if (pBMICmdBuf) {        A_FREE(pBMICmdBuf, MALLOC_ID_TEMPORARY);        pBMICmdBuf = NULL;    }    return A_OK;}

    /* clean up scatter support */void CleanupHIFScatterResources(HIF_DEVICE *device){    HIF_SCATTER_REQ_PRIV    *pReqPriv;    HIF_SCATTER_REQ         *pReq;            /* empty the free list */            while (1) {                pReq = AllocScatterReq(device);                        if (NULL == pReq) {            break;            }                   pReqPriv = (HIF_SCATTER_REQ_PRIV *)pReq->HIFPrivate[0];        A_ASSERT(pReqPriv != NULL);                if (pReqPriv->busrequest != NULL) {            pReqPriv->busrequest->pScatterReq = NULL;                /* free bus request */            hifFreeBusRequest(device, pReqPriv->busrequest);            pReqPriv->busrequest = NULL;        }                if (pReqPriv->pHifScatterReq != NULL) {            A_FREE(pReqPriv->pHifScatterReq);               pReqPriv->pHifScatterReq = NULL;         }                        A_FREE(pReqPriv);           }}

intBMIDone(struct hif_device *device){    int status;    u32 cid;    if (bmiDone) {        AR_DEBUG_PRINTF (ATH_DEBUG_BMI, ("BMIDone skipped/n"));        return 0;    }    AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Enter (device: 0x%p)/n", device));    bmiDone = true;    cid = BMI_DONE;    status = bmiBufferSend(device, (u8 *)&cid, sizeof(cid));    if (status) {        AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to write to the device/n"));        return A_ERROR;    }    if (pBMICmdCredits) {        A_FREE(pBMICmdCredits);        pBMICmdCredits = NULL;    }    if (pBMICmdBuf) {        A_FREE(pBMICmdBuf);        pBMICmdBuf = NULL;    }    AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Exit/n"));    return 0;}

void  ar6000_cleanup_hci(AR_SOFTC_T *ar)#endif{#ifdef EXPORT_HCI_BRIDGE_INTERFACE    AR6K_HCI_BRIDGE_INFO *pHcidevInfo = g_pHcidevInfo;#else    AR6K_HCI_BRIDGE_INFO *pHcidevInfo = (AR6K_HCI_BRIDGE_INFO *)ar->hcidev_info;#endif        if (pHcidevInfo != NULL) {        bt_cleanup_hci(pHcidevInfo);                   if (pHcidevInfo->pHCIDev != NULL) {            HCI_TransportStop(pHcidevInfo->pHCIDev);            HCI_TransportDetach(pHcidevInfo->pHCIDev);            pHcidevInfo->pHCIDev = NULL;        }                 if (pHcidevInfo->pHTCStructAlloc != NULL) {            A_FREE(pHcidevInfo->pHTCStructAlloc);            pHcidevInfo->pHTCStructAlloc = NULL;            }                A_FREE(pHcidevInfo);#ifndef EXPORT_HCI_BRIDGE_INTERFACE        ar->hcidev_info = NULL;        ar->exitCallback = NULL;#endif    }        }

intncvargets(    int		ncid,    int		varid,    const long*	start,    const long*	count,    const long*	stride,    void*	value){	if(stride == NULL)		return ncvarget(ncid, varid, start, count, value);	/* else */	{	NDIMS_DECL	A_DECL(stp, size_t, ndims, start);	A_DECL(cntp, size_t, ndims, count);	A_DECL(strdp, ptrdiff_t, ndims, stride);	A_INIT(stp, size_t, ndims, start);	A_INIT(cntp, size_t, ndims, count);	A_INIT(strdp, ptrdiff_t, ndims, stride);	{	const int status = nc_get_vars(ncid, varid, stp, cntp, strdp, value);	A_FREE(strdp);	A_FREE(cntp);	A_FREE(stp);	if(status != NC_NOERR)	{		nc_advise("ncvargets", status, "ncid %d", ncid);		return -1;	}	}	return 0;	}}

voidwlan_node_free(bss_t *ni){    if (ni->ni_buf != NULL) {        A_FREE(ni->ni_buf);    }    A_FREE(ni);}

static void hif_usb_remove(struct usb_interface *interface){	HIF_DEVICE_USB *device = usb_get_intfdata(interface);	struct hif_usb_softc *sc = device->sc;	struct ol_softc *scn;	/* Attach did not succeed, all resources have been	 * freed in error handler	 */	if (!sc)		return;	/* wait __hdd_wlan_exit until finished and no more than 4 seconds*/	while(usb_sc->hdd_removed_processing == 1 &&			usb_sc->hdd_removed_wait_cnt < 20) {		set_current_state(TASK_INTERRUPTIBLE);		schedule_timeout(msecs_to_jiffies(DELAY_INT_FOR_HDD_REMOVE));		set_current_state(TASK_RUNNING);		usb_sc->hdd_removed_wait_cnt ++;	}	/* do cold reset */	HIFDiagWriteCOLDRESET(sc->hif_device);	/* wait for target jump to boot code and finish the initialization */	set_current_state(TASK_INTERRUPTIBLE);	schedule_timeout(msecs_to_jiffies(DELAY_FOR_TARGET_READY));	set_current_state(TASK_RUNNING);	if (usb_sc->local_state.event != 0) {		hif_usb_resume(usb_sc->interface);		usb_sc->local_state.event = 0;	}	unregister_reboot_notifier(&sc->reboot_notifier);	usb_put_dev(interface_to_usbdev(interface));	if (atomic_read(&hif_usb_unload_state) ==			HIF_USB_UNLOAD_STATE_DRV_DEREG)		atomic_set(&hif_usb_unload_state,			   HIF_USB_UNLOAD_STATE_TARGET_RESET);	scn = sc->ol_sc;	if (usb_sc->hdd_removed == 0) {		usb_sc->hdd_removed_processing = 1;#ifndef REMOVE_PKT_LOG	if (vos_get_conparam() != VOS_FTM_MODE &&		!WLAN_IS_EPPING_ENABLED(vos_get_conparam()))		pktlogmod_exit(scn);#endif		__hdd_wlan_exit();		usb_sc->hdd_removed_processing = 0;		usb_sc->hdd_removed = 1;	}	hif_nointrs(sc);	HIF_USBDeviceDetached(interface, 1);	A_FREE(scn);	A_FREE(sc);	usb_sc = NULL;	pr_info("hif_usb_remove!!!!!!/n");}

voidBMICleanup(void){    if (pBMICmdCredits) {        A_FREE(pBMICmdCredits);        pBMICmdCredits = NULL;    }    if (pBMICmdBuf) {        A_FREE(pBMICmdBuf);        pBMICmdBuf = NULL;    }}

voidBMICleanup(void){    if (pBMICmdCredits) {        A_FREE(pBMICmdCredits, MALLOC_ID_TEMPORARY);        pBMICmdCredits = NULL;    }    if (pBMICmdBuf) {        A_FREE(pBMICmdBuf, MALLOC_ID_TEMPORARY);        pBMICmdBuf = NULL;    }}

voidBMICleanup(void){#if 0    if (pBMICmdCredits) {        A_FREE(pBMICmdCredits);        pBMICmdCredits = NULL;    }#endif    if (pBMICmdBuf) {        A_FREE(pBMICmdBuf);        pBMICmdBuf = NULL;    }}

voidwlan_node_free(bss_t *ni){    if (ni->ni_buf != NULL) {        A_FREE(ni->ni_buf);        ni->ni_buf = NULL;    }#ifdef P2P    if (ni->p2p_dev) {        p2p_device_free(ni->p2p_dev);    }#endif /* P2P */    A_FREE(ni);    ni = NULL;}

void cmp_model_reload(const char* filepath, reshandle_t hdl, int manual){    reshandle_t nhdl;    uint cnt;    struct allocator* tmp_alloc = tsk_get_tmpalloc(0);    cmp_t c = cmp_findtype(cmp_model_type);    const struct cmp_instance_desc** insts = cmp_get_allinstances(c, &cnt, tmp_alloc);    /* reload model and refresh all model component data */    cmp_model_destroyinstances(hdl, insts, cnt);    if (!manual)        nhdl = rs_load_model(filepath, RS_LOAD_REFRESH);    else        nhdl = hdl;    if (nhdl != INVALID_HANDLE) {        if (rs_get_model(nhdl) != NULL)            cmp_model_rebuildhinstances(eng_get_dataalloc(), tmp_alloc, hdl, insts, cnt);        else            cmp_model_clearinstances(hdl, insts, cnt, FALSE);    }    else   {        cmp_model_clearinstances(hdl, insts, cnt, TRUE);  /* this happens when model-reload fails                                                             we have to invalidate handles */    }    A_FREE(tmp_alloc, insts);}

static HTC_PACKET *BuildHTCTxCtrlPacket(adf_os_device_t osdev){    HTC_PACKET *pPacket = NULL;    adf_nbuf_t netbuf;    do {        pPacket = (HTC_PACKET *)A_MALLOC(sizeof(HTC_PACKET));        if (NULL == pPacket) {            break;        }        A_MEMZERO(pPacket,sizeof(HTC_PACKET));#ifdef ATH_USE_NCNB        netbuf = adf_nbuf_alloc_ncnb(osdev, HTC_CONTROL_BUFFER_SIZE, 20, 4, TRUE);#else        netbuf = adf_nbuf_alloc(osdev, HTC_CONTROL_BUFFER_SIZE, 20, 4, TRUE);#endif        if (NULL == netbuf) {            A_FREE(pPacket);            pPacket = NULL;	        adf_os_print("%s: nbuf alloc failed/n",__func__);            break;        }        AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("alloc ctrl netbuf :0x%p /n", netbuf));        SET_HTC_PACKET_NET_BUF_CONTEXT(pPacket, netbuf);    } while (FALSE);    return pPacket;}

A_STATUS write_bdaddr(AR3K_CONFIG_INFO *pConfig,A_UCHAR *bdaddr,int type){	A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01, 							0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };    A_UINT8 *event;    A_UINT8 *bufferToFree = NULL;    A_STATUS result = A_ERROR;	int inc,outc;	if (type == BDADDR_TYPE_STRING)		str2ba(bdaddr,&bdaddr_cmd[7]);	else {		/* Bdaddr has to be sent as LAP first */		for(inc = 5 ,outc = 7; inc >=0; inc--, outc++)			bdaddr_cmd[outc] = bdaddr[inc];	}    if(A_OK == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd,												sizeof(bdaddr_cmd),												&event,&bufferToFree)) {        if(event[4] == 0xFC && event[5] == 0x00){               if(event[3] == 0x0B){                result = A_OK;            }        }    }    if(bufferToFree != NULL) {        A_FREE(bufferToFree);   }    return result;}

A_STATUS write_bdaddr(AR3K_CONFIG_INFO *pConfig,A_UCHAR *bdaddr){	A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01, 							0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };    A_UINT8 *event;    A_UINT8 *bufferToFree = NULL;    A_STATUS result = A_ERROR;		str2ba(bdaddr,&bdaddr_cmd[7]);    if(A_OK == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd,												sizeof(bdaddr_cmd),												&event,&bufferToFree)) {        if(event[4] == 0xFC && event[5] == 0x00){               if(event[3] == 0x0B){                result = A_OK;            }        }    }    if(bufferToFree != NULL) {        A_FREE(bufferToFree);   }    return result;}

/* Update the buffer alone, not the entire node. * This involves, * 1) Freeing the buffer alone. * 2) Allocating a new buffer * 3) Update the node timestamp with the current time. */A_STATUSwlan_node_buf_update(struct ieee80211_node_table *nt, bss_t *ni, A_UINT32 len){    IEEE80211_NODE_LOCK(nt);    /* Free the ni_buf alone.     */    if (ni->ni_buf != NULL) {        A_FREE(ni->ni_buf);        ni->ni_buf = NULL;    }    /* Allocate ni_buf for the new length.     */    if (len) {        ni->ni_buf = A_MALLOC_NOWAIT(len);        if (ni->ni_buf == NULL) {            IEEE80211_NODE_UNLOCK(nt);            return A_ERROR;        } else {            A_MEMZERO(ni->ni_buf, len);        }    }    /* Update the Node's timestamp.     */    wlan_node_update_timestamp(nt, ni);    IEEE80211_NODE_UNLOCK(nt);    return A_OK;}

void model_unloadocc(struct gfx_model_occ* occ, struct allocator* alloc){    if (occ->indexes != NULL)        A_FREE(alloc, occ->indexes);    if (occ->poss != NULL)        A_ALIGNED_FREE(alloc, occ->poss);}

voidAbf_WlanStackNotificationDeInit(ATH_BT_FILTER_INSTANCE *pInstance){    ATHBT_FILTER_INFO *pInfo = (ATHBT_FILTER_INFO *)pInstance->pContext;    ABF_WLAN_INFO *pAbfWlanInfo = pInfo->pWlanInfo;    if (!pAbfWlanInfo) return;    /* Terminate and wait for the WLAN Event Handler task to finish */    A_MUTEX_LOCK(&pAbfWlanInfo->hWaitEventLock);    if (pAbfWlanInfo->Loop) {        pAbfWlanInfo->Loop = FALSE;        A_COND_WAIT(&pAbfWlanInfo->hWaitEvent, &pAbfWlanInfo->hWaitEventLock,                     WAITFOREVER);    }    A_MUTEX_UNLOCK(&pAbfWlanInfo->hWaitEventLock);    /* Flush all the BT actions from the filter core */    HandleAdapterEvent(pInfo, ATH_ADAPTER_REMOVED);    pInfo->pWlanInfo = NULL;    A_MUTEX_DEINIT(&pAbfWlanInfo->hWaitEventLock);    A_COND_DEINIT(&pAbfWlanInfo->hWaitEvent);    A_MEMZERO(pAbfWlanInfo, sizeof(ABF_WLAN_INFO));    A_FREE(pAbfWlanInfo);    A_INFO("WLAN Stack Notification de-init complete/n");}

bss_t *wlan_node_alloc(struct ieee80211_node_table *nt, A_INT32 wh_size){    bss_t *ni;    ni = A_MALLOC(sizeof(bss_t));    if (ni != NULL) {        ni->ni_buf = A_MALLOC(wh_size);        if (ni->ni_buf == NULL) {            A_FREE(ni);            ni = NULL;        }    }	/* Make sure our lists are clean */    if (ni) {        ni->ni_list_next = NULL;        ni->ni_list_prev = NULL;        ni->ni_hash_next = NULL;        ni->ni_hash_prev = NULL;    }    return ni;}

A_STATUSBMIDone(HIF_DEVICE *device){    A_STATUS status;    A_UINT32 cid;    if (bmiDone) {        AR_DEBUG_PRINTF (ATH_DEBUG_BMI, ("BMIDone skipped/n"));        return A_OK;    }    AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Enter (device: 0x%p)/n", device));    bmiDone = TRUE;    cid = BMI_DONE;    A_MEMCPY(pBMICmdBuf,&cid,sizeof(cid));    status = HIFExchangeBMIMsg(device, pBMICmdBuf, sizeof(cid), NULL, NULL, 0);    if (status != A_OK) {        AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to write to the device/n"));        return A_ERROR;    }    if (pBMICmdBuf) {        A_FREE(pBMICmdBuf);        pBMICmdBuf = NULL;    }    AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Exit/n"));    return A_OK;}

void cmp_anim_destroybind(struct cmp_anim* a){    if (a->alloc != NULL)    {        if (a->bindmap != NULL) {            A_FREE(a->alloc, a->bindmap);        }        if (a->root_idxs != NULL)   {            A_FREE(a->alloc, a->root_idxs);        }    }    a->root_idxs = NULL;    a->pose = NULL;    a->bindmap = NULL;    a->root_cnt = 0;}

void android_release_firmware(const struct firmware *firmware){	if (firmware) {        if (firmware->data)            vfree(firmware->data);        A_FREE((struct firmware *)firmware);    }}

void load_pak(struct paki_args* args){    result_t r;    struct pak_file pak;    char filename[DH_PATH_MAX];    path_norm(args->pakfile, args->pakfile);    path_tounix(args->path, args->path);    r = pak_open(&pak, mem_heap(), args->pakfile, 0);    if (IS_FAIL(r))     {        err_sendtolog(FALSE);        return;    }    uint file_id = pak_findfile(&pak, args->path);    if (file_id == INVALID_INDEX)   {        printf(TERM_BOLDRED "Extract failed: file '%s' not found in pak./n" TERM_RESET, args->path);        pak_close(&pak);        return;    }    path_getfullfilename(filename, args->path);    file_t f = fio_createdisk(filename);    if (f == NULL)     {        printf(TERM_BOLDRED "Extract failed: could not create '%s' for writing./n" TERM_RESET,               filename);        pak_close(&pak);        err_sendtolog(FALSE);        return;    }    file_t src_file = pak_getfile(&pak, mem_heap(), mem_heap(), file_id, 0);    if (src_file == NULL)   {        pak_close(&pak);        fio_close(f);        err_sendtolog(FALSE);        return;    }    size_t size;    struct allocator* alloc;    void* buffer = fio_detachmem(src_file, &size, &alloc);    fio_write(f, buffer, size, 1);    A_FREE(alloc, buffer);    fio_close(f);    pak_close(&pak);    if (BIT_CHECK(args->usage, PAKI_USAGE_VERBOSE)) {        printf(TERM_WHITE "%s -> %s/n" TERM_RESET, args->path, filename);    }    args->file_cnt ++;    // report    printf(TERM_BOLDWHITE "Finished: total %d file(s) - %d error(s), %d warning(s)/n" TERM_RESET,           args->file_cnt, args->err_cnt, args->warn_cnt);}

A_STATUS FCore_ModifyControlActionString(BT_FILTER_CORE_INFO          *pCore,                                         ATHBT_STATE_INDICATION       Indication,                                         ATHBT_STATE                  State,                                         A_CHAR                       *pAction,                                         int                          StringLength,                                         ATHBT_MODIFY_CONTROL_ACTION  ModifyAction){    BT_CONTROL_ACTION_DESC  *pNewDesc;    BT_CONTROL_ACTION_DESC  *pDescHead;    A_CHAR                  *pString;        /* get first entry at the head */    pDescHead = &pCore->ActionDescriptors[Indication].Action[State];        /* allocate and assemble an entry for this action */    pNewDesc = (BT_CONTROL_ACTION_DESC  *)A_MALLOC(sizeof(BT_CONTROL_ACTION_DESC) + StringLength + 1);    if (NULL == pNewDesc) {        return A_NO_MEMORY;    }    A_MEMZERO(pNewDesc,sizeof(BT_CONTROL_ACTION_DESC));        /* setup and copy string */    pString = (A_CHAR *)((A_UINT8 *)pNewDesc + sizeof(BT_CONTROL_ACTION_DESC));    A_MEMCPY(pString,pAction,StringLength);    pString[StringLength] = 0;    pNewDesc->pActionString = pString;        /* mark that it was allocated so we can clean it up later */    pNewDesc->Flags = BT_CA_DESC_FLAGS_ALLOCATED;    switch (ModifyAction) {        case ATHBT_MODIFY_CONTROL_ACTION_APPEND:                /* append to the end of the list */            while (pDescHead->pNext != NULL) {                pDescHead = pDescHead->pNext;            }            pDescHead->pNext = pNewDesc;            break;        case ATHBT_MODIFY_CONTROL_ACTION_REPLACE:                /* remove any existing replacements or append operations */            CleanupModifiedControlActionDescChain(pDescHead);                /* ignore the first entry's action string */            pDescHead->pActionString = NULL;                /* add new replacement */            pDescHead->pNext = pNewDesc;            break;        default:            A_FREE(pNewDesc);            break;    }    return A_OK;}

int android_request_firmware(const struct firmware **firmware_p, const char *name,                     struct device *device){    int ret = 0;    struct firmware *firmware;    char filename[256];    const char *raw_filename = name;	*firmware_p = firmware = A_MALLOC(sizeof(*firmware));    if (!firmware) 		return -ENOMEM;    A_MEMZERO(firmware, sizeof(*firmware));	sprintf(filename, "%s/%s", fwpath, raw_filename);#ifdef TARGET_EUROPA    if (strcmp(raw_filename, "softmac")==0) {        sprintf(filename, "/data/.nvmac.info");    }#endif /* TARGET_EUROPA */    do {        size_t length, bufsize, bmisize;        if ( (ret=android_readwrite_file(filename, NULL, NULL, 0)) < 0) {            break;        } else {            length = ret;        }            bufsize = ALIGN(length, PAGE_SIZE);        bmisize = A_ROUND_UP(length, 4);        bufsize = max(bmisize, bufsize);        firmware->data = vmalloc(bufsize);        firmware->size = length;        if (!firmware->data) {            AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: Cannot allocate buffer for firmware/n", __FUNCTION__));            ret = -ENOMEM;            break;        }            if ( (ret=android_readwrite_file(filename, (char*)firmware->data, NULL, length)) != length) {            AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: file read error, ret %d request %d/n", __FUNCTION__, ret, length));            ret = -1;            break;        }        } while (0);    if (ret<0) {        if (firmware) {            if (firmware->data)                vfree(firmware->data);            A_FREE(firmware);        }        *firmware_p = NULL;    } else {        ret = 0;    }    return ret;    }

void mt_event_destroy(mt_event e){    for (int i = 0; i < e->signals.item_cnt; i++) {        HANDLE ehdl = ((HANDLE*)e->signals.buffer)[i];        if (ehdl != NULL)            CloseHandle(ehdl);    }    arr_destroy(&e->signals);    A_FREE(e->alloc, e);}

static void DestroyHTCTxCtrlPacket(HTC_PACKET *pPacket){    adf_nbuf_t netbuf;    netbuf = (adf_nbuf_t)GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);    AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("free ctrl netbuf :0x%p /n", netbuf));    if (netbuf != NULL) {        adf_nbuf_free(netbuf);    }    A_FREE(pPacket);}