VirtualBox

Changeset 6776 in vbox


Ignore:
Timestamp:
Feb 4, 2008 8:16:45 AM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
27867
Message:

Corrected Solaris vboxadd as vboxguest in more places.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxGuest.h

    r6565 r6776  
    5454#elif defined(RT_OS_SOLARIS)
    5555/** The support device name. */
    56 # define VBOXGUEST_DEVICE_NAME        "/devices/pci@0,0/pci80ee,cafe@4:vboxadd"
     56# define VBOXGUEST_DEVICE_NAME        "/devices/pci@0,0/pci80ee,cafe@4:vboxguest"
    5757
    5858#elif defined(RT_OS_WINDOWS)

  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-solaris.c

    r6775 r6776  
    4545*******************************************************************************/
    4646/** The module name. */
    47 #define DEVICE_NAME              "vboxadd"
     47#define DEVICE_NAME              "vboxguest"
    4848/** The module description as seen in 'modinfo'. */
    4949#define DEVICE_DESC              "VirtualBox Guest Driver"
    … …  
    5353*   Internal Functions                                                         *
    5454*******************************************************************************/
    55 static int VBoxAddSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred);
    56 static int VBoxAddSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred);
    57 static int VBoxAddSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred);
    58 static int VBoxAddSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred);
    59 static int VBoxAddSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int mode, cred_t *pCred, int *pVal);
    60 
    61 static int VBoxAddSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pArg, void **ppResult);
    62 static int VBoxAddSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd);
    63 static int VBoxAddSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
     55static int VBoxGuestSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred);
     56static int VBoxGuestSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred);
     57static int VBoxGuestSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred);
     58static int VBoxGuestSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred);
     59static int VBoxGuestSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int mode, cred_t *pCred, int *pVal);
     60
     61static int VBoxGuestSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pArg, void **ppResult);
     62static int VBoxGuestSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd);
     63static int VBoxGuestSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
    6464
    6565static int VBoxGuestSolarisAddIRQ(dev_info_t *pDip, void *pvState);
    … …  
    7878 * cb_ops: for drivers that support char/block entry points
    7979 */
    80 static struct cb_ops g_VBoxAddSolarisCbOps =
    81 {
    82     VBoxAddSolarisOpen,
    83     VBoxAddSolarisClose,
     80static struct cb_ops g_VBoxGuestSolarisCbOps =
     81{
     82    VBoxGuestSolarisOpen,
     83    VBoxGuestSolarisClose,
    8484    nodev,                  /* b strategy */
    8585    nodev,                  /* b dump */
    8686    nodev,                  /* b print */
    87     VBoxAddSolarisRead,
    88     VBoxAddSolarisWrite,
    89     VBoxAddSolarisIOCtl,
     87    VBoxGuestSolarisRead,
     88    VBoxGuestSolarisWrite,
     89    VBoxGuestSolarisIOCtl,
    9090    nodev,                  /* c devmap */
    9191    nodev,                  /* c mmap */
    … …  
    101101 * dev_ops: for driver device operations
    102102 */
    103 static struct dev_ops g_VBoxAddSolarisDevOps =
     103static struct dev_ops g_VBoxGuestSolarisDevOps =
    104104{
    105105    DEVO_REV,               /* driver build revision */
    106106    0,                      /* ref count */
    107     VBoxAddSolarisGetInfo,
     107    VBoxGuestSolarisGetInfo,
    108108    nulldev,                /* identify */
    109109    nulldev,                /* probe */
    110     VBoxAddSolarisAttach,
    111     VBoxAddSolarisDetach,
     110    VBoxGuestSolarisAttach,
     111    VBoxGuestSolarisDetach,
    112112    nodev,                  /* reset */
    113     &g_VBoxAddSolarisCbOps,
     113    &g_VBoxGuestSolarisCbOps,
    114114    (struct bus_ops *)0,
    115115    nodev                   /* power */
    … …  
    119119 * modldrv: export driver specifics to the kernel
    120120 */
    121 static struct modldrv g_VBoxAddSolarisModule =
     121static struct modldrv g_VBoxGuestSolarisModule =
    122122{
    123123    &mod_driverops,         /* extern from kernel */
    124124    DEVICE_DESC,
    125     &g_VBoxAddSolarisDevOps
     125    &g_VBoxGuestSolarisDevOps
    126126};
    127127
    … …  
    129129 * modlinkage: export install/remove/info to the kernel
    130130 */
    131 static struct modlinkage g_VBoxAddSolarisModLinkage =
     131static struct modlinkage g_VBoxGuestSolarisModLinkage =
    132132{
    133133    MODREV_1,               /* loadable module system revision */
    134     &g_VBoxAddSolarisModule,
     134    &g_VBoxGuestSolarisModule,
    135135    NULL                    /* terminate array of linkage structures */
    136136};
    … …  
    171171
    172172/** Opaque pointer to state */
    173 static void *g_pVBoxAddSolarisState;
     173static void *g_pVBoxGuestSolarisState;
    174174
    175175/** Device extention & session data association structure. */
    … …  
    193193{
    194194    LogFlow((DEVICE_NAME ":_init\n"));
    195     int rc = ddi_soft_state_init(&g_pVBoxAddSolarisState, sizeof(VBoxAddDevState), 1);
     195    int rc = ddi_soft_state_init(&g_pVBoxGuestSolarisState, sizeof(VBoxAddDevState), 1);
    196196    if (!rc)
    197197    {
    198         rc = mod_install(&g_VBoxAddSolarisModLinkage);
     198        rc = mod_install(&g_VBoxGuestSolarisModLinkage);
    199199        if (rc)
    200             ddi_soft_state_fini(&g_pVBoxAddSolarisState);
     200            ddi_soft_state_fini(&g_pVBoxGuestSolarisState);
    201201    }
    202202    return rc;
    … …  
    207207{
    208208    LogFlow((DEVICE_NAME ":_fini\n"));
    209     int rc = mod_remove(&g_VBoxAddSolarisModLinkage);
     209    int rc = mod_remove(&g_VBoxGuestSolarisModLinkage);
    210210    if (!rc)
    211         ddi_soft_state_fini(&g_pVBoxAddSolarisState);
     211        ddi_soft_state_fini(&g_pVBoxGuestSolarisState);
    212212    return rc;
    213213}
    … …  
    217217{
    218218    LogFlow((DEVICE_NAME ":_info\n"));
    219     return mod_info(&g_VBoxAddSolarisModLinkage, pModInfo);
     219    return mod_info(&g_VBoxGuestSolarisModLinkage, pModInfo);
    220220}
    221221
    … …  
    229229 * @return  corresponding solaris error code.
    230230 */
    231 static int VBoxAddSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    232 {
    233     LogFlow((DEVICE_NAME ":VBoxAddSolarisAttach\n"));
     231static int VBoxGuestSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
     232{
     233    LogFlow((DEVICE_NAME ":VBoxGuestSolarisAttach\n"));
    234234    switch (enmCmd)
    235235    {
    … …  
    242242            instance = ddi_get_instance(pDip);
    243243#ifdef USE_SESSION_HASH
    244             rc = ddi_soft_state_zalloc(g_pVBoxAddSolarisState, instance);
     244            rc = ddi_soft_state_zalloc(g_pVBoxGuestSolarisState, instance);
    245245            if (rc != DDI_SUCCESS)
    246246            {
    … …  
    249249            }
    250250
    251             pState = ddi_get_soft_state(g_pVBoxAddSolarisState, instance);
     251            pState = ddi_get_soft_state(g_pVBoxGuestSolarisState, instance);
    252252            if (!pState)
    253253            {
    254                 ddi_soft_state_free(g_pVBoxAddSolarisState, instance);
     254                ddi_soft_state_free(g_pVBoxGuestSolarisState, instance);
    255255                Log((DEVICE_NAME ":ddi_get_soft_state for instance %d failed\n", instance));
    256256                return DDI_FAILURE;
    … …  
    409409 * @return  corresponding solaris error code.
    410410 */
    411 static int VBoxAddSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
    412 {
    413     LogFlow((DEVICE_NAME ":VBoxAddSolarisDetach\n"));
     411static int VBoxGuestSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
     412{
     413    LogFlow((DEVICE_NAME ":VBoxGuestSolarisDetach\n"));
    414414    switch (enmCmd)
    415415    {
    … …  
    419419            int instance = ddi_get_instance(pDip);
    420420#ifdef USE_SESSION_HASH
    421             VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxAddSolarisState, instance);
     421            VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxGuestSolarisState, instance);
    422422#else
    423423            VBoxAddDevState *pState = ddi_get_driver_private(g_pDip);
    … …  
    430430                ddi_remove_minor_node(pDip, NULL);
    431431#ifdef USE_SESSION_HASH
    432                 ddi_soft_state_free(g_pVBoxAddSolarisState, instance);
     432                ddi_soft_state_free(g_pVBoxGuestSolarisState, instance);
    433433#else
    434434                RTMemFree(pState);
    … …  
    468468 * @return  corresponding solaris error code.
    469469 */
    470 static int VBoxAddSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pArg, void **ppResult)
    471 {
    472     LogFlow((DEVICE_NAME ":VBoxAddSolarisGetInfo\n"));
     470static int VBoxGuestSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pArg, void **ppResult)
     471{
     472    LogFlow((DEVICE_NAME ":VBoxGuestSolarisGetInfo\n"));
    473473
    474474    int rc = DDI_SUCCESS;
    … …  
    494494 * User context entry points
    495495 */
    496 static int VBoxAddSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred)
     496static int VBoxGuestSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred)
    497497{
    498498    int                 rc;
    499499    PVBOXGUESTSESSION   pSession;
    500500
    501     LogFlow((DEVICE_NAME ":VBoxAddSolarisOpen\n"));
     501    LogFlow((DEVICE_NAME ":VBoxGuestSolarisOpen\n"));
    502502
    503503    /*
    … …  
    512512    for (iOpenInstance = 0; iOpenInstance < 4096; iOpenInstance++)
    513513    {
    514         if (    !ddi_get_soft_state(g_pVBoxAddSolarisState, iOpenInstance) /* faster */
    515             &&  ddi_soft_state_zalloc(g_pVBoxAddSolarisState, iOpenInstance) == DDI_SUCCESS)
    516         {
    517             pState = ddi_get_soft_state(g_pVBoxAddSolarisState, iOpenInstance);
     514        if (    !ddi_get_soft_state(g_pVBoxGuestSolarisState, iOpenInstance) /* faster */
     515            &&  ddi_soft_state_zalloc(g_pVBoxGuestSolarisState, iOpenInstance) == DDI_SUCCESS)
     516        {
     517            pState = ddi_get_soft_state(g_pVBoxGuestSolarisState, iOpenInstance);
    518518            break;
    519519        }
    … …  
    521521    if (!pState)
    522522    {
    523         Log((DEVICE_NAME ":VBoxAddSolarisOpen: too many open instances."));
     523        Log((DEVICE_NAME ":VBoxGuestSolarisOpen: too many open instances."));
    524524        return ENXIO;
    525525    }
    … …  
    533533        pState->pSession = pSession;
    534534        *pDev = makedevice(getmajor(*pDev), iOpenInstance);
    535         Log((DEVICE_NAME "VBoxAddSolarisOpen: pSession=%p pState=%p pid=%d\n", pSession, pState, (int)RTProcSelf()));
     535        Log((DEVICE_NAME "VBoxGuestSolarisOpen: pSession=%p pState=%p pid=%d\n", pSession, pState, (int)RTProcSelf()));
    536536        return 0;
    537537    }
    538538
    539539    /* Failed, clean up. */
    540     ddi_soft_state_free(g_pVBoxAddSolarisState, iOpenInstance);
     540    ddi_soft_state_free(g_pVBoxGuestSolarisState, iOpenInstance);
    541541#else
    542542    /*
    … …  
    559559        for (instance = 0; instance < 4096; instance++)
    560560        {
    561             VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxAddSolarisState, instance);
     561            VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxGuestSolarisState, instance);
    562562            if (pState)
    563563                break;
    … …  
    565565        if (instance >= 4096)
    566566        {
    567             Log((DEVICE_NAME ":VBoxAddSolarisOpen: All instances exhausted\n"));
     567            Log((DEVICE_NAME ":VBoxGuestSolarisOpen: All instances exhausted\n"));
    568568            return ENXIO;
    569569        }
    570570        *pDev = makedevice(getmajor(*pDev), instance);
    571         Log((DEVICE_NAME ":VBoxAddSolarisOpen success: g_DevExt=%p pSession=%p rc=%d pid=%d\n", &g_DevExt, pSession, rc, (int)RTProcSelf()));
     571        Log((DEVICE_NAME ":VBoxGuestSolarisOpen success: g_DevExt=%p pSession=%p rc=%d pid=%d\n", &g_DevExt, pSession, rc, (int)RTProcSelf()));
    572572        return 0;
    573573    }
    574574#endif
    575     LogRel((DEVICE_NAME ":VBoxAddSolarisOpen: VBoxGuestCreateUserSession failed. rc=%d\n", rc));
     575    LogRel((DEVICE_NAME ":VBoxGuestSolarisOpen: VBoxGuestCreateUserSession failed. rc=%d\n", rc));
    576576    return EFAULT;
    577577}
    578578
    579579
    580 static int VBoxAddSolarisClose(dev_t Dev, int flag, int fType, cred_t *pCred)
    581 {
    582     LogFlow((DEVICE_NAME ":VBoxAddSolarisClose pid=%d\n", (int)RTProcSelf()));
     580static int VBoxGuestSolarisClose(dev_t Dev, int flag, int fType, cred_t *pCred)
     581{
     582    LogFlow((DEVICE_NAME ":VBoxGuestSolarisClose pid=%d\n", (int)RTProcSelf()));
    583583
    584584#ifndef USE_SESSION_HASH
    585585    PVBOXGUESTSESSION pSession;
    586     VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxAddSolarisState, getminor(Dev));
     586    VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxGuestSolarisState, getminor(Dev));
    587587    if (!pState)
    588588    {
    589         Log((DEVICE_NAME ":VBoxAddSolarisClose: failed to get pState.\n"));
     589        Log((DEVICE_NAME ":VBoxGuestSolarisClose: failed to get pState.\n"));
    590590        return EFAULT;
    591591    }
    … …  
    593593    pSession = pState->pSession;
    594594    pState->pSession = NULL;
    595     Log((DEVICE_NAME ":VBoxAddSolarisClose: pSession=%p pState=%p\n", pSession, pState));
    596     ddi_soft_state_free(g_pVBoxAddSolarisState, getminor(Dev));
     595    Log((DEVICE_NAME ":VBoxGuestSolarisClose: pSession=%p pState=%p\n", pSession, pState));
     596    ddi_soft_state_free(g_pVBoxGuestSolarisState, getminor(Dev));
    597597    if (!pSession)
    598598    {
    599         Log((DEVICE_NAME ":VBoxAddSolarisClose: failed to get pSession.\n"));
     599        Log((DEVICE_NAME ":VBoxGuestSolarisClose: failed to get pSession.\n"));
    600600        return EFAULT;
    601601    }
    … …  
    641641    if (!pSession)
    642642    {
    643         Log((DEVICE_NAME ":VBoxAddSolarisClose: WHUT?!? pSession == NULL! This must be a mistake... pid=%d", (int)Process));
     643        Log((DEVICE_NAME ":VBoxGuestSolarisClose: WHUT?!? pSession == NULL! This must be a mistake... pid=%d", (int)Process));
    644644        return EFAULT;
    645645    }
    646     Log((DEVICE_NAME ":VBoxAddSolarisClose: pid=%d\n", (int)Process));
     646    Log((DEVICE_NAME ":VBoxGuestSolarisClose: pid=%d\n", (int)Process));
    647647#endif /* USE_SESSION_HASH */
    648648
    … …  
    655655
    656656
    657 static int VBoxAddSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
    658 {
    659     LogFlow((DEVICE_NAME ":VBoxAddSolarisRead\n"));
     657static int VBoxGuestSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
     658{
     659    LogFlow((DEVICE_NAME ":VBoxGuestSolarisRead\n"));
    660660    return 0;
    661661}
    662662
    663663
    664 static int VBoxAddSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
    665 {
    666     LogFlow((DEVICE_NAME ":VBoxAddSolarisWrite\n"));
     664static int VBoxGuestSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
     665{
     666    LogFlow((DEVICE_NAME ":VBoxGuestSolarisWrite\n"));
    667667    return 0;
    668668}
    … …  
    690690 * @return  corresponding solaris error code.
    691691 */
    692 static int VBoxAddSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal)
    693 {
    694     LogFlow((DEVICE_NAME ":VBoxAddSolarisIOCtl\n"));
     692static int VBoxGuestSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal)
     693{
     694    LogFlow((DEVICE_NAME ":VBoxGuestSolarisIOCtl\n"));
    695695
    696696#ifndef USE_SESSION_HASH
    … …  
    698698     * Get the session from the soft state item.
    699699     */
    700     VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxAddSolarisState, getminor(Dev));
     700    VBoxAddDevState *pState = ddi_get_soft_state(g_pVBoxGuestSolarisState, getminor(Dev));
    701701    if (!pState)
    702702    {
    703         Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: no state data for %d\n", getminor(Dev)));
     703        Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: no state data for %d\n", getminor(Dev)));
    704704        return EINVAL;
    705705    }
    … …  
    708708    if (!pSession)
    709709    {
    710         Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: no session data for %d\n", getminor(Dev)));
     710        Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: no session data for %d\n", getminor(Dev)));
    711711        return EINVAL;
    712712    }
    … …  
    731731    if (!pSession)
    732732    {
    733         Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n", (int)Process, Cmd));
     733        Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n", (int)Process, Cmd));
    734734        return EINVAL;
    735735    }
    … …  
    742742    if (IOCPARM_LEN(Cmd) != sizeof(ReqWrap))
    743743    {
    744         Log((DEVICE_NAME ": VBoxAddSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd), sizeof(ReqWrap)));
     744        Log((DEVICE_NAME ": VBoxGuestSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd), sizeof(ReqWrap)));
    745745        return ENOTTY;
    746746    }
    … …  
    749749    if (RT_UNLIKELY(rc))
    750750    {
    751         Log((DEVICE_NAME ": VBoxAddSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d.\n", pArg, Cmd, rc));
     751        Log((DEVICE_NAME ": VBoxGuestSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d.\n", pArg, Cmd, rc));
    752752        return EINVAL;
    753753    }
    … …  
    755755    if (ReqWrap.u32Magic != VBGLBIGREQ_MAGIC)
    756756    {
    757         Log((DEVICE_NAME ": VBoxAddSolarisIOCtl: bad magic %#x; pArg=%p Cmd=%d.\n", ReqWrap.u32Magic, pArg, Cmd));
     757        Log((DEVICE_NAME ": VBoxGuestSolarisIOCtl: bad magic %#x; pArg=%p Cmd=%d.\n", ReqWrap.u32Magic, pArg, Cmd));
    758758        return EINVAL;
    759759    }
    … …  
    761761                    || ReqWrap.cbData > _1M*16))
    762762    {
    763         Log((DEVICE_NAME ": VBoxAddSolarisIOCtl: bad size %#x; pArg=%p Cmd=%d.\n", ReqWrap.cbData, pArg, Cmd));
     763        Log((DEVICE_NAME ": VBoxGuestSolarisIOCtl: bad size %#x; pArg=%p Cmd=%d.\n", ReqWrap.cbData, pArg, Cmd));
    764764        return EINVAL;
    765765    }
    … …  
    771771    if (RT_UNLIKELY(!pvBuf))
    772772    {
    773         Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes.\n", ReqWrap.cbData));
     773        Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes.\n", ReqWrap.cbData));
    774774        return ENOMEM;
    775775    }
    … …  
    779779    {
    780780        RTMemTmpFree(pvBuf);
    781         Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: ddi_copyin failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
     781        Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: ddi_copyin failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
    782782        return EFAULT;
    783783    }
    … …  
    786786    {
    787787        RTMemTmpFree(pvBuf);
    788         Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: pvBuf invalid pointer %p\n", pvBuf));
     788        Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: pvBuf invalid pointer %p\n", pvBuf));
    789789        return EINVAL;
    790790    }
    791     Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: pSession=%p pid=%d.\n", pSession, (int)RTProcSelf()));
     791    Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: pSession=%p pid=%d.\n", pSession, (int)RTProcSelf()));
    792792
    793793    /*
    … …  
    801801        if (RT_UNLIKELY(cbDataReturned > ReqWrap.cbData))
    802802        {
    803             Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: too much output data %d expected %d\n", cbDataReturned, ReqWrap.cbData));
     803            Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: too much output data %d expected %d\n", cbDataReturned, ReqWrap.cbData));
    804804            cbDataReturned = ReqWrap.cbData;
    805805        }
    … …  
    809809            if (RT_UNLIKELY(rc))
    810810            {
    811                 Log((DEVICE_NAME ":VBoxAddSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
     811                Log((DEVICE_NAME ":VBoxGuestSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc));
    812812                rc = EFAULT;
    813813            }
    … …  
    816816    else
    817817    {
    818         LogRel((DEVICE_NAME ":VBoxAddSolarisIOCtl: VBoxGuestCommonIOCtl failed. rc=%d\n", rc));
     818        LogRel((DEVICE_NAME ":VBoxGuestSolarisIOCtl: VBoxGuestCommonIOCtl failed. rc=%d\n", rc));
    819819        rc = EFAULT;
    820820    }
Note: See TracChangeset for help on using the changeset viewer.

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