VirtualBox

Changeset 38895 in vbox


Ignore:
Timestamp:
Sep 28, 2011 12:04:39 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
74221
Message:

HostDrivers/solaris: LogFlow->Log for debug purposes.

Location:
trunk/src/VBox/HostDrivers
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c

    r37280 r38895  
    2929*******************************************************************************/
    3030#define LOG_GROUP LOG_GROUP_SUP_DRV
     31#ifdef DEBUG_ramshankar
     32# define LOG_ENABLED
     33# define LOG_INSTANCE       RTLogRelDefaultInstance()
     34#endif
    3135#include <sys/types.h>
    3236#include <sys/param.h>
  • trunk/src/VBox/HostDrivers/VBoxNetAdp/solaris/VBoxNetAdp-solaris.c

    r38736 r38895  
    2121#define LOG_GROUP LOG_GROUP_NET_ADP_DRV
    2222#ifdef DEBUG_ramshankar
     23# define LOG_ENABLED
    2324# define LOG_INSTANCE       RTLogRelDefaultInstance()
    2425#endif
     
    214215int _init(void)
    215216{
    216     LogFlowFunc((DEVICE_NAME ":_init\n"));
     217    LogFunc((DEVICE_NAME ":_init\n"));
    217218
    218219    /*
     
    247248int _fini(void)
    248249{
    249     LogFlowFunc((DEVICE_NAME ":_fini\n"));
     250    LogFunc((DEVICE_NAME ":_fini\n"));
    250251
    251252    /*
     
    260261int _info(struct modinfo *pModInfo)
    261262{
    262     LogFlowFunc((DEVICE_NAME ":_info\n"));
     263    LogFunc((DEVICE_NAME ":_info\n"));
    263264
    264265    int rc = mod_info(&g_VBoxNetAdpSolarisModLinkage, pModInfo);
    265266
    266     LogFlow((DEVICE_NAME ":_info returns %d\n", rc));
     267    Log((DEVICE_NAME ":_info returns %d\n", rc));
    267268    return rc;
    268269}
     
    279280static int VBoxNetAdpSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    280281{
    281     LogFlowFunc((DEVICE_NAME ":VBoxNetAdpSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     282    LogFunc((DEVICE_NAME ":VBoxNetAdpSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    282283
    283284    int rc = -1;
     
    384385static int VBoxNetAdpSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
    385386{
    386     LogFlowFunc((DEVICE_NAME ":VBoxNetAdpSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     387    LogFunc((DEVICE_NAME ":VBoxNetAdpSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    387388
    388389    switch (enmCmd)
     
    439440    pMac->au8[2] = 0x27;
    440441    RTRandBytes(&pMac->au8[3], 3);
    441     LogFlow((DEVICE_NAME ":VBoxNetAdpSolarisGenerateMac Generated %.*Rhxs\n", sizeof(RTMAC), &pMac));
     442    Log((DEVICE_NAME ":VBoxNetAdpSolarisGenerateMac Generated %.*Rhxs\n", sizeof(RTMAC), &pMac));
    442443    return VINF_SUCCESS;
    443444}
     
    450451    {
    451452        bcopy(pszMacAddr, &pState->CurrentMac, sizeof(RTMAC));
    452         LogFlow((DEVICE_NAME ":vboxNetAdpSolarisSetMacAddress updated MAC %.*Rhxs\n", sizeof(RTMAC), &pState->CurrentMac));
     453        Log((DEVICE_NAME ":vboxNetAdpSolarisSetMacAddress updated MAC %.*Rhxs\n", sizeof(RTMAC), &pState->CurrentMac));
    453454        return GLD_SUCCESS;
    454455    }
  • trunk/src/VBox/HostDrivers/VBoxNetFlt/solaris/VBoxNetFlt-solaris.c

    r38736 r38895  
    2121#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
    2222#ifdef DEBUG_ramshankar
     23# define LOG_ENABLED
    2324# define LOG_INSTANCE       RTLogRelDefaultInstance()
    2425#endif
     
    464465int _init(void)
    465466{
    466     LogFlowFunc((DEVICE_NAME ":_init\n"));
     467    LogFunc((DEVICE_NAME ":_init\n"));
    467468
    468469    /*
     
    541542{
    542543    int rc;
    543     LogFlowFunc((DEVICE_NAME ":_fini\n"));
     544    LogFunc((DEVICE_NAME ":_fini\n"));
    544545
    545546    /*
     
    577578int _info(struct modinfo *pModInfo)
    578579{
    579     LogFlowFunc((DEVICE_NAME ":_info\n"));
     580    LogFunc((DEVICE_NAME ":_info\n"));
    580581
    581582    int rc = mod_info(&g_VBoxNetFltSolarisModLinkage, pModInfo);
    582583
    583     LogFlow((DEVICE_NAME ":_info returns %d\n", rc));
     584    Log((DEVICE_NAME ":_info returns %d\n", rc));
    584585    return rc;
    585586}
     
    596597static int VBoxNetFltSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    597598{
    598     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     599    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    599600
    600601    switch (enmCmd)
     
    613614                int Interval = ddi_getprop(DDI_DEV_T_ANY, pDip, DDI_PROP_DONTPASS, VBOXNETFLT_IP6POLLINTERVAL, -1 /* default */);
    614615                if (Interval == -1)
    615                     LogFlow((DEVICE_NAME ":vboxNetFltSolarisSetupIp6Polling: no poll interval property specified. Skipping Ipv6 polling.\n"));
     616                    Log((DEVICE_NAME ":vboxNetFltSolarisSetupIp6Polling: no poll interval property specified. Skipping Ipv6 polling.\n"));
    616617                else if (Interval < 1 || Interval > 120)
    617618                {
     
    654655static int VBoxNetFltSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
    655656{
    656     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     657    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    657658
    658659    switch (enmCmd)
     
    690691static int VBoxNetFltSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppResult)
    691692{
    692     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisGetInfo pDip=%p enmCmd=%d pArg=%p instance=%d\n", pDip, enmCmd,
     693    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisGetInfo pDip=%p enmCmd=%d pArg=%p instance=%d\n", pDip, enmCmd,
    693694                getminor((dev_t)pvArg)));
    694695
     
    728729    Assert(pQueue);
    729730
    730     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisModOpen pQueue=%p pDev=%p fOpenMode=%d fStreamMode=%d\n", pQueue, pDev,
     731    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisModOpen pQueue=%p pDev=%p fOpenMode=%d fStreamMode=%d\n", pQueue, pDev,
    731732            fOpenMode, fStreamMode));
    732733
     
    911912    NOREF(fOpenMode);
    912913
    913     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModOpen returns 0, DevMinor=%d pQueue=%p\n", DevMinor, pStream->pReadQueue));
     914    Log((DEVICE_NAME ":VBoxNetFltSolarisModOpen returns 0, DevMinor=%d pQueue=%p\n", DevMinor, pStream->pReadQueue));
    914915
    915916    return 0;
     
    930931    Assert(pQueue);
    931932
    932     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisModClose pQueue=%p fOpenMode=%d\n", pQueue, fOpenMode));
     933    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisModClose pQueue=%p fOpenMode=%d\n", pQueue, fOpenMode));
    933934
    934935    vboxnetflt_stream_t *pStream = NULL;
     
    10531054        return 0;
    10541055
    1055     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisModReadPut pQueue=%p pMsg=%p\n", pQueue, pMsg));
     1056    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisModReadPut pQueue=%p pMsg=%p\n", pQueue, pMsg));
    10561057
    10571058    bool fSendUpstream = true;
     
    10871088                case M_DATA:
    10881089                {
    1089                     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut M_DATA\n"));
     1090                    Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut M_DATA\n"));
    10901091
    10911092                    if (   fActive
     
    11031104                    t_uscalar_t Prim = pPrim->dl_primitive;
    11041105
    1105                     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_PCPROTO %d\n", Prim));
     1106                    Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_PCPROTO %d\n", Prim));
    11061107                    switch (Prim)
    11071108                    {
     
    11341135
    11351136                                    bcopy(pMsg->b_rptr + cOffset, &pThis->u.s.MacAddr, sizeof(pThis->u.s.MacAddr));
    1136                                     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_NOTE_PHYS_ADDR. New Mac=%.*Rhxs\n",
     1137                                    Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_NOTE_PHYS_ADDR. New Mac=%.*Rhxs\n",
    11371138                                             sizeof(pThis->u.s.MacAddr), &pThis->u.s.MacAddr));
    11381139                                    break;
     
    11421143                                {
    11431144                                    if (ASMAtomicXchgBool(&pThis->fDisconnectedFromHost, false))
    1144                                         LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_NOTE_LINK_UP.\n"));
     1145                                        Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_NOTE_LINK_UP.\n"));
    11451146                                    break;
    11461147                                }
     
    11491150                                {
    11501151                                    if (!ASMAtomicXchgBool(&pThis->fDisconnectedFromHost, true))
    1151                                         LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_NOTE_LINK_DOWN.\n"));
     1152                                        Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_NOTE_LINK_DOWN.\n"));
    11521153                                    break;
    11531154                                }
     
    11611162                             * Swallow our bind request acknowledgement.
    11621163                             */
    1163                             LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_BIND_ACK. Bound to requested SAP!\n"));
     1164                            Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_BIND_ACK. Bound to requested SAP!\n"));
    11641165                            break;
    11651166                        }
     
    11821183                            if (pOkAck->dl_correct_primitive == DL_PROMISCON_REQ)
    11831184                            {
    1184                                 LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_PCPROTO: DL_OK_ACK: fPromisc is ON.\n"));
     1185                                Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_PCPROTO: DL_OK_ACK: fPromisc is ON.\n"));
    11851186                                pPromiscStream->fPromisc = true;
    11861187                            }
    11871188                            else if (pOkAck->dl_correct_primitive == DL_PROMISCOFF_REQ)
    11881189                            {
    1189                                 LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_PCPROTO: DL_OK_ACK: fPromisc is OFF.\n"));
     1190                                Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_PCPROTO: DL_OK_ACK: fPromisc is OFF.\n"));
    11901191                                pPromiscStream->fPromisc = false;
    11911192                            }
     
    12051206                    {
    12061207                        pPromiscStream->fRawMode = true;
    1207                         LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: Mode acknowledgement. RawMode is %s\n",
     1208                        Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: Mode acknowledgement. RawMode is %s\n",
    12081209                                pPromiscStream->fRawMode ? "ON" : "OFF"));
    12091210                    }
     
    12311232                     * We must support flushing queues.
    12321233                     */
    1233                     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_FLUSH\n"));
     1234                    Log((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: M_FLUSH\n"));
    12341235                    if (*pMsg->b_rptr & FLUSHR)
    12351236                        flushq(pQueue, FLUSHALL);
     
    12761277static int VBoxNetFltSolarisModWritePut(queue_t *pQueue, mblk_t *pMsg)
    12771278{
    1278     LogFlowFunc((DEVICE_NAME ":VBoxNetFltSolarisModWritePut pQueue=%p pMsg=%p\n", pQueue, pMsg));
     1279    LogFunc((DEVICE_NAME ":VBoxNetFltSolarisModWritePut pQueue=%p pMsg=%p\n", pQueue, pMsg));
    12791280
    12801281    putnext(pQueue, pMsg);
     
    12911292static int vboxNetFltSolarisSetRawMode(vboxnetflt_promisc_stream_t *pPromiscStream)
    12921293{
    1293     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisSetRawMode pPromiscStream=%p\n", pPromiscStream));
     1294    LogFunc((DEVICE_NAME ":vboxNetFltSolarisSetRawMode pPromiscStream=%p\n", pPromiscStream));
    12941295
    12951296    mblk_t *pRawMsg = NULL;
     
    13201321static int vboxNetFltSolarisSetFastMode(queue_t *pQueue)
    13211322{
    1322     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisSetFastMode pQueue=%p\n", pQueue));
     1323    LogFunc((DEVICE_NAME ":vboxNetFltSolarisSetFastMode pQueue=%p\n", pQueue));
    13231324
    13241325    mblk_t *pFastMsg = mkiocb(DL_IOC_HDR_INFO);
     
    13691370static int vboxNetFltSolarisPromiscReq(queue_t *pQueue, bool fPromisc)
    13701371{
    1371     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisPromiscReq pQueue=%p fPromisc=%d\n", pQueue, fPromisc));
     1372    LogFunc((DEVICE_NAME ":vboxNetFltSolarisPromiscReq pQueue=%p fPromisc=%d\n", pQueue, fPromisc));
    13721373
    13731374    t_uscalar_t Cmd;
     
    14961497static int vboxNetFltSolarisPhysAddrReq(queue_t *pQueue)
    14971498{
    1498     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisPhysAddrReq pQueue=%p\n", pQueue));
     1499    LogFunc((DEVICE_NAME ":vboxNetFltSolarisPhysAddrReq pQueue=%p\n", pQueue));
    14991500
    15001501    t_uscalar_t Cmd = DL_PHYS_ADDR_REQ;
     
    15211522static void vboxNetFltSolarisCachePhysAddr(PVBOXNETFLTINS pThis, mblk_t *pMsg)
    15221523{
    1523     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisCachePhysAddr pThis=%p pMsg=%p\n", pThis, pMsg));
     1524    LogFunc((DEVICE_NAME ":vboxNetFltSolarisCachePhysAddr pThis=%p pMsg=%p\n", pThis, pMsg));
    15241525
    15251526    AssertCompile(sizeof(RTMAC) == ETHERADDRL);
     
    15291530        bcopy(pMsg->b_rptr + pPhysAddrAck->dl_addr_offset, &pThis->u.s.MacAddr, sizeof(pThis->u.s.MacAddr));
    15301531
    1531         LogFlow((DEVICE_NAME ":vboxNetFltSolarisCachePhysAddr: DL_PHYS_ADDR_ACK: Mac=%.*Rhxs\n",
     1532        Log((DEVICE_NAME ":vboxNetFltSolarisCachePhysAddr: DL_PHYS_ADDR_ACK: Mac=%.*Rhxs\n",
    15321533                 sizeof(pThis->u.s.MacAddr), &pThis->u.s.MacAddr));
    15331534
     
    15571558static int vboxNetFltSolarisBindReq(queue_t *pQueue, int SAP)
    15581559{
    1559     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisBindReq SAP=%d\n", SAP));
     1560    LogFunc((DEVICE_NAME ":vboxNetFltSolarisBindReq SAP=%d\n", SAP));
    15601561
    15611562    mblk_t *pBindMsg = mexchange(NULL, NULL, DL_BIND_REQ_SIZE, M_PROTO, DL_BIND_REQ);
     
    15831584static int vboxNetFltSolarisNotifyReq(queue_t *pQueue)
    15841585{
    1585     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisNotifyReq\n"));
     1586    LogFunc((DEVICE_NAME ":vboxNetFltSolarisNotifyReq\n"));
    15861587
    15871588    mblk_t *pNotifyMsg = mexchange(NULL, NULL, DL_NOTIFY_REQ_SIZE, M_PROTO, DL_NOTIFY_REQ);
     
    18181819static int vboxNetFltSolarisRelinkIp4(vnode_t *pVNode, struct lifreq *pInterface, int IpMuxFd, int ArpMuxFd)
    18191820{
    1820     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisRelinkIp4: pVNode=%p pInterface=%p IpMuxFd=%d ArpMuxFd=%d\n", pVNode,
     1821    LogFunc((DEVICE_NAME ":vboxNetFltSolarisRelinkIp4: pVNode=%p pInterface=%p IpMuxFd=%d ArpMuxFd=%d\n", pVNode,
    18211822            pInterface, IpMuxFd, ArpMuxFd));
    18221823
     
    18531854static int vboxNetFltSolarisRelinkIp6(vnode_t *pVNode, struct lifreq *pInterface, int Ip6MuxFd)
    18541855{
    1855     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisRelinkIp6: pVNode=%p pInterface=%p Ip6MuxFd=%d\n", pVNode, pInterface, Ip6MuxFd));
     1856    LogFunc((DEVICE_NAME ":vboxNetFltSolarisRelinkIp6: pVNode=%p pInterface=%p Ip6MuxFd=%d\n", pVNode, pInterface, Ip6MuxFd));
    18561857
    18571858    int NewIp6MuxId;
     
    18821883static int vboxNetFltSolarisDetermineModPos(bool fAttach, vnode_t *pVNode, int *pModPos)
    18831884{
    1884     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: fAttach=%d pVNode=%p pModPos=%p\n", fAttach, pVNode, pModPos));
     1885    LogFunc((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: fAttach=%d pVNode=%p pModPos=%p\n", fAttach, pVNode, pModPos));
    18851886
    18861887    int cMod;
     
    18981899         * the host driver.
    18991900         */
    1900         LogFlow((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: cMod=%d\n", cMod));
     1901        Log((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: cMod=%d\n", cMod));
    19011902        if (fAttach)
    19021903        {
     
    19141915        if (RT_UNLIKELY(!StrList.sl_modlist))
    19151916        {
    1916             LogFlow((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: failed to alloc memory for StrList.\n"));
     1917            Log((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: failed to alloc memory for StrList.\n"));
    19171918            return VERR_NO_MEMORY;
    19181919        }
     
    19321933                if (!strcmp(DEVICE_NAME, StrList.sl_modlist[i].l_name))
    19331934                {
    1934                     LogFlow((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: Success! Found %s at %d.\n", DEVICE_NAME, i));
     1935                    Log((DEVICE_NAME ":vboxNetFltSolarisDetermineModPos: Success! Found %s at %d.\n", DEVICE_NAME, i));
    19351936                    *pModPos = i;
    19361937                    RTMemFree(StrList.sl_modlist);
     
    21302131static void vboxNetFltSolarisCloseStream(PVBOXNETFLTINS pThis)
    21312132{
    2132     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisCloseStream pThis=%p\n"));
     2133    LogFunc((DEVICE_NAME ":vboxNetFltSolarisCloseStream pThis=%p\n"));
    21332134
    21342135    if (pThis->u.s.hIface)
     
    21492150static int vboxNetFltSolarisAttachIp4(PVBOXNETFLTINS pThis, bool fAttach)
    21502151{
    2151     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisAttachIp4 pThis=%p fAttach=%d\n", pThis, fAttach));
     2152    LogFunc((DEVICE_NAME ":vboxNetFltSolarisAttachIp4 pThis=%p fAttach=%d\n", pThis, fAttach));
    21522153
    21532154    /*
     
    23332334                                            releasef(ArpMuxFd);
    23342335
    2335                                             LogFlow((DEVICE_NAME ":vboxNetFltSolarisAttachIp4: Success! %s %s@(IPv4:%d Arp:%d) "
     2336                                            Log((DEVICE_NAME ":vboxNetFltSolarisAttachIp4: Success! %s %s@(IPv4:%d Arp:%d) "
    23362337                                                    "%s interface %s\n", fAttach ? "Injected" : "Ejected", StrMod.mod_name,
    23372338                                                    StrMod.pos, ArpStrMod.pos, fAttach ? "to" : "from", pThis->szName));
     
    24162417static int vboxNetFltSolarisAttachIp6(PVBOXNETFLTINS pThis, bool fAttach)
    24172418{
    2418     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisAttachIp6 pThis=%p fAttach=%d\n", pThis, fAttach));
     2419    LogFunc((DEVICE_NAME ":vboxNetFltSolarisAttachIp6 pThis=%p fAttach=%d\n", pThis, fAttach));
    24192420
    24202421    /*
     
    25452546                                        releasef(Ip6MuxFd);
    25462547
    2547                                         LogFlow((DEVICE_NAME ":vboxNetFltSolarisAttachIp6: Success! %s %s@(IPv6:%d) "
     2548                                        Log((DEVICE_NAME ":vboxNetFltSolarisAttachIp6: Success! %s %s@(IPv6:%d) "
    25482549                                                "%s interface %s\n", fAttach ? "Injected" : "Ejected", StrMod.mod_name,
    25492550                                                StrMod.pos, fAttach ? "to" : "from", pThis->szName));
     
    25932594    else
    25942595    {
    2595         LogFlow((DEVICE_NAME ":vboxNetFltSolarisAttachIp6: failed to get IPv6 flags.\n", pThis->szName));
     2596        Log((DEVICE_NAME ":vboxNetFltSolarisAttachIp6: failed to get IPv6 flags.\n", pThis->szName));
    25962597        rc = VERR_INTNET_FLT_IF_NOT_FOUND;
    25972598    }
     
    26132614static void vboxNetFltSolarispIp6Timer(PRTTIMER pTimer, void *pvData, uint64_t iTick)
    26142615{
    2615     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarispIp6Timer pTimer=%p pvData=%p\n", pTimer, pvData));
     2616    LogFunc((DEVICE_NAME ":vboxNetFltSolarispIp6Timer pTimer=%p pvData=%p\n", pTimer, pvData));
    26162617
    26172618    PVBOXNETFLTINS pThis = (PVBOXNETFLTINS)pvData;
     
    26522653static int vboxNetFltSolarisSetupIp6Polling(PVBOXNETFLTINS pThis)
    26532654{
    2654     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisSetupIp6Polling pThis=%p\n", pThis));
     2655    LogFunc((DEVICE_NAME ":vboxNetFltSolarisSetupIp6Polling pThis=%p\n", pThis));
    26552656
    26562657    int rc = VERR_GENERAL_FAILURE;
     
    26792680            {
    26802681                rc = RTTimerStart(pPromiscStream->pIp6Timer, 10 * (uint64_t)1000000000 /* 10 seconds to blastoff */);
    2681                 LogFlow((DEVICE_NAME ":vboxNetFltSolarisSetupIp6Polling: Ipv6 %d second timer begins firing in 10 seconds.\n", Interval));
     2682                Log((DEVICE_NAME ":vboxNetFltSolarisSetupIp6Polling: Ipv6 %d second timer begins firing in 10 seconds.\n", Interval));
    26822683            }
    26832684            else
     
    27042705static int vboxNetFltSolarisDetachFromInterface(PVBOXNETFLTINS pThis)
    27052706{
    2706     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisDetachFromInterface pThis=%p\n", pThis));
     2707    LogFunc((DEVICE_NAME ":vboxNetFltSolarisDetachFromInterface pThis=%p\n", pThis));
    27072708
    27082709    ASMAtomicWriteBool(&pThis->fDisconnectedFromHost, true);
     
    27372738static int vboxNetFltSolarisAttachToInterface(PVBOXNETFLTINS pThis)
    27382739{
    2739     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisAttachToInterface pThis=%p\n", pThis));
     2740    LogFunc((DEVICE_NAME ":vboxNetFltSolarisAttachToInterface pThis=%p\n", pThis));
    27402741
    27412742    /*
     
    28152816static mblk_t *vboxNetFltSolarisMBlkFromSG(PVBOXNETFLTINS pThis, PINTNETSG pSG, uint32_t fDst)
    28162817{
    2817     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisMBlkFromSG pThis=%p pSG=%p\n", pThis, pSG));
     2818    LogFunc((DEVICE_NAME ":vboxNetFltSolarisMBlkFromSG pThis=%p pSG=%p\n", pThis, pSG));
    28182819
    28192820    mblk_t *pMsg = allocb(pSG->cbTotal, BPRI_MED);
     
    28792880static int vboxNetFltSolarisMBlkToSG(PVBOXNETFLTINS pThis, mblk_t *pMsg, PINTNETSG pSG, unsigned cSegs, uint32_t fSrc)
    28802881{
    2881     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pThis=%p pMsg=%p pSG=%p cSegs=%d\n", pThis, pMsg, pSG, cSegs));
     2882    LogFunc((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pThis=%p pMsg=%p pSG=%p cSegs=%d\n", pThis, pMsg, pSG, cSegs));
    28822883
    28832884    /*
     
    29062907    if (pSG->cbTotal < 60 && (fSrc & INTNETTRUNKDIR_HOST))
    29072908    {
    2908         LogFlow((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pulling up to length.\n"));
     2909        Log((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pulling up to length.\n"));
    29092910
    29102911        static uint8_t const s_abZero[128] = {0};
     
    29182919#endif
    29192920
    2920     LogFlow((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG iSeg=%d pSG->cbTotal=%d msgdsize=%d\n", iSeg, pSG->cbTotal, msgdsize(pMsg)));
     2921    Log((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG iSeg=%d pSG->cbTotal=%d msgdsize=%d\n", iSeg, pSG->cbTotal, msgdsize(pMsg)));
    29212922    return VINF_SUCCESS;
    29222923}
     
    29362937static int vboxNetFltSolarisRawToUnitData(mblk_t *pMsg, mblk_t **ppDlpiMsg)
    29372938{
    2938     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisRawToUnitData pMsg=%p\n", pMsg));
     2939    LogFunc((DEVICE_NAME ":vboxNetFltSolarisRawToUnitData pMsg=%p\n", pMsg));
    29392940
    29402941    if (DB_TYPE(pMsg) != M_DATA)
     
    29882989static int vboxNetFltSolarisUnitDataToRaw(PVBOXNETFLTINS pThis, mblk_t *pMsg, mblk_t **ppRawMsg)
    29892990{
    2990     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisUnitDataToRaw pMsg=%p\n", pMsg));
     2991    LogFunc((DEVICE_NAME ":vboxNetFltSolarisUnitDataToRaw pMsg=%p\n", pMsg));
    29912992
    29922993    if (   !pMsg->b_cont
     
    31073108    Assert(pPromiscStream);
    31083109
    3109     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback pThis=%p pPromiscStream=%p pMsg=%p\n", pThis, pPromiscStream, pMsg));
     3110    LogFunc((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback pThis=%p pPromiscStream=%p pMsg=%p\n", pThis, pPromiscStream, pMsg));
    31103111
    31113112    if (RT_UNLIKELY(pMsg->b_cont))
     
    31483149                pPromiscStream->cLoopback++;
    31493150
    3150                 LogFlow((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback initialized head. checksum=%u.\n",
     3151                Log((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback initialized head. checksum=%u.\n",
    31513152                        pPromiscStream->pHead->Checksum));
    31523153                break;
     
    31583159                vboxNetFltSolarisInitPacketId(pCur, pMsg);
    31593160
    3160                 LogFlow((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback re-used head checksum=%u cLoopback=%d.\n",
     3161                Log((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback re-used head checksum=%u cLoopback=%d.\n",
    31613162                        pCur->Checksum, pPromiscStream->cLoopback));
    31623163                break;
     
    31773178                pPromiscStream->cLoopback++;
    31783179
    3179                 LogFlow((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback added head checksum=%u cLoopback=%d.\n", pCur->Checksum,
     3180                Log((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback added head checksum=%u cLoopback=%d.\n", pCur->Checksum,
    31803181                        pPromiscStream->cLoopback));
    31813182                break;
     
    32103211
    32113212        vboxNetFltSolarisInitPacketId(pCur, pMsg);
    3212         LogFlow((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback recycled tail!! checksum=%u cLoopback=%d\n", pCur->Checksum,
     3213        Log((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback recycled tail!! checksum=%u cLoopback=%d\n", pCur->Checksum,
    32133214                pPromiscStream->cLoopback));
    32143215    }
     
    32353236    Assert(DB_TYPE(pMsg) == M_DATA);
    32363237
    3237     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk pThis=%p pMsg=%p\n", pThis, pMsg));
     3238    LogFunc((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk pThis=%p pMsg=%p\n", pThis, pMsg));
    32383239
    32393240    if (pMsg->b_cont)
     
    32983299        fIsOurPacket = true;
    32993300
    3300         LogFlow((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk found packet %p Checksum=%u cLoopback=%d\n", pMsg, Checksum,
     3301        Log((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk found packet %p Checksum=%u cLoopback=%d\n", pMsg, Checksum,
    33013302                    pPromiscStream->cLoopback));
    33023303        break;
    33033304    }
    33043305
    3305     LogFlow((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk returns %d.\n", fIsOurPacket));
     3306    Log((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk returns %d.\n", fIsOurPacket));
    33063307    mutex_exit(&pThis->u.s.hMtx);
    33073308    return fIsOurPacket;
     
    33353336static int vboxNetFltSolarisRecv(PVBOXNETFLTINS pThis, vboxnetflt_stream_t *pStream, queue_t *pQueue, mblk_t *pMsg)
    33363337{
    3337     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisRecv pThis=%p pMsg=%p\n", pThis, pMsg));
     3338    LogFunc((DEVICE_NAME ":vboxNetFltSolarisRecv pThis=%p pMsg=%p\n", pThis, pMsg));
    33383339
    33393340    AssertCompile(sizeof(struct ether_header) == sizeof(RTNETETHERHDR));
     
    33773378    if (vboxNetFltSolarisIsOurMBlk(pThis, pPromiscStream, pMsg))
    33783379    {
    3379         LogFlow((DEVICE_NAME ":Avoiding packet loopback.\n"));
     3380        Log((DEVICE_NAME ":Avoiding packet loopback.\n"));
    33803381        return VINF_SUCCESS;
    33813382    }
     
    34353436
    34363437                PVLANHEADER pVlanHdr = (PVLANHEADER)(pMsg->b_rptr + sizeof(RTNETETHERHDR) - sizeof(pEthHdr->EtherType));
    3437                 LogFlow((DEVICE_NAME ":Recv VLAN Pcp=%u Cfi=%u Id=%u\n", VLAN_PRI(RT_BE2H_U16(pVlanHdr->Data)),
     3438                Log((DEVICE_NAME ":Recv VLAN Pcp=%u Cfi=%u Id=%u\n", VLAN_PRI(RT_BE2H_U16(pVlanHdr->Data)),
    34383439                            VLAN_CFI(RT_BE2H_U16(pVlanHdr->Data)), VLAN_ID(RT_BE2H_U16(pVlanHdr->Data))));
    34393440                if (   VLAN_PRI(RT_BE2H_U16(pVlanHdr->Data)) > 0
     
    34613462                        pStrippedMsg->b_cont = pMsg;
    34623463                        pMsg = pStrippedMsg;
    3463                         LogFlow((DEVICE_NAME ":Stripped VLAN tag.\n"));
     3464                        Log((DEVICE_NAME ":Stripped VLAN tag.\n"));
    34643465                    }
    34653466                    else
     
    35223523static mblk_t *vboxNetFltSolarisFixChecksums(mblk_t *pMsg)
    35233524{
    3524     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisFixChecksums pMsg=%p\n"));
     3525    LogFunc((DEVICE_NAME ":vboxNetFltSolarisFixChecksums pMsg=%p\n"));
    35253526
    35263527    Assert(DB_TYPE(pMsg) == M_DATA);
     
    35423543        if (pMsg->b_cont)
    35433544        {
    3544             LogFlow((DEVICE_NAME ":Chained mblk_t.\n"));
     3545            Log((DEVICE_NAME ":Chained mblk_t.\n"));
    35453546
    35463547            /*
     
    35513552            size_t cbFullMsg = msgdsize(pMsg);
    35523553            mblk_t *pFullMsg = allocb(cbFullMsg, BPRI_MED);
    3553             LogFlow((DEVICE_NAME ":msgdsize returns %d\n", cbFullMsg));
     3554            Log((DEVICE_NAME ":msgdsize returns %d\n", cbFullMsg));
    35543555            if (RT_UNLIKELY(!pFullMsg))
    35553556            {
     
    35963597                    pTcpHdr->th_sum = TcpChecksum;
    35973598                    fChecksumAdjusted = true;
    3598                     LogFlow((DEVICE_NAME ":fixed TCP checksum.\n"));
     3599                    Log((DEVICE_NAME ":fixed TCP checksum.\n"));
    35993600                }
    36003601            }
     
    36083609                    pUdpHdr->uh_sum = UdpChecksum;
    36093610                    fChecksumAdjusted = true;
    3610                     LogFlow((DEVICE_NAME ":Fixed UDP checksum."));
     3611                    Log((DEVICE_NAME ":Fixed UDP checksum."));
    36113612                }
    36123613            }
     
    36493650static void vboxNetFltSolarisAnalyzeMBlk(mblk_t *pMsg)
    36503651{
    3651     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisAnalyzeMBlk pMsg=%p\n", pMsg));
     3652    LogFunc((DEVICE_NAME ":vboxNetFltSolarisAnalyzeMBlk pMsg=%p\n", pMsg));
    36523653
    36533654    PCRTNETETHERHDR pEthHdr = (PCRTNETETHERHDR)pMsg->b_rptr;
     
    36763677        else
    36773678        {
    3678             LogFlow((DEVICE_NAME ":Chained IP packet. Skipping validity check.\n"));
     3679            Log((DEVICE_NAME ":Chained IP packet. Skipping validity check.\n"));
    36793680        }
    36803681    }
     
    37043705        LogRel((DEVICE_NAME ":Unknown EtherType=%x D=%.6Rhxs S=%.6Rhxs\n", RT_H2BE_U16(pEthHdr->EtherType), &pEthHdr->DstMac,
    37053706                    &pEthHdr->SrcMac));
    3706         /* LogFlow((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pMsg), pMsg->b_rptr)); */
     3707        /* Log((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pMsg), pMsg->b_rptr)); */
    37073708    }
    37083709}
     
    37163717void vboxNetFltPortOsSetActive(PVBOXNETFLTINS pThis, bool fActive)
    37173718{
    3718     LogFlowFunc((DEVICE_NAME ":vboxNetFltPortOsSetActive pThis=%p fActive=%d\n", pThis, fActive));
     3719    LogFunc((DEVICE_NAME ":vboxNetFltPortOsSetActive pThis=%p fActive=%d\n", pThis, fActive));
    37193720
    37203721    /*
     
    37503751int vboxNetFltOsDisconnectIt(PVBOXNETFLTINS pThis)
    37513752{
    3752     LogFlowFunc((DEVICE_NAME ":vboxNetFltOsDisconnectIt pThis=%p\n", pThis));
     3753    LogFunc((DEVICE_NAME ":vboxNetFltOsDisconnectIt pThis=%p\n", pThis));
    37533754
    37543755    vboxNetFltSolarisDetachFromInterface(pThis);
     
    37673768void vboxNetFltOsDeleteInstance(PVBOXNETFLTINS pThis)
    37683769{
    3769     LogFlowFunc((DEVICE_NAME ":vboxNetFltOsDeleteInstance pThis=%p\n", pThis));
     3770    LogFunc((DEVICE_NAME ":vboxNetFltOsDeleteInstance pThis=%p\n", pThis));
    37703771
    37713772    mutex_destroy(&pThis->u.s.hMtx);
     
    37843785int vboxNetFltOsInitInstance(PVBOXNETFLTINS pThis, void *pvContext)
    37853786{
    3786     LogFlowFunc((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p\n"));
     3787    LogFunc((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p\n"));
    37873788
    37883789    /*
     
    38723873{
    38733874    NOREF(pvIfData);
    3874     LogFlowFunc((DEVICE_NAME ":vboxNetFltPortOsXmit pThis=%p pSG=%p fDst=%d\n", pThis, pSG, fDst));
     3875    LogFunc((DEVICE_NAME ":vboxNetFltPortOsXmit pThis=%p pSG=%p fDst=%d\n", pThis, pSG, fDst));
    38753876
    38763877    int rc = VINF_SUCCESS;
     
    38833884            if (RT_LIKELY(pMsg))
    38843885            {
    3885                 LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_WIRE\n"));
     3886                Log((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_WIRE\n"));
    38863887
    38873888                vboxNetFltSolarisQueueLoopback(pThis, pPromiscStream, pMsg);
     
    39193920            if (pEthHdr->EtherType == RT_H2BE_U16(RTNET_ETHERTYPE_ARP))
    39203921            {
    3921                 LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST ARP\n"));
     3922                Log((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST ARP\n"));
    39223923
    39233924                vboxnetflt_stream_t *pArpStream = ASMAtomicUoReadPtrT(&pThis->u.s.pArpStream, vboxnetflt_stream_t *);
     
    39553956                      * Send messages up IPv6 stream.
    39563957                      */
    3957                      LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST IPv6\n"));
     3958                     Log((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST IPv6\n"));
    39583959
    39593960                     pMsg->b_rptr += sizeof(RTNETETHERHDR);
     
    39663967                     * Send messages up IPv4 stream.
    39673968                     */
    3968                     LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST IPv4\n"));
     3969                    Log((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST IPv4\n"));
    39693970
    39703971                    pMsg->b_rptr += sizeof(RTNETETHERHDR);
  • trunk/src/VBox/HostDrivers/VBoxNetFlt/solaris/VBoxNetFltBow-solaris.c

    r38736 r38895  
    2121#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
    2222#ifdef DEBUG_ramshankar
     23# define LOG_ENABLED
    2324# define LOG_INSTANCE       RTLogRelDefaultInstance()
    2425#endif
     
    260261LOCAL inline int vboxNetFltSolarisGetLinkId(const char *pszMacName, datalink_id_t *pLinkId);
    261262
    262 
    263263/**
    264264 * Kernel entry points
     
    266266int _init(void)
    267267{
    268     LogFlow((DEVICE_NAME ":_init\n"));
     268    Log((DEVICE_NAME ":_init\n"));
    269269
    270270    /*
     
    326326{
    327327    int rc;
    328     LogFlow((DEVICE_NAME ":_fini\n"));
     328    Log((DEVICE_NAME ":_fini\n"));
    329329
    330330    /*
     
    356356int _info(struct modinfo *pModInfo)
    357357{
    358     LogFlow((DEVICE_NAME ":_info\n"));
     358    Log((DEVICE_NAME ":_info\n"));
    359359
    360360    int rc = mod_info(&g_VBoxNetFltSolarisModLinkage, pModInfo);
    361361
    362     LogFlow((DEVICE_NAME ":_info returns %d\n", rc));
     362    Log((DEVICE_NAME ":_info returns %d\n", rc));
    363363    return rc;
    364364}
     
    375375LOCAL int VBoxNetFltSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    376376{
    377     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     377    Log((DEVICE_NAME ":VBoxNetFltSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     378    LogRel((DEVICE_NAME ":blah\n"));
    378379
    379380    switch (enmCmd)
     
    408409LOCAL int VBoxNetFltSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
    409410{
    410     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     411    Log((DEVICE_NAME ":VBoxNetFltSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    411412
    412413    switch (enmCmd)
     
    443444LOCAL int VBoxNetFltSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppResult)
    444445{
    445     LogFlow((DEVICE_NAME ":VBoxNetFltSolarisGetInfo pDip=%p enmCmd=%d pArg=%p instance=%d\n", pDip, enmCmd, getminor((dev_t)pvArg)));
     446    Log((DEVICE_NAME ":VBoxNetFltSolarisGetInfo pDip=%p enmCmd=%d pArg=%p instance=%d\n", pDip, enmCmd, getminor((dev_t)pvArg)));
    446447
    447448    switch (enmCmd)
     
    475476LOCAL inline mblk_t *vboxNetFltSolarisMBlkFromSG(PVBOXNETFLTINS pThis, PINTNETSG pSG, uint32_t fDst)
    476477{
    477     LogFlow((DEVICE_NAME ":vboxNetFltSolarisMBlkFromSG pThis=%p pSG=%p\n", pThis, pSG));
     478    Log((DEVICE_NAME ":vboxNetFltSolarisMBlkFromSG pThis=%p pSG=%p\n", pThis, pSG));
    478479
    479480    mblk_t *pMsg = allocb(pSG->cbTotal, BPRI_HI);
     
    540541LOCAL int vboxNetFltSolarisMBlkToSG(PVBOXNETFLTINS pThis, mblk_t *pMsg, PINTNETSG pSG, unsigned cSegs, uint32_t fSrc)
    541542{
    542     LogFlow((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pThis=%p pMsg=%p pSG=%p cSegs=%d\n", pThis, pMsg, pSG, cSegs));
     543    Log((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pThis=%p pMsg=%p pSG=%p cSegs=%d\n", pThis, pMsg, pSG, cSegs));
    543544
    544545    /*
     
    567568    if (pSG->cbTotal < 60 && (fSrc & INTNETTRUNKDIR_HOST))
    568569    {
    569         LogFlow((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pulling up to length.\n"));
     570        Log((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG pulling up to length.\n"));
    570571
    571572        static uint8_t const s_abZero[128] = {0};
     
    579580#endif
    580581
    581     LogFlow((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG iSeg=%d pSG->cbTotal=%d msgdsize=%d\n", iSeg, pSG->cbTotal, msgdsize(pMsg)));
     582    Log((DEVICE_NAME ":vboxNetFltSolarisMBlkToSG iSeg=%d pSG->cbTotal=%d msgdsize=%d\n", iSeg, pSG->cbTotal, msgdsize(pMsg)));
    582583    return VINF_SUCCESS;
    583584}
     
    591592LOCAL void vboxNetFltSolarisAnalyzeMBlk(mblk_t *pMsg)
    592593{
    593     LogFlowFunc((DEVICE_NAME ":vboxNetFltSolarisAnalyzeMBlk pMsg=%p\n", pMsg));
     594    LogFunc((DEVICE_NAME ":vboxNetFltSolarisAnalyzeMBlk pMsg=%p\n", pMsg));
    594595
    595596    PCRTNETETHERHDR pEthHdr = (PCRTNETETHERHDR)pMsg->b_rptr;
     
    617618        else
    618619        {
    619             LogFlow((DEVICE_NAME ":Chained IP packet. Skipping validity check.\n"));
     620            Log((DEVICE_NAME ":Chained IP packet. Skipping validity check.\n"));
    620621        }
    621622    }
     
    645646        LogRel((DEVICE_NAME ":Unknown EtherType=%x D=%.6Rhxs S=%.6Rhxs\n", RT_H2BE_U16(pEthHdr->EtherType), &pEthHdr->DstMac,
    646647                    &pEthHdr->SrcMac));
    647         /* LogFlow((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pMsg), pMsg->b_rptr)); */
     648        /* Log((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pMsg), pMsg->b_rptr)); */
    648649    }
    649650}
     
    671672LOCAL void vboxNetFltSolarisRecv(void *pvData, mac_resource_handle_t hResource, mblk_t *pMsg, boolean_t fLoopback)
    672673{
    673     LogFlow((DEVICE_NAME ":vboxNetFltSolarisRecv pvData=%p pMsg=%p fLoopback=%d cbData=%d\n", pvData, pMsg, fLoopback, pMsg ? MBLKL(pMsg) : 0));
     674    Log((DEVICE_NAME ":vboxNetFltSolarisRecv pvData=%p pMsg=%p fLoopback=%d cbData=%d\n", pvData, pMsg, fLoopback, pMsg ? MBLKL(pMsg) : 0));
    674675
    675676    PVBOXNETFLTINS pThis = (PVBOXNETFLTINS)pvData;
     
    803804    {
    804805        Assert(pThis->pSwitchPort);
    805         LogFlow((DEVICE_NAME ":vboxNetFltSolarisReportInfo phys mac %.6Rhxs\n", &pThis->u.s.MacAddr));
     806        Log((DEVICE_NAME ":vboxNetFltSolarisReportInfo phys mac %.6Rhxs\n", &pThis->u.s.MacAddr));
    806807        pThis->pSwitchPort->pfnReportMacAddress(pThis->pSwitchPort, &pThis->u.s.MacAddr);
    807808        pThis->pSwitchPort->pfnReportPromiscuousMode(pThis->pSwitchPort, false); /** @todo Promisc */
     
    851852        if (RT_LIKELY(!rc))
    852853        {
    853             LogFlow((DEVICE_NAME ":vboxNetFltSolarisInitVNIC succesfully initialized VNIC.\n"));
     854            Log((DEVICE_NAME ":vboxNetFltSolarisInitVNIC succesfully initialized VNIC.\n"));
    854855            return VINF_SUCCESS;
    855856        }
     
    881882LOCAL int vboxNetFltSolarisInitVNICTemplate(PVBOXNETFLTINS pThis, PVBOXNETFLTVNICTEMPLATE pVNICTemplate)
    882883{
    883     LogFlow((DEVICE_NAME ":vboxNetFltSolarisInitVNICTemplate pThis=%p pVNICTemplate=%p\n", pThis, pVNICTemplate));
     884    Log((DEVICE_NAME ":vboxNetFltSolarisInitVNICTemplate pThis=%p pVNICTemplate=%p\n", pThis, pVNICTemplate));
    884885
    885886    AssertReturn(pVNICTemplate, VERR_INVALID_PARAMETER);
     
    926927                        mac_close(hInterface);
    927928
    928                         LogFlow((DEVICE_NAME ":vboxNetFltSolarisInitVNICTemplate successfully init. VNIC template. szLinkName=%s\n",
     929                        Log((DEVICE_NAME ":vboxNetFltSolarisInitVNICTemplate successfully init. VNIC template. szLinkName=%s\n",
    929930                                    pVNICTemplate->szLinkName));
    930931                        return VINF_SUCCESS;
     
    10611062LOCAL int vboxNetFltSolarisCreateVNIC(PVBOXNETFLTINS pThis, PVBOXNETFLTVNIC *ppVNIC)
    10621063{
    1063     LogFlow((DEVICE_NAME ":vboxNetFltSolarisCreateVNIC pThis=%p\n", pThis));
     1064    Log((DEVICE_NAME ":vboxNetFltSolarisCreateVNIC pThis=%p\n", pThis));
    10641065
    10651066    AssertReturn(pThis, VERR_INVALID_POINTER);
     
    11201121            fFlags |= MAC_VLAN;
    11211122#endif
    1122         LogFlow((DEVICE_NAME ":vboxNetFltSolarisCreateVNIC pThis=%p VLAN Id=%u\n", pThis, uVLANId));
     1123        Log((DEVICE_NAME ":vboxNetFltSolarisCreateVNIC pThis=%p VLAN Id=%u\n", pThis, uVLANId));
    11231124    }
    11241125
     
    11491150            if (RT_SUCCESS(rc))
    11501151            {
    1151                 LogFlow((DEVICE_NAME ":vboxNetFltSolarisCreateVNIC successfully created VNIC '%s' over '%s' with random mac %.6Rhxs\n",
     1152                Log((DEVICE_NAME ":vboxNetFltSolarisCreateVNIC successfully created VNIC '%s' over '%s' with random mac %.6Rhxs\n",
    11521153                         pVNIC->szName, pszLinkName, &GuestMac));
    11531154                *ppVNIC = pVNIC;
     
    12541255void vboxNetFltPortOsSetActive(PVBOXNETFLTINS pThis, bool fActive)
    12551256{
    1256     LogFlow((DEVICE_NAME ":vboxNetFltPortOsSetActive pThis=%p fActive=%d\n", pThis, fActive));
     1257    Log((DEVICE_NAME ":vboxNetFltPortOsSetActive pThis=%p fActive=%d\n", pThis, fActive));
    12571258
    12581259    /*
     
    12871288int vboxNetFltOsDisconnectIt(PVBOXNETFLTINS pThis)
    12881289{
    1289     LogFlow((DEVICE_NAME ":vboxNetFltOsDisconnectIt pThis=%p\n", pThis));
     1290    Log((DEVICE_NAME ":vboxNetFltOsDisconnectIt pThis=%p\n", pThis));
    12901291    return VINF_SUCCESS;
    12911292}
     
    12941295int  vboxNetFltOsConnectIt(PVBOXNETFLTINS pThis)
    12951296{
    1296     LogFlow((DEVICE_NAME ":vboxNetFltOsConnectIt pThis=%p\n", pThis));
     1297    Log((DEVICE_NAME ":vboxNetFltOsConnectIt pThis=%p\n", pThis));
    12971298    return VINF_SUCCESS;
    12981299}
     
    13011302void vboxNetFltOsDeleteInstance(PVBOXNETFLTINS pThis)
    13021303{
    1303     LogFlow((DEVICE_NAME ":vboxNetFltOsDeleteInstance pThis=%p\n", pThis));
     1304    Log((DEVICE_NAME ":vboxNetFltOsDeleteInstance pThis=%p\n", pThis));
    13041305
    13051306    if (pThis->u.s.hNotify)
     
    13251326int vboxNetFltOsInitInstance(PVBOXNETFLTINS pThis, void *pvContext)
    13261327{
    1327     LogFlow((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p pvContext=%p\n", pThis, pvContext));
     1328    Log((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p pvContext=%p\n", pThis, pvContext));
    13281329
    13291330    /*
     
    13381339        if (!rc)
    13391340        {
    1340             LogFlow((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p physical interface '%s' detected.\n", pThis, pThis->szName));
     1341            Log((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p physical interface '%s' detected.\n", pThis, pThis->szName));
    13411342            pThis->u.s.fIsVNIC = false;
    13421343        }
     
    13461347            if (RTStrNCmp(pThis->szName, VBOXBOW_VNIC_TEMPLATE_NAME, sizeof(VBOXBOW_VNIC_TEMPLATE_NAME) - 1) == 0)
    13471348            {
    1348                 LogFlow((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p VNIC template '%s' detected.\n", pThis, pThis->szName));
     1349                Log((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p VNIC template '%s' detected.\n", pThis, pThis->szName));
    13491350                pThis->u.s.fIsVNICTemplate = true;
    13501351            }
     
    13531354        if (    pThis->u.s.fIsVNIC
    13541355            && !pThis->u.s.fIsVNICTemplate)
    1355             LogFlow((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p VNIC '%s' detected.\n", pThis, pThis->szName));
     1356            Log((DEVICE_NAME ":vboxNetFltOsInitInstance pThis=%p VNIC '%s' detected.\n", pThis, pThis->szName));
    13561357
    13571358        /*
     
    14151416    if (RT_LIKELY(pMsg))
    14161417    {
    1417         LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit pThis=%p cbData=%d\n", pThis, MBLKL(pMsg)));
     1418        Log((DEVICE_NAME ":vboxNetFltPortOsXmit pThis=%p cbData=%d\n", pThis, MBLKL(pMsg)));
    14181419
    14191420        mac_tx_cookie_t pXmitCookie = mac_tx(pVNIC->hClient, pMsg, 0 /* Hint */, MAC_DROP_ON_NO_DESC, NULL /* return message */);
     
    14371438void vboxNetFltPortOsNotifyMacAddress(PVBOXNETFLTINS pThis, void *pvIfData, PCRTMAC pMac)
    14381439{
    1439     LogFlow((DEVICE_NAME ":vboxNetFltPortOSNotifyMacAddress pszIf=%s pszVNIC=%s MAC=%.6Rhxs\n", pThis->szName,
     1440    Log((DEVICE_NAME ":vboxNetFltPortOSNotifyMacAddress pszIf=%s pszVNIC=%s MAC=%.6Rhxs\n", pThis->szName,
    14401441             ((PVBOXNETFLTVNIC)pvIfData)->szName, pMac));
    14411442
     
    14961497                 */
    14971498                mac_rx_set(pVNIC->hClient, vboxNetFltSolarisRecv, pThis);
    1498                 LogFlow((DEVICE_NAME ":vboxNetFltPortOsNotifyMacAddress successfully added unicast address %.6Rhxs\n", pMac));
     1499                Log((DEVICE_NAME ":vboxNetFltPortOsNotifyMacAddress successfully added unicast address %.6Rhxs\n", pMac));
    14991500            }
    15001501            else
     
    15301531int vboxNetFltPortOsConnectInterface(PVBOXNETFLTINS pThis, void *pvIf, void **ppvIfData)
    15311532{
    1532     LogFlow((DEVICE_NAME ":vboxNetFltPortOsConnectInterface pThis=%p pvIf=%p\n", pThis, pvIf));
     1533    Log((DEVICE_NAME ":vboxNetFltPortOsConnectInterface pThis=%p pvIf=%p\n", pThis, pvIf));
    15331534
    15341535    int rc = VINF_SUCCESS;
     
    16181619int vboxNetFltPortOsDisconnectInterface(PVBOXNETFLTINS pThis, void *pvIfData)
    16191620{
    1620     LogFlow((DEVICE_NAME ":vboxNetFltPortOsDisconnectInterface pThis=%p\n", pThis));
     1621    Log((DEVICE_NAME ":vboxNetFltPortOsDisconnectInterface pThis=%p\n", pThis));
    16211622
    16221623    PVBOXNETFLTVNIC pVNIC = pvIfData;
     
    16341635         */
    16351636        list_remove(&pThis->u.s.hVNICs, pVNIC);
    1636         LogFlow((DEVICE_NAME ":vboxNetFltPortOsDisconnectInterface destroying pVNIC=%p\n", pVNIC));
     1637        Log((DEVICE_NAME ":vboxNetFltPortOsDisconnectInterface destroying pVNIC=%p\n", pVNIC));
    16371638        vboxNetFltSolarisDestroyVNIC(pVNIC);
    16381639        vboxNetFltSolarisFreeVNIC(pVNIC);
  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c

    r38736 r38895  
    2121#define LOG_GROUP LOG_GROUP_USB_DRV
    2222#ifdef DEBUG_ramshankar
     23# define LOG_ENABLED
    2324# define LOG_INSTANCE       RTLogRelDefaultInstance()
    2425#endif
     
    375376int _init(void)
    376377{
    377     LogFlowFunc((DEVICE_NAME ":_init\n"));
     378    LogFunc((DEVICE_NAME ":_init\n"));
    378379
    379380    /*
     
    417418    int rc;
    418419
    419     LogFlowFunc((DEVICE_NAME ":_fini\n"));
     420    LogFunc((DEVICE_NAME ":_fini\n"));
    420421
    421422    rc = mod_remove(&g_VBoxUSBSolarisModLinkage);
     
    432433int _info(struct modinfo *pModInfo)
    433434{
    434     LogFlowFunc((DEVICE_NAME ":_info\n"));
     435    LogFunc((DEVICE_NAME ":_info\n"));
    435436
    436437    return mod_info(&g_VBoxUSBSolarisModLinkage, pModInfo);
     
    448449int VBoxUSBSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    449450{
    450     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     451    LogFunc((DEVICE_NAME ":VBoxUSBSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    451452
    452453    int rc;
     
    511512                                if (rc == USB_SUCCESS)
    512513                                {
    513                                     LogFlow((DEVICE_NAME ":VBoxUSBSolarisAttach cbMaxBulkXfer=%d\n", pState->cbMaxBulkXfer));
     514                                    Log((DEVICE_NAME ":VBoxUSBSolarisAttach cbMaxBulkXfer=%d\n", pState->cbMaxBulkXfer));
    514515
    515516                                    /*
     
    617618                    }
    618619                    else
    619                         LogFlow((DEVICE_NAME ":VBoxUSBSolarisAttach not a USB device.\n")); /* This would appear on every boot if it were Rel */
     620                        Log((DEVICE_NAME ":VBoxUSBSolarisAttach not a USB device.\n")); /* This would appear on every boot if it were Rel */
    620621                }
    621622                else
     
    659660int VBoxUSBSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
    660661{
    661     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     662    LogFunc((DEVICE_NAME ":VBoxUSBSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    662663
    663664    int instance = ddi_get_instance(pDip);
     
    784785int VBoxUSBSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppvResult)
    785786{
    786     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisGetInfo\n"));
     787    LogFunc((DEVICE_NAME ":VBoxUSBSolarisGetInfo\n"));
    787788
    788789    vboxusb_state_t *pState = NULL;
     
    833834LOCAL int vboxUSBSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved)
    834835{
    835     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials Process=%u Instance=%d\n", Process, Instance));
     836    LogFunc((DEVICE_NAME ":vboxUSBSolarisSetConsumerCredentials Process=%u Instance=%d\n", Process, Instance));
    836837    vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, Instance);
    837838    if (!pState)
     
    860861int VBoxUSBSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred)
    861862{
    862     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisOpen pDev=%p fFlag=%d fType=%d pCred=%p\n", pDev, fFlag, fType, pCred));
     863    LogFunc((DEVICE_NAME ":VBoxUSBSolarisOpen pDev=%p fFlag=%d fType=%d pCred=%p\n", pDev, fFlag, fType, pCred));
    863864
    864865    /*
     
    908909int VBoxUSBSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred)
    909910{
    910     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisClose Dev=%d fFlag=%d fType=%d pCred=%p\n", Dev, fFlag, fType, pCred));
     911    LogFunc((DEVICE_NAME ":VBoxUSBSolarisClose Dev=%d fFlag=%d fType=%d pCred=%p\n", Dev, fFlag, fType, pCred));
    911912
    912913    int instance = getminor((dev_t)Dev);
     
    929930int VBoxUSBSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
    930931{
    931     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisRead\n"));
     932    LogFunc((DEVICE_NAME ":VBoxUSBSolarisRead\n"));
    932933    return ENOTSUP;
    933934}
     
    936937int VBoxUSBSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
    937938{
    938     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisWrite\n"));
     939    LogFunc((DEVICE_NAME ":VBoxUSBSolarisWrite\n"));
    939940    return ENOTSUP;
    940941}
     
    943944int VBoxUSBSolarisPoll(dev_t Dev, short fEvents, int fAnyYet, short *pReqEvents, struct pollhead **ppPollHead)
    944945{
    945     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisPoll Dev=%d fEvents=%d fAnyYet=%d pReqEvents=%p\n", Dev, fEvents, fAnyYet, pReqEvents));
     946    LogFunc((DEVICE_NAME ":VBoxUSBSolarisPoll Dev=%d fEvents=%d fAnyYet=%d pReqEvents=%p\n", Dev, fEvents, fAnyYet, pReqEvents));
    946947
    947948    /*
     
    991992int VBoxUSBSolarisPower(dev_info_t *pDip, int Component, int Level)
    992993{
    993     LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisPower pDip=%p Component=%d Level=%d\n", pDip, Component, Level));
     994    LogFunc((DEVICE_NAME ":VBoxUSBSolarisPower pDip=%p Component=%d Level=%d\n", pDip, Component, Level));
    994995
    995996    int instance = ddi_get_instance(pDip);
     
    10491050        }
    10501051        else
    1051             LogFlow((DEVICE_NAME ":USB_DEV_PWRSTATE_OK failed.\n"));
     1052            Log((DEVICE_NAME ":USB_DEV_PWRSTATE_OK failed.\n"));
    10521053    }
    10531054    else
     
    10701071int VBoxUSBSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal)
    10711072{
    1072 /*    LogFlowFunc((DEVICE_NAME ":VBoxUSBSolarisIOCtl Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg)); */
     1073/*    LogFunc((DEVICE_NAME ":VBoxUSBSolarisIOCtl Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg)); */
    10731074
    10741075    /*
     
    11981199LOCAL int vboxUSBSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf, size_t *pcbDataOut)
    11991200{
    1200 //    LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl iFunction=%d pvState=%p pUSBReq=%p\n", iFunction, pvState, pUSBReq));
     1201//    LogFunc((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl iFunction=%d pvState=%p pUSBReq=%p\n", iFunction, pvState, pUSBReq));
    12011202
    12021203    AssertPtrReturn(pvState, VERR_INVALID_PARAMETER);
     
    12291230            rc = vboxUSBSolarisSendURB(pState, pUrbReq, Mode);
    12301231            *pcbDataOut = 0;
    1231             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SEND_URB returned %d\n", rc));
     1232            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SEND_URB returned %d\n", rc));
    12321233            break;
    12331234        }
     
    12401241            rc = vboxUSBSolarisReapURB(pState, pUrbReq, Mode);
    12411242            *pcbDataOut = sizeof(VBOXUSBREQ_URB);
    1242             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: REAP_URB returned %d\n", rc));
     1243            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: REAP_URB returned %d\n", rc));
    12431244            break;
    12441245        }
     
    12511252            rc = vboxUSBSolarisClearEndPoint(pState, pClearEpReq->bEndpoint);
    12521253            *pcbDataOut = 0;
    1253             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: CLEAR_EP returned %d\n", rc));
     1254            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: CLEAR_EP returned %d\n", rc));
    12541255            break;
    12551256        }
     
    12621263            rc = vboxUSBSolarisSetConfig(pState, pSetCfgReq->bConfigValue);
    12631264            *pcbDataOut = 0;
    1264             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SET_CONFIG returned %d\n", rc));
     1265            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SET_CONFIG returned %d\n", rc));
    12651266            break;
    12661267        }
     
    12731274            rc = vboxUSBSolarisSetInterface(pState, pSetInterfaceReq->bInterface, pSetInterfaceReq->bAlternate);
    12741275            *pcbDataOut = 0;
    1275             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SET_INTERFACE returned %d\n", rc));
     1276            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: SET_INTERFACE returned %d\n", rc));
    12761277            break;
    12771278        }
     
    12841285            rc = vboxUSBSolarisCloseDevice(pState, pCloseDeviceReq->ResetLevel);
    12851286            *pcbDataOut = 0;
    1286             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: CLOSE_DEVICE returned %d\n", rc));
     1287            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: CLOSE_DEVICE returned %d\n", rc));
    12871288            break;
    12881289        }
     
    12951296            rc = vboxUSBSolarisAbortPipe(pState, pAbortPipeReq->bEndpoint);
    12961297            *pcbDataOut = 0;
    1297             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: ABORT_PIPE returned %d\n", rc));
     1298            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: ABORT_PIPE returned %d\n", rc));
    12981299            break;
    12991300        }
     
    13061307            rc = vboxUSBSolarisGetConfig(pState, &pGetCfgReq->bConfigValue);
    13071308            *pcbDataOut = sizeof(VBOXUSBREQ_GET_CONFIG);
    1308             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: GET_CONFIG returned %d\n", rc));
     1309            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: GET_CONFIG returned %d\n", rc));
    13091310            break;
    13101311        }
     
    13191320            *pcbDataOut = sizeof(VBOXUSBREQ_GET_VERSION);
    13201321            rc = VINF_SUCCESS;
    1321             LogFlow((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
     1322            Log((DEVICE_NAME ":vboxUSBSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
    13221323            break;
    13231324        }
     
    13461347LOCAL int vboxUSBSolarisInitPower(vboxusb_state_t *pState)
    13471348{
    1348     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisInitPower pState=%p\n", pState));
     1349    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitPower pState=%p\n", pState));
    13491350
    13501351    int rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_ENABLE);
     
    13761377            }
    13771378            else
    1378                 LogFlow((DEVICE_NAME ":vboxUSBSolarisInitPower failed to create power components.\n"));
     1379                Log((DEVICE_NAME ":vboxUSBSolarisInitPower failed to create power components.\n"));
    13791380
    13801381            return VINF_SUCCESS;
     
    13851386    else
    13861387    {
    1387         LogFlow((DEVICE_NAME ":vboxUSBSolarisInitPower failed to enable remote wakeup. No PM.\n"));
     1388        Log((DEVICE_NAME ":vboxUSBSolarisInitPower failed to enable remote wakeup. No PM.\n"));
    13881389        rc = VINF_SUCCESS;
    13891390    }
     
    14031404LOCAL void vboxUSBSolarisDestroyPower(vboxusb_state_t *pState)
    14041405{
    1405     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDestroyPower pState=%p\n", pState));
     1406    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyPower pState=%p\n", pState));
    14061407
    14071408    if (pState->pPower)
     
    14181419            rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR);
    14191420            if (rc != DDI_SUCCESS)
    1420                 LogFlow((DEVICE_NAME ":vboxUSBSolarisDestroyPower raising power failed! rc=%d\n", rc));
     1421                Log((DEVICE_NAME ":vboxUSBSolarisDestroyPower raising power failed! rc=%d\n", rc));
    14211422
    14221423            rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_DISABLE);
    14231424            if (rc != DDI_SUCCESS)
    1424                 LogFlow((DEVICE_NAME ":vboxUSBSolarisDestroyPower failed to disable remote wakeup.\n"));
     1425                Log((DEVICE_NAME ":vboxUSBSolarisDestroyPower failed to disable remote wakeup.\n"));
    14251426        }
    14261427        else
     
    14291430        rc = pm_lower_power(pState->pDip, 0 /* component */, USB_DEV_OS_PWR_OFF);
    14301431        if (rc != DDI_SUCCESS)
    1431             LogFlow((DEVICE_NAME ":vboxUSBSolarisDestroyPower lowering power failed! rc=%d\n", rc));
     1432            Log((DEVICE_NAME ":vboxUSBSolarisDestroyPower lowering power failed! rc=%d\n", rc));
    14321433
    14331434        vboxUSBSolarisPowerIdle(pState);
     
    15551556        while (cCompatible--)
    15561557        {
    1557             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
     1558            Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
    15581559            if (!strncmp(ppszCompatible[cCompatible], "usb", 3))
    15591560            {
    1560                 LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. pszCompatible=%s\n", ppszCompatible[cCompatible]));
     1561                Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. pszCompatible=%s\n", ppszCompatible[cCompatible]));
    15611562                ddi_prop_free(ppszCompatible);
    15621563                return true;
     
    15681569    }
    15691570    else
    1570         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice USB property lookup failed. rc=%d\n", rc));
     1571        Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice USB property lookup failed. rc=%d\n", rc));
    15711572
    15721573    /*
     
    15811582            while (cCompatible--)
    15821583            {
    1583                 LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice parent compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
     1584                Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice parent compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible]));
    15841585                if (!strncmp(ppszCompatible[cCompatible], "usb", 3))
    15851586                {
    1586                     LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. parent pszCompatible=%s\n",
     1587                    Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice verified device as USB. parent pszCompatible=%s\n",
    15871588                            ppszCompatible[cCompatible]));
    15881589                    ddi_prop_free(ppszCompatible);
     
    15951596        }
    15961597        else
    1597             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice USB parent property lookup failed. rc=%d\n", rc));
     1598            Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice USB parent property lookup failed. rc=%d\n", rc));
    15981599    }
    15991600    else
    1600         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice failed to obtain parent device for property lookup.\n"));
     1601        Log((DEVICE_NAME ":vboxUSBSolarisIsUSBDevice failed to obtain parent device for property lookup.\n"));
    16011602
    16021603    return false;
     
    16191620    AssertPtrReturn(pEp, VERR_INVALID_POINTER);
    16201621
    1621     /* LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisSendUrb pState=%p pUrbReq=%p bEndpoint=%#x[%d] enmDir=%#x enmType=%#x cbData=%d pvData=%p\n",
     1622    /* LogFunc((DEVICE_NAME ":vboxUSBSolarisSendUrb pState=%p pUrbReq=%p bEndpoint=%#x[%d] enmDir=%#x enmType=%#x cbData=%d pvData=%p\n",
    16221623            pState, pUrbReq, pUrbReq->bEndpoint, EndPtIndex, pUrbReq->enmDir, pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData)); */
    16231624
     
    17761777LOCAL int vboxUSBSolarisReapURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
    17771778{
    1778 //    LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisReapUrb pState=%p pUrbReq=%p\n", pState, pUrbReq));
     1779//    LogFunc((DEVICE_NAME ":vboxUSBSolarisReapUrb pState=%p pUrbReq=%p\n", pState, pUrbReq));
    17791780
    17801781    AssertPtrReturn(pUrbReq, VERR_INVALID_POINTER);
     
    18481849                    }
    18491850
    1850                     LogFlow((DEVICE_NAME ":vboxUSBSolarisReapUrb pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3, pUrbReq->pvData, pUrbReq->cbData));
     1851                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3, pUrbReq->pvData, pUrbReq->cbData));
    18511852                }
    18521853                else
     
    18541855                    pUrbReq->cbData = 0;
    18551856                    rc = VERR_INVALID_POINTER;
    1856                     LogFlow((DEVICE_NAME ":vboxUSBSolarisReapUrb missing pvDataR3!!\n"));
     1857                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb missing pvDataR3!!\n"));
    18571858                }
    18581859
     
    18771878                else
    18781879                {
    1879                     LogFlow((DEVICE_NAME ":vboxUSBSolarisReapUrb missing message.\n"));
     1880                    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb missing message.\n"));
    18801881                    pUrbReq->cbData = 0;
    18811882                }
     
    19261927        mutex_exit(&pState->Mtx);
    19271928
    1928     LogFlow((DEVICE_NAME ":vboxUSBSolarisReapUrb returns %d\n", rc));
     1929    Log((DEVICE_NAME ":vboxUSBSolarisReapUrb returns %d\n", rc));
    19291930    return rc;
    19301931}
     
    19411942LOCAL int vboxUSBSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint)
    19421943{
    1943     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisClearEndPoint pState=%p bEndpoint=%#x\n", pState, bEndpoint));
     1944    LogFunc((DEVICE_NAME ":vboxUSBSolarisClearEndPoint pState=%p bEndpoint=%#x\n", pState, bEndpoint));
    19441945
    19451946    /*
     
    19791980                mutex_enter(&pState->Mtx);
    19801981
    1981                 LogFlow((DEVICE_NAME ":vboxUSBSolarisClearEndPoint bEndpoint=%#x[%d] returns %d\n", bEndpoint, EndPtIndex, rc));
     1982                Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint bEndpoint=%#x[%d] returns %d\n", bEndpoint, EndPtIndex, rc));
    19821983
    19831984                rc = VINF_SUCCESS;
     
    19851986            else
    19861987            {
    1987                 LogFlow((DEVICE_NAME ":vboxUSBSolarisClearEndPoint not opened to be cleared. Faking success. bEndpoint=%#x.\n", bEndpoint));
     1988                Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint not opened to be cleared. Faking success. bEndpoint=%#x.\n", bEndpoint));
    19881989                rc = VINF_SUCCESS;
    19891990            }
     
    19961997    }
    19971998    else
    1998         LogFlow((DEVICE_NAME ":vboxUSBSolarisClearEndPoint device state=%d not online.\n", pState->DevState));
     1999        Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint device state=%d not online.\n", pState->DevState));
    19992000
    20002001    mutex_exit(&pState->Mtx);
     
    20132014LOCAL int vboxUSBSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue)
    20142015{
    2015     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisSetConfig pState=%p bCfgValue=%#x\n", pState, bCfgValue));
     2016    LogFunc((DEVICE_NAME ":vboxUSBSolarisSetConfig pState=%p bCfgValue=%#x\n", pState, bCfgValue));
    20162017
    20172018    /*
     
    20702071LOCAL int vboxUSBSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue)
    20712072{
    2072     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisGetConfig pState=%p pCfgValue=%p\n", pState, pCfgValue));
     2073    LogFunc((DEVICE_NAME ":vboxUSBSolarisGetConfig pState=%p pCfgValue=%p\n", pState, pCfgValue));
    20732074    AssertPtrReturn(pCfgValue, VERR_INVALID_POINTER);
    20742075
     
    20852086        {
    20862087            *pCfgValue = pCurrCfg->cfg_descr.bConfigurationValue;
    2087             LogFlow((DEVICE_NAME ":vboxUSBSolarisGetConfig cached config returned. CfgValue=%d\n", *pCfgValue));
     2088            Log((DEVICE_NAME ":vboxUSBSolarisGetConfig cached config returned. CfgValue=%d\n", *pCfgValue));
    20882089            return VINF_SUCCESS;
    20892090        }
     
    21062107    }
    21072108
    2108     LogFlow((DEVICE_NAME ":vboxUSBSolarisGetConfig returns %d CfgValue=%d\n", rc, *pCfgValue));
     2109    Log((DEVICE_NAME ":vboxUSBSolarisGetConfig returns %d CfgValue=%d\n", rc, *pCfgValue));
    21092110    return rc;
    21102111}
     
    21222123LOCAL int vboxUSBSolarisSetInterface(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
    21232124{
    2124     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisSetInterface pState=%p uInterface=%#x uAlt=%#x\n", pState, uInterface, uAlt));
     2125    LogFunc((DEVICE_NAME ":vboxUSBSolarisSetInterface pState=%p uInterface=%#x uAlt=%#x\n", pState, uInterface, uAlt));
    21252126
    21262127    /*
     
    21692170LOCAL int vboxUSBSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset)
    21702171{
    2171     LogFlow((DEVICE_NAME ":vboxUSBSolarisCloseDevice pState=%p enmReset=%d\n", pState, enmReset));
     2172    Log((DEVICE_NAME ":vboxUSBSolarisCloseDevice pState=%p enmReset=%d\n", pState, enmReset));
    21722173
    21732174    /*
     
    22082209    }
    22092210
    2210     LogFlow((DEVICE_NAME ":vboxUSBSolarisCloseDevice returns %d\n", rc));
     2211    Log((DEVICE_NAME ":vboxUSBSolarisCloseDevice returns %d\n", rc));
    22112212    return rc;
    22122213}
     
    22232224LOCAL int vboxUSBSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint)
    22242225{
    2225     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe pState=%p bEndpoint=%#x\n", pState, bEndpoint));
     2226    LogFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe pState=%p bEndpoint=%#x\n", pState, bEndpoint));
    22262227
    22272228    /*
     
    22682269                mutex_enter(&pState->Mtx);
    22692270
    2270                 LogFlow((DEVICE_NAME ":usb_pipe_drain_reqs returns %d\n", rc));
     2271                Log((DEVICE_NAME ":usb_pipe_drain_reqs returns %d\n", rc));
    22712272                rc = vboxUSBSolarisToVBoxRC(rc);
    22722273            }
     
    22862287    mutex_exit(&pState->Mtx);
    22872288
    2288     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe returns %d\n", rc));
     2289    LogFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe returns %d\n", rc));
    22892290    return rc;
    22902291}
     
    23062307                                uchar_t uInterface, uchar_t uAlt)
    23072308{
    2308     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPoint pState=%p pEpData=%p CfgVal=%d Iface=%d Alt=%d", pState,
     2309    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPoint pState=%p pEpData=%p CfgVal=%d Iface=%d Alt=%d", pState,
    23092310                    pEpData, uCfgValue, uInterface, uAlt));
    23102311
     
    23502351        pEp->fInitialized = VBOXUSB_EP_INITIALIZED;
    23512352    }
    2352     LogFlow((DEVICE_NAME ":vboxUSBSolarisInitEndPoint done. %s:[%d] bEndpoint=%#x\n", !pEpData ? "Default " : "Endpoint",
     2353    Log((DEVICE_NAME ":vboxUSBSolarisInitEndPoint done. %s:[%d] bEndpoint=%#x\n", !pEpData ? "Default " : "Endpoint",
    23532354                    EpIndex, pEp->EpDesc.bEndpointAddress));
    23542355    return VINF_SUCCESS;
     
    23652366LOCAL int vboxUSBSolarisInitAllEndPoints(vboxusb_state_t *pState)
    23662367{
    2367     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints pState=%p\n", pState));
     2368    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints pState=%p\n", pState));
    23682369
    23692370    /*
     
    24042405LOCAL int vboxUSBSolarisInitEndPointsForConfig(vboxusb_state_t *pState, uint8_t uCfgIndex)
    24052406{
    2406     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig pState=%p uCfgIndex=%d\n", pState, uCfgIndex));
     2407    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig pState=%p uCfgIndex=%d\n", pState, uCfgIndex));
    24072408    usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex];
    24082409    uchar_t uCfgValue = pConfig->cfg_descr.bConfigurationValue;
     
    24452446LOCAL int vboxUSBSolarisInitEndPointsForInterfaceAlt(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
    24462447{
    2447     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt pState=%p uInterface=%d uAlt=%d\n", pState, uInterface, uAlt));
     2448    LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt pState=%p uInterface=%d uAlt=%d\n", pState, uInterface, uAlt));
    24482449
    24492450    /* Doesn't hurt to be paranoid */
     
    24892490    }
    24902491
    2491     LogFlow((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt returns %d\n", rc));
     2492    Log((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt returns %d\n", rc));
    24922493    return rc;
    24932494}
     
    25032504LOCAL void vboxUSBSolarisDestroyAllEndPoints(vboxusb_state_t *pState)
    25042505{
    2505     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDestroyAllEndPoints pState=%p\n", pState));
     2506    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyAllEndPoints pState=%p\n", pState));
    25062507    for (unsigned i = 0; i < VBOXUSB_MAX_ENDPOINTS; i++)
    25072508    {
     
    25242525LOCAL void vboxUSBSolarisDestroyEndPoint(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
    25252526{
    2526     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDestroyEndPoint pState=%p pEp=%p\n", pState, pEp));
     2527    LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyEndPoint pState=%p pEp=%p\n", pState, pEp));
    25272528
    25282529    if (pEp->fInitialized == VBOXUSB_EP_INITIALIZED)
     
    25632564LOCAL void vboxUSBSolarisCloseAllPipes(vboxusb_state_t *pState, bool fDefault)
    25642565{
    2565     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes pState=%p\n", pState));
     2566    LogFunc((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes pState=%p\n", pState));
    25662567
    25672568    for (int i = 1; i < VBOXUSB_MAX_ENDPOINTS; i++)
     
    25712572            && pEp->pPipe)
    25722573        {
    2573             LogFlow((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes closing[%d]\n", i));
     2574            Log((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes closing[%d]\n", i));
    25742575            vboxUSBSolarisClosePipe(pState, pEp);
    25752576        }
     
    25832584        {
    25842585            vboxUSBSolarisClosePipe(pState, pEp);
    2585             LogFlow((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes closed default pipe.\n"));
     2586            Log((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes closed default pipe.\n"));
    25862587        }
    25872588    }
     
    25972598LOCAL void vboxUSBSolarisCloseInterface(vboxusb_state_t *pState, uint8_t bInterface)
    25982599{
    2599     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisCloseInterface pState=%p bInterface=%#x\n", pState, bInterface));
     2600    LogFunc((DEVICE_NAME ":vboxUSBSolarisCloseInterface pState=%p bInterface=%#x\n", pState, bInterface));
    26002601
    26012602    for (int i = 1; i < VBOXUSB_MAX_ENDPOINTS; i++)
     
    26062607            && pEp->uInterface == bInterface)
    26072608        {
    2608             LogFlow((DEVICE_NAME ":vboxUSBSolarisCloseInterface closing[%d]\n", i));
     2609            Log((DEVICE_NAME ":vboxUSBSolarisCloseInterface closing[%d]\n", i));
    26092610            vboxUSBSolarisClosePipe(pState, pEp);
    26102611        }
     
    26232624LOCAL int vboxUSBSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
    26242625{
    2625 //    LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisOpenPipe pState=%p pEp=%p\n", pState, pEp));
     2626//    LogFunc((DEVICE_NAME ":vboxUSBSolarisOpenPipe pState=%p pEp=%p\n", pState, pEp));
    26262627
    26272628    /*
     
    26382639        pEp->pPipe = pState->pDevDesc->dev_default_ph;
    26392640        pEp->EpState |= VBOXUSB_EP_STATE_OPENED;
    2640         LogFlow((DEVICE_NAME ":vboxUSBSolarisOpenPipe default pipe opened.\n"));
     2641        Log((DEVICE_NAME ":vboxUSBSolarisOpenPipe default pipe opened.\n"));
    26412642        return VINF_SUCCESS;
    26422643    }
     
    26722673                pEp->cbMaxIsocData = 400 * cbMax * 8;
    26732674            }
    2674             LogFlow((DEVICE_NAME ":vboxUSBSolarisOpenPipe pEp=%p cbMaxIsocData=%u\n", pEp->cbMaxIsocData));
     2675            Log((DEVICE_NAME ":vboxUSBSolarisOpenPipe pEp=%p cbMaxIsocData=%u\n", pEp->cbMaxIsocData));
    26752676        }
    26762677
     
    26982699LOCAL void vboxUSBSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
    26992700{
    2700     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisClosePipe pState=%p pEp=%p\n", pState, pEp));
     2701    LogFunc((DEVICE_NAME ":vboxUSBSolarisClosePipe pState=%p pEp=%p\n", pState, pEp));
    27012702    AssertPtr(pEp);
    27022703
     
    27132714            usb_pipe_drain_reqs(pState->pDip, pEp->pPipe, 0, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */);
    27142715            mutex_enter(&pState->Mtx);
    2715             LogFlow((DEVICE_NAME ":vboxUSBSolarisClosePipe closed default pipe\n"));
     2716            Log((DEVICE_NAME ":vboxUSBSolarisClosePipe closed default pipe\n"));
    27162717        }
    27172718        else
     
    27312732             * Non-default pipe: close it.
    27322733             */
    2733             LogFlow((DEVICE_NAME ":vboxUSBSolarisClosePipe pipe bmAttributes=%#x bEndpointAddress=%#x\n", pEp->EpDesc.bmAttributes, pEp->EpDesc.bEndpointAddress));
     2734            Log((DEVICE_NAME ":vboxUSBSolarisClosePipe pipe bmAttributes=%#x bEndpointAddress=%#x\n", pEp->EpDesc.bmAttributes, pEp->EpDesc.bEndpointAddress));
    27342735            mutex_exit(&pState->Mtx);
    27352736            usb_pipe_close(pState->pDip, pEp->pPipe, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */);
     
    27422743        pEp->pPipe = NULL;
    27432744
    2744         LogFlow((DEVICE_NAME ":vboxUSBSolarisClosePipe successful. pEp=%p\n", pEp));
     2745        Log((DEVICE_NAME ":vboxUSBSolarisClosePipe successful. pEp=%p\n", pEp));
    27452746    }
    27462747
     
    27582759LOCAL bool vboxUSBSolarisIsAnyPipeOpen(vboxusb_state_t *pState)
    27592760{
    2760     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIsAnyPipeOpen pState=%p\n", pState));
     2761    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsAnyPipeOpen pState=%p\n", pState));
    27612762
    27622763    for (int i = 1; i < VBOXUSB_MAX_ENDPOINTS; i++)
     
    27652766        if (pEp->pPipe)
    27662767        {
    2767             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsAnyPipeOpen pState=%p pEp=%p returns true.\n", pState, pEp));
     2768            Log((DEVICE_NAME ":vboxUSBSolarisIsAnyPipeOpen pState=%p pEp=%p returns true.\n", pState, pEp));
    27682769            return true;
    27692770        }
    27702771    }
    27712772
    2772     LogFlow((DEVICE_NAME ":vboxUSBSolarisIsAnyPipeOpen pState=%p returns false.\n", pState));
     2773    Log((DEVICE_NAME ":vboxUSBSolarisIsAnyPipeOpen pState=%p returns false.\n", pState));
    27732774    return false;
    27742775}
     
    28522853LOCAL vboxusb_urb_t *vboxUSBSolarisQueueURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg)
    28532854{
    2854     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisQueueURB pState=%p pUrbReq=%p\n", pState, pUrbReq));
     2855    LogFunc((DEVICE_NAME ":vboxUSBSolarisQueueURB pState=%p pUrbReq=%p\n", pState, pUrbReq));
    28552856
    28562857    mutex_enter(&pState->Mtx);
     
    29052906    Assert(pUrb->pMsg == NULL);
    29062907    pUrb->pState = pState;
    2907     LogFlow((DEVICE_NAME ":vboxUSBSolarisQueueURB cInflightUrbs=%d\n", pState->cInflightUrbs));
     2908    Log((DEVICE_NAME ":vboxUSBSolarisQueueURB cInflightUrbs=%d\n", pState->cInflightUrbs));
    29082909
    29092910    if (RT_LIKELY(pUrbReq))
     
    29402941LOCAL inline void vboxUSBSolarisDeQueueURB(vboxusb_urb_t *pUrb, int URBStatus)
    29412942{
    2942     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDeQueue pUrb=%p\n", pUrb));
     2943    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeQueue pUrb=%p\n", pUrb));
    29432944    AssertPtrReturnVoid(pUrb);
    29442945
     
    29632964    else
    29642965    {
    2965         LogFlow((DEVICE_NAME ":vboxUSBSolarisDeQueue State Gone.\n"));
     2966        Log((DEVICE_NAME ":vboxUSBSolarisDeQueue State Gone.\n"));
    29662967        freemsg(pUrb->pMsg);
    29672968        pUrb->pMsg = NULL;
     
    30443045LOCAL int vboxUSBSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    30453046{
    3046     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
     3047    LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
    30473048
    30483049    AssertPtrReturn(pUrb->pMsg, VERR_INVALID_PARAMETER);
     
    30923093        pReq->ctrl_client_private = (usb_opaque_t)pUrb;
    30933094
    3094         LogFlow((DEVICE_NAME ":vboxUSBSolarisCtrlXfer %.*Rhxd\n", VBOXUSB_CTRL_XFER_SIZE, pSetupData));
     3095        Log((DEVICE_NAME ":vboxUSBSolarisCtrlXfer %.*Rhxd\n", VBOXUSB_CTRL_XFER_SIZE, pSetupData));
    30953096
    30963097        /*
     
    31273128LOCAL void vboxUSBSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq)
    31283129{
    3129     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
     3130    LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
    31303131
    31313132    vboxusb_urb_t *pUrb   = (vboxusb_urb_t *)pReq->ctrl_client_private;
     
    31583159                && pUrb->pMsg->b_cont == NULL)  /* Concat succeeded */
    31593160            {
    3160                 LogFlow((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted prepended header rc=%d cbData=%d.\n", pReq->ctrl_completion_reason,
     3161                Log((DEVICE_NAME ":vboxUSBSolarisCtrlXferCompleted prepended header rc=%d cbData=%d.\n", pReq->ctrl_completion_reason,
    31613162                        MBLKL(pUrb->pMsg)));
    3162                 LogFlow((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pUrb->pMsg), pUrb->pMsg->b_rptr));
     3163                Log((DEVICE_NAME ":%.*Rhxd\n", MBLKL(pUrb->pMsg), pUrb->pMsg->b_rptr));
    31633164            }
    31643165#endif
     
    31933194LOCAL int vboxUSBSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    31943195{
    3195     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisBulkXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
     3196    LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
    31963197
    31973198    /*
     
    32583259LOCAL void vboxUSBSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq)
    32593260{
    3260     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
     3261    LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
    32613262
    32623263    vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe);
     
    32783279            }
    32793280
    3280             LogFlow((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted %s. rc=%d cbData=%d\n",
     3281            Log((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted %s. rc=%d cbData=%d\n",
    32813282                    pReq->bulk_completion_reason != USB_CR_OK ? "failed URB" : "success",
    32823283                    pReq->bulk_completion_reason, pUrb->pMsg ? MBLKL(pUrb->pMsg) : 0));
     
    32933294    }
    32943295    else
    3295         LogFlow((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted Pipe Gone.\n"));
     3296        Log((DEVICE_NAME ":vboxUSBSolarisBulkXferCompleted Pipe Gone.\n"));
    32963297
    32973298    usb_free_bulk_req(pReq);
     
    33113312LOCAL int vboxUSBSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    33123313{
    3313     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIntrXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
     3314    LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, pUrb->enmDir, pUrb->cbDataR3));
    33143315
    33153316    int rc = VINF_SUCCESS;
     
    33713372LOCAL void vboxUSBSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq)
    33723373{
    3373     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
     3374    LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
    33743375
    33753376    vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe);
     
    33903391            }
    33913392
    3392             LogFlow((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted rc=%d pMsg=%p enmDir=%#x\n", pReq->intr_completion_reason, pUrb->pMsg,
     3393            Log((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted rc=%d pMsg=%p enmDir=%#x\n", pReq->intr_completion_reason, pUrb->pMsg,
    33933394                    pUrb->enmDir));
    33943395
     
    34043405    }
    34053406    else
    3406         LogFlow((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted Pipe Gone.\n"));
     3407        Log((DEVICE_NAME ":vboxUSBSolarisIntrXferCompleted Pipe Gone.\n"));
    34073408
    34083409    usb_free_intr_req(pReq);
     
    34223423LOCAL int vboxUSBSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
    34233424{
    3424 //    LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIsocXfer pState=%p pEp=%p pUrb=%p\n", pState, pEp, pUrb));
     3425//    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocXfer pState=%p pEp=%p pUrb=%p\n", pState, pEp, pUrb));
    34253426
    34263427    /*
     
    34313432    if (pUrb->enmDir == VUSBDIRECTION_IN)
    34323433    {
    3433         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocXfer Isoc. In queueing.\n"));
     3434        Log((DEVICE_NAME ":vboxUSBSolarisIsocXfer Isoc. In queueing.\n"));
    34343435
    34353436        mutex_enter(&pState->Mtx);
     
    34423443            {
    34433444                mutex_exit(&pState->Mtx);
    3444                 LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocXfer Max Isoc. data %d bytes queued\n", pEp->cbMaxIsocData));
     3445                Log((DEVICE_NAME ":vboxUSBSolarisIsocXfer Max Isoc. data %d bytes queued\n", pEp->cbMaxIsocData));
    34453446                return VERR_TOO_MUCH_DATA;
    34463447            }
     
    34573458    int rc = VINF_SUCCESS;
    34583459    usb_isoc_req_t *pReq = usb_alloc_isoc_req(pState->pDip, pUrb->cIsocPkts, cbData, USB_FLAGS_NOSLEEP);
    3459     LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocXfer enmDir=%#x cIsocPkts=%d aIsocPkts[0]=%d cbDataR3=%d\n", pUrb->enmDir,
     3460    Log((DEVICE_NAME ":vboxUSBSolarisIsocXfer enmDir=%#x cIsocPkts=%d aIsocPkts[0]=%d cbDataR3=%d\n", pUrb->enmDir,
    34603461                    pUrb->cIsocPkts, pUrb->aIsocPkts[0].cbPkt, pUrb->cbDataR3));
    34613462    if (RT_LIKELY(pReq))
     
    35493550LOCAL void vboxUSBSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
    35503551{
    3551 //    LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
     3552//    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
    35523553
    35533554    vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private;
     
    35643565            if (pReq->isoc_error_count == pReq->isoc_pkts_count)
    35653566            {
    3566                 LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted stopping polling! Too many errors.\n"));
     3567                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted stopping polling! Too many errors.\n"));
    35673568                mutex_exit(&pState->Mtx);
    35683569                usb_pipe_stop_isoc_polling(pPipe, USB_FLAGS_NOSLEEP);
     
    35763577            if (RT_LIKELY(pReq->isoc_data))
    35773578            {
    3578                 LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs, pEp->cbIsocInLandedReqs));
     3579                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs, pEp->cbIsocInLandedReqs));
    35793580
    35803581                mutex_enter(&pState->Mtx);
     
    36413642                 * Buffer incoming data if the guest has not yet queued any Input URBs.
    36423643                 */
    3643                 LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted Buffering\n"));
     3644                Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted Buffering\n"));
    36443645                vboxusb_isoc_req_t *pIsocReq = kmem_alloc(sizeof(vboxusb_isoc_req_t), KM_NOSLEEP);
    36453646                if (RT_LIKELY(pIsocReq))
     
    37233724    }
    37243725    else
    3725         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted State Gone.\n"));
     3726        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferCompleted State Gone.\n"));
    37263727
    37273728    usb_free_isoc_req(pReq);
     
    37383739LOCAL void vboxUSBSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
    37393740{
    3740     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIsocInXferError pPipe=%p pReq=%p\n", pPipe, pReq));
     3741    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocInXferError pPipe=%p pReq=%p\n", pPipe, pReq));
    37413742
    37423743    vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private;
    37433744    if (RT_UNLIKELY(!pState))
    37443745    {
    3745         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferError State Gone.\n"));
     3746        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError State Gone.\n"));
    37463747        usb_free_isoc_req(pReq);
    37473748        return;
     
    37523753    if (RT_UNLIKELY(!pEp))
    37533754    {
    3754         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferError Pipe Gone.\n"));
     3755        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError Pipe Gone.\n"));
    37553756        mutex_exit(&pState->Mtx);
    37563757        usb_free_isoc_req(pReq);
     
    37683769            mutex_exit(&pState->Mtx);
    37693770            usb_pipe_isoc_xfer(pPipe, pReq, USB_FLAGS_NOSLEEP);
    3770             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferError resubmitted Isoc. IN request due to immediately unavailable resources.\n"));
     3771            Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError resubmitted Isoc. IN request due to immediately unavailable resources.\n"));
    37713772
    37723773            return;
     
    37843785        default:
    37853786        {
    3786             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferError stopping Isoc. In. polling due to rc=%d\n", pReq->isoc_completion_reason));
     3787            Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError stopping Isoc. In. polling due to rc=%d\n", pReq->isoc_completion_reason));
    37873788            pEp->fIsocPolling = false;
    37883789            mutex_exit(&pState->Mtx);
     
    38013802    {
    38023803        --pEp->cIsocInUrbs;
    3803         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocInXferError Deleting last queued URB as it failed.\n"));
     3804        Log((DEVICE_NAME ":vboxUSBSolarisIsocInXferError Deleting last queued URB as it failed.\n"));
    38043805        freemsg(pUrb->pMsg);
    38053806        RTMemFree(pUrb);
     
    38203821LOCAL void vboxUSBSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq)
    38213822{
    3822     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
     3823    LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted pPipe=%p pReq=%p\n", pPipe, pReq));
    38233824
    38243825    vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe);
     
    38363837            }
    38373838
    3838             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts, pUrb->cbDataR3, cbActPkt));
     3839            Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts, pUrb->cbDataR3, cbActPkt));
    38393840
    38403841            if (pReq->isoc_completion_reason == USB_CR_OK)
     
    38593860        }
    38603861        else
    3861             LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted missing private data!?! Dropping OUT pUrb.\n"));
     3862            Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted missing private data!?! Dropping OUT pUrb.\n"));
    38623863    }
    38633864    else
    3864         LogFlow((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted Pipe Gone.\n"));
     3865        Log((DEVICE_NAME ":vboxUSBSolarisIsocOutXferCompleted Pipe Gone.\n"));
    38653866
    38663867    usb_free_isoc_req(pReq);
     
    38773878LOCAL int vboxUSBSolarisDeviceDisconnected(dev_info_t *pDip)
    38783879{
    3879     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDeviceDisconnected pDip=%p\n", pDip));
     3880    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceDisconnected pDip=%p\n", pDip));
    38803881
    38813882    int instance = ddi_get_instance(pDip);
     
    39153916LOCAL int vboxUSBSolarisDeviceReconnected(dev_info_t *pDip)
    39163917{
    3917     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDeviceReconnected pDip=%p\n", pDip));
     3918    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceReconnected pDip=%p\n", pDip));
    39183919
    39193920    int instance = ddi_get_instance(pDip);
     
    39383939LOCAL void vboxUSBSolarisDeviceRestore(vboxusb_state_t *pState)
    39393940{
    3940     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDeviceRestore pState=%p\n", pState));
     3941    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceRestore pState=%p\n", pState));
    39413942    AssertPtrReturnVoid(pState);
    39423943
     
    39653966        /* Do we need to inform userland here? */
    39663967        vboxUSBSolarisPowerIdle(pState);
    3967         LogFlow((DEVICE_NAME ":vboxUSBSolarisDeviceRestore not the same device.\n"));
     3968        Log((DEVICE_NAME ":vboxUSBSolarisDeviceRestore not the same device.\n"));
    39683969        return;
    39693970    }
     
    39963997LOCAL int vboxUSBSolarisDeviceSuspend(vboxusb_state_t *pState)
    39973998{
    3998     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend pState=%p\n", pState));
     3999    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend pState=%p\n", pState));
    39994000
    40004001    int rc = VERR_VUSB_DEVICE_IS_SUSPENDED;
     
    40614062
    40624063    mutex_exit(&pState->Mtx);
    4063     LogFlow((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend returns %d\n", rc));
     4064    Log((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend returns %d\n", rc));
    40644065    return rc;
    40654066}
     
    40734074LOCAL void vboxUSBSolarisDeviceResume(vboxusb_state_t *pState)
    40744075{
    4075     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisDeviceResume pState=%p\n", pState));
     4076    LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceResume pState=%p\n", pState));
    40764077    return vboxUSBSolarisDeviceRestore(pState);
    40774078}
     
    40854086LOCAL void vboxUSBSolarisPowerBusy(vboxusb_state_t *pState)
    40864087{
    4087     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisPowerBusy pState=%p\n", pState));
     4088    LogFunc((DEVICE_NAME ":vboxUSBSolarisPowerBusy pState=%p\n", pState));
    40884089    AssertPtrReturnVoid(pState);
    40894090
     
    40974098        if (rc != DDI_SUCCESS)
    40984099        {
    4099             LogFlow((DEVICE_NAME ":vboxUSBSolarisPowerBusy busy component failed! rc=%d\n", rc));
     4100            Log((DEVICE_NAME ":vboxUSBSolarisPowerBusy busy component failed! rc=%d\n", rc));
    41004101            mutex_enter(&pState->Mtx);
    41014102            pState->pPower->PowerBusy--;
     
    41154116LOCAL void vboxUSBSolarisPowerIdle(vboxusb_state_t *pState)
    41164117{
    4117     LogFlowFunc((DEVICE_NAME ":vboxUSBSolarisPowerIdle pState=%p\n", pState));
     4118    LogFunc((DEVICE_NAME ":vboxUSBSolarisPowerIdle pState=%p\n", pState));
    41184119    AssertPtrReturnVoid(pState);
    41194120
     
    41294130        }
    41304131        else
    4131             LogFlow((DEVICE_NAME ":vboxUSBSolarisPowerIdle idle component failed! rc=%d\n", rc));
    4132     }
    4133 }
    4134 
     4132            Log((DEVICE_NAME ":vboxUSBSolarisPowerIdle idle component failed! rc=%d\n", rc));
     4133    }
     4134}
     4135
  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c

    r38736 r38895  
    2121#define LOG_GROUP  LOG_GROUP_USB_DRV
    2222#ifdef DEBUG_ramshankar
     23# define LOG_ENABLED
    2324# define LOG_INSTANCE       RTLogRelDefaultInstance()
    2425#endif
     
    193194    int rc;
    194195
    195     LogFlowFunc((DEVICE_NAME ":_init\n"));
     196    LogFunc((DEVICE_NAME ":_init\n"));
    196197
    197198    g_pDip = NULL;
     
    249250    int rc;
    250251
    251     LogFlowFunc((DEVICE_NAME ":_fini\n"));
     252    LogFunc((DEVICE_NAME ":_fini\n"));
    252253
    253254    rc = mod_remove(&g_VBoxUSBMonSolarisModLinkage);
     
    266267int _info(struct modinfo *pModInfo)
    267268{
    268     LogFlowFunc((DEVICE_NAME ":_info\n"));
     269    LogFunc((DEVICE_NAME ":_info\n"));
    269270
    270271    return mod_info(&g_VBoxUSBMonSolarisModLinkage, pModInfo);
     
    282283static int VBoxUSBMonSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    283284{
    284     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
     285    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
    285286    switch (enmCmd)
    286287    {
     
    329330static int VBoxUSBMonSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
    330331{
    331     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisDetach\n"));
     332    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisDetach\n"));
    332333
    333334    switch (enmCmd)
     
    379380    int rc = DDI_SUCCESS;
    380381
    381     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisGetInfo\n"));
     382    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisGetInfo\n"));
    382383
    383384    switch (enmCmd)
     
    404405    unsigned iOpenInstance;
    405406
    406     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisOpen\n"));
     407    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisOpen\n"));
    407408
    408409    /*
     
    431432            return EINVAL;
    432433        }
    433         LogFlow((DEVICE_NAME ":Successfully registered election callback with USBA\n"));
     434        Log((DEVICE_NAME ":Successfully registered election callback with USBA\n"));
    434435        mutex_enter(&g_VBoxUSBMonSolarisMtx);
    435436    }
     
    469470    vboxusbmon_state_t *pState = NULL;
    470471
    471     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisClose\n"));
     472    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisClose\n"));
    472473
    473474    pState = ddi_get_soft_state(g_pVBoxUSBMonSolarisState, getminor(Dev));
     
    486487            mutex_exit(&g_VBoxUSBMonSolarisMtx);
    487488            usb_unregister_dev_driver(g_pDip);
    488             LogFlow((DEVICE_NAME ":Successfully deregistered driver election callback\n"));
     489            Log((DEVICE_NAME ":Successfully deregistered driver election callback\n"));
    489490        }
    490491        else
     
    515516static int VBoxUSBMonSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
    516517{
    517     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisRead\n"));
     518    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisRead\n"));
    518519    return 0;
    519520}
     
    522523static int VBoxUSBMonSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
    523524{
    524     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisWrite\n"));
     525    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisWrite\n"));
    525526    return 0;
    526527}
     
    537538static int VBoxUSBMonSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal)
    538539{
    539     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg));
     540    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg));
    540541
    541542    /*
     
    603604        return EINVAL;
    604605    }
    605     LogFlow((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: pid=%d.\n", (int)RTProcSelf()));
     606    Log((DEVICE_NAME ":VBoxUSBMonSolarisIOCtl: pid=%d.\n", (int)RTProcSelf()));
    606607
    607608    /*
     
    665666static int vboxUSBMonSolarisProcessIOCtl(int iFunction, void *pvState, void *pvData, size_t cbData, size_t *pcbReturnedData)
    666667{
    667     LogFlowFunc((DEVICE_NAME ":solarisUSBProcessIOCtl iFunction=%d pvBuf=%p cbBuf=%zu\n", iFunction, pvData, cbData));
     668    LogFunc((DEVICE_NAME ":solarisUSBProcessIOCtl iFunction=%d pvBuf=%p cbBuf=%zu\n", iFunction, pvData, cbData));
    668669
    669670    AssertPtrReturn(pvState, VERR_INVALID_POINTER);
     
    695696            PUSBFILTER pFilter = (PUSBFILTER)&pReq->Filter;
    696697
    697             LogFlow(("vboxUSBMonSolarisProcessIOCtl: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
     698            Log(("vboxUSBMonSolarisProcessIOCtl: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
    698699                      USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID),
    699700                      USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID),
     
    704705                      USBFilterGetNum(pFilter, USBFILTERIDX_BUS),
    705706                      USBFilterGetNum(pFilter, USBFILTERIDX_PORT)));
    706             LogFlow(("vboxUSBMonSolarisProcessIOCtl: Manufacturer=%s Product=%s Serial=%s\n",
     707            Log(("vboxUSBMonSolarisProcessIOCtl: Manufacturer=%s Product=%s Serial=%s\n",
    707708                      USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR)  ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR)  : "<null>",
    708709                      USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR)       ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR)       : "<null>",
     
    713714            rc = VBoxUSBFilterAdd(pFilter, pState->Process, &pReq->uId);
    714715            *pcbReturnedData = cbData;
    715             LogFlow((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: ADD_FILTER (Process:%d) returned %d\n", pState->Process, rc));
     716            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: ADD_FILTER (Process:%d) returned %d\n", pState->Process, rc));
    716717            break;
    717718        }
     
    724725            rc = VBoxUSBFilterRemove(pState->Process, (uintptr_t)pReq->uId);
    725726            *pcbReturnedData = 0;
    726             LogFlow((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: REMOVE_FILTER (Process:%d) returned %d\n", pState->Process, rc));
     727            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: REMOVE_FILTER (Process:%d) returned %d\n", pState->Process, rc));
    727728            break;
    728729        }
     
    735736            rc = vboxUSBMonSolarisResetDevice(pReq->szDevicePath, pReq->fReattach);
    736737            *pcbReturnedData = 0;
    737             LogFlow((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: RESET_DEVICE (Process:%d) returned %d\n", pState->Process, rc));
     738            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: RESET_DEVICE (Process:%d) returned %d\n", pState->Process, rc));
    738739            break;
    739740        }
     
    746747            rc = vboxUSBMonSolarisClientInfo(pState, pReq);
    747748            *pcbReturnedData = cbData;
    748             LogFlow((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: CLIENT_INFO (Process:%d) returned %d\n", pState->Process, rc));
     749            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: CLIENT_INFO (Process:%d) returned %d\n", pState->Process, rc));
    749750            break;
    750751        }
     
    759760            *pcbReturnedData = sizeof(VBOXUSBREQ_GET_VERSION);
    760761            rc = VINF_SUCCESS;
    761             LogFlow((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
     762            Log((DEVICE_NAME ":vboxUSBMonSolarisProcessIOCtl: GET_VERSION returned %d\n", rc));
    762763            break;
    763764        }
     
    778779    int rc = VERR_GENERAL_FAILURE;
    779780
    780     LogFlowFunc((DEVICE_NAME ":vboxUSBMonSolarisResetDevice pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach));
     781    LogFunc((DEVICE_NAME ":vboxUSBMonSolarisResetDevice pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach));
    781782
    782783    /*
     
    811812         */
    812813        rc = usb_reset_device(pDeviceInfo, fReattach ? USB_RESET_LVL_REATTACH : USB_RESET_LVL_DEFAULT);
    813         LogFlow((DEVICE_NAME ":usb_reset_device for %s level=%s returned %d\n", pszDevicePath, fReattach ? "ReAttach" : "Default", rc));
     814        Log((DEVICE_NAME ":usb_reset_device for %s level=%s returned %d\n", pszDevicePath, fReattach ? "ReAttach" : "Default", rc));
    814815        switch (rc)
    815816        {
     
    846847static int vboxUSBMonSolarisClientInfo(vboxusbmon_state_t *pState, PVBOXUSB_CLIENT_INFO pClientInfo)
    847848{
    848     LogFlowFunc((DEVICE_NAME ":vboxUSBMonSolarisClientInfo pState=%p pClientInfo=%p\n", pState, pClientInfo));
     849    LogFunc((DEVICE_NAME ":vboxUSBMonSolarisClientInfo pState=%p pClientInfo=%p\n", pState, pClientInfo));
    849850
    850851    AssertPtrReturn(pState, VERR_INVALID_POINTER);
     
    876877            mutex_exit(&g_VBoxUSBMonSolarisMtx);
    877878
    878             LogFlow((DEVICE_NAME ":vboxUSBMonSolarisClientInfo found. %s rc=%d\n", pClientInfo->szDeviceIdent, rc));
     879            Log((DEVICE_NAME ":vboxUSBMonSolarisClientInfo found. %s rc=%d\n", pClientInfo->szDeviceIdent, rc));
    879880            return rc;
    880881        }
     
    899900int VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo)
    900901{
    901     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient pClientDip=%p pClientInfo=%p\n", pClientDip, pClientInfo));
     902    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient pClientDip=%p pClientInfo=%p\n", pClientDip, pClientInfo));
    902903    AssertPtrReturn(pClientInfo, VERR_INVALID_PARAMETER);
    903904
     
    918919            mutex_exit(&g_VBoxUSBMonSolarisMtx);
    919920
    920             LogFlow((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient registered. %d %s %s\n",
     921            Log((DEVICE_NAME ":VBoxUSBMonSolarisRegisterClient registered. %d %s %s\n",
    921922                        pClient->Info.Instance, pClient->Info.szClientPath, pClient->Info.szDeviceIdent));
    922923
     
    940941int VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip)
    941942{
    942     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient pClientDip=%p\n", pClientDip));
     943    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient pClientDip=%p\n", pClientDip));
    943944    AssertReturn(pClientDip, VERR_INVALID_PARAMETER);
    944945
     
    960961                mutex_exit(&g_VBoxUSBMonSolarisMtx);
    961962
    962                 LogFlow((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient unregistered. %d %s %s\n",
     963                Log((DEVICE_NAME ":VBoxUSBMonSolarisUnregisterClient unregistered. %d %s %s\n",
    963964                            pCur->Info.Instance, pCur->Info.szClientPath, pCur->Info.szDeviceIdent));
    964965                RTMemFree(pCur);
     
    995996                                char **ppszDrv, void *pvReserved)
    996997{
    997     LogFlowFunc((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver pDevDesc=%p pDevStrings=%p pszDevicePath=%s Bus=%d Port=%d\n", pDevDesc,
     998    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver pDevDesc=%p pDevStrings=%p pszDevicePath=%s Bus=%d Port=%d\n", pDevDesc,
    998999            pDevStrings, pszDevicePath, Bus, Port));
    9991000
     
    10211022    USBFilterSetMustBePresent(&Filter, USBFILTERIDX_BUS, false /* fMustBePresent */);
    10221023
    1023     LogFlow((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
     1024    Log((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
    10241025              USBFilterGetNum(&Filter, USBFILTERIDX_VENDOR_ID),
    10251026              USBFilterGetNum(&Filter, USBFILTERIDX_PRODUCT_ID),
     
    10301031              USBFilterGetNum(&Filter, USBFILTERIDX_BUS),
    10311032              USBFilterGetNum(&Filter, USBFILTERIDX_PORT)));
    1032     LogFlow((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: Manufacturer=%s Product=%s Serial=%s\n",
     1033    Log((DEVICE_NAME ":VBoxUSBMonSolarisElectDriver: Manufacturer=%s Product=%s Serial=%s\n",
    10331034              USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR)  ? USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR)  : "<null>",
    10341035              USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR)       ? USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR)       : "<null>",
     
    10431044    if (Owner == NIL_RTPROCESS)
    10441045    {
    1045         LogFlow((DEVICE_NAME ":No matching filters, device %#x:%#x uninteresting.\n", pDevDesc->idVendor, pDevDesc->idProduct));
     1046        Log((DEVICE_NAME ":No matching filters, device %#x:%#x uninteresting.\n", pDevDesc->idVendor, pDevDesc->idProduct));
    10461047        return USB_FAILURE;
    10471048    }
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette